1253 files changed, 58562 insertions, 38307 deletions

diff --git a/drivers/Kconfig b/drivers/Kconfig
index 1a693d3f9d51..af02a8a8ec4a 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -1,5 +1,7 @@
 menu "Device Drivers"
 
+source "drivers/amba/Kconfig"
+
 source "drivers/base/Kconfig"
 
 source "drivers/bus/Kconfig"
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index b23fe37f67c0..8951cefb0a96 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -360,15 +360,14 @@ config ACPI_BGRT
 config ACPI_REDUCED_HARDWARE_ONLY
         bool "Hardware-reduced ACPI support only" if EXPERT
         def_bool n
-        depends on ACPI
         help
-        This config item changes the way the ACPI code is built.  When this
-        option is selected, the kernel will use a specialized version of
-        ACPICA that ONLY supports the ACPI "reduced hardware" mode.  The
-        resulting kernel will be smaller but it will also be restricted to
-        running in ACPI reduced hardware mode ONLY.
+          This config item changes the way the ACPI code is built.  When this
+          option is selected, the kernel will use a specialized version of
+          ACPICA that ONLY supports the ACPI "reduced hardware" mode.  The
+          resulting kernel will be smaller but it will also be restricted to
+          running in ACPI reduced hardware mode ONLY.
 
-        If you are unsure what to do, do not enable this option.
+          If you are unsure what to do, do not enable this option.
 
 source "drivers/acpi/apei/Kconfig"
 
@@ -394,4 +393,27 @@ config ACPI_EXTLOG
           driver adds support for that functionality with corresponding
           tracepoint which carries that information to userspace.
 
+menuconfig PMIC_OPREGION
+        bool "PMIC (Power Management Integrated Circuit) operation region support"
+        help
+          Select this option to enable support for ACPI operation
+          region of the PMIC chip. The operation region can be used
+          to control power rails and sensor reading/writing on the
+          PMIC chip.
+
+if PMIC_OPREGION
+config CRC_PMIC_OPREGION
+        bool "ACPI operation region support for CrystalCove PMIC"
+        depends on INTEL_SOC_PMIC
+        help
+          This config adds ACPI operation region support for CrystalCove PMIC.
+
+config XPOWER_PMIC_OPREGION
+        bool "ACPI operation region support for XPower AXP288 PMIC"
+        depends on AXP288_ADC = y
+        help
+          This config adds ACPI operation region support for XPower AXP288 PMIC.
+
+endif
+
 endif   # ACPI
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index c3b2fcb729f3..f74317cc1ca9 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -47,6 +47,7 @@ acpi-y				+= int340x_thermal.o
 acpi-y                          += power.o
 acpi-y                          += event.o
 acpi-y                          += sysfs.o
+acpi-y                          += property.o
 acpi-$(CONFIG_X86)              += acpi_cmos_rtc.o
 acpi-$(CONFIG_DEBUG_FS)         += debugfs.o
 acpi-$(CONFIG_ACPI_NUMA)        += numa.o
@@ -87,3 +88,7 @@ obj-$(CONFIG_ACPI_PROCESSOR_AGGREGATOR) += acpi_pad.o
 obj-$(CONFIG_ACPI_APEI)         += apei/
 
 obj-$(CONFIG_ACPI_EXTLOG)       += acpi_extlog.o
+
+obj-$(CONFIG_PMIC_OPREGION)     += pmic/intel_pmic.o
+obj-$(CONFIG_CRC_PMIC_OPREGION) += pmic/intel_pmic_crc.o
+obj-$(CONFIG_XPOWER_PMIC_OPREGION) += pmic/intel_pmic_xpower.o
diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c
index 93d160661f4c..4f3febf8a589 100644
--- a/drivers/acpi/acpi_lpss.c
+++ b/drivers/acpi/acpi_lpss.c
@@ -1,7 +1,7 @@
 /*
  * ACPI support for Intel Lynxpoint LPSS.
  *
- * Copyright (C) 2013, Intel Corporation
+ * Copyright (C) 2013, 2014, Intel Corporation
  * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
  *          Rafael J. Wysocki <rafael.j.wysocki@intel.com>
  *
@@ -60,6 +60,8 @@ ACPI_MODULE_NAME("acpi_lpss");
 #define LPSS_CLK_DIVIDER                BIT(2)
 #define LPSS_LTR                        BIT(3)
 #define LPSS_SAVE_CTX                   BIT(4)
+#define LPSS_DEV_PROXY                  BIT(5)
+#define LPSS_PROXY_REQ                  BIT(6)
 
 struct lpss_private_data;
 
@@ -70,8 +72,10 @@ struct lpss_device_desc {
         void (*setup)(struct lpss_private_data *pdata);
 };
 
+static struct device *proxy_device;
+
 static struct lpss_device_desc lpss_dma_desc = {
-        .flags = LPSS_CLK,
+        .flags = LPSS_CLK | LPSS_PROXY_REQ,
 };
 
 struct lpss_private_data {
@@ -146,22 +150,24 @@ static struct lpss_device_desc byt_pwm_dev_desc = {
 };
 
 static struct lpss_device_desc byt_uart_dev_desc = {
-        .flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX,
+        .flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX |
+                 LPSS_DEV_PROXY,
         .prv_offset = 0x800,
         .setup = lpss_uart_setup,
 };
 
 static struct lpss_device_desc byt_spi_dev_desc = {
-        .flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX,
+        .flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX |
+                 LPSS_DEV_PROXY,
         .prv_offset = 0x400,
 };
 
 static struct lpss_device_desc byt_sdio_dev_desc = {
-        .flags = LPSS_CLK,
+        .flags = LPSS_CLK | LPSS_DEV_PROXY,
 };
 
 static struct lpss_device_desc byt_i2c_dev_desc = {
-        .flags = LPSS_CLK | LPSS_SAVE_CTX,
+        .flags = LPSS_CLK | LPSS_SAVE_CTX | LPSS_DEV_PROXY,
         .prv_offset = 0x800,
         .setup = byt_i2c_setup,
 };
@@ -368,6 +374,8 @@ static int acpi_lpss_create_device(struct acpi_device *adev,
         adev->driver_data = pdata;
         pdev = acpi_create_platform_device(adev);
         if (!IS_ERR_OR_NULL(pdev)) {
+                if (!proxy_device && dev_desc->flags & LPSS_DEV_PROXY)
+                        proxy_device = &pdev->dev;
                 return 1;
         }
 
@@ -499,14 +507,15 @@ static void acpi_lpss_set_ltr(struct device *dev, s32 val)
 /**
  * acpi_lpss_save_ctx() - Save the private registers of LPSS device
  * @dev: LPSS device
+ * @pdata: pointer to the private data of the LPSS device
  *
  * Most LPSS devices have private registers which may loose their context when
  * the device is powered down. acpi_lpss_save_ctx() saves those registers into
  * prv_reg_ctx array.
  */
-static void acpi_lpss_save_ctx(struct device *dev)
+static void acpi_lpss_save_ctx(struct device *dev,
+                               struct lpss_private_data *pdata)
 {
-        struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
         unsigned int i;
 
         for (i = 0; i < LPSS_PRV_REG_COUNT; i++) {
@@ -521,12 +530,13 @@ static void acpi_lpss_save_ctx(struct device *dev)
 /**
  * acpi_lpss_restore_ctx() - Restore the private registers of LPSS device
  * @dev: LPSS device
+ * @pdata: pointer to the private data of the LPSS device
  *
  * Restores the registers that were previously stored with acpi_lpss_save_ctx().
  */
-static void acpi_lpss_restore_ctx(struct device *dev)
+static void acpi_lpss_restore_ctx(struct device *dev,
+                                  struct lpss_private_data *pdata)
 {
-        struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
         unsigned int i;
 
         /*
@@ -549,54 +559,82 @@ static void acpi_lpss_restore_ctx(struct device *dev)
 #ifdef CONFIG_PM_SLEEP
 static int acpi_lpss_suspend_late(struct device *dev)
 {
-        int ret = pm_generic_suspend_late(dev);
+        struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
+        int ret;
 
+        ret = pm_generic_suspend_late(dev);
         if (ret)
                 return ret;
 
-        acpi_lpss_save_ctx(dev);
+        if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
+                acpi_lpss_save_ctx(dev, pdata);
+
         return acpi_dev_suspend_late(dev);
 }
 
 static int acpi_lpss_resume_early(struct device *dev)
 {
-        int ret = acpi_dev_resume_early(dev);
+        struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
+        int ret;
 
+        ret = acpi_dev_resume_early(dev);
         if (ret)
                 return ret;
 
-        acpi_lpss_restore_ctx(dev);
+        if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
+                acpi_lpss_restore_ctx(dev, pdata);
+
         return pm_generic_resume_early(dev);
 }
 #endif /* CONFIG_PM_SLEEP */
 
-#ifdef CONFIG_PM_RUNTIME
 static int acpi_lpss_runtime_suspend(struct device *dev)
 {
-        int ret = pm_generic_runtime_suspend(dev);
+        struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
+        int ret;
+
+        ret = pm_generic_runtime_suspend(dev);
+        if (ret)
+                return ret;
 
+        if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
+                acpi_lpss_save_ctx(dev, pdata);
+
+        ret = acpi_dev_runtime_suspend(dev);
         if (ret)
                 return ret;
 
-        acpi_lpss_save_ctx(dev);
-        return acpi_dev_runtime_suspend(dev);
+        if (pdata->dev_desc->flags & LPSS_PROXY_REQ && proxy_device)
+                return pm_runtime_put_sync_suspend(proxy_device);
+
+        return 0;
 }
 
 static int acpi_lpss_runtime_resume(struct device *dev)
 {
-        int ret = acpi_dev_runtime_resume(dev);
+        struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
+        int ret;
+
+        if (pdata->dev_desc->flags & LPSS_PROXY_REQ && proxy_device) {
+                ret = pm_runtime_get_sync(proxy_device);
+                if (ret)
+                        return ret;
+        }
 
+        ret = acpi_dev_runtime_resume(dev);
         if (ret)
                 return ret;
 
-        acpi_lpss_restore_ctx(dev);
+        if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
+                acpi_lpss_restore_ctx(dev, pdata);
+
         return pm_generic_runtime_resume(dev);
 }
-#endif /* CONFIG_PM_RUNTIME */
 #endif /* CONFIG_PM */
 
 static struct dev_pm_domain acpi_lpss_pm_domain = {
         .ops = {
+#ifdef CONFIG_PM
 #ifdef CONFIG_PM_SLEEP
                 .prepare = acpi_subsys_prepare,
                 .complete = acpi_subsys_complete,
@@ -608,7 +646,6 @@ static struct dev_pm_domain acpi_lpss_pm_domain = {
                 .poweroff_late = acpi_lpss_suspend_late,
                 .restore_early = acpi_lpss_resume_early,
 #endif
-#ifdef CONFIG_PM_RUNTIME
                 .runtime_suspend = acpi_lpss_runtime_suspend,
                 .runtime_resume = acpi_lpss_runtime_resume,
 #endif
@@ -631,30 +668,27 @@ static int acpi_lpss_platform_notify(struct notifier_block *nb,
                 return 0;
 
         pdata = acpi_driver_data(adev);
-        if (!pdata || !pdata->mmio_base)
+        if (!pdata)
                 return 0;
 
-        if (pdata->mmio_size < pdata->dev_desc->prv_offset + LPSS_LTR_SIZE) {
+        if (pdata->mmio_base &&
+            pdata->mmio_size < pdata->dev_desc->prv_offset + LPSS_LTR_SIZE) {
                 dev_err(&pdev->dev, "MMIO size insufficient to access LTR\n");
                 return 0;
         }
 
         switch (action) {
-        case BUS_NOTIFY_BOUND_DRIVER:
-                if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
-                        pdev->dev.pm_domain = &acpi_lpss_pm_domain;
-                break;
-        case BUS_NOTIFY_UNBOUND_DRIVER:
-                if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
-                        pdev->dev.pm_domain = NULL;
-                break;
         case BUS_NOTIFY_ADD_DEVICE:
+                pdev->dev.pm_domain = &acpi_lpss_pm_domain;
                 if (pdata->dev_desc->flags & LPSS_LTR)
                         return sysfs_create_group(&pdev->dev.kobj,
                                                   &lpss_attr_group);
+                break;
         case BUS_NOTIFY_DEL_DEVICE:
                 if (pdata->dev_desc->flags & LPSS_LTR)
                         sysfs_remove_group(&pdev->dev.kobj, &lpss_attr_group);
+                pdev->dev.pm_domain = NULL;
+                break;
         default:
                 break;
         }
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index ebf02cc10a43..7f60582d0c8c 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -305,6 +305,7 @@ ACPI_INIT_GLOBAL(u8, acpi_gbl_db_output_flags, ACPI_DB_CONSOLE_OUTPUT);
 
 ACPI_INIT_GLOBAL(u8, acpi_gbl_no_resource_disassembly, FALSE);
 ACPI_INIT_GLOBAL(u8, acpi_gbl_ignore_noop_operator, FALSE);
+ACPI_INIT_GLOBAL(u8, acpi_gbl_cstyle_disassembly, TRUE);
 
 ACPI_GLOBAL(u8, acpi_gbl_db_opt_disasm);
 ACPI_GLOBAL(u8, acpi_gbl_db_opt_verbose);
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index c00e7e41ad75..680d23bbae7c 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -454,6 +454,7 @@ struct acpi_gpe_register_info {
         u16 base_gpe_number;    /* Base GPE number for this register */
         u8 enable_for_wake;     /* GPEs to keep enabled when sleeping */
         u8 enable_for_run;      /* GPEs to keep enabled when running */
+        u8 enable_mask;         /* Current mask of enabled GPEs */
 };
 
 /*
@@ -722,6 +723,7 @@ union acpi_parse_value {
         ACPI_DISASM_ONLY_MEMBERS (\
         u8                              disasm_flags;   /* Used during AML disassembly */\
         u8                              disasm_opcode;  /* Subtype used for disassembly */\
+        char                            *operator_symbol;/* Used for C-style operator name strings */\
         char                            aml_op_name[16])        /* Op name (debug only) */
 
 /* Flags for disasm_flags field above */
@@ -827,6 +829,8 @@ struct acpi_parse_state {
 #define ACPI_PARSEOP_EMPTY_TERMLIST     0x04
 #define ACPI_PARSEOP_PREDEF_CHECKED     0x08
 #define ACPI_PARSEOP_SPECIAL            0x10
+#define ACPI_PARSEOP_COMPOUND           0x20
+#define ACPI_PARSEOP_ASSIGNMENT         0x40
 
 /*****************************************************************************
  *
diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index 2095dfb72bcb..aa70154cf4fa 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -134,7 +134,7 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 
         /* Enable the requested GPE */
 
-        status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
+        status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE_SAVE);
         return_ACPI_STATUS(status);
 }
 
@@ -213,7 +213,7 @@ acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
                 if (ACPI_SUCCESS(status)) {
                         status =
                             acpi_hw_low_set_gpe(gpe_event_info,
-                                                ACPI_GPE_DISABLE);
+                                                ACPI_GPE_DISABLE_SAVE);
                 }
 
                 if (ACPI_FAILURE(status)) {
@@ -616,8 +616,11 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
 static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context)
 {
         struct acpi_gpe_event_info *gpe_event_info = context;
+        acpi_cpu_flags flags;
 
+        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
         (void)acpi_ev_finish_gpe(gpe_event_info);
+        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 
         ACPI_FREE(gpe_event_info);
         return;
@@ -655,7 +658,7 @@ acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info * gpe_event_info)
 
         /*
          * Enable this GPE, conditionally. This means that the GPE will
-         * only be physically enabled if the enable_for_run bit is set
+         * only be physically enabled if the enable_mask bit is set
          * in the event_info.
          */
         (void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_CONDITIONAL_ENABLE);
diff --git a/drivers/acpi/acpica/hwgpe.c b/drivers/acpi/acpica/hwgpe.c
index 48ac7b7b59cd..494027f5c067 100644
--- a/drivers/acpi/acpica/hwgpe.c
+++ b/drivers/acpi/acpica/hwgpe.c
@@ -115,12 +115,12 @@ acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
         /* Set or clear just the bit that corresponds to this GPE */
 
         register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
-        switch (action) {
+        switch (action & ~ACPI_GPE_SAVE_MASK) {
         case ACPI_GPE_CONDITIONAL_ENABLE:
 
-                /* Only enable if the enable_for_run bit is set */
+                /* Only enable if the corresponding enable_mask bit is set */
 
-                if (!(register_bit & gpe_register_info->enable_for_run)) {
+                if (!(register_bit & gpe_register_info->enable_mask)) {
                         return (AE_BAD_PARAMETER);
                 }
 
@@ -145,6 +145,9 @@ acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
         /* Write the updated enable mask */
 
         status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
+        if (ACPI_SUCCESS(status) && (action & ACPI_GPE_SAVE_MASK)) {
+                gpe_register_info->enable_mask = enable_mask;
+        }
         return (status);
 }
 
@@ -262,6 +265,32 @@ acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
 
 /******************************************************************************
  *
+ * FUNCTION:    acpi_hw_gpe_enable_write
+ *
+ * PARAMETERS:  enable_mask         - Bit mask to write to the GPE register
+ *              gpe_register_info   - Gpe Register info
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Write the enable mask byte to the given GPE register.
+ *
+ ******************************************************************************/
+
+static acpi_status
+acpi_hw_gpe_enable_write(u8 enable_mask,
+                         struct acpi_gpe_register_info *gpe_register_info)
+{
+        acpi_status status;
+
+        status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
+        if (ACPI_SUCCESS(status)) {
+                gpe_register_info->enable_mask = enable_mask;
+        }
+        return (status);
+}
+
+/******************************************************************************
+ *
  * FUNCTION:    acpi_hw_disable_gpe_block
  *
  * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
@@ -287,8 +316,8 @@ acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
                 /* Disable all GPEs in this register */
 
                 status =
-                    acpi_hw_write(0x00,
-                                  &gpe_block->register_info[i].enable_address);
+                    acpi_hw_gpe_enable_write(0x00,
+                                             &gpe_block->register_info[i]);
                 if (ACPI_FAILURE(status)) {
                         return (status);
                 }
@@ -355,21 +384,23 @@ acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 {
         u32 i;
         acpi_status status;
+        struct acpi_gpe_register_info *gpe_register_info;
 
         /* NOTE: assumes that all GPEs are currently disabled */
 
         /* Examine each GPE Register within the block */
 
         for (i = 0; i < gpe_block->register_count; i++) {
-                if (!gpe_block->register_info[i].enable_for_run) {
+                gpe_register_info = &gpe_block->register_info[i];
+                if (!gpe_register_info->enable_for_run) {
                         continue;
                 }
 
                 /* Enable all "runtime" GPEs in this register */
 
                 status =
-                    acpi_hw_write(gpe_block->register_info[i].enable_for_run,
-                                  &gpe_block->register_info[i].enable_address);
+                    acpi_hw_gpe_enable_write(gpe_register_info->enable_for_run,
+                                             gpe_register_info);
                 if (ACPI_FAILURE(status)) {
                         return (status);
                 }
@@ -399,10 +430,12 @@ acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 {
         u32 i;
         acpi_status status;
+        struct acpi_gpe_register_info *gpe_register_info;
 
         /* Examine each GPE Register within the block */
 
         for (i = 0; i < gpe_block->register_count; i++) {
+                gpe_register_info = &gpe_block->register_info[i];
 
                 /*
                  * Enable all "wake" GPEs in this register and disable the
@@ -410,8 +443,8 @@ acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
                  */
 
                 status =
-                    acpi_hw_write(gpe_block->register_info[i].enable_for_wake,
-                                  &gpe_block->register_info[i].enable_address);
+                    acpi_hw_gpe_enable_write(gpe_register_info->enable_for_wake,
+                                             gpe_register_info);
                 if (ACPI_FAILURE(status)) {
                         return (status);
                 }
diff --git a/drivers/acpi/acpica/utresrc.c b/drivers/acpi/acpica/utresrc.c
index 5cd017c7ac0e..bc1ff820c7dd 100644
--- a/drivers/acpi/acpica/utresrc.c
+++ b/drivers/acpi/acpica/utresrc.c
@@ -263,7 +263,7 @@ const char *acpi_gbl_bpb_decode[] = {
 /* UART serial bus stop bits */
 
 const char *acpi_gbl_sb_decode[] = {
-        "StopBitsNone",
+        "StopBitsZero",
         "StopBitsOne",
         "StopBitsOnePlusHalf",
         "StopBitsTwo"
diff --git a/drivers/acpi/acpica/utxface.c b/drivers/acpi/acpica/utxface.c
index 502a8492dc83..49c873c68756 100644
--- a/drivers/acpi/acpica/utxface.c
+++ b/drivers/acpi/acpica/utxface.c
@@ -531,7 +531,9 @@ acpi_decode_pld_buffer(u8 *in_buffer,
         ACPI_MOVE_32_TO_32(&dword, &buffer[0]);
         pld_info->revision = ACPI_PLD_GET_REVISION(&dword);
         pld_info->ignore_color = ACPI_PLD_GET_IGNORE_COLOR(&dword);
-        pld_info->color = ACPI_PLD_GET_COLOR(&dword);
+        pld_info->red = ACPI_PLD_GET_RED(&dword);
+        pld_info->green = ACPI_PLD_GET_GREEN(&dword);
+        pld_info->blue = ACPI_PLD_GET_BLUE(&dword);
 
         /* Second 32-bit DWord */
 
diff --git a/drivers/acpi/acpica/utxfinit.c b/drivers/acpi/acpica/utxfinit.c
index 13380d818462..b1fd6886e439 100644
--- a/drivers/acpi/acpica/utxfinit.c
+++ b/drivers/acpi/acpica/utxfinit.c
@@ -53,6 +53,9 @@
 #define _COMPONENT          ACPI_UTILITIES
 ACPI_MODULE_NAME("utxfinit")
 
+/* For acpi_exec only */
+void ae_do_object_overrides(void);
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_initialize_subsystem
@@ -65,6 +68,7 @@ ACPI_MODULE_NAME("utxfinit")
  *              called, so any early initialization belongs here.
  *
  ******************************************************************************/
+
 acpi_status __init acpi_initialize_subsystem(void)
 {
         acpi_status status;
@@ -275,6 +279,13 @@ acpi_status __init acpi_initialize_objects(u32 flags)
                         return_ACPI_STATUS(status);
                 }
         }
+#ifdef ACPI_EXEC_APP
+        /*
+         * This call implements the "initialization file" option for acpi_exec.
+         * This is the precise point that we want to perform the overrides.
+         */
+        ae_do_object_overrides();
+#endif
 
         /*
          * Execute any module-level code that was detected during the table load
diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c
index fc5f780bb61d..1b6aa514848f 100644
--- a/drivers/acpi/apei/ghes.c
+++ b/drivers/acpi/apei/ghes.c
@@ -128,7 +128,7 @@ static DEFINE_SPINLOCK(ghes_ioremap_lock_irq);
 static struct gen_pool *ghes_estatus_pool;
 static unsigned long ghes_estatus_pool_size_request;
 
-struct ghes_estatus_cache *ghes_estatus_caches[GHES_ESTATUS_CACHES_SIZE];
+static struct ghes_estatus_cache *ghes_estatus_caches[GHES_ESTATUS_CACHES_SIZE];
 static atomic_t ghes_estatus_cache_alloced;
 
 static int ghes_ioremap_init(void)
@@ -738,20 +738,6 @@ static LIST_HEAD(ghes_nmi);
 
 static int ghes_panic_timeout   __read_mostly = 30;
 
-static struct llist_node *llist_nodes_reverse(struct llist_node *llnode)
-{
-        struct llist_node *next, *tail = NULL;
-
-        while (llnode) {
-                next = llnode->next;
-                llnode->next = tail;
-                tail = llnode;
-                llnode = next;
-        }
-
-        return tail;
-}
-
 static void ghes_proc_in_irq(struct irq_work *irq_work)
 {
         struct llist_node *llnode, *next;
@@ -765,7 +751,7 @@ static void ghes_proc_in_irq(struct irq_work *irq_work)
          * Because the time order of estatus in list is reversed,
          * revert it back to proper order.
          */
-        llnode = llist_nodes_reverse(llnode);
+        llnode = llist_reverse_order(llnode);
         while (llnode) {
                 next = llnode->next;
                 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
@@ -798,7 +784,7 @@ static void ghes_print_queued_estatus(void)
          * Because the time order of estatus in list is reversed,
          * revert it back to proper order.
          */
-        llnode = llist_nodes_reverse(llnode);
+        llnode = llist_reverse_order(llnode);
         while (llnode) {
                 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
                                            llnode);
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 8ec8a89a20ab..d98ba4355819 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -1180,6 +1180,10 @@ static int acpi_battery_add(struct acpi_device *device)
 
         if (!device)
                 return -EINVAL;
+
+        if (device->dep_unmet)
+                return -EPROBE_DEFER;
+
         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
         if (!battery)
                 return -ENOMEM;
diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c
index 7db193160766..897640188acd 100644
--- a/drivers/acpi/device_pm.c
+++ b/drivers/acpi/device_pm.c
@@ -201,7 +201,7 @@ int acpi_device_set_power(struct acpi_device *device, int state)
          * Transition Power
          * ----------------
          * In accordance with the ACPI specification first apply power (via
-         * power resources) and then evalute _PSx.
+         * power resources) and then evaluate _PSx.
          */
         if (device->power.flags.power_resources) {
                 result = acpi_power_transition(device, state);
@@ -692,7 +692,6 @@ static int acpi_device_wakeup(struct acpi_device *adev, u32 target_state,
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
 /**
  * acpi_pm_device_run_wake - Enable/disable remote wakeup for given device.
  * @dev: Device to enable/disable the platform to wake up.
@@ -714,7 +713,6 @@ int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
         return acpi_device_wakeup(adev, ACPI_STATE_S0, enable);
 }
 EXPORT_SYMBOL(acpi_pm_device_run_wake);
-#endif /* CONFIG_PM_RUNTIME */
 
 #ifdef CONFIG_PM_SLEEP
 /**
@@ -773,7 +771,6 @@ static int acpi_dev_pm_full_power(struct acpi_device *adev)
                 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
 /**
  * acpi_dev_runtime_suspend - Put device into a low-power state using ACPI.
  * @dev: Device to put into a low-power state.
@@ -855,7 +852,6 @@ int acpi_subsys_runtime_resume(struct device *dev)
         return ret ? ret : pm_generic_runtime_resume(dev);
 }
 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
-#endif /* CONFIG_PM_RUNTIME */
 
 #ifdef CONFIG_PM_SLEEP
 /**
@@ -1023,10 +1019,9 @@ EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
 
 static struct dev_pm_domain acpi_general_pm_domain = {
         .ops = {
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
                 .runtime_suspend = acpi_subsys_runtime_suspend,
                 .runtime_resume = acpi_subsys_runtime_resume,
-#endif
 #ifdef CONFIG_PM_SLEEP
                 .prepare = acpi_subsys_prepare,
                 .complete = acpi_subsys_complete,
@@ -1038,6 +1033,7 @@ static struct dev_pm_domain acpi_general_pm_domain = {
                 .poweroff_late = acpi_subsys_suspend_late,
                 .restore_early = acpi_subsys_resume_early,
 #endif
+#endif
         },
 };
 
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 447f6d679b29..163e82f536fa 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -173,4 +173,10 @@ static inline void suspend_nvs_restore(void) {}
 bool acpi_osi_is_win8(void);
 #endif
 
+/*--------------------------------------------------------------------------
+                                Device properties
+  -------------------------------------------------------------------------- */
+void acpi_init_properties(struct acpi_device *adev);
+void acpi_free_properties(struct acpi_device *adev);
+
 #endif /* _ACPI_INTERNAL_H_ */
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 9964f70be98d..f9eeae871593 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -436,7 +436,7 @@ static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
 static void acpi_os_map_cleanup(struct acpi_ioremap *map)
 {
         if (!map->refcount) {
-                synchronize_rcu();
+                synchronize_rcu_expedited();
                 acpi_unmap(map->phys, map->virt);
                 kfree(map);
         }
@@ -1188,6 +1188,12 @@ EXPORT_SYMBOL(acpi_os_execute);
 
 void acpi_os_wait_events_complete(void)
 {
+        /*
+         * Make sure the GPE handler or the fixed event handler is not used
+         * on another CPU after removal.
+         */
+        if (acpi_irq_handler)
+                synchronize_hardirq(acpi_gbl_FADT.sci_interrupt);
         flush_workqueue(kacpid_wq);
         flush_workqueue(kacpi_notify_wq);
 }
diff --git a/drivers/acpi/pci_irq.c b/drivers/acpi/pci_irq.c
index 6e6b80eb0bba..7cc4e33179f9 100644
--- a/drivers/acpi/pci_irq.c
+++ b/drivers/acpi/pci_irq.c
@@ -484,7 +484,7 @@ void acpi_pci_irq_disable(struct pci_dev *dev)
         /* Keep IOAPIC pin configuration when suspending */
         if (dev->dev.power.is_prepared)
                 return;
-#ifdef  CONFIG_PM_RUNTIME
+#ifdef  CONFIG_PM
         if (dev->dev.power.runtime_status == RPM_SUSPENDING)
                 return;
 #endif
diff --git a/drivers/acpi/pmic/intel_pmic.c b/drivers/acpi/pmic/intel_pmic.c
new file mode 100644
index 000000000000..a732e5d7e322
--- /dev/null
+++ b/drivers/acpi/pmic/intel_pmic.c
@@ -0,0 +1,354 @@
+/*
+ * intel_pmic.c - Intel PMIC operation region driver
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/acpi.h>
+#include <linux/regmap.h>
+#include "intel_pmic.h"
+
+#define PMIC_POWER_OPREGION_ID          0x8d
+#define PMIC_THERMAL_OPREGION_ID        0x8c
+
+struct acpi_lpat {
+        int temp;
+        int raw;
+};
+
+struct intel_pmic_opregion {
+        struct mutex lock;
+        struct acpi_lpat *lpat;
+        int lpat_count;
+        struct regmap *regmap;
+        struct intel_pmic_opregion_data *data;
+};
+
+static int pmic_get_reg_bit(int address, struct pmic_table *table,
+                            int count, int *reg, int *bit)
+{
+        int i;
+
+        for (i = 0; i < count; i++) {
+                if (table[i].address == address) {
+                        *reg = table[i].reg;
+                        if (bit)
+                                *bit = table[i].bit;
+                        return 0;
+                }
+        }
+        return -ENOENT;
+}
+
+/**
+ * raw_to_temp(): Return temperature from raw value through LPAT table
+ *
+ * @lpat: the temperature_raw mapping table
+ * @count: the count of the above mapping table
+ * @raw: the raw value, used as a key to get the temerature from the
+ *       above mapping table
+ *
+ * A positive value will be returned on success, a negative errno will
+ * be returned in error cases.
+ */
+static int raw_to_temp(struct acpi_lpat *lpat, int count, int raw)
+{
+        int i, delta_temp, delta_raw, temp;
+
+        for (i = 0; i < count - 1; i++) {
+                if ((raw >= lpat[i].raw && raw <= lpat[i+1].raw) ||
+                    (raw <= lpat[i].raw && raw >= lpat[i+1].raw))
+                        break;
+        }
+
+        if (i == count - 1)
+                return -ENOENT;
+
+        delta_temp = lpat[i+1].temp - lpat[i].temp;
+        delta_raw = lpat[i+1].raw - lpat[i].raw;
+        temp = lpat[i].temp + (raw - lpat[i].raw) * delta_temp / delta_raw;
+
+        return temp;
+}
+
+/**
+ * temp_to_raw(): Return raw value from temperature through LPAT table
+ *
+ * @lpat: the temperature_raw mapping table
+ * @count: the count of the above mapping table
+ * @temp: the temperature, used as a key to get the raw value from the
+ *        above mapping table
+ *
+ * A positive value will be returned on success, a negative errno will
+ * be returned in error cases.
+ */
+static int temp_to_raw(struct acpi_lpat *lpat, int count, int temp)
+{
+        int i, delta_temp, delta_raw, raw;
+
+        for (i = 0; i < count - 1; i++) {
+                if (temp >= lpat[i].temp && temp <= lpat[i+1].temp)
+                        break;
+        }
+
+        if (i == count - 1)
+                return -ENOENT;
+
+        delta_temp = lpat[i+1].temp - lpat[i].temp;
+        delta_raw = lpat[i+1].raw - lpat[i].raw;
+        raw = lpat[i].raw + (temp - lpat[i].temp) * delta_raw / delta_temp;
+
+        return raw;
+}
+
+static void pmic_thermal_lpat(struct intel_pmic_opregion *opregion,
+                              acpi_handle handle, struct device *dev)
+{
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj_p, *obj_e;
+        int *lpat, i;
+        acpi_status status;
+
+        status = acpi_evaluate_object(handle, "LPAT", NULL, &buffer);
+        if (ACPI_FAILURE(status))
+                return;
+
+        obj_p = (union acpi_object *)buffer.pointer;
+        if (!obj_p || (obj_p->type != ACPI_TYPE_PACKAGE) ||
+            (obj_p->package.count % 2) || (obj_p->package.count < 4))
+                goto out;
+
+        lpat = devm_kmalloc(dev, sizeof(int) * obj_p->package.count,
+                            GFP_KERNEL);
+        if (!lpat)
+                goto out;
+
+        for (i = 0; i < obj_p->package.count; i++) {
+                obj_e = &obj_p->package.elements[i];
+                if (obj_e->type != ACPI_TYPE_INTEGER) {
+                        devm_kfree(dev, lpat);
+                        goto out;
+                }
+                lpat[i] = (s64)obj_e->integer.value;
+        }
+
+        opregion->lpat = (struct acpi_lpat *)lpat;
+        opregion->lpat_count = obj_p->package.count / 2;
+
+out:
+        kfree(buffer.pointer);
+}
+
+static acpi_status intel_pmic_power_handler(u32 function,
+                acpi_physical_address address, u32 bits, u64 *value64,
+                void *handler_context, void *region_context)
+{
+        struct intel_pmic_opregion *opregion = region_context;
+        struct regmap *regmap = opregion->regmap;
+        struct intel_pmic_opregion_data *d = opregion->data;
+        int reg, bit, result;
+
+        if (bits != 32 || !value64)
+                return AE_BAD_PARAMETER;
+
+        if (function == ACPI_WRITE && !(*value64 == 0 || *value64 == 1))
+                return AE_BAD_PARAMETER;
+
+        result = pmic_get_reg_bit(address, d->power_table,
+                                  d->power_table_count, &reg, &bit);
+        if (result == -ENOENT)
+                return AE_BAD_PARAMETER;
+
+        mutex_lock(&opregion->lock);
+
+        result = function == ACPI_READ ?
+                d->get_power(regmap, reg, bit, value64) :
+                d->update_power(regmap, reg, bit, *value64 == 1);
+
+        mutex_unlock(&opregion->lock);
+
+        return result ? AE_ERROR : AE_OK;
+}
+
+static int pmic_read_temp(struct intel_pmic_opregion *opregion,
+                          int reg, u64 *value)
+{
+        int raw_temp, temp;
+
+        if (!opregion->data->get_raw_temp)
+                return -ENXIO;
+
+        raw_temp = opregion->data->get_raw_temp(opregion->regmap, reg);
+        if (raw_temp < 0)
+                return raw_temp;
+
+        if (!opregion->lpat) {
+                *value = raw_temp;
+                return 0;
+        }
+
+        temp = raw_to_temp(opregion->lpat, opregion->lpat_count, raw_temp);
+        if (temp < 0)
+                return temp;
+
+        *value = temp;
+        return 0;
+}
+
+static int pmic_thermal_temp(struct intel_pmic_opregion *opregion, int reg,
+                             u32 function, u64 *value)
+{
+        return function == ACPI_READ ?
+                pmic_read_temp(opregion, reg, value) : -EINVAL;
+}
+
+static int pmic_thermal_aux(struct intel_pmic_opregion *opregion, int reg,
+                            u32 function, u64 *value)
+{
+        int raw_temp;
+
+        if (function == ACPI_READ)
+                return pmic_read_temp(opregion, reg, value);
+
+        if (!opregion->data->update_aux)
+                return -ENXIO;
+
+        if (opregion->lpat) {
+                raw_temp = temp_to_raw(opregion->lpat, opregion->lpat_count,
+                                       *value);
+                if (raw_temp < 0)
+                        return raw_temp;
+        } else {
+                raw_temp = *value;
+        }
+
+        return opregion->data->update_aux(opregion->regmap, reg, raw_temp);
+}
+
+static int pmic_thermal_pen(struct intel_pmic_opregion *opregion, int reg,
+                            u32 function, u64 *value)
+{
+        struct intel_pmic_opregion_data *d = opregion->data;
+        struct regmap *regmap = opregion->regmap;
+
+        if (!d->get_policy || !d->update_policy)
+                return -ENXIO;
+
+        if (function == ACPI_READ)
+                return d->get_policy(regmap, reg, value);
+
+        if (*value != 0 && *value != 1)
+                return -EINVAL;
+
+        return d->update_policy(regmap, reg, *value);
+}
+
+static bool pmic_thermal_is_temp(int address)
+{
+        return (address <= 0x3c) && !(address % 12);
+}
+
+static bool pmic_thermal_is_aux(int address)
+{
+        return (address >= 4 && address <= 0x40 && !((address - 4) % 12)) ||
+               (address >= 8 && address <= 0x44 && !((address - 8) % 12));
+}
+
+static bool pmic_thermal_is_pen(int address)
+{
+        return address >= 0x48 && address <= 0x5c;
+}
+
+static acpi_status intel_pmic_thermal_handler(u32 function,
+                acpi_physical_address address, u32 bits, u64 *value64,
+                void *handler_context, void *region_context)
+{
+        struct intel_pmic_opregion *opregion = region_context;
+        struct intel_pmic_opregion_data *d = opregion->data;
+        int reg, result;
+
+        if (bits != 32 || !value64)
+                return AE_BAD_PARAMETER;
+
+        result = pmic_get_reg_bit(address, d->thermal_table,
+                                  d->thermal_table_count, &reg, NULL);
+        if (result == -ENOENT)
+                return AE_BAD_PARAMETER;
+
+        mutex_lock(&opregion->lock);
+
+        if (pmic_thermal_is_temp(address))
+                result = pmic_thermal_temp(opregion, reg, function, value64);
+        else if (pmic_thermal_is_aux(address))
+                result = pmic_thermal_aux(opregion, reg, function, value64);
+        else if (pmic_thermal_is_pen(address))
+                result = pmic_thermal_pen(opregion, reg, function, value64);
+        else
+                result = -EINVAL;
+
+        mutex_unlock(&opregion->lock);
+
+        if (result < 0) {
+                if (result == -EINVAL)
+                        return AE_BAD_PARAMETER;
+                else
+                        return AE_ERROR;
+        }
+
+        return AE_OK;
+}
+
+int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle,
+                                        struct regmap *regmap,
+                                        struct intel_pmic_opregion_data *d)
+{
+        acpi_status status;
+        struct intel_pmic_opregion *opregion;
+
+        if (!dev || !regmap || !d)
+                return -EINVAL;
+
+        if (!handle)
+                return -ENODEV;
+
+        opregion = devm_kzalloc(dev, sizeof(*opregion), GFP_KERNEL);
+        if (!opregion)
+                return -ENOMEM;
+
+        mutex_init(&opregion->lock);
+        opregion->regmap = regmap;
+        pmic_thermal_lpat(opregion, handle, dev);
+
+        status = acpi_install_address_space_handler(handle,
+                                                    PMIC_POWER_OPREGION_ID,
+                                                    intel_pmic_power_handler,
+                                                    NULL, opregion);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        status = acpi_install_address_space_handler(handle,
+                                                    PMIC_THERMAL_OPREGION_ID,
+                                                    intel_pmic_thermal_handler,
+                                                    NULL, opregion);
+        if (ACPI_FAILURE(status)) {
+                acpi_remove_address_space_handler(handle, PMIC_POWER_OPREGION_ID,
+                                                  intel_pmic_power_handler);
+                return -ENODEV;
+        }
+
+        opregion->data = d;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(intel_pmic_install_opregion_handler);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/pmic/intel_pmic.h b/drivers/acpi/pmic/intel_pmic.h
new file mode 100644
index 000000000000..d4e90af8f0dd
--- /dev/null
+++ b/drivers/acpi/pmic/intel_pmic.h
@@ -0,0 +1,25 @@
+#ifndef __INTEL_PMIC_H
+#define __INTEL_PMIC_H
+
+struct pmic_table {
+        int address;    /* operation region address */
+        int reg;        /* corresponding thermal register */
+        int bit;        /* control bit for power */
+};
+
+struct intel_pmic_opregion_data {
+        int (*get_power)(struct regmap *r, int reg, int bit, u64 *value);
+        int (*update_power)(struct regmap *r, int reg, int bit, bool on);
+        int (*get_raw_temp)(struct regmap *r, int reg);
+        int (*update_aux)(struct regmap *r, int reg, int raw_temp);
+        int (*get_policy)(struct regmap *r, int reg, u64 *value);
+        int (*update_policy)(struct regmap *r, int reg, int enable);
+        struct pmic_table *power_table;
+        int power_table_count;
+        struct pmic_table *thermal_table;
+        int thermal_table_count;
+};
+
+int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle, struct regmap *regmap, struct intel_pmic_opregion_data *d);
+
+#endif
diff --git a/drivers/acpi/pmic/intel_pmic_crc.c b/drivers/acpi/pmic/intel_pmic_crc.c
new file mode 100644
index 000000000000..ef7d8ff95abe
--- /dev/null
+++ b/drivers/acpi/pmic/intel_pmic_crc.c
@@ -0,0 +1,211 @@
+/*
+ * intel_pmic_crc.c - Intel CrystalCove PMIC operation region driver
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/acpi.h>
+#include <linux/mfd/intel_soc_pmic.h>
+#include <linux/regmap.h>
+#include <linux/platform_device.h>
+#include "intel_pmic.h"
+
+#define PWR_SOURCE_SELECT       BIT(1)
+
+#define PMIC_A0LOCK_REG         0xc5
+
+static struct pmic_table power_table[] = {
+        {
+                .address = 0x24,
+                .reg = 0x66,
+                .bit = 0x00,
+        },
+        {
+                .address = 0x48,
+                .reg = 0x5d,
+                .bit = 0x00,
+        },
+};
+
+static struct pmic_table thermal_table[] = {
+        {
+                .address = 0x00,
+                .reg = 0x75
+        },
+        {
+                .address = 0x04,
+                .reg = 0x95
+        },
+        {
+                .address = 0x08,
+                .reg = 0x97
+        },
+        {
+                .address = 0x0c,
+                .reg = 0x77
+        },
+        {
+                .address = 0x10,
+                .reg = 0x9a
+        },
+        {
+                .address = 0x14,
+                .reg = 0x9c
+        },
+        {
+                .address = 0x18,
+                .reg = 0x79
+        },
+        {
+                .address = 0x1c,
+                .reg = 0x9f
+        },
+        {
+                .address = 0x20,
+                .reg = 0xa1
+        },
+        {
+                .address = 0x48,
+                .reg = 0x94
+        },
+        {
+                .address = 0x4c,
+                .reg = 0x99
+        },
+        {
+                .address = 0x50,
+                .reg = 0x9e
+        },
+};
+
+static int intel_crc_pmic_get_power(struct regmap *regmap, int reg,
+                                    int bit, u64 *value)
+{
+        int data;
+
+        if (regmap_read(regmap, reg, &data))
+                return -EIO;
+
+        *value = (data & PWR_SOURCE_SELECT) && (data & BIT(bit)) ? 1 : 0;
+        return 0;
+}
+
+static int intel_crc_pmic_update_power(struct regmap *regmap, int reg,
+                                       int bit, bool on)
+{
+        int data;
+
+        if (regmap_read(regmap, reg, &data))
+                return -EIO;
+
+        if (on) {
+                data |= PWR_SOURCE_SELECT | BIT(bit);
+        } else {
+                data &= ~BIT(bit);
+                data |= PWR_SOURCE_SELECT;
+        }
+
+        if (regmap_write(regmap, reg, data))
+                return -EIO;
+        return 0;
+}
+
+static int intel_crc_pmic_get_raw_temp(struct regmap *regmap, int reg)
+{
+        int temp_l, temp_h;
+
+        /*
+         * Raw temperature value is 10bits: 8bits in reg
+         * and 2bits in reg-1: bit0,1
+         */
+        if (regmap_read(regmap, reg, &temp_l) ||
+            regmap_read(regmap, reg - 1, &temp_h))
+                return -EIO;
+
+        return temp_l | (temp_h & 0x3) << 8;
+}
+
+static int intel_crc_pmic_update_aux(struct regmap *regmap, int reg, int raw)
+{
+        return regmap_write(regmap, reg, raw) ||
+                regmap_update_bits(regmap, reg - 1, 0x3, raw >> 8) ? -EIO : 0;
+}
+
+static int intel_crc_pmic_get_policy(struct regmap *regmap, int reg, u64 *value)
+{
+        int pen;
+
+        if (regmap_read(regmap, reg, &pen))
+                return -EIO;
+        *value = pen >> 7;
+        return 0;
+}
+
+static int intel_crc_pmic_update_policy(struct regmap *regmap,
+                                        int reg, int enable)
+{
+        int alert0;
+
+        /* Update to policy enable bit requires unlocking a0lock */
+        if (regmap_read(regmap, PMIC_A0LOCK_REG, &alert0))
+                return -EIO;
+
+        if (regmap_update_bits(regmap, PMIC_A0LOCK_REG, 0x01, 0))
+                return -EIO;
+
+        if (regmap_update_bits(regmap, reg, 0x80, enable << 7))
+                return -EIO;
+
+        /* restore alert0 */
+        if (regmap_write(regmap, PMIC_A0LOCK_REG, alert0))
+                return -EIO;
+
+        return 0;
+}
+
+static struct intel_pmic_opregion_data intel_crc_pmic_opregion_data = {
+        .get_power      = intel_crc_pmic_get_power,
+        .update_power   = intel_crc_pmic_update_power,
+        .get_raw_temp   = intel_crc_pmic_get_raw_temp,
+        .update_aux     = intel_crc_pmic_update_aux,
+        .get_policy     = intel_crc_pmic_get_policy,
+        .update_policy  = intel_crc_pmic_update_policy,
+        .power_table    = power_table,
+        .power_table_count= ARRAY_SIZE(power_table),
+        .thermal_table  = thermal_table,
+        .thermal_table_count = ARRAY_SIZE(thermal_table),
+};
+
+static int intel_crc_pmic_opregion_probe(struct platform_device *pdev)
+{
+        struct intel_soc_pmic *pmic = dev_get_drvdata(pdev->dev.parent);
+        return intel_pmic_install_opregion_handler(&pdev->dev,
+                        ACPI_HANDLE(pdev->dev.parent), pmic->regmap,
+                        &intel_crc_pmic_opregion_data);
+}
+
+static struct platform_driver intel_crc_pmic_opregion_driver = {
+        .probe = intel_crc_pmic_opregion_probe,
+        .driver = {
+                .name = "crystal_cove_pmic",
+        },
+};
+
+static int __init intel_crc_pmic_opregion_driver_init(void)
+{
+        return platform_driver_register(&intel_crc_pmic_opregion_driver);
+}
+module_init(intel_crc_pmic_opregion_driver_init);
+
+MODULE_DESCRIPTION("CrystalCove ACPI opration region driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/pmic/intel_pmic_xpower.c b/drivers/acpi/pmic/intel_pmic_xpower.c
new file mode 100644
index 000000000000..6a082d4de12c
--- /dev/null
+++ b/drivers/acpi/pmic/intel_pmic_xpower.c
@@ -0,0 +1,268 @@
+/*
+ * intel_pmic_xpower.c - XPower AXP288 PMIC operation region driver
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/acpi.h>
+#include <linux/mfd/axp20x.h>
+#include <linux/regmap.h>
+#include <linux/platform_device.h>
+#include <linux/iio/consumer.h>
+#include "intel_pmic.h"
+
+#define XPOWER_GPADC_LOW        0x5b
+
+static struct pmic_table power_table[] = {
+        {
+                .address = 0x00,
+                .reg = 0x13,
+                .bit = 0x05,
+        },
+        {
+                .address = 0x04,
+                .reg = 0x13,
+                .bit = 0x06,
+        },
+        {
+                .address = 0x08,
+                .reg = 0x13,
+                .bit = 0x07,
+        },
+        {
+                .address = 0x0c,
+                .reg = 0x12,
+                .bit = 0x03,
+        },
+        {
+                .address = 0x10,
+                .reg = 0x12,
+                .bit = 0x04,
+        },
+        {
+                .address = 0x14,
+                .reg = 0x12,
+                .bit = 0x05,
+        },
+        {
+                .address = 0x18,
+                .reg = 0x12,
+                .bit = 0x06,
+        },
+        {
+                .address = 0x1c,
+                .reg = 0x12,
+                .bit = 0x00,
+        },
+        {
+                .address = 0x20,
+                .reg = 0x12,
+                .bit = 0x01,
+        },
+        {
+                .address = 0x24,
+                .reg = 0x12,
+                .bit = 0x02,
+        },
+        {
+                .address = 0x28,
+                .reg = 0x13,
+                .bit = 0x02,
+        },
+        {
+                .address = 0x2c,
+                .reg = 0x13,
+                .bit = 0x03,
+        },
+        {
+                .address = 0x30,
+                .reg = 0x13,
+                .bit = 0x04,
+        },
+        {
+                .address = 0x38,
+                .reg = 0x10,
+                .bit = 0x03,
+        },
+        {
+                .address = 0x3c,
+                .reg = 0x10,
+                .bit = 0x06,
+        },
+        {
+                .address = 0x40,
+                .reg = 0x10,
+                .bit = 0x05,
+        },
+        {
+                .address = 0x44,
+                .reg = 0x10,
+                .bit = 0x04,
+        },
+        {
+                .address = 0x48,
+                .reg = 0x10,
+                .bit = 0x01,
+        },
+        {
+                .address = 0x4c,
+                .reg = 0x10,
+                .bit = 0x00
+        },
+};
+
+/* TMP0 - TMP5 are the same, all from GPADC */
+static struct pmic_table thermal_table[] = {
+        {
+                .address = 0x00,
+                .reg = XPOWER_GPADC_LOW
+        },
+        {
+                .address = 0x0c,
+                .reg = XPOWER_GPADC_LOW
+        },
+        {
+                .address = 0x18,
+                .reg = XPOWER_GPADC_LOW
+        },
+        {
+                .address = 0x24,
+                .reg = XPOWER_GPADC_LOW
+        },
+        {
+                .address = 0x30,
+                .reg = XPOWER_GPADC_LOW
+        },
+        {
+                .address = 0x3c,
+                .reg = XPOWER_GPADC_LOW
+        },
+};
+
+static int intel_xpower_pmic_get_power(struct regmap *regmap, int reg,
+                                       int bit, u64 *value)
+{
+        int data;
+
+        if (regmap_read(regmap, reg, &data))
+                return -EIO;
+
+        *value = (data & BIT(bit)) ? 1 : 0;
+        return 0;
+}
+
+static int intel_xpower_pmic_update_power(struct regmap *regmap, int reg,
+                                          int bit, bool on)
+{
+        int data;
+
+        if (regmap_read(regmap, reg, &data))
+                return -EIO;
+
+        if (on)
+                data |= BIT(bit);
+        else
+                data &= ~BIT(bit);
+
+        if (regmap_write(regmap, reg, data))
+                return -EIO;
+
+        return 0;
+}
+
+/**
+ * intel_xpower_pmic_get_raw_temp(): Get raw temperature reading from the PMIC
+ *
+ * @regmap: regmap of the PMIC device
+ * @reg: register to get the reading
+ *
+ * We could get the sensor value by manipulating the HW regs here, but since
+ * the axp288 IIO driver may also access the same regs at the same time, the
+ * APIs provided by IIO subsystem are used here instead to avoid problems. As
+ * a result, the two passed in params are of no actual use.
+ *
+ * Return a positive value on success, errno on failure.
+ */
+static int intel_xpower_pmic_get_raw_temp(struct regmap *regmap, int reg)
+{
+        struct iio_channel *gpadc_chan;
+        int ret, val;
+
+        gpadc_chan = iio_channel_get(NULL, "axp288-system-temp");
+        if (IS_ERR_OR_NULL(gpadc_chan))
+                return -EACCES;
+
+        ret = iio_read_channel_raw(gpadc_chan, &val);
+        if (ret < 0)
+                val = ret;
+
+        iio_channel_release(gpadc_chan);
+        return val;
+}
+
+static struct intel_pmic_opregion_data intel_xpower_pmic_opregion_data = {
+        .get_power = intel_xpower_pmic_get_power,
+        .update_power = intel_xpower_pmic_update_power,
+        .get_raw_temp = intel_xpower_pmic_get_raw_temp,
+        .power_table = power_table,
+        .power_table_count = ARRAY_SIZE(power_table),
+        .thermal_table = thermal_table,
+        .thermal_table_count = ARRAY_SIZE(thermal_table),
+};
+
+static acpi_status intel_xpower_pmic_gpio_handler(u32 function,
+                acpi_physical_address address, u32 bit_width, u64 *value,
+                void *handler_context, void *region_context)
+{
+        return AE_OK;
+}
+
+static int intel_xpower_pmic_opregion_probe(struct platform_device *pdev)
+{
+        struct device *parent = pdev->dev.parent;
+        struct axp20x_dev *axp20x = dev_get_drvdata(parent);
+        acpi_status status;
+        int result;
+
+        status = acpi_install_address_space_handler(ACPI_HANDLE(parent),
+                        ACPI_ADR_SPACE_GPIO, intel_xpower_pmic_gpio_handler,
+                        NULL, NULL);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        result = intel_pmic_install_opregion_handler(&pdev->dev,
+                                        ACPI_HANDLE(parent), axp20x->regmap,
+                                        &intel_xpower_pmic_opregion_data);
+        if (result)
+                acpi_remove_address_space_handler(ACPI_HANDLE(parent),
+                                                  ACPI_ADR_SPACE_GPIO,
+                                                  intel_xpower_pmic_gpio_handler);
+
+        return result;
+}
+
+static struct platform_driver intel_xpower_pmic_opregion_driver = {
+        .probe = intel_xpower_pmic_opregion_probe,
+        .driver = {
+                .name = "axp288_pmic_acpi",
+        },
+};
+
+static int __init intel_xpower_pmic_opregion_driver_init(void)
+{
+        return platform_driver_register(&intel_xpower_pmic_opregion_driver);
+}
+module_init(intel_xpower_pmic_opregion_driver_init);
+
+MODULE_DESCRIPTION("XPower AXP288 ACPI operation region driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 17f9ec501972..499536504698 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -334,10 +334,10 @@ static int acpi_processor_get_power_info_default(struct acpi_processor *pr)
 
 static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
 {
-        acpi_status status = 0;
+        acpi_status status;
         u64 count;
         int current_count;
-        int i;
+        int i, ret = 0;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *cst;
 
@@ -358,7 +358,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
         /* There must be at least 2 elements */
         if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
                 printk(KERN_ERR PREFIX "not enough elements in _CST\n");
-                status = -EFAULT;
+                ret = -EFAULT;
                 goto end;
         }
 
@@ -367,7 +367,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
         /* Validate number of power states. */
         if (count < 1 || count != cst->package.count - 1) {
                 printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
-                status = -EFAULT;
+                ret = -EFAULT;
                 goto end;
         }
 
@@ -489,12 +489,12 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
 
         /* Validate number of power states discovered */
         if (current_count < 2)
-                status = -EFAULT;
+                ret = -EFAULT;
 
       end:
         kfree(buffer.pointer);
 
-        return status;
+        return ret;
 }
 
 static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
@@ -985,8 +985,8 @@ static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
                 state->flags = 0;
                 switch (cx->type) {
                         case ACPI_STATE_C1:
-                        if (cx->entry_method == ACPI_CSTATE_FFH)
-                                state->flags |= CPUIDLE_FLAG_TIME_VALID;
+                        if (cx->entry_method != ACPI_CSTATE_FFH)
+                                state->flags |= CPUIDLE_FLAG_TIME_INVALID;
 
                         state->enter = acpi_idle_enter_c1;
                         state->enter_dead = acpi_idle_play_dead;
@@ -994,14 +994,12 @@ static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
                         break;
 
                         case ACPI_STATE_C2:
-                        state->flags |= CPUIDLE_FLAG_TIME_VALID;
                         state->enter = acpi_idle_enter_simple;
                         state->enter_dead = acpi_idle_play_dead;
                         drv->safe_state_index = count;
                         break;
 
                         case ACPI_STATE_C3:
-                        state->flags |= CPUIDLE_FLAG_TIME_VALID;
                         state->enter = pr->flags.bm_check ?
                                         acpi_idle_enter_bm :
                                         acpi_idle_enter_simple;
@@ -1111,7 +1109,7 @@ static int acpi_processor_registered;
 
 int acpi_processor_power_init(struct acpi_processor *pr)
 {
-        acpi_status status = 0;
+        acpi_status status;
         int retval;
         struct cpuidle_device *dev;
         static int first_run;
diff --git a/drivers/acpi/property.c b/drivers/acpi/property.c
new file mode 100644
index 000000000000..0d083736e25b
--- /dev/null
+++ b/drivers/acpi/property.c
@@ -0,0 +1,551 @@
+/*
+ * ACPI device specific properties support.
+ *
+ * Copyright (C) 2014, Intel Corporation
+ * All rights reserved.
+ *
+ * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
+ *          Darren Hart <dvhart@linux.intel.com>
+ *          Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/acpi.h>
+#include <linux/device.h>
+#include <linux/export.h>
+
+#include "internal.h"
+
+/* ACPI _DSD device properties UUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
+static const u8 prp_uuid[16] = {
+        0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d,
+        0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01
+};
+
+static bool acpi_property_value_ok(const union acpi_object *value)
+{
+        int j;
+
+        /*
+         * The value must be an integer, a string, a reference, or a package
+         * whose every element must be an integer, a string, or a reference.
+         */
+        switch (value->type) {
+        case ACPI_TYPE_INTEGER:
+        case ACPI_TYPE_STRING:
+        case ACPI_TYPE_LOCAL_REFERENCE:
+                return true;
+
+        case ACPI_TYPE_PACKAGE:
+                for (j = 0; j < value->package.count; j++)
+                        switch (value->package.elements[j].type) {
+                        case ACPI_TYPE_INTEGER:
+                        case ACPI_TYPE_STRING:
+                        case ACPI_TYPE_LOCAL_REFERENCE:
+                                continue;
+
+                        default:
+                                return false;
+                        }
+
+                return true;
+        }
+        return false;
+}
+
+static bool acpi_properties_format_valid(const union acpi_object *properties)
+{
+        int i;
+
+        for (i = 0; i < properties->package.count; i++) {
+                const union acpi_object *property;
+
+                property = &properties->package.elements[i];
+                /*
+                 * Only two elements allowed, the first one must be a string and
+                 * the second one has to satisfy certain conditions.
+                 */
+                if (property->package.count != 2
+                    || property->package.elements[0].type != ACPI_TYPE_STRING
+                    || !acpi_property_value_ok(&property->package.elements[1]))
+                        return false;
+        }
+        return true;
+}
+
+static void acpi_init_of_compatible(struct acpi_device *adev)
+{
+        const union acpi_object *of_compatible;
+        struct acpi_hardware_id *hwid;
+        bool acpi_of = false;
+        int ret;
+
+        /*
+         * Check if the special PRP0001 ACPI ID is present and in that
+         * case we fill in Device Tree compatible properties for this
+         * device.
+         */
+        list_for_each_entry(hwid, &adev->pnp.ids, list) {
+                if (!strcmp(hwid->id, "PRP0001")) {
+                        acpi_of = true;
+                        break;
+                }
+        }
+
+        if (!acpi_of)
+                return;
+
+        ret = acpi_dev_get_property_array(adev, "compatible", ACPI_TYPE_STRING,
+                                          &of_compatible);
+        if (ret) {
+                ret = acpi_dev_get_property(adev, "compatible",
+                                            ACPI_TYPE_STRING, &of_compatible);
+                if (ret) {
+                        acpi_handle_warn(adev->handle,
+                                         "PRP0001 requires compatible property\n");
+                        return;
+                }
+        }
+        adev->data.of_compatible = of_compatible;
+}
+
+void acpi_init_properties(struct acpi_device *adev)
+{
+        struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
+        const union acpi_object *desc;
+        acpi_status status;
+        int i;
+
+        status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
+                                            ACPI_TYPE_PACKAGE);
+        if (ACPI_FAILURE(status))
+                return;
+
+        desc = buf.pointer;
+        if (desc->package.count % 2)
+                goto fail;
+
+        /* Look for the device properties UUID. */
+        for (i = 0; i < desc->package.count; i += 2) {
+                const union acpi_object *uuid, *properties;
+
+                uuid = &desc->package.elements[i];
+                properties = &desc->package.elements[i + 1];
+
+                /*
+                 * The first element must be a UUID and the second one must be
+                 * a package.
+                 */
+                if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16
+                    || properties->type != ACPI_TYPE_PACKAGE)
+                        break;
+
+                if (memcmp(uuid->buffer.pointer, prp_uuid, sizeof(prp_uuid)))
+                        continue;
+
+                /*
+                 * We found the matching UUID. Now validate the format of the
+                 * package immediately following it.
+                 */
+                if (!acpi_properties_format_valid(properties))
+                        break;
+
+                adev->data.pointer = buf.pointer;
+                adev->data.properties = properties;
+
+                acpi_init_of_compatible(adev);
+                return;
+        }
+
+ fail:
+        dev_warn(&adev->dev, "Returned _DSD data is not valid, skipping\n");
+        ACPI_FREE(buf.pointer);
+}
+
+void acpi_free_properties(struct acpi_device *adev)
+{
+        ACPI_FREE((void *)adev->data.pointer);
+        adev->data.of_compatible = NULL;
+        adev->data.pointer = NULL;
+        adev->data.properties = NULL;
+}
+
+/**
+ * acpi_dev_get_property - return an ACPI property with given name
+ * @adev: ACPI device to get property
+ * @name: Name of the property
+ * @type: Expected property type
+ * @obj: Location to store the property value (if not %NULL)
+ *
+ * Look up a property with @name and store a pointer to the resulting ACPI
+ * object at the location pointed to by @obj if found.
+ *
+ * Callers must not attempt to free the returned objects.  These objects will be
+ * freed by the ACPI core automatically during the removal of @adev.
+ *
+ * Return: %0 if property with @name has been found (success),
+ *         %-EINVAL if the arguments are invalid,
+ *         %-ENODATA if the property doesn't exist,
+ *         %-EPROTO if the property value type doesn't match @type.
+ */
+int acpi_dev_get_property(struct acpi_device *adev, const char *name,
+                          acpi_object_type type, const union acpi_object **obj)
+{
+        const union acpi_object *properties;
+        int i;
+
+        if (!adev || !name)
+                return -EINVAL;
+
+        if (!adev->data.pointer || !adev->data.properties)
+                return -ENODATA;
+
+        properties = adev->data.properties;
+        for (i = 0; i < properties->package.count; i++) {
+                const union acpi_object *propname, *propvalue;
+                const union acpi_object *property;
+
+                property = &properties->package.elements[i];
+
+                propname = &property->package.elements[0];
+                propvalue = &property->package.elements[1];
+
+                if (!strcmp(name, propname->string.pointer)) {
+                        if (type != ACPI_TYPE_ANY && propvalue->type != type)
+                                return -EPROTO;
+                        else if (obj)
+                                *obj = propvalue;
+
+                        return 0;
+                }
+        }
+        return -ENODATA;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_get_property);
+
+/**
+ * acpi_dev_get_property_array - return an ACPI array property with given name
+ * @adev: ACPI device to get property
+ * @name: Name of the property
+ * @type: Expected type of array elements
+ * @obj: Location to store a pointer to the property value (if not NULL)
+ *
+ * Look up an array property with @name and store a pointer to the resulting
+ * ACPI object at the location pointed to by @obj if found.
+ *
+ * Callers must not attempt to free the returned objects.  Those objects will be
+ * freed by the ACPI core automatically during the removal of @adev.
+ *
+ * Return: %0 if array property (package) with @name has been found (success),
+ *         %-EINVAL if the arguments are invalid,
+ *         %-ENODATA if the property doesn't exist,
+ *         %-EPROTO if the property is not a package or the type of its elements
+ *           doesn't match @type.
+ */
+int acpi_dev_get_property_array(struct acpi_device *adev, const char *name,
+                                acpi_object_type type,
+                                const union acpi_object **obj)
+{
+        const union acpi_object *prop;
+        int ret, i;
+
+        ret = acpi_dev_get_property(adev, name, ACPI_TYPE_PACKAGE, &prop);
+        if (ret)
+                return ret;
+
+        if (type != ACPI_TYPE_ANY) {
+                /* Check that all elements are of correct type. */
+                for (i = 0; i < prop->package.count; i++)
+                        if (prop->package.elements[i].type != type)
+                                return -EPROTO;
+        }
+        if (obj)
+                *obj = prop;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_get_property_array);
+
+/**
+ * acpi_dev_get_property_reference - returns handle to the referenced object
+ * @adev: ACPI device to get property
+ * @name: Name of the property
+ * @index: Index of the reference to return
+ * @args: Location to store the returned reference with optional arguments
+ *
+ * Find property with @name, verifify that it is a package containing at least
+ * one object reference and if so, store the ACPI device object pointer to the
+ * target object in @args->adev.  If the reference includes arguments, store
+ * them in the @args->args[] array.
+ *
+ * If there's more than one reference in the property value package, @index is
+ * used to select the one to return.
+ *
+ * Return: %0 on success, negative error code on failure.
+ */
+int acpi_dev_get_property_reference(struct acpi_device *adev,
+                                    const char *name, size_t index,
+                                    struct acpi_reference_args *args)
+{
+        const union acpi_object *element, *end;
+        const union acpi_object *obj;
+        struct acpi_device *device;
+        int ret, idx = 0;
+
+        ret = acpi_dev_get_property(adev, name, ACPI_TYPE_ANY, &obj);
+        if (ret)
+                return ret;
+
+        /*
+         * The simplest case is when the value is a single reference.  Just
+         * return that reference then.
+         */
+        if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) {
+                if (index)
+                        return -EINVAL;
+
+                ret = acpi_bus_get_device(obj->reference.handle, &device);
+                if (ret)
+                        return ret;
+
+                args->adev = device;
+                args->nargs = 0;
+                return 0;
+        }
+
+        /*
+         * If it is not a single reference, then it is a package of
+         * references followed by number of ints as follows:
+         *
+         *  Package () { REF, INT, REF, INT, INT }
+         *
+         * The index argument is then used to determine which reference
+         * the caller wants (along with the arguments).
+         */
+        if (obj->type != ACPI_TYPE_PACKAGE || index >= obj->package.count)
+                return -EPROTO;
+
+        element = obj->package.elements;
+        end = element + obj->package.count;
+
+        while (element < end) {
+                u32 nargs, i;
+
+                if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
+                        return -EPROTO;
+
+                ret = acpi_bus_get_device(element->reference.handle, &device);
+                if (ret)
+                        return -ENODEV;
+
+                element++;
+                nargs = 0;
+
+                /* assume following integer elements are all args */
+                for (i = 0; element + i < end; i++) {
+                        int type = element[i].type;
+
+                        if (type == ACPI_TYPE_INTEGER)
+                                nargs++;
+                        else if (type == ACPI_TYPE_LOCAL_REFERENCE)
+                                break;
+                        else
+                                return -EPROTO;
+                }
+
+                if (idx++ == index) {
+                        args->adev = device;
+                        args->nargs = nargs;
+                        for (i = 0; i < nargs; i++)
+                                args->args[i] = element[i].integer.value;
+
+                        return 0;
+                }
+
+                element += nargs;
+        }
+
+        return -EPROTO;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_get_property_reference);
+
+int acpi_dev_prop_get(struct acpi_device *adev, const char *propname,
+                      void **valptr)
+{
+        return acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
+                                     (const union acpi_object **)valptr);
+}
+
+int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
+                              enum dev_prop_type proptype, void *val)
+{
+        const union acpi_object *obj;
+        int ret;
+
+        if (!val)
+                return -EINVAL;
+
+        if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) {
+                ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_INTEGER, &obj);
+                if (ret)
+                        return ret;
+
+                switch (proptype) {
+                case DEV_PROP_U8:
+                        if (obj->integer.value > U8_MAX)
+                                return -EOVERFLOW;
+                        *(u8 *)val = obj->integer.value;
+                        break;
+                case DEV_PROP_U16:
+                        if (obj->integer.value > U16_MAX)
+                                return -EOVERFLOW;
+                        *(u16 *)val = obj->integer.value;
+                        break;
+                case DEV_PROP_U32:
+                        if (obj->integer.value > U32_MAX)
+                                return -EOVERFLOW;
+                        *(u32 *)val = obj->integer.value;
+                        break;
+                default:
+                        *(u64 *)val = obj->integer.value;
+                        break;
+                }
+        } else if (proptype == DEV_PROP_STRING) {
+                ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_STRING, &obj);
+                if (ret)
+                        return ret;
+
+                *(char **)val = obj->string.pointer;
+        } else {
+                ret = -EINVAL;
+        }
+        return ret;
+}
+
+static int acpi_copy_property_array_u8(const union acpi_object *items, u8 *val,
+                                       size_t nval)
+{
+        int i;
+
+        for (i = 0; i < nval; i++) {
+                if (items[i].type != ACPI_TYPE_INTEGER)
+                        return -EPROTO;
+                if (items[i].integer.value > U8_MAX)
+                        return -EOVERFLOW;
+
+                val[i] = items[i].integer.value;
+        }
+        return 0;
+}
+
+static int acpi_copy_property_array_u16(const union acpi_object *items,
+                                        u16 *val, size_t nval)
+{
+        int i;
+
+        for (i = 0; i < nval; i++) {
+                if (items[i].type != ACPI_TYPE_INTEGER)
+                        return -EPROTO;
+                if (items[i].integer.value > U16_MAX)
+                        return -EOVERFLOW;
+
+                val[i] = items[i].integer.value;
+        }
+        return 0;
+}
+
+static int acpi_copy_property_array_u32(const union acpi_object *items,
+                                        u32 *val, size_t nval)
+{
+        int i;
+
+        for (i = 0; i < nval; i++) {
+                if (items[i].type != ACPI_TYPE_INTEGER)
+                        return -EPROTO;
+                if (items[i].integer.value > U32_MAX)
+                        return -EOVERFLOW;
+
+                val[i] = items[i].integer.value;
+        }
+        return 0;
+}
+
+static int acpi_copy_property_array_u64(const union acpi_object *items,
+                                        u64 *val, size_t nval)
+{
+        int i;
+
+        for (i = 0; i < nval; i++) {
+                if (items[i].type != ACPI_TYPE_INTEGER)
+                        return -EPROTO;
+
+                val[i] = items[i].integer.value;
+        }
+        return 0;
+}
+
+static int acpi_copy_property_array_string(const union acpi_object *items,
+                                           char **val, size_t nval)
+{
+        int i;
+
+        for (i = 0; i < nval; i++) {
+                if (items[i].type != ACPI_TYPE_STRING)
+                        return -EPROTO;
+
+                val[i] = items[i].string.pointer;
+        }
+        return 0;
+}
+
+int acpi_dev_prop_read(struct acpi_device *adev, const char *propname,
+                       enum dev_prop_type proptype, void *val, size_t nval)
+{
+        const union acpi_object *obj;
+        const union acpi_object *items;
+        int ret;
+
+        if (val && nval == 1) {
+                ret = acpi_dev_prop_read_single(adev, propname, proptype, val);
+                if (!ret)
+                        return ret;
+        }
+
+        ret = acpi_dev_get_property_array(adev, propname, ACPI_TYPE_ANY, &obj);
+        if (ret)
+                return ret;
+
+        if (!val)
+                return obj->package.count;
+        else if (nval <= 0)
+                return -EINVAL;
+
+        if (nval > obj->package.count)
+                return -EOVERFLOW;
+
+        items = obj->package.elements;
+        switch (proptype) {
+        case DEV_PROP_U8:
+                ret = acpi_copy_property_array_u8(items, (u8 *)val, nval);
+                break;
+        case DEV_PROP_U16:
+                ret = acpi_copy_property_array_u16(items, (u16 *)val, nval);
+                break;
+        case DEV_PROP_U32:
+                ret = acpi_copy_property_array_u32(items, (u32 *)val, nval);
+                break;
+        case DEV_PROP_U64:
+                ret = acpi_copy_property_array_u64(items, (u64 *)val, nval);
+                break;
+        case DEV_PROP_STRING:
+                ret = acpi_copy_property_array_string(items, (char **)val, nval);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+        return ret;
+}
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 0476e90b2091..1b1cf558d3d3 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -36,6 +36,8 @@ bool acpi_force_hot_remove;
 
 static const char *dummy_hid = "device";
 
+static LIST_HEAD(acpi_dep_list);
+static DEFINE_MUTEX(acpi_dep_list_lock);
 static LIST_HEAD(acpi_bus_id_list);
 static DEFINE_MUTEX(acpi_scan_lock);
 static LIST_HEAD(acpi_scan_handlers_list);
@@ -43,6 +45,12 @@ DEFINE_MUTEX(acpi_device_lock);
 LIST_HEAD(acpi_wakeup_device_list);
 static DEFINE_MUTEX(acpi_hp_context_lock);
 
+struct acpi_dep_data {
+        struct list_head node;
+        acpi_handle master;
+        acpi_handle slave;
+};
+
 struct acpi_device_bus_id{
         char bus_id[15];
         unsigned int instance_no;
@@ -124,17 +132,56 @@ static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
         if (list_empty(&acpi_dev->pnp.ids))
                 return 0;
 
-        len = snprintf(modalias, size, "acpi:");
-        size -= len;
-
-        list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
-                count = snprintf(&modalias[len], size, "%s:", id->id);
-                if (count < 0)
-                        return -EINVAL;
-                if (count >= size)
-                        return -ENOMEM;
-                len += count;
-                size -= count;
+        /*
+         * If the device has PRP0001 we expose DT compatible modalias
+         * instead in form of of:NnameTCcompatible.
+         */
+        if (acpi_dev->data.of_compatible) {
+                struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
+                const union acpi_object *of_compatible, *obj;
+                int i, nval;
+                char *c;
+
+                acpi_get_name(acpi_dev->handle, ACPI_SINGLE_NAME, &buf);
+                /* DT strings are all in lower case */
+                for (c = buf.pointer; *c != '\0'; c++)
+                        *c = tolower(*c);
+
+                len = snprintf(modalias, size, "of:N%sT", (char *)buf.pointer);
+                ACPI_FREE(buf.pointer);
+
+                of_compatible = acpi_dev->data.of_compatible;
+                if (of_compatible->type == ACPI_TYPE_PACKAGE) {
+                        nval = of_compatible->package.count;
+                        obj = of_compatible->package.elements;
+                } else { /* Must be ACPI_TYPE_STRING. */
+                        nval = 1;
+                        obj = of_compatible;
+                }
+                for (i = 0; i < nval; i++, obj++) {
+                        count = snprintf(&modalias[len], size, "C%s",
+                                         obj->string.pointer);
+                        if (count < 0)
+                                return -EINVAL;
+                        if (count >= size)
+                                return -ENOMEM;
+
+                        len += count;
+                        size -= count;
+                }
+        } else {
+                len = snprintf(modalias, size, "acpi:");
+                size -= len;
+
+                list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
+                        count = snprintf(&modalias[len], size, "%s:", id->id);
+                        if (count < 0)
+                                return -EINVAL;
+                        if (count >= size)
+                                return -ENOMEM;
+                        len += count;
+                        size -= count;
+                }
         }
 
         modalias[len] = '\0';
@@ -902,6 +949,51 @@ int acpi_match_device_ids(struct acpi_device *device,
 }
 EXPORT_SYMBOL(acpi_match_device_ids);
 
+/* Performs match against special "PRP0001" shoehorn ACPI ID */
+static bool acpi_of_driver_match_device(struct device *dev,
+                                        const struct device_driver *drv)
+{
+        const union acpi_object *of_compatible, *obj;
+        struct acpi_device *adev;
+        int i, nval;
+
+        adev = ACPI_COMPANION(dev);
+        if (!adev)
+                return false;
+
+        of_compatible = adev->data.of_compatible;
+        if (!drv->of_match_table || !of_compatible)
+                return false;
+
+        if (of_compatible->type == ACPI_TYPE_PACKAGE) {
+                nval = of_compatible->package.count;
+                obj = of_compatible->package.elements;
+        } else { /* Must be ACPI_TYPE_STRING. */
+                nval = 1;
+                obj = of_compatible;
+        }
+        /* Now we can look for the driver DT compatible strings */
+        for (i = 0; i < nval; i++, obj++) {
+                const struct of_device_id *id;
+
+                for (id = drv->of_match_table; id->compatible[0]; id++)
+                        if (!strcasecmp(obj->string.pointer, id->compatible))
+                                return true;
+        }
+
+        return false;
+}
+
+bool acpi_driver_match_device(struct device *dev,
+                              const struct device_driver *drv)
+{
+        if (!drv->acpi_match_table)
+                return acpi_of_driver_match_device(dev, drv);
+
+        return !!acpi_match_device(drv->acpi_match_table, dev);
+}
+EXPORT_SYMBOL_GPL(acpi_driver_match_device);
+
 static void acpi_free_power_resources_lists(struct acpi_device *device)
 {
         int i;
@@ -922,6 +1014,7 @@ static void acpi_device_release(struct device *dev)
 {
         struct acpi_device *acpi_dev = to_acpi_device(dev);
 
+        acpi_free_properties(acpi_dev);
         acpi_free_pnp_ids(&acpi_dev->pnp);
         acpi_free_power_resources_lists(acpi_dev);
         kfree(acpi_dev);
@@ -1304,6 +1397,26 @@ int acpi_device_add(struct acpi_device *device,
         return result;
 }
 
+struct acpi_device *acpi_get_next_child(struct device *dev,
+                                        struct acpi_device *child)
+{
+        struct acpi_device *adev = ACPI_COMPANION(dev);
+        struct list_head *head, *next;
+
+        if (!adev)
+                return NULL;
+
+        head = &adev->children;
+        if (list_empty(head))
+                return NULL;
+
+        if (!child)
+                return list_first_entry(head, struct acpi_device, node);
+
+        next = child->node.next;
+        return next == head ? NULL : list_entry(next, struct acpi_device, node);
+}
+
 /* --------------------------------------------------------------------------
                                  Driver Management
    -------------------------------------------------------------------------- */
@@ -1923,9 +2036,11 @@ void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
         device->device_type = type;
         device->handle = handle;
         device->parent = acpi_bus_get_parent(handle);
+        device->fwnode.type = FWNODE_ACPI;
         acpi_set_device_status(device, sta);
         acpi_device_get_busid(device);
         acpi_set_pnp_ids(handle, &device->pnp, type);
+        acpi_init_properties(device);
         acpi_bus_get_flags(device);
         device->flags.match_driver = false;
         device->flags.initialized = true;
@@ -2086,6 +2201,59 @@ static void acpi_scan_init_hotplug(struct acpi_device *adev)
         }
 }
 
+static void acpi_device_dep_initialize(struct acpi_device *adev)
+{
+        struct acpi_dep_data *dep;
+        struct acpi_handle_list dep_devices;
+        acpi_status status;
+        int i;
+
+        if (!acpi_has_method(adev->handle, "_DEP"))
+                return;
+
+        status = acpi_evaluate_reference(adev->handle, "_DEP", NULL,
+                                        &dep_devices);
+        if (ACPI_FAILURE(status)) {
+                dev_err(&adev->dev, "Failed to evaluate _DEP.\n");
+                return;
+        }
+
+        for (i = 0; i < dep_devices.count; i++) {
+                struct acpi_device_info *info;
+                int skip;
+
+                status = acpi_get_object_info(dep_devices.handles[i], &info);
+                if (ACPI_FAILURE(status)) {
+                        dev_err(&adev->dev, "Error reading device info\n");
+                        continue;
+                }
+
+                /*
+                 * Skip the dependency of Windows System Power
+                 * Management Controller
+                 */
+                skip = info->valid & ACPI_VALID_HID &&
+                        !strcmp(info->hardware_id.string, "INT3396");
+
+                kfree(info);
+
+                if (skip)
+                        continue;
+
+                dep = kzalloc(sizeof(struct acpi_dep_data), GFP_KERNEL);
+                if (!dep)
+                        return;
+
+                dep->master = dep_devices.handles[i];
+                dep->slave  = adev->handle;
+                adev->dep_unmet++;
+
+                mutex_lock(&acpi_dep_list_lock);
+                list_add_tail(&dep->node , &acpi_dep_list);
+                mutex_unlock(&acpi_dep_list_lock);
+        }
+}
+
 static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
                                       void *not_used, void **return_value)
 {
@@ -2112,6 +2280,7 @@ static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
                 return AE_CTRL_DEPTH;
 
         acpi_scan_init_hotplug(device);
+        acpi_device_dep_initialize(device);
 
  out:
         if (!*return_value)
@@ -2232,6 +2401,29 @@ static void acpi_bus_attach(struct acpi_device *device)
                 device->handler->hotplug.notify_online(device);
 }
 
+void acpi_walk_dep_device_list(acpi_handle handle)
+{
+        struct acpi_dep_data *dep, *tmp;
+        struct acpi_device *adev;
+
+        mutex_lock(&acpi_dep_list_lock);
+        list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
+                if (dep->master == handle) {
+                        acpi_bus_get_device(dep->slave, &adev);
+                        if (!adev)
+                                continue;
+
+                        adev->dep_unmet--;
+                        if (!adev->dep_unmet)
+                                acpi_bus_attach(adev);
+                        list_del(&dep->node);
+                        kfree(dep);
+                }
+        }
+        mutex_unlock(&acpi_dep_list_lock);
+}
+EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
+
 /**
  * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
  * @handle: Root of the namespace scope to scan.
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index 05a31b573fc3..8aa9254a387f 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -630,6 +630,7 @@ static int acpi_freeze_begin(void)
 static int acpi_freeze_prepare(void)
 {
         acpi_enable_all_wakeup_gpes();
+        acpi_os_wait_events_complete();
         enable_irq_wake(acpi_gbl_FADT.sci_interrupt);
         return 0;
 }
@@ -825,6 +826,7 @@ static void acpi_power_off_prepare(void)
         /* Prepare to power off the system */
         acpi_sleep_prepare(ACPI_STATE_S5);
         acpi_disable_all_gpes();
+        acpi_os_wait_events_complete();
 }
 
 static void acpi_power_off(void)
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index 6d5a6cda0734..93b81523a2fe 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -190,30 +190,24 @@ void acpi_table_print_madt_entry(struct acpi_subtable_header *header)
         }
 }
 
-
 int __init
-acpi_table_parse_entries(char *id,
-                             unsigned long table_size,
-                             int entry_id,
-                             acpi_tbl_entry_handler handler,
-                             unsigned int max_entries)
+acpi_parse_entries(char *id, unsigned long table_size,
+                acpi_tbl_entry_handler handler,
+                struct acpi_table_header *table_header,
+                int entry_id, unsigned int max_entries)
 {
-        struct acpi_table_header *table_header = NULL;
         struct acpi_subtable_header *entry;
-        unsigned int count = 0;
+        int count = 0;
         unsigned long table_end;
-        acpi_size tbl_size;
 
         if (acpi_disabled)
                 return -ENODEV;
 
-        if (!handler)
+        if (!id || !handler)
                 return -EINVAL;
 
-        if (strncmp(id, ACPI_SIG_MADT, 4) == 0)
-                acpi_get_table_with_size(id, acpi_apic_instance, &table_header, &tbl_size);
-        else
-                acpi_get_table_with_size(id, 0, &table_header, &tbl_size);
+        if (!table_size)
+                return -EINVAL;
 
         if (!table_header) {
                 pr_warn("%4.4s not present\n", id);
@@ -230,9 +224,12 @@ acpi_table_parse_entries(char *id,
         while (((unsigned long)entry) + sizeof(struct acpi_subtable_header) <
                table_end) {
                 if (entry->type == entry_id
-                    && (!max_entries || count++ < max_entries))
+                    && (!max_entries || count < max_entries)) {
                         if (handler(entry, table_end))
-                                goto err;
+                                return -EINVAL;
+
+                        count++;
+                }
 
                 /*
                  * If entry->length is 0, break from this loop to avoid
@@ -240,22 +237,53 @@ acpi_table_parse_entries(char *id,
                  */
                 if (entry->length == 0) {
                         pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, entry_id);
-                        goto err;
+                        return -EINVAL;
                 }
 
                 entry = (struct acpi_subtable_header *)
                     ((unsigned long)entry + entry->length);
         }
+
         if (max_entries && count > max_entries) {
                 pr_warn("[%4.4s:0x%02x] ignored %i entries of %i found\n",
                         id, entry_id, count - max_entries, count);
         }
 
-        early_acpi_os_unmap_memory((char *)table_header, tbl_size);
         return count;
-err:
+}
+
+int __init
+acpi_table_parse_entries(char *id,
+                         unsigned long table_size,
+                         int entry_id,
+                         acpi_tbl_entry_handler handler,
+                         unsigned int max_entries)
+{
+        struct acpi_table_header *table_header = NULL;
+        acpi_size tbl_size;
+        int count;
+        u32 instance = 0;
+
+        if (acpi_disabled)
+                return -ENODEV;
+
+        if (!id || !handler)
+                return -EINVAL;
+
+        if (!strncmp(id, ACPI_SIG_MADT, 4))
+                instance = acpi_apic_instance;
+
+        acpi_get_table_with_size(id, instance, &table_header, &tbl_size);
+        if (!table_header) {
+                pr_warn("%4.4s not present\n", id);
+                return -ENODEV;
+        }
+
+        count = acpi_parse_entries(id, table_size, handler, table_header,
+                        entry_id, max_entries);
+
         early_acpi_os_unmap_memory((char *)table_header, tbl_size);
-        return -EINVAL;
+        return count;
 }
 
 int __init
diff --git a/drivers/acpi/utils.c b/drivers/acpi/utils.c
index 371ac12d25b1..dd8ff63ee2b4 100644
--- a/drivers/acpi/utils.c
+++ b/drivers/acpi/utils.c
@@ -136,8 +136,7 @@ acpi_extract_package(union acpi_object *package,
                                 break;
                         case 'B':
                                 size_required +=
-                                    sizeof(u8 *) +
-                                    (element->buffer.length * sizeof(u8));
+                                    sizeof(u8 *) + element->buffer.length;
                                 tail_offset += sizeof(u8 *);
                                 break;
                         default:
@@ -255,7 +254,7 @@ acpi_extract_package(union acpi_object *package,
                                 memcpy(tail, element->buffer.pointer,
                                        element->buffer.length);
                                 head += sizeof(u8 *);
-                                tail += element->buffer.length * sizeof(u8);
+                                tail += element->buffer.length;
                                 break;
                         default:
                                 /* Should never get here */
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 807a88a0f394..185a57d13723 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -1164,7 +1164,8 @@ static bool acpi_video_device_in_dod(struct acpi_video_device *device)
                 return true;
 
         for (i = 0; i < video->attached_count; i++) {
-                if (video->attached_array[i].bind_info == device)
+                if ((video->attached_array[i].value.int_val & 0xfff) ==
+                    (device->device_id & 0xfff))
                         return true;
         }
 
@@ -1680,6 +1681,19 @@ static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
                 printk(KERN_ERR PREFIX "Create sysfs link\n");
 }
 
+static void acpi_video_run_bcl_for_osi(struct acpi_video_bus *video)
+{
+        struct acpi_video_device *dev;
+        union acpi_object *levels;
+
+        mutex_lock(&video->device_list_lock);
+        list_for_each_entry(dev, &video->video_device_list, entry) {
+                if (!acpi_video_device_lcd_query_levels(dev, &levels))
+                        kfree(levels);
+        }
+        mutex_unlock(&video->device_list_lock);
+}
+
 static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
 {
         struct acpi_video_device *dev;
@@ -1687,6 +1701,8 @@ static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
         if (video->backlight_registered)
                 return 0;
 
+        acpi_video_run_bcl_for_osi(video);
+
         if (!acpi_video_verify_backlight_support())
                 return 0;
 
diff --git a/drivers/amba/Kconfig b/drivers/amba/Kconfig
new file mode 100644
index 000000000000..4a5c9d279059
--- /dev/null
+++ b/drivers/amba/Kconfig
@@ -0,0 +1,14 @@
+config ARM_AMBA
+        bool
+
+if ARM_AMBA
+
+config TEGRA_AHB
+        bool "Enable AHB driver for NVIDIA Tegra SoCs"
+        default y if ARCH_TEGRA
+        help
+          Adds AHB configuration functionality for NVIDIA Tegra SoCs,
+          which controls AHB bus master arbitration and some performance
+          parameters (priority, prefetch size).
+
+endif
diff --git a/drivers/amba/bus.c b/drivers/amba/bus.c
index 47bbdc1b5be3..973a3332a85f 100644
--- a/drivers/amba/bus.c
+++ b/drivers/amba/bus.c
@@ -124,7 +124,7 @@ static const struct dev_pm_ops amba_pm = {
         .thaw           = pm_generic_thaw,
         .poweroff       = pm_generic_poweroff,
         .restore        = pm_generic_restore,
-        SET_PM_RUNTIME_PM_OPS(
+        SET_RUNTIME_PM_OPS(
                 amba_pm_runtime_suspend,
                 amba_pm_runtime_resume,
                 NULL
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index e45f83789809..49f1e6890587 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -321,6 +321,9 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, 0x8c87), board_ahci }, /* 9 Series RAID */
         { PCI_VDEVICE(INTEL, 0x8c8e), board_ahci }, /* 9 Series RAID */
         { PCI_VDEVICE(INTEL, 0x8c8f), board_ahci }, /* 9 Series RAID */
+        { PCI_VDEVICE(INTEL, 0x9d03), board_ahci }, /* Sunrise Point-LP AHCI */
+        { PCI_VDEVICE(INTEL, 0x9d05), board_ahci }, /* Sunrise Point-LP RAID */
+        { PCI_VDEVICE(INTEL, 0x9d07), board_ahci }, /* Sunrise Point-LP RAID */
         { PCI_VDEVICE(INTEL, 0xa103), board_ahci }, /* Sunrise Point-H AHCI */
         { PCI_VDEVICE(INTEL, 0xa103), board_ahci }, /* Sunrise Point-H RAID */
         { PCI_VDEVICE(INTEL, 0xa105), board_ahci }, /* Sunrise Point-H RAID */
@@ -492,6 +495,7 @@ static const struct pci_device_id ahci_pci_tbl[] = {
          * enabled.  https://bugzilla.kernel.org/show_bug.cgi?id=60731
          */
         { PCI_VDEVICE(SAMSUNG, 0x1600), board_ahci_nomsi },
+        { PCI_VDEVICE(SAMSUNG, 0xa800), board_ahci_nomsi },
 
         /* Enmotus */
         { PCI_DEVICE(0x1c44, 0x8000), board_ahci },
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 0586f66d70fa..dd45c6a03e5d 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1164,7 +1164,7 @@ static int ata_scsi_dev_config(struct scsi_device *sdev,
 
                 depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
                 depth = min(ATA_MAX_QUEUE - 1, depth);
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
+                scsi_change_queue_depth(sdev, depth);
         }
 
         blk_queue_flush_queueable(q, false);
@@ -1243,21 +1243,17 @@ void ata_scsi_slave_destroy(struct scsi_device *sdev)
  *      @ap: ATA port to which the device change the queue depth
  *      @sdev: SCSI device to configure queue depth for
  *      @queue_depth: new queue depth
- *      @reason: calling context
  *
  *      libsas and libata have different approaches for associating a sdev to
  *      its ata_port.
  *
  */
 int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
-                             int queue_depth, int reason)
+                             int queue_depth)
 {
         struct ata_device *dev;
         unsigned long flags;
 
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (queue_depth < 1 || queue_depth == sdev->queue_depth)
                 return sdev->queue_depth;
 
@@ -1282,15 +1278,13 @@ int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
         if (sdev->queue_depth == queue_depth)
                 return -EINVAL;
 
-        scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
-        return queue_depth;
+        return scsi_change_queue_depth(sdev, queue_depth);
 }
 
 /**
  *      ata_scsi_change_queue_depth - SCSI callback for queue depth config
  *      @sdev: SCSI device to configure queue depth for
  *      @queue_depth: new queue depth
- *      @reason: calling context
  *
  *      This is libata standard hostt->change_queue_depth callback.
  *      SCSI will call into this callback when user tries to set queue
@@ -1302,12 +1296,11 @@ int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
  *      RETURNS:
  *      Newly configured queue depth.
  */
-int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth,
-                                int reason)
+int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
 {
         struct ata_port *ap = ata_shost_to_port(sdev->host);
 
-        return __ata_change_queue_depth(ap, sdev, queue_depth, reason);
+        return __ata_change_queue_depth(ap, sdev, queue_depth);
 }
 
 /**
@@ -3570,7 +3563,7 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
                 break;
 
-        case SERVICE_ACTION_IN:
+        case SERVICE_ACTION_IN_16:
                 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
                 else
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 07bc7e4dbd04..65071591b143 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -1488,7 +1488,7 @@ static int sata_fsl_probe(struct platform_device *ofdev)
         host_priv->csr_base = csr_base;
 
         irq = irq_of_parse_and_map(ofdev->dev.of_node, 0);
-        if (irq < 0) {
+        if (!irq) {
                 dev_err(&ofdev->dev, "invalid irq from platform\n");
                 goto error_exit_with_cleanup;
         }
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index cdf99fac139a..1db6f5ce5e89 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -1951,7 +1951,7 @@ static int nv_swncq_slave_config(struct scsi_device *sdev)
         ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
 
         if (strncmp(model_num, "Maxtor", 6) == 0) {
-                ata_scsi_change_queue_depth(sdev, 1, SCSI_QDEPTH_DEFAULT);
+                ata_scsi_change_queue_depth(sdev, 1);
                 ata_dev_notice(dev, "Disabling SWNCQ mode (depth %x)\n",
                                sdev->queue_depth);
         }
diff --git a/drivers/atm/solos-pci.c b/drivers/atm/solos-pci.c
index 7652e8dc188f..21b0bc6a9c96 100644
--- a/drivers/atm/solos-pci.c
+++ b/drivers/atm/solos-pci.c
@@ -1225,11 +1225,13 @@ static int fpga_probe(struct pci_dev *dev, const struct pci_device_id *id)
         card->config_regs = pci_iomap(dev, 0, CONFIG_RAM_SIZE);
         if (!card->config_regs) {
                 dev_warn(&dev->dev, "Failed to ioremap config registers\n");
+                err = -ENOMEM;
                 goto out_release_regions;
         }
         card->buffers = pci_iomap(dev, 1, DATA_RAM_SIZE);
         if (!card->buffers) {
                 dev_warn(&dev->dev, "Failed to ioremap data buffers\n");
+                err = -ENOMEM;
                 goto out_unmap_config;
         }
 
diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index df04227d00cf..98504ec99c7d 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -267,18 +267,24 @@ comment "Default contiguous memory area size:"
 config CMA_SIZE_MBYTES
         int "Size in Mega Bytes"
         depends on !CMA_SIZE_SEL_PERCENTAGE
+        default 0 if X86
         default 16
         help
           Defines the size (in MiB) of the default memory area for Contiguous
-          Memory Allocator.
+          Memory Allocator.  If the size of 0 is selected, CMA is disabled by
+          default, but it can be enabled by passing cma=size[MG] to the kernel.
+
 
 config CMA_SIZE_PERCENTAGE
         int "Percentage of total memory"
         depends on !CMA_SIZE_SEL_MBYTES
+        default 0 if X86
         default 10
         help
           Defines the size of the default memory area for Contiguous Memory
           Allocator as a percentage of the total memory in the system.
+          If 0 percent is selected, CMA is disabled by default, but it can be
+          enabled by passing cma=size[MG] to the kernel.
 
 choice
         prompt "Selected region size"
diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 6922cd6850a2..53c3fe1aeb29 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -4,7 +4,7 @@ obj-y			:= component.o core.o bus.o dd.o syscore.o \
                            driver.o class.o platform.o \
                            cpu.o firmware.o init.o map.o devres.o \
                            attribute_container.o transport_class.o \
-                           topology.o container.o
+                           topology.o container.o property.o
 obj-$(CONFIG_DEVTMPFS)  += devtmpfs.o
 obj-$(CONFIG_DMA_CMA) += dma-contiguous.o
 obj-y                   += power/
diff --git a/drivers/base/power/clock_ops.c b/drivers/base/power/clock_ops.c
index 78369305e069..d626576a4f75 100644
--- a/drivers/base/power/clock_ops.c
+++ b/drivers/base/power/clock_ops.c
@@ -12,6 +12,7 @@
 #include <linux/pm.h>
 #include <linux/pm_clock.h>
 #include <linux/clk.h>
+#include <linux/clkdev.h>
 #include <linux/slab.h>
 #include <linux/err.h>
 
@@ -34,14 +35,20 @@ struct pm_clock_entry {
 /**
  * pm_clk_enable - Enable a clock, reporting any errors
  * @dev: The device for the given clock
- * @clk: The clock being enabled.
+ * @ce: PM clock entry corresponding to the clock.
  */
-static inline int __pm_clk_enable(struct device *dev, struct clk *clk)
+static inline int __pm_clk_enable(struct device *dev, struct pm_clock_entry *ce)
 {
-        int ret = clk_enable(clk);
-        if (ret)
-                dev_err(dev, "%s: failed to enable clk %p, error %d\n",
-                        __func__, clk, ret);
+        int ret;
+
+        if (ce->status < PCE_STATUS_ERROR) {
+                ret = clk_enable(ce->clk);
+                if (!ret)
+                        ce->status = PCE_STATUS_ENABLED;
+                else
+                        dev_err(dev, "%s: failed to enable clk %p, error %d\n",
+                                __func__, ce->clk, ret);
+        }
 
         return ret;
 }
@@ -53,7 +60,8 @@ static inline int __pm_clk_enable(struct device *dev, struct clk *clk)
  */
 static void pm_clk_acquire(struct device *dev, struct pm_clock_entry *ce)
 {
-        ce->clk = clk_get(dev, ce->con_id);
+        if (!ce->clk)
+                ce->clk = clk_get(dev, ce->con_id);
         if (IS_ERR(ce->clk)) {
                 ce->status = PCE_STATUS_ERROR;
         } else {
@@ -63,15 +71,8 @@ static void pm_clk_acquire(struct device *dev, struct pm_clock_entry *ce)
         }
 }
 
-/**
- * pm_clk_add - Start using a device clock for power management.
- * @dev: Device whose clock is going to be used for power management.
- * @con_id: Connection ID of the clock.
- *
- * Add the clock represented by @con_id to the list of clocks used for
- * the power management of @dev.
- */
-int pm_clk_add(struct device *dev, const char *con_id)
+static int __pm_clk_add(struct device *dev, const char *con_id,
+                        struct clk *clk)
 {
         struct pm_subsys_data *psd = dev_to_psd(dev);
         struct pm_clock_entry *ce;
@@ -93,6 +94,12 @@ int pm_clk_add(struct device *dev, const char *con_id)
                         kfree(ce);
                         return -ENOMEM;
                 }
+        } else {
+                if (IS_ERR(ce->clk) || !__clk_get(clk)) {
+                        kfree(ce);
+                        return -ENOENT;
+                }
+                ce->clk = clk;
         }
 
         pm_clk_acquire(dev, ce);
@@ -104,6 +111,32 @@ int pm_clk_add(struct device *dev, const char *con_id)
 }
 
 /**
+ * pm_clk_add - Start using a device clock for power management.
+ * @dev: Device whose clock is going to be used for power management.
+ * @con_id: Connection ID of the clock.
+ *
+ * Add the clock represented by @con_id to the list of clocks used for
+ * the power management of @dev.
+ */
+int pm_clk_add(struct device *dev, const char *con_id)
+{
+        return __pm_clk_add(dev, con_id, NULL);
+}
+
+/**
+ * pm_clk_add_clk - Start using a device clock for power management.
+ * @dev: Device whose clock is going to be used for power management.
+ * @clk: Clock pointer
+ *
+ * Add the clock to the list of clocks used for the power management of @dev.
+ * It will increment refcount on clock pointer, use clk_put() on it when done.
+ */
+int pm_clk_add_clk(struct device *dev, struct clk *clk)
+{
+        return __pm_clk_add(dev, NULL, clk);
+}
+
+/**
  * __pm_clk_remove - Destroy PM clock entry.
  * @ce: PM clock entry to destroy.
  */
@@ -223,10 +256,6 @@ void pm_clk_destroy(struct device *dev)
         }
 }
 
-#endif /* CONFIG_PM */
-
-#ifdef CONFIG_PM_RUNTIME
-
 /**
  * pm_clk_suspend - Disable clocks in a device's PM clock list.
  * @dev: Device to disable the clocks for.
@@ -266,7 +295,6 @@ int pm_clk_resume(struct device *dev)
         struct pm_subsys_data *psd = dev_to_psd(dev);
         struct pm_clock_entry *ce;
         unsigned long flags;
-        int ret;
 
         dev_dbg(dev, "%s()\n", __func__);
 
@@ -275,13 +303,8 @@ int pm_clk_resume(struct device *dev)
 
         spin_lock_irqsave(&psd->lock, flags);
 
-        list_for_each_entry(ce, &psd->clock_list, node) {
-                if (ce->status < PCE_STATUS_ERROR) {
-                        ret = __pm_clk_enable(dev, ce->clk);
-                        if (!ret)
-                                ce->status = PCE_STATUS_ENABLED;
-                }
-        }
+        list_for_each_entry(ce, &psd->clock_list, node)
+                __pm_clk_enable(dev, ce);
 
         spin_unlock_irqrestore(&psd->lock, flags);
 
@@ -346,74 +369,7 @@ static int pm_clk_notify(struct notifier_block *nb,
         return 0;
 }
 
-#else /* !CONFIG_PM_RUNTIME */
-
-#ifdef CONFIG_PM
-
-/**
- * pm_clk_suspend - Disable clocks in a device's PM clock list.
- * @dev: Device to disable the clocks for.
- */
-int pm_clk_suspend(struct device *dev)
-{
-        struct pm_subsys_data *psd = dev_to_psd(dev);
-        struct pm_clock_entry *ce;
-        unsigned long flags;
-
-        dev_dbg(dev, "%s()\n", __func__);
-
-        /* If there is no driver, the clocks are already disabled. */
-        if (!psd || !dev->driver)
-                return 0;
-
-        spin_lock_irqsave(&psd->lock, flags);
-
-        list_for_each_entry_reverse(ce, &psd->clock_list, node) {
-                if (ce->status < PCE_STATUS_ERROR) {
-                        if (ce->status == PCE_STATUS_ENABLED)
-                                clk_disable(ce->clk);
-                        ce->status = PCE_STATUS_ACQUIRED;
-                }
-        }
-
-        spin_unlock_irqrestore(&psd->lock, flags);
-
-        return 0;
-}
-
-/**
- * pm_clk_resume - Enable clocks in a device's PM clock list.
- * @dev: Device to enable the clocks for.
- */
-int pm_clk_resume(struct device *dev)
-{
-        struct pm_subsys_data *psd = dev_to_psd(dev);
-        struct pm_clock_entry *ce;
-        unsigned long flags;
-        int ret;
-
-        dev_dbg(dev, "%s()\n", __func__);
-
-        /* If there is no driver, the clocks should remain disabled. */
-        if (!psd || !dev->driver)
-                return 0;
-
-        spin_lock_irqsave(&psd->lock, flags);
-
-        list_for_each_entry(ce, &psd->clock_list, node) {
-                if (ce->status < PCE_STATUS_ERROR) {
-                        ret = __pm_clk_enable(dev, ce->clk);
-                        if (!ret)
-                                ce->status = PCE_STATUS_ENABLED;
-                }
-        }
-
-        spin_unlock_irqrestore(&psd->lock, flags);
-
-        return 0;
-}
-
-#endif /* CONFIG_PM */
+#else /* !CONFIG_PM */
 
 /**
  * enable_clock - Enable a device clock.
@@ -493,7 +449,7 @@ static int pm_clk_notify(struct notifier_block *nb,
         return 0;
 }
 
-#endif /* !CONFIG_PM_RUNTIME */
+#endif /* !CONFIG_PM */
 
 /**
  * pm_clk_add_notifier - Add bus type notifier for power management clocks.
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index fb83d4acd400..6a103a35ea9b 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -12,6 +12,7 @@
 #include <linux/pm_runtime.h>
 #include <linux/pm_domain.h>
 #include <linux/pm_qos.h>
+#include <linux/pm_clock.h>
 #include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/sched.h>
@@ -151,6 +152,59 @@ static void genpd_recalc_cpu_exit_latency(struct generic_pm_domain *genpd)
         genpd->cpuidle_data->idle_state->exit_latency = usecs64;
 }
 
+static int genpd_power_on(struct generic_pm_domain *genpd)
+{
+        ktime_t time_start;
+        s64 elapsed_ns;
+        int ret;
+
+        if (!genpd->power_on)
+                return 0;
+
+        time_start = ktime_get();
+        ret = genpd->power_on(genpd);
+        if (ret)
+                return ret;
+
+        elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
+        if (elapsed_ns <= genpd->power_on_latency_ns)
+                return ret;
+
+        genpd->power_on_latency_ns = elapsed_ns;
+        genpd->max_off_time_changed = true;
+        genpd_recalc_cpu_exit_latency(genpd);
+        pr_warn("%s: Power-%s latency exceeded, new value %lld ns\n",
+                genpd->name, "on", elapsed_ns);
+
+        return ret;
+}
+
+static int genpd_power_off(struct generic_pm_domain *genpd)
+{
+        ktime_t time_start;
+        s64 elapsed_ns;
+        int ret;
+
+        if (!genpd->power_off)
+                return 0;
+
+        time_start = ktime_get();
+        ret = genpd->power_off(genpd);
+        if (ret == -EBUSY)
+                return ret;
+
+        elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
+        if (elapsed_ns <= genpd->power_off_latency_ns)
+                return ret;
+
+        genpd->power_off_latency_ns = elapsed_ns;
+        genpd->max_off_time_changed = true;
+        pr_warn("%s: Power-%s latency exceeded, new value %lld ns\n",
+                genpd->name, "off", elapsed_ns);
+
+        return ret;
+}
+
 /**
  * __pm_genpd_poweron - Restore power to a given PM domain and its masters.
  * @genpd: PM domain to power up.
@@ -222,25 +276,9 @@ static int __pm_genpd_poweron(struct generic_pm_domain *genpd)
                 }
         }
 
-        if (genpd->power_on) {
-                ktime_t time_start = ktime_get();
-                s64 elapsed_ns;
-
-                ret = genpd->power_on(genpd);
-                if (ret)
-                        goto err;
-
-                elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
-                if (elapsed_ns > genpd->power_on_latency_ns) {
-                        genpd->power_on_latency_ns = elapsed_ns;
-                        genpd->max_off_time_changed = true;
-                        genpd_recalc_cpu_exit_latency(genpd);
-                        if (genpd->name)
-                                pr_warning("%s: Power-on latency exceeded, "
-                                        "new value %lld ns\n", genpd->name,
-                                        elapsed_ns);
-                }
-        }
+        ret = genpd_power_on(genpd);
+        if (ret)
+                goto err;
 
  out:
         genpd_set_active(genpd);
@@ -280,8 +318,6 @@ int pm_genpd_name_poweron(const char *domain_name)
         return genpd ? pm_genpd_poweron(genpd) : -EINVAL;
 }
 
-#ifdef CONFIG_PM_RUNTIME
-
 static int genpd_start_dev_no_timing(struct generic_pm_domain *genpd,
                                      struct device *dev)
 {
@@ -544,16 +580,11 @@ static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
         }
 
         if (genpd->power_off) {
-                ktime_t time_start;
-                s64 elapsed_ns;
-
                 if (atomic_read(&genpd->sd_count) > 0) {
                         ret = -EBUSY;
                         goto out;
                 }
 
-                time_start = ktime_get();
-
                 /*
                  * If sd_count > 0 at this point, one of the subdomains hasn't
                  * managed to call pm_genpd_poweron() for the master yet after
@@ -562,21 +593,11 @@ static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
                  * the pm_genpd_poweron() restore power for us (this shouldn't
                  * happen very often).
                  */
-                ret = genpd->power_off(genpd);
+                ret = genpd_power_off(genpd);
                 if (ret == -EBUSY) {
                         genpd_set_active(genpd);
                         goto out;
                 }
-
-                elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
-                if (elapsed_ns > genpd->power_off_latency_ns) {
-                        genpd->power_off_latency_ns = elapsed_ns;
-                        genpd->max_off_time_changed = true;
-                        if (genpd->name)
-                                pr_warning("%s: Power-off latency exceeded, "
-                                        "new value %lld ns\n", genpd->name,
-                                        elapsed_ns);
-                }
         }
 
         genpd->status = GPD_STATE_POWER_OFF;
@@ -755,33 +776,15 @@ static int __init genpd_poweroff_unused(void)
 }
 late_initcall(genpd_poweroff_unused);
 
-#else
-
-static inline int genpd_dev_pm_qos_notifier(struct notifier_block *nb,
-                                            unsigned long val, void *ptr)
-{
-        return NOTIFY_DONE;
-}
-
-static inline void
-genpd_queue_power_off_work(struct generic_pm_domain *genpd) {}
-
-static inline void genpd_power_off_work_fn(struct work_struct *work) {}
-
-#define pm_genpd_runtime_suspend        NULL
-#define pm_genpd_runtime_resume         NULL
-
-#endif /* CONFIG_PM_RUNTIME */
-
 #ifdef CONFIG_PM_SLEEP
 
 /**
  * pm_genpd_present - Check if the given PM domain has been initialized.
  * @genpd: PM domain to check.
  */
-static bool pm_genpd_present(struct generic_pm_domain *genpd)
+static bool pm_genpd_present(const struct generic_pm_domain *genpd)
 {
-        struct generic_pm_domain *gpd;
+        const struct generic_pm_domain *gpd;
 
         if (IS_ERR_OR_NULL(genpd))
                 return false;
@@ -822,8 +825,7 @@ static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
             || atomic_read(&genpd->sd_count) > 0)
                 return;
 
-        if (genpd->power_off)
-                genpd->power_off(genpd);
+        genpd_power_off(genpd);
 
         genpd->status = GPD_STATE_POWER_OFF;
 
@@ -854,8 +856,7 @@ static void pm_genpd_sync_poweron(struct generic_pm_domain *genpd)
                 genpd_sd_counter_inc(link->master);
         }
 
-        if (genpd->power_on)
-                genpd->power_on(genpd);
+        genpd_power_on(genpd);
 
         genpd->status = GPD_STATE_ACTIVE;
 }
@@ -1277,8 +1278,7 @@ static int pm_genpd_restore_noirq(struct device *dev)
                          * If the domain was off before the hibernation, make
                          * sure it will be off going forward.
                          */
-                        if (genpd->power_off)
-                                genpd->power_off(genpd);
+                        genpd_power_off(genpd);
 
                         return 0;
                 }
@@ -1364,7 +1364,7 @@ void pm_genpd_syscore_poweron(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron);
 
-#else
+#else /* !CONFIG_PM_SLEEP */
 
 #define pm_genpd_prepare                NULL
 #define pm_genpd_suspend                NULL
@@ -1929,6 +1929,12 @@ void pm_genpd_init(struct generic_pm_domain *genpd,
         genpd->domain.ops.complete = pm_genpd_complete;
         genpd->dev_ops.save_state = pm_genpd_default_save_state;
         genpd->dev_ops.restore_state = pm_genpd_default_restore_state;
+
+        if (genpd->flags & GENPD_FLAG_PM_CLK) {
+                genpd->dev_ops.stop = pm_clk_suspend;
+                genpd->dev_ops.start = pm_clk_resume;
+        }
+
         mutex_lock(&gpd_list_lock);
         list_add(&genpd->gpd_list_node, &gpd_list);
         mutex_unlock(&gpd_list_lock);
@@ -2216,11 +2222,12 @@ int genpd_dev_pm_attach(struct device *dev)
         }
 
         dev->pm_domain->detach = genpd_dev_pm_detach;
+        pm_genpd_poweron(pd);
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(genpd_dev_pm_attach);
-#endif
+#endif /* CONFIG_PM_GENERIC_DOMAINS_OF */
 
 
 /***        debugfs support        ***/
@@ -2236,10 +2243,8 @@ static struct dentry *pm_genpd_debugfs_dir;
 
 /*
  * TODO: This function is a slightly modified version of rtpm_status_show
- * from sysfs.c, but dependencies between PM_GENERIC_DOMAINS and PM_RUNTIME
- * are too loose to generalize it.
+ * from sysfs.c, so generalize it.
  */
-#ifdef CONFIG_PM_RUNTIME
 static void rtpm_status_str(struct seq_file *s, struct device *dev)
 {
         static const char * const status_lookup[] = {
@@ -2261,12 +2266,6 @@ static void rtpm_status_str(struct seq_file *s, struct device *dev)
 
         seq_puts(s, p);
 }
-#else
-static void rtpm_status_str(struct seq_file *s, struct device *dev)
-{
-        seq_puts(s, "active");
-}
-#endif
 
 static int pm_genpd_summary_one(struct seq_file *s,
                 struct generic_pm_domain *gpd)
diff --git a/drivers/base/power/domain_governor.c b/drivers/base/power/domain_governor.c
index d88a62e104d4..2a4154a09e4d 100644
--- a/drivers/base/power/domain_governor.c
+++ b/drivers/base/power/domain_governor.c
@@ -11,8 +11,6 @@
 #include <linux/pm_qos.h>
 #include <linux/hrtimer.h>
 
-#ifdef CONFIG_PM_RUNTIME
-
 static int dev_update_qos_constraint(struct device *dev, void *data)
 {
         s64 *constraint_ns_p = data;
@@ -227,15 +225,6 @@ static bool always_on_power_down_ok(struct dev_pm_domain *domain)
         return false;
 }
 
-#else /* !CONFIG_PM_RUNTIME */
-
-static inline bool default_stop_ok(struct device *dev) { return false; }
-
-#define default_power_down_ok   NULL
-#define always_on_power_down_ok NULL
-
-#endif /* !CONFIG_PM_RUNTIME */
-
 struct dev_power_governor simple_qos_governor = {
         .stop_ok = default_stop_ok,
         .power_down_ok = default_power_down_ok,
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index 89ced955fafa..2d195f3a1998 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -49,11 +49,12 @@
  *              are protected by the dev_opp_list_lock for integrity.
  *              IMPORTANT: the opp nodes should be maintained in increasing
  *              order.
+ * @dynamic:    not-created from static DT entries.
  * @available:  true/false - marks if this OPP as available or not
  * @rate:       Frequency in hertz
  * @u_volt:     Nominal voltage in microvolts corresponding to this OPP
  * @dev_opp:    points back to the device_opp struct this opp belongs to
- * @head:       RCU callback head used for deferred freeing
+ * @rcu_head:   RCU callback head used for deferred freeing
  *
  * This structure stores the OPP information for a given device.
  */
@@ -61,11 +62,12 @@ struct dev_pm_opp {
         struct list_head node;
 
         bool available;
+        bool dynamic;
         unsigned long rate;
         unsigned long u_volt;
 
         struct device_opp *dev_opp;
-        struct rcu_head head;
+        struct rcu_head rcu_head;
 };
 
 /**
@@ -76,7 +78,8 @@ struct dev_pm_opp {
  *              RCU usage: nodes are not modified in the list of device_opp,
  *              however addition is possible and is secured by dev_opp_list_lock
  * @dev:        device pointer
- * @head:       notifier head to notify the OPP availability changes.
+ * @srcu_head:  notifier head to notify the OPP availability changes.
+ * @rcu_head:   RCU callback head used for deferred freeing
  * @opp_list:   list of opps
  *
  * This is an internal data structure maintaining the link to opps attached to
@@ -87,7 +90,8 @@ struct device_opp {
         struct list_head node;
 
         struct device *dev;
-        struct srcu_notifier_head head;
+        struct srcu_notifier_head srcu_head;
+        struct rcu_head rcu_head;
         struct list_head opp_list;
 };
 
@@ -378,30 +382,8 @@ struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
 
-/**
- * dev_pm_opp_add()  - Add an OPP table from a table definitions
- * @dev:        device for which we do this operation
- * @freq:       Frequency in Hz for this OPP
- * @u_volt:     Voltage in uVolts for this OPP
- *
- * This function adds an opp definition to the opp list and returns status.
- * The opp is made available by default and it can be controlled using
- * dev_pm_opp_enable/disable functions.
- *
- * Locking: The internal device_opp and opp structures are RCU protected.
- * Hence this function internally uses RCU updater strategy with mutex locks
- * to keep the integrity of the internal data structures. Callers should ensure
- * that this function is *NOT* called under RCU protection or in contexts where
- * mutex cannot be locked.
- *
- * Return:
- * 0:           On success OR
- *              Duplicate OPPs (both freq and volt are same) and opp->available
- * -EEXIST:     Freq are same and volt are different OR
- *              Duplicate OPPs (both freq and volt are same) and !opp->available
- * -ENOMEM:     Memory allocation failure
- */
-int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
+static int dev_pm_opp_add_dynamic(struct device *dev, unsigned long freq,
+                                  unsigned long u_volt, bool dynamic)
 {
         struct device_opp *dev_opp = NULL;
         struct dev_pm_opp *opp, *new_opp;
@@ -417,6 +399,13 @@ int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
         /* Hold our list modification lock here */
         mutex_lock(&dev_opp_list_lock);
 
+        /* populate the opp table */
+        new_opp->dev_opp = dev_opp;
+        new_opp->rate = freq;
+        new_opp->u_volt = u_volt;
+        new_opp->available = true;
+        new_opp->dynamic = dynamic;
+
         /* Check for existing list for 'dev' */
         dev_opp = find_device_opp(dev);
         if (IS_ERR(dev_opp)) {
@@ -436,19 +425,15 @@ int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
                 }
 
                 dev_opp->dev = dev;
-                srcu_init_notifier_head(&dev_opp->head);
+                srcu_init_notifier_head(&dev_opp->srcu_head);
                 INIT_LIST_HEAD(&dev_opp->opp_list);
 
                 /* Secure the device list modification */
                 list_add_rcu(&dev_opp->node, &dev_opp_list);
+                head = &dev_opp->opp_list;
+                goto list_add;
         }
 
-        /* populate the opp table */
-        new_opp->dev_opp = dev_opp;
-        new_opp->rate = freq;
-        new_opp->u_volt = u_volt;
-        new_opp->available = true;
-
         /*
          * Insert new OPP in order of increasing frequency
          * and discard if already present
@@ -474,6 +459,7 @@ int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
                 return ret;
         }
 
+list_add:
         list_add_rcu(&new_opp->node, head);
         mutex_unlock(&dev_opp_list_lock);
 
@@ -481,11 +467,109 @@ int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
          * Notify the changes in the availability of the operable
          * frequency/voltage list.
          */
-        srcu_notifier_call_chain(&dev_opp->head, OPP_EVENT_ADD, new_opp);
+        srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
         return 0;
 }
+
+/**
+ * dev_pm_opp_add()  - Add an OPP table from a table definitions
+ * @dev:        device for which we do this operation
+ * @freq:       Frequency in Hz for this OPP
+ * @u_volt:     Voltage in uVolts for this OPP
+ *
+ * This function adds an opp definition to the opp list and returns status.
+ * The opp is made available by default and it can be controlled using
+ * dev_pm_opp_enable/disable functions.
+ *
+ * Locking: The internal device_opp and opp structures are RCU protected.
+ * Hence this function internally uses RCU updater strategy with mutex locks
+ * to keep the integrity of the internal data structures. Callers should ensure
+ * that this function is *NOT* called under RCU protection or in contexts where
+ * mutex cannot be locked.
+ *
+ * Return:
+ * 0:           On success OR
+ *              Duplicate OPPs (both freq and volt are same) and opp->available
+ * -EEXIST:     Freq are same and volt are different OR
+ *              Duplicate OPPs (both freq and volt are same) and !opp->available
+ * -ENOMEM:     Memory allocation failure
+ */
+int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
+{
+        return dev_pm_opp_add_dynamic(dev, freq, u_volt, true);
+}
 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
 
+static void kfree_opp_rcu(struct rcu_head *head)
+{
+        struct dev_pm_opp *opp = container_of(head, struct dev_pm_opp, rcu_head);
+
+        kfree_rcu(opp, rcu_head);
+}
+
+static void kfree_device_rcu(struct rcu_head *head)
+{
+        struct device_opp *device_opp = container_of(head, struct device_opp, rcu_head);
+
+        kfree(device_opp);
+}
+
+void __dev_pm_opp_remove(struct device_opp *dev_opp, struct dev_pm_opp *opp)
+{
+        /*
+         * Notify the changes in the availability of the operable
+         * frequency/voltage list.
+         */
+        srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_REMOVE, opp);
+        list_del_rcu(&opp->node);
+        call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, kfree_opp_rcu);
+
+        if (list_empty(&dev_opp->opp_list)) {
+                list_del_rcu(&dev_opp->node);
+                call_srcu(&dev_opp->srcu_head.srcu, &dev_opp->rcu_head,
+                          kfree_device_rcu);
+        }
+}
+
+/**
+ * dev_pm_opp_remove()  - Remove an OPP from OPP list
+ * @dev:        device for which we do this operation
+ * @freq:       OPP to remove with matching 'freq'
+ *
+ * This function removes an opp from the opp list.
+ */
+void dev_pm_opp_remove(struct device *dev, unsigned long freq)
+{
+        struct dev_pm_opp *opp;
+        struct device_opp *dev_opp;
+        bool found = false;
+
+        /* Hold our list modification lock here */
+        mutex_lock(&dev_opp_list_lock);
+
+        dev_opp = find_device_opp(dev);
+        if (IS_ERR(dev_opp))
+                goto unlock;
+
+        list_for_each_entry(opp, &dev_opp->opp_list, node) {
+                if (opp->rate == freq) {
+                        found = true;
+                        break;
+                }
+        }
+
+        if (!found) {
+                dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
+                         __func__, freq);
+                goto unlock;
+        }
+
+        __dev_pm_opp_remove(dev_opp, opp);
+unlock:
+        mutex_unlock(&dev_opp_list_lock);
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
+
 /**
  * opp_set_availability() - helper to set the availability of an opp
  * @dev:                device for which we do this operation
@@ -557,14 +641,14 @@ static int opp_set_availability(struct device *dev, unsigned long freq,
 
         list_replace_rcu(&opp->node, &new_opp->node);
         mutex_unlock(&dev_opp_list_lock);
-        kfree_rcu(opp, head);
+        call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, kfree_opp_rcu);
 
         /* Notify the change of the OPP availability */
         if (availability_req)
-                srcu_notifier_call_chain(&dev_opp->head, OPP_EVENT_ENABLE,
+                srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ENABLE,
                                          new_opp);
         else
-                srcu_notifier_call_chain(&dev_opp->head, OPP_EVENT_DISABLE,
+                srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_DISABLE,
                                          new_opp);
 
         return 0;
@@ -629,7 +713,7 @@ struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
         if (IS_ERR(dev_opp))
                 return ERR_CAST(dev_opp); /* matching type */
 
-        return &dev_opp->head;
+        return &dev_opp->srcu_head;
 }
 
 #ifdef CONFIG_OF
@@ -666,7 +750,7 @@ int of_init_opp_table(struct device *dev)
                 unsigned long freq = be32_to_cpup(val++) * 1000;
                 unsigned long volt = be32_to_cpup(val++);
 
-                if (dev_pm_opp_add(dev, freq, volt))
+                if (dev_pm_opp_add_dynamic(dev, freq, volt, false))
                         dev_warn(dev, "%s: Failed to add OPP %ld\n",
                                  __func__, freq);
                 nr -= 2;
@@ -675,4 +759,34 @@ int of_init_opp_table(struct device *dev)
         return 0;
 }
 EXPORT_SYMBOL_GPL(of_init_opp_table);
+
+/**
+ * of_free_opp_table() - Free OPP table entries created from static DT entries
+ * @dev:        device pointer used to lookup device OPPs.
+ *
+ * Free OPPs created using static entries present in DT.
+ */
+void of_free_opp_table(struct device *dev)
+{
+        struct device_opp *dev_opp = find_device_opp(dev);
+        struct dev_pm_opp *opp, *tmp;
+
+        /* Check for existing list for 'dev' */
+        dev_opp = find_device_opp(dev);
+        if (WARN(IS_ERR(dev_opp), "%s: dev_opp: %ld\n", dev_name(dev),
+                 PTR_ERR(dev_opp)))
+                return;
+
+        /* Hold our list modification lock here */
+        mutex_lock(&dev_opp_list_lock);
+
+        /* Free static OPPs */
+        list_for_each_entry_safe(opp, tmp, &dev_opp->opp_list, node) {
+                if (!opp->dynamic)
+                        __dev_pm_opp_remove(dev_opp, opp);
+        }
+
+        mutex_unlock(&dev_opp_list_lock);
+}
+EXPORT_SYMBOL_GPL(of_free_opp_table);
 #endif
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index a21223d95926..b6b8a273c5da 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -9,7 +9,7 @@ static inline void device_pm_init_common(struct device *dev)
         }
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 
 static inline void pm_runtime_early_init(struct device *dev)
 {
@@ -20,7 +20,21 @@ static inline void pm_runtime_early_init(struct device *dev)
 extern void pm_runtime_init(struct device *dev);
 extern void pm_runtime_remove(struct device *dev);
 
-#else /* !CONFIG_PM_RUNTIME */
+/*
+ * sysfs.c
+ */
+
+extern int dpm_sysfs_add(struct device *dev);
+extern void dpm_sysfs_remove(struct device *dev);
+extern void rpm_sysfs_remove(struct device *dev);
+extern int wakeup_sysfs_add(struct device *dev);
+extern void wakeup_sysfs_remove(struct device *dev);
+extern int pm_qos_sysfs_add_resume_latency(struct device *dev);
+extern void pm_qos_sysfs_remove_resume_latency(struct device *dev);
+extern int pm_qos_sysfs_add_flags(struct device *dev);
+extern void pm_qos_sysfs_remove_flags(struct device *dev);
+
+#else /* CONFIG_PM */
 
 static inline void pm_runtime_early_init(struct device *dev)
 {
@@ -30,7 +44,15 @@ static inline void pm_runtime_early_init(struct device *dev)
 static inline void pm_runtime_init(struct device *dev) {}
 static inline void pm_runtime_remove(struct device *dev) {}
 
-#endif /* !CONFIG_PM_RUNTIME */
+static inline int dpm_sysfs_add(struct device *dev) { return 0; }
+static inline void dpm_sysfs_remove(struct device *dev) {}
+static inline void rpm_sysfs_remove(struct device *dev) {}
+static inline int wakeup_sysfs_add(struct device *dev) { return 0; }
+static inline void wakeup_sysfs_remove(struct device *dev) {}
+static inline int pm_qos_sysfs_add(struct device *dev) { return 0; }
+static inline void pm_qos_sysfs_remove(struct device *dev) {}
+
+#endif
 
 #ifdef CONFIG_PM_SLEEP
 
@@ -77,31 +99,3 @@ static inline void device_pm_init(struct device *dev)
         device_pm_sleep_init(dev);
         pm_runtime_init(dev);
 }
-
-#ifdef CONFIG_PM
-
-/*
- * sysfs.c
- */
-
-extern int dpm_sysfs_add(struct device *dev);
-extern void dpm_sysfs_remove(struct device *dev);
-extern void rpm_sysfs_remove(struct device *dev);
-extern int wakeup_sysfs_add(struct device *dev);
-extern void wakeup_sysfs_remove(struct device *dev);
-extern int pm_qos_sysfs_add_resume_latency(struct device *dev);
-extern void pm_qos_sysfs_remove_resume_latency(struct device *dev);
-extern int pm_qos_sysfs_add_flags(struct device *dev);
-extern void pm_qos_sysfs_remove_flags(struct device *dev);
-
-#else /* CONFIG_PM */
-
-static inline int dpm_sysfs_add(struct device *dev) { return 0; }
-static inline void dpm_sysfs_remove(struct device *dev) {}
-static inline void rpm_sysfs_remove(struct device *dev) {}
-static inline int wakeup_sysfs_add(struct device *dev) { return 0; }
-static inline void wakeup_sysfs_remove(struct device *dev) {}
-static inline int pm_qos_sysfs_add(struct device *dev) { return 0; }
-static inline void pm_qos_sysfs_remove(struct device *dev) {}
-
-#endif
diff --git a/drivers/base/power/qos.c b/drivers/base/power/qos.c
index 36b9eb4862cb..a8fe4c1a8d07 100644
--- a/drivers/base/power/qos.c
+++ b/drivers/base/power/qos.c
@@ -599,7 +599,6 @@ int dev_pm_qos_add_ancestor_request(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_add_ancestor_request);
 
-#ifdef CONFIG_PM_RUNTIME
 static void __dev_pm_qos_drop_user_request(struct device *dev,
                                            enum dev_pm_qos_req_type type)
 {
@@ -880,7 +879,3 @@ int dev_pm_qos_update_user_latency_tolerance(struct device *dev, s32 val)
         mutex_unlock(&dev_pm_qos_mtx);
         return ret;
 }
-#else /* !CONFIG_PM_RUNTIME */
-static void __dev_pm_qos_hide_latency_limit(struct device *dev) {}
-static void __dev_pm_qos_hide_flags(struct device *dev) {}
-#endif /* CONFIG_PM_RUNTIME */
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 67c7938e430b..5070c4fe8542 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -13,43 +13,38 @@
 #include <trace/events/rpm.h>
 #include "power.h"
 
-#define RPM_GET_CALLBACK(dev, cb)                               \
-({                                                              \
-        int (*__rpm_cb)(struct device *__d);                    \
-                                                                \
-        if (dev->pm_domain)                                     \
-                __rpm_cb = dev->pm_domain->ops.cb;              \
-        else if (dev->type && dev->type->pm)                    \
-                __rpm_cb = dev->type->pm->cb;                   \
-        else if (dev->class && dev->class->pm)                  \
-                __rpm_cb = dev->class->pm->cb;                  \
-        else if (dev->bus && dev->bus->pm)                      \
-                __rpm_cb = dev->bus->pm->cb;                    \
-        else                                                    \
-                __rpm_cb = NULL;                                \
-                                                                \
-        if (!__rpm_cb && dev->driver && dev->driver->pm)        \
-                __rpm_cb = dev->driver->pm->cb;                 \
-                                                                \
-        __rpm_cb;                                               \
-})
-
-static int (*rpm_get_suspend_cb(struct device *dev))(struct device *)
-{
-        return RPM_GET_CALLBACK(dev, runtime_suspend);
-}
+typedef int (*pm_callback_t)(struct device *);
 
-static int (*rpm_get_resume_cb(struct device *dev))(struct device *)
+static pm_callback_t __rpm_get_callback(struct device *dev, size_t cb_offset)
 {
-        return RPM_GET_CALLBACK(dev, runtime_resume);
-}
+        pm_callback_t cb;
+        const struct dev_pm_ops *ops;
+
+        if (dev->pm_domain)
+                ops = &dev->pm_domain->ops;
+        else if (dev->type && dev->type->pm)
+                ops = dev->type->pm;
+        else if (dev->class && dev->class->pm)
+                ops = dev->class->pm;
+        else if (dev->bus && dev->bus->pm)
+                ops = dev->bus->pm;
+        else
+                ops = NULL;
 
-#ifdef CONFIG_PM_RUNTIME
-static int (*rpm_get_idle_cb(struct device *dev))(struct device *)
-{
-        return RPM_GET_CALLBACK(dev, runtime_idle);
+        if (ops)
+                cb = *(pm_callback_t *)((void *)ops + cb_offset);
+        else
+                cb = NULL;
+
+        if (!cb && dev->driver && dev->driver->pm)
+                cb = *(pm_callback_t *)((void *)dev->driver->pm + cb_offset);
+
+        return cb;
 }
 
+#define RPM_GET_CALLBACK(dev, callback) \
+                __rpm_get_callback(dev, offsetof(struct dev_pm_ops, callback))
+
 static int rpm_resume(struct device *dev, int rpmflags);
 static int rpm_suspend(struct device *dev, int rpmflags);
 
@@ -347,7 +342,7 @@ static int rpm_idle(struct device *dev, int rpmflags)
 
         dev->power.idle_notification = true;
 
-        callback = rpm_get_idle_cb(dev);
+        callback = RPM_GET_CALLBACK(dev, runtime_idle);
 
         if (callback)
                 retval = __rpm_callback(callback, dev);
@@ -517,7 +512,7 @@ static int rpm_suspend(struct device *dev, int rpmflags)
 
         __update_runtime_status(dev, RPM_SUSPENDING);
 
-        callback = rpm_get_suspend_cb(dev);
+        callback = RPM_GET_CALLBACK(dev, runtime_suspend);
 
         retval = rpm_callback(callback, dev);
         if (retval)
@@ -737,7 +732,7 @@ static int rpm_resume(struct device *dev, int rpmflags)
 
         __update_runtime_status(dev, RPM_RESUMING);
 
-        callback = rpm_get_resume_cb(dev);
+        callback = RPM_GET_CALLBACK(dev, runtime_resume);
 
         retval = rpm_callback(callback, dev);
         if (retval) {
@@ -1402,7 +1397,6 @@ void pm_runtime_remove(struct device *dev)
         if (dev->power.irq_safe && dev->parent)
                 pm_runtime_put(dev->parent);
 }
-#endif
 
 /**
  * pm_runtime_force_suspend - Force a device into suspend state if needed.
@@ -1422,16 +1416,10 @@ int pm_runtime_force_suspend(struct device *dev)
         int ret = 0;
 
         pm_runtime_disable(dev);
-
-        /*
-         * Note that pm_runtime_status_suspended() returns false while
-         * !CONFIG_PM_RUNTIME, which means the device will be put into low
-         * power state.
-         */
         if (pm_runtime_status_suspended(dev))
                 return 0;
 
-        callback = rpm_get_suspend_cb(dev);
+        callback = RPM_GET_CALLBACK(dev, runtime_suspend);
 
         if (!callback) {
                 ret = -ENOSYS;
@@ -1467,7 +1455,7 @@ int pm_runtime_force_resume(struct device *dev)
         int (*callback)(struct device *);
         int ret = 0;
 
-        callback = rpm_get_resume_cb(dev);
+        callback = RPM_GET_CALLBACK(dev, runtime_resume);
 
         if (!callback) {
                 ret = -ENOSYS;
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index a9d26ed11bf4..d2be3f9c211c 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -95,7 +95,6 @@
 const char power_group_name[] = "power";
 EXPORT_SYMBOL_GPL(power_group_name);
 
-#ifdef CONFIG_PM_RUNTIME
 static const char ctrl_auto[] = "auto";
 static const char ctrl_on[] = "on";
 
@@ -330,7 +329,6 @@ static ssize_t pm_qos_remote_wakeup_store(struct device *dev,
 
 static DEVICE_ATTR(pm_qos_remote_wakeup, 0644,
                    pm_qos_remote_wakeup_show, pm_qos_remote_wakeup_store);
-#endif /* CONFIG_PM_RUNTIME */
 
 #ifdef CONFIG_PM_SLEEP
 static const char _enabled[] = "enabled";
@@ -531,8 +529,6 @@ static DEVICE_ATTR(wakeup_prevent_sleep_time_ms, 0444,
 #endif /* CONFIG_PM_SLEEP */
 
 #ifdef CONFIG_PM_ADVANCED_DEBUG
-#ifdef CONFIG_PM_RUNTIME
-
 static ssize_t rtpm_usagecount_show(struct device *dev,
                                     struct device_attribute *attr, char *buf)
 {
@@ -562,10 +558,7 @@ static DEVICE_ATTR(runtime_usage, 0444, rtpm_usagecount_show, NULL);
 static DEVICE_ATTR(runtime_active_kids, 0444, rtpm_children_show, NULL);
 static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
 
-#endif
-
 #ifdef CONFIG_PM_SLEEP
-
 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
                           char *buf)
 {
@@ -595,7 +588,7 @@ static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(async, 0644, async_show, async_store);
 
-#endif
+#endif /* CONFIG_PM_SLEEP */
 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 
 static struct attribute *power_attrs[] = {
@@ -603,12 +596,10 @@ static struct attribute *power_attrs[] = {
 #ifdef CONFIG_PM_SLEEP
         &dev_attr_async.attr,
 #endif
-#ifdef CONFIG_PM_RUNTIME
         &dev_attr_runtime_status.attr,
         &dev_attr_runtime_usage.attr,
         &dev_attr_runtime_active_kids.attr,
         &dev_attr_runtime_enabled.attr,
-#endif
 #endif /* CONFIG_PM_ADVANCED_DEBUG */
         NULL,
 };
@@ -640,7 +631,6 @@ static struct attribute_group pm_wakeup_attr_group = {
 };
 
 static struct attribute *runtime_attrs[] = {
-#ifdef CONFIG_PM_RUNTIME
 #ifndef CONFIG_PM_ADVANCED_DEBUG
         &dev_attr_runtime_status.attr,
 #endif
@@ -648,7 +638,6 @@ static struct attribute *runtime_attrs[] = {
         &dev_attr_runtime_suspended_time.attr,
         &dev_attr_runtime_active_time.attr,
         &dev_attr_autosuspend_delay_ms.attr,
-#endif /* CONFIG_PM_RUNTIME */
         NULL,
 };
 static struct attribute_group pm_runtime_attr_group = {
@@ -657,9 +646,7 @@ static struct attribute_group pm_runtime_attr_group = {
 };
 
 static struct attribute *pm_qos_resume_latency_attrs[] = {
-#ifdef CONFIG_PM_RUNTIME
         &dev_attr_pm_qos_resume_latency_us.attr,
-#endif /* CONFIG_PM_RUNTIME */
         NULL,
 };
 static struct attribute_group pm_qos_resume_latency_attr_group = {
@@ -668,9 +655,7 @@ static struct attribute_group pm_qos_resume_latency_attr_group = {
 };
 
 static struct attribute *pm_qos_latency_tolerance_attrs[] = {
-#ifdef CONFIG_PM_RUNTIME
         &dev_attr_pm_qos_latency_tolerance_us.attr,
-#endif /* CONFIG_PM_RUNTIME */
         NULL,
 };
 static struct attribute_group pm_qos_latency_tolerance_attr_group = {
@@ -679,10 +664,8 @@ static struct attribute_group pm_qos_latency_tolerance_attr_group = {
 };
 
 static struct attribute *pm_qos_flags_attrs[] = {
-#ifdef CONFIG_PM_RUNTIME
         &dev_attr_pm_qos_no_power_off.attr,
         &dev_attr_pm_qos_remote_wakeup.attr,
-#endif /* CONFIG_PM_RUNTIME */
         NULL,
 };
 static struct attribute_group pm_qos_flags_attr_group = {
diff --git a/drivers/base/property.c b/drivers/base/property.c
new file mode 100644
index 000000000000..c45845874d4f
--- /dev/null
+++ b/drivers/base/property.c
@@ -0,0 +1,431 @@
+/*
+ * property.c - Unified device property interface.
+ *
+ * Copyright (C) 2014, Intel Corporation
+ * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+ *          Mika Westerberg <mika.westerberg@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/property.h>
+#include <linux/export.h>
+#include <linux/acpi.h>
+#include <linux/of.h>
+
+/**
+ * device_property_present - check if a property of a device is present
+ * @dev: Device whose property is being checked
+ * @propname: Name of the property
+ *
+ * Check if property @propname is present in the device firmware description.
+ */
+bool device_property_present(struct device *dev, const char *propname)
+{
+        if (IS_ENABLED(CONFIG_OF) && dev->of_node)
+                return of_property_read_bool(dev->of_node, propname);
+
+        return !acpi_dev_prop_get(ACPI_COMPANION(dev), propname, NULL);
+}
+EXPORT_SYMBOL_GPL(device_property_present);
+
+/**
+ * fwnode_property_present - check if a property of a firmware node is present
+ * @fwnode: Firmware node whose property to check
+ * @propname: Name of the property
+ */
+bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname)
+{
+        if (is_of_node(fwnode))
+                return of_property_read_bool(of_node(fwnode), propname);
+        else if (is_acpi_node(fwnode))
+                return !acpi_dev_prop_get(acpi_node(fwnode), propname, NULL);
+
+        return false;
+}
+EXPORT_SYMBOL_GPL(fwnode_property_present);
+
+#define OF_DEV_PROP_READ_ARRAY(node, propname, type, val, nval) \
+        (val) ? of_property_read_##type##_array((node), (propname), (val), (nval)) \
+              : of_property_count_elems_of_size((node), (propname), sizeof(type))
+
+#define DEV_PROP_READ_ARRAY(_dev_, _propname_, _type_, _proptype_, _val_, _nval_) \
+        IS_ENABLED(CONFIG_OF) && _dev_->of_node ? \
+                (OF_DEV_PROP_READ_ARRAY(_dev_->of_node, _propname_, _type_, \
+                                        _val_, _nval_)) : \
+                acpi_dev_prop_read(ACPI_COMPANION(_dev_), _propname_, \
+                                   _proptype_, _val_, _nval_)
+
+/**
+ * device_property_read_u8_array - return a u8 array property of a device
+ * @dev: Device to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Function reads an array of u8 properties with @propname from the device
+ * firmware description and stores them to @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of numbers,
+ *         %-EOVERFLOW if the size of the property is not as expected.
+ */
+int device_property_read_u8_array(struct device *dev, const char *propname,
+                                  u8 *val, size_t nval)
+{
+        return DEV_PROP_READ_ARRAY(dev, propname, u8, DEV_PROP_U8, val, nval);
+}
+EXPORT_SYMBOL_GPL(device_property_read_u8_array);
+
+/**
+ * device_property_read_u16_array - return a u16 array property of a device
+ * @dev: Device to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Function reads an array of u16 properties with @propname from the device
+ * firmware description and stores them to @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of numbers,
+ *         %-EOVERFLOW if the size of the property is not as expected.
+ */
+int device_property_read_u16_array(struct device *dev, const char *propname,
+                                   u16 *val, size_t nval)
+{
+        return DEV_PROP_READ_ARRAY(dev, propname, u16, DEV_PROP_U16, val, nval);
+}
+EXPORT_SYMBOL_GPL(device_property_read_u16_array);
+
+/**
+ * device_property_read_u32_array - return a u32 array property of a device
+ * @dev: Device to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Function reads an array of u32 properties with @propname from the device
+ * firmware description and stores them to @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of numbers,
+ *         %-EOVERFLOW if the size of the property is not as expected.
+ */
+int device_property_read_u32_array(struct device *dev, const char *propname,
+                                   u32 *val, size_t nval)
+{
+        return DEV_PROP_READ_ARRAY(dev, propname, u32, DEV_PROP_U32, val, nval);
+}
+EXPORT_SYMBOL_GPL(device_property_read_u32_array);
+
+/**
+ * device_property_read_u64_array - return a u64 array property of a device
+ * @dev: Device to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Function reads an array of u64 properties with @propname from the device
+ * firmware description and stores them to @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of numbers,
+ *         %-EOVERFLOW if the size of the property is not as expected.
+ */
+int device_property_read_u64_array(struct device *dev, const char *propname,
+                                   u64 *val, size_t nval)
+{
+        return DEV_PROP_READ_ARRAY(dev, propname, u64, DEV_PROP_U64, val, nval);
+}
+EXPORT_SYMBOL_GPL(device_property_read_u64_array);
+
+/**
+ * device_property_read_string_array - return a string array property of device
+ * @dev: Device to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Function reads an array of string properties with @propname from the device
+ * firmware description and stores them to @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO or %-EILSEQ if the property is not an array of strings,
+ *         %-EOVERFLOW if the size of the property is not as expected.
+ */
+int device_property_read_string_array(struct device *dev, const char *propname,
+                                      const char **val, size_t nval)
+{
+        return IS_ENABLED(CONFIG_OF) && dev->of_node ?
+                of_property_read_string_array(dev->of_node, propname, val, nval) :
+                acpi_dev_prop_read(ACPI_COMPANION(dev), propname,
+                                   DEV_PROP_STRING, val, nval);
+}
+EXPORT_SYMBOL_GPL(device_property_read_string_array);
+
+/**
+ * device_property_read_string - return a string property of a device
+ * @dev: Device to get the property of
+ * @propname: Name of the property
+ * @val: The value is stored here
+ *
+ * Function reads property @propname from the device firmware description and
+ * stores the value into @val if found. The value is checked to be a string.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO or %-EILSEQ if the property type is not a string.
+ */
+int device_property_read_string(struct device *dev, const char *propname,
+                                const char **val)
+{
+        return IS_ENABLED(CONFIG_OF) && dev->of_node ?
+                of_property_read_string(dev->of_node, propname, val) :
+                acpi_dev_prop_read(ACPI_COMPANION(dev), propname,
+                                   DEV_PROP_STRING, val, 1);
+}
+EXPORT_SYMBOL_GPL(device_property_read_string);
+
+#define FWNODE_PROP_READ_ARRAY(_fwnode_, _propname_, _type_, _proptype_, _val_, _nval_) \
+({ \
+        int _ret_; \
+        if (is_of_node(_fwnode_)) \
+                _ret_ = OF_DEV_PROP_READ_ARRAY(of_node(_fwnode_), _propname_, \
+                                               _type_, _val_, _nval_); \
+        else if (is_acpi_node(_fwnode_)) \
+                _ret_ = acpi_dev_prop_read(acpi_node(_fwnode_), _propname_, \
+                                           _proptype_, _val_, _nval_); \
+        else \
+                _ret_ = -ENXIO; \
+        _ret_; \
+})
+
+/**
+ * fwnode_property_read_u8_array - return a u8 array property of firmware node
+ * @fwnode: Firmware node to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Read an array of u8 properties with @propname from @fwnode and stores them to
+ * @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of numbers,
+ *         %-EOVERFLOW if the size of the property is not as expected,
+ *         %-ENXIO if no suitable firmware interface is present.
+ */
+int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
+                                  const char *propname, u8 *val, size_t nval)
+{
+        return FWNODE_PROP_READ_ARRAY(fwnode, propname, u8, DEV_PROP_U8,
+                                      val, nval);
+}
+EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array);
+
+/**
+ * fwnode_property_read_u16_array - return a u16 array property of firmware node
+ * @fwnode: Firmware node to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Read an array of u16 properties with @propname from @fwnode and store them to
+ * @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of numbers,
+ *         %-EOVERFLOW if the size of the property is not as expected,
+ *         %-ENXIO if no suitable firmware interface is present.
+ */
+int fwnode_property_read_u16_array(struct fwnode_handle *fwnode,
+                                   const char *propname, u16 *val, size_t nval)
+{
+        return FWNODE_PROP_READ_ARRAY(fwnode, propname, u16, DEV_PROP_U16,
+                                      val, nval);
+}
+EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array);
+
+/**
+ * fwnode_property_read_u32_array - return a u32 array property of firmware node
+ * @fwnode: Firmware node to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Read an array of u32 properties with @propname from @fwnode store them to
+ * @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of numbers,
+ *         %-EOVERFLOW if the size of the property is not as expected,
+ *         %-ENXIO if no suitable firmware interface is present.
+ */
+int fwnode_property_read_u32_array(struct fwnode_handle *fwnode,
+                                   const char *propname, u32 *val, size_t nval)
+{
+        return FWNODE_PROP_READ_ARRAY(fwnode, propname, u32, DEV_PROP_U32,
+                                      val, nval);
+}
+EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array);
+
+/**
+ * fwnode_property_read_u64_array - return a u64 array property firmware node
+ * @fwnode: Firmware node to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Read an array of u64 properties with @propname from @fwnode and store them to
+ * @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of numbers,
+ *         %-EOVERFLOW if the size of the property is not as expected,
+ *         %-ENXIO if no suitable firmware interface is present.
+ */
+int fwnode_property_read_u64_array(struct fwnode_handle *fwnode,
+                                   const char *propname, u64 *val, size_t nval)
+{
+        return FWNODE_PROP_READ_ARRAY(fwnode, propname, u64, DEV_PROP_U64,
+                                      val, nval);
+}
+EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array);
+
+/**
+ * fwnode_property_read_string_array - return string array property of a node
+ * @fwnode: Firmware node to get the property of
+ * @propname: Name of the property
+ * @val: The values are stored here
+ * @nval: Size of the @val array
+ *
+ * Read an string list property @propname from the given firmware node and store
+ * them to @val if found.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO if the property is not an array of strings,
+ *         %-EOVERFLOW if the size of the property is not as expected,
+ *         %-ENXIO if no suitable firmware interface is present.
+ */
+int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
+                                      const char *propname, const char **val,
+                                      size_t nval)
+{
+        if (is_of_node(fwnode))
+                return of_property_read_string_array(of_node(fwnode), propname,
+                                                     val, nval);
+        else if (is_acpi_node(fwnode))
+                return acpi_dev_prop_read(acpi_node(fwnode), propname,
+                                          DEV_PROP_STRING, val, nval);
+
+        return -ENXIO;
+}
+EXPORT_SYMBOL_GPL(fwnode_property_read_string_array);
+
+/**
+ * fwnode_property_read_string - return a string property of a firmware node
+ * @fwnode: Firmware node to get the property of
+ * @propname: Name of the property
+ * @val: The value is stored here
+ *
+ * Read property @propname from the given firmware node and store the value into
+ * @val if found.  The value is checked to be a string.
+ *
+ * Return: %0 if the property was found (success),
+ *         %-EINVAL if given arguments are not valid,
+ *         %-ENODATA if the property does not have a value,
+ *         %-EPROTO or %-EILSEQ if the property is not a string,
+ *         %-ENXIO if no suitable firmware interface is present.
+ */
+int fwnode_property_read_string(struct fwnode_handle *fwnode,
+                                const char *propname, const char **val)
+{
+        if (is_of_node(fwnode))
+                return of_property_read_string(of_node(fwnode),propname, val);
+        else if (is_acpi_node(fwnode))
+                return acpi_dev_prop_read(acpi_node(fwnode), propname,
+                                          DEV_PROP_STRING, val, 1);
+
+        return -ENXIO;
+}
+EXPORT_SYMBOL_GPL(fwnode_property_read_string);
+
+/**
+ * device_get_next_child_node - Return the next child node handle for a device
+ * @dev: Device to find the next child node for.
+ * @child: Handle to one of the device's child nodes or a null handle.
+ */
+struct fwnode_handle *device_get_next_child_node(struct device *dev,
+                                                 struct fwnode_handle *child)
+{
+        if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
+                struct device_node *node;
+
+                node = of_get_next_available_child(dev->of_node, of_node(child));
+                if (node)
+                        return &node->fwnode;
+        } else if (IS_ENABLED(CONFIG_ACPI)) {
+                struct acpi_device *node;
+
+                node = acpi_get_next_child(dev, acpi_node(child));
+                if (node)
+                        return acpi_fwnode_handle(node);
+        }
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(device_get_next_child_node);
+
+/**
+ * fwnode_handle_put - Drop reference to a device node
+ * @fwnode: Pointer to the device node to drop the reference to.
+ *
+ * This has to be used when terminating device_for_each_child_node() iteration
+ * with break or return to prevent stale device node references from being left
+ * behind.
+ */
+void fwnode_handle_put(struct fwnode_handle *fwnode)
+{
+        if (is_of_node(fwnode))
+                of_node_put(of_node(fwnode));
+}
+EXPORT_SYMBOL_GPL(fwnode_handle_put);
+
+/**
+ * device_get_child_node_count - return the number of child nodes for device
+ * @dev: Device to cound the child nodes for
+ */
+unsigned int device_get_child_node_count(struct device *dev)
+{
+        struct fwnode_handle *child;
+        unsigned int count = 0;
+
+        device_for_each_child_node(dev, child)
+                count++;
+
+        return count;
+}
+EXPORT_SYMBOL_GPL(device_get_child_node_count);
diff --git a/drivers/base/regmap/Kconfig b/drivers/base/regmap/Kconfig
index 8a3f51f7b1b9..db9d00c36a3e 100644
--- a/drivers/base/regmap/Kconfig
+++ b/drivers/base/regmap/Kconfig
@@ -3,12 +3,15 @@
 # subsystems should select the appropriate symbols.
 
 config REGMAP
-        default y if (REGMAP_I2C || REGMAP_SPI || REGMAP_SPMI || REGMAP_MMIO || REGMAP_IRQ)
+        default y if (REGMAP_I2C || REGMAP_SPI || REGMAP_SPMI || REGMAP_AC97 || REGMAP_MMIO || REGMAP_IRQ)
         select LZO_COMPRESS
         select LZO_DECOMPRESS
         select IRQ_DOMAIN if REGMAP_IRQ
         bool
 
+config REGMAP_AC97
+        tristate
+
 config REGMAP_I2C
         tristate
         depends on I2C
diff --git a/drivers/base/regmap/Makefile b/drivers/base/regmap/Makefile
index a7c670b4123a..0a533653ef3b 100644
--- a/drivers/base/regmap/Makefile
+++ b/drivers/base/regmap/Makefile
@@ -1,6 +1,7 @@
 obj-$(CONFIG_REGMAP) += regmap.o regcache.o
 obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-lzo.o regcache-flat.o
 obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o
+obj-$(CONFIG_REGMAP_AC97) += regmap-ac97.o
 obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o
 obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o
 obj-$(CONFIG_REGMAP_SPMI) += regmap-spmi.o
diff --git a/drivers/base/regmap/regcache-flat.c b/drivers/base/regmap/regcache-flat.c
index d9762e41959b..0246f44ded74 100644
--- a/drivers/base/regmap/regcache-flat.c
+++ b/drivers/base/regmap/regcache-flat.c
@@ -10,9 +10,9 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include "internal.h"
 
diff --git a/drivers/base/regmap/regcache-lzo.c b/drivers/base/regmap/regcache-lzo.c
index e210a6d1406a..2d53f6f138e1 100644
--- a/drivers/base/regmap/regcache-lzo.c
+++ b/drivers/base/regmap/regcache-lzo.c
@@ -10,9 +10,9 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/lzo.h>
+#include <linux/slab.h>
 
 #include "internal.h"
 
diff --git a/drivers/base/regmap/regcache-rbtree.c b/drivers/base/regmap/regcache-rbtree.c
index f3e8fe0cc650..d453a2c98ad0 100644
--- a/drivers/base/regmap/regcache-rbtree.c
+++ b/drivers/base/regmap/regcache-rbtree.c
@@ -10,11 +10,11 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/slab.h>
-#include <linux/device.h>
 #include <linux/debugfs.h>
+#include <linux/device.h>
 #include <linux/rbtree.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include "internal.h"
 
diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.c
index f1280dc356d0..f373c35f9e1d 100644
--- a/drivers/base/regmap/regcache.c
+++ b/drivers/base/regmap/regcache.c
@@ -10,12 +10,12 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/slab.h>
-#include <linux/export.h>
-#include <linux/device.h>
-#include <trace/events/regmap.h>
 #include <linux/bsearch.h>
+#include <linux/device.h>
+#include <linux/export.h>
+#include <linux/slab.h>
 #include <linux/sort.h>
+#include <trace/events/regmap.h>
 
 #include "internal.h"
 
@@ -36,6 +36,23 @@ static int regcache_hw_init(struct regmap *map)
         if (!map->num_reg_defaults_raw)
                 return -EINVAL;
 
+        /* calculate the size of reg_defaults */
+        for (count = 0, i = 0; i < map->num_reg_defaults_raw; i++)
+                if (!regmap_volatile(map, i * map->reg_stride))
+                        count++;
+
+        /* all registers are volatile, so just bypass */
+        if (!count) {
+                map->cache_bypass = true;
+                return 0;
+        }
+
+        map->num_reg_defaults = count;
+        map->reg_defaults = kmalloc_array(count, sizeof(struct reg_default),
+                                          GFP_KERNEL);
+        if (!map->reg_defaults)
+                return -ENOMEM;
+
         if (!map->reg_defaults_raw) {
                 u32 cache_bypass = map->cache_bypass;
                 dev_warn(map->dev, "No cache defaults, reading back from HW\n");
@@ -43,40 +60,25 @@ static int regcache_hw_init(struct regmap *map)
                 /* Bypass the cache access till data read from HW*/
                 map->cache_bypass = 1;
                 tmp_buf = kmalloc(map->cache_size_raw, GFP_KERNEL);
-                if (!tmp_buf)
-                        return -EINVAL;
+                if (!tmp_buf) {
+                        ret = -ENOMEM;
+                        goto err_free;
+                }
                 ret = regmap_raw_read(map, 0, tmp_buf,
                                       map->num_reg_defaults_raw);
                 map->cache_bypass = cache_bypass;
-                if (ret < 0) {
-                        kfree(tmp_buf);
-                        return ret;
-                }
+                if (ret < 0)
+                        goto err_cache_free;
+
                 map->reg_defaults_raw = tmp_buf;
                 map->cache_free = 1;
         }
 
-        /* calculate the size of reg_defaults */
-        for (count = 0, i = 0; i < map->num_reg_defaults_raw; i++) {
-                val = regcache_get_val(map, map->reg_defaults_raw, i);
-                if (regmap_volatile(map, i * map->reg_stride))
-                        continue;
-                count++;
-        }
-
-        map->reg_defaults = kmalloc(count * sizeof(struct reg_default),
-                                      GFP_KERNEL);
-        if (!map->reg_defaults) {
-                ret = -ENOMEM;
-                goto err_free;
-        }
-
         /* fill the reg_defaults */
-        map->num_reg_defaults = count;
         for (i = 0, j = 0; i < map->num_reg_defaults_raw; i++) {
-                val = regcache_get_val(map, map->reg_defaults_raw, i);
                 if (regmap_volatile(map, i * map->reg_stride))
                         continue;
+                val = regcache_get_val(map, map->reg_defaults_raw, i);
                 map->reg_defaults[j].reg = i * map->reg_stride;
                 map->reg_defaults[j].def = val;
                 j++;
@@ -84,9 +86,10 @@ static int regcache_hw_init(struct regmap *map)
 
         return 0;
 
+err_cache_free:
+        kfree(tmp_buf);
 err_free:
-        if (map->cache_free)
-                kfree(map->reg_defaults_raw);
+        kfree(map->reg_defaults);
 
         return ret;
 }
@@ -150,6 +153,8 @@ int regcache_init(struct regmap *map, const struct regmap_config *config)
                 ret = regcache_hw_init(map);
                 if (ret < 0)
                         return ret;
+                if (map->cache_bypass)
+                        return 0;
         }
 
         if (!map->max_register)
diff --git a/drivers/base/regmap/regmap-ac97.c b/drivers/base/regmap/regmap-ac97.c
new file mode 100644
index 000000000000..e4c45d2299c1
--- /dev/null
+++ b/drivers/base/regmap/regmap-ac97.c
@@ -0,0 +1,114 @@
+/*
+ * Register map access API - AC'97 support
+ *
+ * Copyright 2013 Linaro Ltd.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+
+#include <sound/ac97_codec.h>
+
+bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case AC97_RESET:
+        case AC97_POWERDOWN:
+        case AC97_INT_PAGING:
+        case AC97_EXTENDED_ID:
+        case AC97_EXTENDED_STATUS:
+        case AC97_EXTENDED_MID:
+        case AC97_EXTENDED_MSTATUS:
+        case AC97_GPIO_STATUS:
+        case AC97_MISC_AFE:
+        case AC97_VENDOR_ID1:
+        case AC97_VENDOR_ID2:
+        case AC97_CODEC_CLASS_REV:
+        case AC97_PCI_SVID:
+        case AC97_PCI_SID:
+        case AC97_FUNC_SELECT:
+        case AC97_FUNC_INFO:
+        case AC97_SENSE_INFO:
+                return true;
+        default:
+                return false;
+        }
+}
+EXPORT_SYMBOL_GPL(regmap_ac97_default_volatile);
+
+static int regmap_ac97_reg_read(void *context, unsigned int reg,
+        unsigned int *val)
+{
+        struct snd_ac97 *ac97 = context;
+
+        *val = ac97->bus->ops->read(ac97, reg);
+
+        return 0;
+}
+
+static int regmap_ac97_reg_write(void *context, unsigned int reg,
+        unsigned int val)
+{
+        struct snd_ac97 *ac97 = context;
+
+        ac97->bus->ops->write(ac97, reg, val);
+
+        return 0;
+}
+
+static const struct regmap_bus ac97_regmap_bus = {
+                .reg_write = regmap_ac97_reg_write,
+                .reg_read = regmap_ac97_reg_read,
+};
+
+/**
+ * regmap_init_ac97(): Initialise AC'97 register map
+ *
+ * @ac97: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+struct regmap *regmap_init_ac97(struct snd_ac97 *ac97,
+                                const struct regmap_config *config)
+{
+        return regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config);
+}
+EXPORT_SYMBOL_GPL(regmap_init_ac97);
+
+/**
+ * devm_regmap_init_ac97(): Initialise AC'97 register map
+ *
+ * @ac97: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The regmap will be automatically freed by the
+ * device management code.
+ */
+struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97,
+                                     const struct regmap_config *config)
+{
+        return devm_regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config);
+}
+EXPORT_SYMBOL_GPL(devm_regmap_init_ac97);
+
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/block/drbd/drbd_debugfs.c b/drivers/block/drbd/drbd_debugfs.c
index 900d4d3272d1..9a950022ff88 100644
--- a/drivers/block/drbd/drbd_debugfs.c
+++ b/drivers/block/drbd/drbd_debugfs.c
@@ -419,7 +419,7 @@ static int in_flight_summary_show(struct seq_file *m, void *pos)
         return 0;
 }
 
-/* simple_positive(file->f_dentry) respectively debugfs_positive(),
+/* simple_positive(file->f_path.dentry) respectively debugfs_positive(),
  * but neither is "reachable" from here.
  * So we have our own inline version of it above.  :-( */
 static inline int debugfs_positive(struct dentry *dentry)
@@ -437,14 +437,14 @@ static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, vo
 
         /* Are we still linked,
          * or has debugfs_remove() already been called? */
-        parent = file->f_dentry->d_parent;
+        parent = file->f_path.dentry->d_parent;
         /* not sure if this can happen: */
         if (!parent || !parent->d_inode)
                 goto out;
         /* serialize with d_delete() */
         mutex_lock(&parent->d_inode->i_mutex);
         /* Make sure the object is still alive */
-        if (debugfs_positive(file->f_dentry)
+        if (debugfs_positive(file->f_path.dentry)
         && kref_get_unless_zero(kref))
                 ret = 0;
         mutex_unlock(&parent->d_inode->i_mutex);
diff --git a/drivers/block/nvme-scsi.c b/drivers/block/nvme-scsi.c
index a4cd6d691c63..0b4b2775600e 100644
--- a/drivers/block/nvme-scsi.c
+++ b/drivers/block/nvme-scsi.c
@@ -329,7 +329,7 @@ INQUIRY_EVPD_BIT_MASK) ? 1 : 0)
 (GET_U32_FROM_CDB(cdb, READ_CAP_16_CDB_ALLOC_LENGTH_OFFSET))
 
 #define IS_READ_CAP_16(cdb)                                     \
-((cdb[0] == SERVICE_ACTION_IN && cdb[1] == SAI_READ_CAPACITY_16) ? 1 : 0)
+((cdb[0] == SERVICE_ACTION_IN_16 && cdb[1] == SAI_READ_CAPACITY_16) ? 1 : 0)
 
 /* Request Sense Helper Macros */
 #define GET_REQUEST_SENSE_ALLOC_LENGTH(cdb)                     \
@@ -2947,7 +2947,7 @@ static int nvme_scsi_translate(struct nvme_ns *ns, struct sg_io_hdr *hdr)
         case READ_CAPACITY:
                 retcode = nvme_trans_read_capacity(ns, hdr, cmd);
                 break;
-        case SERVICE_ACTION_IN:
+        case SERVICE_ACTION_IN_16:
                 if (IS_READ_CAP_16(cmd))
                         retcode = nvme_trans_read_capacity(ns, hdr, cmd);
                 else
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index c6a27d54ad62..1fb9e09fbbc5 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -80,7 +80,7 @@ static int __virtblk_add_req(struct virtqueue *vq,
 {
         struct scatterlist hdr, status, cmd, sense, inhdr, *sgs[6];
         unsigned int num_out = 0, num_in = 0;
-        int type = vbr->out_hdr.type & ~VIRTIO_BLK_T_OUT;
+        __virtio32 type = vbr->out_hdr.type & ~cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_OUT);
 
         sg_init_one(&hdr, &vbr->out_hdr, sizeof(vbr->out_hdr));
         sgs[num_out++] = &hdr;
@@ -91,19 +91,19 @@ static int __virtblk_add_req(struct virtqueue *vq,
          * block, and before the normal inhdr we put the sense data and the
          * inhdr with additional status information.
          */
-        if (type == VIRTIO_BLK_T_SCSI_CMD) {
+        if (type == cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_SCSI_CMD)) {
                 sg_init_one(&cmd, vbr->req->cmd, vbr->req->cmd_len);
                 sgs[num_out++] = &cmd;
         }
 
         if (have_data) {
-                if (vbr->out_hdr.type & VIRTIO_BLK_T_OUT)
+                if (vbr->out_hdr.type & cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_OUT))
                         sgs[num_out++] = data_sg;
                 else
                         sgs[num_out + num_in++] = data_sg;
         }
 
-        if (type == VIRTIO_BLK_T_SCSI_CMD) {
+        if (type == cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_SCSI_CMD)) {
                 sg_init_one(&sense, vbr->req->sense, SCSI_SENSE_BUFFERSIZE);
                 sgs[num_out + num_in++] = &sense;
                 sg_init_one(&inhdr, &vbr->in_hdr, sizeof(vbr->in_hdr));
@@ -119,12 +119,13 @@ static int __virtblk_add_req(struct virtqueue *vq,
 static inline void virtblk_request_done(struct request *req)
 {
         struct virtblk_req *vbr = blk_mq_rq_to_pdu(req);
+        struct virtio_blk *vblk = req->q->queuedata;
         int error = virtblk_result(vbr);
 
         if (req->cmd_type == REQ_TYPE_BLOCK_PC) {
-                req->resid_len = vbr->in_hdr.residual;
-                req->sense_len = vbr->in_hdr.sense_len;
-                req->errors = vbr->in_hdr.errors;
+                req->resid_len = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.residual);
+                req->sense_len = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.sense_len);
+                req->errors = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.errors);
         } else if (req->cmd_type == REQ_TYPE_SPECIAL) {
                 req->errors = (error != 0);
         }
@@ -173,25 +174,25 @@ static int virtio_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *req,
 
         vbr->req = req;
         if (req->cmd_flags & REQ_FLUSH) {
-                vbr->out_hdr.type = VIRTIO_BLK_T_FLUSH;
+                vbr->out_hdr.type = cpu_to_virtio32(vblk->vdev, VIRTIO_BLK_T_FLUSH);
                 vbr->out_hdr.sector = 0;
-                vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
+                vbr->out_hdr.ioprio = cpu_to_virtio32(vblk->vdev, req_get_ioprio(vbr->req));
         } else {
                 switch (req->cmd_type) {
                 case REQ_TYPE_FS:
                         vbr->out_hdr.type = 0;
-                        vbr->out_hdr.sector = blk_rq_pos(vbr->req);
-                        vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
+                        vbr->out_hdr.sector = cpu_to_virtio64(vblk->vdev, blk_rq_pos(vbr->req));
+                        vbr->out_hdr.ioprio = cpu_to_virtio32(vblk->vdev, req_get_ioprio(vbr->req));
                         break;
                 case REQ_TYPE_BLOCK_PC:
-                        vbr->out_hdr.type = VIRTIO_BLK_T_SCSI_CMD;
+                        vbr->out_hdr.type = cpu_to_virtio32(vblk->vdev, VIRTIO_BLK_T_SCSI_CMD);
                         vbr->out_hdr.sector = 0;
-                        vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
+                        vbr->out_hdr.ioprio = cpu_to_virtio32(vblk->vdev, req_get_ioprio(vbr->req));
                         break;
                 case REQ_TYPE_SPECIAL:
-                        vbr->out_hdr.type = VIRTIO_BLK_T_GET_ID;
+                        vbr->out_hdr.type = cpu_to_virtio32(vblk->vdev, VIRTIO_BLK_T_GET_ID);
                         vbr->out_hdr.sector = 0;
-                        vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
+                        vbr->out_hdr.ioprio = cpu_to_virtio32(vblk->vdev, req_get_ioprio(vbr->req));
                         break;
                 default:
                         /* We don't put anything else in the queue. */
@@ -204,9 +205,9 @@ static int virtio_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *req,
         num = blk_rq_map_sg(hctx->queue, vbr->req, vbr->sg);
         if (num) {
                 if (rq_data_dir(vbr->req) == WRITE)
-                        vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
+                        vbr->out_hdr.type |= cpu_to_virtio32(vblk->vdev, VIRTIO_BLK_T_OUT);
                 else
-                        vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
+                        vbr->out_hdr.type |= cpu_to_virtio32(vblk->vdev, VIRTIO_BLK_T_IN);
         }
 
         spin_lock_irqsave(&vblk->vqs[qid].lock, flags);
@@ -331,7 +332,8 @@ static ssize_t virtblk_serial_show(struct device *dev,
 
         return err;
 }
-DEVICE_ATTR(serial, S_IRUGO, virtblk_serial_show, NULL);
+
+static DEVICE_ATTR(serial, S_IRUGO, virtblk_serial_show, NULL);
 
 static void virtblk_config_changed_work(struct work_struct *work)
 {
@@ -476,7 +478,8 @@ static int virtblk_get_cache_mode(struct virtio_device *vdev)
                                    struct virtio_blk_config, wce,
                                    &writeback);
         if (err)
-                writeback = virtio_has_feature(vdev, VIRTIO_BLK_F_WCE);
+                writeback = virtio_has_feature(vdev, VIRTIO_BLK_F_WCE) ||
+                            virtio_has_feature(vdev, VIRTIO_F_VERSION_1);
 
         return writeback;
 }
@@ -821,25 +824,34 @@ static const struct virtio_device_id id_table[] = {
         { 0 },
 };
 
-static unsigned int features[] = {
+static unsigned int features_legacy[] = {
         VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX, VIRTIO_BLK_F_GEOMETRY,
         VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE, VIRTIO_BLK_F_SCSI,
         VIRTIO_BLK_F_WCE, VIRTIO_BLK_F_TOPOLOGY, VIRTIO_BLK_F_CONFIG_WCE,
         VIRTIO_BLK_F_MQ,
+}
+;
+static unsigned int features[] = {
+        VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX, VIRTIO_BLK_F_GEOMETRY,
+        VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,
+        VIRTIO_BLK_F_TOPOLOGY,
+        VIRTIO_BLK_F_MQ,
 };
 
 static struct virtio_driver virtio_blk = {
-        .feature_table          = features,
-        .feature_table_size     = ARRAY_SIZE(features),
-        .driver.name            = KBUILD_MODNAME,
-        .driver.owner           = THIS_MODULE,
-        .id_table               = id_table,
-        .probe                  = virtblk_probe,
-        .remove                 = virtblk_remove,
-        .config_changed         = virtblk_config_changed,
+        .feature_table                  = features,
+        .feature_table_size             = ARRAY_SIZE(features),
+        .feature_table_legacy           = features_legacy,
+        .feature_table_size_legacy      = ARRAY_SIZE(features_legacy),
+        .driver.name                    = KBUILD_MODNAME,
+        .driver.owner                   = THIS_MODULE,
+        .id_table                       = id_table,
+        .probe                          = virtblk_probe,
+        .remove                         = virtblk_remove,
+        .config_changed                 = virtblk_config_changed,
 #ifdef CONFIG_PM_SLEEP
-        .freeze                 = virtblk_freeze,
-        .restore                = virtblk_restore,
+        .freeze                         = virtblk_freeze,
+        .restore                        = virtblk_restore,
 #endif
 };
 
@@ -871,8 +883,8 @@ out_destroy_workqueue:
 
 static void __exit fini(void)
 {
-        unregister_blkdev(major, "virtblk");
         unregister_virtio_driver(&virtio_blk);
+        unregister_blkdev(major, "virtblk");
         destroy_workqueue(virtblk_wq);
 }
 module_init(init);
diff --git a/drivers/bus/Kconfig b/drivers/bus/Kconfig
index 603eb1be4f6a..b99729e36860 100644
--- a/drivers/bus/Kconfig
+++ b/drivers/bus/Kconfig
@@ -6,7 +6,7 @@ menu "Bus devices"
 
 config BRCMSTB_GISB_ARB
         bool "Broadcom STB GISB bus arbiter"
-        depends on ARM
+        depends on ARM || MIPS
         help
           Driver for the Broadcom Set Top Box System-on-a-chip internal bus
           arbiter. This driver provides timeout and target abort error handling
diff --git a/drivers/bus/arm-cci.c b/drivers/bus/arm-cci.c
index 7af78df241f2..860da40b78ef 100644
--- a/drivers/bus/arm-cci.c
+++ b/drivers/bus/arm-cci.c
@@ -16,17 +16,17 @@
 
 #include <linux/arm-cci.h>
 #include <linux/io.h>
+#include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
 #include <linux/of_platform.h>
+#include <linux/perf_event.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 
 #include <asm/cacheflush.h>
-#include <asm/irq_regs.h>
-#include <asm/pmu.h>
 #include <asm/smp_plat.h>
 
 #define DRIVER_NAME             "CCI-400"
@@ -98,6 +98,8 @@ static unsigned long cci_ctrl_phys;
 
 #define CCI_PMU_CNTR_BASE(idx)  ((idx) * SZ_4K)
 
+#define CCI_PMU_CNTR_MASK       ((1ULL << 32) -1)
+
 /*
  * Instead of an event id to monitor CCI cycles, a dedicated counter is
  * provided. Use 0xff to represent CCI cycles and hope that no future revisions
@@ -170,18 +172,29 @@ static char *const pmu_names[] = {
         [CCI_REV_R1] = "CCI_400_r1",
 };
 
-struct cci_pmu_drv_data {
+struct cci_pmu_hw_events {
+        struct perf_event *events[CCI_PMU_MAX_HW_EVENTS];
+        unsigned long used_mask[BITS_TO_LONGS(CCI_PMU_MAX_HW_EVENTS)];
+        raw_spinlock_t pmu_lock;
+};
+
+struct cci_pmu {
         void __iomem *base;
-        struct arm_pmu *cci_pmu;
+        struct pmu pmu;
         int nr_irqs;
         int irqs[CCI_PMU_MAX_HW_EVENTS];
         unsigned long active_irqs;
-        struct perf_event *events[CCI_PMU_MAX_HW_EVENTS];
-        unsigned long used_mask[BITS_TO_LONGS(CCI_PMU_MAX_HW_EVENTS)];
         struct pmu_port_event_ranges *port_ranges;
-        struct pmu_hw_events hw_events;
+        struct cci_pmu_hw_events hw_events;
+        struct platform_device *plat_device;
+        int num_events;
+        atomic_t active_events;
+        struct mutex reserve_mutex;
+        cpumask_t cpus;
 };
-static struct cci_pmu_drv_data *pmu;
+static struct cci_pmu *pmu;
+
+#define to_cci_pmu(c)   (container_of(c, struct cci_pmu, pmu))
 
 static bool is_duplicate_irq(int irq, int *irqs, int nr_irqs)
 {
@@ -252,7 +265,7 @@ static int pmu_validate_hw_event(u8 hw_event)
         return -ENOENT;
 }
 
-static int pmu_is_valid_counter(struct arm_pmu *cci_pmu, int idx)
+static int pmu_is_valid_counter(struct cci_pmu *cci_pmu, int idx)
 {
         return CCI_PMU_CYCLE_CNTR_IDX <= idx &&
                 idx <= CCI_PMU_CNTR_LAST(cci_pmu);
@@ -293,14 +306,9 @@ static u32 pmu_get_max_counters(void)
         return n_cnts + 1;
 }
 
-static struct pmu_hw_events *pmu_get_hw_events(void)
-{
-        return &pmu->hw_events;
-}
-
-static int pmu_get_event_idx(struct pmu_hw_events *hw, struct perf_event *event)
+static int pmu_get_event_idx(struct cci_pmu_hw_events *hw, struct perf_event *event)
 {
-        struct arm_pmu *cci_pmu = to_arm_pmu(event->pmu);
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
         struct hw_perf_event *hw_event = &event->hw;
         unsigned long cci_event = hw_event->config_base & CCI_PMU_EVENT_MASK;
         int idx;
@@ -336,7 +344,7 @@ static int pmu_map_event(struct perf_event *event)
         return mapping;
 }
 
-static int pmu_request_irq(struct arm_pmu *cci_pmu, irq_handler_t handler)
+static int pmu_request_irq(struct cci_pmu *cci_pmu, irq_handler_t handler)
 {
         int i;
         struct platform_device *pmu_device = cci_pmu->plat_device;
@@ -371,17 +379,91 @@ static int pmu_request_irq(struct arm_pmu *cci_pmu, irq_handler_t handler)
         return 0;
 }
 
+static void pmu_free_irq(struct cci_pmu *cci_pmu)
+{
+        int i;
+
+        for (i = 0; i < pmu->nr_irqs; i++) {
+                if (!test_and_clear_bit(i, &pmu->active_irqs))
+                        continue;
+
+                free_irq(pmu->irqs[i], cci_pmu);
+        }
+}
+
+static u32 pmu_read_counter(struct perf_event *event)
+{
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
+        struct hw_perf_event *hw_counter = &event->hw;
+        int idx = hw_counter->idx;
+        u32 value;
+
+        if (unlikely(!pmu_is_valid_counter(cci_pmu, idx))) {
+                dev_err(&cci_pmu->plat_device->dev, "Invalid CCI PMU counter %d\n", idx);
+                return 0;
+        }
+        value = pmu_read_register(idx, CCI_PMU_CNTR);
+
+        return value;
+}
+
+static void pmu_write_counter(struct perf_event *event, u32 value)
+{
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
+        struct hw_perf_event *hw_counter = &event->hw;
+        int idx = hw_counter->idx;
+
+        if (unlikely(!pmu_is_valid_counter(cci_pmu, idx)))
+                dev_err(&cci_pmu->plat_device->dev, "Invalid CCI PMU counter %d\n", idx);
+        else
+                pmu_write_register(value, idx, CCI_PMU_CNTR);
+}
+
+static u64 pmu_event_update(struct perf_event *event)
+{
+        struct hw_perf_event *hwc = &event->hw;
+        u64 delta, prev_raw_count, new_raw_count;
+
+        do {
+                prev_raw_count = local64_read(&hwc->prev_count);
+                new_raw_count = pmu_read_counter(event);
+        } while (local64_cmpxchg(&hwc->prev_count, prev_raw_count,
+                 new_raw_count) != prev_raw_count);
+
+        delta = (new_raw_count - prev_raw_count) & CCI_PMU_CNTR_MASK;
+
+        local64_add(delta, &event->count);
+
+        return new_raw_count;
+}
+
+static void pmu_read(struct perf_event *event)
+{
+        pmu_event_update(event);
+}
+
+void pmu_event_set_period(struct perf_event *event)
+{
+        struct hw_perf_event *hwc = &event->hw;
+        /*
+         * The CCI PMU counters have a period of 2^32. To account for the
+         * possiblity of extreme interrupt latency we program for a period of
+         * half that. Hopefully we can handle the interrupt before another 2^31
+         * events occur and the counter overtakes its previous value.
+         */
+        u64 val = 1ULL << 31;
+        local64_set(&hwc->prev_count, val);
+        pmu_write_counter(event, val);
+}
+
 static irqreturn_t pmu_handle_irq(int irq_num, void *dev)
 {
         unsigned long flags;
-        struct arm_pmu *cci_pmu = (struct arm_pmu *)dev;
-        struct pmu_hw_events *events = cci_pmu->get_hw_events();
-        struct perf_sample_data data;
-        struct pt_regs *regs;
+        struct cci_pmu *cci_pmu = dev;
+        struct cci_pmu_hw_events *events = &pmu->hw_events;
         int idx, handled = IRQ_NONE;
 
         raw_spin_lock_irqsave(&events->pmu_lock, flags);
-        regs = get_irq_regs();
         /*
          * Iterate over counters and update the corresponding perf events.
          * This should work regardless of whether we have per-counter overflow
@@ -403,154 +485,407 @@ static irqreturn_t pmu_handle_irq(int irq_num, void *dev)
 
                 pmu_write_register(CCI_PMU_OVRFLW_FLAG, idx, CCI_PMU_OVRFLW);
 
+                pmu_event_update(event);
+                pmu_event_set_period(event);
                 handled = IRQ_HANDLED;
-
-                armpmu_event_update(event);
-                perf_sample_data_init(&data, 0, hw_counter->last_period);
-                if (!armpmu_event_set_period(event))
-                        continue;
-
-                if (perf_event_overflow(event, &data, regs))
-                        cci_pmu->disable(event);
         }
         raw_spin_unlock_irqrestore(&events->pmu_lock, flags);
 
         return IRQ_RETVAL(handled);
 }
 
-static void pmu_free_irq(struct arm_pmu *cci_pmu)
+static int cci_pmu_get_hw(struct cci_pmu *cci_pmu)
 {
-        int i;
+        int ret = pmu_request_irq(cci_pmu, pmu_handle_irq);
+        if (ret) {
+                pmu_free_irq(cci_pmu);
+                return ret;
+        }
+        return 0;
+}
 
-        for (i = 0; i < pmu->nr_irqs; i++) {
-                if (!test_and_clear_bit(i, &pmu->active_irqs))
-                        continue;
+static void cci_pmu_put_hw(struct cci_pmu *cci_pmu)
+{
+        pmu_free_irq(cci_pmu);
+}
 
-                free_irq(pmu->irqs[i], cci_pmu);
+static void hw_perf_event_destroy(struct perf_event *event)
+{
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
+        atomic_t *active_events = &cci_pmu->active_events;
+        struct mutex *reserve_mutex = &cci_pmu->reserve_mutex;
+
+        if (atomic_dec_and_mutex_lock(active_events, reserve_mutex)) {
+                cci_pmu_put_hw(cci_pmu);
+                mutex_unlock(reserve_mutex);
         }
 }
 
-static void pmu_enable_event(struct perf_event *event)
+static void cci_pmu_enable(struct pmu *pmu)
 {
+        struct cci_pmu *cci_pmu = to_cci_pmu(pmu);
+        struct cci_pmu_hw_events *hw_events = &cci_pmu->hw_events;
+        int enabled = bitmap_weight(hw_events->used_mask, cci_pmu->num_events);
         unsigned long flags;
-        struct arm_pmu *cci_pmu = to_arm_pmu(event->pmu);
-        struct pmu_hw_events *events = cci_pmu->get_hw_events();
-        struct hw_perf_event *hw_counter = &event->hw;
-        int idx = hw_counter->idx;
+        u32 val;
+
+        if (!enabled)
+                return;
+
+        raw_spin_lock_irqsave(&hw_events->pmu_lock, flags);
+
+        /* Enable all the PMU counters. */
+        val = readl_relaxed(cci_ctrl_base + CCI_PMCR) | CCI_PMCR_CEN;
+        writel(val, cci_ctrl_base + CCI_PMCR);
+        raw_spin_unlock_irqrestore(&hw_events->pmu_lock, flags);
+
+}
+
+static void cci_pmu_disable(struct pmu *pmu)
+{
+        struct cci_pmu *cci_pmu = to_cci_pmu(pmu);
+        struct cci_pmu_hw_events *hw_events = &cci_pmu->hw_events;
+        unsigned long flags;
+        u32 val;
+
+        raw_spin_lock_irqsave(&hw_events->pmu_lock, flags);
+
+        /* Disable all the PMU counters. */
+        val = readl_relaxed(cci_ctrl_base + CCI_PMCR) & ~CCI_PMCR_CEN;
+        writel(val, cci_ctrl_base + CCI_PMCR);
+        raw_spin_unlock_irqrestore(&hw_events->pmu_lock, flags);
+}
+
+static void cci_pmu_start(struct perf_event *event, int pmu_flags)
+{
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
+        struct cci_pmu_hw_events *hw_events = &cci_pmu->hw_events;
+        struct hw_perf_event *hwc = &event->hw;
+        int idx = hwc->idx;
+        unsigned long flags;
+
+        /*
+         * To handle interrupt latency, we always reprogram the period
+         * regardlesss of PERF_EF_RELOAD.
+         */
+        if (pmu_flags & PERF_EF_RELOAD)
+                WARN_ON_ONCE(!(hwc->state & PERF_HES_UPTODATE));
+
+        hwc->state = 0;
 
         if (unlikely(!pmu_is_valid_counter(cci_pmu, idx))) {
                 dev_err(&cci_pmu->plat_device->dev, "Invalid CCI PMU counter %d\n", idx);
                 return;
         }
 
-        raw_spin_lock_irqsave(&events->pmu_lock, flags);
+        raw_spin_lock_irqsave(&hw_events->pmu_lock, flags);
 
         /* Configure the event to count, unless you are counting cycles */
         if (idx != CCI_PMU_CYCLE_CNTR_IDX)
-                pmu_set_event(idx, hw_counter->config_base);
+                pmu_set_event(idx, hwc->config_base);
 
+        pmu_event_set_period(event);
         pmu_enable_counter(idx);
 
-        raw_spin_unlock_irqrestore(&events->pmu_lock, flags);
+        raw_spin_unlock_irqrestore(&hw_events->pmu_lock, flags);
 }
 
-static void pmu_disable_event(struct perf_event *event)
+static void cci_pmu_stop(struct perf_event *event, int pmu_flags)
 {
-        struct arm_pmu *cci_pmu = to_arm_pmu(event->pmu);
-        struct hw_perf_event *hw_counter = &event->hw;
-        int idx = hw_counter->idx;
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
+        struct hw_perf_event *hwc = &event->hw;
+        int idx = hwc->idx;
+
+        if (hwc->state & PERF_HES_STOPPED)
+                return;
 
         if (unlikely(!pmu_is_valid_counter(cci_pmu, idx))) {
                 dev_err(&cci_pmu->plat_device->dev, "Invalid CCI PMU counter %d\n", idx);
                 return;
         }
 
+        /*
+         * We always reprogram the counter, so ignore PERF_EF_UPDATE. See
+         * cci_pmu_start()
+         */
         pmu_disable_counter(idx);
+        pmu_event_update(event);
+        hwc->state |= PERF_HES_STOPPED | PERF_HES_UPTODATE;
 }
 
-static void pmu_start(struct arm_pmu *cci_pmu)
+static int cci_pmu_add(struct perf_event *event, int flags)
 {
-        u32 val;
-        unsigned long flags;
-        struct pmu_hw_events *events = cci_pmu->get_hw_events();
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
+        struct cci_pmu_hw_events *hw_events = &cci_pmu->hw_events;
+        struct hw_perf_event *hwc = &event->hw;
+        int idx;
+        int err = 0;
 
-        raw_spin_lock_irqsave(&events->pmu_lock, flags);
+        perf_pmu_disable(event->pmu);
 
-        /* Enable all the PMU counters. */
-        val = readl_relaxed(cci_ctrl_base + CCI_PMCR) | CCI_PMCR_CEN;
-        writel(val, cci_ctrl_base + CCI_PMCR);
+        /* If we don't have a space for the counter then finish early. */
+        idx = pmu_get_event_idx(hw_events, event);
+        if (idx < 0) {
+                err = idx;
+                goto out;
+        }
 
-        raw_spin_unlock_irqrestore(&events->pmu_lock, flags);
+        event->hw.idx = idx;
+        hw_events->events[idx] = event;
+
+        hwc->state = PERF_HES_STOPPED | PERF_HES_UPTODATE;
+        if (flags & PERF_EF_START)
+                cci_pmu_start(event, PERF_EF_RELOAD);
+
+        /* Propagate our changes to the userspace mapping. */
+        perf_event_update_userpage(event);
+
+out:
+        perf_pmu_enable(event->pmu);
+        return err;
 }
 
-static void pmu_stop(struct arm_pmu *cci_pmu)
+static void cci_pmu_del(struct perf_event *event, int flags)
 {
-        u32 val;
-        unsigned long flags;
-        struct pmu_hw_events *events = cci_pmu->get_hw_events();
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
+        struct cci_pmu_hw_events *hw_events = &cci_pmu->hw_events;
+        struct hw_perf_event *hwc = &event->hw;
+        int idx = hwc->idx;
 
-        raw_spin_lock_irqsave(&events->pmu_lock, flags);
+        cci_pmu_stop(event, PERF_EF_UPDATE);
+        hw_events->events[idx] = NULL;
+        clear_bit(idx, hw_events->used_mask);
 
-        /* Disable all the PMU counters. */
-        val = readl_relaxed(cci_ctrl_base + CCI_PMCR) & ~CCI_PMCR_CEN;
-        writel(val, cci_ctrl_base + CCI_PMCR);
+        perf_event_update_userpage(event);
+}
 
-        raw_spin_unlock_irqrestore(&events->pmu_lock, flags);
+static int
+validate_event(struct cci_pmu_hw_events *hw_events,
+               struct perf_event *event)
+{
+        if (is_software_event(event))
+                return 1;
+
+        if (event->state < PERF_EVENT_STATE_OFF)
+                return 1;
+
+        if (event->state == PERF_EVENT_STATE_OFF && !event->attr.enable_on_exec)
+                return 1;
+
+        return pmu_get_event_idx(hw_events, event) >= 0;
 }
 
-static u32 pmu_read_counter(struct perf_event *event)
+static int
+validate_group(struct perf_event *event)
 {
-        struct arm_pmu *cci_pmu = to_arm_pmu(event->pmu);
-        struct hw_perf_event *hw_counter = &event->hw;
-        int idx = hw_counter->idx;
-        u32 value;
+        struct perf_event *sibling, *leader = event->group_leader;
+        struct cci_pmu_hw_events fake_pmu = {
+                /*
+                 * Initialise the fake PMU. We only need to populate the
+                 * used_mask for the purposes of validation.
+                 */
+                .used_mask = CPU_BITS_NONE,
+        };
 
-        if (unlikely(!pmu_is_valid_counter(cci_pmu, idx))) {
-                dev_err(&cci_pmu->plat_device->dev, "Invalid CCI PMU counter %d\n", idx);
-                return 0;
+        if (!validate_event(&fake_pmu, leader))
+                return -EINVAL;
+
+        list_for_each_entry(sibling, &leader->sibling_list, group_entry) {
+                if (!validate_event(&fake_pmu, sibling))
+                        return -EINVAL;
         }
-        value = pmu_read_register(idx, CCI_PMU_CNTR);
 
-        return value;
+        if (!validate_event(&fake_pmu, event))
+                return -EINVAL;
+
+        return 0;
 }
 
-static void pmu_write_counter(struct perf_event *event, u32 value)
+static int
+__hw_perf_event_init(struct perf_event *event)
 {
-        struct arm_pmu *cci_pmu = to_arm_pmu(event->pmu);
-        struct hw_perf_event *hw_counter = &event->hw;
-        int idx = hw_counter->idx;
+        struct hw_perf_event *hwc = &event->hw;
+        int mapping;
 
-        if (unlikely(!pmu_is_valid_counter(cci_pmu, idx)))
-                dev_err(&cci_pmu->plat_device->dev, "Invalid CCI PMU counter %d\n", idx);
-        else
-                pmu_write_register(value, idx, CCI_PMU_CNTR);
+        mapping = pmu_map_event(event);
+
+        if (mapping < 0) {
+                pr_debug("event %x:%llx not supported\n", event->attr.type,
+                         event->attr.config);
+                return mapping;
+        }
+
+        /*
+         * We don't assign an index until we actually place the event onto
+         * hardware. Use -1 to signify that we haven't decided where to put it
+         * yet.
+         */
+        hwc->idx                = -1;
+        hwc->config_base        = 0;
+        hwc->config             = 0;
+        hwc->event_base         = 0;
+
+        /*
+         * Store the event encoding into the config_base field.
+         */
+        hwc->config_base            |= (unsigned long)mapping;
+
+        /*
+         * Limit the sample_period to half of the counter width. That way, the
+         * new counter value is far less likely to overtake the previous one
+         * unless you have some serious IRQ latency issues.
+         */
+        hwc->sample_period  = CCI_PMU_CNTR_MASK >> 1;
+        hwc->last_period    = hwc->sample_period;
+        local64_set(&hwc->period_left, hwc->sample_period);
+
+        if (event->group_leader != event) {
+                if (validate_group(event) != 0)
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int cci_pmu_event_init(struct perf_event *event)
+{
+        struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);
+        atomic_t *active_events = &cci_pmu->active_events;
+        int err = 0;
+        int cpu;
+
+        if (event->attr.type != event->pmu->type)
+                return -ENOENT;
+
+        /* Shared by all CPUs, no meaningful state to sample */
+        if (is_sampling_event(event) || event->attach_state & PERF_ATTACH_TASK)
+                return -EOPNOTSUPP;
+
+        /* We have no filtering of any kind */
+        if (event->attr.exclude_user    ||
+            event->attr.exclude_kernel  ||
+            event->attr.exclude_hv      ||
+            event->attr.exclude_idle    ||
+            event->attr.exclude_host    ||
+            event->attr.exclude_guest)
+                return -EINVAL;
+
+        /*
+         * Following the example set by other "uncore" PMUs, we accept any CPU
+         * and rewrite its affinity dynamically rather than having perf core
+         * handle cpu == -1 and pid == -1 for this case.
+         *
+         * The perf core will pin online CPUs for the duration of this call and
+         * the event being installed into its context, so the PMU's CPU can't
+         * change under our feet.
+         */
+        cpu = cpumask_first(&cci_pmu->cpus);
+        if (event->cpu < 0 || cpu < 0)
+                return -EINVAL;
+        event->cpu = cpu;
+
+        event->destroy = hw_perf_event_destroy;
+        if (!atomic_inc_not_zero(active_events)) {
+                mutex_lock(&cci_pmu->reserve_mutex);
+                if (atomic_read(active_events) == 0)
+                        err = cci_pmu_get_hw(cci_pmu);
+                if (!err)
+                        atomic_inc(active_events);
+                mutex_unlock(&cci_pmu->reserve_mutex);
+        }
+        if (err)
+                return err;
+
+        err = __hw_perf_event_init(event);
+        if (err)
+                hw_perf_event_destroy(event);
+
+        return err;
 }
 
-static int cci_pmu_init(struct arm_pmu *cci_pmu, struct platform_device *pdev)
+static ssize_t pmu_attr_cpumask_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
 {
-        *cci_pmu = (struct arm_pmu){
-                .name             = pmu_names[probe_cci_revision()],
-                .max_period       = (1LLU << 32) - 1,
-                .get_hw_events    = pmu_get_hw_events,
-                .get_event_idx    = pmu_get_event_idx,
-                .map_event        = pmu_map_event,
-                .request_irq      = pmu_request_irq,
-                .handle_irq       = pmu_handle_irq,
-                .free_irq         = pmu_free_irq,
-                .enable           = pmu_enable_event,
-                .disable          = pmu_disable_event,
-                .start            = pmu_start,
-                .stop             = pmu_stop,
-                .read_counter     = pmu_read_counter,
-                .write_counter    = pmu_write_counter,
+        int n = cpulist_scnprintf(buf, PAGE_SIZE - 2, &pmu->cpus);
+
+        buf[n++] = '\n';
+        buf[n] = '\0';
+        return n;
+}
+
+static DEVICE_ATTR(cpumask, S_IRUGO, pmu_attr_cpumask_show, NULL);
+
+static struct attribute *pmu_attrs[] = {
+        &dev_attr_cpumask.attr,
+        NULL,
+};
+
+static struct attribute_group pmu_attr_group = {
+        .attrs = pmu_attrs,
+};
+
+static const struct attribute_group *pmu_attr_groups[] = {
+        &pmu_attr_group,
+        NULL
+};
+
+static int cci_pmu_init(struct cci_pmu *cci_pmu, struct platform_device *pdev)
+{
+        char *name = pmu_names[probe_cci_revision()];
+        cci_pmu->pmu = (struct pmu) {
+                .name           = pmu_names[probe_cci_revision()],
+                .task_ctx_nr    = perf_invalid_context,
+                .pmu_enable     = cci_pmu_enable,
+                .pmu_disable    = cci_pmu_disable,
+                .event_init     = cci_pmu_event_init,
+                .add            = cci_pmu_add,
+                .del            = cci_pmu_del,
+                .start          = cci_pmu_start,
+                .stop           = cci_pmu_stop,
+                .read           = pmu_read,
+                .attr_groups    = pmu_attr_groups,
         };
 
         cci_pmu->plat_device = pdev;
         cci_pmu->num_events = pmu_get_max_counters();
 
-        return armpmu_register(cci_pmu, -1);
+        return perf_pmu_register(&cci_pmu->pmu, name, -1);
 }
 
+static int cci_pmu_cpu_notifier(struct notifier_block *self,
+                                unsigned long action, void *hcpu)
+{
+        unsigned int cpu = (long)hcpu;
+        unsigned int target;
+
+        switch (action & ~CPU_TASKS_FROZEN) {
+        case CPU_DOWN_PREPARE:
+                if (!cpumask_test_and_clear_cpu(cpu, &pmu->cpus))
+                        break;
+                target = cpumask_any_but(cpu_online_mask, cpu);
+                if (target < 0) // UP, last CPU
+                        break;
+                /*
+                 * TODO: migrate context once core races on event->ctx have
+                 * been fixed.
+                 */
+                cpumask_set_cpu(target, &pmu->cpus);
+        default:
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+
+static struct notifier_block cci_pmu_cpu_nb = {
+        .notifier_call  = cci_pmu_cpu_notifier,
+        /*
+         * to migrate uncore events, our notifier should be executed
+         * before perf core's notifier.
+         */
+        .priority       = CPU_PRI_PERF + 1,
+};
+
 static const struct of_device_id arm_cci_pmu_matches[] = {
         {
                 .compatible = "arm,cci-400-pmu",
@@ -604,15 +939,16 @@ static int cci_pmu_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        pmu->cci_pmu = devm_kzalloc(&pdev->dev, sizeof(*(pmu->cci_pmu)), GFP_KERNEL);
-        if (!pmu->cci_pmu)
-                return -ENOMEM;
-
-        pmu->hw_events.events = pmu->events;
-        pmu->hw_events.used_mask = pmu->used_mask;
         raw_spin_lock_init(&pmu->hw_events.pmu_lock);
+        mutex_init(&pmu->reserve_mutex);
+        atomic_set(&pmu->active_events, 0);
+        cpumask_set_cpu(smp_processor_id(), &pmu->cpus);
+
+        ret = register_cpu_notifier(&cci_pmu_cpu_nb);
+        if (ret)
+                return ret;
 
-        ret = cci_pmu_init(pmu->cci_pmu, pdev);
+        ret = cci_pmu_init(pmu, pdev);
         if (ret)
                 return ret;
 
diff --git a/drivers/bus/brcmstb_gisb.c b/drivers/bus/brcmstb_gisb.c
index f2cd6a2d40b4..46de8dc39eb4 100644
--- a/drivers/bus/brcmstb_gisb.c
+++ b/drivers/bus/brcmstb_gisb.c
@@ -23,35 +23,103 @@
 #include <linux/list.h>
 #include <linux/of.h>
 #include <linux/bitops.h>
+#include <linux/pm.h>
 
+#ifdef CONFIG_ARM
 #include <asm/bug.h>
 #include <asm/signal.h>
+#endif
 
-#define ARB_TIMER                       0x008
-#define ARB_ERR_CAP_CLR                 0x7e4
 #define  ARB_ERR_CAP_CLEAR              (1 << 0)
-#define ARB_ERR_CAP_HI_ADDR             0x7e8
-#define ARB_ERR_CAP_ADDR                0x7ec
-#define ARB_ERR_CAP_DATA                0x7f0
-#define ARB_ERR_CAP_STATUS              0x7f4
 #define  ARB_ERR_CAP_STATUS_TIMEOUT     (1 << 12)
 #define  ARB_ERR_CAP_STATUS_TEA         (1 << 11)
 #define  ARB_ERR_CAP_STATUS_BS_SHIFT    (1 << 2)
 #define  ARB_ERR_CAP_STATUS_BS_MASK     0x3c
 #define  ARB_ERR_CAP_STATUS_WRITE       (1 << 1)
 #define  ARB_ERR_CAP_STATUS_VALID       (1 << 0)
-#define ARB_ERR_CAP_MASTER              0x7f8
+
+enum {
+        ARB_TIMER,
+        ARB_ERR_CAP_CLR,
+        ARB_ERR_CAP_HI_ADDR,
+        ARB_ERR_CAP_ADDR,
+        ARB_ERR_CAP_DATA,
+        ARB_ERR_CAP_STATUS,
+        ARB_ERR_CAP_MASTER,
+};
+
+static const int gisb_offsets_bcm7038[] = {
+        [ARB_TIMER]             = 0x00c,
+        [ARB_ERR_CAP_CLR]       = 0x0c4,
+        [ARB_ERR_CAP_HI_ADDR]   = -1,
+        [ARB_ERR_CAP_ADDR]      = 0x0c8,
+        [ARB_ERR_CAP_DATA]      = 0x0cc,
+        [ARB_ERR_CAP_STATUS]    = 0x0d0,
+        [ARB_ERR_CAP_MASTER]    = -1,
+};
+
+static const int gisb_offsets_bcm7400[] = {
+        [ARB_TIMER]             = 0x00c,
+        [ARB_ERR_CAP_CLR]       = 0x0c8,
+        [ARB_ERR_CAP_HI_ADDR]   = -1,
+        [ARB_ERR_CAP_ADDR]      = 0x0cc,
+        [ARB_ERR_CAP_DATA]      = 0x0d0,
+        [ARB_ERR_CAP_STATUS]    = 0x0d4,
+        [ARB_ERR_CAP_MASTER]    = 0x0d8,
+};
+
+static const int gisb_offsets_bcm7435[] = {
+        [ARB_TIMER]             = 0x00c,
+        [ARB_ERR_CAP_CLR]       = 0x168,
+        [ARB_ERR_CAP_HI_ADDR]   = -1,
+        [ARB_ERR_CAP_ADDR]      = 0x16c,
+        [ARB_ERR_CAP_DATA]      = 0x170,
+        [ARB_ERR_CAP_STATUS]    = 0x174,
+        [ARB_ERR_CAP_MASTER]    = 0x178,
+};
+
+static const int gisb_offsets_bcm7445[] = {
+        [ARB_TIMER]             = 0x008,
+        [ARB_ERR_CAP_CLR]       = 0x7e4,
+        [ARB_ERR_CAP_HI_ADDR]   = 0x7e8,
+        [ARB_ERR_CAP_ADDR]      = 0x7ec,
+        [ARB_ERR_CAP_DATA]      = 0x7f0,
+        [ARB_ERR_CAP_STATUS]    = 0x7f4,
+        [ARB_ERR_CAP_MASTER]    = 0x7f8,
+};
 
 struct brcmstb_gisb_arb_device {
         void __iomem    *base;
+        const int       *gisb_offsets;
         struct mutex    lock;
         struct list_head next;
         u32 valid_mask;
         const char *master_names[sizeof(u32) * BITS_PER_BYTE];
+        u32 saved_timeout;
 };
 
 static LIST_HEAD(brcmstb_gisb_arb_device_list);
 
+static u32 gisb_read(struct brcmstb_gisb_arb_device *gdev, int reg)
+{
+        int offset = gdev->gisb_offsets[reg];
+
+        /* return 1 if the hardware doesn't have ARB_ERR_CAP_MASTER */
+        if (offset == -1)
+                return 1;
+
+        return ioread32(gdev->base + offset);
+}
+
+static void gisb_write(struct brcmstb_gisb_arb_device *gdev, u32 val, int reg)
+{
+        int offset = gdev->gisb_offsets[reg];
+
+        if (offset == -1)
+                return;
+        iowrite32(val, gdev->base + reg);
+}
+
 static ssize_t gisb_arb_get_timeout(struct device *dev,
                                     struct device_attribute *attr,
                                     char *buf)
@@ -61,7 +129,7 @@ static ssize_t gisb_arb_get_timeout(struct device *dev,
         u32 timeout;
 
         mutex_lock(&gdev->lock);
-        timeout = ioread32(gdev->base + ARB_TIMER);
+        timeout = gisb_read(gdev, ARB_TIMER);
         mutex_unlock(&gdev->lock);
 
         return sprintf(buf, "%d", timeout);
@@ -83,7 +151,7 @@ static ssize_t gisb_arb_set_timeout(struct device *dev,
                 return -EINVAL;
 
         mutex_lock(&gdev->lock);
-        iowrite32(val, gdev->base + ARB_TIMER);
+        gisb_write(gdev, val, ARB_TIMER);
         mutex_unlock(&gdev->lock);
 
         return count;
@@ -110,18 +178,18 @@ static int brcmstb_gisb_arb_decode_addr(struct brcmstb_gisb_arb_device *gdev,
         const char *m_name;
         char m_fmt[11];
 
-        cap_status = ioread32(gdev->base + ARB_ERR_CAP_STATUS);
+        cap_status = gisb_read(gdev, ARB_ERR_CAP_STATUS);
 
         /* Invalid captured address, bail out */
         if (!(cap_status & ARB_ERR_CAP_STATUS_VALID))
                 return 1;
 
         /* Read the address and master */
-        arb_addr = ioread32(gdev->base + ARB_ERR_CAP_ADDR) & 0xffffffff;
+        arb_addr = gisb_read(gdev, ARB_ERR_CAP_ADDR) & 0xffffffff;
 #if (IS_ENABLED(CONFIG_PHYS_ADDR_T_64BIT))
-        arb_addr |= (u64)ioread32(gdev->base + ARB_ERR_CAP_HI_ADDR) << 32;
+        arb_addr |= (u64)gisb_read(gdev, ARB_ERR_CAP_HI_ADDR) << 32;
 #endif
-        master = ioread32(gdev->base + ARB_ERR_CAP_MASTER);
+        master = gisb_read(gdev, ARB_ERR_CAP_MASTER);
 
         m_name = brcmstb_gisb_master_to_str(gdev, master);
         if (!m_name) {
@@ -136,11 +204,12 @@ static int brcmstb_gisb_arb_decode_addr(struct brcmstb_gisb_arb_device *gdev,
                 m_name);
 
         /* clear the GISB error */
-        iowrite32(ARB_ERR_CAP_CLEAR, gdev->base + ARB_ERR_CAP_CLR);
+        gisb_write(gdev, ARB_ERR_CAP_CLEAR, ARB_ERR_CAP_CLR);
 
         return 0;
 }
 
+#ifdef CONFIG_ARM
 static int brcmstb_bus_error_handler(unsigned long addr, unsigned int fsr,
                                      struct pt_regs *regs)
 {
@@ -159,12 +228,7 @@ static int brcmstb_bus_error_handler(unsigned long addr, unsigned int fsr,
 
         return ret;
 }
-
-void __init brcmstb_hook_fault_code(void)
-{
-        hook_fault_code(22, brcmstb_bus_error_handler, SIGBUS, 0,
-                        "imprecise external abort");
-}
+#endif
 
 static irqreturn_t brcmstb_gisb_timeout_handler(int irq, void *dev_id)
 {
@@ -192,10 +256,20 @@ static struct attribute_group gisb_arb_sysfs_attr_group = {
         .attrs = gisb_arb_sysfs_attrs,
 };
 
-static int brcmstb_gisb_arb_probe(struct platform_device *pdev)
+static const struct of_device_id brcmstb_gisb_arb_of_match[] = {
+        { .compatible = "brcm,gisb-arb",         .data = gisb_offsets_bcm7445 },
+        { .compatible = "brcm,bcm7445-gisb-arb", .data = gisb_offsets_bcm7445 },
+        { .compatible = "brcm,bcm7435-gisb-arb", .data = gisb_offsets_bcm7435 },
+        { .compatible = "brcm,bcm7400-gisb-arb", .data = gisb_offsets_bcm7400 },
+        { .compatible = "brcm,bcm7038-gisb-arb", .data = gisb_offsets_bcm7038 },
+        { },
+};
+
+static int __init brcmstb_gisb_arb_probe(struct platform_device *pdev)
 {
         struct device_node *dn = pdev->dev.of_node;
         struct brcmstb_gisb_arb_device *gdev;
+        const struct of_device_id *of_id;
         struct resource *r;
         int err, timeout_irq, tea_irq;
         unsigned int num_masters, j = 0;
@@ -216,6 +290,13 @@ static int brcmstb_gisb_arb_probe(struct platform_device *pdev)
         if (IS_ERR(gdev->base))
                 return PTR_ERR(gdev->base);
 
+        of_id = of_match_node(brcmstb_gisb_arb_of_match, dn);
+        if (!of_id) {
+                pr_err("failed to look up compatible string\n");
+                return -EINVAL;
+        }
+        gdev->gisb_offsets = of_id->data;
+
         err = devm_request_irq(&pdev->dev, timeout_irq,
                                 brcmstb_gisb_timeout_handler, 0, pdev->name,
                                 gdev);
@@ -261,29 +342,63 @@ static int brcmstb_gisb_arb_probe(struct platform_device *pdev)
 
         list_add_tail(&gdev->next, &brcmstb_gisb_arb_device_list);
 
+#ifdef CONFIG_ARM
+        hook_fault_code(22, brcmstb_bus_error_handler, SIGBUS, 0,
+                        "imprecise external abort");
+#endif
+
         dev_info(&pdev->dev, "registered mem: %p, irqs: %d, %d\n",
                         gdev->base, timeout_irq, tea_irq);
 
         return 0;
 }
 
-static const struct of_device_id brcmstb_gisb_arb_of_match[] = {
-        { .compatible = "brcm,gisb-arb" },
-        { },
+#ifdef CONFIG_PM_SLEEP
+static int brcmstb_gisb_arb_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev);
+
+        gdev->saved_timeout = gisb_read(gdev, ARB_TIMER);
+
+        return 0;
+}
+
+/* Make sure we provide the same timeout value that was configured before, and
+ * do this before the GISB timeout interrupt handler has any chance to run.
+ */
+static int brcmstb_gisb_arb_resume_noirq(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev);
+
+        gisb_write(gdev, gdev->saved_timeout, ARB_TIMER);
+
+        return 0;
+}
+#else
+#define brcmstb_gisb_arb_suspend       NULL
+#define brcmstb_gisb_arb_resume_noirq  NULL
+#endif
+
+static const struct dev_pm_ops brcmstb_gisb_arb_pm_ops = {
+        .suspend        = brcmstb_gisb_arb_suspend,
+        .resume_noirq   = brcmstb_gisb_arb_resume_noirq,
 };
 
 static struct platform_driver brcmstb_gisb_arb_driver = {
-        .probe  = brcmstb_gisb_arb_probe,
         .driver = {
                 .name   = "brcm-gisb-arb",
                 .owner  = THIS_MODULE,
                 .of_match_table = brcmstb_gisb_arb_of_match,
+                .pm     = &brcmstb_gisb_arb_pm_ops,
         },
 };
 
 static int __init brcm_gisb_driver_init(void)
 {
-        return platform_driver_register(&brcmstb_gisb_arb_driver);
+        return platform_driver_probe(&brcmstb_gisb_arb_driver,
+                                     brcmstb_gisb_arb_probe);
 }
 
 module_init(brcm_gisb_driver_init);
diff --git a/drivers/bus/mvebu-mbus.c b/drivers/bus/mvebu-mbus.c
index 26c3779d871d..eb7682dc123b 100644
--- a/drivers/bus/mvebu-mbus.c
+++ b/drivers/bus/mvebu-mbus.c
@@ -57,6 +57,7 @@
 #include <linux/of_address.h>
 #include <linux/debugfs.h>
 #include <linux/log2.h>
+#include <linux/syscore_ops.h>
 
 /*
  * DDR target is the same on all platforms.
@@ -94,20 +95,42 @@
 
 #define DOVE_DDR_BASE_CS_OFF(n) ((n) << 4)
 
+/* Relative to mbusbridge_base */
+#define MBUS_BRIDGE_CTRL_OFF    0x0
+#define MBUS_BRIDGE_BASE_OFF    0x4
+
+/* Maximum number of windows, for all known platforms */
+#define MBUS_WINS_MAX           20
+
 struct mvebu_mbus_state;
 
 struct mvebu_mbus_soc_data {
         unsigned int num_wins;
         unsigned int num_remappable_wins;
+        bool has_mbus_bridge;
         unsigned int (*win_cfg_offset)(const int win);
         void (*setup_cpu_target)(struct mvebu_mbus_state *s);
+        int (*save_cpu_target)(struct mvebu_mbus_state *s,
+                               u32 *store_addr);
         int (*show_cpu_target)(struct mvebu_mbus_state *s,
                                struct seq_file *seq, void *v);
 };
 
+/*
+ * Used to store the state of one MBus window accross suspend/resume.
+ */
+struct mvebu_mbus_win_data {
+        u32 ctrl;
+        u32 base;
+        u32 remap_lo;
+        u32 remap_hi;
+};
+
 struct mvebu_mbus_state {
         void __iomem *mbuswins_base;
         void __iomem *sdramwins_base;
+        void __iomem *mbusbridge_base;
+        phys_addr_t sdramwins_phys_base;
         struct dentry *debugfs_root;
         struct dentry *debugfs_sdram;
         struct dentry *debugfs_devs;
@@ -115,6 +138,11 @@ struct mvebu_mbus_state {
         struct resource pcie_io_aperture;
         const struct mvebu_mbus_soc_data *soc;
         int hw_io_coherency;
+
+        /* Used during suspend/resume */
+        u32 mbus_bridge_ctrl;
+        u32 mbus_bridge_base;
+        struct mvebu_mbus_win_data wins[MBUS_WINS_MAX];
 };
 
 static struct mvebu_mbus_state mbus_state;
@@ -516,6 +544,28 @@ mvebu_mbus_default_setup_cpu_target(struct mvebu_mbus_state *mbus)
         mvebu_mbus_dram_info.num_cs = cs;
 }
 
+static int
+mvebu_mbus_default_save_cpu_target(struct mvebu_mbus_state *mbus,
+                                   u32 *store_addr)
+{
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                u32 base = readl(mbus->sdramwins_base + DDR_BASE_CS_OFF(i));
+                u32 size = readl(mbus->sdramwins_base + DDR_SIZE_CS_OFF(i));
+
+                writel(mbus->sdramwins_phys_base + DDR_BASE_CS_OFF(i),
+                       store_addr++);
+                writel(base, store_addr++);
+                writel(mbus->sdramwins_phys_base + DDR_SIZE_CS_OFF(i),
+                       store_addr++);
+                writel(size, store_addr++);
+        }
+
+        /* We've written 16 words to the store address */
+        return 16;
+}
+
 static void __init
 mvebu_mbus_dove_setup_cpu_target(struct mvebu_mbus_state *mbus)
 {
@@ -546,10 +596,35 @@ mvebu_mbus_dove_setup_cpu_target(struct mvebu_mbus_state *mbus)
         mvebu_mbus_dram_info.num_cs = cs;
 }
 
+static int
+mvebu_mbus_dove_save_cpu_target(struct mvebu_mbus_state *mbus,
+                                u32 *store_addr)
+{
+        int i;
+
+        for (i = 0; i < 2; i++) {
+                u32 map = readl(mbus->sdramwins_base + DOVE_DDR_BASE_CS_OFF(i));
+
+                writel(mbus->sdramwins_phys_base + DOVE_DDR_BASE_CS_OFF(i),
+                       store_addr++);
+                writel(map, store_addr++);
+        }
+
+        /* We've written 4 words to the store address */
+        return 4;
+}
+
+int mvebu_mbus_save_cpu_target(u32 *store_addr)
+{
+        return mbus_state.soc->save_cpu_target(&mbus_state, store_addr);
+}
+
 static const struct mvebu_mbus_soc_data armada_370_xp_mbus_data = {
         .num_wins            = 20,
         .num_remappable_wins = 8,
+        .has_mbus_bridge     = true,
         .win_cfg_offset      = armada_370_xp_mbus_win_offset,
+        .save_cpu_target     = mvebu_mbus_default_save_cpu_target,
         .setup_cpu_target    = mvebu_mbus_default_setup_cpu_target,
         .show_cpu_target     = mvebu_sdram_debug_show_orion,
 };
@@ -558,6 +633,7 @@ static const struct mvebu_mbus_soc_data kirkwood_mbus_data = {
         .num_wins            = 8,
         .num_remappable_wins = 4,
         .win_cfg_offset      = orion_mbus_win_offset,
+        .save_cpu_target     = mvebu_mbus_default_save_cpu_target,
         .setup_cpu_target    = mvebu_mbus_default_setup_cpu_target,
         .show_cpu_target     = mvebu_sdram_debug_show_orion,
 };
@@ -566,6 +642,7 @@ static const struct mvebu_mbus_soc_data dove_mbus_data = {
         .num_wins            = 8,
         .num_remappable_wins = 4,
         .win_cfg_offset      = orion_mbus_win_offset,
+        .save_cpu_target     = mvebu_mbus_dove_save_cpu_target,
         .setup_cpu_target    = mvebu_mbus_dove_setup_cpu_target,
         .show_cpu_target     = mvebu_sdram_debug_show_dove,
 };
@@ -578,6 +655,7 @@ static const struct mvebu_mbus_soc_data orion5x_4win_mbus_data = {
         .num_wins            = 8,
         .num_remappable_wins = 4,
         .win_cfg_offset      = orion_mbus_win_offset,
+        .save_cpu_target     = mvebu_mbus_default_save_cpu_target,
         .setup_cpu_target    = mvebu_mbus_default_setup_cpu_target,
         .show_cpu_target     = mvebu_sdram_debug_show_orion,
 };
@@ -586,6 +664,7 @@ static const struct mvebu_mbus_soc_data orion5x_2win_mbus_data = {
         .num_wins            = 8,
         .num_remappable_wins = 2,
         .win_cfg_offset      = orion_mbus_win_offset,
+        .save_cpu_target     = mvebu_mbus_default_save_cpu_target,
         .setup_cpu_target    = mvebu_mbus_default_setup_cpu_target,
         .show_cpu_target     = mvebu_sdram_debug_show_orion,
 };
@@ -594,6 +673,7 @@ static const struct mvebu_mbus_soc_data mv78xx0_mbus_data = {
         .num_wins            = 14,
         .num_remappable_wins = 8,
         .win_cfg_offset      = mv78xx0_mbus_win_offset,
+        .save_cpu_target     = mvebu_mbus_default_save_cpu_target,
         .setup_cpu_target    = mvebu_mbus_default_setup_cpu_target,
         .show_cpu_target     = mvebu_sdram_debug_show_orion,
 };
@@ -698,11 +778,73 @@ static __init int mvebu_mbus_debugfs_init(void)
 }
 fs_initcall(mvebu_mbus_debugfs_init);
 
+static int mvebu_mbus_suspend(void)
+{
+        struct mvebu_mbus_state *s = &mbus_state;
+        int win;
+
+        if (!s->mbusbridge_base)
+                return -ENODEV;
+
+        for (win = 0; win < s->soc->num_wins; win++) {
+                void __iomem *addr = s->mbuswins_base +
+                        s->soc->win_cfg_offset(win);
+
+                s->wins[win].base = readl(addr + WIN_BASE_OFF);
+                s->wins[win].ctrl = readl(addr + WIN_CTRL_OFF);
+
+                if (win >= s->soc->num_remappable_wins)
+                        continue;
+
+                s->wins[win].remap_lo = readl(addr + WIN_REMAP_LO_OFF);
+                s->wins[win].remap_hi = readl(addr + WIN_REMAP_HI_OFF);
+        }
+
+        s->mbus_bridge_ctrl = readl(s->mbusbridge_base +
+                                    MBUS_BRIDGE_CTRL_OFF);
+        s->mbus_bridge_base = readl(s->mbusbridge_base +
+                                    MBUS_BRIDGE_BASE_OFF);
+
+        return 0;
+}
+
+static void mvebu_mbus_resume(void)
+{
+        struct mvebu_mbus_state *s = &mbus_state;
+        int win;
+
+        writel(s->mbus_bridge_ctrl,
+               s->mbusbridge_base + MBUS_BRIDGE_CTRL_OFF);
+        writel(s->mbus_bridge_base,
+               s->mbusbridge_base + MBUS_BRIDGE_BASE_OFF);
+
+        for (win = 0; win < s->soc->num_wins; win++) {
+                void __iomem *addr = s->mbuswins_base +
+                        s->soc->win_cfg_offset(win);
+
+                writel(s->wins[win].base, addr + WIN_BASE_OFF);
+                writel(s->wins[win].ctrl, addr + WIN_CTRL_OFF);
+
+                if (win >= s->soc->num_remappable_wins)
+                        continue;
+
+                writel(s->wins[win].remap_lo, addr + WIN_REMAP_LO_OFF);
+                writel(s->wins[win].remap_hi, addr + WIN_REMAP_HI_OFF);
+        }
+}
+
+struct syscore_ops mvebu_mbus_syscore_ops = {
+        .suspend        = mvebu_mbus_suspend,
+        .resume         = mvebu_mbus_resume,
+};
+
 static int __init mvebu_mbus_common_init(struct mvebu_mbus_state *mbus,
                                          phys_addr_t mbuswins_phys_base,
                                          size_t mbuswins_size,
                                          phys_addr_t sdramwins_phys_base,
-                                         size_t sdramwins_size)
+                                         size_t sdramwins_size,
+                                         phys_addr_t mbusbridge_phys_base,
+                                         size_t mbusbridge_size)
 {
         int win;
 
@@ -716,11 +858,26 @@ static int __init mvebu_mbus_common_init(struct mvebu_mbus_state *mbus,
                 return -ENOMEM;
         }
 
+        mbus->sdramwins_phys_base = sdramwins_phys_base;
+
+        if (mbusbridge_phys_base) {
+                mbus->mbusbridge_base = ioremap(mbusbridge_phys_base,
+                                                mbusbridge_size);
+                if (!mbus->mbusbridge_base) {
+                        iounmap(mbus->sdramwins_base);
+                        iounmap(mbus->mbuswins_base);
+                        return -ENOMEM;
+                }
+        } else
+                mbus->mbusbridge_base = NULL;
+
         for (win = 0; win < mbus->soc->num_wins; win++)
                 mvebu_mbus_disable_window(mbus, win);
 
         mbus->soc->setup_cpu_target(mbus);
 
+        register_syscore_ops(&mvebu_mbus_syscore_ops);
+
         return 0;
 }
 
@@ -746,7 +903,7 @@ int __init mvebu_mbus_init(const char *soc, phys_addr_t mbuswins_phys_base,
                         mbuswins_phys_base,
                         mbuswins_size,
                         sdramwins_phys_base,
-                        sdramwins_size);
+                        sdramwins_size, 0, 0);
 }
 
 #ifdef CONFIG_OF
@@ -887,7 +1044,7 @@ static void __init mvebu_mbus_get_pcie_resources(struct device_node *np,
 
 int __init mvebu_mbus_dt_init(bool is_coherent)
 {
-        struct resource mbuswins_res, sdramwins_res;
+        struct resource mbuswins_res, sdramwins_res, mbusbridge_res;
         struct device_node *np, *controller;
         const struct of_device_id *of_id;
         const __be32 *prop;
@@ -923,6 +1080,19 @@ int __init mvebu_mbus_dt_init(bool is_coherent)
                 return -EINVAL;
         }
 
+        /*
+         * Set the resource to 0 so that it can be left unmapped by
+         * mvebu_mbus_common_init() if the DT doesn't carry the
+         * necessary information. This is needed to preserve backward
+         * compatibility.
+         */
+        memset(&mbusbridge_res, 0, sizeof(mbusbridge_res));
+
+        if (mbus_state.soc->has_mbus_bridge) {
+                if (of_address_to_resource(controller, 2, &mbusbridge_res))
+                        pr_warn(FW_WARN "deprecated mbus-mvebu Device Tree, suspend/resume will not work\n");
+        }
+
         mbus_state.hw_io_coherency = is_coherent;
 
         /* Get optional pcie-{mem,io}-aperture properties */
@@ -933,7 +1103,9 @@ int __init mvebu_mbus_dt_init(bool is_coherent)
                                      mbuswins_res.start,
                                      resource_size(&mbuswins_res),
                                      sdramwins_res.start,
-                                     resource_size(&sdramwins_res));
+                                     resource_size(&sdramwins_res),
+                                     mbusbridge_res.start,
+                                     resource_size(&mbusbridge_res));
         if (ret)
                 return ret;
 
diff --git a/drivers/bus/omap_l3_noc.c b/drivers/bus/omap_l3_noc.c
index 531ae591783b..17d86595951c 100644
--- a/drivers/bus/omap_l3_noc.c
+++ b/drivers/bus/omap_l3_noc.c
@@ -222,10 +222,14 @@ static irqreturn_t l3_interrupt_handler(int irq, void *_l3)
                         }
 
                         /* Error found so break the for loop */
-                        break;
+                        return IRQ_HANDLED;
                 }
         }
-        return IRQ_HANDLED;
+
+        dev_err(l3->dev, "L3 %s IRQ not handled!!\n",
+                inttype ? "debug" : "application");
+
+        return IRQ_NONE;
 }
 
 static const struct of_device_id l3_noc_match[] = {
@@ -296,11 +300,66 @@ static int omap_l3_probe(struct platform_device *pdev)
         return ret;
 }
 
+#ifdef  CONFIG_PM
+
+/**
+ * l3_resume_noirq() - resume function for l3_noc
+ * @dev:        pointer to l3_noc device structure
+ *
+ * We only have the resume handler only since we
+ * have already maintained the delta register
+ * configuration as part of configuring the system
+ */
+static int l3_resume_noirq(struct device *dev)
+{
+        struct omap_l3 *l3 = dev_get_drvdata(dev);
+        int i;
+        struct l3_flagmux_data *flag_mux;
+        void __iomem *base, *mask_regx = NULL;
+        u32 mask_val;
+
+        for (i = 0; i < l3->num_modules; i++) {
+                base = l3->l3_base[i];
+                flag_mux = l3->l3_flagmux[i];
+                if (!flag_mux->mask_app_bits && !flag_mux->mask_dbg_bits)
+                        continue;
+
+                mask_regx = base + flag_mux->offset + L3_FLAGMUX_MASK0 +
+                           (L3_APPLICATION_ERROR << 3);
+                mask_val = readl_relaxed(mask_regx);
+                mask_val &= ~(flag_mux->mask_app_bits);
+
+                writel_relaxed(mask_val, mask_regx);
+                mask_regx = base + flag_mux->offset + L3_FLAGMUX_MASK0 +
+                           (L3_DEBUG_ERROR << 3);
+                mask_val = readl_relaxed(mask_regx);
+                mask_val &= ~(flag_mux->mask_dbg_bits);
+
+                writel_relaxed(mask_val, mask_regx);
+        }
+
+        /* Dummy read to force OCP barrier */
+        if (mask_regx)
+                (void)readl(mask_regx);
+
+        return 0;
+}
+
+static const struct dev_pm_ops l3_dev_pm_ops = {
+        .resume_noirq           = l3_resume_noirq,
+};
+
+#define L3_DEV_PM_OPS (&l3_dev_pm_ops)
+#else
+#define L3_DEV_PM_OPS NULL
+#endif
+
 static struct platform_driver omap_l3_driver = {
         .probe          = omap_l3_probe,
         .driver         = {
                 .name           = "omap_l3_noc",
                 .owner          = THIS_MODULE,
+                .pm             = L3_DEV_PM_OPS,
                 .of_match_table = of_match_ptr(l3_noc_match),
         },
 };
diff --git a/drivers/bus/omap_l3_smx.c b/drivers/bus/omap_l3_smx.c
index acc216491b8a..597fdaee7315 100644
--- a/drivers/bus/omap_l3_smx.c
+++ b/drivers/bus/omap_l3_smx.c
@@ -27,6 +27,10 @@
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+
 #include "omap_l3_smx.h"
 
 static inline u64 omap3_l3_readll(void __iomem *base, u16 reg)
@@ -211,7 +215,17 @@ static irqreturn_t omap3_l3_app_irq(int irq, void *_l3)
         return ret;
 }
 
-static int __init omap3_l3_probe(struct platform_device *pdev)
+#if IS_BUILTIN(CONFIG_OF)
+static const struct of_device_id omap3_l3_match[] = {
+        {
+                .compatible = "ti,omap3-l3-smx",
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(of, omap3_l3_match);
+#endif
+
+static int omap3_l3_probe(struct platform_device *pdev)
 {
         struct omap3_l3 *l3;
         struct resource *res;
@@ -265,7 +279,7 @@ err0:
         return ret;
 }
 
-static int __exit omap3_l3_remove(struct platform_device *pdev)
+static int omap3_l3_remove(struct platform_device *pdev)
 {
         struct omap3_l3         *l3 = platform_get_drvdata(pdev);
 
@@ -278,15 +292,17 @@ static int __exit omap3_l3_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver omap3_l3_driver = {
-        .remove         = __exit_p(omap3_l3_remove),
+        .probe          = omap3_l3_probe,
+        .remove         = omap3_l3_remove,
         .driver         = {
-        .name   = "omap_l3_smx",
+                .name   = "omap_l3_smx",
+                .of_match_table = of_match_ptr(omap3_l3_match),
         },
 };
 
 static int __init omap3_l3_init(void)
 {
-        return platform_driver_probe(&omap3_l3_driver, omap3_l3_probe);
+        return platform_driver_register(&omap3_l3_driver);
 }
 postcore_initcall_sync(omap3_l3_init);
 
diff --git a/drivers/char/hw_random/exynos-rng.c b/drivers/char/hw_random/exynos-rng.c
index 9f8277cc44b4..993efd7f6c7e 100644
--- a/drivers/char/hw_random/exynos-rng.c
+++ b/drivers/char/hw_random/exynos-rng.c
@@ -143,7 +143,7 @@ static int exynos_rng_remove(struct platform_device *pdev)
         return 0;
 }
 
-#if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM_RUNTIME)
+#ifdef CONFIG_PM
 static int exynos_rng_runtime_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 524b707894ef..4c58333b4257 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -84,9 +84,12 @@ static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 }
 #endif
 
-void __weak unxlate_dev_mem_ptr(unsigned long phys, void *addr)
+#ifndef unxlate_dev_mem_ptr
+#define unxlate_dev_mem_ptr unxlate_dev_mem_ptr
+void __weak unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
 {
 }
+#endif
 
 /*
  * This funcion reads the *physical* memory. The f_pos points directly to the
@@ -97,7 +100,7 @@ static ssize_t read_mem(struct file *file, char __user *buf,
 {
         phys_addr_t p = *ppos;
         ssize_t read, sz;
-        char *ptr;
+        void *ptr;
 
         if (p != *ppos)
                 return 0;
@@ -400,7 +403,7 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
                          * uncached, then it must also be accessed uncached
                          * by the kernel or data corruption may occur
                          */
-                        kbuf = xlate_dev_kmem_ptr((char *)p);
+                        kbuf = xlate_dev_kmem_ptr((void *)p);
 
                         if (copy_to_user(buf, kbuf, sz))
                                 return -EFAULT;
@@ -461,7 +464,7 @@ static ssize_t do_write_kmem(unsigned long p, const char __user *buf,
 #endif
 
         while (count > 0) {
-                char *ptr;
+                void *ptr;
 
                 sz = size_inside_page(p, count);
 
@@ -470,7 +473,7 @@ static ssize_t do_write_kmem(unsigned long p, const char __user *buf,
                  * it must also be accessed uncached by the kernel or data
                  * corruption may occur.
                  */
-                ptr = xlate_dev_kmem_ptr((char *)p);
+                ptr = xlate_dev_kmem_ptr((void *)p);
 
                 copied = copy_from_user(ptr, buf, sz);
                 if (copied) {
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index cf7a561fad7c..de03df9dd7c9 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -355,7 +355,7 @@ static inline bool use_multiport(struct ports_device *portdev)
          */
         if (!portdev->vdev)
                 return 0;
-        return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
+        return __virtio_test_bit(portdev->vdev, VIRTIO_CONSOLE_F_MULTIPORT);
 }
 
 static DEFINE_SPINLOCK(dma_bufs_lock);
@@ -566,9 +566,9 @@ static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
         if (!use_multiport(portdev))
                 return 0;
 
-        cpkt.id = port_id;
-        cpkt.event = event;
-        cpkt.value = value;
+        cpkt.id = cpu_to_virtio32(portdev->vdev, port_id);
+        cpkt.event = cpu_to_virtio16(portdev->vdev, event);
+        cpkt.value = cpu_to_virtio16(portdev->vdev, value);
 
         vq = portdev->c_ovq;
 
@@ -669,8 +669,8 @@ done:
  * Give out the data that's requested from the buffer that we have
  * queued up.
  */
-static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
-                            bool to_user)
+static ssize_t fill_readbuf(struct port *port, char __user *out_buf,
+                            size_t out_count, bool to_user)
 {
         struct port_buffer *buf;
         unsigned long flags;
@@ -688,7 +688,8 @@ static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
                 if (ret)
                         return -EFAULT;
         } else {
-                memcpy(out_buf, buf->buf + buf->offset, out_count);
+                memcpy((__force char *)out_buf, buf->buf + buf->offset,
+                       out_count);
         }
 
         buf->offset += out_count;
@@ -1162,7 +1163,7 @@ static int get_chars(u32 vtermno, char *buf, int count)
         /* If we don't have an input queue yet, we can't get input. */
         BUG_ON(!port->in_vq);
 
-        return fill_readbuf(port, buf, count, false);
+        return fill_readbuf(port, (__force char __user *)buf, count, false);
 }
 
 static void resize_console(struct port *port)
@@ -1602,7 +1603,8 @@ static void unplug_port(struct port *port)
 }
 
 /* Any private messages that the Host and Guest want to share */
-static void handle_control_message(struct ports_device *portdev,
+static void handle_control_message(struct virtio_device *vdev,
+                                   struct ports_device *portdev,
                                    struct port_buffer *buf)
 {
         struct virtio_console_control *cpkt;
@@ -1612,15 +1614,16 @@ static void handle_control_message(struct ports_device *portdev,
 
         cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
 
-        port = find_port_by_id(portdev, cpkt->id);
-        if (!port && cpkt->event != VIRTIO_CONSOLE_PORT_ADD) {
+        port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id));
+        if (!port &&
+            cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) {
                 /* No valid header at start of buffer.  Drop it. */
                 dev_dbg(&portdev->vdev->dev,
                         "Invalid index %u in control packet\n", cpkt->id);
                 return;
         }
 
-        switch (cpkt->event) {
+        switch (virtio16_to_cpu(vdev, cpkt->event)) {
         case VIRTIO_CONSOLE_PORT_ADD:
                 if (port) {
                         dev_dbg(&portdev->vdev->dev,
@@ -1628,13 +1631,15 @@ static void handle_control_message(struct ports_device *portdev,
                         send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
                         break;
                 }
-                if (cpkt->id >= portdev->config.max_nr_ports) {
+                if (virtio32_to_cpu(vdev, cpkt->id) >=
+                    portdev->config.max_nr_ports) {
                         dev_warn(&portdev->vdev->dev,
-                                "Request for adding port with out-of-bound id %u, max. supported id: %u\n",
+                                "Request for adding port with "
+                                "out-of-bound id %u, max. supported id: %u\n",
                                 cpkt->id, portdev->config.max_nr_ports - 1);
                         break;
                 }
-                add_port(portdev, cpkt->id);
+                add_port(portdev, virtio32_to_cpu(vdev, cpkt->id));
                 break;
         case VIRTIO_CONSOLE_PORT_REMOVE:
                 unplug_port(port);
@@ -1670,7 +1675,7 @@ static void handle_control_message(struct ports_device *portdev,
                 break;
         }
         case VIRTIO_CONSOLE_PORT_OPEN:
-                port->host_connected = cpkt->value;
+                port->host_connected = virtio16_to_cpu(vdev, cpkt->value);
                 wake_up_interruptible(&port->waitqueue);
                 /*
                  * If the host port got closed and the host had any
@@ -1752,7 +1757,7 @@ static void control_work_handler(struct work_struct *work)
                 buf->len = len;
                 buf->offset = 0;
 
-                handle_control_message(portdev, buf);
+                handle_control_message(vq->vdev, portdev, buf);
 
                 spin_lock(&portdev->c_ivq_lock);
                 if (add_inbuf(portdev->c_ivq, buf) < 0) {
diff --git a/drivers/clk/at91/clk-usb.c b/drivers/clk/at91/clk-usb.c
index 24b5b020753a..a23ac0c724f0 100644
--- a/drivers/clk/at91/clk-usb.c
+++ b/drivers/clk/at91/clk-usb.c
@@ -52,29 +52,26 @@ static unsigned long at91sam9x5_clk_usb_recalc_rate(struct clk_hw *hw,
 
         tmp = pmc_read(pmc, AT91_PMC_USB);
         usbdiv = (tmp & AT91_PMC_OHCIUSBDIV) >> SAM9X5_USB_DIV_SHIFT;
-        return parent_rate / (usbdiv + 1);
+
+        return DIV_ROUND_CLOSEST(parent_rate, (usbdiv + 1));
 }
 
 static long at91sam9x5_clk_usb_round_rate(struct clk_hw *hw, unsigned long rate,
                                           unsigned long *parent_rate)
 {
         unsigned long div;
-        unsigned long bestrate;
-        unsigned long tmp;
+
+        if (!rate)
+                return -EINVAL;
 
         if (rate >= *parent_rate)
                 return *parent_rate;
 
-        div = *parent_rate / rate;
-        if (div >= SAM9X5_USB_MAX_DIV)
-                return *parent_rate / (SAM9X5_USB_MAX_DIV + 1);
-
-        bestrate = *parent_rate / div;
-        tmp = *parent_rate / (div + 1);
-        if (bestrate - rate > rate - tmp)
-                bestrate = tmp;
+        div = DIV_ROUND_CLOSEST(*parent_rate, rate);
+        if (div > SAM9X5_USB_MAX_DIV + 1)
+                div = SAM9X5_USB_MAX_DIV + 1;
 
-        return bestrate;
+        return DIV_ROUND_CLOSEST(*parent_rate, div);
 }
 
 static int at91sam9x5_clk_usb_set_parent(struct clk_hw *hw, u8 index)
@@ -106,9 +103,13 @@ static int at91sam9x5_clk_usb_set_rate(struct clk_hw *hw, unsigned long rate,
         u32 tmp;
         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
         struct at91_pmc *pmc = usb->pmc;
-        unsigned long div = parent_rate / rate;
+        unsigned long div;
+
+        if (!rate)
+                return -EINVAL;
 
-        if (parent_rate % rate || div < 1 || div >= SAM9X5_USB_MAX_DIV)
+        div = DIV_ROUND_CLOSEST(parent_rate, rate);
+        if (div > SAM9X5_USB_MAX_DIV + 1 || !div)
                 return -EINVAL;
 
         tmp = pmc_read(pmc, AT91_PMC_USB) & ~AT91_PMC_OHCIUSBDIV;
@@ -253,7 +254,7 @@ static long at91rm9200_clk_usb_round_rate(struct clk_hw *hw, unsigned long rate,
 
                 tmp_parent_rate = rate * usb->divisors[i];
                 tmp_parent_rate = __clk_round_rate(parent, tmp_parent_rate);
-                tmprate = tmp_parent_rate / usb->divisors[i];
+                tmprate = DIV_ROUND_CLOSEST(tmp_parent_rate, usb->divisors[i]);
                 if (tmprate < rate)
                         tmpdiff = rate - tmprate;
                 else
@@ -281,10 +282,10 @@ static int at91rm9200_clk_usb_set_rate(struct clk_hw *hw, unsigned long rate,
         struct at91_pmc *pmc = usb->pmc;
         unsigned long div;
 
-        if (!rate || parent_rate % rate)
+        if (!rate)
                 return -EINVAL;
 
-        div = parent_rate / rate;
+        div = DIV_ROUND_CLOSEST(parent_rate, rate);
 
         for (i = 0; i < RM9200_USB_DIV_TAB_SIZE; i++) {
                 if (usb->divisors[i] == div) {
diff --git a/drivers/clk/clk-divider.c b/drivers/clk/clk-divider.c
index 18a9de29df0e..c0a842b335c5 100644
--- a/drivers/clk/clk-divider.c
+++ b/drivers/clk/clk-divider.c
@@ -263,6 +263,14 @@ static int clk_divider_bestdiv(struct clk_hw *hw, unsigned long rate,
         if (!rate)
                 rate = 1;
 
+        /* if read only, just return current value */
+        if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+                bestdiv = readl(divider->reg) >> divider->shift;
+                bestdiv &= div_mask(divider);
+                bestdiv = _get_div(divider, bestdiv);
+                return bestdiv;
+        }
+
         maxdiv = _get_maxdiv(divider);
 
         if (!(__clk_get_flags(hw->clk) & CLK_SET_RATE_PARENT)) {
@@ -361,11 +369,6 @@ const struct clk_ops clk_divider_ops = {
 };
 EXPORT_SYMBOL_GPL(clk_divider_ops);
 
-const struct clk_ops clk_divider_ro_ops = {
-        .recalc_rate = clk_divider_recalc_rate,
-};
-EXPORT_SYMBOL_GPL(clk_divider_ro_ops);
-
 static struct clk *_register_divider(struct device *dev, const char *name,
                 const char *parent_name, unsigned long flags,
                 void __iomem *reg, u8 shift, u8 width,
@@ -391,10 +394,7 @@ static struct clk *_register_divider(struct device *dev, const char *name,
         }
 
         init.name = name;
-        if (clk_divider_flags & CLK_DIVIDER_READ_ONLY)
-                init.ops = &clk_divider_ro_ops;
-        else
-                init.ops = &clk_divider_ops;
+        init.ops = &clk_divider_ops;
         init.flags = flags | CLK_IS_BASIC;
         init.parent_names = (parent_name ? &parent_name: NULL);
         init.num_parents = (parent_name ? 1 : 0);
diff --git a/drivers/clk/clk-s2mps11.c b/drivers/clk/clk-s2mps11.c
index b7797fb12e12..7bb13af8e214 100644
--- a/drivers/clk/clk-s2mps11.c
+++ b/drivers/clk/clk-s2mps11.c
@@ -23,6 +23,7 @@
 #include <linux/clk-provider.h>
 #include <linux/platform_device.h>
 #include <linux/mfd/samsung/s2mps11.h>
+#include <linux/mfd/samsung/s2mps13.h>
 #include <linux/mfd/samsung/s2mps14.h>
 #include <linux/mfd/samsung/s5m8767.h>
 #include <linux/mfd/samsung/core.h>
@@ -120,6 +121,24 @@ static struct clk_init_data s2mps11_clks_init[S2MPS11_CLKS_NUM] = {
         },
 };
 
+static struct clk_init_data s2mps13_clks_init[S2MPS11_CLKS_NUM] = {
+        [S2MPS11_CLK_AP] = {
+                .name = "s2mps13_ap",
+                .ops = &s2mps11_clk_ops,
+                .flags = CLK_IS_ROOT,
+        },
+        [S2MPS11_CLK_CP] = {
+                .name = "s2mps13_cp",
+                .ops = &s2mps11_clk_ops,
+                .flags = CLK_IS_ROOT,
+        },
+        [S2MPS11_CLK_BT] = {
+                .name = "s2mps13_bt",
+                .ops = &s2mps11_clk_ops,
+                .flags = CLK_IS_ROOT,
+        },
+};
+
 static struct clk_init_data s2mps14_clks_init[S2MPS11_CLKS_NUM] = {
         [S2MPS11_CLK_AP] = {
                 .name = "s2mps14_ap",
@@ -184,6 +203,10 @@ static int s2mps11_clk_probe(struct platform_device *pdev)
                 s2mps11_reg = S2MPS11_REG_RTC_CTRL;
                 clks_init = s2mps11_clks_init;
                 break;
+        case S2MPS13X:
+                s2mps11_reg = S2MPS13_REG_RTCCTRL;
+                clks_init = s2mps13_clks_init;
+                break;
         case S2MPS14X:
                 s2mps11_reg = S2MPS14_REG_RTCCTRL;
                 clks_init = s2mps14_clks_init;
@@ -279,6 +302,7 @@ static int s2mps11_clk_remove(struct platform_device *pdev)
 
 static const struct platform_device_id s2mps11_clk_id[] = {
         { "s2mps11-clk", S2MPS11X},
+        { "s2mps13-clk", S2MPS13X},
         { "s2mps14-clk", S2MPS14X},
         { "s5m8767-clk", S5M8767X},
         { },
diff --git a/drivers/clk/mvebu/common.c b/drivers/clk/mvebu/common.c
index b7fcb469c87a..0d4d1216f2dd 100644
--- a/drivers/clk/mvebu/common.c
+++ b/drivers/clk/mvebu/common.c
@@ -19,6 +19,7 @@
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
+#include <linux/syscore_ops.h>
 
 #include "common.h"
 
@@ -177,14 +178,17 @@ struct clk_gating_ctrl {
         spinlock_t *lock;
         struct clk **gates;
         int num_gates;
+        void __iomem *base;
+        u32 saved_reg;
 };
 
 #define to_clk_gate(_hw) container_of(_hw, struct clk_gate, hw)
 
+static struct clk_gating_ctrl *ctrl;
+
 static struct clk *clk_gating_get_src(
         struct of_phandle_args *clkspec, void *data)
 {
-        struct clk_gating_ctrl *ctrl = (struct clk_gating_ctrl *)data;
         int n;
 
         if (clkspec->args_count < 1)
@@ -199,15 +203,35 @@ static struct clk *clk_gating_get_src(
         return ERR_PTR(-ENODEV);
 }
 
+static int mvebu_clk_gating_suspend(void)
+{
+        ctrl->saved_reg = readl(ctrl->base);
+        return 0;
+}
+
+static void mvebu_clk_gating_resume(void)
+{
+        writel(ctrl->saved_reg, ctrl->base);
+}
+
+static struct syscore_ops clk_gate_syscore_ops = {
+        .suspend = mvebu_clk_gating_suspend,
+        .resume = mvebu_clk_gating_resume,
+};
+
 void __init mvebu_clk_gating_setup(struct device_node *np,
                                    const struct clk_gating_soc_desc *desc)
 {
-        struct clk_gating_ctrl *ctrl;
         struct clk *clk;
         void __iomem *base;
         const char *default_parent = NULL;
         int n;
 
+        if (ctrl) {
+                pr_err("mvebu-clk-gating: cannot instantiate more than one gatable clock device\n");
+                return;
+        }
+
         base = of_iomap(np, 0);
         if (WARN_ON(!base))
                 return;
@@ -225,6 +249,8 @@ void __init mvebu_clk_gating_setup(struct device_node *np,
         /* lock must already be initialized */
         ctrl->lock = &ctrl_gating_lock;
 
+        ctrl->base = base;
+
         /* Count, allocate, and register clock gates */
         for (n = 0; desc[n].name;)
                 n++;
@@ -246,6 +272,8 @@ void __init mvebu_clk_gating_setup(struct device_node *np,
 
         of_clk_add_provider(np, clk_gating_get_src, ctrl);
 
+        register_syscore_ops(&clk_gate_syscore_ops);
+
         return;
 gates_out:
         kfree(ctrl);
diff --git a/drivers/clk/pxa/clk-pxa27x.c b/drivers/clk/pxa/clk-pxa27x.c
index b345cc791e5d..88b9fe13fa44 100644
--- a/drivers/clk/pxa/clk-pxa27x.c
+++ b/drivers/clk/pxa/clk-pxa27x.c
@@ -322,7 +322,7 @@ static unsigned long clk_pxa27x_memory_get_rate(struct clk_hw *hw,
         unsigned long ccsr = CCSR;
 
         osc_forced = ccsr & (1 << CCCR_CPDIS_BIT);
-        a = cccr & CCCR_A_BIT;
+        a = cccr & (1 << CCCR_A_BIT);
         l  = ccsr & CCSR_L_MASK;
 
         if (osc_forced || a)
@@ -341,7 +341,7 @@ static u8 clk_pxa27x_memory_get_parent(struct clk_hw *hw)
         unsigned long ccsr = CCSR;
 
         osc_forced = ccsr & (1 << CCCR_CPDIS_BIT);
-        a = cccr & CCCR_A_BIT;
+        a = cccr & (1 << CCCR_A_BIT);
         if (osc_forced)
                 return PXA_MEM_13Mhz;
         if (a)
diff --git a/drivers/clk/qcom/mmcc-apq8084.c b/drivers/clk/qcom/mmcc-apq8084.c
index dab988ab8cf1..157139a5c1ca 100644
--- a/drivers/clk/qcom/mmcc-apq8084.c
+++ b/drivers/clk/qcom/mmcc-apq8084.c
@@ -3122,7 +3122,7 @@ static struct clk_regmap *mmcc_apq8084_clocks[] = {
         [ESC1_CLK_SRC] = &esc1_clk_src.clkr,
         [HDMI_CLK_SRC] = &hdmi_clk_src.clkr,
         [VSYNC_CLK_SRC] = &vsync_clk_src.clkr,
-        [RBCPR_CLK_SRC] = &rbcpr_clk_src.clkr,
+        [MMSS_RBCPR_CLK_SRC] = &rbcpr_clk_src.clkr,
         [RBBMTIMER_CLK_SRC] = &rbbmtimer_clk_src.clkr,
         [MAPLE_CLK_SRC] = &maple_clk_src.clkr,
         [VDP_CLK_SRC] = &vdp_clk_src.clkr,
diff --git a/drivers/clk/rockchip/clk.c b/drivers/clk/rockchip/clk.c
index 1e68bff481b8..880a266f0143 100644
--- a/drivers/clk/rockchip/clk.c
+++ b/drivers/clk/rockchip/clk.c
@@ -90,9 +90,7 @@ static struct clk *rockchip_clk_register_branch(const char *name,
                 div->width = div_width;
                 div->lock = lock;
                 div->table = div_table;
-                div_ops = (div_flags & CLK_DIVIDER_READ_ONLY)
-                                                ? &clk_divider_ro_ops
-                                                : &clk_divider_ops;
+                div_ops = &clk_divider_ops;
         }
 
         clk = clk_register_composite(NULL, name, parent_names, num_parents,
diff --git a/drivers/clk/samsung/clk-exynos5440.c b/drivers/clk/samsung/clk-exynos5440.c
index 00d1d00a41de..979e81389cdd 100644
--- a/drivers/clk/samsung/clk-exynos5440.c
+++ b/drivers/clk/samsung/clk-exynos5440.c
@@ -15,6 +15,8 @@
 #include <linux/clk-provider.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
 
 #include "clk.h"
 #include "clk-pll.h"
@@ -23,6 +25,8 @@
 #define CPU_CLK_STATUS          0xfc
 #define MISC_DOUT1              0x558
 
+static void __iomem *reg_base;
+
 /* parent clock name list */
 PNAME(mout_armclk_p)    = { "cplla", "cpllb" };
 PNAME(mout_spi_p)       = { "div125", "div200" };
@@ -89,10 +93,30 @@ static const struct of_device_id ext_clk_match[] __initconst = {
         {},
 };
 
+static int exynos5440_clk_restart_notify(struct notifier_block *this,
+                unsigned long code, void *unused)
+{
+        u32 val, status;
+
+        status = readl_relaxed(reg_base + 0xbc);
+        val = readl_relaxed(reg_base + 0xcc);
+        val = (val & 0xffff0000) | (status & 0xffff);
+        writel_relaxed(val, reg_base + 0xcc);
+
+        return NOTIFY_DONE;
+}
+
+/*
+ * Exynos5440 Clock restart notifier, handles restart functionality
+ */
+static struct notifier_block exynos5440_clk_restart_handler = {
+        .notifier_call = exynos5440_clk_restart_notify,
+        .priority = 128,
+};
+
 /* register exynos5440 clocks */
 static void __init exynos5440_clk_init(struct device_node *np)
 {
-        void __iomem *reg_base;
         struct samsung_clk_provider *ctx;
 
         reg_base = of_iomap(np, 0);
@@ -125,6 +149,9 @@ static void __init exynos5440_clk_init(struct device_node *np)
 
         samsung_clk_of_add_provider(np, ctx);
 
+        if (register_restart_handler(&exynos5440_clk_restart_handler))
+                pr_warn("exynos5440 clock can't register restart handler\n");
+
         pr_info("Exynos5440: arm_clk = %ldHz\n", _get_rate("arm_clk"));
         pr_info("exynos5440 clock initialization complete\n");
 }
diff --git a/drivers/clk/tegra/clk-divider.c b/drivers/clk/tegra/clk-divider.c
index 290f9c1a3749..59a5714dfe18 100644
--- a/drivers/clk/tegra/clk-divider.c
+++ b/drivers/clk/tegra/clk-divider.c
@@ -185,3 +185,16 @@ struct clk *tegra_clk_register_divider(const char *name,
 
         return clk;
 }
+
+static const struct clk_div_table mc_div_table[] = {
+        { .val = 0, .div = 2 },
+        { .val = 1, .div = 1 },
+        { .val = 0, .div = 0 },
+};
+
+struct clk *tegra_clk_register_mc(const char *name, const char *parent_name,
+                                  void __iomem *reg, spinlock_t *lock)
+{
+        return clk_register_divider_table(NULL, name, parent_name, 0, reg,
+                                          16, 1, 0, mc_div_table, lock);
+}
diff --git a/drivers/clk/tegra/clk-tegra114.c b/drivers/clk/tegra/clk-tegra114.c
index f760f31d05c4..0b03d2cf7264 100644
--- a/drivers/clk/tegra/clk-tegra114.c
+++ b/drivers/clk/tegra/clk-tegra114.c
@@ -173,6 +173,7 @@ static DEFINE_SPINLOCK(pll_d_lock);
 static DEFINE_SPINLOCK(pll_d2_lock);
 static DEFINE_SPINLOCK(pll_u_lock);
 static DEFINE_SPINLOCK(pll_re_lock);
+static DEFINE_SPINLOCK(emc_lock);
 
 static struct div_nmp pllxc_nmp = {
         .divm_shift = 0,
@@ -1228,7 +1229,11 @@ static __init void tegra114_periph_clk_init(void __iomem *clk_base,
                                ARRAY_SIZE(mux_pllmcp_clkm),
                                CLK_SET_RATE_NO_REPARENT,
                                clk_base + CLK_SOURCE_EMC,
-                               29, 3, 0, NULL);
+                               29, 3, 0, &emc_lock);
+
+        clk = tegra_clk_register_mc("mc", "emc_mux", clk_base + CLK_SOURCE_EMC,
+                                    &emc_lock);
+        clks[TEGRA114_CLK_MC] = clk;
 
         for (i = 0; i < ARRAY_SIZE(tegra_periph_clk_list); i++) {
                 data = &tegra_periph_clk_list[i];
diff --git a/drivers/clk/tegra/clk-tegra124.c b/drivers/clk/tegra/clk-tegra124.c
index e3a85842ce0c..f5f9baca7bb6 100644
--- a/drivers/clk/tegra/clk-tegra124.c
+++ b/drivers/clk/tegra/clk-tegra124.c
@@ -132,6 +132,7 @@ static DEFINE_SPINLOCK(pll_d2_lock);
 static DEFINE_SPINLOCK(pll_e_lock);
 static DEFINE_SPINLOCK(pll_re_lock);
 static DEFINE_SPINLOCK(pll_u_lock);
+static DEFINE_SPINLOCK(emc_lock);
 
 /* possible OSC frequencies in Hz */
 static unsigned long tegra124_input_freq[] = {
@@ -1127,7 +1128,11 @@ static __init void tegra124_periph_clk_init(void __iomem *clk_base,
         clk = clk_register_mux(NULL, "emc_mux", mux_pllmcp_clkm,
                                ARRAY_SIZE(mux_pllmcp_clkm), 0,
                                clk_base + CLK_SOURCE_EMC,
-                               29, 3, 0, NULL);
+                               29, 3, 0, &emc_lock);
+
+        clk = tegra_clk_register_mc("mc", "emc_mux", clk_base + CLK_SOURCE_EMC,
+                                    &emc_lock);
+        clks[TEGRA124_CLK_MC] = clk;
 
         /* cml0 */
         clk = clk_register_gate(NULL, "cml0", "pll_e", 0, clk_base + PLLE_AUX,
diff --git a/drivers/clk/tegra/clk-tegra20.c b/drivers/clk/tegra/clk-tegra20.c
index dace2b1b5ae6..41272dcc9e22 100644
--- a/drivers/clk/tegra/clk-tegra20.c
+++ b/drivers/clk/tegra/clk-tegra20.c
@@ -140,6 +140,8 @@ static struct cpu_clk_suspend_context {
 static void __iomem *clk_base;
 static void __iomem *pmc_base;
 
+static DEFINE_SPINLOCK(emc_lock);
+
 #define TEGRA_INIT_DATA_MUX(_name, _parents, _offset,   \
                             _clk_num, _gate_flags, _clk_id)     \
         TEGRA_INIT_DATA(_name, NULL, NULL, _parents, _offset,   \
@@ -819,11 +821,15 @@ static void __init tegra20_periph_clk_init(void)
                                ARRAY_SIZE(mux_pllmcp_clkm),
                                CLK_SET_RATE_NO_REPARENT,
                                clk_base + CLK_SOURCE_EMC,
-                               30, 2, 0, NULL);
+                               30, 2, 0, &emc_lock);
         clk = tegra_clk_register_periph_gate("emc", "emc_mux", 0, clk_base, 0,
                                     57, periph_clk_enb_refcnt);
         clks[TEGRA20_CLK_EMC] = clk;
 
+        clk = tegra_clk_register_mc("mc", "emc_mux", clk_base + CLK_SOURCE_EMC,
+                                    &emc_lock);
+        clks[TEGRA20_CLK_MC] = clk;
+
         /* dsi */
         clk = tegra_clk_register_periph_gate("dsi", "pll_d", 0, clk_base, 0,
                                     48, periph_clk_enb_refcnt);
diff --git a/drivers/clk/tegra/clk-tegra30.c b/drivers/clk/tegra/clk-tegra30.c
index 5bbacd01094f..4b9d8bd3d0bf 100644
--- a/drivers/clk/tegra/clk-tegra30.c
+++ b/drivers/clk/tegra/clk-tegra30.c
@@ -177,6 +177,7 @@ static unsigned long input_freq;
 
 static DEFINE_SPINLOCK(cml_lock);
 static DEFINE_SPINLOCK(pll_d_lock);
+static DEFINE_SPINLOCK(emc_lock);
 
 #define TEGRA_INIT_DATA_MUX(_name, _parents, _offset,   \
                             _clk_num, _gate_flags, _clk_id)     \
@@ -1157,11 +1158,15 @@ static void __init tegra30_periph_clk_init(void)
                                ARRAY_SIZE(mux_pllmcp_clkm),
                                CLK_SET_RATE_NO_REPARENT,
                                clk_base + CLK_SOURCE_EMC,
-                               30, 2, 0, NULL);
+                               30, 2, 0, &emc_lock);
         clk = tegra_clk_register_periph_gate("emc", "emc_mux", 0, clk_base, 0,
                                     57, periph_clk_enb_refcnt);
         clks[TEGRA30_CLK_EMC] = clk;
 
+        clk = tegra_clk_register_mc("mc", "emc_mux", clk_base + CLK_SOURCE_EMC,
+                                    &emc_lock);
+        clks[TEGRA30_CLK_MC] = clk;
+
         /* cml0 */
         clk = clk_register_gate(NULL, "cml0", "pll_e", 0, clk_base + PLLE_AUX,
                                 0, 0, &cml_lock);
diff --git a/drivers/clk/tegra/clk.h b/drivers/clk/tegra/clk.h
index 16ec8d6bb87f..4e458aa8d45c 100644
--- a/drivers/clk/tegra/clk.h
+++ b/drivers/clk/tegra/clk.h
@@ -86,6 +86,8 @@ struct clk *tegra_clk_register_divider(const char *name,
                 const char *parent_name, void __iomem *reg,
                 unsigned long flags, u8 clk_divider_flags, u8 shift, u8 width,
                 u8 frac_width, spinlock_t *lock);
+struct clk *tegra_clk_register_mc(const char *name, const char *parent_name,
+                                  void __iomem *reg, spinlock_t *lock);
 
 /*
  * Tegra PLL:
diff --git a/drivers/clk/ti/dpll.c b/drivers/clk/ti/dpll.c
index 79791e1bf282..85ac0dd501de 100644
--- a/drivers/clk/ti/dpll.c
+++ b/drivers/clk/ti/dpll.c
@@ -33,6 +33,9 @@ static const struct clk_ops dpll_m4xen_ck_ops = {
         .recalc_rate    = &omap4_dpll_regm4xen_recalc,
         .round_rate     = &omap4_dpll_regm4xen_round_rate,
         .set_rate       = &omap3_noncore_dpll_set_rate,
+        .set_parent     = &omap3_noncore_dpll_set_parent,
+        .set_rate_and_parent    = &omap3_noncore_dpll_set_rate_and_parent,
+        .determine_rate = &omap4_dpll_regm4xen_determine_rate,
         .get_parent     = &omap2_init_dpll_parent,
 };
 #else
@@ -53,6 +56,9 @@ static const struct clk_ops dpll_ck_ops = {
         .recalc_rate    = &omap3_dpll_recalc,
         .round_rate     = &omap2_dpll_round_rate,
         .set_rate       = &omap3_noncore_dpll_set_rate,
+        .set_parent     = &omap3_noncore_dpll_set_parent,
+        .set_rate_and_parent    = &omap3_noncore_dpll_set_rate_and_parent,
+        .determine_rate = &omap3_noncore_dpll_determine_rate,
         .get_parent     = &omap2_init_dpll_parent,
 };
 
@@ -61,6 +67,9 @@ static const struct clk_ops dpll_no_gate_ck_ops = {
         .get_parent     = &omap2_init_dpll_parent,
         .round_rate     = &omap2_dpll_round_rate,
         .set_rate       = &omap3_noncore_dpll_set_rate,
+        .set_parent     = &omap3_noncore_dpll_set_parent,
+        .set_rate_and_parent    = &omap3_noncore_dpll_set_rate_and_parent,
+        .determine_rate = &omap3_noncore_dpll_determine_rate,
 };
 #else
 static const struct clk_ops dpll_core_ck_ops = {};
@@ -97,6 +106,9 @@ static const struct clk_ops omap3_dpll_ck_ops = {
         .get_parent     = &omap2_init_dpll_parent,
         .recalc_rate    = &omap3_dpll_recalc,
         .set_rate       = &omap3_noncore_dpll_set_rate,
+        .set_parent     = &omap3_noncore_dpll_set_parent,
+        .set_rate_and_parent    = &omap3_noncore_dpll_set_rate_and_parent,
+        .determine_rate = &omap3_noncore_dpll_determine_rate,
         .round_rate     = &omap2_dpll_round_rate,
 };
 
@@ -106,6 +118,9 @@ static const struct clk_ops omap3_dpll_per_ck_ops = {
         .get_parent     = &omap2_init_dpll_parent,
         .recalc_rate    = &omap3_dpll_recalc,
         .set_rate       = &omap3_dpll4_set_rate,
+        .set_parent     = &omap3_noncore_dpll_set_parent,
+        .set_rate_and_parent    = &omap3_dpll4_set_rate_and_parent,
+        .determine_rate = &omap3_noncore_dpll_determine_rate,
         .round_rate     = &omap2_dpll_round_rate,
 };
 #endif
diff --git a/drivers/clk/versatile/Makefile b/drivers/clk/versatile/Makefile
index 162e519cb0f9..8ff03744fe98 100644
--- a/drivers/clk/versatile/Makefile
+++ b/drivers/clk/versatile/Makefile
@@ -2,6 +2,5 @@
 obj-$(CONFIG_ICST)              += clk-icst.o clk-versatile.o
 obj-$(CONFIG_INTEGRATOR_IMPD1)  += clk-impd1.o
 obj-$(CONFIG_ARCH_REALVIEW)     += clk-realview.o
-obj-$(CONFIG_ARCH_VEXPRESS)     += clk-vexpress.o
 obj-$(CONFIG_CLK_SP810)         += clk-sp810.o
 obj-$(CONFIG_CLK_VEXPRESS_OSC)  += clk-vexpress-osc.o
diff --git a/drivers/clk/versatile/clk-vexpress-osc.c b/drivers/clk/versatile/clk-vexpress-osc.c
index 529a59c0fbfa..765f1e0eeeb2 100644
--- a/drivers/clk/versatile/clk-vexpress-osc.c
+++ b/drivers/clk/versatile/clk-vexpress-osc.c
@@ -70,7 +70,6 @@ static struct clk_ops vexpress_osc_ops = {
 
 static int vexpress_osc_probe(struct platform_device *pdev)
 {
-        struct clk_lookup *cl = pdev->dev.platform_data; /* Non-DT lookup */
         struct clk_init_data init;
         struct vexpress_osc *osc;
         struct clk *clk;
@@ -106,12 +105,6 @@ static int vexpress_osc_probe(struct platform_device *pdev)
 
         of_clk_add_provider(pdev->dev.of_node, of_clk_src_simple_get, clk);
 
-        /* Only happens for non-DT cases */
-        if (cl) {
-                cl->clk = clk;
-                clkdev_add(cl);
-        }
-
         dev_dbg(&pdev->dev, "Registered clock '%s'\n", init.name);
 
         return 0;
diff --git a/drivers/clk/versatile/clk-vexpress.c b/drivers/clk/versatile/clk-vexpress.c
deleted file mode 100644
index 2d5e1b4820e0..000000000000
--- a/drivers/clk/versatile/clk-vexpress.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Copyright (C) 2012 ARM Limited
- */
-
-#include <linux/amba/sp810.h>
-#include <linux/clkdev.h>
-#include <linux/clk-provider.h>
-#include <linux/err.h>
-#include <linux/vexpress.h>
-
-static struct clk *vexpress_sp810_timerclken[4];
-static DEFINE_SPINLOCK(vexpress_sp810_lock);
-
-static void __init vexpress_sp810_init(void __iomem *base)
-{
-        int i;
-
-        if (WARN_ON(!base))
-                return;
-
-        for (i = 0; i < ARRAY_SIZE(vexpress_sp810_timerclken); i++) {
-                char name[12];
-                const char *parents[] = {
-                        "v2m:refclk32khz", /* REFCLK */
-                        "v2m:refclk1mhz" /* TIMCLK */
-                };
-
-                snprintf(name, ARRAY_SIZE(name), "timerclken%d", i);
-
-                vexpress_sp810_timerclken[i] = clk_register_mux(NULL, name,
-                                parents, 2, CLK_SET_RATE_NO_REPARENT,
-                                base + SCCTRL, SCCTRL_TIMERENnSEL_SHIFT(i), 1,
-                                0, &vexpress_sp810_lock);
-
-                if (WARN_ON(IS_ERR(vexpress_sp810_timerclken[i])))
-                        break;
-        }
-}
-
-
-static const char * const vexpress_clk_24mhz_periphs[] __initconst = {
-        "mb:uart0", "mb:uart1", "mb:uart2", "mb:uart3",
-        "mb:mmci", "mb:kmi0", "mb:kmi1"
-};
-
-void __init vexpress_clk_init(void __iomem *sp810_base)
-{
-        struct clk *clk;
-        int i;
-
-        clk = clk_register_fixed_rate(NULL, "dummy_apb_pclk", NULL,
-                        CLK_IS_ROOT, 0);
-        WARN_ON(clk_register_clkdev(clk, "apb_pclk", NULL));
-
-        clk = clk_register_fixed_rate(NULL, "v2m:clk_24mhz", NULL,
-                        CLK_IS_ROOT, 24000000);
-        for (i = 0; i < ARRAY_SIZE(vexpress_clk_24mhz_periphs); i++)
-                WARN_ON(clk_register_clkdev(clk, NULL,
-                                vexpress_clk_24mhz_periphs[i]));
-
-        clk = clk_register_fixed_rate(NULL, "v2m:refclk32khz", NULL,
-                        CLK_IS_ROOT, 32768);
-        WARN_ON(clk_register_clkdev(clk, NULL, "v2m:wdt"));
-
-        clk = clk_register_fixed_rate(NULL, "v2m:refclk1mhz", NULL,
-                        CLK_IS_ROOT, 1000000);
-
-        vexpress_sp810_init(sp810_base);
-
-        for (i = 0; i < ARRAY_SIZE(vexpress_sp810_timerclken); i++)
-                WARN_ON(clk_set_parent(vexpress_sp810_timerclken[i], clk));
-
-        WARN_ON(clk_register_clkdev(vexpress_sp810_timerclken[0],
-                                "v2m-timer0", "sp804"));
-        WARN_ON(clk_register_clkdev(vexpress_sp810_timerclken[1],
-                                "v2m-timer1", "sp804"));
-}
diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig
index 90420600e1eb..f657a48d20eb 100644
--- a/drivers/clocksource/Kconfig
+++ b/drivers/clocksource/Kconfig
@@ -32,6 +32,7 @@ config ARMADA_370_XP_TIMER
 
 config MESON6_TIMER
         bool
+        select CLKSRC_MMIO
 
 config ORION_TIMER
         select CLKSRC_OF
diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile
index 756f6f10efa0..fae0435cc23d 100644
--- a/drivers/clocksource/Makefile
+++ b/drivers/clocksource/Makefile
@@ -45,4 +45,5 @@ obj-$(CONFIG_ARM_GLOBAL_TIMER)		+= arm_global_timer.o
 obj-$(CONFIG_CLKSRC_METAG_GENERIC)      += metag_generic.o
 obj-$(CONFIG_ARCH_HAS_TICK_BROADCAST)   += dummy_timer.o
 obj-$(CONFIG_ARCH_KEYSTONE)             += timer-keystone.o
+obj-$(CONFIG_ARCH_INTEGRATOR_AP)        += timer-integrator-ap.o
 obj-$(CONFIG_CLKSRC_VERSATILE)          += versatile.o
diff --git a/drivers/clocksource/arm_arch_timer.c b/drivers/clocksource/arm_arch_timer.c
index 43005d4d3348..6a79fc4f900c 100644
--- a/drivers/clocksource/arm_arch_timer.c
+++ b/drivers/clocksource/arm_arch_timer.c
@@ -462,7 +462,10 @@ static void __init arch_counter_register(unsigned type)
 
         /* Register the CP15 based counter if we have one */
         if (type & ARCH_CP15_TIMER) {
-                arch_timer_read_counter = arch_counter_get_cntvct;
+                if (arch_timer_use_virtual)
+                        arch_timer_read_counter = arch_counter_get_cntvct;
+                else
+                        arch_timer_read_counter = arch_counter_get_cntpct;
         } else {
                 arch_timer_read_counter = arch_counter_get_cntvct_mem;
 
@@ -702,6 +705,14 @@ static void __init arch_timer_init(struct device_node *np)
         arch_timer_detect_rate(NULL, np);
 
         /*
+         * If we cannot rely on firmware initializing the timer registers then
+         * we should use the physical timers instead.
+         */
+        if (IS_ENABLED(CONFIG_ARM) &&
+            of_property_read_bool(np, "arm,cpu-registers-not-fw-configured"))
+                        arch_timer_use_virtual = false;
+
+        /*
          * If HYP mode is available, we know that the physical timer
          * has been configured to be accessible from PL1. Use it, so
          * that a guest can use the virtual timer instead.
diff --git a/drivers/clocksource/time-armada-370-xp.c b/drivers/clocksource/time-armada-370-xp.c
index 0451e62fac7a..0c8c5e337540 100644
--- a/drivers/clocksource/time-armada-370-xp.c
+++ b/drivers/clocksource/time-armada-370-xp.c
@@ -43,6 +43,7 @@
 #include <linux/module.h>
 #include <linux/sched_clock.h>
 #include <linux/percpu.h>
+#include <linux/syscore_ops.h>
 
 /*
  * Timer block registers.
@@ -223,6 +224,28 @@ static struct notifier_block armada_370_xp_timer_cpu_nb = {
         .notifier_call = armada_370_xp_timer_cpu_notify,
 };
 
+static u32 timer0_ctrl_reg, timer0_local_ctrl_reg;
+
+static int armada_370_xp_timer_suspend(void)
+{
+        timer0_ctrl_reg = readl(timer_base + TIMER_CTRL_OFF);
+        timer0_local_ctrl_reg = readl(local_base + TIMER_CTRL_OFF);
+        return 0;
+}
+
+static void armada_370_xp_timer_resume(void)
+{
+        writel(0xffffffff, timer_base + TIMER0_VAL_OFF);
+        writel(0xffffffff, timer_base + TIMER0_RELOAD_OFF);
+        writel(timer0_ctrl_reg, timer_base + TIMER_CTRL_OFF);
+        writel(timer0_local_ctrl_reg, local_base + TIMER_CTRL_OFF);
+}
+
+struct syscore_ops armada_370_xp_timer_syscore_ops = {
+        .suspend        = armada_370_xp_timer_suspend,
+        .resume         = armada_370_xp_timer_resume,
+};
+
 static void __init armada_370_xp_timer_common_init(struct device_node *np)
 {
         u32 clr = 0, set = 0;
@@ -285,6 +308,8 @@ static void __init armada_370_xp_timer_common_init(struct device_node *np)
         /* Immediately configure the timer on the boot CPU */
         if (!res)
                 armada_370_xp_timer_setup(this_cpu_ptr(armada_370_xp_evt));
+
+        register_syscore_ops(&armada_370_xp_timer_syscore_ops);
 }
 
 static void __init armada_xp_timer_init(struct device_node *np)
@@ -293,6 +318,7 @@ static void __init armada_xp_timer_init(struct device_node *np)
 
         /* The 25Mhz fixed clock is mandatory, and must always be available */
         BUG_ON(IS_ERR(clk));
+        clk_prepare_enable(clk);
         timer_clk = clk_get_rate(clk);
 
         armada_370_xp_timer_common_init(np);
@@ -300,11 +326,40 @@ static void __init armada_xp_timer_init(struct device_node *np)
 CLOCKSOURCE_OF_DECLARE(armada_xp, "marvell,armada-xp-timer",
                        armada_xp_timer_init);
 
+static void __init armada_375_timer_init(struct device_node *np)
+{
+        struct clk *clk;
+
+        clk = of_clk_get_by_name(np, "fixed");
+        if (!IS_ERR(clk)) {
+                clk_prepare_enable(clk);
+                timer_clk = clk_get_rate(clk);
+        } else {
+
+                /*
+                 * This fallback is required in order to retain proper
+                 * devicetree backwards compatibility.
+                 */
+                clk = of_clk_get(np, 0);
+
+                /* Must have at least a clock */
+                BUG_ON(IS_ERR(clk));
+                clk_prepare_enable(clk);
+                timer_clk = clk_get_rate(clk) / TIMER_DIVIDER;
+                timer25Mhz = false;
+        }
+
+        armada_370_xp_timer_common_init(np);
+}
+CLOCKSOURCE_OF_DECLARE(armada_375, "marvell,armada-375-timer",
+                       armada_375_timer_init);
+
 static void __init armada_370_timer_init(struct device_node *np)
 {
         struct clk *clk = of_clk_get(np, 0);
 
         BUG_ON(IS_ERR(clk));
+        clk_prepare_enable(clk);
         timer_clk = clk_get_rate(clk) / TIMER_DIVIDER;
         timer25Mhz = false;
 
diff --git a/drivers/clocksource/timer-atmel-pit.c b/drivers/clocksource/timer-atmel-pit.c
index d5289098b3df..b5b4d4585c9a 100644
--- a/drivers/clocksource/timer-atmel-pit.c
+++ b/drivers/clocksource/timer-atmel-pit.c
@@ -262,35 +262,3 @@ static void __init at91sam926x_pit_dt_init(struct device_node *node)
 }
 CLOCKSOURCE_OF_DECLARE(at91sam926x_pit, "atmel,at91sam9260-pit",
                        at91sam926x_pit_dt_init);
-
-static void __iomem *pit_base_addr;
-
-void __init at91sam926x_pit_init(int irq)
-{
-        struct pit_data *data;
-
-        data = kzalloc(sizeof(*data), GFP_KERNEL);
-        if (!data)
-                panic(pr_fmt("Unable to allocate memory\n"));
-
-        data->base = pit_base_addr;
-
-        data->mck = clk_get(NULL, "mck");
-        if (IS_ERR(data->mck))
-                panic(pr_fmt("Unable to get mck clk\n"));
-
-        data->irq = irq;
-
-        at91sam926x_pit_common_init(data);
-}
-
-void __init at91sam926x_ioremap_pit(u32 addr)
-{
-        if (of_have_populated_dt())
-                return;
-
-        pit_base_addr = ioremap(addr, 16);
-
-        if (!pit_base_addr)
-                panic(pr_fmt("Impossible to ioremap PIT\n"));
-}
diff --git a/drivers/clocksource/timer-integrator-ap.c b/drivers/clocksource/timer-integrator-ap.c
new file mode 100644
index 000000000000..b9efd30513d5
--- /dev/null
+++ b/drivers/clocksource/timer-integrator-ap.c
@@ -0,0 +1,210 @@
+/*
+ * Integrator/AP timer driver
+ * Copyright (C) 2000-2003 Deep Blue Solutions Ltd
+ * Copyright (c) 2014, Linaro Limited
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/clk.h>
+#include <linux/clocksource.h>
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+#include <linux/clockchips.h>
+#include <linux/interrupt.h>
+#include <linux/sched_clock.h>
+#include <asm/hardware/arm_timer.h>
+
+static void __iomem * sched_clk_base;
+
+static u64 notrace integrator_read_sched_clock(void)
+{
+        return -readl(sched_clk_base + TIMER_VALUE);
+}
+
+static void integrator_clocksource_init(unsigned long inrate,
+                                        void __iomem *base)
+{
+        u32 ctrl = TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC;
+        unsigned long rate = inrate;
+
+        if (rate >= 1500000) {
+                rate /= 16;
+                ctrl |= TIMER_CTRL_DIV16;
+        }
+
+        writel(0xffff, base + TIMER_LOAD);
+        writel(ctrl, base + TIMER_CTRL);
+
+        clocksource_mmio_init(base + TIMER_VALUE, "timer2",
+                        rate, 200, 16, clocksource_mmio_readl_down);
+
+        sched_clk_base = base;
+        sched_clock_register(integrator_read_sched_clock, 16, rate);
+}
+
+static unsigned long timer_reload;
+static void __iomem * clkevt_base;
+
+/*
+ * IRQ handler for the timer
+ */
+static irqreturn_t integrator_timer_interrupt(int irq, void *dev_id)
+{
+        struct clock_event_device *evt = dev_id;
+
+        /* clear the interrupt */
+        writel(1, clkevt_base + TIMER_INTCLR);
+
+        evt->event_handler(evt);
+
+        return IRQ_HANDLED;
+}
+
+static void clkevt_set_mode(enum clock_event_mode mode, struct clock_event_device *evt)
+{
+        u32 ctrl = readl(clkevt_base + TIMER_CTRL) & ~TIMER_CTRL_ENABLE;
+
+        /* Disable timer */
+        writel(ctrl, clkevt_base + TIMER_CTRL);
+
+        switch (mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+                /* Enable the timer and start the periodic tick */
+                writel(timer_reload, clkevt_base + TIMER_LOAD);
+                ctrl |= TIMER_CTRL_PERIODIC | TIMER_CTRL_ENABLE;
+                writel(ctrl, clkevt_base + TIMER_CTRL);
+                break;
+        case CLOCK_EVT_MODE_ONESHOT:
+                /* Leave the timer disabled, .set_next_event will enable it */
+                ctrl &= ~TIMER_CTRL_PERIODIC;
+                writel(ctrl, clkevt_base + TIMER_CTRL);
+                break;
+        case CLOCK_EVT_MODE_UNUSED:
+        case CLOCK_EVT_MODE_SHUTDOWN:
+        case CLOCK_EVT_MODE_RESUME:
+        default:
+                /* Just leave in disabled state */
+                break;
+        }
+
+}
+
+static int clkevt_set_next_event(unsigned long next, struct clock_event_device *evt)
+{
+        unsigned long ctrl = readl(clkevt_base + TIMER_CTRL);
+
+        writel(ctrl & ~TIMER_CTRL_ENABLE, clkevt_base + TIMER_CTRL);
+        writel(next, clkevt_base + TIMER_LOAD);
+        writel(ctrl | TIMER_CTRL_ENABLE, clkevt_base + TIMER_CTRL);
+
+        return 0;
+}
+
+static struct clock_event_device integrator_clockevent = {
+        .name           = "timer1",
+        .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
+        .set_mode       = clkevt_set_mode,
+        .set_next_event = clkevt_set_next_event,
+        .rating         = 300,
+};
+
+static struct irqaction integrator_timer_irq = {
+        .name           = "timer",
+        .flags          = IRQF_TIMER | IRQF_IRQPOLL,
+        .handler        = integrator_timer_interrupt,
+        .dev_id         = &integrator_clockevent,
+};
+
+static void integrator_clockevent_init(unsigned long inrate,
+                                void __iomem *base, int irq)
+{
+        unsigned long rate = inrate;
+        unsigned int ctrl = 0;
+
+        clkevt_base = base;
+        /* Calculate and program a divisor */
+        if (rate > 0x100000 * HZ) {
+                rate /= 256;
+                ctrl |= TIMER_CTRL_DIV256;
+        } else if (rate > 0x10000 * HZ) {
+                rate /= 16;
+                ctrl |= TIMER_CTRL_DIV16;
+        }
+        timer_reload = rate / HZ;
+        writel(ctrl, clkevt_base + TIMER_CTRL);
+
+        setup_irq(irq, &integrator_timer_irq);
+        clockevents_config_and_register(&integrator_clockevent,
+                                        rate,
+                                        1,
+                                        0xffffU);
+}
+
+static void __init integrator_ap_timer_init_of(struct device_node *node)
+{
+        const char *path;
+        void __iomem *base;
+        int err;
+        int irq;
+        struct clk *clk;
+        unsigned long rate;
+        struct device_node *pri_node;
+        struct device_node *sec_node;
+
+        base = of_io_request_and_map(node, 0, "integrator-timer");
+        if (!base)
+                return;
+
+        clk = of_clk_get(node, 0);
+        if (IS_ERR(clk)) {
+                pr_err("No clock for %s\n", node->name);
+                return;
+        }
+        clk_prepare_enable(clk);
+        rate = clk_get_rate(clk);
+        writel(0, base + TIMER_CTRL);
+
+        err = of_property_read_string(of_aliases,
+                                "arm,timer-primary", &path);
+        if (WARN_ON(err))
+                return;
+        pri_node = of_find_node_by_path(path);
+        err = of_property_read_string(of_aliases,
+                                "arm,timer-secondary", &path);
+        if (WARN_ON(err))
+                return;
+        sec_node = of_find_node_by_path(path);
+
+        if (node == pri_node) {
+                /* The primary timer lacks IRQ, use as clocksource */
+                integrator_clocksource_init(rate, base);
+                return;
+        }
+
+        if (node == sec_node) {
+                /* The secondary timer will drive the clock event */
+                irq = irq_of_parse_and_map(node, 0);
+                integrator_clockevent_init(rate, base, irq);
+                return;
+        }
+
+        pr_info("Timer @%p unused\n", base);
+        clk_disable_unprepare(clk);
+}
+
+CLOCKSOURCE_OF_DECLARE(integrator_ap_timer, "arm,integrator-timer",
+                       integrator_ap_timer_init_of);
diff --git a/drivers/clocksource/timer-marco.c b/drivers/clocksource/timer-marco.c
index caf7a2030461..361a789d4bee 100644
--- a/drivers/clocksource/timer-marco.c
+++ b/drivers/clocksource/timer-marco.c
@@ -20,8 +20,6 @@
 #include <linux/of_address.h>
 #include <linux/sched_clock.h>
 
-#define MARCO_CLOCK_FREQ 1000000
-
 #define SIRFSOC_TIMER_32COUNTER_0_CTRL                  0x0000
 #define SIRFSOC_TIMER_32COUNTER_1_CTRL                  0x0004
 #define SIRFSOC_TIMER_MATCH_0                           0x0018
@@ -40,6 +38,8 @@
 
 #define SIRFSOC_TIMER_REG_CNT 6
 
+static unsigned long marco_timer_rate;
+
 static const u32 sirfsoc_timer_reg_list[SIRFSOC_TIMER_REG_CNT] = {
         SIRFSOC_TIMER_WATCHDOG_EN,
         SIRFSOC_TIMER_32COUNTER_0_CTRL,
@@ -195,7 +195,7 @@ static int sirfsoc_local_timer_setup(struct clock_event_device *ce)
         ce->rating = 200;
         ce->set_mode = sirfsoc_timer_set_mode;
         ce->set_next_event = sirfsoc_timer_set_next_event;
-        clockevents_calc_mult_shift(ce, MARCO_CLOCK_FREQ, 60);
+        clockevents_calc_mult_shift(ce, marco_timer_rate, 60);
         ce->max_delta_ns = clockevent_delta2ns(-2, ce);
         ce->min_delta_ns = clockevent_delta2ns(2, ce);
         ce->cpumask = cpumask_of(cpu);
@@ -257,7 +257,6 @@ static void __init sirfsoc_clockevent_init(void)
 /* initialize the kernel jiffy timer source */
 static void __init sirfsoc_marco_timer_init(struct device_node *np)
 {
-        unsigned long rate;
         u32 timer_div;
         struct clk *clk;
 
@@ -266,16 +265,12 @@ static void __init sirfsoc_marco_timer_init(struct device_node *np)
 
         BUG_ON(clk_prepare_enable(clk));
 
-        rate = clk_get_rate(clk);
-
-        BUG_ON(rate < MARCO_CLOCK_FREQ);
-        BUG_ON(rate % MARCO_CLOCK_FREQ);
+        marco_timer_rate = clk_get_rate(clk);
 
-        /* Initialize the timer dividers */
-        timer_div = rate / MARCO_CLOCK_FREQ - 1;
-        writel_relaxed(timer_div << 16, sirfsoc_timer_base + SIRFSOC_TIMER_64COUNTER_CTRL);
-        writel_relaxed(timer_div << 16, sirfsoc_timer_base + SIRFSOC_TIMER_32COUNTER_0_CTRL);
-        writel_relaxed(timer_div << 16, sirfsoc_timer_base + SIRFSOC_TIMER_32COUNTER_1_CTRL);
+        /* timer dividers: 0, not divided */
+        writel_relaxed(0, sirfsoc_timer_base + SIRFSOC_TIMER_64COUNTER_CTRL);
+        writel_relaxed(0, sirfsoc_timer_base + SIRFSOC_TIMER_32COUNTER_0_CTRL);
+        writel_relaxed(0, sirfsoc_timer_base + SIRFSOC_TIMER_32COUNTER_1_CTRL);
 
         /* Initialize timer counters to 0 */
         writel_relaxed(0, sirfsoc_timer_base + SIRFSOC_TIMER_64COUNTER_LOAD_LO);
@@ -288,7 +283,7 @@ static void __init sirfsoc_marco_timer_init(struct device_node *np)
         /* Clear all interrupts */
         writel_relaxed(0xFFFF, sirfsoc_timer_base + SIRFSOC_TIMER_INTR_STATUS);
 
-        BUG_ON(clocksource_register_hz(&sirfsoc_clocksource, MARCO_CLOCK_FREQ));
+        BUG_ON(clocksource_register_hz(&sirfsoc_clocksource, marco_timer_rate));
 
         sirfsoc_clockevent_init();
 }
diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig
index 3489f8f5fada..29b2ef5a68b9 100644
--- a/drivers/cpufreq/Kconfig
+++ b/drivers/cpufreq/Kconfig
@@ -63,7 +63,6 @@ config CPU_FREQ_DEFAULT_GOV_PERFORMANCE
 
 config CPU_FREQ_DEFAULT_GOV_POWERSAVE
         bool "powersave"
-        depends on EXPERT
         select CPU_FREQ_GOV_POWERSAVE
         help
           Use the CPUFreq governor 'powersave' as default. This sets
@@ -183,6 +182,8 @@ config CPU_FREQ_GOV_CONSERVATIVE
 
           If in doubt, say N.
 
+comment "CPU frequency scaling drivers"
+
 config CPUFREQ_DT
         tristate "Generic DT based cpufreq driver"
         depends on HAVE_CLK && OF
@@ -196,19 +197,19 @@ config CPUFREQ_DT
 
           If in doubt, say N.
 
-menu "x86 CPU frequency scaling drivers"
-depends on X86
+if X86
 source "drivers/cpufreq/Kconfig.x86"
-endmenu
+endif
 
-menu "ARM CPU frequency scaling drivers"
-depends on ARM || ARM64
+if ARM || ARM64
 source "drivers/cpufreq/Kconfig.arm"
-endmenu
+endif
 
-menu "AVR32 CPU frequency scaling drivers"
-depends on AVR32
+if PPC32 || PPC64
+source "drivers/cpufreq/Kconfig.powerpc"
+endif
 
+if AVR32
 config AVR32_AT32AP_CPUFREQ
         bool "CPU frequency driver for AT32AP"
         depends on PLATFORM_AT32AP
@@ -216,12 +217,9 @@ config AVR32_AT32AP_CPUFREQ
         help
           This enables the CPU frequency driver for AT32AP processors.
           If in doubt, say N.
+endif
 
-endmenu
-
-menu "CPUFreq processor drivers"
-depends on IA64
-
+if IA64
 config IA64_ACPI_CPUFREQ
         tristate "ACPI Processor P-States driver"
         depends on ACPI_PROCESSOR
@@ -232,12 +230,9 @@ config IA64_ACPI_CPUFREQ
         For details, take a look at <file:Documentation/cpu-freq/>.
 
         If in doubt, say N.
+endif
 
-endmenu
-
-menu "MIPS CPUFreq processor drivers"
-depends on MIPS
-
+if MIPS
 config LOONGSON2_CPUFREQ
         tristate "Loongson2 CPUFreq Driver"
         help
@@ -250,15 +245,18 @@ config LOONGSON2_CPUFREQ
 
           If in doubt, say N.
 
-endmenu
+config LOONGSON1_CPUFREQ
+        tristate "Loongson1 CPUFreq Driver"
+        help
+          This option adds a CPUFreq driver for loongson1 processors which
+          support software configurable cpu frequency.
 
-menu "PowerPC CPU frequency scaling drivers"
-depends on PPC32 || PPC64
-source "drivers/cpufreq/Kconfig.powerpc"
-endmenu
+          For details, take a look at <file:Documentation/cpu-freq/>.
 
-menu "SPARC CPU frequency scaling drivers"
-depends on SPARC64
+          If in doubt, say N.
+endif
+
+if SPARC64
 config SPARC_US3_CPUFREQ
         tristate "UltraSPARC-III CPU Frequency driver"
         help
@@ -276,10 +274,9 @@ config SPARC_US2E_CPUFREQ
           For details, take a look at <file:Documentation/cpu-freq>.
 
           If in doubt, say N.
-endmenu
+endif
 
-menu "SH CPU Frequency scaling"
-depends on SUPERH
+if SUPERH
 config SH_CPU_FREQ
         tristate "SuperH CPU Frequency driver"
         help
@@ -293,7 +290,7 @@ config SH_CPU_FREQ
           For details, take a look at <file:Documentation/cpu-freq>.
 
           If unsure, say N.
-endmenu
+endif
 
 endif
 endmenu
diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm
index 83a75dc84761..0f9a2c3c0e0d 100644
--- a/drivers/cpufreq/Kconfig.arm
+++ b/drivers/cpufreq/Kconfig.arm
@@ -247,3 +247,11 @@ config ARM_TEGRA_CPUFREQ
         default y
         help
           This adds the CPUFreq driver support for TEGRA SOCs.
+
+config ARM_PXA2xx_CPUFREQ
+        tristate "Intel PXA2xx CPUfreq driver"
+        depends on PXA27x || PXA25x
+        help
+          This add the CPUFreq driver support for Intel PXA2xx SOCs.
+
+          If in doubt, say N.
diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile
index 40c53dc1937e..b3ca7b0b2c33 100644
--- a/drivers/cpufreq/Makefile
+++ b/drivers/cpufreq/Makefile
@@ -61,8 +61,7 @@ obj-$(CONFIG_ARM_IMX6Q_CPUFREQ)		+= imx6q-cpufreq.o
 obj-$(CONFIG_ARM_INTEGRATOR)            += integrator-cpufreq.o
 obj-$(CONFIG_ARM_KIRKWOOD_CPUFREQ)      += kirkwood-cpufreq.o
 obj-$(CONFIG_ARM_OMAP2PLUS_CPUFREQ)     += omap-cpufreq.o
-obj-$(CONFIG_PXA25x)                    += pxa2xx-cpufreq.o
-obj-$(CONFIG_PXA27x)                    += pxa2xx-cpufreq.o
+obj-$(CONFIG_ARM_PXA2xx_CPUFREQ)        += pxa2xx-cpufreq.o
 obj-$(CONFIG_PXA3xx)                    += pxa3xx-cpufreq.o
 obj-$(CONFIG_ARM_S3C24XX_CPUFREQ)       += s3c24xx-cpufreq.o
 obj-$(CONFIG_ARM_S3C24XX_CPUFREQ_DEBUGFS) += s3c24xx-cpufreq-debugfs.o
@@ -98,6 +97,7 @@ obj-$(CONFIG_CRIS_MACH_ARTPEC3)		+= cris-artpec3-cpufreq.o
 obj-$(CONFIG_ETRAXFS)                   += cris-etraxfs-cpufreq.o
 obj-$(CONFIG_IA64_ACPI_CPUFREQ)         += ia64-acpi-cpufreq.o
 obj-$(CONFIG_LOONGSON2_CPUFREQ)         += loongson2_cpufreq.o
+obj-$(CONFIG_LOONGSON1_CPUFREQ)         += ls1x-cpufreq.o
 obj-$(CONFIG_SH_CPU_FREQ)               += sh-cpufreq.o
 obj-$(CONFIG_SPARC_US2E_CPUFREQ)        += sparc-us2e-cpufreq.o
 obj-$(CONFIG_SPARC_US3_CPUFREQ)         += sparc-us3-cpufreq.o
diff --git a/drivers/cpufreq/arm_big_little.c b/drivers/cpufreq/arm_big_little.c
index a46c223c2506..e1a6ba66a7f5 100644
--- a/drivers/cpufreq/arm_big_little.c
+++ b/drivers/cpufreq/arm_big_little.c
@@ -289,6 +289,8 @@ static void _put_cluster_clk_and_freq_table(struct device *cpu_dev)
 
         clk_put(clk[cluster]);
         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table[cluster]);
+        if (arm_bL_ops->free_opp_table)
+                arm_bL_ops->free_opp_table(cpu_dev);
         dev_dbg(cpu_dev, "%s: cluster: %d\n", __func__, cluster);
 }
 
@@ -337,7 +339,7 @@ static int _get_cluster_clk_and_freq_table(struct device *cpu_dev)
         if (ret) {
                 dev_err(cpu_dev, "%s: failed to init cpufreq table, cpu: %d, err: %d\n",
                                 __func__, cpu_dev->id, ret);
-                goto out;
+                goto free_opp_table;
         }
 
         name[12] = cluster + '0';
@@ -354,6 +356,9 @@ static int _get_cluster_clk_and_freq_table(struct device *cpu_dev)
         ret = PTR_ERR(clk[cluster]);
         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table[cluster]);
 
+free_opp_table:
+        if (arm_bL_ops->free_opp_table)
+                arm_bL_ops->free_opp_table(cpu_dev);
 out:
         dev_err(cpu_dev, "%s: Failed to get data for cluster: %d\n", __func__,
                         cluster);
diff --git a/drivers/cpufreq/arm_big_little.h b/drivers/cpufreq/arm_big_little.h
index 70f18fc12d4a..a211f7db9d32 100644
--- a/drivers/cpufreq/arm_big_little.h
+++ b/drivers/cpufreq/arm_big_little.h
@@ -25,13 +25,16 @@
 
 struct cpufreq_arm_bL_ops {
         char name[CPUFREQ_NAME_LEN];
-        int (*get_transition_latency)(struct device *cpu_dev);
 
         /*
          * This must set opp table for cpu_dev in a similar way as done by
          * of_init_opp_table().
          */
         int (*init_opp_table)(struct device *cpu_dev);
+
+        /* Optional */
+        int (*get_transition_latency)(struct device *cpu_dev);
+        void (*free_opp_table)(struct device *cpu_dev);
 };
 
 int bL_cpufreq_register(struct cpufreq_arm_bL_ops *ops);
diff --git a/drivers/cpufreq/arm_big_little_dt.c b/drivers/cpufreq/arm_big_little_dt.c
index 4550f6976768..ef0b3f1324d5 100644
--- a/drivers/cpufreq/arm_big_little_dt.c
+++ b/drivers/cpufreq/arm_big_little_dt.c
@@ -82,6 +82,7 @@ static struct cpufreq_arm_bL_ops dt_bL_ops = {
         .name   = "dt-bl",
         .get_transition_latency = dt_get_transition_latency,
         .init_opp_table = dt_init_opp_table,
+        .free_opp_table = of_free_opp_table,
 };
 
 static int generic_bL_probe(struct platform_device *pdev)
diff --git a/drivers/cpufreq/cpufreq-dt.c b/drivers/cpufreq/cpufreq-dt.c
index f657c571b18e..9bc2720628a4 100644
--- a/drivers/cpufreq/cpufreq-dt.c
+++ b/drivers/cpufreq/cpufreq-dt.c
@@ -58,6 +58,8 @@ static int set_target(struct cpufreq_policy *policy, unsigned int index)
         old_freq = clk_get_rate(cpu_clk) / 1000;
 
         if (!IS_ERR(cpu_reg)) {
+                unsigned long opp_freq;
+
                 rcu_read_lock();
                 opp = dev_pm_opp_find_freq_ceil(cpu_dev, &freq_Hz);
                 if (IS_ERR(opp)) {
@@ -67,13 +69,16 @@ static int set_target(struct cpufreq_policy *policy, unsigned int index)
                         return PTR_ERR(opp);
                 }
                 volt = dev_pm_opp_get_voltage(opp);
+                opp_freq = dev_pm_opp_get_freq(opp);
                 rcu_read_unlock();
                 tol = volt * priv->voltage_tolerance / 100;
                 volt_old = regulator_get_voltage(cpu_reg);
+                dev_dbg(cpu_dev, "Found OPP: %ld kHz, %ld uV\n",
+                        opp_freq / 1000, volt);
         }
 
         dev_dbg(cpu_dev, "%u MHz, %ld mV --> %u MHz, %ld mV\n",
-                old_freq / 1000, volt_old ? volt_old / 1000 : -1,
+                old_freq / 1000, (volt_old > 0) ? volt_old / 1000 : -1,
                 new_freq / 1000, volt ? volt / 1000 : -1);
 
         /* scaling up?  scale voltage before frequency */
@@ -89,7 +94,7 @@ static int set_target(struct cpufreq_policy *policy, unsigned int index)
         ret = clk_set_rate(cpu_clk, freq_exact);
         if (ret) {
                 dev_err(cpu_dev, "failed to set clock rate: %d\n", ret);
-                if (!IS_ERR(cpu_reg))
+                if (!IS_ERR(cpu_reg) && volt_old > 0)
                         regulator_set_voltage_tol(cpu_reg, volt_old, tol);
                 return ret;
         }
@@ -181,7 +186,6 @@ static int cpufreq_init(struct cpufreq_policy *policy)
 {
         struct cpufreq_dt_platform_data *pd;
         struct cpufreq_frequency_table *freq_table;
-        struct thermal_cooling_device *cdev;
         struct device_node *np;
         struct private_data *priv;
         struct device *cpu_dev;
@@ -210,7 +214,7 @@ static int cpufreq_init(struct cpufreq_policy *policy)
         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv) {
                 ret = -ENOMEM;
-                goto out_put_node;
+                goto out_free_opp;
         }
 
         of_property_read_u32(np, "voltage-tolerance", &priv->voltage_tolerance);
@@ -264,20 +268,6 @@ static int cpufreq_init(struct cpufreq_policy *policy)
                 goto out_free_priv;
         }
 
-        /*
-         * For now, just loading the cooling device;
-         * thermal DT code takes care of matching them.
-         */
-        if (of_find_property(np, "#cooling-cells", NULL)) {
-                cdev = of_cpufreq_cooling_register(np, cpu_present_mask);
-                if (IS_ERR(cdev))
-                        dev_err(cpu_dev,
-                                "running cpufreq without cooling device: %ld\n",
-                                PTR_ERR(cdev));
-                else
-                        priv->cdev = cdev;
-        }
-
         priv->cpu_dev = cpu_dev;
         priv->cpu_reg = cpu_reg;
         policy->driver_data = priv;
@@ -287,7 +277,7 @@ static int cpufreq_init(struct cpufreq_policy *policy)
         if (ret) {
                 dev_err(cpu_dev, "%s: invalid frequency table: %d\n", __func__,
                         ret);
-                goto out_cooling_unregister;
+                goto out_free_cpufreq_table;
         }
 
         policy->cpuinfo.transition_latency = transition_latency;
@@ -300,12 +290,12 @@ static int cpufreq_init(struct cpufreq_policy *policy)
 
         return 0;
 
-out_cooling_unregister:
-        cpufreq_cooling_unregister(priv->cdev);
+out_free_cpufreq_table:
         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
 out_free_priv:
         kfree(priv);
-out_put_node:
+out_free_opp:
+        of_free_opp_table(cpu_dev);
         of_node_put(np);
 out_put_reg_clk:
         clk_put(cpu_clk);
@@ -319,8 +309,10 @@ static int cpufreq_exit(struct cpufreq_policy *policy)
 {
         struct private_data *priv = policy->driver_data;
 
-        cpufreq_cooling_unregister(priv->cdev);
+        if (priv->cdev)
+                cpufreq_cooling_unregister(priv->cdev);
         dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
+        of_free_opp_table(priv->cpu_dev);
         clk_put(policy->clk);
         if (!IS_ERR(priv->cpu_reg))
                 regulator_put(priv->cpu_reg);
@@ -329,6 +321,33 @@ static int cpufreq_exit(struct cpufreq_policy *policy)
         return 0;
 }
 
+static void cpufreq_ready(struct cpufreq_policy *policy)
+{
+        struct private_data *priv = policy->driver_data;
+        struct device_node *np = of_node_get(priv->cpu_dev->of_node);
+
+        if (WARN_ON(!np))
+                return;
+
+        /*
+         * For now, just loading the cooling device;
+         * thermal DT code takes care of matching them.
+         */
+        if (of_find_property(np, "#cooling-cells", NULL)) {
+                priv->cdev = of_cpufreq_cooling_register(np,
+                                                         policy->related_cpus);
+                if (IS_ERR(priv->cdev)) {
+                        dev_err(priv->cpu_dev,
+                                "running cpufreq without cooling device: %ld\n",
+                                PTR_ERR(priv->cdev));
+
+                        priv->cdev = NULL;
+                }
+        }
+
+        of_node_put(np);
+}
+
 static struct cpufreq_driver dt_cpufreq_driver = {
         .flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
         .verify = cpufreq_generic_frequency_table_verify,
@@ -336,6 +355,7 @@ static struct cpufreq_driver dt_cpufreq_driver = {
         .get = cpufreq_generic_get,
         .init = cpufreq_init,
         .exit = cpufreq_exit,
+        .ready = cpufreq_ready,
         .name = "cpufreq-dt",
         .attr = cpufreq_generic_attr,
 };
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 4473eba1d6b0..a09a29c312a9 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -535,7 +535,7 @@ static int cpufreq_set_policy(struct cpufreq_policy *policy,
 static ssize_t store_##file_name                                        \
 (struct cpufreq_policy *policy, const char *buf, size_t count)          \
 {                                                                       \
-        int ret;                                                        \
+        int ret, temp;                                                  \
         struct cpufreq_policy new_policy;                               \
                                                                         \
         ret = cpufreq_get_policy(&new_policy, policy->cpu);             \
@@ -546,8 +546,10 @@ static ssize_t store_##file_name					\
         if (ret != 1)                                                   \
                 return -EINVAL;                                         \
                                                                         \
+        temp = new_policy.object;                                       \
         ret = cpufreq_set_policy(policy, &new_policy);          \
-        policy->user_policy.object = policy->object;                    \
+        if (!ret)                                                       \
+                policy->user_policy.object = temp;                      \
                                                                         \
         return ret ? ret : count;                                       \
 }
@@ -898,46 +900,31 @@ static int cpufreq_add_dev_interface(struct cpufreq_policy *policy,
         struct freq_attr **drv_attr;
         int ret = 0;
 
-        /* prepare interface data */
-        ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
-                                   &dev->kobj, "cpufreq");
-        if (ret)
-                return ret;
-
         /* set up files for this cpu device */
         drv_attr = cpufreq_driver->attr;
         while ((drv_attr) && (*drv_attr)) {
                 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
                 if (ret)
-                        goto err_out_kobj_put;
+                        return ret;
                 drv_attr++;
         }
         if (cpufreq_driver->get) {
                 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
                 if (ret)
-                        goto err_out_kobj_put;
+                        return ret;
         }
 
         ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
         if (ret)
-                goto err_out_kobj_put;
+                return ret;
 
         if (cpufreq_driver->bios_limit) {
                 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
                 if (ret)
-                        goto err_out_kobj_put;
+                        return ret;
         }
 
-        ret = cpufreq_add_dev_symlink(policy);
-        if (ret)
-                goto err_out_kobj_put;
-
-        return ret;
-
-err_out_kobj_put:
-        kobject_put(&policy->kobj);
-        wait_for_completion(&policy->kobj_unregister);
-        return ret;
+        return cpufreq_add_dev_symlink(policy);
 }
 
 static void cpufreq_init_policy(struct cpufreq_policy *policy)
@@ -1196,6 +1183,8 @@ static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
                 goto err_set_policy_cpu;
         }
 
+        down_write(&policy->rwsem);
+
         /* related cpus should atleast have policy->cpus */
         cpumask_or(policy->related_cpus, policy->related_cpus, policy->cpus);
 
@@ -1208,9 +1197,17 @@ static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
         if (!recover_policy) {
                 policy->user_policy.min = policy->min;
                 policy->user_policy.max = policy->max;
+
+                /* prepare interface data */
+                ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
+                                           &dev->kobj, "cpufreq");
+                if (ret) {
+                        pr_err("%s: failed to init policy->kobj: %d\n",
+                               __func__, ret);
+                        goto err_init_policy_kobj;
+                }
         }
 
-        down_write(&policy->rwsem);
         write_lock_irqsave(&cpufreq_driver_lock, flags);
         for_each_cpu(j, policy->cpus)
                 per_cpu(cpufreq_cpu_data, j) = policy;
@@ -1288,8 +1285,13 @@ static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
         up_write(&policy->rwsem);
 
         kobject_uevent(&policy->kobj, KOBJ_ADD);
+
         up_read(&cpufreq_rwsem);
 
+        /* Callback for handling stuff after policy is ready */
+        if (cpufreq_driver->ready)
+                cpufreq_driver->ready(policy);
+
         pr_debug("initialization complete\n");
 
         return 0;
@@ -1301,6 +1303,11 @@ err_get_freq:
                 per_cpu(cpufreq_cpu_data, j) = NULL;
         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
+        if (!recover_policy) {
+                kobject_put(&policy->kobj);
+                wait_for_completion(&policy->kobj_unregister);
+        }
+err_init_policy_kobj:
         up_write(&policy->rwsem);
 
         if (cpufreq_driver->exit)
diff --git a/drivers/cpufreq/exynos5440-cpufreq.c b/drivers/cpufreq/exynos5440-cpufreq.c
index f33f25b483ca..27a57ed9eb2c 100644
--- a/drivers/cpufreq/exynos5440-cpufreq.c
+++ b/drivers/cpufreq/exynos5440-cpufreq.c
@@ -371,7 +371,7 @@ static int exynos_cpufreq_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(dvfs_info->dev,
                         "failed to init cpufreq table: %d\n", ret);
-                goto err_put_node;
+                goto err_free_opp;
         }
         dvfs_info->freq_count = dev_pm_opp_get_opp_count(dvfs_info->dev);
         exynos_sort_descend_freq_table();
@@ -423,6 +423,8 @@ static int exynos_cpufreq_probe(struct platform_device *pdev)
 
 err_free_table:
         dev_pm_opp_free_cpufreq_table(dvfs_info->dev, &dvfs_info->freq_table);
+err_free_opp:
+        of_free_opp_table(dvfs_info->dev);
 err_put_node:
         of_node_put(np);
         dev_err(&pdev->dev, "%s: failed initialization\n", __func__);
@@ -433,6 +435,7 @@ static int exynos_cpufreq_remove(struct platform_device *pdev)
 {
         cpufreq_unregister_driver(&exynos_driver);
         dev_pm_opp_free_cpufreq_table(dvfs_info->dev, &dvfs_info->freq_table);
+        of_free_opp_table(dvfs_info->dev);
         return 0;
 }
 
diff --git a/drivers/cpufreq/imx6q-cpufreq.c b/drivers/cpufreq/imx6q-cpufreq.c
index c2d30765bf3d..5da1d131f770 100644
--- a/drivers/cpufreq/imx6q-cpufreq.c
+++ b/drivers/cpufreq/imx6q-cpufreq.c
@@ -31,6 +31,7 @@ static struct clk *step_clk;
 static struct clk *pll2_pfd2_396m_clk;
 
 static struct device *cpu_dev;
+static bool free_opp;
 static struct cpufreq_frequency_table *freq_table;
 static unsigned int transition_latency;
 
@@ -207,11 +208,14 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev)
                         goto put_reg;
                 }
 
+                /* Because we have added the OPPs here, we must free them */
+                free_opp = true;
+
                 num = dev_pm_opp_get_opp_count(cpu_dev);
                 if (num < 0) {
                         ret = num;
                         dev_err(cpu_dev, "no OPP table is found: %d\n", ret);
-                        goto put_reg;
+                        goto out_free_opp;
                 }
         }
 
@@ -306,6 +310,9 @@ soc_opp_out:
 
 free_freq_table:
         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
+out_free_opp:
+        if (free_opp)
+                of_free_opp_table(cpu_dev);
 put_reg:
         if (!IS_ERR(arm_reg))
                 regulator_put(arm_reg);
@@ -332,6 +339,8 @@ static int imx6q_cpufreq_remove(struct platform_device *pdev)
 {
         cpufreq_unregister_driver(&imx6q_cpufreq_driver);
         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
+        if (free_opp)
+                of_free_opp_table(cpu_dev);
         regulator_put(arm_reg);
         if (!IS_ERR(pu_reg))
                 regulator_put(pu_reg);
diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index 27bb6d3877ed..1405b393c93d 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -137,6 +137,7 @@ struct cpu_defaults {
 
 static struct pstate_adjust_policy pid_params;
 static struct pstate_funcs pstate_funcs;
+static int hwp_active;
 
 struct perf_limits {
         int no_turbo;
@@ -244,6 +245,34 @@ static inline void update_turbo_state(void)
                  cpu->pstate.max_pstate == cpu->pstate.turbo_pstate);
 }
 
+#define PCT_TO_HWP(x) (x * 255 / 100)
+static void intel_pstate_hwp_set(void)
+{
+        int min, max, cpu;
+        u64 value, freq;
+
+        get_online_cpus();
+
+        for_each_online_cpu(cpu) {
+                rdmsrl_on_cpu(cpu, MSR_HWP_REQUEST, &value);
+                min = PCT_TO_HWP(limits.min_perf_pct);
+                value &= ~HWP_MIN_PERF(~0L);
+                value |= HWP_MIN_PERF(min);
+
+                max = PCT_TO_HWP(limits.max_perf_pct);
+                if (limits.no_turbo) {
+                        rdmsrl( MSR_HWP_CAPABILITIES, freq);
+                        max = HWP_GUARANTEED_PERF(freq);
+                }
+
+                value &= ~HWP_MAX_PERF(~0L);
+                value |= HWP_MAX_PERF(max);
+                wrmsrl_on_cpu(cpu, MSR_HWP_REQUEST, value);
+        }
+
+        put_online_cpus();
+}
+
 /************************** debugfs begin ************************/
 static int pid_param_set(void *data, u64 val)
 {
@@ -279,6 +308,8 @@ static void __init intel_pstate_debug_expose_params(void)
         struct dentry *debugfs_parent;
         int i = 0;
 
+        if (hwp_active)
+                return;
         debugfs_parent = debugfs_create_dir("pstate_snb", NULL);
         if (IS_ERR_OR_NULL(debugfs_parent))
                 return;
@@ -329,8 +360,12 @@ static ssize_t store_no_turbo(struct kobject *a, struct attribute *b,
                 pr_warn("Turbo disabled by BIOS or unavailable on processor\n");
                 return -EPERM;
         }
+
         limits.no_turbo = clamp_t(int, input, 0, 1);
 
+        if (hwp_active)
+                intel_pstate_hwp_set();
+
         return count;
 }
 
@@ -348,6 +383,8 @@ static ssize_t store_max_perf_pct(struct kobject *a, struct attribute *b,
         limits.max_perf_pct = min(limits.max_policy_pct, limits.max_sysfs_pct);
         limits.max_perf = div_fp(int_tofp(limits.max_perf_pct), int_tofp(100));
 
+        if (hwp_active)
+                intel_pstate_hwp_set();
         return count;
 }
 
@@ -363,6 +400,8 @@ static ssize_t store_min_perf_pct(struct kobject *a, struct attribute *b,
         limits.min_perf_pct = clamp_t(int, input, 0 , 100);
         limits.min_perf = div_fp(int_tofp(limits.min_perf_pct), int_tofp(100));
 
+        if (hwp_active)
+                intel_pstate_hwp_set();
         return count;
 }
 
@@ -395,8 +434,16 @@ static void __init intel_pstate_sysfs_expose_params(void)
         rc = sysfs_create_group(intel_pstate_kobject, &intel_pstate_attr_group);
         BUG_ON(rc);
 }
-
 /************************** sysfs end ************************/
+
+static void intel_pstate_hwp_enable(void)
+{
+        hwp_active++;
+        pr_info("intel_pstate HWP enabled\n");
+
+        wrmsrl( MSR_PM_ENABLE, 0x1);
+}
+
 static int byt_get_min_pstate(void)
 {
         u64 value;
@@ -648,6 +695,14 @@ static inline void intel_pstate_sample(struct cpudata *cpu)
         cpu->prev_mperf = mperf;
 }
 
+static inline void intel_hwp_set_sample_time(struct cpudata *cpu)
+{
+        int delay;
+
+        delay = msecs_to_jiffies(50);
+        mod_timer_pinned(&cpu->timer, jiffies + delay);
+}
+
 static inline void intel_pstate_set_sample_time(struct cpudata *cpu)
 {
         int delay;
@@ -694,6 +749,14 @@ static inline void intel_pstate_adjust_busy_pstate(struct cpudata *cpu)
         intel_pstate_set_pstate(cpu, cpu->pstate.current_pstate - ctl);
 }
 
+static void intel_hwp_timer_func(unsigned long __data)
+{
+        struct cpudata *cpu = (struct cpudata *) __data;
+
+        intel_pstate_sample(cpu);
+        intel_hwp_set_sample_time(cpu);
+}
+
 static void intel_pstate_timer_func(unsigned long __data)
 {
         struct cpudata *cpu = (struct cpudata *) __data;
@@ -730,6 +793,7 @@ static const struct x86_cpu_id intel_pstate_cpu_ids[] = {
         ICPU(0x3f, core_params),
         ICPU(0x45, core_params),
         ICPU(0x46, core_params),
+        ICPU(0x47, core_params),
         ICPU(0x4c, byt_params),
         ICPU(0x4f, core_params),
         ICPU(0x56, core_params),
@@ -737,6 +801,11 @@ static const struct x86_cpu_id intel_pstate_cpu_ids[] = {
 };
 MODULE_DEVICE_TABLE(x86cpu, intel_pstate_cpu_ids);
 
+static const struct x86_cpu_id intel_pstate_cpu_oob_ids[] = {
+        ICPU(0x56, core_params),
+        {}
+};
+
 static int intel_pstate_init_cpu(unsigned int cpunum)
 {
         struct cpudata *cpu;
@@ -753,9 +822,14 @@ static int intel_pstate_init_cpu(unsigned int cpunum)
         intel_pstate_get_cpu_pstates(cpu);
 
         init_timer_deferrable(&cpu->timer);
-        cpu->timer.function = intel_pstate_timer_func;
         cpu->timer.data = (unsigned long)cpu;
         cpu->timer.expires = jiffies + HZ/100;
+
+        if (!hwp_active)
+                cpu->timer.function = intel_pstate_timer_func;
+        else
+                cpu->timer.function = intel_hwp_timer_func;
+
         intel_pstate_busy_pid_reset(cpu);
         intel_pstate_sample(cpu);
 
@@ -792,6 +866,7 @@ static int intel_pstate_set_policy(struct cpufreq_policy *policy)
                 limits.no_turbo = 0;
                 return 0;
         }
+
         limits.min_perf_pct = (policy->min * 100) / policy->cpuinfo.max_freq;
         limits.min_perf_pct = clamp_t(int, limits.min_perf_pct, 0 , 100);
         limits.min_perf = div_fp(int_tofp(limits.min_perf_pct), int_tofp(100));
@@ -801,6 +876,9 @@ static int intel_pstate_set_policy(struct cpufreq_policy *policy)
         limits.max_perf_pct = min(limits.max_policy_pct, limits.max_sysfs_pct);
         limits.max_perf = div_fp(int_tofp(limits.max_perf_pct), int_tofp(100));
 
+        if (hwp_active)
+                intel_pstate_hwp_set();
+
         return 0;
 }
 
@@ -823,6 +901,9 @@ static void intel_pstate_stop_cpu(struct cpufreq_policy *policy)
         pr_info("intel_pstate CPU %d exiting\n", cpu_num);
 
         del_timer_sync(&all_cpu_data[cpu_num]->timer);
+        if (hwp_active)
+                return;
+
         intel_pstate_set_pstate(cpu, cpu->pstate.min_pstate);
 }
 
@@ -866,6 +947,7 @@ static struct cpufreq_driver intel_pstate_driver = {
 };
 
 static int __initdata no_load;
+static int __initdata no_hwp;
 
 static int intel_pstate_msrs_not_valid(void)
 {
@@ -943,15 +1025,46 @@ static bool intel_pstate_no_acpi_pss(void)
         return true;
 }
 
+static bool intel_pstate_has_acpi_ppc(void)
+{
+        int i;
+
+        for_each_possible_cpu(i) {
+                struct acpi_processor *pr = per_cpu(processors, i);
+
+                if (!pr)
+                        continue;
+                if (acpi_has_method(pr->handle, "_PPC"))
+                        return true;
+        }
+        return false;
+}
+
+enum {
+        PSS,
+        PPC,
+};
+
 struct hw_vendor_info {
         u16  valid;
         char oem_id[ACPI_OEM_ID_SIZE];
         char oem_table_id[ACPI_OEM_TABLE_ID_SIZE];
+        int  oem_pwr_table;
 };
 
 /* Hardware vendor-specific info that has its own power management modes */
 static struct hw_vendor_info vendor_info[] = {
-        {1, "HP    ", "ProLiant"},
+        {1, "HP    ", "ProLiant", PSS},
+        {1, "ORACLE", "X4-2    ", PPC},
+        {1, "ORACLE", "X4-2L   ", PPC},
+        {1, "ORACLE", "X4-2B   ", PPC},
+        {1, "ORACLE", "X3-2    ", PPC},
+        {1, "ORACLE", "X3-2L   ", PPC},
+        {1, "ORACLE", "X3-2B   ", PPC},
+        {1, "ORACLE", "X4470M2 ", PPC},
+        {1, "ORACLE", "X4270M3 ", PPC},
+        {1, "ORACLE", "X4270M2 ", PPC},
+        {1, "ORACLE", "X4170M2 ", PPC},
         {0, "", ""},
 };
 
@@ -959,6 +1072,15 @@ static bool intel_pstate_platform_pwr_mgmt_exists(void)
 {
         struct acpi_table_header hdr;
         struct hw_vendor_info *v_info;
+        const struct x86_cpu_id *id;
+        u64 misc_pwr;
+
+        id = x86_match_cpu(intel_pstate_cpu_oob_ids);
+        if (id) {
+                rdmsrl(MSR_MISC_PWR_MGMT, misc_pwr);
+                if ( misc_pwr & (1 << 8))
+                        return true;
+        }
 
         if (acpi_disabled ||
             ACPI_FAILURE(acpi_get_table_header(ACPI_SIG_FADT, 0, &hdr)))
@@ -966,15 +1088,21 @@ static bool intel_pstate_platform_pwr_mgmt_exists(void)
 
         for (v_info = vendor_info; v_info->valid; v_info++) {
                 if (!strncmp(hdr.oem_id, v_info->oem_id, ACPI_OEM_ID_SIZE) &&
-                    !strncmp(hdr.oem_table_id, v_info->oem_table_id, ACPI_OEM_TABLE_ID_SIZE) &&
-                    intel_pstate_no_acpi_pss())
-                        return true;
+                        !strncmp(hdr.oem_table_id, v_info->oem_table_id,
+                                                ACPI_OEM_TABLE_ID_SIZE))
+                        switch (v_info->oem_pwr_table) {
+                        case PSS:
+                                return intel_pstate_no_acpi_pss();
+                        case PPC:
+                                return intel_pstate_has_acpi_ppc();
+                        }
         }
 
         return false;
 }
 #else /* CONFIG_ACPI not enabled */
 static inline bool intel_pstate_platform_pwr_mgmt_exists(void) { return false; }
+static inline bool intel_pstate_has_acpi_ppc(void) { return false; }
 #endif /* CONFIG_ACPI */
 
 static int __init intel_pstate_init(void)
@@ -982,6 +1110,7 @@ static int __init intel_pstate_init(void)
         int cpu, rc = 0;
         const struct x86_cpu_id *id;
         struct cpu_defaults *cpu_info;
+        struct cpuinfo_x86 *c = &boot_cpu_data;
 
         if (no_load)
                 return -ENODEV;
@@ -1011,6 +1140,9 @@ static int __init intel_pstate_init(void)
         if (!all_cpu_data)
                 return -ENOMEM;
 
+        if (cpu_has(c,X86_FEATURE_HWP) && !no_hwp)
+                intel_pstate_hwp_enable();
+
         rc = cpufreq_register_driver(&intel_pstate_driver);
         if (rc)
                 goto out;
@@ -1041,6 +1173,8 @@ static int __init intel_pstate_setup(char *str)
 
         if (!strcmp(str, "disable"))
                 no_load = 1;
+        if (!strcmp(str, "no_hwp"))
+                no_hwp = 1;
         return 0;
 }
 early_param("intel_pstate", intel_pstate_setup);
diff --git a/drivers/cpufreq/ls1x-cpufreq.c b/drivers/cpufreq/ls1x-cpufreq.c
new file mode 100644
index 000000000000..25fbd6a1374f
--- /dev/null
+++ b/drivers/cpufreq/ls1x-cpufreq.c
@@ -0,0 +1,223 @@
+/*
+ * CPU Frequency Scaling for Loongson 1 SoC
+ *
+ * Copyright (C) 2014 Zhang, Keguang <keguang.zhang@gmail.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/cpu.h>
+#include <linux/cpufreq.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <asm/mach-loongson1/cpufreq.h>
+#include <asm/mach-loongson1/loongson1.h>
+
+static struct {
+        struct device *dev;
+        struct clk *clk;        /* CPU clk */
+        struct clk *mux_clk;    /* MUX of CPU clk */
+        struct clk *pll_clk;    /* PLL clk */
+        struct clk *osc_clk;    /* OSC clk */
+        unsigned int max_freq;
+        unsigned int min_freq;
+} ls1x_cpufreq;
+
+static int ls1x_cpufreq_notifier(struct notifier_block *nb,
+                                 unsigned long val, void *data)
+{
+        if (val == CPUFREQ_POSTCHANGE)
+                current_cpu_data.udelay_val = loops_per_jiffy;
+
+        return NOTIFY_OK;
+}
+
+static struct notifier_block ls1x_cpufreq_notifier_block = {
+        .notifier_call = ls1x_cpufreq_notifier
+};
+
+static int ls1x_cpufreq_target(struct cpufreq_policy *policy,
+                               unsigned int index)
+{
+        unsigned int old_freq, new_freq;
+
+        old_freq = policy->cur;
+        new_freq = policy->freq_table[index].frequency;
+
+        /*
+         * The procedure of reconfiguring CPU clk is as below.
+         *
+         *  - Reparent CPU clk to OSC clk
+         *  - Reset CPU clock (very important)
+         *  - Reconfigure CPU DIV
+         *  - Reparent CPU clk back to CPU DIV clk
+         */
+
+        dev_dbg(ls1x_cpufreq.dev, "%u KHz --> %u KHz\n", old_freq, new_freq);
+        clk_set_parent(policy->clk, ls1x_cpufreq.osc_clk);
+        __raw_writel(__raw_readl(LS1X_CLK_PLL_DIV) | RST_CPU_EN | RST_CPU,
+                     LS1X_CLK_PLL_DIV);
+        __raw_writel(__raw_readl(LS1X_CLK_PLL_DIV) & ~(RST_CPU_EN | RST_CPU),
+                     LS1X_CLK_PLL_DIV);
+        clk_set_rate(ls1x_cpufreq.mux_clk, new_freq * 1000);
+        clk_set_parent(policy->clk, ls1x_cpufreq.mux_clk);
+
+        return 0;
+}
+
+static int ls1x_cpufreq_init(struct cpufreq_policy *policy)
+{
+        struct cpufreq_frequency_table *freq_tbl;
+        unsigned int pll_freq, freq;
+        int steps, i, ret;
+
+        pll_freq = clk_get_rate(ls1x_cpufreq.pll_clk) / 1000;
+
+        steps = 1 << DIV_CPU_WIDTH;
+        freq_tbl = kzalloc(sizeof(*freq_tbl) * steps, GFP_KERNEL);
+        if (!freq_tbl) {
+                dev_err(ls1x_cpufreq.dev,
+                        "failed to alloc cpufreq_frequency_table\n");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        for (i = 0; i < (steps - 1); i++) {
+                freq = pll_freq / (i + 1);
+                if ((freq < ls1x_cpufreq.min_freq) ||
+                    (freq > ls1x_cpufreq.max_freq))
+                        freq_tbl[i].frequency = CPUFREQ_ENTRY_INVALID;
+                else
+                        freq_tbl[i].frequency = freq;
+                dev_dbg(ls1x_cpufreq.dev,
+                        "cpufreq table: index %d: frequency %d\n", i,
+                        freq_tbl[i].frequency);
+        }
+        freq_tbl[i].frequency = CPUFREQ_TABLE_END;
+
+        policy->clk = ls1x_cpufreq.clk;
+        ret = cpufreq_generic_init(policy, freq_tbl, 0);
+        if (ret)
+                kfree(freq_tbl);
+out:
+        return ret;
+}
+
+static int ls1x_cpufreq_exit(struct cpufreq_policy *policy)
+{
+        kfree(policy->freq_table);
+        return 0;
+}
+
+static struct cpufreq_driver ls1x_cpufreq_driver = {
+        .name           = "cpufreq-ls1x",
+        .flags          = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
+        .verify         = cpufreq_generic_frequency_table_verify,
+        .target_index   = ls1x_cpufreq_target,
+        .get            = cpufreq_generic_get,
+        .init           = ls1x_cpufreq_init,
+        .exit           = ls1x_cpufreq_exit,
+        .attr           = cpufreq_generic_attr,
+};
+
+static int ls1x_cpufreq_remove(struct platform_device *pdev)
+{
+        cpufreq_unregister_notifier(&ls1x_cpufreq_notifier_block,
+                                    CPUFREQ_TRANSITION_NOTIFIER);
+        cpufreq_unregister_driver(&ls1x_cpufreq_driver);
+
+        return 0;
+}
+
+static int ls1x_cpufreq_probe(struct platform_device *pdev)
+{
+        struct plat_ls1x_cpufreq *pdata = pdev->dev.platform_data;
+        struct clk *clk;
+        int ret;
+
+        if (!pdata || !pdata->clk_name || !pdata->osc_clk_name)
+                return -EINVAL;
+
+        ls1x_cpufreq.dev = &pdev->dev;
+
+        clk = devm_clk_get(&pdev->dev, pdata->clk_name);
+        if (IS_ERR(clk)) {
+                dev_err(ls1x_cpufreq.dev, "unable to get %s clock\n",
+                        pdata->clk_name);
+                ret = PTR_ERR(clk);
+                goto out;
+        }
+        ls1x_cpufreq.clk = clk;
+
+        clk = clk_get_parent(clk);
+        if (IS_ERR(clk)) {
+                dev_err(ls1x_cpufreq.dev, "unable to get parent of %s clock\n",
+                        __clk_get_name(ls1x_cpufreq.clk));
+                ret = PTR_ERR(clk);
+                goto out;
+        }
+        ls1x_cpufreq.mux_clk = clk;
+
+        clk = clk_get_parent(clk);
+        if (IS_ERR(clk)) {
+                dev_err(ls1x_cpufreq.dev, "unable to get parent of %s clock\n",
+                        __clk_get_name(ls1x_cpufreq.mux_clk));
+                ret = PTR_ERR(clk);
+                goto out;
+        }
+        ls1x_cpufreq.pll_clk = clk;
+
+        clk = devm_clk_get(&pdev->dev, pdata->osc_clk_name);
+        if (IS_ERR(clk)) {
+                dev_err(ls1x_cpufreq.dev, "unable to get %s clock\n",
+                        pdata->osc_clk_name);
+                ret = PTR_ERR(clk);
+                goto out;
+        }
+        ls1x_cpufreq.osc_clk = clk;
+
+        ls1x_cpufreq.max_freq = pdata->max_freq;
+        ls1x_cpufreq.min_freq = pdata->min_freq;
+
+        ret = cpufreq_register_driver(&ls1x_cpufreq_driver);
+        if (ret) {
+                dev_err(ls1x_cpufreq.dev,
+                        "failed to register cpufreq driver: %d\n", ret);
+                goto out;
+        }
+
+        ret = cpufreq_register_notifier(&ls1x_cpufreq_notifier_block,
+                                        CPUFREQ_TRANSITION_NOTIFIER);
+
+        if (!ret)
+                goto out;
+
+        dev_err(ls1x_cpufreq.dev, "failed to register cpufreq notifier: %d\n",
+                ret);
+
+        cpufreq_unregister_driver(&ls1x_cpufreq_driver);
+out:
+        return ret;
+}
+
+static struct platform_driver ls1x_cpufreq_platdrv = {
+        .driver = {
+                .name   = "ls1x-cpufreq",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ls1x_cpufreq_probe,
+        .remove         = ls1x_cpufreq_remove,
+};
+
+module_platform_driver(ls1x_cpufreq_platdrv);
+
+MODULE_AUTHOR("Kelvin Cheung <keguang.zhang@gmail.com>");
+MODULE_DESCRIPTION("Loongson 1 CPUFreq driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/cpufreq/pcc-cpufreq.c b/drivers/cpufreq/pcc-cpufreq.c
index 4d2c8e861089..2a0d58959acf 100644
--- a/drivers/cpufreq/pcc-cpufreq.c
+++ b/drivers/cpufreq/pcc-cpufreq.c
@@ -603,6 +603,13 @@ static void __exit pcc_cpufreq_exit(void)
         free_percpu(pcc_cpu_info);
 }
 
+static const struct acpi_device_id processor_device_ids[] = {
+        {ACPI_PROCESSOR_OBJECT_HID, },
+        {ACPI_PROCESSOR_DEVICE_HID, },
+        {},
+};
+MODULE_DEVICE_TABLE(acpi, processor_device_ids);
+
 MODULE_AUTHOR("Matthew Garrett, Naga Chumbalkar");
 MODULE_VERSION(PCC_VERSION);
 MODULE_DESCRIPTION("Processor Clocking Control interface driver");
diff --git a/drivers/cpuidle/cpuidle-arm64.c b/drivers/cpuidle/cpuidle-arm64.c
index 50997ea942fc..80704b931ba4 100644
--- a/drivers/cpuidle/cpuidle-arm64.c
+++ b/drivers/cpuidle/cpuidle-arm64.c
@@ -73,7 +73,6 @@ static struct cpuidle_driver arm64_idle_driver = {
                 .exit_latency           = 1,
                 .target_residency       = 1,
                 .power_usage            = UINT_MAX,
-                .flags                  = CPUIDLE_FLAG_TIME_VALID,
                 .name                   = "WFI",
                 .desc                   = "ARM64 WFI",
         }
@@ -104,11 +103,8 @@ static int __init arm64_idle_init(void)
          * reason to initialize the idle driver if only wfi is supported.
          */
         ret = dt_init_idle_driver(drv, arm64_idle_state_match, 1);
-        if (ret <= 0) {
-                if (ret)
-                        pr_err("failed to initialize idle states\n");
+        if (ret <= 0)
                 return ret ? : -ENODEV;
-        }
 
         /*
          * Call arch CPU operations in order to initialize
@@ -122,12 +118,6 @@ static int __init arm64_idle_init(void)
                 }
         }
 
-        ret = cpuidle_register(drv, NULL);
-        if (ret) {
-                pr_err("failed to register cpuidle driver\n");
-                return ret;
-        }
-
-        return 0;
+        return cpuidle_register(drv, NULL);
 }
 device_initcall(arm64_idle_init);
diff --git a/drivers/cpuidle/cpuidle-at91.c b/drivers/cpuidle/cpuidle-at91.c
index a0774370c6bc..1964ff07117c 100644
--- a/drivers/cpuidle/cpuidle-at91.c
+++ b/drivers/cpuidle/cpuidle-at91.c
@@ -43,7 +43,6 @@ static struct cpuidle_driver at91_idle_driver = {
                 .enter                  = at91_enter_idle,
                 .exit_latency           = 10,
                 .target_residency       = 10000,
-                .flags                  = CPUIDLE_FLAG_TIME_VALID,
                 .name                   = "RAM_SR",
                 .desc                   = "WFI and DDR Self Refresh",
         },
diff --git a/drivers/cpuidle/cpuidle-big_little.c b/drivers/cpuidle/cpuidle-big_little.c
index fbc00a1d3c48..e3e225fe6b45 100644
--- a/drivers/cpuidle/cpuidle-big_little.c
+++ b/drivers/cpuidle/cpuidle-big_little.c
@@ -67,8 +67,7 @@ static struct cpuidle_driver bl_idle_little_driver = {
                 .enter                  = bl_enter_powerdown,
                 .exit_latency           = 700,
                 .target_residency       = 2500,
-                .flags                  = CPUIDLE_FLAG_TIME_VALID |
-                                          CPUIDLE_FLAG_TIMER_STOP,
+                .flags                  = CPUIDLE_FLAG_TIMER_STOP,
                 .name                   = "C1",
                 .desc                   = "ARM little-cluster power down",
         },
@@ -89,8 +88,7 @@ static struct cpuidle_driver bl_idle_big_driver = {
                 .enter                  = bl_enter_powerdown,
                 .exit_latency           = 500,
                 .target_residency       = 2000,
-                .flags                  = CPUIDLE_FLAG_TIME_VALID |
-                                          CPUIDLE_FLAG_TIMER_STOP,
+                .flags                  = CPUIDLE_FLAG_TIMER_STOP,
                 .name                   = "C1",
                 .desc                   = "ARM big-cluster power down",
         },
diff --git a/drivers/cpuidle/cpuidle-calxeda.c b/drivers/cpuidle/cpuidle-calxeda.c
index 6e51114057d0..6541b0bfdfaa 100644
--- a/drivers/cpuidle/cpuidle-calxeda.c
+++ b/drivers/cpuidle/cpuidle-calxeda.c
@@ -55,7 +55,6 @@ static struct cpuidle_driver calxeda_idle_driver = {
                 {
                         .name = "PG",
                         .desc = "Power Gate",
-                        .flags = CPUIDLE_FLAG_TIME_VALID,
                         .exit_latency = 30,
                         .power_usage = 50,
                         .target_residency = 200,
diff --git a/drivers/cpuidle/cpuidle-cps.c b/drivers/cpuidle/cpuidle-cps.c
index fc7b62720deb..1adb6980b707 100644
--- a/drivers/cpuidle/cpuidle-cps.c
+++ b/drivers/cpuidle/cpuidle-cps.c
@@ -79,7 +79,6 @@ static struct cpuidle_driver cps_driver = {
                         .enter  = cps_nc_enter,
                         .exit_latency           = 200,
                         .target_residency       = 450,
-                        .flags  = CPUIDLE_FLAG_TIME_VALID,
                         .name   = "nc-wait",
                         .desc   = "non-coherent MIPS wait",
                 },
@@ -87,8 +86,7 @@ static struct cpuidle_driver cps_driver = {
                         .enter  = cps_nc_enter,
                         .exit_latency           = 300,
                         .target_residency       = 700,
-                        .flags  = CPUIDLE_FLAG_TIME_VALID |
-                                  CPUIDLE_FLAG_TIMER_STOP,
+                        .flags  = CPUIDLE_FLAG_TIMER_STOP,
                         .name   = "clock-gated",
                         .desc   = "core clock gated",
                 },
@@ -96,8 +94,7 @@ static struct cpuidle_driver cps_driver = {
                         .enter  = cps_nc_enter,
                         .exit_latency           = 600,
                         .target_residency       = 1000,
-                        .flags  = CPUIDLE_FLAG_TIME_VALID |
-                                  CPUIDLE_FLAG_TIMER_STOP,
+                        .flags  = CPUIDLE_FLAG_TIMER_STOP,
                         .name   = "power-gated",
                         .desc   = "core power gated",
                 },
diff --git a/drivers/cpuidle/cpuidle-exynos.c b/drivers/cpuidle/cpuidle-exynos.c
index ba9b34b579f3..64d12a855ec6 100644
--- a/drivers/cpuidle/cpuidle-exynos.c
+++ b/drivers/cpuidle/cpuidle-exynos.c
@@ -47,7 +47,6 @@ static struct cpuidle_driver exynos_idle_driver = {
                         .enter                  = exynos_enter_lowpower,
                         .exit_latency           = 300,
                         .target_residency       = 100000,
-                        .flags                  = CPUIDLE_FLAG_TIME_VALID,
                         .name                   = "C1",
                         .desc                   = "ARM power down",
                 },
diff --git a/drivers/cpuidle/cpuidle-kirkwood.c b/drivers/cpuidle/cpuidle-kirkwood.c
index 41ba843251b8..d88f8d7c2143 100644
--- a/drivers/cpuidle/cpuidle-kirkwood.c
+++ b/drivers/cpuidle/cpuidle-kirkwood.c
@@ -47,7 +47,6 @@ static struct cpuidle_driver kirkwood_idle_driver = {
                 .enter                  = kirkwood_enter_idle,
                 .exit_latency           = 10,
                 .target_residency       = 100000,
-                .flags                  = CPUIDLE_FLAG_TIME_VALID,
                 .name                   = "DDR SR",
                 .desc                   = "WFI and DDR Self Refresh",
         },
diff --git a/drivers/cpuidle/cpuidle-mvebu-v7.c b/drivers/cpuidle/cpuidle-mvebu-v7.c
index 45371bb16214..dd4c176df2a3 100644
--- a/drivers/cpuidle/cpuidle-mvebu-v7.c
+++ b/drivers/cpuidle/cpuidle-mvebu-v7.c
@@ -53,7 +53,6 @@ static struct cpuidle_driver armadaxp_idle_driver = {
                 .exit_latency           = 10,
                 .power_usage            = 50,
                 .target_residency       = 100,
-                .flags                  = CPUIDLE_FLAG_TIME_VALID,
                 .name                   = "MV CPU IDLE",
                 .desc                   = "CPU power down",
         },
@@ -62,8 +61,7 @@ static struct cpuidle_driver armadaxp_idle_driver = {
                 .exit_latency           = 100,
                 .power_usage            = 5,
                 .target_residency       = 1000,
-                .flags                  = CPUIDLE_FLAG_TIME_VALID |
-                                                MVEBU_V7_FLAG_DEEP_IDLE,
+                .flags                  = MVEBU_V7_FLAG_DEEP_IDLE,
                 .name                   = "MV CPU DEEP IDLE",
                 .desc                   = "CPU and L2 Fabric power down",
         },
@@ -78,8 +76,7 @@ static struct cpuidle_driver armada370_idle_driver = {
                 .exit_latency           = 100,
                 .power_usage            = 5,
                 .target_residency       = 1000,
-                .flags                  = (CPUIDLE_FLAG_TIME_VALID |
-                                           MVEBU_V7_FLAG_DEEP_IDLE),
+                .flags                  = MVEBU_V7_FLAG_DEEP_IDLE,
                 .name                   = "Deep Idle",
                 .desc                   = "CPU and L2 Fabric power down",
         },
@@ -94,7 +91,6 @@ static struct cpuidle_driver armada38x_idle_driver = {
                 .exit_latency           = 10,
                 .power_usage            = 5,
                 .target_residency       = 100,
-                .flags                  = CPUIDLE_FLAG_TIME_VALID,
                 .name                   = "Idle",
                 .desc                   = "CPU and SCU power down",
         },
diff --git a/drivers/cpuidle/cpuidle-powernv.c b/drivers/cpuidle/cpuidle-powernv.c
index 7d3a3497dd4c..e9248bb9173a 100644
--- a/drivers/cpuidle/cpuidle-powernv.c
+++ b/drivers/cpuidle/cpuidle-powernv.c
@@ -93,7 +93,6 @@ static struct cpuidle_state powernv_states[MAX_POWERNV_IDLE_STATES] = {
         { /* Snooze */
                 .name = "snooze",
                 .desc = "snooze",
-                .flags = CPUIDLE_FLAG_TIME_VALID,
                 .exit_latency = 0,
                 .target_residency = 0,
                 .enter = &snooze_loop },
@@ -202,7 +201,7 @@ static int powernv_add_idle_states(void)
                         /* Add NAP state */
                         strcpy(powernv_states[nr_idle_states].name, "Nap");
                         strcpy(powernv_states[nr_idle_states].desc, "Nap");
-                        powernv_states[nr_idle_states].flags = CPUIDLE_FLAG_TIME_VALID;
+                        powernv_states[nr_idle_states].flags = 0;
                         powernv_states[nr_idle_states].exit_latency =
                                         ((unsigned int)latency_ns) / 1000;
                         powernv_states[nr_idle_states].target_residency =
@@ -215,8 +214,7 @@ static int powernv_add_idle_states(void)
                         /* Add FASTSLEEP state */
                         strcpy(powernv_states[nr_idle_states].name, "FastSleep");
                         strcpy(powernv_states[nr_idle_states].desc, "FastSleep");
-                        powernv_states[nr_idle_states].flags =
-                                CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TIMER_STOP;
+                        powernv_states[nr_idle_states].flags = CPUIDLE_FLAG_TIMER_STOP;
                         powernv_states[nr_idle_states].exit_latency =
                                         ((unsigned int)latency_ns) / 1000;
                         powernv_states[nr_idle_states].target_residency =
diff --git a/drivers/cpuidle/cpuidle-pseries.c b/drivers/cpuidle/cpuidle-pseries.c
index 6f7b01956885..bb9e2b6f3ecc 100644
--- a/drivers/cpuidle/cpuidle-pseries.c
+++ b/drivers/cpuidle/cpuidle-pseries.c
@@ -142,14 +142,12 @@ static struct cpuidle_state dedicated_states[] = {
         { /* Snooze */
                 .name = "snooze",
                 .desc = "snooze",
-                .flags = CPUIDLE_FLAG_TIME_VALID,
                 .exit_latency = 0,
                 .target_residency = 0,
                 .enter = &snooze_loop },
         { /* CEDE */
                 .name = "CEDE",
                 .desc = "CEDE",
-                .flags = CPUIDLE_FLAG_TIME_VALID,
                 .exit_latency = 10,
                 .target_residency = 100,
                 .enter = &dedicated_cede_loop },
@@ -162,7 +160,6 @@ static struct cpuidle_state shared_states[] = {
         { /* Shared Cede */
                 .name = "Shared Cede",
                 .desc = "Shared Cede",
-                .flags = CPUIDLE_FLAG_TIME_VALID,
                 .exit_latency = 0,
                 .target_residency = 0,
                 .enter = &shared_cede_loop },
diff --git a/drivers/cpuidle/cpuidle-ux500.c b/drivers/cpuidle/cpuidle-ux500.c
index 5e35804b1a95..292e65a90308 100644
--- a/drivers/cpuidle/cpuidle-ux500.c
+++ b/drivers/cpuidle/cpuidle-ux500.c
@@ -101,8 +101,7 @@ static struct cpuidle_driver ux500_idle_driver = {
                         .enter            = ux500_enter_idle,
                         .exit_latency     = 70,
                         .target_residency = 260,
-                        .flags            = CPUIDLE_FLAG_TIME_VALID |
-                                            CPUIDLE_FLAG_TIMER_STOP,
+                        .flags            = CPUIDLE_FLAG_TIMER_STOP,
                         .name             = "ApIdle",
                         .desc             = "ARM Retention",
                 },
diff --git a/drivers/cpuidle/cpuidle-zynq.c b/drivers/cpuidle/cpuidle-zynq.c
index c61b8b2a7c77..022dec86de8e 100644
--- a/drivers/cpuidle/cpuidle-zynq.c
+++ b/drivers/cpuidle/cpuidle-zynq.c
@@ -52,7 +52,6 @@ static struct cpuidle_driver zynq_idle_driver = {
                         .enter                  = zynq_enter_idle,
                         .exit_latency           = 10,
                         .target_residency       = 10000,
-                        .flags                  = CPUIDLE_FLAG_TIME_VALID,
                         .name                   = "RAM_SR",
                         .desc                   = "WFI and RAM Self Refresh",
                 },
diff --git a/drivers/cpuidle/driver.c b/drivers/cpuidle/driver.c
index e431d11abf8d..2697e87d5b34 100644
--- a/drivers/cpuidle/driver.c
+++ b/drivers/cpuidle/driver.c
@@ -201,7 +201,6 @@ static void poll_idle_init(struct cpuidle_driver *drv)
         state->exit_latency = 0;
         state->target_residency = 0;
         state->power_usage = -1;
-        state->flags = CPUIDLE_FLAG_TIME_VALID;
         state->enter = poll_idle;
         state->disabled = false;
 }
diff --git a/drivers/cpuidle/dt_idle_states.c b/drivers/cpuidle/dt_idle_states.c
index 52f4d11bbf3f..a5c111b67f37 100644
--- a/drivers/cpuidle/dt_idle_states.c
+++ b/drivers/cpuidle/dt_idle_states.c
@@ -27,6 +27,7 @@ static int init_state_node(struct cpuidle_state *idle_state,
 {
         int err;
         const struct of_device_id *match_id;
+        const char *desc;
 
         match_id = of_match_node(matches, state_node);
         if (!match_id)
@@ -73,7 +74,11 @@ static int init_state_node(struct cpuidle_state *idle_state,
                 return -EINVAL;
         }
 
-        idle_state->flags = CPUIDLE_FLAG_TIME_VALID;
+        err = of_property_read_string(state_node, "idle-state-name", &desc);
+        if (err)
+                desc = state_node->name;
+
+        idle_state->flags = 0;
         if (of_property_read_bool(state_node, "local-timer-stop"))
                 idle_state->flags |= CPUIDLE_FLAG_TIMER_STOP;
         /*
@@ -82,7 +87,7 @@ static int init_state_node(struct cpuidle_state *idle_state,
          *      and desc become string pointers
          */
         strncpy(idle_state->name, state_node->name, CPUIDLE_NAME_LEN - 1);
-        strncpy(idle_state->desc, state_node->name, CPUIDLE_DESC_LEN - 1);
+        strncpy(idle_state->desc, desc, CPUIDLE_DESC_LEN - 1);
         return 0;
 }
 
@@ -169,6 +174,9 @@ int dt_init_idle_driver(struct cpuidle_driver *drv,
                 if (!state_node)
                         break;
 
+                if (!of_device_is_available(state_node))
+                        continue;
+
                 if (!idle_state_valid(state_node, i, cpumask)) {
                         pr_warn("%s idle state not valid, bailing out\n",
                                 state_node->full_name);
diff --git a/drivers/cpuidle/governors/ladder.c b/drivers/cpuidle/governors/ladder.c
index 06b57c4c4d80..37263d9a1051 100644
--- a/drivers/cpuidle/governors/ladder.c
+++ b/drivers/cpuidle/governors/ladder.c
@@ -79,7 +79,7 @@ static int ladder_select_state(struct cpuidle_driver *drv,
 
         last_state = &ldev->states[last_idx];
 
-        if (drv->states[last_idx].flags & CPUIDLE_FLAG_TIME_VALID) {
+        if (!(drv->states[last_idx].flags & CPUIDLE_FLAG_TIME_INVALID)) {
                 last_residency = cpuidle_get_last_residency(dev) - \
                                          drv->states[last_idx].exit_latency;
         }
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index 710a233b9b0d..659d7b0c9ebf 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -405,7 +405,7 @@ static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
          * the measured amount of time is less than the exit latency,
          * assume the state was never reached and the exit latency is 0.
          */
-        if (unlikely(!(target->flags & CPUIDLE_FLAG_TIME_VALID))) {
+        if (unlikely(target->flags & CPUIDLE_FLAG_TIME_INVALID)) {
                 /* Use timer value as is */
                 measured_us = data->next_timer_us;
 
diff --git a/drivers/dma/dw/core.c b/drivers/dma/dw/core.c
index 244722170410..380478562b7d 100644
--- a/drivers/dma/dw/core.c
+++ b/drivers/dma/dw/core.c
@@ -22,6 +22,7 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 #include "../dmaengine.h"
 #include "internal.h"
@@ -1504,6 +1505,9 @@ int dw_dma_probe(struct dw_dma_chip *chip, struct dw_dma_platform_data *pdata)
         dw->regs = chip->regs;
         chip->dw = dw;
 
+        pm_runtime_enable(chip->dev);
+        pm_runtime_get_sync(chip->dev);
+
         dw_params = dma_read_byaddr(chip->regs, DW_PARAMS);
         autocfg = dw_params >> DW_PARAMS_EN & 0x1;
 
@@ -1667,11 +1671,14 @@ int dw_dma_probe(struct dw_dma_chip *chip, struct dw_dma_platform_data *pdata)
         dev_info(chip->dev, "DesignWare DMA Controller, %d channels\n",
                  nr_channels);
 
+        pm_runtime_put_sync_suspend(chip->dev);
+
         return 0;
 
 err_dma_register:
         free_irq(chip->irq, dw);
 err_pdata:
+        pm_runtime_put_sync_suspend(chip->dev);
         return err;
 }
 EXPORT_SYMBOL_GPL(dw_dma_probe);
@@ -1681,6 +1688,8 @@ int dw_dma_remove(struct dw_dma_chip *chip)
         struct dw_dma           *dw = chip->dw;
         struct dw_dma_chan      *dwc, *_dwc;
 
+        pm_runtime_get_sync(chip->dev);
+
         dw_dma_off(dw);
         dma_async_device_unregister(&dw->dma);
 
@@ -1693,6 +1702,8 @@ int dw_dma_remove(struct dw_dma_chip *chip)
                 channel_clear_bit(dw, CH_EN, dwc->mask);
         }
 
+        pm_runtime_put_sync_suspend(chip->dev);
+        pm_runtime_disable(chip->dev);
         return 0;
 }
 EXPORT_SYMBOL_GPL(dw_dma_remove);
diff --git a/drivers/dma/nbpfaxi.c b/drivers/dma/nbpfaxi.c
index 5aeada56a442..bda20e6e1007 100644
--- a/drivers/dma/nbpfaxi.c
+++ b/drivers/dma/nbpfaxi.c
@@ -1479,7 +1479,7 @@ static struct platform_device_id nbpf_ids[] = {
 };
 MODULE_DEVICE_TABLE(platform, nbpf_ids);
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int nbpf_runtime_suspend(struct device *dev)
 {
         struct nbpf_device *nbpf = platform_get_drvdata(to_platform_device(dev));
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index 5fe59335e247..d9ca3e32d748 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -3051,7 +3051,7 @@ static int dma40_runtime_resume(struct device *dev)
 
 static const struct dev_pm_ops dma40_pm_ops = {
         SET_LATE_SYSTEM_SLEEP_PM_OPS(dma40_suspend, dma40_resume)
-        SET_PM_RUNTIME_PM_OPS(dma40_runtime_suspend,
+        SET_RUNTIME_PM_OPS(dma40_runtime_suspend,
                                 dma40_runtime_resume,
                                 NULL)
 };
diff --git a/drivers/dma/tegra20-apb-dma.c b/drivers/dma/tegra20-apb-dma.c
index 16efa603ff65..1c867d0303db 100644
--- a/drivers/dma/tegra20-apb-dma.c
+++ b/drivers/dma/tegra20-apb-dma.c
@@ -1587,7 +1587,7 @@ static int tegra_dma_pm_resume(struct device *dev)
 #endif
 
 static const struct dev_pm_ops tegra_dma_dev_pm_ops = {
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         .runtime_suspend = tegra_dma_runtime_suspend,
         .runtime_resume = tegra_dma_runtime_resume,
 #endif
diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index 7072c2892d63..49c265255a07 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -61,14 +61,14 @@ config EDAC_DECODE_MCE
           has been initialized.
 
 config EDAC_MCE_INJ
-        tristate "Simple MCE injection interface over /sysfs"
-        depends on EDAC_DECODE_MCE
+        tristate "Simple MCE injection interface"
+        depends on EDAC_DECODE_MCE && DEBUG_FS
         default n
         help
-          This is a simple interface to inject MCEs over /sysfs and test
-          the MCE decoding code in EDAC.
+          This is a simple debugfs interface to inject MCEs and test different
+          aspects of the MCE handling code.
 
-          This is currently AMD-only.
+          WARNING: Do not even assume this interface is staying stable!
 
 config EDAC_MM_EDAC
         tristate "Main Memory EDAC (Error Detection And Correction) reporting"
@@ -105,11 +105,11 @@ config EDAC_GHES
           In doubt, say 'Y'.
 
 config EDAC_AMD64
-        tristate "AMD64 (Opteron, Athlon64) K8, F10h"
-        depends on EDAC_MM_EDAC && AMD_NB && X86_64 && EDAC_DECODE_MCE
+        tristate "AMD64 (Opteron, Athlon64)"
+        depends on EDAC_MM_EDAC && AMD_NB && EDAC_DECODE_MCE
         help
           Support for error detection and correction of DRAM ECC errors on
-          the AMD64 families of memory controllers (K8 and F10h)
+          the AMD64 families (>= K8) of memory controllers.
 
 config EDAC_AMD64_ERROR_INJECTION
         bool "Sysfs HW Error injection facilities"
diff --git a/drivers/edac/Makefile b/drivers/edac/Makefile
index 359aa499b200..d40c69a04df7 100644
--- a/drivers/edac/Makefile
+++ b/drivers/edac/Makefile
@@ -9,7 +9,7 @@
 obj-$(CONFIG_EDAC)                      := edac_stub.o
 obj-$(CONFIG_EDAC_MM_EDAC)              += edac_core.o
 
-edac_core-y     := edac_mc.o edac_device.o edac_mc_sysfs.o edac_pci_sysfs.o
+edac_core-y     := edac_mc.o edac_device.o edac_mc_sysfs.o
 edac_core-y     += edac_module.o edac_device_sysfs.o
 
 ifdef CONFIG_PCI
diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c
index bbd65149cdb2..17638d7cf5c2 100644
--- a/drivers/edac/amd64_edac.c
+++ b/drivers/edac/amd64_edac.c
@@ -692,9 +692,19 @@ static void debug_dump_dramcfg_low(struct amd64_pvt *pvt, u32 dclr, int chan)
 {
         edac_dbg(1, "F2x%d90 (DRAM Cfg Low): 0x%08x\n", chan, dclr);
 
-        edac_dbg(1, "  DIMM type: %sbuffered; all DIMMs support ECC: %s\n",
-                 (dclr & BIT(16)) ?  "un" : "",
-                 (dclr & BIT(19)) ? "yes" : "no");
+        if (pvt->dram_type == MEM_LRDDR3) {
+                u32 dcsm = pvt->csels[chan].csmasks[0];
+                /*
+                 * It's assumed all LRDIMMs in a DCT are going to be of
+                 * same 'type' until proven otherwise. So, use a cs
+                 * value of '0' here to get dcsm value.
+                 */
+                edac_dbg(1, " LRDIMM %dx rank multiply\n", (dcsm & 0x3));
+        }
+
+        edac_dbg(1, "All DIMMs support ECC:%s\n",
+                    (dclr & BIT(19)) ? "yes" : "no");
+
 
         edac_dbg(1, "  PAR/ERR parity: %s\n",
                  (dclr & BIT(8)) ?  "enabled" : "disabled");
@@ -756,7 +766,7 @@ static void prep_chip_selects(struct amd64_pvt *pvt)
         if (pvt->fam == 0xf && pvt->ext_model < K8_REV_F) {
                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 8;
-        } else if (pvt->fam == 0x15 && pvt->model >= 0x30) {
+        } else if (pvt->fam == 0x15 && pvt->model == 0x30) {
                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 4;
                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 2;
         } else {
@@ -813,25 +823,63 @@ static void read_dct_base_mask(struct amd64_pvt *pvt)
         }
 }
 
-static enum mem_type determine_memory_type(struct amd64_pvt *pvt, int cs)
+static void determine_memory_type(struct amd64_pvt *pvt)
 {
-        enum mem_type type;
+        u32 dram_ctrl, dcsm;
 
-        /* F15h supports only DDR3 */
-        if (pvt->fam >= 0x15)
-                type = (pvt->dclr0 & BIT(16)) ? MEM_DDR3 : MEM_RDDR3;
-        else if (pvt->fam == 0x10 || pvt->ext_model >= K8_REV_F) {
+        switch (pvt->fam) {
+        case 0xf:
+                if (pvt->ext_model >= K8_REV_F)
+                        goto ddr3;
+
+                pvt->dram_type = (pvt->dclr0 & BIT(18)) ? MEM_DDR : MEM_RDDR;
+                return;
+
+        case 0x10:
                 if (pvt->dchr0 & DDR3_MODE)
-                        type = (pvt->dclr0 & BIT(16)) ? MEM_DDR3 : MEM_RDDR3;
+                        goto ddr3;
+
+                pvt->dram_type = (pvt->dclr0 & BIT(16)) ? MEM_DDR2 : MEM_RDDR2;
+                return;
+
+        case 0x15:
+                if (pvt->model < 0x60)
+                        goto ddr3;
+
+                /*
+                 * Model 0x60h needs special handling:
+                 *
+                 * We use a Chip Select value of '0' to obtain dcsm.
+                 * Theoretically, it is possible to populate LRDIMMs of different
+                 * 'Rank' value on a DCT. But this is not the common case. So,
+                 * it's reasonable to assume all DIMMs are going to be of same
+                 * 'type' until proven otherwise.
+                 */
+                amd64_read_dct_pci_cfg(pvt, 0, DRAM_CONTROL, &dram_ctrl);
+                dcsm = pvt->csels[0].csmasks[0];
+
+                if (((dram_ctrl >> 8) & 0x7) == 0x2)
+                        pvt->dram_type = MEM_DDR4;
+                else if (pvt->dclr0 & BIT(16))
+                        pvt->dram_type = MEM_DDR3;
+                else if (dcsm & 0x3)
+                        pvt->dram_type = MEM_LRDDR3;
                 else
-                        type = (pvt->dclr0 & BIT(16)) ? MEM_DDR2 : MEM_RDDR2;
-        } else {
-                type = (pvt->dclr0 & BIT(18)) ? MEM_DDR : MEM_RDDR;
-        }
+                        pvt->dram_type = MEM_RDDR3;
 
-        amd64_info("CS%d: %s\n", cs, edac_mem_types[type]);
+                return;
 
-        return type;
+        case 0x16:
+                goto ddr3;
+
+        default:
+                WARN(1, KERN_ERR "%s: Family??? 0x%x\n", __func__, pvt->fam);
+                pvt->dram_type = MEM_EMPTY;
+        }
+        return;
+
+ddr3:
+        pvt->dram_type = (pvt->dclr0 & BIT(16)) ? MEM_DDR3 : MEM_RDDR3;
 }
 
 /* Get the number of DCT channels the memory controller is using. */
@@ -958,8 +1006,12 @@ static void read_dram_base_limit_regs(struct amd64_pvt *pvt, unsigned range)
         if (WARN_ON(!nb))
                 return;
 
-        pci_func = (pvt->model == 0x30) ? PCI_DEVICE_ID_AMD_15H_M30H_NB_F1
-                                        : PCI_DEVICE_ID_AMD_15H_NB_F1;
+        if (pvt->model == 0x60)
+                pci_func = PCI_DEVICE_ID_AMD_15H_M60H_NB_F1;
+        else if (pvt->model == 0x30)
+                pci_func = PCI_DEVICE_ID_AMD_15H_M30H_NB_F1;
+        else
+                pci_func = PCI_DEVICE_ID_AMD_15H_NB_F1;
 
         f1 = pci_get_related_function(nb->misc->vendor, pci_func, nb->misc);
         if (WARN_ON(!f1))
@@ -1049,7 +1101,7 @@ static int ddr2_cs_size(unsigned i, bool dct_width)
 }
 
 static int k8_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
-                                  unsigned cs_mode)
+                                  unsigned cs_mode, int cs_mask_nr)
 {
         u32 dclr = dct ? pvt->dclr1 : pvt->dclr0;
 
@@ -1167,8 +1219,43 @@ static int ddr3_cs_size(unsigned i, bool dct_width)
         return cs_size;
 }
 
+static int ddr3_lrdimm_cs_size(unsigned i, unsigned rank_multiply)
+{
+        unsigned shift = 0;
+        int cs_size = 0;
+
+        if (i < 4 || i == 6)
+                cs_size = -1;
+        else if (i == 12)
+                shift = 7;
+        else if (!(i & 0x1))
+                shift = i >> 1;
+        else
+                shift = (i + 1) >> 1;
+
+        if (cs_size != -1)
+                cs_size = rank_multiply * (128 << shift);
+
+        return cs_size;
+}
+
+static int ddr4_cs_size(unsigned i)
+{
+        int cs_size = 0;
+
+        if (i == 0)
+                cs_size = -1;
+        else if (i == 1)
+                cs_size = 1024;
+        else
+                /* Min cs_size = 1G */
+                cs_size = 1024 * (1 << (i >> 1));
+
+        return cs_size;
+}
+
 static int f10_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
-                                   unsigned cs_mode)
+                                   unsigned cs_mode, int cs_mask_nr)
 {
         u32 dclr = dct ? pvt->dclr1 : pvt->dclr0;
 
@@ -1184,18 +1271,49 @@ static int f10_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
  * F15h supports only 64bit DCT interfaces
  */
 static int f15_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
-                                   unsigned cs_mode)
+                                   unsigned cs_mode, int cs_mask_nr)
 {
         WARN_ON(cs_mode > 12);
 
         return ddr3_cs_size(cs_mode, false);
 }
 
+/* F15h M60h supports DDR4 mapping as well.. */
+static int f15_m60h_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
+                                        unsigned cs_mode, int cs_mask_nr)
+{
+        int cs_size;
+        u32 dcsm = pvt->csels[dct].csmasks[cs_mask_nr];
+
+        WARN_ON(cs_mode > 12);
+
+        if (pvt->dram_type == MEM_DDR4) {
+                if (cs_mode > 9)
+                        return -1;
+
+                cs_size = ddr4_cs_size(cs_mode);
+        } else if (pvt->dram_type == MEM_LRDDR3) {
+                unsigned rank_multiply = dcsm & 0xf;
+
+                if (rank_multiply == 3)
+                        rank_multiply = 4;
+                cs_size = ddr3_lrdimm_cs_size(cs_mode, rank_multiply);
+        } else {
+                /* Minimum cs size is 512mb for F15hM60h*/
+                if (cs_mode == 0x1)
+                        return -1;
+
+                cs_size = ddr3_cs_size(cs_mode, false);
+        }
+
+        return cs_size;
+}
+
 /*
  * F16h and F15h model 30h have only limited cs_modes.
  */
 static int f16_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
-                                unsigned cs_mode)
+                                unsigned cs_mode, int cs_mask_nr)
 {
         WARN_ON(cs_mode > 12);
 
@@ -1757,13 +1875,20 @@ static void debug_display_dimm_sizes(struct amd64_pvt *pvt, u8 ctrl)
 
                 size0 = 0;
                 if (dcsb[dimm*2] & DCSB_CS_ENABLE)
+                        /* For f15m60h, need multiplier for LRDIMM cs_size
+                         * calculation. We pass 'dimm' value to the dbam_to_cs
+                         * mapper so we can find the multiplier from the
+                         * corresponding DCSM.
+                         */
                         size0 = pvt->ops->dbam_to_cs(pvt, ctrl,
-                                                     DBAM_DIMM(dimm, dbam));
+                                                     DBAM_DIMM(dimm, dbam),
+                                                     dimm);
 
                 size1 = 0;
                 if (dcsb[dimm*2 + 1] & DCSB_CS_ENABLE)
                         size1 = pvt->ops->dbam_to_cs(pvt, ctrl,
-                                                     DBAM_DIMM(dimm, dbam));
+                                                     DBAM_DIMM(dimm, dbam),
+                                                     dimm);
 
                 amd64_info(EDAC_MC ": %d: %5dMB %d: %5dMB\n",
                                 dimm * 2,     size0,
@@ -1812,6 +1937,16 @@ static struct amd64_family_type family_types[] = {
                         .dbam_to_cs             = f16_dbam_to_chip_select,
                 }
         },
+        [F15_M60H_CPUS] = {
+                .ctl_name = "F15h_M60h",
+                .f1_id = PCI_DEVICE_ID_AMD_15H_M60H_NB_F1,
+                .f3_id = PCI_DEVICE_ID_AMD_15H_M60H_NB_F3,
+                .ops = {
+                        .early_channel_count    = f1x_early_channel_count,
+                        .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
+                        .dbam_to_cs             = f15_m60h_dbam_to_chip_select,
+                }
+        },
         [F16_CPUS] = {
                 .ctl_name = "F16h",
                 .f1_id = PCI_DEVICE_ID_AMD_16H_NB_F1,
@@ -2175,6 +2310,8 @@ static void read_mc_regs(struct amd64_pvt *pvt)
         }
 
         pvt->ecc_sym_sz = 4;
+        determine_memory_type(pvt);
+        edac_dbg(1, "  DIMM type: %s\n", edac_mem_types[pvt->dram_type]);
 
         if (pvt->fam >= 0x10) {
                 amd64_read_pci_cfg(pvt->F3, EXT_NB_MCA_CFG, &tmp);
@@ -2238,7 +2375,8 @@ static u32 get_csrow_nr_pages(struct amd64_pvt *pvt, u8 dct, int csrow_nr)
          */
         cs_mode = DBAM_DIMM(csrow_nr / 2, dbam);
 
-        nr_pages = pvt->ops->dbam_to_cs(pvt, dct, cs_mode) << (20 - PAGE_SHIFT);
+        nr_pages = pvt->ops->dbam_to_cs(pvt, dct, cs_mode, (csrow_nr / 2))
+                                                           << (20 - PAGE_SHIFT);
 
         edac_dbg(0, "csrow: %d, channel: %d, DBAM idx: %d\n",
                     csrow_nr, dct,  cs_mode);
@@ -2257,7 +2395,6 @@ static int init_csrows(struct mem_ctl_info *mci)
         struct csrow_info *csrow;
         struct dimm_info *dimm;
         enum edac_type edac_mode;
-        enum mem_type mtype;
         int i, j, empty = 1;
         int nr_pages = 0;
         u32 val;
@@ -2302,8 +2439,6 @@ static int init_csrows(struct mem_ctl_info *mci)
                         nr_pages += row_dct1_pages;
                 }
 
-                mtype = determine_memory_type(pvt, i);
-
                 edac_dbg(1, "Total csrow%d pages: %u\n", i, nr_pages);
 
                 /*
@@ -2317,7 +2452,7 @@ static int init_csrows(struct mem_ctl_info *mci)
 
                 for (j = 0; j < pvt->channel_count; j++) {
                         dimm = csrow->channels[j]->dimm;
-                        dimm->mtype = mtype;
+                        dimm->mtype = pvt->dram_type;
                         dimm->edac_mode = edac_mode;
                 }
         }
@@ -2604,6 +2739,10 @@ static struct amd64_family_type *per_family_init(struct amd64_pvt *pvt)
                         fam_type = &family_types[F15_M30H_CPUS];
                         pvt->ops = &family_types[F15_M30H_CPUS].ops;
                         break;
+                } else if (pvt->model == 0x60) {
+                        fam_type = &family_types[F15_M60H_CPUS];
+                        pvt->ops = &family_types[F15_M60H_CPUS].ops;
+                        break;
                 }
 
                 fam_type        = &family_types[F15_CPUS];
@@ -2828,55 +2967,13 @@ static void remove_one_instance(struct pci_dev *pdev)
  * inquiry this table to see if this driver is for a given device found.
  */
 static const struct pci_device_id amd64_pci_table[] = {
-        {
-                .vendor         = PCI_VENDOR_ID_AMD,
-                .device         = PCI_DEVICE_ID_AMD_K8_NB_MEMCTL,
-                .subvendor      = PCI_ANY_ID,
-                .subdevice      = PCI_ANY_ID,
-                .class          = 0,
-                .class_mask     = 0,
-        },
-        {
-                .vendor         = PCI_VENDOR_ID_AMD,
-                .device         = PCI_DEVICE_ID_AMD_10H_NB_DRAM,
-                .subvendor      = PCI_ANY_ID,
-                .subdevice      = PCI_ANY_ID,
-                .class          = 0,
-                .class_mask     = 0,
-        },
-        {
-                .vendor         = PCI_VENDOR_ID_AMD,
-                .device         = PCI_DEVICE_ID_AMD_15H_NB_F2,
-                .subvendor      = PCI_ANY_ID,
-                .subdevice      = PCI_ANY_ID,
-                .class          = 0,
-                .class_mask     = 0,
-        },
-        {
-                .vendor         = PCI_VENDOR_ID_AMD,
-                .device         = PCI_DEVICE_ID_AMD_15H_M30H_NB_F2,
-                .subvendor      = PCI_ANY_ID,
-                .subdevice      = PCI_ANY_ID,
-                .class          = 0,
-                .class_mask     = 0,
-        },
-        {
-                .vendor         = PCI_VENDOR_ID_AMD,
-                .device         = PCI_DEVICE_ID_AMD_16H_NB_F2,
-                .subvendor      = PCI_ANY_ID,
-                .subdevice      = PCI_ANY_ID,
-                .class          = 0,
-                .class_mask     = 0,
-        },
-        {
-                .vendor         = PCI_VENDOR_ID_AMD,
-                .device         = PCI_DEVICE_ID_AMD_16H_M30H_NB_F2,
-                .subvendor      = PCI_ANY_ID,
-                .subdevice      = PCI_ANY_ID,
-                .class          = 0,
-                .class_mask     = 0,
-        },
-
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_K8_NB_MEMCTL) },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_10H_NB_DRAM) },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_NB_F2) },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_M30H_NB_F2) },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_M60H_NB_F2) },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_16H_NB_F2) },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_16H_M30H_NB_F2) },
         {0, }
 };
 MODULE_DEVICE_TABLE(pci, amd64_pci_table);
@@ -2938,6 +3035,11 @@ static int __init amd64_edac_init(void)
                 goto err_no_instances;
 
         setup_pci_device();
+
+#ifdef CONFIG_X86_32
+        amd64_err("%s on 32-bit is unsupported. USE AT YOUR OWN RISK!\n", EDAC_MOD_STR);
+#endif
+
         return 0;
 
 err_no_instances:
diff --git a/drivers/edac/amd64_edac.h b/drivers/edac/amd64_edac.h
index 55fb5941c6d4..d8468c667925 100644
--- a/drivers/edac/amd64_edac.h
+++ b/drivers/edac/amd64_edac.h
@@ -162,10 +162,12 @@
 /*
  * PCI-defined configuration space registers
  */
-#define PCI_DEVICE_ID_AMD_15H_M30H_NB_F1 0x141b
-#define PCI_DEVICE_ID_AMD_15H_M30H_NB_F2 0x141c
 #define PCI_DEVICE_ID_AMD_15H_NB_F1     0x1601
 #define PCI_DEVICE_ID_AMD_15H_NB_F2     0x1602
+#define PCI_DEVICE_ID_AMD_15H_M30H_NB_F1 0x141b
+#define PCI_DEVICE_ID_AMD_15H_M30H_NB_F2 0x141c
+#define PCI_DEVICE_ID_AMD_15H_M60H_NB_F1 0x1571
+#define PCI_DEVICE_ID_AMD_15H_M60H_NB_F2 0x1572
 #define PCI_DEVICE_ID_AMD_16H_NB_F1     0x1531
 #define PCI_DEVICE_ID_AMD_16H_NB_F2     0x1532
 #define PCI_DEVICE_ID_AMD_16H_M30H_NB_F1 0x1581
@@ -221,6 +223,8 @@
 
 #define csrow_enabled(i, dct, pvt)      ((pvt)->csels[(dct)].csbases[(i)] & DCSB_CS_ENABLE)
 
+#define DRAM_CONTROL                    0x78
+
 #define DBAM0                           0x80
 #define DBAM1                           0x180
 
@@ -301,6 +305,7 @@ enum amd_families {
         F10_CPUS,
         F15_CPUS,
         F15_M30H_CPUS,
+        F15_M60H_CPUS,
         F16_CPUS,
         F16_M30H_CPUS,
         NUM_FAMILIES,
@@ -379,6 +384,9 @@ struct amd64_pvt {
 
         /* place to store error injection parameters prior to issue */
         struct error_injection injection;
+
+        /* cache the dram_type */
+        enum mem_type dram_type;
 };
 
 enum err_codes {
@@ -480,7 +488,8 @@ struct low_ops {
         int (*early_channel_count)      (struct amd64_pvt *pvt);
         void (*map_sysaddr_to_csrow)    (struct mem_ctl_info *mci, u64 sys_addr,
                                          struct err_info *);
-        int (*dbam_to_cs)               (struct amd64_pvt *pvt, u8 dct, unsigned cs_mode);
+        int (*dbam_to_cs)               (struct amd64_pvt *pvt, u8 dct,
+                                         unsigned cs_mode, int cs_mask_nr);
 };
 
 struct amd64_family_type {
diff --git a/drivers/edac/edac_mc.c b/drivers/edac/edac_mc.c
index c3893b0ddb18..1747906f10ce 100644
--- a/drivers/edac/edac_mc.c
+++ b/drivers/edac/edac_mc.c
@@ -125,27 +125,27 @@ static void edac_mc_dump_mci(struct mem_ctl_info *mci)
 
 #endif                          /* CONFIG_EDAC_DEBUG */
 
-/*
- * keep those in sync with the enum mem_type
- */
 const char * const edac_mem_types[] = {
-        "Empty csrow",
-        "Reserved csrow type",
-        "Unknown csrow type",
-        "Fast page mode RAM",
-        "Extended data out RAM",
-        "Burst Extended data out RAM",
-        "Single data rate SDRAM",
-        "Registered single data rate SDRAM",
-        "Double data rate SDRAM",
-        "Registered Double data rate SDRAM",
-        "Rambus DRAM",
-        "Unbuffered DDR2 RAM",
-        "Fully buffered DDR2",
-        "Registered DDR2 RAM",
-        "Rambus XDR",
-        "Unbuffered DDR3 RAM",
-        "Registered DDR3 RAM",
+        [MEM_EMPTY]     = "Empty csrow",
+        [MEM_RESERVED]  = "Reserved csrow type",
+        [MEM_UNKNOWN]   = "Unknown csrow type",
+        [MEM_FPM]       = "Fast page mode RAM",
+        [MEM_EDO]       = "Extended data out RAM",
+        [MEM_BEDO]      = "Burst Extended data out RAM",
+        [MEM_SDR]       = "Single data rate SDRAM",
+        [MEM_RDR]       = "Registered single data rate SDRAM",
+        [MEM_DDR]       = "Double data rate SDRAM",
+        [MEM_RDDR]      = "Registered Double data rate SDRAM",
+        [MEM_RMBS]      = "Rambus DRAM",
+        [MEM_DDR2]      = "Unbuffered DDR2 RAM",
+        [MEM_FB_DDR2]   = "Fully buffered DDR2",
+        [MEM_RDDR2]     = "Registered DDR2 RAM",
+        [MEM_XDR]       = "Rambus XDR",
+        [MEM_DDR3]      = "Unbuffered DDR3 RAM",
+        [MEM_RDDR3]     = "Registered DDR3 RAM",
+        [MEM_LRDDR3]    = "Load-Reduced DDR3 RAM",
+        [MEM_DDR4]      = "Unbuffered DDR4 RAM",
+        [MEM_RDDR4]     = "Registered DDR4 RAM",
 };
 EXPORT_SYMBOL_GPL(edac_mem_types);
 
diff --git a/drivers/edac/edac_mc_sysfs.c b/drivers/edac/edac_mc_sysfs.c
index a6cd36100663..670d2829c547 100644
--- a/drivers/edac/edac_mc_sysfs.c
+++ b/drivers/edac/edac_mc_sysfs.c
@@ -372,7 +372,7 @@ static int edac_create_csrow_object(struct mem_ctl_info *mci,
 {
         int err, chan;
 
-        if (csrow->nr_channels >= EDAC_NR_CHANNELS)
+        if (csrow->nr_channels > EDAC_NR_CHANNELS)
                 return -ENODEV;
 
         csrow->dev.type = &csrow_attr_type;
diff --git a/drivers/edac/edac_pci_sysfs.c b/drivers/edac/edac_pci_sysfs.c
index e8658e451762..24d877f6e577 100644
--- a/drivers/edac/edac_pci_sysfs.c
+++ b/drivers/edac/edac_pci_sysfs.c
@@ -14,9 +14,6 @@
 #include "edac_core.h"
 #include "edac_module.h"
 
-/* Turn off this whole feature if PCI is not configured */
-#ifdef CONFIG_PCI
-
 #define EDAC_PCI_SYMLINK        "device"
 
 /* data variables exported via sysfs */
@@ -761,5 +758,3 @@ MODULE_PARM_DESC(check_pci_errors,
 module_param(edac_pci_panic_on_pe, int, 0644);
 MODULE_PARM_DESC(edac_pci_panic_on_pe,
                  "Panic on PCI Bus Parity error: 0=off 1=on");
-
-#endif                          /* CONFIG_PCI */
diff --git a/drivers/edac/ghes_edac.c b/drivers/edac/ghes_edac.c
index 8399b4e16fe0..b24681998740 100644
--- a/drivers/edac/ghes_edac.c
+++ b/drivers/edac/ghes_edac.c
@@ -413,8 +413,8 @@ void ghes_edac_report_mem_error(struct ghes *ghes, int sev,
 
         /* Generate the trace event */
         grain_bits = fls_long(e->grain);
-        sprintf(pvt->detail_location, "APEI location: %s %s",
-                e->location, e->other_detail);
+        snprintf(pvt->detail_location, sizeof(pvt->detail_location),
+                 "APEI location: %s %s", e->location, e->other_detail);
         trace_mc_event(type, e->msg, e->label, e->error_count,
                        mci->mc_idx, e->top_layer, e->mid_layer, e->low_layer,
                        PAGES_TO_MiB(e->page_frame_number) | e->offset_in_page,
diff --git a/drivers/edac/i3000_edac.c b/drivers/edac/i3000_edac.c
index cd28b968e5c7..5cb36a6022cc 100644
--- a/drivers/edac/i3000_edac.c
+++ b/drivers/edac/i3000_edac.c
@@ -542,8 +542,7 @@ fail1:
         pci_unregister_driver(&i3000_driver);
 
 fail0:
-        if (mci_pdev)
-                pci_dev_put(mci_pdev);
+        pci_dev_put(mci_pdev);
 
         return pci_rc;
 }
diff --git a/drivers/edac/i3200_edac.c b/drivers/edac/i3200_edac.c
index aa98b136f5d0..4ad062b0ef26 100644
--- a/drivers/edac/i3200_edac.c
+++ b/drivers/edac/i3200_edac.c
@@ -523,8 +523,7 @@ fail1:
         pci_unregister_driver(&i3200_driver);
 
 fail0:
-        if (mci_pdev)
-                pci_dev_put(mci_pdev);
+        pci_dev_put(mci_pdev);
 
         return pci_rc;
 }
diff --git a/drivers/edac/i82443bxgx_edac.c b/drivers/edac/i82443bxgx_edac.c
index d730e276d1a8..b4705d9366bf 100644
--- a/drivers/edac/i82443bxgx_edac.c
+++ b/drivers/edac/i82443bxgx_edac.c
@@ -458,8 +458,7 @@ static void __exit i82443bxgx_edacmc_exit(void)
         if (!i82443bxgx_registered)
                 i82443bxgx_edacmc_remove_one(mci_pdev);
 
-        if (mci_pdev)
-                pci_dev_put(mci_pdev);
+        pci_dev_put(mci_pdev);
 }
 
 module_init(i82443bxgx_edacmc_init);
diff --git a/drivers/edac/mce_amd.c b/drivers/edac/mce_amd.c
index f78c1c54dbd5..58586d59bf8e 100644
--- a/drivers/edac/mce_amd.c
+++ b/drivers/edac/mce_amd.c
@@ -138,6 +138,15 @@ static const char * const mc5_mce_desc[] = {
         "Retire status queue"
 };
 
+static const char * const mc6_mce_desc[] = {
+        "Hardware Assertion",
+        "Free List",
+        "Physical Register File",
+        "Retire Queue",
+        "Scheduler table",
+        "Status Register File",
+};
+
 static bool f12h_mc0_mce(u16 ec, u8 xec)
 {
         bool ret = false;
@@ -432,8 +441,8 @@ static bool k8_mc2_mce(u16 ec, u8 xec)
                 pr_cont(": %s error in the L2 cache tags.\n", R4_MSG(ec));
         else if (xec == 0x0) {
                 if (TLB_ERROR(ec))
-                        pr_cont(": %s error in a Page Descriptor Cache or "
-                                "Guest TLB.\n", TT_MSG(ec));
+                        pr_cont("%s error in a Page Descriptor Cache or Guest TLB.\n",
+                                TT_MSG(ec));
                 else if (BUS_ERROR(ec))
                         pr_cont(": %s/ECC error in data read from NB: %s.\n",
                                 R4_MSG(ec), PP_MSG(ec));
@@ -672,38 +681,10 @@ static void decode_mc6_mce(struct mce *m)
 
         pr_emerg(HW_ERR "MC6 Error: ");
 
-        switch (xec) {
-        case 0x0:
-                pr_cont("Hardware Assertion");
-                break;
-
-        case 0x1:
-                pr_cont("Free List");
-                break;
-
-        case 0x2:
-                pr_cont("Physical Register File");
-                break;
-
-        case 0x3:
-                pr_cont("Retire Queue");
-                break;
-
-        case 0x4:
-                pr_cont("Scheduler table");
-                break;
-
-        case 0x5:
-                pr_cont("Status Register File");
-                break;
-
-        default:
+        if (xec > 0x5)
                 goto wrong_mc6_mce;
-                break;
-        }
-
-        pr_cont(" parity error.\n");
 
+        pr_cont("%s parity error.\n", mc6_mce_desc[xec]);
         return;
 
  wrong_mc6_mce:
@@ -800,7 +781,7 @@ int amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data)
         pr_cont("]: 0x%016llx\n", m->status);
 
         if (m->status & MCI_STATUS_ADDRV)
-                pr_emerg(HW_ERR "MC%d_ADDR: 0x%016llx\n", m->bank, m->addr);
+                pr_emerg(HW_ERR "MC%d Error Address: 0x%016llx\n", m->bank, m->addr);
 
         if (!fam_ops)
                 goto err_code;
diff --git a/drivers/edac/mce_amd.h b/drivers/edac/mce_amd.h
index 51b7e3a36e37..c2359a1ea6b3 100644
--- a/drivers/edac/mce_amd.h
+++ b/drivers/edac/mce_amd.h
@@ -32,9 +32,6 @@
 #define R4(x)                           (((x) >> 4) & 0xf)
 #define R4_MSG(x)                       ((R4(x) < 9) ?  rrrr_msgs[R4(x)] : "Wrong R4!")
 
-#define MCI_STATUS_DEFERRED             BIT_64(44)
-#define MCI_STATUS_POISON               BIT_64(43)
-
 extern const char * const pp_msgs[];
 
 enum tt_ids {
diff --git a/drivers/edac/mce_amd_inj.c b/drivers/edac/mce_amd_inj.c
index 5e46a9fea31b..0bd91a802c67 100644
--- a/drivers/edac/mce_amd_inj.c
+++ b/drivers/edac/mce_amd_inj.c
@@ -1,173 +1,262 @@
 /*
- * A simple MCE injection facility for testing the MCE decoding code. This
- * driver should be built as module so that it can be loaded on production
- * kernels for testing purposes.
+ * A simple MCE injection facility for testing different aspects of the RAS
+ * code. This driver should be built as module so that it can be loaded
+ * on production kernels for testing purposes.
  *
  * This file may be distributed under the terms of the GNU General Public
  * License version 2.
  *
- * Copyright (c) 2010:  Borislav Petkov <bp@alien8.de>
+ * Copyright (c) 2010-14:  Borislav Petkov <bp@alien8.de>
  *                      Advanced Micro Devices Inc.
  */
 
 #include <linux/kobject.h>
+#include <linux/debugfs.h>
 #include <linux/device.h>
-#include <linux/edac.h>
 #include <linux/module.h>
+#include <linux/cpu.h>
 #include <asm/mce.h>
 
 #include "mce_amd.h"
 
-struct edac_mce_attr {
-        struct attribute attr;
-        ssize_t (*show) (struct kobject *kobj, struct edac_mce_attr *attr, char *buf);
-        ssize_t (*store)(struct kobject *kobj, struct edac_mce_attr *attr,
-                         const char *buf, size_t count);
-};
-
-#define EDAC_MCE_ATTR(_name, _mode, _show, _store)                      \
-static struct edac_mce_attr mce_attr_##_name = __ATTR(_name, _mode, _show, _store)
-
-static struct kobject *mce_kobj;
-
 /*
  * Collect all the MCi_XXX settings
  */
 static struct mce i_mce;
+static struct dentry *dfs_inj;
 
-#define MCE_INJECT_STORE(reg)                                           \
-static ssize_t edac_inject_##reg##_store(struct kobject *kobj,          \
-                                         struct edac_mce_attr *attr,    \
-                                         const char *data, size_t count)\
+#define MCE_INJECT_SET(reg)                                             \
+static int inj_##reg##_set(void *data, u64 val)                         \
 {                                                                       \
-        int ret = 0;                                                    \
-        unsigned long value;                                            \
-                                                                        \
-        ret = kstrtoul(data, 16, &value);                               \
-        if (ret < 0)                                                    \
-                printk(KERN_ERR "Error writing MCE " #reg " field.\n"); \
+        struct mce *m = (struct mce *)data;                             \
                                                                         \
-        i_mce.reg = value;                                              \
-                                                                        \
-        return count;                                                   \
+        m->reg = val;                                                   \
+        return 0;                                                       \
 }
 
-MCE_INJECT_STORE(status);
-MCE_INJECT_STORE(misc);
-MCE_INJECT_STORE(addr);
+MCE_INJECT_SET(status);
+MCE_INJECT_SET(misc);
+MCE_INJECT_SET(addr);
 
-#define MCE_INJECT_SHOW(reg)                                            \
-static ssize_t edac_inject_##reg##_show(struct kobject *kobj,           \
-                                        struct edac_mce_attr *attr,     \
-                                        char *buf)                      \
+#define MCE_INJECT_GET(reg)                                             \
+static int inj_##reg##_get(void *data, u64 *val)                        \
 {                                                                       \
-        return sprintf(buf, "0x%016llx\n", i_mce.reg);                  \
+        struct mce *m = (struct mce *)data;                             \
+                                                                        \
+        *val = m->reg;                                                  \
+        return 0;                                                       \
 }
 
-MCE_INJECT_SHOW(status);
-MCE_INJECT_SHOW(misc);
-MCE_INJECT_SHOW(addr);
+MCE_INJECT_GET(status);
+MCE_INJECT_GET(misc);
+MCE_INJECT_GET(addr);
 
-EDAC_MCE_ATTR(status, 0644, edac_inject_status_show, edac_inject_status_store);
-EDAC_MCE_ATTR(misc, 0644, edac_inject_misc_show, edac_inject_misc_store);
-EDAC_MCE_ATTR(addr, 0644, edac_inject_addr_show, edac_inject_addr_store);
+DEFINE_SIMPLE_ATTRIBUTE(status_fops, inj_status_get, inj_status_set, "%llx\n");
+DEFINE_SIMPLE_ATTRIBUTE(misc_fops, inj_misc_get, inj_misc_set, "%llx\n");
+DEFINE_SIMPLE_ATTRIBUTE(addr_fops, inj_addr_get, inj_addr_set, "%llx\n");
 
 /*
- * This denotes into which bank we're injecting and triggers
- * the injection, at the same time.
+ * Caller needs to be make sure this cpu doesn't disappear
+ * from under us, i.e.: get_cpu/put_cpu.
  */
-static ssize_t edac_inject_bank_store(struct kobject *kobj,
-                                      struct edac_mce_attr *attr,
-                                      const char *data, size_t count)
+static int toggle_hw_mce_inject(unsigned int cpu, bool enable)
 {
-        int ret = 0;
-        unsigned long value;
+        u32 l, h;
+        int err;
 
-        ret = kstrtoul(data, 10, &value);
-        if (ret < 0) {
-                printk(KERN_ERR "Invalid bank value!\n");
-                return -EINVAL;
+        err = rdmsr_on_cpu(cpu, MSR_K7_HWCR, &l, &h);
+        if (err) {
+                pr_err("%s: error reading HWCR\n", __func__);
+                return err;
         }
 
-        if (value > 5)
-                if (boot_cpu_data.x86 != 0x15 || value > 6) {
-                        printk(KERN_ERR "Non-existent MCE bank: %lu\n", value);
-                        return -EINVAL;
-                }
+        enable ? (l |= BIT(18)) : (l &= ~BIT(18));
 
-        i_mce.bank = value;
+        err = wrmsr_on_cpu(cpu, MSR_K7_HWCR, l, h);
+        if (err)
+                pr_err("%s: error writing HWCR\n", __func__);
 
-        amd_decode_mce(NULL, 0, &i_mce);
+        return err;
+}
 
-        return count;
+static int flags_get(void *data, u64 *val)
+{
+        struct mce *m = (struct mce *)data;
+
+        *val = m->inject_flags;
+
+        return 0;
 }
 
-static ssize_t edac_inject_bank_show(struct kobject *kobj,
-                                     struct edac_mce_attr *attr, char *buf)
+static int flags_set(void *data, u64 val)
 {
-        return sprintf(buf, "%d\n", i_mce.bank);
+        struct mce *m = (struct mce *)data;
+
+        m->inject_flags = (u8)val;
+        return 0;
 }
 
-EDAC_MCE_ATTR(bank, 0644, edac_inject_bank_show, edac_inject_bank_store);
+DEFINE_SIMPLE_ATTRIBUTE(flags_fops, flags_get, flags_set, "%llu\n");
 
-static struct edac_mce_attr *sysfs_attrs[] = { &mce_attr_status, &mce_attr_misc,
-                                               &mce_attr_addr, &mce_attr_bank
-};
+/*
+ * On which CPU to inject?
+ */
+MCE_INJECT_GET(extcpu);
 
-static int __init edac_init_mce_inject(void)
+static int inj_extcpu_set(void *data, u64 val)
 {
-        struct bus_type *edac_subsys = NULL;
-        int i, err = 0;
+        struct mce *m = (struct mce *)data;
 
-        edac_subsys = edac_get_sysfs_subsys();
-        if (!edac_subsys)
+        if (val >= nr_cpu_ids || !cpu_online(val)) {
+                pr_err("%s: Invalid CPU: %llu\n", __func__, val);
                 return -EINVAL;
+        }
+        m->extcpu = val;
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(extcpu_fops, inj_extcpu_get, inj_extcpu_set, "%llu\n");
 
-        mce_kobj = kobject_create_and_add("mce", &edac_subsys->dev_root->kobj);
-        if (!mce_kobj) {
-                printk(KERN_ERR "Error creating a mce kset.\n");
-                err = -ENOMEM;
-                goto err_mce_kobj;
+static void trigger_mce(void *info)
+{
+        asm volatile("int $18");
+}
+
+static void do_inject(void)
+{
+        u64 mcg_status = 0;
+        unsigned int cpu = i_mce.extcpu;
+        u8 b = i_mce.bank;
+
+        if (!(i_mce.inject_flags & MCJ_EXCEPTION)) {
+                amd_decode_mce(NULL, 0, &i_mce);
+                return;
         }
 
-        for (i = 0; i < ARRAY_SIZE(sysfs_attrs); i++) {
-                err = sysfs_create_file(mce_kobj, &sysfs_attrs[i]->attr);
-                if (err) {
-                        printk(KERN_ERR "Error creating %s in sysfs.\n",
-                                        sysfs_attrs[i]->attr.name);
-                        goto err_sysfs_create;
+        get_online_cpus();
+        if (!cpu_online(cpu))
+                goto err;
+
+        /* prep MCE global settings for the injection */
+        mcg_status = MCG_STATUS_MCIP | MCG_STATUS_EIPV;
+
+        if (!(i_mce.status & MCI_STATUS_PCC))
+                mcg_status |= MCG_STATUS_RIPV;
+
+        toggle_hw_mce_inject(cpu, true);
+
+        wrmsr_on_cpu(cpu, MSR_IA32_MCG_STATUS,
+                     (u32)mcg_status, (u32)(mcg_status >> 32));
+
+        wrmsr_on_cpu(cpu, MSR_IA32_MCx_STATUS(b),
+                     (u32)i_mce.status, (u32)(i_mce.status >> 32));
+
+        wrmsr_on_cpu(cpu, MSR_IA32_MCx_ADDR(b),
+                     (u32)i_mce.addr, (u32)(i_mce.addr >> 32));
+
+        wrmsr_on_cpu(cpu, MSR_IA32_MCx_MISC(b),
+                     (u32)i_mce.misc, (u32)(i_mce.misc >> 32));
+
+        toggle_hw_mce_inject(cpu, false);
+
+        smp_call_function_single(cpu, trigger_mce, NULL, 0);
+
+err:
+        put_online_cpus();
+
+}
+
+/*
+ * This denotes into which bank we're injecting and triggers
+ * the injection, at the same time.
+ */
+static int inj_bank_set(void *data, u64 val)
+{
+        struct mce *m = (struct mce *)data;
+
+        if (val > 5) {
+                if (boot_cpu_data.x86 != 0x15 || val > 6) {
+                        pr_err("Non-existent MCE bank: %llu\n", val);
+                        return -EINVAL;
                 }
         }
-        return 0;
 
-err_sysfs_create:
-        while (--i >= 0)
-                sysfs_remove_file(mce_kobj, &sysfs_attrs[i]->attr);
+        m->bank = val;
+        do_inject();
 
-        kobject_del(mce_kobj);
+        return 0;
+}
 
-err_mce_kobj:
-        edac_put_sysfs_subsys();
+static int inj_bank_get(void *data, u64 *val)
+{
+        struct mce *m = (struct mce *)data;
 
-        return err;
+        *val = m->bank;
+        return 0;
 }
 
-static void __exit edac_exit_mce_inject(void)
+DEFINE_SIMPLE_ATTRIBUTE(bank_fops, inj_bank_get, inj_bank_set, "%llu\n");
+
+struct dfs_node {
+        char *name;
+        struct dentry *d;
+        const struct file_operations *fops;
+} dfs_fls[] = {
+        { .name = "status",     .fops = &status_fops },
+        { .name = "misc",       .fops = &misc_fops },
+        { .name = "addr",       .fops = &addr_fops },
+        { .name = "bank",       .fops = &bank_fops },
+        { .name = "flags",      .fops = &flags_fops },
+        { .name = "cpu",        .fops = &extcpu_fops },
+};
+
+static int __init init_mce_inject(void)
 {
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(sysfs_attrs); i++)
-                sysfs_remove_file(mce_kobj, &sysfs_attrs[i]->attr);
+        dfs_inj = debugfs_create_dir("mce-inject", NULL);
+        if (!dfs_inj)
+                return -EINVAL;
+
+        for (i = 0; i < ARRAY_SIZE(dfs_fls); i++) {
+                dfs_fls[i].d = debugfs_create_file(dfs_fls[i].name,
+                                                    S_IRUSR | S_IWUSR,
+                                                    dfs_inj,
+                                                    &i_mce,
+                                                    dfs_fls[i].fops);
+
+                if (!dfs_fls[i].d)
+                        goto err_dfs_add;
+        }
+
+        return 0;
+
+err_dfs_add:
+        while (--i >= 0)
+                debugfs_remove(dfs_fls[i].d);
 
-        kobject_del(mce_kobj);
+        debugfs_remove(dfs_inj);
+        dfs_inj = NULL;
 
-        edac_put_sysfs_subsys();
+        return -ENOMEM;
 }
 
-module_init(edac_init_mce_inject);
-module_exit(edac_exit_mce_inject);
+static void __exit exit_mce_inject(void)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(dfs_fls); i++)
+                debugfs_remove(dfs_fls[i].d);
+
+        memset(&dfs_fls, 0, sizeof(dfs_fls));
+
+        debugfs_remove(dfs_inj);
+        dfs_inj = NULL;
+}
+module_init(init_mce_inject);
+module_exit(exit_mce_inject);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Borislav Petkov <bp@alien8.de>");
 MODULE_AUTHOR("AMD Inc.");
-MODULE_DESCRIPTION("MCE injection facility for testing MCE decoding");
+MODULE_DESCRIPTION("MCE injection facility for RAS testing");
diff --git a/drivers/edac/mv64x60_edac.c b/drivers/edac/mv64x60_edac.c
index 542fad70e360..6366e880f978 100644
--- a/drivers/edac/mv64x60_edac.c
+++ b/drivers/edac/mv64x60_edac.c
@@ -178,7 +178,7 @@ static int mv64x60_pci_err_probe(struct platform_device *pdev)
                 res = devm_request_irq(&pdev->dev,
                                        pdata->irq,
                                        mv64x60_pci_isr,
-                                       IRQF_DISABLED,
+                                       0,
                                        "[EDAC] PCI err",
                                        pci);
                 if (res < 0) {
@@ -345,7 +345,7 @@ static int mv64x60_sram_err_probe(struct platform_device *pdev)
                 res = devm_request_irq(&pdev->dev,
                                        pdata->irq,
                                        mv64x60_sram_isr,
-                                       IRQF_DISABLED,
+                                       0,
                                        "[EDAC] SRAM err",
                                        edac_dev);
                 if (res < 0) {
@@ -540,7 +540,7 @@ static int mv64x60_cpu_err_probe(struct platform_device *pdev)
                 res = devm_request_irq(&pdev->dev,
                                        pdata->irq,
                                        mv64x60_cpu_isr,
-                                       IRQF_DISABLED,
+                                       0,
                                        "[EDAC] CPU err",
                                        edac_dev);
                 if (res < 0) {
@@ -800,7 +800,7 @@ static int mv64x60_mc_err_probe(struct platform_device *pdev)
                 res = devm_request_irq(&pdev->dev,
                                        pdata->irq,
                                        mv64x60_mc_isr,
-                                       IRQF_DISABLED,
+                                       0,
                                        "[EDAC] MC err",
                                        mci);
                 if (res < 0) {
diff --git a/drivers/edac/ppc4xx_edac.c b/drivers/edac/ppc4xx_edac.c
index 0f04d5ead521..41593539cec4 100644
--- a/drivers/edac/ppc4xx_edac.c
+++ b/drivers/edac/ppc4xx_edac.c
@@ -1120,7 +1120,7 @@ static int ppc4xx_edac_register_irq(struct platform_device *op,
 
         status = request_irq(ded_irq,
                              ppc4xx_edac_isr,
-                             IRQF_DISABLED,
+                             0,
                              "[EDAC] MC ECCDED",
                              mci);
 
@@ -1134,7 +1134,7 @@ static int ppc4xx_edac_register_irq(struct platform_device *op,
 
         status = request_irq(sec_irq,
                              ppc4xx_edac_isr,
-                             IRQF_DISABLED,
+                             0,
                              "[EDAC] MC ECCSEC",
                              mci);
 
diff --git a/drivers/edac/sb_edac.c b/drivers/edac/sb_edac.c
index e9bb1af67c8d..63aa6730e89e 100644
--- a/drivers/edac/sb_edac.c
+++ b/drivers/edac/sb_edac.c
@@ -135,6 +135,7 @@ static inline int sad_pkg(const struct interleave_pkg *table, u32 reg,
 
 #define TOLM            0x80
 #define TOHM            0x84
+#define HASWELL_TOLM    0xd0
 #define HASWELL_TOHM_0  0xd4
 #define HASWELL_TOHM_1  0xd8
 
@@ -261,6 +262,7 @@ enum type {
         SANDY_BRIDGE,
         IVY_BRIDGE,
         HASWELL,
+        BROADWELL,
 };
 
 struct sbridge_pvt;
@@ -445,7 +447,7 @@ static const struct pci_id_table pci_dev_descr_ibridge_table[] = {
  *      - each SMI channel interfaces with a scalable memory buffer
  *      - each scalable memory buffer supports 4 DDR3/DDR4 channels, 3 DPC
  */
-#define HASWELL_DDRCRCLKCONTROLS 0xa10
+#define HASWELL_DDRCRCLKCONTROLS 0xa10 /* Ditto on Broadwell */
 #define HASWELL_HASYSDEFEATURE2 0x84
 #define PCI_DEVICE_ID_INTEL_HASWELL_IMC_VTD_MISC 0x2f28
 #define PCI_DEVICE_ID_INTEL_HASWELL_IMC_HA0     0x2fa0
@@ -497,12 +499,53 @@ static const struct pci_id_table pci_dev_descr_haswell_table[] = {
 };
 
 /*
+ * Broadwell support
+ *
+ * DE processor:
+ *      - 1 IMC
+ *      - 2 DDR3 channels, 2 DPC per channel
+ */
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_VTD_MISC 0x6f28
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0   0x6fa0
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TA        0x6fa8
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_THERMAL 0x6f71
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_CBO_SAD0 0x6ffc
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_CBO_SAD1 0x6ffd
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD0 0x6faa
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD1 0x6fab
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD2 0x6fac
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD3 0x6fad
+#define PCI_DEVICE_ID_INTEL_BROADWELL_IMC_DDRIO0 0x6faf
+
+static const struct pci_id_descr pci_dev_descr_broadwell[] = {
+        /* first item must be the HA */
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0, 0)           },
+
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_CBO_SAD0, 0)      },
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_CBO_SAD1, 0)      },
+
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TA, 0)        },
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_THERMAL, 0)   },
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD0, 0)      },
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD1, 0)      },
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD2, 0)      },
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD3, 0)      },
+        { PCI_DESCR(PCI_DEVICE_ID_INTEL_BROADWELL_IMC_DDRIO0, 1)        },
+};
+
+static const struct pci_id_table pci_dev_descr_broadwell_table[] = {
+        PCI_ID_TABLE_ENTRY(pci_dev_descr_broadwell),
+        {0,}                    /* 0 terminated list. */
+};
+
+/*
  *      pci_device_id   table for which devices we are looking for
  */
 static const struct pci_device_id sbridge_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_HA0)},
         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IBRIDGE_IMC_HA0_TA)},
         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_HASWELL_IMC_HA0)},
+        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0)},
         {0,}                    /* 0 terminated list. */
 };
 
@@ -706,8 +749,8 @@ static u64 haswell_get_tolm(struct sbridge_pvt *pvt)
 {
         u32 reg;
 
-        pci_read_config_dword(pvt->info.pci_vtd, TOLM, &reg);
-        return (GET_BITFIELD(reg, 26, 31) << 26) | 0x1ffffff;
+        pci_read_config_dword(pvt->info.pci_vtd, HASWELL_TOLM, &reg);
+        return (GET_BITFIELD(reg, 26, 31) << 26) | 0x3ffffff;
 }
 
 static u64 haswell_get_tohm(struct sbridge_pvt *pvt)
@@ -767,12 +810,22 @@ static int check_if_ecc_is_active(const u8 bus, enum type type)
         struct pci_dev *pdev = NULL;
         u32 mcmtr, id;
 
-        if (type == IVY_BRIDGE)
+        switch (type) {
+        case IVY_BRIDGE:
                 id = PCI_DEVICE_ID_INTEL_IBRIDGE_IMC_HA0_TA;
-        else if (type == HASWELL)
+                break;
+        case HASWELL:
                 id = PCI_DEVICE_ID_INTEL_HASWELL_IMC_HA0_TA;
-        else
+                break;
+        case SANDY_BRIDGE:
                 id = PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_TA;
+                break;
+        case BROADWELL:
+                id = PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TA;
+                break;
+        default:
+                return -ENODEV;
+        }
 
         pdev = get_pdev_same_bus(bus, id);
         if (!pdev) {
@@ -800,7 +853,7 @@ static int get_dimm_config(struct mem_ctl_info *mci)
         enum edac_type mode;
         enum mem_type mtype;
 
-        if (pvt->info.type == HASWELL)
+        if (pvt->info.type == HASWELL || pvt->info.type == BROADWELL)
                 pci_read_config_dword(pvt->pci_sad1, SAD_TARGET, &reg);
         else
                 pci_read_config_dword(pvt->pci_br0, SAD_TARGET, &reg);
@@ -848,7 +901,7 @@ static int get_dimm_config(struct mem_ctl_info *mci)
         else
                 edac_dbg(0, "Memory is unregistered\n");
 
-        if (mtype == MEM_DDR4 || MEM_RDDR4)
+        if (mtype == MEM_DDR4 || mtype == MEM_RDDR4)
                 banks = 16;
         else
                 banks = 8;
@@ -909,7 +962,7 @@ static void get_memory_layout(const struct mem_ctl_info *mci)
         u32 reg;
         u64 limit, prv = 0;
         u64 tmp_mb;
-        u32 mb, kb;
+        u32 gb, mb;
         u32 rir_way;
 
         /*
@@ -919,15 +972,17 @@ static void get_memory_layout(const struct mem_ctl_info *mci)
         pvt->tolm = pvt->info.get_tolm(pvt);
         tmp_mb = (1 + pvt->tolm) >> 20;
 
-        mb = div_u64_rem(tmp_mb, 1000, &kb);
-        edac_dbg(0, "TOLM: %u.%03u GB (0x%016Lx)\n", mb, kb, (u64)pvt->tolm);
+        gb = div_u64_rem(tmp_mb, 1024, &mb);
+        edac_dbg(0, "TOLM: %u.%03u GB (0x%016Lx)\n",
+                gb, (mb*1000)/1024, (u64)pvt->tolm);
 
         /* Address range is already 45:25 */
         pvt->tohm = pvt->info.get_tohm(pvt);
         tmp_mb = (1 + pvt->tohm) >> 20;
 
-        mb = div_u64_rem(tmp_mb, 1000, &kb);
-        edac_dbg(0, "TOHM: %u.%03u GB (0x%016Lx)\n", mb, kb, (u64)pvt->tohm);
+        gb = div_u64_rem(tmp_mb, 1024, &mb);
+        edac_dbg(0, "TOHM: %u.%03u GB (0x%016Lx)\n",
+                gb, (mb*1000)/1024, (u64)pvt->tohm);
 
         /*
          * Step 2) Get SAD range and SAD Interleave list
@@ -949,11 +1004,11 @@ static void get_memory_layout(const struct mem_ctl_info *mci)
                         break;
 
                 tmp_mb = (limit + 1) >> 20;
-                mb = div_u64_rem(tmp_mb, 1000, &kb);
+                gb = div_u64_rem(tmp_mb, 1024, &mb);
                 edac_dbg(0, "SAD#%d %s up to %u.%03u GB (0x%016Lx) Interleave: %s reg=0x%08x\n",
                          n_sads,
                          get_dram_attr(reg),
-                         mb, kb,
+                         gb, (mb*1000)/1024,
                          ((u64)tmp_mb) << 20L,
                          INTERLEAVE_MODE(reg) ? "8:6" : "[8:6]XOR[18:16]",
                          reg);
@@ -984,9 +1039,9 @@ static void get_memory_layout(const struct mem_ctl_info *mci)
                         break;
                 tmp_mb = (limit + 1) >> 20;
 
-                mb = div_u64_rem(tmp_mb, 1000, &kb);
+                gb = div_u64_rem(tmp_mb, 1024, &mb);
                 edac_dbg(0, "TAD#%d: up to %u.%03u GB (0x%016Lx), socket interleave %d, memory interleave %d, TGT: %d, %d, %d, %d, reg=0x%08x\n",
-                         n_tads, mb, kb,
+                         n_tads, gb, (mb*1000)/1024,
                          ((u64)tmp_mb) << 20L,
                          (u32)TAD_SOCK(reg),
                          (u32)TAD_CH(reg),
@@ -1009,10 +1064,10 @@ static void get_memory_layout(const struct mem_ctl_info *mci)
                                               tad_ch_nilv_offset[j],
                                               &reg);
                         tmp_mb = TAD_OFFSET(reg) >> 20;
-                        mb = div_u64_rem(tmp_mb, 1000, &kb);
+                        gb = div_u64_rem(tmp_mb, 1024, &mb);
                         edac_dbg(0, "TAD CH#%d, offset #%d: %u.%03u GB (0x%016Lx), reg=0x%08x\n",
                                  i, j,
-                                 mb, kb,
+                                 gb, (mb*1000)/1024,
                                  ((u64)tmp_mb) << 20L,
                                  reg);
                 }
@@ -1034,10 +1089,10 @@ static void get_memory_layout(const struct mem_ctl_info *mci)
 
                         tmp_mb = pvt->info.rir_limit(reg) >> 20;
                         rir_way = 1 << RIR_WAY(reg);
-                        mb = div_u64_rem(tmp_mb, 1000, &kb);
+                        gb = div_u64_rem(tmp_mb, 1024, &mb);
                         edac_dbg(0, "CH#%d RIR#%d, limit: %u.%03u GB (0x%016Lx), way: %d, reg=0x%08x\n",
                                  i, j,
-                                 mb, kb,
+                                 gb, (mb*1000)/1024,
                                  ((u64)tmp_mb) << 20L,
                                  rir_way,
                                  reg);
@@ -1048,10 +1103,10 @@ static void get_memory_layout(const struct mem_ctl_info *mci)
                                                       &reg);
                                 tmp_mb = RIR_OFFSET(reg) << 6;
 
-                                mb = div_u64_rem(tmp_mb, 1000, &kb);
+                                gb = div_u64_rem(tmp_mb, 1024, &mb);
                                 edac_dbg(0, "CH#%d RIR#%d INTL#%d, offset %u.%03u GB (0x%016Lx), tgt: %d, reg=0x%08x\n",
                                          i, j, k,
-                                         mb, kb,
+                                         gb, (mb*1000)/1024,
                                          ((u64)tmp_mb) << 20L,
                                          (u32)RIR_RNK_TGT(reg),
                                          reg);
@@ -1089,7 +1144,7 @@ static int get_memory_error_data(struct mem_ctl_info *mci,
         u8                      ch_way, sck_way, pkg, sad_ha = 0;
         u32                     tad_offset;
         u32                     rir_way;
-        u32                     mb, kb;
+        u32                     mb, gb;
         u64                     ch_addr, offset, limit = 0, prv = 0;
 
 
@@ -1179,7 +1234,7 @@ static int get_memory_error_data(struct mem_ctl_info *mci,
                 *socket = sad_interleave[idx];
                 edac_dbg(0, "SAD interleave index: %d (wayness %d) = CPU socket %d\n",
                          idx, sad_way, *socket);
-        } else if (pvt->info.type == HASWELL) {
+        } else if (pvt->info.type == HASWELL || pvt->info.type == BROADWELL) {
                 int bits, a7mode = A7MODE(dram_rule);
 
                 if (a7mode) {
@@ -1358,10 +1413,10 @@ static int get_memory_error_data(struct mem_ctl_info *mci,
                         continue;
 
                 limit = pvt->info.rir_limit(reg);
-                mb = div_u64_rem(limit >> 20, 1000, &kb);
+                gb = div_u64_rem(limit >> 20, 1024, &mb);
                 edac_dbg(0, "RIR#%d, limit: %u.%03u GB (0x%016Lx), way: %d\n",
                          n_rir,
-                         mb, kb,
+                         gb, (mb*1000)/1024,
                          limit,
                          1 << RIR_WAY(reg));
                 if  (ch_addr <= limit)
@@ -1828,6 +1883,82 @@ enodev:
         return -ENODEV;
 }
 
+static int broadwell_mci_bind_devs(struct mem_ctl_info *mci,
+                                 struct sbridge_dev *sbridge_dev)
+{
+        struct sbridge_pvt *pvt = mci->pvt_info;
+        struct pci_dev *pdev;
+        int i;
+
+        /* there's only one device per system; not tied to any bus */
+        if (pvt->info.pci_vtd == NULL)
+                /* result will be checked later */
+                pvt->info.pci_vtd = pci_get_device(PCI_VENDOR_ID_INTEL,
+                                                   PCI_DEVICE_ID_INTEL_BROADWELL_IMC_VTD_MISC,
+                                                   NULL);
+
+        for (i = 0; i < sbridge_dev->n_devs; i++) {
+                pdev = sbridge_dev->pdev[i];
+                if (!pdev)
+                        continue;
+
+                switch (pdev->device) {
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_CBO_SAD0:
+                        pvt->pci_sad0 = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_CBO_SAD1:
+                        pvt->pci_sad1 = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0:
+                        pvt->pci_ha0 = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TA:
+                        pvt->pci_ta = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_THERMAL:
+                        pvt->pci_ras = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD0:
+                        pvt->pci_tad[0] = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD1:
+                        pvt->pci_tad[1] = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD2:
+                        pvt->pci_tad[2] = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0_TAD3:
+                        pvt->pci_tad[3] = pdev;
+                        break;
+                case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_DDRIO0:
+                        pvt->pci_ddrio = pdev;
+                        break;
+                default:
+                        break;
+                }
+
+                edac_dbg(0, "Associated PCI %02x.%02d.%d with dev = %p\n",
+                         sbridge_dev->bus,
+                         PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
+                         pdev);
+        }
+
+        /* Check if everything were registered */
+        if (!pvt->pci_sad0 || !pvt->pci_ha0 || !pvt->pci_sad1 ||
+            !pvt->pci_ras  || !pvt->pci_ta || !pvt->info.pci_vtd)
+                goto enodev;
+
+        for (i = 0; i < NUM_CHANNELS; i++) {
+                if (!pvt->pci_tad[i])
+                        goto enodev;
+        }
+        return 0;
+
+enodev:
+        sbridge_printk(KERN_ERR, "Some needed devices are missing\n");
+        return -ENODEV;
+}
+
 /****************************************************************************
                         Error check routines
  ****************************************************************************/
@@ -2240,6 +2371,25 @@ static int sbridge_register_mci(struct sbridge_dev *sbridge_dev, enum type type)
                 if (unlikely(rc < 0))
                         goto fail0;
                 break;
+        case BROADWELL:
+                /* rankcfgr isn't used */
+                pvt->info.get_tolm = haswell_get_tolm;
+                pvt->info.get_tohm = haswell_get_tohm;
+                pvt->info.dram_rule = ibridge_dram_rule;
+                pvt->info.get_memory_type = haswell_get_memory_type;
+                pvt->info.get_node_id = haswell_get_node_id;
+                pvt->info.rir_limit = haswell_rir_limit;
+                pvt->info.max_sad = ARRAY_SIZE(ibridge_dram_rule);
+                pvt->info.interleave_list = ibridge_interleave_list;
+                pvt->info.max_interleave = ARRAY_SIZE(ibridge_interleave_list);
+                pvt->info.interleave_pkg = ibridge_interleave_pkg;
+                mci->ctl_name = kasprintf(GFP_KERNEL, "Broadwell Socket#%d", mci->mc_idx);
+
+                /* Store pci devices at mci for faster access */
+                rc = broadwell_mci_bind_devs(mci, sbridge_dev);
+                if (unlikely(rc < 0))
+                        goto fail0;
+                break;
         }
 
         /* Get dimm basic config and the memory layout */
@@ -2305,6 +2455,10 @@ static int sbridge_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 rc = sbridge_get_all_devices(&num_mc, pci_dev_descr_haswell_table);
                 type = HASWELL;
                 break;
+        case PCI_DEVICE_ID_INTEL_BROADWELL_IMC_HA0:
+                rc = sbridge_get_all_devices(&num_mc, pci_dev_descr_broadwell_table);
+                type = BROADWELL;
+                break;
         }
         if (unlikely(rc < 0))
                 goto fail0;
diff --git a/drivers/edac/x38_edac.c b/drivers/edac/x38_edac.c
index e644b52c287c..7c5cdc62f31c 100644
--- a/drivers/edac/x38_edac.c
+++ b/drivers/edac/x38_edac.c
@@ -500,8 +500,7 @@ fail1:
         pci_unregister_driver(&x38_driver);
 
 fail0:
-        if (mci_pdev)
-                pci_dev_put(mci_pdev);
+        pci_dev_put(mci_pdev);
 
         return pci_rc;
 }
diff --git a/drivers/firmware/dmi_scan.c b/drivers/firmware/dmi_scan.c
index 17afc51f3054..c5f7b4e9eb6c 100644
--- a/drivers/firmware/dmi_scan.c
+++ b/drivers/firmware/dmi_scan.c
@@ -93,6 +93,12 @@ static void dmi_table(u8 *buf, int len, int num,
                 const struct dmi_header *dm = (const struct dmi_header *)data;
 
                 /*
+                 * 7.45 End-of-Table (Type 127) [SMBIOS reference spec v3.0.0]
+                 */
+                if (dm->type == DMI_ENTRY_END_OF_TABLE)
+                        break;
+
+                /*
                  *  We want to know the total length (formatted area and
                  *  strings) before decoding to make sure we won't run off the
                  *  table in dmi_decode or dmi_string
@@ -107,7 +113,7 @@ static void dmi_table(u8 *buf, int len, int num,
         }
 }
 
-static u32 dmi_base;
+static phys_addr_t dmi_base;
 static u16 dmi_len;
 static u16 dmi_num;
 
@@ -467,7 +473,7 @@ static int __init dmi_present(const u8 *buf)
 
         if (memcmp(buf, "_SM_", 4) == 0 &&
             buf[5] < 32 && dmi_checksum(buf, buf[5])) {
-                smbios_ver = (buf[6] << 8) + buf[7];
+                smbios_ver = get_unaligned_be16(buf + 6);
 
                 /* Some BIOS report weird SMBIOS version, fix that up */
                 switch (smbios_ver) {
@@ -489,10 +495,9 @@ static int __init dmi_present(const u8 *buf)
         buf += 16;
 
         if (memcmp(buf, "_DMI_", 5) == 0 && dmi_checksum(buf, 15)) {
-                dmi_num = (buf[13] << 8) | buf[12];
-                dmi_len = (buf[7] << 8) | buf[6];
-                dmi_base = (buf[11] << 24) | (buf[10] << 16) |
-                        (buf[9] << 8) | buf[8];
+                dmi_num = get_unaligned_le16(buf + 12);
+                dmi_len = get_unaligned_le16(buf + 6);
+                dmi_base = get_unaligned_le32(buf + 8);
 
                 if (dmi_walk_early(dmi_decode) == 0) {
                         if (smbios_ver) {
@@ -514,12 +519,72 @@ static int __init dmi_present(const u8 *buf)
         return 1;
 }
 
+/*
+ * Check for the SMBIOS 3.0 64-bit entry point signature. Unlike the legacy
+ * 32-bit entry point, there is no embedded DMI header (_DMI_) in here.
+ */
+static int __init dmi_smbios3_present(const u8 *buf)
+{
+        if (memcmp(buf, "_SM3_", 5) == 0 &&
+            buf[6] < 32 && dmi_checksum(buf, buf[6])) {
+                dmi_ver = get_unaligned_be16(buf + 7);
+                dmi_len = get_unaligned_le32(buf + 12);
+                dmi_base = get_unaligned_le64(buf + 16);
+
+                /*
+                 * The 64-bit SMBIOS 3.0 entry point no longer has a field
+                 * containing the number of structures present in the table.
+                 * Instead, it defines the table size as a maximum size, and
+                 * relies on the end-of-table structure type (#127) to be used
+                 * to signal the end of the table.
+                 * So let's define dmi_num as an upper bound as well: each
+                 * structure has a 4 byte header, so dmi_len / 4 is an upper
+                 * bound for the number of structures in the table.
+                 */
+                dmi_num = dmi_len / 4;
+
+                if (dmi_walk_early(dmi_decode) == 0) {
+                        pr_info("SMBIOS %d.%d present.\n",
+                                dmi_ver >> 8, dmi_ver & 0xFF);
+                        dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
+                        pr_debug("DMI: %s\n", dmi_ids_string);
+                        return 0;
+                }
+        }
+        return 1;
+}
+
 void __init dmi_scan_machine(void)
 {
         char __iomem *p, *q;
         char buf[32];
 
         if (efi_enabled(EFI_CONFIG_TABLES)) {
+                /*
+                 * According to the DMTF SMBIOS reference spec v3.0.0, it is
+                 * allowed to define both the 64-bit entry point (smbios3) and
+                 * the 32-bit entry point (smbios), in which case they should
+                 * either both point to the same SMBIOS structure table, or the
+                 * table pointed to by the 64-bit entry point should contain a
+                 * superset of the table contents pointed to by the 32-bit entry
+                 * point (section 5.2)
+                 * This implies that the 64-bit entry point should have
+                 * precedence if it is defined and supported by the OS. If we
+                 * have the 64-bit entry point, but fail to decode it, fall
+                 * back to the legacy one (if available)
+                 */
+                if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) {
+                        p = dmi_early_remap(efi.smbios3, 32);
+                        if (p == NULL)
+                                goto error;
+                        memcpy_fromio(buf, p, 32);
+                        dmi_early_unmap(p, 32);
+
+                        if (!dmi_smbios3_present(buf)) {
+                                dmi_available = 1;
+                                goto out;
+                        }
+                }
                 if (efi.smbios == EFI_INVALID_TABLE_ADDR)
                         goto error;
 
@@ -552,7 +617,7 @@ void __init dmi_scan_machine(void)
                 memset(buf, 0, 16);
                 for (q = p; q < p + 0x10000; q += 16) {
                         memcpy_fromio(buf + 16, q, 16);
-                        if (!dmi_present(buf)) {
+                        if (!dmi_smbios3_present(buf) || !dmi_present(buf)) {
                                 dmi_available = 1;
                                 dmi_early_unmap(p, 0x10000);
                                 goto out;
diff --git a/drivers/firmware/efi/Makefile b/drivers/firmware/efi/Makefile
index aef6a95adef5..d8be608a9f3b 100644
--- a/drivers/firmware/efi/Makefile
+++ b/drivers/firmware/efi/Makefile
@@ -7,4 +7,4 @@ obj-$(CONFIG_EFI_VARS_PSTORE)		+= efi-pstore.o
 obj-$(CONFIG_UEFI_CPER)                 += cper.o
 obj-$(CONFIG_EFI_RUNTIME_MAP)           += runtime-map.o
 obj-$(CONFIG_EFI_RUNTIME_WRAPPERS)      += runtime-wrappers.o
-obj-$(CONFIG_EFI_ARM_STUB)              += libstub/
+obj-$(CONFIG_EFI_STUB)                  += libstub/
diff --git a/drivers/firmware/efi/cper.c b/drivers/firmware/efi/cper.c
index 5b53d6183b6b..4fd9961d552e 100644
--- a/drivers/firmware/efi/cper.c
+++ b/drivers/firmware/efi/cper.c
@@ -294,7 +294,7 @@ void cper_mem_err_pack(const struct cper_sec_mem_err *mem,
 const char *cper_mem_err_unpack(struct trace_seq *p,
                                 struct cper_mem_err_compact *cmem)
 {
-        const char *ret = p->buffer + p->len;
+        const char *ret = trace_seq_buffer_ptr(p);
 
         if (cper_mem_err_location(cmem, rcd_decode_str))
                 trace_seq_printf(p, "%s", rcd_decode_str);
diff --git a/drivers/firmware/efi/efi.c b/drivers/firmware/efi/efi.c
index 8590099ac148..9035c1b74d58 100644
--- a/drivers/firmware/efi/efi.c
+++ b/drivers/firmware/efi/efi.c
@@ -30,6 +30,7 @@ struct efi __read_mostly efi = {
         .acpi       = EFI_INVALID_TABLE_ADDR,
         .acpi20     = EFI_INVALID_TABLE_ADDR,
         .smbios     = EFI_INVALID_TABLE_ADDR,
+        .smbios3    = EFI_INVALID_TABLE_ADDR,
         .sal_systab = EFI_INVALID_TABLE_ADDR,
         .boot_info  = EFI_INVALID_TABLE_ADDR,
         .hcdp       = EFI_INVALID_TABLE_ADDR,
@@ -86,6 +87,8 @@ static ssize_t systab_show(struct kobject *kobj,
                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
+        if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
+                str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
@@ -260,6 +263,7 @@ static __initdata efi_config_table_type_t common_tables[] = {
         {MPS_TABLE_GUID, "MPS", &efi.mps},
         {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
+        {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
         {NULL_GUID, NULL, NULL},
 };
diff --git a/drivers/firmware/efi/libstub/arm-stub.c b/drivers/firmware/efi/libstub/arm-stub.c
index 75ee05964cbc..eb48a1a1a576 100644
--- a/drivers/firmware/efi/libstub/arm-stub.c
+++ b/drivers/firmware/efi/libstub/arm-stub.c
@@ -247,9 +247,18 @@ unsigned long __init efi_entry(void *handle, efi_system_table_t *sys_table,
                         goto fail_free_cmdline;
                 }
         }
-        if (!fdt_addr)
+
+        if (fdt_addr) {
+                pr_efi(sys_table, "Using DTB from command line\n");
+        } else {
                 /* Look for a device tree configuration table entry. */
                 fdt_addr = (uintptr_t)get_fdt(sys_table);
+                if (fdt_addr)
+                        pr_efi(sys_table, "Using DTB from configuration table\n");
+        }
+
+        if (!fdt_addr)
+                pr_efi(sys_table, "Generating empty DTB\n");
 
         status = handle_cmdline_files(sys_table, image, cmdline_ptr,
                                       "initrd=", dram_base + SZ_512M,
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 0959ca9b6b27..23dfd5f59b39 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -905,4 +905,16 @@ config GPIO_VIPERBOARD
           River Tech's viperboard.h for detailed meaning
           of the module parameters.
 
+config GPIO_DLN2
+        tristate "Diolan DLN2 GPIO support"
+        depends on MFD_DLN2
+        select GPIOLIB_IRQCHIP
+
+        help
+          Select this option to enable GPIO driver for the Diolan DLN2
+          board.
+
+          This driver can also be built as a module. If so, the module
+          will be called gpio-dln2.
+
 endif
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index e5d346cf3b6e..e60677b8ccb4 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -26,6 +26,7 @@ obj-$(CONFIG_GPIO_CRYSTAL_COVE)	+= gpio-crystalcove.o
 obj-$(CONFIG_GPIO_DA9052)       += gpio-da9052.o
 obj-$(CONFIG_GPIO_DA9055)       += gpio-da9055.o
 obj-$(CONFIG_GPIO_DAVINCI)      += gpio-davinci.o
+obj-$(CONFIG_GPIO_DLN2)         += gpio-dln2.o
 obj-$(CONFIG_GPIO_DWAPB)        += gpio-dwapb.o
 obj-$(CONFIG_GPIO_EM)           += gpio-em.o
 obj-$(CONFIG_GPIO_EP93XX)       += gpio-ep93xx.o
diff --git a/drivers/gpio/devres.c b/drivers/gpio/devres.c
index 954b9f6b0ef8..13dbd3dfc33a 100644
--- a/drivers/gpio/devres.c
+++ b/drivers/gpio/devres.c
@@ -109,6 +109,38 @@ struct gpio_desc *__must_check __devm_gpiod_get_index(struct device *dev,
 EXPORT_SYMBOL(__devm_gpiod_get_index);
 
 /**
+ * devm_get_gpiod_from_child - get a GPIO descriptor from a device's child node
+ * @dev:        GPIO consumer
+ * @child:      firmware node (child of @dev)
+ *
+ * GPIO descriptors returned from this function are automatically disposed on
+ * driver detach.
+ */
+struct gpio_desc *devm_get_gpiod_from_child(struct device *dev,
+                                            struct fwnode_handle *child)
+{
+        struct gpio_desc **dr;
+        struct gpio_desc *desc;
+
+        dr = devres_alloc(devm_gpiod_release, sizeof(struct gpio_desc *),
+                          GFP_KERNEL);
+        if (!dr)
+                return ERR_PTR(-ENOMEM);
+
+        desc = fwnode_get_named_gpiod(child, "gpios");
+        if (IS_ERR(desc)) {
+                devres_free(dr);
+                return desc;
+        }
+
+        *dr = desc;
+        devres_add(dev, dr);
+
+        return desc;
+}
+EXPORT_SYMBOL(devm_get_gpiod_from_child);
+
+/**
  * devm_gpiod_get_index_optional - Resource-managed gpiod_get_index_optional()
  * @dev: GPIO consumer
  * @con_id: function within the GPIO consumer
diff --git a/drivers/gpio/gpio-dln2.c b/drivers/gpio/gpio-dln2.c
new file mode 100644
index 000000000000..978b51eae2ec
--- /dev/null
+++ b/drivers/gpio/gpio-dln2.c
@@ -0,0 +1,553 @@
+/*
+ * Driver for the Diolan DLN-2 USB-GPIO adapter
+ *
+ * Copyright (c) 2014 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/irqdomain.h>
+#include <linux/irq.h>
+#include <linux/irqchip/chained_irq.h>
+#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/dln2.h>
+
+#define DLN2_GPIO_ID                    0x01
+
+#define DLN2_GPIO_GET_PIN_COUNT         DLN2_CMD(0x01, DLN2_GPIO_ID)
+#define DLN2_GPIO_SET_DEBOUNCE          DLN2_CMD(0x04, DLN2_GPIO_ID)
+#define DLN2_GPIO_GET_DEBOUNCE          DLN2_CMD(0x05, DLN2_GPIO_ID)
+#define DLN2_GPIO_PORT_GET_VAL          DLN2_CMD(0x06, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_GET_VAL           DLN2_CMD(0x0B, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_SET_OUT_VAL       DLN2_CMD(0x0C, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_GET_OUT_VAL       DLN2_CMD(0x0D, DLN2_GPIO_ID)
+#define DLN2_GPIO_CONDITION_MET_EV      DLN2_CMD(0x0F, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_ENABLE            DLN2_CMD(0x10, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_DISABLE           DLN2_CMD(0x11, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_SET_DIRECTION     DLN2_CMD(0x13, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_GET_DIRECTION     DLN2_CMD(0x14, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_SET_EVENT_CFG     DLN2_CMD(0x1E, DLN2_GPIO_ID)
+#define DLN2_GPIO_PIN_GET_EVENT_CFG     DLN2_CMD(0x1F, DLN2_GPIO_ID)
+
+#define DLN2_GPIO_EVENT_NONE            0
+#define DLN2_GPIO_EVENT_CHANGE          1
+#define DLN2_GPIO_EVENT_LVL_HIGH        2
+#define DLN2_GPIO_EVENT_LVL_LOW         3
+#define DLN2_GPIO_EVENT_CHANGE_RISING   0x11
+#define DLN2_GPIO_EVENT_CHANGE_FALLING  0x21
+#define DLN2_GPIO_EVENT_MASK            0x0F
+
+#define DLN2_GPIO_MAX_PINS 32
+
+struct dln2_irq_work {
+        struct work_struct work;
+        struct dln2_gpio *dln2;
+        int pin;
+        int type;
+};
+
+struct dln2_gpio {
+        struct platform_device *pdev;
+        struct gpio_chip gpio;
+
+        /*
+         * Cache pin direction to save us one transfer, since the hardware has
+         * separate commands to read the in and out values.
+         */
+        DECLARE_BITMAP(output_enabled, DLN2_GPIO_MAX_PINS);
+
+        DECLARE_BITMAP(irqs_masked, DLN2_GPIO_MAX_PINS);
+        DECLARE_BITMAP(irqs_enabled, DLN2_GPIO_MAX_PINS);
+        DECLARE_BITMAP(irqs_pending, DLN2_GPIO_MAX_PINS);
+        struct dln2_irq_work *irq_work;
+};
+
+struct dln2_gpio_pin {
+        __le16 pin;
+};
+
+struct dln2_gpio_pin_val {
+        __le16 pin __packed;
+        u8 value;
+};
+
+static int dln2_gpio_get_pin_count(struct platform_device *pdev)
+{
+        int ret;
+        __le16 count;
+        int len = sizeof(count);
+
+        ret = dln2_transfer_rx(pdev, DLN2_GPIO_GET_PIN_COUNT, &count, &len);
+        if (ret < 0)
+                return ret;
+        if (len < sizeof(count))
+                return -EPROTO;
+
+        return le16_to_cpu(count);
+}
+
+static int dln2_gpio_pin_cmd(struct dln2_gpio *dln2, int cmd, unsigned pin)
+{
+        struct dln2_gpio_pin req = {
+                .pin = cpu_to_le16(pin),
+        };
+
+        return dln2_transfer_tx(dln2->pdev, cmd, &req, sizeof(req));
+}
+
+static int dln2_gpio_pin_val(struct dln2_gpio *dln2, int cmd, unsigned int pin)
+{
+        int ret;
+        struct dln2_gpio_pin req = {
+                .pin = cpu_to_le16(pin),
+        };
+        struct dln2_gpio_pin_val rsp;
+        int len = sizeof(rsp);
+
+        ret = dln2_transfer(dln2->pdev, cmd, &req, sizeof(req), &rsp, &len);
+        if (ret < 0)
+                return ret;
+        if (len < sizeof(rsp) || req.pin != rsp.pin)
+                return -EPROTO;
+
+        return rsp.value;
+}
+
+static int dln2_gpio_pin_get_in_val(struct dln2_gpio *dln2, unsigned int pin)
+{
+        int ret;
+
+        ret = dln2_gpio_pin_val(dln2, DLN2_GPIO_PIN_GET_VAL, pin);
+        if (ret < 0)
+                return ret;
+        return !!ret;
+}
+
+static int dln2_gpio_pin_get_out_val(struct dln2_gpio *dln2, unsigned int pin)
+{
+        int ret;
+
+        ret = dln2_gpio_pin_val(dln2, DLN2_GPIO_PIN_GET_OUT_VAL, pin);
+        if (ret < 0)
+                return ret;
+        return !!ret;
+}
+
+static void dln2_gpio_pin_set_out_val(struct dln2_gpio *dln2,
+                                      unsigned int pin, int value)
+{
+        struct dln2_gpio_pin_val req = {
+                .pin = cpu_to_le16(pin),
+                .value = value,
+        };
+
+        dln2_transfer_tx(dln2->pdev, DLN2_GPIO_PIN_SET_OUT_VAL, &req,
+                         sizeof(req));
+}
+
+#define DLN2_GPIO_DIRECTION_IN          0
+#define DLN2_GPIO_DIRECTION_OUT         1
+
+static int dln2_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio_pin req = {
+                .pin = cpu_to_le16(offset),
+        };
+        struct dln2_gpio_pin_val rsp;
+        int len = sizeof(rsp);
+        int ret;
+
+        ret = dln2_gpio_pin_cmd(dln2, DLN2_GPIO_PIN_ENABLE, offset);
+        if (ret < 0)
+                return ret;
+
+        /* cache the pin direction */
+        ret = dln2_transfer(dln2->pdev, DLN2_GPIO_PIN_GET_DIRECTION,
+                            &req, sizeof(req), &rsp, &len);
+        if (ret < 0)
+                return ret;
+        if (len < sizeof(rsp) || req.pin != rsp.pin) {
+                ret = -EPROTO;
+                goto out_disable;
+        }
+
+        switch (rsp.value) {
+        case DLN2_GPIO_DIRECTION_IN:
+                clear_bit(offset, dln2->output_enabled);
+                return 0;
+        case DLN2_GPIO_DIRECTION_OUT:
+                set_bit(offset, dln2->output_enabled);
+                return 0;
+        default:
+                ret = -EPROTO;
+                goto out_disable;
+        }
+
+out_disable:
+        dln2_gpio_pin_cmd(dln2, DLN2_GPIO_PIN_DISABLE, offset);
+        return ret;
+}
+
+static void dln2_gpio_free(struct gpio_chip *chip, unsigned offset)
+{
+        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+
+        dln2_gpio_pin_cmd(dln2, DLN2_GPIO_PIN_DISABLE, offset);
+}
+
+static int dln2_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
+{
+        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+
+        if (test_bit(offset, dln2->output_enabled))
+                return GPIOF_DIR_OUT;
+
+        return GPIOF_DIR_IN;
+}
+
+static int dln2_gpio_get(struct gpio_chip *chip, unsigned int offset)
+{
+        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        int dir;
+
+        dir = dln2_gpio_get_direction(chip, offset);
+        if (dir < 0)
+                return dir;
+
+        if (dir == GPIOF_DIR_IN)
+                return dln2_gpio_pin_get_in_val(dln2, offset);
+
+        return dln2_gpio_pin_get_out_val(dln2, offset);
+}
+
+static void dln2_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+
+        dln2_gpio_pin_set_out_val(dln2, offset, value);
+}
+
+static int dln2_gpio_set_direction(struct gpio_chip *chip, unsigned offset,
+                                   unsigned dir)
+{
+        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        struct dln2_gpio_pin_val req = {
+                .pin = cpu_to_le16(offset),
+                .value = dir,
+        };
+        int ret;
+
+        ret = dln2_transfer_tx(dln2->pdev, DLN2_GPIO_PIN_SET_DIRECTION,
+                               &req, sizeof(req));
+        if (ret < 0)
+                return ret;
+
+        if (dir == DLN2_GPIO_DIRECTION_OUT)
+                set_bit(offset, dln2->output_enabled);
+        else
+                clear_bit(offset, dln2->output_enabled);
+
+        return ret;
+}
+
+static int dln2_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        return dln2_gpio_set_direction(chip, offset, DLN2_GPIO_DIRECTION_IN);
+}
+
+static int dln2_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
+                                      int value)
+{
+        return dln2_gpio_set_direction(chip, offset, DLN2_GPIO_DIRECTION_OUT);
+}
+
+static int dln2_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
+                                  unsigned debounce)
+{
+        struct dln2_gpio *dln2 = container_of(chip, struct dln2_gpio, gpio);
+        __le32 duration = cpu_to_le32(debounce);
+
+        return dln2_transfer_tx(dln2->pdev, DLN2_GPIO_SET_DEBOUNCE,
+                                &duration, sizeof(duration));
+}
+
+static int dln2_gpio_set_event_cfg(struct dln2_gpio *dln2, unsigned pin,
+                                   unsigned type, unsigned period)
+{
+        struct {
+                __le16 pin;
+                u8 type;
+                __le16 period;
+        } __packed req = {
+                .pin = cpu_to_le16(pin),
+                .type = type,
+                .period = cpu_to_le16(period),
+        };
+
+        return dln2_transfer_tx(dln2->pdev, DLN2_GPIO_PIN_SET_EVENT_CFG,
+                                &req, sizeof(req));
+}
+
+static void dln2_irq_work(struct work_struct *w)
+{
+        struct dln2_irq_work *iw = container_of(w, struct dln2_irq_work, work);
+        struct dln2_gpio *dln2 = iw->dln2;
+        u8 type = iw->type & DLN2_GPIO_EVENT_MASK;
+
+        if (test_bit(iw->pin, dln2->irqs_enabled))
+                dln2_gpio_set_event_cfg(dln2, iw->pin, type, 0);
+        else
+                dln2_gpio_set_event_cfg(dln2, iw->pin, DLN2_GPIO_EVENT_NONE, 0);
+}
+
+static void dln2_irq_enable(struct irq_data *irqd)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
+        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        int pin = irqd_to_hwirq(irqd);
+
+        set_bit(pin, dln2->irqs_enabled);
+        schedule_work(&dln2->irq_work[pin].work);
+}
+
+static void dln2_irq_disable(struct irq_data *irqd)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
+        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        int pin = irqd_to_hwirq(irqd);
+
+        clear_bit(pin, dln2->irqs_enabled);
+        schedule_work(&dln2->irq_work[pin].work);
+}
+
+static void dln2_irq_mask(struct irq_data *irqd)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
+        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        int pin = irqd_to_hwirq(irqd);
+
+        set_bit(pin, dln2->irqs_masked);
+}
+
+static void dln2_irq_unmask(struct irq_data *irqd)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
+        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        struct device *dev = dln2->gpio.dev;
+        int pin = irqd_to_hwirq(irqd);
+
+        if (test_and_clear_bit(pin, dln2->irqs_pending)) {
+                int irq;
+
+                irq = irq_find_mapping(dln2->gpio.irqdomain, pin);
+                if (!irq) {
+                        dev_err(dev, "pin %d not mapped to IRQ\n", pin);
+                        return;
+                }
+
+                generic_handle_irq(irq);
+        }
+}
+
+static int dln2_irq_set_type(struct irq_data *irqd, unsigned type)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(irqd);
+        struct dln2_gpio *dln2 = container_of(gc, struct dln2_gpio, gpio);
+        int pin = irqd_to_hwirq(irqd);
+
+        switch (type) {
+        case IRQ_TYPE_LEVEL_HIGH:
+                dln2->irq_work[pin].type = DLN2_GPIO_EVENT_LVL_HIGH;
+                break;
+        case IRQ_TYPE_LEVEL_LOW:
+                dln2->irq_work[pin].type = DLN2_GPIO_EVENT_LVL_LOW;
+                break;
+        case IRQ_TYPE_EDGE_BOTH:
+                dln2->irq_work[pin].type = DLN2_GPIO_EVENT_CHANGE;
+                break;
+        case IRQ_TYPE_EDGE_RISING:
+                dln2->irq_work[pin].type = DLN2_GPIO_EVENT_CHANGE_RISING;
+                break;
+        case IRQ_TYPE_EDGE_FALLING:
+                dln2->irq_work[pin].type = DLN2_GPIO_EVENT_CHANGE_FALLING;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static struct irq_chip dln2_gpio_irqchip = {
+        .name = "dln2-irq",
+        .irq_enable = dln2_irq_enable,
+        .irq_disable = dln2_irq_disable,
+        .irq_mask = dln2_irq_mask,
+        .irq_unmask = dln2_irq_unmask,
+        .irq_set_type = dln2_irq_set_type,
+};
+
+static void dln2_gpio_event(struct platform_device *pdev, u16 echo,
+                            const void *data, int len)
+{
+        int pin, irq;
+        const struct {
+                __le16 count;
+                __u8 type;
+                __le16 pin;
+                __u8 value;
+        } __packed *event = data;
+        struct dln2_gpio *dln2 = platform_get_drvdata(pdev);
+
+        if (len < sizeof(*event)) {
+                dev_err(dln2->gpio.dev, "short event message\n");
+                return;
+        }
+
+        pin = le16_to_cpu(event->pin);
+        if (pin >= dln2->gpio.ngpio) {
+                dev_err(dln2->gpio.dev, "out of bounds pin %d\n", pin);
+                return;
+        }
+
+        irq = irq_find_mapping(dln2->gpio.irqdomain, pin);
+        if (!irq) {
+                dev_err(dln2->gpio.dev, "pin %d not mapped to IRQ\n", pin);
+                return;
+        }
+
+        if (!test_bit(pin, dln2->irqs_enabled))
+                return;
+        if (test_bit(pin, dln2->irqs_masked)) {
+                set_bit(pin, dln2->irqs_pending);
+                return;
+        }
+
+        switch (dln2->irq_work[pin].type) {
+        case DLN2_GPIO_EVENT_CHANGE_RISING:
+                if (event->value)
+                        generic_handle_irq(irq);
+                break;
+        case DLN2_GPIO_EVENT_CHANGE_FALLING:
+                if (!event->value)
+                        generic_handle_irq(irq);
+                break;
+        default:
+                generic_handle_irq(irq);
+        }
+}
+
+static int dln2_gpio_probe(struct platform_device *pdev)
+{
+        struct dln2_gpio *dln2;
+        struct device *dev = &pdev->dev;
+        int pins;
+        int i, ret;
+
+        pins = dln2_gpio_get_pin_count(pdev);
+        if (pins < 0) {
+                dev_err(dev, "failed to get pin count: %d\n", pins);
+                return pins;
+        }
+        if (pins > DLN2_GPIO_MAX_PINS) {
+                pins = DLN2_GPIO_MAX_PINS;
+                dev_warn(dev, "clamping pins to %d\n", DLN2_GPIO_MAX_PINS);
+        }
+
+        dln2 = devm_kzalloc(&pdev->dev, sizeof(*dln2), GFP_KERNEL);
+        if (!dln2)
+                return -ENOMEM;
+
+        dln2->irq_work = devm_kcalloc(&pdev->dev, pins,
+                                      sizeof(struct dln2_irq_work), GFP_KERNEL);
+        if (!dln2->irq_work)
+                return -ENOMEM;
+        for (i = 0; i < pins; i++) {
+                INIT_WORK(&dln2->irq_work[i].work, dln2_irq_work);
+                dln2->irq_work[i].pin = i;
+                dln2->irq_work[i].dln2 = dln2;
+        }
+
+        dln2->pdev = pdev;
+
+        dln2->gpio.label = "dln2";
+        dln2->gpio.dev = dev;
+        dln2->gpio.owner = THIS_MODULE;
+        dln2->gpio.base = -1;
+        dln2->gpio.ngpio = pins;
+        dln2->gpio.exported = true;
+        dln2->gpio.can_sleep = true;
+        dln2->gpio.irq_not_threaded = true;
+        dln2->gpio.set = dln2_gpio_set;
+        dln2->gpio.get = dln2_gpio_get;
+        dln2->gpio.request = dln2_gpio_request;
+        dln2->gpio.free = dln2_gpio_free;
+        dln2->gpio.get_direction = dln2_gpio_get_direction;
+        dln2->gpio.direction_input = dln2_gpio_direction_input;
+        dln2->gpio.direction_output = dln2_gpio_direction_output;
+        dln2->gpio.set_debounce = dln2_gpio_set_debounce;
+
+        platform_set_drvdata(pdev, dln2);
+
+        ret = gpiochip_add(&dln2->gpio);
+        if (ret < 0) {
+                dev_err(dev, "failed to add gpio chip: %d\n", ret);
+                goto out;
+        }
+
+        ret = gpiochip_irqchip_add(&dln2->gpio, &dln2_gpio_irqchip, 0,
+                                   handle_simple_irq, IRQ_TYPE_NONE);
+        if (ret < 0) {
+                dev_err(dev, "failed to add irq chip: %d\n", ret);
+                goto out_gpiochip_remove;
+        }
+
+        ret = dln2_register_event_cb(pdev, DLN2_GPIO_CONDITION_MET_EV,
+                                     dln2_gpio_event);
+        if (ret) {
+                dev_err(dev, "failed to register event cb: %d\n", ret);
+                goto out_gpiochip_remove;
+        }
+
+        return 0;
+
+out_gpiochip_remove:
+        gpiochip_remove(&dln2->gpio);
+out:
+        return ret;
+}
+
+static int dln2_gpio_remove(struct platform_device *pdev)
+{
+        struct dln2_gpio *dln2 = platform_get_drvdata(pdev);
+        int i;
+
+        dln2_unregister_event_cb(pdev, DLN2_GPIO_CONDITION_MET_EV);
+        for (i = 0; i < dln2->gpio.ngpio; i++)
+                flush_work(&dln2->irq_work[i].work);
+        gpiochip_remove(&dln2->gpio);
+
+        return 0;
+}
+
+static struct platform_driver dln2_gpio_driver = {
+        .driver.name    = "dln2-gpio",
+        .probe          = dln2_gpio_probe,
+        .remove         = dln2_gpio_remove,
+};
+
+module_platform_driver(dln2_gpio_driver);
+
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
+MODULE_DESCRIPTION("Driver for the Diolan DLN2 GPIO interface");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:dln2-gpio");
diff --git a/drivers/gpio/gpio-omap.c b/drivers/gpio/gpio-omap.c
index 415682f69214..3d6b445665ad 100644
--- a/drivers/gpio/gpio-omap.c
+++ b/drivers/gpio/gpio-omap.c
@@ -1259,7 +1259,7 @@ static int omap_gpio_probe(struct platform_device *pdev)
 
 #ifdef CONFIG_ARCH_OMAP2PLUS
 
-#if defined(CONFIG_PM_RUNTIME)
+#if defined(CONFIG_PM)
 static void omap_gpio_restore_context(struct gpio_bank *bank);
 
 static int omap_gpio_runtime_suspend(struct device *dev)
@@ -1440,7 +1440,7 @@ static int omap_gpio_runtime_resume(struct device *dev)
 
         return 0;
 }
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
 void omap2_gpio_prepare_for_idle(int pwr_mode)
 {
@@ -1468,7 +1468,7 @@ void omap2_gpio_resume_after_idle(void)
         }
 }
 
-#if defined(CONFIG_PM_RUNTIME)
+#if defined(CONFIG_PM)
 static void omap_gpio_init_context(struct gpio_bank *p)
 {
         struct omap_gpio_reg_offs *regs = p->regs;
@@ -1525,7 +1525,7 @@ static void omap_gpio_restore_context(struct gpio_bank *bank)
         writel_relaxed(bank->context.irqenable2,
                                 bank->base + bank->regs->irqenable2);
 }
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 #else
 #define omap_gpio_runtime_suspend NULL
 #define omap_gpio_runtime_resume NULL
diff --git a/drivers/gpio/gpio-sch.c b/drivers/gpio/gpio-sch.c
index 41e91d70301e..99720c8bc8ed 100644
--- a/drivers/gpio/gpio-sch.c
+++ b/drivers/gpio/gpio-sch.c
@@ -29,290 +29,221 @@
 
 #include <linux/gpio.h>
 
-static DEFINE_SPINLOCK(gpio_lock);
-
-#define CGEN    (0x00)
-#define CGIO    (0x04)
-#define CGLV    (0x08)
-
-#define RGEN    (0x20)
-#define RGIO    (0x24)
-#define RGLV    (0x28)
-
-static unsigned short gpio_ba;
-
-static int sch_gpio_core_direction_in(struct gpio_chip *gc, unsigned  gpio_num)
-{
-        u8 curr_dirs;
-        unsigned short offset, bit;
-
-        spin_lock(&gpio_lock);
-
-        offset = CGIO + gpio_num / 8;
-        bit = gpio_num % 8;
-
-        curr_dirs = inb(gpio_ba + offset);
-
-        if (!(curr_dirs & (1 << bit)))
-                outb(curr_dirs | (1 << bit), gpio_ba + offset);
+#define GEN     0x00
+#define GIO     0x04
+#define GLV     0x08
+
+struct sch_gpio {
+        struct gpio_chip chip;
+        spinlock_t lock;
+        unsigned short iobase;
+        unsigned short core_base;
+        unsigned short resume_base;
+};
 
-        spin_unlock(&gpio_lock);
-        return 0;
-}
+#define to_sch_gpio(c)  container_of(c, struct sch_gpio, chip)
 
-static int sch_gpio_core_get(struct gpio_chip *gc, unsigned gpio_num)
+static unsigned sch_gpio_offset(struct sch_gpio *sch, unsigned gpio,
+                                unsigned reg)
 {
-        int res;
-        unsigned short offset, bit;
+        unsigned base = 0;
 
-        offset = CGLV + gpio_num / 8;
-        bit = gpio_num % 8;
+        if (gpio >= sch->resume_base) {
+                gpio -= sch->resume_base;
+                base += 0x20;
+        }
 
-        res = !!(inb(gpio_ba + offset) & (1 << bit));
-        return res;
+        return base + reg + gpio / 8;
 }
 
-static void sch_gpio_core_set(struct gpio_chip *gc, unsigned gpio_num, int val)
+static unsigned sch_gpio_bit(struct sch_gpio *sch, unsigned gpio)
 {
-        u8 curr_vals;
-        unsigned short offset, bit;
-
-        spin_lock(&gpio_lock);
-
-        offset = CGLV + gpio_num / 8;
-        bit = gpio_num % 8;
-
-        curr_vals = inb(gpio_ba + offset);
-
-        if (val)
-                outb(curr_vals | (1 << bit), gpio_ba + offset);
-        else
-                outb((curr_vals & ~(1 << bit)), gpio_ba + offset);
-        spin_unlock(&gpio_lock);
+        if (gpio >= sch->resume_base)
+                gpio -= sch->resume_base;
+        return gpio % 8;
 }
 
-static int sch_gpio_core_direction_out(struct gpio_chip *gc,
-                                        unsigned gpio_num, int val)
+static void sch_gpio_enable(struct sch_gpio *sch, unsigned gpio)
 {
-        u8 curr_dirs;
         unsigned short offset, bit;
+        u8 enable;
 
-        spin_lock(&gpio_lock);
+        spin_lock(&sch->lock);
 
-        offset = CGIO + gpio_num / 8;
-        bit = gpio_num % 8;
-
-        curr_dirs = inb(gpio_ba + offset);
-        if (curr_dirs & (1 << bit))
-                outb(curr_dirs & ~(1 << bit), gpio_ba + offset);
+        offset = sch_gpio_offset(sch, gpio, GEN);
+        bit = sch_gpio_bit(sch, gpio);
 
-        spin_unlock(&gpio_lock);
+        enable = inb(sch->iobase + offset);
+        if (!(enable & (1 << bit)))
+                outb(enable | (1 << bit), sch->iobase + offset);
 
-        /*
-         * according to the datasheet, writing to the level register has no
-         * effect when GPIO is programmed as input.
-         * Actually the the level register is read-only when configured as input.
-         * Thus presetting the output level before switching to output is _NOT_ possible.
-         * Hence we set the level after configuring the GPIO as output.
-         * But we cannot prevent a short low pulse if direction is set to high
-         * and an external pull-up is connected.
-         */
-        sch_gpio_core_set(gc, gpio_num, val);
-        return 0;
+        spin_unlock(&sch->lock);
 }
 
-static struct gpio_chip sch_gpio_core = {
-        .label                  = "sch_gpio_core",
-        .owner                  = THIS_MODULE,
-        .direction_input        = sch_gpio_core_direction_in,
-        .get                    = sch_gpio_core_get,
-        .direction_output       = sch_gpio_core_direction_out,
-        .set                    = sch_gpio_core_set,
-};
-
-static int sch_gpio_resume_direction_in(struct gpio_chip *gc,
-                                        unsigned gpio_num)
+static int sch_gpio_direction_in(struct gpio_chip *gc, unsigned  gpio_num)
 {
+        struct sch_gpio *sch = to_sch_gpio(gc);
         u8 curr_dirs;
         unsigned short offset, bit;
 
-        spin_lock(&gpio_lock);
+        spin_lock(&sch->lock);
 
-        offset = RGIO + gpio_num / 8;
-        bit = gpio_num % 8;
+        offset = sch_gpio_offset(sch, gpio_num, GIO);
+        bit = sch_gpio_bit(sch, gpio_num);
 
-        curr_dirs = inb(gpio_ba + offset);
+        curr_dirs = inb(sch->iobase + offset);
 
         if (!(curr_dirs & (1 << bit)))
-                outb(curr_dirs | (1 << bit), gpio_ba + offset);
+                outb(curr_dirs | (1 << bit), sch->iobase + offset);
 
-        spin_unlock(&gpio_lock);
+        spin_unlock(&sch->lock);
         return 0;
 }
 
-static int sch_gpio_resume_get(struct gpio_chip *gc, unsigned gpio_num)
+static int sch_gpio_get(struct gpio_chip *gc, unsigned gpio_num)
 {
+        struct sch_gpio *sch = to_sch_gpio(gc);
+        int res;
         unsigned short offset, bit;
 
-        offset = RGLV + gpio_num / 8;
-        bit = gpio_num % 8;
+        offset = sch_gpio_offset(sch, gpio_num, GLV);
+        bit = sch_gpio_bit(sch, gpio_num);
+
+        res = !!(inb(sch->iobase + offset) & (1 << bit));
 
-        return !!(inb(gpio_ba + offset) & (1 << bit));
+        return res;
 }
 
-static void sch_gpio_resume_set(struct gpio_chip *gc,
-                                unsigned gpio_num, int val)
+static void sch_gpio_set(struct gpio_chip *gc, unsigned gpio_num, int val)
 {
+        struct sch_gpio *sch = to_sch_gpio(gc);
         u8 curr_vals;
         unsigned short offset, bit;
 
-        spin_lock(&gpio_lock);
+        spin_lock(&sch->lock);
 
-        offset = RGLV + gpio_num / 8;
-        bit = gpio_num % 8;
+        offset = sch_gpio_offset(sch, gpio_num, GLV);
+        bit = sch_gpio_bit(sch, gpio_num);
 
-        curr_vals = inb(gpio_ba + offset);
+        curr_vals = inb(sch->iobase + offset);
 
         if (val)
-                outb(curr_vals | (1 << bit), gpio_ba + offset);
+                outb(curr_vals | (1 << bit), sch->iobase + offset);
         else
-                outb((curr_vals & ~(1 << bit)), gpio_ba + offset);
+                outb((curr_vals & ~(1 << bit)), sch->iobase + offset);
 
-        spin_unlock(&gpio_lock);
+        spin_unlock(&sch->lock);
 }
 
-static int sch_gpio_resume_direction_out(struct gpio_chip *gc,
-                                        unsigned gpio_num, int val)
+static int sch_gpio_direction_out(struct gpio_chip *gc, unsigned gpio_num,
+                                  int val)
 {
+        struct sch_gpio *sch = to_sch_gpio(gc);
         u8 curr_dirs;
         unsigned short offset, bit;
 
-        offset = RGIO + gpio_num / 8;
-        bit = gpio_num % 8;
+        spin_lock(&sch->lock);
 
-        spin_lock(&gpio_lock);
+        offset = sch_gpio_offset(sch, gpio_num, GIO);
+        bit = sch_gpio_bit(sch, gpio_num);
 
-        curr_dirs = inb(gpio_ba + offset);
+        curr_dirs = inb(sch->iobase + offset);
         if (curr_dirs & (1 << bit))
-                outb(curr_dirs & ~(1 << bit), gpio_ba + offset);
+                outb(curr_dirs & ~(1 << bit), sch->iobase + offset);
 
-        spin_unlock(&gpio_lock);
+        spin_unlock(&sch->lock);
 
         /*
-        * according to the datasheet, writing to the level register has no
-        * effect when GPIO is programmed as input.
-        * Actually the the level register is read-only when configured as input.
-        * Thus presetting the output level before switching to output is _NOT_ possible.
-        * Hence we set the level after configuring the GPIO as output.
-        * But we cannot prevent a short low pulse if direction is set to high
-        * and an external pull-up is connected.
-        */
-        sch_gpio_resume_set(gc, gpio_num, val);
+         * according to the datasheet, writing to the level register has no
+         * effect when GPIO is programmed as input.
+         * Actually the the level register is read-only when configured as input.
+         * Thus presetting the output level before switching to output is _NOT_ possible.
+         * Hence we set the level after configuring the GPIO as output.
+         * But we cannot prevent a short low pulse if direction is set to high
+         * and an external pull-up is connected.
+         */
+        sch_gpio_set(gc, gpio_num, val);
         return 0;
 }
 
-static struct gpio_chip sch_gpio_resume = {
-        .label                  = "sch_gpio_resume",
+static struct gpio_chip sch_gpio_chip = {
+        .label                  = "sch_gpio",
         .owner                  = THIS_MODULE,
-        .direction_input        = sch_gpio_resume_direction_in,
-        .get                    = sch_gpio_resume_get,
-        .direction_output       = sch_gpio_resume_direction_out,
-        .set                    = sch_gpio_resume_set,
+        .direction_input        = sch_gpio_direction_in,
+        .get                    = sch_gpio_get,
+        .direction_output       = sch_gpio_direction_out,
+        .set                    = sch_gpio_set,
 };
 
 static int sch_gpio_probe(struct platform_device *pdev)
 {
+        struct sch_gpio *sch;
         struct resource *res;
-        int err, id;
 
-        id = pdev->id;
-        if (!id)
-                return -ENODEV;
+        sch = devm_kzalloc(&pdev->dev, sizeof(*sch), GFP_KERNEL);
+        if (!sch)
+                return -ENOMEM;
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
         if (!res)
                 return -EBUSY;
 
-        if (!request_region(res->start, resource_size(res), pdev->name))
+        if (!devm_request_region(&pdev->dev, res->start, resource_size(res),
+                                 pdev->name))
                 return -EBUSY;
 
-        gpio_ba = res->start;
+        spin_lock_init(&sch->lock);
+        sch->iobase = res->start;
+        sch->chip = sch_gpio_chip;
+        sch->chip.label = dev_name(&pdev->dev);
+        sch->chip.dev = &pdev->dev;
 
-        switch (id) {
+        switch (pdev->id) {
         case PCI_DEVICE_ID_INTEL_SCH_LPC:
-                sch_gpio_core.base = 0;
-                sch_gpio_core.ngpio = 10;
-                sch_gpio_resume.base = 10;
-                sch_gpio_resume.ngpio = 4;
+                sch->core_base = 0;
+                sch->resume_base = 10;
+                sch->chip.ngpio = 14;
+
                 /*
                  * GPIO[6:0] enabled by default
                  * GPIO7 is configured by the CMC as SLPIOVR
                  * Enable GPIO[9:8] core powered gpios explicitly
                  */
-                outb(0x3, gpio_ba + CGEN + 1);
+                sch_gpio_enable(sch, 8);
+                sch_gpio_enable(sch, 9);
                 /*
                  * SUS_GPIO[2:0] enabled by default
                  * Enable SUS_GPIO3 resume powered gpio explicitly
                  */
-                outb(0x8, gpio_ba + RGEN);
+                sch_gpio_enable(sch, 13);
                 break;
 
         case PCI_DEVICE_ID_INTEL_ITC_LPC:
-                sch_gpio_core.base = 0;
-                sch_gpio_core.ngpio = 5;
-                sch_gpio_resume.base = 5;
-                sch_gpio_resume.ngpio = 9;
+                sch->core_base = 0;
+                sch->resume_base = 5;
+                sch->chip.ngpio = 14;
                 break;
 
         case PCI_DEVICE_ID_INTEL_CENTERTON_ILB:
-                sch_gpio_core.base = 0;
-                sch_gpio_core.ngpio = 21;
-                sch_gpio_resume.base = 21;
-                sch_gpio_resume.ngpio = 9;
+                sch->core_base = 0;
+                sch->resume_base = 21;
+                sch->chip.ngpio = 30;
                 break;
 
         default:
-                err = -ENODEV;
-                goto err_sch_gpio_core;
+                return -ENODEV;
         }
 
-        sch_gpio_core.dev = &pdev->dev;
-        sch_gpio_resume.dev = &pdev->dev;
-
-        err = gpiochip_add(&sch_gpio_core);
-        if (err < 0)
-                goto err_sch_gpio_core;
+        platform_set_drvdata(pdev, sch);
 
-        err = gpiochip_add(&sch_gpio_resume);
-        if (err < 0)
-                goto err_sch_gpio_resume;
-
-        return 0;
-
-err_sch_gpio_resume:
-        gpiochip_remove(&sch_gpio_core);
-
-err_sch_gpio_core:
-        release_region(res->start, resource_size(res));
-        gpio_ba = 0;
-
-        return err;
+        return gpiochip_add(&sch->chip);
 }
 
 static int sch_gpio_remove(struct platform_device *pdev)
 {
-        struct resource *res;
-        if (gpio_ba) {
-
-                gpiochip_remove(&sch_gpio_core);
-                gpiochip_remove(&sch_gpio_resume);
-
-                res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-
-                release_region(res->start, resource_size(res));
-                gpio_ba = 0;
-        }
+        struct sch_gpio *sch = platform_get_drvdata(pdev);
 
+        gpiochip_remove(&sch->chip);
         return 0;
 }
 
diff --git a/drivers/gpio/gpio-tc3589x.c b/drivers/gpio/gpio-tc3589x.c
index ae0f6466eb09..abdcf58935f5 100644
--- a/drivers/gpio/gpio-tc3589x.c
+++ b/drivers/gpio/gpio-tc3589x.c
@@ -262,7 +262,7 @@ static int tc3589x_gpio_probe(struct platform_device *pdev)
         tc3589x_gpio->chip = template_chip;
         tc3589x_gpio->chip.ngpio = tc3589x->num_gpio;
         tc3589x_gpio->chip.dev = &pdev->dev;
-        tc3589x_gpio->chip.base = (pdata) ? pdata->gpio_base : -1;
+        tc3589x_gpio->chip.base = -1;
 
 #ifdef CONFIG_OF_GPIO
         tc3589x_gpio->chip.of_node = np;
diff --git a/drivers/gpio/gpio-tz1090.c b/drivers/gpio/gpio-tz1090.c
index 5246a60eff6d..6107d0682fd6 100644
--- a/drivers/gpio/gpio-tz1090.c
+++ b/drivers/gpio/gpio-tz1090.c
@@ -446,7 +446,7 @@ static int tz1090_gpio_bank_probe(struct tz1090_gpio_bank_info *info)
         bank->irq = irq_of_parse_and_map(np, 0);
 
         /* The interrupt is optional (it may be used by another core on chip) */
-        if (bank->irq < 0) {
+        if (!bank->irq) {
                 dev_info(dev, "IRQ not provided for bank %u, IRQs disabled\n",
                          info->index);
                 return 0;
diff --git a/drivers/gpio/gpio-zynq.c b/drivers/gpio/gpio-zynq.c
index 74cd480bf8de..184c4b1b2558 100644
--- a/drivers/gpio/gpio-zynq.c
+++ b/drivers/gpio/gpio-zynq.c
@@ -578,7 +578,7 @@ static void zynq_gpio_free(struct gpio_chip *chip, unsigned offset)
 
 static const struct dev_pm_ops zynq_gpio_dev_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(zynq_gpio_suspend, zynq_gpio_resume)
-        SET_PM_RUNTIME_PM_OPS(zynq_gpio_runtime_suspend,
+        SET_RUNTIME_PM_OPS(zynq_gpio_runtime_suspend,
                         zynq_gpio_runtime_resume, NULL)
 };
 
diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
index 05c6275da224..c3bdaff71c25 100644
--- a/drivers/gpio/gpiolib-acpi.c
+++ b/drivers/gpio/gpiolib-acpi.c
@@ -11,12 +11,14 @@
  */
 
 #include <linux/errno.h>
+#include <linux/gpio.h>
 #include <linux/gpio/consumer.h>
 #include <linux/gpio/driver.h>
 #include <linux/export.h>
 #include <linux/acpi.h>
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
+#include <linux/pinctrl/pinctrl.h>
 
 #include "gpiolib.h"
 
@@ -55,6 +57,58 @@ static int acpi_gpiochip_find(struct gpio_chip *gc, void *data)
         return ACPI_HANDLE(gc->dev) == data;
 }
 
+#ifdef CONFIG_PINCTRL
+/**
+ * acpi_gpiochip_pin_to_gpio_offset() - translates ACPI GPIO to Linux GPIO
+ * @chip: GPIO chip
+ * @pin: ACPI GPIO pin number from GpioIo/GpioInt resource
+ *
+ * Function takes ACPI GpioIo/GpioInt pin number as a parameter and
+ * translates it to a corresponding offset suitable to be passed to a
+ * GPIO controller driver.
+ *
+ * Typically the returned offset is same as @pin, but if the GPIO
+ * controller uses pin controller and the mapping is not contigous the
+ * offset might be different.
+ */
+static int acpi_gpiochip_pin_to_gpio_offset(struct gpio_chip *chip, int pin)
+{
+        struct gpio_pin_range *pin_range;
+
+        /* If there are no ranges in this chip, use 1:1 mapping */
+        if (list_empty(&chip->pin_ranges))
+                return pin;
+
+        list_for_each_entry(pin_range, &chip->pin_ranges, node) {
+                const struct pinctrl_gpio_range *range = &pin_range->range;
+                int i;
+
+                if (range->pins) {
+                        for (i = 0; i < range->npins; i++) {
+                                if (range->pins[i] == pin)
+                                        return range->base + i - chip->base;
+                        }
+                } else {
+                        if (pin >= range->pin_base &&
+                            pin < range->pin_base + range->npins) {
+                                unsigned gpio_base;
+
+                                gpio_base = range->base - chip->base;
+                                return gpio_base + pin - range->pin_base;
+                        }
+                }
+        }
+
+        return -EINVAL;
+}
+#else
+static inline int acpi_gpiochip_pin_to_gpio_offset(struct gpio_chip *chip,
+                                                   int pin)
+{
+        return pin;
+}
+#endif
+
 /**
  * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API
  * @path:       ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1")
@@ -69,6 +123,7 @@ static struct gpio_desc *acpi_get_gpiod(char *path, int pin)
         struct gpio_chip *chip;
         acpi_handle handle;
         acpi_status status;
+        int offset;
 
         status = acpi_get_handle(NULL, path, &handle);
         if (ACPI_FAILURE(status))
@@ -78,10 +133,11 @@ static struct gpio_desc *acpi_get_gpiod(char *path, int pin)
         if (!chip)
                 return ERR_PTR(-ENODEV);
 
-        if (pin < 0 || pin > chip->ngpio)
-                return ERR_PTR(-EINVAL);
+        offset = acpi_gpiochip_pin_to_gpio_offset(chip, pin);
+        if (offset < 0)
+                return ERR_PTR(offset);
 
-        return gpiochip_get_desc(chip, pin);
+        return gpiochip_get_desc(chip, offset);
 }
 
 static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
@@ -287,9 +343,45 @@ void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
         }
 }
 
+int acpi_dev_add_driver_gpios(struct acpi_device *adev,
+                              const struct acpi_gpio_mapping *gpios)
+{
+        if (adev && gpios) {
+                adev->driver_gpios = gpios;
+                return 0;
+        }
+        return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios);
+
+static bool acpi_get_driver_gpio_data(struct acpi_device *adev,
+                                      const char *name, int index,
+                                      struct acpi_reference_args *args)
+{
+        const struct acpi_gpio_mapping *gm;
+
+        if (!adev->driver_gpios)
+                return false;
+
+        for (gm = adev->driver_gpios; gm->name; gm++)
+                if (!strcmp(name, gm->name) && gm->data && index < gm->size) {
+                        const struct acpi_gpio_params *par = gm->data + index;
+
+                        args->adev = adev;
+                        args->args[0] = par->crs_entry_index;
+                        args->args[1] = par->line_index;
+                        args->args[2] = par->active_low;
+                        args->nargs = 3;
+                        return true;
+                }
+
+        return false;
+}
+
 struct acpi_gpio_lookup {
         struct acpi_gpio_info info;
         int index;
+        int pin_index;
         struct gpio_desc *desc;
         int n;
 };
@@ -303,13 +395,24 @@ static int acpi_find_gpio(struct acpi_resource *ares, void *data)
 
         if (lookup->n++ == lookup->index && !lookup->desc) {
                 const struct acpi_resource_gpio *agpio = &ares->data.gpio;
+                int pin_index = lookup->pin_index;
+
+                if (pin_index >= agpio->pin_table_length)
+                        return 1;
 
                 lookup->desc = acpi_get_gpiod(agpio->resource_source.string_ptr,
-                                              agpio->pin_table[0]);
+                                              agpio->pin_table[pin_index]);
                 lookup->info.gpioint =
                         agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT;
-                lookup->info.active_low =
-                        agpio->polarity == ACPI_ACTIVE_LOW;
+
+                /*
+                 * ActiveLow is only specified for GpioInt resource. If
+                 * GpioIo is used then the only way to set the flag is
+                 * to use _DSD "gpios" property.
+                 */
+                if (lookup->info.gpioint)
+                        lookup->info.active_low =
+                                agpio->polarity == ACPI_ACTIVE_LOW;
         }
 
         return 1;
@@ -317,40 +420,79 @@ static int acpi_find_gpio(struct acpi_resource *ares, void *data)
 
 /**
  * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources
- * @dev: pointer to a device to get GPIO from
+ * @adev: pointer to a ACPI device to get GPIO from
+ * @propname: Property name of the GPIO (optional)
  * @index: index of GpioIo/GpioInt resource (starting from %0)
  * @info: info pointer to fill in (optional)
  *
- * Function goes through ACPI resources for @dev and based on @index looks
+ * Function goes through ACPI resources for @adev and based on @index looks
  * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor,
  * and returns it. @index matches GpioIo/GpioInt resources only so if there
  * are total %3 GPIO resources, the index goes from %0 to %2.
  *
+ * If @propname is specified the GPIO is looked using device property. In
+ * that case @index is used to select the GPIO entry in the property value
+ * (in case of multiple).
+ *
  * If the GPIO cannot be translated or there is an error an ERR_PTR is
  * returned.
  *
  * Note: if the GPIO resource has multiple entries in the pin list, this
  * function only returns the first.
  */
-struct gpio_desc *acpi_get_gpiod_by_index(struct device *dev, int index,
+struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
+                                          const char *propname, int index,
                                           struct acpi_gpio_info *info)
 {
         struct acpi_gpio_lookup lookup;
         struct list_head resource_list;
-        struct acpi_device *adev;
-        acpi_handle handle;
+        bool active_low = false;
         int ret;
 
-        if (!dev)
-                return ERR_PTR(-EINVAL);
-
-        handle = ACPI_HANDLE(dev);
-        if (!handle || acpi_bus_get_device(handle, &adev))
+        if (!adev)
                 return ERR_PTR(-ENODEV);
 
         memset(&lookup, 0, sizeof(lookup));
         lookup.index = index;
 
+        if (propname) {
+                struct acpi_reference_args args;
+
+                dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname);
+
+                memset(&args, 0, sizeof(args));
+                ret = acpi_dev_get_property_reference(adev, propname,
+                                                      index, &args);
+                if (ret) {
+                        bool found = acpi_get_driver_gpio_data(adev, propname,
+                                                               index, &args);
+                        if (!found)
+                                return ERR_PTR(ret);
+                }
+
+                /*
+                 * The property was found and resolved so need to
+                 * lookup the GPIO based on returned args instead.
+                 */
+                adev = args.adev;
+                if (args.nargs >= 2) {
+                        lookup.index = args.args[0];
+                        lookup.pin_index = args.args[1];
+                        /*
+                         * 3rd argument, if present is used to
+                         * specify active_low.
+                         */
+                        if (args.nargs >= 3)
+                                active_low = !!args.args[2];
+                }
+
+                dev_dbg(&adev->dev, "GPIO: _DSD returned %s %zd %llu %llu %llu\n",
+                        dev_name(&adev->dev), args.nargs,
+                        args.args[0], args.args[1], args.args[2]);
+        } else {
+                dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index);
+        }
+
         INIT_LIST_HEAD(&resource_list);
         ret = acpi_dev_get_resources(adev, &resource_list, acpi_find_gpio,
                                      &lookup);
@@ -359,8 +501,11 @@ struct gpio_desc *acpi_get_gpiod_by_index(struct device *dev, int index,
 
         acpi_dev_free_resource_list(&resource_list);
 
-        if (lookup.desc && info)
+        if (lookup.desc && info) {
                 *info = lookup.info;
+                if (active_low)
+                        info->active_low = active_low;
+        }
 
         return lookup.desc ? lookup.desc : ERR_PTR(-ENOENT);
 }
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index e8e98ca25ec7..58659dbe702a 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -1505,14 +1505,36 @@ static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
                                         unsigned int idx,
                                         enum gpio_lookup_flags *flags)
 {
+        static const char * const suffixes[] = { "gpios", "gpio" };
+        struct acpi_device *adev = ACPI_COMPANION(dev);
         struct acpi_gpio_info info;
         struct gpio_desc *desc;
+        char propname[32];
+        int i;
 
-        desc = acpi_get_gpiod_by_index(dev, idx, &info);
-        if (IS_ERR(desc))
-                return desc;
+        /* Try first from _DSD */
+        for (i = 0; i < ARRAY_SIZE(suffixes); i++) {
+                if (con_id && strcmp(con_id, "gpios")) {
+                        snprintf(propname, sizeof(propname), "%s-%s",
+                                 con_id, suffixes[i]);
+                } else {
+                        snprintf(propname, sizeof(propname), "%s",
+                                 suffixes[i]);
+                }
+
+                desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
+                if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
+                        break;
+        }
 
-        if (info.gpioint && info.active_low)
+        /* Then from plain _CRS GPIOs */
+        if (IS_ERR(desc)) {
+                desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
+                if (IS_ERR(desc))
+                        return desc;
+        }
+
+        if (info.active_low)
                 *flags |= GPIO_ACTIVE_LOW;
 
         return desc;
@@ -1713,6 +1735,61 @@ struct gpio_desc *__must_check __gpiod_get_index(struct device *dev,
 EXPORT_SYMBOL_GPL(__gpiod_get_index);
 
 /**
+ * fwnode_get_named_gpiod - obtain a GPIO from firmware node
+ * @fwnode:     handle of the firmware node
+ * @propname:   name of the firmware property representing the GPIO
+ *
+ * This function can be used for drivers that get their configuration
+ * from firmware.
+ *
+ * Function properly finds the corresponding GPIO using whatever is the
+ * underlying firmware interface and then makes sure that the GPIO
+ * descriptor is requested before it is returned to the caller.
+ *
+ * In case of error an ERR_PTR() is returned.
+ */
+struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
+                                         const char *propname)
+{
+        struct gpio_desc *desc = ERR_PTR(-ENODEV);
+        bool active_low = false;
+        int ret;
+
+        if (!fwnode)
+                return ERR_PTR(-EINVAL);
+
+        if (is_of_node(fwnode)) {
+                enum of_gpio_flags flags;
+
+                desc = of_get_named_gpiod_flags(of_node(fwnode), propname, 0,
+                                                &flags);
+                if (!IS_ERR(desc))
+                        active_low = flags & OF_GPIO_ACTIVE_LOW;
+        } else if (is_acpi_node(fwnode)) {
+                struct acpi_gpio_info info;
+
+                desc = acpi_get_gpiod_by_index(acpi_node(fwnode), propname, 0,
+                                               &info);
+                if (!IS_ERR(desc))
+                        active_low = info.active_low;
+        }
+
+        if (IS_ERR(desc))
+                return desc;
+
+        ret = gpiod_request(desc, NULL);
+        if (ret)
+                return ERR_PTR(ret);
+
+        /* Only value flag can be set from both DT and ACPI is active_low */
+        if (active_low)
+                set_bit(FLAG_ACTIVE_LOW, &desc->flags);
+
+        return desc;
+}
+EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);
+
+/**
  * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
  *                            function
  * @dev: GPIO consumer, can be NULL for system-global GPIOs
diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h
index 9db2b6a71c5d..e3a52113a541 100644
--- a/drivers/gpio/gpiolib.h
+++ b/drivers/gpio/gpiolib.h
@@ -34,7 +34,8 @@ void acpi_gpiochip_remove(struct gpio_chip *chip);
 void acpi_gpiochip_request_interrupts(struct gpio_chip *chip);
 void acpi_gpiochip_free_interrupts(struct gpio_chip *chip);
 
-struct gpio_desc *acpi_get_gpiod_by_index(struct device *dev, int index,
+struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
+                                          const char *propname, int index,
                                           struct acpi_gpio_info *info);
 #else
 static inline void acpi_gpiochip_add(struct gpio_chip *chip) { }
@@ -47,8 +48,8 @@ static inline void
 acpi_gpiochip_free_interrupts(struct gpio_chip *chip) { }
 
 static inline struct gpio_desc *
-acpi_get_gpiod_by_index(struct device *dev, int index,
-                        struct acpi_gpio_info *info)
+acpi_get_gpiod_by_index(struct acpi_device *adev, const char *propname,
+                        int index, struct acpi_gpio_info *info)
 {
         return ERR_PTR(-ENOSYS);
 }
diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c
index 7496f55611a5..ef5feeecec84 100644
--- a/drivers/gpu/drm/armada/armada_gem.c
+++ b/drivers/gpu/drm/armada/armada_gem.c
@@ -226,7 +226,7 @@ struct armada_gem_object *armada_gem_alloc_object(struct drm_device *dev,
 
         obj->dev_addr = DMA_ERROR_CODE;
 
-        mapping = obj->obj.filp->f_path.dentry->d_inode->i_mapping;
+        mapping = file_inode(obj->obj.filp)->i_mapping;
         mapping_set_gfp_mask(mapping, GFP_HIGHUSER | __GFP_RECLAIMABLE);
 
         DRM_DEBUG_DRIVER("alloc obj %p size %zu\n", obj, size);
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fimc.c b/drivers/gpu/drm/exynos/exynos_drm_fimc.c
index 68d38eb6774d..835b6af00970 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fimc.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fimc.c
@@ -1817,7 +1817,7 @@ static int fimc_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int fimc_runtime_suspend(struct device *dev)
 {
         struct fimc_context *ctx = get_fimc_context(dev);
diff --git a/drivers/gpu/drm/exynos/exynos_drm_g2d.c b/drivers/gpu/drm/exynos/exynos_drm_g2d.c
index 6ff8599f6cbf..81a250830808 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_g2d.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_g2d.c
@@ -1540,7 +1540,7 @@ static int g2d_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int g2d_runtime_suspend(struct device *dev)
 {
         struct g2d_data *g2d = dev_get_drvdata(dev);
diff --git a/drivers/gpu/drm/exynos/exynos_drm_gsc.c b/drivers/gpu/drm/exynos/exynos_drm_gsc.c
index c6a013fc321c..0261468c8019 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_gsc.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_gsc.c
@@ -1764,7 +1764,7 @@ static int gsc_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int gsc_runtime_suspend(struct device *dev)
 {
         struct gsc_context *ctx = get_gsc_context(dev);
diff --git a/drivers/gpu/drm/exynos/exynos_drm_rotator.c b/drivers/gpu/drm/exynos/exynos_drm_rotator.c
index b6a37d4f5b13..425e70625388 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_rotator.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_rotator.c
@@ -822,7 +822,7 @@ static int rotator_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int rotator_runtime_suspend(struct device *dev)
 {
         struct rot_context *rot = dev_get_drvdata(dev);
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index f0a1a56406eb..9cb5c95d5898 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -4325,7 +4325,6 @@ static void ironlake_crtc_disable(struct drm_crtc *crtc)
                 ironlake_fdi_disable(crtc);
 
                 ironlake_disable_pch_transcoder(dev_priv, pipe);
-                intel_set_pch_fifo_underrun_reporting(dev, pipe, true);
 
                 if (HAS_PCH_CPT(dev)) {
                         /* disable TRANS_DP_CTL */
@@ -4389,7 +4388,6 @@ static void haswell_crtc_disable(struct drm_crtc *crtc)
 
         if (intel_crtc->config.has_pch_encoder) {
                 lpt_disable_pch_transcoder(dev_priv);
-                intel_set_pch_fifo_underrun_reporting(dev, TRANSCODER_A, true);
                 intel_ddi_fdi_disable(crtc);
         }
 
@@ -9408,6 +9406,10 @@ static bool page_flip_finished(struct intel_crtc *crtc)
         struct drm_device *dev = crtc->base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
 
+        if (i915_reset_in_progress(&dev_priv->gpu_error) ||
+            crtc->reset_counter != atomic_read(&dev_priv->gpu_error.reset_counter))
+                return true;
+
         /*
          * The relevant registers doen't exist on pre-ctg.
          * As the flip done interrupt doesn't trigger for mmio
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 5ad45bfff3fe..4bcd91757321 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -4450,6 +4450,7 @@ static void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
          * vdd might still be enabled do to the delayed vdd off.
          * Make sure vdd is actually turned off here.
          */
+        cancel_delayed_work_sync(&intel_dp->panel_vdd_work);
         pps_lock(intel_dp);
         edp_panel_vdd_off_sync(intel_dp);
         pps_unlock(intel_dp);
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index a6bd1422e38f..c0bbf2172446 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -899,6 +899,17 @@ void intel_lvds_init(struct drm_device *dev)
         int pipe;
         u8 pin;
 
+        /*
+         * Unlock registers and just leave them unlocked. Do this before
+         * checking quirk lists to avoid bogus WARNINGs.
+         */
+        if (HAS_PCH_SPLIT(dev)) {
+                I915_WRITE(PCH_PP_CONTROL,
+                           I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
+        } else {
+                I915_WRITE(PP_CONTROL,
+                           I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
+        }
         if (!intel_lvds_supported(dev))
                 return;
 
@@ -1097,17 +1108,6 @@ out:
         lvds_encoder->a3_power = I915_READ(lvds_encoder->reg) &
                                  LVDS_A3_POWER_MASK;
 
-        /*
-         * Unlock registers and just
-         * leave them unlocked
-         */
-        if (HAS_PCH_SPLIT(dev)) {
-                I915_WRITE(PCH_PP_CONTROL,
-                           I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
-        } else {
-                I915_WRITE(PP_CONTROL,
-                           I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
-        }
         lvds_connector->lid_notifier.notifier_call = intel_lid_notify;
         if (acpi_lid_notifier_register(&lvds_connector->lid_notifier)) {
                 DRM_DEBUG_KMS("lid notifier registration failed\n");
diff --git a/drivers/gpu/drm/nouveau/core/engine/device/nvc0.c b/drivers/gpu/drm/nouveau/core/engine/device/nvc0.c
index cd05677ad4b7..72a40f95d048 100644
--- a/drivers/gpu/drm/nouveau/core/engine/device/nvc0.c
+++ b/drivers/gpu/drm/nouveau/core/engine/device/nvc0.c
@@ -218,7 +218,6 @@ nvc0_identify(struct nouveau_device *device)
                 device->oclass[NVDEV_ENGINE_BSP    ] = &nvc0_bsp_oclass;
                 device->oclass[NVDEV_ENGINE_PPP    ] = &nvc0_ppp_oclass;
                 device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
-                device->oclass[NVDEV_ENGINE_COPY1  ] = &nvc0_copy1_oclass;
                 device->oclass[NVDEV_ENGINE_DISP   ] =  nva3_disp_oclass;
                 device->oclass[NVDEV_ENGINE_PERFMON] = &nvc0_perfmon_oclass;
                 break;
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.c
index 5ae6a43893b5..1931057f9962 100644
--- a/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.c
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.c
@@ -551,8 +551,8 @@ nv04_fifo_intr(struct nouveau_subdev *subdev)
                         }
 
                         if (status & 0x40000000) {
-                                nouveau_fifo_uevent(&priv->base);
                                 nv_wr32(priv, 0x002100, 0x40000000);
+                                nouveau_fifo_uevent(&priv->base);
                                 status &= ~0x40000000;
                         }
                 }
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nvc0.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nvc0.c
index 1fe1f8fbda0c..074d434c3077 100644
--- a/drivers/gpu/drm/nouveau/core/engine/fifo/nvc0.c
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nvc0.c
@@ -740,6 +740,8 @@ nvc0_fifo_intr_engine_unit(struct nvc0_fifo_priv *priv, int engn)
         u32 inte = nv_rd32(priv, 0x002628);
         u32 unkn;
 
+        nv_wr32(priv, 0x0025a8 + (engn * 0x04), intr);
+
         for (unkn = 0; unkn < 8; unkn++) {
                 u32 ints = (intr >> (unkn * 0x04)) & inte;
                 if (ints & 0x1) {
@@ -751,8 +753,6 @@ nvc0_fifo_intr_engine_unit(struct nvc0_fifo_priv *priv, int engn)
                         nv_mask(priv, 0x002628, ints, 0);
                 }
         }
-
-        nv_wr32(priv, 0x0025a8 + (engn * 0x04), intr);
 }
 
 static void
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nve0.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nve0.c
index d2f0fd39c145..f8734eb74eaa 100644
--- a/drivers/gpu/drm/nouveau/core/engine/fifo/nve0.c
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nve0.c
@@ -952,8 +952,8 @@ nve0_fifo_intr(struct nouveau_subdev *subdev)
         }
 
         if (stat & 0x80000000) {
-                nve0_fifo_intr_engine(priv);
                 nv_wr32(priv, 0x002100, 0x80000000);
+                nve0_fifo_intr_engine(priv);
                 stat &= ~0x80000000;
         }
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_drm.c b/drivers/gpu/drm/nouveau/nouveau_drm.c
index 57238076049f..62b97c4eef8d 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drm.c
+++ b/drivers/gpu/drm/nouveau/nouveau_drm.c
@@ -629,7 +629,6 @@ int nouveau_pmops_suspend(struct device *dev)
 
         pci_save_state(pdev);
         pci_disable_device(pdev);
-        pci_ignore_hotplug(pdev);
         pci_set_power_state(pdev, PCI_D3hot);
         return 0;
 }
@@ -933,6 +932,7 @@ static int nouveau_pmops_runtime_suspend(struct device *dev)
         ret = nouveau_do_suspend(drm_dev, true);
         pci_save_state(pdev);
         pci_disable_device(pdev);
+        pci_ignore_hotplug(pdev);
         pci_set_power_state(pdev, PCI_D3cold);
         drm_dev->switch_power_state = DRM_SWITCH_POWER_DYNAMIC_OFF;
         return ret;
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.c b/drivers/gpu/drm/nouveau/nouveau_fence.c
index 515cd9aebb99..f32a434724e3 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.c
@@ -52,20 +52,24 @@ nouveau_fctx(struct nouveau_fence *fence)
         return container_of(fence->base.lock, struct nouveau_fence_chan, lock);
 }
 
-static void
+static int
 nouveau_fence_signal(struct nouveau_fence *fence)
 {
+        int drop = 0;
+
         fence_signal_locked(&fence->base);
         list_del(&fence->head);
+        rcu_assign_pointer(fence->channel, NULL);
 
         if (test_bit(FENCE_FLAG_USER_BITS, &fence->base.flags)) {
                 struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
 
                 if (!--fctx->notify_ref)
-                        nvif_notify_put(&fctx->notify);
+                        drop = 1;
         }
 
         fence_put(&fence->base);
+        return drop;
 }
 
 static struct nouveau_fence *
@@ -88,16 +92,23 @@ nouveau_fence_context_del(struct nouveau_fence_chan *fctx)
 {
         struct nouveau_fence *fence;
 
-        nvif_notify_fini(&fctx->notify);
-
         spin_lock_irq(&fctx->lock);
         while (!list_empty(&fctx->pending)) {
                 fence = list_entry(fctx->pending.next, typeof(*fence), head);
 
-                nouveau_fence_signal(fence);
-                fence->channel = NULL;
+                if (nouveau_fence_signal(fence))
+                        nvif_notify_put(&fctx->notify);
         }
         spin_unlock_irq(&fctx->lock);
+
+        nvif_notify_fini(&fctx->notify);
+        fctx->dead = 1;
+
+        /*
+         * Ensure that all accesses to fence->channel complete before freeing
+         * the channel.
+         */
+        synchronize_rcu();
 }
 
 static void
@@ -112,21 +123,23 @@ nouveau_fence_context_free(struct nouveau_fence_chan *fctx)
         kref_put(&fctx->fence_ref, nouveau_fence_context_put);
 }
 
-static void
+static int
 nouveau_fence_update(struct nouveau_channel *chan, struct nouveau_fence_chan *fctx)
 {
         struct nouveau_fence *fence;
-
+        int drop = 0;
         u32 seq = fctx->read(chan);
 
         while (!list_empty(&fctx->pending)) {
                 fence = list_entry(fctx->pending.next, typeof(*fence), head);
 
                 if ((int)(seq - fence->base.seqno) < 0)
-                        return;
+                        break;
 
-                nouveau_fence_signal(fence);
+                drop |= nouveau_fence_signal(fence);
         }
+
+        return drop;
 }
 
 static int
@@ -135,18 +148,21 @@ nouveau_fence_wait_uevent_handler(struct nvif_notify *notify)
         struct nouveau_fence_chan *fctx =
                 container_of(notify, typeof(*fctx), notify);
         unsigned long flags;
+        int ret = NVIF_NOTIFY_KEEP;
 
         spin_lock_irqsave(&fctx->lock, flags);
         if (!list_empty(&fctx->pending)) {
                 struct nouveau_fence *fence;
+                struct nouveau_channel *chan;
 
                 fence = list_entry(fctx->pending.next, typeof(*fence), head);
-                nouveau_fence_update(fence->channel, fctx);
+                chan = rcu_dereference_protected(fence->channel, lockdep_is_held(&fctx->lock));
+                if (nouveau_fence_update(fence->channel, fctx))
+                        ret = NVIF_NOTIFY_DROP;
         }
         spin_unlock_irqrestore(&fctx->lock, flags);
 
-        /* Always return keep here. NVIF refcount is handled with nouveau_fence_update */
-        return NVIF_NOTIFY_KEEP;
+        return ret;
 }
 
 void
@@ -262,7 +278,10 @@ nouveau_fence_emit(struct nouveau_fence *fence, struct nouveau_channel *chan)
         if (!ret) {
                 fence_get(&fence->base);
                 spin_lock_irq(&fctx->lock);
-                nouveau_fence_update(chan, fctx);
+
+                if (nouveau_fence_update(chan, fctx))
+                        nvif_notify_put(&fctx->notify);
+
                 list_add_tail(&fence->head, &fctx->pending);
                 spin_unlock_irq(&fctx->lock);
         }
@@ -276,13 +295,16 @@ nouveau_fence_done(struct nouveau_fence *fence)
         if (fence->base.ops == &nouveau_fence_ops_legacy ||
             fence->base.ops == &nouveau_fence_ops_uevent) {
                 struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
+                struct nouveau_channel *chan;
                 unsigned long flags;
 
                 if (test_bit(FENCE_FLAG_SIGNALED_BIT, &fence->base.flags))
                         return true;
 
                 spin_lock_irqsave(&fctx->lock, flags);
-                nouveau_fence_update(fence->channel, fctx);
+                chan = rcu_dereference_protected(fence->channel, lockdep_is_held(&fctx->lock));
+                if (chan && nouveau_fence_update(chan, fctx))
+                        nvif_notify_put(&fctx->notify);
                 spin_unlock_irqrestore(&fctx->lock, flags);
         }
         return fence_is_signaled(&fence->base);
@@ -387,12 +409,18 @@ nouveau_fence_sync(struct nouveau_bo *nvbo, struct nouveau_channel *chan, bool e
 
         if (fence && (!exclusive || !fobj || !fobj->shared_count)) {
                 struct nouveau_channel *prev = NULL;
+                bool must_wait = true;
 
                 f = nouveau_local_fence(fence, chan->drm);
-                if (f)
-                        prev = f->channel;
+                if (f) {
+                        rcu_read_lock();
+                        prev = rcu_dereference(f->channel);
+                        if (prev && (prev == chan || fctx->sync(f, prev, chan) == 0))
+                                must_wait = false;
+                        rcu_read_unlock();
+                }
 
-                if (!prev || (prev != chan && (ret = fctx->sync(f, prev, chan))))
+                if (must_wait)
                         ret = fence_wait(fence, intr);
 
                 return ret;
@@ -403,19 +431,22 @@ nouveau_fence_sync(struct nouveau_bo *nvbo, struct nouveau_channel *chan, bool e
 
         for (i = 0; i < fobj->shared_count && !ret; ++i) {
                 struct nouveau_channel *prev = NULL;
+                bool must_wait = true;
 
                 fence = rcu_dereference_protected(fobj->shared[i],
                                                 reservation_object_held(resv));
 
                 f = nouveau_local_fence(fence, chan->drm);
-                if (f)
-                        prev = f->channel;
+                if (f) {
+                        rcu_read_lock();
+                        prev = rcu_dereference(f->channel);
+                        if (prev && (prev == chan || fctx->sync(f, prev, chan) == 0))
+                                must_wait = false;
+                        rcu_read_unlock();
+                }
 
-                if (!prev || (prev != chan && (ret = fctx->sync(f, prev, chan))))
+                if (must_wait)
                         ret = fence_wait(fence, intr);
-
-                if (ret)
-                        break;
         }
 
         return ret;
@@ -463,7 +494,7 @@ static const char *nouveau_fence_get_timeline_name(struct fence *f)
         struct nouveau_fence *fence = from_fence(f);
         struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
 
-        return fence->channel ? fctx->name : "dead channel";
+        return !fctx->dead ? fctx->name : "dead channel";
 }
 
 /*
@@ -476,9 +507,16 @@ static bool nouveau_fence_is_signaled(struct fence *f)
 {
         struct nouveau_fence *fence = from_fence(f);
         struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
-        struct nouveau_channel *chan = fence->channel;
+        struct nouveau_channel *chan;
+        bool ret = false;
+
+        rcu_read_lock();
+        chan = rcu_dereference(fence->channel);
+        if (chan)
+                ret = (int)(fctx->read(chan) - fence->base.seqno) >= 0;
+        rcu_read_unlock();
 
-        return (int)(fctx->read(chan) - fence->base.seqno) >= 0;
+        return ret;
 }
 
 static bool nouveau_fence_no_signaling(struct fence *f)
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.h b/drivers/gpu/drm/nouveau/nouveau_fence.h
index 943b0b17b1fc..96e461c6f68f 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.h
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.h
@@ -14,7 +14,7 @@ struct nouveau_fence {
 
         bool sysmem;
 
-        struct nouveau_channel *channel;
+        struct nouveau_channel __rcu *channel;
         unsigned long timeout;
 };
 
@@ -47,7 +47,7 @@ struct nouveau_fence_chan {
         char name[32];
 
         struct nvif_notify notify;
-        int notify_ref;
+        int notify_ref, dead;
 };
 
 struct nouveau_fence_priv {
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 300c4b3d4669..26baa9c05f6c 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -322,6 +322,12 @@ static void radeon_connector_get_edid(struct drm_connector *connector)
         }
 
         if (!radeon_connector->edid) {
+                /* don't fetch the edid from the vbios if ddc fails and runpm is
+                 * enabled so we report disconnected.
+                 */
+                if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
+                        return;
+
                 if (rdev->is_atom_bios) {
                         /* some laptops provide a hardcoded edid in rom for LCDs */
                         if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
@@ -826,6 +832,8 @@ static int radeon_lvds_mode_valid(struct drm_connector *connector,
 static enum drm_connector_status
 radeon_lvds_detect(struct drm_connector *connector, bool force)
 {
+        struct drm_device *dev = connector->dev;
+        struct radeon_device *rdev = dev->dev_private;
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
         enum drm_connector_status ret = connector_status_disconnected;
@@ -842,7 +850,11 @@ radeon_lvds_detect(struct drm_connector *connector, bool force)
                 /* check if panel is valid */
                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
                         ret = connector_status_connected;
-
+                /* don't fetch the edid from the vbios if ddc fails and runpm is
+                 * enabled so we report disconnected.
+                 */
+                if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
+                        ret = connector_status_disconnected;
         }
 
         /* check for edid as well */
@@ -1589,6 +1601,11 @@ radeon_dp_detect(struct drm_connector *connector, bool force)
                         /* check if panel is valid */
                         if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
                                 ret = connector_status_connected;
+                        /* don't fetch the edid from the vbios if ddc fails and runpm is
+                         * enabled so we report disconnected.
+                         */
+                        if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
+                                ret = connector_status_disconnected;
                 }
                 /* eDP is always DP */
                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
diff --git a/drivers/gpu/drm/radeon/radeon_cs.c b/drivers/gpu/drm/radeon/radeon_cs.c
index a3e7aed7e680..6f377de099f9 100644
--- a/drivers/gpu/drm/radeon/radeon_cs.c
+++ b/drivers/gpu/drm/radeon/radeon_cs.c
@@ -251,22 +251,19 @@ static int radeon_cs_get_ring(struct radeon_cs_parser *p, u32 ring, s32 priority
 
 static int radeon_cs_sync_rings(struct radeon_cs_parser *p)
 {
-        int i, r = 0;
+        struct radeon_cs_reloc *reloc;
+        int r;
 
-        for (i = 0; i < p->nrelocs; i++) {
+        list_for_each_entry(reloc, &p->validated, tv.head) {
                 struct reservation_object *resv;
 
-                if (!p->relocs[i].robj)
-                        continue;
-
-                resv = p->relocs[i].robj->tbo.resv;
+                resv = reloc->robj->tbo.resv;
                 r = radeon_semaphore_sync_resv(p->rdev, p->ib.semaphore, resv,
-                                               p->relocs[i].tv.shared);
-
+                                               reloc->tv.shared);
                 if (r)
-                        break;
+                        return r;
         }
-        return r;
+        return 0;
 }
 
 /* XXX: note that this is called from the legacy UMS CS ioctl as well */
diff --git a/drivers/gpu/drm/radeon/radeon_irq_kms.c b/drivers/gpu/drm/radeon/radeon_irq_kms.c
index 7784911d78ef..00fc59762e0d 100644
--- a/drivers/gpu/drm/radeon/radeon_irq_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_irq_kms.c
@@ -185,6 +185,16 @@ static bool radeon_msi_ok(struct radeon_device *rdev)
         if (rdev->flags & RADEON_IS_AGP)
                 return false;
 
+        /*
+         * Older chips have a HW limitation, they can only generate 40 bits
+         * of address for "64-bit" MSIs which breaks on some platforms, notably
+         * IBM POWER servers, so we limit them
+         */
+        if (rdev->family < CHIP_BONAIRE) {
+                dev_info(rdev->dev, "radeon: MSI limited to 32-bit\n");
+                rdev->pdev->no_64bit_msi = 1;
+        }
+
         /* force MSI on */
         if (radeon_msi == 1)
                 return true;
diff --git a/drivers/gpu/drm/radeon/radeon_kms.c b/drivers/gpu/drm/radeon/radeon_kms.c
index 8309b11e674d..03586763ee86 100644
--- a/drivers/gpu/drm/radeon/radeon_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_kms.c
@@ -795,6 +795,8 @@ int radeon_get_vblank_timestamp_kms(struct drm_device *dev, int crtc,
 
         /* Get associated drm_crtc: */
         drmcrtc = &rdev->mode_info.crtcs[crtc]->base;
+        if (!drmcrtc)
+                return -EINVAL;
 
         /* Helper routine in DRM core does all the work: */
         return drm_calc_vbltimestamp_from_scanoutpos(dev, crtc, max_error,
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index 99a960a4f302..4c0d786d5c7a 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -213,6 +213,13 @@ int radeon_bo_create(struct radeon_device *rdev,
         if (!(rdev->flags & RADEON_IS_PCIE))
                 bo->flags &= ~(RADEON_GEM_GTT_WC | RADEON_GEM_GTT_UC);
 
+#ifdef CONFIG_X86_32
+        /* XXX: Write-combined CPU mappings of GTT seem broken on 32-bit
+         * See https://bugs.freedesktop.org/show_bug.cgi?id=84627
+         */
+        bo->flags &= ~RADEON_GEM_GTT_WC;
+#endif
+
         radeon_ttm_placement_from_domain(bo, domain);
         /* Kernel allocation are uninterruptible */
         down_read(&rdev->pm.mclk_lock);
diff --git a/drivers/gpu/ipu-v3/ipu-csi.c b/drivers/gpu/ipu-v3/ipu-csi.c
index d6f56471bd2a..752cdd2da89a 100644
--- a/drivers/gpu/ipu-v3/ipu-csi.c
+++ b/drivers/gpu/ipu-v3/ipu-csi.c
@@ -227,83 +227,83 @@ static int ipu_csi_set_testgen_mclk(struct ipu_csi *csi, u32 pixel_clk,
 static int mbus_code_to_bus_cfg(struct ipu_csi_bus_config *cfg, u32 mbus_code)
 {
         switch (mbus_code) {
-        case V4L2_MBUS_FMT_BGR565_2X8_BE:
-        case V4L2_MBUS_FMT_BGR565_2X8_LE:
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_BGR565_2X8_BE:
+        case MEDIA_BUS_FMT_BGR565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_RGB565;
                 cfg->mipi_dt = MIPI_DT_RGB565;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_8;
                 break;
-        case V4L2_MBUS_FMT_RGB444_2X8_PADHI_BE:
-        case V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_RGB444_2X8_PADHI_BE:
+        case MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_RGB444;
                 cfg->mipi_dt = MIPI_DT_RGB444;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_8;
                 break;
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE:
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_RGB555;
                 cfg->mipi_dt = MIPI_DT_RGB555;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_8;
                 break;
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_YUV422_UYVY;
                 cfg->mipi_dt = MIPI_DT_YUV422;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_8;
                 break;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_YUV422_YUYV;
                 cfg->mipi_dt = MIPI_DT_YUV422;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_8;
                 break;
-        case V4L2_MBUS_FMT_UYVY8_1X16:
+        case MEDIA_BUS_FMT_UYVY8_1X16:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_YUV422_UYVY;
                 cfg->mipi_dt = MIPI_DT_YUV422;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_16;
                 break;
-        case V4L2_MBUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_YUV422_YUYV;
                 cfg->mipi_dt = MIPI_DT_YUV422;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_16;
                 break;
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
-        case V4L2_MBUS_FMT_SGBRG8_1X8:
-        case V4L2_MBUS_FMT_SGRBG8_1X8:
-        case V4L2_MBUS_FMT_SRGGB8_1X8:
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_SGBRG8_1X8:
+        case MEDIA_BUS_FMT_SGRBG8_1X8:
+        case MEDIA_BUS_FMT_SRGGB8_1X8:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_BAYER;
                 cfg->mipi_dt = MIPI_DT_RAW8;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_8;
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE:
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE:
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE:
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE:
+        case MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_BAYER;
                 cfg->mipi_dt = MIPI_DT_RAW10;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_8;
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_1X10:
-        case V4L2_MBUS_FMT_SGBRG10_1X10:
-        case V4L2_MBUS_FMT_SGRBG10_1X10:
-        case V4L2_MBUS_FMT_SRGGB10_1X10:
+        case MEDIA_BUS_FMT_SBGGR10_1X10:
+        case MEDIA_BUS_FMT_SGBRG10_1X10:
+        case MEDIA_BUS_FMT_SGRBG10_1X10:
+        case MEDIA_BUS_FMT_SRGGB10_1X10:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_BAYER;
                 cfg->mipi_dt = MIPI_DT_RAW10;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_10;
                 break;
-        case V4L2_MBUS_FMT_SBGGR12_1X12:
-        case V4L2_MBUS_FMT_SGBRG12_1X12:
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
-        case V4L2_MBUS_FMT_SRGGB12_1X12:
+        case MEDIA_BUS_FMT_SBGGR12_1X12:
+        case MEDIA_BUS_FMT_SGBRG12_1X12:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
+        case MEDIA_BUS_FMT_SRGGB12_1X12:
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_BAYER;
                 cfg->mipi_dt = MIPI_DT_RAW12;
                 cfg->data_width = IPU_CSI_DATA_WIDTH_12;
                 break;
-        case V4L2_MBUS_FMT_JPEG_1X8:
+        case MEDIA_BUS_FMT_JPEG_1X8:
                 /* TODO */
                 cfg->data_fmt = CSI_SENS_CONF_DATA_FMT_JPEG;
                 cfg->mipi_dt = MIPI_DT_RAW8;
diff --git a/drivers/hid/hid-sensor-hub.c b/drivers/hid/hid-sensor-hub.c
index e6d8e18dae97..6a58b6c723aa 100644
--- a/drivers/hid/hid-sensor-hub.c
+++ b/drivers/hid/hid-sensor-hub.c
@@ -641,9 +641,6 @@ static int sensor_hub_probe(struct hid_device *hdev,
                                         goto err_stop_hw;
                         }
                         sd->hid_sensor_hub_client_devs[
-                                sd->hid_sensor_client_cnt].id =
-                                                        PLATFORM_DEVID_AUTO;
-                        sd->hid_sensor_hub_client_devs[
                                 sd->hid_sensor_client_cnt].name = name;
                         sd->hid_sensor_hub_client_devs[
                                 sd->hid_sensor_client_cnt].platform_data =
@@ -659,8 +656,9 @@ static int sensor_hub_probe(struct hid_device *hdev,
         if (last_hsdev)
                 last_hsdev->end_collection_index = i;
 
-        ret = mfd_add_devices(&hdev->dev, 0, sd->hid_sensor_hub_client_devs,
-                sd->hid_sensor_client_cnt, NULL, 0, NULL);
+        ret = mfd_add_hotplug_devices(&hdev->dev,
+                        sd->hid_sensor_hub_client_devs,
+                        sd->hid_sensor_client_cnt);
         if (ret < 0)
                 goto err_stop_hw;
 
diff --git a/drivers/hid/i2c-hid/i2c-hid.c b/drivers/hid/i2c-hid/i2c-hid.c
index 747d54421e73..f09e70cafaf1 100644
--- a/drivers/hid/i2c-hid/i2c-hid.c
+++ b/drivers/hid/i2c-hid/i2c-hid.c
@@ -1095,7 +1095,7 @@ static int i2c_hid_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int i2c_hid_runtime_suspend(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
diff --git a/drivers/hsi/controllers/omap_ssi.c b/drivers/hsi/controllers/omap_ssi.c
index bf0eace4cb67..4d5b682fc6af 100644
--- a/drivers/hsi/controllers/omap_ssi.c
+++ b/drivers/hsi/controllers/omap_ssi.c
@@ -555,7 +555,7 @@ static int __exit ssi_remove(struct platform_device *pd)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int omap_ssi_runtime_suspend(struct device *dev)
 {
         struct hsi_controller *ssi = dev_get_drvdata(dev);
diff --git a/drivers/hsi/controllers/omap_ssi_port.c b/drivers/hsi/controllers/omap_ssi_port.c
index 4c0b5820581e..d836cfe50513 100644
--- a/drivers/hsi/controllers/omap_ssi_port.c
+++ b/drivers/hsi/controllers/omap_ssi_port.c
@@ -1260,7 +1260,7 @@ static int __exit ssi_port_remove(struct platform_device *pd)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int ssi_save_port_ctx(struct omap_ssi_port *omap_port)
 {
         struct hsi_port *port = to_hsi_port(omap_port->dev);
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 5286d7ce1f9e..6529c09c46f0 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -1028,11 +1028,11 @@ config SENSORS_LM93
           will be called lm93.
 
 config SENSORS_LM95234
-        tristate "National Semiconductor LM95234"
+        tristate "National Semiconductor LM95234 and compatibles"
         depends on I2C
         help
-          If you say yes here you get support for the LM95234 temperature
-          sensor.
+          If you say yes here you get support for the LM95233 and LM95234
+          temperature sensor chips.
 
           This driver can also be built as a module.  If so, the module
           will be called lm95234.
@@ -1048,10 +1048,11 @@ config SENSORS_LM95241
           will be called lm95241.
 
 config SENSORS_LM95245
-        tristate "National Semiconductor LM95245 sensor chip"
+        tristate "National Semiconductor LM95245 and compatibles"
         depends on I2C
         help
-          If you say yes here you get support for LM95245 sensor chip.
+          If you say yes here you get support for LM95235 and LM95245
+          temperature sensor chips.
 
           This driver can also be built as a module.  If so, the module
           will be called lm95245.
@@ -1117,12 +1118,23 @@ config SENSORS_NCT6775
         help
           If you say yes here you get support for the hardware monitoring
           functionality of the Nuvoton NCT6106D, NCT6775F, NCT6776F, NCT6779D,
-          NCT6791D and compatible Super-I/O chips. This driver replaces the
-          w83627ehf driver for NCT6775F and NCT6776F.
+          NCT6791D, NCT6792D and compatible Super-I/O chips. This driver
+          replaces the w83627ehf driver for NCT6775F and NCT6776F.
 
           This driver can also be built as a module.  If so, the module
           will be called nct6775.
 
+config SENSORS_NCT7802
+        tristate "Nuvoton NCT7802Y"
+        depends on I2C
+        select REGMAP_I2C
+        help
+          If you say yes here you get support for the Nuvoton NCT7802Y
+          hardware monitoring chip.
+
+          This driver can also be built as a module.  If so, the module
+          will be called nct7802.
+
 config SENSORS_PCF8591
         tristate "Philips PCF8591 ADC/DAC"
         depends on I2C
@@ -1454,7 +1466,7 @@ config SENSORS_TMP401
         depends on I2C
         help
           If you say yes here you get support for Texas Instruments TMP401,
-          TMP411, TMP431, and TMP432 temperature sensor chips.
+          TMP411, TMP431, TMP432 and TMP435 temperature sensor chips.
 
           This driver can also be built as a module.  If so, the module
           will be called tmp401.
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index c90a7611efaa..67280643bcf0 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -118,6 +118,7 @@ obj-$(CONFIG_SENSORS_MCP3021)	+= mcp3021.o
 obj-$(CONFIG_SENSORS_MENF21BMC_HWMON) += menf21bmc_hwmon.o
 obj-$(CONFIG_SENSORS_NCT6683)   += nct6683.o
 obj-$(CONFIG_SENSORS_NCT6775)   += nct6775.o
+obj-$(CONFIG_SENSORS_NCT7802)   += nct7802.o
 obj-$(CONFIG_SENSORS_NTC_THERMISTOR)    += ntc_thermistor.o
 obj-$(CONFIG_SENSORS_PC87360)   += pc87360.o
 obj-$(CONFIG_SENSORS_PC87427)   += pc87427.o
diff --git a/drivers/hwmon/g762.c b/drivers/hwmon/g762.c
index 6aac695b1688..9b55e673b67c 100644
--- a/drivers/hwmon/g762.c
+++ b/drivers/hwmon/g762.c
@@ -1084,10 +1084,8 @@ static int g762_probe(struct i2c_client *client, const struct i2c_device_id *id)
         if (ret)
                 goto clock_dis;
 
-        data->hwmon_dev = devm_hwmon_device_register_with_groups(dev,
-                                                                 client->name,
-                                                                 data,
-                                                                 g762_groups);
+        data->hwmon_dev = hwmon_device_register_with_groups(dev, client->name,
+                                                            data, g762_groups);
         if (IS_ERR(data->hwmon_dev)) {
                 ret = PTR_ERR(data->hwmon_dev);
                 goto clock_dis;
diff --git a/drivers/hwmon/gpio-fan.c b/drivers/hwmon/gpio-fan.c
index 4efa1734bdad..36abf814b8c7 100644
--- a/drivers/hwmon/gpio-fan.c
+++ b/drivers/hwmon/gpio-fan.c
@@ -79,7 +79,7 @@ static ssize_t show_fan_alarm(struct device *dev,
 {
         struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
         struct gpio_fan_alarm *alarm = fan_data->alarm;
-        int value = gpio_get_value(alarm->gpio);
+        int value = gpio_get_value_cansleep(alarm->gpio);
 
         if (alarm->active_low)
                 value = !value;
@@ -131,7 +131,7 @@ static void __set_fan_ctrl(struct gpio_fan_data *fan_data, int ctrl_val)
         int i;
 
         for (i = 0; i < fan_data->num_ctrl; i++)
-                gpio_set_value(fan_data->ctrl[i], (ctrl_val >> i) & 1);
+                gpio_set_value_cansleep(fan_data->ctrl[i], (ctrl_val >> i) & 1);
 }
 
 static int __get_fan_ctrl(struct gpio_fan_data *fan_data)
@@ -142,7 +142,7 @@ static int __get_fan_ctrl(struct gpio_fan_data *fan_data)
         for (i = 0; i < fan_data->num_ctrl; i++) {
                 int value;
 
-                value = gpio_get_value(fan_data->ctrl[i]);
+                value = gpio_get_value_cansleep(fan_data->ctrl[i]);
                 ctrl_val |= (value << i);
         }
         return ctrl_val;
@@ -369,7 +369,8 @@ static int fan_ctrl_init(struct gpio_fan_data *fan_data,
                 if (err)
                         return err;
 
-                err = gpio_direction_output(ctrl[i], gpio_get_value(ctrl[i]));
+                err = gpio_direction_output(ctrl[i],
+                                            gpio_get_value_cansleep(ctrl[i]));
                 if (err)
                         return err;
         }
@@ -549,6 +550,14 @@ static int gpio_fan_probe(struct platform_device *pdev)
         return 0;
 }
 
+static void gpio_fan_shutdown(struct platform_device *pdev)
+{
+        struct gpio_fan_data *fan_data = dev_get_drvdata(&pdev->dev);
+
+        if (fan_data->ctrl)
+                set_fan_speed(fan_data, 0);
+}
+
 #ifdef CONFIG_PM_SLEEP
 static int gpio_fan_suspend(struct device *dev)
 {
@@ -580,6 +589,7 @@ static SIMPLE_DEV_PM_OPS(gpio_fan_pm, gpio_fan_suspend, gpio_fan_resume);
 
 static struct platform_driver gpio_fan_driver = {
         .probe          = gpio_fan_probe,
+        .shutdown       = gpio_fan_shutdown,
         .driver = {
                 .name   = "gpio-fan",
                 .pm     = GPIO_FAN_PM,
diff --git a/drivers/hwmon/ibmpowernv.c b/drivers/hwmon/ibmpowernv.c
index 6a30eeea94be..7c2c7be182f2 100644
--- a/drivers/hwmon/ibmpowernv.c
+++ b/drivers/hwmon/ibmpowernv.c
@@ -74,9 +74,6 @@ struct platform_data {
         u32 sensors_count; /* Total count of sensors from each group */
 };
 
-/* Platform device representing all the ibmpowernv sensors */
-static struct platform_device *pdevice;
-
 static ssize_t show_sensor(struct device *dev, struct device_attribute *devattr,
                            char *buf)
 {
@@ -99,7 +96,7 @@ static ssize_t show_sensor(struct device *dev, struct device_attribute *devattr,
         return sprintf(buf, "%u\n", x);
 }
 
-static int __init get_sensor_index_attr(const char *name, u32 *index,
+static int get_sensor_index_attr(const char *name, u32 *index,
                                         char *attr)
 {
         char *hash_pos = strchr(name, '#');
@@ -136,7 +133,7 @@ static int __init get_sensor_index_attr(const char *name, u32 *index,
  * which need to be mapped as fan2_input, temp1_max respectively before
  * populating them inside hwmon device class.
  */
-static int __init create_hwmon_attr_name(struct device *dev, enum sensors type,
+static int create_hwmon_attr_name(struct device *dev, enum sensors type,
                                          const char *node_name,
                                          char *hwmon_attr_name)
 {
@@ -172,7 +169,7 @@ static int __init create_hwmon_attr_name(struct device *dev, enum sensors type,
         return 0;
 }
 
-static int __init populate_attr_groups(struct platform_device *pdev)
+static int populate_attr_groups(struct platform_device *pdev)
 {
         struct platform_data *pdata = platform_get_drvdata(pdev);
         const struct attribute_group **pgroups = pdata->attr_groups;
@@ -180,11 +177,6 @@ static int __init populate_attr_groups(struct platform_device *pdev)
         enum sensors type;
 
         opal = of_find_node_by_path("/ibm,opal/sensors");
-        if (!opal) {
-                dev_dbg(&pdev->dev, "Opal node 'sensors' not found\n");
-                return -ENODEV;
-        }
-
         for_each_child_of_node(opal, np) {
                 if (np->name == NULL)
                         continue;
@@ -221,7 +213,7 @@ static int __init populate_attr_groups(struct platform_device *pdev)
  * to the name required by the higher 'hwmon' driver like fan1_input, temp1_max
  * etc..
  */
-static int __init create_device_attrs(struct platform_device *pdev)
+static int create_device_attrs(struct platform_device *pdev)
 {
         struct platform_data *pdata = platform_get_drvdata(pdev);
         const struct attribute_group **pgroups = pdata->attr_groups;
@@ -280,7 +272,7 @@ exit_put_node:
         return err;
 }
 
-static int __init ibmpowernv_probe(struct platform_device *pdev)
+static int ibmpowernv_probe(struct platform_device *pdev)
 {
         struct platform_data *pdata;
         struct device *hwmon_dev;
@@ -309,57 +301,25 @@ static int __init ibmpowernv_probe(struct platform_device *pdev)
         return PTR_ERR_OR_ZERO(hwmon_dev);
 }
 
-static struct platform_driver ibmpowernv_driver = {
-        .driver = {
-                .owner = THIS_MODULE,
-                .name = DRVNAME,
+static const struct platform_device_id opal_sensor_driver_ids[] = {
+        {
+                .name = "opal-sensor",
         },
+        { }
 };
+MODULE_DEVICE_TABLE(platform, opal_sensor_driver_ids);
 
-static int __init ibmpowernv_init(void)
-{
-        int err;
-
-        pdevice = platform_device_alloc(DRVNAME, 0);
-        if (!pdevice) {
-                pr_err("Device allocation failed\n");
-                err = -ENOMEM;
-                goto exit;
-        }
-
-        err = platform_device_add(pdevice);
-        if (err) {
-                pr_err("Device addition failed (%d)\n", err);
-                goto exit_device_put;
-        }
-
-        err = platform_driver_probe(&ibmpowernv_driver, ibmpowernv_probe);
-        if (err) {
-                if (err != -ENODEV)
-                        pr_err("Platform driver probe failed (%d)\n", err);
-
-                goto exit_device_del;
-        }
-
-        return 0;
-
-exit_device_del:
-        platform_device_del(pdevice);
-exit_device_put:
-        platform_device_put(pdevice);
-exit:
-        return err;
-}
+static struct platform_driver ibmpowernv_driver = {
+        .probe          = ibmpowernv_probe,
+        .id_table       = opal_sensor_driver_ids,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = DRVNAME,
+        },
+};
 
-static void __exit ibmpowernv_exit(void)
-{
-        platform_driver_unregister(&ibmpowernv_driver);
-        platform_device_unregister(pdevice);
-}
+module_platform_driver(ibmpowernv_driver);
 
 MODULE_AUTHOR("Neelesh Gupta <neelegup@linux.vnet.ibm.com>");
 MODULE_DESCRIPTION("IBM POWERNV platform sensors");
 MODULE_LICENSE("GPL");
-
-module_init(ibmpowernv_init);
-module_exit(ibmpowernv_exit);
diff --git a/drivers/hwmon/iio_hwmon.c b/drivers/hwmon/iio_hwmon.c
index 14c82daab019..980175628563 100644
--- a/drivers/hwmon/iio_hwmon.c
+++ b/drivers/hwmon/iio_hwmon.c
@@ -63,7 +63,7 @@ static int iio_hwmon_probe(struct platform_device *pdev)
         struct iio_hwmon_state *st;
         struct sensor_device_attribute *a;
         int ret, i;
-        int in_i = 1, temp_i = 1, curr_i = 1;
+        int in_i = 1, temp_i = 1, curr_i = 1, humidity_i = 1;
         enum iio_chan_type type;
         struct iio_channel *channels;
         const char *name = "iio_hwmon";
@@ -123,6 +123,11 @@ static int iio_hwmon_probe(struct platform_device *pdev)
                                                           "curr%d_input",
                                                           curr_i++);
                         break;
+                case IIO_HUMIDITYRELATIVE:
+                        a->dev_attr.attr.name = kasprintf(GFP_KERNEL,
+                                                          "humidity%d_input",
+                                                          humidity_i++);
+                        break;
                 default:
                         ret = -EINVAL;
                         goto error_release_channels;
diff --git a/drivers/hwmon/ina2xx.c b/drivers/hwmon/ina2xx.c
index bfd3f3eeabcd..e01feba909c3 100644
--- a/drivers/hwmon/ina2xx.c
+++ b/drivers/hwmon/ina2xx.c
@@ -223,6 +223,7 @@ static int ina2xx_probe(struct i2c_client *client,
         struct device *hwmon_dev;
         long shunt = 10000; /* default shunt value 10mOhms */
         u32 val;
+        int ret;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
                 return -ENODEV;
@@ -247,12 +248,25 @@ static int ina2xx_probe(struct i2c_client *client,
         data->config = &ina2xx_config[data->kind];
 
         /* device configuration */
-        i2c_smbus_write_word_swapped(client, INA2XX_CONFIG,
-                                     data->config->config_default);
-        /* set current LSB to 1mA, shunt is in uOhms */
-        /* (equation 13 in datasheet) */
-        i2c_smbus_write_word_swapped(client, INA2XX_CALIBRATION,
-                                     data->config->calibration_factor / shunt);
+        ret = i2c_smbus_write_word_swapped(client, INA2XX_CONFIG,
+                                           data->config->config_default);
+        if (ret < 0) {
+                dev_err(dev,
+                        "error writing to the config register: %d", ret);
+                return -ENODEV;
+        }
+
+        /*
+         * Set current LSB to 1mA, shunt is in uOhms
+         * (equation 13 in datasheet).
+         */
+        ret = i2c_smbus_write_word_swapped(client, INA2XX_CALIBRATION,
+                                data->config->calibration_factor / shunt);
+        if (ret < 0) {
+                dev_err(dev,
+                        "error writing to the calibration register: %d", ret);
+                return -ENODEV;
+        }
 
         data->client = client;
         mutex_init(&data->update_lock);
diff --git a/drivers/hwmon/lm75.c b/drivers/hwmon/lm75.c
index d16dbb33a531..6753fd940c76 100644
--- a/drivers/hwmon/lm75.c
+++ b/drivers/hwmon/lm75.c
@@ -44,6 +44,7 @@ enum lm75_type {		/* keep sorted in alphabetical order */
         g751,
         lm75,
         lm75a,
+        lm75b,
         max6625,
         max6626,
         mcp980x,
@@ -233,6 +234,10 @@ lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
                 data->resolution = 9;
                 data->sample_time = HZ / 2;
                 break;
+        case lm75b:
+                data->resolution = 11;
+                data->sample_time = HZ / 4;
+                break;
         case max6625:
                 data->resolution = 9;
                 data->sample_time = HZ / 4;
@@ -322,6 +327,7 @@ static const struct i2c_device_id lm75_ids[] = {
         { "g751", g751, },
         { "lm75", lm75, },
         { "lm75a", lm75a, },
+        { "lm75b", lm75b, },
         { "max6625", max6625, },
         { "max6626", max6626, },
         { "mcp980x", mcp980x, },
@@ -409,6 +415,12 @@ static int lm75_detect(struct i2c_client *new_client,
                  || i2c_smbus_read_byte_data(new_client, 7) != os)
                         return -ENODEV;
         }
+        /*
+         * It is very unlikely that this is a LM75 if both
+         * hysteresis and temperature limit registers are 0.
+         */
+        if (hyst == 0 && os == 0)
+                return -ENODEV;
 
         /* Addresses cycling */
         for (i = 8; i <= 248; i += 40) {
diff --git a/drivers/hwmon/lm95234.c b/drivers/hwmon/lm95234.c
index 411202bdaf6b..8796de39ff9b 100644
--- a/drivers/hwmon/lm95234.c
+++ b/drivers/hwmon/lm95234.c
@@ -1,7 +1,7 @@
 /*
  * Driver for Texas Instruments / National Semiconductor LM95234
  *
- * Copyright (c) 2013 Guenter Roeck <linux@roeck-us.net>
+ * Copyright (c) 2013, 2014 Guenter Roeck <linux@roeck-us.net>
  *
  * Derived from lm95241.c
  * Copyright (C) 2008, 2010 Davide Rizzo <elpa.rizzo@gmail.com>
@@ -30,7 +30,10 @@
 
 #define DRVNAME "lm95234"
 
-static const unsigned short normal_i2c[] = { 0x18, 0x4d, 0x4e, I2C_CLIENT_END };
+enum chips { lm95233, lm95234 };
+
+static const unsigned short normal_i2c[] = {
+        0x18, 0x2a, 0x2b, 0x4d, 0x4e, I2C_CLIENT_END };
 
 /* LM95234 registers */
 #define LM95234_REG_MAN_ID              0xFE
@@ -53,11 +56,13 @@ static const unsigned short normal_i2c[] = { 0x18, 0x4d, 0x4e, I2C_CLIENT_END };
 #define LM95234_REG_TCRIT_HYST          0x5a
 
 #define NATSEMI_MAN_ID                  0x01
+#define LM95233_CHIP_ID                 0x89
 #define LM95234_CHIP_ID                 0x79
 
 /* Client data (each client gets its own) */
 struct lm95234_data {
         struct i2c_client *client;
+        const struct attribute_group *groups[3];
         struct mutex update_lock;
         unsigned long last_updated, interval;   /* in jiffies */
         bool valid;             /* false until following fields are valid */
@@ -564,35 +569,23 @@ static SENSOR_DEVICE_ATTR(temp5_offset, S_IWUSR | S_IRUGO, show_offset,
 static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval,
                    set_interval);
 
-static struct attribute *lm95234_attrs[] = {
+static struct attribute *lm95234_common_attrs[] = {
         &sensor_dev_attr_temp1_input.dev_attr.attr,
         &sensor_dev_attr_temp2_input.dev_attr.attr,
         &sensor_dev_attr_temp3_input.dev_attr.attr,
-        &sensor_dev_attr_temp4_input.dev_attr.attr,
-        &sensor_dev_attr_temp5_input.dev_attr.attr,
         &sensor_dev_attr_temp2_fault.dev_attr.attr,
         &sensor_dev_attr_temp3_fault.dev_attr.attr,
-        &sensor_dev_attr_temp4_fault.dev_attr.attr,
-        &sensor_dev_attr_temp5_fault.dev_attr.attr,
         &sensor_dev_attr_temp2_type.dev_attr.attr,
         &sensor_dev_attr_temp3_type.dev_attr.attr,
-        &sensor_dev_attr_temp4_type.dev_attr.attr,
-        &sensor_dev_attr_temp5_type.dev_attr.attr,
         &sensor_dev_attr_temp1_max.dev_attr.attr,
         &sensor_dev_attr_temp2_max.dev_attr.attr,
         &sensor_dev_attr_temp3_max.dev_attr.attr,
-        &sensor_dev_attr_temp4_max.dev_attr.attr,
-        &sensor_dev_attr_temp5_max.dev_attr.attr,
         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
         &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
         &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
-        &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
-        &sensor_dev_attr_temp5_max_hyst.dev_attr.attr,
         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_crit.dev_attr.attr,
         &sensor_dev_attr_temp3_crit.dev_attr.attr,
         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
@@ -601,18 +594,44 @@ static struct attribute *lm95234_attrs[] = {
         &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_offset.dev_attr.attr,
         &sensor_dev_attr_temp3_offset.dev_attr.attr,
+        &dev_attr_update_interval.attr,
+        NULL
+};
+
+static const struct attribute_group lm95234_common_group = {
+        .attrs = lm95234_common_attrs,
+};
+
+static struct attribute *lm95234_attrs[] = {
+        &sensor_dev_attr_temp4_input.dev_attr.attr,
+        &sensor_dev_attr_temp5_input.dev_attr.attr,
+        &sensor_dev_attr_temp4_fault.dev_attr.attr,
+        &sensor_dev_attr_temp5_fault.dev_attr.attr,
+        &sensor_dev_attr_temp4_type.dev_attr.attr,
+        &sensor_dev_attr_temp5_type.dev_attr.attr,
+        &sensor_dev_attr_temp4_max.dev_attr.attr,
+        &sensor_dev_attr_temp5_max.dev_attr.attr,
+        &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp5_max_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
         &sensor_dev_attr_temp4_offset.dev_attr.attr,
         &sensor_dev_attr_temp5_offset.dev_attr.attr,
-        &dev_attr_update_interval.attr,
         NULL
 };
-ATTRIBUTE_GROUPS(lm95234);
+
+static const struct attribute_group lm95234_group = {
+        .attrs = lm95234_attrs,
+};
 
 static int lm95234_detect(struct i2c_client *client,
                           struct i2c_board_info *info)
 {
         struct i2c_adapter *adapter = client->adapter;
+        int address = client->addr;
+        u8 config_mask, model_mask;
         int mfg_id, chip_id, val;
+        const char *name;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                 return -ENODEV;
@@ -622,15 +641,31 @@ static int lm95234_detect(struct i2c_client *client,
                 return -ENODEV;
 
         chip_id = i2c_smbus_read_byte_data(client, LM95234_REG_CHIP_ID);
-        if (chip_id != LM95234_CHIP_ID)
+        switch (chip_id) {
+        case LM95233_CHIP_ID:
+                if (address != 0x18 && address != 0x2a && address != 0x2b)
+                        return -ENODEV;
+                config_mask = 0xbf;
+                model_mask = 0xf9;
+                name = "lm95233";
+                break;
+        case LM95234_CHIP_ID:
+                if (address != 0x18 && address != 0x4d && address != 0x4e)
+                        return -ENODEV;
+                config_mask = 0xbc;
+                model_mask = 0xe1;
+                name = "lm95234";
+                break;
+        default:
                 return -ENODEV;
+        }
 
         val = i2c_smbus_read_byte_data(client, LM95234_REG_STATUS);
         if (val & 0x30)
                 return -ENODEV;
 
         val = i2c_smbus_read_byte_data(client, LM95234_REG_CONFIG);
-        if (val & 0xbc)
+        if (val & config_mask)
                 return -ENODEV;
 
         val = i2c_smbus_read_byte_data(client, LM95234_REG_CONVRATE);
@@ -638,14 +673,14 @@ static int lm95234_detect(struct i2c_client *client,
                 return -ENODEV;
 
         val = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL);
-        if (val & 0xe1)
+        if (val & model_mask)
                 return -ENODEV;
 
         val = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL_STS);
-        if (val & 0xe1)
+        if (val & model_mask)
                 return -ENODEV;
 
-        strlcpy(info->type, "lm95234", I2C_NAME_SIZE);
+        strlcpy(info->type, name, I2C_NAME_SIZE);
         return 0;
 }
 
@@ -698,15 +733,19 @@ static int lm95234_probe(struct i2c_client *client,
         if (err < 0)
                 return err;
 
+        data->groups[0] = &lm95234_common_group;
+        if (id->driver_data == lm95234)
+                data->groups[1] = &lm95234_group;
+
         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-                                                           data,
-                                                           lm95234_groups);
+                                                           data, data->groups);
         return PTR_ERR_OR_ZERO(hwmon_dev);
 }
 
 /* Driver data (common to all clients) */
 static const struct i2c_device_id lm95234_id[] = {
-        { "lm95234", 0 },
+        { "lm95233", lm95233 },
+        { "lm95234", lm95234 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, lm95234_id);
@@ -725,5 +764,5 @@ static struct i2c_driver lm95234_driver = {
 module_i2c_driver(lm95234_driver);
 
 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
-MODULE_DESCRIPTION("LM95234 sensor driver");
+MODULE_DESCRIPTION("LM95233/LM95234 sensor driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/lm95245.c b/drivers/hwmon/lm95245.c
index 0ae0dfdafdff..e7aef4561c83 100644
--- a/drivers/hwmon/lm95245.c
+++ b/drivers/hwmon/lm95245.c
@@ -1,10 +1,8 @@
 /*
  * Copyright (C) 2011 Alexander Stein <alexander.stein@systec-electronic.com>
  *
- * The LM95245 is a sensor chip made by National Semiconductors.
+ * The LM95245 is a sensor chip made by TI / National Semiconductor.
  * It reports up to two temperatures (its own plus an external one).
- * Complete datasheet can be obtained from National's website at:
- *   http://www.national.com/ds.cgi/LM/LM95245.pdf
  *
  * This driver is based on lm95241.c
  *
@@ -34,8 +32,6 @@
 #include <linux/mutex.h>
 #include <linux/sysfs.h>
 
-#define DEVNAME "lm95245"
-
 static const unsigned short normal_i2c[] = {
         0x18, 0x19, 0x29, 0x4c, 0x4d, I2C_CLIENT_END };
 
@@ -98,7 +94,8 @@ static const unsigned short normal_i2c[] = {
 #define STATUS1_LOC             0x01
 
 #define MANUFACTURER_ID         0x01
-#define DEFAULT_REVISION        0xB3
+#define LM95235_REVISION        0xB1
+#define LM95245_REVISION        0xB3
 
 static const u8 lm95245_reg_address[] = {
         LM95245_REG_R_LOCAL_TEMPH_S,
@@ -427,17 +424,32 @@ static int lm95245_detect(struct i2c_client *new_client,
                           struct i2c_board_info *info)
 {
         struct i2c_adapter *adapter = new_client->adapter;
+        int address = new_client->addr;
+        const char *name;
+        int rev, id;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                 return -ENODEV;
 
-        if (i2c_smbus_read_byte_data(new_client, LM95245_REG_R_MAN_ID)
-                        != MANUFACTURER_ID
-                || i2c_smbus_read_byte_data(new_client, LM95245_REG_R_CHIP_ID)
-                        != DEFAULT_REVISION)
+        id = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_MAN_ID);
+        if (id != MANUFACTURER_ID)
                 return -ENODEV;
 
-        strlcpy(info->type, DEVNAME, I2C_NAME_SIZE);
+        rev = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_CHIP_ID);
+        switch (rev) {
+        case LM95235_REVISION:
+                if (address != 0x18 && address != 0x29 && address != 0x4c)
+                        return -ENODEV;
+                name = "lm95235";
+                break;
+        case LM95245_REVISION:
+                name = "lm95245";
+                break;
+        default:
+                return -ENODEV;
+        }
+
+        strlcpy(info->type, name, I2C_NAME_SIZE);
         return 0;
 }
 
@@ -484,7 +496,8 @@ static int lm95245_probe(struct i2c_client *client,
 
 /* Driver data (common to all clients) */
 static const struct i2c_device_id lm95245_id[] = {
-        { DEVNAME, 0 },
+        { "lm95235", 0 },
+        { "lm95245", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, lm95245_id);
@@ -492,7 +505,7 @@ MODULE_DEVICE_TABLE(i2c, lm95245_id);
 static struct i2c_driver lm95245_driver = {
         .class          = I2C_CLASS_HWMON,
         .driver = {
-                .name   = DEVNAME,
+                .name   = "lm95245",
         },
         .probe          = lm95245_probe,
         .id_table       = lm95245_id,
@@ -503,5 +516,5 @@ static struct i2c_driver lm95245_driver = {
 module_i2c_driver(lm95245_driver);
 
 MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>");
-MODULE_DESCRIPTION("LM95245 sensor driver");
+MODULE_DESCRIPTION("LM95235/LM95245 sensor driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/nct6775.c b/drivers/hwmon/nct6775.c
index 504cbddbdd90..dc0df57200cd 100644
--- a/drivers/hwmon/nct6775.c
+++ b/drivers/hwmon/nct6775.c
@@ -38,6 +38,7 @@
  * nct6776f     9      5       3       6+3    0xc330 0xc1    0x5ca3
  * nct6779d    15      5       5       2+6    0xc560 0xc1    0x5ca3
  * nct6791d    15      6       6       2+6    0xc800 0xc1    0x5ca3
+ * nct6792d    15      6       6       2+6    0xc910 0xc1    0x5ca3
  *
  * #temp lists the number of monitored temperature sources (first value) plus
  * the number of directly connectable temperature sensors (second value).
@@ -61,7 +62,7 @@
 
 #define USE_ALTERNATE
 
-enum kinds { nct6106, nct6775, nct6776, nct6779, nct6791 };
+enum kinds { nct6106, nct6775, nct6776, nct6779, nct6791, nct6792 };
 
 /* used to set data->name = nct6775_device_names[data->sio_kind] */
 static const char * const nct6775_device_names[] = {
@@ -70,6 +71,7 @@ static const char * const nct6775_device_names[] = {
         "nct6776",
         "nct6779",
         "nct6791",
+        "nct6792",
 };
 
 static unsigned short force_id;
@@ -100,6 +102,7 @@ MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal");
 #define SIO_NCT6776_ID          0xc330
 #define SIO_NCT6779_ID          0xc560
 #define SIO_NCT6791_ID          0xc800
+#define SIO_NCT6792_ID          0xc910
 #define SIO_ID_MASK             0xFFF0
 
 enum pwm_enable { off, manual, thermal_cruise, speed_cruise, sf3, sf4 };
@@ -529,6 +532,12 @@ static const s8 NCT6791_ALARM_BITS[] = {
         4, 5, 13, -1, -1, -1,           /* temp1..temp6 */
         12, 9 };                        /* intrusion0, intrusion1 */
 
+/* NCT6792 specific data */
+
+static const u16 NCT6792_REG_TEMP_MON[] = {
+        0x73, 0x75, 0x77, 0x79, 0x7b, 0x7d };
+static const u16 NCT6792_REG_BEEP[NUM_REG_BEEP] = {
+        0xb2, 0xb3, 0xb4, 0xb5, 0xbf };
 
 /* NCT6102D/NCT6106D specific data */
 
@@ -1043,13 +1052,14 @@ static bool is_word_sized(struct nct6775_data *data, u16 reg)
                   reg == 0x73 || reg == 0x75 || reg == 0x77;
         case nct6779:
         case nct6791:
+        case nct6792:
                 return reg == 0x150 || reg == 0x153 || reg == 0x155 ||
                   ((reg & 0xfff0) == 0x4b0 && (reg & 0x000f) < 0x0b) ||
                   reg == 0x402 ||
                   reg == 0x63a || reg == 0x63c || reg == 0x63e ||
                   reg == 0x640 || reg == 0x642 ||
                   reg == 0x73 || reg == 0x75 || reg == 0x77 || reg == 0x79 ||
-                  reg == 0x7b;
+                  reg == 0x7b || reg == 0x7d;
         }
         return false;
 }
@@ -1063,6 +1073,7 @@ static bool is_word_sized(struct nct6775_data *data, u16 reg)
 static inline void nct6775_set_bank(struct nct6775_data *data, u16 reg)
 {
         u8 bank = reg >> 8;
+
         if (data->bank != bank) {
                 outb_p(NCT6775_REG_BANK, data->addr + ADDR_REG_OFFSET);
                 outb_p(bank, data->addr + DATA_REG_OFFSET);
@@ -1300,6 +1311,7 @@ static void nct6775_update_pwm(struct device *dev)
                 if (!data->target_speed_tolerance[i] ||
                     data->pwm_enable[i] == speed_cruise) {
                         u8 t = fanmodecfg & 0x0f;
+
                         if (data->REG_TOLERANCE_H) {
                                 t |= (nct6775_read_value(data,
                                       data->REG_TOLERANCE_H[i]) & 0x70) >> 1;
@@ -1391,6 +1403,7 @@ static void nct6775_update_pwm_limits(struct device *dev)
                 case nct6106:
                 case nct6779:
                 case nct6791:
+                case nct6792:
                         reg = nct6775_read_value(data,
                                         data->REG_CRITICAL_PWM_ENABLE[i]);
                         if (reg & data->CRITICAL_PWM_ENABLE_MASK)
@@ -1473,6 +1486,7 @@ static struct nct6775_data *nct6775_update_device(struct device *dev)
                 data->alarms = 0;
                 for (i = 0; i < NUM_REG_ALARM; i++) {
                         u8 alarm;
+
                         if (!data->REG_ALARM[i])
                                 continue;
                         alarm = nct6775_read_value(data, data->REG_ALARM[i]);
@@ -1482,6 +1496,7 @@ static struct nct6775_data *nct6775_update_device(struct device *dev)
                 data->beeps = 0;
                 for (i = 0; i < NUM_REG_BEEP; i++) {
                         u8 beep;
+
                         if (!data->REG_BEEP[i])
                                 continue;
                         beep = nct6775_read_value(data, data->REG_BEEP[i]);
@@ -1504,8 +1519,9 @@ show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct nct6775_data *data = nct6775_update_device(dev);
         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
-        int nr = sattr->nr;
         int index = sattr->index;
+        int nr = sattr->nr;
+
         return sprintf(buf, "%ld\n", in_from_reg(data->in[nr][index], nr));
 }
 
@@ -1515,10 +1531,12 @@ store_in_reg(struct device *dev, struct device_attribute *attr, const char *buf,
 {
         struct nct6775_data *data = dev_get_drvdata(dev);
         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
-        int nr = sattr->nr;
         int index = sattr->index;
+        int nr = sattr->nr;
         unsigned long val;
-        int err = kstrtoul(buf, 10, &val);
+        int err;
+
+        err = kstrtoul(buf, 10, &val);
         if (err < 0)
                 return err;
         mutex_lock(&data->update_lock);
@@ -1535,6 +1553,7 @@ show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
         struct nct6775_data *data = nct6775_update_device(dev);
         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
         int nr = data->ALARM_BITS[sattr->index];
+
         return sprintf(buf, "%u\n",
                        (unsigned int)((data->alarms >> nr) & 0x01));
 }
@@ -1570,6 +1589,7 @@ show_temp_alarm(struct device *dev, struct device_attribute *attr, char *buf)
         nr = find_temp_source(data, sattr->index, data->num_temp_alarms);
         if (nr >= 0) {
                 int bit = data->ALARM_BITS[nr + TEMP_ALARM_BASE];
+
                 alarm = (data->alarms >> bit) & 0x01;
         }
         return sprintf(buf, "%u\n", alarm);
@@ -1595,8 +1615,9 @@ store_beep(struct device *dev, struct device_attribute *attr, const char *buf,
         int nr = data->BEEP_BITS[sattr->index];
         int regindex = nr >> 3;
         unsigned long val;
+        int err;
 
-        int err = kstrtoul(buf, 10, &val);
+        err = kstrtoul(buf, 10, &val);
         if (err < 0)
                 return err;
         if (val > 1)
@@ -1629,6 +1650,7 @@ show_temp_beep(struct device *dev, struct device_attribute *attr, char *buf)
         nr = find_temp_source(data, sattr->index, data->num_temp_beeps);
         if (nr >= 0) {
                 int bit = data->BEEP_BITS[nr + TEMP_ALARM_BASE];
+
                 beep = (data->beeps >> bit) & 0x01;
         }
         return sprintf(buf, "%u\n", beep);
@@ -1642,8 +1664,9 @@ store_temp_beep(struct device *dev, struct device_attribute *attr,
         struct nct6775_data *data = dev_get_drvdata(dev);
         int nr, bit, regindex;
         unsigned long val;
+        int err;
 
-        int err = kstrtoul(buf, 10, &val);
+        err = kstrtoul(buf, 10, &val);
         if (err < 0)
                 return err;
         if (val > 1)
@@ -1715,6 +1738,7 @@ show_fan(struct device *dev, struct device_attribute *attr, char *buf)
         struct nct6775_data *data = nct6775_update_device(dev);
         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
         int nr = sattr->index;
+
         return sprintf(buf, "%d\n", data->rpm[nr]);
 }
 
@@ -1724,6 +1748,7 @@ show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
         struct nct6775_data *data = nct6775_update_device(dev);
         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
         int nr = sattr->index;
+
         return sprintf(buf, "%d\n",
                        data->fan_from_reg_min(data->fan_min[nr],
                                               data->fan_div[nr]));
@@ -1735,6 +1760,7 @@ show_fan_div(struct device *dev, struct device_attribute *attr, char *buf)
         struct nct6775_data *data = nct6775_update_device(dev);
         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
         int nr = sattr->index;
+
         return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
 }
 
@@ -1746,9 +1772,9 @@ store_fan_min(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
         int nr = sattr->index;
         unsigned long val;
-        int err;
         unsigned int reg;
         u8 new_div;
+        int err;
 
         err = kstrtoul(buf, 10, &val);
         if (err < 0)
@@ -1932,6 +1958,7 @@ show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
         struct nct6775_data *data = nct6775_update_device(dev);
         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
         int nr = sattr->index;
+
         return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
 }
 
@@ -2008,6 +2035,7 @@ show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
         struct nct6775_data *data = nct6775_update_device(dev);
         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
         int nr = sattr->index;
+
         return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
 }
 
@@ -2790,6 +2818,7 @@ store_auto_pwm(struct device *dev, struct device_attribute *attr,
                 case nct6106:
                 case nct6779:
                 case nct6791:
+                case nct6792:
                         nct6775_write_value(data, data->REG_CRITICAL_PWM[nr],
                                             val);
                         reg = nct6775_read_value(data,
@@ -2997,6 +3026,7 @@ static ssize_t
 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct nct6775_data *data = dev_get_drvdata(dev);
+
         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
 }
 
@@ -3202,7 +3232,7 @@ nct6775_check_fan_inputs(struct nct6775_data *data)
                 pwm4pin = false;
                 pwm5pin = false;
                 pwm6pin = false;
-        } else {        /* NCT6779D or NCT6791D */
+        } else {        /* NCT6779D, NCT6791D, or NCT6792D */
                 regval = superio_inb(sioreg, 0x1c);
 
                 fan3pin = !(regval & (1 << 5));
@@ -3215,7 +3245,7 @@ nct6775_check_fan_inputs(struct nct6775_data *data)
 
                 fan4min = fan4pin;
 
-                if (data->kind == nct6791) {
+                if (data->kind == nct6791 || data->kind == nct6792) {
                         regval = superio_inb(sioreg, 0x2d);
                         fan6pin = (regval & (1 << 1));
                         pwm6pin = (regval & (1 << 0));
@@ -3588,6 +3618,7 @@ static int nct6775_probe(struct platform_device *pdev)
 
                 break;
         case nct6791:
+        case nct6792:
                 data->in_num = 15;
                 data->pwm_num = 6;
                 data->auto_pwm_num = 4;
@@ -3650,12 +3681,20 @@ static int nct6775_probe(struct platform_device *pdev)
                 data->REG_WEIGHT_TEMP[1] = NCT6791_REG_WEIGHT_TEMP_STEP_TOL;
                 data->REG_WEIGHT_TEMP[2] = NCT6791_REG_WEIGHT_TEMP_BASE;
                 data->REG_ALARM = NCT6791_REG_ALARM;
-                data->REG_BEEP = NCT6776_REG_BEEP;
+                if (data->kind == nct6791)
+                        data->REG_BEEP = NCT6776_REG_BEEP;
+                else
+                        data->REG_BEEP = NCT6792_REG_BEEP;
 
                 reg_temp = NCT6779_REG_TEMP;
-                reg_temp_mon = NCT6779_REG_TEMP_MON;
                 num_reg_temp = ARRAY_SIZE(NCT6779_REG_TEMP);
-                num_reg_temp_mon = ARRAY_SIZE(NCT6779_REG_TEMP_MON);
+                if (data->kind == nct6791) {
+                        reg_temp_mon = NCT6779_REG_TEMP_MON;
+                        num_reg_temp_mon = ARRAY_SIZE(NCT6779_REG_TEMP_MON);
+                } else {
+                        reg_temp_mon = NCT6792_REG_TEMP_MON;
+                        num_reg_temp_mon = ARRAY_SIZE(NCT6792_REG_TEMP_MON);
+                }
                 reg_temp_over = NCT6779_REG_TEMP_OVER;
                 reg_temp_hyst = NCT6779_REG_TEMP_HYST;
                 reg_temp_config = NCT6779_REG_TEMP_CONFIG;
@@ -3854,6 +3893,7 @@ static int nct6775_probe(struct platform_device *pdev)
         case nct6106:
         case nct6779:
         case nct6791:
+        case nct6792:
                 break;
         }
 
@@ -3885,6 +3925,7 @@ static int nct6775_probe(struct platform_device *pdev)
                         tmp |= 0x3e;
                         break;
                 case nct6791:
+                case nct6792:
                         tmp |= 0x7e;
                         break;
                 }
@@ -3972,7 +4013,7 @@ static int nct6775_resume(struct device *dev)
         mutex_lock(&data->update_lock);
         data->bank = 0xff;              /* Force initial bank selection */
 
-        if (data->kind == nct6791) {
+        if (data->kind == nct6791 || data->kind == nct6792) {
                 err = superio_enter(data->sioreg);
                 if (err)
                         goto abort;
@@ -4052,6 +4093,7 @@ static const char * const nct6775_sio_names[] __initconst = {
         "NCT6776D/F",
         "NCT6779D",
         "NCT6791D",
+        "NCT6792D",
 };
 
 /* nct6775_find() looks for a '627 in the Super-I/O config space */
@@ -4086,6 +4128,9 @@ static int __init nct6775_find(int sioaddr, struct nct6775_sio_data *sio_data)
         case SIO_NCT6791_ID:
                 sio_data->kind = nct6791;
                 break;
+        case SIO_NCT6792_ID:
+                sio_data->kind = nct6792;
+                break;
         default:
                 if (val != 0xffff)
                         pr_debug("unsupported chip ID: 0x%04x\n", val);
@@ -4111,7 +4156,7 @@ static int __init nct6775_find(int sioaddr, struct nct6775_sio_data *sio_data)
                 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
         }
 
-        if (sio_data->kind == nct6791)
+        if (sio_data->kind == nct6791 || sio_data->kind == nct6792)
                 nct6791_enable_io_mapping(sioaddr);
 
         superio_exit(sioaddr);
@@ -4221,7 +4266,7 @@ static void __exit sensors_nct6775_exit(void)
 }
 
 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
-MODULE_DESCRIPTION("NCT6106D/NCT6775F/NCT6776F/NCT6779D/NCT6791D driver");
+MODULE_DESCRIPTION("NCT6106D/NCT6775F/NCT6776F/NCT6779D/NCT6791D/NCT6792D driver");
 MODULE_LICENSE("GPL");
 
 module_init(sensors_nct6775_init);
diff --git a/drivers/hwmon/nct7802.c b/drivers/hwmon/nct7802.c
new file mode 100644
index 000000000000..ec5678289e4a
--- /dev/null
+++ b/drivers/hwmon/nct7802.c
@@ -0,0 +1,860 @@
+/*
+ * nct7802 - Driver for Nuvoton NCT7802Y
+ *
+ * Copyright (C) 2014  Guenter Roeck <linux@roeck-us.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+
+#define DRVNAME "nct7802"
+
+static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e };
+
+static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = {
+        { 0x40, 0x00, 0x42, 0x44, 0x46 },
+        { 0x3f, 0x00, 0x41, 0x43, 0x45 },
+};
+
+static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };
+
+static const u8 REG_VOLTAGE_LIMIT_MSB_SHIFT[2][5] = {
+        { 0, 0, 4, 0, 4 },
+        { 2, 0, 6, 2, 6 },
+};
+
+#define REG_BANK                0x00
+#define REG_TEMP_LSB            0x05
+#define REG_TEMP_PECI_LSB       0x08
+#define REG_VOLTAGE_LOW         0x0f
+#define REG_FANCOUNT_LOW        0x13
+#define REG_START               0x21
+#define REG_MODE                0x22
+#define REG_PECI_ENABLE         0x23
+#define REG_FAN_ENABLE          0x24
+#define REG_VMON_ENABLE         0x25
+#define REG_VENDOR_ID           0xfd
+#define REG_CHIP_ID             0xfe
+#define REG_VERSION_ID          0xff
+
+/*
+ * Data structures and manipulation thereof
+ */
+
+struct nct7802_data {
+        struct regmap *regmap;
+        struct mutex access_lock; /* for multi-byte read and write operations */
+};
+
+static int nct7802_read_temp(struct nct7802_data *data,
+                             u8 reg_temp, u8 reg_temp_low, int *temp)
+{
+        unsigned int t1, t2 = 0;
+        int err;
+
+        *temp = 0;
+
+        mutex_lock(&data->access_lock);
+        err = regmap_read(data->regmap, reg_temp, &t1);
+        if (err < 0)
+                goto abort;
+        t1 <<= 8;
+        if (reg_temp_low) {     /* 11 bit data */
+                err = regmap_read(data->regmap, reg_temp_low, &t2);
+                if (err < 0)
+                        goto abort;
+        }
+        t1 |= t2 & 0xe0;
+        *temp = (s16)t1 / 32 * 125;
+abort:
+        mutex_unlock(&data->access_lock);
+        return err;
+}
+
+static int nct7802_read_fan(struct nct7802_data *data, u8 reg_fan)
+{
+        unsigned int f1, f2;
+        int ret;
+
+        mutex_lock(&data->access_lock);
+        ret = regmap_read(data->regmap, reg_fan, &f1);
+        if (ret < 0)
+                goto abort;
+        ret = regmap_read(data->regmap, REG_FANCOUNT_LOW, &f2);
+        if (ret < 0)
+                goto abort;
+        ret = (f1 << 5) | (f2 >> 3);
+        /* convert fan count to rpm */
+        if (ret == 0x1fff)      /* maximum value, assume fan is stopped */
+                ret = 0;
+        else if (ret)
+                ret = DIV_ROUND_CLOSEST(1350000U, ret);
+abort:
+        mutex_unlock(&data->access_lock);
+        return ret;
+}
+
+static int nct7802_read_fan_min(struct nct7802_data *data, u8 reg_fan_low,
+                                u8 reg_fan_high)
+{
+        unsigned int f1, f2;
+        int ret;
+
+        mutex_lock(&data->access_lock);
+        ret = regmap_read(data->regmap, reg_fan_low, &f1);
+        if (ret < 0)
+                goto abort;
+        ret = regmap_read(data->regmap, reg_fan_high, &f2);
+        if (ret < 0)
+                goto abort;
+        ret = f1 | ((f2 & 0xf8) << 5);
+        /* convert fan count to rpm */
+        if (ret == 0x1fff)      /* maximum value, assume no limit */
+                ret = 0;
+        else if (ret)
+                ret = DIV_ROUND_CLOSEST(1350000U, ret);
+abort:
+        mutex_unlock(&data->access_lock);
+        return ret;
+}
+
+static int nct7802_write_fan_min(struct nct7802_data *data, u8 reg_fan_low,
+                                 u8 reg_fan_high, unsigned int limit)
+{
+        int err;
+
+        if (limit)
+                limit = DIV_ROUND_CLOSEST(1350000U, limit);
+        else
+                limit = 0x1fff;
+        limit = clamp_val(limit, 0, 0x1fff);
+
+        mutex_lock(&data->access_lock);
+        err = regmap_write(data->regmap, reg_fan_low, limit & 0xff);
+        if (err < 0)
+                goto abort;
+
+        err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5);
+abort:
+        mutex_unlock(&data->access_lock);
+        return err;
+}
+
+static u8 nct7802_vmul[] = { 4, 2, 2, 2, 2 };
+
+static int nct7802_read_voltage(struct nct7802_data *data, int nr, int index)
+{
+        unsigned int v1, v2;
+        int ret;
+
+        mutex_lock(&data->access_lock);
+        if (index == 0) {       /* voltage */
+                ret = regmap_read(data->regmap, REG_VOLTAGE[nr], &v1);
+                if (ret < 0)
+                        goto abort;
+                ret = regmap_read(data->regmap, REG_VOLTAGE_LOW, &v2);
+                if (ret < 0)
+                        goto abort;
+                ret = ((v1 << 2) | (v2 >> 6)) * nct7802_vmul[nr];
+        }  else {       /* limit */
+                int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr];
+
+                ret = regmap_read(data->regmap,
+                                  REG_VOLTAGE_LIMIT_LSB[index - 1][nr], &v1);
+                if (ret < 0)
+                        goto abort;
+                ret = regmap_read(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr],
+                                  &v2);
+                if (ret < 0)
+                        goto abort;
+                ret = (v1 | ((v2 << shift) & 0x300)) * nct7802_vmul[nr];
+        }
+abort:
+        mutex_unlock(&data->access_lock);
+        return ret;
+}
+
+static int nct7802_write_voltage(struct nct7802_data *data, int nr, int index,
+                                 unsigned int voltage)
+{
+        int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr];
+        int err;
+
+        voltage = DIV_ROUND_CLOSEST(voltage, nct7802_vmul[nr]);
+        voltage = clamp_val(voltage, 0, 0x3ff);
+
+        mutex_lock(&data->access_lock);
+        err = regmap_write(data->regmap,
+                           REG_VOLTAGE_LIMIT_LSB[index - 1][nr],
+                           voltage & 0xff);
+        if (err < 0)
+                goto abort;
+
+        err = regmap_update_bits(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr],
+                                 0x0300 >> shift, (voltage & 0x0300) >> shift);
+abort:
+        mutex_unlock(&data->access_lock);
+        return err;
+}
+
+static ssize_t show_in(struct device *dev, struct device_attribute *attr,
+                       char *buf)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        int voltage;
+
+        voltage = nct7802_read_voltage(data, sattr->nr, sattr->index);
+        if (voltage < 0)
+                return voltage;
+
+        return sprintf(buf, "%d\n", voltage);
+}
+
+static ssize_t store_in(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        int index = sattr->index;
+        int nr = sattr->nr;
+        unsigned long val;
+        int err;
+
+        err = kstrtoul(buf, 10, &val);
+        if (err < 0)
+                return err;
+
+        err = nct7802_write_voltage(data, nr, index, val);
+        return err ? : count;
+}
+
+static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        int err, temp;
+
+        err = nct7802_read_temp(data, sattr->nr, sattr->index, &temp);
+        if (err < 0)
+                return err;
+
+        return sprintf(buf, "%d\n", temp);
+}
+
+static ssize_t store_temp(struct device *dev, struct device_attribute *attr,
+                          const char *buf, size_t count)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        int nr = sattr->nr;
+        long val;
+        int err;
+
+        err = kstrtol(buf, 10, &val);
+        if (err < 0)
+                return err;
+
+        val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
+
+        err = regmap_write(data->regmap, nr, val & 0xff);
+        return err ? : count;
+}
+
+static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        int speed;
+
+        speed = nct7802_read_fan(data, sattr->index);
+        if (speed < 0)
+                return speed;
+
+        return sprintf(buf, "%d\n", speed);
+}
+
+static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        int speed;
+
+        speed = nct7802_read_fan_min(data, sattr->nr, sattr->index);
+        if (speed < 0)
+                return speed;
+
+        return sprintf(buf, "%d\n", speed);
+}
+
+static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
+                             const char *buf, size_t count)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        unsigned long val;
+        int err;
+
+        err = kstrtoul(buf, 10, &val);
+        if (err < 0)
+                return err;
+
+        err = nct7802_write_fan_min(data, sattr->nr, sattr->index, val);
+        return err ? : count;
+}
+
+static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        int bit = sattr->index;
+        unsigned int val;
+        int ret;
+
+        ret = regmap_read(data->regmap, sattr->nr, &val);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%u\n", !!(val & (1 << bit)));
+}
+
+static ssize_t
+show_beep(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        unsigned int regval;
+        int err;
+
+        err = regmap_read(data->regmap, sattr->nr, &regval);
+        if (err)
+                return err;
+
+        return sprintf(buf, "%u\n", !!(regval & (1 << sattr->index)));
+}
+
+static ssize_t
+store_beep(struct device *dev, struct device_attribute *attr, const char *buf,
+           size_t count)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        unsigned long val;
+        int err;
+
+        err = kstrtoul(buf, 10, &val);
+        if (err < 0)
+                return err;
+        if (val > 1)
+                return -EINVAL;
+
+        err = regmap_update_bits(data->regmap, sattr->nr, 1 << sattr->index,
+                                 val ? 1 << sattr->index : 0);
+        return err ? : count;
+}
+
+static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0x01,
+                            REG_TEMP_LSB);
+static SENSOR_DEVICE_ATTR_2(temp1_min, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x31, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x30, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x3a, 0);
+
+static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 0x02,
+                            REG_TEMP_LSB);
+static SENSOR_DEVICE_ATTR_2(temp2_min, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x33, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x32, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x3b, 0);
+
+static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 0x03,
+                            REG_TEMP_LSB);
+static SENSOR_DEVICE_ATTR_2(temp3_min, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x35, 0);
+static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x34, 0);
+static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x3c, 0);
+
+static SENSOR_DEVICE_ATTR_2(temp4_input, S_IRUGO, show_temp, NULL, 0x04, 0);
+static SENSOR_DEVICE_ATTR_2(temp4_min, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x37, 0);
+static SENSOR_DEVICE_ATTR_2(temp4_max, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x36, 0);
+static SENSOR_DEVICE_ATTR_2(temp4_crit, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x3d, 0);
+
+static SENSOR_DEVICE_ATTR_2(temp5_input, S_IRUGO, show_temp, NULL, 0x06,
+                            REG_TEMP_PECI_LSB);
+static SENSOR_DEVICE_ATTR_2(temp5_min, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x39, 0);
+static SENSOR_DEVICE_ATTR_2(temp5_max, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x38, 0);
+static SENSOR_DEVICE_ATTR_2(temp5_crit, S_IRUGO | S_IWUSR, show_temp,
+                            store_temp, 0x3e, 0);
+
+static SENSOR_DEVICE_ATTR_2(temp6_input, S_IRUGO, show_temp, NULL, 0x07,
+                            REG_TEMP_PECI_LSB);
+
+static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO, show_alarm, NULL,
+                            0x18, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO, show_alarm, NULL,
+                            0x18, 1);
+static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO, show_alarm, NULL,
+                            0x18, 2);
+static SENSOR_DEVICE_ATTR_2(temp4_min_alarm, S_IRUGO, show_alarm, NULL,
+                            0x18, 3);
+static SENSOR_DEVICE_ATTR_2(temp5_min_alarm, S_IRUGO, show_alarm, NULL,
+                            0x18, 4);
+
+static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO, show_alarm, NULL,
+                            0x19, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO, show_alarm, NULL,
+                            0x19, 1);
+static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO, show_alarm, NULL,
+                            0x19, 2);
+static SENSOR_DEVICE_ATTR_2(temp4_max_alarm, S_IRUGO, show_alarm, NULL,
+                            0x19, 3);
+static SENSOR_DEVICE_ATTR_2(temp5_max_alarm, S_IRUGO, show_alarm, NULL,
+                            0x19, 4);
+
+static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, show_alarm, NULL,
+                            0x1b, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, show_alarm, NULL,
+                            0x1b, 1);
+static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, show_alarm, NULL,
+                            0x1b, 2);
+static SENSOR_DEVICE_ATTR_2(temp4_crit_alarm, S_IRUGO, show_alarm, NULL,
+                            0x1b, 3);
+static SENSOR_DEVICE_ATTR_2(temp5_crit_alarm, S_IRUGO, show_alarm, NULL,
+                            0x1b, 4);
+
+static SENSOR_DEVICE_ATTR_2(temp1_fault, S_IRUGO, show_alarm, NULL, 0x17, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_fault, S_IRUGO, show_alarm, NULL, 0x17, 1);
+static SENSOR_DEVICE_ATTR_2(temp3_fault, S_IRUGO, show_alarm, NULL, 0x17, 2);
+
+static SENSOR_DEVICE_ATTR_2(temp1_beep, S_IRUGO | S_IWUSR, show_beep,
+                            store_beep, 0x5c, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_beep, S_IRUGO | S_IWUSR, show_beep,
+                            store_beep, 0x5c, 1);
+static SENSOR_DEVICE_ATTR_2(temp3_beep, S_IRUGO | S_IWUSR, show_beep,
+                            store_beep, 0x5c, 2);
+static SENSOR_DEVICE_ATTR_2(temp4_beep, S_IRUGO | S_IWUSR, show_beep,
+                            store_beep, 0x5c, 3);
+static SENSOR_DEVICE_ATTR_2(temp5_beep, S_IRUGO | S_IWUSR, show_beep,
+                            store_beep, 0x5c, 4);
+static SENSOR_DEVICE_ATTR_2(temp6_beep, S_IRUGO | S_IWUSR, show_beep,
+                            store_beep, 0x5c, 5);
+
+static struct attribute *nct7802_temp_attrs[] = {
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit.dev_attr.attr,
+        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_fault.dev_attr.attr,
+        &sensor_dev_attr_temp1_beep.dev_attr.attr,
+
+        &sensor_dev_attr_temp2_input.dev_attr.attr,             /* 9 */
+        &sensor_dev_attr_temp2_min.dev_attr.attr,
+        &sensor_dev_attr_temp2_max.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit.dev_attr.attr,
+        &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
+        &sensor_dev_attr_temp2_beep.dev_attr.attr,
+
+        &sensor_dev_attr_temp3_input.dev_attr.attr,             /* 18 */
+        &sensor_dev_attr_temp3_min.dev_attr.attr,
+        &sensor_dev_attr_temp3_max.dev_attr.attr,
+        &sensor_dev_attr_temp3_crit.dev_attr.attr,
+        &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp3_fault.dev_attr.attr,
+        &sensor_dev_attr_temp3_beep.dev_attr.attr,
+
+        &sensor_dev_attr_temp4_input.dev_attr.attr,             /* 27 */
+        &sensor_dev_attr_temp4_min.dev_attr.attr,
+        &sensor_dev_attr_temp4_max.dev_attr.attr,
+        &sensor_dev_attr_temp4_crit.dev_attr.attr,
+        &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp4_beep.dev_attr.attr,
+
+        &sensor_dev_attr_temp5_input.dev_attr.attr,             /* 35 */
+        &sensor_dev_attr_temp5_min.dev_attr.attr,
+        &sensor_dev_attr_temp5_max.dev_attr.attr,
+        &sensor_dev_attr_temp5_crit.dev_attr.attr,
+        &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp5_beep.dev_attr.attr,
+
+        &sensor_dev_attr_temp6_input.dev_attr.attr,             /* 43 */
+        &sensor_dev_attr_temp6_beep.dev_attr.attr,
+
+        NULL
+};
+
+static umode_t nct7802_temp_is_visible(struct kobject *kobj,
+                                       struct attribute *attr, int index)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        unsigned int reg;
+        int err;
+
+        err = regmap_read(data->regmap, REG_MODE, &reg);
+        if (err < 0)
+                return 0;
+
+        if (index < 9 &&
+            (reg & 03) != 0x01 && (reg & 0x03) != 0x02)         /* RD1 */
+                return 0;
+        if (index >= 9 && index < 18 &&
+            (reg & 0x0c) != 0x04 && (reg & 0x0c) != 0x08)       /* RD2 */
+                return 0;
+        if (index >= 18 && index < 27 && (reg & 0x30) != 0x10)  /* RD3 */
+                return 0;
+        if (index >= 27 && index < 35)                          /* local */
+                return attr->mode;
+
+        err = regmap_read(data->regmap, REG_PECI_ENABLE, &reg);
+        if (err < 0)
+                return 0;
+
+        if (index >= 35 && index < 43 && !(reg & 0x01))         /* PECI 0 */
+                return 0;
+
+        if (index >= 0x43 && (!(reg & 0x02)))                   /* PECI 1 */
+                return 0;
+
+        return attr->mode;
+}
+
+static struct attribute_group nct7802_temp_group = {
+        .attrs = nct7802_temp_attrs,
+        .is_visible = nct7802_temp_is_visible,
+};
+
+static SENSOR_DEVICE_ATTR_2(in0_input, S_IRUGO, show_in, NULL, 0, 0);
+static SENSOR_DEVICE_ATTR_2(in0_min, S_IRUGO | S_IWUSR, show_in, store_in,
+                            0, 1);
+static SENSOR_DEVICE_ATTR_2(in0_max, S_IRUGO | S_IWUSR, show_in, store_in,
+                            0, 2);
+static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 3);
+static SENSOR_DEVICE_ATTR_2(in0_beep, S_IRUGO | S_IWUSR, show_beep, store_beep,
+                            0x5a, 3);
+
+static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_in, NULL, 1, 0);
+
+static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_in, NULL, 2, 0);
+static SENSOR_DEVICE_ATTR_2(in2_min, S_IRUGO | S_IWUSR, show_in, store_in,
+                            2, 1);
+static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_in, store_in,
+                            2, 2);
+static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 0);
+static SENSOR_DEVICE_ATTR_2(in2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep,
+                            0x5a, 0);
+
+static SENSOR_DEVICE_ATTR_2(in3_input, S_IRUGO, show_in, NULL, 3, 0);
+static SENSOR_DEVICE_ATTR_2(in3_min, S_IRUGO | S_IWUSR, show_in, store_in,
+                            3, 1);
+static SENSOR_DEVICE_ATTR_2(in3_max, S_IRUGO | S_IWUSR, show_in, store_in,
+                            3, 2);
+static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 1);
+static SENSOR_DEVICE_ATTR_2(in3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep,
+                            0x5a, 1);
+
+static SENSOR_DEVICE_ATTR_2(in4_input, S_IRUGO, show_in, NULL, 4, 0);
+static SENSOR_DEVICE_ATTR_2(in4_min, S_IRUGO | S_IWUSR, show_in, store_in,
+                            4, 1);
+static SENSOR_DEVICE_ATTR_2(in4_max, S_IRUGO | S_IWUSR, show_in, store_in,
+                            4, 2);
+static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 2);
+static SENSOR_DEVICE_ATTR_2(in4_beep, S_IRUGO | S_IWUSR, show_beep, store_beep,
+                            0x5a, 2);
+
+static struct attribute *nct7802_in_attrs[] = {
+        &sensor_dev_attr_in0_input.dev_attr.attr,
+        &sensor_dev_attr_in0_min.dev_attr.attr,
+        &sensor_dev_attr_in0_max.dev_attr.attr,
+        &sensor_dev_attr_in0_alarm.dev_attr.attr,
+        &sensor_dev_attr_in0_beep.dev_attr.attr,
+
+        &sensor_dev_attr_in1_input.dev_attr.attr,       /* 5 */
+
+        &sensor_dev_attr_in2_input.dev_attr.attr,       /* 6 */
+        &sensor_dev_attr_in2_min.dev_attr.attr,
+        &sensor_dev_attr_in2_max.dev_attr.attr,
+        &sensor_dev_attr_in2_alarm.dev_attr.attr,
+        &sensor_dev_attr_in2_beep.dev_attr.attr,
+
+        &sensor_dev_attr_in3_input.dev_attr.attr,       /* 11 */
+        &sensor_dev_attr_in3_min.dev_attr.attr,
+        &sensor_dev_attr_in3_max.dev_attr.attr,
+        &sensor_dev_attr_in3_alarm.dev_attr.attr,
+        &sensor_dev_attr_in3_beep.dev_attr.attr,
+
+        &sensor_dev_attr_in4_input.dev_attr.attr,       /* 17 */
+        &sensor_dev_attr_in4_min.dev_attr.attr,
+        &sensor_dev_attr_in4_max.dev_attr.attr,
+        &sensor_dev_attr_in4_alarm.dev_attr.attr,
+        &sensor_dev_attr_in4_beep.dev_attr.attr,
+
+        NULL,
+};
+
+static umode_t nct7802_in_is_visible(struct kobject *kobj,
+                                     struct attribute *attr, int index)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        unsigned int reg;
+        int err;
+
+        if (index < 6)                                          /* VCC, VCORE */
+                return attr->mode;
+
+        err = regmap_read(data->regmap, REG_MODE, &reg);
+        if (err < 0)
+                return 0;
+
+        if (index >= 6 && index < 11 && (reg & 0x03) != 0x03)   /* VSEN1 */
+                return 0;
+        if (index >= 11 && index < 17 && (reg & 0x0c) != 0x0c)  /* VSEN2 */
+                return 0;
+        if (index >= 17 && (reg & 0x30) != 0x30)                /* VSEN3 */
+                return 0;
+
+        return attr->mode;
+}
+
+static struct attribute_group nct7802_in_group = {
+        .attrs = nct7802_in_attrs,
+        .is_visible = nct7802_in_is_visible,
+};
+
+static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0x10);
+static SENSOR_DEVICE_ATTR_2(fan1_min, S_IRUGO | S_IWUSR, show_fan_min,
+                            store_fan_min, 0x49, 0x4c);
+static SENSOR_DEVICE_ATTR_2(fan1_alarm, S_IRUGO, show_alarm, NULL, 0x1a, 0);
+static SENSOR_DEVICE_ATTR_2(fan1_beep, S_IRUGO | S_IWUSR, show_beep, store_beep,
+                            0x5b, 0);
+static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 0x11);
+static SENSOR_DEVICE_ATTR_2(fan2_min, S_IRUGO | S_IWUSR, show_fan_min,
+                            store_fan_min, 0x4a, 0x4d);
+static SENSOR_DEVICE_ATTR_2(fan2_alarm, S_IRUGO, show_alarm, NULL, 0x1a, 1);
+static SENSOR_DEVICE_ATTR_2(fan2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep,
+                            0x5b, 1);
+static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 0x12);
+static SENSOR_DEVICE_ATTR_2(fan3_min, S_IRUGO | S_IWUSR, show_fan_min,
+                            store_fan_min, 0x4b, 0x4e);
+static SENSOR_DEVICE_ATTR_2(fan3_alarm, S_IRUGO, show_alarm, NULL, 0x1a, 2);
+static SENSOR_DEVICE_ATTR_2(fan3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep,
+                            0x5b, 2);
+
+static struct attribute *nct7802_fan_attrs[] = {
+        &sensor_dev_attr_fan1_input.dev_attr.attr,
+        &sensor_dev_attr_fan1_min.dev_attr.attr,
+        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan1_beep.dev_attr.attr,
+        &sensor_dev_attr_fan2_input.dev_attr.attr,
+        &sensor_dev_attr_fan2_min.dev_attr.attr,
+        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan2_beep.dev_attr.attr,
+        &sensor_dev_attr_fan3_input.dev_attr.attr,
+        &sensor_dev_attr_fan3_min.dev_attr.attr,
+        &sensor_dev_attr_fan3_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan3_beep.dev_attr.attr,
+
+        NULL
+};
+
+static umode_t nct7802_fan_is_visible(struct kobject *kobj,
+                                      struct attribute *attr, int index)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct nct7802_data *data = dev_get_drvdata(dev);
+        int fan = index / 4;    /* 4 attributes per fan */
+        unsigned int reg;
+        int err;
+
+        err = regmap_read(data->regmap, REG_FAN_ENABLE, &reg);
+        if (err < 0 || !(reg & (1 << fan)))
+                return 0;
+
+        return attr->mode;
+}
+
+static struct attribute_group nct7802_fan_group = {
+        .attrs = nct7802_fan_attrs,
+        .is_visible = nct7802_fan_is_visible,
+};
+
+static const struct attribute_group *nct7802_groups[] = {
+        &nct7802_temp_group,
+        &nct7802_in_group,
+        &nct7802_fan_group,
+        NULL
+};
+
+static int nct7802_detect(struct i2c_client *client,
+                          struct i2c_board_info *info)
+{
+        int reg;
+
+        /*
+         * Chip identification registers are only available in bank 0,
+         * so only attempt chip detection if bank 0 is selected
+         */
+        reg = i2c_smbus_read_byte_data(client, REG_BANK);
+        if (reg != 0x00)
+                return -ENODEV;
+
+        reg = i2c_smbus_read_byte_data(client, REG_VENDOR_ID);
+        if (reg != 0x50)
+                return -ENODEV;
+
+        reg = i2c_smbus_read_byte_data(client, REG_CHIP_ID);
+        if (reg != 0xc3)
+                return -ENODEV;
+
+        reg = i2c_smbus_read_byte_data(client, REG_VERSION_ID);
+        if (reg < 0 || (reg & 0xf0) != 0x20)
+                return -ENODEV;
+
+        /* Also validate lower bits of voltage and temperature registers */
+        reg = i2c_smbus_read_byte_data(client, REG_TEMP_LSB);
+        if (reg < 0 || (reg & 0x1f))
+                return -ENODEV;
+
+        reg = i2c_smbus_read_byte_data(client, REG_TEMP_PECI_LSB);
+        if (reg < 0 || (reg & 0x3f))
+                return -ENODEV;
+
+        reg = i2c_smbus_read_byte_data(client, REG_VOLTAGE_LOW);
+        if (reg < 0 || (reg & 0x3f))
+                return -ENODEV;
+
+        strlcpy(info->type, "nct7802", I2C_NAME_SIZE);
+        return 0;
+}
+
+static bool nct7802_regmap_is_volatile(struct device *dev, unsigned int reg)
+{
+        return reg != REG_BANK && reg <= 0x20;
+}
+
+static struct regmap_config nct7802_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .cache_type = REGCACHE_RBTREE,
+        .volatile_reg = nct7802_regmap_is_volatile,
+};
+
+static int nct7802_init_chip(struct nct7802_data *data)
+{
+        int err;
+
+        /* Enable ADC */
+        err = regmap_update_bits(data->regmap, REG_START, 0x01, 0x01);
+        if (err)
+                return err;
+
+        /* Enable local temperature sensor */
+        err = regmap_update_bits(data->regmap, REG_MODE, 0x40, 0x40);
+        if (err)
+                return err;
+
+        /* Enable Vcore and VCC voltage monitoring */
+        return regmap_update_bits(data->regmap, REG_VMON_ENABLE, 0x03, 0x03);
+}
+
+static int nct7802_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct nct7802_data *data;
+        struct device *hwmon_dev;
+        int ret;
+
+        data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
+
+        data->regmap = devm_regmap_init_i2c(client, &nct7802_regmap_config);
+        if (IS_ERR(data->regmap))
+                return PTR_ERR(data->regmap);
+
+        mutex_init(&data->access_lock);
+
+        ret = nct7802_init_chip(data);
+        if (ret < 0)
+                return ret;
+
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
+                                                           data,
+                                                           nct7802_groups);
+        return PTR_ERR_OR_ZERO(hwmon_dev);
+}
+
+static const unsigned short nct7802_address_list[] = {
+        0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END
+};
+
+static const struct i2c_device_id nct7802_idtable[] = {
+        { "nct7802", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, nct7802_idtable);
+
+static struct i2c_driver nct7802_driver = {
+        .class = I2C_CLASS_HWMON,
+        .driver = {
+                .name = DRVNAME,
+        },
+        .detect = nct7802_detect,
+        .probe = nct7802_probe,
+        .id_table = nct7802_idtable,
+        .address_list = nct7802_address_list,
+};
+
+module_i2c_driver(nct7802_driver);
+
+MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
+MODULE_DESCRIPTION("NCT7802Y Hardware Monitoring Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/hwmon/pmbus/Kconfig b/drivers/hwmon/pmbus/Kconfig
index 6e1e4935fc62..a674cd83a4e2 100644
--- a/drivers/hwmon/pmbus/Kconfig
+++ b/drivers/hwmon/pmbus/Kconfig
@@ -47,15 +47,22 @@ config SENSORS_LM25066
           be called lm25066.
 
 config SENSORS_LTC2978
-        tristate "Linear Technologies LTC2974, LTC2978, LTC3880, and LTC3883"
+        tristate "Linear Technologies LTC2978 and compatibles"
         default n
         help
           If you say yes here you get hardware monitoring support for Linear
-          Technology LTC2974, LTC2978, LTC3880, and LTC3883.
+          Technology LTC2974, LTC2977, LTC2978, LTC3880, LTC3883, and LTM4676.
 
           This driver can also be built as a module. If so, the module will
           be called ltc2978.
 
+config SENSORS_LTC2978_REGULATOR
+        boolean "Regulator support for LTC2978 and compatibles"
+        depends on SENSORS_LTC2978 && REGULATOR
+        help
+          If you say yes here you get regulator support for Linear
+          Technology LTC2974, LTC2977, LTC2978, LTC3880, LTC3883, and LTM4676.
+
 config SENSORS_MAX16064
         tristate "Maxim MAX16064"
         default n
diff --git a/drivers/hwmon/pmbus/ltc2978.c b/drivers/hwmon/pmbus/ltc2978.c
index e24ed521051a..0835050ec245 100644
--- a/drivers/hwmon/pmbus/ltc2978.c
+++ b/drivers/hwmon/pmbus/ltc2978.c
@@ -22,6 +22,7 @@
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/i2c.h>
+#include <linux/regulator/driver.h>
 #include "pmbus.h"
 
 enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883, ltm4676 };
@@ -374,6 +375,19 @@ static const struct i2c_device_id ltc2978_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
 
+#if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
+static const struct regulator_desc ltc2978_reg_desc[] = {
+        PMBUS_REGULATOR("vout", 0),
+        PMBUS_REGULATOR("vout", 1),
+        PMBUS_REGULATOR("vout", 2),
+        PMBUS_REGULATOR("vout", 3),
+        PMBUS_REGULATOR("vout", 4),
+        PMBUS_REGULATOR("vout", 5),
+        PMBUS_REGULATOR("vout", 6),
+        PMBUS_REGULATOR("vout", 7),
+};
+#endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
+
 static int ltc2978_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
@@ -487,13 +501,36 @@ static int ltc2978_probe(struct i2c_client *client,
         default:
                 return -ENODEV;
         }
+
+#if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
+        info->num_regulators = info->pages;
+        info->reg_desc = ltc2978_reg_desc;
+        if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
+                dev_err(&client->dev, "num_regulators too large!");
+                info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
+        }
+#endif
+
         return pmbus_do_probe(client, id, info);
 }
 
-/* This is the driver that will be inserted */
+#ifdef CONFIG_OF
+static const struct of_device_id ltc2978_of_match[] = {
+        { .compatible = "lltc,ltc2974" },
+        { .compatible = "lltc,ltc2977" },
+        { .compatible = "lltc,ltc2978" },
+        { .compatible = "lltc,ltc3880" },
+        { .compatible = "lltc,ltc3883" },
+        { .compatible = "lltc,ltm4676" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, ltc2978_of_match);
+#endif
+
 static struct i2c_driver ltc2978_driver = {
         .driver = {
                    .name = "ltc2978",
+                   .of_match_table = of_match_ptr(ltc2978_of_match),
                    },
         .probe = ltc2978_probe,
         .remove = pmbus_do_remove,
diff --git a/drivers/hwmon/pmbus/pmbus.h b/drivers/hwmon/pmbus/pmbus.h
index fa9beb3eb60c..89a23ff836e7 100644
--- a/drivers/hwmon/pmbus/pmbus.h
+++ b/drivers/hwmon/pmbus/pmbus.h
@@ -19,6 +19,8 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/regulator/driver.h>
+
 #ifndef PMBUS_H
 #define PMBUS_H
 
@@ -186,6 +188,11 @@
 #define PMBUS_VIRT_STATUS_VMON          (PMBUS_VIRT_BASE + 35)
 
 /*
+ * OPERATION
+ */
+#define PB_OPERATION_CONTROL_ON         (1<<7)
+
+/*
  * CAPABILITY
  */
 #define PB_CAPABILITY_SMBALERT          (1<<4)
@@ -365,8 +372,27 @@ struct pmbus_driver_info {
          */
         int (*identify)(struct i2c_client *client,
                         struct pmbus_driver_info *info);
+
+        /* Regulator functionality, if supported by this chip driver. */
+        int num_regulators;
+        const struct regulator_desc *reg_desc;
 };
 
+/* Regulator ops */
+
+extern struct regulator_ops pmbus_regulator_ops;
+
+/* Macro for filling in array of struct regulator_desc */
+#define PMBUS_REGULATOR(_name, _id)                             \
+        [_id] = {                                               \
+                .name = (_name # _id),                          \
+                .id = (_id),                                    \
+                .of_match = of_match_ptr(_name # _id),          \
+                .regulators_node = of_match_ptr("regulators"),  \
+                .ops = &pmbus_regulator_ops,                    \
+                .owner = THIS_MODULE,                           \
+        }
+
 /* Function declarations */
 
 void pmbus_clear_cache(struct i2c_client *client);
@@ -375,6 +401,10 @@ int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg);
 int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg, u16 word);
 int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg);
 int pmbus_write_byte(struct i2c_client *client, int page, u8 value);
+int pmbus_write_byte_data(struct i2c_client *client, int page, u8 reg,
+                          u8 value);
+int pmbus_update_byte_data(struct i2c_client *client, int page, u8 reg,
+                           u8 mask, u8 value);
 void pmbus_clear_faults(struct i2c_client *client);
 bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg);
 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg);
diff --git a/drivers/hwmon/pmbus/pmbus_core.c b/drivers/hwmon/pmbus/pmbus_core.c
index 291d11fe93e7..f2e47c7dd808 100644
--- a/drivers/hwmon/pmbus/pmbus_core.c
+++ b/drivers/hwmon/pmbus/pmbus_core.c
@@ -29,6 +29,8 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/jiffies.h>
 #include <linux/i2c/pmbus.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
 #include "pmbus.h"
 
 /*
@@ -253,6 +255,37 @@ int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg)
 }
 EXPORT_SYMBOL_GPL(pmbus_read_byte_data);
 
+int pmbus_write_byte_data(struct i2c_client *client, int page, u8 reg, u8 value)
+{
+        int rv;
+
+        rv = pmbus_set_page(client, page);
+        if (rv < 0)
+                return rv;
+
+        return i2c_smbus_write_byte_data(client, reg, value);
+}
+EXPORT_SYMBOL_GPL(pmbus_write_byte_data);
+
+int pmbus_update_byte_data(struct i2c_client *client, int page, u8 reg,
+                           u8 mask, u8 value)
+{
+        unsigned int tmp;
+        int rv;
+
+        rv = pmbus_read_byte_data(client, page, reg);
+        if (rv < 0)
+                return rv;
+
+        tmp = (rv & ~mask) | (value & mask);
+
+        if (tmp != rv)
+                rv = pmbus_write_byte_data(client, page, reg, tmp);
+
+        return rv;
+}
+EXPORT_SYMBOL_GPL(pmbus_update_byte_data);
+
 /*
  * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
  * a device specific mapping function exists and calls it if necessary.
@@ -1727,6 +1760,84 @@ static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data,
         return 0;
 }
 
+#if IS_ENABLED(CONFIG_REGULATOR)
+static int pmbus_regulator_is_enabled(struct regulator_dev *rdev)
+{
+        struct device *dev = rdev_get_dev(rdev);
+        struct i2c_client *client = to_i2c_client(dev->parent);
+        u8 page = rdev_get_id(rdev);
+        int ret;
+
+        ret = pmbus_read_byte_data(client, page, PMBUS_OPERATION);
+        if (ret < 0)
+                return ret;
+
+        return !!(ret & PB_OPERATION_CONTROL_ON);
+}
+
+static int _pmbus_regulator_on_off(struct regulator_dev *rdev, bool enable)
+{
+        struct device *dev = rdev_get_dev(rdev);
+        struct i2c_client *client = to_i2c_client(dev->parent);
+        u8 page = rdev_get_id(rdev);
+
+        return pmbus_update_byte_data(client, page, PMBUS_OPERATION,
+                                      PB_OPERATION_CONTROL_ON,
+                                      enable ? PB_OPERATION_CONTROL_ON : 0);
+}
+
+static int pmbus_regulator_enable(struct regulator_dev *rdev)
+{
+        return _pmbus_regulator_on_off(rdev, 1);
+}
+
+static int pmbus_regulator_disable(struct regulator_dev *rdev)
+{
+        return _pmbus_regulator_on_off(rdev, 0);
+}
+
+struct regulator_ops pmbus_regulator_ops = {
+        .enable = pmbus_regulator_enable,
+        .disable = pmbus_regulator_disable,
+        .is_enabled = pmbus_regulator_is_enabled,
+};
+EXPORT_SYMBOL_GPL(pmbus_regulator_ops);
+
+static int pmbus_regulator_register(struct pmbus_data *data)
+{
+        struct device *dev = data->dev;
+        const struct pmbus_driver_info *info = data->info;
+        const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
+        struct regulator_dev *rdev;
+        int i;
+
+        for (i = 0; i < info->num_regulators; i++) {
+                struct regulator_config config = { };
+
+                config.dev = dev;
+                config.driver_data = data;
+
+                if (pdata && pdata->reg_init_data)
+                        config.init_data = &pdata->reg_init_data[i];
+
+                rdev = devm_regulator_register(dev, &info->reg_desc[i],
+                                               &config);
+                if (IS_ERR(rdev)) {
+                        dev_err(dev, "Failed to register %s regulator\n",
+                                info->reg_desc[i].name);
+                        return PTR_ERR(rdev);
+                }
+        }
+
+        return 0;
+}
+#else
+static int pmbus_regulator_register(struct pmbus_data *data)
+{
+        return 0;
+}
+#endif
+
 int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
                    struct pmbus_driver_info *info)
 {
@@ -1781,8 +1892,15 @@ int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
                 dev_err(dev, "Failed to register hwmon device\n");
                 goto out_kfree;
         }
+
+        ret = pmbus_regulator_register(data);
+        if (ret)
+                goto out_unregister;
+
         return 0;
 
+out_unregister:
+        hwmon_device_unregister(data->hwmon_dev);
 out_kfree:
         kfree(data->group.attrs);
         return ret;
diff --git a/drivers/hwmon/tmp401.c b/drivers/hwmon/tmp401.c
index 7fa6e7d0b9b6..99664ebc738d 100644
--- a/drivers/hwmon/tmp401.c
+++ b/drivers/hwmon/tmp401.c
@@ -44,9 +44,10 @@
 #include <linux/sysfs.h>
 
 /* Addresses to scan */
-static const unsigned short normal_i2c[] = { 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
+static const unsigned short normal_i2c[] = { 0x37, 0x48, 0x49, 0x4a, 0x4c, 0x4d,
+        0x4e, 0x4f, I2C_CLIENT_END };
 
-enum chips { tmp401, tmp411, tmp431, tmp432 };
+enum chips { tmp401, tmp411, tmp431, tmp432, tmp435 };
 
 /*
  * The TMP401 registers, note some registers have different addresses for
@@ -136,6 +137,7 @@ static const u8 TMP432_STATUS_REG[] = {
 #define TMP411C_DEVICE_ID                       0x10
 #define TMP431_DEVICE_ID                        0x31
 #define TMP432_DEVICE_ID                        0x32
+#define TMP435_DEVICE_ID                        0x35
 
 /*
  * Driver data (common to all clients)
@@ -146,6 +148,7 @@ static const struct i2c_device_id tmp401_id[] = {
         { "tmp411", tmp411 },
         { "tmp431", tmp431 },
         { "tmp432", tmp432 },
+        { "tmp435", tmp435 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, tmp401_id);
@@ -613,10 +616,10 @@ static const struct attribute_group tmp432_group = {
  * Begin non sysfs callback code (aka Real code)
  */
 
-static void tmp401_init_client(struct tmp401_data *data,
-                               struct i2c_client *client)
+static int tmp401_init_client(struct tmp401_data *data,
+                              struct i2c_client *client)
 {
-        int config, config_orig;
+        int config, config_orig, status = 0;
 
         /* Set the conversion rate to 2 Hz */
         i2c_smbus_write_byte_data(client, TMP401_CONVERSION_RATE_WRITE, 5);
@@ -624,16 +627,18 @@ static void tmp401_init_client(struct tmp401_data *data,
 
         /* Start conversions (disable shutdown if necessary) */
         config = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
-        if (config < 0) {
-                dev_warn(&client->dev, "Initialization failed!\n");
-                return;
-        }
+        if (config < 0)
+                return config;
 
         config_orig = config;
         config &= ~TMP401_CONFIG_SHUTDOWN;
 
         if (config != config_orig)
-                i2c_smbus_write_byte_data(client, TMP401_CONFIG_WRITE, config);
+                status = i2c_smbus_write_byte_data(client,
+                                                   TMP401_CONFIG_WRITE,
+                                                   config);
+
+        return status;
 }
 
 static int tmp401_detect(struct i2c_client *client,
@@ -675,15 +680,18 @@ static int tmp401_detect(struct i2c_client *client,
                 kind = tmp411;
                 break;
         case TMP431_DEVICE_ID:
-                if (client->addr == 0x4e)
+                if (client->addr != 0x4c && client->addr != 0x4d)
                         return -ENODEV;
                 kind = tmp431;
                 break;
         case TMP432_DEVICE_ID:
-                if (client->addr == 0x4e)
+                if (client->addr != 0x4c && client->addr != 0x4d)
                         return -ENODEV;
                 kind = tmp432;
                 break;
+        case TMP435_DEVICE_ID:
+                kind = tmp435;
+                break;
         default:
                 return -ENODEV;
         }
@@ -705,11 +713,13 @@ static int tmp401_detect(struct i2c_client *client,
 static int tmp401_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
-        const char *names[] = { "TMP401", "TMP411", "TMP431", "TMP432" };
+        static const char * const names[] = {
+                "TMP401", "TMP411", "TMP431", "TMP432", "TMP435"
+        };
         struct device *dev = &client->dev;
         struct device *hwmon_dev;
         struct tmp401_data *data;
-        int groups = 0;
+        int groups = 0, status;
 
         data = devm_kzalloc(dev, sizeof(struct tmp401_data), GFP_KERNEL);
         if (!data)
@@ -720,7 +730,9 @@ static int tmp401_probe(struct i2c_client *client,
         data->kind = id->driver_data;
 
         /* Initialize the TMP401 chip */
-        tmp401_init_client(data, client);
+        status = tmp401_init_client(data, client);
+        if (status < 0)
+                return status;
 
         /* Register sysfs hooks */
         data->groups[groups++] = &tmp401_group;
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 917c3585f45b..b4d135cc2f39 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -881,6 +881,16 @@ config I2C_DIOLAN_U2C
           This driver can also be built as a module.  If so, the module
           will be called i2c-diolan-u2c.
 
+config I2C_DLN2
+       tristate "Diolan DLN-2 USB I2C adapter"
+       depends on MFD_DLN2
+       help
+         If you say yes to this option, support will be included for Diolan
+         DLN2, a USB to I2C interface.
+
+         This driver can also be built as a module.  If so, the module
+         will be called i2c-dln2.
+
 config I2C_PARPORT
         tristate "Parallel port adapter"
         depends on PARPORT
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index 78d56c54ba2b..cdac7f15eab5 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -87,6 +87,7 @@ obj-$(CONFIG_I2C_RCAR)		+= i2c-rcar.o
 
 # External I2C/SMBus adapter drivers
 obj-$(CONFIG_I2C_DIOLAN_U2C)    += i2c-diolan-u2c.o
+obj-$(CONFIG_I2C_DLN2)          += i2c-dln2.o
 obj-$(CONFIG_I2C_PARPORT)       += i2c-parport.o
 obj-$(CONFIG_I2C_PARPORT_LIGHT) += i2c-parport-light.o
 obj-$(CONFIG_I2C_ROBOTFUZZ_OSIF)        += i2c-robotfuzz-osif.o
diff --git a/drivers/i2c/busses/i2c-cadence.c b/drivers/i2c/busses/i2c-cadence.c
index 63f3f03ecc9b..c604f4c3ac0d 100644
--- a/drivers/i2c/busses/i2c-cadence.c
+++ b/drivers/i2c/busses/i2c-cadence.c
@@ -111,6 +111,8 @@
 #define CDNS_I2C_DIVA_MAX       4
 #define CDNS_I2C_DIVB_MAX       64
 
+#define CDNS_I2C_TIMEOUT_MAX    0xFF
+
 #define cdns_i2c_readreg(offset)       readl_relaxed(id->membase + offset)
 #define cdns_i2c_writereg(val, offset) writel_relaxed(val, id->membase + offset)
 
@@ -852,6 +854,15 @@ static int cdns_i2c_probe(struct platform_device *pdev)
                 goto err_clk_dis;
         }
 
+        /*
+         * Cadence I2C controller has a bug wherein it generates
+         * invalid read transaction after HW timeout in master receiver mode.
+         * HW timeout is not used by this driver and the interrupt is disabled.
+         * But the feature itself cannot be disabled. Hence maximum value
+         * is written to this register to reduce the chances of error.
+         */
+        cdns_i2c_writereg(CDNS_I2C_TIMEOUT_MAX, CDNS_I2C_TIME_OUT_OFFSET);
+
         dev_info(&pdev->dev, "%u kHz mmio %08lx irq %d\n",
                  id->i2c_clk / 1000, (unsigned long)r_mem->start, id->irq);
 
diff --git a/drivers/i2c/busses/i2c-davinci.c b/drivers/i2c/busses/i2c-davinci.c
index d15b7c9b9219..01f0cd87a4a5 100644
--- a/drivers/i2c/busses/i2c-davinci.c
+++ b/drivers/i2c/busses/i2c-davinci.c
@@ -407,11 +407,9 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
         if (dev->cmd_err & DAVINCI_I2C_STR_NACK) {
                 if (msg->flags & I2C_M_IGNORE_NAK)
                         return msg->len;
-                if (stop) {
-                        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
-                        w |= DAVINCI_I2C_MDR_STP;
-                        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
-                }
+                w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
+                w |= DAVINCI_I2C_MDR_STP;
+                davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
                 return -EREMOTEIO;
         }
         return -EIO;
diff --git a/drivers/i2c/busses/i2c-designware-core.c b/drivers/i2c/busses/i2c-designware-core.c
index edca99dbba23..23628b7bfb8d 100644
--- a/drivers/i2c/busses/i2c-designware-core.c
+++ b/drivers/i2c/busses/i2c-designware-core.c
@@ -359,7 +359,7 @@ int i2c_dw_init(struct dw_i2c_dev *dev)
         }
 
         /* Configure Tx/Rx FIFO threshold levels */
-        dw_writel(dev, dev->tx_fifo_depth - 1, DW_IC_TX_TL);
+        dw_writel(dev, dev->tx_fifo_depth / 2, DW_IC_TX_TL);
         dw_writel(dev, 0, DW_IC_RX_TL);
 
         /* configure the i2c master */
diff --git a/drivers/i2c/busses/i2c-dln2.c b/drivers/i2c/busses/i2c-dln2.c
new file mode 100644
index 000000000000..b3fb86af4cbb
--- /dev/null
+++ b/drivers/i2c/busses/i2c-dln2.c
@@ -0,0 +1,262 @@
+/*
+ * Driver for the Diolan DLN-2 USB-I2C adapter
+ *
+ * Copyright (c) 2014 Intel Corporation
+ *
+ * Derived from:
+ *  i2c-diolan-u2c.c
+ *  Copyright (c) 2010-2011 Ericsson AB
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/dln2.h>
+
+#define DLN2_I2C_MODULE_ID              0x03
+#define DLN2_I2C_CMD(cmd)               DLN2_CMD(cmd, DLN2_I2C_MODULE_ID)
+
+/* I2C commands */
+#define DLN2_I2C_GET_PORT_COUNT         DLN2_I2C_CMD(0x00)
+#define DLN2_I2C_ENABLE                 DLN2_I2C_CMD(0x01)
+#define DLN2_I2C_DISABLE                DLN2_I2C_CMD(0x02)
+#define DLN2_I2C_IS_ENABLED             DLN2_I2C_CMD(0x03)
+#define DLN2_I2C_WRITE                  DLN2_I2C_CMD(0x06)
+#define DLN2_I2C_READ                   DLN2_I2C_CMD(0x07)
+#define DLN2_I2C_SCAN_DEVICES           DLN2_I2C_CMD(0x08)
+#define DLN2_I2C_PULLUP_ENABLE          DLN2_I2C_CMD(0x09)
+#define DLN2_I2C_PULLUP_DISABLE         DLN2_I2C_CMD(0x0A)
+#define DLN2_I2C_PULLUP_IS_ENABLED      DLN2_I2C_CMD(0x0B)
+#define DLN2_I2C_TRANSFER               DLN2_I2C_CMD(0x0C)
+#define DLN2_I2C_SET_MAX_REPLY_COUNT    DLN2_I2C_CMD(0x0D)
+#define DLN2_I2C_GET_MAX_REPLY_COUNT    DLN2_I2C_CMD(0x0E)
+
+#define DLN2_I2C_MAX_XFER_SIZE          256
+#define DLN2_I2C_BUF_SIZE               (DLN2_I2C_MAX_XFER_SIZE + 16)
+
+struct dln2_i2c {
+        struct platform_device *pdev;
+        struct i2c_adapter adapter;
+        u8 port;
+        /*
+         * Buffer to hold the packet for read or write transfers. One is enough
+         * since we can't have multiple transfers in parallel on the i2c bus.
+         */
+        void *buf;
+};
+
+static int dln2_i2c_enable(struct dln2_i2c *dln2, bool enable)
+{
+        u16 cmd;
+        struct {
+                u8 port;
+        } tx;
+
+        tx.port = dln2->port;
+
+        if (enable)
+                cmd = DLN2_I2C_ENABLE;
+        else
+                cmd = DLN2_I2C_DISABLE;
+
+        return dln2_transfer_tx(dln2->pdev, cmd, &tx, sizeof(tx));
+}
+
+static int dln2_i2c_write(struct dln2_i2c *dln2, u8 addr,
+                          u8 *data, u16 data_len)
+{
+        int ret;
+        struct {
+                u8 port;
+                u8 addr;
+                u8 mem_addr_len;
+                __le32 mem_addr;
+                __le16 buf_len;
+                u8 buf[DLN2_I2C_MAX_XFER_SIZE];
+        } __packed *tx = dln2->buf;
+        unsigned len;
+
+        BUILD_BUG_ON(sizeof(*tx) > DLN2_I2C_BUF_SIZE);
+
+        tx->port = dln2->port;
+        tx->addr = addr;
+        tx->mem_addr_len = 0;
+        tx->mem_addr = 0;
+        tx->buf_len = cpu_to_le16(data_len);
+        memcpy(tx->buf, data, data_len);
+
+        len = sizeof(*tx) + data_len - DLN2_I2C_MAX_XFER_SIZE;
+        ret = dln2_transfer_tx(dln2->pdev, DLN2_I2C_WRITE, tx, len);
+        if (ret < 0)
+                return ret;
+
+        return data_len;
+}
+
+static int dln2_i2c_read(struct dln2_i2c *dln2, u16 addr, u8 *data,
+                         u16 data_len)
+{
+        int ret;
+        struct {
+                u8 port;
+                u8 addr;
+                u8 mem_addr_len;
+                __le32 mem_addr;
+                __le16 buf_len;
+        } __packed tx;
+        struct {
+                __le16 buf_len;
+                u8 buf[DLN2_I2C_MAX_XFER_SIZE];
+        } __packed *rx = dln2->buf;
+        unsigned rx_len = sizeof(*rx);
+
+        BUILD_BUG_ON(sizeof(*rx) > DLN2_I2C_BUF_SIZE);
+
+        tx.port = dln2->port;
+        tx.addr = addr;
+        tx.mem_addr_len = 0;
+        tx.mem_addr = 0;
+        tx.buf_len = cpu_to_le16(data_len);
+
+        ret = dln2_transfer(dln2->pdev, DLN2_I2C_READ, &tx, sizeof(tx),
+                            rx, &rx_len);
+        if (ret < 0)
+                return ret;
+        if (rx_len < sizeof(rx->buf_len) + data_len)
+                return -EPROTO;
+        if (le16_to_cpu(rx->buf_len) != data_len)
+                return -EPROTO;
+
+        memcpy(data, rx->buf, data_len);
+
+        return data_len;
+}
+
+static int dln2_i2c_xfer(struct i2c_adapter *adapter,
+                         struct i2c_msg *msgs, int num)
+{
+        struct dln2_i2c *dln2 = i2c_get_adapdata(adapter);
+        struct i2c_msg *pmsg;
+        struct device *dev = &dln2->adapter.dev;
+        int i;
+
+        for (i = 0; i < num; i++) {
+                int ret;
+
+                pmsg = &msgs[i];
+
+                if (pmsg->len > DLN2_I2C_MAX_XFER_SIZE) {
+                        dev_warn(dev, "maximum transfer size exceeded\n");
+                        return -EOPNOTSUPP;
+                }
+
+                if (pmsg->flags & I2C_M_RD) {
+                        ret = dln2_i2c_read(dln2, pmsg->addr, pmsg->buf,
+                                            pmsg->len);
+                        if (ret < 0)
+                                return ret;
+
+                        pmsg->len = ret;
+                } else {
+                        ret = dln2_i2c_write(dln2, pmsg->addr, pmsg->buf,
+                                             pmsg->len);
+                        if (ret != pmsg->len)
+                                return -EPROTO;
+                }
+        }
+
+        return num;
+}
+
+static u32 dln2_i2c_func(struct i2c_adapter *a)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA |
+                I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
+                I2C_FUNC_SMBUS_I2C_BLOCK;
+}
+
+static const struct i2c_algorithm dln2_i2c_usb_algorithm = {
+        .master_xfer = dln2_i2c_xfer,
+        .functionality = dln2_i2c_func,
+};
+
+static int dln2_i2c_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct dln2_i2c *dln2;
+        struct device *dev = &pdev->dev;
+        struct dln2_platform_data *pdata = dev_get_platdata(&pdev->dev);
+
+        dln2 = devm_kzalloc(dev, sizeof(*dln2), GFP_KERNEL);
+        if (!dln2)
+                return -ENOMEM;
+
+        dln2->buf = devm_kmalloc(dev, DLN2_I2C_BUF_SIZE, GFP_KERNEL);
+        if (!dln2->buf)
+                return -ENOMEM;
+
+        dln2->pdev = pdev;
+        dln2->port = pdata->port;
+
+        /* setup i2c adapter description */
+        dln2->adapter.owner = THIS_MODULE;
+        dln2->adapter.class = I2C_CLASS_HWMON;
+        dln2->adapter.algo = &dln2_i2c_usb_algorithm;
+        dln2->adapter.dev.parent = dev;
+        i2c_set_adapdata(&dln2->adapter, dln2);
+        snprintf(dln2->adapter.name, sizeof(dln2->adapter.name), "%s-%s-%d",
+                 "dln2-i2c", dev_name(pdev->dev.parent), dln2->port);
+
+        platform_set_drvdata(pdev, dln2);
+
+        /* initialize the i2c interface */
+        ret = dln2_i2c_enable(dln2, true);
+        if (ret < 0) {
+                dev_err(dev, "failed to initialize adapter: %d\n", ret);
+                return ret;
+        }
+
+        /* and finally attach to i2c layer */
+        ret = i2c_add_adapter(&dln2->adapter);
+        if (ret < 0) {
+                dev_err(dev, "failed to add I2C adapter: %d\n", ret);
+                goto out_disable;
+        }
+
+        return 0;
+
+out_disable:
+        dln2_i2c_enable(dln2, false);
+
+        return ret;
+}
+
+static int dln2_i2c_remove(struct platform_device *pdev)
+{
+        struct dln2_i2c *dln2 = platform_get_drvdata(pdev);
+
+        i2c_del_adapter(&dln2->adapter);
+        dln2_i2c_enable(dln2, false);
+
+        return 0;
+}
+
+static struct platform_driver dln2_i2c_driver = {
+        .driver.name    = "dln2-i2c",
+        .probe          = dln2_i2c_probe,
+        .remove         = dln2_i2c_remove,
+};
+
+module_platform_driver(dln2_i2c_driver);
+
+MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
+MODULE_DESCRIPTION("Driver for the Diolan DLN2 I2C master interface");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:dln2-i2c");
diff --git a/drivers/i2c/busses/i2c-hix5hd2.c b/drivers/i2c/busses/i2c-hix5hd2.c
index 9490d0f4255c..8fe78d08e01c 100644
--- a/drivers/i2c/busses/i2c-hix5hd2.c
+++ b/drivers/i2c/busses/i2c-hix5hd2.c
@@ -528,7 +528,7 @@ static int hix5hd2_i2c_runtime_resume(struct device *dev)
 #endif
 
 static const struct dev_pm_ops hix5hd2_i2c_pm_ops = {
-        SET_PM_RUNTIME_PM_OPS(hix5hd2_i2c_runtime_suspend,
+        SET_RUNTIME_PM_OPS(hix5hd2_i2c_runtime_suspend,
                               hix5hd2_i2c_runtime_resume,
                               NULL)
 };
diff --git a/drivers/i2c/busses/i2c-nomadik.c b/drivers/i2c/busses/i2c-nomadik.c
index 9ad038d223c4..97998946c4f6 100644
--- a/drivers/i2c/busses/i2c-nomadik.c
+++ b/drivers/i2c/busses/i2c-nomadik.c
@@ -932,7 +932,7 @@ static int nmk_i2c_runtime_resume(struct device *dev)
 
 static const struct dev_pm_ops nmk_i2c_pm = {
         SET_LATE_SYSTEM_SLEEP_PM_OPS(nmk_i2c_suspend_late, nmk_i2c_resume_early)
-        SET_PM_RUNTIME_PM_OPS(nmk_i2c_runtime_suspend,
+        SET_RUNTIME_PM_OPS(nmk_i2c_runtime_suspend,
                         nmk_i2c_runtime_resume,
                         NULL)
 };
diff --git a/drivers/i2c/busses/i2c-omap.c b/drivers/i2c/busses/i2c-omap.c
index 26942c159de1..0e650a0d0ad0 100644
--- a/drivers/i2c/busses/i2c-omap.c
+++ b/drivers/i2c/busses/i2c-omap.c
@@ -922,14 +922,12 @@ omap_i2c_isr_thread(int this_irq, void *dev_id)
                 if (stat & OMAP_I2C_STAT_NACK) {
                         err |= OMAP_I2C_STAT_NACK;
                         omap_i2c_ack_stat(dev, OMAP_I2C_STAT_NACK);
-                        break;
                 }
 
                 if (stat & OMAP_I2C_STAT_AL) {
                         dev_err(dev->dev, "Arbitration lost\n");
                         err |= OMAP_I2C_STAT_AL;
                         omap_i2c_ack_stat(dev, OMAP_I2C_STAT_AL);
-                        break;
                 }
 
                 /*
@@ -954,11 +952,13 @@ omap_i2c_isr_thread(int this_irq, void *dev_id)
                         if (dev->fifo_size)
                                 num_bytes = dev->buf_len;
 
-                        omap_i2c_receive_data(dev, num_bytes, true);
-
-                        if (dev->errata & I2C_OMAP_ERRATA_I207)
+                        if (dev->errata & I2C_OMAP_ERRATA_I207) {
                                 i2c_omap_errata_i207(dev, stat);
+                                num_bytes = (omap_i2c_read_reg(dev,
+                                        OMAP_I2C_BUFSTAT_REG) >> 8) & 0x3F;
+                        }
 
+                        omap_i2c_receive_data(dev, num_bytes, true);
                         omap_i2c_ack_stat(dev, OMAP_I2C_STAT_RDR);
                         continue;
                 }
@@ -1280,7 +1280,6 @@ static int omap_i2c_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-#ifdef CONFIG_PM_RUNTIME
 static int omap_i2c_runtime_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
@@ -1318,7 +1317,6 @@ static int omap_i2c_runtime_resume(struct device *dev)
 
         return 0;
 }
-#endif /* CONFIG_PM_RUNTIME */
 
 static struct dev_pm_ops omap_i2c_pm_ops = {
         SET_RUNTIME_PM_OPS(omap_i2c_runtime_suspend,
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index d8afd3f28ca4..229a89e84b0f 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -404,6 +404,7 @@ static int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
                 return -ENOMEM;
         }
 
+        acpi_walk_dep_device_list(handle);
         return 0;
 }
 
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index 9b7ee7e427df..9cceacb92f9d 100644
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -128,28 +128,28 @@ static struct cpuidle_state nehalem_cstates[] = {
         {
                 .name = "C1-NHM",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 3,
                 .target_residency = 6,
                 .enter = &intel_idle },
         {
                 .name = "C1E-NHM",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 10,
                 .target_residency = 20,
                 .enter = &intel_idle },
         {
                 .name = "C3-NHM",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 20,
                 .target_residency = 80,
                 .enter = &intel_idle },
         {
                 .name = "C6-NHM",
                 .desc = "MWAIT 0x20",
-                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 200,
                 .target_residency = 800,
                 .enter = &intel_idle },
@@ -161,35 +161,35 @@ static struct cpuidle_state snb_cstates[] = {
         {
                 .name = "C1-SNB",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 2,
                 .target_residency = 2,
                 .enter = &intel_idle },
         {
                 .name = "C1E-SNB",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 10,
                 .target_residency = 20,
                 .enter = &intel_idle },
         {
                 .name = "C3-SNB",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 80,
                 .target_residency = 211,
                 .enter = &intel_idle },
         {
                 .name = "C6-SNB",
                 .desc = "MWAIT 0x20",
-                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 104,
                 .target_residency = 345,
                 .enter = &intel_idle },
         {
                 .name = "C7-SNB",
                 .desc = "MWAIT 0x30",
-                .flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 109,
                 .target_residency = 345,
                 .enter = &intel_idle },
@@ -201,42 +201,42 @@ static struct cpuidle_state byt_cstates[] = {
         {
                 .name = "C1-BYT",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 1,
                 .target_residency = 1,
                 .enter = &intel_idle },
         {
                 .name = "C1E-BYT",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 15,
                 .target_residency = 30,
                 .enter = &intel_idle },
         {
                 .name = "C6N-BYT",
                 .desc = "MWAIT 0x58",
-                .flags = MWAIT2flg(0x58) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x58) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 40,
                 .target_residency = 275,
                 .enter = &intel_idle },
         {
                 .name = "C6S-BYT",
                 .desc = "MWAIT 0x52",
-                .flags = MWAIT2flg(0x52) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x52) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 140,
                 .target_residency = 560,
                 .enter = &intel_idle },
         {
                 .name = "C7-BYT",
                 .desc = "MWAIT 0x60",
-                .flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 1200,
                 .target_residency = 1500,
                 .enter = &intel_idle },
         {
                 .name = "C7S-BYT",
                 .desc = "MWAIT 0x64",
-                .flags = MWAIT2flg(0x64) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x64) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 10000,
                 .target_residency = 20000,
                 .enter = &intel_idle },
@@ -248,35 +248,35 @@ static struct cpuidle_state ivb_cstates[] = {
         {
                 .name = "C1-IVB",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 1,
                 .target_residency = 1,
                 .enter = &intel_idle },
         {
                 .name = "C1E-IVB",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 10,
                 .target_residency = 20,
                 .enter = &intel_idle },
         {
                 .name = "C3-IVB",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 59,
                 .target_residency = 156,
                 .enter = &intel_idle },
         {
                 .name = "C6-IVB",
                 .desc = "MWAIT 0x20",
-                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 80,
                 .target_residency = 300,
                 .enter = &intel_idle },
         {
                 .name = "C7-IVB",
                 .desc = "MWAIT 0x30",
-                .flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 87,
                 .target_residency = 300,
                 .enter = &intel_idle },
@@ -288,28 +288,28 @@ static struct cpuidle_state ivt_cstates[] = {
         {
                 .name = "C1-IVT",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 1,
                 .target_residency = 1,
                 .enter = &intel_idle },
         {
                 .name = "C1E-IVT",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 10,
                 .target_residency = 80,
                 .enter = &intel_idle },
         {
                 .name = "C3-IVT",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 59,
                 .target_residency = 156,
                 .enter = &intel_idle },
         {
                 .name = "C6-IVT",
                 .desc = "MWAIT 0x20",
-                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 82,
                 .target_residency = 300,
                 .enter = &intel_idle },
@@ -321,28 +321,28 @@ static struct cpuidle_state ivt_cstates_4s[] = {
         {
                 .name = "C1-IVT-4S",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 1,
                 .target_residency = 1,
                 .enter = &intel_idle },
         {
                 .name = "C1E-IVT-4S",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 10,
                 .target_residency = 250,
                 .enter = &intel_idle },
         {
                 .name = "C3-IVT-4S",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 59,
                 .target_residency = 300,
                 .enter = &intel_idle },
         {
                 .name = "C6-IVT-4S",
                 .desc = "MWAIT 0x20",
-                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 84,
                 .target_residency = 400,
                 .enter = &intel_idle },
@@ -354,28 +354,28 @@ static struct cpuidle_state ivt_cstates_8s[] = {
         {
                 .name = "C1-IVT-8S",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 1,
                 .target_residency = 1,
                 .enter = &intel_idle },
         {
                 .name = "C1E-IVT-8S",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 10,
                 .target_residency = 500,
                 .enter = &intel_idle },
         {
                 .name = "C3-IVT-8S",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 59,
                 .target_residency = 600,
                 .enter = &intel_idle },
         {
                 .name = "C6-IVT-8S",
                 .desc = "MWAIT 0x20",
-                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 88,
                 .target_residency = 700,
                 .enter = &intel_idle },
@@ -387,56 +387,56 @@ static struct cpuidle_state hsw_cstates[] = {
         {
                 .name = "C1-HSW",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 2,
                 .target_residency = 2,
                 .enter = &intel_idle },
         {
                 .name = "C1E-HSW",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 10,
                 .target_residency = 20,
                 .enter = &intel_idle },
         {
                 .name = "C3-HSW",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 33,
                 .target_residency = 100,
                 .enter = &intel_idle },
         {
                 .name = "C6-HSW",
                 .desc = "MWAIT 0x20",
-                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 133,
                 .target_residency = 400,
                 .enter = &intel_idle },
         {
                 .name = "C7s-HSW",
                 .desc = "MWAIT 0x32",
-                .flags = MWAIT2flg(0x32) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x32) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 166,
                 .target_residency = 500,
                 .enter = &intel_idle },
         {
                 .name = "C8-HSW",
                 .desc = "MWAIT 0x40",
-                .flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 300,
                 .target_residency = 900,
                 .enter = &intel_idle },
         {
                 .name = "C9-HSW",
                 .desc = "MWAIT 0x50",
-                .flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 600,
                 .target_residency = 1800,
                 .enter = &intel_idle },
         {
                 .name = "C10-HSW",
                 .desc = "MWAIT 0x60",
-                .flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 2600,
                 .target_residency = 7700,
                 .enter = &intel_idle },
@@ -447,56 +447,56 @@ static struct cpuidle_state bdw_cstates[] = {
         {
                 .name = "C1-BDW",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 2,
                 .target_residency = 2,
                 .enter = &intel_idle },
         {
                 .name = "C1E-BDW",
                 .desc = "MWAIT 0x01",
-                .flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x01),
                 .exit_latency = 10,
                 .target_residency = 20,
                 .enter = &intel_idle },
         {
                 .name = "C3-BDW",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 40,
                 .target_residency = 100,
                 .enter = &intel_idle },
         {
                 .name = "C6-BDW",
                 .desc = "MWAIT 0x20",
-                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 133,
                 .target_residency = 400,
                 .enter = &intel_idle },
         {
                 .name = "C7s-BDW",
                 .desc = "MWAIT 0x32",
-                .flags = MWAIT2flg(0x32) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x32) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 166,
                 .target_residency = 500,
                 .enter = &intel_idle },
         {
                 .name = "C8-BDW",
                 .desc = "MWAIT 0x40",
-                .flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 300,
                 .target_residency = 900,
                 .enter = &intel_idle },
         {
                 .name = "C9-BDW",
                 .desc = "MWAIT 0x50",
-                .flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 600,
                 .target_residency = 1800,
                 .enter = &intel_idle },
         {
                 .name = "C10-BDW",
                 .desc = "MWAIT 0x60",
-                .flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 2600,
                 .target_residency = 7700,
                 .enter = &intel_idle },
@@ -508,28 +508,28 @@ static struct cpuidle_state atom_cstates[] = {
         {
                 .name = "C1E-ATM",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 10,
                 .target_residency = 20,
                 .enter = &intel_idle },
         {
                 .name = "C2-ATM",
                 .desc = "MWAIT 0x10",
-                .flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x10),
                 .exit_latency = 20,
                 .target_residency = 80,
                 .enter = &intel_idle },
         {
                 .name = "C4-ATM",
                 .desc = "MWAIT 0x30",
-                .flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x30) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 100,
                 .target_residency = 400,
                 .enter = &intel_idle },
         {
                 .name = "C6-ATM",
                 .desc = "MWAIT 0x52",
-                .flags = MWAIT2flg(0x52) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x52) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 140,
                 .target_residency = 560,
                 .enter = &intel_idle },
@@ -540,14 +540,14 @@ static struct cpuidle_state avn_cstates[] = {
         {
                 .name = "C1-AVN",
                 .desc = "MWAIT 0x00",
-                .flags = MWAIT2flg(0x00) | CPUIDLE_FLAG_TIME_VALID,
+                .flags = MWAIT2flg(0x00),
                 .exit_latency = 2,
                 .target_residency = 2,
                 .enter = &intel_idle },
         {
                 .name = "C6-AVN",
                 .desc = "MWAIT 0x51",
-                .flags = MWAIT2flg(0x51) | CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
+                .flags = MWAIT2flg(0x51) | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 15,
                 .target_residency = 45,
                 .enter = &intel_idle },
diff --git a/drivers/iio/accel/bmc150-accel.c b/drivers/iio/accel/bmc150-accel.c
index 22c096ce39ad..066d0c04072c 100644
--- a/drivers/iio/accel/bmc150-accel.c
+++ b/drivers/iio/accel/bmc150-accel.c
@@ -44,6 +44,9 @@
 
 #define BMC150_ACCEL_REG_INT_STATUS_2           0x0B
 #define BMC150_ACCEL_ANY_MOTION_MASK            0x07
+#define BMC150_ACCEL_ANY_MOTION_BIT_X           BIT(0)
+#define BMC150_ACCEL_ANY_MOTION_BIT_Y           BIT(1)
+#define BMC150_ACCEL_ANY_MOTION_BIT_Z           BIT(2)
 #define BMC150_ACCEL_ANY_MOTION_BIT_SIGN        BIT(3)
 
 #define BMC150_ACCEL_REG_PMU_LPW                0x11
@@ -92,9 +95,9 @@
 #define BMC150_ACCEL_SLOPE_THRES_MASK           0xFF
 
 /* Slope duration in terms of number of samples */
-#define BMC150_ACCEL_DEF_SLOPE_DURATION 2
+#define BMC150_ACCEL_DEF_SLOPE_DURATION         1
 /* in terms of multiples of g's/LSB, based on range */
-#define BMC150_ACCEL_DEF_SLOPE_THRESHOLD        5
+#define BMC150_ACCEL_DEF_SLOPE_THRESHOLD        1
 
 #define BMC150_ACCEL_REG_XOUT_L         0x02
 
@@ -510,7 +513,7 @@ static int bmc150_accel_get_bw(struct bmc150_accel_data *data, int *val,
         return -EINVAL;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int bmc150_accel_get_startup_times(struct bmc150_accel_data *data)
 {
         int i;
@@ -536,6 +539,9 @@ static int bmc150_accel_set_power_state(struct bmc150_accel_data *data, bool on)
         if (ret < 0) {
                 dev_err(&data->client->dev,
                         "Failed: bmc150_accel_set_power_state for %d\n", on);
+                if (on)
+                        pm_runtime_put_noidle(&data->client->dev);
+
                 return ret;
         }
 
@@ -811,6 +817,7 @@ static int bmc150_accel_write_event_config(struct iio_dev *indio_dev,
 
         ret =  bmc150_accel_setup_any_motion_interrupt(data, state);
         if (ret < 0) {
+                bmc150_accel_set_power_state(data, false);
                 mutex_unlock(&data->mutex);
                 return ret;
         }
@@ -846,7 +853,7 @@ static const struct attribute_group bmc150_accel_attrs_group = {
 
 static const struct iio_event_spec bmc150_accel_event = {
                 .type = IIO_EV_TYPE_ROC,
-                .dir = IIO_EV_DIR_RISING | IIO_EV_DIR_FALLING,
+                .dir = IIO_EV_DIR_EITHER,
                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
                                  BIT(IIO_EV_INFO_ENABLE) |
                                  BIT(IIO_EV_INFO_PERIOD)
@@ -1054,6 +1061,7 @@ static int bmc150_accel_data_rdy_trigger_set_state(struct iio_trigger *trig,
         else
                 ret = bmc150_accel_setup_new_data_interrupt(data, state);
         if (ret < 0) {
+                bmc150_accel_set_power_state(data, false);
                 mutex_unlock(&data->mutex);
                 return ret;
         }
@@ -1092,12 +1100,26 @@ static irqreturn_t bmc150_accel_event_handler(int irq, void *private)
         else
                 dir = IIO_EV_DIR_RISING;
 
-        if (ret & BMC150_ACCEL_ANY_MOTION_MASK)
+        if (ret & BMC150_ACCEL_ANY_MOTION_BIT_X)
+                iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ACCEL,
+                                                        0,
+                                                        IIO_MOD_X,
+                                                        IIO_EV_TYPE_ROC,
+                                                        dir),
+                                                        data->timestamp);
+        if (ret & BMC150_ACCEL_ANY_MOTION_BIT_Y)
                 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ACCEL,
                                                         0,
-                                                        IIO_MOD_X_OR_Y_OR_Z,
+                                                        IIO_MOD_Y,
                                                         IIO_EV_TYPE_ROC,
-                                                        IIO_EV_DIR_EITHER),
+                                                        dir),
+                                                        data->timestamp);
+        if (ret & BMC150_ACCEL_ANY_MOTION_BIT_Z)
+                iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ACCEL,
+                                                        0,
+                                                        IIO_MOD_Z,
+                                                        IIO_EV_TYPE_ROC,
+                                                        dir),
                                                         data->timestamp);
 ack_intr_status:
         if (!data->dready_trigger_on)
@@ -1349,15 +1371,19 @@ static int bmc150_accel_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int bmc150_accel_runtime_suspend(struct device *dev)
 {
         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
         struct bmc150_accel_data *data = iio_priv(indio_dev);
+        int ret;
 
         dev_dbg(&data->client->dev,  __func__);
+        ret = bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_SUSPEND, 0);
+        if (ret < 0)
+                return -EAGAIN;
 
-        return bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_SUSPEND, 0);
+        return 0;
 }
 
 static int bmc150_accel_runtime_resume(struct device *dev)
diff --git a/drivers/iio/accel/kxcjk-1013.c b/drivers/iio/accel/kxcjk-1013.c
index a23e58c4ed99..da2fe93739a2 100644
--- a/drivers/iio/accel/kxcjk-1013.c
+++ b/drivers/iio/accel/kxcjk-1013.c
@@ -269,6 +269,8 @@ static int kxcjk1013_set_range(struct kxcjk1013_data *data, int range_index)
                 return ret;
         }
 
+        ret &= ~(KXCJK1013_REG_CTRL1_BIT_GSEL0 |
+                 KXCJK1013_REG_CTRL1_BIT_GSEL1);
         ret |= (KXCJK1013_scale_table[range_index].gsel_0 << 3);
         ret |= (KXCJK1013_scale_table[range_index].gsel_1 << 4);
 
@@ -358,7 +360,7 @@ static int kxcjk1013_chip_init(struct kxcjk1013_data *data)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int kxcjk1013_get_startup_times(struct kxcjk1013_data *data)
 {
         int i;
@@ -1357,7 +1359,7 @@ static int kxcjk1013_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int kxcjk1013_runtime_suspend(struct device *dev)
 {
         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 88bdc8f612e2..bc4e787096e8 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -127,6 +127,14 @@ config AT91_ADC
         help
           Say yes here to build support for Atmel AT91 ADC.
 
+config AXP288_ADC
+        tristate "X-Powers AXP288 ADC driver"
+        depends on MFD_AXP20X
+        help
+          Say yes here to have support for X-Powers power management IC (PMIC) ADC
+          device. Depending on platform configuration, this general purpose ADC can
+          be used for sampling sensors such as thermal resistors.
+
 config EXYNOS_ADC
         tristate "Exynos ADC driver support"
         depends on ARCH_EXYNOS || ARCH_S3C24XX || ARCH_S3C64XX || (OF && COMPILE_TEST)
diff --git a/drivers/iio/adc/Makefile b/drivers/iio/adc/Makefile
index cb88a6a23b8f..f30093f5b67a 100644
--- a/drivers/iio/adc/Makefile
+++ b/drivers/iio/adc/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_AD7793) += ad7793.o
 obj-$(CONFIG_AD7887) += ad7887.o
 obj-$(CONFIG_AD799X) += ad799x.o
 obj-$(CONFIG_AT91_ADC) += at91_adc.o
+obj-$(CONFIG_AXP288_ADC) += axp288_adc.o
 obj-$(CONFIG_EXYNOS_ADC) += exynos_adc.o
 obj-$(CONFIG_LP8788_ADC) += lp8788_adc.o
 obj-$(CONFIG_MAX1027) += max1027.o
diff --git a/drivers/iio/adc/axp288_adc.c b/drivers/iio/adc/axp288_adc.c
new file mode 100644
index 000000000000..08bcfb061ca5
--- /dev/null
+++ b/drivers/iio/adc/axp288_adc.c
@@ -0,0 +1,261 @@
+/*
+ * axp288_adc.c - X-Powers AXP288 PMIC ADC Driver
+ *
+ * Copyright (C) 2014 Intel Corporation
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/regmap.h>
+#include <linux/mfd/axp20x.h>
+#include <linux/platform_device.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/machine.h>
+#include <linux/iio/driver.h>
+
+#define AXP288_ADC_EN_MASK              0xF1
+#define AXP288_ADC_TS_PIN_GPADC         0xF2
+#define AXP288_ADC_TS_PIN_ON            0xF3
+
+enum axp288_adc_id {
+        AXP288_ADC_TS,
+        AXP288_ADC_PMIC,
+        AXP288_ADC_GP,
+        AXP288_ADC_BATT_CHRG_I,
+        AXP288_ADC_BATT_DISCHRG_I,
+        AXP288_ADC_BATT_V,
+        AXP288_ADC_NR_CHAN,
+};
+
+struct axp288_adc_info {
+        int irq;
+        struct regmap *regmap;
+};
+
+static const struct iio_chan_spec const axp288_adc_channels[] = {
+        {
+                .indexed = 1,
+                .type = IIO_TEMP,
+                .channel = 0,
+                .address = AXP288_TS_ADC_H,
+                .datasheet_name = "TS_PIN",
+        }, {
+                .indexed = 1,
+                .type = IIO_TEMP,
+                .channel = 1,
+                .address = AXP288_PMIC_ADC_H,
+                .datasheet_name = "PMIC_TEMP",
+        }, {
+                .indexed = 1,
+                .type = IIO_TEMP,
+                .channel = 2,
+                .address = AXP288_GP_ADC_H,
+                .datasheet_name = "GPADC",
+        }, {
+                .indexed = 1,
+                .type = IIO_CURRENT,
+                .channel = 3,
+                .address = AXP20X_BATT_CHRG_I_H,
+                .datasheet_name = "BATT_CHG_I",
+                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+        }, {
+                .indexed = 1,
+                .type = IIO_CURRENT,
+                .channel = 4,
+                .address = AXP20X_BATT_DISCHRG_I_H,
+                .datasheet_name = "BATT_DISCHRG_I",
+                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+        }, {
+                .indexed = 1,
+                .type = IIO_VOLTAGE,
+                .channel = 5,
+                .address = AXP20X_BATT_V_H,
+                .datasheet_name = "BATT_V",
+                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+        },
+};
+
+#define AXP288_ADC_MAP(_adc_channel_label, _consumer_dev_name,  \
+                _consumer_channel)                              \
+        {                                                       \
+                .adc_channel_label = _adc_channel_label,        \
+                .consumer_dev_name = _consumer_dev_name,        \
+                .consumer_channel = _consumer_channel,          \
+        }
+
+/* for consumer drivers */
+static struct iio_map axp288_adc_default_maps[] = {
+        AXP288_ADC_MAP("TS_PIN", "axp288-batt", "axp288-batt-temp"),
+        AXP288_ADC_MAP("PMIC_TEMP", "axp288-pmic", "axp288-pmic-temp"),
+        AXP288_ADC_MAP("GPADC", "axp288-gpadc", "axp288-system-temp"),
+        AXP288_ADC_MAP("BATT_CHG_I", "axp288-chrg", "axp288-chrg-curr"),
+        AXP288_ADC_MAP("BATT_DISCHRG_I", "axp288-chrg", "axp288-chrg-d-curr"),
+        AXP288_ADC_MAP("BATT_V", "axp288-batt", "axp288-batt-volt"),
+        {},
+};
+
+static int axp288_adc_read_channel(int *val, unsigned long address,
+                                struct regmap *regmap)
+{
+        u8 buf[2];
+
+        if (regmap_bulk_read(regmap, address, buf, 2))
+                return -EIO;
+        *val = (buf[0] << 4) + ((buf[1] >> 4) & 0x0F);
+
+        return IIO_VAL_INT;
+}
+
+static int axp288_adc_set_ts(struct regmap *regmap, unsigned int mode,
+                                unsigned long address)
+{
+        /* channels other than GPADC do not need to switch TS pin */
+        if (address != AXP288_GP_ADC_H)
+                return 0;
+
+        return regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, mode);
+}
+
+static int axp288_adc_read_raw(struct iio_dev *indio_dev,
+                        struct iio_chan_spec const *chan,
+                        int *val, int *val2, long mask)
+{
+        int ret;
+        struct axp288_adc_info *info = iio_priv(indio_dev);
+
+        mutex_lock(&indio_dev->mlock);
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_GPADC,
+                                        chan->address)) {
+                        dev_err(&indio_dev->dev, "GPADC mode\n");
+                        ret = -EINVAL;
+                        break;
+                }
+                ret = axp288_adc_read_channel(val, chan->address, info->regmap);
+                if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_ON,
+                                                chan->address))
+                        dev_err(&indio_dev->dev, "TS pin restore\n");
+                break;
+        case IIO_CHAN_INFO_PROCESSED:
+                ret = axp288_adc_read_channel(val, chan->address, info->regmap);
+                break;
+        default:
+                ret = -EINVAL;
+        }
+        mutex_unlock(&indio_dev->mlock);
+
+        return ret;
+}
+
+static int axp288_adc_set_state(struct regmap *regmap)
+{
+        /* ADC should be always enabled for internal FG to function */
+        if (regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, AXP288_ADC_TS_PIN_ON))
+                return -EIO;
+
+        return regmap_write(regmap, AXP20X_ADC_EN1, AXP288_ADC_EN_MASK);
+}
+
+static const struct iio_info axp288_adc_iio_info = {
+        .read_raw = &axp288_adc_read_raw,
+        .driver_module = THIS_MODULE,
+};
+
+static int axp288_adc_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct axp288_adc_info *info;
+        struct iio_dev *indio_dev;
+        struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
+
+        indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*info));
+        if (!indio_dev)
+                return -ENOMEM;
+
+        info = iio_priv(indio_dev);
+        info->irq = platform_get_irq(pdev, 0);
+        if (info->irq < 0) {
+                dev_err(&pdev->dev, "no irq resource?\n");
+                return info->irq;
+        }
+        platform_set_drvdata(pdev, indio_dev);
+        info->regmap = axp20x->regmap;
+        /*
+         * Set ADC to enabled state at all time, including system suspend.
+         * otherwise internal fuel gauge functionality may be affected.
+         */
+        ret = axp288_adc_set_state(axp20x->regmap);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to enable ADC device\n");
+                return ret;
+        }
+
+        indio_dev->dev.parent = &pdev->dev;
+        indio_dev->name = pdev->name;
+        indio_dev->channels = axp288_adc_channels;
+        indio_dev->num_channels = ARRAY_SIZE(axp288_adc_channels);
+        indio_dev->info = &axp288_adc_iio_info;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        ret = iio_map_array_register(indio_dev, axp288_adc_default_maps);
+        if (ret < 0)
+                return ret;
+
+        ret = iio_device_register(indio_dev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "unable to register iio device\n");
+                goto err_array_unregister;
+        }
+        return 0;
+
+err_array_unregister:
+        iio_map_array_unregister(indio_dev);
+
+        return ret;
+}
+
+static int axp288_adc_remove(struct platform_device *pdev)
+{
+        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
+
+        iio_device_unregister(indio_dev);
+        iio_map_array_unregister(indio_dev);
+
+        return 0;
+}
+
+static struct platform_device_id axp288_adc_id_table[] = {
+        { .name = "axp288_adc" },
+        {},
+};
+
+static struct platform_driver axp288_adc_driver = {
+        .probe = axp288_adc_probe,
+        .remove = axp288_adc_remove,
+        .id_table = axp288_adc_id_table,
+        .driver = {
+                .name = "axp288_adc",
+        },
+};
+
+MODULE_DEVICE_TABLE(platform, axp288_adc_id_table);
+
+module_platform_driver(axp288_adc_driver);
+
+MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@linux.intel.com>");
+MODULE_DESCRIPTION("X-Powers AXP288 ADC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/iio/adc/men_z188_adc.c b/drivers/iio/adc/men_z188_adc.c
index b58d6302521f..d095efe1ba14 100644
--- a/drivers/iio/adc/men_z188_adc.c
+++ b/drivers/iio/adc/men_z188_adc.c
@@ -152,6 +152,7 @@ static void men_z188_remove(struct mcb_device *dev)
 
 static const struct mcb_device_id men_z188_ids[] = {
         { .device = 0xbc },
+        { }
 };
 MODULE_DEVICE_TABLE(mcb, men_z188_ids);
 
diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160.c
index 1f967e0d688e..60451b328242 100644
--- a/drivers/iio/gyro/bmg160.c
+++ b/drivers/iio/gyro/bmg160.c
@@ -67,6 +67,9 @@
 #define BMG160_REG_INT_EN_0             0x15
 #define BMG160_DATA_ENABLE_INT          BIT(7)
 
+#define BMG160_REG_INT_EN_1             0x16
+#define BMG160_INT1_BIT_OD              BIT(1)
+
 #define BMG160_REG_XOUT_L               0x02
 #define BMG160_AXIS_TO_REG(axis)        (BMG160_REG_XOUT_L + (axis * 2))
 
@@ -82,6 +85,9 @@
 
 #define BMG160_REG_INT_STATUS_2 0x0B
 #define BMG160_ANY_MOTION_MASK          0x07
+#define BMG160_ANY_MOTION_BIT_X         BIT(0)
+#define BMG160_ANY_MOTION_BIT_Y         BIT(1)
+#define BMG160_ANY_MOTION_BIT_Z         BIT(2)
 
 #define BMG160_REG_TEMP         0x08
 #define BMG160_TEMP_CENTER_VAL          23
@@ -222,6 +228,19 @@ static int bmg160_chip_init(struct bmg160_data *data)
         data->slope_thres = ret;
 
         /* Set default interrupt mode */
+        ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_EN_1);
+        if (ret < 0) {
+                dev_err(&data->client->dev, "Error reading reg_int_en_1\n");
+                return ret;
+        }
+        ret &= ~BMG160_INT1_BIT_OD;
+        ret = i2c_smbus_write_byte_data(data->client,
+                                        BMG160_REG_INT_EN_1, ret);
+        if (ret < 0) {
+                dev_err(&data->client->dev, "Error writing reg_int_en_1\n");
+                return ret;
+        }
+
         ret = i2c_smbus_write_byte_data(data->client,
                                         BMG160_REG_INT_RST_LATCH,
                                         BMG160_INT_MODE_LATCH_INT |
@@ -237,7 +256,7 @@ static int bmg160_chip_init(struct bmg160_data *data)
 
 static int bmg160_set_power_state(struct bmg160_data *data, bool on)
 {
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         int ret;
 
         if (on)
@@ -250,6 +269,9 @@ static int bmg160_set_power_state(struct bmg160_data *data, bool on)
         if (ret < 0) {
                 dev_err(&data->client->dev,
                         "Failed: bmg160_set_power_state for %d\n", on);
+                if (on)
+                        pm_runtime_put_noidle(&data->client->dev);
+
                 return ret;
         }
 #endif
@@ -705,6 +727,7 @@ static int bmg160_write_event_config(struct iio_dev *indio_dev,
 
         ret =  bmg160_setup_any_motion_interrupt(data, state);
         if (ret < 0) {
+                bmg160_set_power_state(data, false);
                 mutex_unlock(&data->mutex);
                 return ret;
         }
@@ -743,7 +766,7 @@ static const struct attribute_group bmg160_attrs_group = {
 
 static const struct iio_event_spec bmg160_event = {
                 .type = IIO_EV_TYPE_ROC,
-                .dir = IIO_EV_DIR_RISING | IIO_EV_DIR_FALLING,
+                .dir = IIO_EV_DIR_EITHER,
                 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) |
                                        BIT(IIO_EV_INFO_ENABLE)
 };
@@ -871,6 +894,7 @@ static int bmg160_data_rdy_trigger_set_state(struct iio_trigger *trig,
         else
                 ret = bmg160_setup_new_data_interrupt(data, state);
         if (ret < 0) {
+                bmg160_set_power_state(data, false);
                 mutex_unlock(&data->mutex);
                 return ret;
         }
@@ -908,10 +932,24 @@ static irqreturn_t bmg160_event_handler(int irq, void *private)
         else
                 dir = IIO_EV_DIR_FALLING;
 
-        if (ret & BMG160_ANY_MOTION_MASK)
+        if (ret & BMG160_ANY_MOTION_BIT_X)
                 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
                                                         0,
-                                                        IIO_MOD_X_OR_Y_OR_Z,
+                                                        IIO_MOD_X,
+                                                        IIO_EV_TYPE_ROC,
+                                                        dir),
+                                                        data->timestamp);
+        if (ret & BMG160_ANY_MOTION_BIT_Y)
+                iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
+                                                        0,
+                                                        IIO_MOD_Y,
+                                                        IIO_EV_TYPE_ROC,
+                                                        dir),
+                                                        data->timestamp);
+        if (ret & BMG160_ANY_MOTION_BIT_Z)
+                iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
+                                                        0,
+                                                        IIO_MOD_Z,
                                                         IIO_EV_TYPE_ROC,
                                                         dir),
                                                         data->timestamp);
@@ -1164,13 +1202,20 @@ static int bmg160_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int bmg160_runtime_suspend(struct device *dev)
 {
         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
         struct bmg160_data *data = iio_priv(indio_dev);
+        int ret;
+
+        ret = bmg160_set_mode(data, BMG160_MODE_SUSPEND);
+        if (ret < 0) {
+                dev_err(&data->client->dev, "set mode failed\n");
+                return -EAGAIN;
+        }
 
-        return bmg160_set_mode(data, BMG160_MODE_SUSPEND);
+        return 0;
 }
 
 static int bmg160_runtime_resume(struct device *dev)
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.c b/drivers/infiniband/ulp/iser/iscsi_iser.c
index f42ab14105ac..20ca6a619476 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.c
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.c
@@ -911,7 +911,7 @@ static struct scsi_host_template iscsi_iser_sht = {
         .module                 = THIS_MODULE,
         .name                   = "iSCSI Initiator over iSER",
         .queuecommand           = iscsi_queuecommand,
-        .change_queue_depth     = iscsi_change_queue_depth,
+        .change_queue_depth     = scsi_change_queue_depth,
         .sg_tablesize           = ISCSI_ISER_SG_TABLESIZE,
         .max_sectors            = 1024,
         .cmd_per_lun            = ISER_DEF_CMD_PER_LUN,
@@ -922,6 +922,7 @@ static struct scsi_host_template iscsi_iser_sht = {
         .use_clustering         = DISABLE_CLUSTERING,
         .proc_name              = "iscsi_iser",
         .this_id                = -1,
+        .track_queue_depth      = 1,
 };
 
 static struct iscsi_transport iscsi_iser_transport = {
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index 62d2a18e1b41..5461924c9f10 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -123,10 +123,15 @@ MODULE_PARM_DESC(dev_loss_tmo,
                  " if fast_io_fail_tmo has not been set. \"off\" means that"
                  " this functionality is disabled.");
 
+static unsigned ch_count;
+module_param(ch_count, uint, 0444);
+MODULE_PARM_DESC(ch_count,
+                 "Number of RDMA channels to use for communication with an SRP target. Using more than one channel improves performance if the HCA supports multiple completion vectors. The default value is the minimum of four times the number of online CPU sockets and the number of completion vectors supported by the HCA.");
+
 static void srp_add_one(struct ib_device *device);
 static void srp_remove_one(struct ib_device *device);
-static void srp_recv_completion(struct ib_cq *cq, void *target_ptr);
-static void srp_send_completion(struct ib_cq *cq, void *target_ptr);
+static void srp_recv_completion(struct ib_cq *cq, void *ch_ptr);
+static void srp_send_completion(struct ib_cq *cq, void *ch_ptr);
 static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event);
 
 static struct scsi_transport_template *ib_srp_transport_template;
@@ -262,7 +267,7 @@ static int srp_init_qp(struct srp_target_port *target,
 
         ret = ib_find_pkey(target->srp_host->srp_dev->dev,
                            target->srp_host->port,
-                           be16_to_cpu(target->path.pkey),
+                           be16_to_cpu(target->pkey),
                            &attr->pkey_index);
         if (ret)
                 goto out;
@@ -283,18 +288,23 @@ out:
         return ret;
 }
 
-static int srp_new_cm_id(struct srp_target_port *target)
+static int srp_new_cm_id(struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         struct ib_cm_id *new_cm_id;
 
         new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev,
-                                    srp_cm_handler, target);
+                                    srp_cm_handler, ch);
         if (IS_ERR(new_cm_id))
                 return PTR_ERR(new_cm_id);
 
-        if (target->cm_id)
-                ib_destroy_cm_id(target->cm_id);
-        target->cm_id = new_cm_id;
+        if (ch->cm_id)
+                ib_destroy_cm_id(ch->cm_id);
+        ch->cm_id = new_cm_id;
+        ch->path.sgid = target->sgid;
+        ch->path.dgid = target->orig_dgid;
+        ch->path.pkey = target->pkey;
+        ch->path.service_id = target->service_id;
 
         return 0;
 }
@@ -443,8 +453,44 @@ static struct srp_fr_pool *srp_alloc_fr_pool(struct srp_target_port *target)
                                   dev->max_pages_per_mr);
 }
 
-static int srp_create_target_ib(struct srp_target_port *target)
+/**
+ * srp_destroy_qp() - destroy an RDMA queue pair
+ * @ch: SRP RDMA channel.
+ *
+ * Change a queue pair into the error state and wait until all receive
+ * completions have been processed before destroying it. This avoids that
+ * the receive completion handler can access the queue pair while it is
+ * being destroyed.
+ */
+static void srp_destroy_qp(struct srp_rdma_ch *ch)
+{
+        struct srp_target_port *target = ch->target;
+        static struct ib_qp_attr attr = { .qp_state = IB_QPS_ERR };
+        static struct ib_recv_wr wr = { .wr_id = SRP_LAST_WR_ID };
+        struct ib_recv_wr *bad_wr;
+        int ret;
+
+        /* Destroying a QP and reusing ch->done is only safe if not connected */
+        WARN_ON_ONCE(target->connected);
+
+        ret = ib_modify_qp(ch->qp, &attr, IB_QP_STATE);
+        WARN_ONCE(ret, "ib_cm_init_qp_attr() returned %d\n", ret);
+        if (ret)
+                goto out;
+
+        init_completion(&ch->done);
+        ret = ib_post_recv(ch->qp, &wr, &bad_wr);
+        WARN_ONCE(ret, "ib_post_recv() returned %d\n", ret);
+        if (ret == 0)
+                wait_for_completion(&ch->done);
+
+out:
+        ib_destroy_qp(ch->qp);
+}
+
+static int srp_create_ch_ib(struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_qp_init_attr *init_attr;
         struct ib_cq *recv_cq, *send_cq;
@@ -458,15 +504,16 @@ static int srp_create_target_ib(struct srp_target_port *target)
         if (!init_attr)
                 return -ENOMEM;
 
-        recv_cq = ib_create_cq(dev->dev, srp_recv_completion, NULL, target,
-                               target->queue_size, target->comp_vector);
+        /* + 1 for SRP_LAST_WR_ID */
+        recv_cq = ib_create_cq(dev->dev, srp_recv_completion, NULL, ch,
+                               target->queue_size + 1, ch->comp_vector);
         if (IS_ERR(recv_cq)) {
                 ret = PTR_ERR(recv_cq);
                 goto err;
         }
 
-        send_cq = ib_create_cq(dev->dev, srp_send_completion, NULL, target,
-                               m * target->queue_size, target->comp_vector);
+        send_cq = ib_create_cq(dev->dev, srp_send_completion, NULL, ch,
+                               m * target->queue_size, ch->comp_vector);
         if (IS_ERR(send_cq)) {
                 ret = PTR_ERR(send_cq);
                 goto err_recv_cq;
@@ -476,7 +523,7 @@ static int srp_create_target_ib(struct srp_target_port *target)
 
         init_attr->event_handler       = srp_qp_event;
         init_attr->cap.max_send_wr     = m * target->queue_size;
-        init_attr->cap.max_recv_wr     = target->queue_size;
+        init_attr->cap.max_recv_wr     = target->queue_size + 1;
         init_attr->cap.max_recv_sge    = 1;
         init_attr->cap.max_send_sge    = 1;
         init_attr->sq_sig_type         = IB_SIGNAL_REQ_WR;
@@ -502,9 +549,9 @@ static int srp_create_target_ib(struct srp_target_port *target)
                                      "FR pool allocation failed (%d)\n", ret);
                         goto err_qp;
                 }
-                if (target->fr_pool)
-                        srp_destroy_fr_pool(target->fr_pool);
-                target->fr_pool = fr_pool;
+                if (ch->fr_pool)
+                        srp_destroy_fr_pool(ch->fr_pool);
+                ch->fr_pool = fr_pool;
         } else if (!dev->use_fast_reg && dev->has_fmr) {
                 fmr_pool = srp_alloc_fmr_pool(target);
                 if (IS_ERR(fmr_pool)) {
@@ -513,21 +560,21 @@ static int srp_create_target_ib(struct srp_target_port *target)
                                      "FMR pool allocation failed (%d)\n", ret);
                         goto err_qp;
                 }
-                if (target->fmr_pool)
-                        ib_destroy_fmr_pool(target->fmr_pool);
-                target->fmr_pool = fmr_pool;
+                if (ch->fmr_pool)
+                        ib_destroy_fmr_pool(ch->fmr_pool);
+                ch->fmr_pool = fmr_pool;
         }
 
-        if (target->qp)
-                ib_destroy_qp(target->qp);
-        if (target->recv_cq)
-                ib_destroy_cq(target->recv_cq);
-        if (target->send_cq)
-                ib_destroy_cq(target->send_cq);
+        if (ch->qp)
+                srp_destroy_qp(ch);
+        if (ch->recv_cq)
+                ib_destroy_cq(ch->recv_cq);
+        if (ch->send_cq)
+                ib_destroy_cq(ch->send_cq);
 
-        target->qp = qp;
-        target->recv_cq = recv_cq;
-        target->send_cq = send_cq;
+        ch->qp = qp;
+        ch->recv_cq = recv_cq;
+        ch->send_cq = send_cq;
 
         kfree(init_attr);
         return 0;
@@ -548,93 +595,117 @@ err:
 
 /*
  * Note: this function may be called without srp_alloc_iu_bufs() having been
- * invoked. Hence the target->[rt]x_ring checks.
+ * invoked. Hence the ch->[rt]x_ring checks.
  */
-static void srp_free_target_ib(struct srp_target_port *target)
+static void srp_free_ch_ib(struct srp_target_port *target,
+                           struct srp_rdma_ch *ch)
 {
         struct srp_device *dev = target->srp_host->srp_dev;
         int i;
 
+        if (!ch->target)
+                return;
+
+        if (ch->cm_id) {
+                ib_destroy_cm_id(ch->cm_id);
+                ch->cm_id = NULL;
+        }
+
+        /* If srp_new_cm_id() succeeded but srp_create_ch_ib() not, return. */
+        if (!ch->qp)
+                return;
+
         if (dev->use_fast_reg) {
-                if (target->fr_pool)
-                        srp_destroy_fr_pool(target->fr_pool);
+                if (ch->fr_pool)
+                        srp_destroy_fr_pool(ch->fr_pool);
         } else {
-                if (target->fmr_pool)
-                        ib_destroy_fmr_pool(target->fmr_pool);
+                if (ch->fmr_pool)
+                        ib_destroy_fmr_pool(ch->fmr_pool);
         }
-        ib_destroy_qp(target->qp);
-        ib_destroy_cq(target->send_cq);
-        ib_destroy_cq(target->recv_cq);
+        srp_destroy_qp(ch);
+        ib_destroy_cq(ch->send_cq);
+        ib_destroy_cq(ch->recv_cq);
+
+        /*
+         * Avoid that the SCSI error handler tries to use this channel after
+         * it has been freed. The SCSI error handler can namely continue
+         * trying to perform recovery actions after scsi_remove_host()
+         * returned.
+         */
+        ch->target = NULL;
 
-        target->qp = NULL;
-        target->send_cq = target->recv_cq = NULL;
+        ch->qp = NULL;
+        ch->send_cq = ch->recv_cq = NULL;
 
-        if (target->rx_ring) {
+        if (ch->rx_ring) {
                 for (i = 0; i < target->queue_size; ++i)
-                        srp_free_iu(target->srp_host, target->rx_ring[i]);
-                kfree(target->rx_ring);
-                target->rx_ring = NULL;
+                        srp_free_iu(target->srp_host, ch->rx_ring[i]);
+                kfree(ch->rx_ring);
+                ch->rx_ring = NULL;
         }
-        if (target->tx_ring) {
+        if (ch->tx_ring) {
                 for (i = 0; i < target->queue_size; ++i)
-                        srp_free_iu(target->srp_host, target->tx_ring[i]);
-                kfree(target->tx_ring);
-                target->tx_ring = NULL;
+                        srp_free_iu(target->srp_host, ch->tx_ring[i]);
+                kfree(ch->tx_ring);
+                ch->tx_ring = NULL;
         }
 }
 
 static void srp_path_rec_completion(int status,
                                     struct ib_sa_path_rec *pathrec,
-                                    void *target_ptr)
+                                    void *ch_ptr)
 {
-        struct srp_target_port *target = target_ptr;
+        struct srp_rdma_ch *ch = ch_ptr;
+        struct srp_target_port *target = ch->target;
 
-        target->status = status;
+        ch->status = status;
         if (status)
                 shost_printk(KERN_ERR, target->scsi_host,
                              PFX "Got failed path rec status %d\n", status);
         else
-                target->path = *pathrec;
-        complete(&target->done);
+                ch->path = *pathrec;
+        complete(&ch->done);
 }
 
-static int srp_lookup_path(struct srp_target_port *target)
+static int srp_lookup_path(struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         int ret;
 
-        target->path.numb_path = 1;
-
-        init_completion(&target->done);
-
-        target->path_query_id = ib_sa_path_rec_get(&srp_sa_client,
-                                                   target->srp_host->srp_dev->dev,
-                                                   target->srp_host->port,
-                                                   &target->path,
-                                                   IB_SA_PATH_REC_SERVICE_ID    |
-                                                   IB_SA_PATH_REC_DGID          |
-                                                   IB_SA_PATH_REC_SGID          |
-                                                   IB_SA_PATH_REC_NUMB_PATH     |
-                                                   IB_SA_PATH_REC_PKEY,
-                                                   SRP_PATH_REC_TIMEOUT_MS,
-                                                   GFP_KERNEL,
-                                                   srp_path_rec_completion,
-                                                   target, &target->path_query);
-        if (target->path_query_id < 0)
-                return target->path_query_id;
-
-        ret = wait_for_completion_interruptible(&target->done);
+        ch->path.numb_path = 1;
+
+        init_completion(&ch->done);
+
+        ch->path_query_id = ib_sa_path_rec_get(&srp_sa_client,
+                                               target->srp_host->srp_dev->dev,
+                                               target->srp_host->port,
+                                               &ch->path,
+                                               IB_SA_PATH_REC_SERVICE_ID |
+                                               IB_SA_PATH_REC_DGID       |
+                                               IB_SA_PATH_REC_SGID       |
+                                               IB_SA_PATH_REC_NUMB_PATH  |
+                                               IB_SA_PATH_REC_PKEY,
+                                               SRP_PATH_REC_TIMEOUT_MS,
+                                               GFP_KERNEL,
+                                               srp_path_rec_completion,
+                                               ch, &ch->path_query);
+        if (ch->path_query_id < 0)
+                return ch->path_query_id;
+
+        ret = wait_for_completion_interruptible(&ch->done);
         if (ret < 0)
                 return ret;
 
-        if (target->status < 0)
+        if (ch->status < 0)
                 shost_printk(KERN_WARNING, target->scsi_host,
                              PFX "Path record query failed\n");
 
-        return target->status;
+        return ch->status;
 }
 
-static int srp_send_req(struct srp_target_port *target)
+static int srp_send_req(struct srp_rdma_ch *ch, bool multich)
 {
+        struct srp_target_port *target = ch->target;
         struct {
                 struct ib_cm_req_param param;
                 struct srp_login_req   priv;
@@ -645,11 +716,11 @@ static int srp_send_req(struct srp_target_port *target)
         if (!req)
                 return -ENOMEM;
 
-        req->param.primary_path               = &target->path;
+        req->param.primary_path               = &ch->path;
         req->param.alternate_path             = NULL;
         req->param.service_id                 = target->service_id;
-        req->param.qp_num                     = target->qp->qp_num;
-        req->param.qp_type                    = target->qp->qp_type;
+        req->param.qp_num                     = ch->qp->qp_num;
+        req->param.qp_type                    = ch->qp->qp_type;
         req->param.private_data               = &req->priv;
         req->param.private_data_len           = sizeof req->priv;
         req->param.flow_control               = 1;
@@ -673,6 +744,8 @@ static int srp_send_req(struct srp_target_port *target)
         req->priv.req_it_iu_len = cpu_to_be32(target->max_iu_len);
         req->priv.req_buf_fmt   = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
                                               SRP_BUF_FORMAT_INDIRECT);
+        req->priv.req_flags     = (multich ? SRP_MULTICHAN_MULTI :
+                                   SRP_MULTICHAN_SINGLE);
         /*
          * In the published SRP specification (draft rev. 16a), the
          * port identifier format is 8 bytes of ID extension followed
@@ -684,7 +757,7 @@ static int srp_send_req(struct srp_target_port *target)
          */
         if (target->io_class == SRP_REV10_IB_IO_CLASS) {
                 memcpy(req->priv.initiator_port_id,
-                       &target->path.sgid.global.interface_id, 8);
+                       &target->sgid.global.interface_id, 8);
                 memcpy(req->priv.initiator_port_id + 8,
                        &target->initiator_ext, 8);
                 memcpy(req->priv.target_port_id,     &target->ioc_guid, 8);
@@ -693,7 +766,7 @@ static int srp_send_req(struct srp_target_port *target)
                 memcpy(req->priv.initiator_port_id,
                        &target->initiator_ext, 8);
                 memcpy(req->priv.initiator_port_id + 8,
-                       &target->path.sgid.global.interface_id, 8);
+                       &target->sgid.global.interface_id, 8);
                 memcpy(req->priv.target_port_id,     &target->id_ext, 8);
                 memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8);
         }
@@ -713,7 +786,7 @@ static int srp_send_req(struct srp_target_port *target)
                        &target->srp_host->srp_dev->dev->node_guid, 8);
         }
 
-        status = ib_send_cm_req(target->cm_id, &req->param);
+        status = ib_send_cm_req(ch->cm_id, &req->param);
 
         kfree(req);
 
@@ -754,28 +827,35 @@ static bool srp_change_conn_state(struct srp_target_port *target,
 
 static void srp_disconnect_target(struct srp_target_port *target)
 {
+        struct srp_rdma_ch *ch;
+        int i;
+
         if (srp_change_conn_state(target, false)) {
                 /* XXX should send SRP_I_LOGOUT request */
 
-                if (ib_send_cm_dreq(target->cm_id, NULL, 0)) {
-                        shost_printk(KERN_DEBUG, target->scsi_host,
-                                     PFX "Sending CM DREQ failed\n");
+                for (i = 0; i < target->ch_count; i++) {
+                        ch = &target->ch[i];
+                        if (ch->cm_id && ib_send_cm_dreq(ch->cm_id, NULL, 0)) {
+                                shost_printk(KERN_DEBUG, target->scsi_host,
+                                             PFX "Sending CM DREQ failed\n");
+                        }
                 }
         }
 }
 
-static void srp_free_req_data(struct srp_target_port *target)
+static void srp_free_req_data(struct srp_target_port *target,
+                              struct srp_rdma_ch *ch)
 {
         struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_device *ibdev = dev->dev;
         struct srp_request *req;
         int i;
 
-        if (!target->req_ring)
+        if (!ch->target || !ch->req_ring)
                 return;
 
         for (i = 0; i < target->req_ring_size; ++i) {
-                req = &target->req_ring[i];
+                req = &ch->req_ring[i];
                 if (dev->use_fast_reg)
                         kfree(req->fr_list);
                 else
@@ -789,12 +869,13 @@ static void srp_free_req_data(struct srp_target_port *target)
                 kfree(req->indirect_desc);
         }
 
-        kfree(target->req_ring);
-        target->req_ring = NULL;
+        kfree(ch->req_ring);
+        ch->req_ring = NULL;
 }
 
-static int srp_alloc_req_data(struct srp_target_port *target)
+static int srp_alloc_req_data(struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_device *srp_dev = target->srp_host->srp_dev;
         struct ib_device *ibdev = srp_dev->dev;
         struct srp_request *req;
@@ -802,15 +883,13 @@ static int srp_alloc_req_data(struct srp_target_port *target)
         dma_addr_t dma_addr;
         int i, ret = -ENOMEM;
 
-        INIT_LIST_HEAD(&target->free_reqs);
-
-        target->req_ring = kzalloc(target->req_ring_size *
-                                   sizeof(*target->req_ring), GFP_KERNEL);
-        if (!target->req_ring)
+        ch->req_ring = kcalloc(target->req_ring_size, sizeof(*ch->req_ring),
+                               GFP_KERNEL);
+        if (!ch->req_ring)
                 goto out;
 
         for (i = 0; i < target->req_ring_size; ++i) {
-                req = &target->req_ring[i];
+                req = &ch->req_ring[i];
                 mr_list = kmalloc(target->cmd_sg_cnt * sizeof(void *),
                                   GFP_KERNEL);
                 if (!mr_list)
@@ -834,8 +913,6 @@ static int srp_alloc_req_data(struct srp_target_port *target)
                         goto out;
 
                 req->indirect_dma_addr = dma_addr;
-                req->index = i;
-                list_add_tail(&req->list, &target->free_reqs);
         }
         ret = 0;
 
@@ -860,6 +937,9 @@ static void srp_del_scsi_host_attr(struct Scsi_Host *shost)
 
 static void srp_remove_target(struct srp_target_port *target)
 {
+        struct srp_rdma_ch *ch;
+        int i;
+
         WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED);
 
         srp_del_scsi_host_attr(target->scsi_host);
@@ -868,11 +948,18 @@ static void srp_remove_target(struct srp_target_port *target)
         scsi_remove_host(target->scsi_host);
         srp_stop_rport_timers(target->rport);
         srp_disconnect_target(target);
-        ib_destroy_cm_id(target->cm_id);
-        srp_free_target_ib(target);
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                srp_free_ch_ib(target, ch);
+        }
         cancel_work_sync(&target->tl_err_work);
         srp_rport_put(target->rport);
-        srp_free_req_data(target);
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                srp_free_req_data(target, ch);
+        }
+        kfree(target->ch);
+        target->ch = NULL;
 
         spin_lock(&target->srp_host->target_lock);
         list_del(&target->list);
@@ -898,25 +985,25 @@ static void srp_rport_delete(struct srp_rport *rport)
         srp_queue_remove_work(target);
 }
 
-static int srp_connect_target(struct srp_target_port *target)
+static int srp_connect_ch(struct srp_rdma_ch *ch, bool multich)
 {
-        int retries = 3;
+        struct srp_target_port *target = ch->target;
         int ret;
 
-        WARN_ON_ONCE(target->connected);
+        WARN_ON_ONCE(!multich && target->connected);
 
         target->qp_in_error = false;
 
-        ret = srp_lookup_path(target);
+        ret = srp_lookup_path(ch);
         if (ret)
                 return ret;
 
         while (1) {
-                init_completion(&target->done);
-                ret = srp_send_req(target);
+                init_completion(&ch->done);
+                ret = srp_send_req(ch, multich);
                 if (ret)
                         return ret;
-                ret = wait_for_completion_interruptible(&target->done);
+                ret = wait_for_completion_interruptible(&ch->done);
                 if (ret < 0)
                         return ret;
 
@@ -926,13 +1013,13 @@ static int srp_connect_target(struct srp_target_port *target)
                  * back, or SRP_DLID_REDIRECT if we get a lid/qp
                  * redirect REJ back.
                  */
-                switch (target->status) {
+                switch (ch->status) {
                 case 0:
                         srp_change_conn_state(target, true);
                         return 0;
 
                 case SRP_PORT_REDIRECT:
-                        ret = srp_lookup_path(target);
+                        ret = srp_lookup_path(ch);
                         if (ret)
                                 return ret;
                         break;
@@ -941,27 +1028,18 @@ static int srp_connect_target(struct srp_target_port *target)
                         break;
 
                 case SRP_STALE_CONN:
-                        /* Our current CM id was stale, and is now in timewait.
-                         * Try to reconnect with a new one.
-                         */
-                        if (!retries-- || srp_new_cm_id(target)) {
-                                shost_printk(KERN_ERR, target->scsi_host, PFX
-                                             "giving up on stale connection\n");
-                                target->status = -ECONNRESET;
-                                return target->status;
-                        }
-
                         shost_printk(KERN_ERR, target->scsi_host, PFX
-                                     "retrying stale connection\n");
-                        break;
+                                     "giving up on stale connection\n");
+                        ch->status = -ECONNRESET;
+                        return ch->status;
 
                 default:
-                        return target->status;
+                        return ch->status;
                 }
         }
 }
 
-static int srp_inv_rkey(struct srp_target_port *target, u32 rkey)
+static int srp_inv_rkey(struct srp_rdma_ch *ch, u32 rkey)
 {
         struct ib_send_wr *bad_wr;
         struct ib_send_wr wr = {
@@ -973,13 +1051,14 @@ static int srp_inv_rkey(struct srp_target_port *target, u32 rkey)
                 .ex.invalidate_rkey = rkey,
         };
 
-        return ib_post_send(target->qp, &wr, &bad_wr);
+        return ib_post_send(ch->qp, &wr, &bad_wr);
 }
 
 static void srp_unmap_data(struct scsi_cmnd *scmnd,
-                           struct srp_target_port *target,
+                           struct srp_rdma_ch *ch,
                            struct srp_request *req)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_device *ibdev = dev->dev;
         int i, res;
@@ -993,7 +1072,7 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd,
                 struct srp_fr_desc **pfr;
 
                 for (i = req->nmdesc, pfr = req->fr_list; i > 0; i--, pfr++) {
-                        res = srp_inv_rkey(target, (*pfr)->mr->rkey);
+                        res = srp_inv_rkey(ch, (*pfr)->mr->rkey);
                         if (res < 0) {
                                 shost_printk(KERN_ERR, target->scsi_host, PFX
                                   "Queueing INV WR for rkey %#x failed (%d)\n",
@@ -1003,7 +1082,7 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd,
                         }
                 }
                 if (req->nmdesc)
-                        srp_fr_pool_put(target->fr_pool, req->fr_list,
+                        srp_fr_pool_put(ch->fr_pool, req->fr_list,
                                         req->nmdesc);
         } else {
                 struct ib_pool_fmr **pfmr;
@@ -1018,7 +1097,7 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd,
 
 /**
  * srp_claim_req - Take ownership of the scmnd associated with a request.
- * @target: SRP target port.
+ * @ch: SRP RDMA channel.
  * @req: SRP request.
  * @sdev: If not NULL, only take ownership for this SCSI device.
  * @scmnd: If NULL, take ownership of @req->scmnd. If not NULL, only take
@@ -1027,14 +1106,14 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd,
  * Return value:
  * Either NULL or a pointer to the SCSI command the caller became owner of.
  */
-static struct scsi_cmnd *srp_claim_req(struct srp_target_port *target,
+static struct scsi_cmnd *srp_claim_req(struct srp_rdma_ch *ch,
                                        struct srp_request *req,
                                        struct scsi_device *sdev,
                                        struct scsi_cmnd *scmnd)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&target->lock, flags);
+        spin_lock_irqsave(&ch->lock, flags);
         if (req->scmnd &&
             (!sdev || req->scmnd->device == sdev) &&
             (!scmnd || req->scmnd == scmnd)) {
@@ -1043,40 +1122,37 @@ static struct scsi_cmnd *srp_claim_req(struct srp_target_port *target,
         } else {
                 scmnd = NULL;
         }
-        spin_unlock_irqrestore(&target->lock, flags);
+        spin_unlock_irqrestore(&ch->lock, flags);
 
         return scmnd;
 }
 
 /**
  * srp_free_req() - Unmap data and add request to the free request list.
- * @target: SRP target port.
+ * @ch:     SRP RDMA channel.
  * @req:    Request to be freed.
  * @scmnd:  SCSI command associated with @req.
  * @req_lim_delta: Amount to be added to @target->req_lim.
  */
-static void srp_free_req(struct srp_target_port *target,
-                         struct srp_request *req, struct scsi_cmnd *scmnd,
-                         s32 req_lim_delta)
+static void srp_free_req(struct srp_rdma_ch *ch, struct srp_request *req,
+                         struct scsi_cmnd *scmnd, s32 req_lim_delta)
 {
         unsigned long flags;
 
-        srp_unmap_data(scmnd, target, req);
+        srp_unmap_data(scmnd, ch, req);
 
-        spin_lock_irqsave(&target->lock, flags);
-        target->req_lim += req_lim_delta;
-        list_add_tail(&req->list, &target->free_reqs);
-        spin_unlock_irqrestore(&target->lock, flags);
+        spin_lock_irqsave(&ch->lock, flags);
+        ch->req_lim += req_lim_delta;
+        spin_unlock_irqrestore(&ch->lock, flags);
 }
 
-static void srp_finish_req(struct srp_target_port *target,
-                           struct srp_request *req, struct scsi_device *sdev,
-                           int result)
+static void srp_finish_req(struct srp_rdma_ch *ch, struct srp_request *req,
+                           struct scsi_device *sdev, int result)
 {
-        struct scsi_cmnd *scmnd = srp_claim_req(target, req, sdev, NULL);
+        struct scsi_cmnd *scmnd = srp_claim_req(ch, req, sdev, NULL);
 
         if (scmnd) {
-                srp_free_req(target, req, scmnd, 0);
+                srp_free_req(ch, req, scmnd, 0);
                 scmnd->result = result;
                 scmnd->scsi_done(scmnd);
         }
@@ -1085,9 +1161,10 @@ static void srp_finish_req(struct srp_target_port *target,
 static void srp_terminate_io(struct srp_rport *rport)
 {
         struct srp_target_port *target = rport->lld_data;
+        struct srp_rdma_ch *ch;
         struct Scsi_Host *shost = target->scsi_host;
         struct scsi_device *sdev;
-        int i;
+        int i, j;
 
         /*
          * Invoking srp_terminate_io() while srp_queuecommand() is running
@@ -1096,9 +1173,15 @@ static void srp_terminate_io(struct srp_rport *rport)
         shost_for_each_device(sdev, shost)
                 WARN_ON_ONCE(sdev->request_queue->request_fn_active);
 
-        for (i = 0; i < target->req_ring_size; ++i) {
-                struct srp_request *req = &target->req_ring[i];
-                srp_finish_req(target, req, NULL, DID_TRANSPORT_FAILFAST << 16);
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+
+                for (j = 0; j < target->req_ring_size; ++j) {
+                        struct srp_request *req = &ch->req_ring[j];
+
+                        srp_finish_req(ch, req, NULL,
+                                       DID_TRANSPORT_FAILFAST << 16);
+                }
         }
 }
 
@@ -1114,34 +1197,61 @@ static void srp_terminate_io(struct srp_rport *rport)
 static int srp_rport_reconnect(struct srp_rport *rport)
 {
         struct srp_target_port *target = rport->lld_data;
-        int i, ret;
+        struct srp_rdma_ch *ch;
+        int i, j, ret = 0;
+        bool multich = false;
 
         srp_disconnect_target(target);
+
+        if (target->state == SRP_TARGET_SCANNING)
+                return -ENODEV;
+
         /*
          * Now get a new local CM ID so that we avoid confusing the target in
          * case things are really fouled up. Doing so also ensures that all CM
          * callbacks will have finished before a new QP is allocated.
          */
-        ret = srp_new_cm_id(target);
-
-        for (i = 0; i < target->req_ring_size; ++i) {
-                struct srp_request *req = &target->req_ring[i];
-                srp_finish_req(target, req, NULL, DID_RESET << 16);
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                if (!ch->target)
+                        break;
+                ret += srp_new_cm_id(ch);
         }
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                if (!ch->target)
+                        break;
+                for (j = 0; j < target->req_ring_size; ++j) {
+                        struct srp_request *req = &ch->req_ring[j];
 
-        /*
-         * Whether or not creating a new CM ID succeeded, create a new
-         * QP. This guarantees that all callback functions for the old QP have
-         * finished before any send requests are posted on the new QP.
-         */
-        ret += srp_create_target_ib(target);
-
-        INIT_LIST_HEAD(&target->free_tx);
-        for (i = 0; i < target->queue_size; ++i)
-                list_add(&target->tx_ring[i]->list, &target->free_tx);
+                        srp_finish_req(ch, req, NULL, DID_RESET << 16);
+                }
+        }
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                if (!ch->target)
+                        break;
+                /*
+                 * Whether or not creating a new CM ID succeeded, create a new
+                 * QP. This guarantees that all completion callback function
+                 * invocations have finished before request resetting starts.
+                 */
+                ret += srp_create_ch_ib(ch);
 
-        if (ret == 0)
-                ret = srp_connect_target(target);
+                INIT_LIST_HEAD(&ch->free_tx);
+                for (j = 0; j < target->queue_size; ++j)
+                        list_add(&ch->tx_ring[j]->list, &ch->free_tx);
+        }
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                if (ret || !ch->target) {
+                        if (i > 1)
+                                ret = 0;
+                        break;
+                }
+                ret = srp_connect_ch(ch, multich);
+                multich = true;
+        }
 
         if (ret == 0)
                 shost_printk(KERN_INFO, target->scsi_host,
@@ -1165,12 +1275,12 @@ static void srp_map_desc(struct srp_map_state *state, dma_addr_t dma_addr,
 }
 
 static int srp_map_finish_fmr(struct srp_map_state *state,
-                              struct srp_target_port *target)
+                              struct srp_rdma_ch *ch)
 {
         struct ib_pool_fmr *fmr;
         u64 io_addr = 0;
 
-        fmr = ib_fmr_pool_map_phys(target->fmr_pool, state->pages,
+        fmr = ib_fmr_pool_map_phys(ch->fmr_pool, state->pages,
                                    state->npages, io_addr);
         if (IS_ERR(fmr))
                 return PTR_ERR(fmr);
@@ -1184,15 +1294,16 @@ static int srp_map_finish_fmr(struct srp_map_state *state,
 }
 
 static int srp_map_finish_fr(struct srp_map_state *state,
-                             struct srp_target_port *target)
+                             struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_send_wr *bad_wr;
         struct ib_send_wr wr;
         struct srp_fr_desc *desc;
         u32 rkey;
 
-        desc = srp_fr_pool_get(target->fr_pool);
+        desc = srp_fr_pool_get(ch->fr_pool);
         if (!desc)
                 return -ENOMEM;
 
@@ -1221,12 +1332,13 @@ static int srp_map_finish_fr(struct srp_map_state *state,
         srp_map_desc(state, state->base_dma_addr, state->dma_len,
                      desc->mr->rkey);
 
-        return ib_post_send(target->qp, &wr, &bad_wr);
+        return ib_post_send(ch->qp, &wr, &bad_wr);
 }
 
 static int srp_finish_mapping(struct srp_map_state *state,
-                              struct srp_target_port *target)
+                              struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         int ret = 0;
 
         if (state->npages == 0)
@@ -1237,8 +1349,8 @@ static int srp_finish_mapping(struct srp_map_state *state,
                              target->rkey);
         else
                 ret = target->srp_host->srp_dev->use_fast_reg ?
-                        srp_map_finish_fr(state, target) :
-                        srp_map_finish_fmr(state, target);
+                        srp_map_finish_fr(state, ch) :
+                        srp_map_finish_fmr(state, ch);
 
         if (ret == 0) {
                 state->npages = 0;
@@ -1258,10 +1370,11 @@ static void srp_map_update_start(struct srp_map_state *state,
 }
 
 static int srp_map_sg_entry(struct srp_map_state *state,
-                            struct srp_target_port *target,
+                            struct srp_rdma_ch *ch,
                             struct scatterlist *sg, int sg_index,
                             bool use_mr)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_device *ibdev = dev->dev;
         dma_addr_t dma_addr = ib_sg_dma_address(ibdev, sg);
@@ -1290,7 +1403,7 @@ static int srp_map_sg_entry(struct srp_map_state *state,
          */
         if ((!dev->use_fast_reg && dma_addr & ~dev->mr_page_mask) ||
             dma_len > dev->mr_max_size) {
-                ret = srp_finish_mapping(state, target);
+                ret = srp_finish_mapping(state, ch);
                 if (ret)
                         return ret;
 
@@ -1311,7 +1424,7 @@ static int srp_map_sg_entry(struct srp_map_state *state,
         while (dma_len) {
                 unsigned offset = dma_addr & ~dev->mr_page_mask;
                 if (state->npages == dev->max_pages_per_mr || offset != 0) {
-                        ret = srp_finish_mapping(state, target);
+                        ret = srp_finish_mapping(state, ch);
                         if (ret)
                                 return ret;
 
@@ -1335,17 +1448,18 @@ static int srp_map_sg_entry(struct srp_map_state *state,
          */
         ret = 0;
         if (len != dev->mr_page_size) {
-                ret = srp_finish_mapping(state, target);
+                ret = srp_finish_mapping(state, ch);
                 if (!ret)
                         srp_map_update_start(state, NULL, 0, 0);
         }
         return ret;
 }
 
-static int srp_map_sg(struct srp_map_state *state,
-                      struct srp_target_port *target, struct srp_request *req,
-                      struct scatterlist *scat, int count)
+static int srp_map_sg(struct srp_map_state *state, struct srp_rdma_ch *ch,
+                      struct srp_request *req, struct scatterlist *scat,
+                      int count)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_device *ibdev = dev->dev;
         struct scatterlist *sg;
@@ -1356,14 +1470,14 @@ static int srp_map_sg(struct srp_map_state *state,
         state->pages    = req->map_page;
         if (dev->use_fast_reg) {
                 state->next_fr = req->fr_list;
-                use_mr = !!target->fr_pool;
+                use_mr = !!ch->fr_pool;
         } else {
                 state->next_fmr = req->fmr_list;
-                use_mr = !!target->fmr_pool;
+                use_mr = !!ch->fmr_pool;
         }
 
         for_each_sg(scat, sg, count, i) {
-                if (srp_map_sg_entry(state, target, sg, i, use_mr)) {
+                if (srp_map_sg_entry(state, ch, sg, i, use_mr)) {
                         /*
                          * Memory registration failed, so backtrack to the
                          * first unmapped entry and continue on without using
@@ -1385,7 +1499,7 @@ backtrack:
                 }
         }
 
-        if (use_mr && srp_finish_mapping(state, target))
+        if (use_mr && srp_finish_mapping(state, ch))
                 goto backtrack;
 
         req->nmdesc = state->nmdesc;
@@ -1393,9 +1507,10 @@ backtrack:
         return 0;
 }
 
-static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target,
+static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_rdma_ch *ch,
                         struct srp_request *req)
 {
+        struct srp_target_port *target = ch->target;
         struct scatterlist *scat;
         struct srp_cmd *cmd = req->cmd->buf;
         int len, nents, count;
@@ -1457,7 +1572,7 @@ static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target,
                                    target->indirect_size, DMA_TO_DEVICE);
 
         memset(&state, 0, sizeof(state));
-        srp_map_sg(&state, target, req, scat, count);
+        srp_map_sg(&state, ch, req, scat, count);
 
         /* We've mapped the request, now pull as much of the indirect
          * descriptor table as we can into the command buffer. If this
@@ -1518,20 +1633,20 @@ map_complete:
 /*
  * Return an IU and possible credit to the free pool
  */
-static void srp_put_tx_iu(struct srp_target_port *target, struct srp_iu *iu,
+static void srp_put_tx_iu(struct srp_rdma_ch *ch, struct srp_iu *iu,
                           enum srp_iu_type iu_type)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&target->lock, flags);
-        list_add(&iu->list, &target->free_tx);
+        spin_lock_irqsave(&ch->lock, flags);
+        list_add(&iu->list, &ch->free_tx);
         if (iu_type != SRP_IU_RSP)
-                ++target->req_lim;
-        spin_unlock_irqrestore(&target->lock, flags);
+                ++ch->req_lim;
+        spin_unlock_irqrestore(&ch->lock, flags);
 }
 
 /*
- * Must be called with target->lock held to protect req_lim and free_tx.
+ * Must be called with ch->lock held to protect req_lim and free_tx.
  * If IU is not sent, it must be returned using srp_put_tx_iu().
  *
  * Note:
@@ -1543,35 +1658,36 @@ static void srp_put_tx_iu(struct srp_target_port *target, struct srp_iu *iu,
  * - SRP_IU_RSP: 1, since a conforming SRP target never sends more than
  *   one unanswered SRP request to an initiator.
  */
-static struct srp_iu *__srp_get_tx_iu(struct srp_target_port *target,
+static struct srp_iu *__srp_get_tx_iu(struct srp_rdma_ch *ch,
                                       enum srp_iu_type iu_type)
 {
+        struct srp_target_port *target = ch->target;
         s32 rsv = (iu_type == SRP_IU_TSK_MGMT) ? 0 : SRP_TSK_MGMT_SQ_SIZE;
         struct srp_iu *iu;
 
-        srp_send_completion(target->send_cq, target);
+        srp_send_completion(ch->send_cq, ch);
 
-        if (list_empty(&target->free_tx))
+        if (list_empty(&ch->free_tx))
                 return NULL;
 
         /* Initiator responses to target requests do not consume credits */
         if (iu_type != SRP_IU_RSP) {
-                if (target->req_lim <= rsv) {
+                if (ch->req_lim <= rsv) {
                         ++target->zero_req_lim;
                         return NULL;
                 }
 
-                --target->req_lim;
+                --ch->req_lim;
         }
 
-        iu = list_first_entry(&target->free_tx, struct srp_iu, list);
+        iu = list_first_entry(&ch->free_tx, struct srp_iu, list);
         list_del(&iu->list);
         return iu;
 }
 
-static int srp_post_send(struct srp_target_port *target,
-                         struct srp_iu *iu, int len)
+static int srp_post_send(struct srp_rdma_ch *ch, struct srp_iu *iu, int len)
 {
+        struct srp_target_port *target = ch->target;
         struct ib_sge list;
         struct ib_send_wr wr, *bad_wr;
 
@@ -1586,11 +1702,12 @@ static int srp_post_send(struct srp_target_port *target,
         wr.opcode     = IB_WR_SEND;
         wr.send_flags = IB_SEND_SIGNALED;
 
-        return ib_post_send(target->qp, &wr, &bad_wr);
+        return ib_post_send(ch->qp, &wr, &bad_wr);
 }
 
-static int srp_post_recv(struct srp_target_port *target, struct srp_iu *iu)
+static int srp_post_recv(struct srp_rdma_ch *ch, struct srp_iu *iu)
 {
+        struct srp_target_port *target = ch->target;
         struct ib_recv_wr wr, *bad_wr;
         struct ib_sge list;
 
@@ -1603,35 +1720,39 @@ static int srp_post_recv(struct srp_target_port *target, struct srp_iu *iu)
         wr.sg_list  = &list;
         wr.num_sge  = 1;
 
-        return ib_post_recv(target->qp, &wr, &bad_wr);
+        return ib_post_recv(ch->qp, &wr, &bad_wr);
 }
 
-static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
+static void srp_process_rsp(struct srp_rdma_ch *ch, struct srp_rsp *rsp)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_request *req;
         struct scsi_cmnd *scmnd;
         unsigned long flags;
 
         if (unlikely(rsp->tag & SRP_TAG_TSK_MGMT)) {
-                spin_lock_irqsave(&target->lock, flags);
-                target->req_lim += be32_to_cpu(rsp->req_lim_delta);
-                spin_unlock_irqrestore(&target->lock, flags);
+                spin_lock_irqsave(&ch->lock, flags);
+                ch->req_lim += be32_to_cpu(rsp->req_lim_delta);
+                spin_unlock_irqrestore(&ch->lock, flags);
 
-                target->tsk_mgmt_status = -1;
+                ch->tsk_mgmt_status = -1;
                 if (be32_to_cpu(rsp->resp_data_len) >= 4)
-                        target->tsk_mgmt_status = rsp->data[3];
-                complete(&target->tsk_mgmt_done);
+                        ch->tsk_mgmt_status = rsp->data[3];
+                complete(&ch->tsk_mgmt_done);
         } else {
-                req = &target->req_ring[rsp->tag];
-                scmnd = srp_claim_req(target, req, NULL, NULL);
+                scmnd = scsi_host_find_tag(target->scsi_host, rsp->tag);
+                if (scmnd) {
+                        req = (void *)scmnd->host_scribble;
+                        scmnd = srp_claim_req(ch, req, NULL, scmnd);
+                }
                 if (!scmnd) {
                         shost_printk(KERN_ERR, target->scsi_host,
-                                     "Null scmnd for RSP w/tag %016llx\n",
-                                     (unsigned long long) rsp->tag);
+                                     "Null scmnd for RSP w/tag %#016llx received on ch %td / QP %#x\n",
+                                     rsp->tag, ch - target->ch, ch->qp->qp_num);
 
-                        spin_lock_irqsave(&target->lock, flags);
-                        target->req_lim += be32_to_cpu(rsp->req_lim_delta);
-                        spin_unlock_irqrestore(&target->lock, flags);
+                        spin_lock_irqsave(&ch->lock, flags);
+                        ch->req_lim += be32_to_cpu(rsp->req_lim_delta);
+                        spin_unlock_irqrestore(&ch->lock, flags);
 
                         return;
                 }
@@ -1653,7 +1774,7 @@ static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
                 else if (unlikely(rsp->flags & SRP_RSP_FLAG_DOOVER))
                         scsi_set_resid(scmnd, -be32_to_cpu(rsp->data_out_res_cnt));
 
-                srp_free_req(target, req, scmnd,
+                srp_free_req(ch, req, scmnd,
                              be32_to_cpu(rsp->req_lim_delta));
 
                 scmnd->host_scribble = NULL;
@@ -1661,18 +1782,19 @@ static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
         }
 }
 
-static int srp_response_common(struct srp_target_port *target, s32 req_delta,
+static int srp_response_common(struct srp_rdma_ch *ch, s32 req_delta,
                                void *rsp, int len)
 {
+        struct srp_target_port *target = ch->target;
         struct ib_device *dev = target->srp_host->srp_dev->dev;
         unsigned long flags;
         struct srp_iu *iu;
         int err;
 
-        spin_lock_irqsave(&target->lock, flags);
-        target->req_lim += req_delta;
-        iu = __srp_get_tx_iu(target, SRP_IU_RSP);
-        spin_unlock_irqrestore(&target->lock, flags);
+        spin_lock_irqsave(&ch->lock, flags);
+        ch->req_lim += req_delta;
+        iu = __srp_get_tx_iu(ch, SRP_IU_RSP);
+        spin_unlock_irqrestore(&ch->lock, flags);
 
         if (!iu) {
                 shost_printk(KERN_ERR, target->scsi_host, PFX
@@ -1684,17 +1806,17 @@ static int srp_response_common(struct srp_target_port *target, s32 req_delta,
         memcpy(iu->buf, rsp, len);
         ib_dma_sync_single_for_device(dev, iu->dma, len, DMA_TO_DEVICE);
 
-        err = srp_post_send(target, iu, len);
+        err = srp_post_send(ch, iu, len);
         if (err) {
                 shost_printk(KERN_ERR, target->scsi_host, PFX
                              "unable to post response: %d\n", err);
-                srp_put_tx_iu(target, iu, SRP_IU_RSP);
+                srp_put_tx_iu(ch, iu, SRP_IU_RSP);
         }
 
         return err;
 }
 
-static void srp_process_cred_req(struct srp_target_port *target,
+static void srp_process_cred_req(struct srp_rdma_ch *ch,
                                  struct srp_cred_req *req)
 {
         struct srp_cred_rsp rsp = {
@@ -1703,14 +1825,15 @@ static void srp_process_cred_req(struct srp_target_port *target,
         };
         s32 delta = be32_to_cpu(req->req_lim_delta);
 
-        if (srp_response_common(target, delta, &rsp, sizeof rsp))
-                shost_printk(KERN_ERR, target->scsi_host, PFX
+        if (srp_response_common(ch, delta, &rsp, sizeof(rsp)))
+                shost_printk(KERN_ERR, ch->target->scsi_host, PFX
                              "problems processing SRP_CRED_REQ\n");
 }
 
-static void srp_process_aer_req(struct srp_target_port *target,
+static void srp_process_aer_req(struct srp_rdma_ch *ch,
                                 struct srp_aer_req *req)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_aer_rsp rsp = {
                 .opcode = SRP_AER_RSP,
                 .tag = req->tag,
@@ -1720,19 +1843,20 @@ static void srp_process_aer_req(struct srp_target_port *target,
         shost_printk(KERN_ERR, target->scsi_host, PFX
                      "ignoring AER for LUN %llu\n", be64_to_cpu(req->lun));
 
-        if (srp_response_common(target, delta, &rsp, sizeof rsp))
+        if (srp_response_common(ch, delta, &rsp, sizeof(rsp)))
                 shost_printk(KERN_ERR, target->scsi_host, PFX
                              "problems processing SRP_AER_REQ\n");
 }
 
-static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
+static void srp_handle_recv(struct srp_rdma_ch *ch, struct ib_wc *wc)
 {
+        struct srp_target_port *target = ch->target;
         struct ib_device *dev = target->srp_host->srp_dev->dev;
         struct srp_iu *iu = (struct srp_iu *) (uintptr_t) wc->wr_id;
         int res;
         u8 opcode;
 
-        ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len,
+        ib_dma_sync_single_for_cpu(dev, iu->dma, ch->max_ti_iu_len,
                                    DMA_FROM_DEVICE);
 
         opcode = *(u8 *) iu->buf;
@@ -1746,15 +1870,15 @@ static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
 
         switch (opcode) {
         case SRP_RSP:
-                srp_process_rsp(target, iu->buf);
+                srp_process_rsp(ch, iu->buf);
                 break;
 
         case SRP_CRED_REQ:
-                srp_process_cred_req(target, iu->buf);
+                srp_process_cred_req(ch, iu->buf);
                 break;
 
         case SRP_AER_REQ:
-                srp_process_aer_req(target, iu->buf);
+                srp_process_aer_req(ch, iu->buf);
                 break;
 
         case SRP_T_LOGOUT:
@@ -1769,10 +1893,10 @@ static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
                 break;
         }
 
-        ib_dma_sync_single_for_device(dev, iu->dma, target->max_ti_iu_len,
+        ib_dma_sync_single_for_device(dev, iu->dma, ch->max_ti_iu_len,
                                       DMA_FROM_DEVICE);
 
-        res = srp_post_recv(target, iu);
+        res = srp_post_recv(ch, iu);
         if (res != 0)
                 shost_printk(KERN_ERR, target->scsi_host,
                              PFX "Recv failed with error code %d\n", res);
@@ -1795,8 +1919,15 @@ static void srp_tl_err_work(struct work_struct *work)
 }
 
 static void srp_handle_qp_err(u64 wr_id, enum ib_wc_status wc_status,
-                              bool send_err, struct srp_target_port *target)
+                              bool send_err, struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
+
+        if (wr_id == SRP_LAST_WR_ID) {
+                complete(&ch->done);
+                return;
+        }
+
         if (target->connected && !target->qp_in_error) {
                 if (wr_id & LOCAL_INV_WR_ID_MASK) {
                         shost_printk(KERN_ERR, target->scsi_host, PFX
@@ -1817,33 +1948,33 @@ static void srp_handle_qp_err(u64 wr_id, enum ib_wc_status wc_status,
         target->qp_in_error = true;
 }
 
-static void srp_recv_completion(struct ib_cq *cq, void *target_ptr)
+static void srp_recv_completion(struct ib_cq *cq, void *ch_ptr)
 {
-        struct srp_target_port *target = target_ptr;
+        struct srp_rdma_ch *ch = ch_ptr;
         struct ib_wc wc;
 
         ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
         while (ib_poll_cq(cq, 1, &wc) > 0) {
                 if (likely(wc.status == IB_WC_SUCCESS)) {
-                        srp_handle_recv(target, &wc);
+                        srp_handle_recv(ch, &wc);
                 } else {
-                        srp_handle_qp_err(wc.wr_id, wc.status, false, target);
+                        srp_handle_qp_err(wc.wr_id, wc.status, false, ch);
                 }
         }
 }
 
-static void srp_send_completion(struct ib_cq *cq, void *target_ptr)
+static void srp_send_completion(struct ib_cq *cq, void *ch_ptr)
 {
-        struct srp_target_port *target = target_ptr;
+        struct srp_rdma_ch *ch = ch_ptr;
         struct ib_wc wc;
         struct srp_iu *iu;
 
         while (ib_poll_cq(cq, 1, &wc) > 0) {
                 if (likely(wc.status == IB_WC_SUCCESS)) {
                         iu = (struct srp_iu *) (uintptr_t) wc.wr_id;
-                        list_add(&iu->list, &target->free_tx);
+                        list_add(&iu->list, &ch->free_tx);
                 } else {
-                        srp_handle_qp_err(wc.wr_id, wc.status, true, target);
+                        srp_handle_qp_err(wc.wr_id, wc.status, true, ch);
                 }
         }
 }
@@ -1852,11 +1983,14 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
 {
         struct srp_target_port *target = host_to_target(shost);
         struct srp_rport *rport = target->rport;
+        struct srp_rdma_ch *ch;
         struct srp_request *req;
         struct srp_iu *iu;
         struct srp_cmd *cmd;
         struct ib_device *dev;
         unsigned long flags;
+        u32 tag;
+        u16 idx;
         int len, ret;
         const bool in_scsi_eh = !in_interrupt() && current == shost->ehandler;
 
@@ -1873,15 +2007,22 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         if (unlikely(scmnd->result))
                 goto err;
 
-        spin_lock_irqsave(&target->lock, flags);
-        iu = __srp_get_tx_iu(target, SRP_IU_CMD);
-        if (!iu)
-                goto err_unlock;
+        WARN_ON_ONCE(scmnd->request->tag < 0);
+        tag = blk_mq_unique_tag(scmnd->request);
+        ch = &target->ch[blk_mq_unique_tag_to_hwq(tag)];
+        idx = blk_mq_unique_tag_to_tag(tag);
+        WARN_ONCE(idx >= target->req_ring_size, "%s: tag %#x: idx %d >= %d\n",
+                  dev_name(&shost->shost_gendev), tag, idx,
+                  target->req_ring_size);
 
-        req = list_first_entry(&target->free_reqs, struct srp_request, list);
-        list_del(&req->list);
-        spin_unlock_irqrestore(&target->lock, flags);
+        spin_lock_irqsave(&ch->lock, flags);
+        iu = __srp_get_tx_iu(ch, SRP_IU_CMD);
+        spin_unlock_irqrestore(&ch->lock, flags);
 
+        if (!iu)
+                goto err;
+
+        req = &ch->req_ring[idx];
         dev = target->srp_host->srp_dev->dev;
         ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_iu_len,
                                    DMA_TO_DEVICE);
@@ -1893,13 +2034,13 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
 
         cmd->opcode = SRP_CMD;
         cmd->lun    = cpu_to_be64((u64) scmnd->device->lun << 48);
-        cmd->tag    = req->index;
+        cmd->tag    = tag;
         memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len);
 
         req->scmnd    = scmnd;
         req->cmd      = iu;
 
-        len = srp_map_data(scmnd, target, req);
+        len = srp_map_data(scmnd, ch, req);
         if (len < 0) {
                 shost_printk(KERN_ERR, target->scsi_host,
                              PFX "Failed to map data (%d)\n", len);
@@ -1917,7 +2058,7 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         ib_dma_sync_single_for_device(dev, iu->dma, target->max_iu_len,
                                       DMA_TO_DEVICE);
 
-        if (srp_post_send(target, iu, len)) {
+        if (srp_post_send(ch, iu, len)) {
                 shost_printk(KERN_ERR, target->scsi_host, PFX "Send failed\n");
                 goto err_unmap;
         }
@@ -1931,10 +2072,10 @@ unlock_rport:
         return ret;
 
 err_unmap:
-        srp_unmap_data(scmnd, target, req);
+        srp_unmap_data(scmnd, ch, req);
 
 err_iu:
-        srp_put_tx_iu(target, iu, SRP_IU_CMD);
+        srp_put_tx_iu(ch, iu, SRP_IU_CMD);
 
         /*
          * Avoid that the loops that iterate over the request ring can
@@ -1942,12 +2083,6 @@ err_iu:
          */
         req->scmnd = NULL;
 
-        spin_lock_irqsave(&target->lock, flags);
-        list_add(&req->list, &target->free_reqs);
-
-err_unlock:
-        spin_unlock_irqrestore(&target->lock, flags);
-
 err:
         if (scmnd->result) {
                 scmnd->scsi_done(scmnd);
@@ -1961,53 +2096,54 @@ err:
 
 /*
  * Note: the resources allocated in this function are freed in
- * srp_free_target_ib().
+ * srp_free_ch_ib().
  */
-static int srp_alloc_iu_bufs(struct srp_target_port *target)
+static int srp_alloc_iu_bufs(struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         int i;
 
-        target->rx_ring = kzalloc(target->queue_size * sizeof(*target->rx_ring),
-                                  GFP_KERNEL);
-        if (!target->rx_ring)
+        ch->rx_ring = kcalloc(target->queue_size, sizeof(*ch->rx_ring),
+                              GFP_KERNEL);
+        if (!ch->rx_ring)
                 goto err_no_ring;
-        target->tx_ring = kzalloc(target->queue_size * sizeof(*target->tx_ring),
-                                  GFP_KERNEL);
-        if (!target->tx_ring)
+        ch->tx_ring = kcalloc(target->queue_size, sizeof(*ch->tx_ring),
+                              GFP_KERNEL);
+        if (!ch->tx_ring)
                 goto err_no_ring;
 
         for (i = 0; i < target->queue_size; ++i) {
-                target->rx_ring[i] = srp_alloc_iu(target->srp_host,
-                                                  target->max_ti_iu_len,
-                                                  GFP_KERNEL, DMA_FROM_DEVICE);
-                if (!target->rx_ring[i])
+                ch->rx_ring[i] = srp_alloc_iu(target->srp_host,
+                                              ch->max_ti_iu_len,
+                                              GFP_KERNEL, DMA_FROM_DEVICE);
+                if (!ch->rx_ring[i])
                         goto err;
         }
 
         for (i = 0; i < target->queue_size; ++i) {
-                target->tx_ring[i] = srp_alloc_iu(target->srp_host,
-                                                  target->max_iu_len,
-                                                  GFP_KERNEL, DMA_TO_DEVICE);
-                if (!target->tx_ring[i])
+                ch->tx_ring[i] = srp_alloc_iu(target->srp_host,
+                                              target->max_iu_len,
+                                              GFP_KERNEL, DMA_TO_DEVICE);
+                if (!ch->tx_ring[i])
                         goto err;
 
-                list_add(&target->tx_ring[i]->list, &target->free_tx);
+                list_add(&ch->tx_ring[i]->list, &ch->free_tx);
         }
 
         return 0;
 
 err:
         for (i = 0; i < target->queue_size; ++i) {
-                srp_free_iu(target->srp_host, target->rx_ring[i]);
-                srp_free_iu(target->srp_host, target->tx_ring[i]);
+                srp_free_iu(target->srp_host, ch->rx_ring[i]);
+                srp_free_iu(target->srp_host, ch->tx_ring[i]);
         }
 
 
 err_no_ring:
-        kfree(target->tx_ring);
-        target->tx_ring = NULL;
-        kfree(target->rx_ring);
-        target->rx_ring = NULL;
+        kfree(ch->tx_ring);
+        ch->tx_ring = NULL;
+        kfree(ch->rx_ring);
+        ch->rx_ring = NULL;
 
         return -ENOMEM;
 }
@@ -2041,23 +2177,24 @@ static uint32_t srp_compute_rq_tmo(struct ib_qp_attr *qp_attr, int attr_mask)
 
 static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
                                struct srp_login_rsp *lrsp,
-                               struct srp_target_port *target)
+                               struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         struct ib_qp_attr *qp_attr = NULL;
         int attr_mask = 0;
         int ret;
         int i;
 
         if (lrsp->opcode == SRP_LOGIN_RSP) {
-                target->max_ti_iu_len = be32_to_cpu(lrsp->max_ti_iu_len);
-                target->req_lim       = be32_to_cpu(lrsp->req_lim_delta);
+                ch->max_ti_iu_len = be32_to_cpu(lrsp->max_ti_iu_len);
+                ch->req_lim       = be32_to_cpu(lrsp->req_lim_delta);
 
                 /*
                  * Reserve credits for task management so we don't
                  * bounce requests back to the SCSI mid-layer.
                  */
                 target->scsi_host->can_queue
-                        = min(target->req_lim - SRP_TSK_MGMT_SQ_SIZE,
+                        = min(ch->req_lim - SRP_TSK_MGMT_SQ_SIZE,
                               target->scsi_host->can_queue);
                 target->scsi_host->cmd_per_lun
                         = min_t(int, target->scsi_host->can_queue,
@@ -2069,8 +2206,8 @@ static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
                 goto error;
         }
 
-        if (!target->rx_ring) {
-                ret = srp_alloc_iu_bufs(target);
+        if (!ch->rx_ring) {
+                ret = srp_alloc_iu_bufs(ch);
                 if (ret)
                         goto error;
         }
@@ -2085,13 +2222,14 @@ static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
         if (ret)
                 goto error_free;
 
-        ret = ib_modify_qp(target->qp, qp_attr, attr_mask);
+        ret = ib_modify_qp(ch->qp, qp_attr, attr_mask);
         if (ret)
                 goto error_free;
 
         for (i = 0; i < target->queue_size; i++) {
-                struct srp_iu *iu = target->rx_ring[i];
-                ret = srp_post_recv(target, iu);
+                struct srp_iu *iu = ch->rx_ring[i];
+
+                ret = srp_post_recv(ch, iu);
                 if (ret)
                         goto error_free;
         }
@@ -2103,7 +2241,7 @@ static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
 
         target->rq_tmo_jiffies = srp_compute_rq_tmo(qp_attr, attr_mask);
 
-        ret = ib_modify_qp(target->qp, qp_attr, attr_mask);
+        ret = ib_modify_qp(ch->qp, qp_attr, attr_mask);
         if (ret)
                 goto error_free;
 
@@ -2113,13 +2251,14 @@ error_free:
         kfree(qp_attr);
 
 error:
-        target->status = ret;
+        ch->status = ret;
 }
 
 static void srp_cm_rej_handler(struct ib_cm_id *cm_id,
                                struct ib_cm_event *event,
-                               struct srp_target_port *target)
+                               struct srp_rdma_ch *ch)
 {
+        struct srp_target_port *target = ch->target;
         struct Scsi_Host *shost = target->scsi_host;
         struct ib_class_port_info *cpi;
         int opcode;
@@ -2127,12 +2266,12 @@ static void srp_cm_rej_handler(struct ib_cm_id *cm_id,
         switch (event->param.rej_rcvd.reason) {
         case IB_CM_REJ_PORT_CM_REDIRECT:
                 cpi = event->param.rej_rcvd.ari;
-                target->path.dlid = cpi->redirect_lid;
-                target->path.pkey = cpi->redirect_pkey;
+                ch->path.dlid = cpi->redirect_lid;
+                ch->path.pkey = cpi->redirect_pkey;
                 cm_id->remote_cm_qpn = be32_to_cpu(cpi->redirect_qp) & 0x00ffffff;
-                memcpy(target->path.dgid.raw, cpi->redirect_gid, 16);
+                memcpy(ch->path.dgid.raw, cpi->redirect_gid, 16);
 
-                target->status = target->path.dlid ?
+                ch->status = ch->path.dlid ?
                         SRP_DLID_REDIRECT : SRP_PORT_REDIRECT;
                 break;
 
@@ -2143,26 +2282,26 @@ static void srp_cm_rej_handler(struct ib_cm_id *cm_id,
                          * reject reason code 25 when they mean 24
                          * (port redirect).
                          */
-                        memcpy(target->path.dgid.raw,
+                        memcpy(ch->path.dgid.raw,
                                event->param.rej_rcvd.ari, 16);
 
                         shost_printk(KERN_DEBUG, shost,
                                      PFX "Topspin/Cisco redirect to target port GID %016llx%016llx\n",
-                                     (unsigned long long) be64_to_cpu(target->path.dgid.global.subnet_prefix),
-                                     (unsigned long long) be64_to_cpu(target->path.dgid.global.interface_id));
+                                     be64_to_cpu(ch->path.dgid.global.subnet_prefix),
+                                     be64_to_cpu(ch->path.dgid.global.interface_id));
 
-                        target->status = SRP_PORT_REDIRECT;
+                        ch->status = SRP_PORT_REDIRECT;
                 } else {
                         shost_printk(KERN_WARNING, shost,
                                      "  REJ reason: IB_CM_REJ_PORT_REDIRECT\n");
-                        target->status = -ECONNRESET;
+                        ch->status = -ECONNRESET;
                 }
                 break;
 
         case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID:
                 shost_printk(KERN_WARNING, shost,
                             "  REJ reason: IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID\n");
-                target->status = -ECONNRESET;
+                ch->status = -ECONNRESET;
                 break;
 
         case IB_CM_REJ_CONSUMER_DEFINED:
@@ -2177,30 +2316,31 @@ static void srp_cm_rej_handler(struct ib_cm_id *cm_id,
                         else
                                 shost_printk(KERN_WARNING, shost, PFX
                                              "SRP LOGIN from %pI6 to %pI6 REJECTED, reason 0x%08x\n",
-                                             target->path.sgid.raw,
-                                             target->orig_dgid, reason);
+                                             target->sgid.raw,
+                                             target->orig_dgid.raw, reason);
                 } else
                         shost_printk(KERN_WARNING, shost,
                                      "  REJ reason: IB_CM_REJ_CONSUMER_DEFINED,"
                                      " opcode 0x%02x\n", opcode);
-                target->status = -ECONNRESET;
+                ch->status = -ECONNRESET;
                 break;
 
         case IB_CM_REJ_STALE_CONN:
                 shost_printk(KERN_WARNING, shost, "  REJ reason: stale connection\n");
-                target->status = SRP_STALE_CONN;
+                ch->status = SRP_STALE_CONN;
                 break;
 
         default:
                 shost_printk(KERN_WARNING, shost, "  REJ reason 0x%x\n",
                              event->param.rej_rcvd.reason);
-                target->status = -ECONNRESET;
+                ch->status = -ECONNRESET;
         }
 }
 
 static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
 {
-        struct srp_target_port *target = cm_id->context;
+        struct srp_rdma_ch *ch = cm_id->context;
+        struct srp_target_port *target = ch->target;
         int comp = 0;
 
         switch (event->event) {
@@ -2208,19 +2348,19 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
                 shost_printk(KERN_DEBUG, target->scsi_host,
                              PFX "Sending CM REQ failed\n");
                 comp = 1;
-                target->status = -ECONNRESET;
+                ch->status = -ECONNRESET;
                 break;
 
         case IB_CM_REP_RECEIVED:
                 comp = 1;
-                srp_cm_rep_handler(cm_id, event->private_data, target);
+                srp_cm_rep_handler(cm_id, event->private_data, ch);
                 break;
 
         case IB_CM_REJ_RECEIVED:
                 shost_printk(KERN_DEBUG, target->scsi_host, PFX "REJ received\n");
                 comp = 1;
 
-                srp_cm_rej_handler(cm_id, event, target);
+                srp_cm_rej_handler(cm_id, event, ch);
                 break;
 
         case IB_CM_DREQ_RECEIVED:
@@ -2238,7 +2378,7 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
                              PFX "connection closed\n");
                 comp = 1;
 
-                target->status = 0;
+                ch->status = 0;
                 break;
 
         case IB_CM_MRA_RECEIVED:
@@ -2253,65 +2393,30 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
         }
 
         if (comp)
-                complete(&target->done);
+                complete(&ch->done);
 
         return 0;
 }
 
 /**
- * srp_change_queue_type - changing device queue tag type
- * @sdev: scsi device struct
- * @tag_type: requested tag type
- *
- * Returns queue tag type.
- */
-static int
-srp_change_queue_type(struct scsi_device *sdev, int tag_type)
-{
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, tag_type);
-                if (tag_type)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                tag_type = 0;
-
-        return tag_type;
-}
-
-/**
  * srp_change_queue_depth - setting device queue depth
  * @sdev: scsi device struct
  * @qdepth: requested queue depth
- * @reason: SCSI_QDEPTH_DEFAULT/SCSI_QDEPTH_QFULL/SCSI_QDEPTH_RAMP_UP
- * (see include/scsi/scsi_host.h for definition)
  *
  * Returns queue depth.
  */
 static int
-srp_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
+srp_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
-        struct Scsi_Host *shost = sdev->host;
-        int max_depth;
-        if (reason == SCSI_QDEPTH_DEFAULT || reason == SCSI_QDEPTH_RAMP_UP) {
-                max_depth = shost->can_queue;
-                if (!sdev->tagged_supported)
-                        max_depth = 1;
-                if (qdepth > max_depth)
-                        qdepth = max_depth;
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-        } else if (reason == SCSI_QDEPTH_QFULL)
-                scsi_track_queue_full(sdev, qdepth);
-        else
-                return -EOPNOTSUPP;
-
-        return sdev->queue_depth;
+        if (!sdev->tagged_supported)
+                qdepth = 1;
+        return scsi_change_queue_depth(sdev, qdepth);
 }
 
-static int srp_send_tsk_mgmt(struct srp_target_port *target,
-                             u64 req_tag, unsigned int lun, u8 func)
+static int srp_send_tsk_mgmt(struct srp_rdma_ch *ch, u64 req_tag,
+                             unsigned int lun, u8 func)
 {
+        struct srp_target_port *target = ch->target;
         struct srp_rport *rport = target->rport;
         struct ib_device *dev = target->srp_host->srp_dev->dev;
         struct srp_iu *iu;
@@ -2320,16 +2425,16 @@ static int srp_send_tsk_mgmt(struct srp_target_port *target,
         if (!target->connected || target->qp_in_error)
                 return -1;
 
-        init_completion(&target->tsk_mgmt_done);
+        init_completion(&ch->tsk_mgmt_done);
 
         /*
-         * Lock the rport mutex to avoid that srp_create_target_ib() is
+         * Lock the rport mutex to avoid that srp_create_ch_ib() is
          * invoked while a task management function is being sent.
          */
         mutex_lock(&rport->mutex);
-        spin_lock_irq(&target->lock);
-        iu = __srp_get_tx_iu(target, SRP_IU_TSK_MGMT);
-        spin_unlock_irq(&target->lock);
+        spin_lock_irq(&ch->lock);
+        iu = __srp_get_tx_iu(ch, SRP_IU_TSK_MGMT);
+        spin_unlock_irq(&ch->lock);
 
         if (!iu) {
                 mutex_unlock(&rport->mutex);
@@ -2350,15 +2455,15 @@ static int srp_send_tsk_mgmt(struct srp_target_port *target,
 
         ib_dma_sync_single_for_device(dev, iu->dma, sizeof *tsk_mgmt,
                                       DMA_TO_DEVICE);
-        if (srp_post_send(target, iu, sizeof *tsk_mgmt)) {
-                srp_put_tx_iu(target, iu, SRP_IU_TSK_MGMT);
+        if (srp_post_send(ch, iu, sizeof(*tsk_mgmt))) {
+                srp_put_tx_iu(ch, iu, SRP_IU_TSK_MGMT);
                 mutex_unlock(&rport->mutex);
 
                 return -1;
         }
         mutex_unlock(&rport->mutex);
 
-        if (!wait_for_completion_timeout(&target->tsk_mgmt_done,
+        if (!wait_for_completion_timeout(&ch->tsk_mgmt_done,
                                          msecs_to_jiffies(SRP_ABORT_TIMEOUT_MS)))
                 return -1;
 
@@ -2369,20 +2474,32 @@ static int srp_abort(struct scsi_cmnd *scmnd)
 {
         struct srp_target_port *target = host_to_target(scmnd->device->host);
         struct srp_request *req = (struct srp_request *) scmnd->host_scribble;
+        u32 tag;
+        u16 ch_idx;
+        struct srp_rdma_ch *ch;
         int ret;
 
         shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");
 
-        if (!req || !srp_claim_req(target, req, NULL, scmnd))
+        if (!req)
+                return SUCCESS;
+        tag = blk_mq_unique_tag(scmnd->request);
+        ch_idx = blk_mq_unique_tag_to_hwq(tag);
+        if (WARN_ON_ONCE(ch_idx >= target->ch_count))
                 return SUCCESS;
-        if (srp_send_tsk_mgmt(target, req->index, scmnd->device->lun,
+        ch = &target->ch[ch_idx];
+        if (!srp_claim_req(ch, req, NULL, scmnd))
+                return SUCCESS;
+        shost_printk(KERN_ERR, target->scsi_host,
+                     "Sending SRP abort for tag %#x\n", tag);
+        if (srp_send_tsk_mgmt(ch, tag, scmnd->device->lun,
                               SRP_TSK_ABORT_TASK) == 0)
                 ret = SUCCESS;
         else if (target->rport->state == SRP_RPORT_LOST)
                 ret = FAST_IO_FAIL;
         else
                 ret = FAILED;
-        srp_free_req(target, req, scmnd, 0);
+        srp_free_req(ch, req, scmnd, 0);
         scmnd->result = DID_ABORT << 16;
         scmnd->scsi_done(scmnd);
 
@@ -2392,19 +2509,25 @@ static int srp_abort(struct scsi_cmnd *scmnd)
 static int srp_reset_device(struct scsi_cmnd *scmnd)
 {
         struct srp_target_port *target = host_to_target(scmnd->device->host);
+        struct srp_rdma_ch *ch;
         int i;
 
         shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n");
 
-        if (srp_send_tsk_mgmt(target, SRP_TAG_NO_REQ, scmnd->device->lun,
+        ch = &target->ch[0];
+        if (srp_send_tsk_mgmt(ch, SRP_TAG_NO_REQ, scmnd->device->lun,
                               SRP_TSK_LUN_RESET))
                 return FAILED;
-        if (target->tsk_mgmt_status)
+        if (ch->tsk_mgmt_status)
                 return FAILED;
 
-        for (i = 0; i < target->req_ring_size; ++i) {
-                struct srp_request *req = &target->req_ring[i];
-                srp_finish_req(target, req, scmnd->device, DID_RESET << 16);
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                for (i = 0; i < target->req_ring_size; ++i) {
+                        struct srp_request *req = &ch->req_ring[i];
+
+                        srp_finish_req(ch, req, scmnd->device, DID_RESET << 16);
+                }
         }
 
         return SUCCESS;
@@ -2466,7 +2589,7 @@ static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
-        return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey));
+        return sprintf(buf, "0x%04x\n", be16_to_cpu(target->pkey));
 }
 
 static ssize_t show_sgid(struct device *dev, struct device_attribute *attr,
@@ -2474,15 +2597,16 @@ static ssize_t show_sgid(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
-        return sprintf(buf, "%pI6\n", target->path.sgid.raw);
+        return sprintf(buf, "%pI6\n", target->sgid.raw);
 }
 
 static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
                          char *buf)
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
+        struct srp_rdma_ch *ch = &target->ch[0];
 
-        return sprintf(buf, "%pI6\n", target->path.dgid.raw);
+        return sprintf(buf, "%pI6\n", ch->path.dgid.raw);
 }
 
 static ssize_t show_orig_dgid(struct device *dev,
@@ -2490,15 +2614,21 @@ static ssize_t show_orig_dgid(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
-        return sprintf(buf, "%pI6\n", target->orig_dgid);
+        return sprintf(buf, "%pI6\n", target->orig_dgid.raw);
 }
 
 static ssize_t show_req_lim(struct device *dev,
                             struct device_attribute *attr, char *buf)
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
+        struct srp_rdma_ch *ch;
+        int i, req_lim = INT_MAX;
 
-        return sprintf(buf, "%d\n", target->req_lim);
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                req_lim = min(req_lim, ch->req_lim);
+        }
+        return sprintf(buf, "%d\n", req_lim);
 }
 
 static ssize_t show_zero_req_lim(struct device *dev,
@@ -2525,6 +2655,14 @@ static ssize_t show_local_ib_device(struct device *dev,
         return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name);
 }
 
+static ssize_t show_ch_count(struct device *dev, struct device_attribute *attr,
+                             char *buf)
+{
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
+
+        return sprintf(buf, "%d\n", target->ch_count);
+}
+
 static ssize_t show_comp_vector(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
@@ -2568,6 +2706,7 @@ static DEVICE_ATTR(req_lim,         S_IRUGO, show_req_lim,         NULL);
 static DEVICE_ATTR(zero_req_lim,    S_IRUGO, show_zero_req_lim,    NULL);
 static DEVICE_ATTR(local_ib_port,   S_IRUGO, show_local_ib_port,   NULL);
 static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL);
+static DEVICE_ATTR(ch_count,        S_IRUGO, show_ch_count,        NULL);
 static DEVICE_ATTR(comp_vector,     S_IRUGO, show_comp_vector,     NULL);
 static DEVICE_ATTR(tl_retry_count,  S_IRUGO, show_tl_retry_count,  NULL);
 static DEVICE_ATTR(cmd_sg_entries,  S_IRUGO, show_cmd_sg_entries,  NULL);
@@ -2585,6 +2724,7 @@ static struct device_attribute *srp_host_attrs[] = {
         &dev_attr_zero_req_lim,
         &dev_attr_local_ib_port,
         &dev_attr_local_ib_device,
+        &dev_attr_ch_count,
         &dev_attr_comp_vector,
         &dev_attr_tl_retry_count,
         &dev_attr_cmd_sg_entries,
@@ -2600,7 +2740,7 @@ static struct scsi_host_template srp_template = {
         .info                           = srp_target_info,
         .queuecommand                   = srp_queuecommand,
         .change_queue_depth             = srp_change_queue_depth,
-        .change_queue_type              = srp_change_queue_type,
+        .change_queue_type              = scsi_change_queue_type,
         .eh_abort_handler               = srp_abort,
         .eh_device_reset_handler        = srp_reset_device,
         .eh_host_reset_handler          = srp_reset_host,
@@ -2610,14 +2750,28 @@ static struct scsi_host_template srp_template = {
         .this_id                        = -1,
         .cmd_per_lun                    = SRP_DEFAULT_CMD_SQ_SIZE,
         .use_clustering                 = ENABLE_CLUSTERING,
-        .shost_attrs                    = srp_host_attrs
+        .shost_attrs                    = srp_host_attrs,
+        .use_blk_tags                   = 1,
+        .track_queue_depth              = 1,
 };
 
+static int srp_sdev_count(struct Scsi_Host *host)
+{
+        struct scsi_device *sdev;
+        int c = 0;
+
+        shost_for_each_device(sdev, host)
+                c++;
+
+        return c;
+}
+
 static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
 {
         struct srp_rport_identifiers ids;
         struct srp_rport *rport;
 
+        target->state = SRP_TARGET_SCANNING;
         sprintf(target->target_name, "SRP.T10:%016llX",
                  (unsigned long long) be64_to_cpu(target->id_ext));
 
@@ -2640,11 +2794,26 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
         list_add_tail(&target->list, &host->target_list);
         spin_unlock(&host->target_lock);
 
-        target->state = SRP_TARGET_LIVE;
-
         scsi_scan_target(&target->scsi_host->shost_gendev,
                          0, target->scsi_id, SCAN_WILD_CARD, 0);
 
+        if (!target->connected || target->qp_in_error) {
+                shost_printk(KERN_INFO, target->scsi_host,
+                             PFX "SCSI scan failed - removing SCSI host\n");
+                srp_queue_remove_work(target);
+                goto out;
+        }
+
+        pr_debug(PFX "%s: SCSI scan succeeded - detected %d LUNs\n",
+                 dev_name(&target->scsi_host->shost_gendev),
+                 srp_sdev_count(target->scsi_host));
+
+        spin_lock_irq(&target->lock);
+        if (target->state == SRP_TARGET_SCANNING)
+                target->state = SRP_TARGET_LIVE;
+        spin_unlock_irq(&target->lock);
+
+out:
         return 0;
 }
 
@@ -2801,11 +2970,15 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                         }
 
                         for (i = 0; i < 16; ++i) {
-                                strlcpy(dgid, p + i * 2, 3);
-                                target->path.dgid.raw[i] = simple_strtoul(dgid, NULL, 16);
+                                strlcpy(dgid, p + i * 2, sizeof(dgid));
+                                if (sscanf(dgid, "%hhx",
+                                           &target->orig_dgid.raw[i]) < 1) {
+                                        ret = -EINVAL;
+                                        kfree(p);
+                                        goto out;
+                                }
                         }
                         kfree(p);
-                        memcpy(target->orig_dgid, target->path.dgid.raw, 16);
                         break;
 
                 case SRP_OPT_PKEY:
@@ -2813,7 +2986,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                                 pr_warn("bad P_Key parameter '%s'\n", p);
                                 goto out;
                         }
-                        target->path.pkey = cpu_to_be16(token);
+                        target->pkey = cpu_to_be16(token);
                         break;
 
                 case SRP_OPT_SERVICE_ID:
@@ -2823,7 +2996,6 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                                 goto out;
                         }
                         target->service_id = cpu_to_be64(simple_strtoull(p, NULL, 16));
-                        target->path.service_id = target->service_id;
                         kfree(p);
                         break;
 
@@ -2960,9 +3132,11 @@ static ssize_t srp_create_target(struct device *dev,
                 container_of(dev, struct srp_host, dev);
         struct Scsi_Host *target_host;
         struct srp_target_port *target;
+        struct srp_rdma_ch *ch;
         struct srp_device *srp_dev = host->srp_dev;
         struct ib_device *ibdev = srp_dev->dev;
-        int ret;
+        int ret, node_idx, node, cpu, i;
+        bool multich = false;
 
         target_host = scsi_host_alloc(&srp_template,
                                       sizeof (struct srp_target_port));
@@ -2988,12 +3162,22 @@ static ssize_t srp_create_target(struct device *dev,
         target->tl_retry_count  = 7;
         target->queue_size      = SRP_DEFAULT_QUEUE_SIZE;
 
+        /*
+         * Avoid that the SCSI host can be removed by srp_remove_target()
+         * before this function returns.
+         */
+        scsi_host_get(target->scsi_host);
+
         mutex_lock(&host->add_target_mutex);
 
         ret = srp_parse_options(buf, target);
         if (ret)
                 goto err;
 
+        ret = scsi_init_shared_tag_map(target_host, target_host->can_queue);
+        if (ret)
+                goto err;
+
         target->req_ring_size = target->queue_size - SRP_TSK_MGMT_SQ_SIZE;
 
         if (!srp_conn_unique(target->srp_host, target)) {
@@ -3022,59 +3206,115 @@ static ssize_t srp_create_target(struct device *dev,
         INIT_WORK(&target->tl_err_work, srp_tl_err_work);
         INIT_WORK(&target->remove_work, srp_remove_work);
         spin_lock_init(&target->lock);
-        INIT_LIST_HEAD(&target->free_tx);
-        ret = srp_alloc_req_data(target);
+        ret = ib_query_gid(ibdev, host->port, 0, &target->sgid);
         if (ret)
-                goto err_free_mem;
+                goto err;
 
-        ret = ib_query_gid(ibdev, host->port, 0, &target->path.sgid);
-        if (ret)
-                goto err_free_mem;
+        ret = -ENOMEM;
+        target->ch_count = max_t(unsigned, num_online_nodes(),
+                                 min(ch_count ? :
+                                     min(4 * num_online_nodes(),
+                                         ibdev->num_comp_vectors),
+                                     num_online_cpus()));
+        target->ch = kcalloc(target->ch_count, sizeof(*target->ch),
+                             GFP_KERNEL);
+        if (!target->ch)
+                goto err;
 
-        ret = srp_create_target_ib(target);
-        if (ret)
-                goto err_free_mem;
+        node_idx = 0;
+        for_each_online_node(node) {
+                const int ch_start = (node_idx * target->ch_count /
+                                      num_online_nodes());
+                const int ch_end = ((node_idx + 1) * target->ch_count /
+                                    num_online_nodes());
+                const int cv_start = (node_idx * ibdev->num_comp_vectors /
+                                      num_online_nodes() + target->comp_vector)
+                                     % ibdev->num_comp_vectors;
+                const int cv_end = ((node_idx + 1) * ibdev->num_comp_vectors /
+                                    num_online_nodes() + target->comp_vector)
+                                   % ibdev->num_comp_vectors;
+                int cpu_idx = 0;
+
+                for_each_online_cpu(cpu) {
+                        if (cpu_to_node(cpu) != node)
+                                continue;
+                        if (ch_start + cpu_idx >= ch_end)
+                                continue;
+                        ch = &target->ch[ch_start + cpu_idx];
+                        ch->target = target;
+                        ch->comp_vector = cv_start == cv_end ? cv_start :
+                                cv_start + cpu_idx % (cv_end - cv_start);
+                        spin_lock_init(&ch->lock);
+                        INIT_LIST_HEAD(&ch->free_tx);
+                        ret = srp_new_cm_id(ch);
+                        if (ret)
+                                goto err_disconnect;
 
-        ret = srp_new_cm_id(target);
-        if (ret)
-                goto err_free_ib;
+                        ret = srp_create_ch_ib(ch);
+                        if (ret)
+                                goto err_disconnect;
 
-        ret = srp_connect_target(target);
-        if (ret) {
-                shost_printk(KERN_ERR, target->scsi_host,
-                             PFX "Connection failed\n");
-                goto err_cm_id;
+                        ret = srp_alloc_req_data(ch);
+                        if (ret)
+                                goto err_disconnect;
+
+                        ret = srp_connect_ch(ch, multich);
+                        if (ret) {
+                                shost_printk(KERN_ERR, target->scsi_host,
+                                             PFX "Connection %d/%d failed\n",
+                                             ch_start + cpu_idx,
+                                             target->ch_count);
+                                if (node_idx == 0 && cpu_idx == 0) {
+                                        goto err_disconnect;
+                                } else {
+                                        srp_free_ch_ib(target, ch);
+                                        srp_free_req_data(target, ch);
+                                        target->ch_count = ch - target->ch;
+                                        break;
+                                }
+                        }
+
+                        multich = true;
+                        cpu_idx++;
+                }
+                node_idx++;
         }
 
+        target->scsi_host->nr_hw_queues = target->ch_count;
+
         ret = srp_add_target(host, target);
         if (ret)
                 goto err_disconnect;
 
-        shost_printk(KERN_DEBUG, target->scsi_host, PFX
-                     "new target: id_ext %016llx ioc_guid %016llx pkey %04x service_id %016llx sgid %pI6 dgid %pI6\n",
-                     be64_to_cpu(target->id_ext),
-                     be64_to_cpu(target->ioc_guid),
-                     be16_to_cpu(target->path.pkey),
-                     be64_to_cpu(target->service_id),
-                     target->path.sgid.raw, target->path.dgid.raw);
+        if (target->state != SRP_TARGET_REMOVED) {
+                shost_printk(KERN_DEBUG, target->scsi_host, PFX
+                             "new target: id_ext %016llx ioc_guid %016llx pkey %04x service_id %016llx sgid %pI6 dgid %pI6\n",
+                             be64_to_cpu(target->id_ext),
+                             be64_to_cpu(target->ioc_guid),
+                             be16_to_cpu(target->pkey),
+                             be64_to_cpu(target->service_id),
+                             target->sgid.raw, target->orig_dgid.raw);
+        }
 
         ret = count;
 
 out:
         mutex_unlock(&host->add_target_mutex);
+
+        scsi_host_put(target->scsi_host);
+
         return ret;
 
 err_disconnect:
         srp_disconnect_target(target);
 
-err_cm_id:
-        ib_destroy_cm_id(target->cm_id);
-
-err_free_ib:
-        srp_free_target_ib(target);
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                srp_free_ch_ib(target, ch);
+                srp_free_req_data(target, ch);
+        }
 
-err_free_mem:
-        srp_free_req_data(target);
+        kfree(target->ch);
 
 err:
         scsi_host_put(target_host);
diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h
index e46ecb15aa0d..a611556406ac 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.h
+++ b/drivers/infiniband/ulp/srp/ib_srp.h
@@ -70,9 +70,12 @@ enum {
 
         LOCAL_INV_WR_ID_MASK    = 1,
         FAST_REG_WR_ID_MASK     = 2,
+
+        SRP_LAST_WR_ID          = 0xfffffffcU,
 };
 
 enum srp_target_state {
+        SRP_TARGET_SCANNING,
         SRP_TARGET_LIVE,
         SRP_TARGET_REMOVED,
 };
@@ -115,7 +118,6 @@ struct srp_host {
 };
 
 struct srp_request {
-        struct list_head        list;
         struct scsi_cmnd       *scmnd;
         struct srp_iu          *cmd;
         union {
@@ -126,24 +128,62 @@ struct srp_request {
         struct srp_direct_buf  *indirect_desc;
         dma_addr_t              indirect_dma_addr;
         short                   nmdesc;
-        short                   index;
 };
 
-struct srp_target_port {
+/**
+ * struct srp_rdma_ch
+ * @comp_vector: Completion vector used by this RDMA channel.
+ */
+struct srp_rdma_ch {
         /* These are RW in the hot path, and commonly used together */
         struct list_head        free_tx;
-        struct list_head        free_reqs;
         spinlock_t              lock;
         s32                     req_lim;
 
         /* These are read-only in the hot path */
-        struct ib_cq           *send_cq ____cacheline_aligned_in_smp;
+        struct srp_target_port *target ____cacheline_aligned_in_smp;
+        struct ib_cq           *send_cq;
         struct ib_cq           *recv_cq;
         struct ib_qp           *qp;
         union {
                 struct ib_fmr_pool     *fmr_pool;
                 struct srp_fr_pool     *fr_pool;
         };
+
+        /* Everything above this point is used in the hot path of
+         * command processing. Try to keep them packed into cachelines.
+         */
+
+        struct completion       done;
+        int                     status;
+
+        struct ib_sa_path_rec   path;
+        struct ib_sa_query     *path_query;
+        int                     path_query_id;
+
+        struct ib_cm_id        *cm_id;
+        struct srp_iu         **tx_ring;
+        struct srp_iu         **rx_ring;
+        struct srp_request     *req_ring;
+        int                     max_ti_iu_len;
+        int                     comp_vector;
+
+        struct completion       tsk_mgmt_done;
+        u8                      tsk_mgmt_status;
+};
+
+/**
+ * struct srp_target_port
+ * @comp_vector: Completion vector used by the first RDMA channel created for
+ *   this target port.
+ */
+struct srp_target_port {
+        /* read and written in the hot path */
+        spinlock_t              lock;
+
+        /* read only in the hot path */
+        struct srp_rdma_ch      *ch;
+        u32                     ch_count;
         u32                     lkey;
         u32                     rkey;
         enum srp_target_state   state;
@@ -152,10 +192,8 @@ struct srp_target_port {
         unsigned int            indirect_size;
         bool                    allow_ext_sg;
 
-        /* Everything above this point is used in the hot path of
-         * command processing. Try to keep them packed into cachelines.
-         */
-
+        /* other member variables */
+        union ib_gid            sgid;
         __be64                  id_ext;
         __be64                  ioc_guid;
         __be64                  service_id;
@@ -172,34 +210,19 @@ struct srp_target_port {
         int                     comp_vector;
         int                     tl_retry_count;
 
-        struct ib_sa_path_rec   path;
-        __be16                  orig_dgid[8];
-        struct ib_sa_query     *path_query;
-        int                     path_query_id;
+        union ib_gid            orig_dgid;
+        __be16                  pkey;
 
         u32                     rq_tmo_jiffies;
         bool                    connected;
 
-        struct ib_cm_id        *cm_id;
-
-        int                     max_ti_iu_len;
-
         int                     zero_req_lim;
 
-        struct srp_iu          **tx_ring;
-        struct srp_iu          **rx_ring;
-        struct srp_request      *req_ring;
-
         struct work_struct      tl_err_work;
         struct work_struct      remove_work;
 
         struct list_head        list;
-        struct completion       done;
-        int                     status;
         bool                    qp_in_error;
-
-        struct completion       tsk_mgmt_done;
-        u8                      tsk_mgmt_status;
 };
 
 struct srp_iu {
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index bc203485716d..8afa28e4570e 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -421,7 +421,7 @@ static int evdev_open(struct inode *inode, struct file *file)
 
  err_free_client:
         evdev_detach_client(evdev, client);
-        kfree(client);
+        kvfree(client);
         return error;
 }
 
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 2ed7905a068f..fc55f0d15b70 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -1179,9 +1179,19 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                 }
 
                 ep_irq_in = &intf->cur_altsetting->endpoint[1].desc;
-                usb_fill_bulk_urb(xpad->bulk_out, udev,
-                                usb_sndbulkpipe(udev, ep_irq_in->bEndpointAddress),
-                                xpad->bdata, XPAD_PKT_LEN, xpad_bulk_out, xpad);
+                if (usb_endpoint_is_bulk_out(ep_irq_in)) {
+                        usb_fill_bulk_urb(xpad->bulk_out, udev,
+                                          usb_sndbulkpipe(udev,
+                                                          ep_irq_in->bEndpointAddress),
+                                          xpad->bdata, XPAD_PKT_LEN,
+                                          xpad_bulk_out, xpad);
+                } else {
+                        usb_fill_int_urb(xpad->bulk_out, udev,
+                                         usb_sndintpipe(udev,
+                                                        ep_irq_in->bEndpointAddress),
+                                         xpad->bdata, XPAD_PKT_LEN,
+                                         xpad_bulk_out, xpad, 0);
+                }
 
                 /*
                  * Submit the int URB immediately rather than waiting for open
diff --git a/drivers/input/keyboard/gpio_keys_polled.c b/drivers/input/keyboard/gpio_keys_polled.c
index 432d36395f35..c9c1c8ca7267 100644
--- a/drivers/input/keyboard/gpio_keys_polled.c
+++ b/drivers/input/keyboard/gpio_keys_polled.c
@@ -23,10 +23,9 @@
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
+#include <linux/gpio/consumer.h>
 #include <linux/gpio_keys.h>
-#include <linux/of.h>
-#include <linux/of_platform.h>
-#include <linux/of_gpio.h>
+#include <linux/property.h>
 
 #define DRV_NAME        "gpio-keys-polled"
 
@@ -51,15 +50,14 @@ static void gpio_keys_polled_check_state(struct input_dev *input,
         int state;
 
         if (bdata->can_sleep)
-                state = !!gpio_get_value_cansleep(button->gpio);
+                state = !!gpiod_get_value_cansleep(button->gpiod);
         else
-                state = !!gpio_get_value(button->gpio);
+                state = !!gpiod_get_value(button->gpiod);
 
         if (state != bdata->last_state) {
                 unsigned int type = button->type ?: EV_KEY;
 
-                input_event(input, type, button->code,
-                            !!(state ^ button->active_low));
+                input_event(input, type, button->code, state);
                 input_sync(input);
                 bdata->count = 0;
                 bdata->last_state = state;
@@ -102,21 +100,15 @@ static void gpio_keys_polled_close(struct input_polled_dev *dev)
                 pdata->disable(bdev->dev);
 }
 
-#ifdef CONFIG_OF
 static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct device *dev)
 {
-        struct device_node *node, *pp;
         struct gpio_keys_platform_data *pdata;
         struct gpio_keys_button *button;
+        struct fwnode_handle *child;
         int error;
         int nbuttons;
-        int i;
-
-        node = dev->of_node;
-        if (!node)
-                return NULL;
 
-        nbuttons = of_get_child_count(node);
+        nbuttons = device_get_child_node_count(dev);
         if (nbuttons == 0)
                 return NULL;
 
@@ -126,52 +118,44 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
                 return ERR_PTR(-ENOMEM);
 
         pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
-        pdata->nbuttons = nbuttons;
 
-        pdata->rep = !!of_get_property(node, "autorepeat", NULL);
-        of_property_read_u32(node, "poll-interval", &pdata->poll_interval);
+        pdata->rep = device_property_present(dev, "autorepeat");
+        device_property_read_u32(dev, "poll-interval", &pdata->poll_interval);
 
-        i = 0;
-        for_each_child_of_node(node, pp) {
-                int gpio;
-                enum of_gpio_flags flags;
+        device_for_each_child_node(dev, child) {
+                struct gpio_desc *desc;
 
-                if (!of_find_property(pp, "gpios", NULL)) {
-                        pdata->nbuttons--;
-                        dev_warn(dev, "Found button without gpios\n");
-                        continue;
-                }
-
-                gpio = of_get_gpio_flags(pp, 0, &flags);
-                if (gpio < 0) {
-                        error = gpio;
+                desc = devm_get_gpiod_from_child(dev, child);
+                if (IS_ERR(desc)) {
+                        error = PTR_ERR(desc);
                         if (error != -EPROBE_DEFER)
                                 dev_err(dev,
                                         "Failed to get gpio flags, error: %d\n",
                                         error);
+                        fwnode_handle_put(child);
                         return ERR_PTR(error);
                 }
 
-                button = &pdata->buttons[i++];
-
-                button->gpio = gpio;
-                button->active_low = flags & OF_GPIO_ACTIVE_LOW;
+                button = &pdata->buttons[pdata->nbuttons++];
+                button->gpiod = desc;
 
-                if (of_property_read_u32(pp, "linux,code", &button->code)) {
-                        dev_err(dev, "Button without keycode: 0x%x\n",
-                                button->gpio);
+                if (fwnode_property_read_u32(child, "linux,code", &button->code)) {
+                        dev_err(dev, "Button without keycode: %d\n",
+                                pdata->nbuttons - 1);
+                        fwnode_handle_put(child);
                         return ERR_PTR(-EINVAL);
                 }
 
-                button->desc = of_get_property(pp, "label", NULL);
+                fwnode_property_read_string(child, "label", &button->desc);
 
-                if (of_property_read_u32(pp, "linux,input-type", &button->type))
+                if (fwnode_property_read_u32(child, "linux,input-type",
+                                             &button->type))
                         button->type = EV_KEY;
 
-                button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);
+                button->wakeup = fwnode_property_present(child, "gpio-key,wakeup");
 
-                if (of_property_read_u32(pp, "debounce-interval",
-                                         &button->debounce_interval))
+                if (fwnode_property_read_u32(child, "debounce-interval",
+                                             &button->debounce_interval))
                         button->debounce_interval = 5;
         }
 
@@ -187,15 +171,6 @@ static const struct of_device_id gpio_keys_polled_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);
 
-#else
-
-static inline struct gpio_keys_platform_data *
-gpio_keys_polled_get_devtree_pdata(struct device *dev)
-{
-        return NULL;
-}
-#endif
-
 static int gpio_keys_polled_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
@@ -259,7 +234,6 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
         for (i = 0; i < pdata->nbuttons; i++) {
                 struct gpio_keys_button *button = &pdata->buttons[i];
                 struct gpio_keys_button_data *bdata = &bdev->data[i];
-                unsigned int gpio = button->gpio;
                 unsigned int type = button->type ?: EV_KEY;
 
                 if (button->wakeup) {
@@ -267,15 +241,31 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
                         return -EINVAL;
                 }
 
-                error = devm_gpio_request_one(&pdev->dev, gpio, GPIOF_IN,
-                                              button->desc ? : DRV_NAME);
-                if (error) {
-                        dev_err(dev, "unable to claim gpio %u, err=%d\n",
-                                gpio, error);
-                        return error;
+                /*
+                 * Legacy GPIO number so request the GPIO here and
+                 * convert it to descriptor.
+                 */
+                if (!button->gpiod && gpio_is_valid(button->gpio)) {
+                        unsigned flags = 0;
+
+                        if (button->active_low)
+                                flags |= GPIOF_ACTIVE_LOW;
+
+                        error = devm_gpio_request_one(&pdev->dev, button->gpio,
+                                        flags, button->desc ? : DRV_NAME);
+                        if (error) {
+                                dev_err(dev, "unable to claim gpio %u, err=%d\n",
+                                        button->gpio, error);
+                                return error;
+                        }
+
+                        button->gpiod = gpio_to_desc(button->gpio);
                 }
 
-                bdata->can_sleep = gpio_cansleep(gpio);
+                if (IS_ERR(button->gpiod))
+                        return PTR_ERR(button->gpiod);
+
+                bdata->can_sleep = gpiod_cansleep(button->gpiod);
                 bdata->last_state = -1;
                 bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
                                                 pdata->poll_interval);
@@ -308,7 +298,7 @@ static struct platform_driver gpio_keys_polled_driver = {
         .driver = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(gpio_keys_polled_of_match),
+                .of_match_table = gpio_keys_polled_of_match,
         },
 };
 module_platform_driver(gpio_keys_polled_driver);
diff --git a/drivers/input/keyboard/samsung-keypad.c b/drivers/input/keyboard/samsung-keypad.c
index 5e80fbf7b5ed..c994e3bbd776 100644
--- a/drivers/input/keyboard/samsung-keypad.c
+++ b/drivers/input/keyboard/samsung-keypad.c
@@ -463,7 +463,7 @@ static int samsung_keypad_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int samsung_keypad_runtime_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index 3fcb6b3cb0bd..f2b978026407 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -428,14 +428,6 @@ static void elantech_report_trackpoint(struct psmouse *psmouse,
         int x, y;
         u32 t;
 
-        if (dev_WARN_ONCE(&psmouse->ps2dev.serio->dev,
-                          !tp_dev,
-                          psmouse_fmt("Unexpected trackpoint message\n"))) {
-                if (etd->debug == 1)
-                        elantech_packet_dump(psmouse);
-                return;
-        }
-
         t = get_unaligned_le32(&packet[0]);
 
         switch (t & ~7U) {
@@ -793,7 +785,7 @@ static int elantech_packet_check_v4(struct psmouse *psmouse)
         unsigned char packet_type = packet[3] & 0x03;
         bool sanity_check;
 
-        if ((packet[3] & 0x0f) == 0x06)
+        if (etd->tp_dev && (packet[3] & 0x0f) == 0x06)
                 return PACKET_TRACKPOINT;
 
         /*
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index 2a7a9174c702..f9472920d986 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -143,6 +143,10 @@ static const struct min_max_quirk min_max_pnpid_table[] = {
                 (const char * const []){"LEN2001", NULL},
                 1024, 5022, 2508, 4832
         },
+        {
+                (const char * const []){"LEN2006", NULL},
+                1264, 5675, 1171, 4688
+        },
         { }
 };
 
diff --git a/drivers/input/touchscreen/cyttsp4_core.c b/drivers/input/touchscreen/cyttsp4_core.c
index a035a390f8e2..568a3d340c8a 100644
--- a/drivers/input/touchscreen/cyttsp4_core.c
+++ b/drivers/input/touchscreen/cyttsp4_core.c
@@ -1716,7 +1716,7 @@ static void cyttsp4_free_si_ptrs(struct cyttsp4 *cd)
         kfree(si->btn_rec_data);
 }
 
-#if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM_RUNTIME)
+#ifdef CONFIG_PM
 static int cyttsp4_core_sleep(struct cyttsp4 *cd)
 {
         int rc;
diff --git a/drivers/iommu/Kconfig b/drivers/iommu/Kconfig
index dd5112265cc9..6dbfbc209491 100644
--- a/drivers/iommu/Kconfig
+++ b/drivers/iommu/Kconfig
@@ -163,14 +163,14 @@ config TEGRA_IOMMU_GART
           hardware included on Tegra SoCs.
 
 config TEGRA_IOMMU_SMMU
-        bool "Tegra SMMU IOMMU Support"
-        depends on ARCH_TEGRA && TEGRA_AHB
+        bool "NVIDIA Tegra SMMU Support"
+        depends on ARCH_TEGRA
+        depends on TEGRA_AHB
+        depends on TEGRA_MC
         select IOMMU_API
         help
-          Enables support for remapping discontiguous physical memory
-          shared with the operating system into contiguous I/O virtual
-          space through the SMMU (System Memory Management Unit)
-          hardware included on Tegra SoCs.
+          This driver supports the IOMMU hardware (SMMU) found on NVIDIA Tegra
+          SoCs (Tegra30 up to Tegra124).
 
 config EXYNOS_IOMMU
         bool "Exynos IOMMU Support"
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index 505a9adac2d5..2d84c9edf3b8 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -3424,6 +3424,7 @@ static const struct iommu_ops amd_iommu_ops = {
         .detach_dev = amd_iommu_detach_device,
         .map = amd_iommu_map,
         .unmap = amd_iommu_unmap,
+        .map_sg = default_iommu_map_sg,
         .iova_to_phys = amd_iommu_iova_to_phys,
         .pgsize_bitmap  = AMD_IOMMU_PGSIZES,
 };
diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c
index 60558f794922..e393ae01b5d2 100644
--- a/drivers/iommu/arm-smmu.c
+++ b/drivers/iommu/arm-smmu.c
@@ -1652,6 +1652,7 @@ static const struct iommu_ops arm_smmu_ops = {
         .detach_dev     = arm_smmu_detach_dev,
         .map            = arm_smmu_map,
         .unmap          = arm_smmu_unmap,
+        .map_sg         = default_iommu_map_sg,
         .iova_to_phys   = arm_smmu_iova_to_phys,
         .add_device     = arm_smmu_add_device,
         .remove_device  = arm_smmu_remove_device,
diff --git a/drivers/iommu/exynos-iommu.c b/drivers/iommu/exynos-iommu.c
index 74233186f6f7..28372b85d8da 100644
--- a/drivers/iommu/exynos-iommu.c
+++ b/drivers/iommu/exynos-iommu.c
@@ -1178,6 +1178,7 @@ static const struct iommu_ops exynos_iommu_ops = {
         .detach_dev = exynos_iommu_detach_device,
         .map = exynos_iommu_map,
         .unmap = exynos_iommu_unmap,
+        .map_sg = default_iommu_map_sg,
         .iova_to_phys = exynos_iommu_iova_to_phys,
         .add_device = exynos_iommu_add_device,
         .remove_device = exynos_iommu_remove_device,
diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index a27d6cb1a793..02cd26a17fe0 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -4467,6 +4467,7 @@ static const struct iommu_ops intel_iommu_ops = {
         .detach_dev     = intel_iommu_detach_device,
         .map            = intel_iommu_map,
         .unmap          = intel_iommu_unmap,
+        .map_sg         = default_iommu_map_sg,
         .iova_to_phys   = intel_iommu_iova_to_phys,
         .add_device     = intel_iommu_add_device,
         .remove_device  = intel_iommu_remove_device,
diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index ed8b04867b1f..02e4313e937c 100644
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -818,7 +818,15 @@ static int iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
                 kfree(nb);
                 return err;
         }
-        return bus_for_each_dev(bus, NULL, &cb, add_iommu_group);
+
+        err = bus_for_each_dev(bus, NULL, &cb, add_iommu_group);
+        if (err) {
+                bus_unregister_notifier(bus, nb);
+                kfree(nb);
+                return err;
+        }
+
+        return 0;
 }
 
 /**
@@ -836,13 +844,19 @@ static int iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
  */
 int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops)
 {
+        int err;
+
         if (bus->iommu_ops != NULL)
                 return -EBUSY;
 
         bus->iommu_ops = ops;
 
         /* Do IOMMU specific setup for this bus-type */
-        return iommu_bus_init(bus, ops);
+        err = iommu_bus_init(bus, ops);
+        if (err)
+                bus->iommu_ops = NULL;
+
+        return err;
 }
 EXPORT_SYMBOL_GPL(bus_set_iommu);
 
@@ -1124,6 +1138,38 @@ size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
 }
 EXPORT_SYMBOL_GPL(iommu_unmap);
 
+size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
+                         struct scatterlist *sg, unsigned int nents, int prot)
+{
+        struct scatterlist *s;
+        size_t mapped = 0;
+        unsigned int i;
+        int ret;
+
+        for_each_sg(sg, s, nents, i) {
+                phys_addr_t phys = page_to_phys(sg_page(s));
+
+                /* We are mapping on page boundarys, so offset must be 0 */
+                if (s->offset)
+                        goto out_err;
+
+                ret = iommu_map(domain, iova + mapped, phys, s->length, prot);
+                if (ret)
+                        goto out_err;
+
+                mapped += s->length;
+        }
+
+        return mapped;
+
+out_err:
+        /* undo mappings already done */
+        iommu_unmap(domain, iova, mapped);
+
+        return 0;
+
+}
+EXPORT_SYMBOL_GPL(default_iommu_map_sg);
 
 int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
                                phys_addr_t paddr, u64 size, int prot)
diff --git a/drivers/iommu/ipmmu-vmsa.c b/drivers/iommu/ipmmu-vmsa.c
index 7dab5cbcc775..e509c58eee92 100644
--- a/drivers/iommu/ipmmu-vmsa.c
+++ b/drivers/iommu/ipmmu-vmsa.c
@@ -1127,6 +1127,7 @@ static const struct iommu_ops ipmmu_ops = {
         .detach_dev = ipmmu_detach_device,
         .map = ipmmu_map,
         .unmap = ipmmu_unmap,
+        .map_sg = default_iommu_map_sg,
         .iova_to_phys = ipmmu_iova_to_phys,
         .add_device = ipmmu_add_device,
         .remove_device = ipmmu_remove_device,
diff --git a/drivers/iommu/irq_remapping.c b/drivers/iommu/irq_remapping.c
index 74a1767c89b5..2c3f5ad01098 100644
--- a/drivers/iommu/irq_remapping.c
+++ b/drivers/iommu/irq_remapping.c
@@ -56,19 +56,13 @@ static int do_setup_msi_irqs(struct pci_dev *dev, int nvec)
         unsigned int irq;
         struct msi_desc *msidesc;
 
-        WARN_ON(!list_is_singular(&dev->msi_list));
         msidesc = list_entry(dev->msi_list.next, struct msi_desc, list);
-        WARN_ON(msidesc->irq);
-        WARN_ON(msidesc->msi_attrib.multiple);
-        WARN_ON(msidesc->nvec_used);
 
         irq = irq_alloc_hwirqs(nvec, dev_to_node(&dev->dev));
         if (irq == 0)
                 return -ENOSPC;
 
         nvec_pow2 = __roundup_pow_of_two(nvec);
-        msidesc->nvec_used = nvec;
-        msidesc->msi_attrib.multiple = ilog2(nvec_pow2);
         for (sub_handle = 0; sub_handle < nvec; sub_handle++) {
                 if (!sub_handle) {
                         index = msi_alloc_remapped_irq(dev, irq, nvec_pow2);
@@ -96,8 +90,6 @@ error:
          * IRQs from tearing down again in default_teardown_msi_irqs()
          */
         msidesc->irq = 0;
-        msidesc->nvec_used = 0;
-        msidesc->msi_attrib.multiple = 0;
 
         return ret;
 }
diff --git a/drivers/iommu/msm_iommu.c b/drivers/iommu/msm_iommu.c
index 6e3dcc289d59..1c7b78ecf3e3 100644
--- a/drivers/iommu/msm_iommu.c
+++ b/drivers/iommu/msm_iommu.c
@@ -681,6 +681,7 @@ static const struct iommu_ops msm_iommu_ops = {
         .detach_dev = msm_iommu_detach_dev,
         .map = msm_iommu_map,
         .unmap = msm_iommu_unmap,
+        .map_sg = default_iommu_map_sg,
         .iova_to_phys = msm_iommu_iova_to_phys,
         .pgsize_bitmap = MSM_IOMMU_PGSIZES,
 };
diff --git a/drivers/iommu/omap-iommu.c b/drivers/iommu/omap-iommu.c
index 36278870e84a..18003c044454 100644
--- a/drivers/iommu/omap-iommu.c
+++ b/drivers/iommu/omap-iommu.c
@@ -1288,6 +1288,7 @@ static const struct iommu_ops omap_iommu_ops = {
         .detach_dev     = omap_iommu_detach_dev,
         .map            = omap_iommu_map,
         .unmap          = omap_iommu_unmap,
+        .map_sg         = default_iommu_map_sg,
         .iova_to_phys   = omap_iommu_iova_to_phys,
         .add_device     = omap_iommu_add_device,
         .remove_device  = omap_iommu_remove_device,
diff --git a/drivers/iommu/shmobile-iommu.c b/drivers/iommu/shmobile-iommu.c
index 1333e6fb3405..f1b00774e4de 100644
--- a/drivers/iommu/shmobile-iommu.c
+++ b/drivers/iommu/shmobile-iommu.c
@@ -361,6 +361,7 @@ static const struct iommu_ops shmobile_iommu_ops = {
         .detach_dev = shmobile_iommu_detach_device,
         .map = shmobile_iommu_map,
         .unmap = shmobile_iommu_unmap,
+        .map_sg = default_iommu_map_sg,
         .iova_to_phys = shmobile_iommu_iova_to_phys,
         .add_device = shmobile_iommu_add_device,
         .pgsize_bitmap = SZ_1M | SZ_64K | SZ_4K,
diff --git a/drivers/iommu/tegra-smmu.c b/drivers/iommu/tegra-smmu.c
index 3afdf43f732a..6e134c7c227f 100644
--- a/drivers/iommu/tegra-smmu.c
+++ b/drivers/iommu/tegra-smmu.c
@@ -1,1295 +1,732 @@
 /*
- * IOMMU API for SMMU in Tegra30
+ * Copyright (C) 2011-2014 NVIDIA CORPORATION.  All rights reserved.
  *
- * Copyright (c) 2011-2013, NVIDIA CORPORATION.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
  */
 
-#define pr_fmt(fmt)     "%s(): " fmt, __func__
-
 #include <linux/err.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/spinlock.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-#include <linux/mm.h>
-#include <linux/pagemap.h>
-#include <linux/device.h>
-#include <linux/sched.h>
 #include <linux/iommu.h>
-#include <linux/io.h>
+#include <linux/kernel.h>
 #include <linux/of.h>
-#include <linux/of_iommu.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #include <soc/tegra/ahb.h>
+#include <soc/tegra/mc.h>
 
-#include <asm/page.h>
-#include <asm/cacheflush.h>
-
-enum smmu_hwgrp {
-        HWGRP_AFI,
-        HWGRP_AVPC,
-        HWGRP_DC,
-        HWGRP_DCB,
-        HWGRP_EPP,
-        HWGRP_G2,
-        HWGRP_HC,
-        HWGRP_HDA,
-        HWGRP_ISP,
-        HWGRP_MPE,
-        HWGRP_NV,
-        HWGRP_NV2,
-        HWGRP_PPCS,
-        HWGRP_SATA,
-        HWGRP_VDE,
-        HWGRP_VI,
-
-        HWGRP_COUNT,
-
-        HWGRP_END = ~0,
-};
+struct tegra_smmu {
+        void __iomem *regs;
+        struct device *dev;
 
-#define HWG_AFI         (1 << HWGRP_AFI)
-#define HWG_AVPC        (1 << HWGRP_AVPC)
-#define HWG_DC          (1 << HWGRP_DC)
-#define HWG_DCB         (1 << HWGRP_DCB)
-#define HWG_EPP         (1 << HWGRP_EPP)
-#define HWG_G2          (1 << HWGRP_G2)
-#define HWG_HC          (1 << HWGRP_HC)
-#define HWG_HDA         (1 << HWGRP_HDA)
-#define HWG_ISP         (1 << HWGRP_ISP)
-#define HWG_MPE         (1 << HWGRP_MPE)
-#define HWG_NV          (1 << HWGRP_NV)
-#define HWG_NV2         (1 << HWGRP_NV2)
-#define HWG_PPCS        (1 << HWGRP_PPCS)
-#define HWG_SATA        (1 << HWGRP_SATA)
-#define HWG_VDE         (1 << HWGRP_VDE)
-#define HWG_VI          (1 << HWGRP_VI)
-
-/* bitmap of the page sizes currently supported */
-#define SMMU_IOMMU_PGSIZES      (SZ_4K)
-
-#define SMMU_CONFIG                             0x10
-#define SMMU_CONFIG_DISABLE                     0
-#define SMMU_CONFIG_ENABLE                      1
-
-/* REVISIT: To support multiple MCs */
-enum {
-        _MC = 0,
-};
+        struct tegra_mc *mc;
+        const struct tegra_smmu_soc *soc;
 
-enum {
-        _TLB = 0,
-        _PTC,
-};
+        unsigned long *asids;
+        struct mutex lock;
 
-#define SMMU_CACHE_CONFIG_BASE                  0x14
-#define __SMMU_CACHE_CONFIG(mc, cache)          (SMMU_CACHE_CONFIG_BASE + 4 * cache)
-#define SMMU_CACHE_CONFIG(cache)                __SMMU_CACHE_CONFIG(_MC, cache)
-
-#define SMMU_CACHE_CONFIG_STATS_SHIFT           31
-#define SMMU_CACHE_CONFIG_STATS_ENABLE          (1 << SMMU_CACHE_CONFIG_STATS_SHIFT)
-#define SMMU_CACHE_CONFIG_STATS_TEST_SHIFT      30
-#define SMMU_CACHE_CONFIG_STATS_TEST            (1 << SMMU_CACHE_CONFIG_STATS_TEST_SHIFT)
-
-#define SMMU_TLB_CONFIG_HIT_UNDER_MISS__ENABLE  (1 << 29)
-#define SMMU_TLB_CONFIG_ACTIVE_LINES__VALUE     0x10
-#define SMMU_TLB_CONFIG_RESET_VAL               0x20000010
-
-#define SMMU_PTC_CONFIG_CACHE__ENABLE           (1 << 29)
-#define SMMU_PTC_CONFIG_INDEX_MAP__PATTERN      0x3f
-#define SMMU_PTC_CONFIG_RESET_VAL               0x2000003f
-
-#define SMMU_PTB_ASID                           0x1c
-#define SMMU_PTB_ASID_CURRENT_SHIFT             0
-
-#define SMMU_PTB_DATA                           0x20
-#define SMMU_PTB_DATA_RESET_VAL                 0
-#define SMMU_PTB_DATA_ASID_NONSECURE_SHIFT      29
-#define SMMU_PTB_DATA_ASID_WRITABLE_SHIFT       30
-#define SMMU_PTB_DATA_ASID_READABLE_SHIFT       31
-
-#define SMMU_TLB_FLUSH                          0x30
-#define SMMU_TLB_FLUSH_VA_MATCH_ALL             0
-#define SMMU_TLB_FLUSH_VA_MATCH_SECTION         2
-#define SMMU_TLB_FLUSH_VA_MATCH_GROUP           3
-#define SMMU_TLB_FLUSH_ASID_SHIFT               29
-#define SMMU_TLB_FLUSH_ASID_MATCH_DISABLE       0
-#define SMMU_TLB_FLUSH_ASID_MATCH_ENABLE        1
-#define SMMU_TLB_FLUSH_ASID_MATCH_SHIFT         31
-
-#define SMMU_PTC_FLUSH                          0x34
-#define SMMU_PTC_FLUSH_TYPE_ALL                 0
-#define SMMU_PTC_FLUSH_TYPE_ADR                 1
-#define SMMU_PTC_FLUSH_ADR_SHIFT                4
-
-#define SMMU_ASID_SECURITY                      0x38
-
-#define SMMU_STATS_CACHE_COUNT_BASE             0x1f0
-
-#define SMMU_STATS_CACHE_COUNT(mc, cache, hitmiss)              \
-        (SMMU_STATS_CACHE_COUNT_BASE + 8 * cache + 4 * hitmiss)
-
-#define SMMU_TRANSLATION_ENABLE_0               0x228
-#define SMMU_TRANSLATION_ENABLE_1               0x22c
-#define SMMU_TRANSLATION_ENABLE_2               0x230
-
-#define SMMU_AFI_ASID   0x238   /* PCIE */
-#define SMMU_AVPC_ASID  0x23c   /* AVP */
-#define SMMU_DC_ASID    0x240   /* Display controller */
-#define SMMU_DCB_ASID   0x244   /* Display controller B */
-#define SMMU_EPP_ASID   0x248   /* Encoder pre-processor */
-#define SMMU_G2_ASID    0x24c   /* 2D engine */
-#define SMMU_HC_ASID    0x250   /* Host1x */
-#define SMMU_HDA_ASID   0x254   /* High-def audio */
-#define SMMU_ISP_ASID   0x258   /* Image signal processor */
-#define SMMU_MPE_ASID   0x264   /* MPEG encoder */
-#define SMMU_NV_ASID    0x268   /* (3D) */
-#define SMMU_NV2_ASID   0x26c   /* (3D) */
-#define SMMU_PPCS_ASID  0x270   /* AHB */
-#define SMMU_SATA_ASID  0x278   /* SATA */
-#define SMMU_VDE_ASID   0x27c   /* Video decoder */
-#define SMMU_VI_ASID    0x280   /* Video input */
-
-#define SMMU_PDE_NEXT_SHIFT             28
-
-#define SMMU_TLB_FLUSH_VA_SECTION__MASK         0xffc00000
-#define SMMU_TLB_FLUSH_VA_SECTION__SHIFT        12 /* right shift */
-#define SMMU_TLB_FLUSH_VA_GROUP__MASK           0xffffc000
-#define SMMU_TLB_FLUSH_VA_GROUP__SHIFT          12 /* right shift */
-#define SMMU_TLB_FLUSH_VA(iova, which)  \
-        ((((iova) & SMMU_TLB_FLUSH_VA_##which##__MASK) >> \
-                SMMU_TLB_FLUSH_VA_##which##__SHIFT) |   \
-        SMMU_TLB_FLUSH_VA_MATCH_##which)
-#define SMMU_PTB_ASID_CUR(n)    \
-                ((n) << SMMU_PTB_ASID_CURRENT_SHIFT)
-#define SMMU_TLB_FLUSH_ASID_MATCH_disable               \
-                (SMMU_TLB_FLUSH_ASID_MATCH_DISABLE <<   \
-                        SMMU_TLB_FLUSH_ASID_MATCH_SHIFT)
-#define SMMU_TLB_FLUSH_ASID_MATCH__ENABLE               \
-                (SMMU_TLB_FLUSH_ASID_MATCH_ENABLE <<    \
-                        SMMU_TLB_FLUSH_ASID_MATCH_SHIFT)
-
-#define SMMU_PAGE_SHIFT 12
-#define SMMU_PAGE_SIZE  (1 << SMMU_PAGE_SHIFT)
-#define SMMU_PAGE_MASK  ((1 << SMMU_PAGE_SHIFT) - 1)
-
-#define SMMU_PDIR_COUNT 1024
-#define SMMU_PDIR_SIZE  (sizeof(unsigned long) * SMMU_PDIR_COUNT)
-#define SMMU_PTBL_COUNT 1024
-#define SMMU_PTBL_SIZE  (sizeof(unsigned long) * SMMU_PTBL_COUNT)
-#define SMMU_PDIR_SHIFT 12
-#define SMMU_PDE_SHIFT  12
-#define SMMU_PTE_SHIFT  12
-#define SMMU_PFN_MASK   0x000fffff
-
-#define SMMU_ADDR_TO_PFN(addr)  ((addr) >> 12)
-#define SMMU_ADDR_TO_PDN(addr)  ((addr) >> 22)
-#define SMMU_PDN_TO_ADDR(pdn)   ((pdn) << 22)
-
-#define _READABLE       (1 << SMMU_PTB_DATA_ASID_READABLE_SHIFT)
-#define _WRITABLE       (1 << SMMU_PTB_DATA_ASID_WRITABLE_SHIFT)
-#define _NONSECURE      (1 << SMMU_PTB_DATA_ASID_NONSECURE_SHIFT)
-#define _PDE_NEXT       (1 << SMMU_PDE_NEXT_SHIFT)
-#define _MASK_ATTR      (_READABLE | _WRITABLE | _NONSECURE)
-
-#define _PDIR_ATTR      (_READABLE | _WRITABLE | _NONSECURE)
-
-#define _PDE_ATTR       (_READABLE | _WRITABLE | _NONSECURE)
-#define _PDE_ATTR_N     (_PDE_ATTR | _PDE_NEXT)
-#define _PDE_VACANT(pdn)        (((pdn) << 10) | _PDE_ATTR)
-
-#define _PTE_ATTR       (_READABLE | _WRITABLE | _NONSECURE)
-#define _PTE_VACANT(addr)       (((addr) >> SMMU_PAGE_SHIFT) | _PTE_ATTR)
-
-#define SMMU_MK_PDIR(page, attr)        \
-                ((page_to_phys(page) >> SMMU_PDIR_SHIFT) | (attr))
-#define SMMU_MK_PDE(page, attr)         \
-                (unsigned long)((page_to_phys(page) >> SMMU_PDE_SHIFT) | (attr))
-#define SMMU_EX_PTBL_PAGE(pde)          \
-                pfn_to_page((unsigned long)(pde) & SMMU_PFN_MASK)
-#define SMMU_PFN_TO_PTE(pfn, attr)      (unsigned long)((pfn) | (attr))
-
-#define SMMU_ASID_ENABLE(asid)  ((asid) | (1 << 31))
-#define SMMU_ASID_DISABLE       0
-#define SMMU_ASID_ASID(n)       ((n) & ~SMMU_ASID_ENABLE(0))
-
-#define NUM_SMMU_REG_BANKS      3
-
-#define smmu_client_enable_hwgrp(c, m)  smmu_client_set_hwgrp(c, m, 1)
-#define smmu_client_disable_hwgrp(c)    smmu_client_set_hwgrp(c, 0, 0)
-#define __smmu_client_enable_hwgrp(c, m) __smmu_client_set_hwgrp(c, m, 1)
-#define __smmu_client_disable_hwgrp(c)  __smmu_client_set_hwgrp(c, 0, 0)
-
-#define HWGRP_INIT(client) [HWGRP_##client] = SMMU_##client##_ASID
-
-static const u32 smmu_hwgrp_asid_reg[] = {
-        HWGRP_INIT(AFI),
-        HWGRP_INIT(AVPC),
-        HWGRP_INIT(DC),
-        HWGRP_INIT(DCB),
-        HWGRP_INIT(EPP),
-        HWGRP_INIT(G2),
-        HWGRP_INIT(HC),
-        HWGRP_INIT(HDA),
-        HWGRP_INIT(ISP),
-        HWGRP_INIT(MPE),
-        HWGRP_INIT(NV),
-        HWGRP_INIT(NV2),
-        HWGRP_INIT(PPCS),
-        HWGRP_INIT(SATA),
-        HWGRP_INIT(VDE),
-        HWGRP_INIT(VI),
+        struct list_head list;
 };
-#define HWGRP_ASID_REG(x) (smmu_hwgrp_asid_reg[x])
 
-/*
- * Per client for address space
- */
-struct smmu_client {
-        struct device           *dev;
-        struct list_head        list;
-        struct smmu_as          *as;
-        u32                     hwgrp;
+struct tegra_smmu_as {
+        struct iommu_domain *domain;
+        struct tegra_smmu *smmu;
+        unsigned int use_count;
+        struct page *count;
+        struct page *pd;
+        unsigned id;
+        u32 attr;
 };
 
-/*
- * Per address space
- */
-struct smmu_as {
-        struct smmu_device      *smmu;  /* back pointer to container */
-        unsigned int            asid;
-        spinlock_t              lock;   /* for pagetable */
-        struct page             *pdir_page;
-        unsigned long           pdir_attr;
-        unsigned long           pde_attr;
-        unsigned long           pte_attr;
-        unsigned int            *pte_count;
-
-        struct list_head        client;
-        spinlock_t              client_lock; /* for client list */
-};
+static inline void smmu_writel(struct tegra_smmu *smmu, u32 value,
+                               unsigned long offset)
+{
+        writel(value, smmu->regs + offset);
+}
 
-struct smmu_debugfs_info {
-        struct smmu_device *smmu;
-        int mc;
-        int cache;
-};
+static inline u32 smmu_readl(struct tegra_smmu *smmu, unsigned long offset)
+{
+        return readl(smmu->regs + offset);
+}
 
-/*
- * Per SMMU device - IOMMU device
- */
-struct smmu_device {
-        void __iomem    *regbase;       /* register offset base */
-        void __iomem    **regs;         /* register block start address array */
-        void __iomem    **rege;         /* register block end address array */
-        int             nregs;          /* number of register blocks */
-
-        unsigned long   iovmm_base;     /* remappable base address */
-        unsigned long   page_count;     /* total remappable size */
-        spinlock_t      lock;
-        char            *name;
-        struct device   *dev;
-        struct page *avp_vector_page;   /* dummy page shared by all AS's */
+#define SMMU_CONFIG 0x010
+#define  SMMU_CONFIG_ENABLE (1 << 0)
 
-        /*
-         * Register image savers for suspend/resume
-         */
-        unsigned long translation_enable_0;
-        unsigned long translation_enable_1;
-        unsigned long translation_enable_2;
-        unsigned long asid_security;
+#define SMMU_TLB_CONFIG 0x14
+#define  SMMU_TLB_CONFIG_HIT_UNDER_MISS (1 << 29)
+#define  SMMU_TLB_CONFIG_ROUND_ROBIN_ARBITRATION (1 << 28)
+#define  SMMU_TLB_CONFIG_ACTIVE_LINES(x) ((x) & 0x3f)
 
-        struct dentry *debugfs_root;
-        struct smmu_debugfs_info *debugfs_info;
+#define SMMU_PTC_CONFIG 0x18
+#define  SMMU_PTC_CONFIG_ENABLE (1 << 29)
+#define  SMMU_PTC_CONFIG_REQ_LIMIT(x) (((x) & 0x0f) << 24)
+#define  SMMU_PTC_CONFIG_INDEX_MAP(x) ((x) & 0x3f)
 
-        struct device_node *ahb;
+#define SMMU_PTB_ASID 0x01c
+#define  SMMU_PTB_ASID_VALUE(x) ((x) & 0x7f)
 
-        int             num_as;
-        struct smmu_as  as[0];          /* Run-time allocated array */
-};
+#define SMMU_PTB_DATA 0x020
+#define  SMMU_PTB_DATA_VALUE(page, attr) (page_to_phys(page) >> 12 | (attr))
 
-static struct smmu_device *smmu_handle; /* unique for a system */
+#define SMMU_MK_PDE(page, attr) (page_to_phys(page) >> SMMU_PTE_SHIFT | (attr))
 
-/*
- *      SMMU register accessors
- */
-static bool inline smmu_valid_reg(struct smmu_device *smmu,
-                                  void __iomem *addr)
-{
-        int i;
+#define SMMU_TLB_FLUSH 0x030
+#define  SMMU_TLB_FLUSH_VA_MATCH_ALL     (0 << 0)
+#define  SMMU_TLB_FLUSH_VA_MATCH_SECTION (2 << 0)
+#define  SMMU_TLB_FLUSH_VA_MATCH_GROUP   (3 << 0)
+#define  SMMU_TLB_FLUSH_ASID(x)          (((x) & 0x7f) << 24)
+#define  SMMU_TLB_FLUSH_VA_SECTION(addr) ((((addr) & 0xffc00000) >> 12) | \
+                                          SMMU_TLB_FLUSH_VA_MATCH_SECTION)
+#define  SMMU_TLB_FLUSH_VA_GROUP(addr)   ((((addr) & 0xffffc000) >> 12) | \
+                                          SMMU_TLB_FLUSH_VA_MATCH_GROUP)
+#define  SMMU_TLB_FLUSH_ASID_MATCH       (1 << 31)
 
-        for (i = 0; i < smmu->nregs; i++) {
-                if (addr < smmu->regs[i])
-                        break;
-                if (addr <= smmu->rege[i])
-                        return true;
-        }
+#define SMMU_PTC_FLUSH 0x034
+#define  SMMU_PTC_FLUSH_TYPE_ALL (0 << 0)
+#define  SMMU_PTC_FLUSH_TYPE_ADR (1 << 0)
 
-        return false;
-}
+#define SMMU_PTC_FLUSH_HI 0x9b8
+#define  SMMU_PTC_FLUSH_HI_MASK 0x3
 
-static inline u32 smmu_read(struct smmu_device *smmu, size_t offs)
-{
-        void __iomem *addr = smmu->regbase + offs;
+/* per-SWGROUP SMMU_*_ASID register */
+#define SMMU_ASID_ENABLE (1 << 31)
+#define SMMU_ASID_MASK 0x7f
+#define SMMU_ASID_VALUE(x) ((x) & SMMU_ASID_MASK)
 
-        BUG_ON(!smmu_valid_reg(smmu, addr));
+/* page table definitions */
+#define SMMU_NUM_PDE 1024
+#define SMMU_NUM_PTE 1024
 
-        return readl(addr);
-}
+#define SMMU_SIZE_PD (SMMU_NUM_PDE * 4)
+#define SMMU_SIZE_PT (SMMU_NUM_PTE * 4)
 
-static inline void smmu_write(struct smmu_device *smmu, u32 val, size_t offs)
-{
-        void __iomem *addr = smmu->regbase + offs;
+#define SMMU_PDE_SHIFT 22
+#define SMMU_PTE_SHIFT 12
 
-        BUG_ON(!smmu_valid_reg(smmu, addr));
+#define SMMU_PFN_MASK 0x000fffff
 
-        writel(val, addr);
-}
+#define SMMU_PD_READABLE        (1 << 31)
+#define SMMU_PD_WRITABLE        (1 << 30)
+#define SMMU_PD_NONSECURE       (1 << 29)
 
-#define VA_PAGE_TO_PA(va, page) \
-        (page_to_phys(page) + ((unsigned long)(va) & ~PAGE_MASK))
+#define SMMU_PDE_READABLE       (1 << 31)
+#define SMMU_PDE_WRITABLE       (1 << 30)
+#define SMMU_PDE_NONSECURE      (1 << 29)
+#define SMMU_PDE_NEXT           (1 << 28)
 
-#define FLUSH_CPU_DCACHE(va, page, size)        \
-        do {    \
-                unsigned long _pa_ = VA_PAGE_TO_PA(va, page);           \
-                __cpuc_flush_dcache_area((void *)(va), (size_t)(size)); \
-                outer_flush_range(_pa_, _pa_+(size_t)(size));           \
-        } while (0)
+#define SMMU_PTE_READABLE       (1 << 31)
+#define SMMU_PTE_WRITABLE       (1 << 30)
+#define SMMU_PTE_NONSECURE      (1 << 29)
 
-/*
- * Any interaction between any block on PPSB and a block on APB or AHB
- * must have these read-back barriers to ensure the APB/AHB bus
- * transaction is complete before initiating activity on the PPSB
- * block.
- */
-#define FLUSH_SMMU_REGS(smmu)   smmu_read(smmu, SMMU_CONFIG)
+#define SMMU_PDE_ATTR           (SMMU_PDE_READABLE | SMMU_PDE_WRITABLE | \
+                                 SMMU_PDE_NONSECURE)
+#define SMMU_PTE_ATTR           (SMMU_PTE_READABLE | SMMU_PTE_WRITABLE | \
+                                 SMMU_PTE_NONSECURE)
 
-#define smmu_client_hwgrp(c) (u32)((c)->dev->platform_data)
-
-static int __smmu_client_set_hwgrp(struct smmu_client *c,
-                                   unsigned long map, int on)
+static inline void smmu_flush_ptc(struct tegra_smmu *smmu, struct page *page,
+                                  unsigned long offset)
 {
-        int i;
-        struct smmu_as *as = c->as;
-        u32 val, offs, mask = SMMU_ASID_ENABLE(as->asid);
-        struct smmu_device *smmu = as->smmu;
-
-        WARN_ON(!on && map);
-        if (on && !map)
-                return -EINVAL;
-        if (!on)
-                map = smmu_client_hwgrp(c);
-
-        for_each_set_bit(i, &map, HWGRP_COUNT) {
-                offs = HWGRP_ASID_REG(i);
-                val = smmu_read(smmu, offs);
-                if (on) {
-                        if (WARN_ON(val & mask))
-                                goto err_hw_busy;
-                        val |= mask;
-                } else {
-                        WARN_ON((val & mask) == mask);
-                        val &= ~mask;
+        phys_addr_t phys = page ? page_to_phys(page) : 0;
+        u32 value;
+
+        if (page) {
+                offset &= ~(smmu->mc->soc->atom_size - 1);
+
+                if (smmu->mc->soc->num_address_bits > 32) {
+#ifdef CONFIG_PHYS_ADDR_T_64BIT
+                        value = (phys >> 32) & SMMU_PTC_FLUSH_HI_MASK;
+#else
+                        value = 0;
+#endif
+                        smmu_writel(smmu, value, SMMU_PTC_FLUSH_HI);
                 }
-                smmu_write(smmu, val, offs);
-        }
-        FLUSH_SMMU_REGS(smmu);
-        c->hwgrp = map;
-        return 0;
 
-err_hw_busy:
-        for_each_set_bit(i, &map, HWGRP_COUNT) {
-                offs = HWGRP_ASID_REG(i);
-                val = smmu_read(smmu, offs);
-                val &= ~mask;
-                smmu_write(smmu, val, offs);
+                value = (phys + offset) | SMMU_PTC_FLUSH_TYPE_ADR;
+        } else {
+                value = SMMU_PTC_FLUSH_TYPE_ALL;
         }
-        return -EBUSY;
+
+        smmu_writel(smmu, value, SMMU_PTC_FLUSH);
 }
 
-static int smmu_client_set_hwgrp(struct smmu_client *c, u32 map, int on)
+static inline void smmu_flush_tlb(struct tegra_smmu *smmu)
 {
-        u32 val;
-        unsigned long flags;
-        struct smmu_as *as = c->as;
-        struct smmu_device *smmu = as->smmu;
-
-        spin_lock_irqsave(&smmu->lock, flags);
-        val = __smmu_client_set_hwgrp(c, map, on);
-        spin_unlock_irqrestore(&smmu->lock, flags);
-        return val;
+        smmu_writel(smmu, SMMU_TLB_FLUSH_VA_MATCH_ALL, SMMU_TLB_FLUSH);
 }
 
-/*
- * Flush all TLB entries and all PTC entries
- * Caller must lock smmu
- */
-static void smmu_flush_regs(struct smmu_device *smmu, int enable)
+static inline void smmu_flush_tlb_asid(struct tegra_smmu *smmu,
+                                       unsigned long asid)
 {
-        u32 val;
-
-        smmu_write(smmu, SMMU_PTC_FLUSH_TYPE_ALL, SMMU_PTC_FLUSH);
-        FLUSH_SMMU_REGS(smmu);
-        val = SMMU_TLB_FLUSH_VA_MATCH_ALL |
-                SMMU_TLB_FLUSH_ASID_MATCH_disable;
-        smmu_write(smmu, val, SMMU_TLB_FLUSH);
+        u32 value;
 
-        if (enable)
-                smmu_write(smmu, SMMU_CONFIG_ENABLE, SMMU_CONFIG);
-        FLUSH_SMMU_REGS(smmu);
+        value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
+                SMMU_TLB_FLUSH_VA_MATCH_ALL;
+        smmu_writel(smmu, value, SMMU_TLB_FLUSH);
 }
 
-static int smmu_setup_regs(struct smmu_device *smmu)
+static inline void smmu_flush_tlb_section(struct tegra_smmu *smmu,
+                                          unsigned long asid,
+                                          unsigned long iova)
 {
-        int i;
-        u32 val;
+        u32 value;
 
-        for (i = 0; i < smmu->num_as; i++) {
-                struct smmu_as *as = &smmu->as[i];
-                struct smmu_client *c;
-
-                smmu_write(smmu, SMMU_PTB_ASID_CUR(as->asid), SMMU_PTB_ASID);
-                val = as->pdir_page ?
-                        SMMU_MK_PDIR(as->pdir_page, as->pdir_attr) :
-                        SMMU_PTB_DATA_RESET_VAL;
-                smmu_write(smmu, val, SMMU_PTB_DATA);
-
-                list_for_each_entry(c, &as->client, list)
-                        __smmu_client_set_hwgrp(c, c->hwgrp, 1);
-        }
-
-        smmu_write(smmu, smmu->translation_enable_0, SMMU_TRANSLATION_ENABLE_0);
-        smmu_write(smmu, smmu->translation_enable_1, SMMU_TRANSLATION_ENABLE_1);
-        smmu_write(smmu, smmu->translation_enable_2, SMMU_TRANSLATION_ENABLE_2);
-        smmu_write(smmu, smmu->asid_security, SMMU_ASID_SECURITY);
-        smmu_write(smmu, SMMU_TLB_CONFIG_RESET_VAL, SMMU_CACHE_CONFIG(_TLB));
-        smmu_write(smmu, SMMU_PTC_CONFIG_RESET_VAL, SMMU_CACHE_CONFIG(_PTC));
-
-        smmu_flush_regs(smmu, 1);
-
-        return tegra_ahb_enable_smmu(smmu->ahb);
+        value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
+                SMMU_TLB_FLUSH_VA_SECTION(iova);
+        smmu_writel(smmu, value, SMMU_TLB_FLUSH);
 }
 
-static void flush_ptc_and_tlb(struct smmu_device *smmu,
-                      struct smmu_as *as, dma_addr_t iova,
-                      unsigned long *pte, struct page *page, int is_pde)
+static inline void smmu_flush_tlb_group(struct tegra_smmu *smmu,
+                                        unsigned long asid,
+                                        unsigned long iova)
 {
-        u32 val;
-        unsigned long tlb_flush_va = is_pde
-                ?  SMMU_TLB_FLUSH_VA(iova, SECTION)
-                :  SMMU_TLB_FLUSH_VA(iova, GROUP);
-
-        val = SMMU_PTC_FLUSH_TYPE_ADR | VA_PAGE_TO_PA(pte, page);
-        smmu_write(smmu, val, SMMU_PTC_FLUSH);
-        FLUSH_SMMU_REGS(smmu);
-        val = tlb_flush_va |
-                SMMU_TLB_FLUSH_ASID_MATCH__ENABLE |
-                (as->asid << SMMU_TLB_FLUSH_ASID_SHIFT);
-        smmu_write(smmu, val, SMMU_TLB_FLUSH);
-        FLUSH_SMMU_REGS(smmu);
-}
+        u32 value;
 
-static void free_ptbl(struct smmu_as *as, dma_addr_t iova)
-{
-        unsigned long pdn = SMMU_ADDR_TO_PDN(iova);
-        unsigned long *pdir = (unsigned long *)page_address(as->pdir_page);
-
-        if (pdir[pdn] != _PDE_VACANT(pdn)) {
-                dev_dbg(as->smmu->dev, "pdn: %lx\n", pdn);
-
-                ClearPageReserved(SMMU_EX_PTBL_PAGE(pdir[pdn]));
-                __free_page(SMMU_EX_PTBL_PAGE(pdir[pdn]));
-                pdir[pdn] = _PDE_VACANT(pdn);
-                FLUSH_CPU_DCACHE(&pdir[pdn], as->pdir_page, sizeof pdir[pdn]);
-                flush_ptc_and_tlb(as->smmu, as, iova, &pdir[pdn],
-                                  as->pdir_page, 1);
-        }
+        value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
+                SMMU_TLB_FLUSH_VA_GROUP(iova);
+        smmu_writel(smmu, value, SMMU_TLB_FLUSH);
 }
 
-static void free_pdir(struct smmu_as *as)
+static inline void smmu_flush(struct tegra_smmu *smmu)
 {
-        unsigned addr;
-        int count;
-        struct device *dev = as->smmu->dev;
-
-        if (!as->pdir_page)
-                return;
-
-        addr = as->smmu->iovmm_base;
-        count = as->smmu->page_count;
-        while (count-- > 0) {
-                free_ptbl(as, addr);
-                addr += SMMU_PAGE_SIZE * SMMU_PTBL_COUNT;
-        }
-        ClearPageReserved(as->pdir_page);
-        __free_page(as->pdir_page);
-        as->pdir_page = NULL;
-        devm_kfree(dev, as->pte_count);
-        as->pte_count = NULL;
+        smmu_readl(smmu, SMMU_CONFIG);
 }
 
-/*
- * Maps PTBL for given iova and returns the PTE address
- * Caller must unmap the mapped PTBL returned in *ptbl_page_p
- */
-static unsigned long *locate_pte(struct smmu_as *as,
-                                 dma_addr_t iova, bool allocate,
-                                 struct page **ptbl_page_p,
-                                 unsigned int **count)
+static int tegra_smmu_alloc_asid(struct tegra_smmu *smmu, unsigned int *idp)
 {
-        unsigned long ptn = SMMU_ADDR_TO_PFN(iova);
-        unsigned long pdn = SMMU_ADDR_TO_PDN(iova);
-        unsigned long *pdir = page_address(as->pdir_page);
-        unsigned long *ptbl;
-
-        if (pdir[pdn] != _PDE_VACANT(pdn)) {
-                /* Mapped entry table already exists */
-                *ptbl_page_p = SMMU_EX_PTBL_PAGE(pdir[pdn]);
-                ptbl = page_address(*ptbl_page_p);
-        } else if (!allocate) {
-                return NULL;
-        } else {
-                int pn;
-                unsigned long addr = SMMU_PDN_TO_ADDR(pdn);
+        unsigned long id;
 
-                /* Vacant - allocate a new page table */
-                dev_dbg(as->smmu->dev, "New PTBL pdn: %lx\n", pdn);
+        mutex_lock(&smmu->lock);
 
-                *ptbl_page_p = alloc_page(GFP_ATOMIC);
-                if (!*ptbl_page_p) {
-                        dev_err(as->smmu->dev,
-                                "failed to allocate smmu_device page table\n");
-                        return NULL;
-                }
-                SetPageReserved(*ptbl_page_p);
-                ptbl = (unsigned long *)page_address(*ptbl_page_p);
-                for (pn = 0; pn < SMMU_PTBL_COUNT;
-                     pn++, addr += SMMU_PAGE_SIZE) {
-                        ptbl[pn] = _PTE_VACANT(addr);
-                }
-                FLUSH_CPU_DCACHE(ptbl, *ptbl_page_p, SMMU_PTBL_SIZE);
-                pdir[pdn] = SMMU_MK_PDE(*ptbl_page_p,
-                                        as->pde_attr | _PDE_NEXT);
-                FLUSH_CPU_DCACHE(&pdir[pdn], as->pdir_page, sizeof pdir[pdn]);
-                flush_ptc_and_tlb(as->smmu, as, iova, &pdir[pdn],
-                                  as->pdir_page, 1);
+        id = find_first_zero_bit(smmu->asids, smmu->soc->num_asids);
+        if (id >= smmu->soc->num_asids) {
+                mutex_unlock(&smmu->lock);
+                return -ENOSPC;
         }
-        *count = &as->pte_count[pdn];
 
-        return &ptbl[ptn % SMMU_PTBL_COUNT];
+        set_bit(id, smmu->asids);
+        *idp = id;
+
+        mutex_unlock(&smmu->lock);
+        return 0;
 }
 
-#ifdef CONFIG_SMMU_SIG_DEBUG
-static void put_signature(struct smmu_as *as,
-                          dma_addr_t iova, unsigned long pfn)
+static void tegra_smmu_free_asid(struct tegra_smmu *smmu, unsigned int id)
 {
-        struct page *page;
-        unsigned long *vaddr;
-
-        page = pfn_to_page(pfn);
-        vaddr = page_address(page);
-        if (!vaddr)
-                return;
-
-        vaddr[0] = iova;
-        vaddr[1] = pfn << PAGE_SHIFT;
-        FLUSH_CPU_DCACHE(vaddr, page, sizeof(vaddr[0]) * 2);
+        mutex_lock(&smmu->lock);
+        clear_bit(id, smmu->asids);
+        mutex_unlock(&smmu->lock);
 }
-#else
-static inline void put_signature(struct smmu_as *as,
-                                 unsigned long addr, unsigned long pfn)
+
+static bool tegra_smmu_capable(enum iommu_cap cap)
 {
+        return false;
 }
-#endif
 
-/*
- * Caller must not hold as->lock
- */
-static int alloc_pdir(struct smmu_as *as)
+static int tegra_smmu_domain_init(struct iommu_domain *domain)
 {
-        unsigned long *pdir, flags;
-        int pdn, err = 0;
-        u32 val;
-        struct smmu_device *smmu = as->smmu;
-        struct page *page;
-        unsigned int *cnt;
+        struct tegra_smmu_as *as;
+        unsigned int i;
+        uint32_t *pd;
 
-        /*
-         * do the allocation, then grab as->lock
-         */
-        cnt = devm_kzalloc(smmu->dev,
-                           sizeof(cnt[0]) * SMMU_PDIR_COUNT,
-                           GFP_KERNEL);
-        page = alloc_page(GFP_KERNEL | __GFP_DMA);
+        as = kzalloc(sizeof(*as), GFP_KERNEL);
+        if (!as)
+                return -ENOMEM;
 
-        spin_lock_irqsave(&as->lock, flags);
+        as->attr = SMMU_PD_READABLE | SMMU_PD_WRITABLE | SMMU_PD_NONSECURE;
+        as->domain = domain;
 
-        if (as->pdir_page) {
-                /* We raced, free the redundant */
-                err = -EAGAIN;
-                goto err_out;
+        as->pd = alloc_page(GFP_KERNEL | __GFP_DMA);
+        if (!as->pd) {
+                kfree(as);
+                return -ENOMEM;
         }
 
-        if (!page || !cnt) {
-                dev_err(smmu->dev, "failed to allocate at %s\n", __func__);
-                err = -ENOMEM;
-                goto err_out;
+        as->count = alloc_page(GFP_KERNEL);
+        if (!as->count) {
+                __free_page(as->pd);
+                kfree(as);
+                return -ENOMEM;
         }
 
-        as->pdir_page = page;
-        as->pte_count = cnt;
+        /* clear PDEs */
+        pd = page_address(as->pd);
+        SetPageReserved(as->pd);
 
-        SetPageReserved(as->pdir_page);
-        pdir = page_address(as->pdir_page);
+        for (i = 0; i < SMMU_NUM_PDE; i++)
+                pd[i] = 0;
 
-        for (pdn = 0; pdn < SMMU_PDIR_COUNT; pdn++)
-                pdir[pdn] = _PDE_VACANT(pdn);
-        FLUSH_CPU_DCACHE(pdir, as->pdir_page, SMMU_PDIR_SIZE);
-        val = SMMU_PTC_FLUSH_TYPE_ADR | VA_PAGE_TO_PA(pdir, as->pdir_page);
-        smmu_write(smmu, val, SMMU_PTC_FLUSH);
-        FLUSH_SMMU_REGS(as->smmu);
-        val = SMMU_TLB_FLUSH_VA_MATCH_ALL |
-                SMMU_TLB_FLUSH_ASID_MATCH__ENABLE |
-                (as->asid << SMMU_TLB_FLUSH_ASID_SHIFT);
-        smmu_write(smmu, val, SMMU_TLB_FLUSH);
-        FLUSH_SMMU_REGS(as->smmu);
+        /* clear PDE usage counters */
+        pd = page_address(as->count);
+        SetPageReserved(as->count);
 
-        spin_unlock_irqrestore(&as->lock, flags);
-
-        return 0;
+        for (i = 0; i < SMMU_NUM_PDE; i++)
+                pd[i] = 0;
 
-err_out:
-        spin_unlock_irqrestore(&as->lock, flags);
+        domain->priv = as;
 
-        devm_kfree(smmu->dev, cnt);
-        if (page)
-                __free_page(page);
-        return err;
+        return 0;
 }
 
-static void __smmu_iommu_unmap(struct smmu_as *as, dma_addr_t iova)
+static void tegra_smmu_domain_destroy(struct iommu_domain *domain)
 {
-        unsigned long *pte;
-        struct page *page;
-        unsigned int *count;
+        struct tegra_smmu_as *as = domain->priv;
 
-        pte = locate_pte(as, iova, false, &page, &count);
-        if (WARN_ON(!pte))
-                return;
+        /* TODO: free page directory and page tables */
+        ClearPageReserved(as->pd);
 
-        if (WARN_ON(*pte == _PTE_VACANT(iova)))
-                return;
-
-        *pte = _PTE_VACANT(iova);
-        FLUSH_CPU_DCACHE(pte, page, sizeof(*pte));
-        flush_ptc_and_tlb(as->smmu, as, iova, pte, page, 0);
-        if (!--(*count))
-                free_ptbl(as, iova);
+        kfree(as);
 }
 
-static void __smmu_iommu_map_pfn(struct smmu_as *as, dma_addr_t iova,
-                                 unsigned long pfn)
+static const struct tegra_smmu_swgroup *
+tegra_smmu_find_swgroup(struct tegra_smmu *smmu, unsigned int swgroup)
 {
-        struct smmu_device *smmu = as->smmu;
-        unsigned long *pte;
-        unsigned int *count;
-        struct page *page;
+        const struct tegra_smmu_swgroup *group = NULL;
+        unsigned int i;
 
-        pte = locate_pte(as, iova, true, &page, &count);
-        if (WARN_ON(!pte))
-                return;
+        for (i = 0; i < smmu->soc->num_swgroups; i++) {
+                if (smmu->soc->swgroups[i].swgroup == swgroup) {
+                        group = &smmu->soc->swgroups[i];
+                        break;
+                }
+        }
 
-        if (*pte == _PTE_VACANT(iova))
-                (*count)++;
-        *pte = SMMU_PFN_TO_PTE(pfn, as->pte_attr);
-        if (unlikely((*pte == _PTE_VACANT(iova))))
-                (*count)--;
-        FLUSH_CPU_DCACHE(pte, page, sizeof(*pte));
-        flush_ptc_and_tlb(smmu, as, iova, pte, page, 0);
-        put_signature(as, iova, pfn);
+        return group;
 }
 
-static int smmu_iommu_map(struct iommu_domain *domain, unsigned long iova,
-                          phys_addr_t pa, size_t bytes, int prot)
+static void tegra_smmu_enable(struct tegra_smmu *smmu, unsigned int swgroup,
+                              unsigned int asid)
 {
-        struct smmu_as *as = domain->priv;
-        unsigned long pfn = __phys_to_pfn(pa);
-        unsigned long flags;
+        const struct tegra_smmu_swgroup *group;
+        unsigned int i;
+        u32 value;
 
-        dev_dbg(as->smmu->dev, "[%d] %08lx:%pa\n", as->asid, iova, &pa);
+        for (i = 0; i < smmu->soc->num_clients; i++) {
+                const struct tegra_mc_client *client = &smmu->soc->clients[i];
 
-        if (!pfn_valid(pfn))
-                return -ENOMEM;
-
-        spin_lock_irqsave(&as->lock, flags);
-        __smmu_iommu_map_pfn(as, iova, pfn);
-        spin_unlock_irqrestore(&as->lock, flags);
-        return 0;
-}
-
-static size_t smmu_iommu_unmap(struct iommu_domain *domain, unsigned long iova,
-                               size_t bytes)
-{
-        struct smmu_as *as = domain->priv;
-        unsigned long flags;
+                if (client->swgroup != swgroup)
+                        continue;
 
-        dev_dbg(as->smmu->dev, "[%d] %08lx\n", as->asid, iova);
+                value = smmu_readl(smmu, client->smmu.reg);
+                value |= BIT(client->smmu.bit);
+                smmu_writel(smmu, value, client->smmu.reg);
+        }
 
-        spin_lock_irqsave(&as->lock, flags);
-        __smmu_iommu_unmap(as, iova);
-        spin_unlock_irqrestore(&as->lock, flags);
-        return SMMU_PAGE_SIZE;
+        group = tegra_smmu_find_swgroup(smmu, swgroup);
+        if (group) {
+                value = smmu_readl(smmu, group->reg);
+                value &= ~SMMU_ASID_MASK;
+                value |= SMMU_ASID_VALUE(asid);
+                value |= SMMU_ASID_ENABLE;
+                smmu_writel(smmu, value, group->reg);
+        }
 }
 
-static phys_addr_t smmu_iommu_iova_to_phys(struct iommu_domain *domain,
-                                           dma_addr_t iova)
+static void tegra_smmu_disable(struct tegra_smmu *smmu, unsigned int swgroup,
+                               unsigned int asid)
 {
-        struct smmu_as *as = domain->priv;
-        unsigned long *pte;
-        unsigned int *count;
-        struct page *page;
-        unsigned long pfn;
-        unsigned long flags;
+        const struct tegra_smmu_swgroup *group;
+        unsigned int i;
+        u32 value;
 
-        spin_lock_irqsave(&as->lock, flags);
+        group = tegra_smmu_find_swgroup(smmu, swgroup);
+        if (group) {
+                value = smmu_readl(smmu, group->reg);
+                value &= ~SMMU_ASID_MASK;
+                value |= SMMU_ASID_VALUE(asid);
+                value &= ~SMMU_ASID_ENABLE;
+                smmu_writel(smmu, value, group->reg);
+        }
 
-        pte = locate_pte(as, iova, true, &page, &count);
-        pfn = *pte & SMMU_PFN_MASK;
-        WARN_ON(!pfn_valid(pfn));
-        dev_dbg(as->smmu->dev,
-                "iova:%08llx pfn:%08lx asid:%d\n", (unsigned long long)iova,
-                 pfn, as->asid);
+        for (i = 0; i < smmu->soc->num_clients; i++) {
+                const struct tegra_mc_client *client = &smmu->soc->clients[i];
 
-        spin_unlock_irqrestore(&as->lock, flags);
-        return PFN_PHYS(pfn);
-}
+                if (client->swgroup != swgroup)
+                        continue;
 
-static bool smmu_iommu_capable(enum iommu_cap cap)
-{
-        return false;
+                value = smmu_readl(smmu, client->smmu.reg);
+                value &= ~BIT(client->smmu.bit);
+                smmu_writel(smmu, value, client->smmu.reg);
+        }
 }
 
-static int smmu_iommu_attach_dev(struct iommu_domain *domain,
-                                 struct device *dev)
+static int tegra_smmu_as_prepare(struct tegra_smmu *smmu,
+                                 struct tegra_smmu_as *as)
 {
-        struct smmu_as *as = domain->priv;
-        struct smmu_device *smmu = as->smmu;
-        struct smmu_client *client, *c;
-        u32 map;
+        u32 value;
         int err;
 
-        client = devm_kzalloc(smmu->dev, sizeof(*c), GFP_KERNEL);
-        if (!client)
-                return -ENOMEM;
-        client->dev = dev;
-        client->as = as;
-        map = (unsigned long)dev->platform_data;
-        if (!map)
-                return -EINVAL;
-
-        err = smmu_client_enable_hwgrp(client, map);
-        if (err)
-                goto err_hwgrp;
-
-        spin_lock(&as->client_lock);
-        list_for_each_entry(c, &as->client, list) {
-                if (c->dev == dev) {
-                        dev_err(smmu->dev,
-                                "%s is already attached\n", dev_name(c->dev));
-                        err = -EINVAL;
-                        goto err_client;
-                }
+        if (as->use_count > 0) {
+                as->use_count++;
+                return 0;
         }
-        list_add(&client->list, &as->client);
-        spin_unlock(&as->client_lock);
 
-        /*
-         * Reserve "page zero" for AVP vectors using a common dummy
-         * page.
-         */
-        if (map & HWG_AVPC) {
-                struct page *page;
+        err = tegra_smmu_alloc_asid(smmu, &as->id);
+        if (err < 0)
+                return err;
 
-                page = as->smmu->avp_vector_page;
-                __smmu_iommu_map_pfn(as, 0, page_to_pfn(page));
+        smmu->soc->ops->flush_dcache(as->pd, 0, SMMU_SIZE_PD);
+        smmu_flush_ptc(smmu, as->pd, 0);
+        smmu_flush_tlb_asid(smmu, as->id);
 
-                pr_info("Reserve \"page zero\" for AVP vectors using a common dummy\n");
-        }
+        smmu_writel(smmu, as->id & 0x7f, SMMU_PTB_ASID);
+        value = SMMU_PTB_DATA_VALUE(as->pd, as->attr);
+        smmu_writel(smmu, value, SMMU_PTB_DATA);
+        smmu_flush(smmu);
 
-        dev_dbg(smmu->dev, "%s is attached\n", dev_name(dev));
-        return 0;
+        as->smmu = smmu;
+        as->use_count++;
 
-err_client:
-        smmu_client_disable_hwgrp(client);
-        spin_unlock(&as->client_lock);
-err_hwgrp:
-        devm_kfree(smmu->dev, client);
-        return err;
+        return 0;
 }
 
-static void smmu_iommu_detach_dev(struct iommu_domain *domain,
-                                  struct device *dev)
+static void tegra_smmu_as_unprepare(struct tegra_smmu *smmu,
+                                    struct tegra_smmu_as *as)
 {
-        struct smmu_as *as = domain->priv;
-        struct smmu_device *smmu = as->smmu;
-        struct smmu_client *c;
-
-        spin_lock(&as->client_lock);
-
-        list_for_each_entry(c, &as->client, list) {
-                if (c->dev == dev) {
-                        smmu_client_disable_hwgrp(c);
-                        list_del(&c->list);
-                        devm_kfree(smmu->dev, c);
-                        c->as = NULL;
-                        dev_dbg(smmu->dev,
-                                "%s is detached\n", dev_name(c->dev));
-                        goto out;
-                }
-        }
-        dev_err(smmu->dev, "Couldn't find %s\n", dev_name(dev));
-out:
-        spin_unlock(&as->client_lock);
+        if (--as->use_count > 0)
+                return;
+
+        tegra_smmu_free_asid(smmu, as->id);
+        as->smmu = NULL;
 }
 
-static int smmu_iommu_domain_init(struct iommu_domain *domain)
+static int tegra_smmu_attach_dev(struct iommu_domain *domain,
+                                 struct device *dev)
 {
-        int i, err = -EAGAIN;
-        unsigned long flags;
-        struct smmu_as *as;
-        struct smmu_device *smmu = smmu_handle;
+        struct tegra_smmu *smmu = dev->archdata.iommu;
+        struct tegra_smmu_as *as = domain->priv;
+        struct device_node *np = dev->of_node;
+        struct of_phandle_args args;
+        unsigned int index = 0;
+        int err = 0;
 
-        /* Look for a free AS with lock held */
-        for  (i = 0; i < smmu->num_as; i++) {
-                as = &smmu->as[i];
+        while (!of_parse_phandle_with_args(np, "iommus", "#iommu-cells", index,
+                                           &args)) {
+                unsigned int swgroup = args.args[0];
 
-                if (as->pdir_page)
+                if (args.np != smmu->dev->of_node) {
+                        of_node_put(args.np);
                         continue;
+                }
 
-                err = alloc_pdir(as);
-                if (!err)
-                        goto found;
+                of_node_put(args.np);
 
-                if (err != -EAGAIN)
-                        break;
+                err = tegra_smmu_as_prepare(smmu, as);
+                if (err < 0)
+                        return err;
+
+                tegra_smmu_enable(smmu, swgroup, as->id);
+                index++;
         }
-        if (i == smmu->num_as)
-                dev_err(smmu->dev,  "no free AS\n");
-        return err;
 
-found:
-        spin_lock_irqsave(&smmu->lock, flags);
+        if (index == 0)
+                return -ENODEV;
 
-        /* Update PDIR register */
-        smmu_write(smmu, SMMU_PTB_ASID_CUR(as->asid), SMMU_PTB_ASID);
-        smmu_write(smmu,
-                   SMMU_MK_PDIR(as->pdir_page, as->pdir_attr), SMMU_PTB_DATA);
-        FLUSH_SMMU_REGS(smmu);
+        return 0;
+}
 
-        spin_unlock_irqrestore(&smmu->lock, flags);
+static void tegra_smmu_detach_dev(struct iommu_domain *domain, struct device *dev)
+{
+        struct tegra_smmu_as *as = domain->priv;
+        struct device_node *np = dev->of_node;
+        struct tegra_smmu *smmu = as->smmu;
+        struct of_phandle_args args;
+        unsigned int index = 0;
 
-        domain->priv = as;
+        while (!of_parse_phandle_with_args(np, "iommus", "#iommu-cells", index,
+                                           &args)) {
+                unsigned int swgroup = args.args[0];
 
-        domain->geometry.aperture_start = smmu->iovmm_base;
-        domain->geometry.aperture_end   = smmu->iovmm_base +
-                smmu->page_count * SMMU_PAGE_SIZE - 1;
-        domain->geometry.force_aperture = true;
+                if (args.np != smmu->dev->of_node) {
+                        of_node_put(args.np);
+                        continue;
+                }
 
-        dev_dbg(smmu->dev, "smmu_as@%p\n", as);
+                of_node_put(args.np);
 
-        return 0;
+                tegra_smmu_disable(smmu, swgroup, as->id);
+                tegra_smmu_as_unprepare(smmu, as);
+                index++;
+        }
 }
 
-static void smmu_iommu_domain_destroy(struct iommu_domain *domain)
+static u32 *as_get_pte(struct tegra_smmu_as *as, dma_addr_t iova,
+                       struct page **pagep)
 {
-        struct smmu_as *as = domain->priv;
-        struct smmu_device *smmu = as->smmu;
-        unsigned long flags;
+        u32 *pd = page_address(as->pd), *pt, *count;
+        u32 pde = (iova >> SMMU_PDE_SHIFT) & 0x3ff;
+        u32 pte = (iova >> SMMU_PTE_SHIFT) & 0x3ff;
+        struct tegra_smmu *smmu = as->smmu;
+        struct page *page;
+        unsigned int i;
+
+        if (pd[pde] == 0) {
+                page = alloc_page(GFP_KERNEL | __GFP_DMA);
+                if (!page)
+                        return NULL;
 
-        spin_lock_irqsave(&as->lock, flags);
+                pt = page_address(page);
+                SetPageReserved(page);
 
-        if (as->pdir_page) {
-                spin_lock(&smmu->lock);
-                smmu_write(smmu, SMMU_PTB_ASID_CUR(as->asid), SMMU_PTB_ASID);
-                smmu_write(smmu, SMMU_PTB_DATA_RESET_VAL, SMMU_PTB_DATA);
-                FLUSH_SMMU_REGS(smmu);
-                spin_unlock(&smmu->lock);
+                for (i = 0; i < SMMU_NUM_PTE; i++)
+                        pt[i] = 0;
 
-                free_pdir(as);
-        }
+                smmu->soc->ops->flush_dcache(page, 0, SMMU_SIZE_PT);
 
-        if (!list_empty(&as->client)) {
-                struct smmu_client *c;
+                pd[pde] = SMMU_MK_PDE(page, SMMU_PDE_ATTR | SMMU_PDE_NEXT);
 
-                list_for_each_entry(c, &as->client, list)
-                        smmu_iommu_detach_dev(domain, c->dev);
+                smmu->soc->ops->flush_dcache(as->pd, pde << 2, 4);
+                smmu_flush_ptc(smmu, as->pd, pde << 2);
+                smmu_flush_tlb_section(smmu, as->id, iova);
+                smmu_flush(smmu);
+        } else {
+                page = pfn_to_page(pd[pde] & SMMU_PFN_MASK);
+                pt = page_address(page);
         }
 
-        spin_unlock_irqrestore(&as->lock, flags);
+        *pagep = page;
 
-        domain->priv = NULL;
-        dev_dbg(smmu->dev, "smmu_as@%p\n", as);
-}
+        /* Keep track of entries in this page table. */
+        count = page_address(as->count);
+        if (pt[pte] == 0)
+                count[pde]++;
 
-static const struct iommu_ops smmu_iommu_ops = {
-        .capable        = smmu_iommu_capable,
-        .domain_init    = smmu_iommu_domain_init,
-        .domain_destroy = smmu_iommu_domain_destroy,
-        .attach_dev     = smmu_iommu_attach_dev,
-        .detach_dev     = smmu_iommu_detach_dev,
-        .map            = smmu_iommu_map,
-        .unmap          = smmu_iommu_unmap,
-        .iova_to_phys   = smmu_iommu_iova_to_phys,
-        .pgsize_bitmap  = SMMU_IOMMU_PGSIZES,
-};
-
-/* Should be in the order of enum */
-static const char * const smmu_debugfs_mc[] = { "mc", };
-static const char * const smmu_debugfs_cache[] = {  "tlb", "ptc", };
+        return &pt[pte];
+}
 
-static ssize_t smmu_debugfs_stats_write(struct file *file,
-                                        const char __user *buffer,
-                                        size_t count, loff_t *pos)
+static void as_put_pte(struct tegra_smmu_as *as, dma_addr_t iova)
 {
-        struct smmu_debugfs_info *info;
-        struct smmu_device *smmu;
-        int i;
-        enum {
-                _OFF = 0,
-                _ON,
-                _RESET,
-        };
-        const char * const command[] = {
-                [_OFF]          = "off",
-                [_ON]           = "on",
-                [_RESET]        = "reset",
-        };
-        char str[] = "reset";
-        u32 val;
-        size_t offs;
+        u32 pde = (iova >> SMMU_PDE_SHIFT) & 0x3ff;
+        u32 pte = (iova >> SMMU_PTE_SHIFT) & 0x3ff;
+        u32 *count = page_address(as->count);
+        u32 *pd = page_address(as->pd), *pt;
+        struct page *page;
 
-        count = min_t(size_t, count, sizeof(str));
-        if (copy_from_user(str, buffer, count))
-                return -EINVAL;
+        page = pfn_to_page(pd[pde] & SMMU_PFN_MASK);
+        pt = page_address(page);
 
-        for (i = 0; i < ARRAY_SIZE(command); i++)
-                if (strncmp(str, command[i],
-                            strlen(command[i])) == 0)
-                        break;
+        /*
+         * When no entries in this page table are used anymore, return the
+         * memory page to the system.
+         */
+        if (pt[pte] != 0) {
+                if (--count[pde] == 0) {
+                        ClearPageReserved(page);
+                        __free_page(page);
+                        pd[pde] = 0;
+                }
 
-        if (i == ARRAY_SIZE(command))
-                return -EINVAL;
-
-        info = file_inode(file)->i_private;
-        smmu = info->smmu;
-
-        offs = SMMU_CACHE_CONFIG(info->cache);
-        val = smmu_read(smmu, offs);
-        switch (i) {
-        case _OFF:
-                val &= ~SMMU_CACHE_CONFIG_STATS_ENABLE;
-                val &= ~SMMU_CACHE_CONFIG_STATS_TEST;
-                smmu_write(smmu, val, offs);
-                break;
-        case _ON:
-                val |= SMMU_CACHE_CONFIG_STATS_ENABLE;
-                val &= ~SMMU_CACHE_CONFIG_STATS_TEST;
-                smmu_write(smmu, val, offs);
-                break;
-        case _RESET:
-                val |= SMMU_CACHE_CONFIG_STATS_TEST;
-                smmu_write(smmu, val, offs);
-                val &= ~SMMU_CACHE_CONFIG_STATS_TEST;
-                smmu_write(smmu, val, offs);
-                break;
-        default:
-                BUG();
-                break;
+                pt[pte] = 0;
         }
-
-        dev_dbg(smmu->dev, "%s() %08x, %08x @%08x\n", __func__,
-                val, smmu_read(smmu, offs), offs);
-
-        return count;
 }
 
-static int smmu_debugfs_stats_show(struct seq_file *s, void *v)
+static int tegra_smmu_map(struct iommu_domain *domain, unsigned long iova,
+                          phys_addr_t paddr, size_t size, int prot)
 {
-        struct smmu_debugfs_info *info = s->private;
-        struct smmu_device *smmu = info->smmu;
-        int i;
-        const char * const stats[] = { "hit", "miss", };
+        struct tegra_smmu_as *as = domain->priv;
+        struct tegra_smmu *smmu = as->smmu;
+        unsigned long offset;
+        struct page *page;
+        u32 *pte;
 
+        pte = as_get_pte(as, iova, &page);
+        if (!pte)
+                return -ENOMEM;
 
-        for (i = 0; i < ARRAY_SIZE(stats); i++) {
-                u32 val;
-                size_t offs;
+        *pte = __phys_to_pfn(paddr) | SMMU_PTE_ATTR;
+        offset = offset_in_page(pte);
 
-                offs = SMMU_STATS_CACHE_COUNT(info->mc, info->cache, i);
-                val = smmu_read(smmu, offs);
-                seq_printf(s, "%s:%08x ", stats[i], val);
+        smmu->soc->ops->flush_dcache(page, offset, 4);
+        smmu_flush_ptc(smmu, page, offset);
+        smmu_flush_tlb_group(smmu, as->id, iova);
+        smmu_flush(smmu);
 
-                dev_dbg(smmu->dev, "%s() %s %08x @%08x\n", __func__,
-                        stats[i], val, offs);
-        }
-        seq_printf(s, "\n");
         return 0;
 }
 
-static int smmu_debugfs_stats_open(struct inode *inode, struct file *file)
+static size_t tegra_smmu_unmap(struct iommu_domain *domain, unsigned long iova,
+                               size_t size)
 {
-        return single_open(file, smmu_debugfs_stats_show, inode->i_private);
-}
+        struct tegra_smmu_as *as = domain->priv;
+        struct tegra_smmu *smmu = as->smmu;
+        unsigned long offset;
+        struct page *page;
+        u32 *pte;
 
-static const struct file_operations smmu_debugfs_stats_fops = {
-        .open           = smmu_debugfs_stats_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-        .write          = smmu_debugfs_stats_write,
-};
+        pte = as_get_pte(as, iova, &page);
+        if (!pte)
+                return 0;
 
-static void smmu_debugfs_delete(struct smmu_device *smmu)
-{
-        debugfs_remove_recursive(smmu->debugfs_root);
-        kfree(smmu->debugfs_info);
+        offset = offset_in_page(pte);
+        as_put_pte(as, iova);
+
+        smmu->soc->ops->flush_dcache(page, offset, 4);
+        smmu_flush_ptc(smmu, page, offset);
+        smmu_flush_tlb_group(smmu, as->id, iova);
+        smmu_flush(smmu);
+
+        return size;
 }
 
-static void smmu_debugfs_create(struct smmu_device *smmu)
+static phys_addr_t tegra_smmu_iova_to_phys(struct iommu_domain *domain,
+                                           dma_addr_t iova)
 {
-        int i;
-        size_t bytes;
-        struct dentry *root;
-
-        bytes = ARRAY_SIZE(smmu_debugfs_mc) * ARRAY_SIZE(smmu_debugfs_cache) *
-                sizeof(*smmu->debugfs_info);
-        smmu->debugfs_info = kmalloc(bytes, GFP_KERNEL);
-        if (!smmu->debugfs_info)
-                return;
-
-        root = debugfs_create_dir(dev_name(smmu->dev), NULL);
-        if (!root)
-                goto err_out;
-        smmu->debugfs_root = root;
-
-        for (i = 0; i < ARRAY_SIZE(smmu_debugfs_mc); i++) {
-                int j;
-                struct dentry *mc;
-
-                mc = debugfs_create_dir(smmu_debugfs_mc[i], root);
-                if (!mc)
-                        goto err_out;
-
-                for (j = 0; j < ARRAY_SIZE(smmu_debugfs_cache); j++) {
-                        struct dentry *cache;
-                        struct smmu_debugfs_info *info;
-
-                        info = smmu->debugfs_info;
-                        info += i * ARRAY_SIZE(smmu_debugfs_mc) + j;
-                        info->smmu = smmu;
-                        info->mc = i;
-                        info->cache = j;
-
-                        cache = debugfs_create_file(smmu_debugfs_cache[j],
-                                                    S_IWUGO | S_IRUGO, mc,
-                                                    (void *)info,
-                                                    &smmu_debugfs_stats_fops);
-                        if (!cache)
-                                goto err_out;
-                }
-        }
+        struct tegra_smmu_as *as = domain->priv;
+        struct page *page;
+        unsigned long pfn;
+        u32 *pte;
 
-        return;
+        pte = as_get_pte(as, iova, &page);
+        pfn = *pte & SMMU_PFN_MASK;
 
-err_out:
-        smmu_debugfs_delete(smmu);
+        return PFN_PHYS(pfn);
 }
 
-static int tegra_smmu_suspend(struct device *dev)
+static struct tegra_smmu *tegra_smmu_find(struct device_node *np)
 {
-        struct smmu_device *smmu = dev_get_drvdata(dev);
+        struct platform_device *pdev;
+        struct tegra_mc *mc;
 
-        smmu->translation_enable_0 = smmu_read(smmu, SMMU_TRANSLATION_ENABLE_0);
-        smmu->translation_enable_1 = smmu_read(smmu, SMMU_TRANSLATION_ENABLE_1);
-        smmu->translation_enable_2 = smmu_read(smmu, SMMU_TRANSLATION_ENABLE_2);
-        smmu->asid_security = smmu_read(smmu, SMMU_ASID_SECURITY);
-        return 0;
+        pdev = of_find_device_by_node(np);
+        if (!pdev)
+                return NULL;
+
+        mc = platform_get_drvdata(pdev);
+        if (!mc)
+                return NULL;
+
+        return mc->smmu;
 }
 
-static int tegra_smmu_resume(struct device *dev)
+static int tegra_smmu_add_device(struct device *dev)
 {
-        struct smmu_device *smmu = dev_get_drvdata(dev);
-        unsigned long flags;
-        int err;
+        struct device_node *np = dev->of_node;
+        struct of_phandle_args args;
+        unsigned int index = 0;
 
-        spin_lock_irqsave(&smmu->lock, flags);
-        err = smmu_setup_regs(smmu);
-        spin_unlock_irqrestore(&smmu->lock, flags);
-        return err;
+        while (of_parse_phandle_with_args(np, "iommus", "#iommu-cells", index,
+                                          &args) == 0) {
+                struct tegra_smmu *smmu;
+
+                smmu = tegra_smmu_find(args.np);
+                if (smmu) {
+                        /*
+                         * Only a single IOMMU master interface is currently
+                         * supported by the Linux kernel, so abort after the
+                         * first match.
+                         */
+                        dev->archdata.iommu = smmu;
+                        break;
+                }
+
+                index++;
+        }
+
+        return 0;
 }
 
-static int tegra_smmu_probe(struct platform_device *pdev)
+static void tegra_smmu_remove_device(struct device *dev)
 {
-        struct smmu_device *smmu;
-        struct device *dev = &pdev->dev;
-        int i, asids, err = 0;
-        dma_addr_t uninitialized_var(base);
-        size_t bytes, uninitialized_var(size);
+        dev->archdata.iommu = NULL;
+}
 
-        if (smmu_handle)
-                return -EIO;
+static const struct iommu_ops tegra_smmu_ops = {
+        .capable = tegra_smmu_capable,
+        .domain_init = tegra_smmu_domain_init,
+        .domain_destroy = tegra_smmu_domain_destroy,
+        .attach_dev = tegra_smmu_attach_dev,
+        .detach_dev = tegra_smmu_detach_dev,
+        .add_device = tegra_smmu_add_device,
+        .remove_device = tegra_smmu_remove_device,
+        .map = tegra_smmu_map,
+        .unmap = tegra_smmu_unmap,
+        .map_sg = default_iommu_map_sg,
+        .iova_to_phys = tegra_smmu_iova_to_phys,
 
-        BUILD_BUG_ON(PAGE_SHIFT != SMMU_PAGE_SHIFT);
+        .pgsize_bitmap = SZ_4K,
+};
 
-        if (of_property_read_u32(dev->of_node, "nvidia,#asids", &asids))
-                return -ENODEV;
+static void tegra_smmu_ahb_enable(void)
+{
+        static const struct of_device_id ahb_match[] = {
+                { .compatible = "nvidia,tegra30-ahb", },
+                { }
+        };
+        struct device_node *ahb;
 
-        bytes = sizeof(*smmu) + asids * sizeof(*smmu->as);
-        smmu = devm_kzalloc(dev, bytes, GFP_KERNEL);
-        if (!smmu) {
-                dev_err(dev, "failed to allocate smmu_device\n");
-                return -ENOMEM;
+        ahb = of_find_matching_node(NULL, ahb_match);
+        if (ahb) {
+                tegra_ahb_enable_smmu(ahb);
+                of_node_put(ahb);
         }
+}
 
-        smmu->nregs = pdev->num_resources;
-        smmu->regs = devm_kzalloc(dev, 2 * smmu->nregs * sizeof(*smmu->regs),
-                                  GFP_KERNEL);
-        smmu->rege = smmu->regs + smmu->nregs;
-        if (!smmu->regs)
-                return -ENOMEM;
-        for (i = 0; i < smmu->nregs; i++) {
-                struct resource *res;
-
-                res = platform_get_resource(pdev, IORESOURCE_MEM, i);
-                smmu->regs[i] = devm_ioremap_resource(&pdev->dev, res);
-                if (IS_ERR(smmu->regs[i]))
-                        return PTR_ERR(smmu->regs[i]);
-                smmu->rege[i] = smmu->regs[i] + resource_size(res) - 1;
-        }
-        /* Same as "mc" 1st regiter block start address */
-        smmu->regbase = (void __iomem *)((u32)smmu->regs[0] & PAGE_MASK);
+struct tegra_smmu *tegra_smmu_probe(struct device *dev,
+                                    const struct tegra_smmu_soc *soc,
+                                    struct tegra_mc *mc)
+{
+        struct tegra_smmu *smmu;
+        size_t size;
+        u32 value;
+        int err;
 
-        err = of_get_dma_window(dev->of_node, NULL, 0, NULL, &base, &size);
-        if (err)
-                return -ENODEV;
+        /* This can happen on Tegra20 which doesn't have an SMMU */
+        if (!soc)
+                return NULL;
 
-        if (size & SMMU_PAGE_MASK)
-                return -EINVAL;
+        smmu = devm_kzalloc(dev, sizeof(*smmu), GFP_KERNEL);
+        if (!smmu)
+                return ERR_PTR(-ENOMEM);
 
-        size >>= SMMU_PAGE_SHIFT;
-        if (!size)
-                return -EINVAL;
+        /*
+         * This is a bit of a hack. Ideally we'd want to simply return this
+         * value. However the IOMMU registration process will attempt to add
+         * all devices to the IOMMU when bus_set_iommu() is called. In order
+         * not to rely on global variables to track the IOMMU instance, we
+         * set it here so that it can be looked up from the .add_device()
+         * callback via the IOMMU device's .drvdata field.
+         */
+        mc->smmu = smmu;
 
-        smmu->ahb = of_parse_phandle(dev->of_node, "nvidia,ahb", 0);
-        if (!smmu->ahb)
-                return -ENODEV;
+        size = BITS_TO_LONGS(soc->num_asids) * sizeof(long);
 
-        smmu->dev = dev;
-        smmu->num_as = asids;
-        smmu->iovmm_base = base;
-        smmu->page_count = size;
-
-        smmu->translation_enable_0 = ~0;
-        smmu->translation_enable_1 = ~0;
-        smmu->translation_enable_2 = ~0;
-        smmu->asid_security = 0;
-
-        for (i = 0; i < smmu->num_as; i++) {
-                struct smmu_as *as = &smmu->as[i];
-
-                as->smmu = smmu;
-                as->asid = i;
-                as->pdir_attr = _PDIR_ATTR;
-                as->pde_attr = _PDE_ATTR;
-                as->pte_attr = _PTE_ATTR;
-
-                spin_lock_init(&as->lock);
-                spin_lock_init(&as->client_lock);
-                INIT_LIST_HEAD(&as->client);
-        }
-        spin_lock_init(&smmu->lock);
-        err = smmu_setup_regs(smmu);
-        if (err)
-                return err;
-        platform_set_drvdata(pdev, smmu);
+        smmu->asids = devm_kzalloc(dev, size, GFP_KERNEL);
+        if (!smmu->asids)
+                return ERR_PTR(-ENOMEM);
 
-        smmu->avp_vector_page = alloc_page(GFP_KERNEL);
-        if (!smmu->avp_vector_page)
-                return -ENOMEM;
+        mutex_init(&smmu->lock);
 
-        smmu_debugfs_create(smmu);
-        smmu_handle = smmu;
-        bus_set_iommu(&platform_bus_type, &smmu_iommu_ops);
-        return 0;
-}
+        smmu->regs = mc->regs;
+        smmu->soc = soc;
+        smmu->dev = dev;
+        smmu->mc = mc;
 
-static int tegra_smmu_remove(struct platform_device *pdev)
-{
-        struct smmu_device *smmu = platform_get_drvdata(pdev);
-        int i;
+        value = SMMU_PTC_CONFIG_ENABLE | SMMU_PTC_CONFIG_INDEX_MAP(0x3f);
 
-        smmu_debugfs_delete(smmu);
+        if (soc->supports_request_limit)
+                value |= SMMU_PTC_CONFIG_REQ_LIMIT(8);
 
-        smmu_write(smmu, SMMU_CONFIG_DISABLE, SMMU_CONFIG);
-        for (i = 0; i < smmu->num_as; i++)
-                free_pdir(&smmu->as[i]);
-        __free_page(smmu->avp_vector_page);
-        smmu_handle = NULL;
-        return 0;
-}
+        smmu_writel(smmu, value, SMMU_PTC_CONFIG);
 
-static const struct dev_pm_ops tegra_smmu_pm_ops = {
-        .suspend        = tegra_smmu_suspend,
-        .resume         = tegra_smmu_resume,
-};
+        value = SMMU_TLB_CONFIG_HIT_UNDER_MISS |
+                SMMU_TLB_CONFIG_ACTIVE_LINES(0x20);
 
-static const struct of_device_id tegra_smmu_of_match[] = {
-        { .compatible = "nvidia,tegra30-smmu", },
-        { },
-};
-MODULE_DEVICE_TABLE(of, tegra_smmu_of_match);
-
-static struct platform_driver tegra_smmu_driver = {
-        .probe          = tegra_smmu_probe,
-        .remove         = tegra_smmu_remove,
-        .driver = {
-                .owner  = THIS_MODULE,
-                .name   = "tegra-smmu",
-                .pm     = &tegra_smmu_pm_ops,
-                .of_match_table = tegra_smmu_of_match,
-        },
-};
+        if (soc->supports_round_robin_arbitration)
+                value |= SMMU_TLB_CONFIG_ROUND_ROBIN_ARBITRATION;
 
-static int tegra_smmu_init(void)
-{
-        return platform_driver_register(&tegra_smmu_driver);
-}
+        smmu_writel(smmu, value, SMMU_TLB_CONFIG);
 
-static void __exit tegra_smmu_exit(void)
-{
-        platform_driver_unregister(&tegra_smmu_driver);
-}
+        smmu_flush_ptc(smmu, NULL, 0);
+        smmu_flush_tlb(smmu);
+        smmu_writel(smmu, SMMU_CONFIG_ENABLE, SMMU_CONFIG);
+        smmu_flush(smmu);
+
+        tegra_smmu_ahb_enable();
 
-subsys_initcall(tegra_smmu_init);
-module_exit(tegra_smmu_exit);
+        err = bus_set_iommu(&platform_bus_type, &tegra_smmu_ops);
+        if (err < 0)
+                return ERR_PTR(err);
 
-MODULE_DESCRIPTION("IOMMU API for SMMU in Tegra30");
-MODULE_AUTHOR("Hiroshi DOYU <hdoyu@nvidia.com>");
-MODULE_ALIAS("platform:tegra-smmu");
-MODULE_LICENSE("GPL v2");
+        return smmu;
+}
diff --git a/drivers/irqchip/Kconfig b/drivers/irqchip/Kconfig
index b21f12f1766d..9efe5f10f97b 100644
--- a/drivers/irqchip/Kconfig
+++ b/drivers/irqchip/Kconfig
@@ -48,14 +48,19 @@ config ATMEL_AIC5_IRQ
         select MULTI_IRQ_HANDLER
         select SPARSE_IRQ
 
+config BCM7120_L2_IRQ
+        bool
+        select GENERIC_IRQ_CHIP
+        select IRQ_DOMAIN
+
 config BRCMSTB_L2_IRQ
         bool
-        depends on ARM
         select GENERIC_IRQ_CHIP
         select IRQ_DOMAIN
 
 config DW_APB_ICTL
         bool
+        select GENERIC_IRQ_CHIP
         select IRQ_DOMAIN
 
 config IMGPDC_IRQ
diff --git a/drivers/irqchip/Makefile b/drivers/irqchip/Makefile
index 173bb5fa2cc9..f0909d05eae3 100644
--- a/drivers/irqchip/Makefile
+++ b/drivers/irqchip/Makefile
@@ -35,6 +35,6 @@ obj-$(CONFIG_TB10X_IRQC)		+= irq-tb10x.o
 obj-$(CONFIG_XTENSA)                    += irq-xtensa-pic.o
 obj-$(CONFIG_XTENSA_MX)                 += irq-xtensa-mx.o
 obj-$(CONFIG_IRQ_CROSSBAR)              += irq-crossbar.o
-obj-$(CONFIG_BRCMSTB_L2_IRQ)            += irq-brcmstb-l2.o \
-                                           irq-bcm7120-l2.o
+obj-$(CONFIG_BCM7120_L2_IRQ)            += irq-bcm7120-l2.o
+obj-$(CONFIG_BRCMSTB_L2_IRQ)            += irq-brcmstb-l2.o
 obj-$(CONFIG_KEYSTONE_IRQ)              += irq-keystone.o
diff --git a/drivers/irqchip/irq-armada-370-xp.c b/drivers/irqchip/irq-armada-370-xp.c
index 6a2e168c3ab0..463c235acbdc 100644
--- a/drivers/irqchip/irq-armada-370-xp.c
+++ b/drivers/irqchip/irq-armada-370-xp.c
@@ -26,6 +26,7 @@
 #include <linux/of_pci.h>
 #include <linux/irqdomain.h>
 #include <linux/slab.h>
+#include <linux/syscore_ops.h>
 #include <linux/msi.h>
 #include <asm/mach/arch.h>
 #include <asm/exception.h>
@@ -67,6 +68,7 @@
 static void __iomem *per_cpu_int_base;
 static void __iomem *main_int_base;
 static struct irq_domain *armada_370_xp_mpic_domain;
+static u32 doorbell_mask_reg;
 #ifdef CONFIG_PCI_MSI
 static struct irq_domain *armada_370_xp_msi_domain;
 static DECLARE_BITMAP(msi_used, PCI_MSI_DOORBELL_NR);
@@ -130,7 +132,7 @@ static void armada_370_xp_free_msi(int hwirq)
         mutex_unlock(&msi_used_lock);
 }
 
-static int armada_370_xp_setup_msi_irq(struct msi_chip *chip,
+static int armada_370_xp_setup_msi_irq(struct msi_controller *chip,
                                        struct pci_dev *pdev,
                                        struct msi_desc *desc)
 {
@@ -157,11 +159,11 @@ static int armada_370_xp_setup_msi_irq(struct msi_chip *chip,
         msg.address_hi = 0;
         msg.data = 0xf00 | (hwirq + 16);
 
-        write_msi_msg(virq, &msg);
+        pci_write_msi_msg(virq, &msg);
         return 0;
 }
 
-static void armada_370_xp_teardown_msi_irq(struct msi_chip *chip,
+static void armada_370_xp_teardown_msi_irq(struct msi_controller *chip,
                                            unsigned int irq)
 {
         struct irq_data *d = irq_get_irq_data(irq);
@@ -173,10 +175,10 @@ static void armada_370_xp_teardown_msi_irq(struct msi_chip *chip,
 
 static struct irq_chip armada_370_xp_msi_irq_chip = {
         .name = "armada_370_xp_msi_irq",
-        .irq_enable = unmask_msi_irq,
-        .irq_disable = mask_msi_irq,
-        .irq_mask = mask_msi_irq,
-        .irq_unmask = unmask_msi_irq,
+        .irq_enable = pci_msi_unmask_irq,
+        .irq_disable = pci_msi_mask_irq,
+        .irq_mask = pci_msi_mask_irq,
+        .irq_unmask = pci_msi_unmask_irq,
 };
 
 static int armada_370_xp_msi_map(struct irq_domain *domain, unsigned int virq,
@@ -196,7 +198,7 @@ static const struct irq_domain_ops armada_370_xp_msi_irq_ops = {
 static int armada_370_xp_msi_init(struct device_node *node,
                                   phys_addr_t main_int_phys_base)
 {
-        struct msi_chip *msi_chip;
+        struct msi_controller *msi_chip;
         u32 reg;
         int ret;
 
@@ -266,7 +268,7 @@ static int armada_xp_set_affinity(struct irq_data *d,
         writel(reg, main_int_base + ARMADA_370_XP_INT_SOURCE_CTL(hwirq));
         raw_spin_unlock(&irq_controller_lock);
 
-        return 0;
+        return IRQ_SET_MASK_OK;
 }
 #endif
 
@@ -485,6 +487,54 @@ armada_370_xp_handle_irq(struct pt_regs *regs)
         } while (1);
 }
 
+static int armada_370_xp_mpic_suspend(void)
+{
+        doorbell_mask_reg = readl(per_cpu_int_base +
+                                  ARMADA_370_XP_IN_DRBEL_MSK_OFFS);
+        return 0;
+}
+
+static void armada_370_xp_mpic_resume(void)
+{
+        int nirqs;
+        irq_hw_number_t irq;
+
+        /* Re-enable interrupts */
+        nirqs = (readl(main_int_base + ARMADA_370_XP_INT_CONTROL) >> 2) & 0x3ff;
+        for (irq = 0; irq < nirqs; irq++) {
+                struct irq_data *data;
+                int virq;
+
+                virq = irq_linear_revmap(armada_370_xp_mpic_domain, irq);
+                if (virq == 0)
+                        continue;
+
+                if (irq != ARMADA_370_XP_TIMER0_PER_CPU_IRQ)
+                        writel(irq, per_cpu_int_base +
+                               ARMADA_370_XP_INT_CLEAR_MASK_OFFS);
+                else
+                        writel(irq, main_int_base +
+                               ARMADA_370_XP_INT_SET_ENABLE_OFFS);
+
+                data = irq_get_irq_data(virq);
+                if (!irqd_irq_disabled(data))
+                        armada_370_xp_irq_unmask(data);
+        }
+
+        /* Reconfigure doorbells for IPIs and MSIs */
+        writel(doorbell_mask_reg,
+               per_cpu_int_base + ARMADA_370_XP_IN_DRBEL_MSK_OFFS);
+        if (doorbell_mask_reg & IPI_DOORBELL_MASK)
+                writel(0, per_cpu_int_base + ARMADA_370_XP_INT_CLEAR_MASK_OFFS);
+        if (doorbell_mask_reg & PCI_MSI_DOORBELL_MASK)
+                writel(1, per_cpu_int_base + ARMADA_370_XP_INT_CLEAR_MASK_OFFS);
+}
+
+struct syscore_ops armada_370_xp_mpic_syscore_ops = {
+        .suspend        = armada_370_xp_mpic_suspend,
+        .resume         = armada_370_xp_mpic_resume,
+};
+
 static int __init armada_370_xp_mpic_of_init(struct device_node *node,
                                              struct device_node *parent)
 {
@@ -541,6 +591,8 @@ static int __init armada_370_xp_mpic_of_init(struct device_node *node,
                                         armada_370_xp_mpic_handle_cascade_irq);
         }
 
+        register_syscore_ops(&armada_370_xp_mpic_syscore_ops);
+
         return 0;
 }
 
diff --git a/drivers/irqchip/irq-atmel-aic-common.c b/drivers/irqchip/irq-atmel-aic-common.c
index 6ae3cdee0681..d111ac779c40 100644
--- a/drivers/irqchip/irq-atmel-aic-common.c
+++ b/drivers/irqchip/irq-atmel-aic-common.c
@@ -167,6 +167,32 @@ void __init aic_common_rtc_irq_fixup(struct device_node *root)
         iounmap(regs);
 }
 
+#define AT91_RTT_MR             0x00                    /* Real-time Mode Register */
+#define AT91_RTT_ALMIEN         (1 << 16)               /* Alarm Interrupt Enable */
+#define AT91_RTT_RTTINCIEN      (1 << 17)               /* Real Time Timer Increment Interrupt Enable */
+
+void __init aic_common_rtt_irq_fixup(struct device_node *root)
+{
+        struct device_node *np;
+        void __iomem *regs;
+
+        /*
+         * The at91sam9263 SoC has 2 instances of the RTT block, hence we
+         * iterate over the DT to find each occurrence.
+         */
+        for_each_compatible_node(np, NULL, "atmel,at91sam9260-rtt") {
+                regs = of_iomap(np, 0);
+                if (!regs)
+                        continue;
+
+                writel(readl(regs + AT91_RTT_MR) &
+                       ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN),
+                       regs + AT91_RTT_MR);
+
+                iounmap(regs);
+        }
+}
+
 void __init aic_common_irq_fixup(const struct of_device_id *matches)
 {
         struct device_node *root = of_find_node_by_path("/");
@@ -217,8 +243,9 @@ struct irq_domain *__init aic_common_of_init(struct device_node *node,
         }
 
         ret = irq_alloc_domain_generic_chips(domain, 32, 1, name,
-                                             handle_level_irq, 0, 0,
-                                             IRQCHIP_SKIP_SET_WAKE);
+                                             handle_fasteoi_irq,
+                                             IRQ_NOREQUEST | IRQ_NOPROBE |
+                                             IRQ_NOAUTOEN, 0, 0);
         if (ret)
                 goto err_domain_remove;
 
@@ -230,7 +257,6 @@ struct irq_domain *__init aic_common_of_init(struct device_node *node,
                 gc->unused = 0;
                 gc->wake_enabled = ~0;
                 gc->chip_types[0].type = IRQ_TYPE_SENSE_MASK;
-                gc->chip_types[0].handler = handle_fasteoi_irq;
                 gc->chip_types[0].chip.irq_eoi = irq_gc_eoi;
                 gc->chip_types[0].chip.irq_set_wake = irq_gc_set_wake;
                 gc->chip_types[0].chip.irq_shutdown = aic_common_shutdown;
diff --git a/drivers/irqchip/irq-atmel-aic-common.h b/drivers/irqchip/irq-atmel-aic-common.h
index 90aa00e918d6..603f0a9d5411 100644
--- a/drivers/irqchip/irq-atmel-aic-common.h
+++ b/drivers/irqchip/irq-atmel-aic-common.h
@@ -34,6 +34,8 @@ struct irq_domain *__init aic_common_of_init(struct device_node *node,
 
 void __init aic_common_rtc_irq_fixup(struct device_node *root);
 
+void __init aic_common_rtt_irq_fixup(struct device_node *root);
+
 void __init aic_common_irq_fixup(const struct of_device_id *matches);
 
 #endif /* __IRQ_ATMEL_AIC_COMMON_H */
diff --git a/drivers/irqchip/irq-atmel-aic.c b/drivers/irqchip/irq-atmel-aic.c
index 9a2cf3c1a3a5..dae3604b32a9 100644
--- a/drivers/irqchip/irq-atmel-aic.c
+++ b/drivers/irqchip/irq-atmel-aic.c
@@ -65,11 +65,11 @@ aic_handle(struct pt_regs *regs)
         u32 irqnr;
         u32 irqstat;
 
-        irqnr = irq_reg_readl(gc->reg_base + AT91_AIC_IVR);
-        irqstat = irq_reg_readl(gc->reg_base + AT91_AIC_ISR);
+        irqnr = irq_reg_readl(gc, AT91_AIC_IVR);
+        irqstat = irq_reg_readl(gc, AT91_AIC_ISR);
 
         if (!irqstat)
-                irq_reg_writel(0, gc->reg_base + AT91_AIC_EOICR);
+                irq_reg_writel(gc, 0, AT91_AIC_EOICR);
         else
                 handle_domain_irq(aic_domain, irqnr, regs);
 }
@@ -80,7 +80,7 @@ static int aic_retrigger(struct irq_data *d)
 
         /* Enable interrupt on AIC5 */
         irq_gc_lock(gc);
-        irq_reg_writel(d->mask, gc->reg_base + AT91_AIC_ISCR);
+        irq_reg_writel(gc, d->mask, AT91_AIC_ISCR);
         irq_gc_unlock(gc);
 
         return 0;
@@ -92,12 +92,12 @@ static int aic_set_type(struct irq_data *d, unsigned type)
         unsigned int smr;
         int ret;
 
-        smr = irq_reg_readl(gc->reg_base + AT91_AIC_SMR(d->hwirq));
+        smr = irq_reg_readl(gc, AT91_AIC_SMR(d->hwirq));
         ret = aic_common_set_type(d, type, &smr);
         if (ret)
                 return ret;
 
-        irq_reg_writel(smr, gc->reg_base + AT91_AIC_SMR(d->hwirq));
+        irq_reg_writel(gc, smr, AT91_AIC_SMR(d->hwirq));
 
         return 0;
 }
@@ -108,8 +108,8 @@ static void aic_suspend(struct irq_data *d)
         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
 
         irq_gc_lock(gc);
-        irq_reg_writel(gc->mask_cache, gc->reg_base + AT91_AIC_IDCR);
-        irq_reg_writel(gc->wake_active, gc->reg_base + AT91_AIC_IECR);
+        irq_reg_writel(gc, gc->mask_cache, AT91_AIC_IDCR);
+        irq_reg_writel(gc, gc->wake_active, AT91_AIC_IECR);
         irq_gc_unlock(gc);
 }
 
@@ -118,8 +118,8 @@ static void aic_resume(struct irq_data *d)
         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
 
         irq_gc_lock(gc);
-        irq_reg_writel(gc->wake_active, gc->reg_base + AT91_AIC_IDCR);
-        irq_reg_writel(gc->mask_cache, gc->reg_base + AT91_AIC_IECR);
+        irq_reg_writel(gc, gc->wake_active, AT91_AIC_IDCR);
+        irq_reg_writel(gc, gc->mask_cache, AT91_AIC_IECR);
         irq_gc_unlock(gc);
 }
 
@@ -128,8 +128,8 @@ static void aic_pm_shutdown(struct irq_data *d)
         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
 
         irq_gc_lock(gc);
-        irq_reg_writel(0xffffffff, gc->reg_base + AT91_AIC_IDCR);
-        irq_reg_writel(0xffffffff, gc->reg_base + AT91_AIC_ICCR);
+        irq_reg_writel(gc, 0xffffffff, AT91_AIC_IDCR);
+        irq_reg_writel(gc, 0xffffffff, AT91_AIC_ICCR);
         irq_gc_unlock(gc);
 }
 #else
@@ -148,24 +148,24 @@ static void __init aic_hw_init(struct irq_domain *domain)
          * will not Lock out nIRQ
          */
         for (i = 0; i < 8; i++)
-                irq_reg_writel(0, gc->reg_base + AT91_AIC_EOICR);
+                irq_reg_writel(gc, 0, AT91_AIC_EOICR);
 
         /*
          * Spurious Interrupt ID in Spurious Vector Register.
          * When there is no current interrupt, the IRQ Vector Register
          * reads the value stored in AIC_SPU
          */
-        irq_reg_writel(0xffffffff, gc->reg_base + AT91_AIC_SPU);
+        irq_reg_writel(gc, 0xffffffff, AT91_AIC_SPU);
 
         /* No debugging in AIC: Debug (Protect) Control Register */
-        irq_reg_writel(0, gc->reg_base + AT91_AIC_DCR);
+        irq_reg_writel(gc, 0, AT91_AIC_DCR);
 
         /* Disable and clear all interrupts initially */
-        irq_reg_writel(0xffffffff, gc->reg_base + AT91_AIC_IDCR);
-        irq_reg_writel(0xffffffff, gc->reg_base + AT91_AIC_ICCR);
+        irq_reg_writel(gc, 0xffffffff, AT91_AIC_IDCR);
+        irq_reg_writel(gc, 0xffffffff, AT91_AIC_ICCR);
 
         for (i = 0; i < 32; i++)
-                irq_reg_writel(i, gc->reg_base + AT91_AIC_SVR(i));
+                irq_reg_writel(gc, i, AT91_AIC_SVR(i));
 }
 
 static int aic_irq_domain_xlate(struct irq_domain *d,
@@ -195,10 +195,10 @@ static int aic_irq_domain_xlate(struct irq_domain *d,
         gc = dgc->gc[idx];
 
         irq_gc_lock(gc);
-        smr = irq_reg_readl(gc->reg_base + AT91_AIC_SMR(*out_hwirq));
+        smr = irq_reg_readl(gc, AT91_AIC_SMR(*out_hwirq));
         ret = aic_common_set_priority(intspec[2], &smr);
         if (!ret)
-                irq_reg_writel(smr, gc->reg_base + AT91_AIC_SMR(*out_hwirq));
+                irq_reg_writel(gc, smr, AT91_AIC_SMR(*out_hwirq));
         irq_gc_unlock(gc);
 
         return ret;
@@ -209,16 +209,32 @@ static const struct irq_domain_ops aic_irq_ops = {
         .xlate  = aic_irq_domain_xlate,
 };
 
-static void __init at91sam9_aic_irq_fixup(struct device_node *root)
+static void __init at91rm9200_aic_irq_fixup(struct device_node *root)
 {
         aic_common_rtc_irq_fixup(root);
 }
 
+static void __init at91sam9260_aic_irq_fixup(struct device_node *root)
+{
+        aic_common_rtt_irq_fixup(root);
+}
+
+static void __init at91sam9g45_aic_irq_fixup(struct device_node *root)
+{
+        aic_common_rtc_irq_fixup(root);
+        aic_common_rtt_irq_fixup(root);
+}
+
 static const struct of_device_id __initdata aic_irq_fixups[] = {
-        { .compatible = "atmel,at91sam9g45", .data = at91sam9_aic_irq_fixup },
-        { .compatible = "atmel,at91sam9n12", .data = at91sam9_aic_irq_fixup },
-        { .compatible = "atmel,at91sam9rl", .data = at91sam9_aic_irq_fixup },
-        { .compatible = "atmel,at91sam9x5", .data = at91sam9_aic_irq_fixup },
+        { .compatible = "atmel,at91rm9200", .data = at91rm9200_aic_irq_fixup },
+        { .compatible = "atmel,at91sam9g45", .data = at91sam9g45_aic_irq_fixup },
+        { .compatible = "atmel,at91sam9n12", .data = at91rm9200_aic_irq_fixup },
+        { .compatible = "atmel,at91sam9rl", .data = at91sam9g45_aic_irq_fixup },
+        { .compatible = "atmel,at91sam9x5", .data = at91rm9200_aic_irq_fixup },
+        { .compatible = "atmel,at91sam9260", .data = at91sam9260_aic_irq_fixup },
+        { .compatible = "atmel,at91sam9261", .data = at91sam9260_aic_irq_fixup },
+        { .compatible = "atmel,at91sam9263", .data = at91sam9260_aic_irq_fixup },
+        { .compatible = "atmel,at91sam9g20", .data = at91sam9260_aic_irq_fixup },
         { /* sentinel */ },
 };
 
diff --git a/drivers/irqchip/irq-atmel-aic5.c b/drivers/irqchip/irq-atmel-aic5.c
index a11aae8fb006..a2e8c3f876cb 100644
--- a/drivers/irqchip/irq-atmel-aic5.c
+++ b/drivers/irqchip/irq-atmel-aic5.c
@@ -75,11 +75,11 @@ aic5_handle(struct pt_regs *regs)
         u32 irqnr;
         u32 irqstat;
 
-        irqnr = irq_reg_readl(gc->reg_base + AT91_AIC5_IVR);
-        irqstat = irq_reg_readl(gc->reg_base + AT91_AIC5_ISR);
+        irqnr = irq_reg_readl(gc, AT91_AIC5_IVR);
+        irqstat = irq_reg_readl(gc, AT91_AIC5_ISR);
 
         if (!irqstat)
-                irq_reg_writel(0, gc->reg_base + AT91_AIC5_EOICR);
+                irq_reg_writel(gc, 0, AT91_AIC5_EOICR);
         else
                 handle_domain_irq(aic5_domain, irqnr, regs);
 }
@@ -92,8 +92,8 @@ static void aic5_mask(struct irq_data *d)
 
         /* Disable interrupt on AIC5 */
         irq_gc_lock(gc);
-        irq_reg_writel(d->hwirq, gc->reg_base + AT91_AIC5_SSR);
-        irq_reg_writel(1, gc->reg_base + AT91_AIC5_IDCR);
+        irq_reg_writel(gc, d->hwirq, AT91_AIC5_SSR);
+        irq_reg_writel(gc, 1, AT91_AIC5_IDCR);
         gc->mask_cache &= ~d->mask;
         irq_gc_unlock(gc);
 }
@@ -106,8 +106,8 @@ static void aic5_unmask(struct irq_data *d)
 
         /* Enable interrupt on AIC5 */
         irq_gc_lock(gc);
-        irq_reg_writel(d->hwirq, gc->reg_base + AT91_AIC5_SSR);
-        irq_reg_writel(1, gc->reg_base + AT91_AIC5_IECR);
+        irq_reg_writel(gc, d->hwirq, AT91_AIC5_SSR);
+        irq_reg_writel(gc, 1, AT91_AIC5_IECR);
         gc->mask_cache |= d->mask;
         irq_gc_unlock(gc);
 }
@@ -120,8 +120,8 @@ static int aic5_retrigger(struct irq_data *d)
 
         /* Enable interrupt on AIC5 */
         irq_gc_lock(gc);
-        irq_reg_writel(d->hwirq, gc->reg_base + AT91_AIC5_SSR);
-        irq_reg_writel(1, gc->reg_base + AT91_AIC5_ISCR);
+        irq_reg_writel(gc, d->hwirq, AT91_AIC5_SSR);
+        irq_reg_writel(gc, 1, AT91_AIC5_ISCR);
         irq_gc_unlock(gc);
 
         return 0;
@@ -136,11 +136,11 @@ static int aic5_set_type(struct irq_data *d, unsigned type)
         int ret;
 
         irq_gc_lock(gc);
-        irq_reg_writel(d->hwirq, gc->reg_base + AT91_AIC5_SSR);
-        smr = irq_reg_readl(gc->reg_base + AT91_AIC5_SMR);
+        irq_reg_writel(gc, d->hwirq, AT91_AIC5_SSR);
+        smr = irq_reg_readl(gc, AT91_AIC5_SMR);
         ret = aic_common_set_type(d, type, &smr);
         if (!ret)
-                irq_reg_writel(smr, gc->reg_base + AT91_AIC5_SMR);
+                irq_reg_writel(gc, smr, AT91_AIC5_SMR);
         irq_gc_unlock(gc);
 
         return ret;
@@ -162,12 +162,11 @@ static void aic5_suspend(struct irq_data *d)
                 if ((mask & gc->mask_cache) == (mask & gc->wake_active))
                         continue;
 
-                irq_reg_writel(i + gc->irq_base,
-                               bgc->reg_base + AT91_AIC5_SSR);
+                irq_reg_writel(bgc, i + gc->irq_base, AT91_AIC5_SSR);
                 if (mask & gc->wake_active)
-                        irq_reg_writel(1, bgc->reg_base + AT91_AIC5_IECR);
+                        irq_reg_writel(bgc, 1, AT91_AIC5_IECR);
                 else
-                        irq_reg_writel(1, bgc->reg_base + AT91_AIC5_IDCR);
+                        irq_reg_writel(bgc, 1, AT91_AIC5_IDCR);
         }
         irq_gc_unlock(bgc);
 }
@@ -187,12 +186,11 @@ static void aic5_resume(struct irq_data *d)
                 if ((mask & gc->mask_cache) == (mask & gc->wake_active))
                         continue;
 
-                irq_reg_writel(i + gc->irq_base,
-                               bgc->reg_base + AT91_AIC5_SSR);
+                irq_reg_writel(bgc, i + gc->irq_base, AT91_AIC5_SSR);
                 if (mask & gc->mask_cache)
-                        irq_reg_writel(1, bgc->reg_base + AT91_AIC5_IECR);
+                        irq_reg_writel(bgc, 1, AT91_AIC5_IECR);
                 else
-                        irq_reg_writel(1, bgc->reg_base + AT91_AIC5_IDCR);
+                        irq_reg_writel(bgc, 1, AT91_AIC5_IDCR);
         }
         irq_gc_unlock(bgc);
 }
@@ -207,10 +205,9 @@ static void aic5_pm_shutdown(struct irq_data *d)
 
         irq_gc_lock(bgc);
         for (i = 0; i < dgc->irqs_per_chip; i++) {
-                irq_reg_writel(i + gc->irq_base,
-                               bgc->reg_base + AT91_AIC5_SSR);
-                irq_reg_writel(1, bgc->reg_base + AT91_AIC5_IDCR);
-                irq_reg_writel(1, bgc->reg_base + AT91_AIC5_ICCR);
+                irq_reg_writel(bgc, i + gc->irq_base, AT91_AIC5_SSR);
+                irq_reg_writel(bgc, 1, AT91_AIC5_IDCR);
+                irq_reg_writel(bgc, 1, AT91_AIC5_ICCR);
         }
         irq_gc_unlock(bgc);
 }
@@ -230,24 +227,24 @@ static void __init aic5_hw_init(struct irq_domain *domain)
          * will not Lock out nIRQ
          */
         for (i = 0; i < 8; i++)
-                irq_reg_writel(0, gc->reg_base + AT91_AIC5_EOICR);
+                irq_reg_writel(gc, 0, AT91_AIC5_EOICR);
 
         /*
          * Spurious Interrupt ID in Spurious Vector Register.
          * When there is no current interrupt, the IRQ Vector Register
          * reads the value stored in AIC_SPU
          */
-        irq_reg_writel(0xffffffff, gc->reg_base + AT91_AIC5_SPU);
+        irq_reg_writel(gc, 0xffffffff, AT91_AIC5_SPU);
 
         /* No debugging in AIC: Debug (Protect) Control Register */
-        irq_reg_writel(0, gc->reg_base + AT91_AIC5_DCR);
+        irq_reg_writel(gc, 0, AT91_AIC5_DCR);
 
         /* Disable and clear all interrupts initially */
         for (i = 0; i < domain->revmap_size; i++) {
-                irq_reg_writel(i, gc->reg_base + AT91_AIC5_SSR);
-                irq_reg_writel(i, gc->reg_base + AT91_AIC5_SVR);
-                irq_reg_writel(1, gc->reg_base + AT91_AIC5_IDCR);
-                irq_reg_writel(1, gc->reg_base + AT91_AIC5_ICCR);
+                irq_reg_writel(gc, i, AT91_AIC5_SSR);
+                irq_reg_writel(gc, i, AT91_AIC5_SVR);
+                irq_reg_writel(gc, 1, AT91_AIC5_IDCR);
+                irq_reg_writel(gc, 1, AT91_AIC5_ICCR);
         }
 }
 
@@ -273,11 +270,11 @@ static int aic5_irq_domain_xlate(struct irq_domain *d,
         gc = dgc->gc[0];
 
         irq_gc_lock(gc);
-        irq_reg_writel(*out_hwirq, gc->reg_base + AT91_AIC5_SSR);
-        smr = irq_reg_readl(gc->reg_base + AT91_AIC5_SMR);
+        irq_reg_writel(gc, *out_hwirq, AT91_AIC5_SSR);
+        smr = irq_reg_readl(gc, AT91_AIC5_SMR);
         ret = aic_common_set_priority(intspec[2], &smr);
         if (!ret)
-                irq_reg_writel(intspec[2] | smr, gc->reg_base + AT91_AIC5_SMR);
+                irq_reg_writel(gc, intspec[2] | smr, AT91_AIC5_SMR);
         irq_gc_unlock(gc);
 
         return ret;
diff --git a/drivers/irqchip/irq-bcm7120-l2.c b/drivers/irqchip/irq-bcm7120-l2.c
index b9f4fb808e49..8eec8e1201d9 100644
--- a/drivers/irqchip/irq-bcm7120-l2.c
+++ b/drivers/irqchip/irq-bcm7120-l2.c
@@ -13,6 +13,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/kconfig.h>
 #include <linux/platform_device.h>
 #include <linux/of.h>
 #include <linux/of_irq.h>
@@ -23,47 +24,52 @@
 #include <linux/io.h>
 #include <linux/irqdomain.h>
 #include <linux/reboot.h>
+#include <linux/bitops.h>
 #include <linux/irqchip/chained_irq.h>
 
 #include "irqchip.h"
 
-#include <asm/mach/irq.h>
-
 /* Register offset in the L2 interrupt controller */
 #define IRQEN           0x00
 #define IRQSTAT         0x04
 
+#define MAX_WORDS       4
+#define IRQS_PER_WORD   32
+
 struct bcm7120_l2_intc_data {
-        void __iomem *base;
+        unsigned int n_words;
+        void __iomem *base[MAX_WORDS];
         struct irq_domain *domain;
         bool can_wake;
-        u32 irq_fwd_mask;
-        u32 irq_map_mask;
-        u32 saved_mask;
+        u32 irq_fwd_mask[MAX_WORDS];
+        u32 irq_map_mask[MAX_WORDS];
 };
 
 static void bcm7120_l2_intc_irq_handle(unsigned int irq, struct irq_desc *desc)
 {
         struct bcm7120_l2_intc_data *b = irq_desc_get_handler_data(desc);
         struct irq_chip *chip = irq_desc_get_chip(desc);
-        u32 status;
+        unsigned int idx;
 
         chained_irq_enter(chip, desc);
 
-        status = __raw_readl(b->base + IRQSTAT);
-
-        if (status == 0) {
-                do_bad_IRQ(irq, desc);
-                goto out;
+        for (idx = 0; idx < b->n_words; idx++) {
+                int base = idx * IRQS_PER_WORD;
+                struct irq_chip_generic *gc =
+                        irq_get_domain_generic_chip(b->domain, base);
+                unsigned long pending;
+                int hwirq;
+
+                irq_gc_lock(gc);
+                pending = irq_reg_readl(gc, IRQSTAT) & gc->mask_cache;
+                irq_gc_unlock(gc);
+
+                for_each_set_bit(hwirq, &pending, IRQS_PER_WORD) {
+                        generic_handle_irq(irq_find_mapping(b->domain,
+                                           base + hwirq));
+                }
         }
 
-        do {
-                irq = ffs(status) - 1;
-                status &= ~(1 << irq);
-                generic_handle_irq(irq_find_mapping(b->domain, irq));
-        } while (status);
-
-out:
         chained_irq_exit(chip, desc);
 }
 
@@ -71,26 +77,20 @@ static void bcm7120_l2_intc_suspend(struct irq_data *d)
 {
         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
         struct bcm7120_l2_intc_data *b = gc->private;
-        u32 reg;
 
         irq_gc_lock(gc);
-        /* Save the current mask and the interrupt forward mask */
-        b->saved_mask = __raw_readl(b->base) | b->irq_fwd_mask;
-        if (b->can_wake) {
-                reg = b->saved_mask | gc->wake_active;
-                __raw_writel(reg, b->base);
-        }
+        if (b->can_wake)
+                irq_reg_writel(gc, gc->mask_cache | gc->wake_active, IRQEN);
         irq_gc_unlock(gc);
 }
 
 static void bcm7120_l2_intc_resume(struct irq_data *d)
 {
         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
-        struct bcm7120_l2_intc_data *b = gc->private;
 
         /* Restore the saved mask */
         irq_gc_lock(gc);
-        __raw_writel(b->saved_mask, b->base);
+        irq_reg_writel(gc, gc->mask_cache, IRQEN);
         irq_gc_unlock(gc);
 }
 
@@ -99,14 +99,20 @@ static int bcm7120_l2_intc_init_one(struct device_node *dn,
                                         int irq, const __be32 *map_mask)
 {
         int parent_irq;
+        unsigned int idx;
 
         parent_irq = irq_of_parse_and_map(dn, irq);
-        if (parent_irq < 0) {
+        if (!parent_irq) {
                 pr_err("failed to map interrupt %d\n", irq);
-                return parent_irq;
+                return -EINVAL;
         }
 
-        data->irq_map_mask |= be32_to_cpup(map_mask + irq);
+        /* For multiple parent IRQs with multiple words, this looks like:
+         * <irq0_w0 irq0_w1 irq1_w0 irq1_w1 ...>
+         */
+        for (idx = 0; idx < data->n_words; idx++)
+                data->irq_map_mask[idx] |=
+                        be32_to_cpup(map_mask + irq * data->n_words + idx);
 
         irq_set_handler_data(parent_irq, data);
         irq_set_chained_handler(parent_irq, bcm7120_l2_intc_irq_handle);
@@ -123,26 +129,41 @@ int __init bcm7120_l2_intc_of_init(struct device_node *dn,
         struct irq_chip_type *ct;
         const __be32 *map_mask;
         int num_parent_irqs;
-        int ret = 0, len, irq;
+        int ret = 0, len;
+        unsigned int idx, irq, flags;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
-        data->base = of_iomap(dn, 0);
-        if (!data->base) {
+        for (idx = 0; idx < MAX_WORDS; idx++) {
+                data->base[idx] = of_iomap(dn, idx);
+                if (!data->base[idx])
+                        break;
+                data->n_words = idx + 1;
+        }
+        if (!data->n_words) {
                 pr_err("failed to remap intc L2 registers\n");
                 ret = -ENOMEM;
-                goto out_free;
+                goto out_unmap;
         }
 
-        if (of_property_read_u32(dn, "brcm,int-fwd-mask", &data->irq_fwd_mask))
-                data->irq_fwd_mask = 0;
-
-        /* Enable all interrupt specified in the interrupt forward mask and have
-         * the other disabled
+        /* Enable all interrupts specified in the interrupt forward mask;
+         * disable all others.  If the property doesn't exist (-EINVAL),
+         * assume all zeroes.
          */
-        __raw_writel(data->irq_fwd_mask, data->base + IRQEN);
+        ret = of_property_read_u32_array(dn, "brcm,int-fwd-mask",
+                                         data->irq_fwd_mask, data->n_words);
+        if (ret == 0 || ret == -EINVAL) {
+                for (idx = 0; idx < data->n_words; idx++)
+                        __raw_writel(data->irq_fwd_mask[idx],
+                                     data->base[idx] + IRQEN);
+        } else {
+                /* property exists but has the wrong number of words */
+                pr_err("invalid int-fwd-mask property\n");
+                ret = -EINVAL;
+                goto out_unmap;
+        }
 
         num_parent_irqs = of_irq_count(dn);
         if (num_parent_irqs <= 0) {
@@ -152,7 +173,8 @@ int __init bcm7120_l2_intc_of_init(struct device_node *dn,
         }
 
         map_mask = of_get_property(dn, "brcm,int-map-mask", &len);
-        if (!map_mask || (len != (sizeof(*map_mask) * num_parent_irqs))) {
+        if (!map_mask ||
+            (len != (sizeof(*map_mask) * num_parent_irqs * data->n_words))) {
                 pr_err("invalid brcm,int-map-mask property\n");
                 ret = -EINVAL;
                 goto out_unmap;
@@ -164,56 +186,70 @@ int __init bcm7120_l2_intc_of_init(struct device_node *dn,
                         goto out_unmap;
         }
 
-        data->domain = irq_domain_add_linear(dn, 32,
-                                        &irq_generic_chip_ops, NULL);
+        data->domain = irq_domain_add_linear(dn, IRQS_PER_WORD * data->n_words,
+                                             &irq_generic_chip_ops, NULL);
         if (!data->domain) {
                 ret = -ENOMEM;
                 goto out_unmap;
         }
 
-        ret = irq_alloc_domain_generic_chips(data->domain, 32, 1,
-                                dn->full_name, handle_level_irq, clr, 0,
-                                IRQ_GC_INIT_MASK_CACHE);
+        /* MIPS chips strapped for BE will automagically configure the
+         * peripheral registers for CPU-native byte order.
+         */
+        flags = IRQ_GC_INIT_MASK_CACHE;
+        if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
+                flags |= IRQ_GC_BE_IO;
+
+        ret = irq_alloc_domain_generic_chips(data->domain, IRQS_PER_WORD, 1,
+                                dn->full_name, handle_level_irq, clr, 0, flags);
         if (ret) {
                 pr_err("failed to allocate generic irq chip\n");
                 goto out_free_domain;
         }
 
-        gc = irq_get_domain_generic_chip(data->domain, 0);
-        gc->unused = 0xfffffff & ~data->irq_map_mask;
-        gc->reg_base = data->base;
-        gc->private = data;
-        ct = gc->chip_types;
-
-        ct->regs.mask = IRQEN;
-        ct->chip.irq_mask = irq_gc_mask_clr_bit;
-        ct->chip.irq_unmask = irq_gc_mask_set_bit;
-        ct->chip.irq_ack = irq_gc_noop;
-        ct->chip.irq_suspend = bcm7120_l2_intc_suspend;
-        ct->chip.irq_resume = bcm7120_l2_intc_resume;
-
-        if (of_property_read_bool(dn, "brcm,irq-can-wake")) {
+        if (of_property_read_bool(dn, "brcm,irq-can-wake"))
                 data->can_wake = true;
-                /* This IRQ chip can wake the system, set all relevant child
-                 * interupts in wake_enabled mask
-                 */
-                gc->wake_enabled = 0xffffffff;
-                gc->wake_enabled &= ~gc->unused;
-                ct->chip.irq_set_wake = irq_gc_set_wake;
+
+        for (idx = 0; idx < data->n_words; idx++) {
+                irq = idx * IRQS_PER_WORD;
+                gc = irq_get_domain_generic_chip(data->domain, irq);
+
+                gc->unused = 0xffffffff & ~data->irq_map_mask[idx];
+                gc->reg_base = data->base[idx];
+                gc->private = data;
+                ct = gc->chip_types;
+
+                ct->regs.mask = IRQEN;
+                ct->chip.irq_mask = irq_gc_mask_clr_bit;
+                ct->chip.irq_unmask = irq_gc_mask_set_bit;
+                ct->chip.irq_ack = irq_gc_noop;
+                ct->chip.irq_suspend = bcm7120_l2_intc_suspend;
+                ct->chip.irq_resume = bcm7120_l2_intc_resume;
+
+                if (data->can_wake) {
+                        /* This IRQ chip can wake the system, set all
+                         * relevant child interupts in wake_enabled mask
+                         */
+                        gc->wake_enabled = 0xffffffff;
+                        gc->wake_enabled &= ~gc->unused;
+                        ct->chip.irq_set_wake = irq_gc_set_wake;
+                }
         }
 
         pr_info("registered BCM7120 L2 intc (mem: 0x%p, parent IRQ(s): %d)\n",
-                        data->base, num_parent_irqs);
+                        data->base[0], num_parent_irqs);
 
         return 0;
 
 out_free_domain:
         irq_domain_remove(data->domain);
 out_unmap:
-        iounmap(data->base);
-out_free:
+        for (idx = 0; idx < MAX_WORDS; idx++) {
+                if (data->base[idx])
+                        iounmap(data->base[idx]);
+        }
         kfree(data);
         return ret;
 }
-IRQCHIP_DECLARE(brcmstb_l2_intc, "brcm,bcm7120-l2-intc",
+IRQCHIP_DECLARE(bcm7120_l2_intc, "brcm,bcm7120-l2-intc",
                 bcm7120_l2_intc_of_init);
diff --git a/drivers/irqchip/irq-brcmstb-l2.c b/drivers/irqchip/irq-brcmstb-l2.c
index c15c840987d2..313c2c64498a 100644
--- a/drivers/irqchip/irq-brcmstb-l2.c
+++ b/drivers/irqchip/irq-brcmstb-l2.c
@@ -18,7 +18,9 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/kconfig.h>
 #include <linux/platform_device.h>
+#include <linux/spinlock.h>
 #include <linux/of.h>
 #include <linux/of_irq.h>
 #include <linux/of_address.h>
@@ -30,8 +32,6 @@
 #include <linux/irqchip.h>
 #include <linux/irqchip/chained_irq.h>
 
-#include <asm/mach/irq.h>
-
 #include "irqchip.h"
 
 /* Register offsets in the L2 interrupt controller */
@@ -54,23 +54,26 @@ struct brcmstb_l2_intc_data {
 static void brcmstb_l2_intc_irq_handle(unsigned int irq, struct irq_desc *desc)
 {
         struct brcmstb_l2_intc_data *b = irq_desc_get_handler_data(desc);
+        struct irq_chip_generic *gc = irq_get_domain_generic_chip(b->domain, 0);
         struct irq_chip *chip = irq_desc_get_chip(desc);
         u32 status;
 
         chained_irq_enter(chip, desc);
 
-        status = __raw_readl(b->base + CPU_STATUS) &
-                ~(__raw_readl(b->base + CPU_MASK_STATUS));
+        status = irq_reg_readl(gc, CPU_STATUS) &
+                ~(irq_reg_readl(gc, CPU_MASK_STATUS));
 
         if (status == 0) {
-                do_bad_IRQ(irq, desc);
+                raw_spin_lock(&desc->lock);
+                handle_bad_irq(irq, desc);
+                raw_spin_unlock(&desc->lock);
                 goto out;
         }
 
         do {
                 irq = ffs(status) - 1;
                 /* ack at our level */
-                __raw_writel(1 << irq, b->base + CPU_CLEAR);
+                irq_reg_writel(gc, 1 << irq, CPU_CLEAR);
                 status &= ~(1 << irq);
                 generic_handle_irq(irq_find_mapping(b->domain, irq));
         } while (status);
@@ -85,12 +88,12 @@ static void brcmstb_l2_intc_suspend(struct irq_data *d)
 
         irq_gc_lock(gc);
         /* Save the current mask */
-        b->saved_mask = __raw_readl(b->base + CPU_MASK_STATUS);
+        b->saved_mask = irq_reg_readl(gc, CPU_MASK_STATUS);
 
         if (b->can_wake) {
                 /* Program the wakeup mask */
-                __raw_writel(~gc->wake_active, b->base + CPU_MASK_SET);
-                __raw_writel(gc->wake_active, b->base + CPU_MASK_CLEAR);
+                irq_reg_writel(gc, ~gc->wake_active, CPU_MASK_SET);
+                irq_reg_writel(gc, gc->wake_active, CPU_MASK_CLEAR);
         }
         irq_gc_unlock(gc);
 }
@@ -102,11 +105,11 @@ static void brcmstb_l2_intc_resume(struct irq_data *d)
 
         irq_gc_lock(gc);
         /* Clear unmasked non-wakeup interrupts */
-        __raw_writel(~b->saved_mask & ~gc->wake_active, b->base + CPU_CLEAR);
+        irq_reg_writel(gc, ~b->saved_mask & ~gc->wake_active, CPU_CLEAR);
 
         /* Restore the saved mask */
-        __raw_writel(b->saved_mask, b->base + CPU_MASK_SET);
-        __raw_writel(~b->saved_mask, b->base + CPU_MASK_CLEAR);
+        irq_reg_writel(gc, b->saved_mask, CPU_MASK_SET);
+        irq_reg_writel(gc, ~b->saved_mask, CPU_MASK_CLEAR);
         irq_gc_unlock(gc);
 }
 
@@ -118,6 +121,7 @@ int __init brcmstb_l2_intc_of_init(struct device_node *np,
         struct irq_chip_generic *gc;
         struct irq_chip_type *ct;
         int ret;
+        unsigned int flags;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
@@ -131,13 +135,13 @@ int __init brcmstb_l2_intc_of_init(struct device_node *np,
         }
 
         /* Disable all interrupts by default */
-        __raw_writel(0xffffffff, data->base + CPU_MASK_SET);
-        __raw_writel(0xffffffff, data->base + CPU_CLEAR);
+        writel(0xffffffff, data->base + CPU_MASK_SET);
+        writel(0xffffffff, data->base + CPU_CLEAR);
 
         data->parent_irq = irq_of_parse_and_map(np, 0);
-        if (data->parent_irq < 0) {
+        if (!data->parent_irq) {
                 pr_err("failed to find parent interrupt\n");
-                ret = data->parent_irq;
+                ret = -EINVAL;
                 goto out_unmap;
         }
 
@@ -148,9 +152,16 @@ int __init brcmstb_l2_intc_of_init(struct device_node *np,
                 goto out_unmap;
         }
 
+        /* MIPS chips strapped for BE will automagically configure the
+         * peripheral registers for CPU-native byte order.
+         */
+        flags = 0;
+        if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
+                flags |= IRQ_GC_BE_IO;
+
         /* Allocate a single Generic IRQ chip for this node */
         ret = irq_alloc_domain_generic_chips(data->domain, 32, 1,
-                                np->full_name, handle_edge_irq, clr, 0, 0);
+                                np->full_name, handle_edge_irq, clr, 0, flags);
         if (ret) {
                 pr_err("failed to allocate generic irq chip\n");
                 goto out_free_domain;
diff --git a/drivers/irqchip/irq-dw-apb-ictl.c b/drivers/irqchip/irq-dw-apb-ictl.c
index 31e231e1f566..53bb7326a60a 100644
--- a/drivers/irqchip/irq-dw-apb-ictl.c
+++ b/drivers/irqchip/irq-dw-apb-ictl.c
@@ -50,6 +50,21 @@ static void dw_apb_ictl_handler(unsigned int irq, struct irq_desc *desc)
         chained_irq_exit(chip, desc);
 }
 
+#ifdef CONFIG_PM
+static void dw_apb_ictl_resume(struct irq_data *d)
+{
+        struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
+        struct irq_chip_type *ct = irq_data_get_chip_type(d);
+
+        irq_gc_lock(gc);
+        writel_relaxed(~0, gc->reg_base + ct->regs.enable);
+        writel_relaxed(*ct->mask_cache, gc->reg_base + ct->regs.mask);
+        irq_gc_unlock(gc);
+}
+#else
+#define dw_apb_ictl_resume      NULL
+#endif /* CONFIG_PM */
+
 static int __init dw_apb_ictl_init(struct device_node *np,
                                    struct device_node *parent)
 {
@@ -94,16 +109,16 @@ static int __init dw_apb_ictl_init(struct device_node *np,
          */
 
         /* mask and enable all interrupts */
-        writel(~0, iobase + APB_INT_MASK_L);
-        writel(~0, iobase + APB_INT_MASK_H);
-        writel(~0, iobase + APB_INT_ENABLE_L);
-        writel(~0, iobase + APB_INT_ENABLE_H);
+        writel_relaxed(~0, iobase + APB_INT_MASK_L);
+        writel_relaxed(~0, iobase + APB_INT_MASK_H);
+        writel_relaxed(~0, iobase + APB_INT_ENABLE_L);
+        writel_relaxed(~0, iobase + APB_INT_ENABLE_H);
 
-        reg = readl(iobase + APB_INT_ENABLE_H);
+        reg = readl_relaxed(iobase + APB_INT_ENABLE_H);
         if (reg)
                 nrirqs = 32 + fls(reg);
         else
-                nrirqs = fls(readl(iobase + APB_INT_ENABLE_L));
+                nrirqs = fls(readl_relaxed(iobase + APB_INT_ENABLE_L));
 
         domain = irq_domain_add_linear(np, nrirqs,
                                        &irq_generic_chip_ops, NULL);
@@ -115,6 +130,7 @@ static int __init dw_apb_ictl_init(struct device_node *np,
 
         ret = irq_alloc_domain_generic_chips(domain, 32, (nrirqs > 32) ? 2 : 1,
                                              np->name, handle_level_irq, clr, 0,
+                                             IRQ_GC_MASK_CACHE_PER_TYPE |
                                              IRQ_GC_INIT_MASK_CACHE);
         if (ret) {
                 pr_err("%s: unable to alloc irq domain gc\n", np->full_name);
@@ -126,13 +142,17 @@ static int __init dw_apb_ictl_init(struct device_node *np,
         gc->reg_base = iobase;
 
         gc->chip_types[0].regs.mask = APB_INT_MASK_L;
+        gc->chip_types[0].regs.enable = APB_INT_ENABLE_L;
         gc->chip_types[0].chip.irq_mask = irq_gc_mask_set_bit;
         gc->chip_types[0].chip.irq_unmask = irq_gc_mask_clr_bit;
+        gc->chip_types[0].chip.irq_resume = dw_apb_ictl_resume;
 
         if (nrirqs > 32) {
                 gc->chip_types[1].regs.mask = APB_INT_MASK_H;
+                gc->chip_types[1].regs.enable = APB_INT_ENABLE_H;
                 gc->chip_types[1].chip.irq_mask = irq_gc_mask_set_bit;
                 gc->chip_types[1].chip.irq_unmask = irq_gc_mask_clr_bit;
+                gc->chip_types[1].chip.irq_resume = dw_apb_ictl_resume;
         }
 
         irq_set_handler_data(irq, gc);
diff --git a/drivers/irqchip/irq-gic.c b/drivers/irqchip/irq-gic.c
index 38493ff28fa5..7f9be0785c6a 100644
--- a/drivers/irqchip/irq-gic.c
+++ b/drivers/irqchip/irq-gic.c
@@ -1041,6 +1041,8 @@ gic_of_init(struct device_node *node, struct device_node *parent)
         return 0;
 }
 IRQCHIP_DECLARE(gic_400, "arm,gic-400", gic_of_init);
+IRQCHIP_DECLARE(arm11mp_gic, "arm,arm11mp-gic", gic_of_init);
+IRQCHIP_DECLARE(arm1176jzf_dc_gic, "arm,arm1176jzf-devchip-gic", gic_of_init);
 IRQCHIP_DECLARE(cortex_a15_gic, "arm,cortex-a15-gic", gic_of_init);
 IRQCHIP_DECLARE(cortex_a9_gic, "arm,cortex-a9-gic", gic_of_init);
 IRQCHIP_DECLARE(cortex_a7_gic, "arm,cortex-a7-gic", gic_of_init);
diff --git a/drivers/irqchip/irq-hip04.c b/drivers/irqchip/irq-hip04.c
index 9c8f833522e6..29b8f21b74d0 100644
--- a/drivers/irqchip/irq-hip04.c
+++ b/drivers/irqchip/irq-hip04.c
@@ -176,8 +176,7 @@ static void __exception_irq_entry hip04_handle_irq(struct pt_regs *regs)
                 irqnr = irqstat & GICC_IAR_INT_ID_MASK;
 
                 if (likely(irqnr > 15 && irqnr <= HIP04_MAX_IRQS)) {
-                        irqnr = irq_find_mapping(hip04_data.domain, irqnr);
-                        handle_IRQ(irqnr, regs);
+                        handle_domain_irq(hip04_data.domain, irqnr, regs);
                         continue;
                 }
                 if (irqnr < 16) {
diff --git a/drivers/irqchip/irq-sunxi-nmi.c b/drivers/irqchip/irq-sunxi-nmi.c
index 12f547a44ae4..4a9ce5b50c5b 100644
--- a/drivers/irqchip/irq-sunxi-nmi.c
+++ b/drivers/irqchip/irq-sunxi-nmi.c
@@ -50,12 +50,12 @@ static struct sunxi_sc_nmi_reg_offs sun6i_reg_offs = {
 static inline void sunxi_sc_nmi_write(struct irq_chip_generic *gc, u32 off,
                                       u32 val)
 {
-        irq_reg_writel(val, gc->reg_base + off);
+        irq_reg_writel(gc, val, off);
 }
 
 static inline u32 sunxi_sc_nmi_read(struct irq_chip_generic *gc, u32 off)
 {
-        return irq_reg_readl(gc->reg_base + off);
+        return irq_reg_readl(gc, off);
 }
 
 static void sunxi_sc_nmi_handle_irq(unsigned int irq, struct irq_desc *desc)
diff --git a/drivers/irqchip/irq-tb10x.c b/drivers/irqchip/irq-tb10x.c
index 7c44c99bf1f2..accc20036a3c 100644
--- a/drivers/irqchip/irq-tb10x.c
+++ b/drivers/irqchip/irq-tb10x.c
@@ -43,12 +43,12 @@
 static inline void ab_irqctl_writereg(struct irq_chip_generic *gc, u32 reg,
         u32 val)
 {
-        irq_reg_writel(val, gc->reg_base + reg);
+        irq_reg_writel(gc, val, reg);
 }
 
 static inline u32 ab_irqctl_readreg(struct irq_chip_generic *gc, u32 reg)
 {
-        return irq_reg_readl(gc->reg_base + reg);
+        return irq_reg_readl(gc, reg);
 }
 
 static int tb10x_irq_set_type(struct irq_data *data, unsigned int flow_type)
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index b4518c8751c8..868e6fc17cba 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -12,25 +12,23 @@
  */
 #include <linux/err.h>
 #include <linux/gpio.h>
+#include <linux/gpio/consumer.h>
 #include <linux/kernel.h>
 #include <linux/leds.h>
 #include <linux/module.h>
-#include <linux/of.h>
-#include <linux/of_gpio.h>
-#include <linux/of_platform.h>
 #include <linux/platform_device.h>
+#include <linux/property.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 
 struct gpio_led_data {
         struct led_classdev cdev;
-        unsigned gpio;
+        struct gpio_desc *gpiod;
         struct work_struct work;
         u8 new_level;
         u8 can_sleep;
-        u8 active_low;
         u8 blinking;
-        int (*platform_gpio_blink_set)(unsigned gpio, int state,
+        int (*platform_gpio_blink_set)(struct gpio_desc *desc, int state,
                         unsigned long *delay_on, unsigned long *delay_off);
 };
 
@@ -40,12 +38,11 @@ static void gpio_led_work(struct work_struct *work)
                 container_of(work, struct gpio_led_data, work);
 
         if (led_dat->blinking) {
-                led_dat->platform_gpio_blink_set(led_dat->gpio,
-                                                 led_dat->new_level,
-                                                 NULL, NULL);
+                led_dat->platform_gpio_blink_set(led_dat->gpiod,
+                                        led_dat->new_level, NULL, NULL);
                 led_dat->blinking = 0;
         } else
-                gpio_set_value_cansleep(led_dat->gpio, led_dat->new_level);
+                gpiod_set_value_cansleep(led_dat->gpiod, led_dat->new_level);
 }
 
 static void gpio_led_set(struct led_classdev *led_cdev,
@@ -60,9 +57,6 @@ static void gpio_led_set(struct led_classdev *led_cdev,
         else
                 level = 1;
 
-        if (led_dat->active_low)
-                level = !level;
-
         /* Setting GPIOs with I2C/etc requires a task context, and we don't
          * seem to have a reliable way to know if we're already in one; so
          * let's just assume the worst.
@@ -72,11 +66,11 @@ static void gpio_led_set(struct led_classdev *led_cdev,
                 schedule_work(&led_dat->work);
         } else {
                 if (led_dat->blinking) {
-                        led_dat->platform_gpio_blink_set(led_dat->gpio, level,
+                        led_dat->platform_gpio_blink_set(led_dat->gpiod, level,
                                                          NULL, NULL);
                         led_dat->blinking = 0;
                 } else
-                        gpio_set_value(led_dat->gpio, level);
+                        gpiod_set_value(led_dat->gpiod, level);
         }
 }
 
@@ -87,34 +81,49 @@ static int gpio_blink_set(struct led_classdev *led_cdev,
                 container_of(led_cdev, struct gpio_led_data, cdev);
 
         led_dat->blinking = 1;
-        return led_dat->platform_gpio_blink_set(led_dat->gpio, GPIO_LED_BLINK,
+        return led_dat->platform_gpio_blink_set(led_dat->gpiod, GPIO_LED_BLINK,
                                                 delay_on, delay_off);
 }
 
 static int create_gpio_led(const struct gpio_led *template,
         struct gpio_led_data *led_dat, struct device *parent,
-        int (*blink_set)(unsigned, int, unsigned long *, unsigned long *))
+        int (*blink_set)(struct gpio_desc *, int, unsigned long *,
+                         unsigned long *))
 {
         int ret, state;
 
-        led_dat->gpio = -1;
+        led_dat->gpiod = template->gpiod;
+        if (!led_dat->gpiod) {
+                /*
+                 * This is the legacy code path for platform code that
+                 * still uses GPIO numbers. Ultimately we would like to get
+                 * rid of this block completely.
+                 */
+                unsigned long flags = 0;
+
+                /* skip leds that aren't available */
+                if (!gpio_is_valid(template->gpio)) {
+                        dev_info(parent, "Skipping unavailable LED gpio %d (%s)\n",
+                                        template->gpio, template->name);
+                        return 0;
+                }
 
-        /* skip leds that aren't available */
-        if (!gpio_is_valid(template->gpio)) {
-                dev_info(parent, "Skipping unavailable LED gpio %d (%s)\n",
-                                template->gpio, template->name);
-                return 0;
-        }
+                if (template->active_low)
+                        flags |= GPIOF_ACTIVE_LOW;
 
-        ret = devm_gpio_request(parent, template->gpio, template->name);
-        if (ret < 0)
-                return ret;
+                ret = devm_gpio_request_one(parent, template->gpio, flags,
+                                            template->name);
+                if (ret < 0)
+                        return ret;
+
+                led_dat->gpiod = gpio_to_desc(template->gpio);
+                if (IS_ERR(led_dat->gpiod))
+                        return PTR_ERR(led_dat->gpiod);
+        }
 
         led_dat->cdev.name = template->name;
         led_dat->cdev.default_trigger = template->default_trigger;
-        led_dat->gpio = template->gpio;
-        led_dat->can_sleep = gpio_cansleep(template->gpio);
-        led_dat->active_low = template->active_low;
+        led_dat->can_sleep = gpiod_cansleep(led_dat->gpiod);
         led_dat->blinking = 0;
         if (blink_set) {
                 led_dat->platform_gpio_blink_set = blink_set;
@@ -122,30 +131,24 @@ static int create_gpio_led(const struct gpio_led *template,
         }
         led_dat->cdev.brightness_set = gpio_led_set;
         if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP)
-                state = !!gpio_get_value_cansleep(led_dat->gpio) ^ led_dat->active_low;
+                state = !!gpiod_get_value_cansleep(led_dat->gpiod);
         else
                 state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);
         led_dat->cdev.brightness = state ? LED_FULL : LED_OFF;
         if (!template->retain_state_suspended)
                 led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
 
-        ret = gpio_direction_output(led_dat->gpio, led_dat->active_low ^ state);
+        ret = gpiod_direction_output(led_dat->gpiod, state);
         if (ret < 0)
                 return ret;
 
         INIT_WORK(&led_dat->work, gpio_led_work);
 
-        ret = led_classdev_register(parent, &led_dat->cdev);
-        if (ret < 0)
-                return ret;
-
-        return 0;
+        return led_classdev_register(parent, &led_dat->cdev);
 }
 
 static void delete_gpio_led(struct gpio_led_data *led)
 {
-        if (!gpio_is_valid(led->gpio))
-                return;
         led_classdev_unregister(&led->cdev);
         cancel_work_sync(&led->work);
 }
@@ -161,40 +164,47 @@ static inline int sizeof_gpio_leds_priv(int num_leds)
                 (sizeof(struct gpio_led_data) * num_leds);
 }
 
-/* Code to create from OpenFirmware platform devices */
-#ifdef CONFIG_OF_GPIO
-static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
+static struct gpio_leds_priv *gpio_leds_create(struct platform_device *pdev)
 {
-        struct device_node *np = pdev->dev.of_node, *child;
+        struct device *dev = &pdev->dev;
+        struct fwnode_handle *child;
         struct gpio_leds_priv *priv;
         int count, ret;
+        struct device_node *np;
 
-        /* count LEDs in this device, so we know how much to allocate */
-        count = of_get_available_child_count(np);
+        count = device_get_child_node_count(dev);
         if (!count)
                 return ERR_PTR(-ENODEV);
 
-        for_each_available_child_of_node(np, child)
-                if (of_get_gpio(child, 0) == -EPROBE_DEFER)
-                        return ERR_PTR(-EPROBE_DEFER);
-
-        priv = devm_kzalloc(&pdev->dev, sizeof_gpio_leds_priv(count),
-                        GFP_KERNEL);
+        priv = devm_kzalloc(dev, sizeof_gpio_leds_priv(count), GFP_KERNEL);
         if (!priv)
                 return ERR_PTR(-ENOMEM);
 
-        for_each_available_child_of_node(np, child) {
+        device_for_each_child_node(dev, child) {
                 struct gpio_led led = {};
-                enum of_gpio_flags flags;
-                const char *state;
-
-                led.gpio = of_get_gpio_flags(child, 0, &flags);
-                led.active_low = flags & OF_GPIO_ACTIVE_LOW;
-                led.name = of_get_property(child, "label", NULL) ? : child->name;
-                led.default_trigger =
-                        of_get_property(child, "linux,default-trigger", NULL);
-                state = of_get_property(child, "default-state", NULL);
-                if (state) {
+                const char *state = NULL;
+
+                led.gpiod = devm_get_gpiod_from_child(dev, child);
+                if (IS_ERR(led.gpiod)) {
+                        fwnode_handle_put(child);
+                        goto err;
+                }
+
+                np = of_node(child);
+
+                if (fwnode_property_present(child, "label")) {
+                        fwnode_property_read_string(child, "label", &led.name);
+                } else {
+                        if (IS_ENABLED(CONFIG_OF) && !led.name && np)
+                                led.name = np->name;
+                        if (!led.name)
+                                return ERR_PTR(-EINVAL);
+                }
+                fwnode_property_read_string(child, "linux,default-trigger",
+                                            &led.default_trigger);
+
+                if (!fwnode_property_read_string(child, "linux,default_state",
+                                                 &state)) {
                         if (!strcmp(state, "keep"))
                                 led.default_state = LEDS_GPIO_DEFSTATE_KEEP;
                         else if (!strcmp(state, "on"))
@@ -203,13 +213,13 @@ static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
                                 led.default_state = LEDS_GPIO_DEFSTATE_OFF;
                 }
 
-                if (of_get_property(child, "retain-state-suspended", NULL))
+                if (fwnode_property_present(child, "retain-state-suspended"))
                         led.retain_state_suspended = 1;
 
                 ret = create_gpio_led(&led, &priv->leds[priv->num_leds++],
-                                      &pdev->dev, NULL);
+                                      dev, NULL);
                 if (ret < 0) {
-                        of_node_put(child);
+                        fwnode_handle_put(child);
                         goto err;
                 }
         }
@@ -228,12 +238,6 @@ static const struct of_device_id of_gpio_leds_match[] = {
 };
 
 MODULE_DEVICE_TABLE(of, of_gpio_leds_match);
-#else /* CONFIG_OF_GPIO */
-static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
-{
-        return ERR_PTR(-ENODEV);
-}
-#endif /* CONFIG_OF_GPIO */
 
 static int gpio_led_probe(struct platform_device *pdev)
 {
@@ -261,7 +265,7 @@ static int gpio_led_probe(struct platform_device *pdev)
                         }
                 }
         } else {
-                priv = gpio_leds_create_of(pdev);
+                priv = gpio_leds_create(pdev);
                 if (IS_ERR(priv))
                         return PTR_ERR(priv);
         }
@@ -288,7 +292,7 @@ static struct platform_driver gpio_led_driver = {
         .driver         = {
                 .name   = "leds-gpio",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(of_gpio_leds_match),
+                .of_match_table = of_gpio_leds_match,
         },
 };
 
diff --git a/drivers/lguest/lguest_device.c b/drivers/lguest/lguest_device.c
index d0a1d8a45c81..89088d6538fd 100644
--- a/drivers/lguest/lguest_device.c
+++ b/drivers/lguest/lguest_device.c
@@ -94,7 +94,7 @@ static unsigned desc_size(const struct lguest_device_desc *desc)
 }
 
 /* This gets the device's feature bits. */
-static u32 lg_get_features(struct virtio_device *vdev)
+static u64 lg_get_features(struct virtio_device *vdev)
 {
         unsigned int i;
         u32 features = 0;
@@ -126,7 +126,7 @@ static void status_notify(struct virtio_device *vdev)
  * sorted out, this routine is called so we can tell the Host which features we
  * understand and accept.
  */
-static void lg_finalize_features(struct virtio_device *vdev)
+static int lg_finalize_features(struct virtio_device *vdev)
 {
         unsigned int i, bits;
         struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
@@ -136,20 +136,25 @@ static void lg_finalize_features(struct virtio_device *vdev)
         /* Give virtio_ring a chance to accept features. */
         vring_transport_features(vdev);
 
+        /* Make sure we don't have any features > 32 bits! */
+        BUG_ON((u32)vdev->features != vdev->features);
+
         /*
-         * The vdev->feature array is a Linux bitmask: this isn't the same as a
-         * the simple array of bits used by lguest devices for features.  So we
-         * do this slow, manual conversion which is completely general.
+         * Since lguest is currently x86-only, we're little-endian.  That
+         * means we could just memcpy.  But it's not time critical, and in
+         * case someone copies this code, we do it the slow, obvious way.
          */
         memset(out_features, 0, desc->feature_len);
         bits = min_t(unsigned, desc->feature_len, sizeof(vdev->features)) * 8;
         for (i = 0; i < bits; i++) {
-                if (test_bit(i, vdev->features))
+                if (__virtio_test_bit(vdev, i))
                         out_features[i / 8] |= (1 << (i % 8));
         }
 
         /* Tell Host we've finished with this device's feature negotiation */
         status_notify(vdev);
+
+        return 0;
 }
 
 /* Once they've found a field, getting a copy of it is easy. */
diff --git a/drivers/mailbox/Kconfig b/drivers/mailbox/Kconfig
index 9fd9c6717e0c..c04fed9eb15d 100644
--- a/drivers/mailbox/Kconfig
+++ b/drivers/mailbox/Kconfig
@@ -33,4 +33,16 @@ config OMAP_MBOX_KFIFO_SIZE
           Specify the default size of mailbox's kfifo buffers (bytes).
           This can also be changed at runtime (via the mbox_kfifo_size
           module parameter).
+
+config PCC
+        bool "Platform Communication Channel Driver"
+        depends on ACPI
+        help
+          ACPI 5.0+ spec defines a generic mode of communication
+          between the OS and a platform such as the BMC. This medium
+          (PCC) is typically used by CPPC (ACPI CPU Performance management),
+          RAS (ACPI reliability protocol) and MPST (ACPI Memory power
+          states). Select this driver if your platform implements the
+          PCC clients mentioned above.
+
 endif
diff --git a/drivers/mailbox/Makefile b/drivers/mailbox/Makefile
index 94ed7cefb14d..dd412c22208b 100644
--- a/drivers/mailbox/Makefile
+++ b/drivers/mailbox/Makefile
@@ -5,3 +5,5 @@ obj-$(CONFIG_MAILBOX)		+= mailbox.o
 obj-$(CONFIG_PL320_MBOX)        += pl320-ipc.o
 
 obj-$(CONFIG_OMAP2PLUS_MBOX)    += omap-mailbox.o
+
+obj-$(CONFIG_PCC)               += pcc.o
diff --git a/drivers/mailbox/mailbox.c b/drivers/mailbox/mailbox.c
index afcb430508ec..59aad4d5da53 100644
--- a/drivers/mailbox/mailbox.c
+++ b/drivers/mailbox/mailbox.c
@@ -21,13 +21,13 @@
 #include <linux/mailbox_client.h>
 #include <linux/mailbox_controller.h>
 
-#define TXDONE_BY_IRQ   BIT(0) /* controller has remote RTR irq */
-#define TXDONE_BY_POLL  BIT(1) /* controller can read status of last TX */
-#define TXDONE_BY_ACK   BIT(2) /* S/W ACK recevied by Client ticks the TX */
+#include "mailbox.h"
 
 static LIST_HEAD(mbox_cons);
 static DEFINE_MUTEX(con_mutex);
 
+static void poll_txdone(unsigned long data);
+
 static int add_to_rbuf(struct mbox_chan *chan, void *mssg)
 {
         int idx;
@@ -60,7 +60,7 @@ static void msg_submit(struct mbox_chan *chan)
         unsigned count, idx;
         unsigned long flags;
         void *data;
-        int err;
+        int err = -EBUSY;
 
         spin_lock_irqsave(&chan->lock, flags);
 
@@ -76,6 +76,8 @@ static void msg_submit(struct mbox_chan *chan)
 
         data = chan->msg_data[idx];
 
+        if (chan->cl->tx_prepare)
+                chan->cl->tx_prepare(chan->cl, data);
         /* Try to submit a message to the MBOX controller */
         err = chan->mbox->ops->send_data(chan, data);
         if (!err) {
@@ -84,6 +86,9 @@ static void msg_submit(struct mbox_chan *chan)
         }
 exit:
         spin_unlock_irqrestore(&chan->lock, flags);
+
+        if (!err && chan->txdone_method == TXDONE_BY_POLL)
+                poll_txdone((unsigned long)chan->mbox);
 }
 
 static void tx_tick(struct mbox_chan *chan, int r)
@@ -117,10 +122,11 @@ static void poll_txdone(unsigned long data)
                 struct mbox_chan *chan = &mbox->chans[i];
 
                 if (chan->active_req && chan->cl) {
-                        resched = true;
                         txdone = chan->mbox->ops->last_tx_done(chan);
                         if (txdone)
                                 tx_tick(chan, 0);
+                        else
+                                resched = true;
                 }
         }
 
@@ -252,9 +258,6 @@ int mbox_send_message(struct mbox_chan *chan, void *mssg)
 
         msg_submit(chan);
 
-        if (chan->txdone_method == TXDONE_BY_POLL)
-                poll_txdone((unsigned long)chan->mbox);
-
         if (chan->cl->tx_block && chan->active_req) {
                 unsigned long wait;
                 int ret;
diff --git a/drivers/mailbox/mailbox.h b/drivers/mailbox/mailbox.h
new file mode 100644
index 000000000000..456ba68513bb
--- /dev/null
+++ b/drivers/mailbox/mailbox.h
@@ -0,0 +1,14 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __MAILBOX_H
+#define __MAILBOX_H
+
+#define TXDONE_BY_IRQ   BIT(0) /* controller has remote RTR irq */
+#define TXDONE_BY_POLL  BIT(1) /* controller can read status of last TX */
+#define TXDONE_BY_ACK   BIT(2) /* S/W ACK recevied by Client ticks the TX */
+
+#endif /* __MAILBOX_H */
diff --git a/drivers/mailbox/omap-mailbox.c b/drivers/mailbox/omap-mailbox.c
index bcc7ee129276..66b83ca94dcf 100644
--- a/drivers/mailbox/omap-mailbox.c
+++ b/drivers/mailbox/omap-mailbox.c
@@ -29,13 +29,14 @@
 #include <linux/slab.h>
 #include <linux/kfifo.h>
 #include <linux/err.h>
-#include <linux/notifier.h>
 #include <linux/module.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 #include <linux/platform_data/mailbox-omap.h>
 #include <linux/omap-mailbox.h>
+#include <linux/mailbox_controller.h>
+#include <linux/mailbox_client.h>
 
 #define MAILBOX_REVISION                0x000
 #define MAILBOX_MESSAGE(m)              (0x040 + 4 * (m))
@@ -80,7 +81,6 @@ struct omap_mbox_queue {
         spinlock_t              lock;
         struct kfifo            fifo;
         struct work_struct      work;
-        struct tasklet_struct   tasklet;
         struct omap_mbox        *mbox;
         bool full;
 };
@@ -92,6 +92,7 @@ struct omap_mbox_device {
         u32 num_users;
         u32 num_fifos;
         struct omap_mbox **mboxes;
+        struct mbox_controller controller;
         struct list_head elem;
 };
 
@@ -110,15 +111,14 @@ struct omap_mbox_fifo_info {
 struct omap_mbox {
         const char              *name;
         int                     irq;
-        struct omap_mbox_queue  *txq, *rxq;
+        struct omap_mbox_queue  *rxq;
         struct device           *dev;
         struct omap_mbox_device *parent;
         struct omap_mbox_fifo   tx_fifo;
         struct omap_mbox_fifo   rx_fifo;
         u32                     ctx[OMAP4_MBOX_NR_REGS];
         u32                     intr_type;
-        int                     use_count;
-        struct blocking_notifier_head   notifier;
+        struct mbox_chan        *chan;
 };
 
 /* global variables for the mailbox devices */
@@ -129,6 +129,14 @@ static unsigned int mbox_kfifo_size = CONFIG_OMAP_MBOX_KFIFO_SIZE;
 module_param(mbox_kfifo_size, uint, S_IRUGO);
 MODULE_PARM_DESC(mbox_kfifo_size, "Size of omap's mailbox kfifo (bytes)");
 
+static struct omap_mbox *mbox_chan_to_omap_mbox(struct mbox_chan *chan)
+{
+        if (!chan || !chan->con_priv)
+                return NULL;
+
+        return (struct omap_mbox *)chan->con_priv;
+}
+
 static inline
 unsigned int mbox_read_reg(struct omap_mbox_device *mdev, size_t ofs)
 {
@@ -194,41 +202,14 @@ static int is_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
         return (int)(enable & status & bit);
 }
 
-/*
- * message sender
- */
-int omap_mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg)
-{
-        struct omap_mbox_queue *mq = mbox->txq;
-        int ret = 0, len;
-
-        spin_lock_bh(&mq->lock);
-
-        if (kfifo_avail(&mq->fifo) < sizeof(msg)) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        if (kfifo_is_empty(&mq->fifo) && !mbox_fifo_full(mbox)) {
-                mbox_fifo_write(mbox, msg);
-                goto out;
-        }
-
-        len = kfifo_in(&mq->fifo, (unsigned char *)&msg, sizeof(msg));
-        WARN_ON(len != sizeof(msg));
-
-        tasklet_schedule(&mbox->txq->tasklet);
-
-out:
-        spin_unlock_bh(&mq->lock);
-        return ret;
-}
-EXPORT_SYMBOL(omap_mbox_msg_send);
-
-void omap_mbox_save_ctx(struct omap_mbox *mbox)
+void omap_mbox_save_ctx(struct mbox_chan *chan)
 {
         int i;
         int nr_regs;
+        struct omap_mbox *mbox = mbox_chan_to_omap_mbox(chan);
+
+        if (WARN_ON(!mbox))
+                return;
 
         if (mbox->intr_type)
                 nr_regs = OMAP4_MBOX_NR_REGS;
@@ -243,10 +224,14 @@ void omap_mbox_save_ctx(struct omap_mbox *mbox)
 }
 EXPORT_SYMBOL(omap_mbox_save_ctx);
 
-void omap_mbox_restore_ctx(struct omap_mbox *mbox)
+void omap_mbox_restore_ctx(struct mbox_chan *chan)
 {
         int i;
         int nr_regs;
+        struct omap_mbox *mbox = mbox_chan_to_omap_mbox(chan);
+
+        if (WARN_ON(!mbox))
+                return;
 
         if (mbox->intr_type)
                 nr_regs = OMAP4_MBOX_NR_REGS;
@@ -254,14 +239,13 @@ void omap_mbox_restore_ctx(struct omap_mbox *mbox)
                 nr_regs = MBOX_NR_REGS;
         for (i = 0; i < nr_regs; i++) {
                 mbox_write_reg(mbox->parent, mbox->ctx[i], i * sizeof(u32));
-
                 dev_dbg(mbox->dev, "%s: [%02x] %08x\n", __func__,
                         i, mbox->ctx[i]);
         }
 }
 EXPORT_SYMBOL(omap_mbox_restore_ctx);
 
-void omap_mbox_enable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
+static void _omap_mbox_enable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
 {
         u32 l;
         struct omap_mbox_fifo *fifo = (irq == IRQ_TX) ?
@@ -273,9 +257,8 @@ void omap_mbox_enable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
         l |= bit;
         mbox_write_reg(mbox->parent, l, irqenable);
 }
-EXPORT_SYMBOL(omap_mbox_enable_irq);
 
-void omap_mbox_disable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
+static void _omap_mbox_disable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
 {
         struct omap_mbox_fifo *fifo = (irq == IRQ_TX) ?
                                 &mbox->tx_fifo : &mbox->rx_fifo;
@@ -291,28 +274,28 @@ void omap_mbox_disable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
 
         mbox_write_reg(mbox->parent, bit, irqdisable);
 }
-EXPORT_SYMBOL(omap_mbox_disable_irq);
 
-static void mbox_tx_tasklet(unsigned long tx_data)
+void omap_mbox_enable_irq(struct mbox_chan *chan, omap_mbox_irq_t irq)
 {
-        struct omap_mbox *mbox = (struct omap_mbox *)tx_data;
-        struct omap_mbox_queue *mq = mbox->txq;
-        mbox_msg_t msg;
-        int ret;
+        struct omap_mbox *mbox = mbox_chan_to_omap_mbox(chan);
 
-        while (kfifo_len(&mq->fifo)) {
-                if (mbox_fifo_full(mbox)) {
-                        omap_mbox_enable_irq(mbox, IRQ_TX);
-                        break;
-                }
+        if (WARN_ON(!mbox))
+                return;
 
-                ret = kfifo_out(&mq->fifo, (unsigned char *)&msg,
-                                                                sizeof(msg));
-                WARN_ON(ret != sizeof(msg));
+        _omap_mbox_enable_irq(mbox, irq);
+}
+EXPORT_SYMBOL(omap_mbox_enable_irq);
 
-                mbox_fifo_write(mbox, msg);
-        }
+void omap_mbox_disable_irq(struct mbox_chan *chan, omap_mbox_irq_t irq)
+{
+        struct omap_mbox *mbox = mbox_chan_to_omap_mbox(chan);
+
+        if (WARN_ON(!mbox))
+                return;
+
+        _omap_mbox_disable_irq(mbox, irq);
 }
+EXPORT_SYMBOL(omap_mbox_disable_irq);
 
 /*
  * Message receiver(workqueue)
@@ -328,12 +311,11 @@ static void mbox_rx_work(struct work_struct *work)
                 len = kfifo_out(&mq->fifo, (unsigned char *)&msg, sizeof(msg));
                 WARN_ON(len != sizeof(msg));
 
-                blocking_notifier_call_chain(&mq->mbox->notifier, len,
-                                                                (void *)msg);
+                mbox_chan_received_data(mq->mbox->chan, (void *)msg);
                 spin_lock_irq(&mq->lock);
                 if (mq->full) {
                         mq->full = false;
-                        omap_mbox_enable_irq(mq->mbox, IRQ_RX);
+                        _omap_mbox_enable_irq(mq->mbox, IRQ_RX);
                 }
                 spin_unlock_irq(&mq->lock);
         }
@@ -344,9 +326,9 @@ static void mbox_rx_work(struct work_struct *work)
  */
 static void __mbox_tx_interrupt(struct omap_mbox *mbox)
 {
-        omap_mbox_disable_irq(mbox, IRQ_TX);
+        _omap_mbox_disable_irq(mbox, IRQ_TX);
         ack_mbox_irq(mbox, IRQ_TX);
-        tasklet_schedule(&mbox->txq->tasklet);
+        mbox_chan_txdone(mbox->chan, 0);
 }
 
 static void __mbox_rx_interrupt(struct omap_mbox *mbox)
@@ -357,7 +339,7 @@ static void __mbox_rx_interrupt(struct omap_mbox *mbox)
 
         while (!mbox_fifo_empty(mbox)) {
                 if (unlikely(kfifo_avail(&mq->fifo) < sizeof(msg))) {
-                        omap_mbox_disable_irq(mbox, IRQ_RX);
+                        _omap_mbox_disable_irq(mbox, IRQ_RX);
                         mq->full = true;
                         goto nomem;
                 }
@@ -388,11 +370,13 @@ static irqreturn_t mbox_interrupt(int irq, void *p)
 }
 
 static struct omap_mbox_queue *mbox_queue_alloc(struct omap_mbox *mbox,
-                                        void (*work) (struct work_struct *),
-                                        void (*tasklet)(unsigned long))
+                                        void (*work)(struct work_struct *))
 {
         struct omap_mbox_queue *mq;
 
+        if (!work)
+                return NULL;
+
         mq = kzalloc(sizeof(struct omap_mbox_queue), GFP_KERNEL);
         if (!mq)
                 return NULL;
@@ -402,12 +386,9 @@ static struct omap_mbox_queue *mbox_queue_alloc(struct omap_mbox *mbox,
         if (kfifo_alloc(&mq->fifo, mbox_kfifo_size, GFP_KERNEL))
                 goto error;
 
-        if (work)
-                INIT_WORK(&mq->work, work);
-
-        if (tasklet)
-                tasklet_init(&mq->tasklet, tasklet, (unsigned long)mbox);
+        INIT_WORK(&mq->work, work);
         return mq;
+
 error:
         kfree(mq);
         return NULL;
@@ -423,71 +404,35 @@ static int omap_mbox_startup(struct omap_mbox *mbox)
 {
         int ret = 0;
         struct omap_mbox_queue *mq;
-        struct omap_mbox_device *mdev = mbox->parent;
 
-        mutex_lock(&mdev->cfg_lock);
-        ret = pm_runtime_get_sync(mdev->dev);
-        if (unlikely(ret < 0))
-                goto fail_startup;
-
-        if (!mbox->use_count++) {
-                mq = mbox_queue_alloc(mbox, NULL, mbox_tx_tasklet);
-                if (!mq) {
-                        ret = -ENOMEM;
-                        goto fail_alloc_txq;
-                }
-                mbox->txq = mq;
+        mq = mbox_queue_alloc(mbox, mbox_rx_work);
+        if (!mq)
+                return -ENOMEM;
+        mbox->rxq = mq;
+        mq->mbox = mbox;
+
+        ret = request_irq(mbox->irq, mbox_interrupt, IRQF_SHARED,
+                          mbox->name, mbox);
+        if (unlikely(ret)) {
+                pr_err("failed to register mailbox interrupt:%d\n", ret);
+                goto fail_request_irq;
+        }
 
-                mq = mbox_queue_alloc(mbox, mbox_rx_work, NULL);
-                if (!mq) {
-                        ret = -ENOMEM;
-                        goto fail_alloc_rxq;
-                }
-                mbox->rxq = mq;
-                mq->mbox = mbox;
-                ret = request_irq(mbox->irq, mbox_interrupt, IRQF_SHARED,
-                                                        mbox->name, mbox);
-                if (unlikely(ret)) {
-                        pr_err("failed to register mailbox interrupt:%d\n",
-                                                                        ret);
-                        goto fail_request_irq;
-                }
+        _omap_mbox_enable_irq(mbox, IRQ_RX);
 
-                omap_mbox_enable_irq(mbox, IRQ_RX);
-        }
-        mutex_unlock(&mdev->cfg_lock);
         return 0;
 
 fail_request_irq:
         mbox_queue_free(mbox->rxq);
-fail_alloc_rxq:
-        mbox_queue_free(mbox->txq);
-fail_alloc_txq:
-        pm_runtime_put_sync(mdev->dev);
-        mbox->use_count--;
-fail_startup:
-        mutex_unlock(&mdev->cfg_lock);
         return ret;
 }
 
 static void omap_mbox_fini(struct omap_mbox *mbox)
 {
-        struct omap_mbox_device *mdev = mbox->parent;
-
-        mutex_lock(&mdev->cfg_lock);
-
-        if (!--mbox->use_count) {
-                omap_mbox_disable_irq(mbox, IRQ_RX);
-                free_irq(mbox->irq, mbox);
-                tasklet_kill(&mbox->txq->tasklet);
-                flush_work(&mbox->rxq->work);
-                mbox_queue_free(mbox->txq);
-                mbox_queue_free(mbox->rxq);
-        }
-
-        pm_runtime_put_sync(mdev->dev);
-
-        mutex_unlock(&mdev->cfg_lock);
+        _omap_mbox_disable_irq(mbox, IRQ_RX);
+        free_irq(mbox->irq, mbox);
+        flush_work(&mbox->rxq->work);
+        mbox_queue_free(mbox->rxq);
 }
 
 static struct omap_mbox *omap_mbox_device_find(struct omap_mbox_device *mdev,
@@ -509,42 +454,55 @@ static struct omap_mbox *omap_mbox_device_find(struct omap_mbox_device *mdev,
         return mbox;
 }
 
-struct omap_mbox *omap_mbox_get(const char *name, struct notifier_block *nb)
+struct mbox_chan *omap_mbox_request_channel(struct mbox_client *cl,
+                                            const char *chan_name)
 {
+        struct device *dev = cl->dev;
         struct omap_mbox *mbox = NULL;
         struct omap_mbox_device *mdev;
+        struct mbox_chan *chan;
+        unsigned long flags;
         int ret;
 
+        if (!dev)
+                return ERR_PTR(-ENODEV);
+
+        if (dev->of_node) {
+                pr_err("%s: please use mbox_request_channel(), this API is supported only for OMAP non-DT usage\n",
+                       __func__);
+                return ERR_PTR(-ENODEV);
+        }
+
         mutex_lock(&omap_mbox_devices_lock);
         list_for_each_entry(mdev, &omap_mbox_devices, elem) {
-                mbox = omap_mbox_device_find(mdev, name);
+                mbox = omap_mbox_device_find(mdev, chan_name);
                 if (mbox)
                         break;
         }
         mutex_unlock(&omap_mbox_devices_lock);
 
-        if (!mbox)
+        if (!mbox || !mbox->chan)
                 return ERR_PTR(-ENOENT);
 
-        if (nb)
-                blocking_notifier_chain_register(&mbox->notifier, nb);
+        chan = mbox->chan;
+        spin_lock_irqsave(&chan->lock, flags);
+        chan->msg_free = 0;
+        chan->msg_count = 0;
+        chan->active_req = NULL;
+        chan->cl = cl;
+        init_completion(&chan->tx_complete);
+        spin_unlock_irqrestore(&chan->lock, flags);
 
-        ret = omap_mbox_startup(mbox);
+        ret = chan->mbox->ops->startup(chan);
         if (ret) {
-                blocking_notifier_chain_unregister(&mbox->notifier, nb);
-                return ERR_PTR(-ENODEV);
+                pr_err("Unable to startup the chan (%d)\n", ret);
+                mbox_free_channel(chan);
+                chan = ERR_PTR(ret);
         }
 
-        return mbox;
-}
-EXPORT_SYMBOL(omap_mbox_get);
-
-void omap_mbox_put(struct omap_mbox *mbox, struct notifier_block *nb)
-{
-        blocking_notifier_chain_unregister(&mbox->notifier, nb);
-        omap_mbox_fini(mbox);
+        return chan;
 }
-EXPORT_SYMBOL(omap_mbox_put);
+EXPORT_SYMBOL(omap_mbox_request_channel);
 
 static struct class omap_mbox_class = { .name = "mbox", };
 
@@ -560,25 +518,25 @@ static int omap_mbox_register(struct omap_mbox_device *mdev)
         mboxes = mdev->mboxes;
         for (i = 0; mboxes[i]; i++) {
                 struct omap_mbox *mbox = mboxes[i];
-                mbox->dev = device_create(&omap_mbox_class,
-                                mdev->dev, 0, mbox, "%s", mbox->name);
+                mbox->dev = device_create(&omap_mbox_class, mdev->dev,
+                                        0, mbox, "%s", mbox->name);
                 if (IS_ERR(mbox->dev)) {
                         ret = PTR_ERR(mbox->dev);
                         goto err_out;
                 }
-
-                BLOCKING_INIT_NOTIFIER_HEAD(&mbox->notifier);
         }
 
         mutex_lock(&omap_mbox_devices_lock);
         list_add(&mdev->elem, &omap_mbox_devices);
         mutex_unlock(&omap_mbox_devices_lock);
 
-        return 0;
+        ret = mbox_controller_register(&mdev->controller);
 
 err_out:
-        while (i--)
-                device_unregister(mboxes[i]->dev);
+        if (ret) {
+                while (i--)
+                        device_unregister(mboxes[i]->dev);
+        }
         return ret;
 }
 
@@ -594,12 +552,64 @@ static int omap_mbox_unregister(struct omap_mbox_device *mdev)
         list_del(&mdev->elem);
         mutex_unlock(&omap_mbox_devices_lock);
 
+        mbox_controller_unregister(&mdev->controller);
+
         mboxes = mdev->mboxes;
         for (i = 0; mboxes[i]; i++)
                 device_unregister(mboxes[i]->dev);
         return 0;
 }
 
+static int omap_mbox_chan_startup(struct mbox_chan *chan)
+{
+        struct omap_mbox *mbox = mbox_chan_to_omap_mbox(chan);
+        struct omap_mbox_device *mdev = mbox->parent;
+        int ret = 0;
+
+        mutex_lock(&mdev->cfg_lock);
+        pm_runtime_get_sync(mdev->dev);
+        ret = omap_mbox_startup(mbox);
+        if (ret)
+                pm_runtime_put_sync(mdev->dev);
+        mutex_unlock(&mdev->cfg_lock);
+        return ret;
+}
+
+static void omap_mbox_chan_shutdown(struct mbox_chan *chan)
+{
+        struct omap_mbox *mbox = mbox_chan_to_omap_mbox(chan);
+        struct omap_mbox_device *mdev = mbox->parent;
+
+        mutex_lock(&mdev->cfg_lock);
+        omap_mbox_fini(mbox);
+        pm_runtime_put_sync(mdev->dev);
+        mutex_unlock(&mdev->cfg_lock);
+}
+
+static int omap_mbox_chan_send_data(struct mbox_chan *chan, void *data)
+{
+        struct omap_mbox *mbox = mbox_chan_to_omap_mbox(chan);
+        int ret = -EBUSY;
+
+        if (!mbox)
+                return -EINVAL;
+
+        if (!mbox_fifo_full(mbox)) {
+                mbox_fifo_write(mbox, (mbox_msg_t)data);
+                ret = 0;
+        }
+
+        /* always enable the interrupt */
+        _omap_mbox_enable_irq(mbox, IRQ_TX);
+        return ret;
+}
+
+static struct mbox_chan_ops omap_mbox_chan_ops = {
+        .startup        = omap_mbox_chan_startup,
+        .send_data      = omap_mbox_chan_send_data,
+        .shutdown       = omap_mbox_chan_shutdown,
+};
+
 static const struct of_device_id omap_mailbox_of_match[] = {
         {
                 .compatible     = "ti,omap2-mailbox",
@@ -619,10 +629,35 @@ static const struct of_device_id omap_mailbox_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, omap_mailbox_of_match);
 
+static struct mbox_chan *omap_mbox_of_xlate(struct mbox_controller *controller,
+                                            const struct of_phandle_args *sp)
+{
+        phandle phandle = sp->args[0];
+        struct device_node *node;
+        struct omap_mbox_device *mdev;
+        struct omap_mbox *mbox;
+
+        mdev = container_of(controller, struct omap_mbox_device, controller);
+        if (WARN_ON(!mdev))
+                return NULL;
+
+        node = of_find_node_by_phandle(phandle);
+        if (!node) {
+                pr_err("%s: could not find node phandle 0x%x\n",
+                       __func__, phandle);
+                return NULL;
+        }
+
+        mbox = omap_mbox_device_find(mdev, node->name);
+        of_node_put(node);
+        return mbox ? mbox->chan : NULL;
+}
+
 static int omap_mbox_probe(struct platform_device *pdev)
 {
         struct resource *mem;
         int ret;
+        struct mbox_chan *chnls;
         struct omap_mbox **list, *mbox, *mboxblk;
         struct omap_mbox_pdata *pdata = pdev->dev.platform_data;
         struct omap_mbox_dev_info *info = NULL;
@@ -727,6 +762,11 @@ static int omap_mbox_probe(struct platform_device *pdev)
         if (!list)
                 return -ENOMEM;
 
+        chnls = devm_kzalloc(&pdev->dev, (info_count + 1) * sizeof(*chnls),
+                             GFP_KERNEL);
+        if (!chnls)
+                return -ENOMEM;
+
         mboxblk = devm_kzalloc(&pdev->dev, info_count * sizeof(*mbox),
                                GFP_KERNEL);
         if (!mboxblk)
@@ -758,6 +798,8 @@ static int omap_mbox_probe(struct platform_device *pdev)
                 mbox->irq = platform_get_irq(pdev, finfo->tx_irq);
                 if (mbox->irq < 0)
                         return mbox->irq;
+                mbox->chan = &chnls[i];
+                chnls[i].con_priv = mbox;
                 list[i] = mbox++;
         }
 
@@ -766,6 +808,14 @@ static int omap_mbox_probe(struct platform_device *pdev)
         mdev->num_users = num_users;
         mdev->num_fifos = num_fifos;
         mdev->mboxes = list;
+
+        /* OMAP does not have a Tx-Done IRQ, but rather a Tx-Ready IRQ */
+        mdev->controller.txdone_irq = true;
+        mdev->controller.dev = mdev->dev;
+        mdev->controller.ops = &omap_mbox_chan_ops;
+        mdev->controller.chans = chnls;
+        mdev->controller.num_chans = info_count;
+        mdev->controller.of_xlate = omap_mbox_of_xlate;
         ret = omap_mbox_register(mdev);
         if (ret)
                 return ret;
diff --git a/drivers/mailbox/pcc.c b/drivers/mailbox/pcc.c
new file mode 100644
index 000000000000..6dbf6fcbdfaf
--- /dev/null
+++ b/drivers/mailbox/pcc.c
@@ -0,0 +1,403 @@
+/*
+ *      Copyright (C) 2014 Linaro Ltd.
+ *      Author: Ashwin Chaugule <ashwin.chaugule@linaro.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  PCC (Platform Communication Channel) is defined in the ACPI 5.0+
+ *  specification. It is a mailbox like mechanism to allow clients
+ *  such as CPPC (Collaborative Processor Performance Control), RAS
+ *  (Reliability, Availability and Serviceability) and MPST (Memory
+ *  Node Power State Table) to talk to the platform (e.g. BMC) through
+ *  shared memory regions as defined in the PCC table entries. The PCC
+ *  specification supports a Doorbell mechanism for the PCC clients
+ *  to notify the platform about new data. This Doorbell information
+ *  is also specified in each PCC table entry. See pcc_send_data()
+ *  and pcc_tx_done() for basic mode of operation.
+ *
+ *  For more details about PCC, please see the ACPI specification from
+ *  http://www.uefi.org/ACPIv5.1 Section 14.
+ *
+ *  This file implements PCC as a Mailbox controller and allows for PCC
+ *  clients to be implemented as its Mailbox Client Channels.
+ */
+
+#include <linux/acpi.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/platform_device.h>
+#include <linux/mailbox_controller.h>
+#include <linux/mailbox_client.h>
+
+#include "mailbox.h"
+
+#define MAX_PCC_SUBSPACES       256
+#define PCCS_SS_SIG_MAGIC       0x50434300
+#define PCC_CMD_COMPLETE        0x1
+
+static struct mbox_chan *pcc_mbox_channels;
+
+static struct mbox_controller pcc_mbox_ctrl = {};
+/**
+ * get_pcc_channel - Given a PCC subspace idx, get
+ *      the respective mbox_channel.
+ * @id: PCC subspace index.
+ *
+ * Return: ERR_PTR(errno) if error, else pointer
+ *      to mbox channel.
+ */
+static struct mbox_chan *get_pcc_channel(int id)
+{
+        struct mbox_chan *pcc_chan;
+
+        if (id < 0 || id > pcc_mbox_ctrl.num_chans)
+                return ERR_PTR(-ENOENT);
+
+        pcc_chan = (struct mbox_chan *)
+                (unsigned long) pcc_mbox_channels +
+                (id * sizeof(*pcc_chan));
+
+        return pcc_chan;
+}
+
+/**
+ * get_subspace_id - Given a Mailbox channel, find out the
+ *              PCC subspace id.
+ * @chan: Pointer to Mailbox Channel from which we want
+ *              the index.
+ * Return: Errno if not found, else positive index number.
+ */
+static int get_subspace_id(struct mbox_chan *chan)
+{
+        unsigned int id = chan - pcc_mbox_channels;
+
+        if (id < 0 || id > pcc_mbox_ctrl.num_chans)
+                return -ENOENT;
+
+        return id;
+}
+
+/**
+ * pcc_mbox_request_channel - PCC clients call this function to
+ *              request a pointer to their PCC subspace, from which they
+ *              can get the details of communicating with the remote.
+ * @cl: Pointer to Mailbox client, so we know where to bind the
+ *              Channel.
+ * @subspace_id: The PCC Subspace index as parsed in the PCC client
+ *              ACPI package. This is used to lookup the array of PCC
+ *              subspaces as parsed by the PCC Mailbox controller.
+ *
+ * Return: Pointer to the Mailbox Channel if successful or
+ *              ERR_PTR.
+ */
+struct mbox_chan *pcc_mbox_request_channel(struct mbox_client *cl,
+                int subspace_id)
+{
+        struct device *dev = pcc_mbox_ctrl.dev;
+        struct mbox_chan *chan;
+        unsigned long flags;
+
+        /*
+         * Each PCC Subspace is a Mailbox Channel.
+         * The PCC Clients get their PCC Subspace ID
+         * from their own tables and pass it here.
+         * This returns a pointer to the PCC subspace
+         * for the Client to operate on.
+         */
+        chan = get_pcc_channel(subspace_id);
+
+        if (!chan || chan->cl) {
+                dev_err(dev, "%s: PCC mailbox not free\n", __func__);
+                return ERR_PTR(-EBUSY);
+        }
+
+        spin_lock_irqsave(&chan->lock, flags);
+        chan->msg_free = 0;
+        chan->msg_count = 0;
+        chan->active_req = NULL;
+        chan->cl = cl;
+        init_completion(&chan->tx_complete);
+
+        if (chan->txdone_method == TXDONE_BY_POLL && cl->knows_txdone)
+                chan->txdone_method |= TXDONE_BY_ACK;
+
+        spin_unlock_irqrestore(&chan->lock, flags);
+
+        return chan;
+}
+EXPORT_SYMBOL_GPL(pcc_mbox_request_channel);
+
+/**
+ * pcc_mbox_free_channel - Clients call this to free their Channel.
+ *
+ * @chan: Pointer to the mailbox channel as returned by
+ *              pcc_mbox_request_channel()
+ */
+void pcc_mbox_free_channel(struct mbox_chan *chan)
+{
+        unsigned long flags;
+
+        if (!chan || !chan->cl)
+                return;
+
+        spin_lock_irqsave(&chan->lock, flags);
+        chan->cl = NULL;
+        chan->active_req = NULL;
+        if (chan->txdone_method == (TXDONE_BY_POLL | TXDONE_BY_ACK))
+                chan->txdone_method = TXDONE_BY_POLL;
+
+        spin_unlock_irqrestore(&chan->lock, flags);
+}
+EXPORT_SYMBOL_GPL(pcc_mbox_free_channel);
+
+/**
+ * pcc_tx_done - Callback from Mailbox controller code to
+ *              check if PCC message transmission completed.
+ * @chan: Pointer to Mailbox channel on which previous
+ *              transmission occurred.
+ *
+ * Return: TRUE if succeeded.
+ */
+static bool pcc_tx_done(struct mbox_chan *chan)
+{
+        struct acpi_pcct_hw_reduced *pcct_ss = chan->con_priv;
+        struct acpi_pcct_shared_memory *generic_comm_base =
+                (struct acpi_pcct_shared_memory *) pcct_ss->base_address;
+        u16 cmd_delay = pcct_ss->latency;
+        unsigned int retries = 0;
+
+        /* Try a few times while waiting for platform to consume */
+        while (!(readw_relaxed(&generic_comm_base->status)
+                    & PCC_CMD_COMPLETE)) {
+
+                if (retries++ < 5)
+                        udelay(cmd_delay);
+                else {
+                        /*
+                         * If the remote is dead, this will cause the Mbox
+                         * controller to timeout after mbox client.tx_tout
+                         * msecs.
+                         */
+                        pr_err("PCC platform did not respond.\n");
+                        return false;
+                }
+        }
+        return true;
+}
+
+/**
+ * pcc_send_data - Called from Mailbox Controller code to finally
+ *      transmit data over channel.
+ * @chan: Pointer to Mailbox channel over which to send data.
+ * @data: Actual data to be written over channel.
+ *
+ * Return: Err if something failed else 0 for success.
+ */
+static int pcc_send_data(struct mbox_chan *chan, void *data)
+{
+        struct acpi_pcct_hw_reduced *pcct_ss = chan->con_priv;
+        struct acpi_pcct_shared_memory *generic_comm_base =
+                (struct acpi_pcct_shared_memory *) pcct_ss->base_address;
+        struct acpi_generic_address doorbell;
+        u64 doorbell_preserve;
+        u64 doorbell_val;
+        u64 doorbell_write;
+        u16 cmd = *(u16 *) data;
+        u16 ss_idx = -1;
+
+        ss_idx = get_subspace_id(chan);
+
+        if (ss_idx < 0) {
+                pr_err("Invalid Subspace ID from PCC client\n");
+                return -EINVAL;
+        }
+
+        doorbell = pcct_ss->doorbell_register;
+        doorbell_preserve = pcct_ss->preserve_mask;
+        doorbell_write = pcct_ss->write_mask;
+
+        /* Write to the shared comm region. */
+        writew(cmd, &generic_comm_base->command);
+
+        /* Write Subspace MAGIC value so platform can identify destination. */
+        writel((PCCS_SS_SIG_MAGIC | ss_idx), &generic_comm_base->signature);
+
+        /* Flip CMD COMPLETE bit */
+        writew(0, &generic_comm_base->status);
+
+        /* Sync notification from OSPM to Platform. */
+        acpi_read(&doorbell_val, &doorbell);
+        acpi_write((doorbell_val & doorbell_preserve) | doorbell_write,
+                        &doorbell);
+
+        return 0;
+}
+
+static struct mbox_chan_ops pcc_chan_ops = {
+        .send_data = pcc_send_data,
+        .last_tx_done = pcc_tx_done,
+};
+
+/**
+ * parse_pcc_subspace - Parse the PCC table and verify PCC subspace
+ *              entries. There should be one entry per PCC client.
+ * @header: Pointer to the ACPI subtable header under the PCCT.
+ * @end: End of subtable entry.
+ *
+ * Return: 0 for Success, else errno.
+ *
+ * This gets called for each entry in the PCC table.
+ */
+static int parse_pcc_subspace(struct acpi_subtable_header *header,
+                const unsigned long end)
+{
+        struct acpi_pcct_hw_reduced *pcct_ss;
+
+        if (pcc_mbox_ctrl.num_chans <= MAX_PCC_SUBSPACES) {
+                pcct_ss = (struct acpi_pcct_hw_reduced *) header;
+
+                if (pcct_ss->header.type !=
+                                ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE) {
+                        pr_err("Incorrect PCC Subspace type detected\n");
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * acpi_pcc_probe - Parse the ACPI tree for the PCCT.
+ *
+ * Return: 0 for Success, else errno.
+ */
+static int __init acpi_pcc_probe(void)
+{
+        acpi_size pcct_tbl_header_size;
+        struct acpi_table_header *pcct_tbl;
+        struct acpi_subtable_header *pcct_entry;
+        int count, i;
+        acpi_status status = AE_OK;
+
+        /* Search for PCCT */
+        status = acpi_get_table_with_size(ACPI_SIG_PCCT, 0,
+                        &pcct_tbl,
+                        &pcct_tbl_header_size);
+
+        if (ACPI_FAILURE(status) || !pcct_tbl) {
+                pr_warn("PCCT header not found.\n");
+                return -ENODEV;
+        }
+
+        count = acpi_table_parse_entries(ACPI_SIG_PCCT,
+                        sizeof(struct acpi_table_pcct),
+                        ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE,
+                        parse_pcc_subspace, MAX_PCC_SUBSPACES);
+
+        if (count <= 0) {
+                pr_err("Error parsing PCC subspaces from PCCT\n");
+                return -EINVAL;
+        }
+
+        pcc_mbox_channels = kzalloc(sizeof(struct mbox_chan) *
+                        count, GFP_KERNEL);
+
+        if (!pcc_mbox_channels) {
+                pr_err("Could not allocate space for PCC mbox channels\n");
+                return -ENOMEM;
+        }
+
+        /* Point to the first PCC subspace entry */
+        pcct_entry = (struct acpi_subtable_header *) (
+                (unsigned long) pcct_tbl + sizeof(struct acpi_table_pcct));
+
+        for (i = 0; i < count; i++) {
+                pcc_mbox_channels[i].con_priv = pcct_entry;
+                pcct_entry = (struct acpi_subtable_header *)
+                        ((unsigned long) pcct_entry + pcct_entry->length);
+        }
+
+        pcc_mbox_ctrl.num_chans = count;
+
+        pr_info("Detected %d PCC Subspaces\n", pcc_mbox_ctrl.num_chans);
+
+        return 0;
+}
+
+/**
+ * pcc_mbox_probe - Called when we find a match for the
+ *      PCCT platform device. This is purely used to represent
+ *      the PCCT as a virtual device for registering with the
+ *      generic Mailbox framework.
+ *
+ * @pdev: Pointer to platform device returned when a match
+ *      is found.
+ *
+ *      Return: 0 for Success, else errno.
+ */
+static int pcc_mbox_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+
+        pcc_mbox_ctrl.chans = pcc_mbox_channels;
+        pcc_mbox_ctrl.ops = &pcc_chan_ops;
+        pcc_mbox_ctrl.txdone_poll = true;
+        pcc_mbox_ctrl.txpoll_period = 10;
+        pcc_mbox_ctrl.dev = &pdev->dev;
+
+        pr_info("Registering PCC driver as Mailbox controller\n");
+        ret = mbox_controller_register(&pcc_mbox_ctrl);
+
+        if (ret) {
+                pr_err("Err registering PCC as Mailbox controller: %d\n", ret);
+                ret = -ENODEV;
+        }
+
+        return ret;
+}
+
+struct platform_driver pcc_mbox_driver = {
+        .probe = pcc_mbox_probe,
+        .driver = {
+                .name = "PCCT",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init pcc_init(void)
+{
+        int ret;
+        struct platform_device *pcc_pdev;
+
+        if (acpi_disabled)
+                return -ENODEV;
+
+        /* Check if PCC support is available. */
+        ret = acpi_pcc_probe();
+
+        if (ret) {
+                pr_err("ACPI PCC probe failed.\n");
+                return -ENODEV;
+        }
+
+        pcc_pdev = platform_create_bundle(&pcc_mbox_driver,
+                        pcc_mbox_probe, NULL, 0, NULL, 0);
+
+        if (!pcc_pdev) {
+                pr_err("Err creating PCC platform bundle\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+device_initcall(pcc_init);
diff --git a/drivers/md/dm-bio-prison.c b/drivers/md/dm-bio-prison.c
index f752d12081ff..be065300e93c 100644
--- a/drivers/md/dm-bio-prison.c
+++ b/drivers/md/dm-bio-prison.c
@@ -14,68 +14,38 @@
 
 /*----------------------------------------------------------------*/
 
-struct bucket {
-        spinlock_t lock;
-        struct hlist_head cells;
-};
+#define MIN_CELLS 1024
 
 struct dm_bio_prison {
+        spinlock_t lock;
         mempool_t *cell_pool;
-
-        unsigned nr_buckets;
-        unsigned hash_mask;
-        struct bucket *buckets;
+        struct rb_root cells;
 };
 
-/*----------------------------------------------------------------*/
-
-static uint32_t calc_nr_buckets(unsigned nr_cells)
-{
-        uint32_t n = 128;
-
-        nr_cells /= 4;
-        nr_cells = min(nr_cells, 8192u);
-
-        while (n < nr_cells)
-                n <<= 1;
-
-        return n;
-}
-
 static struct kmem_cache *_cell_cache;
 
-static void init_bucket(struct bucket *b)
-{
-        spin_lock_init(&b->lock);
-        INIT_HLIST_HEAD(&b->cells);
-}
+/*----------------------------------------------------------------*/
 
 /*
  * @nr_cells should be the number of cells you want in use _concurrently_.
  * Don't confuse it with the number of distinct keys.
  */
-struct dm_bio_prison *dm_bio_prison_create(unsigned nr_cells)
+struct dm_bio_prison *dm_bio_prison_create(void)
 {
-        unsigned i;
-        uint32_t nr_buckets = calc_nr_buckets(nr_cells);
-        size_t len = sizeof(struct dm_bio_prison) +
-                (sizeof(struct bucket) * nr_buckets);
-        struct dm_bio_prison *prison = kmalloc(len, GFP_KERNEL);
+        struct dm_bio_prison *prison = kmalloc(sizeof(*prison), GFP_KERNEL);
 
         if (!prison)
                 return NULL;
 
-        prison->cell_pool = mempool_create_slab_pool(nr_cells, _cell_cache);
+        spin_lock_init(&prison->lock);
+
+        prison->cell_pool = mempool_create_slab_pool(MIN_CELLS, _cell_cache);
         if (!prison->cell_pool) {
                 kfree(prison);
                 return NULL;
         }
 
-        prison->nr_buckets = nr_buckets;
-        prison->hash_mask = nr_buckets - 1;
-        prison->buckets = (struct bucket *) (prison + 1);
-        for (i = 0; i < nr_buckets; i++)
-                init_bucket(prison->buckets + i);
+        prison->cells = RB_ROOT;
 
         return prison;
 }
@@ -101,68 +71,73 @@ void dm_bio_prison_free_cell(struct dm_bio_prison *prison,
 }
 EXPORT_SYMBOL_GPL(dm_bio_prison_free_cell);
 
-static uint32_t hash_key(struct dm_bio_prison *prison, struct dm_cell_key *key)
+static void __setup_new_cell(struct dm_cell_key *key,
+                             struct bio *holder,
+                             struct dm_bio_prison_cell *cell)
 {
-        const unsigned long BIG_PRIME = 4294967291UL;
-        uint64_t hash = key->block * BIG_PRIME;
-
-        return (uint32_t) (hash & prison->hash_mask);
+       memcpy(&cell->key, key, sizeof(cell->key));
+       cell->holder = holder;
+       bio_list_init(&cell->bios);
 }
 
-static int keys_equal(struct dm_cell_key *lhs, struct dm_cell_key *rhs)
+static int cmp_keys(struct dm_cell_key *lhs,
+                    struct dm_cell_key *rhs)
 {
-               return (lhs->virtual == rhs->virtual) &&
-                       (lhs->dev == rhs->dev) &&
-                       (lhs->block == rhs->block);
-}
+        if (lhs->virtual < rhs->virtual)
+                return -1;
 
-static struct bucket *get_bucket(struct dm_bio_prison *prison,
-                                 struct dm_cell_key *key)
-{
-        return prison->buckets + hash_key(prison, key);
-}
+        if (lhs->virtual > rhs->virtual)
+                return 1;
 
-static struct dm_bio_prison_cell *__search_bucket(struct bucket *b,
-                                                  struct dm_cell_key *key)
-{
-        struct dm_bio_prison_cell *cell;
+        if (lhs->dev < rhs->dev)
+                return -1;
 
-        hlist_for_each_entry(cell, &b->cells, list)
-                if (keys_equal(&cell->key, key))
-                        return cell;
+        if (lhs->dev > rhs->dev)
+                return 1;
 
-        return NULL;
-}
+        if (lhs->block_end <= rhs->block_begin)
+                return -1;
 
-static void __setup_new_cell(struct bucket *b,
-                             struct dm_cell_key *key,
-                             struct bio *holder,
-                             struct dm_bio_prison_cell *cell)
-{
-        memcpy(&cell->key, key, sizeof(cell->key));
-        cell->holder = holder;
-        bio_list_init(&cell->bios);
-        hlist_add_head(&cell->list, &b->cells);
+        if (lhs->block_begin >= rhs->block_end)
+                return 1;
+
+        return 0;
 }
 
-static int __bio_detain(struct bucket *b,
+static int __bio_detain(struct dm_bio_prison *prison,
                         struct dm_cell_key *key,
                         struct bio *inmate,
                         struct dm_bio_prison_cell *cell_prealloc,
                         struct dm_bio_prison_cell **cell_result)
 {
-        struct dm_bio_prison_cell *cell;
-
-        cell = __search_bucket(b, key);
-        if (cell) {
-                if (inmate)
-                        bio_list_add(&cell->bios, inmate);
-                *cell_result = cell;
-                return 1;
+        int r;
+        struct rb_node **new = &prison->cells.rb_node, *parent = NULL;
+
+        while (*new) {
+                struct dm_bio_prison_cell *cell =
+                        container_of(*new, struct dm_bio_prison_cell, node);
+
+                r = cmp_keys(key, &cell->key);
+
+                parent = *new;
+                if (r < 0)
+                        new = &((*new)->rb_left);
+                else if (r > 0)
+                        new = &((*new)->rb_right);
+                else {
+                        if (inmate)
+                                bio_list_add(&cell->bios, inmate);
+                        *cell_result = cell;
+                        return 1;
+                }
         }
 
-        __setup_new_cell(b, key, inmate, cell_prealloc);
+        __setup_new_cell(key, inmate, cell_prealloc);
         *cell_result = cell_prealloc;
+
+        rb_link_node(&cell_prealloc->node, parent, new);
+        rb_insert_color(&cell_prealloc->node, &prison->cells);
+
         return 0;
 }
 
@@ -174,11 +149,10 @@ static int bio_detain(struct dm_bio_prison *prison,
 {
         int r;
         unsigned long flags;
-        struct bucket *b = get_bucket(prison, key);
 
-        spin_lock_irqsave(&b->lock, flags);
-        r = __bio_detain(b, key, inmate, cell_prealloc, cell_result);
-        spin_unlock_irqrestore(&b->lock, flags);
+        spin_lock_irqsave(&prison->lock, flags);
+        r = __bio_detain(prison, key, inmate, cell_prealloc, cell_result);
+        spin_unlock_irqrestore(&prison->lock, flags);
 
         return r;
 }
@@ -205,10 +179,11 @@ EXPORT_SYMBOL_GPL(dm_get_cell);
 /*
  * @inmates must have been initialised prior to this call
  */
-static void __cell_release(struct dm_bio_prison_cell *cell,
+static void __cell_release(struct dm_bio_prison *prison,
+                           struct dm_bio_prison_cell *cell,
                            struct bio_list *inmates)
 {
-        hlist_del(&cell->list);
+        rb_erase(&cell->node, &prison->cells);
 
         if (inmates) {
                 if (cell->holder)
@@ -222,21 +197,21 @@ void dm_cell_release(struct dm_bio_prison *prison,
                      struct bio_list *bios)
 {
         unsigned long flags;
-        struct bucket *b = get_bucket(prison, &cell->key);
 
-        spin_lock_irqsave(&b->lock, flags);
-        __cell_release(cell, bios);
-        spin_unlock_irqrestore(&b->lock, flags);
+        spin_lock_irqsave(&prison->lock, flags);
+        __cell_release(prison, cell, bios);
+        spin_unlock_irqrestore(&prison->lock, flags);
 }
 EXPORT_SYMBOL_GPL(dm_cell_release);
 
 /*
  * Sometimes we don't want the holder, just the additional bios.
  */
-static void __cell_release_no_holder(struct dm_bio_prison_cell *cell,
+static void __cell_release_no_holder(struct dm_bio_prison *prison,
+                                     struct dm_bio_prison_cell *cell,
                                      struct bio_list *inmates)
 {
-        hlist_del(&cell->list);
+        rb_erase(&cell->node, &prison->cells);
         bio_list_merge(inmates, &cell->bios);
 }
 
@@ -245,11 +220,10 @@ void dm_cell_release_no_holder(struct dm_bio_prison *prison,
                                struct bio_list *inmates)
 {
         unsigned long flags;
-        struct bucket *b = get_bucket(prison, &cell->key);
 
-        spin_lock_irqsave(&b->lock, flags);
-        __cell_release_no_holder(cell, inmates);
-        spin_unlock_irqrestore(&b->lock, flags);
+        spin_lock_irqsave(&prison->lock, flags);
+        __cell_release_no_holder(prison, cell, inmates);
+        spin_unlock_irqrestore(&prison->lock, flags);
 }
 EXPORT_SYMBOL_GPL(dm_cell_release_no_holder);
 
@@ -267,6 +241,20 @@ void dm_cell_error(struct dm_bio_prison *prison,
 }
 EXPORT_SYMBOL_GPL(dm_cell_error);
 
+void dm_cell_visit_release(struct dm_bio_prison *prison,
+                           void (*visit_fn)(void *, struct dm_bio_prison_cell *),
+                           void *context,
+                           struct dm_bio_prison_cell *cell)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&prison->lock, flags);
+        visit_fn(context, cell);
+        rb_erase(&cell->node, &prison->cells);
+        spin_unlock_irqrestore(&prison->lock, flags);
+}
+EXPORT_SYMBOL_GPL(dm_cell_visit_release);
+
 /*----------------------------------------------------------------*/
 
 #define DEFERRED_SET_SIZE 64
diff --git a/drivers/md/dm-bio-prison.h b/drivers/md/dm-bio-prison.h
index 6805a142b750..74cf01144b1f 100644
--- a/drivers/md/dm-bio-prison.h
+++ b/drivers/md/dm-bio-prison.h
@@ -10,8 +10,8 @@
 #include "persistent-data/dm-block-manager.h" /* FIXME: for dm_block_t */
 #include "dm-thin-metadata.h" /* FIXME: for dm_thin_id */
 
-#include <linux/list.h>
 #include <linux/bio.h>
+#include <linux/rbtree.h>
 
 /*----------------------------------------------------------------*/
 
@@ -23,11 +23,14 @@
  */
 struct dm_bio_prison;
 
-/* FIXME: this needs to be more abstract */
+/*
+ * Keys define a range of blocks within either a virtual or physical
+ * device.
+ */
 struct dm_cell_key {
         int virtual;
         dm_thin_id dev;
-        dm_block_t block;
+        dm_block_t block_begin, block_end;
 };
 
 /*
@@ -35,13 +38,15 @@ struct dm_cell_key {
  * themselves.
  */
 struct dm_bio_prison_cell {
-        struct hlist_node list;
+        struct list_head user_list;     /* for client use */
+        struct rb_node node;
+
         struct dm_cell_key key;
         struct bio *holder;
         struct bio_list bios;
 };
 
-struct dm_bio_prison *dm_bio_prison_create(unsigned nr_cells);
+struct dm_bio_prison *dm_bio_prison_create(void);
 void dm_bio_prison_destroy(struct dm_bio_prison *prison);
 
 /*
@@ -57,7 +62,7 @@ void dm_bio_prison_free_cell(struct dm_bio_prison *prison,
                              struct dm_bio_prison_cell *cell);
 
 /*
- * Creates, or retrieves a cell for the given key.
+ * Creates, or retrieves a cell that overlaps the given key.
  *
  * Returns 1 if pre-existing cell returned, zero if new cell created using
  * @cell_prealloc.
@@ -68,7 +73,8 @@ int dm_get_cell(struct dm_bio_prison *prison,
                 struct dm_bio_prison_cell **cell_result);
 
 /*
- * An atomic op that combines retrieving a cell, and adding a bio to it.
+ * An atomic op that combines retrieving or creating a cell, and adding a
+ * bio to it.
  *
  * Returns 1 if the cell was already held, 0 if @inmate is the new holder.
  */
@@ -87,6 +93,14 @@ void dm_cell_release_no_holder(struct dm_bio_prison *prison,
 void dm_cell_error(struct dm_bio_prison *prison,
                    struct dm_bio_prison_cell *cell, int error);
 
+/*
+ * Visits the cell and then releases.  Guarantees no new inmates are
+ * inserted between the visit and release.
+ */
+void dm_cell_visit_release(struct dm_bio_prison *prison,
+                           void (*visit_fn)(void *, struct dm_bio_prison_cell *),
+                           void *context, struct dm_bio_prison_cell *cell);
+
 /*----------------------------------------------------------------*/
 
 /*
diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c
index afe79719ea32..c33b49792b87 100644
--- a/drivers/md/dm-bufio.c
+++ b/drivers/md/dm-bufio.c
@@ -14,6 +14,7 @@
 #include <linux/vmalloc.h>
 #include <linux/shrinker.h>
 #include <linux/module.h>
+#include <linux/rbtree.h>
 
 #define DM_MSG_PREFIX "bufio"
 
@@ -34,26 +35,23 @@
 /*
  * Check buffer ages in this interval (seconds)
  */
-#define DM_BUFIO_WORK_TIMER_SECS        10
+#define DM_BUFIO_WORK_TIMER_SECS        30
 
 /*
  * Free buffers when they are older than this (seconds)
  */
-#define DM_BUFIO_DEFAULT_AGE_SECS       60
+#define DM_BUFIO_DEFAULT_AGE_SECS       300
 
 /*
- * The number of bvec entries that are embedded directly in the buffer.
- * If the chunk size is larger, dm-io is used to do the io.
+ * The nr of bytes of cached data to keep around.
  */
-#define DM_BUFIO_INLINE_VECS            16
+#define DM_BUFIO_DEFAULT_RETAIN_BYTES   (256 * 1024)
 
 /*
- * Buffer hash
+ * The number of bvec entries that are embedded directly in the buffer.
+ * If the chunk size is larger, dm-io is used to do the io.
  */
-#define DM_BUFIO_HASH_BITS      20
-#define DM_BUFIO_HASH(block) \
-        ((((block) >> DM_BUFIO_HASH_BITS) ^ (block)) & \
-         ((1 << DM_BUFIO_HASH_BITS) - 1))
+#define DM_BUFIO_INLINE_VECS            16
 
 /*
  * Don't try to use kmem_cache_alloc for blocks larger than this.
@@ -106,7 +104,7 @@ struct dm_bufio_client {
 
         unsigned minimum_buffers;
 
-        struct hlist_head *cache_hash;
+        struct rb_root buffer_tree;
         wait_queue_head_t free_buffer_wait;
 
         int async_write_error;
@@ -135,7 +133,7 @@ enum data_mode {
 };
 
 struct dm_buffer {
-        struct hlist_node hash_list;
+        struct rb_node node;
         struct list_head lru_list;
         sector_t block;
         void *data;
@@ -223,6 +221,7 @@ static DEFINE_SPINLOCK(param_spinlock);
  * Buffers are freed after this timeout
  */
 static unsigned dm_bufio_max_age = DM_BUFIO_DEFAULT_AGE_SECS;
+static unsigned dm_bufio_retain_bytes = DM_BUFIO_DEFAULT_RETAIN_BYTES;
 
 static unsigned long dm_bufio_peak_allocated;
 static unsigned long dm_bufio_allocated_kmem_cache;
@@ -253,6 +252,53 @@ static LIST_HEAD(dm_bufio_all_clients);
  */
 static DEFINE_MUTEX(dm_bufio_clients_lock);
 
+/*----------------------------------------------------------------
+ * A red/black tree acts as an index for all the buffers.
+ *--------------------------------------------------------------*/
+static struct dm_buffer *__find(struct dm_bufio_client *c, sector_t block)
+{
+        struct rb_node *n = c->buffer_tree.rb_node;
+        struct dm_buffer *b;
+
+        while (n) {
+                b = container_of(n, struct dm_buffer, node);
+
+                if (b->block == block)
+                        return b;
+
+                n = (b->block < block) ? n->rb_left : n->rb_right;
+        }
+
+        return NULL;
+}
+
+static void __insert(struct dm_bufio_client *c, struct dm_buffer *b)
+{
+        struct rb_node **new = &c->buffer_tree.rb_node, *parent = NULL;
+        struct dm_buffer *found;
+
+        while (*new) {
+                found = container_of(*new, struct dm_buffer, node);
+
+                if (found->block == b->block) {
+                        BUG_ON(found != b);
+                        return;
+                }
+
+                parent = *new;
+                new = (found->block < b->block) ?
+                        &((*new)->rb_left) : &((*new)->rb_right);
+        }
+
+        rb_link_node(&b->node, parent, new);
+        rb_insert_color(&b->node, &c->buffer_tree);
+}
+
+static void __remove(struct dm_bufio_client *c, struct dm_buffer *b)
+{
+        rb_erase(&b->node, &c->buffer_tree);
+}
+
 /*----------------------------------------------------------------*/
 
 static void adjust_total_allocated(enum data_mode data_mode, long diff)
@@ -434,7 +480,7 @@ static void __link_buffer(struct dm_buffer *b, sector_t block, int dirty)
         b->block = block;
         b->list_mode = dirty;
         list_add(&b->lru_list, &c->lru[dirty]);
-        hlist_add_head(&b->hash_list, &c->cache_hash[DM_BUFIO_HASH(block)]);
+        __insert(b->c, b);
         b->last_accessed = jiffies;
 }
 
@@ -448,7 +494,7 @@ static void __unlink_buffer(struct dm_buffer *b)
         BUG_ON(!c->n_buffers[b->list_mode]);
 
         c->n_buffers[b->list_mode]--;
-        hlist_del(&b->hash_list);
+        __remove(b->c, b);
         list_del(&b->lru_list);
 }
 
@@ -532,6 +578,19 @@ static void use_dmio(struct dm_buffer *b, int rw, sector_t block,
                 end_io(&b->bio, r);
 }
 
+static void inline_endio(struct bio *bio, int error)
+{
+        bio_end_io_t *end_fn = bio->bi_private;
+
+        /*
+         * Reset the bio to free any attached resources
+         * (e.g. bio integrity profiles).
+         */
+        bio_reset(bio);
+
+        end_fn(bio, error);
+}
+
 static void use_inline_bio(struct dm_buffer *b, int rw, sector_t block,
                            bio_end_io_t *end_io)
 {
@@ -543,7 +602,12 @@ static void use_inline_bio(struct dm_buffer *b, int rw, sector_t block,
         b->bio.bi_max_vecs = DM_BUFIO_INLINE_VECS;
         b->bio.bi_iter.bi_sector = block << b->c->sectors_per_block_bits;
         b->bio.bi_bdev = b->c->bdev;
-        b->bio.bi_end_io = end_io;
+        b->bio.bi_end_io = inline_endio;
+        /*
+         * Use of .bi_private isn't a problem here because
+         * the dm_buffer's inline bio is local to bufio.
+         */
+        b->bio.bi_private = end_io;
 
         /*
          * We assume that if len >= PAGE_SIZE ptr is page-aligned.
@@ -887,23 +951,6 @@ static void __check_watermark(struct dm_bufio_client *c,
                 __write_dirty_buffers_async(c, 1, write_list);
 }
 
-/*
- * Find a buffer in the hash.
- */
-static struct dm_buffer *__find(struct dm_bufio_client *c, sector_t block)
-{
-        struct dm_buffer *b;
-
-        hlist_for_each_entry(b, &c->cache_hash[DM_BUFIO_HASH(block)],
-                             hash_list) {
-                dm_bufio_cond_resched();
-                if (b->block == block)
-                        return b;
-        }
-
-        return NULL;
-}
-
 /*----------------------------------------------------------------
  * Getting a buffer
  *--------------------------------------------------------------*/
@@ -1433,45 +1480,52 @@ static void drop_buffers(struct dm_bufio_client *c)
 }
 
 /*
- * Test if the buffer is unused and too old, and commit it.
+ * We may not be able to evict this buffer if IO pending or the client
+ * is still using it.  Caller is expected to know buffer is too old.
+ *
  * And if GFP_NOFS is used, we must not do any I/O because we hold
  * dm_bufio_clients_lock and we would risk deadlock if the I/O gets
  * rerouted to different bufio client.
  */
-static int __cleanup_old_buffer(struct dm_buffer *b, gfp_t gfp,
-                                unsigned long max_jiffies)
+static bool __try_evict_buffer(struct dm_buffer *b, gfp_t gfp)
 {
-        if (jiffies - b->last_accessed < max_jiffies)
-                return 0;
-
         if (!(gfp & __GFP_FS)) {
                 if (test_bit(B_READING, &b->state) ||
                     test_bit(B_WRITING, &b->state) ||
                     test_bit(B_DIRTY, &b->state))
-                        return 0;
+                        return false;
         }
 
         if (b->hold_count)
-                return 0;
+                return false;
 
         __make_buffer_clean(b);
         __unlink_buffer(b);
         __free_buffer_wake(b);
 
-        return 1;
+        return true;
 }
 
-static long __scan(struct dm_bufio_client *c, unsigned long nr_to_scan,
-                   gfp_t gfp_mask)
+static unsigned get_retain_buffers(struct dm_bufio_client *c)
+{
+        unsigned retain_bytes = ACCESS_ONCE(dm_bufio_retain_bytes);
+        return retain_bytes / c->block_size;
+}
+
+static unsigned long __scan(struct dm_bufio_client *c, unsigned long nr_to_scan,
+                            gfp_t gfp_mask)
 {
         int l;
         struct dm_buffer *b, *tmp;
-        long freed = 0;
+        unsigned long freed = 0;
+        unsigned long count = nr_to_scan;
+        unsigned retain_target = get_retain_buffers(c);
 
         for (l = 0; l < LIST_SIZE; l++) {
                 list_for_each_entry_safe_reverse(b, tmp, &c->lru[l], lru_list) {
-                        freed += __cleanup_old_buffer(b, gfp_mask, 0);
-                        if (!--nr_to_scan)
+                        if (__try_evict_buffer(b, gfp_mask))
+                                freed++;
+                        if (!--nr_to_scan || ((count - freed) <= retain_target))
                                 return freed;
                         dm_bufio_cond_resched();
                 }
@@ -1533,11 +1587,7 @@ struct dm_bufio_client *dm_bufio_client_create(struct block_device *bdev, unsign
                 r = -ENOMEM;
                 goto bad_client;
         }
-        c->cache_hash = vmalloc(sizeof(struct hlist_head) << DM_BUFIO_HASH_BITS);
-        if (!c->cache_hash) {
-                r = -ENOMEM;
-                goto bad_hash;
-        }
+        c->buffer_tree = RB_ROOT;
 
         c->bdev = bdev;
         c->block_size = block_size;
@@ -1556,9 +1606,6 @@ struct dm_bufio_client *dm_bufio_client_create(struct block_device *bdev, unsign
                 c->n_buffers[i] = 0;
         }
 
-        for (i = 0; i < 1 << DM_BUFIO_HASH_BITS; i++)
-                INIT_HLIST_HEAD(&c->cache_hash[i]);
-
         mutex_init(&c->lock);
         INIT_LIST_HEAD(&c->reserved_buffers);
         c->need_reserved_buffers = reserved_buffers;
@@ -1632,8 +1679,6 @@ bad_cache:
         }
         dm_io_client_destroy(c->dm_io);
 bad_dm_io:
-        vfree(c->cache_hash);
-bad_hash:
         kfree(c);
 bad_client:
         return ERR_PTR(r);
@@ -1660,9 +1705,7 @@ void dm_bufio_client_destroy(struct dm_bufio_client *c)
 
         mutex_unlock(&dm_bufio_clients_lock);
 
-        for (i = 0; i < 1 << DM_BUFIO_HASH_BITS; i++)
-                BUG_ON(!hlist_empty(&c->cache_hash[i]));
-
+        BUG_ON(!RB_EMPTY_ROOT(&c->buffer_tree));
         BUG_ON(c->need_reserved_buffers);
 
         while (!list_empty(&c->reserved_buffers)) {
@@ -1680,36 +1723,60 @@ void dm_bufio_client_destroy(struct dm_bufio_client *c)
                 BUG_ON(c->n_buffers[i]);
 
         dm_io_client_destroy(c->dm_io);
-        vfree(c->cache_hash);
         kfree(c);
 }
 EXPORT_SYMBOL_GPL(dm_bufio_client_destroy);
 
-static void cleanup_old_buffers(void)
+static unsigned get_max_age_hz(void)
 {
-        unsigned long max_age = ACCESS_ONCE(dm_bufio_max_age);
-        struct dm_bufio_client *c;
+        unsigned max_age = ACCESS_ONCE(dm_bufio_max_age);
 
-        if (max_age > ULONG_MAX / HZ)
-                max_age = ULONG_MAX / HZ;
+        if (max_age > UINT_MAX / HZ)
+                max_age = UINT_MAX / HZ;
 
-        mutex_lock(&dm_bufio_clients_lock);
-        list_for_each_entry(c, &dm_bufio_all_clients, client_list) {
-                if (!dm_bufio_trylock(c))
-                        continue;
+        return max_age * HZ;
+}
 
-                while (!list_empty(&c->lru[LIST_CLEAN])) {
-                        struct dm_buffer *b;
-                        b = list_entry(c->lru[LIST_CLEAN].prev,
-                                       struct dm_buffer, lru_list);
-                        if (!__cleanup_old_buffer(b, 0, max_age * HZ))
-                                break;
-                        dm_bufio_cond_resched();
-                }
+static bool older_than(struct dm_buffer *b, unsigned long age_hz)
+{
+        return (jiffies - b->last_accessed) >= age_hz;
+}
+
+static void __evict_old_buffers(struct dm_bufio_client *c, unsigned long age_hz)
+{
+        struct dm_buffer *b, *tmp;
+        unsigned retain_target = get_retain_buffers(c);
+        unsigned count;
+
+        dm_bufio_lock(c);
+
+        count = c->n_buffers[LIST_CLEAN] + c->n_buffers[LIST_DIRTY];
+        list_for_each_entry_safe_reverse(b, tmp, &c->lru[LIST_CLEAN], lru_list) {
+                if (count <= retain_target)
+                        break;
+
+                if (!older_than(b, age_hz))
+                        break;
+
+                if (__try_evict_buffer(b, 0))
+                        count--;
 
-                dm_bufio_unlock(c);
                 dm_bufio_cond_resched();
         }
+
+        dm_bufio_unlock(c);
+}
+
+static void cleanup_old_buffers(void)
+{
+        unsigned long max_age_hz = get_max_age_hz();
+        struct dm_bufio_client *c;
+
+        mutex_lock(&dm_bufio_clients_lock);
+
+        list_for_each_entry(c, &dm_bufio_all_clients, client_list)
+                __evict_old_buffers(c, max_age_hz);
+
         mutex_unlock(&dm_bufio_clients_lock);
 }
 
@@ -1834,6 +1901,9 @@ MODULE_PARM_DESC(max_cache_size_bytes, "Size of metadata cache");
 module_param_named(max_age_seconds, dm_bufio_max_age, uint, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(max_age_seconds, "Max age of a buffer in seconds");
 
+module_param_named(retain_bytes, dm_bufio_retain_bytes, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(retain_bytes, "Try to keep at least this many bytes cached in memory");
+
 module_param_named(peak_allocated_bytes, dm_bufio_peak_allocated, ulong, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(peak_allocated_bytes, "Tracks the maximum allocated memory");
 
diff --git a/drivers/md/dm-cache-block-types.h b/drivers/md/dm-cache-block-types.h
index aac0e2df06be..bed4ad4e1b7c 100644
--- a/drivers/md/dm-cache-block-types.h
+++ b/drivers/md/dm-cache-block-types.h
@@ -19,6 +19,7 @@
 
 typedef dm_block_t __bitwise__ dm_oblock_t;
 typedef uint32_t __bitwise__ dm_cblock_t;
+typedef dm_block_t __bitwise__ dm_dblock_t;
 
 static inline dm_oblock_t to_oblock(dm_block_t b)
 {
@@ -40,4 +41,14 @@ static inline uint32_t from_cblock(dm_cblock_t b)
         return (__force uint32_t) b;
 }
 
+static inline dm_dblock_t to_dblock(dm_block_t b)
+{
+        return (__force dm_dblock_t) b;
+}
+
+static inline dm_block_t from_dblock(dm_dblock_t b)
+{
+        return (__force dm_block_t) b;
+}
+
 #endif /* DM_CACHE_BLOCK_TYPES_H */
diff --git a/drivers/md/dm-cache-metadata.c b/drivers/md/dm-cache-metadata.c
index 06709257adde..9fc616c2755e 100644
--- a/drivers/md/dm-cache-metadata.c
+++ b/drivers/md/dm-cache-metadata.c
@@ -109,7 +109,7 @@ struct dm_cache_metadata {
         dm_block_t discard_root;
 
         sector_t discard_block_size;
-        dm_oblock_t discard_nr_blocks;
+        dm_dblock_t discard_nr_blocks;
 
         sector_t data_block_size;
         dm_cblock_t cache_blocks;
@@ -329,7 +329,7 @@ static int __write_initial_superblock(struct dm_cache_metadata *cmd)
         disk_super->hint_root = cpu_to_le64(cmd->hint_root);
         disk_super->discard_root = cpu_to_le64(cmd->discard_root);
         disk_super->discard_block_size = cpu_to_le64(cmd->discard_block_size);
-        disk_super->discard_nr_blocks = cpu_to_le64(from_oblock(cmd->discard_nr_blocks));
+        disk_super->discard_nr_blocks = cpu_to_le64(from_dblock(cmd->discard_nr_blocks));
         disk_super->metadata_block_size = cpu_to_le32(DM_CACHE_METADATA_BLOCK_SIZE);
         disk_super->data_block_size = cpu_to_le32(cmd->data_block_size);
         disk_super->cache_blocks = cpu_to_le32(0);
@@ -528,7 +528,7 @@ static void read_superblock_fields(struct dm_cache_metadata *cmd,
         cmd->hint_root = le64_to_cpu(disk_super->hint_root);
         cmd->discard_root = le64_to_cpu(disk_super->discard_root);
         cmd->discard_block_size = le64_to_cpu(disk_super->discard_block_size);
-        cmd->discard_nr_blocks = to_oblock(le64_to_cpu(disk_super->discard_nr_blocks));
+        cmd->discard_nr_blocks = to_dblock(le64_to_cpu(disk_super->discard_nr_blocks));
         cmd->data_block_size = le32_to_cpu(disk_super->data_block_size);
         cmd->cache_blocks = to_cblock(le32_to_cpu(disk_super->cache_blocks));
         strncpy(cmd->policy_name, disk_super->policy_name, sizeof(cmd->policy_name));
@@ -626,7 +626,7 @@ static int __commit_transaction(struct dm_cache_metadata *cmd,
         disk_super->hint_root = cpu_to_le64(cmd->hint_root);
         disk_super->discard_root = cpu_to_le64(cmd->discard_root);
         disk_super->discard_block_size = cpu_to_le64(cmd->discard_block_size);
-        disk_super->discard_nr_blocks = cpu_to_le64(from_oblock(cmd->discard_nr_blocks));
+        disk_super->discard_nr_blocks = cpu_to_le64(from_dblock(cmd->discard_nr_blocks));
         disk_super->cache_blocks = cpu_to_le32(from_cblock(cmd->cache_blocks));
         strncpy(disk_super->policy_name, cmd->policy_name, sizeof(disk_super->policy_name));
         disk_super->policy_version[0] = cpu_to_le32(cmd->policy_version[0]);
@@ -797,15 +797,15 @@ out:
 
 int dm_cache_discard_bitset_resize(struct dm_cache_metadata *cmd,
                                    sector_t discard_block_size,
-                                   dm_oblock_t new_nr_entries)
+                                   dm_dblock_t new_nr_entries)
 {
         int r;
 
         down_write(&cmd->root_lock);
         r = dm_bitset_resize(&cmd->discard_info,
                              cmd->discard_root,
-                             from_oblock(cmd->discard_nr_blocks),
-                             from_oblock(new_nr_entries),
+                             from_dblock(cmd->discard_nr_blocks),
+                             from_dblock(new_nr_entries),
                              false, &cmd->discard_root);
         if (!r) {
                 cmd->discard_block_size = discard_block_size;
@@ -818,28 +818,28 @@ int dm_cache_discard_bitset_resize(struct dm_cache_metadata *cmd,
         return r;
 }
 
-static int __set_discard(struct dm_cache_metadata *cmd, dm_oblock_t b)
+static int __set_discard(struct dm_cache_metadata *cmd, dm_dblock_t b)
 {
         return dm_bitset_set_bit(&cmd->discard_info, cmd->discard_root,
-                                 from_oblock(b), &cmd->discard_root);
+                                 from_dblock(b), &cmd->discard_root);
 }
 
-static int __clear_discard(struct dm_cache_metadata *cmd, dm_oblock_t b)
+static int __clear_discard(struct dm_cache_metadata *cmd, dm_dblock_t b)
 {
         return dm_bitset_clear_bit(&cmd->discard_info, cmd->discard_root,
-                                   from_oblock(b), &cmd->discard_root);
+                                   from_dblock(b), &cmd->discard_root);
 }
 
-static int __is_discarded(struct dm_cache_metadata *cmd, dm_oblock_t b,
+static int __is_discarded(struct dm_cache_metadata *cmd, dm_dblock_t b,
                           bool *is_discarded)
 {
         return dm_bitset_test_bit(&cmd->discard_info, cmd->discard_root,
-                                  from_oblock(b), &cmd->discard_root,
+                                  from_dblock(b), &cmd->discard_root,
                                   is_discarded);
 }
 
 static int __discard(struct dm_cache_metadata *cmd,
-                     dm_oblock_t dblock, bool discard)
+                     dm_dblock_t dblock, bool discard)
 {
         int r;
 
@@ -852,7 +852,7 @@ static int __discard(struct dm_cache_metadata *cmd,
 }
 
 int dm_cache_set_discard(struct dm_cache_metadata *cmd,
-                         dm_oblock_t dblock, bool discard)
+                         dm_dblock_t dblock, bool discard)
 {
         int r;
 
@@ -870,8 +870,8 @@ static int __load_discards(struct dm_cache_metadata *cmd,
         dm_block_t b;
         bool discard;
 
-        for (b = 0; b < from_oblock(cmd->discard_nr_blocks); b++) {
-                dm_oblock_t dblock = to_oblock(b);
+        for (b = 0; b < from_dblock(cmd->discard_nr_blocks); b++) {
+                dm_dblock_t dblock = to_dblock(b);
 
                 if (cmd->clean_when_opened) {
                         r = __is_discarded(cmd, dblock, &discard);
diff --git a/drivers/md/dm-cache-metadata.h b/drivers/md/dm-cache-metadata.h
index 7383c90ccdb8..4ecc403be283 100644
--- a/drivers/md/dm-cache-metadata.h
+++ b/drivers/md/dm-cache-metadata.h
@@ -70,14 +70,14 @@ dm_cblock_t dm_cache_size(struct dm_cache_metadata *cmd);
 
 int dm_cache_discard_bitset_resize(struct dm_cache_metadata *cmd,
                                    sector_t discard_block_size,
-                                   dm_oblock_t new_nr_entries);
+                                   dm_dblock_t new_nr_entries);
 
 typedef int (*load_discard_fn)(void *context, sector_t discard_block_size,
-                               dm_oblock_t dblock, bool discarded);
+                               dm_dblock_t dblock, bool discarded);
 int dm_cache_load_discards(struct dm_cache_metadata *cmd,
                            load_discard_fn fn, void *context);
 
-int dm_cache_set_discard(struct dm_cache_metadata *cmd, dm_oblock_t dblock, bool discard);
+int dm_cache_set_discard(struct dm_cache_metadata *cmd, dm_dblock_t dblock, bool discard);
 
 int dm_cache_remove_mapping(struct dm_cache_metadata *cmd, dm_cblock_t cblock);
 int dm_cache_insert_mapping(struct dm_cache_metadata *cmd, dm_cblock_t cblock, dm_oblock_t oblock);
diff --git a/drivers/md/dm-cache-policy-mq.c b/drivers/md/dm-cache-policy-mq.c
index 0e385e40909e..13f547a4eeb6 100644
--- a/drivers/md/dm-cache-policy-mq.c
+++ b/drivers/md/dm-cache-policy-mq.c
@@ -181,24 +181,30 @@ static void queue_shift_down(struct queue *q)
  * Gives us the oldest entry of the lowest popoulated level.  If the first
  * level is emptied then we shift down one level.
  */
-static struct list_head *queue_pop(struct queue *q)
+static struct list_head *queue_peek(struct queue *q)
 {
         unsigned level;
-        struct list_head *r;
 
         for (level = 0; level < NR_QUEUE_LEVELS; level++)
-                if (!list_empty(q->qs + level)) {
-                        r = q->qs[level].next;
-                        list_del(r);
+                if (!list_empty(q->qs + level))
+                        return q->qs[level].next;
 
-                        /* have we just emptied the bottom level? */
-                        if (level == 0 && list_empty(q->qs))
-                                queue_shift_down(q);
+        return NULL;
+}
 
-                        return r;
-                }
+static struct list_head *queue_pop(struct queue *q)
+{
+        struct list_head *r = queue_peek(q);
 
-        return NULL;
+        if (r) {
+                list_del(r);
+
+                /* have we just emptied the bottom level? */
+                if (list_empty(q->qs))
+                        queue_shift_down(q);
+        }
+
+        return r;
 }
 
 static struct list_head *list_pop(struct list_head *lh)
@@ -383,13 +389,6 @@ struct mq_policy {
         unsigned generation;
         unsigned generation_period; /* in lookups (will probably change) */
 
-        /*
-         * Entries in the pre_cache whose hit count passes the promotion
-         * threshold move to the cache proper.  Working out the correct
-         * value for the promotion_threshold is crucial to this policy.
-         */
-        unsigned promote_threshold;
-
         unsigned discard_promote_adjustment;
         unsigned read_promote_adjustment;
         unsigned write_promote_adjustment;
@@ -406,6 +405,7 @@ struct mq_policy {
 #define DEFAULT_DISCARD_PROMOTE_ADJUSTMENT 1
 #define DEFAULT_READ_PROMOTE_ADJUSTMENT 4
 #define DEFAULT_WRITE_PROMOTE_ADJUSTMENT 8
+#define DISCOURAGE_DEMOTING_DIRTY_THRESHOLD 128
 
 /*----------------------------------------------------------------*/
 
@@ -518,6 +518,12 @@ static struct entry *pop(struct mq_policy *mq, struct queue *q)
         return e;
 }
 
+static struct entry *peek(struct queue *q)
+{
+        struct list_head *h = queue_peek(q);
+        return h ? container_of(h, struct entry, list) : NULL;
+}
+
 /*
  * Has this entry already been updated?
  */
@@ -570,10 +576,6 @@ static void check_generation(struct mq_policy *mq)
                                         break;
                         }
                 }
-
-                mq->promote_threshold = nr ? total / nr : 1;
-                if (mq->promote_threshold * nr < total)
-                        mq->promote_threshold++;
         }
 }
 
@@ -641,6 +643,30 @@ static int demote_cblock(struct mq_policy *mq, dm_oblock_t *oblock)
 }
 
 /*
+ * Entries in the pre_cache whose hit count passes the promotion
+ * threshold move to the cache proper.  Working out the correct
+ * value for the promotion_threshold is crucial to this policy.
+ */
+static unsigned promote_threshold(struct mq_policy *mq)
+{
+        struct entry *e;
+
+        if (any_free_cblocks(mq))
+                return 0;
+
+        e = peek(&mq->cache_clean);
+        if (e)
+                return e->hit_count;
+
+        e = peek(&mq->cache_dirty);
+        if (e)
+                return e->hit_count + DISCOURAGE_DEMOTING_DIRTY_THRESHOLD;
+
+        /* This should never happen */
+        return 0;
+}
+
+/*
  * We modify the basic promotion_threshold depending on the specific io.
  *
  * If the origin block has been discarded then there's no cost to copy it
@@ -653,7 +679,7 @@ static unsigned adjusted_promote_threshold(struct mq_policy *mq,
                                            bool discarded_oblock, int data_dir)
 {
         if (data_dir == READ)
-                return mq->promote_threshold + mq->read_promote_adjustment;
+                return promote_threshold(mq) + mq->read_promote_adjustment;
 
         if (discarded_oblock && (any_free_cblocks(mq) || any_clean_cblocks(mq))) {
                 /*
@@ -663,7 +689,7 @@ static unsigned adjusted_promote_threshold(struct mq_policy *mq,
                 return mq->discard_promote_adjustment;
         }
 
-        return mq->promote_threshold + mq->write_promote_adjustment;
+        return promote_threshold(mq) + mq->write_promote_adjustment;
 }
 
 static bool should_promote(struct mq_policy *mq, struct entry *e,
@@ -839,7 +865,8 @@ static int map(struct mq_policy *mq, dm_oblock_t oblock,
         if (e && in_cache(mq, e))
                 r = cache_entry_found(mq, e, result);
 
-        else if (iot_pattern(&mq->tracker) == PATTERN_SEQUENTIAL)
+        else if (mq->tracker.thresholds[PATTERN_SEQUENTIAL] &&
+                 iot_pattern(&mq->tracker) == PATTERN_SEQUENTIAL)
                 result->op = POLICY_MISS;
 
         else if (e)
@@ -1230,7 +1257,6 @@ static struct dm_cache_policy *mq_create(dm_cblock_t cache_size,
         mq->tick = 0;
         mq->hit_count = 0;
         mq->generation = 0;
-        mq->promote_threshold = 0;
         mq->discard_promote_adjustment = DEFAULT_DISCARD_PROMOTE_ADJUSTMENT;
         mq->read_promote_adjustment = DEFAULT_READ_PROMOTE_ADJUSTMENT;
         mq->write_promote_adjustment = DEFAULT_WRITE_PROMOTE_ADJUSTMENT;
@@ -1265,7 +1291,7 @@ bad_pre_cache_init:
 
 static struct dm_cache_policy_type mq_policy_type = {
         .name = "mq",
-        .version = {1, 2, 0},
+        .version = {1, 3, 0},
         .hint_size = 4,
         .owner = THIS_MODULE,
         .create = mq_create
@@ -1273,7 +1299,7 @@ static struct dm_cache_policy_type mq_policy_type = {
 
 static struct dm_cache_policy_type default_policy_type = {
         .name = "default",
-        .version = {1, 2, 0},
+        .version = {1, 3, 0},
         .hint_size = 4,
         .owner = THIS_MODULE,
         .create = mq_create,
diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c
index 7130505c2425..1e96d7889f51 100644
--- a/drivers/md/dm-cache-target.c
+++ b/drivers/md/dm-cache-target.c
@@ -95,7 +95,6 @@ static void dm_unhook_bio(struct dm_hook_info *h, struct bio *bio)
 
 /*----------------------------------------------------------------*/
 
-#define PRISON_CELLS 1024
 #define MIGRATION_POOL_SIZE 128
 #define COMMIT_PERIOD HZ
 #define MIGRATION_COUNT_WINDOW 10
@@ -237,8 +236,9 @@ struct cache {
         /*
          * origin_blocks entries, discarded if set.
          */
-        dm_oblock_t discard_nr_blocks;
+        dm_dblock_t discard_nr_blocks;
         unsigned long *discard_bitset;
+        uint32_t discard_block_size; /* a power of 2 times sectors per block */
 
         /*
          * Rather than reconstructing the table line for the status we just
@@ -310,6 +310,7 @@ struct dm_cache_migration {
         dm_cblock_t cblock;
 
         bool err:1;
+        bool discard:1;
         bool writeback:1;
         bool demote:1;
         bool promote:1;
@@ -433,11 +434,12 @@ static void prealloc_put_cell(struct prealloc *p, struct dm_bio_prison_cell *cel
 
 /*----------------------------------------------------------------*/
 
-static void build_key(dm_oblock_t oblock, struct dm_cell_key *key)
+static void build_key(dm_oblock_t begin, dm_oblock_t end, struct dm_cell_key *key)
 {
         key->virtual = 0;
         key->dev = 0;
-        key->block = from_oblock(oblock);
+        key->block_begin = from_oblock(begin);
+        key->block_end = from_oblock(end);
 }
 
 /*
@@ -447,15 +449,15 @@ static void build_key(dm_oblock_t oblock, struct dm_cell_key *key)
  */
 typedef void (*cell_free_fn)(void *context, struct dm_bio_prison_cell *cell);
 
-static int bio_detain(struct cache *cache, dm_oblock_t oblock,
-                      struct bio *bio, struct dm_bio_prison_cell *cell_prealloc,
-                      cell_free_fn free_fn, void *free_context,
-                      struct dm_bio_prison_cell **cell_result)
+static int bio_detain_range(struct cache *cache, dm_oblock_t oblock_begin, dm_oblock_t oblock_end,
+                            struct bio *bio, struct dm_bio_prison_cell *cell_prealloc,
+                            cell_free_fn free_fn, void *free_context,
+                            struct dm_bio_prison_cell **cell_result)
 {
         int r;
         struct dm_cell_key key;
 
-        build_key(oblock, &key);
+        build_key(oblock_begin, oblock_end, &key);
         r = dm_bio_detain(cache->prison, &key, bio, cell_prealloc, cell_result);
         if (r)
                 free_fn(free_context, cell_prealloc);
@@ -463,6 +465,16 @@ static int bio_detain(struct cache *cache, dm_oblock_t oblock,
         return r;
 }
 
+static int bio_detain(struct cache *cache, dm_oblock_t oblock,
+                      struct bio *bio, struct dm_bio_prison_cell *cell_prealloc,
+                      cell_free_fn free_fn, void *free_context,
+                      struct dm_bio_prison_cell **cell_result)
+{
+        dm_oblock_t end = to_oblock(from_oblock(oblock) + 1ULL);
+        return bio_detain_range(cache, oblock, end, bio,
+                                cell_prealloc, free_fn, free_context, cell_result);
+}
+
 static int get_cell(struct cache *cache,
                     dm_oblock_t oblock,
                     struct prealloc *structs,
@@ -474,7 +486,7 @@ static int get_cell(struct cache *cache,
 
         cell_prealloc = prealloc_get_cell(structs);
 
-        build_key(oblock, &key);
+        build_key(oblock, to_oblock(from_oblock(oblock) + 1ULL), &key);
         r = dm_get_cell(cache->prison, &key, cell_prealloc, cell_result);
         if (r)
                 prealloc_put_cell(structs, cell_prealloc);
@@ -524,33 +536,57 @@ static dm_block_t block_div(dm_block_t b, uint32_t n)
         return b;
 }
 
-static void set_discard(struct cache *cache, dm_oblock_t b)
+static dm_block_t oblocks_per_dblock(struct cache *cache)
+{
+        dm_block_t oblocks = cache->discard_block_size;
+
+        if (block_size_is_power_of_two(cache))
+                oblocks >>= cache->sectors_per_block_shift;
+        else
+                oblocks = block_div(oblocks, cache->sectors_per_block);
+
+        return oblocks;
+}
+
+static dm_dblock_t oblock_to_dblock(struct cache *cache, dm_oblock_t oblock)
+{
+        return to_dblock(block_div(from_oblock(oblock),
+                                   oblocks_per_dblock(cache)));
+}
+
+static dm_oblock_t dblock_to_oblock(struct cache *cache, dm_dblock_t dblock)
+{
+        return to_oblock(from_dblock(dblock) * oblocks_per_dblock(cache));
+}
+
+static void set_discard(struct cache *cache, dm_dblock_t b)
 {
         unsigned long flags;
 
+        BUG_ON(from_dblock(b) >= from_dblock(cache->discard_nr_blocks));
         atomic_inc(&cache->stats.discard_count);
 
         spin_lock_irqsave(&cache->lock, flags);
-        set_bit(from_oblock(b), cache->discard_bitset);
+        set_bit(from_dblock(b), cache->discard_bitset);
         spin_unlock_irqrestore(&cache->lock, flags);
 }
 
-static void clear_discard(struct cache *cache, dm_oblock_t b)
+static void clear_discard(struct cache *cache, dm_dblock_t b)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&cache->lock, flags);
-        clear_bit(from_oblock(b), cache->discard_bitset);
+        clear_bit(from_dblock(b), cache->discard_bitset);
         spin_unlock_irqrestore(&cache->lock, flags);
 }
 
-static bool is_discarded(struct cache *cache, dm_oblock_t b)
+static bool is_discarded(struct cache *cache, dm_dblock_t b)
 {
         int r;
         unsigned long flags;
 
         spin_lock_irqsave(&cache->lock, flags);
-        r = test_bit(from_oblock(b), cache->discard_bitset);
+        r = test_bit(from_dblock(b), cache->discard_bitset);
         spin_unlock_irqrestore(&cache->lock, flags);
 
         return r;
@@ -562,7 +598,8 @@ static bool is_discarded_oblock(struct cache *cache, dm_oblock_t b)
         unsigned long flags;
 
         spin_lock_irqsave(&cache->lock, flags);
-        r = test_bit(from_oblock(b), cache->discard_bitset);
+        r = test_bit(from_dblock(oblock_to_dblock(cache, b)),
+                     cache->discard_bitset);
         spin_unlock_irqrestore(&cache->lock, flags);
 
         return r;
@@ -687,7 +724,7 @@ static void remap_to_origin_clear_discard(struct cache *cache, struct bio *bio,
         check_if_tick_bio_needed(cache, bio);
         remap_to_origin(cache, bio);
         if (bio_data_dir(bio) == WRITE)
-                clear_discard(cache, oblock);
+                clear_discard(cache, oblock_to_dblock(cache, oblock));
 }
 
 static void remap_to_cache_dirty(struct cache *cache, struct bio *bio,
@@ -697,7 +734,7 @@ static void remap_to_cache_dirty(struct cache *cache, struct bio *bio,
         remap_to_cache(cache, bio, cblock);
         if (bio_data_dir(bio) == WRITE) {
                 set_dirty(cache, oblock, cblock);
-                clear_discard(cache, oblock);
+                clear_discard(cache, oblock_to_dblock(cache, oblock));
         }
 }
 
@@ -951,10 +988,14 @@ static void migration_success_post_commit(struct dm_cache_migration *mg)
                 }
 
         } else {
-                clear_dirty(cache, mg->new_oblock, mg->cblock);
-                if (mg->requeue_holder)
+                if (mg->requeue_holder) {
+                        clear_dirty(cache, mg->new_oblock, mg->cblock);
                         cell_defer(cache, mg->new_ocell, true);
-                else {
+                } else {
+                        /*
+                         * The block was promoted via an overwrite, so it's dirty.
+                         */
+                        set_dirty(cache, mg->new_oblock, mg->cblock);
                         bio_endio(mg->new_ocell->holder, 0);
                         cell_defer(cache, mg->new_ocell, false);
                 }
@@ -978,7 +1019,7 @@ static void copy_complete(int read_err, unsigned long write_err, void *context)
         wake_worker(cache);
 }
 
-static void issue_copy_real(struct dm_cache_migration *mg)
+static void issue_copy(struct dm_cache_migration *mg)
 {
         int r;
         struct dm_io_region o_region, c_region;
@@ -1057,11 +1098,46 @@ static void avoid_copy(struct dm_cache_migration *mg)
         migration_success_pre_commit(mg);
 }
 
-static void issue_copy(struct dm_cache_migration *mg)
+static void calc_discard_block_range(struct cache *cache, struct bio *bio,
+                                     dm_dblock_t *b, dm_dblock_t *e)
+{
+        sector_t sb = bio->bi_iter.bi_sector;
+        sector_t se = bio_end_sector(bio);
+
+        *b = to_dblock(dm_sector_div_up(sb, cache->discard_block_size));
+
+        if (se - sb < cache->discard_block_size)
+                *e = *b;
+        else
+                *e = to_dblock(block_div(se, cache->discard_block_size));
+}
+
+static void issue_discard(struct dm_cache_migration *mg)
+{
+        dm_dblock_t b, e;
+        struct bio *bio = mg->new_ocell->holder;
+
+        calc_discard_block_range(mg->cache, bio, &b, &e);
+        while (b != e) {
+                set_discard(mg->cache, b);
+                b = to_dblock(from_dblock(b) + 1);
+        }
+
+        bio_endio(bio, 0);
+        cell_defer(mg->cache, mg->new_ocell, false);
+        free_migration(mg);
+}
+
+static void issue_copy_or_discard(struct dm_cache_migration *mg)
 {
         bool avoid;
         struct cache *cache = mg->cache;
 
+        if (mg->discard) {
+                issue_discard(mg);
+                return;
+        }
+
         if (mg->writeback || mg->demote)
                 avoid = !is_dirty(cache, mg->cblock) ||
                         is_discarded_oblock(cache, mg->old_oblock);
@@ -1070,13 +1146,14 @@ static void issue_copy(struct dm_cache_migration *mg)
 
                 avoid = is_discarded_oblock(cache, mg->new_oblock);
 
-                if (!avoid && bio_writes_complete_block(cache, bio)) {
+                if (writeback_mode(&cache->features) &&
+                    !avoid && bio_writes_complete_block(cache, bio)) {
                         issue_overwrite(mg, bio);
                         return;
                 }
         }
 
-        avoid ? avoid_copy(mg) : issue_copy_real(mg);
+        avoid ? avoid_copy(mg) : issue_copy(mg);
 }
 
 static void complete_migration(struct dm_cache_migration *mg)
@@ -1161,6 +1238,7 @@ static void promote(struct cache *cache, struct prealloc *structs,
         struct dm_cache_migration *mg = prealloc_get_migration(structs);
 
         mg->err = false;
+        mg->discard = false;
         mg->writeback = false;
         mg->demote = false;
         mg->promote = true;
@@ -1184,6 +1262,7 @@ static void writeback(struct cache *cache, struct prealloc *structs,
         struct dm_cache_migration *mg = prealloc_get_migration(structs);
 
         mg->err = false;
+        mg->discard = false;
         mg->writeback = true;
         mg->demote = false;
         mg->promote = false;
@@ -1209,6 +1288,7 @@ static void demote_then_promote(struct cache *cache, struct prealloc *structs,
         struct dm_cache_migration *mg = prealloc_get_migration(structs);
 
         mg->err = false;
+        mg->discard = false;
         mg->writeback = false;
         mg->demote = true;
         mg->promote = true;
@@ -1237,6 +1317,7 @@ static void invalidate(struct cache *cache, struct prealloc *structs,
         struct dm_cache_migration *mg = prealloc_get_migration(structs);
 
         mg->err = false;
+        mg->discard = false;
         mg->writeback = false;
         mg->demote = true;
         mg->promote = false;
@@ -1253,6 +1334,26 @@ static void invalidate(struct cache *cache, struct prealloc *structs,
         quiesce_migration(mg);
 }
 
+static void discard(struct cache *cache, struct prealloc *structs,
+                    struct dm_bio_prison_cell *cell)
+{
+        struct dm_cache_migration *mg = prealloc_get_migration(structs);
+
+        mg->err = false;
+        mg->discard = true;
+        mg->writeback = false;
+        mg->demote = false;
+        mg->promote = false;
+        mg->requeue_holder = false;
+        mg->invalidate = false;
+        mg->cache = cache;
+        mg->old_ocell = NULL;
+        mg->new_ocell = cell;
+        mg->start_jiffies = jiffies;
+
+        quiesce_migration(mg);
+}
+
 /*----------------------------------------------------------------
  * bio processing
  *--------------------------------------------------------------*/
@@ -1286,31 +1387,27 @@ static void process_flush_bio(struct cache *cache, struct bio *bio)
         issue(cache, bio);
 }
 
-/*
- * People generally discard large parts of a device, eg, the whole device
- * when formatting.  Splitting these large discards up into cache block
- * sized ios and then quiescing (always neccessary for discard) takes too
- * long.
- *
- * We keep it simple, and allow any size of discard to come in, and just
- * mark off blocks on the discard bitset.  No passdown occurs!
- *
- * To implement passdown we need to change the bio_prison such that a cell
- * can have a key that spans many blocks.
- */
-static void process_discard_bio(struct cache *cache, struct bio *bio)
+static void process_discard_bio(struct cache *cache, struct prealloc *structs,
+                                struct bio *bio)
 {
-        dm_block_t start_block = dm_sector_div_up(bio->bi_iter.bi_sector,
-                                                  cache->sectors_per_block);
-        dm_block_t end_block = bio_end_sector(bio);
-        dm_block_t b;
+        int r;
+        dm_dblock_t b, e;
+        struct dm_bio_prison_cell *cell_prealloc, *new_ocell;
 
-        end_block = block_div(end_block, cache->sectors_per_block);
+        calc_discard_block_range(cache, bio, &b, &e);
+        if (b == e) {
+                bio_endio(bio, 0);
+                return;
+        }
 
-        for (b = start_block; b < end_block; b++)
-                set_discard(cache, to_oblock(b));
+        cell_prealloc = prealloc_get_cell(structs);
+        r = bio_detain_range(cache, dblock_to_oblock(cache, b), dblock_to_oblock(cache, e), bio, cell_prealloc,
+                             (cell_free_fn) prealloc_put_cell,
+                             structs, &new_ocell);
+        if (r > 0)
+                return;
 
-        bio_endio(bio, 0);
+        discard(cache, structs, new_ocell);
 }
 
 static bool spare_migration_bandwidth(struct cache *cache)
@@ -1340,9 +1437,8 @@ static void process_bio(struct cache *cache, struct prealloc *structs,
         dm_oblock_t block = get_bio_block(cache, bio);
         struct dm_bio_prison_cell *cell_prealloc, *old_ocell, *new_ocell;
         struct policy_result lookup_result;
-        bool discarded_block = is_discarded_oblock(cache, block);
         bool passthrough = passthrough_mode(&cache->features);
-        bool can_migrate = !passthrough && (discarded_block || spare_migration_bandwidth(cache));
+        bool discarded_block, can_migrate;
 
         /*
          * Check to see if that block is currently migrating.
@@ -1354,6 +1450,9 @@ static void process_bio(struct cache *cache, struct prealloc *structs,
         if (r > 0)
                 return;
 
+        discarded_block = is_discarded_oblock(cache, block);
+        can_migrate = !passthrough && (discarded_block || spare_migration_bandwidth(cache));
+
         r = policy_map(cache->policy, block, true, can_migrate, discarded_block,
                        bio, &lookup_result);
 
@@ -1500,7 +1599,7 @@ static void process_deferred_bios(struct cache *cache)
                 if (bio->bi_rw & REQ_FLUSH)
                         process_flush_bio(cache, bio);
                 else if (bio->bi_rw & REQ_DISCARD)
-                        process_discard_bio(cache, bio);
+                        process_discard_bio(cache, &structs, bio);
                 else
                         process_bio(cache, &structs, bio);
         }
@@ -1715,7 +1814,7 @@ static void do_worker(struct work_struct *ws)
                         process_invalidation_requests(cache);
                 }
 
-                process_migrations(cache, &cache->quiesced_migrations, issue_copy);
+                process_migrations(cache, &cache->quiesced_migrations, issue_copy_or_discard);
                 process_migrations(cache, &cache->completed_migrations, complete_migration);
 
                 if (commit_if_needed(cache)) {
@@ -2180,6 +2279,45 @@ static int create_cache_policy(struct cache *cache, struct cache_args *ca,
         return 0;
 }
 
+/*
+ * We want the discard block size to be at least the size of the cache
+ * block size and have no more than 2^14 discard blocks across the origin.
+ */
+#define MAX_DISCARD_BLOCKS (1 << 14)
+
+static bool too_many_discard_blocks(sector_t discard_block_size,
+                                    sector_t origin_size)
+{
+        (void) sector_div(origin_size, discard_block_size);
+
+        return origin_size > MAX_DISCARD_BLOCKS;
+}
+
+static sector_t calculate_discard_block_size(sector_t cache_block_size,
+                                             sector_t origin_size)
+{
+        sector_t discard_block_size = cache_block_size;
+
+        if (origin_size)
+                while (too_many_discard_blocks(discard_block_size, origin_size))
+                        discard_block_size *= 2;
+
+        return discard_block_size;
+}
+
+static void set_cache_size(struct cache *cache, dm_cblock_t size)
+{
+        dm_block_t nr_blocks = from_cblock(size);
+
+        if (nr_blocks > (1 << 20) && cache->cache_size != size)
+                DMWARN_LIMIT("You have created a cache device with a lot of individual cache blocks (%llu)\n"
+                             "All these mappings can consume a lot of kernel memory, and take some time to read/write.\n"
+                             "Please consider increasing the cache block size to reduce the overall cache block count.",
+                             (unsigned long long) nr_blocks);
+
+        cache->cache_size = size;
+}
+
 #define DEFAULT_MIGRATION_THRESHOLD 2048
 
 static int cache_create(struct cache_args *ca, struct cache **result)
@@ -2204,8 +2342,7 @@ static int cache_create(struct cache_args *ca, struct cache **result)
         ti->num_discard_bios = 1;
         ti->discards_supported = true;
         ti->discard_zeroes_data_unsupported = true;
-        /* Discard bios must be split on a block boundary */
-        ti->split_discard_bios = true;
+        ti->split_discard_bios = false;
 
         cache->features = ca->features;
         ti->per_bio_data_size = get_per_bio_data_size(cache);
@@ -2235,10 +2372,10 @@ static int cache_create(struct cache_args *ca, struct cache **result)
 
                 cache->sectors_per_block_shift = -1;
                 cache_size = block_div(cache_size, ca->block_size);
-                cache->cache_size = to_cblock(cache_size);
+                set_cache_size(cache, to_cblock(cache_size));
         } else {
                 cache->sectors_per_block_shift = __ffs(ca->block_size);
-                cache->cache_size = to_cblock(ca->cache_sectors >> cache->sectors_per_block_shift);
+                set_cache_size(cache, to_cblock(ca->cache_sectors >> cache->sectors_per_block_shift));
         }
 
         r = create_cache_policy(cache, ca, error);
@@ -2303,13 +2440,17 @@ static int cache_create(struct cache_args *ca, struct cache **result)
         }
         clear_bitset(cache->dirty_bitset, from_cblock(cache->cache_size));
 
-        cache->discard_nr_blocks = cache->origin_blocks;
-        cache->discard_bitset = alloc_bitset(from_oblock(cache->discard_nr_blocks));
+        cache->discard_block_size =
+                calculate_discard_block_size(cache->sectors_per_block,
+                                             cache->origin_sectors);
+        cache->discard_nr_blocks = to_dblock(dm_sector_div_up(cache->origin_sectors,
+                                                              cache->discard_block_size));
+        cache->discard_bitset = alloc_bitset(from_dblock(cache->discard_nr_blocks));
         if (!cache->discard_bitset) {
                 *error = "could not allocate discard bitset";
                 goto bad;
         }
-        clear_bitset(cache->discard_bitset, from_oblock(cache->discard_nr_blocks));
+        clear_bitset(cache->discard_bitset, from_dblock(cache->discard_nr_blocks));
 
         cache->copier = dm_kcopyd_client_create(&dm_kcopyd_throttle);
         if (IS_ERR(cache->copier)) {
@@ -2327,7 +2468,7 @@ static int cache_create(struct cache_args *ca, struct cache **result)
         INIT_DELAYED_WORK(&cache->waker, do_waker);
         cache->last_commit_jiffies = jiffies;
 
-        cache->prison = dm_bio_prison_create(PRISON_CELLS);
+        cache->prison = dm_bio_prison_create();
         if (!cache->prison) {
                 *error = "could not create bio prison";
                 goto bad;
@@ -2549,11 +2690,11 @@ static int __cache_map(struct cache *cache, struct bio *bio, struct dm_bio_priso
 static int cache_map(struct dm_target *ti, struct bio *bio)
 {
         int r;
-        struct dm_bio_prison_cell *cell;
+        struct dm_bio_prison_cell *cell = NULL;
         struct cache *cache = ti->private;
 
         r = __cache_map(cache, bio, &cell);
-        if (r == DM_MAPIO_REMAPPED) {
+        if (r == DM_MAPIO_REMAPPED && cell) {
                 inc_ds(cache, bio, cell);
                 cell_defer(cache, cell, false);
         }
@@ -2599,16 +2740,16 @@ static int write_discard_bitset(struct cache *cache)
 {
         unsigned i, r;
 
-        r = dm_cache_discard_bitset_resize(cache->cmd, cache->sectors_per_block,
-                                           cache->origin_blocks);
+        r = dm_cache_discard_bitset_resize(cache->cmd, cache->discard_block_size,
+                                           cache->discard_nr_blocks);
         if (r) {
                 DMERR("could not resize on-disk discard bitset");
                 return r;
         }
 
-        for (i = 0; i < from_oblock(cache->discard_nr_blocks); i++) {
-                r = dm_cache_set_discard(cache->cmd, to_oblock(i),
-                                         is_discarded(cache, to_oblock(i)));
+        for (i = 0; i < from_dblock(cache->discard_nr_blocks); i++) {
+                r = dm_cache_set_discard(cache->cmd, to_dblock(i),
+                                         is_discarded(cache, to_dblock(i)));
                 if (r)
                         return r;
         }
@@ -2680,15 +2821,86 @@ static int load_mapping(void *context, dm_oblock_t oblock, dm_cblock_t cblock,
         return 0;
 }
 
+/*
+ * The discard block size in the on disk metadata is not
+ * neccessarily the same as we're currently using.  So we have to
+ * be careful to only set the discarded attribute if we know it
+ * covers a complete block of the new size.
+ */
+struct discard_load_info {
+        struct cache *cache;
+
+        /*
+         * These blocks are sized using the on disk dblock size, rather
+         * than the current one.
+         */
+        dm_block_t block_size;
+        dm_block_t discard_begin, discard_end;
+};
+
+static void discard_load_info_init(struct cache *cache,
+                                   struct discard_load_info *li)
+{
+        li->cache = cache;
+        li->discard_begin = li->discard_end = 0;
+}
+
+static void set_discard_range(struct discard_load_info *li)
+{
+        sector_t b, e;
+
+        if (li->discard_begin == li->discard_end)
+                return;
+
+        /*
+         * Convert to sectors.
+         */
+        b = li->discard_begin * li->block_size;
+        e = li->discard_end * li->block_size;
+
+        /*
+         * Then convert back to the current dblock size.
+         */
+        b = dm_sector_div_up(b, li->cache->discard_block_size);
+        sector_div(e, li->cache->discard_block_size);
+
+        /*
+         * The origin may have shrunk, so we need to check we're still in
+         * bounds.
+         */
+        if (e > from_dblock(li->cache->discard_nr_blocks))
+                e = from_dblock(li->cache->discard_nr_blocks);
+
+        for (; b < e; b++)
+                set_discard(li->cache, to_dblock(b));
+}
+
 static int load_discard(void *context, sector_t discard_block_size,
-                        dm_oblock_t oblock, bool discard)
+                        dm_dblock_t dblock, bool discard)
 {
-        struct cache *cache = context;
+        struct discard_load_info *li = context;
 
-        if (discard)
-                set_discard(cache, oblock);
-        else
-                clear_discard(cache, oblock);
+        li->block_size = discard_block_size;
+
+        if (discard) {
+                if (from_dblock(dblock) == li->discard_end)
+                        /*
+                         * We're already in a discard range, just extend it.
+                         */
+                        li->discard_end = li->discard_end + 1ULL;
+
+                else {
+                        /*
+                         * Emit the old range and start a new one.
+                         */
+                        set_discard_range(li);
+                        li->discard_begin = from_dblock(dblock);
+                        li->discard_end = li->discard_begin + 1ULL;
+                }
+        } else {
+                set_discard_range(li);
+                li->discard_begin = li->discard_end = 0;
+        }
 
         return 0;
 }
@@ -2730,7 +2942,7 @@ static int resize_cache_dev(struct cache *cache, dm_cblock_t new_size)
                 return r;
         }
 
-        cache->cache_size = new_size;
+        set_cache_size(cache, new_size);
 
         return 0;
 }
@@ -2772,11 +2984,22 @@ static int cache_preresume(struct dm_target *ti)
         }
 
         if (!cache->loaded_discards) {
-                r = dm_cache_load_discards(cache->cmd, load_discard, cache);
+                struct discard_load_info li;
+
+                /*
+                 * The discard bitset could have been resized, or the
+                 * discard block size changed.  To be safe we start by
+                 * setting every dblock to not discarded.
+                 */
+                clear_bitset(cache->discard_bitset, from_dblock(cache->discard_nr_blocks));
+
+                discard_load_info_init(cache, &li);
+                r = dm_cache_load_discards(cache->cmd, load_discard, &li);
                 if (r) {
                         DMERR("could not load origin discards");
                         return r;
                 }
+                set_discard_range(&li);
 
                 cache->loaded_discards = true;
         }
@@ -3079,8 +3302,9 @@ static void set_discard_limits(struct cache *cache, struct queue_limits *limits)
         /*
          * FIXME: these limits may be incompatible with the cache device
          */
-        limits->max_discard_sectors = cache->sectors_per_block;
-        limits->discard_granularity = cache->sectors_per_block << SECTOR_SHIFT;
+        limits->max_discard_sectors = min_t(sector_t, cache->discard_block_size * 1024,
+                                            cache->origin_sectors);
+        limits->discard_granularity = cache->discard_block_size << SECTOR_SHIFT;
 }
 
 static void cache_io_hints(struct dm_target *ti, struct queue_limits *limits)
@@ -3104,7 +3328,7 @@ static void cache_io_hints(struct dm_target *ti, struct queue_limits *limits)
 
 static struct target_type cache_target = {
         .name = "cache",
-        .version = {1, 5, 0},
+        .version = {1, 6, 0},
         .module = THIS_MODULE,
         .ctr = cache_ctr,
         .dtr = cache_dtr,
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index fc93b9330af4..08981be7baa1 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -705,7 +705,7 @@ static int crypt_iv_tcw_whitening(struct crypt_config *cc,
         for (i = 0; i < ((1 << SECTOR_SHIFT) / 8); i++)
                 crypto_xor(data + i * 8, buf, 8);
 out:
-        memset(buf, 0, sizeof(buf));
+        memzero_explicit(buf, sizeof(buf));
         return r;
 }
 
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 0be9381365d7..73f791bb9ea4 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -684,11 +684,14 @@ static void __dev_status(struct mapped_device *md, struct dm_ioctl *param)
         int srcu_idx;
 
         param->flags &= ~(DM_SUSPEND_FLAG | DM_READONLY_FLAG |
-                          DM_ACTIVE_PRESENT_FLAG);
+                          DM_ACTIVE_PRESENT_FLAG | DM_INTERNAL_SUSPEND_FLAG);
 
         if (dm_suspended_md(md))
                 param->flags |= DM_SUSPEND_FLAG;
 
+        if (dm_suspended_internally_md(md))
+                param->flags |= DM_INTERNAL_SUSPEND_FLAG;
+
         if (dm_test_deferred_remove_flag(md))
                 param->flags |= DM_DEFERRED_REMOVE;
 
diff --git a/drivers/md/dm-stats.c b/drivers/md/dm-stats.c
index 87f86c77b094..f478a4c96d2f 100644
--- a/drivers/md/dm-stats.c
+++ b/drivers/md/dm-stats.c
@@ -824,7 +824,7 @@ static int message_stats_create(struct mapped_device *md,
                 return 1;
 
         id = dm_stats_create(dm_get_stats(md), start, end, step, program_id, aux_data,
-                             dm_internal_suspend, dm_internal_resume, md);
+                             dm_internal_suspend_fast, dm_internal_resume_fast, md);
         if (id < 0)
                 return id;
 
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index b2bd1ebf4562..3afae9e062f8 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1521,18 +1521,32 @@ fmode_t dm_table_get_mode(struct dm_table *t)
 }
 EXPORT_SYMBOL(dm_table_get_mode);
 
-static void suspend_targets(struct dm_table *t, unsigned postsuspend)
+enum suspend_mode {
+        PRESUSPEND,
+        PRESUSPEND_UNDO,
+        POSTSUSPEND,
+};
+
+static void suspend_targets(struct dm_table *t, enum suspend_mode mode)
 {
         int i = t->num_targets;
         struct dm_target *ti = t->targets;
 
         while (i--) {
-                if (postsuspend) {
+                switch (mode) {
+                case PRESUSPEND:
+                        if (ti->type->presuspend)
+                                ti->type->presuspend(ti);
+                        break;
+                case PRESUSPEND_UNDO:
+                        if (ti->type->presuspend_undo)
+                                ti->type->presuspend_undo(ti);
+                        break;
+                case POSTSUSPEND:
                         if (ti->type->postsuspend)
                                 ti->type->postsuspend(ti);
-                } else if (ti->type->presuspend)
-                        ti->type->presuspend(ti);
-
+                        break;
+                }
                 ti++;
         }
 }
@@ -1542,7 +1556,15 @@ void dm_table_presuspend_targets(struct dm_table *t)
         if (!t)
                 return;
 
-        suspend_targets(t, 0);
+        suspend_targets(t, PRESUSPEND);
+}
+
+void dm_table_presuspend_undo_targets(struct dm_table *t)
+{
+        if (!t)
+                return;
+
+        suspend_targets(t, PRESUSPEND_UNDO);
 }
 
 void dm_table_postsuspend_targets(struct dm_table *t)
@@ -1550,7 +1572,7 @@ void dm_table_postsuspend_targets(struct dm_table *t)
         if (!t)
                 return;
 
-        suspend_targets(t, 1);
+        suspend_targets(t, POSTSUSPEND);
 }
 
 int dm_table_resume_targets(struct dm_table *t)
diff --git a/drivers/md/dm-thin-metadata.c b/drivers/md/dm-thin-metadata.c
index e9d33ad59df5..43adbb863f5a 100644
--- a/drivers/md/dm-thin-metadata.c
+++ b/drivers/md/dm-thin-metadata.c
@@ -1384,42 +1384,38 @@ static bool __snapshotted_since(struct dm_thin_device *td, uint32_t time)
 }
 
 int dm_thin_find_block(struct dm_thin_device *td, dm_block_t block,
-                       int can_block, struct dm_thin_lookup_result *result)
+                       int can_issue_io, struct dm_thin_lookup_result *result)
 {
-        int r = -EINVAL;
-        uint64_t block_time = 0;
+        int r;
         __le64 value;
         struct dm_pool_metadata *pmd = td->pmd;
         dm_block_t keys[2] = { td->id, block };
         struct dm_btree_info *info;
 
-        if (can_block) {
-                down_read(&pmd->root_lock);
-                info = &pmd->info;
-        } else if (down_read_trylock(&pmd->root_lock))
-                info = &pmd->nb_info;
-        else
-                return -EWOULDBLOCK;
-
         if (pmd->fail_io)
-                goto out;
+                return -EINVAL;
 
-        r = dm_btree_lookup(info, pmd->root, keys, &value);
-        if (!r)
-                block_time = le64_to_cpu(value);
+        down_read(&pmd->root_lock);
 
-out:
-        up_read(&pmd->root_lock);
+        if (can_issue_io) {
+                info = &pmd->info;
+        } else
+                info = &pmd->nb_info;
 
+        r = dm_btree_lookup(info, pmd->root, keys, &value);
         if (!r) {
+                uint64_t block_time = 0;
                 dm_block_t exception_block;
                 uint32_t exception_time;
+
+                block_time = le64_to_cpu(value);
                 unpack_block_time(block_time, &exception_block,
                                   &exception_time);
                 result->block = exception_block;
                 result->shared = __snapshotted_since(td, exception_time);
         }
 
+        up_read(&pmd->root_lock);
         return r;
 }
 
@@ -1813,3 +1809,8 @@ bool dm_pool_metadata_needs_check(struct dm_pool_metadata *pmd)
 
         return needs_check;
 }
+
+void dm_pool_issue_prefetches(struct dm_pool_metadata *pmd)
+{
+        dm_tm_issue_prefetches(pmd->tm);
+}
diff --git a/drivers/md/dm-thin-metadata.h b/drivers/md/dm-thin-metadata.h
index e3c857db195a..921d15ee56a0 100644
--- a/drivers/md/dm-thin-metadata.h
+++ b/drivers/md/dm-thin-metadata.h
@@ -139,12 +139,12 @@ struct dm_thin_lookup_result {
 
 /*
  * Returns:
- *   -EWOULDBLOCK iff @can_block is set and would block.
+ *   -EWOULDBLOCK iff @can_issue_io is set and would issue IO
  *   -ENODATA iff that mapping is not present.
  *   0 success
  */
 int dm_thin_find_block(struct dm_thin_device *td, dm_block_t block,
-                       int can_block, struct dm_thin_lookup_result *result);
+                       int can_issue_io, struct dm_thin_lookup_result *result);
 
 /*
  * Obtain an unused block.
@@ -213,6 +213,11 @@ int dm_pool_register_metadata_threshold(struct dm_pool_metadata *pmd,
 int dm_pool_metadata_set_needs_check(struct dm_pool_metadata *pmd);
 bool dm_pool_metadata_needs_check(struct dm_pool_metadata *pmd);
 
+/*
+ * Issue any prefetches that may be useful.
+ */
+void dm_pool_issue_prefetches(struct dm_pool_metadata *pmd);
+
 /*----------------------------------------------------------------*/
 
 #endif
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 0f86d802b533..8735543eacdb 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -11,11 +11,13 @@
 #include <linux/device-mapper.h>
 #include <linux/dm-io.h>
 #include <linux/dm-kcopyd.h>
+#include <linux/log2.h>
 #include <linux/list.h>
 #include <linux/rculist.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/slab.h>
+#include <linux/sort.h>
 #include <linux/rbtree.h>
 
 #define DM_MSG_PREFIX   "thin"
@@ -25,7 +27,6 @@
  */
 #define ENDIO_HOOK_POOL_SIZE 1024
 #define MAPPING_POOL_SIZE 1024
-#define PRISON_CELLS 1024
 #define COMMIT_PERIOD HZ
 #define NO_SPACE_TIMEOUT_SECS 60
 
@@ -114,7 +115,8 @@ static void build_data_key(struct dm_thin_device *td,
 {
         key->virtual = 0;
         key->dev = dm_thin_dev_id(td);
-        key->block = b;
+        key->block_begin = b;
+        key->block_end = b + 1ULL;
 }
 
 static void build_virtual_key(struct dm_thin_device *td, dm_block_t b,
@@ -122,7 +124,55 @@ static void build_virtual_key(struct dm_thin_device *td, dm_block_t b,
 {
         key->virtual = 1;
         key->dev = dm_thin_dev_id(td);
-        key->block = b;
+        key->block_begin = b;
+        key->block_end = b + 1ULL;
+}
+
+/*----------------------------------------------------------------*/
+
+#define THROTTLE_THRESHOLD (1 * HZ)
+
+struct throttle {
+        struct rw_semaphore lock;
+        unsigned long threshold;
+        bool throttle_applied;
+};
+
+static void throttle_init(struct throttle *t)
+{
+        init_rwsem(&t->lock);
+        t->throttle_applied = false;
+}
+
+static void throttle_work_start(struct throttle *t)
+{
+        t->threshold = jiffies + THROTTLE_THRESHOLD;
+}
+
+static void throttle_work_update(struct throttle *t)
+{
+        if (!t->throttle_applied && jiffies > t->threshold) {
+                down_write(&t->lock);
+                t->throttle_applied = true;
+        }
+}
+
+static void throttle_work_complete(struct throttle *t)
+{
+        if (t->throttle_applied) {
+                t->throttle_applied = false;
+                up_write(&t->lock);
+        }
+}
+
+static void throttle_lock(struct throttle *t)
+{
+        down_read(&t->lock);
+}
+
+static void throttle_unlock(struct throttle *t)
+{
+        up_read(&t->lock);
 }
 
 /*----------------------------------------------------------------*/
@@ -155,8 +205,11 @@ struct pool_features {
 
 struct thin_c;
 typedef void (*process_bio_fn)(struct thin_c *tc, struct bio *bio);
+typedef void (*process_cell_fn)(struct thin_c *tc, struct dm_bio_prison_cell *cell);
 typedef void (*process_mapping_fn)(struct dm_thin_new_mapping *m);
 
+#define CELL_SORT_ARRAY_SIZE 8192
+
 struct pool {
         struct list_head list;
         struct dm_target *ti;   /* Only set if a pool target is bound */
@@ -171,11 +224,13 @@ struct pool {
 
         struct pool_features pf;
         bool low_water_triggered:1;     /* A dm event has been sent */
+        bool suspended:1;
 
         struct dm_bio_prison *prison;
         struct dm_kcopyd_client *copier;
 
         struct workqueue_struct *wq;
+        struct throttle throttle;
         struct work_struct worker;
         struct delayed_work waker;
         struct delayed_work no_space_timeout;
@@ -198,8 +253,13 @@ struct pool {
         process_bio_fn process_bio;
         process_bio_fn process_discard;
 
+        process_cell_fn process_cell;
+        process_cell_fn process_discard_cell;
+
         process_mapping_fn process_prepared_mapping;
         process_mapping_fn process_prepared_discard;
+
+        struct dm_bio_prison_cell *cell_sort_array[CELL_SORT_ARRAY_SIZE];
 };
 
 static enum pool_mode get_pool_mode(struct pool *pool);
@@ -232,8 +292,11 @@ struct thin_c {
 
         struct pool *pool;
         struct dm_thin_device *td;
+        struct mapped_device *thin_md;
+
         bool requeue_mode:1;
         spinlock_t lock;
+        struct list_head deferred_cells;
         struct bio_list deferred_bio_list;
         struct bio_list retry_on_resume_list;
         struct rb_root sort_bio_list; /* sorted list of deferred bios */
@@ -290,6 +353,15 @@ static void cell_release(struct pool *pool,
         dm_bio_prison_free_cell(pool->prison, cell);
 }
 
+static void cell_visit_release(struct pool *pool,
+                               void (*fn)(void *, struct dm_bio_prison_cell *),
+                               void *context,
+                               struct dm_bio_prison_cell *cell)
+{
+        dm_cell_visit_release(pool->prison, fn, context, cell);
+        dm_bio_prison_free_cell(pool->prison, cell);
+}
+
 static void cell_release_no_holder(struct pool *pool,
                                    struct dm_bio_prison_cell *cell,
                                    struct bio_list *bios)
@@ -298,19 +370,6 @@ static void cell_release_no_holder(struct pool *pool,
         dm_bio_prison_free_cell(pool->prison, cell);
 }
 
-static void cell_defer_no_holder_no_free(struct thin_c *tc,
-                                         struct dm_bio_prison_cell *cell)
-{
-        struct pool *pool = tc->pool;
-        unsigned long flags;
-
-        spin_lock_irqsave(&tc->lock, flags);
-        dm_cell_release_no_holder(pool->prison, cell, &tc->deferred_bio_list);
-        spin_unlock_irqrestore(&tc->lock, flags);
-
-        wake_worker(pool);
-}
-
 static void cell_error_with_code(struct pool *pool,
                                  struct dm_bio_prison_cell *cell, int error_code)
 {
@@ -323,6 +382,16 @@ static void cell_error(struct pool *pool, struct dm_bio_prison_cell *cell)
         cell_error_with_code(pool, cell, -EIO);
 }
 
+static void cell_success(struct pool *pool, struct dm_bio_prison_cell *cell)
+{
+        cell_error_with_code(pool, cell, 0);
+}
+
+static void cell_requeue(struct pool *pool, struct dm_bio_prison_cell *cell)
+{
+        cell_error_with_code(pool, cell, DM_ENDIO_REQUEUE);
+}
+
 /*----------------------------------------------------------------*/
 
 /*
@@ -393,44 +462,65 @@ struct dm_thin_endio_hook {
         struct rb_node rb_node;
 };
 
-static void requeue_bio_list(struct thin_c *tc, struct bio_list *master)
+static void __merge_bio_list(struct bio_list *bios, struct bio_list *master)
+{
+        bio_list_merge(bios, master);
+        bio_list_init(master);
+}
+
+static void error_bio_list(struct bio_list *bios, int error)
 {
         struct bio *bio;
+
+        while ((bio = bio_list_pop(bios)))
+                bio_endio(bio, error);
+}
+
+static void error_thin_bio_list(struct thin_c *tc, struct bio_list *master, int error)
+{
         struct bio_list bios;
         unsigned long flags;
 
         bio_list_init(&bios);
 
         spin_lock_irqsave(&tc->lock, flags);
-        bio_list_merge(&bios, master);
-        bio_list_init(master);
+        __merge_bio_list(&bios, master);
         spin_unlock_irqrestore(&tc->lock, flags);
 
-        while ((bio = bio_list_pop(&bios)))
-                bio_endio(bio, DM_ENDIO_REQUEUE);
+        error_bio_list(&bios, error);
 }
 
-static void requeue_io(struct thin_c *tc)
+static void requeue_deferred_cells(struct thin_c *tc)
 {
-        requeue_bio_list(tc, &tc->deferred_bio_list);
-        requeue_bio_list(tc, &tc->retry_on_resume_list);
+        struct pool *pool = tc->pool;
+        unsigned long flags;
+        struct list_head cells;
+        struct dm_bio_prison_cell *cell, *tmp;
+
+        INIT_LIST_HEAD(&cells);
+
+        spin_lock_irqsave(&tc->lock, flags);
+        list_splice_init(&tc->deferred_cells, &cells);
+        spin_unlock_irqrestore(&tc->lock, flags);
+
+        list_for_each_entry_safe(cell, tmp, &cells, user_list)
+                cell_requeue(pool, cell);
 }
 
-static void error_thin_retry_list(struct thin_c *tc)
+static void requeue_io(struct thin_c *tc)
 {
-        struct bio *bio;
-        unsigned long flags;
         struct bio_list bios;
+        unsigned long flags;
 
         bio_list_init(&bios);
 
         spin_lock_irqsave(&tc->lock, flags);
-        bio_list_merge(&bios, &tc->retry_on_resume_list);
-        bio_list_init(&tc->retry_on_resume_list);
+        __merge_bio_list(&bios, &tc->deferred_bio_list);
+        __merge_bio_list(&bios, &tc->retry_on_resume_list);
         spin_unlock_irqrestore(&tc->lock, flags);
 
-        while ((bio = bio_list_pop(&bios)))
-                bio_io_error(bio);
+        error_bio_list(&bios, DM_ENDIO_REQUEUE);
+        requeue_deferred_cells(tc);
 }
 
 static void error_retry_list(struct pool *pool)
@@ -439,7 +529,7 @@ static void error_retry_list(struct pool *pool)
 
         rcu_read_lock();
         list_for_each_entry_rcu(tc, &pool->active_thins, list)
-                error_thin_retry_list(tc);
+                error_thin_bio_list(tc, &tc->retry_on_resume_list, -EIO);
         rcu_read_unlock();
 }
 
@@ -629,33 +719,75 @@ static void overwrite_endio(struct bio *bio, int err)
  */
 
 /*
- * This sends the bios in the cell back to the deferred_bios list.
+ * This sends the bios in the cell, except the original holder, back
+ * to the deferred_bios list.
  */
-static void cell_defer(struct thin_c *tc, struct dm_bio_prison_cell *cell)
+static void cell_defer_no_holder(struct thin_c *tc, struct dm_bio_prison_cell *cell)
 {
         struct pool *pool = tc->pool;
         unsigned long flags;
 
         spin_lock_irqsave(&tc->lock, flags);
-        cell_release(pool, cell, &tc->deferred_bio_list);
+        cell_release_no_holder(pool, cell, &tc->deferred_bio_list);
         spin_unlock_irqrestore(&tc->lock, flags);
 
         wake_worker(pool);
 }
 
-/*
- * Same as cell_defer above, except it omits the original holder of the cell.
- */
-static void cell_defer_no_holder(struct thin_c *tc, struct dm_bio_prison_cell *cell)
+static void thin_defer_bio(struct thin_c *tc, struct bio *bio);
+
+struct remap_info {
+        struct thin_c *tc;
+        struct bio_list defer_bios;
+        struct bio_list issue_bios;
+};
+
+static void __inc_remap_and_issue_cell(void *context,
+                                       struct dm_bio_prison_cell *cell)
 {
-        struct pool *pool = tc->pool;
-        unsigned long flags;
+        struct remap_info *info = context;
+        struct bio *bio;
 
-        spin_lock_irqsave(&tc->lock, flags);
-        cell_release_no_holder(pool, cell, &tc->deferred_bio_list);
-        spin_unlock_irqrestore(&tc->lock, flags);
+        while ((bio = bio_list_pop(&cell->bios))) {
+                if (bio->bi_rw & (REQ_DISCARD | REQ_FLUSH | REQ_FUA))
+                        bio_list_add(&info->defer_bios, bio);
+                else {
+                        inc_all_io_entry(info->tc->pool, bio);
 
-        wake_worker(pool);
+                        /*
+                         * We can't issue the bios with the bio prison lock
+                         * held, so we add them to a list to issue on
+                         * return from this function.
+                         */
+                        bio_list_add(&info->issue_bios, bio);
+                }
+        }
+}
+
+static void inc_remap_and_issue_cell(struct thin_c *tc,
+                                     struct dm_bio_prison_cell *cell,
+                                     dm_block_t block)
+{
+        struct bio *bio;
+        struct remap_info info;
+
+        info.tc = tc;
+        bio_list_init(&info.defer_bios);
+        bio_list_init(&info.issue_bios);
+
+        /*
+         * We have to be careful to inc any bios we're about to issue
+         * before the cell is released, and avoid a race with new bios
+         * being added to the cell.
+         */
+        cell_visit_release(tc->pool, __inc_remap_and_issue_cell,
+                           &info, cell);
+
+        while ((bio = bio_list_pop(&info.defer_bios)))
+                thin_defer_bio(tc, bio);
+
+        while ((bio = bio_list_pop(&info.issue_bios)))
+                remap_and_issue(info.tc, bio, block);
 }
 
 static void process_prepared_mapping_fail(struct dm_thin_new_mapping *m)
@@ -706,10 +838,13 @@ static void process_prepared_mapping(struct dm_thin_new_mapping *m)
          * the bios in the cell.
          */
         if (bio) {
-                cell_defer_no_holder(tc, m->cell);
+                inc_remap_and_issue_cell(tc, m->cell, m->data_block);
                 bio_endio(bio, 0);
-        } else
-                cell_defer(tc, m->cell);
+        } else {
+                inc_all_io_entry(tc->pool, m->cell->holder);
+                remap_and_issue(tc, m->cell->holder, m->data_block);
+                inc_remap_and_issue_cell(tc, m->cell, m->data_block);
+        }
 
 out:
         list_del(&m->list);
@@ -842,6 +977,20 @@ static void ll_zero(struct thin_c *tc, struct dm_thin_new_mapping *m,
         }
 }
 
+static void remap_and_issue_overwrite(struct thin_c *tc, struct bio *bio,
+                                      dm_block_t data_block,
+                                      struct dm_thin_new_mapping *m)
+{
+        struct pool *pool = tc->pool;
+        struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
+
+        h->overwrite_mapping = m;
+        m->bio = bio;
+        save_and_set_endio(bio, &m->saved_bi_end_io, overwrite_endio);
+        inc_all_io_entry(pool, bio);
+        remap_and_issue(tc, bio, data_block);
+}
+
 /*
  * A partial copy also needs to zero the uncopied region.
  */
@@ -876,15 +1025,9 @@ static void schedule_copy(struct thin_c *tc, dm_block_t virt_block,
          * If the whole block of data is being overwritten, we can issue the
          * bio immediately. Otherwise we use kcopyd to clone the data first.
          */
-        if (io_overwrites_block(pool, bio)) {
-                struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
-
-                h->overwrite_mapping = m;
-                m->bio = bio;
-                save_and_set_endio(bio, &m->saved_bi_end_io, overwrite_endio);
-                inc_all_io_entry(pool, bio);
-                remap_and_issue(tc, bio, data_dest);
-        } else {
+        if (io_overwrites_block(pool, bio))
+                remap_and_issue_overwrite(tc, bio, data_dest, m);
+        else {
                 struct dm_io_region from, to;
 
                 from.bdev = origin->bdev;
@@ -953,16 +1096,10 @@ static void schedule_zero(struct thin_c *tc, dm_block_t virt_block,
         if (!pool->pf.zero_new_blocks)
                 process_prepared_mapping(m);
 
-        else if (io_overwrites_block(pool, bio)) {
-                struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
-
-                h->overwrite_mapping = m;
-                m->bio = bio;
-                save_and_set_endio(bio, &m->saved_bi_end_io, overwrite_endio);
-                inc_all_io_entry(pool, bio);
-                remap_and_issue(tc, bio, data_block);
+        else if (io_overwrites_block(pool, bio))
+                remap_and_issue_overwrite(tc, bio, data_block, m);
 
-        } else
+        else
                 ll_zero(tc, m,
                         data_block * pool->sectors_per_block,
                         (data_block + 1) * pool->sectors_per_block);
@@ -1134,29 +1271,25 @@ static void retry_bios_on_resume(struct pool *pool, struct dm_bio_prison_cell *c
         bio_list_init(&bios);
         cell_release(pool, cell, &bios);
 
-        error = should_error_unserviceable_bio(pool);
-        if (error)
-                while ((bio = bio_list_pop(&bios)))
-                        bio_endio(bio, error);
-        else
-                while ((bio = bio_list_pop(&bios)))
-                        retry_on_resume(bio);
+        while ((bio = bio_list_pop(&bios)))
+                retry_on_resume(bio);
 }
 
-static void process_discard(struct thin_c *tc, struct bio *bio)
+static void process_discard_cell(struct thin_c *tc, struct dm_bio_prison_cell *cell)
 {
         int r;
-        unsigned long flags;
+        struct bio *bio = cell->holder;
         struct pool *pool = tc->pool;
-        struct dm_bio_prison_cell *cell, *cell2;
-        struct dm_cell_key key, key2;
+        struct dm_bio_prison_cell *cell2;
+        struct dm_cell_key key2;
         dm_block_t block = get_bio_block(tc, bio);
         struct dm_thin_lookup_result lookup_result;
         struct dm_thin_new_mapping *m;
 
-        build_virtual_key(tc->td, block, &key);
-        if (bio_detain(tc->pool, &key, bio, &cell))
+        if (tc->requeue_mode) {
+                cell_requeue(pool, cell);
                 return;
+        }
 
         r = dm_thin_find_block(tc->td, block, 1, &lookup_result);
         switch (r) {
@@ -1187,12 +1320,9 @@ static void process_discard(struct thin_c *tc, struct bio *bio)
                         m->cell2 = cell2;
                         m->bio = bio;
 
-                        if (!dm_deferred_set_add_work(pool->all_io_ds, &m->list)) {
-                                spin_lock_irqsave(&pool->lock, flags);
-                                list_add_tail(&m->list, &pool->prepared_discards);
-                                spin_unlock_irqrestore(&pool->lock, flags);
-                                wake_worker(pool);
-                        }
+                        if (!dm_deferred_set_add_work(pool->all_io_ds, &m->list))
+                                pool->process_prepared_discard(m);
+
                 } else {
                         inc_all_io_entry(pool, bio);
                         cell_defer_no_holder(tc, cell);
@@ -1227,6 +1357,19 @@ static void process_discard(struct thin_c *tc, struct bio *bio)
         }
 }
 
+static void process_discard_bio(struct thin_c *tc, struct bio *bio)
+{
+        struct dm_bio_prison_cell *cell;
+        struct dm_cell_key key;
+        dm_block_t block = get_bio_block(tc, bio);
+
+        build_virtual_key(tc->td, block, &key);
+        if (bio_detain(tc->pool, &key, bio, &cell))
+                return;
+
+        process_discard_cell(tc, cell);
+}
+
 static void break_sharing(struct thin_c *tc, struct bio *bio, dm_block_t block,
                           struct dm_cell_key *key,
                           struct dm_thin_lookup_result *lookup_result,
@@ -1255,11 +1398,53 @@ static void break_sharing(struct thin_c *tc, struct bio *bio, dm_block_t block,
         }
 }
 
+static void __remap_and_issue_shared_cell(void *context,
+                                          struct dm_bio_prison_cell *cell)
+{
+        struct remap_info *info = context;
+        struct bio *bio;
+
+        while ((bio = bio_list_pop(&cell->bios))) {
+                if ((bio_data_dir(bio) == WRITE) ||
+                    (bio->bi_rw & (REQ_DISCARD | REQ_FLUSH | REQ_FUA)))
+                        bio_list_add(&info->defer_bios, bio);
+                else {
+                        struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));;
+
+                        h->shared_read_entry = dm_deferred_entry_inc(info->tc->pool->shared_read_ds);
+                        inc_all_io_entry(info->tc->pool, bio);
+                        bio_list_add(&info->issue_bios, bio);
+                }
+        }
+}
+
+static void remap_and_issue_shared_cell(struct thin_c *tc,
+                                        struct dm_bio_prison_cell *cell,
+                                        dm_block_t block)
+{
+        struct bio *bio;
+        struct remap_info info;
+
+        info.tc = tc;
+        bio_list_init(&info.defer_bios);
+        bio_list_init(&info.issue_bios);
+
+        cell_visit_release(tc->pool, __remap_and_issue_shared_cell,
+                           &info, cell);
+
+        while ((bio = bio_list_pop(&info.defer_bios)))
+                thin_defer_bio(tc, bio);
+
+        while ((bio = bio_list_pop(&info.issue_bios)))
+                remap_and_issue(tc, bio, block);
+}
+
 static void process_shared_bio(struct thin_c *tc, struct bio *bio,
                                dm_block_t block,
-                               struct dm_thin_lookup_result *lookup_result)
+                               struct dm_thin_lookup_result *lookup_result,
+                               struct dm_bio_prison_cell *virt_cell)
 {
-        struct dm_bio_prison_cell *cell;
+        struct dm_bio_prison_cell *data_cell;
         struct pool *pool = tc->pool;
         struct dm_cell_key key;
 
@@ -1268,19 +1453,23 @@ static void process_shared_bio(struct thin_c *tc, struct bio *bio,
          * of being broken so we have nothing further to do here.
          */
         build_data_key(tc->td, lookup_result->block, &key);
-        if (bio_detain(pool, &key, bio, &cell))
+        if (bio_detain(pool, &key, bio, &data_cell)) {
+                cell_defer_no_holder(tc, virt_cell);
                 return;
+        }
 
-        if (bio_data_dir(bio) == WRITE && bio->bi_iter.bi_size)
-                break_sharing(tc, bio, block, &key, lookup_result, cell);
-        else {
+        if (bio_data_dir(bio) == WRITE && bio->bi_iter.bi_size) {
+                break_sharing(tc, bio, block, &key, lookup_result, data_cell);
+                cell_defer_no_holder(tc, virt_cell);
+        } else {
                 struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
 
                 h->shared_read_entry = dm_deferred_entry_inc(pool->shared_read_ds);
                 inc_all_io_entry(pool, bio);
-                cell_defer_no_holder(tc, cell);
-
                 remap_and_issue(tc, bio, lookup_result->block);
+
+                remap_and_issue_shared_cell(tc, data_cell, lookup_result->block);
+                remap_and_issue_shared_cell(tc, virt_cell, lookup_result->block);
         }
 }
 
@@ -1333,34 +1522,28 @@ static void provision_block(struct thin_c *tc, struct bio *bio, dm_block_t block
         }
 }
 
-static void process_bio(struct thin_c *tc, struct bio *bio)
+static void process_cell(struct thin_c *tc, struct dm_bio_prison_cell *cell)
 {
         int r;
         struct pool *pool = tc->pool;
+        struct bio *bio = cell->holder;
         dm_block_t block = get_bio_block(tc, bio);
-        struct dm_bio_prison_cell *cell;
-        struct dm_cell_key key;
         struct dm_thin_lookup_result lookup_result;
 
-        /*
-         * If cell is already occupied, then the block is already
-         * being provisioned so we have nothing further to do here.
-         */
-        build_virtual_key(tc->td, block, &key);
-        if (bio_detain(pool, &key, bio, &cell))
+        if (tc->requeue_mode) {
+                cell_requeue(pool, cell);
                 return;
+        }
 
         r = dm_thin_find_block(tc->td, block, 1, &lookup_result);
         switch (r) {
         case 0:
-                if (lookup_result.shared) {
-                        process_shared_bio(tc, bio, block, &lookup_result);
-                        cell_defer_no_holder(tc, cell); /* FIXME: pass this cell into process_shared? */
-                } else {
+                if (lookup_result.shared)
+                        process_shared_bio(tc, bio, block, &lookup_result, cell);
+                else {
                         inc_all_io_entry(pool, bio);
-                        cell_defer_no_holder(tc, cell);
-
                         remap_and_issue(tc, bio, lookup_result.block);
+                        inc_remap_and_issue_cell(tc, cell, lookup_result.block);
                 }
                 break;
 
@@ -1394,7 +1577,26 @@ static void process_bio(struct thin_c *tc, struct bio *bio)
         }
 }
 
-static void process_bio_read_only(struct thin_c *tc, struct bio *bio)
+static void process_bio(struct thin_c *tc, struct bio *bio)
+{
+        struct pool *pool = tc->pool;
+        dm_block_t block = get_bio_block(tc, bio);
+        struct dm_bio_prison_cell *cell;
+        struct dm_cell_key key;
+
+        /*
+         * If cell is already occupied, then the block is already
+         * being provisioned so we have nothing further to do here.
+         */
+        build_virtual_key(tc->td, block, &key);
+        if (bio_detain(pool, &key, bio, &cell))
+                return;
+
+        process_cell(tc, cell);
+}
+
+static void __process_bio_read_only(struct thin_c *tc, struct bio *bio,
+                                    struct dm_bio_prison_cell *cell)
 {
         int r;
         int rw = bio_data_dir(bio);
@@ -1404,15 +1606,21 @@ static void process_bio_read_only(struct thin_c *tc, struct bio *bio)
         r = dm_thin_find_block(tc->td, block, 1, &lookup_result);
         switch (r) {
         case 0:
-                if (lookup_result.shared && (rw == WRITE) && bio->bi_iter.bi_size)
+                if (lookup_result.shared && (rw == WRITE) && bio->bi_iter.bi_size) {
                         handle_unserviceable_bio(tc->pool, bio);
-                else {
+                        if (cell)
+                                cell_defer_no_holder(tc, cell);
+                } else {
                         inc_all_io_entry(tc->pool, bio);
                         remap_and_issue(tc, bio, lookup_result.block);
+                        if (cell)
+                                inc_remap_and_issue_cell(tc, cell, lookup_result.block);
                 }
                 break;
 
         case -ENODATA:
+                if (cell)
+                        cell_defer_no_holder(tc, cell);
                 if (rw != READ) {
                         handle_unserviceable_bio(tc->pool, bio);
                         break;
@@ -1431,11 +1639,23 @@ static void process_bio_read_only(struct thin_c *tc, struct bio *bio)
         default:
                 DMERR_LIMIT("%s: dm_thin_find_block() failed: error = %d",
                             __func__, r);
+                if (cell)
+                        cell_defer_no_holder(tc, cell);
                 bio_io_error(bio);
                 break;
         }
 }
 
+static void process_bio_read_only(struct thin_c *tc, struct bio *bio)
+{
+        __process_bio_read_only(tc, bio, NULL);
+}
+
+static void process_cell_read_only(struct thin_c *tc, struct dm_bio_prison_cell *cell)
+{
+        __process_bio_read_only(tc, cell->holder, cell);
+}
+
 static void process_bio_success(struct thin_c *tc, struct bio *bio)
 {
         bio_endio(bio, 0);
@@ -1446,6 +1666,16 @@ static void process_bio_fail(struct thin_c *tc, struct bio *bio)
         bio_io_error(bio);
 }
 
+static void process_cell_success(struct thin_c *tc, struct dm_bio_prison_cell *cell)
+{
+        cell_success(tc->pool, cell);
+}
+
+static void process_cell_fail(struct thin_c *tc, struct dm_bio_prison_cell *cell)
+{
+        cell_error(tc->pool, cell);
+}
+
 /*
  * FIXME: should we also commit due to size of transaction, measured in
  * metadata blocks?
@@ -1527,9 +1757,10 @@ static void process_thin_deferred_bios(struct thin_c *tc)
         struct bio *bio;
         struct bio_list bios;
         struct blk_plug plug;
+        unsigned count = 0;
 
         if (tc->requeue_mode) {
-                requeue_bio_list(tc, &tc->deferred_bio_list);
+                error_thin_bio_list(tc, &tc->deferred_bio_list, DM_ENDIO_REQUEUE);
                 return;
         }
 
@@ -1568,10 +1799,97 @@ static void process_thin_deferred_bios(struct thin_c *tc)
                         pool->process_discard(tc, bio);
                 else
                         pool->process_bio(tc, bio);
+
+                if ((count++ & 127) == 0) {
+                        throttle_work_update(&pool->throttle);
+                        dm_pool_issue_prefetches(pool->pmd);
+                }
         }
         blk_finish_plug(&plug);
 }
 
+static int cmp_cells(const void *lhs, const void *rhs)
+{
+        struct dm_bio_prison_cell *lhs_cell = *((struct dm_bio_prison_cell **) lhs);
+        struct dm_bio_prison_cell *rhs_cell = *((struct dm_bio_prison_cell **) rhs);
+
+        BUG_ON(!lhs_cell->holder);
+        BUG_ON(!rhs_cell->holder);
+
+        if (lhs_cell->holder->bi_iter.bi_sector < rhs_cell->holder->bi_iter.bi_sector)
+                return -1;
+
+        if (lhs_cell->holder->bi_iter.bi_sector > rhs_cell->holder->bi_iter.bi_sector)
+                return 1;
+
+        return 0;
+}
+
+static unsigned sort_cells(struct pool *pool, struct list_head *cells)
+{
+        unsigned count = 0;
+        struct dm_bio_prison_cell *cell, *tmp;
+
+        list_for_each_entry_safe(cell, tmp, cells, user_list) {
+                if (count >= CELL_SORT_ARRAY_SIZE)
+                        break;
+
+                pool->cell_sort_array[count++] = cell;
+                list_del(&cell->user_list);
+        }
+
+        sort(pool->cell_sort_array, count, sizeof(cell), cmp_cells, NULL);
+
+        return count;
+}
+
+static void process_thin_deferred_cells(struct thin_c *tc)
+{
+        struct pool *pool = tc->pool;
+        unsigned long flags;
+        struct list_head cells;
+        struct dm_bio_prison_cell *cell;
+        unsigned i, j, count;
+
+        INIT_LIST_HEAD(&cells);
+
+        spin_lock_irqsave(&tc->lock, flags);
+        list_splice_init(&tc->deferred_cells, &cells);
+        spin_unlock_irqrestore(&tc->lock, flags);
+
+        if (list_empty(&cells))
+                return;
+
+        do {
+                count = sort_cells(tc->pool, &cells);
+
+                for (i = 0; i < count; i++) {
+                        cell = pool->cell_sort_array[i];
+                        BUG_ON(!cell->holder);
+
+                        /*
+                         * If we've got no free new_mapping structs, and processing
+                         * this bio might require one, we pause until there are some
+                         * prepared mappings to process.
+                         */
+                        if (ensure_next_mapping(pool)) {
+                                for (j = i; j < count; j++)
+                                        list_add(&pool->cell_sort_array[j]->user_list, &cells);
+
+                                spin_lock_irqsave(&tc->lock, flags);
+                                list_splice(&cells, &tc->deferred_cells);
+                                spin_unlock_irqrestore(&tc->lock, flags);
+                                return;
+                        }
+
+                        if (cell->holder->bi_rw & REQ_DISCARD)
+                                pool->process_discard_cell(tc, cell);
+                        else
+                                pool->process_cell(tc, cell);
+                }
+        } while (!list_empty(&cells));
+}
+
 static void thin_get(struct thin_c *tc);
 static void thin_put(struct thin_c *tc);
 
@@ -1620,6 +1938,7 @@ static void process_deferred_bios(struct pool *pool)
 
         tc = get_first_thin(pool);
         while (tc) {
+                process_thin_deferred_cells(tc);
                 process_thin_deferred_bios(tc);
                 tc = get_next_thin(pool, tc);
         }
@@ -1653,9 +1972,15 @@ static void do_worker(struct work_struct *ws)
 {
         struct pool *pool = container_of(ws, struct pool, worker);
 
+        throttle_work_start(&pool->throttle);
+        dm_pool_issue_prefetches(pool->pmd);
+        throttle_work_update(&pool->throttle);
         process_prepared(pool, &pool->prepared_mappings, &pool->process_prepared_mapping);
+        throttle_work_update(&pool->throttle);
         process_prepared(pool, &pool->prepared_discards, &pool->process_prepared_discard);
+        throttle_work_update(&pool->throttle);
         process_deferred_bios(pool);
+        throttle_work_complete(&pool->throttle);
 }
 
 /*
@@ -1792,6 +2117,8 @@ static void set_pool_mode(struct pool *pool, enum pool_mode new_mode)
                 dm_pool_metadata_read_only(pool->pmd);
                 pool->process_bio = process_bio_fail;
                 pool->process_discard = process_bio_fail;
+                pool->process_cell = process_cell_fail;
+                pool->process_discard_cell = process_cell_fail;
                 pool->process_prepared_mapping = process_prepared_mapping_fail;
                 pool->process_prepared_discard = process_prepared_discard_fail;
 
@@ -1804,6 +2131,8 @@ static void set_pool_mode(struct pool *pool, enum pool_mode new_mode)
                 dm_pool_metadata_read_only(pool->pmd);
                 pool->process_bio = process_bio_read_only;
                 pool->process_discard = process_bio_success;
+                pool->process_cell = process_cell_read_only;
+                pool->process_discard_cell = process_cell_success;
                 pool->process_prepared_mapping = process_prepared_mapping_fail;
                 pool->process_prepared_discard = process_prepared_discard_passdown;
 
@@ -1822,7 +2151,9 @@ static void set_pool_mode(struct pool *pool, enum pool_mode new_mode)
                 if (old_mode != new_mode)
                         notify_of_pool_mode_change(pool, "out-of-data-space");
                 pool->process_bio = process_bio_read_only;
-                pool->process_discard = process_discard;
+                pool->process_discard = process_discard_bio;
+                pool->process_cell = process_cell_read_only;
+                pool->process_discard_cell = process_discard_cell;
                 pool->process_prepared_mapping = process_prepared_mapping;
                 pool->process_prepared_discard = process_prepared_discard_passdown;
 
@@ -1835,7 +2166,9 @@ static void set_pool_mode(struct pool *pool, enum pool_mode new_mode)
                         notify_of_pool_mode_change(pool, "write");
                 dm_pool_metadata_read_write(pool->pmd);
                 pool->process_bio = process_bio;
-                pool->process_discard = process_discard;
+                pool->process_discard = process_discard_bio;
+                pool->process_cell = process_cell;
+                pool->process_discard_cell = process_discard_cell;
                 pool->process_prepared_mapping = process_prepared_mapping;
                 pool->process_prepared_discard = process_prepared_discard;
                 break;
@@ -1895,6 +2228,29 @@ static void thin_defer_bio(struct thin_c *tc, struct bio *bio)
         wake_worker(pool);
 }
 
+static void thin_defer_bio_with_throttle(struct thin_c *tc, struct bio *bio)
+{
+        struct pool *pool = tc->pool;
+
+        throttle_lock(&pool->throttle);
+        thin_defer_bio(tc, bio);
+        throttle_unlock(&pool->throttle);
+}
+
+static void thin_defer_cell(struct thin_c *tc, struct dm_bio_prison_cell *cell)
+{
+        unsigned long flags;
+        struct pool *pool = tc->pool;
+
+        throttle_lock(&pool->throttle);
+        spin_lock_irqsave(&tc->lock, flags);
+        list_add_tail(&cell->user_list, &tc->deferred_cells);
+        spin_unlock_irqrestore(&tc->lock, flags);
+        throttle_unlock(&pool->throttle);
+
+        wake_worker(pool);
+}
+
 static void thin_hook_bio(struct thin_c *tc, struct bio *bio)
 {
         struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
@@ -1915,8 +2271,7 @@ static int thin_bio_map(struct dm_target *ti, struct bio *bio)
         dm_block_t block = get_bio_block(tc, bio);
         struct dm_thin_device *td = tc->td;
         struct dm_thin_lookup_result result;
-        struct dm_bio_prison_cell cell1, cell2;
-        struct dm_bio_prison_cell *cell_result;
+        struct dm_bio_prison_cell *virt_cell, *data_cell;
         struct dm_cell_key key;
 
         thin_hook_bio(tc, bio);
@@ -1932,7 +2287,7 @@ static int thin_bio_map(struct dm_target *ti, struct bio *bio)
         }
 
         if (bio->bi_rw & (REQ_DISCARD | REQ_FLUSH | REQ_FUA)) {
-                thin_defer_bio(tc, bio);
+                thin_defer_bio_with_throttle(tc, bio);
                 return DM_MAPIO_SUBMITTED;
         }
 
@@ -1941,7 +2296,7 @@ static int thin_bio_map(struct dm_target *ti, struct bio *bio)
          * there's a race with discard.
          */
         build_virtual_key(tc->td, block, &key);
-        if (dm_bio_detain(tc->pool->prison, &key, bio, &cell1, &cell_result))
+        if (bio_detain(tc->pool, &key, bio, &virt_cell))
                 return DM_MAPIO_SUBMITTED;
 
         r = dm_thin_find_block(td, block, 0, &result);
@@ -1966,20 +2321,19 @@ static int thin_bio_map(struct dm_target *ti, struct bio *bio)
                          * More distant ancestors are irrelevant. The
                          * shared flag will be set in their case.
                          */
-                        thin_defer_bio(tc, bio);
-                        cell_defer_no_holder_no_free(tc, &cell1);
+                        thin_defer_cell(tc, virt_cell);
                         return DM_MAPIO_SUBMITTED;
                 }
 
                 build_data_key(tc->td, result.block, &key);
-                if (dm_bio_detain(tc->pool->prison, &key, bio, &cell2, &cell_result)) {
-                        cell_defer_no_holder_no_free(tc, &cell1);
+                if (bio_detain(tc->pool, &key, bio, &data_cell)) {
+                        cell_defer_no_holder(tc, virt_cell);
                         return DM_MAPIO_SUBMITTED;
                 }
 
                 inc_all_io_entry(tc->pool, bio);
-                cell_defer_no_holder_no_free(tc, &cell2);
-                cell_defer_no_holder_no_free(tc, &cell1);
+                cell_defer_no_holder(tc, data_cell);
+                cell_defer_no_holder(tc, virt_cell);
 
                 remap(tc, bio, result.block);
                 return DM_MAPIO_REMAPPED;
@@ -1991,18 +2345,13 @@ static int thin_bio_map(struct dm_target *ti, struct bio *bio)
                          * of doing so.
                          */
                         handle_unserviceable_bio(tc->pool, bio);
-                        cell_defer_no_holder_no_free(tc, &cell1);
+                        cell_defer_no_holder(tc, virt_cell);
                         return DM_MAPIO_SUBMITTED;
                 }
                 /* fall through */
 
         case -EWOULDBLOCK:
-                /*
-                 * In future, the failed dm_thin_find_block above could
-                 * provide the hint to load the metadata into cache.
-                 */
-                thin_defer_bio(tc, bio);
-                cell_defer_no_holder_no_free(tc, &cell1);
+                thin_defer_cell(tc, virt_cell);
                 return DM_MAPIO_SUBMITTED;
 
         default:
@@ -2012,7 +2361,7 @@ static int thin_bio_map(struct dm_target *ti, struct bio *bio)
                  * pool is switched to fail-io mode.
                  */
                 bio_io_error(bio);
-                cell_defer_no_holder_no_free(tc, &cell1);
+                cell_defer_no_holder(tc, virt_cell);
                 return DM_MAPIO_SUBMITTED;
         }
 }
@@ -2193,7 +2542,7 @@ static struct pool *pool_create(struct mapped_device *pool_md,
                 pool->sectors_per_block_shift = __ffs(block_size);
         pool->low_water_blocks = 0;
         pool_features_init(&pool->pf);
-        pool->prison = dm_bio_prison_create(PRISON_CELLS);
+        pool->prison = dm_bio_prison_create();
         if (!pool->prison) {
                 *error = "Error creating pool's bio prison";
                 err_p = ERR_PTR(-ENOMEM);
@@ -2219,6 +2568,7 @@ static struct pool *pool_create(struct mapped_device *pool_md,
                 goto bad_wq;
         }
 
+        throttle_init(&pool->throttle);
         INIT_WORK(&pool->worker, do_worker);
         INIT_DELAYED_WORK(&pool->waker, do_waker);
         INIT_DELAYED_WORK(&pool->no_space_timeout, do_no_space_timeout);
@@ -2228,6 +2578,7 @@ static struct pool *pool_create(struct mapped_device *pool_md,
         INIT_LIST_HEAD(&pool->prepared_discards);
         INIT_LIST_HEAD(&pool->active_thins);
         pool->low_water_triggered = false;
+        pool->suspended = true;
 
         pool->shared_read_ds = dm_deferred_set_create();
         if (!pool->shared_read_ds) {
@@ -2764,20 +3115,77 @@ static int pool_preresume(struct dm_target *ti)
         return 0;
 }
 
+static void pool_suspend_active_thins(struct pool *pool)
+{
+        struct thin_c *tc;
+
+        /* Suspend all active thin devices */
+        tc = get_first_thin(pool);
+        while (tc) {
+                dm_internal_suspend_noflush(tc->thin_md);
+                tc = get_next_thin(pool, tc);
+        }
+}
+
+static void pool_resume_active_thins(struct pool *pool)
+{
+        struct thin_c *tc;
+
+        /* Resume all active thin devices */
+        tc = get_first_thin(pool);
+        while (tc) {
+                dm_internal_resume(tc->thin_md);
+                tc = get_next_thin(pool, tc);
+        }
+}
+
 static void pool_resume(struct dm_target *ti)
 {
         struct pool_c *pt = ti->private;
         struct pool *pool = pt->pool;
         unsigned long flags;
 
+        /*
+         * Must requeue active_thins' bios and then resume
+         * active_thins _before_ clearing 'suspend' flag.
+         */
+        requeue_bios(pool);
+        pool_resume_active_thins(pool);
+
         spin_lock_irqsave(&pool->lock, flags);
         pool->low_water_triggered = false;
+        pool->suspended = false;
         spin_unlock_irqrestore(&pool->lock, flags);
-        requeue_bios(pool);
 
         do_waker(&pool->waker.work);
 }
 
+static void pool_presuspend(struct dm_target *ti)
+{
+        struct pool_c *pt = ti->private;
+        struct pool *pool = pt->pool;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pool->lock, flags);
+        pool->suspended = true;
+        spin_unlock_irqrestore(&pool->lock, flags);
+
+        pool_suspend_active_thins(pool);
+}
+
+static void pool_presuspend_undo(struct dm_target *ti)
+{
+        struct pool_c *pt = ti->private;
+        struct pool *pool = pt->pool;
+        unsigned long flags;
+
+        pool_resume_active_thins(pool);
+
+        spin_lock_irqsave(&pool->lock, flags);
+        pool->suspended = false;
+        spin_unlock_irqrestore(&pool->lock, flags);
+}
+
 static void pool_postsuspend(struct dm_target *ti)
 {
         struct pool_c *pt = ti->private;
@@ -2949,7 +3357,6 @@ static int process_release_metadata_snap_mesg(unsigned argc, char **argv, struct
  *   create_thin        <dev_id>
  *   create_snap        <dev_id> <origin_id>
  *   delete             <dev_id>
- *   trim               <dev_id> <new_size_in_sectors>
  *   set_transaction_id <current_trans_id> <new_trans_id>
  *   reserve_metadata_snap
  *   release_metadata_snap
@@ -3177,15 +3584,35 @@ static void pool_io_hints(struct dm_target *ti, struct queue_limits *limits)
 {
         struct pool_c *pt = ti->private;
         struct pool *pool = pt->pool;
-        uint64_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;
+        sector_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;
+
+        /*
+         * If max_sectors is smaller than pool->sectors_per_block adjust it
+         * to the highest possible power-of-2 factor of pool->sectors_per_block.
+         * This is especially beneficial when the pool's data device is a RAID
+         * device that has a full stripe width that matches pool->sectors_per_block
+         * -- because even though partial RAID stripe-sized IOs will be issued to a
+         *    single RAID stripe; when aggregated they will end on a full RAID stripe
+         *    boundary.. which avoids additional partial RAID stripe writes cascading
+         */
+        if (limits->max_sectors < pool->sectors_per_block) {
+                while (!is_factor(pool->sectors_per_block, limits->max_sectors)) {
+                        if ((limits->max_sectors & (limits->max_sectors - 1)) == 0)
+                                limits->max_sectors--;
+                        limits->max_sectors = rounddown_pow_of_two(limits->max_sectors);
+                }
+        }
 
         /*
          * If the system-determined stacked limits are compatible with the
          * pool's blocksize (io_opt is a factor) do not override them.
          */
         if (io_opt_sectors < pool->sectors_per_block ||
-            do_div(io_opt_sectors, pool->sectors_per_block)) {
-                blk_limits_io_min(limits, pool->sectors_per_block << SECTOR_SHIFT);
+            !is_factor(io_opt_sectors, pool->sectors_per_block)) {
+                if (is_factor(pool->sectors_per_block, limits->max_sectors))
+                        blk_limits_io_min(limits, limits->max_sectors << SECTOR_SHIFT);
+                else
+                        blk_limits_io_min(limits, pool->sectors_per_block << SECTOR_SHIFT);
                 blk_limits_io_opt(limits, pool->sectors_per_block << SECTOR_SHIFT);
         }
 
@@ -3214,11 +3641,13 @@ static struct target_type pool_target = {
         .name = "thin-pool",
         .features = DM_TARGET_SINGLETON | DM_TARGET_ALWAYS_WRITEABLE |
                     DM_TARGET_IMMUTABLE,
-        .version = {1, 13, 0},
+        .version = {1, 14, 0},
         .module = THIS_MODULE,
         .ctr = pool_ctr,
         .dtr = pool_dtr,
         .map = pool_map,
+        .presuspend = pool_presuspend,
+        .presuspend_undo = pool_presuspend_undo,
         .postsuspend = pool_postsuspend,
         .preresume = pool_preresume,
         .resume = pool_resume,
@@ -3248,14 +3677,14 @@ static void thin_dtr(struct dm_target *ti)
         struct thin_c *tc = ti->private;
         unsigned long flags;
 
-        thin_put(tc);
-        wait_for_completion(&tc->can_destroy);
-
         spin_lock_irqsave(&tc->pool->lock, flags);
         list_del_rcu(&tc->list);
         spin_unlock_irqrestore(&tc->pool->lock, flags);
         synchronize_rcu();
 
+        thin_put(tc);
+        wait_for_completion(&tc->can_destroy);
+
         mutex_lock(&dm_thin_pool_table.mutex);
 
         __pool_dec(tc->pool);
@@ -3302,7 +3731,9 @@ static int thin_ctr(struct dm_target *ti, unsigned argc, char **argv)
                 r = -ENOMEM;
                 goto out_unlock;
         }
+        tc->thin_md = dm_table_get_md(ti->table);
         spin_lock_init(&tc->lock);
+        INIT_LIST_HEAD(&tc->deferred_cells);
         bio_list_init(&tc->deferred_bio_list);
         bio_list_init(&tc->retry_on_resume_list);
         tc->sort_bio_list = RB_ROOT;
@@ -3347,18 +3778,18 @@ static int thin_ctr(struct dm_target *ti, unsigned argc, char **argv)
         if (get_pool_mode(tc->pool) == PM_FAIL) {
                 ti->error = "Couldn't open thin device, Pool is in fail mode";
                 r = -EINVAL;
-                goto bad_thin_open;
+                goto bad_pool;
         }
 
         r = dm_pool_open_thin_device(tc->pool->pmd, tc->dev_id, &tc->td);
         if (r) {
                 ti->error = "Couldn't open thin internal device";
-                goto bad_thin_open;
+                goto bad_pool;
         }
 
         r = dm_set_target_max_io_len(ti, tc->pool->sectors_per_block);
         if (r)
-                goto bad_target_max_io_len;
+                goto bad;
 
         ti->num_flush_bios = 1;
         ti->flush_supported = true;
@@ -3373,14 +3804,16 @@ static int thin_ctr(struct dm_target *ti, unsigned argc, char **argv)
                 ti->split_discard_bios = true;
         }
 
-        dm_put(pool_md);
-
         mutex_unlock(&dm_thin_pool_table.mutex);
 
-        atomic_set(&tc->refcount, 1);
-        init_completion(&tc->can_destroy);
-
         spin_lock_irqsave(&tc->pool->lock, flags);
+        if (tc->pool->suspended) {
+                spin_unlock_irqrestore(&tc->pool->lock, flags);
+                mutex_lock(&dm_thin_pool_table.mutex); /* reacquire for __pool_dec */
+                ti->error = "Unable to activate thin device while pool is suspended";
+                r = -EINVAL;
+                goto bad;
+        }
         list_add_tail_rcu(&tc->list, &tc->pool->active_thins);
         spin_unlock_irqrestore(&tc->pool->lock, flags);
         /*
@@ -3391,11 +3824,16 @@ static int thin_ctr(struct dm_target *ti, unsigned argc, char **argv)
          */
         synchronize_rcu();
 
+        dm_put(pool_md);
+
+        atomic_set(&tc->refcount, 1);
+        init_completion(&tc->can_destroy);
+
         return 0;
 
-bad_target_max_io_len:
+bad:
         dm_pool_close_thin_device(tc->td);
-bad_thin_open:
+bad_pool:
         __pool_dec(tc->pool);
 bad_pool_lookup:
         dm_put(pool_md);
@@ -3541,6 +3979,21 @@ err:
         DMEMIT("Error");
 }
 
+static int thin_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
+                      struct bio_vec *biovec, int max_size)
+{
+        struct thin_c *tc = ti->private;
+        struct request_queue *q = bdev_get_queue(tc->pool_dev->bdev);
+
+        if (!q->merge_bvec_fn)
+                return max_size;
+
+        bvm->bi_bdev = tc->pool_dev->bdev;
+        bvm->bi_sector = dm_target_offset(ti, bvm->bi_sector);
+
+        return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
+}
+
 static int thin_iterate_devices(struct dm_target *ti,
                                 iterate_devices_callout_fn fn, void *data)
 {
@@ -3565,7 +4018,7 @@ static int thin_iterate_devices(struct dm_target *ti,
 
 static struct target_type thin_target = {
         .name = "thin",
-        .version = {1, 13, 0},
+        .version = {1, 14, 0},
         .module = THIS_MODULE,
         .ctr = thin_ctr,
         .dtr = thin_dtr,
@@ -3575,6 +4028,7 @@ static struct target_type thin_target = {
         .presuspend = thin_presuspend,
         .postsuspend = thin_postsuspend,
         .status = thin_status,
+        .merge = thin_merge,
         .iterate_devices = thin_iterate_devices,
 };
 
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 58f3927fd7cc..8f37ed215b19 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -19,6 +19,7 @@
 #include <linux/idr.h>
 #include <linux/hdreg.h>
 #include <linux/delay.h>
+#include <linux/wait.h>
 
 #include <trace/events/block.h>
 
@@ -117,6 +118,7 @@ EXPORT_SYMBOL_GPL(dm_get_rq_mapinfo);
 #define DMF_NOFLUSH_SUSPENDING 5
 #define DMF_MERGE_IS_OPTIONAL 6
 #define DMF_DEFERRED_REMOVE 7
+#define DMF_SUSPENDED_INTERNALLY 8
 
 /*
  * A dummy definition to make RCU happy.
@@ -140,7 +142,7 @@ struct mapped_device {
          * Use dm_get_live_table{_fast} or take suspend_lock for
          * dereference.
          */
-        struct dm_table *map;
+        struct dm_table __rcu *map;
 
         struct list_head table_devices;
         struct mutex table_devices_lock;
@@ -525,14 +527,15 @@ retry:
                 goto out;
 
         tgt = dm_table_get_target(map, 0);
+        if (!tgt->type->ioctl)
+                goto out;
 
         if (dm_suspended_md(md)) {
                 r = -EAGAIN;
                 goto out;
         }
 
-        if (tgt->type->ioctl)
-                r = tgt->type->ioctl(tgt, cmd, arg);
+        r = tgt->type->ioctl(tgt, cmd, arg);
 
 out:
         dm_put_live_table(md, srcu_idx);
@@ -1607,9 +1610,9 @@ static int dm_merge_bvec(struct request_queue *q,
          * Find maximum amount of I/O that won't need splitting
          */
         max_sectors = min(max_io_len(bvm->bi_sector, ti),
-                          (sector_t) BIO_MAX_SECTORS);
+                          (sector_t) queue_max_sectors(q));
         max_size = (max_sectors << SECTOR_SHIFT) - bvm->bi_size;
-        if (max_size < 0)
+        if (unlikely(max_size < 0)) /* this shouldn't _ever_ happen */
                 max_size = 0;
 
         /*
@@ -1621,10 +1624,10 @@ static int dm_merge_bvec(struct request_queue *q,
                 max_size = ti->type->merge(ti, bvm, biovec, max_size);
         /*
          * If the target doesn't support merge method and some of the devices
-         * provided their merge_bvec method (we know this by looking at
-         * queue_max_hw_sectors), then we can't allow bios with multiple vector
-         * entries.  So always set max_size to 0, and the code below allows
-         * just one page.
+         * provided their merge_bvec method (we know this by looking for the
+         * max_hw_sectors that dm_set_device_limits may set), then we can't
+         * allow bios with multiple vector entries.  So always set max_size
+         * to 0, and the code below allows just one page.
          */
         else if (queue_max_hw_sectors(q) <= PAGE_SIZE >> 9)
                 max_size = 0;
@@ -2332,7 +2335,7 @@ static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
 
         merge_is_optional = dm_table_merge_is_optional(t);
 
-        old_map = md->map;
+        old_map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
         rcu_assign_pointer(md->map, t);
         md->immutable_target_type = dm_table_get_immutable_target_type(t);
 
@@ -2341,7 +2344,8 @@ static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
                 set_bit(DMF_MERGE_IS_OPTIONAL, &md->flags);
         else
                 clear_bit(DMF_MERGE_IS_OPTIONAL, &md->flags);
-        dm_sync_table(md);
+        if (old_map)
+                dm_sync_table(md);
 
         return old_map;
 }
@@ -2351,7 +2355,7 @@ static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
  */
 static struct dm_table *__unbind(struct mapped_device *md)
 {
-        struct dm_table *map = md->map;
+        struct dm_table *map = rcu_dereference_protected(md->map, 1);
 
         if (!map)
                 return NULL;
@@ -2716,36 +2720,18 @@ static void unlock_fs(struct mapped_device *md)
 }
 
 /*
- * We need to be able to change a mapping table under a mounted
- * filesystem.  For example we might want to move some data in
- * the background.  Before the table can be swapped with
- * dm_bind_table, dm_suspend must be called to flush any in
- * flight bios and ensure that any further io gets deferred.
- */
-/*
- * Suspend mechanism in request-based dm.
+ * If __dm_suspend returns 0, the device is completely quiescent
+ * now. There is no request-processing activity. All new requests
+ * are being added to md->deferred list.
  *
- * 1. Flush all I/Os by lock_fs() if needed.
- * 2. Stop dispatching any I/O by stopping the request_queue.
- * 3. Wait for all in-flight I/Os to be completed or requeued.
- *
- * To abort suspend, start the request_queue.
+ * Caller must hold md->suspend_lock
  */
-int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
+static int __dm_suspend(struct mapped_device *md, struct dm_table *map,
+                        unsigned suspend_flags, int interruptible)
 {
-        struct dm_table *map = NULL;
-        int r = 0;
-        int do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG ? 1 : 0;
-        int noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG ? 1 : 0;
-
-        mutex_lock(&md->suspend_lock);
-
-        if (dm_suspended_md(md)) {
-                r = -EINVAL;
-                goto out_unlock;
-        }
-
-        map = md->map;
+        bool do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG;
+        bool noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG;
+        int r;
 
         /*
          * DMF_NOFLUSH_SUSPENDING must be set before presuspend.
@@ -2754,7 +2740,10 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
         if (noflush)
                 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
 
-        /* This does not get reverted if there's an error later. */
+        /*
+         * This gets reverted if there's an error later and the targets
+         * provide the .presuspend_undo hook.
+         */
         dm_table_presuspend_targets(map);
 
         /*
@@ -2765,8 +2754,10 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
          */
         if (!noflush && do_lockfs) {
                 r = lock_fs(md);
-                if (r)
-                        goto out_unlock;
+                if (r) {
+                        dm_table_presuspend_undo_targets(map);
+                        return r;
+                }
         }
 
         /*
@@ -2782,7 +2773,8 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
          * flush_workqueue(md->wq).
          */
         set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
-        synchronize_srcu(&md->io_barrier);
+        if (map)
+                synchronize_srcu(&md->io_barrier);
 
         /*
          * Stop md->queue before flushing md->wq in case request-based
@@ -2798,11 +2790,12 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
          * We call dm_wait_for_completion to wait for all existing requests
          * to finish.
          */
-        r = dm_wait_for_completion(md, TASK_INTERRUPTIBLE);
+        r = dm_wait_for_completion(md, interruptible);
 
         if (noflush)
                 clear_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
-        synchronize_srcu(&md->io_barrier);
+        if (map)
+                synchronize_srcu(&md->io_barrier);
 
         /* were we interrupted ? */
         if (r < 0) {
@@ -2812,14 +2805,56 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
                         start_queue(md->queue);
 
                 unlock_fs(md);
-                goto out_unlock; /* pushback list is already flushed, so skip flush */
+                dm_table_presuspend_undo_targets(map);
+                /* pushback list is already flushed, so skip flush */
         }
 
-        /*
-         * If dm_wait_for_completion returned 0, the device is completely
-         * quiescent now. There is no request-processing activity. All new
-         * requests are being added to md->deferred list.
-         */
+        return r;
+}
+
+/*
+ * We need to be able to change a mapping table under a mounted
+ * filesystem.  For example we might want to move some data in
+ * the background.  Before the table can be swapped with
+ * dm_bind_table, dm_suspend must be called to flush any in
+ * flight bios and ensure that any further io gets deferred.
+ */
+/*
+ * Suspend mechanism in request-based dm.
+ *
+ * 1. Flush all I/Os by lock_fs() if needed.
+ * 2. Stop dispatching any I/O by stopping the request_queue.
+ * 3. Wait for all in-flight I/Os to be completed or requeued.
+ *
+ * To abort suspend, start the request_queue.
+ */
+int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
+{
+        struct dm_table *map = NULL;
+        int r = 0;
+
+retry:
+        mutex_lock_nested(&md->suspend_lock, SINGLE_DEPTH_NESTING);
+
+        if (dm_suspended_md(md)) {
+                r = -EINVAL;
+                goto out_unlock;
+        }
+
+        if (dm_suspended_internally_md(md)) {
+                /* already internally suspended, wait for internal resume */
+                mutex_unlock(&md->suspend_lock);
+                r = wait_on_bit(&md->flags, DMF_SUSPENDED_INTERNALLY, TASK_INTERRUPTIBLE);
+                if (r)
+                        return r;
+                goto retry;
+        }
+
+        map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
+
+        r = __dm_suspend(md, map, suspend_flags, TASK_INTERRUPTIBLE);
+        if (r)
+                goto out_unlock;
 
         set_bit(DMF_SUSPENDED, &md->flags);
 
@@ -2830,22 +2865,13 @@ out_unlock:
         return r;
 }
 
-int dm_resume(struct mapped_device *md)
+static int __dm_resume(struct mapped_device *md, struct dm_table *map)
 {
-        int r = -EINVAL;
-        struct dm_table *map = NULL;
-
-        mutex_lock(&md->suspend_lock);
-        if (!dm_suspended_md(md))
-                goto out;
-
-        map = md->map;
-        if (!map || !dm_table_get_size(map))
-                goto out;
-
-        r = dm_table_resume_targets(map);
-        if (r)
-                goto out;
+        if (map) {
+                int r = dm_table_resume_targets(map);
+                if (r)
+                        return r;
+        }
 
         dm_queue_flush(md);
 
@@ -2859,6 +2885,37 @@ int dm_resume(struct mapped_device *md)
 
         unlock_fs(md);
 
+        return 0;
+}
+
+int dm_resume(struct mapped_device *md)
+{
+        int r = -EINVAL;
+        struct dm_table *map = NULL;
+
+retry:
+        mutex_lock_nested(&md->suspend_lock, SINGLE_DEPTH_NESTING);
+
+        if (!dm_suspended_md(md))
+                goto out;
+
+        if (dm_suspended_internally_md(md)) {
+                /* already internally suspended, wait for internal resume */
+                mutex_unlock(&md->suspend_lock);
+                r = wait_on_bit(&md->flags, DMF_SUSPENDED_INTERNALLY, TASK_INTERRUPTIBLE);
+                if (r)
+                        return r;
+                goto retry;
+        }
+
+        map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
+        if (!map || !dm_table_get_size(map))
+                goto out;
+
+        r = __dm_resume(md, map);
+        if (r)
+                goto out;
+
         clear_bit(DMF_SUSPENDED, &md->flags);
 
         r = 0;
@@ -2872,15 +2929,80 @@ out:
  * Internal suspend/resume works like userspace-driven suspend. It waits
  * until all bios finish and prevents issuing new bios to the target drivers.
  * It may be used only from the kernel.
- *
- * Internal suspend holds md->suspend_lock, which prevents interaction with
- * userspace-driven suspend.
  */
 
-void dm_internal_suspend(struct mapped_device *md)
+static void __dm_internal_suspend(struct mapped_device *md, unsigned suspend_flags)
 {
-        mutex_lock(&md->suspend_lock);
+        struct dm_table *map = NULL;
+
+        if (dm_suspended_internally_md(md))
+                return; /* nested internal suspend */
+
+        if (dm_suspended_md(md)) {
+                set_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
+                return; /* nest suspend */
+        }
+
+        map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
+
+        /*
+         * Using TASK_UNINTERRUPTIBLE because only NOFLUSH internal suspend is
+         * supported.  Properly supporting a TASK_INTERRUPTIBLE internal suspend
+         * would require changing .presuspend to return an error -- avoid this
+         * until there is a need for more elaborate variants of internal suspend.
+         */
+        (void) __dm_suspend(md, map, suspend_flags, TASK_UNINTERRUPTIBLE);
+
+        set_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
+
+        dm_table_postsuspend_targets(map);
+}
+
+static void __dm_internal_resume(struct mapped_device *md)
+{
+        if (!dm_suspended_internally_md(md))
+                return; /* resume from nested internal suspend */
+
         if (dm_suspended_md(md))
+                goto done; /* resume from nested suspend */
+
+        /*
+         * NOTE: existing callers don't need to call dm_table_resume_targets
+         * (which may fail -- so best to avoid it for now by passing NULL map)
+         */
+        (void) __dm_resume(md, NULL);
+
+done:
+        clear_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
+        smp_mb__after_atomic();
+        wake_up_bit(&md->flags, DMF_SUSPENDED_INTERNALLY);
+}
+
+void dm_internal_suspend_noflush(struct mapped_device *md)
+{
+        mutex_lock(&md->suspend_lock);
+        __dm_internal_suspend(md, DM_SUSPEND_NOFLUSH_FLAG);
+        mutex_unlock(&md->suspend_lock);
+}
+EXPORT_SYMBOL_GPL(dm_internal_suspend_noflush);
+
+void dm_internal_resume(struct mapped_device *md)
+{
+        mutex_lock(&md->suspend_lock);
+        __dm_internal_resume(md);
+        mutex_unlock(&md->suspend_lock);
+}
+EXPORT_SYMBOL_GPL(dm_internal_resume);
+
+/*
+ * Fast variants of internal suspend/resume hold md->suspend_lock,
+ * which prevents interaction with userspace-driven suspend.
+ */
+
+void dm_internal_suspend_fast(struct mapped_device *md)
+{
+        mutex_lock(&md->suspend_lock);
+        if (dm_suspended_md(md) || dm_suspended_internally_md(md))
                 return;
 
         set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
@@ -2889,9 +3011,9 @@ void dm_internal_suspend(struct mapped_device *md)
         dm_wait_for_completion(md, TASK_UNINTERRUPTIBLE);
 }
 
-void dm_internal_resume(struct mapped_device *md)
+void dm_internal_resume_fast(struct mapped_device *md)
 {
-        if (dm_suspended_md(md))
+        if (dm_suspended_md(md) || dm_suspended_internally_md(md))
                 goto done;
 
         dm_queue_flush(md);
@@ -2977,6 +3099,11 @@ int dm_suspended_md(struct mapped_device *md)
         return test_bit(DMF_SUSPENDED, &md->flags);
 }
 
+int dm_suspended_internally_md(struct mapped_device *md)
+{
+        return test_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
+}
+
 int dm_test_deferred_remove_flag(struct mapped_device *md)
 {
         return test_bit(DMF_DEFERRED_REMOVE, &md->flags);
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 988c7fb7b145..84b0f9e4ba6c 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -65,6 +65,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
                                struct queue_limits *limits);
 struct list_head *dm_table_get_devices(struct dm_table *t);
 void dm_table_presuspend_targets(struct dm_table *t);
+void dm_table_presuspend_undo_targets(struct dm_table *t);
 void dm_table_postsuspend_targets(struct dm_table *t);
 int dm_table_resume_targets(struct dm_table *t);
 int dm_table_any_congested(struct dm_table *t, int bdi_bits);
@@ -129,6 +130,15 @@ int dm_deleting_md(struct mapped_device *md);
 int dm_suspended_md(struct mapped_device *md);
 
 /*
+ * Internal suspend and resume methods.
+ */
+int dm_suspended_internally_md(struct mapped_device *md);
+void dm_internal_suspend_fast(struct mapped_device *md);
+void dm_internal_resume_fast(struct mapped_device *md);
+void dm_internal_suspend_noflush(struct mapped_device *md);
+void dm_internal_resume(struct mapped_device *md);
+
+/*
  * Test if the device is scheduled for deferred remove.
  */
 int dm_test_deferred_remove_flag(struct mapped_device *md);
diff --git a/drivers/md/persistent-data/dm-array.c b/drivers/md/persistent-data/dm-array.c
index 1d75b1dc1e2e..e64b61ad0ef3 100644
--- a/drivers/md/persistent-data/dm-array.c
+++ b/drivers/md/persistent-data/dm-array.c
@@ -645,8 +645,10 @@ static int array_resize(struct dm_array_info *info, dm_block_t root,
         int r;
         struct resize resize;
 
-        if (old_size == new_size)
+        if (old_size == new_size) {
+                *new_root = root;
                 return 0;
+        }
 
         resize.info = info;
         resize.root = root;
diff --git a/drivers/md/persistent-data/dm-space-map-metadata.c b/drivers/md/persistent-data/dm-space-map-metadata.c
index 786b689bdfc7..e8a904298887 100644
--- a/drivers/md/persistent-data/dm-space-map-metadata.c
+++ b/drivers/md/persistent-data/dm-space-map-metadata.c
@@ -564,7 +564,9 @@ static int sm_bootstrap_get_nr_blocks(struct dm_space_map *sm, dm_block_t *count
 {
         struct sm_metadata *smm = container_of(sm, struct sm_metadata, sm);
 
-        return smm->ll.nr_blocks;
+        *count = smm->ll.nr_blocks;
+
+        return 0;
 }
 
 static int sm_bootstrap_get_nr_free(struct dm_space_map *sm, dm_block_t *count)
@@ -581,7 +583,9 @@ static int sm_bootstrap_get_count(struct dm_space_map *sm, dm_block_t b,
 {
         struct sm_metadata *smm = container_of(sm, struct sm_metadata, sm);
 
-        return b < smm->begin ? 1 : 0;
+        *result = (b < smm->begin) ? 1 : 0;
+
+        return 0;
 }
 
 static int sm_bootstrap_count_is_more_than_one(struct dm_space_map *sm,
diff --git a/drivers/md/persistent-data/dm-transaction-manager.c b/drivers/md/persistent-data/dm-transaction-manager.c
index 3bc30a0ae3d6..9cb797d800cf 100644
--- a/drivers/md/persistent-data/dm-transaction-manager.c
+++ b/drivers/md/persistent-data/dm-transaction-manager.c
@@ -10,6 +10,8 @@
 #include "dm-persistent-data-internal.h"
 
 #include <linux/export.h>
+#include <linux/mutex.h>
+#include <linux/hash.h>
 #include <linux/slab.h>
 #include <linux/device-mapper.h>
 
@@ -17,6 +19,61 @@
 
 /*----------------------------------------------------------------*/
 
+#define PREFETCH_SIZE 128
+#define PREFETCH_BITS 7
+#define PREFETCH_SENTINEL ((dm_block_t) -1ULL)
+
+struct prefetch_set {
+        struct mutex lock;
+        dm_block_t blocks[PREFETCH_SIZE];
+};
+
+static unsigned prefetch_hash(dm_block_t b)
+{
+        return hash_64(b, PREFETCH_BITS);
+}
+
+static void prefetch_wipe(struct prefetch_set *p)
+{
+        unsigned i;
+        for (i = 0; i < PREFETCH_SIZE; i++)
+                p->blocks[i] = PREFETCH_SENTINEL;
+}
+
+static void prefetch_init(struct prefetch_set *p)
+{
+        mutex_init(&p->lock);
+        prefetch_wipe(p);
+}
+
+static void prefetch_add(struct prefetch_set *p, dm_block_t b)
+{
+        unsigned h = prefetch_hash(b);
+
+        mutex_lock(&p->lock);
+        if (p->blocks[h] == PREFETCH_SENTINEL)
+                p->blocks[h] = b;
+
+        mutex_unlock(&p->lock);
+}
+
+static void prefetch_issue(struct prefetch_set *p, struct dm_block_manager *bm)
+{
+        unsigned i;
+
+        mutex_lock(&p->lock);
+
+        for (i = 0; i < PREFETCH_SIZE; i++)
+                if (p->blocks[i] != PREFETCH_SENTINEL) {
+                        dm_bm_prefetch(bm, p->blocks[i]);
+                        p->blocks[i] = PREFETCH_SENTINEL;
+                }
+
+        mutex_unlock(&p->lock);
+}
+
+/*----------------------------------------------------------------*/
+
 struct shadow_info {
         struct hlist_node hlist;
         dm_block_t where;
@@ -37,6 +94,8 @@ struct dm_transaction_manager {
 
         spinlock_t lock;
         struct hlist_head buckets[DM_HASH_SIZE];
+
+        struct prefetch_set prefetches;
 };
 
 /*----------------------------------------------------------------*/
@@ -117,6 +176,8 @@ static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
         for (i = 0; i < DM_HASH_SIZE; i++)
                 INIT_HLIST_HEAD(tm->buckets + i);
 
+        prefetch_init(&tm->prefetches);
+
         return tm;
 }
 
@@ -268,8 +329,14 @@ int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
                     struct dm_block_validator *v,
                     struct dm_block **blk)
 {
-        if (tm->is_clone)
-                return dm_bm_read_try_lock(tm->real->bm, b, v, blk);
+        if (tm->is_clone) {
+                int r = dm_bm_read_try_lock(tm->real->bm, b, v, blk);
+
+                if (r == -EWOULDBLOCK)
+                        prefetch_add(&tm->real->prefetches, b);
+
+                return r;
+        }
 
         return dm_bm_read_lock(tm->bm, b, v, blk);
 }
@@ -317,6 +384,12 @@ struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
         return tm->bm;
 }
 
+void dm_tm_issue_prefetches(struct dm_transaction_manager *tm)
+{
+        prefetch_issue(&tm->prefetches, tm->bm);
+}
+EXPORT_SYMBOL_GPL(dm_tm_issue_prefetches);
+
 /*----------------------------------------------------------------*/
 
 static int dm_tm_create_internal(struct dm_block_manager *bm,
diff --git a/drivers/md/persistent-data/dm-transaction-manager.h b/drivers/md/persistent-data/dm-transaction-manager.h
index 2772ed2a781a..2e0d4d66fb1b 100644
--- a/drivers/md/persistent-data/dm-transaction-manager.h
+++ b/drivers/md/persistent-data/dm-transaction-manager.h
@@ -109,6 +109,13 @@ int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm);
 
 /*
+ * If you're using a non-blocking clone the tm will build up a list of
+ * requested blocks that weren't in core.  This call will request those
+ * blocks to be prefetched.
+ */
+void dm_tm_issue_prefetches(struct dm_transaction_manager *tm);
+
+/*
  * A little utility that ties the knot by producing a transaction manager
  * that has a space map managed by the transaction manager...
  *
diff --git a/drivers/media/common/cx2341x.c b/drivers/media/common/cx2341x.c
index be763150b8aa..c07b9db51b05 100644
--- a/drivers/media/common/cx2341x.c
+++ b/drivers/media/common/cx2341x.c
@@ -931,6 +931,35 @@ static void cx2341x_calc_audio_properties(struct cx2341x_mpeg_params *params)
         }
 }
 
+/* Check for correctness of the ctrl's value based on the data from
+   struct v4l2_queryctrl and the available menu items. Note that
+   menu_items may be NULL, in that case it is ignored. */
+static int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
+                const char * const *menu_items)
+{
+        if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
+                return -EINVAL;
+        if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
+                return -EBUSY;
+        if (qctrl->type == V4L2_CTRL_TYPE_STRING)
+                return 0;
+        if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
+            qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
+            qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
+                return 0;
+        if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
+                return -ERANGE;
+        if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
+                if (menu_items[ctrl->value] == NULL ||
+                    menu_items[ctrl->value][0] == '\0')
+                        return -EINVAL;
+        }
+        if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
+                        (ctrl->value & ~qctrl->maximum))
+                return -ERANGE;
+        return 0;
+}
+
 int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params, int busy,
                   struct v4l2_ext_controls *ctrls, unsigned int cmd)
 {
diff --git a/drivers/media/common/saa7146/saa7146_core.c b/drivers/media/common/saa7146/saa7146_core.c
index 4418119cf707..1ff9f5323bc3 100644
--- a/drivers/media/common/saa7146/saa7146_core.c
+++ b/drivers/media/common/saa7146/saa7146_core.c
@@ -71,7 +71,7 @@ static inline int saa7146_wait_for_debi_done_sleep(struct saa7146_dev *dev,
                 if (saa7146_read(dev, MC2) & 2)
                         break;
                 if (err) {
-                        pr_err("%s: %s timed out while waiting for registers getting programmed\n",
+                        pr_debug("%s: %s timed out while waiting for registers getting programmed\n",
                                dev->name, __func__);
                         return -ETIMEDOUT;
                 }
diff --git a/drivers/media/common/siano/smsir.c b/drivers/media/common/siano/smsir.c
index 273043ea8f47..35d0e887bd65 100644
--- a/drivers/media/common/siano/smsir.c
+++ b/drivers/media/common/siano/smsir.c
@@ -107,8 +107,7 @@ int sms_ir_init(struct smscore_device_t *coredev)
 
 void sms_ir_exit(struct smscore_device_t *coredev)
 {
-        if (coredev->ir.dev)
-                rc_unregister_device(coredev->ir.dev);
+        rc_unregister_device(coredev->ir.dev);
 
         sms_log("");
 }
diff --git a/drivers/media/common/tveeprom.c b/drivers/media/common/tveeprom.c
index c7dace671a9d..47da0378cad8 100644
--- a/drivers/media/common/tveeprom.c
+++ b/drivers/media/common/tveeprom.c
@@ -286,9 +286,17 @@ static const struct {
         { TUNER_ABSENT,                 "Xceive XC5200C"},
         { TUNER_ABSENT,                 "NXP 18273"},
         { TUNER_ABSENT,                 "Montage M88TS2022"},
-        /* 180-189 */
+        /* 180-188 */
         { TUNER_ABSENT,                 "NXP 18272M"},
         { TUNER_ABSENT,                 "NXP 18272S"},
+
+        { TUNER_ABSENT,                 "Mirics MSi003"},
+        { TUNER_ABSENT,                 "MaxLinear MxL256"},
+        { TUNER_ABSENT,                 "SiLabs Si2158"},
+        { TUNER_ABSENT,                 "SiLabs Si2178"},
+        { TUNER_ABSENT,                 "SiLabs Si2157"},
+        { TUNER_ABSENT,                 "SiLabs Si2177"},
+        { TUNER_ABSENT,                 "ITE IT9137FN"},
 };
 
 /* Use TVEEPROM_AUDPROC_INTERNAL for those audio 'chips' that are
@@ -351,6 +359,16 @@ static const struct {
         { TVEEPROM_AUDPROC_INTERNAL, "CX23887"   },
         { TVEEPROM_AUDPROC_INTERNAL, "SAA7164"   },
         { TVEEPROM_AUDPROC_INTERNAL, "AU8522"    },
+        /* 45-49 */
+        { TVEEPROM_AUDPROC_INTERNAL, "AVF4910B"  },
+        { TVEEPROM_AUDPROC_INTERNAL, "SAA7231"   },
+        { TVEEPROM_AUDPROC_INTERNAL, "CX23102"   },
+        { TVEEPROM_AUDPROC_INTERNAL, "SAA7163"   },
+        { TVEEPROM_AUDPROC_OTHER,    "AK4113"    },
+        /* 50-52 */
+        { TVEEPROM_AUDPROC_OTHER,    "CS5340"    },
+        { TVEEPROM_AUDPROC_OTHER,    "CS8416"    },
+        { TVEEPROM_AUDPROC_OTHER,    "CX20810"   },
 };
 
 /* This list is supplied by Hauppauge. Thanks! */
@@ -371,8 +389,12 @@ static const char *decoderIC[] = {
         "CX25843", "CX23418", "NEC61153", "CX23885", "CX23888",
         /* 35-39 */
         "SAA7131", "CX25837", "CX23887", "CX23885A", "CX23887A",
-        /* 40-42 */
-        "SAA7164", "CX23885B", "AU8522"
+        /* 40-44 */
+        "SAA7164", "CX23885B", "AU8522", "ADV7401", "AVF4910B",
+        /* 45-49 */
+        "SAA7231", "CX23102", "SAA7163", "ADV7441A", "ADV7181C",
+        /* 50-53 */
+        "CX25836", "TDA9955", "TDA19977", "ADV7842"
 };
 
 static int hasRadioTuner(int tunerType)
@@ -548,10 +570,10 @@ void tveeprom_hauppauge_analog(struct i2c_client *c, struct tveeprom *tvee,
                         tvee->serial_number =
                                 eeprom_data[i+5] +
                                 (eeprom_data[i+6] << 8) +
-                                (eeprom_data[i+7] << 16);
+                                (eeprom_data[i+7] << 16)+
+                                (eeprom_data[i+8] << 24);
 
-                        if ((eeprom_data[i + 8] & 0xf0) &&
-                                        (tvee->serial_number < 0xffffff)) {
+                        if (eeprom_data[i + 8] == 0xf0) {
                                 tvee->MAC_address[0] = 0x00;
                                 tvee->MAC_address[1] = 0x0D;
                                 tvee->MAC_address[2] = 0xFE;
@@ -696,7 +718,7 @@ void tveeprom_hauppauge_analog(struct i2c_client *c, struct tveeprom *tvee,
                 }
         }
 
-        tveeprom_info("Hauppauge model %d, rev %s, serial# %d\n",
+        tveeprom_info("Hauppauge model %d, rev %s, serial# %u\n",
                 tvee->model, tvee->rev_str, tvee->serial_number);
         if (tvee->has_MAC_address == 1)
                 tveeprom_info("MAC address is %pM\n", tvee->MAC_address);
diff --git a/drivers/media/dvb-core/dvb-usb-ids.h b/drivers/media/dvb-core/dvb-usb-ids.h
index e07a84e7bc56..80ab8d0ff6e0 100644
--- a/drivers/media/dvb-core/dvb-usb-ids.h
+++ b/drivers/media/dvb-core/dvb-usb-ids.h
@@ -356,6 +356,7 @@
 #define USB_PID_MSI_DIGI_VOX_MINI_III                   0x8807
 #define USB_PID_SONY_PLAYTV                             0x0003
 #define USB_PID_MYGICA_D689                             0xd811
+#define USB_PID_MYGICA_T230                             0xc688
 #define USB_PID_ELGATO_EYETV_DIVERSITY                  0x0011
 #define USB_PID_ELGATO_EYETV_DTT                        0x0021
 #define USB_PID_ELGATO_EYETV_DTT_2                      0x003f
diff --git a/drivers/media/dvb-core/dvb_net.c b/drivers/media/dvb-core/dvb_net.c
index 059e6117f22b..e4041f074909 100644
--- a/drivers/media/dvb-core/dvb_net.c
+++ b/drivers/media/dvb-core/dvb_net.c
@@ -379,7 +379,9 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
                         /* Check TS error conditions: sync_byte, transport_error_indicator, scrambling_control . */
                         if ((ts[0] != TS_SYNC) || (ts[1] & TS_TEI) || ((ts[3] & TS_SC) != 0)) {
                                 printk(KERN_WARNING "%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",
-                                       priv->ts_count, ts[0], ts[1] & TS_TEI >> 7, ts[3] & 0xC0 >> 6);
+                                       priv->ts_count, ts[0],
+                                       (ts[1] & TS_TEI) >> 7,
+                                       (ts[3] & TS_SC) >> 6);
 
                                 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
                                 if (priv->ule_skb) {
diff --git a/drivers/media/dvb-frontends/Kconfig b/drivers/media/dvb-frontends/Kconfig
index 5a134547e325..6c75418222e2 100644
--- a/drivers/media/dvb-frontends/Kconfig
+++ b/drivers/media/dvb-frontends/Kconfig
@@ -648,12 +648,15 @@ config DVB_MB86A20S
           A driver for Fujitsu mb86a20s ISDB-T/ISDB-Tsb demodulator.
           Say Y when you want to support this frontend.
 
+comment "ISDB-S (satellite) & ISDB-T (terrestrial) frontends"
+        depends on DVB_CORE
+
 config DVB_TC90522
         tristate "Toshiba TC90522"
         depends on DVB_CORE && I2C
         default m if !MEDIA_SUBDRV_AUTOSELECT
         help
-          A Toshiba TC90522 2xISDB-T + 2xISDB-S demodulator.
+          Toshiba TC90522 2xISDB-S 8PSK + 2xISDB-T OFDM demodulator.
           Say Y when you want to support this frontend.
 
 comment "Digital terrestrial only tuners/PLL"
diff --git a/drivers/media/dvb-frontends/af9033.c b/drivers/media/dvb-frontends/af9033.c
index 63a89c1c59ff..82ce47bdf5dc 100644
--- a/drivers/media/dvb-frontends/af9033.c
+++ b/drivers/media/dvb-frontends/af9033.c
@@ -291,6 +291,12 @@ static int af9033_init(struct dvb_frontend *fe)
                 if (clock_adc_lut[i].clock == dev->cfg.clock)
                         break;
         }
+        if (i == ARRAY_SIZE(clock_adc_lut)) {
+                dev_err(&dev->client->dev,
+                        "Couldn't find ADC config for clock=%d\n",
+                        dev->cfg.clock);
+                goto err;
+        }
 
         adc_cw = af9033_div(dev, clock_adc_lut[i].adc, 1000000ul, 19ul);
         buf[0] = (adc_cw >>  0) & 0xff;
@@ -580,7 +586,15 @@ static int af9033_set_frontend(struct dvb_frontend *fe)
                                 break;
                         }
                 }
-                ret =  af9033_wr_regs(dev, 0x800001,
+                if (i == ARRAY_SIZE(coeff_lut)) {
+                        dev_err(&dev->client->dev,
+                                "Couldn't find LUT config for clock=%d\n",
+                                dev->cfg.clock);
+                        ret = -EINVAL;
+                        goto err;
+                }
+
+                ret = af9033_wr_regs(dev, 0x800001,
                                 coeff_lut[i].val, sizeof(coeff_lut[i].val));
         }
 
@@ -592,6 +606,13 @@ static int af9033_set_frontend(struct dvb_frontend *fe)
                         if (clock_adc_lut[i].clock == dev->cfg.clock)
                                 break;
                 }
+                if (i == ARRAY_SIZE(clock_adc_lut)) {
+                        dev_err(&dev->client->dev,
+                                "Couldn't find ADC clock for clock=%d\n",
+                                dev->cfg.clock);
+                        ret = -EINVAL;
+                        goto err;
+                }
                 adc_freq = clock_adc_lut[i].adc;
 
                 /* get used IF frequency */
@@ -849,29 +870,97 @@ static int af9033_read_snr(struct dvb_frontend *fe, u16 *snr)
 {
         struct af9033_dev *dev = fe->demodulator_priv;
         struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
+        int ret;
+        u8 u8tmp;
 
         /* use DVBv5 CNR */
-        if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
-                *snr = div_s64(c->cnr.stat[0].svalue, 100); /* 1000x => 10x */
-        else
+        if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL) {
+                /* Return 0.1 dB for AF9030 and 0-0xffff for IT9130. */
+                if (dev->is_af9035) {
+                        /* 1000x => 10x (0.1 dB) */
+                        *snr = div_s64(c->cnr.stat[0].svalue, 100);
+                } else {
+                        /* 1000x => 1x (1 dB) */
+                        *snr = div_s64(c->cnr.stat[0].svalue, 1000);
+
+                        /* read current modulation */
+                        ret = af9033_rd_reg(dev, 0x80f903, &u8tmp);
+                        if (ret)
+                                goto err;
+
+                        /* scale value to 0x0000-0xffff */
+                        switch ((u8tmp >> 0) & 3) {
+                        case 0:
+                                *snr = *snr * 0xffff / 23;
+                                break;
+                        case 1:
+                                *snr = *snr * 0xffff / 26;
+                                break;
+                        case 2:
+                                *snr = *snr * 0xffff / 32;
+                                break;
+                        default:
+                                goto err;
+                        }
+                }
+        } else {
                 *snr = 0;
+        }
 
         return 0;
+
+err:
+        dev_dbg(&dev->client->dev, "failed=%d\n", ret);
+
+        return ret;
 }
 
 static int af9033_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 {
         struct af9033_dev *dev = fe->demodulator_priv;
-        int ret;
-        u8 strength2;
+        struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
+        int ret, tmp, power_real;
+        u8 u8tmp, gain_offset, buf[7];
 
-        /* read signal strength of 0-100 scale */
-        ret = af9033_rd_reg(dev, 0x800048, &strength2);
-        if (ret < 0)
-                goto err;
+        if (dev->is_af9035) {
+                /* read signal strength of 0-100 scale */
+                ret = af9033_rd_reg(dev, 0x800048, &u8tmp);
+                if (ret < 0)
+                        goto err;
+
+                /* scale value to 0x0000-0xffff */
+                *strength = u8tmp * 0xffff / 100;
+        } else {
+                ret = af9033_rd_reg(dev, 0x8000f7, &u8tmp);
+                if (ret < 0)
+                        goto err;
+
+                ret = af9033_rd_regs(dev, 0x80f900, buf, 7);
+                if (ret < 0)
+                        goto err;
+
+                if (c->frequency <= 300000000)
+                        gain_offset = 7; /* VHF */
+                else
+                        gain_offset = 4; /* UHF */
+
+                power_real = (u8tmp - 100 - gain_offset) -
+                        power_reference[((buf[3] >> 0) & 3)][((buf[6] >> 0) & 7)];
+
+                if (power_real < -15)
+                        tmp = 0;
+                else if ((power_real >= -15) && (power_real < 0))
+                        tmp = (2 * (power_real + 15)) / 3;
+                else if ((power_real >= 0) && (power_real < 20))
+                        tmp = 4 * power_real + 10;
+                else if ((power_real >= 20) && (power_real < 35))
+                        tmp = (2 * (power_real - 20)) / 3 + 90;
+                else
+                        tmp = 100;
 
-        /* scale value to 0x0000-0xffff */
-        *strength = strength2 * 0xffff / 100;
+                /* scale value to 0x0000-0xffff */
+                *strength = tmp * 0xffff / 100;
+        }
 
         return 0;
 
@@ -1011,6 +1100,33 @@ static void af9033_stat_work(struct work_struct *work)
 
                 snr_val = (buf[2] << 16) | (buf[1] << 8) | (buf[0] << 0);
 
+                /* read superframe number */
+                ret = af9033_rd_reg(dev, 0x80f78b, &u8tmp);
+                if (ret)
+                        goto err;
+
+                if (u8tmp)
+                        snr_val /= u8tmp;
+
+                /* read current transmission mode */
+                ret = af9033_rd_reg(dev, 0x80f900, &u8tmp);
+                if (ret)
+                        goto err;
+
+                switch ((u8tmp >> 0) & 3) {
+                case 0:
+                        snr_val *= 4;
+                        break;
+                case 1:
+                        snr_val *= 1;
+                        break;
+                case 2:
+                        snr_val *= 2;
+                        break;
+                default:
+                        goto err_schedule_delayed_work;
+                }
+
                 /* read current modulation */
                 ret = af9033_rd_reg(dev, 0x80f903, &u8tmp);
                 if (ret)
diff --git a/drivers/media/dvb-frontends/af9033_priv.h b/drivers/media/dvb-frontends/af9033_priv.h
index c12c92cb5855..8e23275148ed 100644
--- a/drivers/media/dvb-frontends/af9033_priv.h
+++ b/drivers/media/dvb-frontends/af9033_priv.h
@@ -181,7 +181,10 @@ static const struct val_snr qam64_snr_lut[] = {
         { 0x05570d, 26 },
         { 0x059feb, 27 },
         { 0x05bf38, 28 },
-        { 0xffffff, 29 },
+        { 0x05f78f, 29 },
+        { 0x0612c3, 30 },
+        { 0x0626be, 31 },
+        { 0xffffff, 32 },
 };
 
 static const struct reg_val ofsm_init[] = {
@@ -2051,4 +2054,10 @@ static const struct reg_val tuner_init_it9135_62[] = {
         { 0x80fd8b, 0x00 },
 };
 
+/* NorDig power reference table */
+static const int power_reference[][5] = {
+        {-93, -91, -90, -89, -88}, /* QPSK 1/2 ~ 7/8 */
+        {-87, -85, -84, -83, -82}, /* 16QAM 1/2 ~ 7/8 */
+        {-82, -80, -78, -77, -76}, /* 64QAM 1/2 ~ 7/8 */
+};
 #endif /* AF9033_PRIV_H */
diff --git a/drivers/media/dvb-frontends/au8522_dig.c b/drivers/media/dvb-frontends/au8522_dig.c
index a68974f6d708..5d06c99b0e97 100644
--- a/drivers/media/dvb-frontends/au8522_dig.c
+++ b/drivers/media/dvb-frontends/au8522_dig.c
@@ -29,6 +29,7 @@
 #include "au8522_priv.h"
 
 static int debug;
+static int zv_mode = 1; /* default to on */
 
 #define dprintk(arg...)\
         do { if (debug)\
@@ -469,6 +470,87 @@ static struct {
         { 0x8526, 0x01 },
 };
 
+static struct {
+        u16 reg;
+        u16 data;
+} QAM256_mod_tab_zv_mode[] = {
+        { 0x80a3, 0x09 },
+        { 0x80a4, 0x00 },
+        { 0x8081, 0xc4 },
+        { 0x80a5, 0x40 },
+        { 0x80b5, 0xfb },
+        { 0x80b6, 0x8e },
+        { 0x80b7, 0x39 },
+        { 0x80aa, 0x77 },
+        { 0x80ad, 0x77 },
+        { 0x80a6, 0x67 },
+        { 0x8262, 0x20 },
+        { 0x821c, 0x30 },
+        { 0x80b8, 0x3e },
+        { 0x80b9, 0xf0 },
+        { 0x80ba, 0x01 },
+        { 0x80bb, 0x18 },
+        { 0x80bc, 0x50 },
+        { 0x80bd, 0x00 },
+        { 0x80be, 0xea },
+        { 0x80bf, 0xef },
+        { 0x80c0, 0xfc },
+        { 0x80c1, 0xbd },
+        { 0x80c2, 0x1f },
+        { 0x80c3, 0xfc },
+        { 0x80c4, 0xdd },
+        { 0x80c5, 0xaf },
+        { 0x80c6, 0x00 },
+        { 0x80c7, 0x38 },
+        { 0x80c8, 0x30 },
+        { 0x80c9, 0x05 },
+        { 0x80ca, 0x4a },
+        { 0x80cb, 0xd0 },
+        { 0x80cc, 0x01 },
+        { 0x80cd, 0xd9 },
+        { 0x80ce, 0x6f },
+        { 0x80cf, 0xf9 },
+        { 0x80d0, 0x70 },
+        { 0x80d1, 0xdf },
+        { 0x80d2, 0xf7 },
+        { 0x80d3, 0xc2 },
+        { 0x80d4, 0xdf },
+        { 0x80d5, 0x02 },
+        { 0x80d6, 0x9a },
+        { 0x80d7, 0xd0 },
+        { 0x8250, 0x0d },
+        { 0x8251, 0xcd },
+        { 0x8252, 0xe0 },
+        { 0x8253, 0x05 },
+        { 0x8254, 0xa7 },
+        { 0x8255, 0xff },
+        { 0x8256, 0xed },
+        { 0x8257, 0x5b },
+        { 0x8258, 0xae },
+        { 0x8259, 0xe6 },
+        { 0x825a, 0x3d },
+        { 0x825b, 0x0f },
+        { 0x825c, 0x0d },
+        { 0x825d, 0xea },
+        { 0x825e, 0xf2 },
+        { 0x825f, 0x51 },
+        { 0x8260, 0xf5 },
+        { 0x8261, 0x06 },
+        { 0x821a, 0x01 },
+        { 0x8546, 0x40 },
+        { 0x8210, 0x26 },
+        { 0x8211, 0xf6 },
+        { 0x8212, 0x84 },
+        { 0x8213, 0x02 },
+        { 0x8502, 0x01 },
+        { 0x8121, 0x04 },
+        { 0x8122, 0x04 },
+        { 0x852e, 0x10 },
+        { 0x80a4, 0xca },
+        { 0x80a7, 0x40 },
+        { 0x8526, 0x01 },
+};
+
 static int au8522_enable_modulation(struct dvb_frontend *fe,
                                     fe_modulation_t m)
 {
@@ -495,12 +577,23 @@ static int au8522_enable_modulation(struct dvb_frontend *fe,
                 au8522_set_if(fe, state->config->qam_if);
                 break;
         case QAM_256:
-                dprintk("%s() QAM 256\n", __func__);
-                for (i = 0; i < ARRAY_SIZE(QAM256_mod_tab); i++)
-                        au8522_writereg(state,
-                                QAM256_mod_tab[i].reg,
-                                QAM256_mod_tab[i].data);
-                au8522_set_if(fe, state->config->qam_if);
+                if (zv_mode) {
+                        dprintk("%s() QAM 256 (zv_mode)\n", __func__);
+                        for (i = 0; i < ARRAY_SIZE(QAM256_mod_tab_zv_mode); i++)
+                                au8522_writereg(state,
+                                        QAM256_mod_tab_zv_mode[i].reg,
+                                        QAM256_mod_tab_zv_mode[i].data);
+                        au8522_set_if(fe, state->config->qam_if);
+                        msleep(100);
+                        au8522_writereg(state, 0x821a, 0x00);
+                } else {
+                        dprintk("%s() QAM 256\n", __func__);
+                        for (i = 0; i < ARRAY_SIZE(QAM256_mod_tab); i++)
+                                au8522_writereg(state,
+                                        QAM256_mod_tab[i].reg,
+                                        QAM256_mod_tab[i].data);
+                        au8522_set_if(fe, state->config->qam_if);
+                }
                 break;
         default:
                 dprintk("%s() Invalid modulation\n", __func__);
@@ -537,7 +630,12 @@ static int au8522_set_frontend(struct dvb_frontend *fe)
                 return ret;
 
         /* Allow the tuner to settle */
-        msleep(100);
+        if (zv_mode) {
+                dprintk("%s() increase tuner settling time for zv_mode\n",
+                        __func__);
+                msleep(250);
+        } else
+                msleep(100);
 
         au8522_enable_modulation(fe, c->modulation);
 
@@ -823,6 +921,11 @@ static struct dvb_frontend_ops au8522_ops = {
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Enable verbose debug messages");
 
+module_param(zv_mode, int, 0644);
+MODULE_PARM_DESC(zv_mode, "Turn on/off ZeeVee modulator compatability mode (default:on).\n"
+        "\t\ton - modified AU8522 QAM256 initialization.\n"
+        "\t\tProvides faster lock when using ZeeVee modulator based sources");
+
 MODULE_DESCRIPTION("Auvitek AU8522 QAM-B/ATSC Demodulator driver");
 MODULE_AUTHOR("Steven Toth");
 MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb-frontends/cx22700.c b/drivers/media/dvb-frontends/cx22700.c
index 3d399d9a6343..86563260d0f2 100644
--- a/drivers/media/dvb-frontends/cx22700.c
+++ b/drivers/media/dvb-frontends/cx22700.c
@@ -169,6 +169,9 @@ static int cx22700_set_tps(struct cx22700_state *state,
 
         cx22700_writereg (state, 0x04, val);
 
+        if (p->code_rate_HP - FEC_1_2 >= sizeof(fec_tab) ||
+            p->code_rate_LP - FEC_1_2 >= sizeof(fec_tab))
+                return -EINVAL;
         val = fec_tab[p->code_rate_HP - FEC_1_2] << 3;
         val |= fec_tab[p->code_rate_LP - FEC_1_2];
 
diff --git a/drivers/media/dvb-frontends/cx24110.c b/drivers/media/dvb-frontends/cx24110.c
index 95b981cd7115..7b510f2ae20f 100644
--- a/drivers/media/dvb-frontends/cx24110.c
+++ b/drivers/media/dvb-frontends/cx24110.c
@@ -177,47 +177,45 @@ static int cx24110_set_inversion (struct cx24110_state* state, fe_spectral_inver
         return 0;
 }
 
-static int cx24110_set_fec (struct cx24110_state* state, fe_code_rate_t fec)
+static int cx24110_set_fec(struct cx24110_state* state, fe_code_rate_t fec)
 {
-/* fixme (low): error handling */
-
-        static const int rate[]={-1,1,2,3,5,7,-1};
-        static const int g1[]={-1,0x01,0x02,0x05,0x15,0x45,-1};
-        static const int g2[]={-1,0x01,0x03,0x06,0x1a,0x7a,-1};
+        static const int rate[FEC_AUTO] = {-1,    1,    2,    3,    5,    7, -1};
+        static const int g1[FEC_AUTO]   = {-1, 0x01, 0x02, 0x05, 0x15, 0x45, -1};
+        static const int g2[FEC_AUTO]   = {-1, 0x01, 0x03, 0x06, 0x1a, 0x7a, -1};
 
         /* Well, the AutoAcq engine of the cx24106 and 24110 automatically
            searches all enabled viterbi rates, and can handle non-standard
            rates as well. */
 
-        if (fec>FEC_AUTO)
-                fec=FEC_AUTO;
+        if (fec > FEC_AUTO)
+                fec = FEC_AUTO;
 
-        if (fec==FEC_AUTO) { /* (re-)establish AutoAcq behaviour */
-                cx24110_writereg(state,0x37,cx24110_readreg(state,0x37)&0xdf);
+        if (fec == FEC_AUTO) { /* (re-)establish AutoAcq behaviour */
+                cx24110_writereg(state, 0x37, cx24110_readreg(state, 0x37) & 0xdf);
                 /* clear AcqVitDis bit */
-                cx24110_writereg(state,0x18,0xae);
+                cx24110_writereg(state, 0x18, 0xae);
                 /* allow all DVB standard code rates */
-                cx24110_writereg(state,0x05,(cx24110_readreg(state,0x05)&0xf0)|0x3);
+                cx24110_writereg(state, 0x05, (cx24110_readreg(state, 0x05) & 0xf0) | 0x3);
                 /* set nominal Viterbi rate 3/4 */
-                cx24110_writereg(state,0x22,(cx24110_readreg(state,0x22)&0xf0)|0x3);
+                cx24110_writereg(state, 0x22, (cx24110_readreg(state, 0x22) & 0xf0) | 0x3);
                 /* set current Viterbi rate 3/4 */
-                cx24110_writereg(state,0x1a,0x05); cx24110_writereg(state,0x1b,0x06);
+                cx24110_writereg(state, 0x1a, 0x05);
+                cx24110_writereg(state, 0x1b, 0x06);
                 /* set the puncture registers for code rate 3/4 */
                 return 0;
         } else {
-                cx24110_writereg(state,0x37,cx24110_readreg(state,0x37)|0x20);
+                cx24110_writereg(state, 0x37, cx24110_readreg(state, 0x37) | 0x20);
                 /* set AcqVitDis bit */
-                if(rate[fec]>0) {
-                        cx24110_writereg(state,0x05,(cx24110_readreg(state,0x05)&0xf0)|rate[fec]);
-                        /* set nominal Viterbi rate */
-                        cx24110_writereg(state,0x22,(cx24110_readreg(state,0x22)&0xf0)|rate[fec]);
-                        /* set current Viterbi rate */
-                        cx24110_writereg(state,0x1a,g1[fec]);
-                        cx24110_writereg(state,0x1b,g2[fec]);
-                        /* not sure if this is the right way: I always used AutoAcq mode */
-           } else
-                   return -EOPNOTSUPP;
-/* fixme (low): which is the correct return code? */
+                if (rate[fec] < 0)
+                        return -EINVAL;
+
+                cx24110_writereg(state, 0x05, (cx24110_readreg(state, 0x05) & 0xf0) | rate[fec]);
+                /* set nominal Viterbi rate */
+                cx24110_writereg(state, 0x22, (cx24110_readreg(state, 0x22) & 0xf0) | rate[fec]);
+                /* set current Viterbi rate */
+                cx24110_writereg(state, 0x1a, g1[fec]);
+                cx24110_writereg(state, 0x1b, g2[fec]);
+                /* not sure if this is the right way: I always used AutoAcq mode */
         }
         return 0;
 }
diff --git a/drivers/media/dvb-frontends/cx24117.c b/drivers/media/dvb-frontends/cx24117.c
index a6c3c9e2e897..acb965ce0358 100644
--- a/drivers/media/dvb-frontends/cx24117.c
+++ b/drivers/media/dvb-frontends/cx24117.c
@@ -459,7 +459,7 @@ static int cx24117_firmware_ondemand(struct dvb_frontend *fe)
         if (state->priv->skip_fw_load)
                 return 0;
 
-        /* check if firmware if already running */
+        /* check if firmware is already running */
         if (cx24117_readreg(state, 0xeb) != 0xa) {
                 /* Load firmware */
                 /* request the firmware, this will block until loaded */
diff --git a/drivers/media/dvb-frontends/dib7000p.c b/drivers/media/dvb-frontends/dib7000p.c
index 589134e95175..c505d696f92d 100644
--- a/drivers/media/dvb-frontends/dib7000p.c
+++ b/drivers/media/dvb-frontends/dib7000p.c
@@ -1780,7 +1780,7 @@ static u32 interpolate_value(u32 value, struct linear_segments *segments,
 }
 
 /* FIXME: may require changes - this one was borrowed from dib8000 */
-static u32 dib7000p_get_time_us(struct dvb_frontend *demod, int layer)
+static u32 dib7000p_get_time_us(struct dvb_frontend *demod)
 {
         struct dtv_frontend_properties *c = &demod->dtv_property_cache;
         u64 time_us, tmp64;
@@ -1881,7 +1881,6 @@ static int dib7000p_get_stats(struct dvb_frontend *demod, fe_status_t stat)
 {
         struct dib7000p_state *state = demod->demodulator_priv;
         struct dtv_frontend_properties *c = &demod->dtv_property_cache;
-        int i;
         int show_per_stats = 0;
         u32 time_us = 0, val, snr;
         u64 blocks, ucb;
@@ -1935,7 +1934,7 @@ static int dib7000p_get_stats(struct dvb_frontend *demod, fe_status_t stat)
 
                 /* Estimate the number of packets based on bitrate */
                 if (!time_us)
-                        time_us = dib7000p_get_time_us(demod, -1);
+                        time_us = dib7000p_get_time_us(demod);
 
                 if (time_us) {
                         blocks = 1250000ULL * 1000000ULL;
@@ -1949,7 +1948,7 @@ static int dib7000p_get_stats(struct dvb_frontend *demod, fe_status_t stat)
 
         /* Get post-BER measures */
         if (time_after(jiffies, state->ber_jiffies_stats)) {
-                time_us = dib7000p_get_time_us(demod, -1);
+                time_us = dib7000p_get_time_us(demod);
                 state->ber_jiffies_stats = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
 
                 dprintk("Next all layers stats available in %u us.", time_us);
@@ -1969,7 +1968,7 @@ static int dib7000p_get_stats(struct dvb_frontend *demod, fe_status_t stat)
                 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
                 c->block_error.stat[0].uvalue += val;
 
-                time_us = dib7000p_get_time_us(demod, i);
+                time_us = dib7000p_get_time_us(demod);
                 if (time_us) {
                         blocks = 1250000ULL * 1000000ULL;
                         do_div(blocks, time_us * 8 * 204);
diff --git a/drivers/media/dvb-frontends/drx39xyj/drxj.c b/drivers/media/dvb-frontends/drx39xyj/drxj.c
index 5ec221ffdfca..2bfa7a435974 100644
--- a/drivers/media/dvb-frontends/drx39xyj/drxj.c
+++ b/drivers/media/dvb-frontends/drx39xyj/drxj.c
@@ -12255,8 +12255,7 @@ static void drx39xxj_release(struct dvb_frontend *fe)
         kfree(demod->my_ext_attr);
         kfree(demod->my_common_attr);
         kfree(demod->my_i2c_dev_addr);
-        if (demod->firmware)
-                release_firmware(demod->firmware);
+        release_firmware(demod->firmware);
         kfree(demod);
         kfree(state);
 }
diff --git a/drivers/media/dvb-frontends/drxk_hard.c b/drivers/media/dvb-frontends/drxk_hard.c
index 672195147d01..d46cf5f7cd2e 100644
--- a/drivers/media/dvb-frontends/drxk_hard.c
+++ b/drivers/media/dvb-frontends/drxk_hard.c
@@ -166,9 +166,9 @@ static unsigned int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "enable debug messages");
 
-#define dprintk(level, fmt, arg...) do {                        \
-if (debug >= level)                                             \
-        pr_debug(fmt, ##arg);                                   \
+#define dprintk(level, fmt, arg...) do {                                \
+if (debug >= level)                                                     \
+        printk(KERN_DEBUG KBUILD_MODNAME ": %s " fmt, __func__, ##arg); \
 } while (0)
 
 
@@ -6310,8 +6310,7 @@ static void drxk_release(struct dvb_frontend *fe)
         struct drxk_state *state = fe->demodulator_priv;
 
         dprintk(1, "\n");
-        if (state->fw)
-                release_firmware(state->fw);
+        release_firmware(state->fw);
 
         kfree(state);
 }
diff --git a/drivers/media/dvb-frontends/m88ds3103.c b/drivers/media/dvb-frontends/m88ds3103.c
index 81657e94c5a4..ba4ee0b48834 100644
--- a/drivers/media/dvb-frontends/m88ds3103.c
+++ b/drivers/media/dvb-frontends/m88ds3103.c
@@ -1,5 +1,5 @@
 /*
- * Montage M88DS3103 demodulator driver
+ * Montage M88DS3103/M88RS6000 demodulator driver
  *
  * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
  *
@@ -162,7 +162,7 @@ static int m88ds3103_wr_reg_val_tab(struct m88ds3103_priv *priv,
 
         dev_dbg(&priv->i2c->dev, "%s: tab_len=%d\n", __func__, tab_len);
 
-        if (tab_len > 83) {
+        if (tab_len > 86) {
                 ret = -EINVAL;
                 goto err;
         }
@@ -245,9 +245,9 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
         int ret, len;
         const struct m88ds3103_reg_val *init;
-        u8 u8tmp, u8tmp1, u8tmp2;
-        u8 buf[2];
-        u16 u16tmp, divide_ratio;
+        u8 u8tmp, u8tmp1 = 0, u8tmp2 = 0; /* silence compiler warning */
+        u8 buf[3];
+        u16 u16tmp, divide_ratio = 0;
         u32 tuner_frequency, target_mclk;
         s32 s32tmp;
 
@@ -262,6 +262,22 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
                 goto err;
         }
 
+        /* reset */
+        ret = m88ds3103_wr_reg(priv, 0x07, 0x80);
+        if (ret)
+                goto err;
+
+        ret = m88ds3103_wr_reg(priv, 0x07, 0x00);
+        if (ret)
+                goto err;
+
+        /* Disable demod clock path */
+        if (priv->chip_id == M88RS6000_CHIP_ID) {
+                ret = m88ds3103_wr_reg(priv, 0x06, 0xe0);
+                if (ret)
+                        goto err;
+        }
+
         /* program tuner */
         if (fe->ops.tuner_ops.set_params) {
                 ret = fe->ops.tuner_ops.set_params(fe);
@@ -282,49 +298,44 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
                 tuner_frequency = c->frequency;
         }
 
-        /* reset */
-        ret = m88ds3103_wr_reg(priv, 0x07, 0x80);
-        if (ret)
-                goto err;
-
-        ret = m88ds3103_wr_reg(priv, 0x07, 0x00);
-        if (ret)
-                goto err;
-
-        ret = m88ds3103_wr_reg(priv, 0xb2, 0x01);
-        if (ret)
-                goto err;
+        /* select M88RS6000 demod main mclk and ts mclk from tuner die. */
+        if (priv->chip_id == M88RS6000_CHIP_ID) {
+                if (c->symbol_rate > 45010000)
+                        priv->mclk_khz = 110250;
+                else
+                        priv->mclk_khz = 96000;
 
-        ret = m88ds3103_wr_reg(priv, 0x00, 0x01);
-        if (ret)
-                goto err;
+                if (c->delivery_system == SYS_DVBS)
+                        target_mclk = 96000;
+                else
+                        target_mclk = 144000;
 
-        switch (c->delivery_system) {
-        case SYS_DVBS:
-                len = ARRAY_SIZE(m88ds3103_dvbs_init_reg_vals);
-                init = m88ds3103_dvbs_init_reg_vals;
-                target_mclk = 96000;
-                break;
-        case SYS_DVBS2:
-                len = ARRAY_SIZE(m88ds3103_dvbs2_init_reg_vals);
-                init = m88ds3103_dvbs2_init_reg_vals;
+                /* Enable demod clock path */
+                ret = m88ds3103_wr_reg(priv, 0x06, 0x00);
+                if (ret)
+                        goto err;
+                usleep_range(10000, 20000);
+        } else {
+        /* set M88DS3103 mclk and ts mclk. */
+                priv->mclk_khz = 96000;
 
                 switch (priv->cfg->ts_mode) {
                 case M88DS3103_TS_SERIAL:
                 case M88DS3103_TS_SERIAL_D7:
-                        if (c->symbol_rate < 18000000)
-                                target_mclk = 96000;
-                        else
-                                target_mclk = 144000;
+                        target_mclk = priv->cfg->ts_clk;
                         break;
                 case M88DS3103_TS_PARALLEL:
                 case M88DS3103_TS_CI:
-                        if (c->symbol_rate < 18000000)
+                        if (c->delivery_system == SYS_DVBS)
                                 target_mclk = 96000;
-                        else if (c->symbol_rate < 28000000)
-                                target_mclk = 144000;
-                        else
-                                target_mclk = 192000;
+                        else {
+                                if (c->symbol_rate < 18000000)
+                                        target_mclk = 96000;
+                                else if (c->symbol_rate < 28000000)
+                                        target_mclk = 144000;
+                                else
+                                        target_mclk = 192000;
+                        }
                         break;
                 default:
                         dev_dbg(&priv->i2c->dev, "%s: invalid ts_mode\n",
@@ -332,6 +343,55 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
                         ret = -EINVAL;
                         goto err;
                 }
+
+                switch (target_mclk) {
+                case 96000:
+                        u8tmp1 = 0x02; /* 0b10 */
+                        u8tmp2 = 0x01; /* 0b01 */
+                        break;
+                case 144000:
+                        u8tmp1 = 0x00; /* 0b00 */
+                        u8tmp2 = 0x01; /* 0b01 */
+                        break;
+                case 192000:
+                        u8tmp1 = 0x03; /* 0b11 */
+                        u8tmp2 = 0x00; /* 0b00 */
+                        break;
+                }
+                ret = m88ds3103_wr_reg_mask(priv, 0x22, u8tmp1 << 6, 0xc0);
+                if (ret)
+                        goto err;
+                ret = m88ds3103_wr_reg_mask(priv, 0x24, u8tmp2 << 6, 0xc0);
+                if (ret)
+                        goto err;
+        }
+
+        ret = m88ds3103_wr_reg(priv, 0xb2, 0x01);
+        if (ret)
+                goto err;
+
+        ret = m88ds3103_wr_reg(priv, 0x00, 0x01);
+        if (ret)
+                goto err;
+
+        switch (c->delivery_system) {
+        case SYS_DVBS:
+                if (priv->chip_id == M88RS6000_CHIP_ID) {
+                        len = ARRAY_SIZE(m88rs6000_dvbs_init_reg_vals);
+                        init = m88rs6000_dvbs_init_reg_vals;
+                } else {
+                        len = ARRAY_SIZE(m88ds3103_dvbs_init_reg_vals);
+                        init = m88ds3103_dvbs_init_reg_vals;
+                }
+                break;
+        case SYS_DVBS2:
+                if (priv->chip_id == M88RS6000_CHIP_ID) {
+                        len = ARRAY_SIZE(m88rs6000_dvbs2_init_reg_vals);
+                        init = m88rs6000_dvbs2_init_reg_vals;
+                } else {
+                        len = ARRAY_SIZE(m88ds3103_dvbs2_init_reg_vals);
+                        init = m88ds3103_dvbs2_init_reg_vals;
+                }
                 break;
         default:
                 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n",
@@ -347,7 +407,30 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
                         goto err;
         }
 
-        u8tmp1 = 0; /* silence compiler warning */
+        if (priv->chip_id == M88RS6000_CHIP_ID) {
+                if ((c->delivery_system == SYS_DVBS2)
+                        && ((c->symbol_rate / 1000) <= 5000)) {
+                        ret = m88ds3103_wr_reg(priv, 0xc0, 0x04);
+                        if (ret)
+                                goto err;
+                        buf[0] = 0x09;
+                        buf[1] = 0x22;
+                        buf[2] = 0x88;
+                        ret = m88ds3103_wr_regs(priv, 0x8a, buf, 3);
+                        if (ret)
+                                goto err;
+                }
+                ret = m88ds3103_wr_reg_mask(priv, 0x9d, 0x08, 0x08);
+                if (ret)
+                        goto err;
+                ret = m88ds3103_wr_reg(priv, 0xf1, 0x01);
+                if (ret)
+                        goto err;
+                ret = m88ds3103_wr_reg_mask(priv, 0x30, 0x80, 0x80);
+                if (ret)
+                        goto err;
+        }
+
         switch (priv->cfg->ts_mode) {
         case M88DS3103_TS_SERIAL:
                 u8tmp1 = 0x00;
@@ -383,16 +466,15 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
                 ret = m88ds3103_wr_reg_mask(priv, 0x29, u8tmp1, 0x20);
                 if (ret)
                         goto err;
-        }
-
-        if (priv->cfg->ts_clk) {
-                divide_ratio = DIV_ROUND_UP(target_mclk, priv->cfg->ts_clk);
-                u8tmp1 = divide_ratio / 2;
-                u8tmp2 = DIV_ROUND_UP(divide_ratio, 2);
-        } else {
-                divide_ratio = 0;
                 u8tmp1 = 0;
                 u8tmp2 = 0;
+                break;
+        default:
+                if (priv->cfg->ts_clk) {
+                        divide_ratio = DIV_ROUND_UP(target_mclk, priv->cfg->ts_clk);
+                        u8tmp1 = divide_ratio / 2;
+                        u8tmp2 = DIV_ROUND_UP(divide_ratio, 2);
+                }
         }
 
         dev_dbg(&priv->i2c->dev,
@@ -420,29 +502,6 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
         if (ret)
                 goto err;
 
-        switch (target_mclk) {
-        case 96000:
-                u8tmp1 = 0x02; /* 0b10 */
-                u8tmp2 = 0x01; /* 0b01 */
-                break;
-        case 144000:
-                u8tmp1 = 0x00; /* 0b00 */
-                u8tmp2 = 0x01; /* 0b01 */
-                break;
-        case 192000:
-                u8tmp1 = 0x03; /* 0b11 */
-                u8tmp2 = 0x00; /* 0b00 */
-                break;
-        }
-
-        ret = m88ds3103_wr_reg_mask(priv, 0x22, u8tmp1 << 6, 0xc0);
-        if (ret)
-                goto err;
-
-        ret = m88ds3103_wr_reg_mask(priv, 0x24, u8tmp2 << 6, 0xc0);
-        if (ret)
-                goto err;
-
         if (c->symbol_rate <= 3000000)
                 u8tmp = 0x20;
         else if (c->symbol_rate <= 10000000)
@@ -466,7 +525,7 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
         if (ret)
                 goto err;
 
-        u16tmp = DIV_ROUND_CLOSEST((c->symbol_rate / 1000) << 15, M88DS3103_MCLK_KHZ / 2);
+        u16tmp = DIV_ROUND_CLOSEST((c->symbol_rate / 1000) << 15, priv->mclk_khz / 2);
         buf[0] = (u16tmp >> 0) & 0xff;
         buf[1] = (u16tmp >> 8) & 0xff;
         ret = m88ds3103_wr_regs(priv, 0x61, buf, 2);
@@ -489,7 +548,7 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
                         (tuner_frequency - c->frequency));
 
         s32tmp = 0x10000 * (tuner_frequency - c->frequency);
-        s32tmp = DIV_ROUND_CLOSEST(s32tmp, M88DS3103_MCLK_KHZ);
+        s32tmp = DIV_ROUND_CLOSEST(s32tmp, priv->mclk_khz);
         if (s32tmp < 0)
                 s32tmp += 0x10000;
 
@@ -520,7 +579,7 @@ static int m88ds3103_init(struct dvb_frontend *fe)
         struct m88ds3103_priv *priv = fe->demodulator_priv;
         int ret, len, remaining;
         const struct firmware *fw = NULL;
-        u8 *fw_file = M88DS3103_FIRMWARE;
+        u8 *fw_file;
         u8 u8tmp;
 
         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
@@ -541,15 +600,6 @@ static int m88ds3103_init(struct dvb_frontend *fe)
         if (ret)
                 goto err;
 
-        /* reset */
-        ret = m88ds3103_wr_reg(priv, 0x07, 0x60);
-        if (ret)
-                goto err;
-
-        ret = m88ds3103_wr_reg(priv, 0x07, 0x00);
-        if (ret)
-                goto err;
-
         /* firmware status */
         ret = m88ds3103_rd_reg(priv, 0xb9, &u8tmp);
         if (ret)
@@ -560,10 +610,23 @@ static int m88ds3103_init(struct dvb_frontend *fe)
         if (u8tmp)
                 goto skip_fw_download;
 
+        /* global reset, global diseqc reset, golbal fec reset */
+        ret = m88ds3103_wr_reg(priv, 0x07, 0xe0);
+        if (ret)
+                goto err;
+
+        ret = m88ds3103_wr_reg(priv, 0x07, 0x00);
+        if (ret)
+                goto err;
+
         /* cold state - try to download firmware */
         dev_info(&priv->i2c->dev, "%s: found a '%s' in cold state\n",
                         KBUILD_MODNAME, m88ds3103_ops.info.name);
 
+        if (priv->chip_id == M88RS6000_CHIP_ID)
+                fw_file = M88RS6000_FIRMWARE;
+        else
+                fw_file = M88DS3103_FIRMWARE;
         /* request the firmware, this will block and timeout */
         ret = request_firmware(&fw, fw_file, priv->i2c->dev.parent);
         if (ret) {
@@ -577,7 +640,7 @@ static int m88ds3103_init(struct dvb_frontend *fe)
 
         ret = m88ds3103_wr_reg(priv, 0xb2, 0x01);
         if (ret)
-                goto err;
+                goto error_fw_release;
 
         for (remaining = fw->size; remaining > 0;
                         remaining -= (priv->cfg->i2c_wr_max - 1)) {
@@ -591,13 +654,13 @@ static int m88ds3103_init(struct dvb_frontend *fe)
                         dev_err(&priv->i2c->dev,
                                         "%s: firmware download failed=%d\n",
                                         KBUILD_MODNAME, ret);
-                        goto err;
+                        goto error_fw_release;
                 }
         }
 
         ret = m88ds3103_wr_reg(priv, 0xb2, 0x00);
         if (ret)
-                goto err;
+                goto error_fw_release;
 
         release_firmware(fw);
         fw = NULL;
@@ -623,10 +686,10 @@ skip_fw_download:
         priv->warm = true;
 
         return 0;
-err:
-        if (fw)
-                release_firmware(fw);
 
+error_fw_release:
+        release_firmware(fw);
+err:
         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
         return ret;
 }
@@ -635,13 +698,18 @@ static int m88ds3103_sleep(struct dvb_frontend *fe)
 {
         struct m88ds3103_priv *priv = fe->demodulator_priv;
         int ret;
+        u8 u8tmp;
 
         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 
         priv->delivery_system = SYS_UNDEFINED;
 
         /* TS Hi-Z */
-        ret = m88ds3103_wr_reg_mask(priv, 0x27, 0x00, 0x01);
+        if (priv->chip_id == M88RS6000_CHIP_ID)
+                u8tmp = 0x29;
+        else
+                u8tmp = 0x27;
+        ret = m88ds3103_wr_reg_mask(priv, u8tmp, 0x00, 0x01);
         if (ret)
                 goto err;
 
@@ -830,7 +898,7 @@ static int m88ds3103_get_frontend(struct dvb_frontend *fe)
                 goto err;
 
         c->symbol_rate = 1ull * ((buf[1] << 8) | (buf[0] << 0)) *
-                        M88DS3103_MCLK_KHZ * 1000 / 0x10000;
+                        priv->mclk_khz * 1000 / 0x10000;
 
         return 0;
 err:
@@ -1310,18 +1378,22 @@ struct dvb_frontend *m88ds3103_attach(const struct m88ds3103_config *cfg,
         priv->i2c = i2c;
         mutex_init(&priv->i2c_mutex);
 
-        ret = m88ds3103_rd_reg(priv, 0x01, &chip_id);
+        /* 0x00: chip id[6:0], 0x01: chip ver[7:0], 0x02: chip ver[15:8] */
+        ret = m88ds3103_rd_reg(priv, 0x00, &chip_id);
         if (ret)
                 goto err;
 
-        dev_dbg(&priv->i2c->dev, "%s: chip_id=%02x\n", __func__, chip_id);
+        chip_id >>= 1;
+        dev_info(&priv->i2c->dev, "%s: chip_id=%02x\n", __func__, chip_id);
 
         switch (chip_id) {
-        case 0xd0:
+        case M88RS6000_CHIP_ID:
+        case M88DS3103_CHIP_ID:
                 break;
         default:
                 goto err;
         }
+        priv->chip_id = chip_id;
 
         switch (priv->cfg->clock_out) {
         case M88DS3103_CLOCK_OUT_DISABLED:
@@ -1337,6 +1409,11 @@ struct dvb_frontend *m88ds3103_attach(const struct m88ds3103_config *cfg,
                 goto err;
         }
 
+        /* 0x29 register is defined differently for m88rs6000. */
+        /* set internal tuner address to 0x21 */
+        if (chip_id == M88RS6000_CHIP_ID)
+                u8tmp = 0x00;
+
         ret = m88ds3103_wr_reg(priv, 0x29, u8tmp);
         if (ret)
                 goto err;
@@ -1364,6 +1441,9 @@ struct dvb_frontend *m88ds3103_attach(const struct m88ds3103_config *cfg,
 
         /* create dvb_frontend */
         memcpy(&priv->fe.ops, &m88ds3103_ops, sizeof(struct dvb_frontend_ops));
+        if (priv->chip_id == M88RS6000_CHIP_ID)
+                strncpy(priv->fe.ops.info.name,
+                        "Montage M88RS6000", sizeof(priv->fe.ops.info.name));
         priv->fe.demodulator_priv = priv;
 
         return &priv->fe;
@@ -1423,3 +1503,4 @@ MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 MODULE_DESCRIPTION("Montage M88DS3103 DVB-S/S2 demodulator driver");
 MODULE_LICENSE("GPL");
 MODULE_FIRMWARE(M88DS3103_FIRMWARE);
+MODULE_FIRMWARE(M88RS6000_FIRMWARE);
diff --git a/drivers/media/dvb-frontends/m88ds3103_priv.h b/drivers/media/dvb-frontends/m88ds3103_priv.h
index 9169fdd143cf..a2c0958111f8 100644
--- a/drivers/media/dvb-frontends/m88ds3103_priv.h
+++ b/drivers/media/dvb-frontends/m88ds3103_priv.h
@@ -25,7 +25,10 @@
 #include <linux/math64.h>
 
 #define M88DS3103_FIRMWARE "dvb-demod-m88ds3103.fw"
+#define M88RS6000_FIRMWARE "dvb-demod-m88rs6000.fw"
 #define M88DS3103_MCLK_KHZ 96000
+#define M88RS6000_CHIP_ID 0x74
+#define M88DS3103_CHIP_ID 0x70
 
 struct m88ds3103_priv {
         struct i2c_adapter *i2c;
@@ -38,6 +41,10 @@ struct m88ds3103_priv {
         u32 ber;
         bool warm; /* FW running */
         struct i2c_adapter *i2c_adapter;
+        /* auto detect chip id to do different config */
+        u8 chip_id;
+        /* main mclk is calculated for M88RS6000 dynamically */
+        u32 mclk_khz;
 };
 
 struct m88ds3103_reg_val {
@@ -214,4 +221,178 @@ static const struct m88ds3103_reg_val m88ds3103_dvbs2_init_reg_vals[] = {
         {0xb8, 0x00},
 };
 
+static const struct m88ds3103_reg_val m88rs6000_dvbs_init_reg_vals[] = {
+        {0x23, 0x07},
+        {0x08, 0x03},
+        {0x0c, 0x02},
+        {0x20, 0x00},
+        {0x21, 0x54},
+        {0x25, 0x82},
+        {0x27, 0x31},
+        {0x30, 0x08},
+        {0x31, 0x40},
+        {0x32, 0x32},
+        {0x33, 0x35},
+        {0x35, 0xff},
+        {0x3a, 0x00},
+        {0x37, 0x10},
+        {0x38, 0x10},
+        {0x39, 0x02},
+        {0x42, 0x60},
+        {0x4a, 0x80},
+        {0x4b, 0x04},
+        {0x4d, 0x91},
+        {0x5d, 0xc8},
+        {0x50, 0x36},
+        {0x51, 0x36},
+        {0x52, 0x36},
+        {0x53, 0x36},
+        {0x63, 0x0f},
+        {0x64, 0x30},
+        {0x65, 0x40},
+        {0x68, 0x26},
+        {0x69, 0x4c},
+        {0x70, 0x20},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0x40},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0x60},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0x80},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0xa0},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0x1f},
+        {0x76, 0x38},
+        {0x77, 0xa6},
+        {0x78, 0x0c},
+        {0x79, 0x80},
+        {0x7f, 0x14},
+        {0x7c, 0x00},
+        {0xae, 0x82},
+        {0x80, 0x64},
+        {0x81, 0x66},
+        {0x82, 0x44},
+        {0x85, 0x04},
+        {0xcd, 0xf4},
+        {0x90, 0x33},
+        {0xa0, 0x44},
+        {0xbe, 0x00},
+        {0xc0, 0x08},
+        {0xc3, 0x10},
+        {0xc4, 0x08},
+        {0xc5, 0xf0},
+        {0xc6, 0xff},
+        {0xc7, 0x00},
+        {0xc8, 0x1a},
+        {0xc9, 0x80},
+        {0xe0, 0xf8},
+        {0xe6, 0x8b},
+        {0xd0, 0x40},
+        {0xf8, 0x20},
+        {0xfa, 0x0f},
+        {0x00, 0x00},
+        {0xbd, 0x01},
+        {0xb8, 0x00},
+        {0x29, 0x11},
+};
+
+static const struct m88ds3103_reg_val m88rs6000_dvbs2_init_reg_vals[] = {
+        {0x23, 0x07},
+        {0x08, 0x07},
+        {0x0c, 0x02},
+        {0x20, 0x00},
+        {0x21, 0x54},
+        {0x25, 0x82},
+        {0x27, 0x31},
+        {0x30, 0x08},
+        {0x32, 0x32},
+        {0x33, 0x35},
+        {0x35, 0xff},
+        {0x3a, 0x00},
+        {0x37, 0x10},
+        {0x38, 0x10},
+        {0x39, 0x02},
+        {0x42, 0x60},
+        {0x4a, 0x80},
+        {0x4b, 0x04},
+        {0x4d, 0x91},
+        {0x5d, 0xc8},
+        {0x50, 0x36},
+        {0x51, 0x36},
+        {0x52, 0x36},
+        {0x53, 0x36},
+        {0x63, 0x0f},
+        {0x64, 0x10},
+        {0x65, 0x20},
+        {0x68, 0x46},
+        {0x69, 0xcd},
+        {0x70, 0x20},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0x40},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0x60},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0x80},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0xa0},
+        {0x71, 0x70},
+        {0x72, 0x04},
+        {0x73, 0x00},
+        {0x70, 0x1f},
+        {0x76, 0x38},
+        {0x77, 0xa6},
+        {0x78, 0x0c},
+        {0x79, 0x80},
+        {0x7f, 0x14},
+        {0x85, 0x08},
+        {0xcd, 0xf4},
+        {0x90, 0x33},
+        {0x86, 0x00},
+        {0x87, 0x0f},
+        {0x89, 0x00},
+        {0x8b, 0x44},
+        {0x8c, 0x66},
+        {0x9d, 0xc1},
+        {0x8a, 0x10},
+        {0xad, 0x40},
+        {0xa0, 0x44},
+        {0xbe, 0x00},
+        {0xc0, 0x08},
+        {0xc1, 0x10},
+        {0xc2, 0x08},
+        {0xc3, 0x10},
+        {0xc4, 0x08},
+        {0xc5, 0xf0},
+        {0xc6, 0xff},
+        {0xc7, 0x00},
+        {0xc8, 0x1a},
+        {0xc9, 0x80},
+        {0xca, 0x23},
+        {0xcb, 0x24},
+        {0xcc, 0xf4},
+        {0xce, 0x74},
+        {0x00, 0x00},
+        {0xbd, 0x01},
+        {0xb8, 0x00},
+        {0x29, 0x01},
+};
 #endif
diff --git a/drivers/media/dvb-frontends/mn88472.h b/drivers/media/dvb-frontends/mn88472.h
new file mode 100644
index 000000000000..da4558bce60f
--- /dev/null
+++ b/drivers/media/dvb-frontends/mn88472.h
@@ -0,0 +1,38 @@
+/*
+ * Panasonic MN88472 DVB-T/T2/C demodulator driver
+ *
+ * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#ifndef MN88472_H
+#define MN88472_H
+
+#include <linux/dvb/frontend.h>
+
+struct mn88472_config {
+        /*
+         * Max num of bytes given I2C adapter could write at once.
+         * Default: none
+         */
+        u16 i2c_wr_max;
+
+
+        /* Everything after that is returned by the driver. */
+
+        /*
+         * DVB frontend.
+         */
+        struct dvb_frontend **fe;
+};
+
+#endif
diff --git a/drivers/media/dvb-frontends/mn88473.h b/drivers/media/dvb-frontends/mn88473.h
new file mode 100644
index 000000000000..a373ec93cbe0
--- /dev/null
+++ b/drivers/media/dvb-frontends/mn88473.h
@@ -0,0 +1,38 @@
+/*
+ * Panasonic MN88473 DVB-T/T2/C demodulator driver
+ *
+ * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#ifndef MN88473_H
+#define MN88473_H
+
+#include <linux/dvb/frontend.h>
+
+struct mn88473_config {
+        /*
+         * Max num of bytes given I2C adapter could write at once.
+         * Default: none
+         */
+        u16 i2c_wr_max;
+
+
+        /* Everything after that is returned by the driver. */
+
+        /*
+         * DVB frontend.
+         */
+        struct dvb_frontend **fe;
+};
+
+#endif
diff --git a/drivers/media/dvb-frontends/rtl2832.c b/drivers/media/dvb-frontends/rtl2832.c
index eb737cf29a36..9026e1aee163 100644
--- a/drivers/media/dvb-frontends/rtl2832.c
+++ b/drivers/media/dvb-frontends/rtl2832.c
@@ -258,13 +258,11 @@ static int rtl2832_rd_regs(struct rtl2832_priv *priv, u8 reg, u8 page, u8 *val,
         return rtl2832_rd(priv, reg, val, len);
 }
 
-#if 0 /* currently not used */
 /* write single register */
 static int rtl2832_wr_reg(struct rtl2832_priv *priv, u8 reg, u8 page, u8 val)
 {
         return rtl2832_wr_regs(priv, reg, page, &val, 1);
 }
-#endif
 
 /* read single register */
 static int rtl2832_rd_reg(struct rtl2832_priv *priv, u8 reg, u8 page, u8 *val)
@@ -599,6 +597,11 @@ static int rtl2832_set_frontend(struct dvb_frontend *fe)
         if (fe->ops.tuner_ops.set_params)
                 fe->ops.tuner_ops.set_params(fe);
 
+        /* PIP mode related */
+        ret = rtl2832_wr_regs(priv, 0x92, 1, "\x00\x0f\xff", 3);
+        if (ret)
+                goto err;
+
         /* If the frontend has get_if_frequency(), use it */
         if (fe->ops.tuner_ops.get_if_frequency) {
                 u32 if_freq;
@@ -661,7 +664,6 @@ static int rtl2832_set_frontend(struct dvb_frontend *fe)
         if (ret)
                 goto err;
 
-
         /* soft reset */
         ret = rtl2832_wr_demod_reg(priv, DVBT_SOFT_RST, 0x1);
         if (ret)
@@ -1020,6 +1022,58 @@ static int rtl2832_deselect(struct i2c_adapter *adap, void *mux_priv,
         return 0;
 }
 
+int rtl2832_enable_external_ts_if(struct dvb_frontend *fe)
+{
+        struct rtl2832_priv *priv = fe->demodulator_priv;
+        int ret;
+
+        dev_dbg(&priv->i2c->dev, "%s: setting PIP mode\n", __func__);
+
+        ret = rtl2832_wr_regs(priv, 0x0c, 1, "\x5f\xff", 2);
+        if (ret)
+                goto err;
+
+        ret = rtl2832_wr_demod_reg(priv, DVBT_PIP_ON, 0x1);
+        if (ret)
+                goto err;
+
+        ret = rtl2832_wr_reg(priv, 0xbc, 0, 0x18);
+        if (ret)
+                goto err;
+
+        ret = rtl2832_wr_reg(priv, 0x22, 0, 0x01);
+        if (ret)
+                goto err;
+
+        ret = rtl2832_wr_reg(priv, 0x26, 0, 0x1f);
+        if (ret)
+                goto err;
+
+        ret = rtl2832_wr_reg(priv, 0x27, 0, 0xff);
+        if (ret)
+                goto err;
+
+        ret = rtl2832_wr_regs(priv, 0x92, 1, "\x7f\xf7\xff", 3);
+        if (ret)
+                goto err;
+
+        /* soft reset */
+        ret = rtl2832_wr_demod_reg(priv, DVBT_SOFT_RST, 0x1);
+        if (ret)
+                goto err;
+
+        ret = rtl2832_wr_demod_reg(priv, DVBT_SOFT_RST, 0x0);
+        if (ret)
+                goto err;
+
+        return 0;
+err:
+        dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
+        return ret;
+
+}
+EXPORT_SYMBOL(rtl2832_enable_external_ts_if);
+
 struct i2c_adapter *rtl2832_get_i2c_adapter(struct dvb_frontend *fe)
 {
         struct rtl2832_priv *priv = fe->demodulator_priv;
diff --git a/drivers/media/dvb-frontends/rtl2832.h b/drivers/media/dvb-frontends/rtl2832.h
index cb3b6b0775b8..5254c1dfc8de 100644
--- a/drivers/media/dvb-frontends/rtl2832.h
+++ b/drivers/media/dvb-frontends/rtl2832.h
@@ -64,6 +64,10 @@ extern struct i2c_adapter *rtl2832_get_private_i2c_adapter(
         struct dvb_frontend *fe
 );
 
+extern int rtl2832_enable_external_ts_if(
+        struct dvb_frontend *fe
+);
+
 #else
 
 static inline struct dvb_frontend *rtl2832_attach(
@@ -89,6 +93,13 @@ static inline struct i2c_adapter *rtl2832_get_private_i2c_adapter(
         return NULL;
 }
 
+static inline int rtl2832_enable_external_ts_if(
+        struct dvb_frontend *fe
+)
+{
+        return -ENODEV;
+}
+
 #endif
 
 
diff --git a/drivers/media/dvb-frontends/rtl2832_sdr.c b/drivers/media/dvb-frontends/rtl2832_sdr.c
index 7bf98cf6bbe1..2896b47c29d8 100644
--- a/drivers/media/dvb-frontends/rtl2832_sdr.c
+++ b/drivers/media/dvb-frontends/rtl2832_sdr.c
@@ -1013,6 +1013,10 @@ static int rtl2832_sdr_start_streaming(struct vb2_queue *vq, unsigned int count)
         if (s->d->props->power_ctrl)
                 s->d->props->power_ctrl(s->d, 1);
 
+        /* enable ADC */
+        if (s->d->props->frontend_ctrl)
+                s->d->props->frontend_ctrl(s->fe, 1);
+
         set_bit(POWER_ON, &s->flags);
 
         ret = rtl2832_sdr_set_tuner(s);
@@ -1064,6 +1068,10 @@ static void rtl2832_sdr_stop_streaming(struct vb2_queue *vq)
 
         clear_bit(POWER_ON, &s->flags);
 
+        /* disable ADC */
+        if (s->d->props->frontend_ctrl)
+                s->d->props->frontend_ctrl(s->fe, 0);
+
         if (s->d->props->power_ctrl)
                 s->d->props->power_ctrl(s->d, 0);
 
diff --git a/drivers/media/dvb-frontends/si2168.c b/drivers/media/dvb-frontends/si2168.c
index 1cd93be281ed..ce9ab442b4b6 100644
--- a/drivers/media/dvb-frontends/si2168.c
+++ b/drivers/media/dvb-frontends/si2168.c
@@ -308,14 +308,16 @@ static int si2168_set_frontend(struct dvb_frontend *fe)
         if (ret)
                 goto err;
 
-        memcpy(cmd.args, "\x14\x00\x09\x10\xe3\x18", 6);
+        memcpy(cmd.args, "\x14\x00\x09\x10\xe3\x08", 6);
+        cmd.args[5] |= s->ts_clock_inv ? 0x00 : 0x10;
         cmd.wlen = 6;
         cmd.rlen = 4;
         ret = si2168_cmd_execute(s, &cmd);
         if (ret)
                 goto err;
 
-        memcpy(cmd.args, "\x14\x00\x08\x10\xd7\x15", 6);
+        memcpy(cmd.args, "\x14\x00\x08\x10\xd7\x05", 6);
+        cmd.args[5] |= s->ts_clock_inv ? 0x00 : 0x10;
         cmd.wlen = 6;
         cmd.rlen = 4;
         ret = si2168_cmd_execute(s, &cmd);
@@ -453,27 +455,45 @@ static int si2168_init(struct dvb_frontend *fe)
                         dev_err(&s->client->dev,
                                         "firmware file '%s' not found\n",
                                         fw_file);
-                        goto err;
+                        goto error_fw_release;
                 }
         }
 
         dev_info(&s->client->dev, "downloading firmware from file '%s'\n",
                         fw_file);
 
-        for (remaining = fw->size; remaining > 0; remaining -= i2c_wr_max) {
-                len = remaining;
-                if (len > i2c_wr_max)
-                        len = i2c_wr_max;
-
-                memcpy(cmd.args, &fw->data[fw->size - remaining], len);
-                cmd.wlen = len;
-                cmd.rlen = 1;
-                ret = si2168_cmd_execute(s, &cmd);
-                if (ret) {
-                        dev_err(&s->client->dev,
-                                        "firmware download failed=%d\n",
-                                        ret);
-                        goto err;
+        if ((fw->size % 17 == 0) && (fw->data[0] > 5)) {
+                /* firmware is in the new format */
+                for (remaining = fw->size; remaining > 0; remaining -= 17) {
+                        len = fw->data[fw->size - remaining];
+                        memcpy(cmd.args, &fw->data[(fw->size - remaining) + 1], len);
+                        cmd.wlen = len;
+                        cmd.rlen = 1;
+                        ret = si2168_cmd_execute(s, &cmd);
+                        if (ret) {
+                                dev_err(&s->client->dev,
+                                                "firmware download failed=%d\n",
+                                                ret);
+                                goto error_fw_release;
+                        }
+                }
+        } else {
+                /* firmware is in the old format */
+                for (remaining = fw->size; remaining > 0; remaining -= i2c_wr_max) {
+                        len = remaining;
+                        if (len > i2c_wr_max)
+                                len = i2c_wr_max;
+
+                        memcpy(cmd.args, &fw->data[fw->size - remaining], len);
+                        cmd.wlen = len;
+                        cmd.rlen = 1;
+                        ret = si2168_cmd_execute(s, &cmd);
+                        if (ret) {
+                                dev_err(&s->client->dev,
+                                                "firmware download failed=%d\n",
+                                                ret);
+                                goto error_fw_release;
+                        }
                 }
         }
 
@@ -487,6 +507,17 @@ static int si2168_init(struct dvb_frontend *fe)
         if (ret)
                 goto err;
 
+        /* query firmware version */
+        memcpy(cmd.args, "\x11", 1);
+        cmd.wlen = 1;
+        cmd.rlen = 10;
+        ret = si2168_cmd_execute(s, &cmd);
+        if (ret)
+                goto err;
+
+        dev_dbg(&s->client->dev, "firmware version: %c.%c.%d\n",
+                        cmd.args[6], cmd.args[7], cmd.args[8]);
+
         /* set ts mode */
         memcpy(cmd.args, "\x14\x00\x01\x10\x10\x00", 6);
         cmd.args[4] |= s->ts_mode;
@@ -498,17 +529,16 @@ static int si2168_init(struct dvb_frontend *fe)
 
         s->fw_loaded = true;
 
-warm:
         dev_info(&s->client->dev, "found a '%s' in warm state\n",
                         si2168_ops.info.name);
-
+warm:
         s->active = true;
 
         return 0;
-err:
-        if (fw)
-                release_firmware(fw);
 
+error_fw_release:
+        release_firmware(fw);
+err:
         dev_dbg(&s->client->dev, "failed=%d\n", ret);
         return ret;
 }
@@ -670,6 +700,7 @@ static int si2168_probe(struct i2c_client *client,
         *config->i2c_adapter = s->adapter;
         *config->fe = &s->fe;
         s->ts_mode = config->ts_mode;
+        s->ts_clock_inv = config->ts_clock_inv;
         s->fw_loaded = false;
 
         i2c_set_clientdata(client, s);
diff --git a/drivers/media/dvb-frontends/si2168.h b/drivers/media/dvb-frontends/si2168.h
index e086d6719451..87bc12146667 100644
--- a/drivers/media/dvb-frontends/si2168.h
+++ b/drivers/media/dvb-frontends/si2168.h
@@ -37,6 +37,10 @@ struct si2168_config {
 
         /* TS mode */
         u8 ts_mode;
+
+        /* TS clock inverted */
+        bool ts_clock_inv;
+
 };
 
 #define SI2168_TS_PARALLEL      0x06
diff --git a/drivers/media/dvb-frontends/si2168_priv.h b/drivers/media/dvb-frontends/si2168_priv.h
index e13983ed4be1..60bc3349b6c3 100644
--- a/drivers/media/dvb-frontends/si2168_priv.h
+++ b/drivers/media/dvb-frontends/si2168_priv.h
@@ -38,6 +38,7 @@ struct si2168 {
         bool active;
         bool fw_loaded;
         u8 ts_mode;
+        bool ts_clock_inv;
 };
 
 /* firmare command struct */
diff --git a/drivers/media/dvb-frontends/sp2.c b/drivers/media/dvb-frontends/sp2.c
index 15bf4318cb74..cc1ef966f99f 100644
--- a/drivers/media/dvb-frontends/sp2.c
+++ b/drivers/media/dvb-frontends/sp2.c
@@ -92,6 +92,9 @@ static int sp2_write_i2c(struct sp2 *s, u8 reg, u8 *buf, int len)
                         return -EIO;
         }
 
+        dev_dbg(&s->client->dev, "addr=0x%04x, reg = 0x%02x, data = %*ph\n",
+                                client->addr, reg, len, buf);
+
         return 0;
 }
 
@@ -103,9 +106,6 @@ static int sp2_ci_op_cam(struct dvb_ca_en50221 *en50221, int slot, u8 acs,
         int mem, ret;
         int (*ci_op_cam)(void*, u8, int, u8, int*) = s->ci_control;
 
-        dev_dbg(&s->client->dev, "slot=%d, acs=0x%02x, addr=0x%04x, data = 0x%02x",
-                        slot, acs, addr, data);
-
         if (slot != 0)
                 return -EINVAL;
 
@@ -140,13 +140,16 @@ static int sp2_ci_op_cam(struct dvb_ca_en50221 *en50221, int slot, u8 acs,
         if (ret)
                 return ret;
 
-        if (read) {
-                dev_dbg(&s->client->dev, "cam read, addr=0x%04x, data = 0x%04x",
-                                addr, mem);
+        dev_dbg(&s->client->dev, "%s: slot=%d, addr=0x%04x, %s, data=%x",
+                        (read) ? "read" : "write", slot, addr,
+                        (acs == SP2_CI_ATTR_ACS) ? "attr" : "io",
+                        (read) ? mem : data);
+
+        if (read)
                 return mem;
-        } else {
+        else
                 return 0;
-        }
+
 }
 
 int sp2_ci_read_attribute_mem(struct dvb_ca_en50221 *en50221,
@@ -407,7 +410,7 @@ err:
 
 static int sp2_remove(struct i2c_client *client)
 {
-        struct si2157 *s = i2c_get_clientdata(client);
+        struct sp2 *s = i2c_get_clientdata(client);
 
         dev_dbg(&client->dev, "\n");
 
diff --git a/drivers/media/dvb-frontends/stb0899_drv.c b/drivers/media/dvb-frontends/stb0899_drv.c
index 07cd5ea7a038..19646fbb061d 100644
--- a/drivers/media/dvb-frontends/stb0899_drv.c
+++ b/drivers/media/dvb-frontends/stb0899_drv.c
@@ -705,7 +705,7 @@ static int stb0899_send_diseqc_msg(struct dvb_frontend *fe, struct dvb_diseqc_ma
         struct stb0899_state *state = fe->demodulator_priv;
         u8 reg, i;
 
-        if (cmd->msg_len > 8)
+        if (cmd->msg_len > sizeof(cmd->msg))
                 return -EINVAL;
 
         /* enable FIFO precharge        */
diff --git a/drivers/media/dvb-frontends/stv090x.c b/drivers/media/dvb-frontends/stv090x.c
index 23e872f84742..0b2a934f53e5 100644
--- a/drivers/media/dvb-frontends/stv090x.c
+++ b/drivers/media/dvb-frontends/stv090x.c
@@ -2146,7 +2146,7 @@ static int stv090x_get_coldlock(struct stv090x_state *state, s32 timeout_dmd)
 
         u32 reg;
         s32 car_step, steps, cur_step, dir, freq, timeout_lock;
-        int lock = 0;
+        int lock;
 
         if (state->srate >= 10000000)
                 timeout_lock = timeout_dmd / 3;
@@ -2154,98 +2154,96 @@ static int stv090x_get_coldlock(struct stv090x_state *state, s32 timeout_dmd)
                 timeout_lock = timeout_dmd / 2;
 
         lock = stv090x_get_dmdlock(state, timeout_lock); /* cold start wait */
-        if (!lock) {
-                if (state->srate >= 10000000) {
-                        if (stv090x_chk_tmg(state)) {
-                                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
-                                        goto err;
-                                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x15) < 0)
-                                        goto err;
-                                lock = stv090x_get_dmdlock(state, timeout_dmd);
-                        } else {
-                                lock = 0;
-                        }
-                } else {
-                        if (state->srate <= 4000000)
-                                car_step = 1000;
-                        else if (state->srate <= 7000000)
-                                car_step = 2000;
-                        else if (state->srate <= 10000000)
-                                car_step = 3000;
-                        else
-                                car_step = 5000;
-
-                        steps  = (state->search_range / 1000) / car_step;
-                        steps /= 2;
-                        steps  = 2 * (steps + 1);
-                        if (steps < 0)
-                                steps = 2;
-                        else if (steps > 12)
-                                steps = 12;
-
-                        cur_step = 1;
-                        dir = 1;
-
-                        if (!lock) {
-                                freq = state->frequency;
-                                state->tuner_bw = stv090x_car_width(state->srate, state->rolloff) + state->srate;
-                                while ((cur_step <= steps) && (!lock)) {
-                                        if (dir > 0)
-                                                freq += cur_step * car_step;
-                                        else
-                                                freq -= cur_step * car_step;
-
-                                        /* Setup tuner */
-                                        if (stv090x_i2c_gate_ctrl(state, 1) < 0)
-                                                goto err;
+        if (lock)
+                return lock;
 
-                                        if (state->config->tuner_set_frequency) {
-                                                if (state->config->tuner_set_frequency(fe, freq) < 0)
-                                                        goto err_gateoff;
-                                        }
+        if (state->srate >= 10000000) {
+                if (stv090x_chk_tmg(state)) {
+                        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
+                                goto err;
+                        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x15) < 0)
+                                goto err;
+                        return stv090x_get_dmdlock(state, timeout_dmd);
+                }
+                return 0;
+        }
 
-                                        if (state->config->tuner_set_bandwidth) {
-                                                if (state->config->tuner_set_bandwidth(fe, state->tuner_bw) < 0)
-                                                        goto err_gateoff;
-                                        }
+        if (state->srate <= 4000000)
+                car_step = 1000;
+        else if (state->srate <= 7000000)
+                car_step = 2000;
+        else if (state->srate <= 10000000)
+                car_step = 3000;
+        else
+                car_step = 5000;
 
-                                        if (stv090x_i2c_gate_ctrl(state, 0) < 0)
-                                                goto err;
+        steps  = (state->search_range / 1000) / car_step;
+        steps /= 2;
+        steps  = 2 * (steps + 1);
+        if (steps < 0)
+                steps = 2;
+        else if (steps > 12)
+                steps = 12;
 
-                                        msleep(50);
+        cur_step = 1;
+        dir = 1;
 
-                                        if (stv090x_i2c_gate_ctrl(state, 1) < 0)
-                                                goto err;
+        freq = state->frequency;
+        state->tuner_bw = stv090x_car_width(state->srate, state->rolloff) + state->srate;
+        while ((cur_step <= steps) && (!lock)) {
+                if (dir > 0)
+                        freq += cur_step * car_step;
+                else
+                        freq -= cur_step * car_step;
 
-                                        if (state->config->tuner_get_status) {
-                                                if (state->config->tuner_get_status(fe, &reg) < 0)
-                                                        goto err_gateoff;
-                                        }
+                /* Setup tuner */
+                if (stv090x_i2c_gate_ctrl(state, 1) < 0)
+                        goto err;
 
-                                        if (reg)
-                                                dprintk(FE_DEBUG, 1, "Tuner phase locked");
-                                        else
-                                                dprintk(FE_DEBUG, 1, "Tuner unlocked");
+                if (state->config->tuner_set_frequency) {
+                        if (state->config->tuner_set_frequency(fe, freq) < 0)
+                                goto err_gateoff;
+                }
 
-                                        if (stv090x_i2c_gate_ctrl(state, 0) < 0)
-                                                goto err;
+                if (state->config->tuner_set_bandwidth) {
+                        if (state->config->tuner_set_bandwidth(fe, state->tuner_bw) < 0)
+                                goto err_gateoff;
+                }
 
-                                        STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1c);
-                                        if (STV090x_WRITE_DEMOD(state, CFRINIT1, 0x00) < 0)
-                                                goto err;
-                                        if (STV090x_WRITE_DEMOD(state, CFRINIT0, 0x00) < 0)
-                                                goto err;
-                                        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
-                                                goto err;
-                                        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x15) < 0)
-                                                goto err;
-                                        lock = stv090x_get_dmdlock(state, (timeout_dmd / 3));
+                if (stv090x_i2c_gate_ctrl(state, 0) < 0)
+                        goto err;
 
-                                        dir *= -1;
-                                        cur_step++;
-                                }
-                        }
+                msleep(50);
+
+                if (stv090x_i2c_gate_ctrl(state, 1) < 0)
+                        goto err;
+
+                if (state->config->tuner_get_status) {
+                        if (state->config->tuner_get_status(fe, &reg) < 0)
+                                goto err_gateoff;
                 }
+
+                if (reg)
+                        dprintk(FE_DEBUG, 1, "Tuner phase locked");
+                else
+                        dprintk(FE_DEBUG, 1, "Tuner unlocked");
+
+                if (stv090x_i2c_gate_ctrl(state, 0) < 0)
+                        goto err;
+
+                STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1c);
+                if (STV090x_WRITE_DEMOD(state, CFRINIT1, 0x00) < 0)
+                        goto err;
+                if (STV090x_WRITE_DEMOD(state, CFRINIT0, 0x00) < 0)
+                        goto err;
+                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
+                        goto err;
+                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x15) < 0)
+                        goto err;
+                lock = stv090x_get_dmdlock(state, (timeout_dmd / 3));
+
+                dir *= -1;
+                cur_step++;
         }
 
         return lock;
@@ -2663,13 +2661,9 @@ static enum stv090x_signal_state stv090x_get_sig_params(struct stv090x_state *st
                         return STV090x_RANGEOK;
                 else if (abs(offst_freq) <= (stv090x_car_width(state->srate, state->rolloff) / 2000))
                         return STV090x_RANGEOK;
-                else
-                        return STV090x_OUTOFRANGE; /* Out of Range */
         } else {
                 if (abs(offst_freq) <= ((state->search_range / 2000) + 500))
                         return STV090x_RANGEOK;
-                else
-                        return STV090x_OUTOFRANGE;
         }
 
         return STV090x_OUTOFRANGE;
@@ -2789,6 +2783,12 @@ static u8 stv090x_optimize_carloop(struct stv090x_state *state, enum stv090x_mod
                                 aclc = car_loop[i].crl_pilots_off_30;
                 }
         } else { /* 16APSK and 32APSK */
+                /*
+                 * This should never happen in practice, except if
+                 * something is really wrong at the car_loop table.
+                 */
+                if (i >= 11)
+                        i = 10;
                 if (state->srate <= 3000000)
                         aclc = car_loop_apsk_low[i].crl_pilots_on_2;
                 else if (state->srate <= 7000000)
@@ -3470,7 +3470,20 @@ static enum dvbfe_search stv090x_search(struct dvb_frontend *fe)
         if (props->frequency == 0)
                 return DVBFE_ALGO_SEARCH_INVALID;
 
-        state->delsys = props->delivery_system;
+        switch (props->delivery_system) {
+        case SYS_DSS:
+                state->delsys = STV090x_DSS;
+                break;
+        case SYS_DVBS:
+                state->delsys = STV090x_DVBS1;
+                break;
+        case SYS_DVBS2:
+                state->delsys = STV090x_DVBS2;
+                break;
+        default:
+                return DVBFE_ALGO_SEARCH_INVALID;
+        }
+
         state->frequency = props->frequency;
         state->srate = props->symbol_rate;
         state->search_mode = STV090x_SEARCH_AUTO;
@@ -4859,8 +4872,8 @@ err:
         return -1;
 }
 
-int stv090x_set_gpio(struct dvb_frontend *fe, u8 gpio, u8 dir, u8 value,
-                u8 xor_value)
+static int stv090x_set_gpio(struct dvb_frontend *fe, u8 gpio, u8 dir,
+                            u8 value, u8 xor_value)
 {
         struct stv090x_state *state = fe->demodulator_priv;
         u8 reg = 0;
@@ -4871,7 +4884,6 @@ int stv090x_set_gpio(struct dvb_frontend *fe, u8 gpio, u8 dir, u8 value,
 
         return stv090x_write_reg(state, STV090x_GPIOxCFG(gpio), reg);
 }
-EXPORT_SYMBOL(stv090x_set_gpio);
 
 static struct dvb_frontend_ops stv090x_ops = {
         .delsys = { SYS_DVBS, SYS_DVBS2, SYS_DSS },
@@ -4908,7 +4920,7 @@ static struct dvb_frontend_ops stv090x_ops = {
 };
 
 
-struct dvb_frontend *stv090x_attach(const struct stv090x_config *config,
+struct dvb_frontend *stv090x_attach(struct stv090x_config *config,
                                     struct i2c_adapter *i2c,
                                     enum stv090x_demodulator demod)
 {
@@ -4969,6 +4981,8 @@ struct dvb_frontend *stv090x_attach(const struct stv090x_config *config,
         if (config->diseqc_envelope_mode)
                 stv090x_send_diseqc_burst(&state->frontend, SEC_MINI_A);
 
+        config->set_gpio = stv090x_set_gpio;
+
         dprintk(FE_ERROR, 1, "Attaching %s demodulator(%d) Cut=0x%02x",
                state->device == STV0900 ? "STV0900" : "STV0903",
                demod,
diff --git a/drivers/media/dvb-frontends/stv090x.h b/drivers/media/dvb-frontends/stv090x.h
index 0bd6adcfee8a..742eeda99000 100644
--- a/drivers/media/dvb-frontends/stv090x.h
+++ b/drivers/media/dvb-frontends/stv090x.h
@@ -89,29 +89,29 @@ struct stv090x_config {
 
         bool diseqc_envelope_mode;
 
-        int (*tuner_init) (struct dvb_frontend *fe);
-        int (*tuner_sleep) (struct dvb_frontend *fe);
-        int (*tuner_set_mode) (struct dvb_frontend *fe, enum tuner_mode mode);
-        int (*tuner_set_frequency) (struct dvb_frontend *fe, u32 frequency);
-        int (*tuner_get_frequency) (struct dvb_frontend *fe, u32 *frequency);
-        int (*tuner_set_bandwidth) (struct dvb_frontend *fe, u32 bandwidth);
-        int (*tuner_get_bandwidth) (struct dvb_frontend *fe, u32 *bandwidth);
-        int (*tuner_set_bbgain) (struct dvb_frontend *fe, u32 gain);
-        int (*tuner_get_bbgain) (struct dvb_frontend *fe, u32 *gain);
-        int (*tuner_set_refclk)  (struct dvb_frontend *fe, u32 refclk);
-        int (*tuner_get_status) (struct dvb_frontend *fe, u32 *status);
-        void (*tuner_i2c_lock) (struct dvb_frontend *fe, int lock);
+        int (*tuner_init)(struct dvb_frontend *fe);
+        int (*tuner_sleep)(struct dvb_frontend *fe);
+        int (*tuner_set_mode)(struct dvb_frontend *fe, enum tuner_mode mode);
+        int (*tuner_set_frequency)(struct dvb_frontend *fe, u32 frequency);
+        int (*tuner_get_frequency)(struct dvb_frontend *fe, u32 *frequency);
+        int (*tuner_set_bandwidth)(struct dvb_frontend *fe, u32 bandwidth);
+        int (*tuner_get_bandwidth)(struct dvb_frontend *fe, u32 *bandwidth);
+        int (*tuner_set_bbgain)(struct dvb_frontend *fe, u32 gain);
+        int (*tuner_get_bbgain)(struct dvb_frontend *fe, u32 *gain);
+        int (*tuner_set_refclk)(struct dvb_frontend *fe, u32 refclk);
+        int (*tuner_get_status)(struct dvb_frontend *fe, u32 *status);
+        void (*tuner_i2c_lock)(struct dvb_frontend *fe, int lock);
+
+        /* dir = 0 -> output, dir = 1 -> input/open-drain */
+        int (*set_gpio)(struct dvb_frontend *fe, u8 gpio, u8 dir, u8 value,
+                        u8 xor_value);
 };
 
 #if IS_ENABLED(CONFIG_DVB_STV090x)
 
-extern struct dvb_frontend *stv090x_attach(const struct stv090x_config *config,
-                                           struct i2c_adapter *i2c,
-                                           enum stv090x_demodulator demod);
-
-/* dir = 0 -> output, dir = 1 -> input/open-drain */
-extern int stv090x_set_gpio(struct dvb_frontend *fe, u8 gpio,
-                u8 dir, u8 value, u8 xor_value);
+struct dvb_frontend *stv090x_attach(struct stv090x_config *config,
+                                    struct i2c_adapter *i2c,
+                                    enum stv090x_demodulator demod);
 
 #else
 
@@ -123,12 +123,6 @@ static inline struct dvb_frontend *stv090x_attach(const struct stv090x_config *c
         return NULL;
 }
 
-static inline int stv090x_set_gpio(struct dvb_frontend *fe, u8 gpio,
-                u8 opd, u8 value, u8 xor_value)
-{
-        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-        return -ENODEV;
-}
 #endif /* CONFIG_DVB_STV090x */
 
 #endif /* __STV090x_H */
diff --git a/drivers/media/firewire/firedtv-ci.c b/drivers/media/firewire/firedtv-ci.c
index e5ebdbfe8c19..e63f582378bf 100644
--- a/drivers/media/firewire/firedtv-ci.c
+++ b/drivers/media/firewire/firedtv-ci.c
@@ -253,6 +253,5 @@ int fdtv_ca_register(struct firedtv *fdtv)
 
 void fdtv_ca_release(struct firedtv *fdtv)
 {
-        if (fdtv->cadev)
-                dvb_unregister_device(fdtv->cadev);
+        dvb_unregister_device(fdtv->cadev);
 }
diff --git a/drivers/media/firewire/firedtv.h b/drivers/media/firewire/firedtv.h
index c2ba085e0d20..346a85be6de2 100644
--- a/drivers/media/firewire/firedtv.h
+++ b/drivers/media/firewire/firedtv.h
@@ -96,7 +96,7 @@ struct firedtv {
 
         enum model_type         type;
         char                    subunit;
-        char                    isochannel;
+        s8                      isochannel;
         struct fdtv_ir_context  *ir_context;
 
         fe_sec_voltage_t        voltage;
diff --git a/drivers/media/i2c/adv7170.c b/drivers/media/i2c/adv7170.c
index 04bb29720aaf..40a1a95c7ce9 100644
--- a/drivers/media/i2c/adv7170.c
+++ b/drivers/media/i2c/adv7170.c
@@ -63,9 +63,9 @@ static inline struct adv7170 *to_adv7170(struct v4l2_subdev *sd)
 
 static char *inputs[] = { "pass_through", "play_back" };
 
-static enum v4l2_mbus_pixelcode adv7170_codes[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_UYVY8_1X16,
+static u32 adv7170_codes[] = {
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_UYVY8_1X16,
 };
 
 /* ----------------------------------------------------------------------- */
@@ -263,7 +263,7 @@ static int adv7170_s_routing(struct v4l2_subdev *sd,
 }
 
 static int adv7170_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                                enum v4l2_mbus_pixelcode *code)
+                                u32 *code)
 {
         if (index >= ARRAY_SIZE(adv7170_codes))
                 return -EINVAL;
@@ -278,9 +278,9 @@ static int adv7170_g_fmt(struct v4l2_subdev *sd,
         u8 val = adv7170_read(sd, 0x7);
 
         if ((val & 0x40) == (1 << 6))
-                mf->code = V4L2_MBUS_FMT_UYVY8_1X16;
+                mf->code = MEDIA_BUS_FMT_UYVY8_1X16;
         else
-                mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+                mf->code = MEDIA_BUS_FMT_UYVY8_2X8;
 
         mf->colorspace  = V4L2_COLORSPACE_SMPTE170M;
         mf->width       = 0;
@@ -297,11 +297,11 @@ static int adv7170_s_fmt(struct v4l2_subdev *sd,
         int ret;
 
         switch (mf->code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 val &= ~0x40;
                 break;
 
-        case V4L2_MBUS_FMT_UYVY8_1X16:
+        case MEDIA_BUS_FMT_UYVY8_1X16:
                 val |= 0x40;
                 break;
 
diff --git a/drivers/media/i2c/adv7175.c b/drivers/media/i2c/adv7175.c
index b88f3b3d5ed9..d220af579a64 100644
--- a/drivers/media/i2c/adv7175.c
+++ b/drivers/media/i2c/adv7175.c
@@ -60,9 +60,9 @@ static inline struct adv7175 *to_adv7175(struct v4l2_subdev *sd)
 
 static char *inputs[] = { "pass_through", "play_back", "color_bar" };
 
-static enum v4l2_mbus_pixelcode adv7175_codes[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_UYVY8_1X16,
+static u32 adv7175_codes[] = {
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_UYVY8_1X16,
 };
 
 /* ----------------------------------------------------------------------- */
@@ -301,7 +301,7 @@ static int adv7175_s_routing(struct v4l2_subdev *sd,
 }
 
 static int adv7175_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                                enum v4l2_mbus_pixelcode *code)
+                                u32 *code)
 {
         if (index >= ARRAY_SIZE(adv7175_codes))
                 return -EINVAL;
@@ -316,9 +316,9 @@ static int adv7175_g_fmt(struct v4l2_subdev *sd,
         u8 val = adv7175_read(sd, 0x7);
 
         if ((val & 0x40) == (1 << 6))
-                mf->code = V4L2_MBUS_FMT_UYVY8_1X16;
+                mf->code = MEDIA_BUS_FMT_UYVY8_1X16;
         else
-                mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+                mf->code = MEDIA_BUS_FMT_UYVY8_2X8;
 
         mf->colorspace  = V4L2_COLORSPACE_SMPTE170M;
         mf->width       = 0;
@@ -335,11 +335,11 @@ static int adv7175_s_fmt(struct v4l2_subdev *sd,
         int ret;
 
         switch (mf->code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 val &= ~0x40;
                 break;
 
-        case V4L2_MBUS_FMT_UYVY8_1X16:
+        case MEDIA_BUS_FMT_UYVY8_1X16:
                 val |= 0x40;
                 break;
 
diff --git a/drivers/media/i2c/adv7180.c b/drivers/media/i2c/adv7180.c
index 821178dcb08e..bffe6eb528a3 100644
--- a/drivers/media/i2c/adv7180.c
+++ b/drivers/media/i2c/adv7180.c
@@ -422,12 +422,12 @@ static void adv7180_exit_controls(struct adv7180_state *state)
 }
 
 static int adv7180_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned int index,
-                                 enum v4l2_mbus_pixelcode *code)
+                                 u32 *code)
 {
         if (index > 0)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_YUYV8_2X8;
+        *code = MEDIA_BUS_FMT_YUYV8_2X8;
 
         return 0;
 }
@@ -437,7 +437,7 @@ static int adv7180_mbus_fmt(struct v4l2_subdev *sd,
 {
         struct adv7180_state *state = to_state(sd);
 
-        fmt->code = V4L2_MBUS_FMT_YUYV8_2X8;
+        fmt->code = MEDIA_BUS_FMT_YUYV8_2X8;
         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
         fmt->field = V4L2_FIELD_INTERLACED;
         fmt->width = 720;
diff --git a/drivers/media/i2c/adv7183.c b/drivers/media/i2c/adv7183.c
index df461b07b2f7..28940cc3a766 100644
--- a/drivers/media/i2c/adv7183.c
+++ b/drivers/media/i2c/adv7183.c
@@ -421,12 +421,12 @@ static int adv7183_g_input_status(struct v4l2_subdev *sd, u32 *status)
 }
 
 static int adv7183_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
-                                enum v4l2_mbus_pixelcode *code)
+                                u32 *code)
 {
         if (index > 0)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_UYVY8_2X8;
+        *code = MEDIA_BUS_FMT_UYVY8_2X8;
         return 0;
 }
 
@@ -435,7 +435,7 @@ static int adv7183_try_mbus_fmt(struct v4l2_subdev *sd,
 {
         struct adv7183 *decoder = to_adv7183(sd);
 
-        fmt->code = V4L2_MBUS_FMT_UYVY8_2X8;
+        fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
         if (decoder->std & V4L2_STD_525_60) {
                 fmt->field = V4L2_FIELD_SEQ_TB;
diff --git a/drivers/media/i2c/adv7511.c b/drivers/media/i2c/adv7511.c
index f98acf4aafd4..81736aaf0f31 100644
--- a/drivers/media/i2c/adv7511.c
+++ b/drivers/media/i2c/adv7511.c
@@ -26,6 +26,7 @@
 #include <linux/videodev2.h>
 #include <linux/gpio.h>
 #include <linux/workqueue.h>
+#include <linux/hdmi.h>
 #include <linux/v4l2-dv-timings.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-common.h>
@@ -96,6 +97,10 @@ struct adv7511_state {
         bool have_monitor;
         /* timings from s_dv_timings */
         struct v4l2_dv_timings dv_timings;
+        u32 fmt_code;
+        u32 colorspace;
+        u32 ycbcr_enc;
+        u32 quantization;
         /* controls */
         struct v4l2_ctrl *hdmi_mode_ctrl;
         struct v4l2_ctrl *hotplug_ctrl;
@@ -779,26 +784,234 @@ static int adv7511_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
 {
         struct adv7511_state *state = get_adv7511_state(sd);
 
+        memset(edid->reserved, 0, sizeof(edid->reserved));
+
         if (edid->pad != 0)
                 return -EINVAL;
-        if ((edid->blocks == 0) || (edid->blocks > 256))
-                return -EINVAL;
-        if (!state->edid.segments) {
-                v4l2_dbg(1, debug, sd, "EDID segment 0 not found\n");
-                return -ENODATA;
+
+        if (edid->start_block == 0 && edid->blocks == 0) {
+                edid->blocks = state->edid.segments * 2;
+                return 0;
         }
+
+        if (state->edid.segments == 0)
+                return -ENODATA;
+
         if (edid->start_block >= state->edid.segments * 2)
-                return -E2BIG;
-        if ((edid->blocks + edid->start_block) >= state->edid.segments * 2)
+                return -EINVAL;
+
+        if (edid->start_block + edid->blocks > state->edid.segments * 2)
                 edid->blocks = state->edid.segments * 2 - edid->start_block;
 
         memcpy(edid->edid, &state->edid.data[edid->start_block * 128],
                         128 * edid->blocks);
+
+        return 0;
+}
+
+static int adv7511_enum_mbus_code(struct v4l2_subdev *sd,
+                                  struct v4l2_subdev_fh *fh,
+                                  struct v4l2_subdev_mbus_code_enum *code)
+{
+        if (code->pad != 0)
+                return -EINVAL;
+
+        switch (code->index) {
+        case 0:
+                code->code = MEDIA_BUS_FMT_RGB888_1X24;
+                break;
+        case 1:
+                code->code = MEDIA_BUS_FMT_YUYV8_1X16;
+                break;
+        case 2:
+                code->code = MEDIA_BUS_FMT_UYVY8_1X16;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static void adv7511_fill_format(struct adv7511_state *state,
+                                struct v4l2_mbus_framefmt *format)
+{
+        memset(format, 0, sizeof(*format));
+
+        format->width = state->dv_timings.bt.width;
+        format->height = state->dv_timings.bt.height;
+        format->field = V4L2_FIELD_NONE;
+}
+
+static int adv7511_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
+                              struct v4l2_subdev_format *format)
+{
+        struct adv7511_state *state = get_adv7511_state(sd);
+
+        if (format->pad != 0)
+                return -EINVAL;
+
+        adv7511_fill_format(state, &format->format);
+
+        if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
+                struct v4l2_mbus_framefmt *fmt;
+
+                fmt = v4l2_subdev_get_try_format(fh, format->pad);
+                format->format.code = fmt->code;
+                format->format.colorspace = fmt->colorspace;
+                format->format.ycbcr_enc = fmt->ycbcr_enc;
+                format->format.quantization = fmt->quantization;
+        } else {
+                format->format.code = state->fmt_code;
+                format->format.colorspace = state->colorspace;
+                format->format.ycbcr_enc = state->ycbcr_enc;
+                format->format.quantization = state->quantization;
+        }
+
+        return 0;
+}
+
+static int adv7511_set_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
+                       struct v4l2_subdev_format *format)
+{
+        struct adv7511_state *state = get_adv7511_state(sd);
+        /*
+         * Bitfield namings come the CEA-861-F standard, table 8 "Auxiliary
+         * Video Information (AVI) InfoFrame Format"
+         *
+         * c = Colorimetry
+         * ec = Extended Colorimetry
+         * y = RGB or YCbCr
+         * q = RGB Quantization Range
+         * yq = YCC Quantization Range
+         */
+        u8 c = HDMI_COLORIMETRY_NONE;
+        u8 ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+        u8 y = HDMI_COLORSPACE_RGB;
+        u8 q = HDMI_QUANTIZATION_RANGE_DEFAULT;
+        u8 yq = HDMI_YCC_QUANTIZATION_RANGE_LIMITED;
+
+        if (format->pad != 0)
+                return -EINVAL;
+        switch (format->format.code) {
+        case MEDIA_BUS_FMT_UYVY8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_RGB888_1X24:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        adv7511_fill_format(state, &format->format);
+        if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
+                struct v4l2_mbus_framefmt *fmt;
+
+                fmt = v4l2_subdev_get_try_format(fh, format->pad);
+                fmt->code = format->format.code;
+                fmt->colorspace = format->format.colorspace;
+                fmt->ycbcr_enc = format->format.ycbcr_enc;
+                fmt->quantization = format->format.quantization;
+                return 0;
+        }
+
+        switch (format->format.code) {
+        case MEDIA_BUS_FMT_UYVY8_1X16:
+                adv7511_wr_and_or(sd, 0x15, 0xf0, 0x01);
+                adv7511_wr_and_or(sd, 0x16, 0x03, 0xb8);
+                y = HDMI_COLORSPACE_YUV422;
+                break;
+        case MEDIA_BUS_FMT_YUYV8_1X16:
+                adv7511_wr_and_or(sd, 0x15, 0xf0, 0x01);
+                adv7511_wr_and_or(sd, 0x16, 0x03, 0xbc);
+                y = HDMI_COLORSPACE_YUV422;
+                break;
+        case MEDIA_BUS_FMT_RGB888_1X24:
+        default:
+                adv7511_wr_and_or(sd, 0x15, 0xf0, 0x00);
+                adv7511_wr_and_or(sd, 0x16, 0x03, 0x00);
+                break;
+        }
+        state->fmt_code = format->format.code;
+        state->colorspace = format->format.colorspace;
+        state->ycbcr_enc = format->format.ycbcr_enc;
+        state->quantization = format->format.quantization;
+
+        switch (format->format.colorspace) {
+        case V4L2_COLORSPACE_ADOBERGB:
+                c = HDMI_COLORIMETRY_EXTENDED;
+                ec = y ? HDMI_EXTENDED_COLORIMETRY_ADOBE_YCC_601 :
+                         HDMI_EXTENDED_COLORIMETRY_ADOBE_RGB;
+                break;
+        case V4L2_COLORSPACE_SMPTE170M:
+                c = y ? HDMI_COLORIMETRY_ITU_601 : HDMI_COLORIMETRY_NONE;
+                if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_XV601) {
+                        c = HDMI_COLORIMETRY_EXTENDED;
+                        ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+                }
+                break;
+        case V4L2_COLORSPACE_REC709:
+                c = y ? HDMI_COLORIMETRY_ITU_709 : HDMI_COLORIMETRY_NONE;
+                if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_XV709) {
+                        c = HDMI_COLORIMETRY_EXTENDED;
+                        ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_709;
+                }
+                break;
+        case V4L2_COLORSPACE_SRGB:
+                c = y ? HDMI_COLORIMETRY_EXTENDED : HDMI_COLORIMETRY_NONE;
+                ec = y ? HDMI_EXTENDED_COLORIMETRY_S_YCC_601 :
+                         HDMI_EXTENDED_COLORIMETRY_XV_YCC_601;
+                break;
+        case V4L2_COLORSPACE_BT2020:
+                c = HDMI_COLORIMETRY_EXTENDED;
+                if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_BT2020_CONST_LUM)
+                        ec = 5; /* Not yet available in hdmi.h */
+                else
+                        ec = 6; /* Not yet available in hdmi.h */
+                break;
+        default:
+                break;
+        }
+
+        /*
+         * CEA-861-F says that for RGB formats the YCC range must match the
+         * RGB range, although sources should ignore the YCC range.
+         *
+         * The RGB quantization range shouldn't be non-zero if the EDID doesn't
+         * have the Q bit set in the Video Capabilities Data Block, however this
+         * isn't checked at the moment. The assumption is that the application
+         * knows the EDID and can detect this.
+         *
+         * The same is true for the YCC quantization range: non-standard YCC
+         * quantization ranges should only be sent if the EDID has the YQ bit
+         * set in the Video Capabilities Data Block.
+         */
+        switch (format->format.quantization) {
+        case V4L2_QUANTIZATION_FULL_RANGE:
+                q = y ? HDMI_QUANTIZATION_RANGE_DEFAULT :
+                        HDMI_QUANTIZATION_RANGE_FULL;
+                yq = q ? q - 1 : HDMI_YCC_QUANTIZATION_RANGE_FULL;
+                break;
+        case V4L2_QUANTIZATION_LIM_RANGE:
+                q = y ? HDMI_QUANTIZATION_RANGE_DEFAULT :
+                        HDMI_QUANTIZATION_RANGE_LIMITED;
+                yq = q ? q - 1 : HDMI_YCC_QUANTIZATION_RANGE_LIMITED;
+                break;
+        }
+
+        adv7511_wr_and_or(sd, 0x4a, 0xbf, 0);
+        adv7511_wr_and_or(sd, 0x55, 0x9f, y << 5);
+        adv7511_wr_and_or(sd, 0x56, 0x3f, c << 6);
+        adv7511_wr_and_or(sd, 0x57, 0x83, (ec << 4) | (q << 2));
+        adv7511_wr_and_or(sd, 0x59, 0x0f, yq << 4);
+        adv7511_wr_and_or(sd, 0x4a, 0xff, 1);
+
         return 0;
 }
 
 static const struct v4l2_subdev_pad_ops adv7511_pad_ops = {
         .get_edid = adv7511_get_edid,
+        .enum_mbus_code = adv7511_enum_mbus_code,
+        .get_fmt = adv7511_get_fmt,
+        .set_fmt = adv7511_set_fmt,
         .enum_dv_timings = adv7511_enum_dv_timings,
         .dv_timings_cap = adv7511_dv_timings_cap,
 };
@@ -1116,6 +1329,8 @@ static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *
                 return -ENODEV;
         }
         memcpy(&state->pdata, pdata, sizeof(state->pdata));
+        state->fmt_code = MEDIA_BUS_FMT_RGB888_1X24;
+        state->colorspace = V4L2_COLORSPACE_SRGB;
 
         sd = &state->sd;
 
diff --git a/drivers/media/i2c/adv7604.c b/drivers/media/i2c/adv7604.c
index 47795ff71688..e43dd2e2a38a 100644
--- a/drivers/media/i2c/adv7604.c
+++ b/drivers/media/i2c/adv7604.c
@@ -88,7 +88,7 @@ struct adv7604_reg_seq {
 };
 
 struct adv7604_format_info {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         u8 op_ch_sel;
         bool rgb_out;
         bool swap_cb_cr;
@@ -749,77 +749,77 @@ static void adv7604_write_reg_seq(struct v4l2_subdev *sd,
  */
 
 static const struct adv7604_format_info adv7604_formats[] = {
-        { V4L2_MBUS_FMT_RGB888_1X24, ADV7604_OP_CH_SEL_RGB, true, false,
+        { MEDIA_BUS_FMT_RGB888_1X24, ADV7604_OP_CH_SEL_RGB, true, false,
           ADV7604_OP_MODE_SEL_SDR_444 | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YUYV8_2X8, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV8_2X8, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YVYU8_2X8, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU8_2X8, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YUYV10_2X10, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV10_2X10, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_10BIT },
-        { V4L2_MBUS_FMT_YVYU10_2X10, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU10_2X10, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_10BIT },
-        { V4L2_MBUS_FMT_YUYV12_2X12, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV12_2X12, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_YVYU12_2X12, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU12_2X12, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_UYVY8_1X16, ADV7604_OP_CH_SEL_RBG, false, false,
+        { MEDIA_BUS_FMT_UYVY8_1X16, ADV7604_OP_CH_SEL_RBG, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_VYUY8_1X16, ADV7604_OP_CH_SEL_RBG, false, true,
+        { MEDIA_BUS_FMT_VYUY8_1X16, ADV7604_OP_CH_SEL_RBG, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YUYV8_1X16, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV8_1X16, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YVYU8_1X16, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU8_1X16, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_UYVY10_1X20, ADV7604_OP_CH_SEL_RBG, false, false,
+        { MEDIA_BUS_FMT_UYVY10_1X20, ADV7604_OP_CH_SEL_RBG, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_10BIT },
-        { V4L2_MBUS_FMT_VYUY10_1X20, ADV7604_OP_CH_SEL_RBG, false, true,
+        { MEDIA_BUS_FMT_VYUY10_1X20, ADV7604_OP_CH_SEL_RBG, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_10BIT },
-        { V4L2_MBUS_FMT_YUYV10_1X20, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV10_1X20, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_10BIT },
-        { V4L2_MBUS_FMT_YVYU10_1X20, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU10_1X20, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_10BIT },
-        { V4L2_MBUS_FMT_UYVY12_1X24, ADV7604_OP_CH_SEL_RBG, false, false,
+        { MEDIA_BUS_FMT_UYVY12_1X24, ADV7604_OP_CH_SEL_RBG, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_VYUY12_1X24, ADV7604_OP_CH_SEL_RBG, false, true,
+        { MEDIA_BUS_FMT_VYUY12_1X24, ADV7604_OP_CH_SEL_RBG, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_YUYV12_1X24, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV12_1X24, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_YVYU12_1X24, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU12_1X24, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_12BIT },
 };
 
 static const struct adv7604_format_info adv7611_formats[] = {
-        { V4L2_MBUS_FMT_RGB888_1X24, ADV7604_OP_CH_SEL_RGB, true, false,
+        { MEDIA_BUS_FMT_RGB888_1X24, ADV7604_OP_CH_SEL_RGB, true, false,
           ADV7604_OP_MODE_SEL_SDR_444 | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YUYV8_2X8, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV8_2X8, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YVYU8_2X8, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU8_2X8, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YUYV12_2X12, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV12_2X12, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_YVYU12_2X12, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU12_2X12, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422 | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_UYVY8_1X16, ADV7604_OP_CH_SEL_RBG, false, false,
+        { MEDIA_BUS_FMT_UYVY8_1X16, ADV7604_OP_CH_SEL_RBG, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_VYUY8_1X16, ADV7604_OP_CH_SEL_RBG, false, true,
+        { MEDIA_BUS_FMT_VYUY8_1X16, ADV7604_OP_CH_SEL_RBG, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YUYV8_1X16, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV8_1X16, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_YVYU8_1X16, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU8_1X16, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_8BIT },
-        { V4L2_MBUS_FMT_UYVY12_1X24, ADV7604_OP_CH_SEL_RBG, false, false,
+        { MEDIA_BUS_FMT_UYVY12_1X24, ADV7604_OP_CH_SEL_RBG, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_VYUY12_1X24, ADV7604_OP_CH_SEL_RBG, false, true,
+        { MEDIA_BUS_FMT_VYUY12_1X24, ADV7604_OP_CH_SEL_RBG, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_YUYV12_1X24, ADV7604_OP_CH_SEL_RGB, false, false,
+        { MEDIA_BUS_FMT_YUYV12_1X24, ADV7604_OP_CH_SEL_RGB, false, false,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_12BIT },
-        { V4L2_MBUS_FMT_YVYU12_1X24, ADV7604_OP_CH_SEL_RGB, false, true,
+        { MEDIA_BUS_FMT_YVYU12_1X24, ADV7604_OP_CH_SEL_RGB, false, true,
           ADV7604_OP_MODE_SEL_SDR_422_2X | ADV7604_OP_FORMAT_SEL_12BIT },
 };
 
 static const struct adv7604_format_info *
-adv7604_format_info(struct adv7604_state *state, enum v4l2_mbus_pixelcode code)
+adv7604_format_info(struct adv7604_state *state, u32 code)
 {
         unsigned int i;
 
@@ -1917,7 +1917,7 @@ static int adv7604_set_format(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
 
         info = adv7604_format_info(state, format->format.code);
         if (info == NULL)
-                info = adv7604_format_info(state, V4L2_MBUS_FMT_YUYV8_2X8);
+                info = adv7604_format_info(state, MEDIA_BUS_FMT_YUYV8_2X8);
 
         adv7604_fill_format(state, &format->format);
         format->format.code = info->code;
@@ -1997,19 +1997,7 @@ static int adv7604_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
         struct adv7604_state *state = to_state(sd);
         u8 *data = NULL;
 
-        if (edid->pad > ADV7604_PAD_HDMI_PORT_D)
-                return -EINVAL;
-        if (edid->blocks == 0)
-                return -EINVAL;
-        if (edid->blocks > 2)
-                return -EINVAL;
-        if (edid->start_block > 1)
-                return -EINVAL;
-        if (edid->start_block == 1)
-                edid->blocks = 1;
-
-        if (edid->blocks > state->edid.blocks)
-                edid->blocks = state->edid.blocks;
+        memset(edid->reserved, 0, sizeof(edid->reserved));
 
         switch (edid->pad) {
         case ADV7604_PAD_HDMI_PORT_A:
@@ -2021,14 +2009,24 @@ static int adv7604_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
                 break;
         default:
                 return -EINVAL;
-                break;
         }
-        if (!data)
+
+        if (edid->start_block == 0 && edid->blocks == 0) {
+                edid->blocks = data ? state->edid.blocks : 0;
+                return 0;
+        }
+
+        if (data == NULL)
                 return -ENODATA;
 
-        memcpy(edid->edid,
-               data + edid->start_block * 128,
-               edid->blocks * 128);
+        if (edid->start_block >= state->edid.blocks)
+                return -EINVAL;
+
+        if (edid->start_block + edid->blocks > state->edid.blocks)
+                edid->blocks = state->edid.blocks - edid->start_block;
+
+        memcpy(edid->edid, data + edid->start_block * 128, edid->blocks * 128);
+
         return 0;
 }
 
@@ -2068,6 +2066,8 @@ static int adv7604_set_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
         int err;
         int i;
 
+        memset(edid->reserved, 0, sizeof(edid->reserved));
+
         if (edid->pad > ADV7604_PAD_HDMI_PORT_D)
                 return -EINVAL;
         if (edid->start_block != 0)
@@ -2164,7 +2164,6 @@ static int adv7604_set_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
                 return -EIO;
         }
 
-
         /* enable hotplug after 100 ms */
         queue_delayed_work(state->work_queues,
                         &state->delayed_work_enable_hotplug, HZ / 10);
@@ -2807,7 +2806,7 @@ static int adv7604_probe(struct i2c_client *client,
         }
 
         state->timings = cea640x480;
-        state->format = adv7604_format_info(state, V4L2_MBUS_FMT_YUYV8_2X8);
+        state->format = adv7604_format_info(state, MEDIA_BUS_FMT_YUYV8_2X8);
 
         sd = &state->sd;
         v4l2_i2c_subdev_init(sd, client, &adv7604_ops);
diff --git a/drivers/media/i2c/adv7842.c b/drivers/media/i2c/adv7842.c
index 48b628bc6714..75d26dfd0939 100644
--- a/drivers/media/i2c/adv7842.c
+++ b/drivers/media/i2c/adv7842.c
@@ -1877,12 +1877,12 @@ static int adv7842_s_routing(struct v4l2_subdev *sd,
 }
 
 static int adv7842_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned int index,
-                                 enum v4l2_mbus_pixelcode *code)
+                                 u32 *code)
 {
         if (index)
                 return -EINVAL;
         /* Good enough for now */
-        *code = V4L2_MBUS_FMT_FIXED;
+        *code = MEDIA_BUS_FMT_FIXED;
         return 0;
 }
 
@@ -1893,7 +1893,7 @@ static int adv7842_g_mbus_fmt(struct v4l2_subdev *sd,
 
         fmt->width = state->timings.bt.width;
         fmt->height = state->timings.bt.height;
-        fmt->code = V4L2_MBUS_FMT_FIXED;
+        fmt->code = MEDIA_BUS_FMT_FIXED;
         fmt->field = V4L2_FIELD_NONE;
 
         if (state->mode == ADV7842_MODE_SDP) {
@@ -2028,16 +2028,7 @@ static int adv7842_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
         struct adv7842_state *state = to_state(sd);
         u8 *data = NULL;
 
-        if (edid->pad > ADV7842_EDID_PORT_VGA)
-                return -EINVAL;
-        if (edid->blocks == 0)
-                return -EINVAL;
-        if (edid->blocks > 2)
-                return -EINVAL;
-        if (edid->start_block > 1)
-                return -EINVAL;
-        if (edid->start_block == 1)
-                edid->blocks = 1;
+        memset(edid->reserved, 0, sizeof(edid->reserved));
 
         switch (edid->pad) {
         case ADV7842_EDID_PORT_A:
@@ -2052,12 +2043,23 @@ static int adv7842_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid)
         default:
                 return -EINVAL;
         }
+
+        if (edid->start_block == 0 && edid->blocks == 0) {
+                edid->blocks = data ? 2 : 0;
+                return 0;
+        }
+
         if (!data)
                 return -ENODATA;
 
-        memcpy(edid->edid,
-               data + edid->start_block * 128,
-               edid->blocks * 128);
+        if (edid->start_block >= 2)
+                return -EINVAL;
+
+        if (edid->start_block + edid->blocks > 2)
+                edid->blocks = 2 - edid->start_block;
+
+        memcpy(edid->edid, data + edid->start_block * 128, edid->blocks * 128);
+
         return 0;
 }
 
@@ -2066,12 +2068,16 @@ static int adv7842_set_edid(struct v4l2_subdev *sd, struct v4l2_edid *e)
         struct adv7842_state *state = to_state(sd);
         int err = 0;
 
+        memset(e->reserved, 0, sizeof(e->reserved));
+
         if (e->pad > ADV7842_EDID_PORT_VGA)
                 return -EINVAL;
         if (e->start_block != 0)
                 return -EINVAL;
-        if (e->blocks > 2)
+        if (e->blocks > 2) {
+                e->blocks = 2;
                 return -E2BIG;
+        }
 
         /* todo, per edid */
         state->aspect_ratio = v4l2_calc_aspect_ratio(e->edid[0x15],
diff --git a/drivers/media/i2c/ak881x.c b/drivers/media/i2c/ak881x.c
index c14e66756b98..69aeaf397624 100644
--- a/drivers/media/i2c/ak881x.c
+++ b/drivers/media/i2c/ak881x.c
@@ -102,7 +102,7 @@ static int ak881x_try_g_mbus_fmt(struct v4l2_subdev *sd,
         v4l_bound_align_image(&mf->width, 0, 720, 2,
                               &mf->height, 0, ak881x->lines, 1, 0);
         mf->field       = V4L2_FIELD_INTERLACED;
-        mf->code        = V4L2_MBUS_FMT_YUYV8_2X8;
+        mf->code        = MEDIA_BUS_FMT_YUYV8_2X8;
         mf->colorspace  = V4L2_COLORSPACE_SMPTE170M;
 
         return 0;
@@ -112,19 +112,19 @@ static int ak881x_s_mbus_fmt(struct v4l2_subdev *sd,
                              struct v4l2_mbus_framefmt *mf)
 {
         if (mf->field != V4L2_FIELD_INTERLACED ||
-            mf->code != V4L2_MBUS_FMT_YUYV8_2X8)
+            mf->code != MEDIA_BUS_FMT_YUYV8_2X8)
                 return -EINVAL;
 
         return ak881x_try_g_mbus_fmt(sd, mf);
 }
 
 static int ak881x_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned int index,
-                                enum v4l2_mbus_pixelcode *code)
+                                u32 *code)
 {
         if (index)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_YUYV8_2X8;
+        *code = MEDIA_BUS_FMT_YUYV8_2X8;
         return 0;
 }
 
diff --git a/drivers/media/i2c/cx25840/cx25840-core.c b/drivers/media/i2c/cx25840/cx25840-core.c
index e453a3ffe7d1..573e08826b9b 100644
--- a/drivers/media/i2c/cx25840/cx25840-core.c
+++ b/drivers/media/i2c/cx25840/cx25840-core.c
@@ -879,7 +879,7 @@ void cx25840_std_setup(struct i2c_client *client)
         /* Sets horizontal blanking delay and active lines */
         cx25840_write(client, 0x470, hblank);
         cx25840_write(client, 0x471,
-                        0xff & (((hblank >> 8) & 0x3) | (hactive << 4)));
+                      (((hblank >> 8) & 0x3) | (hactive << 4)) & 0xff);
         cx25840_write(client, 0x472, hactive >> 4);
 
         /* Sets burst gate delay */
@@ -888,13 +888,13 @@ void cx25840_std_setup(struct i2c_client *client)
         /* Sets vertical blanking delay and active duration */
         cx25840_write(client, 0x474, vblank);
         cx25840_write(client, 0x475,
-                        0xff & (((vblank >> 8) & 0x3) | (vactive << 4)));
+                      (((vblank >> 8) & 0x3) | (vactive << 4)) & 0xff);
         cx25840_write(client, 0x476, vactive >> 4);
         cx25840_write(client, 0x477, vblank656);
 
         /* Sets src decimation rate */
-        cx25840_write(client, 0x478, 0xff & src_decimation);
-        cx25840_write(client, 0x479, 0xff & (src_decimation >> 8));
+        cx25840_write(client, 0x478, src_decimation & 0xff);
+        cx25840_write(client, 0x479, (src_decimation >> 8) & 0xff);
 
         /* Sets Luma and UV Low pass filters */
         cx25840_write(client, 0x47a, luma_lpf << 6 | ((uv_lpf << 4) & 0x30));
@@ -904,8 +904,8 @@ void cx25840_std_setup(struct i2c_client *client)
 
         /* Sets SC Step*/
         cx25840_write(client, 0x47c, sc);
-        cx25840_write(client, 0x47d, 0xff & sc >> 8);
-        cx25840_write(client, 0x47e, 0xff & sc >> 16);
+        cx25840_write(client, 0x47d, (sc >> 8) & 0xff);
+        cx25840_write(client, 0x47e, (sc >> 16) & 0xff);
 
         /* Sets VBI parameters */
         if (std & V4L2_STD_625_50) {
@@ -1373,7 +1373,7 @@ static int cx25840_s_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt
         int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
         int is_50Hz = !(state->std & V4L2_STD_525_60);
 
-        if (fmt->code != V4L2_MBUS_FMT_FIXED)
+        if (fmt->code != MEDIA_BUS_FMT_FIXED)
                 return -EINVAL;
 
         fmt->field = V4L2_FIELD_INTERLACED;
diff --git a/drivers/media/i2c/cx25840/cx25840-firmware.c b/drivers/media/i2c/cx25840/cx25840-firmware.c
index b3169f94ece8..9bbb31adc29d 100644
--- a/drivers/media/i2c/cx25840/cx25840-firmware.c
+++ b/drivers/media/i2c/cx25840/cx25840-firmware.c
@@ -113,7 +113,7 @@ int cx25840_loadfw(struct i2c_client *client)
         const u8 *ptr;
         const char *fwname = get_fw_name(client);
         int size, retval;
-        int MAX_BUF_SIZE = FWSEND;
+        int max_buf_size = FWSEND;
         u32 gpio_oe = 0, gpio_da = 0;
 
         if (is_cx2388x(state)) {
@@ -122,10 +122,9 @@ int cx25840_loadfw(struct i2c_client *client)
                 gpio_da = cx25840_read(client, 0x164);
         }
 
-        if (is_cx231xx(state) && MAX_BUF_SIZE > 16) {
-                v4l_err(client, " Firmware download size changed to 16 bytes max length\n");
-                MAX_BUF_SIZE = 16;  /* cx231xx cannot accept more than 16 bytes at a time */
-        }
+        /* cx231xx cannot accept more than 16 bytes at a time */
+        if (is_cx231xx(state) && max_buf_size > 16)
+                max_buf_size = 16;
 
         if (request_firmware(&fw, fwname, FWDEV(client)) != 0) {
                 v4l_err(client, "unable to open firmware %s\n", fwname);
@@ -140,7 +139,7 @@ int cx25840_loadfw(struct i2c_client *client)
         size = fw->size;
         ptr = fw->data;
         while (size > 0) {
-                int len = min(MAX_BUF_SIZE - 2, size);
+                int len = min(max_buf_size - 2, size);
 
                 memcpy(buffer + 2, ptr, len);
 
diff --git a/drivers/media/i2c/ir-kbd-i2c.c b/drivers/media/i2c/ir-kbd-i2c.c
index 8311f1a9a38e..175a76114953 100644
--- a/drivers/media/i2c/ir-kbd-i2c.c
+++ b/drivers/media/i2c/ir-kbd-i2c.c
@@ -464,8 +464,7 @@ static int ir_remove(struct i2c_client *client)
         cancel_delayed_work_sync(&ir->work);
 
         /* unregister device */
-        if (ir->rc)
-                rc_unregister_device(ir->rc);
+        rc_unregister_device(ir->rc);
 
         /* free memory */
         return 0;
diff --git a/drivers/media/i2c/m5mols/m5mols_core.c b/drivers/media/i2c/m5mols/m5mols_core.c
index 8d870b7b43ff..2820f7c38cba 100644
--- a/drivers/media/i2c/m5mols/m5mols_core.c
+++ b/drivers/media/i2c/m5mols/m5mols_core.c
@@ -57,14 +57,14 @@ static struct v4l2_mbus_framefmt m5mols_default_ffmt[M5MOLS_RESTYPE_MAX] = {
         [M5MOLS_RESTYPE_MONITOR] = {
                 .width          = 1920,
                 .height         = 1080,
-                .code           = V4L2_MBUS_FMT_VYUY8_2X8,
+                .code           = MEDIA_BUS_FMT_VYUY8_2X8,
                 .field          = V4L2_FIELD_NONE,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
         },
         [M5MOLS_RESTYPE_CAPTURE] = {
                 .width          = 1920,
                 .height         = 1080,
-                .code           = V4L2_MBUS_FMT_JPEG_1X8,
+                .code           = MEDIA_BUS_FMT_JPEG_1X8,
                 .field          = V4L2_FIELD_NONE,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
         },
@@ -479,7 +479,7 @@ static int m5mols_get_version(struct v4l2_subdev *sd)
  * __find_restype - Lookup M-5MOLS resolution type according to pixel code
  * @code: pixel code
  */
-static enum m5mols_restype __find_restype(enum v4l2_mbus_pixelcode code)
+static enum m5mols_restype __find_restype(u32 code)
 {
         enum m5mols_restype type = M5MOLS_RESTYPE_MONITOR;
 
diff --git a/drivers/media/i2c/ml86v7667.c b/drivers/media/i2c/ml86v7667.c
index 2cace7313a22..d7307862c2c5 100644
--- a/drivers/media/i2c/ml86v7667.c
+++ b/drivers/media/i2c/ml86v7667.c
@@ -192,12 +192,12 @@ static int ml86v7667_g_input_status(struct v4l2_subdev *sd, u32 *status)
 }
 
 static int ml86v7667_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned int index,
-                                   enum v4l2_mbus_pixelcode *code)
+                                   u32 *code)
 {
         if (index > 0)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_YUYV8_2X8;
+        *code = MEDIA_BUS_FMT_YUYV8_2X8;
 
         return 0;
 }
@@ -207,7 +207,7 @@ static int ml86v7667_mbus_fmt(struct v4l2_subdev *sd,
 {
         struct ml86v7667_priv *priv = to_ml86v7667(sd);
 
-        fmt->code = V4L2_MBUS_FMT_YUYV8_2X8;
+        fmt->code = MEDIA_BUS_FMT_YUYV8_2X8;
         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
         /* The top field is always transferred first by the chip */
         fmt->field = V4L2_FIELD_INTERLACED_TB;
diff --git a/drivers/media/i2c/mt9m032.c b/drivers/media/i2c/mt9m032.c
index 85ec3bacdf1c..45b3fca188ca 100644
--- a/drivers/media/i2c/mt9m032.c
+++ b/drivers/media/i2c/mt9m032.c
@@ -323,7 +323,7 @@ static int mt9m032_enum_mbus_code(struct v4l2_subdev *subdev,
         if (code->index != 0)
                 return -EINVAL;
 
-        code->code = V4L2_MBUS_FMT_Y8_1X8;
+        code->code = MEDIA_BUS_FMT_Y8_1X8;
         return 0;
 }
 
@@ -331,7 +331,7 @@ static int mt9m032_enum_frame_size(struct v4l2_subdev *subdev,
                                    struct v4l2_subdev_fh *fh,
                                    struct v4l2_subdev_frame_size_enum *fse)
 {
-        if (fse->index != 0 || fse->code != V4L2_MBUS_FMT_Y8_1X8)
+        if (fse->index != 0 || fse->code != MEDIA_BUS_FMT_Y8_1X8)
                 return -EINVAL;
 
         fse->min_width = MT9M032_COLUMN_SIZE_DEF;
@@ -759,7 +759,7 @@ static int mt9m032_probe(struct i2c_client *client,
 
         sensor->format.width = sensor->crop.width;
         sensor->format.height = sensor->crop.height;
-        sensor->format.code = V4L2_MBUS_FMT_Y8_1X8;
+        sensor->format.code = MEDIA_BUS_FMT_Y8_1X8;
         sensor->format.field = V4L2_FIELD_NONE;
         sensor->format.colorspace = V4L2_COLORSPACE_SRGB;
 
diff --git a/drivers/media/i2c/mt9p031.c b/drivers/media/i2c/mt9p031.c
index e18797ff7faf..edb76bd33d16 100644
--- a/drivers/media/i2c/mt9p031.c
+++ b/drivers/media/i2c/mt9p031.c
@@ -950,9 +950,9 @@ static int mt9p031_open(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh)
         format = v4l2_subdev_get_try_format(fh, 0);
 
         if (mt9p031->model == MT9P031_MODEL_MONOCHROME)
-                format->code = V4L2_MBUS_FMT_Y12_1X12;
+                format->code = MEDIA_BUS_FMT_Y12_1X12;
         else
-                format->code = V4L2_MBUS_FMT_SGRBG12_1X12;
+                format->code = MEDIA_BUS_FMT_SGRBG12_1X12;
 
         format->width = MT9P031_WINDOW_WIDTH_DEF;
         format->height = MT9P031_WINDOW_HEIGHT_DEF;
@@ -1120,9 +1120,9 @@ static int mt9p031_probe(struct i2c_client *client,
         mt9p031->crop.top = MT9P031_ROW_START_DEF;
 
         if (mt9p031->model == MT9P031_MODEL_MONOCHROME)
-                mt9p031->format.code = V4L2_MBUS_FMT_Y12_1X12;
+                mt9p031->format.code = MEDIA_BUS_FMT_Y12_1X12;
         else
-                mt9p031->format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
+                mt9p031->format.code = MEDIA_BUS_FMT_SGRBG12_1X12;
 
         mt9p031->format.width = MT9P031_WINDOW_WIDTH_DEF;
         mt9p031->format.height = MT9P031_WINDOW_HEIGHT_DEF;
diff --git a/drivers/media/i2c/mt9t001.c b/drivers/media/i2c/mt9t001.c
index 422e068f5f1b..d9e9889b579f 100644
--- a/drivers/media/i2c/mt9t001.c
+++ b/drivers/media/i2c/mt9t001.c
@@ -333,7 +333,7 @@ static int mt9t001_enum_mbus_code(struct v4l2_subdev *subdev,
         if (code->index > 0)
                 return -EINVAL;
 
-        code->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        code->code = MEDIA_BUS_FMT_SGRBG10_1X10;
         return 0;
 }
 
@@ -341,7 +341,7 @@ static int mt9t001_enum_frame_size(struct v4l2_subdev *subdev,
                                    struct v4l2_subdev_fh *fh,
                                    struct v4l2_subdev_frame_size_enum *fse)
 {
-        if (fse->index >= 8 || fse->code != V4L2_MBUS_FMT_SGRBG10_1X10)
+        if (fse->index >= 8 || fse->code != MEDIA_BUS_FMT_SGRBG10_1X10)
                 return -EINVAL;
 
         fse->min_width = (MT9T001_WINDOW_WIDTH_DEF + 1) / fse->index;
@@ -792,7 +792,7 @@ static int mt9t001_open(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh)
         crop->height = MT9T001_WINDOW_HEIGHT_DEF + 1;
 
         format = v4l2_subdev_get_try_format(fh, 0);
-        format->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        format->code = MEDIA_BUS_FMT_SGRBG10_1X10;
         format->width = MT9T001_WINDOW_WIDTH_DEF + 1;
         format->height = MT9T001_WINDOW_HEIGHT_DEF + 1;
         format->field = V4L2_FIELD_NONE;
@@ -917,7 +917,7 @@ static int mt9t001_probe(struct i2c_client *client,
         mt9t001->crop.width = MT9T001_WINDOW_WIDTH_DEF + 1;
         mt9t001->crop.height = MT9T001_WINDOW_HEIGHT_DEF + 1;
 
-        mt9t001->format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        mt9t001->format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         mt9t001->format.width = MT9T001_WINDOW_WIDTH_DEF + 1;
         mt9t001->format.height = MT9T001_WINDOW_HEIGHT_DEF + 1;
         mt9t001->format.field = V4L2_FIELD_NONE;
diff --git a/drivers/media/i2c/mt9v011.c b/drivers/media/i2c/mt9v011.c
index 47e475319a24..a10f7f8f0558 100644
--- a/drivers/media/i2c/mt9v011.c
+++ b/drivers/media/i2c/mt9v011.c
@@ -325,18 +325,18 @@ static int mt9v011_reset(struct v4l2_subdev *sd, u32 val)
 }
 
 static int mt9v011_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
-                                        enum v4l2_mbus_pixelcode *code)
+                                        u32 *code)
 {
         if (index > 0)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_SGRBG8_1X8;
+        *code = MEDIA_BUS_FMT_SGRBG8_1X8;
         return 0;
 }
 
 static int mt9v011_try_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *fmt)
 {
-        if (fmt->code != V4L2_MBUS_FMT_SGRBG8_1X8)
+        if (fmt->code != MEDIA_BUS_FMT_SGRBG8_1X8)
                 return -EINVAL;
 
         v4l_bound_align_image(&fmt->width, 48, 639, 1,
diff --git a/drivers/media/i2c/mt9v032.c b/drivers/media/i2c/mt9v032.c
index d044bce312e0..93687c1e4097 100644
--- a/drivers/media/i2c/mt9v032.c
+++ b/drivers/media/i2c/mt9v032.c
@@ -454,7 +454,7 @@ static int mt9v032_enum_mbus_code(struct v4l2_subdev *subdev,
         if (code->index > 0)
                 return -EINVAL;
 
-        code->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        code->code = MEDIA_BUS_FMT_SGRBG10_1X10;
         return 0;
 }
 
@@ -462,7 +462,7 @@ static int mt9v032_enum_frame_size(struct v4l2_subdev *subdev,
                                    struct v4l2_subdev_fh *fh,
                                    struct v4l2_subdev_frame_size_enum *fse)
 {
-        if (fse->index >= 3 || fse->code != V4L2_MBUS_FMT_SGRBG10_1X10)
+        if (fse->index >= 3 || fse->code != MEDIA_BUS_FMT_SGRBG10_1X10)
                 return -EINVAL;
 
         fse->min_width = MT9V032_WINDOW_WIDTH_DEF / (1 << fse->index);
@@ -814,9 +814,9 @@ static int mt9v032_open(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh)
         format = v4l2_subdev_get_try_format(fh, 0);
 
         if (mt9v032->model->color)
-                format->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                format->code = MEDIA_BUS_FMT_SGRBG10_1X10;
         else
-                format->code = V4L2_MBUS_FMT_Y10_1X10;
+                format->code = MEDIA_BUS_FMT_Y10_1X10;
 
         format->width = MT9V032_WINDOW_WIDTH_DEF;
         format->height = MT9V032_WINDOW_HEIGHT_DEF;
@@ -966,9 +966,9 @@ static int mt9v032_probe(struct i2c_client *client,
         mt9v032->crop.height = MT9V032_WINDOW_HEIGHT_DEF;
 
         if (mt9v032->model->color)
-                mt9v032->format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                mt9v032->format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         else
-                mt9v032->format.code = V4L2_MBUS_FMT_Y10_1X10;
+                mt9v032->format.code = MEDIA_BUS_FMT_Y10_1X10;
 
         mt9v032->format.width = MT9V032_WINDOW_WIDTH_DEF;
         mt9v032->format.height = MT9V032_WINDOW_HEIGHT_DEF;
diff --git a/drivers/media/i2c/noon010pc30.c b/drivers/media/i2c/noon010pc30.c
index 7eae48766e2b..00c7b26f4823 100644
--- a/drivers/media/i2c/noon010pc30.c
+++ b/drivers/media/i2c/noon010pc30.c
@@ -112,7 +112,7 @@ MODULE_PARM_DESC(debug, "Enable module debug trace. Set to 1 to enable.");
 #define REG_TERM                0xFFFF
 
 struct noon010_format {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         enum v4l2_colorspace colorspace;
         u16 ispctl1_reg;
 };
@@ -175,23 +175,23 @@ static const struct noon010_frmsize noon010_sizes[] = {
 /* Supported pixel formats. */
 static const struct noon010_format noon010_formats[] = {
         {
-                .code           = V4L2_MBUS_FMT_YUYV8_2X8,
+                .code           = MEDIA_BUS_FMT_YUYV8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0x03,
         }, {
-                .code           = V4L2_MBUS_FMT_YVYU8_2X8,
+                .code           = MEDIA_BUS_FMT_YVYU8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0x02,
         }, {
-                .code           = V4L2_MBUS_FMT_VYUY8_2X8,
+                .code           = MEDIA_BUS_FMT_VYUY8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0,
         }, {
-                .code           = V4L2_MBUS_FMT_UYVY8_2X8,
+                .code           = MEDIA_BUS_FMT_UYVY8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0x01,
         }, {
-                .code           = V4L2_MBUS_FMT_RGB565_2X8_BE,
+                .code           = MEDIA_BUS_FMT_RGB565_2X8_BE,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0x40,
         },
diff --git a/drivers/media/i2c/ov7670.c b/drivers/media/i2c/ov7670.c
index dd3db2458a4f..957927f7a353 100644
--- a/drivers/media/i2c/ov7670.c
+++ b/drivers/media/i2c/ov7670.c
@@ -632,31 +632,31 @@ static int ov7670_detect(struct v4l2_subdev *sd)
  * The magic matrix numbers come from OmniVision.
  */
 static struct ov7670_format_struct {
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
         enum v4l2_colorspace colorspace;
         struct regval_list *regs;
         int cmatrix[CMATRIX_LEN];
 } ov7670_formats[] = {
         {
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .regs           = ov7670_fmt_yuv422,
                 .cmatrix        = { 128, -128, 0, -34, -94, 128 },
         },
         {
-                .mbus_code      = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
+                .mbus_code      = MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .regs           = ov7670_fmt_rgb444,
                 .cmatrix        = { 179, -179, 0, -61, -176, 228 },
         },
         {
-                .mbus_code      = V4L2_MBUS_FMT_RGB565_2X8_LE,
+                .mbus_code      = MEDIA_BUS_FMT_RGB565_2X8_LE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .regs           = ov7670_fmt_rgb565,
                 .cmatrix        = { 179, -179, 0, -61, -176, 228 },
         },
         {
-                .mbus_code      = V4L2_MBUS_FMT_SBGGR8_1X8,
+                .mbus_code      = MEDIA_BUS_FMT_SBGGR8_1X8,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .regs           = ov7670_fmt_raw,
                 .cmatrix        = { 0, 0, 0, 0, 0, 0 },
@@ -772,7 +772,7 @@ static void ov7675_get_framerate(struct v4l2_subdev *sd,
                 pll_factor = PLL_FACTOR;
 
         clkrc++;
-        if (info->fmt->mbus_code == V4L2_MBUS_FMT_SBGGR8_1X8)
+        if (info->fmt->mbus_code == MEDIA_BUS_FMT_SBGGR8_1X8)
                 clkrc = (clkrc >> 1);
 
         tpf->numerator = 1;
@@ -810,7 +810,7 @@ static int ov7675_set_framerate(struct v4l2_subdev *sd,
         } else {
                 clkrc = (5 * pll_factor * info->clock_speed * tpf->numerator) /
                         (4 * tpf->denominator);
-                if (info->fmt->mbus_code == V4L2_MBUS_FMT_SBGGR8_1X8)
+                if (info->fmt->mbus_code == MEDIA_BUS_FMT_SBGGR8_1X8)
                         clkrc = (clkrc << 1);
                 clkrc--;
         }
@@ -900,7 +900,7 @@ static int ov7670_set_hw(struct v4l2_subdev *sd, int hstart, int hstop,
 
 
 static int ov7670_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
-                                        enum v4l2_mbus_pixelcode *code)
+                                        u32 *code)
 {
         if (index >= N_OV7670_FMTS)
                 return -EINVAL;
diff --git a/drivers/media/i2c/ov9650.c b/drivers/media/i2c/ov9650.c
index 4da90c621f7e..2246bd5436ad 100644
--- a/drivers/media/i2c/ov9650.c
+++ b/drivers/media/i2c/ov9650.c
@@ -384,17 +384,17 @@ static const struct ov965x_framesize ov965x_framesizes[] = {
 };
 
 struct ov965x_pixfmt {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         u32 colorspace;
         /* REG_TSLB value, only bits [3:2] may be set. */
         u8 tslb_reg;
 };
 
 static const struct ov965x_pixfmt ov965x_formats[] = {
-        { V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG, 0x00},
-        { V4L2_MBUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG, 0x04},
-        { V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG, 0x0c},
-        { V4L2_MBUS_FMT_VYUY8_2X8, V4L2_COLORSPACE_JPEG, 0x08},
+        { MEDIA_BUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG, 0x00},
+        { MEDIA_BUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG, 0x04},
+        { MEDIA_BUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG, 0x0c},
+        { MEDIA_BUS_FMT_VYUY8_2X8, V4L2_COLORSPACE_JPEG, 0x08},
 };
 
 /*
diff --git a/drivers/media/i2c/s5c73m3/s5c73m3.h b/drivers/media/i2c/s5c73m3/s5c73m3.h
index 9656b6723dc6..13aed59f0f5d 100644
--- a/drivers/media/i2c/s5c73m3/s5c73m3.h
+++ b/drivers/media/i2c/s5c73m3/s5c73m3.h
@@ -27,8 +27,8 @@
 
 #define DRIVER_NAME                     "S5C73M3"
 
-#define S5C73M3_ISP_FMT                 V4L2_MBUS_FMT_VYUY8_2X8
-#define S5C73M3_JPEG_FMT                V4L2_MBUS_FMT_S5C_UYVY_JPEG_1X8
+#define S5C73M3_ISP_FMT                 MEDIA_BUS_FMT_VYUY8_2X8
+#define S5C73M3_JPEG_FMT                MEDIA_BUS_FMT_S5C_UYVY_JPEG_1X8
 
 /* Subdevs pad index definitions */
 enum s5c73m3_pads {
@@ -402,7 +402,7 @@ struct s5c73m3 {
 
         const struct s5c73m3_frame_size *sensor_pix_size[2];
         const struct s5c73m3_frame_size *oif_pix_size[2];
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
 
         const struct s5c73m3_interval *fiv;
 
diff --git a/drivers/media/i2c/s5k4ecgx.c b/drivers/media/i2c/s5k4ecgx.c
index 1fcc76fd1bbf..d1c50c9d43ae 100644
--- a/drivers/media/i2c/s5k4ecgx.c
+++ b/drivers/media/i2c/s5k4ecgx.c
@@ -151,7 +151,7 @@ static const struct s5k4ecgx_frmsize s5k4ecgx_prev_sizes[] = {
 #define S5K4ECGX_NUM_PREV ARRAY_SIZE(s5k4ecgx_prev_sizes)
 
 struct s5k4ecgx_pixfmt {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         u32 colorspace;
         /* REG_TC_PCFG_Format register value */
         u16 reg_p_format;
@@ -159,7 +159,7 @@ struct s5k4ecgx_pixfmt {
 
 /* By default value, output from sensor will be YUV422 0-255 */
 static const struct s5k4ecgx_pixfmt s5k4ecgx_formats[] = {
-        { V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG, 5 },
+        { MEDIA_BUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG, 5 },
 };
 
 static const char * const s5k4ecgx_supply_names[] = {
diff --git a/drivers/media/i2c/s5k5baf.c b/drivers/media/i2c/s5k5baf.c
index 0e461a6fd065..60a74d8d38d5 100644
--- a/drivers/media/i2c/s5k5baf.c
+++ b/drivers/media/i2c/s5k5baf.c
@@ -248,7 +248,7 @@ enum s5k5baf_gpio_id {
 #define NUM_ISP_PADS 2
 
 struct s5k5baf_pixfmt {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         u32 colorspace;
         /* REG_P_FMT(x) register value */
         u16 reg_p_fmt;
@@ -331,10 +331,10 @@ struct s5k5baf {
 };
 
 static const struct s5k5baf_pixfmt s5k5baf_formats[] = {
-        { V4L2_MBUS_FMT_VYUY8_2X8,      V4L2_COLORSPACE_JPEG,   5 },
+        { MEDIA_BUS_FMT_VYUY8_2X8,      V4L2_COLORSPACE_JPEG,   5 },
         /* range 16-240 */
-        { V4L2_MBUS_FMT_VYUY8_2X8,      V4L2_COLORSPACE_REC709, 6 },
-        { V4L2_MBUS_FMT_RGB565_2X8_BE,  V4L2_COLORSPACE_JPEG,   0 },
+        { MEDIA_BUS_FMT_VYUY8_2X8,      V4L2_COLORSPACE_REC709, 6 },
+        { MEDIA_BUS_FMT_RGB565_2X8_BE,  V4L2_COLORSPACE_JPEG,   0 },
 };
 
 static struct v4l2_rect s5k5baf_cis_rect = {
@@ -1206,7 +1206,7 @@ static int s5k5baf_enum_mbus_code(struct v4l2_subdev *sd,
         if (code->pad == PAD_CIS) {
                 if (code->index > 0)
                         return -EINVAL;
-                code->code = V4L2_MBUS_FMT_FIXED;
+                code->code = MEDIA_BUS_FMT_FIXED;
                 return 0;
         }
 
@@ -1227,7 +1227,7 @@ static int s5k5baf_enum_frame_size(struct v4l2_subdev *sd,
                 return -EINVAL;
 
         if (fse->pad == PAD_CIS) {
-                fse->code = V4L2_MBUS_FMT_FIXED;
+                fse->code = MEDIA_BUS_FMT_FIXED;
                 fse->min_width = S5K5BAF_CIS_WIDTH;
                 fse->max_width = S5K5BAF_CIS_WIDTH;
                 fse->min_height = S5K5BAF_CIS_HEIGHT;
@@ -1252,7 +1252,7 @@ static void s5k5baf_try_cis_format(struct v4l2_mbus_framefmt *mf)
 {
         mf->width = S5K5BAF_CIS_WIDTH;
         mf->height = S5K5BAF_CIS_HEIGHT;
-        mf->code = V4L2_MBUS_FMT_FIXED;
+        mf->code = MEDIA_BUS_FMT_FIXED;
         mf->colorspace = V4L2_COLORSPACE_JPEG;
         mf->field = V4L2_FIELD_NONE;
 }
diff --git a/drivers/media/i2c/s5k6a3.c b/drivers/media/i2c/s5k6a3.c
index c11a40850ed1..91b841a1b850 100644
--- a/drivers/media/i2c/s5k6a3.c
+++ b/drivers/media/i2c/s5k6a3.c
@@ -80,7 +80,7 @@ static inline struct s5k6a3 *sd_to_s5k6a3(struct v4l2_subdev *sd)
 
 static const struct v4l2_mbus_framefmt s5k6a3_formats[] = {
         {
-                .code = V4L2_MBUS_FMT_SGRBG10_1X10,
+                .code = MEDIA_BUS_FMT_SGRBG10_1X10,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .field = V4L2_FIELD_NONE,
         }
diff --git a/drivers/media/i2c/s5k6aa.c b/drivers/media/i2c/s5k6aa.c
index 629a5cdadd3a..2851581e0061 100644
--- a/drivers/media/i2c/s5k6aa.c
+++ b/drivers/media/i2c/s5k6aa.c
@@ -191,7 +191,7 @@ struct s5k6aa_regval {
 };
 
 struct s5k6aa_pixfmt {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         u32 colorspace;
         /* REG_P_FMT(x) register value */
         u16 reg_p_fmt;
@@ -285,10 +285,10 @@ static struct s5k6aa_regval s5k6aa_analog_config[] = {
 
 /* TODO: Add RGB888 and Bayer format */
 static const struct s5k6aa_pixfmt s5k6aa_formats[] = {
-        { V4L2_MBUS_FMT_YUYV8_2X8,      V4L2_COLORSPACE_JPEG,   5 },
+        { MEDIA_BUS_FMT_YUYV8_2X8,      V4L2_COLORSPACE_JPEG,   5 },
         /* range 16-240 */
-        { V4L2_MBUS_FMT_YUYV8_2X8,      V4L2_COLORSPACE_REC709, 6 },
-        { V4L2_MBUS_FMT_RGB565_2X8_BE,  V4L2_COLORSPACE_JPEG,   0 },
+        { MEDIA_BUS_FMT_YUYV8_2X8,      V4L2_COLORSPACE_REC709, 6 },
+        { MEDIA_BUS_FMT_RGB565_2X8_BE,  V4L2_COLORSPACE_JPEG,   0 },
 };
 
 static const struct s5k6aa_interval s5k6aa_intervals[] = {
diff --git a/drivers/media/i2c/saa6752hs.c b/drivers/media/i2c/saa6752hs.c
index 4024ea6f1371..f14c0e6435a3 100644
--- a/drivers/media/i2c/saa6752hs.c
+++ b/drivers/media/i2c/saa6752hs.c
@@ -562,7 +562,7 @@ static int saa6752hs_g_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefm
                 h->video_format = SAA6752HS_VF_D1;
         f->width = v4l2_format_table[h->video_format].fmt.pix.width;
         f->height = v4l2_format_table[h->video_format].fmt.pix.height;
-        f->code = V4L2_MBUS_FMT_FIXED;
+        f->code = MEDIA_BUS_FMT_FIXED;
         f->field = V4L2_FIELD_INTERLACED;
         f->colorspace = V4L2_COLORSPACE_SMPTE170M;
         return 0;
@@ -572,7 +572,7 @@ static int saa6752hs_try_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_frame
 {
         int dist_352, dist_480, dist_720;
 
-        f->code = V4L2_MBUS_FMT_FIXED;
+        f->code = MEDIA_BUS_FMT_FIXED;
 
         dist_352 = abs(f->width - 352);
         dist_480 = abs(f->width - 480);
@@ -599,7 +599,7 @@ static int saa6752hs_s_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefm
 {
         struct saa6752hs_state *h = to_state(sd);
 
-        if (f->code != V4L2_MBUS_FMT_FIXED)
+        if (f->code != MEDIA_BUS_FMT_FIXED)
                 return -EINVAL;
 
         /*
diff --git a/drivers/media/i2c/saa7115.c b/drivers/media/i2c/saa7115.c
index 35a44648150e..7147c8b68fac 100644
--- a/drivers/media/i2c/saa7115.c
+++ b/drivers/media/i2c/saa7115.c
@@ -1172,7 +1172,7 @@ static int saa711x_s_sliced_fmt(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_f
 
 static int saa711x_s_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *fmt)
 {
-        if (fmt->code != V4L2_MBUS_FMT_FIXED)
+        if (fmt->code != MEDIA_BUS_FMT_FIXED)
                 return -EINVAL;
         fmt->field = V4L2_FIELD_INTERLACED;
         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
diff --git a/drivers/media/i2c/saa717x.c b/drivers/media/i2c/saa717x.c
index 6922a9f9a5cd..0d0f9a917cd3 100644
--- a/drivers/media/i2c/saa717x.c
+++ b/drivers/media/i2c/saa717x.c
@@ -998,7 +998,7 @@ static int saa717x_s_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt
 
         v4l2_dbg(1, debug, sd, "decoder set size\n");
 
-        if (fmt->code != V4L2_MBUS_FMT_FIXED)
+        if (fmt->code != MEDIA_BUS_FMT_FIXED)
                 return -EINVAL;
 
         /* FIXME need better bounds checking here */
diff --git a/drivers/media/i2c/smiapp-pll.c b/drivers/media/i2c/smiapp-pll.c
index 2335529b195c..e40d9027df3d 100644
--- a/drivers/media/i2c/smiapp-pll.c
+++ b/drivers/media/i2c/smiapp-pll.c
@@ -65,26 +65,89 @@ static int bounds_check(struct device *dev, uint32_t val,
 
 static void print_pll(struct device *dev, struct smiapp_pll *pll)
 {
-        dev_dbg(dev, "pre_pll_clk_div\t%d\n",  pll->pre_pll_clk_div);
-        dev_dbg(dev, "pll_multiplier \t%d\n",  pll->pll_multiplier);
-        if (pll->flags != SMIAPP_PLL_FLAG_NO_OP_CLOCKS) {
-                dev_dbg(dev, "op_sys_clk_div \t%d\n", pll->op_sys_clk_div);
-                dev_dbg(dev, "op_pix_clk_div \t%d\n", pll->op_pix_clk_div);
+        dev_dbg(dev, "pre_pll_clk_div\t%u\n",  pll->pre_pll_clk_div);
+        dev_dbg(dev, "pll_multiplier \t%u\n",  pll->pll_multiplier);
+        if (!(pll->flags & SMIAPP_PLL_FLAG_NO_OP_CLOCKS)) {
+                dev_dbg(dev, "op_sys_clk_div \t%u\n", pll->op.sys_clk_div);
+                dev_dbg(dev, "op_pix_clk_div \t%u\n", pll->op.pix_clk_div);
         }
-        dev_dbg(dev, "vt_sys_clk_div \t%d\n",  pll->vt_sys_clk_div);
-        dev_dbg(dev, "vt_pix_clk_div \t%d\n",  pll->vt_pix_clk_div);
-
-        dev_dbg(dev, "ext_clk_freq_hz \t%d\n", pll->ext_clk_freq_hz);
-        dev_dbg(dev, "pll_ip_clk_freq_hz \t%d\n", pll->pll_ip_clk_freq_hz);
-        dev_dbg(dev, "pll_op_clk_freq_hz \t%d\n", pll->pll_op_clk_freq_hz);
-        if (pll->flags & SMIAPP_PLL_FLAG_NO_OP_CLOCKS) {
-                dev_dbg(dev, "op_sys_clk_freq_hz \t%d\n",
-                        pll->op_sys_clk_freq_hz);
-                dev_dbg(dev, "op_pix_clk_freq_hz \t%d\n",
-                        pll->op_pix_clk_freq_hz);
+        dev_dbg(dev, "vt_sys_clk_div \t%u\n",  pll->vt.sys_clk_div);
+        dev_dbg(dev, "vt_pix_clk_div \t%u\n",  pll->vt.pix_clk_div);
+
+        dev_dbg(dev, "ext_clk_freq_hz \t%u\n", pll->ext_clk_freq_hz);
+        dev_dbg(dev, "pll_ip_clk_freq_hz \t%u\n", pll->pll_ip_clk_freq_hz);
+        dev_dbg(dev, "pll_op_clk_freq_hz \t%u\n", pll->pll_op_clk_freq_hz);
+        if (!(pll->flags & SMIAPP_PLL_FLAG_NO_OP_CLOCKS)) {
+                dev_dbg(dev, "op_sys_clk_freq_hz \t%u\n",
+                        pll->op.sys_clk_freq_hz);
+                dev_dbg(dev, "op_pix_clk_freq_hz \t%u\n",
+                        pll->op.pix_clk_freq_hz);
         }
-        dev_dbg(dev, "vt_sys_clk_freq_hz \t%d\n", pll->vt_sys_clk_freq_hz);
-        dev_dbg(dev, "vt_pix_clk_freq_hz \t%d\n", pll->vt_pix_clk_freq_hz);
+        dev_dbg(dev, "vt_sys_clk_freq_hz \t%u\n", pll->vt.sys_clk_freq_hz);
+        dev_dbg(dev, "vt_pix_clk_freq_hz \t%u\n", pll->vt.pix_clk_freq_hz);
+}
+
+static int check_all_bounds(struct device *dev,
+                            const struct smiapp_pll_limits *limits,
+                            const struct smiapp_pll_branch_limits *op_limits,
+                            struct smiapp_pll *pll,
+                            struct smiapp_pll_branch *op_pll)
+{
+        int rval;
+
+        rval = bounds_check(dev, pll->pll_ip_clk_freq_hz,
+                            limits->min_pll_ip_freq_hz,
+                            limits->max_pll_ip_freq_hz,
+                            "pll_ip_clk_freq_hz");
+        if (!rval)
+                rval = bounds_check(
+                        dev, pll->pll_multiplier,
+                        limits->min_pll_multiplier, limits->max_pll_multiplier,
+                        "pll_multiplier");
+        if (!rval)
+                rval = bounds_check(
+                        dev, pll->pll_op_clk_freq_hz,
+                        limits->min_pll_op_freq_hz, limits->max_pll_op_freq_hz,
+                        "pll_op_clk_freq_hz");
+        if (!rval)
+                rval = bounds_check(
+                        dev, op_pll->sys_clk_div,
+                        op_limits->min_sys_clk_div, op_limits->max_sys_clk_div,
+                        "op_sys_clk_div");
+        if (!rval)
+                rval = bounds_check(
+                        dev, op_pll->sys_clk_freq_hz,
+                        op_limits->min_sys_clk_freq_hz,
+                        op_limits->max_sys_clk_freq_hz,
+                        "op_sys_clk_freq_hz");
+        if (!rval)
+                rval = bounds_check(
+                        dev, op_pll->pix_clk_freq_hz,
+                        op_limits->min_pix_clk_freq_hz,
+                        op_limits->max_pix_clk_freq_hz,
+                        "op_pix_clk_freq_hz");
+
+        /*
+         * If there are no OP clocks, the VT clocks are contained in
+         * the OP clock struct.
+         */
+        if (pll->flags & SMIAPP_PLL_FLAG_NO_OP_CLOCKS)
+                return rval;
+
+        if (!rval)
+                rval = bounds_check(
+                        dev, pll->vt.sys_clk_freq_hz,
+                        limits->vt.min_sys_clk_freq_hz,
+                        limits->vt.max_sys_clk_freq_hz,
+                        "vt_sys_clk_freq_hz");
+        if (!rval)
+                rval = bounds_check(
+                        dev, pll->vt.pix_clk_freq_hz,
+                        limits->vt.min_pix_clk_freq_hz,
+                        limits->vt.max_pix_clk_freq_hz,
+                        "vt_pix_clk_freq_hz");
+
+        return rval;
 }
 
 /*
@@ -98,10 +161,11 @@ static void print_pll(struct device *dev, struct smiapp_pll *pll)
  *
  * @return Zero on success, error code on error.
  */
-static int __smiapp_pll_calculate(struct device *dev,
-                                  const struct smiapp_pll_limits *limits,
-                                  struct smiapp_pll *pll, uint32_t mul,
-                                  uint32_t div, uint32_t lane_op_clock_ratio)
+static int __smiapp_pll_calculate(
+        struct device *dev, const struct smiapp_pll_limits *limits,
+        const struct smiapp_pll_branch_limits *op_limits,
+        struct smiapp_pll *pll, struct smiapp_pll_branch *op_pll, uint32_t mul,
+        uint32_t div, uint32_t lane_op_clock_ratio)
 {
         uint32_t sys_div;
         uint32_t best_pix_div = INT_MAX >> 1;
@@ -117,17 +181,16 @@ static int __smiapp_pll_calculate(struct device *dev,
         uint32_t min_vt_div, max_vt_div, vt_div;
         uint32_t min_sys_div, max_sys_div;
         unsigned int i;
-        int rval;
 
         /*
          * Get pre_pll_clk_div so that our pll_op_clk_freq_hz won't be
          * too high.
          */
-        dev_dbg(dev, "pre_pll_clk_div %d\n", pll->pre_pll_clk_div);
+        dev_dbg(dev, "pre_pll_clk_div %u\n", pll->pre_pll_clk_div);
 
         /* Don't go above max pll multiplier. */
         more_mul_max = limits->max_pll_multiplier / mul;
-        dev_dbg(dev, "more_mul_max: max_pll_multiplier check: %d\n",
+        dev_dbg(dev, "more_mul_max: max_pll_multiplier check: %u\n",
                 more_mul_max);
         /* Don't go above max pll op frequency. */
         more_mul_max =
@@ -135,30 +198,30 @@ static int __smiapp_pll_calculate(struct device *dev,
                       more_mul_max,
                       limits->max_pll_op_freq_hz
                       / (pll->ext_clk_freq_hz / pll->pre_pll_clk_div * mul));
-        dev_dbg(dev, "more_mul_max: max_pll_op_freq_hz check: %d\n",
+        dev_dbg(dev, "more_mul_max: max_pll_op_freq_hz check: %u\n",
                 more_mul_max);
         /* Don't go above the division capability of op sys clock divider. */
         more_mul_max = min(more_mul_max,
-                           limits->op.max_sys_clk_div * pll->pre_pll_clk_div
+                           op_limits->max_sys_clk_div * pll->pre_pll_clk_div
                            / div);
-        dev_dbg(dev, "more_mul_max: max_op_sys_clk_div check: %d\n",
+        dev_dbg(dev, "more_mul_max: max_op_sys_clk_div check: %u\n",
                 more_mul_max);
         /* Ensure we won't go above min_pll_multiplier. */
         more_mul_max = min(more_mul_max,
                            DIV_ROUND_UP(limits->max_pll_multiplier, mul));
-        dev_dbg(dev, "more_mul_max: min_pll_multiplier check: %d\n",
+        dev_dbg(dev, "more_mul_max: min_pll_multiplier check: %u\n",
                 more_mul_max);
 
         /* Ensure we won't go below min_pll_op_freq_hz. */
         more_mul_min = DIV_ROUND_UP(limits->min_pll_op_freq_hz,
                                     pll->ext_clk_freq_hz / pll->pre_pll_clk_div
                                     * mul);
-        dev_dbg(dev, "more_mul_min: min_pll_op_freq_hz check: %d\n",
+        dev_dbg(dev, "more_mul_min: min_pll_op_freq_hz check: %u\n",
                 more_mul_min);
         /* Ensure we won't go below min_pll_multiplier. */
         more_mul_min = max(more_mul_min,
                            DIV_ROUND_UP(limits->min_pll_multiplier, mul));
-        dev_dbg(dev, "more_mul_min: min_pll_multiplier check: %d\n",
+        dev_dbg(dev, "more_mul_min: min_pll_multiplier check: %u\n",
                 more_mul_min);
 
         if (more_mul_min > more_mul_max) {
@@ -168,23 +231,23 @@ static int __smiapp_pll_calculate(struct device *dev,
         }
 
         more_mul_factor = lcm(div, pll->pre_pll_clk_div) / div;
-        dev_dbg(dev, "more_mul_factor: %d\n", more_mul_factor);
-        more_mul_factor = lcm(more_mul_factor, limits->op.min_sys_clk_div);
+        dev_dbg(dev, "more_mul_factor: %u\n", more_mul_factor);
+        more_mul_factor = lcm(more_mul_factor, op_limits->min_sys_clk_div);
         dev_dbg(dev, "more_mul_factor: min_op_sys_clk_div: %d\n",
                 more_mul_factor);
         i = roundup(more_mul_min, more_mul_factor);
         if (!is_one_or_even(i))
                 i <<= 1;
 
-        dev_dbg(dev, "final more_mul: %d\n", i);
+        dev_dbg(dev, "final more_mul: %u\n", i);
         if (i > more_mul_max) {
-                dev_dbg(dev, "final more_mul is bad, max %d\n", more_mul_max);
+                dev_dbg(dev, "final more_mul is bad, max %u\n", more_mul_max);
                 return -EINVAL;
         }
 
         pll->pll_multiplier = mul * i;
-        pll->op_sys_clk_div = div * i / pll->pre_pll_clk_div;
-        dev_dbg(dev, "op_sys_clk_div: %d\n", pll->op_sys_clk_div);
+        op_pll->sys_clk_div = div * i / pll->pre_pll_clk_div;
+        dev_dbg(dev, "op_sys_clk_div: %u\n", op_pll->sys_clk_div);
 
         pll->pll_ip_clk_freq_hz = pll->ext_clk_freq_hz
                 / pll->pre_pll_clk_div;
@@ -193,14 +256,19 @@ static int __smiapp_pll_calculate(struct device *dev,
                 * pll->pll_multiplier;
 
         /* Derive pll_op_clk_freq_hz. */
-        pll->op_sys_clk_freq_hz =
-                pll->pll_op_clk_freq_hz / pll->op_sys_clk_div;
+        op_pll->sys_clk_freq_hz =
+                pll->pll_op_clk_freq_hz / op_pll->sys_clk_div;
+
+        op_pll->pix_clk_div = pll->bits_per_pixel;
+        dev_dbg(dev, "op_pix_clk_div: %u\n", op_pll->pix_clk_div);
 
-        pll->op_pix_clk_div = pll->bits_per_pixel;
-        dev_dbg(dev, "op_pix_clk_div: %d\n", pll->op_pix_clk_div);
+        op_pll->pix_clk_freq_hz =
+                op_pll->sys_clk_freq_hz / op_pll->pix_clk_div;
 
-        pll->op_pix_clk_freq_hz =
-                pll->op_sys_clk_freq_hz / pll->op_pix_clk_div;
+        if (pll->flags & SMIAPP_PLL_FLAG_NO_OP_CLOCKS) {
+                /* No OP clocks --- VT clocks are used instead. */
+                goto out_skip_vt_calc;
+        }
 
         /*
          * Some sensors perform analogue binning and some do this
@@ -214,7 +282,7 @@ static int __smiapp_pll_calculate(struct device *dev,
                 vt_op_binning_div = pll->binning_horizontal;
         else
                 vt_op_binning_div = 1;
-        dev_dbg(dev, "vt_op_binning_div: %d\n", vt_op_binning_div);
+        dev_dbg(dev, "vt_op_binning_div: %u\n", vt_op_binning_div);
 
         /*
          * Profile 2 supports vt_pix_clk_div E [4, 10]
@@ -227,30 +295,30 @@ static int __smiapp_pll_calculate(struct device *dev,
          *
          * Find absolute limits for the factor of vt divider.
          */
-        dev_dbg(dev, "scale_m: %d\n", pll->scale_m);
-        min_vt_div = DIV_ROUND_UP(pll->op_pix_clk_div * pll->op_sys_clk_div
+        dev_dbg(dev, "scale_m: %u\n", pll->scale_m);
+        min_vt_div = DIV_ROUND_UP(op_pll->pix_clk_div * op_pll->sys_clk_div
                                   * pll->scale_n,
                                   lane_op_clock_ratio * vt_op_binning_div
                                   * pll->scale_m);
 
         /* Find smallest and biggest allowed vt divisor. */
-        dev_dbg(dev, "min_vt_div: %d\n", min_vt_div);
+        dev_dbg(dev, "min_vt_div: %u\n", min_vt_div);
         min_vt_div = max(min_vt_div,
                          DIV_ROUND_UP(pll->pll_op_clk_freq_hz,
                                       limits->vt.max_pix_clk_freq_hz));
-        dev_dbg(dev, "min_vt_div: max_vt_pix_clk_freq_hz: %d\n",
+        dev_dbg(dev, "min_vt_div: max_vt_pix_clk_freq_hz: %u\n",
                 min_vt_div);
         min_vt_div = max_t(uint32_t, min_vt_div,
                            limits->vt.min_pix_clk_div
                            * limits->vt.min_sys_clk_div);
-        dev_dbg(dev, "min_vt_div: min_vt_clk_div: %d\n", min_vt_div);
+        dev_dbg(dev, "min_vt_div: min_vt_clk_div: %u\n", min_vt_div);
 
         max_vt_div = limits->vt.max_sys_clk_div * limits->vt.max_pix_clk_div;
-        dev_dbg(dev, "max_vt_div: %d\n", max_vt_div);
+        dev_dbg(dev, "max_vt_div: %u\n", max_vt_div);
         max_vt_div = min(max_vt_div,
                          DIV_ROUND_UP(pll->pll_op_clk_freq_hz,
                                       limits->vt.min_pix_clk_freq_hz));
-        dev_dbg(dev, "max_vt_div: min_vt_pix_clk_freq_hz: %d\n",
+        dev_dbg(dev, "max_vt_div: min_vt_pix_clk_freq_hz: %u\n",
                 max_vt_div);
 
         /*
@@ -258,28 +326,28 @@ static int __smiapp_pll_calculate(struct device *dev,
          * with all values of pix_clk_div.
          */
         min_sys_div = limits->vt.min_sys_clk_div;
-        dev_dbg(dev, "min_sys_div: %d\n", min_sys_div);
+        dev_dbg(dev, "min_sys_div: %u\n", min_sys_div);
         min_sys_div = max(min_sys_div,
                           DIV_ROUND_UP(min_vt_div,
                                        limits->vt.max_pix_clk_div));
-        dev_dbg(dev, "min_sys_div: max_vt_pix_clk_div: %d\n", min_sys_div);
+        dev_dbg(dev, "min_sys_div: max_vt_pix_clk_div: %u\n", min_sys_div);
         min_sys_div = max(min_sys_div,
                           pll->pll_op_clk_freq_hz
                           / limits->vt.max_sys_clk_freq_hz);
-        dev_dbg(dev, "min_sys_div: max_pll_op_clk_freq_hz: %d\n", min_sys_div);
+        dev_dbg(dev, "min_sys_div: max_pll_op_clk_freq_hz: %u\n", min_sys_div);
         min_sys_div = clk_div_even_up(min_sys_div);
-        dev_dbg(dev, "min_sys_div: one or even: %d\n", min_sys_div);
+        dev_dbg(dev, "min_sys_div: one or even: %u\n", min_sys_div);
 
         max_sys_div = limits->vt.max_sys_clk_div;
-        dev_dbg(dev, "max_sys_div: %d\n", max_sys_div);
+        dev_dbg(dev, "max_sys_div: %u\n", max_sys_div);
         max_sys_div = min(max_sys_div,
                           DIV_ROUND_UP(max_vt_div,
                                        limits->vt.min_pix_clk_div));
-        dev_dbg(dev, "max_sys_div: min_vt_pix_clk_div: %d\n", max_sys_div);
+        dev_dbg(dev, "max_sys_div: min_vt_pix_clk_div: %u\n", max_sys_div);
         max_sys_div = min(max_sys_div,
                           DIV_ROUND_UP(pll->pll_op_clk_freq_hz,
                                        limits->vt.min_pix_clk_freq_hz));
-        dev_dbg(dev, "max_sys_div: min_vt_pix_clk_freq_hz: %d\n", max_sys_div);
+        dev_dbg(dev, "max_sys_div: min_vt_pix_clk_freq_hz: %u\n", max_sys_div);
 
         /*
          * Find pix_div such that a legal pix_div * sys_div results
@@ -296,7 +364,7 @@ static int __smiapp_pll_calculate(struct device *dev,
                         if (pix_div < limits->vt.min_pix_clk_div
                             || pix_div > limits->vt.max_pix_clk_div) {
                                 dev_dbg(dev,
-                                        "pix_div %d too small or too big (%d--%d)\n",
+                                        "pix_div %u too small or too big (%u--%u)\n",
                                         pix_div,
                                         limits->vt.min_pix_clk_div,
                                         limits->vt.max_pix_clk_div);
@@ -312,73 +380,28 @@ static int __smiapp_pll_calculate(struct device *dev,
                         break;
         }
 
-        pll->vt_sys_clk_div = DIV_ROUND_UP(min_vt_div, best_pix_div);
-        pll->vt_pix_clk_div = best_pix_div;
+        pll->vt.sys_clk_div = DIV_ROUND_UP(min_vt_div, best_pix_div);
+        pll->vt.pix_clk_div = best_pix_div;
 
-        pll->vt_sys_clk_freq_hz =
-                pll->pll_op_clk_freq_hz / pll->vt_sys_clk_div;
-        pll->vt_pix_clk_freq_hz =
-                pll->vt_sys_clk_freq_hz / pll->vt_pix_clk_div;
+        pll->vt.sys_clk_freq_hz =
+                pll->pll_op_clk_freq_hz / pll->vt.sys_clk_div;
+        pll->vt.pix_clk_freq_hz =
+                pll->vt.sys_clk_freq_hz / pll->vt.pix_clk_div;
 
+out_skip_vt_calc:
         pll->pixel_rate_csi =
-                pll->op_pix_clk_freq_hz * lane_op_clock_ratio;
+                op_pll->pix_clk_freq_hz * lane_op_clock_ratio;
+        pll->pixel_rate_pixel_array = pll->vt.pix_clk_freq_hz;
 
-        rval = bounds_check(dev, pll->pll_ip_clk_freq_hz,
-                            limits->min_pll_ip_freq_hz,
-                            limits->max_pll_ip_freq_hz,
-                            "pll_ip_clk_freq_hz");
-        if (!rval)
-                rval = bounds_check(
-                        dev, pll->pll_multiplier,
-                        limits->min_pll_multiplier, limits->max_pll_multiplier,
-                        "pll_multiplier");
-        if (!rval)
-                rval = bounds_check(
-                        dev, pll->pll_op_clk_freq_hz,
-                        limits->min_pll_op_freq_hz, limits->max_pll_op_freq_hz,
-                        "pll_op_clk_freq_hz");
-        if (!rval)
-                rval = bounds_check(
-                        dev, pll->op_sys_clk_div,
-                        limits->op.min_sys_clk_div, limits->op.max_sys_clk_div,
-                        "op_sys_clk_div");
-        if (!rval)
-                rval = bounds_check(
-                        dev, pll->op_pix_clk_div,
-                        limits->op.min_pix_clk_div, limits->op.max_pix_clk_div,
-                        "op_pix_clk_div");
-        if (!rval)
-                rval = bounds_check(
-                        dev, pll->op_sys_clk_freq_hz,
-                        limits->op.min_sys_clk_freq_hz,
-                        limits->op.max_sys_clk_freq_hz,
-                        "op_sys_clk_freq_hz");
-        if (!rval)
-                rval = bounds_check(
-                        dev, pll->op_pix_clk_freq_hz,
-                        limits->op.min_pix_clk_freq_hz,
-                        limits->op.max_pix_clk_freq_hz,
-                        "op_pix_clk_freq_hz");
-        if (!rval)
-                rval = bounds_check(
-                        dev, pll->vt_sys_clk_freq_hz,
-                        limits->vt.min_sys_clk_freq_hz,
-                        limits->vt.max_sys_clk_freq_hz,
-                        "vt_sys_clk_freq_hz");
-        if (!rval)
-                rval = bounds_check(
-                        dev, pll->vt_pix_clk_freq_hz,
-                        limits->vt.min_pix_clk_freq_hz,
-                        limits->vt.max_pix_clk_freq_hz,
-                        "vt_pix_clk_freq_hz");
-
-        return rval;
+        return check_all_bounds(dev, limits, op_limits, pll, op_pll);
 }
 
 int smiapp_pll_calculate(struct device *dev,
                          const struct smiapp_pll_limits *limits,
                          struct smiapp_pll *pll)
 {
+        const struct smiapp_pll_branch_limits *op_limits = &limits->op;
+        struct smiapp_pll_branch *op_pll = &pll->op;
         uint16_t min_pre_pll_clk_div;
         uint16_t max_pre_pll_clk_div;
         uint32_t lane_op_clock_ratio;
@@ -386,13 +409,23 @@ int smiapp_pll_calculate(struct device *dev,
         unsigned int i;
         int rval = -EINVAL;
 
+        if (pll->flags & SMIAPP_PLL_FLAG_NO_OP_CLOCKS) {
+                /*
+                 * If there's no OP PLL at all, use the VT values
+                 * instead. The OP values are ignored for the rest of
+                 * the PLL calculation.
+                 */
+                op_limits = &limits->vt;
+                op_pll = &pll->vt;
+        }
+
         if (pll->flags & SMIAPP_PLL_FLAG_OP_PIX_CLOCK_PER_LANE)
                 lane_op_clock_ratio = pll->csi2.lanes;
         else
                 lane_op_clock_ratio = 1;
-        dev_dbg(dev, "lane_op_clock_ratio: %d\n", lane_op_clock_ratio);
+        dev_dbg(dev, "lane_op_clock_ratio: %u\n", lane_op_clock_ratio);
 
-        dev_dbg(dev, "binning: %dx%d\n", pll->binning_horizontal,
+        dev_dbg(dev, "binning: %ux%u\n", pll->binning_horizontal,
                 pll->binning_vertical);
 
         switch (pll->bus_type) {
@@ -411,7 +444,7 @@ int smiapp_pll_calculate(struct device *dev,
         }
 
         /* Figure out limits for pre-pll divider based on extclk */
-        dev_dbg(dev, "min / max pre_pll_clk_div: %d / %d\n",
+        dev_dbg(dev, "min / max pre_pll_clk_div: %u / %u\n",
                 limits->min_pre_pll_clk_div, limits->max_pre_pll_clk_div);
         max_pre_pll_clk_div =
                 min_t(uint16_t, limits->max_pre_pll_clk_div,
@@ -422,26 +455,27 @@ int smiapp_pll_calculate(struct device *dev,
                       clk_div_even_up(
                               DIV_ROUND_UP(pll->ext_clk_freq_hz,
                                            limits->max_pll_ip_freq_hz)));
-        dev_dbg(dev, "pre-pll check: min / max pre_pll_clk_div: %d / %d\n",
+        dev_dbg(dev, "pre-pll check: min / max pre_pll_clk_div: %u / %u\n",
                 min_pre_pll_clk_div, max_pre_pll_clk_div);
 
         i = gcd(pll->pll_op_clk_freq_hz, pll->ext_clk_freq_hz);
         mul = div_u64(pll->pll_op_clk_freq_hz, i);
         div = pll->ext_clk_freq_hz / i;
-        dev_dbg(dev, "mul %d / div %d\n", mul, div);
+        dev_dbg(dev, "mul %u / div %u\n", mul, div);
 
         min_pre_pll_clk_div =
                 max_t(uint16_t, min_pre_pll_clk_div,
                       clk_div_even_up(
                               DIV_ROUND_UP(mul * pll->ext_clk_freq_hz,
                                            limits->max_pll_op_freq_hz)));
-        dev_dbg(dev, "pll_op check: min / max pre_pll_clk_div: %d / %d\n",
+        dev_dbg(dev, "pll_op check: min / max pre_pll_clk_div: %u / %u\n",
                 min_pre_pll_clk_div, max_pre_pll_clk_div);
 
         for (pll->pre_pll_clk_div = min_pre_pll_clk_div;
              pll->pre_pll_clk_div <= max_pre_pll_clk_div;
              pll->pre_pll_clk_div += 2 - (pll->pre_pll_clk_div & 1)) {
-                rval = __smiapp_pll_calculate(dev, limits, pll, mul, div,
+                rval = __smiapp_pll_calculate(dev, limits, op_limits, pll,
+                                              op_pll, mul, div,
                                               lane_op_clock_ratio);
                 if (rval)
                         continue;
diff --git a/drivers/media/i2c/smiapp-pll.h b/drivers/media/i2c/smiapp-pll.h
index 5ce2b61da3c5..e8f035a50c76 100644
--- a/drivers/media/i2c/smiapp-pll.h
+++ b/drivers/media/i2c/smiapp-pll.h
@@ -35,6 +35,13 @@
 #define SMIAPP_PLL_FLAG_OP_PIX_CLOCK_PER_LANE                   (1 << 0)
 #define SMIAPP_PLL_FLAG_NO_OP_CLOCKS                            (1 << 1)
 
+struct smiapp_pll_branch {
+        uint16_t sys_clk_div;
+        uint16_t pix_clk_div;
+        uint32_t sys_clk_freq_hz;
+        uint32_t pix_clk_freq_hz;
+};
+
 struct smiapp_pll {
         /* input values */
         uint8_t bus_type;
@@ -53,24 +60,18 @@ struct smiapp_pll {
         uint8_t scale_n;
         uint8_t bits_per_pixel;
         uint32_t link_freq;
+        uint32_t ext_clk_freq_hz;
 
         /* output values */
         uint16_t pre_pll_clk_div;
         uint16_t pll_multiplier;
-        uint16_t op_sys_clk_div;
-        uint16_t op_pix_clk_div;
-        uint16_t vt_sys_clk_div;
-        uint16_t vt_pix_clk_div;
-
-        uint32_t ext_clk_freq_hz;
         uint32_t pll_ip_clk_freq_hz;
         uint32_t pll_op_clk_freq_hz;
-        uint32_t op_sys_clk_freq_hz;
-        uint32_t op_pix_clk_freq_hz;
-        uint32_t vt_sys_clk_freq_hz;
-        uint32_t vt_pix_clk_freq_hz;
+        struct smiapp_pll_branch vt;
+        struct smiapp_pll_branch op;
 
         uint32_t pixel_rate_csi;
+        uint32_t pixel_rate_pixel_array;
 };
 
 struct smiapp_pll_branch_limits {
diff --git a/drivers/media/i2c/smiapp/smiapp-core.c b/drivers/media/i2c/smiapp/smiapp-core.c
index 932ed9be9ff3..0df5070e73c7 100644
--- a/drivers/media/i2c/smiapp/smiapp-core.c
+++ b/drivers/media/i2c/smiapp/smiapp-core.c
@@ -205,12 +205,12 @@ static int smiapp_pll_configure(struct smiapp_sensor *sensor)
         int rval;
 
         rval = smiapp_write(
-                sensor, SMIAPP_REG_U16_VT_PIX_CLK_DIV, pll->vt_pix_clk_div);
+                sensor, SMIAPP_REG_U16_VT_PIX_CLK_DIV, pll->vt.pix_clk_div);
         if (rval < 0)
                 return rval;
 
         rval = smiapp_write(
-                sensor, SMIAPP_REG_U16_VT_SYS_CLK_DIV, pll->vt_sys_clk_div);
+                sensor, SMIAPP_REG_U16_VT_SYS_CLK_DIV, pll->vt.sys_clk_div);
         if (rval < 0)
                 return rval;
 
@@ -227,20 +227,21 @@ static int smiapp_pll_configure(struct smiapp_sensor *sensor)
         /* Lane op clock ratio does not apply here. */
         rval = smiapp_write(
                 sensor, SMIAPP_REG_U32_REQUESTED_LINK_BIT_RATE_MBPS,
-                DIV_ROUND_UP(pll->op_sys_clk_freq_hz, 1000000 / 256 / 256));
+                DIV_ROUND_UP(pll->op.sys_clk_freq_hz, 1000000 / 256 / 256));
         if (rval < 0 || sensor->minfo.smiapp_profile == SMIAPP_PROFILE_0)
                 return rval;
 
         rval = smiapp_write(
-                sensor, SMIAPP_REG_U16_OP_PIX_CLK_DIV, pll->op_pix_clk_div);
+                sensor, SMIAPP_REG_U16_OP_PIX_CLK_DIV, pll->op.pix_clk_div);
         if (rval < 0)
                 return rval;
 
         return smiapp_write(
-                sensor, SMIAPP_REG_U16_OP_SYS_CLK_DIV, pll->op_sys_clk_div);
+                sensor, SMIAPP_REG_U16_OP_SYS_CLK_DIV, pll->op.sys_clk_div);
 }
 
-static int smiapp_pll_update(struct smiapp_sensor *sensor)
+static int smiapp_pll_try(struct smiapp_sensor *sensor,
+                          struct smiapp_pll *pll)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
         struct smiapp_pll_limits lim = {
@@ -274,19 +275,15 @@ static int smiapp_pll_update(struct smiapp_sensor *sensor)
                 .min_line_length_pck_bin = sensor->limits[SMIAPP_LIMIT_MIN_LINE_LENGTH_PCK_BIN],
                 .min_line_length_pck = sensor->limits[SMIAPP_LIMIT_MIN_LINE_LENGTH_PCK],
         };
+
+        return smiapp_pll_calculate(&client->dev, &lim, pll);
+}
+
+static int smiapp_pll_update(struct smiapp_sensor *sensor)
+{
         struct smiapp_pll *pll = &sensor->pll;
         int rval;
 
-        if (sensor->minfo.smiapp_profile == SMIAPP_PROFILE_0) {
-                /*
-                 * Fill in operational clock divisors limits from the
-                 * video timing ones. On profile 0 sensors the
-                 * requirements regarding them are essentially the
-                 * same as on VT ones.
-                 */
-                lim.op = lim.vt;
-        }
-
         pll->binning_horizontal = sensor->binning_horizontal;
         pll->binning_vertical = sensor->binning_vertical;
         pll->link_freq =
@@ -294,12 +291,12 @@ static int smiapp_pll_update(struct smiapp_sensor *sensor)
         pll->scale_m = sensor->scale_m;
         pll->bits_per_pixel = sensor->csi_format->compressed;
 
-        rval = smiapp_pll_calculate(&client->dev, &lim, pll);
+        rval = smiapp_pll_try(sensor, pll);
         if (rval < 0)
                 return rval;
 
         __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_parray,
-                                 pll->vt_pix_clk_freq_hz);
+                                 pll->pixel_rate_pixel_array);
         __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_csi, pll->pixel_rate_csi);
 
         return 0;
@@ -333,22 +330,22 @@ static void __smiapp_update_exposure_limits(struct smiapp_sensor *sensor)
  *    orders must be defined.
  */
 static const struct smiapp_csi_data_format smiapp_csi_data_formats[] = {
-        { V4L2_MBUS_FMT_SGRBG12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_GRBG, },
-        { V4L2_MBUS_FMT_SRGGB12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_RGGB, },
-        { V4L2_MBUS_FMT_SBGGR12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_BGGR, },
-        { V4L2_MBUS_FMT_SGBRG12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_GBRG, },
-        { V4L2_MBUS_FMT_SGRBG10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_GRBG, },
-        { V4L2_MBUS_FMT_SRGGB10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_RGGB, },
-        { V4L2_MBUS_FMT_SBGGR10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_BGGR, },
-        { V4L2_MBUS_FMT_SGBRG10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_GBRG, },
-        { V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_GRBG, },
-        { V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_RGGB, },
-        { V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_BGGR, },
-        { V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_GBRG, },
-        { V4L2_MBUS_FMT_SGRBG8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_GRBG, },
-        { V4L2_MBUS_FMT_SRGGB8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_RGGB, },
-        { V4L2_MBUS_FMT_SBGGR8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_BGGR, },
-        { V4L2_MBUS_FMT_SGBRG8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_GBRG, },
+        { MEDIA_BUS_FMT_SGRBG12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_GRBG, },
+        { MEDIA_BUS_FMT_SRGGB12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_RGGB, },
+        { MEDIA_BUS_FMT_SBGGR12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_BGGR, },
+        { MEDIA_BUS_FMT_SGBRG12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_GBRG, },
+        { MEDIA_BUS_FMT_SGRBG10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_GRBG, },
+        { MEDIA_BUS_FMT_SRGGB10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_RGGB, },
+        { MEDIA_BUS_FMT_SBGGR10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_BGGR, },
+        { MEDIA_BUS_FMT_SGBRG10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_GBRG, },
+        { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_GRBG, },
+        { MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_RGGB, },
+        { MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_BGGR, },
+        { MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_GBRG, },
+        { MEDIA_BUS_FMT_SGRBG8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_GRBG, },
+        { MEDIA_BUS_FMT_SRGGB8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_RGGB, },
+        { MEDIA_BUS_FMT_SBGGR8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_BGGR, },
+        { MEDIA_BUS_FMT_SGBRG8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_GBRG, },
 };
 
 const char *pixel_order_str[] = { "GRBG", "RGGB", "BGGR", "GBRG" };
@@ -526,6 +523,8 @@ static const struct v4l2_ctrl_ops smiapp_ctrl_ops = {
 static int smiapp_init_controls(struct smiapp_sensor *sensor)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
+        unsigned long *valid_link_freqs = &sensor->valid_link_freqs[
+                sensor->csi_format->compressed - SMIAPP_COMPRESSED_BASE];
         unsigned int max, i;
         int rval;
 
@@ -608,8 +607,8 @@ static int smiapp_init_controls(struct smiapp_sensor *sensor)
 
         sensor->link_freq = v4l2_ctrl_new_int_menu(
                 &sensor->src->ctrl_handler, &smiapp_ctrl_ops,
-                V4L2_CID_LINK_FREQ, max, 0,
-                sensor->platform_data->op_sys_clock);
+                V4L2_CID_LINK_FREQ, __fls(*valid_link_freqs),
+                __ffs(*valid_link_freqs), sensor->platform_data->op_sys_clock);
 
         sensor->pixel_rate_csi = v4l2_ctrl_new_std(
                 &sensor->src->ctrl_handler, &smiapp_ctrl_ops,
@@ -745,6 +744,7 @@ static int smiapp_get_limits_binning(struct smiapp_sensor *sensor)
 static int smiapp_get_mbus_formats(struct smiapp_sensor *sensor)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
+        struct smiapp_pll *pll = &sensor->pll;
         unsigned int type, n;
         unsigned int i, pixel_order;
         int rval;
@@ -808,14 +808,57 @@ static int smiapp_get_mbus_formats(struct smiapp_sensor *sensor)
                         dev_dbg(&client->dev, "jolly good! %d\n", j);
 
                         sensor->default_mbus_frame_fmts |= 1 << j;
-                        if (!sensor->csi_format
-                            || f->width > sensor->csi_format->width
-                            || (f->width == sensor->csi_format->width
-                                && f->compressed
-                                > sensor->csi_format->compressed)) {
-                                sensor->csi_format = f;
-                                sensor->internal_csi_format = f;
-                        }
+                }
+        }
+
+        /* Figure out which BPP values can be used with which formats. */
+        pll->binning_horizontal = 1;
+        pll->binning_vertical = 1;
+        pll->scale_m = sensor->scale_m;
+
+        for (i = 0; i < ARRAY_SIZE(smiapp_csi_data_formats); i++) {
+                const struct smiapp_csi_data_format *f =
+                        &smiapp_csi_data_formats[i];
+                unsigned long *valid_link_freqs =
+                        &sensor->valid_link_freqs[
+                                f->compressed - SMIAPP_COMPRESSED_BASE];
+                unsigned int j;
+
+                BUG_ON(f->compressed < SMIAPP_COMPRESSED_BASE);
+                BUG_ON(f->compressed > SMIAPP_COMPRESSED_MAX);
+
+                if (!(sensor->default_mbus_frame_fmts & 1 << i))
+                        continue;
+
+                pll->bits_per_pixel = f->compressed;
+
+                for (j = 0; sensor->platform_data->op_sys_clock[j]; j++) {
+                        pll->link_freq = sensor->platform_data->op_sys_clock[j];
+
+                        rval = smiapp_pll_try(sensor, pll);
+                        dev_dbg(&client->dev, "link freq %u Hz, bpp %u %s\n",
+                                pll->link_freq, pll->bits_per_pixel,
+                                rval ? "not ok" : "ok");
+                        if (rval)
+                                continue;
+
+                        set_bit(j, valid_link_freqs);
+                }
+
+                if (!*valid_link_freqs) {
+                        dev_info(&client->dev,
+                                 "no valid link frequencies for %u bpp\n",
+                                 f->compressed);
+                        sensor->default_mbus_frame_fmts &= ~BIT(i);
+                        continue;
+                }
+
+                if (!sensor->csi_format
+                    || f->width > sensor->csi_format->width
+                    || (f->width == sensor->csi_format->width
+                        && f->compressed > sensor->csi_format->compressed)) {
+                        sensor->csi_format = f;
+                        sensor->internal_csi_format = f;
                 }
         }
 
@@ -904,7 +947,7 @@ static int smiapp_update_mode(struct smiapp_sensor *sensor)
         dev_dbg(&client->dev, "hblank\t\t%d\n", sensor->hblank->val);
 
         dev_dbg(&client->dev, "real timeperframe\t100/%d\n",
-                sensor->pll.vt_pix_clk_freq_hz /
+                sensor->pll.pixel_rate_pixel_array /
                 ((sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].width
                   + sensor->hblank->val) *
                  (sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height
@@ -1687,51 +1730,77 @@ static const struct smiapp_csi_data_format
         return csi_format;
 }
 
-static int smiapp_set_format(struct v4l2_subdev *subdev,
-                             struct v4l2_subdev_fh *fh,
-                             struct v4l2_subdev_format *fmt)
+static int smiapp_set_format_source(struct v4l2_subdev *subdev,
+                                    struct v4l2_subdev_fh *fh,
+                                    struct v4l2_subdev_format *fmt)
 {
         struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
-        struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
-        struct v4l2_rect *crops[SMIAPP_PADS];
+        const struct smiapp_csi_data_format *csi_format,
+                *old_csi_format = sensor->csi_format;
+        unsigned long *valid_link_freqs;
+        u32 code = fmt->format.code;
+        unsigned int i;
+        int rval;
 
-        mutex_lock(&sensor->mutex);
+        rval = __smiapp_get_format(subdev, fh, fmt);
+        if (rval)
+                return rval;
 
         /*
          * Media bus code is changeable on src subdev's source pad. On
          * other source pads we just get format here.
          */
-        if (fmt->pad == ssd->source_pad) {
-                u32 code = fmt->format.code;
-                int rval = __smiapp_get_format(subdev, fh, fmt);
-                bool range_changed = false;
-                unsigned int i;
-
-                if (!rval && subdev == &sensor->src->sd) {
-                        const struct smiapp_csi_data_format *csi_format =
-                                smiapp_validate_csi_data_format(sensor, code);
+        if (subdev != &sensor->src->sd)
+                return 0;
 
-                        if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
-                                if (csi_format->width !=
-                                    sensor->csi_format->width)
-                                        range_changed = true;
+        csi_format = smiapp_validate_csi_data_format(sensor, code);
 
-                                sensor->csi_format = csi_format;
-                        }
+        fmt->format.code = csi_format->code;
 
-                        fmt->format.code = csi_format->code;
-                }
+        if (fmt->which != V4L2_SUBDEV_FORMAT_ACTIVE)
+                return 0;
 
-                mutex_unlock(&sensor->mutex);
-                if (rval || !range_changed)
-                        return rval;
+        sensor->csi_format = csi_format;
 
+        if (csi_format->width != old_csi_format->width)
                 for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++)
-                        v4l2_ctrl_modify_range(
-                                sensor->test_data[i],
-                                0, (1 << sensor->csi_format->width) - 1, 1, 0);
+                        __v4l2_ctrl_modify_range(
+                                sensor->test_data[i], 0,
+                                (1 << csi_format->width) - 1, 1, 0);
 
+        if (csi_format->compressed == old_csi_format->compressed)
                 return 0;
+
+        valid_link_freqs = 
+                &sensor->valid_link_freqs[sensor->csi_format->compressed
+                                          - SMIAPP_COMPRESSED_BASE];
+
+        __v4l2_ctrl_modify_range(
+                sensor->link_freq, 0,
+                __fls(*valid_link_freqs), ~*valid_link_freqs,
+                __ffs(*valid_link_freqs));
+
+        return smiapp_pll_update(sensor);
+}
+
+static int smiapp_set_format(struct v4l2_subdev *subdev,
+                             struct v4l2_subdev_fh *fh,
+                             struct v4l2_subdev_format *fmt)
+{
+        struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
+        struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
+        struct v4l2_rect *crops[SMIAPP_PADS];
+
+        mutex_lock(&sensor->mutex);
+
+        if (fmt->pad == ssd->source_pad) {
+                int rval;
+
+                rval = smiapp_set_format_source(subdev, fh, fmt);
+
+                mutex_unlock(&sensor->mutex);
+
+                return rval;
         }
 
         /* Sink pad. Width and height are changeable here. */
@@ -2023,6 +2092,11 @@ static int __smiapp_sel_supported(struct v4l2_subdev *subdev,
                     == SMIAPP_DIGITAL_CROP_CAPABILITY_INPUT_CROP)
                         return 0;
                 return -EINVAL;
+        case V4L2_SEL_TGT_NATIVE_SIZE:
+                if (ssd == sensor->pixel_array
+                    && sel->pad == SMIAPP_PA_PAD_SRC)
+                        return 0;
+                return -EINVAL;
         case V4L2_SEL_TGT_COMPOSE:
         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
                 if (sel->pad == ssd->source_pad)
@@ -2121,7 +2195,9 @@ static int __smiapp_get_selection(struct v4l2_subdev *subdev,
 
         switch (sel->target) {
         case V4L2_SEL_TGT_CROP_BOUNDS:
+        case V4L2_SEL_TGT_NATIVE_SIZE:
                 if (ssd == sensor->pixel_array) {
+                        sel->r.left = sel->r.top = 0;
                         sel->r.width =
                                 sensor->limits[SMIAPP_LIMIT_X_ADDR_MAX] + 1;
                         sel->r.height =
@@ -2190,7 +2266,7 @@ static int smiapp_set_selection(struct v4l2_subdev *subdev,
                 ret = smiapp_set_compose(subdev, fh, sel);
                 break;
         default:
-                BUG();
+                ret = -EINVAL;
         }
 
         mutex_unlock(&sensor->mutex);
@@ -2482,12 +2558,6 @@ static int smiapp_registered(struct v4l2_subdev *subdev)
                 goto out_power_off;
         }
 
-        rval = smiapp_get_mbus_formats(sensor);
-        if (rval) {
-                rval = -ENODEV;
-                goto out_power_off;
-        }
-
         if (sensor->limits[SMIAPP_LIMIT_BINNING_CAPABILITY]) {
                 u32 val;
 
@@ -2569,6 +2639,22 @@ static int smiapp_registered(struct v4l2_subdev *subdev)
 
         sensor->scale_m = sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN];
 
+        /* prepare PLL configuration input values */
+        pll->bus_type = SMIAPP_PLL_BUS_TYPE_CSI2;
+        pll->csi2.lanes = sensor->platform_data->lanes;
+        pll->ext_clk_freq_hz = sensor->platform_data->ext_clk;
+        pll->flags = smiapp_call_quirk(sensor, pll_flags);
+        pll->scale_n = sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN];
+        /* Profile 0 sensors have no separate OP clock branch. */
+        if (sensor->minfo.smiapp_profile == SMIAPP_PROFILE_0)
+                pll->flags |= SMIAPP_PLL_FLAG_NO_OP_CLOCKS;
+
+        rval = smiapp_get_mbus_formats(sensor);
+        if (rval) {
+                rval = -ENODEV;
+                goto out_nvm_release;
+        }
+
         for (i = 0; i < SMIAPP_SUBDEVS; i++) {
                 struct {
                         struct smiapp_subdev *ssd;
@@ -2666,18 +2752,9 @@ static int smiapp_registered(struct v4l2_subdev *subdev)
         if (rval < 0)
                 goto out_nvm_release;
 
-        /* prepare PLL configuration input values */
-        pll->bus_type = SMIAPP_PLL_BUS_TYPE_CSI2;
-        pll->csi2.lanes = sensor->platform_data->lanes;
-        pll->ext_clk_freq_hz = sensor->platform_data->ext_clk;
-        pll->flags = smiapp_call_quirk(sensor, pll_flags);
-
-        /* Profile 0 sensors have no separate OP clock branch. */
-        if (sensor->minfo.smiapp_profile == SMIAPP_PROFILE_0)
-                pll->flags |= SMIAPP_PLL_FLAG_NO_OP_CLOCKS;
-        pll->scale_n = sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN];
-
+        mutex_lock(&sensor->mutex);
         rval = smiapp_update_mode(sensor);
+        mutex_unlock(&sensor->mutex);
         if (rval) {
                 dev_err(&client->dev, "update mode failed\n");
                 goto out_nvm_release;
diff --git a/drivers/media/i2c/smiapp/smiapp.h b/drivers/media/i2c/smiapp/smiapp.h
index 874b49ffd88f..f88f8ec344d3 100644
--- a/drivers/media/i2c/smiapp/smiapp.h
+++ b/drivers/media/i2c/smiapp/smiapp.h
@@ -156,6 +156,11 @@ struct smiapp_csi_data_format {
 #define SMIAPP_PAD_SRC                  1
 #define SMIAPP_PADS                     2
 
+#define SMIAPP_COMPRESSED_BASE          8
+#define SMIAPP_COMPRESSED_MAX           12
+#define SMIAPP_NR_OF_COMPRESSED         (SMIAPP_COMPRESSED_MAX - \
+                                         SMIAPP_COMPRESSED_BASE + 1)
+
 struct smiapp_binning_subtype {
         u8 horizontal:4;
         u8 vertical:4;
@@ -232,6 +237,9 @@ struct smiapp_sensor {
 
         struct smiapp_pll pll;
 
+        /* Is a default format supported for a given BPP? */
+        unsigned long valid_link_freqs[SMIAPP_NR_OF_COMPRESSED];
+
         /* Pixel array controls */
         struct v4l2_ctrl *analog_gain;
         struct v4l2_ctrl *exposure;
diff --git a/drivers/media/i2c/soc_camera/imx074.c b/drivers/media/i2c/soc_camera/imx074.c
index 5b915936c3f3..ec89cfa927a2 100644
--- a/drivers/media/i2c/soc_camera/imx074.c
+++ b/drivers/media/i2c/soc_camera/imx074.c
@@ -71,7 +71,7 @@
 
 /* IMX074 has only one fixed colorspace per pixelcode */
 struct imx074_datafmt {
-        enum v4l2_mbus_pixelcode        code;
+        u32     code;
         enum v4l2_colorspace            colorspace;
 };
 
@@ -82,7 +82,7 @@ struct imx074 {
 };
 
 static const struct imx074_datafmt imx074_colour_fmts[] = {
-        {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
 };
 
 static struct imx074 *to_imx074(const struct i2c_client *client)
@@ -91,7 +91,7 @@ static struct imx074 *to_imx074(const struct i2c_client *client)
 }
 
 /* Find a data format by a pixel code in an array */
-static const struct imx074_datafmt *imx074_find_datafmt(enum v4l2_mbus_pixelcode code)
+static const struct imx074_datafmt *imx074_find_datafmt(u32 code)
 {
         int i;
 
@@ -236,7 +236,7 @@ static int imx074_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
 }
 
 static int imx074_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if ((unsigned int)index >= ARRAY_SIZE(imx074_colour_fmts))
                 return -EINVAL;
diff --git a/drivers/media/i2c/soc_camera/mt9m001.c b/drivers/media/i2c/soc_camera/mt9m001.c
index dbd8c142d6ef..2e9a53502551 100644
--- a/drivers/media/i2c/soc_camera/mt9m001.c
+++ b/drivers/media/i2c/soc_camera/mt9m001.c
@@ -53,13 +53,13 @@
 
 /* MT9M001 has only one fixed colorspace per pixelcode */
 struct mt9m001_datafmt {
-        enum v4l2_mbus_pixelcode        code;
+        u32     code;
         enum v4l2_colorspace            colorspace;
 };
 
 /* Find a data format by a pixel code in an array */
 static const struct mt9m001_datafmt *mt9m001_find_datafmt(
-        enum v4l2_mbus_pixelcode code, const struct mt9m001_datafmt *fmt,
+        u32 code, const struct mt9m001_datafmt *fmt,
         int n)
 {
         int i;
@@ -75,14 +75,14 @@ static const struct mt9m001_datafmt mt9m001_colour_fmts[] = {
          * Order important: first natively supported,
          * second supported with a GPIO extender
          */
-        {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
 };
 
 static const struct mt9m001_datafmt mt9m001_monochrome_fmts[] = {
         /* Order important - see above */
-        {V4L2_MBUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
-        {V4L2_MBUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
 };
 
 struct mt9m001 {
@@ -563,7 +563,7 @@ static struct v4l2_subdev_core_ops mt9m001_subdev_core_ops = {
 };
 
 static int mt9m001_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                            enum v4l2_mbus_pixelcode *code)
+                            u32 *code)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct mt9m001 *mt9m001 = to_mt9m001(client);
diff --git a/drivers/media/i2c/soc_camera/mt9m111.c b/drivers/media/i2c/soc_camera/mt9m111.c
index b51e8562e775..5992ea93257a 100644
--- a/drivers/media/i2c/soc_camera/mt9m111.c
+++ b/drivers/media/i2c/soc_camera/mt9m111.c
@@ -182,23 +182,23 @@ static struct mt9m111_context context_b = {
 
 /* MT9M111 has only one fixed colorspace per pixelcode */
 struct mt9m111_datafmt {
-        enum v4l2_mbus_pixelcode        code;
+        u32     code;
         enum v4l2_colorspace            colorspace;
 };
 
 static const struct mt9m111_datafmt mt9m111_colour_fmts[] = {
-        {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
-        {V4L2_MBUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
-        {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},
-        {V4L2_MBUS_FMT_VYUY8_2X8, V4L2_COLORSPACE_JPEG},
-        {V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_BGR565_2X8_LE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_BGR565_2X8_BE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_VYUY8_2X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_BGR565_2X8_LE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_BGR565_2X8_BE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
 };
 
 struct mt9m111 {
@@ -218,7 +218,7 @@ struct mt9m111 {
 
 /* Find a data format by a pixel code */
 static const struct mt9m111_datafmt *mt9m111_find_datafmt(struct mt9m111 *mt9m111,
-                                                enum v4l2_mbus_pixelcode code)
+                                                u32 code)
 {
         int i;
         for (i = 0; i < ARRAY_SIZE(mt9m111_colour_fmts); i++)
@@ -331,7 +331,7 @@ static int mt9m111_setup_rect_ctx(struct mt9m111 *mt9m111,
 }
 
 static int mt9m111_setup_geometry(struct mt9m111 *mt9m111, struct v4l2_rect *rect,
-                        int width, int height, enum v4l2_mbus_pixelcode code)
+                        int width, int height, u32 code)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
         int ret;
@@ -345,7 +345,7 @@ static int mt9m111_setup_geometry(struct mt9m111 *mt9m111, struct v4l2_rect *rec
         if (!ret)
                 ret = reg_write(WINDOW_HEIGHT, rect->height);
 
-        if (code != V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
+        if (code != MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE) {
                 /* IFP in use, down-scaling possible */
                 if (!ret)
                         ret = mt9m111_setup_rect_ctx(mt9m111, &context_b,
@@ -393,8 +393,8 @@ static int mt9m111_s_crop(struct v4l2_subdev *sd, const struct v4l2_crop *a)
         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
-        if (mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
-            mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
+        if (mt9m111->fmt->code == MEDIA_BUS_FMT_SBGGR8_1X8 ||
+            mt9m111->fmt->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE) {
                 /* Bayer format - even size lengths */
                 rect.width      = ALIGN(rect.width, 2);
                 rect.height     = ALIGN(rect.height, 2);
@@ -462,7 +462,7 @@ static int mt9m111_g_fmt(struct v4l2_subdev *sd,
 }
 
 static int mt9m111_set_pixfmt(struct mt9m111 *mt9m111,
-                              enum v4l2_mbus_pixelcode code)
+                              u32 code)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
         u16 data_outfmt2, mask_outfmt2 = MT9M111_OUTFMT_PROCESSED_BAYER |
@@ -474,46 +474,46 @@ static int mt9m111_set_pixfmt(struct mt9m111 *mt9m111,
         int ret;
 
         switch (code) {
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
                 data_outfmt2 = MT9M111_OUTFMT_PROCESSED_BAYER |
                         MT9M111_OUTFMT_RGB;
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE:
                 data_outfmt2 = MT9M111_OUTFMT_BYPASS_IFP | MT9M111_OUTFMT_RGB;
                 break;
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
                 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555 |
                         MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
                 break;
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE:
                 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555;
                 break;
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
                         MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
                 break;
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
                 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565;
                 break;
-        case V4L2_MBUS_FMT_BGR565_2X8_BE:
+        case MEDIA_BUS_FMT_BGR565_2X8_BE:
                 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
                         MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
                 break;
-        case V4L2_MBUS_FMT_BGR565_2X8_LE:
+        case MEDIA_BUS_FMT_BGR565_2X8_LE:
                 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
                         MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
                         MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
                 break;
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 data_outfmt2 = 0;
                 break;
-        case V4L2_MBUS_FMT_VYUY8_2X8:
+        case MEDIA_BUS_FMT_VYUY8_2X8:
                 data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
                 break;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
                 break;
-        case V4L2_MBUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
                 data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
                         MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
                 break;
@@ -542,8 +542,8 @@ static int mt9m111_try_fmt(struct v4l2_subdev *sd,
 
         fmt = mt9m111_find_datafmt(mt9m111, mf->code);
 
-        bayer = fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
-                fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE;
+        bayer = fmt->code == MEDIA_BUS_FMT_SBGGR8_1X8 ||
+                fmt->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE;
 
         /*
          * With Bayer format enforce even side lengths, but let the user play
@@ -554,7 +554,7 @@ static int mt9m111_try_fmt(struct v4l2_subdev *sd,
                 rect->height = ALIGN(rect->height, 2);
         }
 
-        if (fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
+        if (fmt->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE) {
                 /* IFP bypass mode, no scaling */
                 mf->width = rect->width;
                 mf->height = rect->height;
@@ -840,7 +840,7 @@ static struct v4l2_subdev_core_ops mt9m111_subdev_core_ops = {
 };
 
 static int mt9m111_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                            enum v4l2_mbus_pixelcode *code)
+                            u32 *code)
 {
         if (index >= ARRAY_SIZE(mt9m111_colour_fmts))
                 return -EINVAL;
diff --git a/drivers/media/i2c/soc_camera/mt9t031.c b/drivers/media/i2c/soc_camera/mt9t031.c
index f8358c4071a9..35d9c8d25589 100644
--- a/drivers/media/i2c/soc_camera/mt9t031.c
+++ b/drivers/media/i2c/soc_camera/mt9t031.c
@@ -345,7 +345,7 @@ static int mt9t031_g_fmt(struct v4l2_subdev *sd,
 
         mf->width       = mt9t031->rect.width / mt9t031->xskip;
         mf->height      = mt9t031->rect.height / mt9t031->yskip;
-        mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
+        mf->code        = MEDIA_BUS_FMT_SBGGR10_1X10;
         mf->colorspace  = V4L2_COLORSPACE_SRGB;
         mf->field       = V4L2_FIELD_NONE;
 
@@ -367,7 +367,7 @@ static int mt9t031_s_fmt(struct v4l2_subdev *sd,
         xskip = mt9t031_skip(&rect.width, mf->width, MT9T031_MAX_WIDTH);
         yskip = mt9t031_skip(&rect.height, mf->height, MT9T031_MAX_HEIGHT);
 
-        mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
+        mf->code        = MEDIA_BUS_FMT_SBGGR10_1X10;
         mf->colorspace  = V4L2_COLORSPACE_SRGB;
 
         /* mt9t031_set_params() doesn't change width and height */
@@ -385,7 +385,7 @@ static int mt9t031_try_fmt(struct v4l2_subdev *sd,
                 &mf->width, MT9T031_MIN_WIDTH, MT9T031_MAX_WIDTH, 1,
                 &mf->height, MT9T031_MIN_HEIGHT, MT9T031_MAX_HEIGHT, 1, 0);
 
-        mf->code        = V4L2_MBUS_FMT_SBGGR10_1X10;
+        mf->code        = MEDIA_BUS_FMT_SBGGR10_1X10;
         mf->colorspace  = V4L2_COLORSPACE_SRGB;
 
         return 0;
@@ -673,12 +673,12 @@ static struct v4l2_subdev_core_ops mt9t031_subdev_core_ops = {
 };
 
 static int mt9t031_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                            enum v4l2_mbus_pixelcode *code)
+                            u32 *code)
 {
         if (index)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_SBGGR10_1X10;
+        *code = MEDIA_BUS_FMT_SBGGR10_1X10;
         return 0;
 }
 
diff --git a/drivers/media/i2c/soc_camera/mt9t112.c b/drivers/media/i2c/soc_camera/mt9t112.c
index 996d7b4007a5..64f08365e6b2 100644
--- a/drivers/media/i2c/soc_camera/mt9t112.c
+++ b/drivers/media/i2c/soc_camera/mt9t112.c
@@ -77,7 +77,7 @@
                         struct
 ************************************************************************/
 struct mt9t112_format {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         enum v4l2_colorspace colorspace;
         u16 fmt;
         u16 order;
@@ -103,32 +103,32 @@ struct mt9t112_priv {
 
 static const struct mt9t112_format mt9t112_cfmts[] = {
         {
-                .code           = V4L2_MBUS_FMT_UYVY8_2X8,
+                .code           = MEDIA_BUS_FMT_UYVY8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .fmt            = 1,
                 .order          = 0,
         }, {
-                .code           = V4L2_MBUS_FMT_VYUY8_2X8,
+                .code           = MEDIA_BUS_FMT_VYUY8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .fmt            = 1,
                 .order          = 1,
         }, {
-                .code           = V4L2_MBUS_FMT_YUYV8_2X8,
+                .code           = MEDIA_BUS_FMT_YUYV8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .fmt            = 1,
                 .order          = 2,
         }, {
-                .code           = V4L2_MBUS_FMT_YVYU8_2X8,
+                .code           = MEDIA_BUS_FMT_YVYU8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .fmt            = 1,
                 .order          = 3,
         }, {
-                .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
+                .code           = MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .fmt            = 8,
                 .order          = 2,
         }, {
-                .code           = V4L2_MBUS_FMT_RGB565_2X8_LE,
+                .code           = MEDIA_BUS_FMT_RGB565_2X8_LE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .fmt            = 4,
                 .order          = 2,
@@ -840,7 +840,7 @@ static int mt9t112_s_stream(struct v4l2_subdev *sd, int enable)
 
 static int mt9t112_set_params(struct mt9t112_priv *priv,
                               const struct v4l2_rect *rect,
-                              enum v4l2_mbus_pixelcode code)
+                              u32 code)
 {
         int i;
 
@@ -953,7 +953,7 @@ static int mt9t112_try_fmt(struct v4l2_subdev *sd,
                         break;
 
         if (i == priv->num_formats) {
-                mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+                mf->code = MEDIA_BUS_FMT_UYVY8_2X8;
                 mf->colorspace = V4L2_COLORSPACE_JPEG;
         } else {
                 mf->colorspace  = mt9t112_cfmts[i].colorspace;
@@ -967,7 +967,7 @@ static int mt9t112_try_fmt(struct v4l2_subdev *sd,
 }
 
 static int mt9t112_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct mt9t112_priv *priv = to_mt9t112(client);
@@ -1101,7 +1101,7 @@ static int mt9t112_probe(struct i2c_client *client,
 
         /* Cannot fail: using the default supported pixel code */
         if (!ret)
-                mt9t112_set_params(priv, &rect, V4L2_MBUS_FMT_UYVY8_2X8);
+                mt9t112_set_params(priv, &rect, MEDIA_BUS_FMT_UYVY8_2X8);
         else
                 v4l2_clk_put(priv->clk);
 
diff --git a/drivers/media/i2c/soc_camera/mt9v022.c b/drivers/media/i2c/soc_camera/mt9v022.c
index 99022c8d76eb..a246d4d64b8b 100644
--- a/drivers/media/i2c/soc_camera/mt9v022.c
+++ b/drivers/media/i2c/soc_camera/mt9v022.c
@@ -85,13 +85,13 @@ MODULE_PARM_DESC(sensor_type, "Sensor type: \"colour\" or \"monochrome\"");
 
 /* MT9V022 has only one fixed colorspace per pixelcode */
 struct mt9v022_datafmt {
-        enum v4l2_mbus_pixelcode        code;
+        u32     code;
         enum v4l2_colorspace            colorspace;
 };
 
 /* Find a data format by a pixel code in an array */
 static const struct mt9v022_datafmt *mt9v022_find_datafmt(
-        enum v4l2_mbus_pixelcode code, const struct mt9v022_datafmt *fmt,
+        u32 code, const struct mt9v022_datafmt *fmt,
         int n)
 {
         int i;
@@ -107,14 +107,14 @@ static const struct mt9v022_datafmt mt9v022_colour_fmts[] = {
          * Order important: first natively supported,
          * second supported with a GPIO extender
          */
-        {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
 };
 
 static const struct mt9v022_datafmt mt9v022_monochrome_fmts[] = {
         /* Order important - see above */
-        {V4L2_MBUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
-        {V4L2_MBUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
 };
 
 /* only registers with different addresses on different mt9v02x sensors */
@@ -410,13 +410,13 @@ static int mt9v022_s_fmt(struct v4l2_subdev *sd,
          * .try_mbus_fmt(), datawidth is from our supported format list
          */
         switch (mf->code) {
-        case V4L2_MBUS_FMT_Y8_1X8:
-        case V4L2_MBUS_FMT_Y10_1X10:
+        case MEDIA_BUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_Y10_1X10:
                 if (mt9v022->model != MT9V022IX7ATM)
                         return -EINVAL;
                 break;
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
-        case V4L2_MBUS_FMT_SBGGR10_1X10:
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_SBGGR10_1X10:
                 if (mt9v022->model != MT9V022IX7ATC)
                         return -EINVAL;
                 break;
@@ -443,8 +443,8 @@ static int mt9v022_try_fmt(struct v4l2_subdev *sd,
         struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct mt9v022 *mt9v022 = to_mt9v022(client);
         const struct mt9v022_datafmt *fmt;
-        int align = mf->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
-                mf->code == V4L2_MBUS_FMT_SBGGR10_1X10;
+        int align = mf->code == MEDIA_BUS_FMT_SBGGR8_1X8 ||
+                mf->code == MEDIA_BUS_FMT_SBGGR10_1X10;
 
         v4l_bound_align_image(&mf->width, MT9V022_MIN_WIDTH,
                 MT9V022_MAX_WIDTH, align,
@@ -759,7 +759,7 @@ static struct v4l2_subdev_core_ops mt9v022_subdev_core_ops = {
 };
 
 static int mt9v022_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                            enum v4l2_mbus_pixelcode *code)
+                            u32 *code)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct mt9v022 *mt9v022 = to_mt9v022(client);
diff --git a/drivers/media/i2c/soc_camera/ov2640.c b/drivers/media/i2c/soc_camera/ov2640.c
index 6c6b1c3b45e3..6f2dd9093d94 100644
--- a/drivers/media/i2c/soc_camera/ov2640.c
+++ b/drivers/media/i2c/soc_camera/ov2640.c
@@ -302,7 +302,7 @@ struct ov2640_win_size {
 struct ov2640_priv {
         struct v4l2_subdev              subdev;
         struct v4l2_ctrl_handler        hdl;
-        enum v4l2_mbus_pixelcode        cfmt_code;
+        u32     cfmt_code;
         struct v4l2_clk                 *clk;
         const struct ov2640_win_size    *win;
 };
@@ -623,11 +623,11 @@ static const struct regval_list ov2640_rgb565_le_regs[] = {
         ENDMARKER,
 };
 
-static enum v4l2_mbus_pixelcode ov2640_codes[] = {
-        V4L2_MBUS_FMT_YUYV8_2X8,
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_RGB565_2X8_BE,
-        V4L2_MBUS_FMT_RGB565_2X8_LE,
+static u32 ov2640_codes[] = {
+        MEDIA_BUS_FMT_YUYV8_2X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_RGB565_2X8_BE,
+        MEDIA_BUS_FMT_RGB565_2X8_LE,
 };
 
 /*
@@ -785,7 +785,7 @@ static const struct ov2640_win_size *ov2640_select_win(u32 *width, u32 *height)
 }
 
 static int ov2640_set_params(struct i2c_client *client, u32 *width, u32 *height,
-                             enum v4l2_mbus_pixelcode code)
+                             u32 code)
 {
         struct ov2640_priv       *priv = to_ov2640(client);
         const struct regval_list *selected_cfmt_regs;
@@ -797,20 +797,20 @@ static int ov2640_set_params(struct i2c_client *client, u32 *width, u32 *height,
         /* select format */
         priv->cfmt_code = 0;
         switch (code) {
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
                 dev_dbg(&client->dev, "%s: Selected cfmt RGB565 BE", __func__);
                 selected_cfmt_regs = ov2640_rgb565_be_regs;
                 break;
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 dev_dbg(&client->dev, "%s: Selected cfmt RGB565 LE", __func__);
                 selected_cfmt_regs = ov2640_rgb565_le_regs;
                 break;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 dev_dbg(&client->dev, "%s: Selected cfmt YUYV (YUV422)", __func__);
                 selected_cfmt_regs = ov2640_yuyv_regs;
                 break;
         default:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 dev_dbg(&client->dev, "%s: Selected cfmt UYVY", __func__);
                 selected_cfmt_regs = ov2640_uyvy_regs;
         }
@@ -869,7 +869,7 @@ static int ov2640_g_fmt(struct v4l2_subdev *sd,
         if (!priv->win) {
                 u32 width = W_SVGA, height = H_SVGA;
                 priv->win = ov2640_select_win(&width, &height);
-                priv->cfmt_code = V4L2_MBUS_FMT_UYVY8_2X8;
+                priv->cfmt_code = MEDIA_BUS_FMT_UYVY8_2X8;
         }
 
         mf->width       = priv->win->width;
@@ -877,13 +877,13 @@ static int ov2640_g_fmt(struct v4l2_subdev *sd,
         mf->code        = priv->cfmt_code;
 
         switch (mf->code) {
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 mf->colorspace = V4L2_COLORSPACE_SRGB;
                 break;
         default:
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 mf->colorspace = V4L2_COLORSPACE_JPEG;
         }
         mf->field       = V4L2_FIELD_NONE;
@@ -899,14 +899,14 @@ static int ov2640_s_fmt(struct v4l2_subdev *sd,
 
 
         switch (mf->code) {
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 mf->colorspace = V4L2_COLORSPACE_SRGB;
                 break;
         default:
-                mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+                mf->code = MEDIA_BUS_FMT_UYVY8_2X8;
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 mf->colorspace = V4L2_COLORSPACE_JPEG;
         }
 
@@ -926,14 +926,14 @@ static int ov2640_try_fmt(struct v4l2_subdev *sd,
         mf->field       = V4L2_FIELD_NONE;
 
         switch (mf->code) {
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 mf->colorspace = V4L2_COLORSPACE_SRGB;
                 break;
         default:
-                mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+                mf->code = MEDIA_BUS_FMT_UYVY8_2X8;
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 mf->colorspace = V4L2_COLORSPACE_JPEG;
         }
 
@@ -941,7 +941,7 @@ static int ov2640_try_fmt(struct v4l2_subdev *sd,
 }
 
 static int ov2640_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if (index >= ARRAY_SIZE(ov2640_codes))
                 return -EINVAL;
diff --git a/drivers/media/i2c/soc_camera/ov5642.c b/drivers/media/i2c/soc_camera/ov5642.c
index d2daa6a8f272..93ae031bdafb 100644
--- a/drivers/media/i2c/soc_camera/ov5642.c
+++ b/drivers/media/i2c/soc_camera/ov5642.c
@@ -602,7 +602,7 @@ static struct regval_list ov5642_default_regs_finalise[] = {
 };
 
 struct ov5642_datafmt {
-        enum v4l2_mbus_pixelcode        code;
+        u32     code;
         enum v4l2_colorspace            colorspace;
 };
 
@@ -618,7 +618,7 @@ struct ov5642 {
 };
 
 static const struct ov5642_datafmt ov5642_colour_fmts[] = {
-        {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},
 };
 
 static struct ov5642 *to_ov5642(const struct i2c_client *client)
@@ -628,7 +628,7 @@ static struct ov5642 *to_ov5642(const struct i2c_client *client)
 
 /* Find a data format by a pixel code in an array */
 static const struct ov5642_datafmt
-                        *ov5642_find_datafmt(enum v4l2_mbus_pixelcode code)
+                        *ov5642_find_datafmt(u32 code)
 {
         int i;
 
@@ -840,7 +840,7 @@ static int ov5642_g_fmt(struct v4l2_subdev *sd,
 }
 
 static int ov5642_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if (index >= ARRAY_SIZE(ov5642_colour_fmts))
                 return -EINVAL;
diff --git a/drivers/media/i2c/soc_camera/ov6650.c b/drivers/media/i2c/soc_camera/ov6650.c
index ab01598ec83f..f4eef2fa6f6f 100644
--- a/drivers/media/i2c/soc_camera/ov6650.c
+++ b/drivers/media/i2c/soc_camera/ov6650.c
@@ -202,18 +202,18 @@ struct ov6650 {
         unsigned long           pclk_limit;     /* from host */
         unsigned long           pclk_max;       /* from resolution and format */
         struct v4l2_fract       tpf;            /* as requested with s_parm */
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         enum v4l2_colorspace    colorspace;
 };
 
 
-static enum v4l2_mbus_pixelcode ov6650_codes[] = {
-        V4L2_MBUS_FMT_YUYV8_2X8,
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_YVYU8_2X8,
-        V4L2_MBUS_FMT_VYUY8_2X8,
-        V4L2_MBUS_FMT_SBGGR8_1X8,
-        V4L2_MBUS_FMT_Y8_1X8,
+static u32 ov6650_codes[] = {
+        MEDIA_BUS_FMT_YUYV8_2X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_YVYU8_2X8,
+        MEDIA_BUS_FMT_VYUY8_2X8,
+        MEDIA_BUS_FMT_SBGGR8_1X8,
+        MEDIA_BUS_FMT_Y8_1X8,
 };
 
 /* read a register */
@@ -555,29 +555,29 @@ static int ov6650_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
                         .height = mf->height << half_scale,
                 },
         };
-        enum v4l2_mbus_pixelcode code = mf->code;
+        u32 code = mf->code;
         unsigned long mclk, pclk;
         u8 coma_set = 0, coma_mask = 0, coml_set, coml_mask, clkrc;
         int ret;
 
         /* select color matrix configuration for given color encoding */
         switch (code) {
-        case V4L2_MBUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_Y8_1X8:
                 dev_dbg(&client->dev, "pixel format GREY8_1X8\n");
                 coma_mask |= COMA_RGB | COMA_WORD_SWAP | COMA_BYTE_SWAP;
                 coma_set |= COMA_BW;
                 break;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 dev_dbg(&client->dev, "pixel format YUYV8_2X8_LE\n");
                 coma_mask |= COMA_RGB | COMA_BW | COMA_BYTE_SWAP;
                 coma_set |= COMA_WORD_SWAP;
                 break;
-        case V4L2_MBUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
                 dev_dbg(&client->dev, "pixel format YVYU8_2X8_LE (untested)\n");
                 coma_mask |= COMA_RGB | COMA_BW | COMA_WORD_SWAP |
                                 COMA_BYTE_SWAP;
                 break;
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 dev_dbg(&client->dev, "pixel format YUYV8_2X8_BE\n");
                 if (half_scale) {
                         coma_mask |= COMA_RGB | COMA_BW | COMA_WORD_SWAP;
@@ -587,7 +587,7 @@ static int ov6650_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
                         coma_set |= COMA_BYTE_SWAP | COMA_WORD_SWAP;
                 }
                 break;
-        case V4L2_MBUS_FMT_VYUY8_2X8:
+        case MEDIA_BUS_FMT_VYUY8_2X8:
                 dev_dbg(&client->dev, "pixel format YVYU8_2X8_BE (untested)\n");
                 if (half_scale) {
                         coma_mask |= COMA_RGB | COMA_BW;
@@ -597,7 +597,7 @@ static int ov6650_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
                         coma_set |= COMA_BYTE_SWAP;
                 }
                 break;
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
                 dev_dbg(&client->dev, "pixel format SBGGR8_1X8 (untested)\n");
                 coma_mask |= COMA_BW | COMA_BYTE_SWAP | COMA_WORD_SWAP;
                 coma_set |= COMA_RAW_RGB | COMA_RGB;
@@ -608,8 +608,8 @@ static int ov6650_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
         }
         priv->code = code;
 
-        if (code == V4L2_MBUS_FMT_Y8_1X8 ||
-                        code == V4L2_MBUS_FMT_SBGGR8_1X8) {
+        if (code == MEDIA_BUS_FMT_Y8_1X8 ||
+                        code == MEDIA_BUS_FMT_SBGGR8_1X8) {
                 coml_mask = COML_ONE_CHANNEL;
                 coml_set = 0;
                 priv->pclk_max = 4000000;
@@ -619,7 +619,7 @@ static int ov6650_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
                 priv->pclk_max = 8000000;
         }
 
-        if (code == V4L2_MBUS_FMT_SBGGR8_1X8)
+        if (code == MEDIA_BUS_FMT_SBGGR8_1X8)
                 priv->colorspace = V4L2_COLORSPACE_SRGB;
         else if (code != 0)
                 priv->colorspace = V4L2_COLORSPACE_JPEG;
@@ -697,18 +697,18 @@ static int ov6650_try_fmt(struct v4l2_subdev *sd,
         mf->field = V4L2_FIELD_NONE;
 
         switch (mf->code) {
-        case V4L2_MBUS_FMT_Y10_1X10:
-                mf->code = V4L2_MBUS_FMT_Y8_1X8;
-        case V4L2_MBUS_FMT_Y8_1X8:
-        case V4L2_MBUS_FMT_YVYU8_2X8:
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_VYUY8_2X8:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_Y10_1X10:
+                mf->code = MEDIA_BUS_FMT_Y8_1X8;
+        case MEDIA_BUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_VYUY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 mf->colorspace = V4L2_COLORSPACE_JPEG;
                 break;
         default:
-                mf->code = V4L2_MBUS_FMT_SBGGR8_1X8;
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
+                mf->code = MEDIA_BUS_FMT_SBGGR8_1X8;
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
                 mf->colorspace = V4L2_COLORSPACE_SRGB;
                 break;
         }
@@ -717,7 +717,7 @@ static int ov6650_try_fmt(struct v4l2_subdev *sd,
 }
 
 static int ov6650_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if (index >= ARRAY_SIZE(ov6650_codes))
                 return -EINVAL;
@@ -1013,7 +1013,7 @@ static int ov6650_probe(struct i2c_client *client,
         priv->rect.width  = W_CIF;
         priv->rect.height = H_CIF;
         priv->half_scale  = false;
-        priv->code        = V4L2_MBUS_FMT_YUYV8_2X8;
+        priv->code        = MEDIA_BUS_FMT_YUYV8_2X8;
         priv->colorspace  = V4L2_COLORSPACE_JPEG;
 
         priv->clk = v4l2_clk_get(&client->dev, "mclk");
diff --git a/drivers/media/i2c/soc_camera/ov772x.c b/drivers/media/i2c/soc_camera/ov772x.c
index 970a04e1e56e..8daac88b33fe 100644
--- a/drivers/media/i2c/soc_camera/ov772x.c
+++ b/drivers/media/i2c/soc_camera/ov772x.c
@@ -376,7 +376,7 @@
  */
 
 struct ov772x_color_format {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         enum v4l2_colorspace colorspace;
         u8 dsp3;
         u8 dsp4;
@@ -408,7 +408,7 @@ struct ov772x_priv {
  */
 static const struct ov772x_color_format ov772x_cfmts[] = {
         {
-                .code           = V4L2_MBUS_FMT_YUYV8_2X8,
+                .code           = MEDIA_BUS_FMT_YUYV8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .dsp3           = 0x0,
                 .dsp4           = DSP_OFMT_YUV,
@@ -416,7 +416,7 @@ static const struct ov772x_color_format ov772x_cfmts[] = {
                 .com7           = OFMT_YUV,
         },
         {
-                .code           = V4L2_MBUS_FMT_YVYU8_2X8,
+                .code           = MEDIA_BUS_FMT_YVYU8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .dsp3           = UV_ON,
                 .dsp4           = DSP_OFMT_YUV,
@@ -424,7 +424,7 @@ static const struct ov772x_color_format ov772x_cfmts[] = {
                 .com7           = OFMT_YUV,
         },
         {
-                .code           = V4L2_MBUS_FMT_UYVY8_2X8,
+                .code           = MEDIA_BUS_FMT_UYVY8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .dsp3           = 0x0,
                 .dsp4           = DSP_OFMT_YUV,
@@ -432,7 +432,7 @@ static const struct ov772x_color_format ov772x_cfmts[] = {
                 .com7           = OFMT_YUV,
         },
         {
-                .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
+                .code           = MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .dsp3           = 0x0,
                 .dsp4           = DSP_OFMT_YUV,
@@ -440,7 +440,7 @@ static const struct ov772x_color_format ov772x_cfmts[] = {
                 .com7           = FMT_RGB555 | OFMT_RGB,
         },
         {
-                .code           = V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE,
+                .code           = MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .dsp3           = 0x0,
                 .dsp4           = DSP_OFMT_YUV,
@@ -448,7 +448,7 @@ static const struct ov772x_color_format ov772x_cfmts[] = {
                 .com7           = FMT_RGB555 | OFMT_RGB,
         },
         {
-                .code           = V4L2_MBUS_FMT_RGB565_2X8_LE,
+                .code           = MEDIA_BUS_FMT_RGB565_2X8_LE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .dsp3           = 0x0,
                 .dsp4           = DSP_OFMT_YUV,
@@ -456,7 +456,7 @@ static const struct ov772x_color_format ov772x_cfmts[] = {
                 .com7           = FMT_RGB565 | OFMT_RGB,
         },
         {
-                .code           = V4L2_MBUS_FMT_RGB565_2X8_BE,
+                .code           = MEDIA_BUS_FMT_RGB565_2X8_BE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .dsp3           = 0x0,
                 .dsp4           = DSP_OFMT_YUV,
@@ -468,7 +468,7 @@ static const struct ov772x_color_format ov772x_cfmts[] = {
                  * regardless of the COM7 value. We can thus only support 10-bit
                  * Bayer until someone figures it out.
                  */
-                .code           = V4L2_MBUS_FMT_SBGGR10_1X10,
+                .code           = MEDIA_BUS_FMT_SBGGR10_1X10,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
                 .dsp3           = 0x0,
                 .dsp4           = DSP_OFMT_RAW10,
@@ -990,7 +990,7 @@ static struct v4l2_subdev_core_ops ov772x_subdev_core_ops = {
 };
 
 static int ov772x_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if (index >= ARRAY_SIZE(ov772x_cfmts))
                 return -EINVAL;
diff --git a/drivers/media/i2c/soc_camera/ov9640.c b/drivers/media/i2c/soc_camera/ov9640.c
index bc74224503e7..aa93d2e88572 100644
--- a/drivers/media/i2c/soc_camera/ov9640.c
+++ b/drivers/media/i2c/soc_camera/ov9640.c
@@ -159,10 +159,10 @@ static const struct ov9640_reg ov9640_regs_rgb[] = {
         { OV9640_MTXS,  0x65 },
 };
 
-static enum v4l2_mbus_pixelcode ov9640_codes[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
-        V4L2_MBUS_FMT_RGB565_2X8_LE,
+static u32 ov9640_codes[] = {
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE,
+        MEDIA_BUS_FMT_RGB565_2X8_LE,
 };
 
 /* read a register */
@@ -351,22 +351,22 @@ static void ov9640_res_roundup(u32 *width, u32 *height)
 }
 
 /* Prepare necessary register changes depending on color encoding */
-static void ov9640_alter_regs(enum v4l2_mbus_pixelcode code,
+static void ov9640_alter_regs(u32 code,
                               struct ov9640_reg_alt *alt)
 {
         switch (code) {
         default:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 alt->com12      = OV9640_COM12_YUV_AVG;
                 alt->com13      = OV9640_COM13_Y_DELAY_EN |
                                         OV9640_COM13_YUV_DLY(0x01);
                 break;
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
                 alt->com7       = OV9640_COM7_RGB;
                 alt->com13      = OV9640_COM13_RGB_AVG;
                 alt->com15      = OV9640_COM15_RGB_555;
                 break;
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 alt->com7       = OV9640_COM7_RGB;
                 alt->com13      = OV9640_COM13_RGB_AVG;
                 alt->com15      = OV9640_COM15_RGB_565;
@@ -376,7 +376,7 @@ static void ov9640_alter_regs(enum v4l2_mbus_pixelcode code,
 
 /* Setup registers according to resolution and color encoding */
 static int ov9640_write_regs(struct i2c_client *client, u32 width,
-                enum v4l2_mbus_pixelcode code, struct ov9640_reg_alt *alts)
+                u32 code, struct ov9640_reg_alt *alts)
 {
         const struct ov9640_reg *ov9640_regs, *matrix_regs;
         int                     ov9640_regs_len, matrix_regs_len;
@@ -419,7 +419,7 @@ static int ov9640_write_regs(struct i2c_client *client, u32 width,
         }
 
         /* select color matrix configuration for given color encoding */
-        if (code == V4L2_MBUS_FMT_UYVY8_2X8) {
+        if (code == MEDIA_BUS_FMT_UYVY8_2X8) {
                 matrix_regs     = ov9640_regs_yuv;
                 matrix_regs_len = ARRAY_SIZE(ov9640_regs_yuv);
         } else {
@@ -487,7 +487,7 @@ static int ov9640_s_fmt(struct v4l2_subdev *sd,
         struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct ov9640_reg_alt alts = {0};
         enum v4l2_colorspace cspace;
-        enum v4l2_mbus_pixelcode code = mf->code;
+        u32 code = mf->code;
         int ret;
 
         ov9640_res_roundup(&mf->width, &mf->height);
@@ -500,13 +500,13 @@ static int ov9640_s_fmt(struct v4l2_subdev *sd,
                 return ret;
 
         switch (code) {
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 cspace = V4L2_COLORSPACE_SRGB;
                 break;
         default:
-                code = V4L2_MBUS_FMT_UYVY8_2X8;
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+                code = MEDIA_BUS_FMT_UYVY8_2X8;
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 cspace = V4L2_COLORSPACE_JPEG;
         }
 
@@ -527,13 +527,13 @@ static int ov9640_try_fmt(struct v4l2_subdev *sd,
         mf->field = V4L2_FIELD_NONE;
 
         switch (mf->code) {
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 mf->colorspace = V4L2_COLORSPACE_SRGB;
                 break;
         default:
-                mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+                mf->code = MEDIA_BUS_FMT_UYVY8_2X8;
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 mf->colorspace = V4L2_COLORSPACE_JPEG;
         }
 
@@ -541,7 +541,7 @@ static int ov9640_try_fmt(struct v4l2_subdev *sd,
 }
 
 static int ov9640_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if (index >= ARRAY_SIZE(ov9640_codes))
                 return -EINVAL;
diff --git a/drivers/media/i2c/soc_camera/ov9740.c b/drivers/media/i2c/soc_camera/ov9740.c
index ee9eb635d540..841dc55457cf 100644
--- a/drivers/media/i2c/soc_camera/ov9740.c
+++ b/drivers/media/i2c/soc_camera/ov9740.c
@@ -392,8 +392,8 @@ static const struct ov9740_reg ov9740_defaults[] = {
         { OV9740_ISP_CTRL19,            0x02 },
 };
 
-static enum v4l2_mbus_pixelcode ov9740_codes[] = {
-        V4L2_MBUS_FMT_YUYV8_2X8,
+static u32 ov9740_codes[] = {
+        MEDIA_BUS_FMT_YUYV8_2X8,
 };
 
 /* read a register */
@@ -674,13 +674,13 @@ static int ov9740_s_fmt(struct v4l2_subdev *sd,
         struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct ov9740_priv *priv = to_ov9740(sd);
         enum v4l2_colorspace cspace;
-        enum v4l2_mbus_pixelcode code = mf->code;
+        u32 code = mf->code;
         int ret;
 
         ov9740_res_roundup(&mf->width, &mf->height);
 
         switch (code) {
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 cspace = V4L2_COLORSPACE_SRGB;
                 break;
         default:
@@ -710,14 +710,14 @@ static int ov9740_try_fmt(struct v4l2_subdev *sd,
         ov9740_res_roundup(&mf->width, &mf->height);
 
         mf->field = V4L2_FIELD_NONE;
-        mf->code = V4L2_MBUS_FMT_YUYV8_2X8;
+        mf->code = MEDIA_BUS_FMT_YUYV8_2X8;
         mf->colorspace = V4L2_COLORSPACE_SRGB;
 
         return 0;
 }
 
 static int ov9740_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if (index >= ARRAY_SIZE(ov9740_codes))
                 return -EINVAL;
diff --git a/drivers/media/i2c/soc_camera/rj54n1cb0c.c b/drivers/media/i2c/soc_camera/rj54n1cb0c.c
index 7e6d97847874..1752428c43c5 100644
--- a/drivers/media/i2c/soc_camera/rj54n1cb0c.c
+++ b/drivers/media/i2c/soc_camera/rj54n1cb0c.c
@@ -111,13 +111,13 @@
 
 /* RJ54N1CB0C has only one fixed colorspace per pixelcode */
 struct rj54n1_datafmt {
-        enum v4l2_mbus_pixelcode        code;
+        u32     code;
         enum v4l2_colorspace            colorspace;
 };
 
 /* Find a data format by a pixel code in an array */
 static const struct rj54n1_datafmt *rj54n1_find_datafmt(
-        enum v4l2_mbus_pixelcode code, const struct rj54n1_datafmt *fmt,
+        u32 code, const struct rj54n1_datafmt *fmt,
         int n)
 {
         int i;
@@ -129,15 +129,15 @@ static const struct rj54n1_datafmt *rj54n1_find_datafmt(
 }
 
 static const struct rj54n1_datafmt rj54n1_colour_fmts[] = {
-        {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
-        {V4L2_MBUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
-        {V4L2_MBUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE, V4L2_COLORSPACE_SRGB},
-        {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
+        {MEDIA_BUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE, V4L2_COLORSPACE_SRGB},
+        {MEDIA_BUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
 };
 
 struct rj54n1_clock_div {
@@ -486,7 +486,7 @@ static int reg_write_multiple(struct i2c_client *client,
 }
 
 static int rj54n1_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if (index >= ARRAY_SIZE(rj54n1_colour_fmts))
                 return -EINVAL;
@@ -965,11 +965,11 @@ static int rj54n1_try_fmt(struct v4l2_subdev *sd,
         struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct rj54n1 *rj54n1 = to_rj54n1(client);
         const struct rj54n1_datafmt *fmt;
-        int align = mf->code == V4L2_MBUS_FMT_SBGGR10_1X10 ||
-                mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE ||
-                mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE ||
-                mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE ||
-                mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE;
+        int align = mf->code == MEDIA_BUS_FMT_SBGGR10_1X10 ||
+                mf->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE ||
+                mf->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE ||
+                mf->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE ||
+                mf->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE;
 
         dev_dbg(&client->dev, "%s: code = %d, width = %u, height = %u\n",
                 __func__, mf->code, mf->width, mf->height);
@@ -1025,55 +1025,55 @@ static int rj54n1_s_fmt(struct v4l2_subdev *sd,
 
         /* RA_SEL_UL is only relevant for raw modes, ignored otherwise. */
         switch (mf->code) {
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 0);
                 if (!ret)
                         ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
                 break;
-        case V4L2_MBUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 0);
                 if (!ret)
                         ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
                 break;
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 0x11);
                 if (!ret)
                         ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
                 break;
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 0x11);
                 if (!ret)
                         ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 4);
                 if (!ret)
                         ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
                 if (!ret)
                         ret = reg_write(client, RJ54N1_RA_SEL_UL, 0);
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 4);
                 if (!ret)
                         ret = reg_set(client, RJ54N1_BYTE_SWAP, 8, 8);
                 if (!ret)
                         ret = reg_write(client, RJ54N1_RA_SEL_UL, 8);
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 4);
                 if (!ret)
                         ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
                 if (!ret)
                         ret = reg_write(client, RJ54N1_RA_SEL_UL, 0);
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE:
+        case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 4);
                 if (!ret)
                         ret = reg_set(client, RJ54N1_BYTE_SWAP, 0, 8);
                 if (!ret)
                         ret = reg_write(client, RJ54N1_RA_SEL_UL, 8);
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_1X10:
+        case MEDIA_BUS_FMT_SBGGR10_1X10:
                 ret = reg_write(client, RJ54N1_OUT_SEL, 5);
                 break;
         default:
@@ -1083,7 +1083,7 @@ static int rj54n1_s_fmt(struct v4l2_subdev *sd,
         /* Special case: a raw mode with 10 bits of data per clock tick */
         if (!ret)
                 ret = reg_set(client, RJ54N1_OCLK_SEL_EN,
-                              (mf->code == V4L2_MBUS_FMT_SBGGR10_1X10) << 1, 2);
+                              (mf->code == MEDIA_BUS_FMT_SBGGR10_1X10) << 1, 2);
 
         if (ret < 0)
                 return ret;
diff --git a/drivers/media/i2c/soc_camera/tw9910.c b/drivers/media/i2c/soc_camera/tw9910.c
index 416402eb4f82..9b853215d146 100644
--- a/drivers/media/i2c/soc_camera/tw9910.c
+++ b/drivers/media/i2c/soc_camera/tw9910.c
@@ -705,7 +705,7 @@ static int tw9910_g_fmt(struct v4l2_subdev *sd,
 
         mf->width       = priv->scale->width;
         mf->height      = priv->scale->height;
-        mf->code        = V4L2_MBUS_FMT_UYVY8_2X8;
+        mf->code        = MEDIA_BUS_FMT_UYVY8_2X8;
         mf->colorspace  = V4L2_COLORSPACE_JPEG;
         mf->field       = V4L2_FIELD_INTERLACED_BT;
 
@@ -724,7 +724,7 @@ static int tw9910_s_fmt(struct v4l2_subdev *sd,
         /*
          * check color format
          */
-        if (mf->code != V4L2_MBUS_FMT_UYVY8_2X8)
+        if (mf->code != MEDIA_BUS_FMT_UYVY8_2X8)
                 return -EINVAL;
 
         mf->colorspace = V4L2_COLORSPACE_JPEG;
@@ -751,7 +751,7 @@ static int tw9910_try_fmt(struct v4l2_subdev *sd,
                 return -EINVAL;
         }
 
-        mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+        mf->code = MEDIA_BUS_FMT_UYVY8_2X8;
         mf->colorspace = V4L2_COLORSPACE_JPEG;
 
         /*
@@ -822,12 +822,12 @@ static struct v4l2_subdev_core_ops tw9910_subdev_core_ops = {
 };
 
 static int tw9910_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                           enum v4l2_mbus_pixelcode *code)
+                           u32 *code)
 {
         if (index)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_UYVY8_2X8;
+        *code = MEDIA_BUS_FMT_UYVY8_2X8;
         return 0;
 }
 
diff --git a/drivers/media/i2c/sr030pc30.c b/drivers/media/i2c/sr030pc30.c
index 118f8ee88465..10c735c3a082 100644
--- a/drivers/media/i2c/sr030pc30.c
+++ b/drivers/media/i2c/sr030pc30.c
@@ -165,7 +165,7 @@ struct sr030pc30_info {
 };
 
 struct sr030pc30_format {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         enum v4l2_colorspace colorspace;
         u16 ispctl1_reg;
 };
@@ -201,23 +201,23 @@ static const struct sr030pc30_frmsize sr030pc30_sizes[] = {
 /* supported pixel formats */
 static const struct sr030pc30_format sr030pc30_formats[] = {
         {
-                .code           = V4L2_MBUS_FMT_YUYV8_2X8,
+                .code           = MEDIA_BUS_FMT_YUYV8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0x03,
         }, {
-                .code           = V4L2_MBUS_FMT_YVYU8_2X8,
+                .code           = MEDIA_BUS_FMT_YVYU8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0x02,
         }, {
-                .code           = V4L2_MBUS_FMT_VYUY8_2X8,
+                .code           = MEDIA_BUS_FMT_VYUY8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0,
         }, {
-                .code           = V4L2_MBUS_FMT_UYVY8_2X8,
+                .code           = MEDIA_BUS_FMT_UYVY8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0x01,
         }, {
-                .code           = V4L2_MBUS_FMT_RGB565_2X8_BE,
+                .code           = MEDIA_BUS_FMT_RGB565_2X8_BE,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
                 .ispctl1_reg    = 0x40,
         },
@@ -472,7 +472,7 @@ static int sr030pc30_s_ctrl(struct v4l2_ctrl *ctrl)
 }
 
 static int sr030pc30_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                              enum v4l2_mbus_pixelcode *code)
+                              u32 *code)
 {
         if (!code || index >= ARRAY_SIZE(sr030pc30_formats))
                 return -EINVAL;
diff --git a/drivers/media/i2c/tvp514x.c b/drivers/media/i2c/tvp514x.c
index b9dabc9f4050..204204259ac6 100644
--- a/drivers/media/i2c/tvp514x.c
+++ b/drivers/media/i2c/tvp514x.c
@@ -756,12 +756,12 @@ static int tvp514x_s_ctrl(struct v4l2_ctrl *ctrl)
  */
 static int
 tvp514x_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
-                                        enum v4l2_mbus_pixelcode *code)
+                                        u32 *code)
 {
         if (index)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_YUYV10_2X10;
+        *code = MEDIA_BUS_FMT_YUYV10_2X10;
         return 0;
 }
 
@@ -784,7 +784,7 @@ tvp514x_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *f)
         /* Calculate height and width based on current standard */
         current_std = decoder->current_std;
 
-        f->code = V4L2_MBUS_FMT_YUYV8_2X8;
+        f->code = MEDIA_BUS_FMT_YUYV8_2X8;
         f->width = decoder->std_list[current_std].width;
         f->height = decoder->std_list[current_std].height;
         f->field = V4L2_FIELD_INTERLACED;
@@ -942,7 +942,7 @@ static int tvp514x_enum_mbus_code(struct v4l2_subdev *sd,
         if (index != 0)
                 return -EINVAL;
 
-        code->code = V4L2_MBUS_FMT_YUYV8_2X8;
+        code->code = MEDIA_BUS_FMT_YUYV8_2X8;
 
         return 0;
 }
@@ -967,7 +967,7 @@ static int tvp514x_get_pad_format(struct v4l2_subdev *sd,
                 return 0;
         }
 
-        format->format.code = V4L2_MBUS_FMT_YUYV8_2X8;
+        format->format.code = MEDIA_BUS_FMT_YUYV8_2X8;
         format->format.width = tvp514x_std_list[decoder->current_std].width;
         format->format.height = tvp514x_std_list[decoder->current_std].height;
         format->format.colorspace = V4L2_COLORSPACE_SMPTE170M;
@@ -991,7 +991,7 @@ static int tvp514x_set_pad_format(struct v4l2_subdev *sd,
         struct tvp514x_decoder *decoder = to_decoder(sd);
 
         if (fmt->format.field != V4L2_FIELD_INTERLACED ||
-            fmt->format.code != V4L2_MBUS_FMT_YUYV8_2X8 ||
+            fmt->format.code != MEDIA_BUS_FMT_YUYV8_2X8 ||
             fmt->format.colorspace != V4L2_COLORSPACE_SMPTE170M ||
             fmt->format.width != tvp514x_std_list[decoder->current_std].width ||
             fmt->format.height != tvp514x_std_list[decoder->current_std].height)
diff --git a/drivers/media/i2c/tvp5150.c b/drivers/media/i2c/tvp5150.c
index 193e7d6c29c8..68cdab9c0903 100644
--- a/drivers/media/i2c/tvp5150.c
+++ b/drivers/media/i2c/tvp5150.c
@@ -818,12 +818,12 @@ static v4l2_std_id tvp5150_read_std(struct v4l2_subdev *sd)
 }
 
 static int tvp5150_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
-                                                enum v4l2_mbus_pixelcode *code)
+                                                u32 *code)
 {
         if (index)
                 return -EINVAL;
 
-        *code = V4L2_MBUS_FMT_UYVY8_2X8;
+        *code = MEDIA_BUS_FMT_UYVY8_2X8;
         return 0;
 }
 
@@ -840,7 +840,7 @@ static int tvp5150_mbus_fmt(struct v4l2_subdev *sd,
         f->width = decoder->rect.width;
         f->height = decoder->rect.height;
 
-        f->code = V4L2_MBUS_FMT_UYVY8_2X8;
+        f->code = MEDIA_BUS_FMT_UYVY8_2X8;
         f->field = V4L2_FIELD_SEQ_TB;
         f->colorspace = V4L2_COLORSPACE_SMPTE170M;
 
diff --git a/drivers/media/i2c/tvp7002.c b/drivers/media/i2c/tvp7002.c
index 51bac762638b..fe4870e22cfe 100644
--- a/drivers/media/i2c/tvp7002.c
+++ b/drivers/media/i2c/tvp7002.c
@@ -626,7 +626,7 @@ static int tvp7002_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *f
 
         f->width = bt->width;
         f->height = bt->height;
-        f->code = V4L2_MBUS_FMT_YUYV10_1X20;
+        f->code = MEDIA_BUS_FMT_YUYV10_1X20;
         f->field = device->current_timings->scanmode;
         f->colorspace = device->current_timings->color_space;
 
@@ -756,12 +756,12 @@ static int tvp7002_s_register(struct v4l2_subdev *sd,
  */
 
 static int tvp7002_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
-                                        enum v4l2_mbus_pixelcode *code)
+                                        u32 *code)
 {
         /* Check requested format index is within range */
         if (index)
                 return -EINVAL;
-        *code = V4L2_MBUS_FMT_YUYV10_1X20;
+        *code = MEDIA_BUS_FMT_YUYV10_1X20;
         return 0;
 }
 
@@ -859,7 +859,7 @@ tvp7002_enum_mbus_code(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
         if (code->index != 0)
                 return -EINVAL;
 
-        code->code = V4L2_MBUS_FMT_YUYV10_1X20;
+        code->code = MEDIA_BUS_FMT_YUYV10_1X20;
 
         return 0;
 }
@@ -878,7 +878,7 @@ tvp7002_get_pad_format(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
 {
         struct tvp7002 *tvp7002 = to_tvp7002(sd);
 
-        fmt->format.code = V4L2_MBUS_FMT_YUYV10_1X20;
+        fmt->format.code = MEDIA_BUS_FMT_YUYV10_1X20;
         fmt->format.width = tvp7002->current_timings->timings.bt.width;
         fmt->format.height = tvp7002->current_timings->timings.bt.height;
         fmt->format.field = tvp7002->current_timings->scanmode;
diff --git a/drivers/media/i2c/vs6624.c b/drivers/media/i2c/vs6624.c
index 373f2df52492..00e7f043977e 100644
--- a/drivers/media/i2c/vs6624.c
+++ b/drivers/media/i2c/vs6624.c
@@ -45,19 +45,19 @@ struct vs6624 {
 };
 
 static const struct vs6624_format {
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
         enum v4l2_colorspace colorspace;
 } vs6624_formats[] = {
         {
-                .mbus_code      = V4L2_MBUS_FMT_UYVY8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_UYVY8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
         },
         {
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .colorspace     = V4L2_COLORSPACE_JPEG,
         },
         {
-                .mbus_code      = V4L2_MBUS_FMT_RGB565_2X8_LE,
+                .mbus_code      = MEDIA_BUS_FMT_RGB565_2X8_LE,
                 .colorspace     = V4L2_COLORSPACE_SRGB,
         },
 };
@@ -65,7 +65,7 @@ static const struct vs6624_format {
 static struct v4l2_mbus_framefmt vs6624_default_fmt = {
         .width = VGA_WIDTH,
         .height = VGA_HEIGHT,
-        .code = V4L2_MBUS_FMT_UYVY8_2X8,
+        .code = MEDIA_BUS_FMT_UYVY8_2X8,
         .field = V4L2_FIELD_NONE,
         .colorspace = V4L2_COLORSPACE_JPEG,
 };
@@ -558,7 +558,7 @@ static int vs6624_s_ctrl(struct v4l2_ctrl *ctrl)
 }
 
 static int vs6624_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
-                                enum v4l2_mbus_pixelcode *code)
+                                u32 *code)
 {
         if (index >= ARRAY_SIZE(vs6624_formats))
                 return -EINVAL;
@@ -605,15 +605,15 @@ static int vs6624_s_mbus_fmt(struct v4l2_subdev *sd,
 
         /* set image format */
         switch (fmt->code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 vs6624_write(sd, VS6624_IMG_FMT0, 0x0);
                 vs6624_write(sd, VS6624_YUV_SETUP, 0x1);
                 break;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 vs6624_write(sd, VS6624_IMG_FMT0, 0x0);
                 vs6624_write(sd, VS6624_YUV_SETUP, 0x3);
                 break;
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 vs6624_write(sd, VS6624_IMG_FMT0, 0x4);
                 vs6624_write(sd, VS6624_RGB_SETUP, 0x0);
                 break;
diff --git a/drivers/media/media-entity.c b/drivers/media/media-entity.c
index 37c334edc7e8..4d8e01c7b1b2 100644
--- a/drivers/media/media-entity.c
+++ b/drivers/media/media-entity.c
@@ -279,8 +279,14 @@ __must_check int media_entity_pipeline_start(struct media_entity *entity,
                                 continue;
 
                         ret = entity->ops->link_validate(link);
-                        if (ret < 0 && ret != -ENOIOCTLCMD)
+                        if (ret < 0 && ret != -ENOIOCTLCMD) {
+                                dev_dbg(entity->parent->dev,
+                                        "link validation failed for \"%s\":%u -> \"%s\":%u, error %d\n",
+                                        entity->name, link->source->index,
+                                        link->sink->entity->name,
+                                        link->sink->index, ret);
                                 goto error;
+                        }
                 }
 
                 /* Either no links or validated links are fine. */
@@ -288,6 +294,11 @@ __must_check int media_entity_pipeline_start(struct media_entity *entity,
 
                 if (!bitmap_full(active, entity->num_pads)) {
                         ret = -EPIPE;
+                        dev_dbg(entity->parent->dev,
+                                "\"%s\":%u must be connected by an enabled link\n",
+                                entity->name,
+                                (unsigned)find_first_zero_bit(
+                                        active, entity->num_pads));
                         goto error;
                 }
         }
diff --git a/drivers/media/pci/Kconfig b/drivers/media/pci/Kconfig
index f8cec8e8cf82..218144a99016 100644
--- a/drivers/media/pci/Kconfig
+++ b/drivers/media/pci/Kconfig
@@ -46,6 +46,7 @@ source "drivers/media/pci/pt3/Kconfig"
 source "drivers/media/pci/mantis/Kconfig"
 source "drivers/media/pci/ngene/Kconfig"
 source "drivers/media/pci/ddbridge/Kconfig"
+source "drivers/media/pci/smipcie/Kconfig"
 endif
 
 endif #MEDIA_PCI_SUPPORT
diff --git a/drivers/media/pci/Makefile b/drivers/media/pci/Makefile
index a12926e4b51f..0baf0d2967ee 100644
--- a/drivers/media/pci/Makefile
+++ b/drivers/media/pci/Makefile
@@ -11,7 +11,8 @@ obj-y        +=	ttpci/		\
                 mantis/         \
                 ngene/          \
                 ddbridge/       \
-                saa7146/
+                saa7146/        \
+                smipcie/
 
 obj-$(CONFIG_VIDEO_IVTV) += ivtv/
 obj-$(CONFIG_VIDEO_ZORAN) += zoran/
diff --git a/drivers/media/pci/bt8xx/bttv-cards.c b/drivers/media/pci/bt8xx/bttv-cards.c
index d8ec583c154c..41055606b969 100644
--- a/drivers/media/pci/bt8xx/bttv-cards.c
+++ b/drivers/media/pci/bt8xx/bttv-cards.c
@@ -3870,10 +3870,10 @@ static void osprey_eeprom(struct bttv *btv, const u8 ee[256])
         } else {
                 unsigned short type;
 
-                for (i = 4*16; i < 8*16; i += 16) {
-                        u16 checksum = ip_compute_csum(ee + i, 16);
+                for (i = 4 * 16; i < 8 * 16; i += 16) {
+                        u16 checksum = (__force u16)ip_compute_csum(ee + i, 16);
 
-                        if ((checksum&0xff) + (checksum>>8) == 0xff)
+                        if ((checksum & 0xff) + (checksum >> 8) == 0xff)
                                 break;
                 }
                 if (i >= 8*16)
diff --git a/drivers/media/pci/bt8xx/bttv-risc.c b/drivers/media/pci/bt8xx/bttv-risc.c
index 82cc47d2e3fa..4d3f05a19af3 100644
--- a/drivers/media/pci/bt8xx/bttv-risc.c
+++ b/drivers/media/pci/bt8xx/bttv-risc.c
@@ -84,7 +84,7 @@ bttv_risc_packed(struct bttv *btv, struct btcx_riscmem *risc,
                         continue;
                 while (offset && offset >= sg_dma_len(sg)) {
                         offset -= sg_dma_len(sg);
-                        sg++;
+                        sg = sg_next(sg);
                 }
                 if (bpl <= sg_dma_len(sg)-offset) {
                         /* fits into current chunk */
@@ -100,13 +100,13 @@ bttv_risc_packed(struct bttv *btv, struct btcx_riscmem *risc,
                         *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
                         todo -= (sg_dma_len(sg)-offset);
                         offset = 0;
-                        sg++;
+                        sg = sg_next(sg);
                         while (todo > sg_dma_len(sg)) {
                                 *(rp++)=cpu_to_le32(BT848_RISC_WRITE|
                                                     sg_dma_len(sg));
                                 *(rp++)=cpu_to_le32(sg_dma_address(sg));
                                 todo -= sg_dma_len(sg);
-                                sg++;
+                                sg = sg_next(sg);
                         }
                         *(rp++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_EOL|
                                             todo);
@@ -187,15 +187,15 @@ bttv_risc_planar(struct bttv *btv, struct btcx_riscmem *risc,
                         /* go to next sg entry if needed */
                         while (yoffset && yoffset >= sg_dma_len(ysg)) {
                                 yoffset -= sg_dma_len(ysg);
-                                ysg++;
+                                ysg = sg_next(ysg);
                         }
                         while (uoffset && uoffset >= sg_dma_len(usg)) {
                                 uoffset -= sg_dma_len(usg);
-                                usg++;
+                                usg = sg_next(usg);
                         }
                         while (voffset && voffset >= sg_dma_len(vsg)) {
                                 voffset -= sg_dma_len(vsg);
-                                vsg++;
+                                vsg = sg_next(vsg);
                         }
 
                         /* calculate max number of bytes we can write */
diff --git a/drivers/media/pci/cx18/cx18-av-core.c b/drivers/media/pci/cx18/cx18-av-core.c
index 2d3afe0431a9..5a55630d09db 100644
--- a/drivers/media/pci/cx18/cx18-av-core.c
+++ b/drivers/media/pci/cx18/cx18-av-core.c
@@ -490,8 +490,8 @@ void cx18_av_std_setup(struct cx18 *cx)
 
         /* Sets horizontal blanking delay and active lines */
         cx18_av_write(cx, 0x470, hblank);
-        cx18_av_write(cx, 0x471, 0xff & (((hblank >> 8) & 0x3) |
-                                                (hactive << 4)));
+        cx18_av_write(cx, 0x471,
+                      (((hblank >> 8) & 0x3) | (hactive << 4)) & 0xff);
         cx18_av_write(cx, 0x472, hactive >> 4);
 
         /* Sets burst gate delay */
@@ -499,14 +499,14 @@ void cx18_av_std_setup(struct cx18 *cx)
 
         /* Sets vertical blanking delay and active duration */
         cx18_av_write(cx, 0x474, vblank);
-        cx18_av_write(cx, 0x475, 0xff & (((vblank >> 8) & 0x3) |
-                                                (vactive << 4)));
+        cx18_av_write(cx, 0x475,
+                      (((vblank >> 8) & 0x3) | (vactive << 4)) & 0xff);
         cx18_av_write(cx, 0x476, vactive >> 4);
         cx18_av_write(cx, 0x477, vblank656);
 
         /* Sets src decimation rate */
-        cx18_av_write(cx, 0x478, 0xff & src_decimation);
-        cx18_av_write(cx, 0x479, 0xff & (src_decimation >> 8));
+        cx18_av_write(cx, 0x478, src_decimation & 0xff);
+        cx18_av_write(cx, 0x479, (src_decimation >> 8) & 0xff);
 
         /* Sets Luma and UV Low pass filters */
         cx18_av_write(cx, 0x47a, luma_lpf << 6 | ((uv_lpf << 4) & 0x30));
@@ -516,8 +516,8 @@ void cx18_av_std_setup(struct cx18 *cx)
 
         /* Sets SC Step*/
         cx18_av_write(cx, 0x47c, sc);
-        cx18_av_write(cx, 0x47d, 0xff & sc >> 8);
-        cx18_av_write(cx, 0x47e, 0xff & sc >> 16);
+        cx18_av_write(cx, 0x47d, (sc >> 8) & 0xff);
+        cx18_av_write(cx, 0x47e, (sc >> 16) & 0xff);
 
         if (std & V4L2_STD_625_50) {
                 state->slicer_line_delay = 1;
@@ -952,7 +952,7 @@ static int cx18_av_s_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt
         int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
         int is_50Hz = !(state->std & V4L2_STD_525_60);
 
-        if (fmt->code != V4L2_MBUS_FMT_FIXED)
+        if (fmt->code != MEDIA_BUS_FMT_FIXED)
                 return -EINVAL;
 
         fmt->field = V4L2_FIELD_INTERLACED;
diff --git a/drivers/media/pci/cx18/cx18-cards.h b/drivers/media/pci/cx18/cx18-cards.h
index add7391ecaba..f6b921f3b0ac 100644
--- a/drivers/media/pci/cx18/cx18-cards.h
+++ b/drivers/media/pci/cx18/cx18-cards.h
@@ -57,7 +57,8 @@
 /* V4L2 capability aliases */
 #define CX18_CAP_ENCODER (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER | \
                           V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | \
-                          V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE)
+                          V4L2_CAP_STREAMING | V4L2_CAP_VBI_CAPTURE | \
+                          V4L2_CAP_SLICED_VBI_CAPTURE)
 
 struct cx18_card_video_input {
         u8  video_type;         /* video input type */
diff --git a/drivers/media/pci/cx18/cx18-controls.c b/drivers/media/pci/cx18/cx18-controls.c
index 282a3d29fdaa..4aeb7c6b8ce1 100644
--- a/drivers/media/pci/cx18/cx18-controls.c
+++ b/drivers/media/pci/cx18/cx18-controls.c
@@ -98,7 +98,7 @@ static int cx18_s_video_encoding(struct cx2341x_handler *cxhdl, u32 val)
         /* fix videodecoder resolution */
         fmt.width = cxhdl->width / (is_mpeg1 ? 2 : 1);
         fmt.height = cxhdl->height;
-        fmt.code = V4L2_MBUS_FMT_FIXED;
+        fmt.code = MEDIA_BUS_FMT_FIXED;
         v4l2_subdev_call(cx->sd_av, video, s_mbus_fmt, &fmt);
         return 0;
 }
diff --git a/drivers/media/pci/cx18/cx18-driver.h b/drivers/media/pci/cx18/cx18-driver.h
index 57f4688ea55b..dcfd7a1d317e 100644
--- a/drivers/media/pci/cx18/cx18-driver.h
+++ b/drivers/media/pci/cx18/cx18-driver.h
@@ -379,6 +379,7 @@ struct cx18_stream {
         const char *name;               /* name of the stream */
         int type;                       /* stream type */
         u32 handle;                     /* task handle */
+        u32 v4l2_dev_caps;              /* device capabilities */
         unsigned int mdl_base_idx;
 
         u32 id;
diff --git a/drivers/media/pci/cx18/cx18-ioctl.c b/drivers/media/pci/cx18/cx18-ioctl.c
index 6f2b59042b73..b8e4b68a9196 100644
--- a/drivers/media/pci/cx18/cx18-ioctl.c
+++ b/drivers/media/pci/cx18/cx18-ioctl.c
@@ -294,7 +294,7 @@ static int cx18_s_fmt_vid_cap(struct file *file, void *fh,
 
         mbus_fmt.width = cx->cxhdl.width = w;
         mbus_fmt.height = cx->cxhdl.height = h;
-        mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
+        mbus_fmt.code = MEDIA_BUS_FMT_FIXED;
         v4l2_subdev_call(cx->sd_av, video, s_mbus_fmt, &mbus_fmt);
         return cx18_g_fmt_vid_cap(file, fh, fmt);
 }
@@ -393,15 +393,16 @@ static int cx18_querycap(struct file *file, void *fh,
                                 struct v4l2_capability *vcap)
 {
         struct cx18_open_id *id = fh2id(fh);
+        struct cx18_stream *s = video_drvdata(file);
         struct cx18 *cx = id->cx;
 
         strlcpy(vcap->driver, CX18_DRIVER_NAME, sizeof(vcap->driver));
         strlcpy(vcap->card, cx->card_name, sizeof(vcap->card));
         snprintf(vcap->bus_info, sizeof(vcap->bus_info),
                  "PCI:%s", pci_name(cx->pci_dev));
-        vcap->capabilities = cx->v4l2_cap;          /* capabilities */
-        if (id->type == CX18_ENC_STREAM_TYPE_YUV)
-                vcap->capabilities |= V4L2_CAP_STREAMING;
+        vcap->capabilities = cx->v4l2_cap;      /* capabilities */
+        vcap->device_caps = s->v4l2_dev_caps;   /* device capabilities */
+        vcap->capabilities |= V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/pci/cx18/cx18-streams.c b/drivers/media/pci/cx18/cx18-streams.c
index f3541b5156ce..369445fcf3e5 100644
--- a/drivers/media/pci/cx18/cx18-streams.c
+++ b/drivers/media/pci/cx18/cx18-streams.c
@@ -58,11 +58,14 @@ static struct {
         int vfl_type;
         int num_offset;
         int dma;
+        u32 caps;
 } cx18_stream_info[] = {
         {       /* CX18_ENC_STREAM_TYPE_MPG */
                 "encoder MPEG",
                 VFL_TYPE_GRABBER, 0,
                 PCI_DMA_FROMDEVICE,
+                V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                V4L2_CAP_AUDIO | V4L2_CAP_TUNER
         },
         {       /* CX18_ENC_STREAM_TYPE_TS */
                 "TS",
@@ -73,11 +76,15 @@ static struct {
                 "encoder YUV",
                 VFL_TYPE_GRABBER, CX18_V4L2_ENC_YUV_OFFSET,
                 PCI_DMA_FROMDEVICE,
+                V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                V4L2_CAP_STREAMING | V4L2_CAP_AUDIO | V4L2_CAP_TUNER
         },
         {       /* CX18_ENC_STREAM_TYPE_VBI */
                 "encoder VBI",
                 VFL_TYPE_VBI, 0,
                 PCI_DMA_FROMDEVICE,
+                V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE |
+                V4L2_CAP_READWRITE | V4L2_CAP_TUNER
         },
         {       /* CX18_ENC_STREAM_TYPE_PCM */
                 "encoder PCM audio",
@@ -93,6 +100,7 @@ static struct {
                 "encoder radio",
                 VFL_TYPE_RADIO, 0,
                 PCI_DMA_NONE,
+                V4L2_CAP_RADIO | V4L2_CAP_TUNER
         },
 };
 
@@ -260,6 +268,7 @@ static void cx18_stream_init(struct cx18 *cx, int type)
         s->handle = CX18_INVALID_TASK_HANDLE;
 
         s->dma = cx18_stream_info[type].dma;
+        s->v4l2_dev_caps = cx18_stream_info[type].caps;
         s->buffers = cx->stream_buffers[type];
         s->buf_size = cx->stream_buf_size[type];
         INIT_LIST_HEAD(&s->buf_pool);
diff --git a/drivers/media/pci/cx23885/cx23885-417.c b/drivers/media/pci/cx23885/cx23885-417.c
index 3948db386fb5..e4901a503c73 100644
--- a/drivers/media/pci/cx23885/cx23885-417.c
+++ b/drivers/media/pci/cx23885/cx23885-417.c
@@ -1148,6 +1148,7 @@ static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
         dev->ts1.ts_packet_count = mpeglines;
         *num_planes = 1;
         sizes[0] = mpeglinesize * mpeglines;
+        alloc_ctxs[0] = dev->alloc_ctx;
         *num_buffers = mpegbufs;
         return 0;
 }
@@ -1166,11 +1167,8 @@ static void buffer_finish(struct vb2_buffer *vb)
         struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
         struct cx23885_buffer *buf = container_of(vb,
                 struct cx23885_buffer, vb);
-        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
 
         cx23885_free_buffer(dev, buf);
-
-        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
 static void buffer_queue(struct vb2_buffer *vb)
diff --git a/drivers/media/pci/cx23885/cx23885-cards.c b/drivers/media/pci/cx23885/cx23885-cards.c
index 88c257d1161b..db99ca2613ba 100644
--- a/drivers/media/pci/cx23885/cx23885-cards.c
+++ b/drivers/media/pci/cx23885/cx23885-cards.c
@@ -680,6 +680,32 @@ struct cx23885_board cx23885_boards[] = {
                 .portb          = CX23885_MPEG_DVB,
                 .portc          = CX23885_MPEG_DVB,
         },
+        [CX23885_BOARD_DVBSKY_T980C] = {
+                .name           = "DVBSky T980C",
+                .portb          = CX23885_MPEG_DVB,
+        },
+        [CX23885_BOARD_DVBSKY_S950C] = {
+                .name           = "DVBSky S950C",
+                .portb          = CX23885_MPEG_DVB,
+        },
+        [CX23885_BOARD_TT_CT2_4500_CI] = {
+                .name           = "Technotrend TT-budget CT2-4500 CI",
+                .portb          = CX23885_MPEG_DVB,
+        },
+        [CX23885_BOARD_DVBSKY_S950] = {
+                .name           = "DVBSky S950",
+                .portb          = CX23885_MPEG_DVB,
+        },
+        [CX23885_BOARD_DVBSKY_S952] = {
+                .name           = "DVBSky S952",
+                .portb          = CX23885_MPEG_DVB,
+                .portc          = CX23885_MPEG_DVB,
+        },
+        [CX23885_BOARD_DVBSKY_T982] = {
+                .name           = "DVBSky T982",
+                .portb          = CX23885_MPEG_DVB,
+                .portc          = CX23885_MPEG_DVB,
+        },
 };
 const unsigned int cx23885_bcount = ARRAY_SIZE(cx23885_boards);
 
@@ -939,6 +965,30 @@ struct cx23885_subid cx23885_subids[] = {
                 .subvendor = 0x4254,
                 .subdevice = 0x9580,
                 .card      = CX23885_BOARD_DVBSKY_T9580,
+        }, {
+                .subvendor = 0x4254,
+                .subdevice = 0x980c,
+                .card      = CX23885_BOARD_DVBSKY_T980C,
+        }, {
+                .subvendor = 0x4254,
+                .subdevice = 0x950c,
+                .card      = CX23885_BOARD_DVBSKY_S950C,
+        }, {
+                .subvendor = 0x13c2,
+                .subdevice = 0x3013,
+                .card      = CX23885_BOARD_TT_CT2_4500_CI,
+        }, {
+                .subvendor = 0x4254,
+                .subdevice = 0x0950,
+                .card      = CX23885_BOARD_DVBSKY_S950,
+        }, {
+                .subvendor = 0x4254,
+                .subdevice = 0x0952,
+                .card      = CX23885_BOARD_DVBSKY_S952,
+        }, {
+                .subvendor = 0x4254,
+                .subdevice = 0x0982,
+                .card      = CX23885_BOARD_DVBSKY_T982,
         },
 };
 const unsigned int cx23885_idcount = ARRAY_SIZE(cx23885_subids);
@@ -1534,6 +1584,8 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
                 mdelay(60);
                 break;
         case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982:
                 /* enable GPIO3-18 pins */
                 cx_write(MC417_CTL, 0x00000037);
                 cx23885_gpio_enable(dev, GPIO_2 | GPIO_11, 1);
@@ -1541,6 +1593,45 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
                 mdelay(100);
                 cx23885_gpio_set(dev, GPIO_2 | GPIO_11);
                 break;
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+                /*
+                 * GPIO-0 INTA from CiMax, input
+                 * GPIO-1 reset CiMax, output, high active
+                 * GPIO-2 reset demod, output, low active
+                 * GPIO-3 to GPIO-10 data/addr for CAM
+                 * GPIO-11 ~CS0 to CiMax1
+                 * GPIO-12 ~CS1 to CiMax2
+                 * GPIO-13 ADL0 load LSB addr
+                 * GPIO-14 ADL1 load MSB addr
+                 * GPIO-15 ~RDY from CiMax
+                 * GPIO-17 ~RD to CiMax
+                 * GPIO-18 ~WR to CiMax
+                 */
+
+                cx_set(GP0_IO, 0x00060002); /* GPIO 1/2 as output */
+                cx_clear(GP0_IO, 0x00010004); /* GPIO 0 as input */
+                mdelay(100); /* reset delay */
+                cx_set(GP0_IO, 0x00060004); /* GPIO as out, reset high */
+                cx_clear(GP0_IO, 0x00010002);
+                cx_write(MC417_CTL, 0x00000037); /* enable GPIO3-18 pins */
+
+                /* GPIO-15 IN as ~ACK, rest as OUT */
+                cx_write(MC417_OEN, 0x00001000);
+
+                /* ~RD, ~WR high; ADL0, ADL1 low; ~CS0, ~CS1 high */
+                cx_write(MC417_RWD, 0x0000c300);
+
+                /* enable irq */
+                cx_write(GPIO_ISM, 0x00000000); /* INTERRUPTS active low */
+                break;
+        case CX23885_BOARD_DVBSKY_S950:
+                cx23885_gpio_enable(dev, GPIO_2, 1);
+                cx23885_gpio_clear(dev, GPIO_2);
+                msleep(100);
+                cx23885_gpio_set(dev, GPIO_2);
+                break;
         }
 }
 
@@ -1621,6 +1712,13 @@ int cx23885_ir_init(struct cx23885_dev *dev)
         case CX23885_BOARD_MYGICA_X8507:
         case CX23885_BOARD_TBS_6980:
         case CX23885_BOARD_TBS_6981:
+        case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+        case CX23885_BOARD_DVBSKY_S950:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982:
                 if (!enable_885_ir)
                         break;
                 dev->sd_ir = cx23885_find_hw(dev, CX23885_HW_AV_CORE);
@@ -1667,6 +1765,13 @@ void cx23885_ir_fini(struct cx23885_dev *dev)
         case CX23885_BOARD_MYGICA_X8507:
         case CX23885_BOARD_TBS_6980:
         case CX23885_BOARD_TBS_6981:
+        case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+        case CX23885_BOARD_DVBSKY_S950:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982:
                 cx23885_irq_remove(dev, PCI_MSK_AV_CORE);
                 /* sd_ir is a duplicate pointer to the AV Core, just clear it */
                 dev->sd_ir = NULL;
@@ -1714,6 +1819,13 @@ void cx23885_ir_pci_int_enable(struct cx23885_dev *dev)
         case CX23885_BOARD_MYGICA_X8507:
         case CX23885_BOARD_TBS_6980:
         case CX23885_BOARD_TBS_6981:
+        case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+        case CX23885_BOARD_DVBSKY_S950:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982:
                 if (dev->sd_ir)
                         cx23885_irq_add_enable(dev, PCI_MSK_AV_CORE);
                 break;
@@ -1817,6 +1929,10 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_TEVII_S471:
         case CX23885_BOARD_DVBWORLD_2005:
         case CX23885_BOARD_PROF_8000:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+        case CX23885_BOARD_DVBSKY_S950:
                 ts1->gen_ctrl_val  = 0x5; /* Parallel */
                 ts1->ts_clk_en_val = 0x1; /* Enable TS_CLK */
                 ts1->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
@@ -1865,6 +1981,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
                 ts2->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
                 break;
         case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_T982:
                 ts1->gen_ctrl_val  = 0x5; /* Parallel */
                 ts1->ts_clk_en_val = 0x1; /* Enable TS_CLK */
                 ts1->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
@@ -1872,6 +1989,14 @@ void cx23885_card_setup(struct cx23885_dev *dev)
                 ts2->ts_clk_en_val = 0x1; /* Enable TS_CLK */
                 ts2->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
                 break;
+        case CX23885_BOARD_DVBSKY_S952:
+                ts1->gen_ctrl_val  = 0x5; /* Parallel */
+                ts1->ts_clk_en_val = 0x1; /* Enable TS_CLK */
+                ts1->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
+                ts2->gen_ctrl_val  = 0xe; /* Serial bus */
+                ts2->ts_clk_en_val = 0x1; /* Enable TS_CLK */
+                ts2->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
+                break;
         case CX23885_BOARD_HAUPPAUGE_HVR1250:
         case CX23885_BOARD_HAUPPAUGE_HVR1500:
         case CX23885_BOARD_HAUPPAUGE_HVR1500Q:
@@ -1935,6 +2060,12 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_TBS_6980:
         case CX23885_BOARD_TBS_6981:
         case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+        case CX23885_BOARD_DVBSKY_S950:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982:
                 dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_bus[2].i2c_adap,
                                 "cx25840", 0x88 >> 1, NULL);
diff --git a/drivers/media/pci/cx23885/cx23885-core.c b/drivers/media/pci/cx23885/cx23885-core.c
index 331eddac7222..1d9d0f86ca8c 100644
--- a/drivers/media/pci/cx23885/cx23885-core.c
+++ b/drivers/media/pci/cx23885/cx23885-core.c
@@ -1078,7 +1078,7 @@ static __le32 *cx23885_risc_field(__le32 *rp, struct scatterlist *sglist,
         for (line = 0; line < lines; line++) {
                 while (offset && offset >= sg_dma_len(sg)) {
                         offset -= sg_dma_len(sg);
-                        sg++;
+                        sg = sg_next(sg);
                 }
 
                 if (lpi && line > 0 && !(line % lpi))
@@ -1101,14 +1101,14 @@ static __le32 *cx23885_risc_field(__le32 *rp, struct scatterlist *sglist,
                         *(rp++) = cpu_to_le32(0); /* bits 63-32 */
                         todo -= (sg_dma_len(sg)-offset);
                         offset = 0;
-                        sg++;
+                        sg = sg_next(sg);
                         while (todo > sg_dma_len(sg)) {
                                 *(rp++) = cpu_to_le32(RISC_WRITE|
                                                     sg_dma_len(sg));
                                 *(rp++) = cpu_to_le32(sg_dma_address(sg));
                                 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
                                 todo -= sg_dma_len(sg);
-                                sg++;
+                                sg = sg_next(sg);
                         }
                         *(rp++) = cpu_to_le32(RISC_WRITE|RISC_EOL|todo);
                         *(rp++) = cpu_to_le32(sg_dma_address(sg));
@@ -1453,17 +1453,12 @@ int cx23885_buf_prepare(struct cx23885_buffer *buf, struct cx23885_tsport *port)
         struct cx23885_dev *dev = port->dev;
         int size = port->ts_packet_size * port->ts_packet_count;
         struct sg_table *sgt = vb2_dma_sg_plane_desc(&buf->vb, 0);
-        int rc;
 
         dprintk(1, "%s: %p\n", __func__, buf);
         if (vb2_plane_size(&buf->vb, 0) < size)
                 return -EINVAL;
         vb2_set_plane_payload(&buf->vb, 0, size);
 
-        rc = dma_map_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
-        if (!rc)
-                return -EIO;
-
         cx23885_risc_databuffer(dev->pci, &buf->risc,
                                 sgt->sgl,
                                 port->ts_packet_size, port->ts_packet_count, 0);
@@ -1997,9 +1992,14 @@ static int cx23885_initdev(struct pci_dev *pci_dev,
         if (!pci_dma_supported(pci_dev, 0xffffffff)) {
                 printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
                 err = -EIO;
-                goto fail_irq;
+                goto fail_context;
         }
 
+        dev->alloc_ctx = vb2_dma_sg_init_ctx(&pci_dev->dev);
+        if (IS_ERR(dev->alloc_ctx)) {
+                err = PTR_ERR(dev->alloc_ctx);
+                goto fail_context;
+        }
         err = request_irq(pci_dev->irq, cx23885_irq,
                           IRQF_SHARED, dev->name, dev);
         if (err < 0) {
@@ -2028,6 +2028,8 @@ static int cx23885_initdev(struct pci_dev *pci_dev,
         return 0;
 
 fail_irq:
+        vb2_dma_sg_cleanup_ctx(dev->alloc_ctx);
+fail_context:
         cx23885_dev_unregister(dev);
 fail_ctrl:
         v4l2_ctrl_handler_free(hdl);
@@ -2053,6 +2055,7 @@ static void cx23885_finidev(struct pci_dev *pci_dev)
         free_irq(pci_dev->irq, dev);
 
         cx23885_dev_unregister(dev);
+        vb2_dma_sg_cleanup_ctx(dev->alloc_ctx);
         v4l2_ctrl_handler_free(&dev->ctrl_handler);
         v4l2_device_unregister(v4l2_dev);
         kfree(dev);
diff --git a/drivers/media/pci/cx23885/cx23885-dvb.c b/drivers/media/pci/cx23885/cx23885-dvb.c
index 4cb90317ff45..c47d18270cfc 100644
--- a/drivers/media/pci/cx23885/cx23885-dvb.c
+++ b/drivers/media/pci/cx23885/cx23885-dvb.c
@@ -71,6 +71,7 @@
 #include "si2165.h"
 #include "si2168.h"
 #include "si2157.h"
+#include "sp2.h"
 #include "m88ds3103.h"
 #include "m88ts2022.h"
 
@@ -101,6 +102,7 @@ static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
         port->ts_packet_count = 32;
         *num_planes = 1;
         sizes[0] = port->ts_packet_size * port->ts_packet_count;
+        alloc_ctxs[0] = port->dev->alloc_ctx;
         *num_buffers = 32;
         return 0;
 }
@@ -121,11 +123,8 @@ static void buffer_finish(struct vb2_buffer *vb)
         struct cx23885_dev *dev = port->dev;
         struct cx23885_buffer *buf = container_of(vb,
                 struct cx23885_buffer, vb);
-        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
 
         cx23885_free_buffer(dev, buf);
-
-        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
 static void buffer_queue(struct vb2_buffer *vb)
@@ -616,6 +615,103 @@ static int dvbsky_t9580_set_voltage(struct dvb_frontend *fe,
         return 0;
 }
 
+static int dvbsky_s952_portc_set_voltage(struct dvb_frontend *fe,
+                                        fe_sec_voltage_t voltage)
+{
+        struct cx23885_tsport *port = fe->dvb->priv;
+        struct cx23885_dev *dev = port->dev;
+
+        cx23885_gpio_enable(dev, GPIO_12 | GPIO_13, 1);
+
+        switch (voltage) {
+        case SEC_VOLTAGE_13:
+                cx23885_gpio_set(dev, GPIO_13);
+                cx23885_gpio_clear(dev, GPIO_12);
+                break;
+        case SEC_VOLTAGE_18:
+                cx23885_gpio_set(dev, GPIO_13);
+                cx23885_gpio_set(dev, GPIO_12);
+                break;
+        case SEC_VOLTAGE_OFF:
+                cx23885_gpio_clear(dev, GPIO_13);
+                cx23885_gpio_clear(dev, GPIO_12);
+                break;
+        }
+        /* call the frontend set_voltage function */
+        return port->fe_set_voltage(fe, voltage);
+}
+
+static int cx23885_sp2_ci_ctrl(void *priv, u8 read, int addr,
+                                u8 data, int *mem)
+{
+        /* MC417 */
+        #define SP2_DATA              0x000000ff
+        #define SP2_WR                0x00008000
+        #define SP2_RD                0x00004000
+        #define SP2_ACK               0x00001000
+        #define SP2_ADHI              0x00000800
+        #define SP2_ADLO              0x00000400
+        #define SP2_CS1               0x00000200
+        #define SP2_CS0               0x00000100
+        #define SP2_EN_ALL            0x00001000
+        #define SP2_CTRL_OFF          (SP2_CS1 | SP2_CS0 | SP2_WR | SP2_RD)
+
+        struct cx23885_tsport *port = priv;
+        struct cx23885_dev *dev = port->dev;
+        int ret;
+        int tmp = 0;
+        unsigned long timeout;
+
+        mutex_lock(&dev->gpio_lock);
+
+        /* write addr */
+        cx_write(MC417_OEN, SP2_EN_ALL);
+        cx_write(MC417_RWD, SP2_CTRL_OFF |
+                                SP2_ADLO | (0xff & addr));
+        cx_clear(MC417_RWD, SP2_ADLO);
+        cx_write(MC417_RWD, SP2_CTRL_OFF |
+                                SP2_ADHI | (0xff & (addr >> 8)));
+        cx_clear(MC417_RWD, SP2_ADHI);
+
+        if (read)
+                /* data in */
+                cx_write(MC417_OEN, SP2_EN_ALL | SP2_DATA);
+        else
+                /* data out */
+                cx_write(MC417_RWD, SP2_CTRL_OFF | data);
+
+        /* chip select 0 */
+        cx_clear(MC417_RWD, SP2_CS0);
+
+        /* read/write */
+        cx_clear(MC417_RWD, (read) ? SP2_RD : SP2_WR);
+
+        /* wait for a maximum of 1 msec */
+        timeout = jiffies + msecs_to_jiffies(1);
+        while (!time_after(jiffies, timeout)) {
+                tmp = cx_read(MC417_RWD);
+                if ((tmp & SP2_ACK) == 0)
+                        break;
+                usleep_range(50, 100);
+        }
+
+        cx_set(MC417_RWD, SP2_CTRL_OFF);
+        *mem = tmp & 0xff;
+
+        mutex_unlock(&dev->gpio_lock);
+
+        if (!read) {
+                if (*mem < 0) {
+                        ret = -EREMOTEIO;
+                        goto err;
+                }
+        }
+
+        return 0;
+err:
+        return ret;
+}
+
 static int cx23885_dvb_set_frontend(struct dvb_frontend *fe)
 {
         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
@@ -793,6 +889,32 @@ static const struct m88ds3103_config dvbsky_t9580_m88ds3103_config = {
         .agc = 0x99,
 };
 
+static const struct m88ds3103_config dvbsky_s950c_m88ds3103_config = {
+        .i2c_addr = 0x68,
+        .clock = 27000000,
+        .i2c_wr_max = 33,
+        .clock_out = 0,
+        .ts_mode = M88DS3103_TS_CI,
+        .ts_clk = 10000,
+        .ts_clk_pol = 1,
+        .lnb_en_pol = 1,
+        .lnb_hv_pol = 0,
+        .agc = 0x99,
+};
+
+static const struct m88ds3103_config dvbsky_s952_portc_m88ds3103_config = {
+        .i2c_addr = 0x68,
+        .clock = 27000000,
+        .i2c_wr_max = 33,
+        .clock_out = 0,
+        .ts_mode = M88DS3103_TS_SERIAL,
+        .ts_clk = 96000,
+        .ts_clk_pol = 0,
+        .lnb_en_pol = 1,
+        .lnb_hv_pol = 0,
+        .agc = 0x99,
+};
+
 static int netup_altera_fpga_rw(void *device, int flag, int data, int read)
 {
         struct cx23885_dev *dev = (struct cx23885_dev *)device;
@@ -944,11 +1066,13 @@ static int dvb_register(struct cx23885_tsport *port)
         struct vb2_dvb_frontend *fe0, *fe1 = NULL;
         struct si2168_config si2168_config;
         struct si2157_config si2157_config;
+        struct sp2_config sp2_config;
         struct m88ts2022_config m88ts2022_config;
         struct i2c_board_info info;
         struct i2c_adapter *adapter;
-        struct i2c_client *client_demod;
-        struct i2c_client *client_tuner;
+        struct i2c_client *client_demod = NULL, *client_tuner = NULL, *client_ci = NULL;
+        const struct m88ds3103_config *p_m88ds3103_config = NULL;
+        int (*p_set_voltage)(struct dvb_frontend *fe, fe_sec_voltage_t voltage) = NULL;
         int mfe_shared = 0; /* bus not shared by default */
         int ret;
 
@@ -973,11 +1097,11 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(s5h1409_attach,
                                                 &hauppauge_generic_config,
                                                 &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(mt2131_attach, fe0->dvb.frontend,
-                                   &i2c_bus->i2c_adap,
-                                   &hauppauge_generic_tunerconfig, 0);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(mt2131_attach, fe0->dvb.frontend,
+                           &i2c_bus->i2c_adap,
+                           &hauppauge_generic_tunerconfig, 0);
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
@@ -985,11 +1109,11 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(lgdt3305_attach,
                                                &hauppauge_lgdt3305_config,
                                                &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
-                                   0x60, &dev->i2c_bus[1].i2c_adap,
-                                   &hauppauge_hvr127x_config);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                           0x60, &dev->i2c_bus[1].i2c_adap,
+                           &hauppauge_hvr127x_config);
                 if (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1275)
                         cx23885_set_frontend_hook(port, fe0->dvb.frontend);
                 break;
@@ -999,11 +1123,12 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(s5h1411_attach,
                                                &hcw_s5h1411_config,
                                                &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
-                                   0x60, &dev->i2c_bus[1].i2c_adap,
-                                   &hauppauge_tda18271_config);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+
+                dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                           0x60, &dev->i2c_bus[1].i2c_adap,
+                           &hauppauge_tda18271_config);
 
                 tda18271_attach(&dev->ts1.analog_fe,
                         0x60, &dev->i2c_bus[1].i2c_adap,
@@ -1018,14 +1143,15 @@ static int dvb_register(struct cx23885_tsport *port)
                                 dvb_attach(s5h1409_attach,
                                            &hauppauge_ezqam_config,
                                            &i2c_bus->i2c_adap);
-                        if (fe0->dvb.frontend != NULL) {
-                                dvb_attach(tda829x_attach, fe0->dvb.frontend,
-                                           &dev->i2c_bus[1].i2c_adap, 0x42,
-                                           &tda829x_no_probe);
-                                dvb_attach(tda18271_attach, fe0->dvb.frontend,
-                                           0x60, &dev->i2c_bus[1].i2c_adap,
-                                           &hauppauge_tda18271_config);
-                        }
+                        if (fe0->dvb.frontend == NULL)
+                                break;
+
+                        dvb_attach(tda829x_attach, fe0->dvb.frontend,
+                                   &dev->i2c_bus[1].i2c_adap, 0x42,
+                                   &tda829x_no_probe);
+                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                                   0x60, &dev->i2c_bus[1].i2c_adap,
+                                   &hauppauge_tda18271_config);
                         break;
                 case 0:
                 default:
@@ -1033,11 +1159,11 @@ static int dvb_register(struct cx23885_tsport *port)
                                 dvb_attach(s5h1409_attach,
                                            &hauppauge_generic_config,
                                            &i2c_bus->i2c_adap);
-                        if (fe0->dvb.frontend != NULL)
-                                dvb_attach(mt2131_attach, fe0->dvb.frontend,
-                                           &i2c_bus->i2c_adap,
-                                           &hauppauge_generic_tunerconfig, 0);
-                        break;
+                        if (fe0->dvb.frontend == NULL)
+                                break;
+                        dvb_attach(mt2131_attach, fe0->dvb.frontend,
+                                   &i2c_bus->i2c_adap,
+                                   &hauppauge_generic_tunerconfig, 0);
                 }
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1800lp:
@@ -1045,32 +1171,33 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(s5h1409_attach,
                                                 &hauppauge_hvr1800lp_config,
                                                 &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(mt2131_attach, fe0->dvb.frontend,
-                                   &i2c_bus->i2c_adap,
-                                   &hauppauge_generic_tunerconfig, 0);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(mt2131_attach, fe0->dvb.frontend,
+                           &i2c_bus->i2c_adap,
+                           &hauppauge_generic_tunerconfig, 0);
                 break;
         case CX23885_BOARD_DVICO_FUSIONHDTV_5_EXP:
                 i2c_bus = &dev->i2c_bus[0];
                 fe0->dvb.frontend = dvb_attach(lgdt330x_attach,
                                                 &fusionhdtv_5_express,
                                                 &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
-                                   &i2c_bus->i2c_adap, 0x61,
-                                   TUNER_LG_TDVS_H06XF);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
+                           &i2c_bus->i2c_adap, 0x61,
+                           TUNER_LG_TDVS_H06XF);
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1500Q:
                 i2c_bus = &dev->i2c_bus[1];
                 fe0->dvb.frontend = dvb_attach(s5h1409_attach,
                                                 &hauppauge_hvr1500q_config,
                                                 &dev->i2c_bus[0].i2c_adap);
-                if (fe0->dvb.frontend != NULL)
-                        dvb_attach(xc5000_attach, fe0->dvb.frontend,
-                                   &i2c_bus->i2c_adap,
-                                   &hauppauge_hvr1500q_tunerconfig);
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(xc5000_attach, fe0->dvb.frontend,
+                           &i2c_bus->i2c_adap,
+                           &hauppauge_hvr1500q_tunerconfig);
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1500:
                 i2c_bus = &dev->i2c_bus[1];
@@ -1101,14 +1228,14 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(tda10048_attach,
                         &hauppauge_hvr1200_config,
                         &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(tda829x_attach, fe0->dvb.frontend,
-                                &dev->i2c_bus[1].i2c_adap, 0x42,
-                                &tda829x_no_probe);
-                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
-                                0x60, &dev->i2c_bus[1].i2c_adap,
-                                &hauppauge_hvr1200_tuner_config);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(tda829x_attach, fe0->dvb.frontend,
+                           &dev->i2c_bus[1].i2c_adap, 0x42,
+                           &tda829x_no_probe);
+                dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                           0x60, &dev->i2c_bus[1].i2c_adap,
+                           &hauppauge_hvr1200_tuner_config);
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
                 i2c_bus = &dev->i2c_bus[0];
@@ -1367,12 +1494,10 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(lgs8gxx_attach,
                         &mygica_x8506_lgs8gl5_config,
                         &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(xc5000_attach,
-                                fe0->dvb.frontend,
-                                &i2c_bus2->i2c_adap,
-                                &mygica_x8506_xc5000_config);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(xc5000_attach, fe0->dvb.frontend,
+                           &i2c_bus2->i2c_adap, &mygica_x8506_xc5000_config);
                 cx23885_set_frontend_hook(port, fe0->dvb.frontend);
                 break;
         case CX23885_BOARD_MYGICA_X8507:
@@ -1381,12 +1506,12 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(mb86a20s_attach,
                         &mygica_x8507_mb86a20s_config,
                         &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(xc5000_attach,
-                        fe0->dvb.frontend,
-                        &i2c_bus2->i2c_adap,
-                        &mygica_x8507_xc5000_config);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+
+                dvb_attach(xc5000_attach, fe0->dvb.frontend,
+                           &i2c_bus2->i2c_adap,
+                           &mygica_x8507_xc5000_config);
                 cx23885_set_frontend_hook(port, fe0->dvb.frontend);
                 break;
         case CX23885_BOARD_MAGICPRO_PROHDTVE2:
@@ -1395,12 +1520,11 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(lgs8gxx_attach,
                         &magicpro_prohdtve2_lgs8g75_config,
                         &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(xc5000_attach,
-                                fe0->dvb.frontend,
-                                &i2c_bus2->i2c_adap,
-                                &magicpro_prohdtve2_xc5000_config);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(xc5000_attach, fe0->dvb.frontend,
+                           &i2c_bus2->i2c_adap,
+                           &magicpro_prohdtve2_xc5000_config);
                 cx23885_set_frontend_hook(port, fe0->dvb.frontend);
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
@@ -1408,10 +1532,11 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(s5h1411_attach,
                         &hcw_s5h1411_config,
                         &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL)
-                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
-                                0x60, &dev->i2c_bus[0].i2c_adap,
-                                &hauppauge_tda18271_config);
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                           0x60, &dev->i2c_bus[0].i2c_adap,
+                           &hauppauge_tda18271_config);
 
                 tda18271_attach(&dev->ts1.analog_fe,
                         0x60, &dev->i2c_bus[1].i2c_adap,
@@ -1423,10 +1548,11 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(s5h1411_attach,
                         &hcw_s5h1411_config,
                         &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL)
-                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
-                                0x60, &dev->i2c_bus[0].i2c_adap,
-                                &hauppauge_tda18271_config);
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                           0x60, &dev->i2c_bus[0].i2c_adap,
+                           &hauppauge_tda18271_config);
                 break;
         case CX23885_BOARD_MYGICA_X8558PRO:
                 switch (port->nr) {
@@ -1436,12 +1562,11 @@ static int dvb_register(struct cx23885_tsport *port)
                         fe0->dvb.frontend = dvb_attach(atbm8830_attach,
                                 &mygica_x8558pro_atbm8830_cfg1,
                                 &i2c_bus->i2c_adap);
-                        if (fe0->dvb.frontend != NULL) {
-                                dvb_attach(max2165_attach,
-                                        fe0->dvb.frontend,
-                                        &i2c_bus->i2c_adap,
-                                        &mygic_x8558pro_max2165_cfg1);
-                        }
+                        if (fe0->dvb.frontend == NULL)
+                                break;
+                        dvb_attach(max2165_attach, fe0->dvb.frontend,
+                                   &i2c_bus->i2c_adap,
+                                   &mygic_x8558pro_max2165_cfg1);
                         break;
                 /* port C */
                 case 2:
@@ -1449,13 +1574,11 @@ static int dvb_register(struct cx23885_tsport *port)
                         fe0->dvb.frontend = dvb_attach(atbm8830_attach,
                                 &mygica_x8558pro_atbm8830_cfg2,
                                 &i2c_bus->i2c_adap);
-                        if (fe0->dvb.frontend != NULL) {
-                                dvb_attach(max2165_attach,
-                                        fe0->dvb.frontend,
-                                        &i2c_bus->i2c_adap,
-                                        &mygic_x8558pro_max2165_cfg2);
-                        }
-                        break;
+                        if (fe0->dvb.frontend == NULL)
+                                break;
+                        dvb_attach(max2165_attach, fe0->dvb.frontend,
+                                   &i2c_bus->i2c_adap,
+                                   &mygic_x8558pro_max2165_cfg2);
                 }
                 break;
         case CX23885_BOARD_NETUP_DUAL_DVB_T_C_CI_RF:
@@ -1467,15 +1590,15 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(stv0367ter_attach,
                                         &netup_stv0367_config[port->nr - 1],
                                         &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        if (NULL == dvb_attach(xc5000_attach,
-                                        fe0->dvb.frontend,
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                if (NULL == dvb_attach(xc5000_attach, fe0->dvb.frontend,
                                         &i2c_bus->i2c_adap,
                                         &netup_xc5000_config[port->nr - 1]))
-                                goto frontend_detach;
-                        /* load xc5000 firmware */
-                        fe0->dvb.frontend->ops.tuner_ops.init(fe0->dvb.frontend);
-                }
+                        goto frontend_detach;
+                /* load xc5000 firmware */
+                fe0->dvb.frontend->ops.tuner_ops.init(fe0->dvb.frontend);
+
                 /* MFE frontend 2 */
                 fe1 = vb2_dvb_get_frontend(&port->frontends, 2);
                 if (fe1 == NULL)
@@ -1484,14 +1607,15 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe1->dvb.frontend = dvb_attach(stv0367cab_attach,
                                         &netup_stv0367_config[port->nr - 1],
                                         &i2c_bus->i2c_adap);
-                if (fe1->dvb.frontend != NULL) {
-                        fe1->dvb.frontend->id = 1;
-                        if (NULL == dvb_attach(xc5000_attach,
-                                        fe1->dvb.frontend,
-                                        &i2c_bus->i2c_adap,
-                                        &netup_xc5000_config[port->nr - 1]))
-                                goto frontend_detach;
-                }
+                if (fe1->dvb.frontend == NULL)
+                        break;
+
+                fe1->dvb.frontend->id = 1;
+                if (NULL == dvb_attach(xc5000_attach,
+                                       fe1->dvb.frontend,
+                                       &i2c_bus->i2c_adap,
+                                       &netup_xc5000_config[port->nr - 1]))
+                        goto frontend_detach;
                 break;
         case CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL:
                 i2c_bus = &dev->i2c_bus[0];
@@ -1503,26 +1627,26 @@ static int dvb_register(struct cx23885_tsport *port)
                         fe0->dvb.frontend = dvb_attach(drxk_attach,
                                         &terratec_drxk_config[0],
                                         &i2c_bus->i2c_adap);
-                        if (fe0->dvb.frontend != NULL) {
-                                if (!dvb_attach(mt2063_attach,
-                                                fe0->dvb.frontend,
-                                                &terratec_mt2063_config[0],
-                                                &i2c_bus2->i2c_adap))
-                                        goto frontend_detach;
-                        }
+                        if (fe0->dvb.frontend == NULL)
+                                break;
+                        if (!dvb_attach(mt2063_attach,
+                                        fe0->dvb.frontend,
+                                        &terratec_mt2063_config[0],
+                                        &i2c_bus2->i2c_adap))
+                                goto frontend_detach;
                         break;
                 /* port c */
                 case 2:
                         fe0->dvb.frontend = dvb_attach(drxk_attach,
                                         &terratec_drxk_config[1],
                                         &i2c_bus->i2c_adap);
-                        if (fe0->dvb.frontend != NULL) {
-                                if (!dvb_attach(mt2063_attach,
-                                                fe0->dvb.frontend,
-                                                &terratec_mt2063_config[1],
-                                                &i2c_bus2->i2c_adap))
-                                        goto frontend_detach;
-                        }
+                        if (fe0->dvb.frontend == NULL)
+                                break;
+                        if (!dvb_attach(mt2063_attach,
+                                        fe0->dvb.frontend,
+                                        &terratec_mt2063_config[1],
+                                        &i2c_bus2->i2c_adap))
+                                goto frontend_detach;
                         break;
                 }
                 break;
@@ -1532,10 +1656,10 @@ static int dvb_register(struct cx23885_tsport *port)
                 fe0->dvb.frontend = dvb_attach(ds3000_attach,
                                         &tevii_ds3000_config,
                                         &i2c_bus->i2c_adap);
-                if (fe0->dvb.frontend != NULL) {
-                        dvb_attach(ts2020_attach, fe0->dvb.frontend,
-                                &tevii_ts2020_config, &i2c_bus->i2c_adap);
-                }
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                dvb_attach(ts2020_attach, fe0->dvb.frontend,
+                           &tevii_ts2020_config, &i2c_bus->i2c_adap);
                 break;
         case CX23885_BOARD_PROF_8000:
                 i2c_bus = &dev->i2c_bus[0];
@@ -1544,15 +1668,15 @@ static int dvb_register(struct cx23885_tsport *port)
                                                 &prof_8000_stv090x_config,
                                                 &i2c_bus->i2c_adap,
                                                 STV090x_DEMODULATOR_0);
-                if (fe0->dvb.frontend != NULL) {
-                        if (!dvb_attach(stb6100_attach,
-                                        fe0->dvb.frontend,
-                                        &prof_8000_stb6100_config,
-                                        &i2c_bus->i2c_adap))
-                                goto frontend_detach;
+                if (fe0->dvb.frontend == NULL)
+                        break;
+                if (!dvb_attach(stb6100_attach,
+                                fe0->dvb.frontend,
+                                &prof_8000_stb6100_config,
+                                &i2c_bus->i2c_adap))
+                        goto frontend_detach;
 
-                        fe0->dvb.frontend->ops.set_voltage = p8000_set_voltage;
-                }
+                fe0->dvb.frontend->ops.set_voltage = p8000_set_voltage;
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR4400:
                 i2c_bus = &dev->i2c_bus[0];
@@ -1563,30 +1687,31 @@ static int dvb_register(struct cx23885_tsport *port)
                         fe0->dvb.frontend = dvb_attach(tda10071_attach,
                                                 &hauppauge_tda10071_config,
                                                 &i2c_bus->i2c_adap);
-                        if (fe0->dvb.frontend != NULL) {
-                                if (!dvb_attach(a8293_attach, fe0->dvb.frontend,
-                                                &i2c_bus->i2c_adap,
-                                                &hauppauge_a8293_config))
-                                        goto frontend_detach;
-                        }
+                        if (fe0->dvb.frontend == NULL)
+                                break;
+                        if (!dvb_attach(a8293_attach, fe0->dvb.frontend,
+                                        &i2c_bus->i2c_adap,
+                                        &hauppauge_a8293_config))
+                                goto frontend_detach;
                         break;
                 /* port c */
                 case 2:
                         fe0->dvb.frontend = dvb_attach(si2165_attach,
                                         &hauppauge_hvr4400_si2165_config,
                                         &i2c_bus->i2c_adap);
-                        if (fe0->dvb.frontend != NULL) {
-                                fe0->dvb.frontend->ops.i2c_gate_ctrl = NULL;
-                                if (!dvb_attach(tda18271_attach,
-                                                fe0->dvb.frontend,
-                                                0x60, &i2c_bus2->i2c_adap,
-                                          &hauppauge_hvr4400_tuner_config))
-                                        goto frontend_detach;
-                        }
+                        if (fe0->dvb.frontend == NULL)
+                                break;
+                        fe0->dvb.frontend->ops.i2c_gate_ctrl = NULL;
+                        if (!dvb_attach(tda18271_attach,
+                                        fe0->dvb.frontend,
+                                        0x60, &i2c_bus2->i2c_adap,
+                                  &hauppauge_hvr4400_tuner_config))
+                                goto frontend_detach;
                         break;
                 }
                 break;
         case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_S950:
                 i2c_bus = &dev->i2c_bus[0];
                 i2c_bus2 = &dev->i2c_bus[1];
                 switch (port->nr) {
@@ -1680,6 +1805,201 @@ static int dvb_register(struct cx23885_tsport *port)
                         break;
                 }
                 break;
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+                i2c_bus = &dev->i2c_bus[1];
+                i2c_bus2 = &dev->i2c_bus[0];
+
+                /* attach frontend */
+                memset(&si2168_config, 0, sizeof(si2168_config));
+                si2168_config.i2c_adapter = &adapter;
+                si2168_config.fe = &fe0->dvb.frontend;
+                si2168_config.ts_mode = SI2168_TS_PARALLEL;
+                memset(&info, 0, sizeof(struct i2c_board_info));
+                strlcpy(info.type, "si2168", I2C_NAME_SIZE);
+                info.addr = 0x64;
+                info.platform_data = &si2168_config;
+                request_module(info.type);
+                client_demod = i2c_new_device(&i2c_bus->i2c_adap, &info);
+                if (client_demod == NULL ||
+                                client_demod->dev.driver == NULL)
+                        goto frontend_detach;
+                if (!try_module_get(client_demod->dev.driver->owner)) {
+                        i2c_unregister_device(client_demod);
+                        goto frontend_detach;
+                }
+                port->i2c_client_demod = client_demod;
+
+                /* attach tuner */
+                memset(&si2157_config, 0, sizeof(si2157_config));
+                si2157_config.fe = fe0->dvb.frontend;
+                memset(&info, 0, sizeof(struct i2c_board_info));
+                strlcpy(info.type, "si2157", I2C_NAME_SIZE);
+                info.addr = 0x60;
+                info.platform_data = &si2157_config;
+                request_module(info.type);
+                client_tuner = i2c_new_device(adapter, &info);
+                if (client_tuner == NULL ||
+                                client_tuner->dev.driver == NULL) {
+                        module_put(client_demod->dev.driver->owner);
+                        i2c_unregister_device(client_demod);
+                        goto frontend_detach;
+                }
+                if (!try_module_get(client_tuner->dev.driver->owner)) {
+                        i2c_unregister_device(client_tuner);
+                        module_put(client_demod->dev.driver->owner);
+                        i2c_unregister_device(client_demod);
+                        goto frontend_detach;
+                }
+                port->i2c_client_tuner = client_tuner;
+                break;
+        case CX23885_BOARD_DVBSKY_S950C:
+                i2c_bus = &dev->i2c_bus[1];
+                i2c_bus2 = &dev->i2c_bus[0];
+
+                /* attach frontend */
+                fe0->dvb.frontend = dvb_attach(m88ds3103_attach,
+                                &dvbsky_s950c_m88ds3103_config,
+                                &i2c_bus->i2c_adap, &adapter);
+                if (fe0->dvb.frontend == NULL)
+                        break;
+
+                /* attach tuner */
+                memset(&m88ts2022_config, 0, sizeof(m88ts2022_config));
+                m88ts2022_config.fe = fe0->dvb.frontend;
+                m88ts2022_config.clock = 27000000;
+                memset(&info, 0, sizeof(struct i2c_board_info));
+                strlcpy(info.type, "m88ts2022", I2C_NAME_SIZE);
+                info.addr = 0x60;
+                info.platform_data = &m88ts2022_config;
+                request_module(info.type);
+                client_tuner = i2c_new_device(adapter, &info);
+                if (client_tuner == NULL ||
+                                client_tuner->dev.driver == NULL)
+                        goto frontend_detach;
+                if (!try_module_get(client_tuner->dev.driver->owner)) {
+                        i2c_unregister_device(client_tuner);
+                        goto frontend_detach;
+                }
+
+                /* delegate signal strength measurement to tuner */
+                fe0->dvb.frontend->ops.read_signal_strength =
+                        fe0->dvb.frontend->ops.tuner_ops.get_rf_strength;
+
+                port->i2c_client_tuner = client_tuner;
+                break;
+        case CX23885_BOARD_DVBSKY_S952:
+                switch (port->nr) {
+                /* port b */
+                case 1:
+                        i2c_bus = &dev->i2c_bus[1];
+                        p_m88ds3103_config = &dvbsky_t9580_m88ds3103_config;
+                        p_set_voltage = dvbsky_t9580_set_voltage;
+                        break;
+                /* port c */
+                case 2:
+                        i2c_bus = &dev->i2c_bus[0];
+                        p_m88ds3103_config = &dvbsky_s952_portc_m88ds3103_config;
+                        p_set_voltage = dvbsky_s952_portc_set_voltage;
+                        break;
+                }
+
+                /* attach frontend */
+                fe0->dvb.frontend = dvb_attach(m88ds3103_attach,
+                                p_m88ds3103_config,
+                                &i2c_bus->i2c_adap, &adapter);
+                if (fe0->dvb.frontend == NULL)
+                        break;
+
+                /* attach tuner */
+                memset(&m88ts2022_config, 0, sizeof(m88ts2022_config));
+                m88ts2022_config.fe = fe0->dvb.frontend;
+                m88ts2022_config.clock = 27000000;
+                memset(&info, 0, sizeof(struct i2c_board_info));
+                strlcpy(info.type, "m88ts2022", I2C_NAME_SIZE);
+                info.addr = 0x60;
+                info.platform_data = &m88ts2022_config;
+                request_module(info.type);
+                client_tuner = i2c_new_device(adapter, &info);
+                if (client_tuner == NULL ||
+                                client_tuner->dev.driver == NULL)
+                        goto frontend_detach;
+                if (!try_module_get(client_tuner->dev.driver->owner)) {
+                        i2c_unregister_device(client_tuner);
+                        goto frontend_detach;
+                }
+
+                /* delegate signal strength measurement to tuner */
+                fe0->dvb.frontend->ops.read_signal_strength =
+                        fe0->dvb.frontend->ops.tuner_ops.get_rf_strength;
+
+                /*
+                 * for setting the voltage we need to set GPIOs on
+                 * the card.
+                 */
+                port->fe_set_voltage =
+                        fe0->dvb.frontend->ops.set_voltage;
+                fe0->dvb.frontend->ops.set_voltage = p_set_voltage;
+
+                port->i2c_client_tuner = client_tuner;
+                break;
+        case CX23885_BOARD_DVBSKY_T982:
+                memset(&si2168_config, 0, sizeof(si2168_config));
+                switch (port->nr) {
+                /* port b */
+                case 1:
+                        i2c_bus = &dev->i2c_bus[1];
+                        si2168_config.ts_mode = SI2168_TS_PARALLEL;
+                        break;
+                /* port c */
+                case 2:
+                        i2c_bus = &dev->i2c_bus[0];
+                        si2168_config.ts_mode = SI2168_TS_SERIAL;
+                        break;
+                }
+
+                /* attach frontend */
+                si2168_config.i2c_adapter = &adapter;
+                si2168_config.fe = &fe0->dvb.frontend;
+                memset(&info, 0, sizeof(struct i2c_board_info));
+                strlcpy(info.type, "si2168", I2C_NAME_SIZE);
+                info.addr = 0x64;
+                info.platform_data = &si2168_config;
+                request_module(info.type);
+                client_demod = i2c_new_device(&i2c_bus->i2c_adap, &info);
+                if (client_demod == NULL ||
+                                client_demod->dev.driver == NULL)
+                        goto frontend_detach;
+                if (!try_module_get(client_demod->dev.driver->owner)) {
+                        i2c_unregister_device(client_demod);
+                        goto frontend_detach;
+                }
+                port->i2c_client_demod = client_demod;
+
+                /* attach tuner */
+                memset(&si2157_config, 0, sizeof(si2157_config));
+                si2157_config.fe = fe0->dvb.frontend;
+                memset(&info, 0, sizeof(struct i2c_board_info));
+                strlcpy(info.type, "si2157", I2C_NAME_SIZE);
+                info.addr = 0x60;
+                info.platform_data = &si2157_config;
+                request_module(info.type);
+                client_tuner = i2c_new_device(adapter, &info);
+                if (client_tuner == NULL ||
+                                client_tuner->dev.driver == NULL) {
+                        module_put(client_demod->dev.driver->owner);
+                        i2c_unregister_device(client_demod);
+                        goto frontend_detach;
+                }
+                if (!try_module_get(client_tuner->dev.driver->owner)) {
+                        i2c_unregister_device(client_tuner);
+                        module_put(client_demod->dev.driver->owner);
+                        i2c_unregister_device(client_demod);
+                        port->i2c_client_demod = NULL;
+                        goto frontend_detach;
+                }
+                port->i2c_client_tuner = client_tuner;
+                break;
         default:
                 printk(KERN_INFO "%s: The frontend of your DVB/ATSC card "
                         " isn't supported yet\n",
@@ -1754,7 +2074,10 @@ static int dvb_register(struct cx23885_tsport *port)
                 memcpy(port->frontends.adapter.proposed_mac, eeprom + 0xa0, 6);
                 break;
                 }
-        case CX23885_BOARD_DVBSKY_T9580: {
+        case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_S950:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982: {
                 u8 eeprom[256]; /* 24C02 i2c eeprom */
 
                 if (port->nr > 2)
@@ -1764,12 +2087,67 @@ static int dvb_register(struct cx23885_tsport *port)
                 dev->i2c_bus[0].i2c_client.addr = 0xa0 >> 1;
                 tveeprom_read(&dev->i2c_bus[0].i2c_client, eeprom,
                                 sizeof(eeprom));
-                printk(KERN_INFO "DVBSky T9580 port %d MAC address: %pM\n",
-                        port->nr, eeprom + 0xc0 + (port->nr-1) * 8);
+                printk(KERN_INFO "%s port %d MAC address: %pM\n",
+                        cx23885_boards[dev->board].name, port->nr,
+                        eeprom + 0xc0 + (port->nr-1) * 8);
                 memcpy(port->frontends.adapter.proposed_mac, eeprom + 0xc0 +
                         (port->nr-1) * 8, 6);
                 break;
                 }
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_TT_CT2_4500_CI: {
+                u8 eeprom[256]; /* 24C02 i2c eeprom */
+
+                /* attach CI */
+                memset(&sp2_config, 0, sizeof(sp2_config));
+                sp2_config.dvb_adap = &port->frontends.adapter;
+                sp2_config.priv = port;
+                sp2_config.ci_control = cx23885_sp2_ci_ctrl;
+                memset(&info, 0, sizeof(struct i2c_board_info));
+                strlcpy(info.type, "sp2", I2C_NAME_SIZE);
+                info.addr = 0x40;
+                info.platform_data = &sp2_config;
+                request_module(info.type);
+                client_ci = i2c_new_device(&i2c_bus2->i2c_adap, &info);
+                if (client_ci == NULL ||
+                                client_ci->dev.driver == NULL) {
+                        if (client_tuner) {
+                                module_put(client_tuner->dev.driver->owner);
+                                i2c_unregister_device(client_tuner);
+                        }
+                        if (client_demod) {
+                                module_put(client_demod->dev.driver->owner);
+                                i2c_unregister_device(client_demod);
+                        }
+                        goto frontend_detach;
+                }
+                if (!try_module_get(client_ci->dev.driver->owner)) {
+                        i2c_unregister_device(client_ci);
+                        if (client_tuner) {
+                                module_put(client_tuner->dev.driver->owner);
+                                i2c_unregister_device(client_tuner);
+                        }
+                        if (client_demod) {
+                                module_put(client_demod->dev.driver->owner);
+                                i2c_unregister_device(client_demod);
+                        }
+                        goto frontend_detach;
+                }
+                port->i2c_client_ci = client_ci;
+
+                if (port->nr != 1)
+                        break;
+
+                /* Read entire EEPROM */
+                dev->i2c_bus[0].i2c_client.addr = 0xa0 >> 1;
+                tveeprom_read(&dev->i2c_bus[0].i2c_client, eeprom,
+                                sizeof(eeprom));
+                printk(KERN_INFO "%s MAC address: %pM\n",
+                        cx23885_boards[dev->board].name, eeprom + 0xc0);
+                memcpy(port->frontends.adapter.proposed_mac, eeprom + 0xc0, 6);
+                break;
+                }
         }
 
         return ret;
@@ -1810,7 +2188,7 @@ int cx23885_dvb_register(struct cx23885_tsport *port)
 
                 fe0 = vb2_dvb_get_frontend(&port->frontends, i);
                 if (!fe0)
-                        err = -EINVAL;
+                        return -EINVAL;
 
                 dprintk(1, "%s\n", __func__);
                 dprintk(1, " ->probed by Card=%d Name=%s, PCI %02x:%02x\n",
@@ -1853,6 +2231,13 @@ int cx23885_dvb_unregister(struct cx23885_tsport *port)
         struct vb2_dvb_frontend *fe0;
         struct i2c_client *client;
 
+        /* remove I2C client for CI */
+        client = port->i2c_client_ci;
+        if (client) {
+                module_put(client->dev.driver->owner);
+                i2c_unregister_device(client);
+        }
+
         /* remove I2C client for tuner */
         client = port->i2c_client_tuner;
         if (client) {
diff --git a/drivers/media/pci/cx23885/cx23885-input.c b/drivers/media/pci/cx23885/cx23885-input.c
index 9d37fe661691..088799c3b49b 100644
--- a/drivers/media/pci/cx23885/cx23885-input.c
+++ b/drivers/media/pci/cx23885/cx23885-input.c
@@ -87,6 +87,13 @@ void cx23885_input_rx_work_handler(struct cx23885_dev *dev, u32 events)
         case CX23885_BOARD_MYGICA_X8507:
         case CX23885_BOARD_TBS_6980:
         case CX23885_BOARD_TBS_6981:
+        case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+        case CX23885_BOARD_DVBSKY_S950:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982:
                 /*
                  * The only boards we handle right now.  However other boards
                  * using the CX2388x integrated IR controller should be similar
@@ -139,6 +146,13 @@ static int cx23885_input_ir_start(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1290:
         case CX23885_BOARD_HAUPPAUGE_HVR1250:
         case CX23885_BOARD_MYGICA_X8507:
+        case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_TT_CT2_4500_CI:
+        case CX23885_BOARD_DVBSKY_S950:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982:
                 /*
                  * The IR controller on this board only returns pulse widths.
                  * Any other mode setting will fail to set up the device.
@@ -305,6 +319,23 @@ int cx23885_input_init(struct cx23885_dev *dev)
                 /* A guess at the remote */
                 rc_map = RC_MAP_TBS_NEC;
                 break;
+        case CX23885_BOARD_DVBSKY_T9580:
+        case CX23885_BOARD_DVBSKY_T980C:
+        case CX23885_BOARD_DVBSKY_S950C:
+        case CX23885_BOARD_DVBSKY_S950:
+        case CX23885_BOARD_DVBSKY_S952:
+        case CX23885_BOARD_DVBSKY_T982:
+                /* Integrated CX23885 IR controller */
+                driver_type = RC_DRIVER_IR_RAW;
+                allowed_protos = RC_BIT_ALL;
+                rc_map = RC_MAP_DVBSKY;
+                break;
+        case CX23885_BOARD_TT_CT2_4500_CI:
+                /* Integrated CX23885 IR controller */
+                driver_type = RC_DRIVER_IR_RAW;
+                allowed_protos = RC_BIT_ALL;
+                rc_map = RC_MAP_TT_1500;
+                break;
         default:
                 return -ENODEV;
         }
diff --git a/drivers/media/pci/cx23885/cx23885-vbi.c b/drivers/media/pci/cx23885/cx23885-vbi.c
index a7c6ef8f3ea3..d362d3838c84 100644
--- a/drivers/media/pci/cx23885/cx23885-vbi.c
+++ b/drivers/media/pci/cx23885/cx23885-vbi.c
@@ -132,6 +132,7 @@ static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
                 lines = VBI_NTSC_LINE_COUNT;
         *num_planes = 1;
         sizes[0] = lines * VBI_LINE_LENGTH * 2;
+        alloc_ctxs[0] = dev->alloc_ctx;
         return 0;
 }
 
@@ -142,7 +143,6 @@ static int buffer_prepare(struct vb2_buffer *vb)
                 struct cx23885_buffer, vb);
         struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
         unsigned lines = VBI_PAL_LINE_COUNT;
-        int ret;
 
         if (dev->tvnorm & V4L2_STD_525_60)
                 lines = VBI_NTSC_LINE_COUNT;
@@ -151,10 +151,6 @@ static int buffer_prepare(struct vb2_buffer *vb)
                 return -EINVAL;
         vb2_set_plane_payload(vb, 0, lines * VBI_LINE_LENGTH * 2);
 
-        ret = dma_map_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
-        if (!ret)
-                return -EIO;
-
         cx23885_risc_vbibuffer(dev->pci, &buf->risc,
                          sgt->sgl,
                          0, VBI_LINE_LENGTH * lines,
@@ -165,14 +161,10 @@ static int buffer_prepare(struct vb2_buffer *vb)
 
 static void buffer_finish(struct vb2_buffer *vb)
 {
-        struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
         struct cx23885_buffer *buf = container_of(vb,
                 struct cx23885_buffer, vb);
-        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
 
         cx23885_free_buffer(vb->vb2_queue->drv_priv, buf);
-
-        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
 /*
diff --git a/drivers/media/pci/cx23885/cx23885-video.c b/drivers/media/pci/cx23885/cx23885-video.c
index 682a4f95df6b..5e93c682a3f5 100644
--- a/drivers/media/pci/cx23885/cx23885-video.c
+++ b/drivers/media/pci/cx23885/cx23885-video.c
@@ -323,6 +323,7 @@ static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
 
         *num_planes = 1;
         sizes[0] = (dev->fmt->depth * dev->width * dev->height) >> 3;
+        alloc_ctxs[0] = dev->alloc_ctx;
         return 0;
 }
 
@@ -334,7 +335,6 @@ static int buffer_prepare(struct vb2_buffer *vb)
         u32 line0_offset, line1_offset;
         struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
         int field_tff;
-        int ret;
 
         buf->bpl = (dev->width * dev->fmt->depth) >> 3;
 
@@ -342,10 +342,6 @@ static int buffer_prepare(struct vb2_buffer *vb)
                 return -EINVAL;
         vb2_set_plane_payload(vb, 0, dev->height * buf->bpl);
 
-        ret = dma_map_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
-        if (!ret)
-                return -EIO;
-
         switch (dev->field) {
         case V4L2_FIELD_TOP:
                 cx23885_risc_buffer(dev->pci, &buf->risc,
@@ -413,14 +409,10 @@ static int buffer_prepare(struct vb2_buffer *vb)
 
 static void buffer_finish(struct vb2_buffer *vb)
 {
-        struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
         struct cx23885_buffer *buf = container_of(vb,
                 struct cx23885_buffer, vb);
-        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
 
         cx23885_free_buffer(vb->vb2_queue->drv_priv, buf);
-
-        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
 /*
@@ -608,7 +600,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
         dev->field      = f->fmt.pix.field;
         dprintk(2, "%s() width=%d height=%d field=%d\n", __func__,
                 dev->width, dev->height, dev->field);
-        v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, V4L2_MBUS_FMT_FIXED);
+        v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
         call_all(dev, video, s_mbus_fmt, &mbus_fmt);
         v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt);
         /* s_mbus_fmt overwrites f->fmt.pix.field, restore it */
diff --git a/drivers/media/pci/cx23885/cx23885.h b/drivers/media/pci/cx23885/cx23885.h
index 6c35e6115969..f55cd12da0fd 100644
--- a/drivers/media/pci/cx23885/cx23885.h
+++ b/drivers/media/pci/cx23885/cx23885.h
@@ -93,6 +93,12 @@
 #define CX23885_BOARD_HAUPPAUGE_IMPACTVCBE     43
 #define CX23885_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL_EXP2 44
 #define CX23885_BOARD_DVBSKY_T9580             45
+#define CX23885_BOARD_DVBSKY_T980C             46
+#define CX23885_BOARD_DVBSKY_S950C             47
+#define CX23885_BOARD_TT_CT2_4500_CI           48
+#define CX23885_BOARD_DVBSKY_S950              49
+#define CX23885_BOARD_DVBSKY_S952              50
+#define CX23885_BOARD_DVBSKY_T982              51
 
 #define GPIO_0 0x00000001
 #define GPIO_1 0x00000002
@@ -296,6 +302,7 @@ struct cx23885_tsport {
 
         struct i2c_client *i2c_client_demod;
         struct i2c_client *i2c_client_tuner;
+        struct i2c_client *i2c_client_ci;
 
         int (*set_frontend)(struct dvb_frontend *fe);
         int (*fe_set_voltage)(struct dvb_frontend *fe,
@@ -418,6 +425,7 @@ struct cx23885_dev {
         struct vb2_queue           vb2_vidq;
         struct cx23885_dmaqueue    vbiq;
         struct vb2_queue           vb2_vbiq;
+        void                       *alloc_ctx;
 
         spinlock_t                 slock;
 
diff --git a/drivers/media/pci/cx25821/cx25821-core.c b/drivers/media/pci/cx25821/cx25821-core.c
index e81173c41e5a..389fffd2f36f 100644
--- a/drivers/media/pci/cx25821/cx25821-core.c
+++ b/drivers/media/pci/cx25821/cx25821-core.c
@@ -996,7 +996,7 @@ static __le32 *cx25821_risc_field(__le32 * rp, struct scatterlist *sglist,
         for (line = 0; line < lines; line++) {
                 while (offset && offset >= sg_dma_len(sg)) {
                         offset -= sg_dma_len(sg);
-                        sg++;
+                        sg = sg_next(sg);
                 }
                 if (bpl <= sg_dma_len(sg) - offset) {
                         /* fits into current chunk */
@@ -1014,14 +1014,14 @@ static __le32 *cx25821_risc_field(__le32 * rp, struct scatterlist *sglist,
                         *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                         todo -= (sg_dma_len(sg) - offset);
                         offset = 0;
-                        sg++;
+                        sg = sg_next(sg);
                         while (todo > sg_dma_len(sg)) {
                                 *(rp++) = cpu_to_le32(RISC_WRITE |
                                                 sg_dma_len(sg));
                                 *(rp++) = cpu_to_le32(sg_dma_address(sg));
                                 *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                                 todo -= sg_dma_len(sg);
-                                sg++;
+                                sg = sg_next(sg);
                         }
                         *(rp++) = cpu_to_le32(RISC_WRITE | RISC_EOL | todo);
                         *(rp++) = cpu_to_le32(sg_dma_address(sg));
@@ -1101,7 +1101,7 @@ static __le32 *cx25821_risc_field_audio(__le32 * rp, struct scatterlist *sglist,
         for (line = 0; line < lines; line++) {
                 while (offset && offset >= sg_dma_len(sg)) {
                         offset -= sg_dma_len(sg);
-                        sg++;
+                        sg = sg_next(sg);
                 }
 
                 if (lpi && line > 0 && !(line % lpi))
@@ -1125,14 +1125,14 @@ static __le32 *cx25821_risc_field_audio(__le32 * rp, struct scatterlist *sglist,
                         *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                         todo -= (sg_dma_len(sg) - offset);
                         offset = 0;
-                        sg++;
+                        sg = sg_next(sg);
                         while (todo > sg_dma_len(sg)) {
                                 *(rp++) = cpu_to_le32(RISC_WRITE |
                                                 sg_dma_len(sg));
                                 *(rp++) = cpu_to_le32(sg_dma_address(sg));
                                 *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                                 todo -= sg_dma_len(sg);
-                                sg++;
+                                sg = sg_next(sg);
                         }
                         *(rp++) = cpu_to_le32(RISC_WRITE | RISC_EOL | todo);
                         *(rp++) = cpu_to_le32(sg_dma_address(sg));
diff --git a/drivers/media/pci/cx88/Kconfig b/drivers/media/pci/cx88/Kconfig
index a63a9ad163b2..14b813d634a8 100644
--- a/drivers/media/pci/cx88/Kconfig
+++ b/drivers/media/pci/cx88/Kconfig
@@ -2,8 +2,7 @@ config VIDEO_CX88
         tristate "Conexant 2388x (bt878 successor) support"
         depends on VIDEO_DEV && PCI && I2C && RC_CORE
         select I2C_ALGOBIT
-        select VIDEO_BTCX
-        select VIDEOBUF_DMA_SG
+        select VIDEOBUF2_DMA_SG
         select VIDEO_TUNER
         select VIDEO_TVEEPROM
         select VIDEO_WM8775 if MEDIA_SUBDRV_AUTOSELECT
@@ -45,7 +44,7 @@ config VIDEO_CX88_BLACKBIRD
 config VIDEO_CX88_DVB
         tristate "DVB/ATSC Support for cx2388x based TV cards"
         depends on VIDEO_CX88 && DVB_CORE
-        select VIDEOBUF_DVB
+        select VIDEOBUF2_DVB
         select DVB_PLL if MEDIA_SUBDRV_AUTOSELECT
         select DVB_MT352 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_ZL10353 if MEDIA_SUBDRV_AUTOSELECT
diff --git a/drivers/media/pci/cx88/Makefile b/drivers/media/pci/cx88/Makefile
index 8619c1becee2..d3679c3ee248 100644
--- a/drivers/media/pci/cx88/Makefile
+++ b/drivers/media/pci/cx88/Makefile
@@ -11,7 +11,6 @@ obj-$(CONFIG_VIDEO_CX88_DVB) += cx88-dvb.o
 obj-$(CONFIG_VIDEO_CX88_VP3054) += cx88-vp3054-i2c.o
 
 ccflags-y += -Idrivers/media/i2c
-ccflags-y += -Idrivers/media/common
 ccflags-y += -Idrivers/media/tuners
 ccflags-y += -Idrivers/media/dvb-core
 ccflags-y += -Idrivers/media/dvb-frontends
diff --git a/drivers/media/pci/cx88/cx88-alsa.c b/drivers/media/pci/cx88/cx88-alsa.c
index a72579a9f67f..7f8dc60028d5 100644
--- a/drivers/media/pci/cx88/cx88-alsa.c
+++ b/drivers/media/pci/cx88/cx88-alsa.c
@@ -61,8 +61,11 @@
 
 struct cx88_audio_buffer {
         unsigned int               bpl;
-        struct btcx_riscmem        risc;
-        struct videobuf_dmabuf     dma;
+        struct cx88_riscmem        risc;
+        void                    *vaddr;
+        struct scatterlist      *sglist;
+        int                     sglen;
+        int                     nr_pages;
 };
 
 struct cx88_audio_dev {
@@ -84,8 +87,6 @@ struct cx88_audio_dev {
         unsigned int               period_size;
         unsigned int               num_periods;
 
-        struct videobuf_dmabuf     *dma_risc;
-
         struct cx88_audio_buffer   *buf;
 
         struct snd_pcm_substream   *substream;
@@ -290,19 +291,97 @@ static irqreturn_t cx8801_irq(int irq, void *dev_id)
         return IRQ_RETVAL(handled);
 }
 
+static int cx88_alsa_dma_init(struct cx88_audio_dev *chip, int nr_pages)
+{
+        struct cx88_audio_buffer *buf = chip->buf;
+        struct page *pg;
+        int i;
+
+        buf->vaddr = vmalloc_32(nr_pages << PAGE_SHIFT);
+        if (NULL == buf->vaddr) {
+                dprintk(1, "vmalloc_32(%d pages) failed\n", nr_pages);
+                return -ENOMEM;
+        }
+
+        dprintk(1, "vmalloc is at addr 0x%08lx, size=%d\n",
+                                (unsigned long)buf->vaddr,
+                                nr_pages << PAGE_SHIFT);
+
+        memset(buf->vaddr, 0, nr_pages << PAGE_SHIFT);
+        buf->nr_pages = nr_pages;
+
+        buf->sglist = vzalloc(buf->nr_pages * sizeof(*buf->sglist));
+        if (NULL == buf->sglist)
+                goto vzalloc_err;
+
+        sg_init_table(buf->sglist, buf->nr_pages);
+        for (i = 0; i < buf->nr_pages; i++) {
+                pg = vmalloc_to_page(buf->vaddr + i * PAGE_SIZE);
+                if (NULL == pg)
+                        goto vmalloc_to_page_err;
+                sg_set_page(&buf->sglist[i], pg, PAGE_SIZE, 0);
+        }
+        return 0;
+
+vmalloc_to_page_err:
+        vfree(buf->sglist);
+        buf->sglist = NULL;
+vzalloc_err:
+        vfree(buf->vaddr);
+        buf->vaddr = NULL;
+        return -ENOMEM;
+}
+
+static int cx88_alsa_dma_map(struct cx88_audio_dev *dev)
+{
+        struct cx88_audio_buffer *buf = dev->buf;
+
+        buf->sglen = dma_map_sg(&dev->pci->dev, buf->sglist,
+                        buf->nr_pages, PCI_DMA_FROMDEVICE);
+
+        if (0 == buf->sglen) {
+                pr_warn("%s: cx88_alsa_map_sg failed\n", __func__);
+                return -ENOMEM;
+        }
+        return 0;
+}
+
+static int cx88_alsa_dma_unmap(struct cx88_audio_dev *dev)
+{
+        struct cx88_audio_buffer *buf = dev->buf;
+
+        if (!buf->sglen)
+                return 0;
+
+        dma_unmap_sg(&dev->pci->dev, buf->sglist, buf->sglen, PCI_DMA_FROMDEVICE);
+        buf->sglen = 0;
+        return 0;
+}
+
+static int cx88_alsa_dma_free(struct cx88_audio_buffer *buf)
+{
+        vfree(buf->sglist);
+        buf->sglist = NULL;
+        vfree(buf->vaddr);
+        buf->vaddr = NULL;
+        return 0;
+}
+
 
 static int dsp_buffer_free(snd_cx88_card_t *chip)
 {
+        struct cx88_riscmem *risc = &chip->buf->risc;
+
         BUG_ON(!chip->dma_size);
 
         dprintk(2,"Freeing buffer\n");
-        videobuf_dma_unmap(&chip->pci->dev, chip->dma_risc);
-        videobuf_dma_free(chip->dma_risc);
-        btcx_riscmem_free(chip->pci,&chip->buf->risc);
+        cx88_alsa_dma_unmap(chip);
+        cx88_alsa_dma_free(chip->buf);
+        if (risc->cpu)
+                pci_free_consistent(chip->pci, risc->size, risc->cpu, risc->dma);
         kfree(chip->buf);
 
-        chip->dma_risc = NULL;
-        chip->dma_size = 0;
+        chip->buf = NULL;
 
         return 0;
 }
@@ -387,7 +466,6 @@ static int snd_cx88_hw_params(struct snd_pcm_substream * substream,
                               struct snd_pcm_hw_params * hw_params)
 {
         snd_cx88_card_t *chip = snd_pcm_substream_chip(substream);
-        struct videobuf_dmabuf *dma;
 
         struct cx88_audio_buffer *buf;
         int ret;
@@ -408,20 +486,19 @@ static int snd_cx88_hw_params(struct snd_pcm_substream * substream,
         if (NULL == buf)
                 return -ENOMEM;
 
+        chip->buf = buf;
         buf->bpl = chip->period_size;
 
-        dma = &buf->dma;
-        videobuf_dma_init(dma);
-        ret = videobuf_dma_init_kernel(dma, PCI_DMA_FROMDEVICE,
+        ret = cx88_alsa_dma_init(chip,
                         (PAGE_ALIGN(chip->dma_size) >> PAGE_SHIFT));
         if (ret < 0)
                 goto error;
 
-        ret = videobuf_dma_map(&chip->pci->dev, dma);
+        ret = cx88_alsa_dma_map(chip);
         if (ret < 0)
                 goto error;
 
-        ret = cx88_risc_databuffer(chip->pci, &buf->risc, dma->sglist,
+        ret = cx88_risc_databuffer(chip->pci, &buf->risc, buf->sglist,
                                    chip->period_size, chip->num_periods, 1);
         if (ret < 0)
                 goto error;
@@ -430,10 +507,7 @@ static int snd_cx88_hw_params(struct snd_pcm_substream * substream,
         buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP|RISC_IRQ1|RISC_CNT_INC);
         buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 
-        chip->buf = buf;
-        chip->dma_risc = dma;
-
-        substream->runtime->dma_area = chip->dma_risc->vaddr;
+        substream->runtime->dma_area = chip->buf->vaddr;
         substream->runtime->dma_bytes = chip->dma_size;
         substream->runtime->dma_addr = 0;
         return 0;
diff --git a/drivers/media/pci/cx88/cx88-blackbird.c b/drivers/media/pci/cx88/cx88-blackbird.c
index 150bb76e7839..4160ca4e5413 100644
--- a/drivers/media/pci/cx88/cx88-blackbird.c
+++ b/drivers/media/pci/cx88/cx88-blackbird.c
@@ -45,10 +45,6 @@ MODULE_AUTHOR("Jelle Foks <jelle@foks.us>, Gerd Knorr <kraxel@bytesex.org> [SuSE
 MODULE_LICENSE("GPL");
 MODULE_VERSION(CX88_VERSION);
 
-static unsigned int mpegbufs = 32;
-module_param(mpegbufs,int,0644);
-MODULE_PARM_DESC(mpegbufs,"number of mpeg buffers, range 2-32");
-
 static unsigned int debug;
 module_param(debug,int,0644);
 MODULE_PARM_DESC(debug,"enable debug messages [blackbird]");
@@ -326,13 +322,13 @@ static int blackbird_mbox_func(void *priv, u32 command, int in, int out, u32 dat
         memory_read(dev->core, dev->mailbox - 4, &value);
         if (value != 0x12345678) {
                 dprintk(0, "Firmware and/or mailbox pointer not initialized or corrupted\n");
-                return -1;
+                return -EIO;
         }
 
         memory_read(dev->core, dev->mailbox, &flag);
         if (flag) {
                 dprintk(0, "ERROR: Mailbox appears to be in use (%x)\n", flag);
-                return -1;
+                return -EIO;
         }
 
         flag |= 1; /* tell 'em we're working on it */
@@ -352,14 +348,14 @@ static int blackbird_mbox_func(void *priv, u32 command, int in, int out, u32 dat
         memory_write(dev->core, dev->mailbox, flag);
 
         /* wait for firmware to handle the API command */
-        timeout = jiffies + msecs_to_jiffies(10);
+        timeout = jiffies + msecs_to_jiffies(1000);
         for (;;) {
                 memory_read(dev->core, dev->mailbox, &flag);
                 if (0 != (flag & 4))
                         break;
                 if (time_after(jiffies,timeout)) {
-                        dprintk(0, "ERROR: API Mailbox timeout\n");
-                        return -1;
+                        dprintk(0, "ERROR: API Mailbox timeout %x\n", command);
+                        return -EIO;
                 }
                 udelay(10);
         }
@@ -420,7 +416,7 @@ static int blackbird_find_mailbox(struct cx8802_dev *dev)
                 }
         }
         dprintk(0, "Mailbox signature values not found!\n");
-        return -1;
+        return -EIO;
 }
 
 static int blackbird_load_firmware(struct cx8802_dev *dev)
@@ -432,7 +428,7 @@ static int blackbird_load_firmware(struct cx8802_dev *dev)
         int i, retval = 0;
         u32 value = 0;
         u32 checksum = 0;
-        u32 *dataptr;
+        __le32 *dataptr;
 
         retval  = register_write(dev->core, IVTV_REG_VPU, 0xFFFFFFED);
         retval |= register_write(dev->core, IVTV_REG_HW_BLOCKS, IVTV_CMD_HW_BLOCKS_RST);
@@ -449,29 +445,28 @@ static int blackbird_load_firmware(struct cx8802_dev *dev)
 
 
         if (retval != 0) {
-                dprintk(0, "ERROR: Hotplug firmware request failed (%s).\n",
+                pr_err("Hotplug firmware request failed (%s).\n",
                         CX2341X_FIRM_ENC_FILENAME);
-                dprintk(0, "Please fix your hotplug setup, the board will "
-                        "not work without firmware loaded!\n");
-                return -1;
+                pr_err("Please fix your hotplug setup, the board will not work without firmware loaded!\n");
+                return -EIO;
         }
 
         if (firmware->size != BLACKBIRD_FIRM_IMAGE_SIZE) {
-                dprintk(0, "ERROR: Firmware size mismatch (have %zd, expected %d)\n",
+                pr_err("Firmware size mismatch (have %zd, expected %d)\n",
                         firmware->size, BLACKBIRD_FIRM_IMAGE_SIZE);
                 release_firmware(firmware);
-                return -1;
+                return -EINVAL;
         }
 
         if (0 != memcmp(firmware->data, magic, 8)) {
-                dprintk(0, "ERROR: Firmware magic mismatch, wrong file?\n");
+                pr_err("Firmware magic mismatch, wrong file?\n");
                 release_firmware(firmware);
-                return -1;
+                return -EINVAL;
         }
 
         /* transfer to the chip */
         dprintk(1,"Loading firmware ...\n");
-        dataptr = (u32*)firmware->data;
+        dataptr = (__le32 *)firmware->data;
         for (i = 0; i < (firmware->size >> 2); i++) {
                 value = le32_to_cpu(*dataptr);
                 checksum += ~value;
@@ -484,12 +479,11 @@ static int blackbird_load_firmware(struct cx8802_dev *dev)
                 memory_read(dev->core, i, &value);
                 checksum -= ~value;
         }
+        release_firmware(firmware);
         if (checksum) {
-                dprintk(0, "ERROR: Firmware load failed (checksum mismatch).\n");
-                release_firmware(firmware);
-                return -1;
+                pr_err("Firmware load might have failed (checksum mismatch).\n");
+                return -EIO;
         }
-        release_firmware(firmware);
         dprintk(0, "Firmware upload successful.\n");
 
         retval |= register_write(dev->core, IVTV_REG_HW_BLOCKS, IVTV_CMD_HW_BLOCKS_RST);
@@ -521,12 +515,14 @@ DB* DVD | MPEG2 | 720x576PAL | CBR     | 600 :Good    | 6000 Kbps  | 25fps   | M
 
 static void blackbird_codec_settings(struct cx8802_dev *dev)
 {
+        struct cx88_core *core = dev->core;
+
         /* assign frame size */
         blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
-                                dev->height, dev->width);
+                                core->height, core->width);
 
-        dev->cxhdl.width = dev->width;
-        dev->cxhdl.height = dev->height;
+        dev->cxhdl.width = core->width;
+        dev->cxhdl.height = core->height;
         cx2341x_handler_set_50hz(&dev->cxhdl, dev->core->tvnorm & V4L2_STD_625_50);
         cx2341x_handler_setup(&dev->cxhdl);
 }
@@ -540,9 +536,6 @@ static int blackbird_initialize_codec(struct cx8802_dev *dev)
         dprintk(1,"Initialize codec\n");
         retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
         if (retval < 0) {
-
-                dev->mpeg_active = 0;
-
                 /* ping was not successful, reset and upload firmware */
                 cx_write(MO_SRST_IO, 0); /* SYS_RSTO=0 */
                 cx_write(MO_SRST_IO, 1); /* SYS_RSTO=1 */
@@ -589,9 +582,8 @@ static int blackbird_initialize_codec(struct cx8802_dev *dev)
         return 0;
 }
 
-static int blackbird_start_codec(struct file *file, void *priv)
+static int blackbird_start_codec(struct cx8802_dev *dev)
 {
-        struct cx8802_dev *dev  = ((struct cx8802_fh *)priv)->dev;
         struct cx88_core *core = dev->core;
         /* start capturing to the host interface */
         u32 reg;
@@ -627,7 +619,6 @@ static int blackbird_start_codec(struct file *file, void *priv)
                         BLACKBIRD_RAW_BITS_NONE
                 );
 
-        dev->mpeg_active = 1;
         return 0;
 }
 
@@ -641,51 +632,139 @@ static int blackbird_stop_codec(struct cx8802_dev *dev)
 
         cx2341x_handler_set_busy(&dev->cxhdl, 0);
 
-        dev->mpeg_active = 0;
         return 0;
 }
 
 /* ------------------------------------------------------------------ */
 
-static int bb_buf_setup(struct videobuf_queue *q,
-                        unsigned int *count, unsigned int *size)
+static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
+                           unsigned int *num_buffers, unsigned int *num_planes,
+                           unsigned int sizes[], void *alloc_ctxs[])
 {
-        struct cx8802_fh *fh = q->priv_data;
-
-        fh->dev->ts_packet_size  = 188 * 4; /* was: 512 */
-        fh->dev->ts_packet_count = mpegbufs; /* was: 100 */
+        struct cx8802_dev *dev = q->drv_priv;
 
-        *size = fh->dev->ts_packet_size * fh->dev->ts_packet_count;
-        *count = fh->dev->ts_packet_count;
+        *num_planes = 1;
+        dev->ts_packet_size  = 188 * 4;
+        dev->ts_packet_count  = 32;
+        sizes[0] = dev->ts_packet_size * dev->ts_packet_count;
         return 0;
 }
 
-static int
-bb_buf_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
-               enum v4l2_field field)
+static int buffer_prepare(struct vb2_buffer *vb)
 {
-        struct cx8802_fh *fh = q->priv_data;
-        return cx8802_buf_prepare(q, fh->dev, (struct cx88_buffer*)vb, field);
+        struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
+
+        return cx8802_buf_prepare(vb->vb2_queue, dev, buf);
 }
 
-static void
-bb_buf_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
+static void buffer_finish(struct vb2_buffer *vb)
 {
-        struct cx8802_fh *fh = q->priv_data;
-        cx8802_buf_queue(fh->dev, (struct cx88_buffer*)vb);
+        struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
+        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+        struct cx88_riscmem *risc = &buf->risc;
+
+        if (risc->cpu)
+                pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+        memset(risc, 0, sizeof(*risc));
+
+        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
-static void
-bb_buf_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
+static void buffer_queue(struct vb2_buffer *vb)
 {
-        cx88_free_buffer(q, (struct cx88_buffer*)vb);
+        struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer    *buf = container_of(vb, struct cx88_buffer, vb);
+
+        cx8802_buf_queue(dev, buf);
+}
+
+static int start_streaming(struct vb2_queue *q, unsigned int count)
+{
+        struct cx8802_dev *dev = q->drv_priv;
+        struct cx88_dmaqueue *dmaq = &dev->mpegq;
+        struct cx8802_driver *drv;
+        struct cx88_buffer *buf;
+        unsigned long flags;
+        int err;
+
+        /* Make sure we can acquire the hardware */
+        drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
+        if (!drv) {
+                dprintk(1, "%s: blackbird driver is not loaded\n", __func__);
+                err = -ENODEV;
+                goto fail;
+        }
+
+        err = drv->request_acquire(drv);
+        if (err != 0) {
+                dprintk(1, "%s: Unable to acquire hardware, %d\n", __func__, err);
+                goto fail;
+        }
+
+        if (blackbird_initialize_codec(dev) < 0) {
+                drv->request_release(drv);
+                err = -EINVAL;
+                goto fail;
+        }
+
+        err = blackbird_start_codec(dev);
+        if (err == 0) {
+                buf = list_entry(dmaq->active.next, struct cx88_buffer, list);
+                cx8802_start_dma(dev, dmaq, buf);
+                return 0;
+        }
+
+fail:
+        spin_lock_irqsave(&dev->slock, flags);
+        while (!list_empty(&dmaq->active)) {
+                struct cx88_buffer *buf = list_entry(dmaq->active.next,
+                        struct cx88_buffer, list);
+
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_QUEUED);
+        }
+        spin_unlock_irqrestore(&dev->slock, flags);
+        return err;
 }
 
-static struct videobuf_queue_ops blackbird_qops = {
-        .buf_setup    = bb_buf_setup,
-        .buf_prepare  = bb_buf_prepare,
-        .buf_queue    = bb_buf_queue,
-        .buf_release  = bb_buf_release,
+static void stop_streaming(struct vb2_queue *q)
+{
+        struct cx8802_dev *dev = q->drv_priv;
+        struct cx88_dmaqueue *dmaq = &dev->mpegq;
+        struct cx8802_driver *drv = NULL;
+        unsigned long flags;
+
+        cx8802_cancel_buffers(dev);
+        blackbird_stop_codec(dev);
+
+        /* Make sure we release the hardware */
+        drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
+        WARN_ON(!drv);
+        if (drv)
+                drv->request_release(drv);
+
+        spin_lock_irqsave(&dev->slock, flags);
+        while (!list_empty(&dmaq->active)) {
+                struct cx88_buffer *buf = list_entry(dmaq->active.next,
+                        struct cx88_buffer, list);
+
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+        }
+        spin_unlock_irqrestore(&dev->slock, flags);
+}
+
+static struct vb2_ops blackbird_qops = {
+        .queue_setup    = queue_setup,
+        .buf_prepare  = buffer_prepare,
+        .buf_finish = buffer_finish,
+        .buf_queue    = buffer_queue,
+        .wait_prepare = vb2_ops_wait_prepare,
+        .wait_finish = vb2_ops_wait_finish,
+        .start_streaming = start_streaming,
+        .stop_streaming = stop_streaming,
 };
 
 /* ------------------------------------------------------------------ */
@@ -693,8 +772,8 @@ static struct videobuf_queue_ops blackbird_qops = {
 static int vidioc_querycap(struct file *file, void  *priv,
                                         struct v4l2_capability *cap)
 {
-        struct cx8802_dev *dev  = ((struct cx8802_fh *)priv)->dev;
-        struct cx88_core  *core = dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         strcpy(cap->driver, "cx88_blackbird");
         sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
@@ -714,131 +793,111 @@ static int vidioc_enum_fmt_vid_cap (struct file *file, void  *priv,
         return 0;
 }
 
-static int vidioc_g_fmt_vid_cap (struct file *file, void *priv,
+static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                         struct v4l2_format *f)
 {
-        struct cx8802_fh  *fh   = priv;
-        struct cx8802_dev *dev  = fh->dev;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
         f->fmt.pix.bytesperline = 0;
-        f->fmt.pix.sizeimage    = 188 * 4 * mpegbufs; /* 188 * 4 * 1024; */
+        f->fmt.pix.sizeimage    = dev->ts_packet_size * dev->ts_packet_count;
         f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
-        f->fmt.pix.width        = dev->width;
-        f->fmt.pix.height       = dev->height;
-        f->fmt.pix.field        = fh->mpegq.field;
-        dprintk(1, "VIDIOC_G_FMT: w: %d, h: %d, f: %d\n",
-                dev->width, dev->height, fh->mpegq.field );
+        f->fmt.pix.width        = core->width;
+        f->fmt.pix.height       = core->height;
+        f->fmt.pix.field        = core->field;
         return 0;
 }
 
-static int vidioc_try_fmt_vid_cap (struct file *file, void *priv,
+static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                         struct v4l2_format *f)
 {
-        struct cx8802_fh  *fh   = priv;
-        struct cx8802_dev *dev  = fh->dev;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
+        unsigned maxw, maxh;
+        enum v4l2_field field;
 
         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
         f->fmt.pix.bytesperline = 0;
-        f->fmt.pix.sizeimage    = 188 * 4 * mpegbufs; /* 188 * 4 * 1024; */
+        f->fmt.pix.sizeimage    = dev->ts_packet_size * dev->ts_packet_count;
         f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
-        dprintk(1, "VIDIOC_TRY_FMT: w: %d, h: %d, f: %d\n",
-                dev->width, dev->height, fh->mpegq.field );
+
+        maxw = norm_maxw(core->tvnorm);
+        maxh = norm_maxh(core->tvnorm);
+
+        field = f->fmt.pix.field;
+
+        switch (field) {
+        case V4L2_FIELD_TOP:
+        case V4L2_FIELD_BOTTOM:
+        case V4L2_FIELD_INTERLACED:
+        case V4L2_FIELD_SEQ_BT:
+        case V4L2_FIELD_SEQ_TB:
+                break;
+        default:
+                field = (f->fmt.pix.height > maxh / 2)
+                        ? V4L2_FIELD_INTERLACED
+                        : V4L2_FIELD_BOTTOM;
+                break;
+        }
+        if (V4L2_FIELD_HAS_T_OR_B(field))
+                maxh /= 2;
+
+        v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
+                              &f->fmt.pix.height, 32, maxh, 0, 0);
+        f->fmt.pix.field = field;
         return 0;
 }
 
-static int vidioc_s_fmt_vid_cap (struct file *file, void *priv,
+static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                                         struct v4l2_format *f)
 {
-        struct cx8802_fh  *fh   = priv;
-        struct cx8802_dev *dev  = fh->dev;
+        struct cx8802_dev *dev = video_drvdata(file);
         struct cx88_core  *core = dev->core;
 
-        f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
-        f->fmt.pix.bytesperline = 0;
-        f->fmt.pix.sizeimage    = 188 * 4 * mpegbufs; /* 188 * 4 * 1024; */
-        f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
-        dev->width              = f->fmt.pix.width;
-        dev->height             = f->fmt.pix.height;
-        fh->mpegq.field         = f->fmt.pix.field;
+        if (vb2_is_busy(&dev->vb2_mpegq))
+                return -EBUSY;
+        if (core->v4ldev && (vb2_is_busy(&core->v4ldev->vb2_vidq) ||
+                             vb2_is_busy(&core->v4ldev->vb2_vbiq)))
+                return -EBUSY;
+        vidioc_try_fmt_vid_cap(file, priv, f);
+        core->width = f->fmt.pix.width;
+        core->height = f->fmt.pix.height;
+        core->field = f->fmt.pix.field;
         cx88_set_scale(core, f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
         blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
                                 f->fmt.pix.height, f->fmt.pix.width);
-        dprintk(1, "VIDIOC_S_FMT: w: %d, h: %d, f: %d\n",
-                f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field );
         return 0;
 }
 
-static int vidioc_reqbufs (struct file *file, void *priv, struct v4l2_requestbuffers *p)
-{
-        struct cx8802_fh  *fh   = priv;
-        return (videobuf_reqbufs(&fh->mpegq, p));
-}
-
-static int vidioc_querybuf (struct file *file, void *priv, struct v4l2_buffer *p)
-{
-        struct cx8802_fh  *fh   = priv;
-        return (videobuf_querybuf(&fh->mpegq, p));
-}
-
-static int vidioc_qbuf (struct file *file, void *priv, struct v4l2_buffer *p)
-{
-        struct cx8802_fh  *fh   = priv;
-        return (videobuf_qbuf(&fh->mpegq, p));
-}
-
-static int vidioc_dqbuf (struct file *file, void *priv, struct v4l2_buffer *p)
-{
-        struct cx8802_fh  *fh   = priv;
-        return (videobuf_dqbuf(&fh->mpegq, p,
-                                file->f_flags & O_NONBLOCK));
-}
-
-static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
-{
-        struct cx8802_fh  *fh   = priv;
-        struct cx8802_dev *dev  = fh->dev;
-
-        if (!dev->mpeg_active)
-                blackbird_start_codec(file, fh);
-        return videobuf_streamon(&fh->mpegq);
-}
-
-static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
-{
-        struct cx8802_fh  *fh   = priv;
-        struct cx8802_dev *dev  = fh->dev;
-
-        if (dev->mpeg_active)
-                blackbird_stop_codec(dev);
-        return videobuf_streamoff(&fh->mpegq);
-}
-
 static int vidioc_s_frequency (struct file *file, void *priv,
                                 const struct v4l2_frequency *f)
 {
-        struct cx8802_fh  *fh   = priv;
-        struct cx8802_dev *dev  = fh->dev;
-        struct cx88_core  *core = dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
+        bool streaming;
 
         if (unlikely(UNSET == core->board.tuner_type))
                 return -EINVAL;
         if (unlikely(f->tuner != 0))
                 return -EINVAL;
-        if (dev->mpeg_active)
+        streaming = vb2_start_streaming_called(&dev->vb2_mpegq);
+        if (streaming)
                 blackbird_stop_codec(dev);
 
         cx88_set_freq (core,f);
         blackbird_initialize_codec(dev);
-        cx88_set_scale(dev->core, dev->width, dev->height,
-                        fh->mpegq.field);
+        cx88_set_scale(core, core->width, core->height,
+                        core->field);
+        if (streaming)
+                blackbird_start_codec(dev);
         return 0;
 }
 
 static int vidioc_log_status (struct file *file, void *priv)
 {
-        struct cx8802_dev *dev  = ((struct cx8802_fh *)priv)->dev;
-        struct cx88_core  *core = dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
         char name[32 + 2];
 
         snprintf(name, sizeof(name), "%s/2", core->name);
@@ -850,15 +909,16 @@ static int vidioc_log_status (struct file *file, void *priv)
 static int vidioc_enum_input (struct file *file, void *priv,
                                 struct v4l2_input *i)
 {
-        struct cx88_core  *core = ((struct cx8802_fh *)priv)->dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
         return cx88_enum_input (core,i);
 }
 
 static int vidioc_g_frequency (struct file *file, void *priv,
                                 struct v4l2_frequency *f)
 {
-        struct cx8802_fh  *fh   = priv;
-        struct cx88_core  *core = fh->dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         if (unlikely(UNSET == core->board.tuner_type))
                 return -EINVAL;
@@ -873,7 +933,8 @@ static int vidioc_g_frequency (struct file *file, void *priv,
 
 static int vidioc_g_input (struct file *file, void *priv, unsigned int *i)
 {
-        struct cx88_core  *core = ((struct cx8802_fh *)priv)->dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         *i = core->input;
         return 0;
@@ -881,24 +942,24 @@ static int vidioc_g_input (struct file *file, void *priv, unsigned int *i)
 
 static int vidioc_s_input (struct file *file, void *priv, unsigned int i)
 {
-        struct cx88_core  *core = ((struct cx8802_fh *)priv)->dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         if (i >= 4)
                 return -EINVAL;
         if (0 == INPUT(i).type)
                 return -EINVAL;
 
-        mutex_lock(&core->lock);
         cx88_newstation(core);
         cx88_video_mux(core,i);
-        mutex_unlock(&core->lock);
         return 0;
 }
 
 static int vidioc_g_tuner (struct file *file, void *priv,
                                 struct v4l2_tuner *t)
 {
-        struct cx88_core  *core = ((struct cx8802_fh *)priv)->dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
         u32 reg;
 
         if (unlikely(UNSET == core->board.tuner_type))
@@ -920,7 +981,8 @@ static int vidioc_g_tuner (struct file *file, void *priv,
 static int vidioc_s_tuner (struct file *file, void *priv,
                                 const struct v4l2_tuner *t)
 {
-        struct cx88_core  *core = ((struct cx8802_fh *)priv)->dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         if (UNSET == core->board.tuner_type)
                 return -EINVAL;
@@ -933,7 +995,8 @@ static int vidioc_s_tuner (struct file *file, void *priv,
 
 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm)
 {
-        struct cx88_core *core = ((struct cx8802_fh *)priv)->dev->core;
+        struct cx8802_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         *tvnorm = core->tvnorm;
         return 0;
@@ -941,155 +1004,20 @@ static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm)
 
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
 {
-        struct cx88_core  *core = ((struct cx8802_fh *)priv)->dev->core;
-
-        mutex_lock(&core->lock);
-        cx88_set_tvnorm(core, id);
-        mutex_unlock(&core->lock);
-        return 0;
-}
-
-/* FIXME: cx88_ioctl_hook not implemented */
-
-static int mpeg_open(struct file *file)
-{
-        struct video_device *vdev = video_devdata(file);
         struct cx8802_dev *dev = video_drvdata(file);
-        struct cx8802_fh *fh;
-        struct cx8802_driver *drv = NULL;
-        int err;
-
-        dprintk( 1, "%s\n", __func__);
-
-        mutex_lock(&dev->core->lock);
-
-        /* Make sure we can acquire the hardware */
-        drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
-        if (!drv) {
-                dprintk(1, "%s: blackbird driver is not loaded\n", __func__);
-                mutex_unlock(&dev->core->lock);
-                return -ENODEV;
-        }
-
-        err = drv->request_acquire(drv);
-        if (err != 0) {
-                dprintk(1,"%s: Unable to acquire hardware, %d\n", __func__, err);
-                mutex_unlock(&dev->core->lock);
-                return err;
-        }
-
-        if (!dev->core->mpeg_users && blackbird_initialize_codec(dev) < 0) {
-                drv->request_release(drv);
-                mutex_unlock(&dev->core->lock);
-                return -EINVAL;
-        }
-        dprintk(1, "open dev=%s\n", video_device_node_name(vdev));
-
-        /* allocate + initialize per filehandle data */
-        fh = kzalloc(sizeof(*fh),GFP_KERNEL);
-        if (NULL == fh) {
-                drv->request_release(drv);
-                mutex_unlock(&dev->core->lock);
-                return -ENOMEM;
-        }
-        v4l2_fh_init(&fh->fh, vdev);
-        file->private_data = fh;
-        fh->dev      = dev;
-
-        videobuf_queue_sg_init(&fh->mpegq, &blackbird_qops,
-                            &dev->pci->dev, &dev->slock,
-                            V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                            V4L2_FIELD_INTERLACED,
-                            sizeof(struct cx88_buffer),
-                            fh, NULL);
-
-        /* FIXME: locking against other video device */
-        cx88_set_scale(dev->core, dev->width, dev->height,
-                        fh->mpegq.field);
-
-        dev->core->mpeg_users++;
-        mutex_unlock(&dev->core->lock);
-        v4l2_fh_add(&fh->fh);
-        return 0;
-}
-
-static int mpeg_release(struct file *file)
-{
-        struct cx8802_fh  *fh  = file->private_data;
-        struct cx8802_dev *dev = fh->dev;
-        struct cx8802_driver *drv = NULL;
-
-        mutex_lock(&dev->core->lock);
-
-        if (dev->mpeg_active && dev->core->mpeg_users == 1)
-                blackbird_stop_codec(dev);
-
-        cx8802_cancel_buffers(fh->dev);
-        /* stop mpeg capture */
-        videobuf_stop(&fh->mpegq);
-
-        videobuf_mmap_free(&fh->mpegq);
-
-        v4l2_fh_del(&fh->fh);
-        v4l2_fh_exit(&fh->fh);
-        file->private_data = NULL;
-        kfree(fh);
-
-        /* Make sure we release the hardware */
-        drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
-        WARN_ON(!drv);
-        if (drv)
-                drv->request_release(drv);
-
-        dev->core->mpeg_users--;
-
-        mutex_unlock(&dev->core->lock);
-
-        return 0;
-}
-
-static ssize_t
-mpeg_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
-{
-        struct cx8802_fh *fh = file->private_data;
-        struct cx8802_dev *dev = fh->dev;
-
-        if (!dev->mpeg_active)
-                blackbird_start_codec(file, fh);
-
-        return videobuf_read_stream(&fh->mpegq, data, count, ppos, 0,
-                                    file->f_flags & O_NONBLOCK);
-}
-
-static unsigned int
-mpeg_poll(struct file *file, struct poll_table_struct *wait)
-{
-        unsigned long req_events = poll_requested_events(wait);
-        struct cx8802_fh *fh = file->private_data;
-        struct cx8802_dev *dev = fh->dev;
-
-        if (!dev->mpeg_active && (req_events & (POLLIN | POLLRDNORM)))
-                blackbird_start_codec(file, fh);
-
-        return v4l2_ctrl_poll(file, wait) | videobuf_poll_stream(file, &fh->mpegq, wait);
-}
-
-static int
-mpeg_mmap(struct file *file, struct vm_area_struct * vma)
-{
-        struct cx8802_fh *fh = file->private_data;
+        struct cx88_core *core = dev->core;
 
-        return videobuf_mmap_mapper(&fh->mpegq, vma);
+        return cx88_set_tvnorm(core, id);
 }
 
 static const struct v4l2_file_operations mpeg_fops =
 {
         .owner         = THIS_MODULE,
-        .open          = mpeg_open,
-        .release       = mpeg_release,
-        .read          = mpeg_read,
-        .poll          = mpeg_poll,
-        .mmap          = mpeg_mmap,
+        .open          = v4l2_fh_open,
+        .release       = vb2_fop_release,
+        .read          = vb2_fop_read,
+        .poll          = vb2_fop_poll,
+        .mmap          = vb2_fop_mmap,
         .unlocked_ioctl = video_ioctl2,
 };
 
@@ -1099,12 +1027,12 @@ static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
-        .vidioc_reqbufs       = vidioc_reqbufs,
-        .vidioc_querybuf      = vidioc_querybuf,
-        .vidioc_qbuf          = vidioc_qbuf,
-        .vidioc_dqbuf         = vidioc_dqbuf,
-        .vidioc_streamon      = vidioc_streamon,
-        .vidioc_streamoff     = vidioc_streamoff,
+        .vidioc_reqbufs       = vb2_ioctl_reqbufs,
+        .vidioc_querybuf      = vb2_ioctl_querybuf,
+        .vidioc_qbuf          = vb2_ioctl_qbuf,
+        .vidioc_dqbuf         = vb2_ioctl_dqbuf,
+        .vidioc_streamon      = vb2_ioctl_streamon,
+        .vidioc_streamoff     = vb2_ioctl_streamoff,
         .vidioc_s_frequency   = vidioc_s_frequency,
         .vidioc_log_status    = vidioc_log_status,
         .vidioc_enum_input    = vidioc_enum_input,
@@ -1189,11 +1117,12 @@ static int blackbird_register_video(struct cx8802_dev *dev)
 {
         int err;
 
-        dev->mpeg_dev = cx88_vdev_init(dev->core,dev->pci,
-                                       &cx8802_mpeg_template,"mpeg");
+        dev->mpeg_dev = cx88_vdev_init(dev->core, dev->pci,
+                                       &cx8802_mpeg_template, "mpeg");
         dev->mpeg_dev->ctrl_handler = &dev->cxhdl.hdl;
         video_set_drvdata(dev->mpeg_dev, dev);
-        err = video_register_device(dev->mpeg_dev,VFL_TYPE_GRABBER, -1);
+        dev->mpeg_dev->queue = &dev->vb2_mpegq;
+        err = video_register_device(dev->mpeg_dev, VFL_TYPE_GRABBER, -1);
         if (err < 0) {
                 printk(KERN_INFO "%s/2: can't register mpeg device\n",
                        dev->core->name);
@@ -1210,6 +1139,7 @@ static int cx8802_blackbird_probe(struct cx8802_driver *drv)
 {
         struct cx88_core *core = drv->core;
         struct cx8802_dev *dev = core->dvbdev;
+        struct vb2_queue *q;
         int err;
 
         dprintk( 1, "%s\n", __func__);
@@ -1223,15 +1153,9 @@ static int cx8802_blackbird_probe(struct cx8802_driver *drv)
         if (!(core->board.mpeg & CX88_MPEG_BLACKBIRD))
                 goto fail_core;
 
-        dev->width = 720;
-        if (core->tvnorm & V4L2_STD_525_60) {
-                dev->height = 480;
-        } else {
-                dev->height = 576;
-        }
         dev->cxhdl.port = CX2341X_PORT_STREAMING;
-        dev->cxhdl.width = dev->width;
-        dev->cxhdl.height = dev->height;
+        dev->cxhdl.width = core->width;
+        dev->cxhdl.height = core->height;
         dev->cxhdl.func = blackbird_mbox_func;
         dev->cxhdl.priv = dev;
         err = cx2341x_handler_init(&dev->cxhdl, 36);
@@ -1250,13 +1174,30 @@ static int cx8802_blackbird_probe(struct cx8802_driver *drv)
 //      init_controls(core);
         cx88_set_tvnorm(core,core->tvnorm);
         cx88_video_mux(core,0);
-        cx2341x_handler_set_50hz(&dev->cxhdl, dev->height == 576);
+        cx2341x_handler_set_50hz(&dev->cxhdl, core->height == 576);
         cx2341x_handler_setup(&dev->cxhdl);
+
+        q = &dev->vb2_mpegq;
+        q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
+        q->gfp_flags = GFP_DMA32;
+        q->min_buffers_needed = 2;
+        q->drv_priv = dev;
+        q->buf_struct_size = sizeof(struct cx88_buffer);
+        q->ops = &blackbird_qops;
+        q->mem_ops = &vb2_dma_sg_memops;
+        q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+        q->lock = &core->lock;
+
+        err = vb2_queue_init(q);
+        if (err < 0)
+                goto fail_core;
+
         blackbird_register_video(dev);
 
         return 0;
 
- fail_core:
+fail_core:
         return err;
 }
 
diff --git a/drivers/media/pci/cx88/cx88-cards.c b/drivers/media/pci/cx88/cx88-cards.c
index 851754bf1291..8f2556ec3971 100644
--- a/drivers/media/pci/cx88/cx88-cards.c
+++ b/drivers/media/pci/cx88/cx88-cards.c
@@ -347,7 +347,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_IODATA_GVVCP3PCI] = {
                 .name           = "IODATA GV-VCP3/PCI",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -436,7 +436,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_KWORLD_DVB_T] = {
                 .name           = "KWorld/VStream XPert DVB-T",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -455,7 +455,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1] = {
                 .name           = "DViCO FusionHDTV DVB-T1",
-                .tuner_type     = TUNER_ABSENT, /* No analog tuner */
+                .tuner_type     = UNSET, /* No analog tuner */
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -542,7 +542,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_HAUPPAUGE_DVB_T1] = {
                 .name           = "Hauppauge Nova-T DVB-T",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -554,7 +554,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_CONEXANT_DVB_T1] = {
                 .name           = "Conexant DVB-T reference design",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -579,7 +579,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS] = {
                 .name           = "DViCO FusionHDTV DVB-T Plus",
-                .tuner_type     = TUNER_ABSENT, /* No analog tuner */
+                .tuner_type     = UNSET, /* No analog tuner */
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -596,7 +596,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_DNTV_LIVE_DVB_T] = {
                 .name           = "digitalnow DNTV Live! DVB-T",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -787,7 +787,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_ADSTECH_DVB_T_PCI] = {
                 .name           = "ADS Tech Instant TV DVB-T PCI",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -806,7 +806,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1] = {
                 .name           = "TerraTec Cinergy 1400 DVB-T",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .input          = { {
                         .type   = CX88_VMUX_DVB,
                         .vmux   = 0,
@@ -924,7 +924,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_WINFAST_DTV1000] = {
                 .name           = "WinFast DTV1000-T",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -972,7 +972,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1] = {
                 .name           = "Hauppauge Nova-S-Plus DVB-S",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -998,7 +998,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_HAUPPAUGE_NOVASE2_S1] = {
                 .name           = "Hauppauge Nova-SE2 DVB-S",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -1010,7 +1010,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_KWORLD_DVBS_100] = {
                 .name           = "KWorld DVB-S 100",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -1102,7 +1102,7 @@ static const struct cx88_board cx88_boards[] = {
                 /* DTT 7579 Conexant CX22702-19 Conexant CX2388x  */
                 /* Manenti Marco <marco_manenti@colman.it> */
                 .name           = "KWorld/VStream XPert DVB-T with cx22702",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -1121,7 +1121,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL] = {
                 .name           = "DViCO FusionHDTV DVB-T Dual Digital",
-                .tuner_type     = TUNER_ABSENT, /* No analog tuner */
+                .tuner_type     = UNSET, /* No analog tuner */
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -1356,7 +1356,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_GENIATECH_DVBS] = {
                 .name          = "Geniatech DVB-S",
-                .tuner_type    = TUNER_ABSENT,
+                .tuner_type    = UNSET,
                 .radio_type    = UNSET,
                 .tuner_addr    = ADDR_UNSET,
                 .radio_addr    = ADDR_UNSET,
@@ -1494,7 +1494,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_SAMSUNG_SMT_7020] = {
                 .name           = "Samsung SMT 7020 DVB-S",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -1506,7 +1506,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_ADSTECH_PTV_390] = {
                 .name           = "ADS Tech Instant Video PCI",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -1553,7 +1553,7 @@ static const struct cx88_board cx88_boards[] = {
         [CX88_BOARD_DVICO_FUSIONHDTV_5_PCI_NANO] = {
                 .name           = "DViCO FusionHDTV 5 PCI nano",
                 /* xc3008 tuner, digital only for now */
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -2069,7 +2069,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_TBS_8920] = {
                 .name           = "TBS 8920 DVB-S/S2",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -2304,7 +2304,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_TWINHAN_VP1027_DVBS] = {
                 .name           = "Twinhan VP-1027 DVB-S",
-                .tuner_type     = TUNER_ABSENT,
+                .tuner_type     = UNSET,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -2921,33 +2921,33 @@ static const struct {
         int  fm;
         const char *name;
 } gdi_tuner[] = {
-        [ 0x01 ] = { .id   = TUNER_ABSENT,
+        [ 0x01 ] = { .id   = UNSET,
                      .name = "NTSC_M" },
-        [ 0x02 ] = { .id   = TUNER_ABSENT,
+        [ 0x02 ] = { .id   = UNSET,
                      .name = "PAL_B" },
-        [ 0x03 ] = { .id   = TUNER_ABSENT,
+        [ 0x03 ] = { .id   = UNSET,
                      .name = "PAL_I" },
-        [ 0x04 ] = { .id   = TUNER_ABSENT,
+        [ 0x04 ] = { .id   = UNSET,
                      .name = "PAL_D" },
-        [ 0x05 ] = { .id   = TUNER_ABSENT,
+        [ 0x05 ] = { .id   = UNSET,
                      .name = "SECAM" },
 
-        [ 0x10 ] = { .id   = TUNER_ABSENT,
+        [ 0x10 ] = { .id   = UNSET,
                      .fm   = 1,
                      .name = "TEMIC_4049" },
         [ 0x11 ] = { .id   = TUNER_TEMIC_4136FY5,
                      .name = "TEMIC_4136" },
-        [ 0x12 ] = { .id   = TUNER_ABSENT,
+        [ 0x12 ] = { .id   = UNSET,
                      .name = "TEMIC_4146" },
 
         [ 0x20 ] = { .id   = TUNER_PHILIPS_FQ1216ME,
                      .fm   = 1,
                      .name = "PHILIPS_FQ1216_MK3" },
-        [ 0x21 ] = { .id   = TUNER_ABSENT, .fm = 1,
+        [ 0x21 ] = { .id   = UNSET, .fm = 1,
                      .name = "PHILIPS_FQ1236_MK3" },
-        [ 0x22 ] = { .id   = TUNER_ABSENT,
+        [ 0x22 ] = { .id   = UNSET,
                      .name = "PHILIPS_FI1236_MK3" },
-        [ 0x23 ] = { .id   = TUNER_ABSENT,
+        [ 0x23 ] = { .id   = UNSET,
                      .name = "PHILIPS_FI1216_MK3" },
 };
 
@@ -3564,7 +3564,7 @@ static void cx88_card_setup(struct cx88_core *core)
                 mode_mask &= ~T_RADIO;
         }
 
-        if (core->board.tuner_type != TUNER_ABSENT) {
+        if (core->board.tuner_type != UNSET) {
                 tun_setup.mode_mask      = mode_mask;
                 tun_setup.type           = core->board.tuner_type;
                 tun_setup.addr           = core->board.tuner_addr;
@@ -3691,6 +3691,11 @@ struct cx88_core *cx88_core_create(struct pci_dev *pci, int nr)
         core->nr = nr;
         sprintf(core->name, "cx88[%d]", core->nr);
 
+        core->tvnorm = V4L2_STD_NTSC_M;
+        core->width   = 320;
+        core->height  = 240;
+        core->field   = V4L2_FIELD_INTERLACED;
+
         strcpy(core->v4l2_dev.name, core->name);
         if (v4l2_device_register(NULL, &core->v4l2_dev)) {
                 kfree(core);
@@ -3772,7 +3777,7 @@ struct cx88_core *cx88_core_create(struct pci_dev *pci, int nr)
         cx88_i2c_init(core, pci);
 
         /* load tuner module, if needed */
-        if (TUNER_ABSENT != core->board.tuner_type) {
+        if (UNSET != core->board.tuner_type) {
                 /* Ignore 0x6b and 0x6f on cx88 boards.
                  * FusionHDTV5 RT Gold has an ir receiver at 0x6b
                  * and an RTC at 0x6f which can get corrupted if probed. */
diff --git a/drivers/media/pci/cx88/cx88-core.c b/drivers/media/pci/cx88/cx88-core.c
index 71630238027b..dee177ed5fe9 100644
--- a/drivers/media/pci/cx88/cx88-core.c
+++ b/drivers/media/pci/cx88/cx88-core.c
@@ -76,11 +76,16 @@ static DEFINE_MUTEX(devlist);
 static __le32* cx88_risc_field(__le32 *rp, struct scatterlist *sglist,
                             unsigned int offset, u32 sync_line,
                             unsigned int bpl, unsigned int padding,
-                            unsigned int lines, unsigned int lpi)
+                            unsigned int lines, unsigned int lpi, bool jump)
 {
         struct scatterlist *sg;
         unsigned int line,todo,sol;
 
+        if (jump) {
+                (*rp++) = cpu_to_le32(RISC_JUMP);
+                (*rp++) = 0;
+        }
+
         /* sync instruction */
         if (sync_line != NO_SYNC_LINE)
                 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
@@ -90,7 +95,7 @@ static __le32* cx88_risc_field(__le32 *rp, struct scatterlist *sglist,
         for (line = 0; line < lines; line++) {
                 while (offset && offset >= sg_dma_len(sg)) {
                         offset -= sg_dma_len(sg);
-                        sg++;
+                        sg = sg_next(sg);
                 }
                 if (lpi && line>0 && !(line % lpi))
                         sol = RISC_SOL | RISC_IRQ1 | RISC_CNT_INC;
@@ -109,13 +114,13 @@ static __le32* cx88_risc_field(__le32 *rp, struct scatterlist *sglist,
                         *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
                         todo -= (sg_dma_len(sg)-offset);
                         offset = 0;
-                        sg++;
+                        sg = sg_next(sg);
                         while (todo > sg_dma_len(sg)) {
                                 *(rp++)=cpu_to_le32(RISC_WRITE|
                                                     sg_dma_len(sg));
                                 *(rp++)=cpu_to_le32(sg_dma_address(sg));
                                 todo -= sg_dma_len(sg);
-                                sg++;
+                                sg = sg_next(sg);
                         }
                         *(rp++)=cpu_to_le32(RISC_WRITE|RISC_EOL|todo);
                         *(rp++)=cpu_to_le32(sg_dma_address(sg));
@@ -127,14 +132,13 @@ static __le32* cx88_risc_field(__le32 *rp, struct scatterlist *sglist,
         return rp;
 }
 
-int cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+int cx88_risc_buffer(struct pci_dev *pci, struct cx88_riscmem *risc,
                      struct scatterlist *sglist,
                      unsigned int top_offset, unsigned int bottom_offset,
                      unsigned int bpl, unsigned int padding, unsigned int lines)
 {
         u32 instructions,fields;
         __le32 *rp;
-        int rc;
 
         fields = 0;
         if (UNSET != top_offset)
@@ -147,18 +151,21 @@ int cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
            can cause next bpl to start close to a page border.  First DMA
            region may be smaller than PAGE_SIZE */
         instructions  = fields * (1 + ((bpl + padding) * lines) / PAGE_SIZE + lines);
-        instructions += 2;
-        if ((rc = btcx_riscmem_alloc(pci,risc,instructions*8)) < 0)
-                return rc;
+        instructions += 4;
+        risc->size = instructions * 8;
+        risc->dma = 0;
+        risc->cpu = pci_zalloc_consistent(pci, risc->size, &risc->dma);
+        if (NULL == risc->cpu)
+                return -ENOMEM;
 
         /* write risc instructions */
         rp = risc->cpu;
         if (UNSET != top_offset)
                 rp = cx88_risc_field(rp, sglist, top_offset, 0,
-                                     bpl, padding, lines, 0);
+                                     bpl, padding, lines, 0, true);
         if (UNSET != bottom_offset)
                 rp = cx88_risc_field(rp, sglist, bottom_offset, 0x200,
-                                     bpl, padding, lines, 0);
+                                     bpl, padding, lines, 0, top_offset == UNSET);
 
         /* save pointer to jmp instruction address */
         risc->jmp = rp;
@@ -166,26 +173,28 @@ int cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
         return 0;
 }
 
-int cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+int cx88_risc_databuffer(struct pci_dev *pci, struct cx88_riscmem *risc,
                          struct scatterlist *sglist, unsigned int bpl,
                          unsigned int lines, unsigned int lpi)
 {
         u32 instructions;
         __le32 *rp;
-        int rc;
 
         /* estimate risc mem: worst case is one write per page border +
            one write per scan line + syncs + jump (all 2 dwords).  Here
            there is no padding and no sync.  First DMA region may be smaller
            than PAGE_SIZE */
         instructions  = 1 + (bpl * lines) / PAGE_SIZE + lines;
-        instructions += 1;
-        if ((rc = btcx_riscmem_alloc(pci,risc,instructions*8)) < 0)
-                return rc;
+        instructions += 3;
+        risc->size = instructions * 8;
+        risc->dma = 0;
+        risc->cpu = pci_zalloc_consistent(pci, risc->size, &risc->dma);
+        if (NULL == risc->cpu)
+                return -ENOMEM;
 
         /* write risc instructions */
         rp = risc->cpu;
-        rp = cx88_risc_field(rp, sglist, 0, NO_SYNC_LINE, bpl, 0, lines, lpi);
+        rp = cx88_risc_field(rp, sglist, 0, NO_SYNC_LINE, bpl, 0, lines, lpi, !lpi);
 
         /* save pointer to jmp instruction address */
         risc->jmp = rp;
@@ -193,39 +202,6 @@ int cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
         return 0;
 }
 
-int cx88_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
-                      u32 reg, u32 mask, u32 value)
-{
-        __le32 *rp;
-        int rc;
-
-        if ((rc = btcx_riscmem_alloc(pci, risc, 4*16)) < 0)
-                return rc;
-
-        /* write risc instructions */
-        rp = risc->cpu;
-        *(rp++) = cpu_to_le32(RISC_WRITECR  | RISC_IRQ2 | RISC_IMM);
-        *(rp++) = cpu_to_le32(reg);
-        *(rp++) = cpu_to_le32(value);
-        *(rp++) = cpu_to_le32(mask);
-        *(rp++) = cpu_to_le32(RISC_JUMP);
-        *(rp++) = cpu_to_le32(risc->dma);
-        return 0;
-}
-
-void
-cx88_free_buffer(struct videobuf_queue *q, struct cx88_buffer *buf)
-{
-        struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
-
-        BUG_ON(in_interrupt());
-        videobuf_waiton(q, &buf->vb, 0, 0);
-        videobuf_dma_unmap(q->dev, dma);
-        videobuf_dma_free(dma);
-        btcx_riscmem_free(to_pci_dev(q->dev), &buf->risc);
-        buf->vb.state = VIDEOBUF_NEEDS_INIT;
-}
-
 /* ------------------------------------------------------------------ */
 /* our SRAM memory layout                                             */
 
@@ -539,33 +515,12 @@ void cx88_wakeup(struct cx88_core *core,
                  struct cx88_dmaqueue *q, u32 count)
 {
         struct cx88_buffer *buf;
-        int bc;
-
-        for (bc = 0;; bc++) {
-                if (list_empty(&q->active))
-                        break;
-                buf = list_entry(q->active.next,
-                                 struct cx88_buffer, vb.queue);
-                /* count comes from the hw and is is 16bit wide --
-                 * this trick handles wrap-arounds correctly for
-                 * up to 32767 buffers in flight... */
-                if ((s16) (count - buf->count) < 0)
-                        break;
-                v4l2_get_timestamp(&buf->vb.ts);
-                dprintk(2,"[%p/%d] wakeup reg=%d buf=%d\n",buf,buf->vb.i,
-                        count, buf->count);
-                buf->vb.state = VIDEOBUF_DONE;
-                list_del(&buf->vb.queue);
-                wake_up(&buf->vb.done);
-        }
-        if (list_empty(&q->active)) {
-                del_timer(&q->timeout);
-        } else {
-                mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
-        }
-        if (bc != 1)
-                dprintk(2, "%s: %d buffers handled (should be 1)\n",
-                        __func__, bc);
+
+        buf = list_entry(q->active.next,
+                         struct cx88_buffer, list);
+        v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
+        list_del(&buf->list);
+        vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 }
 
 void cx88_shutdown(struct cx88_core *core)
@@ -909,6 +864,13 @@ int cx88_set_tvnorm(struct cx88_core *core, v4l2_std_id norm)
         u32 bdelay,agcdelay,htotal;
         u32 cxiformat, cxoformat;
 
+        if (norm == core->tvnorm)
+                return 0;
+        if (core->v4ldev && (vb2_is_busy(&core->v4ldev->vb2_vidq) ||
+                             vb2_is_busy(&core->v4ldev->vb2_vbiq)))
+                return -EBUSY;
+        if (core->dvbdev && vb2_is_busy(&core->dvbdev->vb2_mpegq))
+                return -EBUSY;
         core->tvnorm = norm;
         fsc8       = norm_fsc8(norm);
         adc_clock  = xtal;
@@ -1043,6 +1005,7 @@ struct video_device *cx88_vdev_init(struct cx88_core *core,
         vfd->v4l2_dev = &core->v4l2_dev;
         vfd->dev_parent = &pci->dev;
         vfd->release = video_device_release;
+        vfd->lock = &core->lock;
         snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
                  core->name, type, core->board.name);
         return vfd;
@@ -1114,8 +1077,6 @@ EXPORT_SYMBOL(cx88_shutdown);
 
 EXPORT_SYMBOL(cx88_risc_buffer);
 EXPORT_SYMBOL(cx88_risc_databuffer);
-EXPORT_SYMBOL(cx88_risc_stopper);
-EXPORT_SYMBOL(cx88_free_buffer);
 
 EXPORT_SYMBOL(cx88_sram_channels);
 EXPORT_SYMBOL(cx88_sram_channel_setup);
diff --git a/drivers/media/pci/cx88/cx88-dvb.c b/drivers/media/pci/cx88/cx88-dvb.c
index 053ed1ba1d85..c344bfd0b896 100644
--- a/drivers/media/pci/cx88/cx88-dvb.c
+++ b/drivers/media/pci/cx88/cx88-dvb.c
@@ -82,43 +82,89 @@ DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 
 /* ------------------------------------------------------------------ */
 
-static int dvb_buf_setup(struct videobuf_queue *q,
-                         unsigned int *count, unsigned int *size)
+static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
+                           unsigned int *num_buffers, unsigned int *num_planes,
+                           unsigned int sizes[], void *alloc_ctxs[])
 {
-        struct cx8802_dev *dev = q->priv_data;
+        struct cx8802_dev *dev = q->drv_priv;
 
+        *num_planes = 1;
         dev->ts_packet_size  = 188 * 4;
         dev->ts_packet_count = dvb_buf_tscnt;
-
-        *size  = dev->ts_packet_size * dev->ts_packet_count;
-        *count = dvb_buf_tscnt;
+        sizes[0] = dev->ts_packet_size * dev->ts_packet_count;
+        *num_buffers = dvb_buf_tscnt;
         return 0;
 }
 
-static int dvb_buf_prepare(struct videobuf_queue *q,
-                           struct videobuf_buffer *vb, enum v4l2_field field)
+static int buffer_prepare(struct vb2_buffer *vb)
+{
+        struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
+
+        return cx8802_buf_prepare(vb->vb2_queue, dev, buf);
+}
+
+static void buffer_finish(struct vb2_buffer *vb)
+{
+        struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
+        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+        struct cx88_riscmem *risc = &buf->risc;
+
+        if (risc->cpu)
+                pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+        memset(risc, 0, sizeof(*risc));
+
+        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
+}
+
+static void buffer_queue(struct vb2_buffer *vb)
 {
-        struct cx8802_dev *dev = q->priv_data;
-        return cx8802_buf_prepare(q, dev, (struct cx88_buffer*)vb,field);
+        struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer    *buf = container_of(vb, struct cx88_buffer, vb);
+
+        cx8802_buf_queue(dev, buf);
 }
 
-static void dvb_buf_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
+static int start_streaming(struct vb2_queue *q, unsigned int count)
 {
-        struct cx8802_dev *dev = q->priv_data;
-        cx8802_buf_queue(dev, (struct cx88_buffer*)vb);
+        struct cx8802_dev *dev = q->drv_priv;
+        struct cx88_dmaqueue *dmaq = &dev->mpegq;
+        struct cx88_buffer *buf;
+
+        buf = list_entry(dmaq->active.next, struct cx88_buffer, list);
+        cx8802_start_dma(dev, dmaq, buf);
+        return 0;
 }
 
-static void dvb_buf_release(struct videobuf_queue *q,
-                            struct videobuf_buffer *vb)
+static void stop_streaming(struct vb2_queue *q)
 {
-        cx88_free_buffer(q, (struct cx88_buffer*)vb);
+        struct cx8802_dev *dev = q->drv_priv;
+        struct cx88_dmaqueue *dmaq = &dev->mpegq;
+        unsigned long flags;
+
+        cx8802_cancel_buffers(dev);
+
+        spin_lock_irqsave(&dev->slock, flags);
+        while (!list_empty(&dmaq->active)) {
+                struct cx88_buffer *buf = list_entry(dmaq->active.next,
+                        struct cx88_buffer, list);
+
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+        }
+        spin_unlock_irqrestore(&dev->slock, flags);
 }
 
-static const struct videobuf_queue_ops dvb_qops = {
-        .buf_setup    = dvb_buf_setup,
-        .buf_prepare  = dvb_buf_prepare,
-        .buf_queue    = dvb_buf_queue,
-        .buf_release  = dvb_buf_release,
+static struct vb2_ops dvb_qops = {
+        .queue_setup    = queue_setup,
+        .buf_prepare  = buffer_prepare,
+        .buf_finish = buffer_finish,
+        .buf_queue    = buffer_queue,
+        .wait_prepare = vb2_ops_wait_prepare,
+        .wait_finish = vb2_ops_wait_finish,
+        .start_streaming = start_streaming,
+        .stop_streaming = stop_streaming,
 };
 
 /* ------------------------------------------------------------------ */
@@ -130,7 +176,7 @@ static int cx88_dvb_bus_ctrl(struct dvb_frontend* fe, int acquire)
         int ret = 0;
         int fe_id;
 
-        fe_id = videobuf_dvb_find_frontend(&dev->frontends, fe);
+        fe_id = vb2_dvb_find_frontend(&dev->frontends, fe);
         if (!fe_id) {
                 printk(KERN_ERR "%s() No frontend found\n", __func__);
                 return -EINVAL;
@@ -154,8 +200,8 @@ static int cx88_dvb_bus_ctrl(struct dvb_frontend* fe, int acquire)
 
 static void cx88_dvb_gate_ctrl(struct cx88_core  *core, int open)
 {
-        struct videobuf_dvb_frontends *f;
-        struct videobuf_dvb_frontend *fe;
+        struct vb2_dvb_frontends *f;
+        struct vb2_dvb_frontend *fe;
 
         if (!core->dvbdev)
                 return;
@@ -166,9 +212,9 @@ static void cx88_dvb_gate_ctrl(struct cx88_core  *core, int open)
                 return;
 
         if (f->gate <= 1) /* undefined or fe0 */
-                fe = videobuf_dvb_get_frontend(f, 1);
+                fe = vb2_dvb_get_frontend(f, 1);
         else
-                fe = videobuf_dvb_get_frontend(f, f->gate);
+                fe = vb2_dvb_get_frontend(f, f->gate);
 
         if (fe && fe->dvb.frontend && fe->dvb.frontend->ops.i2c_gate_ctrl)
                 fe->dvb.frontend->ops.i2c_gate_ctrl(fe->dvb.frontend, open);
@@ -565,7 +611,7 @@ static const struct xc5000_config dvico_fusionhdtv7_tuner_config = {
 static int attach_xc3028(u8 addr, struct cx8802_dev *dev)
 {
         struct dvb_frontend *fe;
-        struct videobuf_dvb_frontend *fe0 = NULL;
+        struct vb2_dvb_frontend *fe0 = NULL;
         struct xc2028_ctrl ctl;
         struct xc2028_config cfg = {
                 .i2c_adap  = &dev->core->i2c_adap,
@@ -574,7 +620,7 @@ static int attach_xc3028(u8 addr, struct cx8802_dev *dev)
         };
 
         /* Get the first frontend */
-        fe0 = videobuf_dvb_get_frontend(&dev->frontends, 1);
+        fe0 = vb2_dvb_get_frontend(&dev->frontends, 1);
         if (!fe0)
                 return -EINVAL;
 
@@ -611,10 +657,10 @@ static int attach_xc3028(u8 addr, struct cx8802_dev *dev)
 static int attach_xc4000(struct cx8802_dev *dev, struct xc4000_config *cfg)
 {
         struct dvb_frontend *fe;
-        struct videobuf_dvb_frontend *fe0 = NULL;
+        struct vb2_dvb_frontend *fe0 = NULL;
 
         /* Get the first frontend */
-        fe0 = videobuf_dvb_get_frontend(&dev->frontends, 1);
+        fe0 = vb2_dvb_get_frontend(&dev->frontends, 1);
         if (!fe0)
                 return -EINVAL;
 
@@ -745,7 +791,7 @@ static const struct stv0288_config tevii_tuner_earda_config = {
 static int cx8802_alloc_frontends(struct cx8802_dev *dev)
 {
         struct cx88_core *core = dev->core;
-        struct videobuf_dvb_frontend *fe = NULL;
+        struct vb2_dvb_frontend *fe = NULL;
         int i;
 
         mutex_init(&dev->frontends.lock);
@@ -757,10 +803,10 @@ static int cx8802_alloc_frontends(struct cx8802_dev *dev)
         printk(KERN_INFO "%s() allocating %d frontend(s)\n", __func__,
                          core->board.num_frontends);
         for (i = 1; i <= core->board.num_frontends; i++) {
-                fe = videobuf_dvb_alloc_frontend(&dev->frontends, i);
+                fe = vb2_dvb_alloc_frontend(&dev->frontends, i);
                 if (!fe) {
                         printk(KERN_ERR "%s() failed to alloc\n", __func__);
-                        videobuf_dvb_dealloc_frontends(&dev->frontends);
+                        vb2_dvb_dealloc_frontends(&dev->frontends);
                         return -ENOMEM;
                 }
         }
@@ -958,7 +1004,7 @@ static const struct stv0299_config samsung_stv0299_config = {
 static int dvb_register(struct cx8802_dev *dev)
 {
         struct cx88_core *core = dev->core;
-        struct videobuf_dvb_frontend *fe0, *fe1 = NULL;
+        struct vb2_dvb_frontend *fe0, *fe1 = NULL;
         int mfe_shared = 0; /* bus not shared by default */
         int res = -EINVAL;
 
@@ -968,7 +1014,7 @@ static int dvb_register(struct cx8802_dev *dev)
         }
 
         /* Get the first frontend */
-        fe0 = videobuf_dvb_get_frontend(&dev->frontends, 1);
+        fe0 = vb2_dvb_get_frontend(&dev->frontends, 1);
         if (!fe0)
                 goto frontend_detach;
 
@@ -1046,7 +1092,7 @@ static int dvb_register(struct cx8802_dev *dev)
                                 goto frontend_detach;
                 }
                 /* MFE frontend 2 */
-                fe1 = videobuf_dvb_get_frontend(&dev->frontends, 2);
+                fe1 = vb2_dvb_get_frontend(&dev->frontends, 2);
                 if (!fe1)
                         goto frontend_detach;
                 /* DVB-T init */
@@ -1415,7 +1461,7 @@ static int dvb_register(struct cx8802_dev *dev)
                                 goto frontend_detach;
                 }
                 /* MFE frontend 2 */
-                fe1 = videobuf_dvb_get_frontend(&dev->frontends, 2);
+                fe1 = vb2_dvb_get_frontend(&dev->frontends, 2);
                 if (!fe1)
                         goto frontend_detach;
                 /* DVB-T Init */
@@ -1594,7 +1640,7 @@ static int dvb_register(struct cx8802_dev *dev)
         call_all(core, core, s_power, 0);
 
         /* register everything */
-        res = videobuf_dvb_register_bus(&dev->frontends, THIS_MODULE, dev,
+        res = vb2_dvb_register_bus(&dev->frontends, THIS_MODULE, dev,
                 &dev->pci->dev, adapter_nr, mfe_shared);
         if (res)
                 goto frontend_detach;
@@ -1602,7 +1648,7 @@ static int dvb_register(struct cx8802_dev *dev)
 
 frontend_detach:
         core->gate_ctrl = NULL;
-        videobuf_dvb_dealloc_frontends(&dev->frontends);
+        vb2_dvb_dealloc_frontends(&dev->frontends);
         return res;
 }
 
@@ -1697,7 +1743,7 @@ static int cx8802_dvb_probe(struct cx8802_driver *drv)
         struct cx88_core *core = drv->core;
         struct cx8802_dev *dev = drv->core->dvbdev;
         int err;
-        struct videobuf_dvb_frontend *fe;
+        struct vb2_dvb_frontend *fe;
         int i;
 
         dprintk( 1, "%s\n", __func__);
@@ -1726,19 +1772,31 @@ static int cx8802_dvb_probe(struct cx8802_driver *drv)
 
         err = -ENODEV;
         for (i = 1; i <= core->board.num_frontends; i++) {
-                fe = videobuf_dvb_get_frontend(&core->dvbdev->frontends, i);
+                struct vb2_queue *q;
+
+                fe = vb2_dvb_get_frontend(&core->dvbdev->frontends, i);
                 if (fe == NULL) {
                         printk(KERN_ERR "%s() failed to get frontend(%d)\n",
                                         __func__, i);
                         goto fail_probe;
                 }
-                videobuf_queue_sg_init(&fe->dvb.dvbq, &dvb_qops,
-                                    &dev->pci->dev, &dev->slock,
-                                    V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                                    V4L2_FIELD_TOP,
-                                    sizeof(struct cx88_buffer),
-                                    dev, NULL);
-                /* init struct videobuf_dvb */
+                q = &fe->dvb.dvbq;
+                q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
+                q->gfp_flags = GFP_DMA32;
+                q->min_buffers_needed = 2;
+                q->drv_priv = dev;
+                q->buf_struct_size = sizeof(struct cx88_buffer);
+                q->ops = &dvb_qops;
+                q->mem_ops = &vb2_dma_sg_memops;
+                q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+                q->lock = &core->lock;
+
+                err = vb2_queue_init(q);
+                if (err < 0)
+                        goto fail_probe;
+
+                /* init struct vb2_dvb */
                 fe->dvb.name = dev->core->name;
         }
 
@@ -1749,7 +1807,7 @@ static int cx8802_dvb_probe(struct cx8802_driver *drv)
                        core->name, err);
         return err;
 fail_probe:
-        videobuf_dvb_dealloc_frontends(&core->dvbdev->frontends);
+        vb2_dvb_dealloc_frontends(&core->dvbdev->frontends);
 fail_core:
         return err;
 }
@@ -1761,7 +1819,7 @@ static int cx8802_dvb_remove(struct cx8802_driver *drv)
 
         dprintk( 1, "%s\n", __func__);
 
-        videobuf_dvb_unregister_bus(&dev->frontends);
+        vb2_dvb_unregister_bus(&dev->frontends);
 
         vp3054_i2c_remove(dev);
 
diff --git a/drivers/media/pci/cx88/cx88-mpeg.c b/drivers/media/pci/cx88/cx88-mpeg.c
index 74b7b8614c23..f181a3a10389 100644
--- a/drivers/media/pci/cx88/cx88-mpeg.c
+++ b/drivers/media/pci/cx88/cx88-mpeg.c
@@ -86,21 +86,21 @@ static LIST_HEAD(cx8802_devlist);
 static DEFINE_MUTEX(cx8802_mutex);
 /* ------------------------------------------------------------------ */
 
-static int cx8802_start_dma(struct cx8802_dev    *dev,
+int cx8802_start_dma(struct cx8802_dev    *dev,
                             struct cx88_dmaqueue *q,
                             struct cx88_buffer   *buf)
 {
         struct cx88_core *core = dev->core;
 
         dprintk(1, "cx8802_start_dma w: %d, h: %d, f: %d\n",
-                buf->vb.width, buf->vb.height, buf->vb.field);
+                core->width, core->height, core->field);
 
         /* setup fifo + format */
         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH28],
                                 dev->ts_packet_size, buf->risc.dma);
 
         /* write TS length to chip */
-        cx_write(MO_TS_LNGTH, buf->vb.width);
+        cx_write(MO_TS_LNGTH, dev->ts_packet_size);
 
         /* FIXME: this needs a review.
          * also: move to cx88-blackbird + cx88-dvb source files? */
@@ -210,83 +210,44 @@ static int cx8802_restart_queue(struct cx8802_dev    *dev,
 
         dprintk( 1, "cx8802_restart_queue\n" );
         if (list_empty(&q->active))
-        {
-                struct cx88_buffer *prev;
-                prev = NULL;
-
-                dprintk(1, "cx8802_restart_queue: queue is empty\n" );
-
-                for (;;) {
-                        if (list_empty(&q->queued))
-                                return 0;
-                        buf = list_entry(q->queued.next, struct cx88_buffer, vb.queue);
-                        if (NULL == prev) {
-                                list_move_tail(&buf->vb.queue, &q->active);
-                                cx8802_start_dma(dev, q, buf);
-                                buf->vb.state = VIDEOBUF_ACTIVE;
-                                buf->count    = q->count++;
-                                mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
-                                dprintk(1,"[%p/%d] restart_queue - first active\n",
-                                        buf,buf->vb.i);
-
-                        } else if (prev->vb.width  == buf->vb.width  &&
-                                   prev->vb.height == buf->vb.height &&
-                                   prev->fmt       == buf->fmt) {
-                                list_move_tail(&buf->vb.queue, &q->active);
-                                buf->vb.state = VIDEOBUF_ACTIVE;
-                                buf->count    = q->count++;
-                                prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
-                                dprintk(1,"[%p/%d] restart_queue - move to active\n",
-                                        buf,buf->vb.i);
-                        } else {
-                                return 0;
-                        }
-                        prev = buf;
-                }
                 return 0;
-        }
 
-        buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
+        buf = list_entry(q->active.next, struct cx88_buffer, list);
         dprintk(2,"restart_queue [%p/%d]: restart dma\n",
-                buf, buf->vb.i);
+                buf, buf->vb.v4l2_buf.index);
         cx8802_start_dma(dev, q, buf);
-        list_for_each_entry(buf, &q->active, vb.queue)
+        list_for_each_entry(buf, &q->active, list)
                 buf->count = q->count++;
-        mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
         return 0;
 }
 
 /* ------------------------------------------------------------------ */
 
-int cx8802_buf_prepare(struct videobuf_queue *q, struct cx8802_dev *dev,
-                        struct cx88_buffer *buf, enum v4l2_field field)
+int cx8802_buf_prepare(struct vb2_queue *q, struct cx8802_dev *dev,
+                        struct cx88_buffer *buf)
 {
         int size = dev->ts_packet_size * dev->ts_packet_count;
-        struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
+        struct sg_table *sgt = vb2_dma_sg_plane_desc(&buf->vb, 0);
+        struct cx88_riscmem *risc = &buf->risc;
         int rc;
 
-        dprintk(1, "%s: %p\n", __func__, buf);
-        if (0 != buf->vb.baddr  &&  buf->vb.bsize < size)
+        if (vb2_plane_size(&buf->vb, 0) < size)
                 return -EINVAL;
+        vb2_set_plane_payload(&buf->vb, 0, size);
 
-        if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
-                buf->vb.width  = dev->ts_packet_size;
-                buf->vb.height = dev->ts_packet_count;
-                buf->vb.size   = size;
-                buf->vb.field  = field /*V4L2_FIELD_TOP*/;
-
-                if (0 != (rc = videobuf_iolock(q,&buf->vb,NULL)))
-                        goto fail;
-                cx88_risc_databuffer(dev->pci, &buf->risc,
-                                     dma->sglist,
-                                     buf->vb.width, buf->vb.height, 0);
+        rc = dma_map_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
+        if (!rc)
+                return -EIO;
+
+        rc = cx88_risc_databuffer(dev->pci, risc, sgt->sgl,
+                             dev->ts_packet_size, dev->ts_packet_count, 0);
+        if (rc) {
+                if (risc->cpu)
+                        pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+                memset(risc, 0, sizeof(*risc));
+                return rc;
         }
-        buf->vb.state = VIDEOBUF_PREPARED;
         return 0;
-
- fail:
-        cx88_free_buffer(q,buf);
-        return rc;
 }
 
 void cx8802_buf_queue(struct cx8802_dev *dev, struct cx88_buffer *buf)
@@ -295,35 +256,33 @@ void cx8802_buf_queue(struct cx8802_dev *dev, struct cx88_buffer *buf)
         struct cx88_dmaqueue  *cx88q = &dev->mpegq;
 
         dprintk( 1, "cx8802_buf_queue\n" );
-        /* add jump to stopper */
-        buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
-        buf->risc.jmp[1] = cpu_to_le32(cx88q->stopper.dma);
+        /* add jump to start */
+        buf->risc.cpu[1] = cpu_to_le32(buf->risc.dma + 8);
+        buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_CNT_INC);
+        buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma + 8);
 
         if (list_empty(&cx88q->active)) {
                 dprintk( 1, "queue is empty - first active\n" );
-                list_add_tail(&buf->vb.queue,&cx88q->active);
-                cx8802_start_dma(dev, cx88q, buf);
-                buf->vb.state = VIDEOBUF_ACTIVE;
+                list_add_tail(&buf->list, &cx88q->active);
                 buf->count    = cx88q->count++;
-                mod_timer(&cx88q->timeout, jiffies+BUFFER_TIMEOUT);
                 dprintk(1,"[%p/%d] %s - first active\n",
-                        buf, buf->vb.i, __func__);
+                        buf, buf->vb.v4l2_buf.index, __func__);
 
         } else {
+                buf->risc.cpu[0] |= cpu_to_le32(RISC_IRQ1);
                 dprintk( 1, "queue is not empty - append to active\n" );
-                prev = list_entry(cx88q->active.prev, struct cx88_buffer, vb.queue);
-                list_add_tail(&buf->vb.queue,&cx88q->active);
-                buf->vb.state = VIDEOBUF_ACTIVE;
+                prev = list_entry(cx88q->active.prev, struct cx88_buffer, list);
+                list_add_tail(&buf->list, &cx88q->active);
                 buf->count    = cx88q->count++;
                 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
                 dprintk( 1, "[%p/%d] %s - append to active\n",
-                        buf, buf->vb.i, __func__);
+                        buf, buf->vb.v4l2_buf.index, __func__);
         }
 }
 
 /* ----------------------------------------------------------- */
 
-static void do_cancel_buffers(struct cx8802_dev *dev, const char *reason, int restart)
+static void do_cancel_buffers(struct cx8802_dev *dev)
 {
         struct cx88_dmaqueue *q = &dev->mpegq;
         struct cx88_buffer *buf;
@@ -331,41 +290,18 @@ static void do_cancel_buffers(struct cx8802_dev *dev, const char *reason, int re
 
         spin_lock_irqsave(&dev->slock,flags);
         while (!list_empty(&q->active)) {
-                buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
-                list_del(&buf->vb.queue);
-                buf->vb.state = VIDEOBUF_ERROR;
-                wake_up(&buf->vb.done);
-                dprintk(1,"[%p/%d] %s - dma=0x%08lx\n",
-                        buf, buf->vb.i, reason, (unsigned long)buf->risc.dma);
-        }
-        if (restart)
-        {
-                dprintk(1, "restarting queue\n" );
-                cx8802_restart_queue(dev,q);
+                buf = list_entry(q->active.next, struct cx88_buffer, list);
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
         }
         spin_unlock_irqrestore(&dev->slock,flags);
 }
 
 void cx8802_cancel_buffers(struct cx8802_dev *dev)
 {
-        struct cx88_dmaqueue *q = &dev->mpegq;
-
         dprintk( 1, "cx8802_cancel_buffers" );
-        del_timer_sync(&q->timeout);
         cx8802_stop_dma(dev);
-        do_cancel_buffers(dev,"cancel",0);
-}
-
-static void cx8802_timeout(unsigned long data)
-{
-        struct cx8802_dev *dev = (struct cx8802_dev*)data;
-
-        dprintk(1, "%s\n",__func__);
-
-        if (debug)
-                cx88_sram_channel_dump(dev->core, &cx88_sram_channels[SRAM_CH28]);
-        cx8802_stop_dma(dev);
-        do_cancel_buffers(dev,"timeout",1);
+        do_cancel_buffers(dev);
 }
 
 static const char * cx88_mpeg_irqs[32] = {
@@ -411,19 +347,11 @@ static void cx8802_mpeg_irq(struct cx8802_dev *dev)
                 spin_unlock(&dev->slock);
         }
 
-        /* risc2 y */
-        if (status & 0x10) {
-                spin_lock(&dev->slock);
-                cx8802_restart_queue(dev,&dev->mpegq);
-                spin_unlock(&dev->slock);
-        }
-
         /* other general errors */
         if (status & 0x1f0100) {
                 dprintk( 0, "general errors: 0x%08x\n", status & 0x1f0100 );
                 spin_lock(&dev->slock);
                 cx8802_stop_dma(dev);
-                cx8802_restart_queue(dev,&dev->mpegq);
                 spin_unlock(&dev->slock);
         }
 }
@@ -490,12 +418,6 @@ static int cx8802_init_common(struct cx8802_dev *dev)
 
         /* init dma queue */
         INIT_LIST_HEAD(&dev->mpegq.active);
-        INIT_LIST_HEAD(&dev->mpegq.queued);
-        dev->mpegq.timeout.function = cx8802_timeout;
-        dev->mpegq.timeout.data     = (unsigned long)dev;
-        init_timer(&dev->mpegq.timeout);
-        cx88_risc_stopper(dev->pci,&dev->mpegq.stopper,
-                          MO_TS_DMACNTRL,0x11,0x00);
 
         /* get irq */
         err = request_irq(dev->pci->irq, cx8802_irq,
@@ -520,9 +442,6 @@ static void cx8802_fini_common(struct cx8802_dev *dev)
 
         /* unregister stuff */
         free_irq(dev->pci->irq, dev);
-
-        /* free memory */
-        btcx_riscmem_free(dev->pci,&dev->mpegq.stopper);
 }
 
 /* ----------------------------------------------------------- */
@@ -539,7 +458,6 @@ static int cx8802_suspend_common(struct pci_dev *pci_dev, pm_message_t state)
                 dprintk( 2, "suspend\n" );
                 printk("%s: suspend mpeg\n", core->name);
                 cx8802_stop_dma(dev);
-                del_timer(&dev->mpegq.timeout);
         }
         spin_unlock_irqrestore(&dev->slock, flags);
 
@@ -907,6 +825,7 @@ module_pci_driver(cx8802_pci_driver);
 EXPORT_SYMBOL(cx8802_buf_prepare);
 EXPORT_SYMBOL(cx8802_buf_queue);
 EXPORT_SYMBOL(cx8802_cancel_buffers);
+EXPORT_SYMBOL(cx8802_start_dma);
 
 EXPORT_SYMBOL(cx8802_register_driver);
 EXPORT_SYMBOL(cx8802_unregister_driver);
diff --git a/drivers/media/pci/cx88/cx88-vbi.c b/drivers/media/pci/cx88/cx88-vbi.c
index f8f8389c0362..6ab6e27648f6 100644
--- a/drivers/media/pci/cx88/cx88-vbi.c
+++ b/drivers/media/pci/cx88/cx88-vbi.c
@@ -6,10 +6,6 @@
 
 #include "cx88.h"
 
-static unsigned int vbibufs = 4;
-module_param(vbibufs,int,0644);
-MODULE_PARM_DESC(vbibufs,"number of vbi buffers, range 2-32");
-
 static unsigned int vbi_debug;
 module_param(vbi_debug,int,0644);
 MODULE_PARM_DESC(vbi_debug,"enable debug messages [vbi]");
@@ -22,26 +18,27 @@ MODULE_PARM_DESC(vbi_debug,"enable debug messages [vbi]");
 int cx8800_vbi_fmt (struct file *file, void *priv,
                                         struct v4l2_format *f)
 {
-        struct cx8800_fh  *fh   = priv;
-        struct cx8800_dev *dev  = fh->dev;
+        struct cx8800_dev *dev = video_drvdata(file);
 
         f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH;
         f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
         f->fmt.vbi.offset = 244;
-        f->fmt.vbi.count[0] = VBI_LINE_COUNT;
-        f->fmt.vbi.count[1] = VBI_LINE_COUNT;
 
         if (dev->core->tvnorm & V4L2_STD_525_60) {
                 /* ntsc */
                 f->fmt.vbi.sampling_rate = 28636363;
                 f->fmt.vbi.start[0] = 10;
                 f->fmt.vbi.start[1] = 273;
+                f->fmt.vbi.count[0] = VBI_LINE_NTSC_COUNT;
+                f->fmt.vbi.count[1] = VBI_LINE_NTSC_COUNT;
 
         } else if (dev->core->tvnorm & V4L2_STD_625_50) {
                 /* pal */
                 f->fmt.vbi.sampling_rate = 35468950;
-                f->fmt.vbi.start[0] = 7 -1;
-                f->fmt.vbi.start[1] = 319 -1;
+                f->fmt.vbi.start[0] = V4L2_VBI_ITU_625_F1_START + 5;
+                f->fmt.vbi.start[1] = V4L2_VBI_ITU_625_F2_START + 5;
+                f->fmt.vbi.count[0] = VBI_LINE_PAL_COUNT;
+                f->fmt.vbi.count[1] = VBI_LINE_PAL_COUNT;
         }
         return 0;
 }
@@ -54,7 +51,7 @@ static int cx8800_start_vbi_dma(struct cx8800_dev    *dev,
 
         /* setup fifo + format */
         cx88_sram_channel_setup(dev->core, &cx88_sram_channels[SRAM_CH24],
-                                buf->vb.width, buf->risc.dma);
+                                VBI_LINE_LENGTH, buf->risc.dma);
 
         cx_write(MO_VBOS_CONTROL, ( (1 << 18) |  // comb filter delay fixup
                                     (1 << 15) |  // enable vbi capture
@@ -78,7 +75,7 @@ static int cx8800_start_vbi_dma(struct cx8800_dev    *dev,
         return 0;
 }
 
-int cx8800_stop_vbi_dma(struct cx8800_dev *dev)
+void cx8800_stop_vbi_dma(struct cx8800_dev *dev)
 {
         struct cx88_core *core = dev->core;
 
@@ -91,7 +88,6 @@ int cx8800_stop_vbi_dma(struct cx8800_dev *dev)
         /* disable irqs */
         cx_clear(MO_PCI_INTMSK, PCI_INT_VIDINT);
         cx_clear(MO_VID_INTMSK, 0x0f0088);
-        return 0;
 }
 
 int cx8800_restart_vbi_queue(struct cx8800_dev    *dev,
@@ -102,144 +98,144 @@ int cx8800_restart_vbi_queue(struct cx8800_dev    *dev,
         if (list_empty(&q->active))
                 return 0;
 
-        buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
+        buf = list_entry(q->active.next, struct cx88_buffer, list);
         dprintk(2,"restart_queue [%p/%d]: restart dma\n",
-                buf, buf->vb.i);
+                buf, buf->vb.v4l2_buf.index);
         cx8800_start_vbi_dma(dev, q, buf);
-        list_for_each_entry(buf, &q->active, vb.queue)
+        list_for_each_entry(buf, &q->active, list)
                 buf->count = q->count++;
-        mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
         return 0;
 }
 
-void cx8800_vbi_timeout(unsigned long data)
-{
-        struct cx8800_dev *dev = (struct cx8800_dev*)data;
-        struct cx88_core *core = dev->core;
-        struct cx88_dmaqueue *q = &dev->vbiq;
-        struct cx88_buffer *buf;
-        unsigned long flags;
-
-        cx88_sram_channel_dump(dev->core, &cx88_sram_channels[SRAM_CH24]);
-
-        cx_clear(MO_VID_DMACNTRL, 0x88);
-        cx_clear(VID_CAPTURE_CONTROL, 0x18);
-
-        spin_lock_irqsave(&dev->slock,flags);
-        while (!list_empty(&q->active)) {
-                buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
-                list_del(&buf->vb.queue);
-                buf->vb.state = VIDEOBUF_ERROR;
-                wake_up(&buf->vb.done);
-                printk("%s/0: [%p/%d] timeout - dma=0x%08lx\n", dev->core->name,
-                       buf, buf->vb.i, (unsigned long)buf->risc.dma);
-        }
-        cx8800_restart_vbi_queue(dev,q);
-        spin_unlock_irqrestore(&dev->slock,flags);
-}
-
 /* ------------------------------------------------------------------ */
 
-static int
-vbi_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
+static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
+                           unsigned int *num_buffers, unsigned int *num_planes,
+                           unsigned int sizes[], void *alloc_ctxs[])
 {
-        *size = VBI_LINE_COUNT * VBI_LINE_LENGTH * 2;
-        if (0 == *count)
-                *count = vbibufs;
-        if (*count < 2)
-                *count = 2;
-        if (*count > 32)
-                *count = 32;
+        struct cx8800_dev *dev = q->drv_priv;
+
+        *num_planes = 1;
+        if (dev->core->tvnorm & V4L2_STD_525_60)
+                sizes[0] = VBI_LINE_NTSC_COUNT * VBI_LINE_LENGTH * 2;
+        else
+                sizes[0] = VBI_LINE_PAL_COUNT * VBI_LINE_LENGTH * 2;
         return 0;
 }
 
-static int
-vbi_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
-            enum v4l2_field field)
+
+static int buffer_prepare(struct vb2_buffer *vb)
 {
-        struct cx8800_fh   *fh  = q->priv_data;
-        struct cx8800_dev  *dev = fh->dev;
-        struct cx88_buffer *buf = container_of(vb,struct cx88_buffer,vb);
+        struct cx8800_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
+        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+        unsigned int lines;
         unsigned int size;
         int rc;
 
-        size = VBI_LINE_COUNT * VBI_LINE_LENGTH * 2;
-        if (0 != buf->vb.baddr  &&  buf->vb.bsize < size)
+        if (dev->core->tvnorm & V4L2_STD_525_60)
+                lines = VBI_LINE_NTSC_COUNT;
+        else
+                lines = VBI_LINE_PAL_COUNT;
+        size = lines * VBI_LINE_LENGTH * 2;
+        if (vb2_plane_size(vb, 0) < size)
                 return -EINVAL;
+        vb2_set_plane_payload(vb, 0, size);
 
-        if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
-                struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
-                buf->vb.width  = VBI_LINE_LENGTH;
-                buf->vb.height = VBI_LINE_COUNT;
-                buf->vb.size   = size;
-                buf->vb.field  = V4L2_FIELD_SEQ_TB;
-
-                if (0 != (rc = videobuf_iolock(q,&buf->vb,NULL)))
-                        goto fail;
-                cx88_risc_buffer(dev->pci, &buf->risc,
-                                 dma->sglist,
-                                 0, buf->vb.width * buf->vb.height,
-                                 buf->vb.width, 0,
-                                 buf->vb.height);
-        }
-        buf->vb.state = VIDEOBUF_PREPARED;
+        rc = dma_map_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
+        if (!rc)
+                return -EIO;
+
+        cx88_risc_buffer(dev->pci, &buf->risc, sgt->sgl,
+                         0, VBI_LINE_LENGTH * lines,
+                         VBI_LINE_LENGTH, 0,
+                         lines);
         return 0;
+}
 
- fail:
-        cx88_free_buffer(q,buf);
-        return rc;
+static void buffer_finish(struct vb2_buffer *vb)
+{
+        struct cx8800_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
+        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+        struct cx88_riscmem *risc = &buf->risc;
+
+        if (risc->cpu)
+                pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+        memset(risc, 0, sizeof(*risc));
+
+        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
-static void
-vbi_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
+static void buffer_queue(struct vb2_buffer *vb)
 {
-        struct cx88_buffer    *buf = container_of(vb,struct cx88_buffer,vb);
+        struct cx8800_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer    *buf = container_of(vb, struct cx88_buffer, vb);
         struct cx88_buffer    *prev;
-        struct cx8800_fh      *fh   = vq->priv_data;
-        struct cx8800_dev     *dev  = fh->dev;
         struct cx88_dmaqueue  *q    = &dev->vbiq;
 
-        /* add jump to stopper */
-        buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
-        buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma);
+        /* add jump to start */
+        buf->risc.cpu[1] = cpu_to_le32(buf->risc.dma + 8);
+        buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_CNT_INC);
+        buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma + 8);
 
         if (list_empty(&q->active)) {
-                list_add_tail(&buf->vb.queue,&q->active);
+                list_add_tail(&buf->list, &q->active);
                 cx8800_start_vbi_dma(dev, q, buf);
-                buf->vb.state = VIDEOBUF_ACTIVE;
                 buf->count    = q->count++;
-                mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
                 dprintk(2,"[%p/%d] vbi_queue - first active\n",
-                        buf, buf->vb.i);
+                        buf, buf->vb.v4l2_buf.index);
 
         } else {
-                prev = list_entry(q->active.prev, struct cx88_buffer, vb.queue);
-                list_add_tail(&buf->vb.queue,&q->active);
-                buf->vb.state = VIDEOBUF_ACTIVE;
+                buf->risc.cpu[0] |= cpu_to_le32(RISC_IRQ1);
+                prev = list_entry(q->active.prev, struct cx88_buffer, list);
+                list_add_tail(&buf->list, &q->active);
                 buf->count    = q->count++;
                 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
                 dprintk(2,"[%p/%d] buffer_queue - append to active\n",
-                        buf, buf->vb.i);
+                        buf, buf->vb.v4l2_buf.index);
         }
 }
 
-static void vbi_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
+static int start_streaming(struct vb2_queue *q, unsigned int count)
 {
-        struct cx88_buffer *buf = container_of(vb,struct cx88_buffer,vb);
+        struct cx8800_dev *dev = q->drv_priv;
+        struct cx88_dmaqueue *dmaq = &dev->vbiq;
+        struct cx88_buffer *buf = list_entry(dmaq->active.next,
+                        struct cx88_buffer, list);
 
-        cx88_free_buffer(q,buf);
+        cx8800_start_vbi_dma(dev, dmaq, buf);
+        return 0;
 }
 
-const struct videobuf_queue_ops cx8800_vbi_qops = {
-        .buf_setup    = vbi_setup,
-        .buf_prepare  = vbi_prepare,
-        .buf_queue    = vbi_queue,
-        .buf_release  = vbi_release,
-};
+static void stop_streaming(struct vb2_queue *q)
+{
+        struct cx8800_dev *dev = q->drv_priv;
+        struct cx88_core *core = dev->core;
+        struct cx88_dmaqueue *dmaq = &dev->vbiq;
+        unsigned long flags;
 
-/* ------------------------------------------------------------------ */
-/*
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
+        cx_clear(MO_VID_DMACNTRL, 0x11);
+        cx_clear(VID_CAPTURE_CONTROL, 0x06);
+        cx8800_stop_vbi_dma(dev);
+        spin_lock_irqsave(&dev->slock, flags);
+        while (!list_empty(&dmaq->active)) {
+                struct cx88_buffer *buf = list_entry(dmaq->active.next,
+                        struct cx88_buffer, list);
+
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+        }
+        spin_unlock_irqrestore(&dev->slock, flags);
+}
+
+const struct vb2_ops cx8800_vbi_qops = {
+        .queue_setup    = queue_setup,
+        .buf_prepare  = buffer_prepare,
+        .buf_finish = buffer_finish,
+        .buf_queue    = buffer_queue,
+        .wait_prepare = vb2_ops_wait_prepare,
+        .wait_finish = vb2_ops_wait_finish,
+        .start_streaming = start_streaming,
+        .stop_streaming = stop_streaming,
+};
diff --git a/drivers/media/pci/cx88/cx88-video.c b/drivers/media/pci/cx88/cx88-video.c
index ce27e6d4f16e..a64ae31ae142 100644
--- a/drivers/media/pci/cx88/cx88-video.c
+++ b/drivers/media/pci/cx88/cx88-video.c
@@ -70,10 +70,6 @@ static unsigned int irq_debug;
 module_param(irq_debug,int,0644);
 MODULE_PARM_DESC(irq_debug,"enable debug messages [IRQ handler]");
 
-static unsigned int vid_limit = 16;
-module_param(vid_limit,int,0644);
-MODULE_PARM_DESC(vid_limit,"capture memory limit in megabytes");
-
 #define dprintk(level,fmt, arg...)      if (video_debug >= level) \
         printk(KERN_DEBUG "%s/0: " fmt, core->name , ## arg)
 
@@ -297,56 +293,6 @@ enum {
         CX8800_AUD_CTLS = ARRAY_SIZE(cx8800_aud_ctls),
 };
 
-/* ------------------------------------------------------------------- */
-/* resource management                                                 */
-
-static int res_get(struct cx8800_dev *dev, struct cx8800_fh *fh, unsigned int bit)
-{
-        struct cx88_core *core = dev->core;
-        if (fh->resources & bit)
-                /* have it already allocated */
-                return 1;
-
-        /* is it free? */
-        mutex_lock(&core->lock);
-        if (dev->resources & bit) {
-                /* no, someone else uses it */
-                mutex_unlock(&core->lock);
-                return 0;
-        }
-        /* it's free, grab it */
-        fh->resources  |= bit;
-        dev->resources |= bit;
-        dprintk(1,"res: get %d\n",bit);
-        mutex_unlock(&core->lock);
-        return 1;
-}
-
-static
-int res_check(struct cx8800_fh *fh, unsigned int bit)
-{
-        return (fh->resources & bit);
-}
-
-static
-int res_locked(struct cx8800_dev *dev, unsigned int bit)
-{
-        return (dev->resources & bit);
-}
-
-static
-void res_free(struct cx8800_dev *dev, struct cx8800_fh *fh, unsigned int bits)
-{
-        struct cx88_core *core = dev->core;
-        BUG_ON((fh->resources & bits) != bits);
-
-        mutex_lock(&core->lock);
-        fh->resources  &= ~bits;
-        dev->resources &= ~bits;
-        dprintk(1,"res: put %d\n",bits);
-        mutex_unlock(&core->lock);
-}
-
 /* ------------------------------------------------------------------ */
 
 int cx88_video_mux(struct cx88_core *core, unsigned int input)
@@ -419,8 +365,8 @@ static int start_video_dma(struct cx8800_dev    *dev,
         /* setup fifo + format */
         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH21],
                                 buf->bpl, buf->risc.dma);
-        cx88_set_scale(core, buf->vb.width, buf->vb.height, buf->vb.field);
-        cx_write(MO_COLOR_CTRL, buf->fmt->cxformat | ColorFormatGamma);
+        cx88_set_scale(core, core->width, core->height, core->field);
+        cx_write(MO_COLOR_CTRL, dev->fmt->cxformat | ColorFormatGamma);
 
         /* reset counter */
         cx_write(MO_VIDY_GPCNTRL,GP_COUNT_CONTROL_RESET);
@@ -470,433 +416,211 @@ static int restart_video_queue(struct cx8800_dev    *dev,
                                struct cx88_dmaqueue *q)
 {
         struct cx88_core *core = dev->core;
-        struct cx88_buffer *buf, *prev;
+        struct cx88_buffer *buf;
 
         if (!list_empty(&q->active)) {
-                buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
+                buf = list_entry(q->active.next, struct cx88_buffer, list);
                 dprintk(2,"restart_queue [%p/%d]: restart dma\n",
-                        buf, buf->vb.i);
+                        buf, buf->vb.v4l2_buf.index);
                 start_video_dma(dev, q, buf);
-                list_for_each_entry(buf, &q->active, vb.queue)
+                list_for_each_entry(buf, &q->active, list)
                         buf->count = q->count++;
-                mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
-                return 0;
-        }
-
-        prev = NULL;
-        for (;;) {
-                if (list_empty(&q->queued))
-                        return 0;
-                buf = list_entry(q->queued.next, struct cx88_buffer, vb.queue);
-                if (NULL == prev) {
-                        list_move_tail(&buf->vb.queue, &q->active);
-                        start_video_dma(dev, q, buf);
-                        buf->vb.state = VIDEOBUF_ACTIVE;
-                        buf->count    = q->count++;
-                        mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
-                        dprintk(2,"[%p/%d] restart_queue - first active\n",
-                                buf,buf->vb.i);
-
-                } else if (prev->vb.width  == buf->vb.width  &&
-                           prev->vb.height == buf->vb.height &&
-                           prev->fmt       == buf->fmt) {
-                        list_move_tail(&buf->vb.queue, &q->active);
-                        buf->vb.state = VIDEOBUF_ACTIVE;
-                        buf->count    = q->count++;
-                        prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
-                        dprintk(2,"[%p/%d] restart_queue - move to active\n",
-                                buf,buf->vb.i);
-                } else {
-                        return 0;
-                }
-                prev = buf;
         }
+        return 0;
 }
 
 /* ------------------------------------------------------------------ */
 
-static int
-buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
+static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
+                           unsigned int *num_buffers, unsigned int *num_planes,
+                           unsigned int sizes[], void *alloc_ctxs[])
 {
-        struct cx8800_fh *fh = q->priv_data;
-        struct cx8800_dev  *dev = fh->dev;
-
-        *size = dev->fmt->depth * dev->width * dev->height >> 3;
-        if (0 == *count)
-                *count = 32;
-        if (*size * *count > vid_limit * 1024 * 1024)
-                *count = (vid_limit * 1024 * 1024) / *size;
+        struct cx8800_dev *dev = q->drv_priv;
+        struct cx88_core *core = dev->core;
+
+        *num_planes = 1;
+        sizes[0] = (dev->fmt->depth * core->width * core->height) >> 3;
         return 0;
 }
 
-static int
-buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
-               enum v4l2_field field)
+static int buffer_prepare(struct vb2_buffer *vb)
 {
-        struct cx8800_fh   *fh  = q->priv_data;
-        struct cx8800_dev  *dev = fh->dev;
+        struct cx8800_dev *dev = vb->vb2_queue->drv_priv;
         struct cx88_core *core = dev->core;
-        struct cx88_buffer *buf = container_of(vb,struct cx88_buffer,vb);
-        struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
-        int rc, init_buffer = 0;
+        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
+        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+        int rc;
 
-        BUG_ON(NULL == dev->fmt);
-        if (dev->width  < 48 || dev->width  > norm_maxw(core->tvnorm) ||
-            dev->height < 32 || dev->height > norm_maxh(core->tvnorm))
-                return -EINVAL;
-        buf->vb.size = (dev->width * dev->height * dev->fmt->depth) >> 3;
-        if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
-                return -EINVAL;
+        buf->bpl = core->width * dev->fmt->depth >> 3;
 
-        if (buf->fmt       != dev->fmt    ||
-            buf->vb.width  != dev->width  ||
-            buf->vb.height != dev->height ||
-            buf->vb.field  != field) {
-                buf->fmt       = dev->fmt;
-                buf->vb.width  = dev->width;
-                buf->vb.height = dev->height;
-                buf->vb.field  = field;
-                init_buffer = 1;
-        }
+        if (vb2_plane_size(vb, 0) < core->height * buf->bpl)
+                return -EINVAL;
+        vb2_set_plane_payload(vb, 0, core->height * buf->bpl);
 
-        if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
-                init_buffer = 1;
-                if (0 != (rc = videobuf_iolock(q,&buf->vb,NULL)))
-                        goto fail;
-        }
+        rc = dma_map_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
+        if (!rc)
+                return -EIO;
 
-        if (init_buffer) {
-                buf->bpl = buf->vb.width * buf->fmt->depth >> 3;
-                switch (buf->vb.field) {
-                case V4L2_FIELD_TOP:
-                        cx88_risc_buffer(dev->pci, &buf->risc,
-                                         dma->sglist, 0, UNSET,
-                                         buf->bpl, 0, buf->vb.height);
-                        break;
-                case V4L2_FIELD_BOTTOM:
-                        cx88_risc_buffer(dev->pci, &buf->risc,
-                                         dma->sglist, UNSET, 0,
-                                         buf->bpl, 0, buf->vb.height);
-                        break;
-                case V4L2_FIELD_INTERLACED:
-                        cx88_risc_buffer(dev->pci, &buf->risc,
-                                         dma->sglist, 0, buf->bpl,
-                                         buf->bpl, buf->bpl,
-                                         buf->vb.height >> 1);
-                        break;
-                case V4L2_FIELD_SEQ_TB:
-                        cx88_risc_buffer(dev->pci, &buf->risc,
-                                         dma->sglist,
-                                         0, buf->bpl * (buf->vb.height >> 1),
-                                         buf->bpl, 0,
-                                         buf->vb.height >> 1);
-                        break;
-                case V4L2_FIELD_SEQ_BT:
-                        cx88_risc_buffer(dev->pci, &buf->risc,
-                                         dma->sglist,
-                                         buf->bpl * (buf->vb.height >> 1), 0,
-                                         buf->bpl, 0,
-                                         buf->vb.height >> 1);
-                        break;
-                default:
-                        BUG();
-                }
+        switch (core->field) {
+        case V4L2_FIELD_TOP:
+                cx88_risc_buffer(dev->pci, &buf->risc,
+                                 sgt->sgl, 0, UNSET,
+                                 buf->bpl, 0, core->height);
+                break;
+        case V4L2_FIELD_BOTTOM:
+                cx88_risc_buffer(dev->pci, &buf->risc,
+                                 sgt->sgl, UNSET, 0,
+                                 buf->bpl, 0, core->height);
+                break;
+        case V4L2_FIELD_SEQ_TB:
+                cx88_risc_buffer(dev->pci, &buf->risc,
+                                 sgt->sgl,
+                                 0, buf->bpl * (core->height >> 1),
+                                 buf->bpl, 0,
+                                 core->height >> 1);
+                break;
+        case V4L2_FIELD_SEQ_BT:
+                cx88_risc_buffer(dev->pci, &buf->risc,
+                                 sgt->sgl,
+                                 buf->bpl * (core->height >> 1), 0,
+                                 buf->bpl, 0,
+                                 core->height >> 1);
+                break;
+        case V4L2_FIELD_INTERLACED:
+        default:
+                cx88_risc_buffer(dev->pci, &buf->risc,
+                                 sgt->sgl, 0, buf->bpl,
+                                 buf->bpl, buf->bpl,
+                                 core->height >> 1);
+                break;
         }
         dprintk(2,"[%p/%d] buffer_prepare - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
-                buf, buf->vb.i,
-                dev->width, dev->height, dev->fmt->depth, dev->fmt->name,
+                buf, buf->vb.v4l2_buf.index,
+                core->width, core->height, dev->fmt->depth, dev->fmt->name,
                 (unsigned long)buf->risc.dma);
-
-        buf->vb.state = VIDEOBUF_PREPARED;
         return 0;
+}
+
+static void buffer_finish(struct vb2_buffer *vb)
+{
+        struct cx8800_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
+        struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
+        struct cx88_riscmem *risc = &buf->risc;
+
+        if (risc->cpu)
+                pci_free_consistent(dev->pci, risc->size, risc->cpu, risc->dma);
+        memset(risc, 0, sizeof(*risc));
 
- fail:
-        cx88_free_buffer(q,buf);
-        return rc;
+        dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
 }
 
-static void
-buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
+static void buffer_queue(struct vb2_buffer *vb)
 {
-        struct cx88_buffer    *buf = container_of(vb,struct cx88_buffer,vb);
+        struct cx8800_dev *dev = vb->vb2_queue->drv_priv;
+        struct cx88_buffer    *buf = container_of(vb, struct cx88_buffer, vb);
         struct cx88_buffer    *prev;
-        struct cx8800_fh      *fh   = vq->priv_data;
-        struct cx8800_dev     *dev  = fh->dev;
         struct cx88_core      *core = dev->core;
         struct cx88_dmaqueue  *q    = &dev->vidq;
 
-        /* add jump to stopper */
-        buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
-        buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma);
+        /* add jump to start */
+        buf->risc.cpu[1] = cpu_to_le32(buf->risc.dma + 8);
+        buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_CNT_INC);
+        buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma + 8);
 
-        if (!list_empty(&q->queued)) {
-                list_add_tail(&buf->vb.queue,&q->queued);
-                buf->vb.state = VIDEOBUF_QUEUED;
-                dprintk(2,"[%p/%d] buffer_queue - append to queued\n",
-                        buf, buf->vb.i);
-
-        } else if (list_empty(&q->active)) {
-                list_add_tail(&buf->vb.queue,&q->active);
+        if (list_empty(&q->active)) {
+                list_add_tail(&buf->list, &q->active);
                 start_video_dma(dev, q, buf);
-                buf->vb.state = VIDEOBUF_ACTIVE;
                 buf->count    = q->count++;
-                mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
                 dprintk(2,"[%p/%d] buffer_queue - first active\n",
-                        buf, buf->vb.i);
+                        buf, buf->vb.v4l2_buf.index);
 
         } else {
-                prev = list_entry(q->active.prev, struct cx88_buffer, vb.queue);
-                if (prev->vb.width  == buf->vb.width  &&
-                    prev->vb.height == buf->vb.height &&
-                    prev->fmt       == buf->fmt) {
-                        list_add_tail(&buf->vb.queue,&q->active);
-                        buf->vb.state = VIDEOBUF_ACTIVE;
-                        buf->count    = q->count++;
-                        prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
-                        dprintk(2,"[%p/%d] buffer_queue - append to active\n",
-                                buf, buf->vb.i);
-
-                } else {
-                        list_add_tail(&buf->vb.queue,&q->queued);
-                        buf->vb.state = VIDEOBUF_QUEUED;
-                        dprintk(2,"[%p/%d] buffer_queue - first queued\n",
-                                buf, buf->vb.i);
-                }
+                buf->risc.cpu[0] |= cpu_to_le32(RISC_IRQ1);
+                prev = list_entry(q->active.prev, struct cx88_buffer, list);
+                list_add_tail(&buf->list, &q->active);
+                buf->count    = q->count++;
+                prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
+                dprintk(2, "[%p/%d] buffer_queue - append to active\n",
+                        buf, buf->vb.v4l2_buf.index);
         }
 }
 
-static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
+static int start_streaming(struct vb2_queue *q, unsigned int count)
 {
-        struct cx88_buffer *buf = container_of(vb,struct cx88_buffer,vb);
+        struct cx8800_dev *dev = q->drv_priv;
+        struct cx88_dmaqueue *dmaq = &dev->vidq;
+        struct cx88_buffer *buf = list_entry(dmaq->active.next,
+                        struct cx88_buffer, list);
 
-        cx88_free_buffer(q,buf);
+        start_video_dma(dev, dmaq, buf);
+        return 0;
 }
 
-static const struct videobuf_queue_ops cx8800_video_qops = {
-        .buf_setup    = buffer_setup,
-        .buf_prepare  = buffer_prepare,
-        .buf_queue    = buffer_queue,
-        .buf_release  = buffer_release,
-};
-
-/* ------------------------------------------------------------------ */
-
-
-/* ------------------------------------------------------------------ */
-
-static struct videobuf_queue *get_queue(struct file *file)
+static void stop_streaming(struct vb2_queue *q)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct cx8800_fh *fh = file->private_data;
+        struct cx8800_dev *dev = q->drv_priv;
+        struct cx88_core *core = dev->core;
+        struct cx88_dmaqueue *dmaq = &dev->vidq;
+        unsigned long flags;
 
-        switch (vdev->vfl_type) {
-        case VFL_TYPE_GRABBER:
-                return &fh->vidq;
-        case VFL_TYPE_VBI:
-                return &fh->vbiq;
-        default:
-                BUG();
+        cx_clear(MO_VID_DMACNTRL, 0x11);
+        cx_clear(VID_CAPTURE_CONTROL, 0x06);
+        spin_lock_irqsave(&dev->slock, flags);
+        while (!list_empty(&dmaq->active)) {
+                struct cx88_buffer *buf = list_entry(dmaq->active.next,
+                        struct cx88_buffer, list);
+
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
         }
+        spin_unlock_irqrestore(&dev->slock, flags);
 }
 
-static int get_resource(struct file *file)
-{
-        struct video_device *vdev = video_devdata(file);
+static struct vb2_ops cx8800_video_qops = {
+        .queue_setup    = queue_setup,
+        .buf_prepare  = buffer_prepare,
+        .buf_finish = buffer_finish,
+        .buf_queue    = buffer_queue,
+        .wait_prepare = vb2_ops_wait_prepare,
+        .wait_finish = vb2_ops_wait_finish,
+        .start_streaming = start_streaming,
+        .stop_streaming = stop_streaming,
+};
 
-        switch (vdev->vfl_type) {
-        case VFL_TYPE_GRABBER:
-                return RESOURCE_VIDEO;
-        case VFL_TYPE_VBI:
-                return RESOURCE_VBI;
-        default:
-                BUG();
-        }
-}
+/* ------------------------------------------------------------------ */
 
-static int video_open(struct file *file)
+static int radio_open(struct file *file)
 {
-        struct video_device *vdev = video_devdata(file);
         struct cx8800_dev *dev = video_drvdata(file);
         struct cx88_core *core = dev->core;
-        struct cx8800_fh *fh;
-        enum v4l2_buf_type type = 0;
-        int radio = 0;
+        int ret = v4l2_fh_open(file);
 
-        switch (vdev->vfl_type) {
-        case VFL_TYPE_GRABBER:
-                type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-                break;
-        case VFL_TYPE_VBI:
-                type = V4L2_BUF_TYPE_VBI_CAPTURE;
-                break;
-        case VFL_TYPE_RADIO:
-                radio = 1;
-                break;
-        }
-
-        dprintk(1, "open dev=%s radio=%d type=%s\n",
-                video_device_node_name(vdev), radio, v4l2_type_names[type]);
-
-        /* allocate + initialize per filehandle data */
-        fh = kzalloc(sizeof(*fh),GFP_KERNEL);
-        if (unlikely(!fh))
-                return -ENOMEM;
-
-        v4l2_fh_init(&fh->fh, vdev);
-        file->private_data = fh;
-        fh->dev      = dev;
+        if (ret)
+                return ret;
 
-        mutex_lock(&core->lock);
-
-        videobuf_queue_sg_init(&fh->vidq, &cx8800_video_qops,
-                            &dev->pci->dev, &dev->slock,
-                            V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                            V4L2_FIELD_INTERLACED,
-                            sizeof(struct cx88_buffer),
-                            fh, NULL);
-        videobuf_queue_sg_init(&fh->vbiq, &cx8800_vbi_qops,
-                            &dev->pci->dev, &dev->slock,
-                            V4L2_BUF_TYPE_VBI_CAPTURE,
-                            V4L2_FIELD_SEQ_TB,
-                            sizeof(struct cx88_buffer),
-                            fh, NULL);
-
-        if (vdev->vfl_type == VFL_TYPE_RADIO) {
-                dprintk(1,"video_open: setting radio device\n");
-                cx_write(MO_GP3_IO, core->board.radio.gpio3);
-                cx_write(MO_GP0_IO, core->board.radio.gpio0);
-                cx_write(MO_GP1_IO, core->board.radio.gpio1);
-                cx_write(MO_GP2_IO, core->board.radio.gpio2);
-                if (core->board.radio.audioroute) {
-                        if (core->sd_wm8775) {
-                                call_all(core, audio, s_routing,
+        cx_write(MO_GP3_IO, core->board.radio.gpio3);
+        cx_write(MO_GP0_IO, core->board.radio.gpio0);
+        cx_write(MO_GP1_IO, core->board.radio.gpio1);
+        cx_write(MO_GP2_IO, core->board.radio.gpio2);
+        if (core->board.radio.audioroute) {
+                if (core->sd_wm8775) {
+                        call_all(core, audio, s_routing,
                                         core->board.radio.audioroute, 0, 0);
-                        }
-                        /* "I2S ADC mode" */
-                        core->tvaudio = WW_I2SADC;
-                        cx88_set_tvaudio(core);
-                } else {
-                        /* FM Mode */
-                        core->tvaudio = WW_FM;
-                        cx88_set_tvaudio(core);
-                        cx88_set_stereo(core,V4L2_TUNER_MODE_STEREO,1);
                 }
-                call_all(core, tuner, s_radio);
-        }
-
-        core->users++;
-        mutex_unlock(&core->lock);
-        v4l2_fh_add(&fh->fh);
-
-        return 0;
-}
-
-static ssize_t
-video_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
-{
-        struct video_device *vdev = video_devdata(file);
-        struct cx8800_fh *fh = file->private_data;
-
-        switch (vdev->vfl_type) {
-        case VFL_TYPE_GRABBER:
-                if (res_locked(fh->dev,RESOURCE_VIDEO))
-                        return -EBUSY;
-                return videobuf_read_one(&fh->vidq, data, count, ppos,
-                                         file->f_flags & O_NONBLOCK);
-        case VFL_TYPE_VBI:
-                if (!res_get(fh->dev,fh,RESOURCE_VBI))
-                        return -EBUSY;
-                return videobuf_read_stream(&fh->vbiq, data, count, ppos, 1,
-                                            file->f_flags & O_NONBLOCK);
-        default:
-                BUG();
-        }
-}
-
-static unsigned int
-video_poll(struct file *file, struct poll_table_struct *wait)
-{
-        struct video_device *vdev = video_devdata(file);
-        struct cx8800_fh *fh = file->private_data;
-        struct cx88_buffer *buf;
-        unsigned int rc = v4l2_ctrl_poll(file, wait);
-
-        if (vdev->vfl_type == VFL_TYPE_VBI) {
-                if (!res_get(fh->dev,fh,RESOURCE_VBI))
-                        return rc | POLLERR;
-                return rc | videobuf_poll_stream(file, &fh->vbiq, wait);
-        }
-        mutex_lock(&fh->vidq.vb_lock);
-        if (res_check(fh,RESOURCE_VIDEO)) {
-                /* streaming capture */
-                if (list_empty(&fh->vidq.stream))
-                        goto done;
-                buf = list_entry(fh->vidq.stream.next,struct cx88_buffer,vb.stream);
+                /* "I2S ADC mode" */
+                core->tvaudio = WW_I2SADC;
+                cx88_set_tvaudio(core);
         } else {
-                /* read() capture */
-                buf = (struct cx88_buffer*)fh->vidq.read_buf;
-                if (NULL == buf)
-                        goto done;
-        }
-        poll_wait(file, &buf->vb.done, wait);
-        if (buf->vb.state == VIDEOBUF_DONE ||
-            buf->vb.state == VIDEOBUF_ERROR)
-                rc |= POLLIN|POLLRDNORM;
-done:
-        mutex_unlock(&fh->vidq.vb_lock);
-        return rc;
-}
-
-static int video_release(struct file *file)
-{
-        struct cx8800_fh  *fh  = file->private_data;
-        struct cx8800_dev *dev = fh->dev;
-
-        /* turn off overlay */
-        if (res_check(fh, RESOURCE_OVERLAY)) {
-                /* FIXME */
-                res_free(dev,fh,RESOURCE_OVERLAY);
-        }
-
-        /* stop video capture */
-        if (res_check(fh, RESOURCE_VIDEO)) {
-                videobuf_queue_cancel(&fh->vidq);
-                res_free(dev,fh,RESOURCE_VIDEO);
+                /* FM Mode */
+                core->tvaudio = WW_FM;
+                cx88_set_tvaudio(core);
+                cx88_set_stereo(core, V4L2_TUNER_MODE_STEREO, 1);
         }
-        if (fh->vidq.read_buf) {
-                buffer_release(&fh->vidq,fh->vidq.read_buf);
-                kfree(fh->vidq.read_buf);
-        }
-
-        /* stop vbi capture */
-        if (res_check(fh, RESOURCE_VBI)) {
-                videobuf_stop(&fh->vbiq);
-                res_free(dev,fh,RESOURCE_VBI);
-        }
-
-        videobuf_mmap_free(&fh->vidq);
-        videobuf_mmap_free(&fh->vbiq);
-
-        mutex_lock(&dev->core->lock);
-        v4l2_fh_del(&fh->fh);
-        v4l2_fh_exit(&fh->fh);
-        file->private_data = NULL;
-        kfree(fh);
-
-        dev->core->users--;
-        if (!dev->core->users)
-                call_all(dev->core, core, s_power, 0);
-        mutex_unlock(&dev->core->lock);
-
+        call_all(core, tuner, s_radio);
         return 0;
 }
 
-static int
-video_mmap(struct file *file, struct vm_area_struct * vma)
-{
-        return videobuf_mmap_mapper(get_queue(file), vma);
-}
-
 /* ------------------------------------------------------------------ */
 /* VIDEO CTRL IOCTLS                                                  */
 
@@ -999,12 +723,12 @@ static int cx8800_s_aud_ctrl(struct v4l2_ctrl *ctrl)
 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                         struct v4l2_format *f)
 {
-        struct cx8800_fh  *fh   = priv;
-        struct cx8800_dev *dev = fh->dev;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
-        f->fmt.pix.width        = dev->width;
-        f->fmt.pix.height       = dev->height;
-        f->fmt.pix.field        = fh->vidq.field;
+        f->fmt.pix.width        = core->width;
+        f->fmt.pix.height       = core->height;
+        f->fmt.pix.field        = core->field;
         f->fmt.pix.pixelformat  = dev->fmt->fourcc;
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * dev->fmt->depth) >> 3;
@@ -1017,7 +741,8 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                         struct v4l2_format *f)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
         const struct cx8800_fmt *fmt;
         enum v4l2_field   field;
         unsigned int      maxw, maxh;
@@ -1026,30 +751,30 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         if (NULL == fmt)
                 return -EINVAL;
 
-        field = f->fmt.pix.field;
-        maxw  = norm_maxw(core->tvnorm);
-        maxh  = norm_maxh(core->tvnorm);
+        maxw = norm_maxw(core->tvnorm);
+        maxh = norm_maxh(core->tvnorm);
 
-        if (V4L2_FIELD_ANY == field) {
-                field = (f->fmt.pix.height > maxh/2)
-                        ? V4L2_FIELD_INTERLACED
-                        : V4L2_FIELD_BOTTOM;
-        }
+        field = f->fmt.pix.field;
 
         switch (field) {
         case V4L2_FIELD_TOP:
         case V4L2_FIELD_BOTTOM:
-                maxh = maxh / 2;
-                break;
         case V4L2_FIELD_INTERLACED:
+        case V4L2_FIELD_SEQ_BT:
+        case V4L2_FIELD_SEQ_TB:
                 break;
         default:
-                return -EINVAL;
+                field = (f->fmt.pix.height > maxh / 2)
+                        ? V4L2_FIELD_INTERLACED
+                        : V4L2_FIELD_BOTTOM;
+                break;
         }
+        if (V4L2_FIELD_HAS_T_OR_B(field))
+                maxh /= 2;
 
-        f->fmt.pix.field = field;
         v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
                               &f->fmt.pix.height, 32, maxh, 0, 0);
+        f->fmt.pix.field = field;
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * fmt->depth) >> 3;
         f->fmt.pix.sizeimage =
@@ -1061,16 +786,20 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                                         struct v4l2_format *f)
 {
-        struct cx8800_fh  *fh   = priv;
-        struct cx8800_dev *dev = fh->dev;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
         int err = vidioc_try_fmt_vid_cap (file,priv,f);
 
         if (0 != err)
                 return err;
-        dev->fmt        = format_by_fourcc(f->fmt.pix.pixelformat);
-        dev->width      = f->fmt.pix.width;
-        dev->height     = f->fmt.pix.height;
-        fh->vidq.field = f->fmt.pix.field;
+        if (vb2_is_busy(&dev->vb2_vidq) || vb2_is_busy(&dev->vb2_vbiq))
+                return -EBUSY;
+        if (core->dvbdev && vb2_is_busy(&core->dvbdev->vb2_mpegq))
+                return -EBUSY;
+        dev->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
+        core->width = f->fmt.pix.width;
+        core->height = f->fmt.pix.height;
+        core->field = f->fmt.pix.field;
         return 0;
 }
 
@@ -1104,8 +833,8 @@ EXPORT_SYMBOL(cx88_querycap);
 static int vidioc_querycap(struct file *file, void  *priv,
                                         struct v4l2_capability *cap)
 {
-        struct cx8800_dev *dev  = ((struct cx8800_fh *)priv)->dev;
-        struct cx88_core  *core = dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         strcpy(cap->driver, "cx8800");
         sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
@@ -1125,64 +854,10 @@ static int vidioc_enum_fmt_vid_cap (struct file *file, void  *priv,
         return 0;
 }
 
-static int vidioc_reqbufs (struct file *file, void *priv, struct v4l2_requestbuffers *p)
-{
-        return videobuf_reqbufs(get_queue(file), p);
-}
-
-static int vidioc_querybuf (struct file *file, void *priv, struct v4l2_buffer *p)
-{
-        return videobuf_querybuf(get_queue(file), p);
-}
-
-static int vidioc_qbuf (struct file *file, void *priv, struct v4l2_buffer *p)
-{
-        return videobuf_qbuf(get_queue(file), p);
-}
-
-static int vidioc_dqbuf (struct file *file, void *priv, struct v4l2_buffer *p)
-{
-        return videobuf_dqbuf(get_queue(file), p,
-                                file->f_flags & O_NONBLOCK);
-}
-
-static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
-{
-        struct video_device *vdev = video_devdata(file);
-        struct cx8800_fh  *fh   = priv;
-        struct cx8800_dev *dev  = fh->dev;
-
-        if ((vdev->vfl_type == VFL_TYPE_GRABBER && i != V4L2_BUF_TYPE_VIDEO_CAPTURE) ||
-            (vdev->vfl_type == VFL_TYPE_VBI && i != V4L2_BUF_TYPE_VBI_CAPTURE))
-                return -EINVAL;
-
-        if (unlikely(!res_get(dev, fh, get_resource(file))))
-                return -EBUSY;
-        return videobuf_streamon(get_queue(file));
-}
-
-static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
-{
-        struct video_device *vdev = video_devdata(file);
-        struct cx8800_fh  *fh   = priv;
-        struct cx8800_dev *dev  = fh->dev;
-        int               err, res;
-
-        if ((vdev->vfl_type == VFL_TYPE_GRABBER && i != V4L2_BUF_TYPE_VIDEO_CAPTURE) ||
-            (vdev->vfl_type == VFL_TYPE_VBI && i != V4L2_BUF_TYPE_VBI_CAPTURE))
-                return -EINVAL;
-
-        res = get_resource(file);
-        err = videobuf_streamoff(get_queue(file));
-        if (err < 0)
-                return err;
-        res_free(dev,fh,res);
-        return 0;
-}
-
 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm)
 {
-        struct cx88_core *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         *tvnorm = core->tvnorm;
         return 0;
@@ -1190,13 +865,10 @@ static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm)
 
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id tvnorms)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
-
-        mutex_lock(&core->lock);
-        cx88_set_tvnorm(core, tvnorms);
-        mutex_unlock(&core->lock);
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
-        return 0;
+        return cx88_set_tvnorm(core, tvnorms);
 }
 
 /* only one input in this sample driver */
@@ -1233,13 +905,15 @@ EXPORT_SYMBOL(cx88_enum_input);
 static int vidioc_enum_input (struct file *file, void *priv,
                                 struct v4l2_input *i)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
         return cx88_enum_input (core,i);
 }
 
 static int vidioc_g_input (struct file *file, void *priv, unsigned int *i)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         *i = core->input;
         return 0;
@@ -1247,24 +921,24 @@ static int vidioc_g_input (struct file *file, void *priv, unsigned int *i)
 
 static int vidioc_s_input (struct file *file, void *priv, unsigned int i)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         if (i >= 4)
                 return -EINVAL;
         if (0 == INPUT(i).type)
                 return -EINVAL;
 
-        mutex_lock(&core->lock);
         cx88_newstation(core);
         cx88_video_mux(core,i);
-        mutex_unlock(&core->lock);
         return 0;
 }
 
 static int vidioc_g_tuner (struct file *file, void *priv,
                                 struct v4l2_tuner *t)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
         u32 reg;
 
         if (unlikely(UNSET == core->board.tuner_type))
@@ -1286,7 +960,8 @@ static int vidioc_g_tuner (struct file *file, void *priv,
 static int vidioc_s_tuner (struct file *file, void *priv,
                                 const struct v4l2_tuner *t)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         if (UNSET == core->board.tuner_type)
                 return -EINVAL;
@@ -1300,8 +975,8 @@ static int vidioc_s_tuner (struct file *file, void *priv,
 static int vidioc_g_frequency (struct file *file, void *priv,
                                 struct v4l2_frequency *f)
 {
-        struct cx8800_fh  *fh   = priv;
-        struct cx88_core  *core = fh->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         if (unlikely(UNSET == core->board.tuner_type))
                 return -EINVAL;
@@ -1325,7 +1000,6 @@ int cx88_set_freq (struct cx88_core  *core,
         if (unlikely(f->tuner != 0))
                 return -EINVAL;
 
-        mutex_lock(&core->lock);
         cx88_newstation(core);
         call_all(core, tuner, s_frequency, f);
         call_all(core, tuner, g_frequency, &new_freq);
@@ -1335,8 +1009,6 @@ int cx88_set_freq (struct cx88_core  *core,
         msleep (10);
         cx88_set_tvaudio(core);
 
-        mutex_unlock(&core->lock);
-
         return 0;
 }
 EXPORT_SYMBOL(cx88_set_freq);
@@ -1344,8 +1016,8 @@ EXPORT_SYMBOL(cx88_set_freq);
 static int vidioc_s_frequency (struct file *file, void *priv,
                                 const struct v4l2_frequency *f)
 {
-        struct cx8800_fh  *fh   = priv;
-        struct cx88_core  *core = fh->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         return cx88_set_freq(core, f);
 }
@@ -1354,7 +1026,8 @@ static int vidioc_s_frequency (struct file *file, void *priv,
 static int vidioc_g_register (struct file *file, void *fh,
                                 struct v4l2_dbg_register *reg)
 {
-        struct cx88_core *core = ((struct cx8800_fh*)fh)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         /* cx2388x has a 24-bit register space */
         reg->val = cx_read(reg->reg & 0xfffffc);
@@ -1365,7 +1038,8 @@ static int vidioc_g_register (struct file *file, void *fh,
 static int vidioc_s_register (struct file *file, void *fh,
                                 const struct v4l2_dbg_register *reg)
 {
-        struct cx88_core *core = ((struct cx8800_fh*)fh)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         cx_write(reg->reg & 0xfffffc, reg->val);
         return 0;
@@ -1379,7 +1053,8 @@ static int vidioc_s_register (struct file *file, void *fh,
 static int radio_g_tuner (struct file *file, void *priv,
                                 struct v4l2_tuner *t)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         if (unlikely(t->index > 0))
                 return -EINVAL;
@@ -1393,7 +1068,8 @@ static int radio_g_tuner (struct file *file, void *priv,
 static int radio_s_tuner (struct file *file, void *priv,
                                 const struct v4l2_tuner *t)
 {
-        struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
+        struct cx8800_dev *dev = video_drvdata(file);
+        struct cx88_core *core = dev->core;
 
         if (0 != t->index)
                 return -EINVAL;
@@ -1404,32 +1080,6 @@ static int radio_s_tuner (struct file *file, void *priv,
 
 /* ----------------------------------------------------------- */
 
-static void cx8800_vid_timeout(unsigned long data)
-{
-        struct cx8800_dev *dev = (struct cx8800_dev*)data;
-        struct cx88_core *core = dev->core;
-        struct cx88_dmaqueue *q = &dev->vidq;
-        struct cx88_buffer *buf;
-        unsigned long flags;
-
-        cx88_sram_channel_dump(core, &cx88_sram_channels[SRAM_CH21]);
-
-        cx_clear(MO_VID_DMACNTRL, 0x11);
-        cx_clear(VID_CAPTURE_CONTROL, 0x06);
-
-        spin_lock_irqsave(&dev->slock,flags);
-        while (!list_empty(&q->active)) {
-                buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
-                list_del(&buf->vb.queue);
-                buf->vb.state = VIDEOBUF_ERROR;
-                wake_up(&buf->vb.done);
-                printk("%s/0: [%p/%d] timeout - dma=0x%08lx\n", core->name,
-                       buf, buf->vb.i, (unsigned long)buf->risc.dma);
-        }
-        restart_video_queue(dev,q);
-        spin_unlock_irqrestore(&dev->slock,flags);
-}
-
 static const char *cx88_vid_irqs[32] = {
         "y_risci1", "u_risci1", "v_risci1", "vbi_risc1",
         "y_risci2", "u_risci2", "v_risci2", "vbi_risc2",
@@ -1476,22 +1126,6 @@ static void cx8800_vid_irq(struct cx8800_dev *dev)
                 cx88_wakeup(core, &dev->vbiq, count);
                 spin_unlock(&dev->slock);
         }
-
-        /* risc2 y */
-        if (status & 0x10) {
-                dprintk(2,"stopper video\n");
-                spin_lock(&dev->slock);
-                restart_video_queue(dev,&dev->vidq);
-                spin_unlock(&dev->slock);
-        }
-
-        /* risc2 vbi */
-        if (status & 0x80) {
-                dprintk(2,"stopper vbi\n");
-                spin_lock(&dev->slock);
-                cx8800_restart_vbi_queue(dev,&dev->vbiq);
-                spin_unlock(&dev->slock);
-        }
 }
 
 static irqreturn_t cx8800_irq(int irq, void *dev_id)
@@ -1530,11 +1164,11 @@ static irqreturn_t cx8800_irq(int irq, void *dev_id)
 static const struct v4l2_file_operations video_fops =
 {
         .owner         = THIS_MODULE,
-        .open          = video_open,
-        .release       = video_release,
-        .read          = video_read,
-        .poll          = video_poll,
-        .mmap          = video_mmap,
+        .open          = v4l2_fh_open,
+        .release       = vb2_fop_release,
+        .read          = vb2_fop_read,
+        .poll          = vb2_fop_poll,
+        .mmap          = vb2_fop_mmap,
         .unlocked_ioctl = video_ioctl2,
 };
 
@@ -1544,17 +1178,17 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
-        .vidioc_reqbufs       = vidioc_reqbufs,
-        .vidioc_querybuf      = vidioc_querybuf,
-        .vidioc_qbuf          = vidioc_qbuf,
-        .vidioc_dqbuf         = vidioc_dqbuf,
+        .vidioc_reqbufs       = vb2_ioctl_reqbufs,
+        .vidioc_querybuf      = vb2_ioctl_querybuf,
+        .vidioc_qbuf          = vb2_ioctl_qbuf,
+        .vidioc_dqbuf         = vb2_ioctl_dqbuf,
         .vidioc_g_std         = vidioc_g_std,
         .vidioc_s_std         = vidioc_s_std,
         .vidioc_enum_input    = vidioc_enum_input,
         .vidioc_g_input       = vidioc_g_input,
         .vidioc_s_input       = vidioc_s_input,
-        .vidioc_streamon      = vidioc_streamon,
-        .vidioc_streamoff     = vidioc_streamoff,
+        .vidioc_streamon      = vb2_ioctl_streamon,
+        .vidioc_streamoff     = vb2_ioctl_streamoff,
         .vidioc_g_tuner       = vidioc_g_tuner,
         .vidioc_s_tuner       = vidioc_s_tuner,
         .vidioc_g_frequency   = vidioc_g_frequency,
@@ -1579,17 +1213,17 @@ static const struct v4l2_ioctl_ops vbi_ioctl_ops = {
         .vidioc_g_fmt_vbi_cap     = cx8800_vbi_fmt,
         .vidioc_try_fmt_vbi_cap   = cx8800_vbi_fmt,
         .vidioc_s_fmt_vbi_cap     = cx8800_vbi_fmt,
-        .vidioc_reqbufs       = vidioc_reqbufs,
-        .vidioc_querybuf      = vidioc_querybuf,
-        .vidioc_qbuf          = vidioc_qbuf,
-        .vidioc_dqbuf         = vidioc_dqbuf,
+        .vidioc_reqbufs       = vb2_ioctl_reqbufs,
+        .vidioc_querybuf      = vb2_ioctl_querybuf,
+        .vidioc_qbuf          = vb2_ioctl_qbuf,
+        .vidioc_dqbuf         = vb2_ioctl_dqbuf,
         .vidioc_g_std         = vidioc_g_std,
         .vidioc_s_std         = vidioc_s_std,
         .vidioc_enum_input    = vidioc_enum_input,
         .vidioc_g_input       = vidioc_g_input,
         .vidioc_s_input       = vidioc_s_input,
-        .vidioc_streamon      = vidioc_streamon,
-        .vidioc_streamoff     = vidioc_streamoff,
+        .vidioc_streamon      = vb2_ioctl_streamon,
+        .vidioc_streamoff     = vb2_ioctl_streamoff,
         .vidioc_g_tuner       = vidioc_g_tuner,
         .vidioc_s_tuner       = vidioc_s_tuner,
         .vidioc_g_frequency   = vidioc_g_frequency,
@@ -1610,9 +1244,9 @@ static const struct video_device cx8800_vbi_template = {
 static const struct v4l2_file_operations radio_fops =
 {
         .owner         = THIS_MODULE,
-        .open          = video_open,
+        .open          = radio_open,
         .poll          = v4l2_ctrl_poll,
-        .release       = video_release,
+        .release       = v4l2_fh_release,
         .unlocked_ioctl = video_ioctl2,
 };
 
@@ -1676,6 +1310,7 @@ static int cx8800_initdev(struct pci_dev *pci_dev,
 {
         struct cx8800_dev *dev;
         struct cx88_core *core;
+        struct vb2_queue *q;
         int err;
         int i;
 
@@ -1713,25 +1348,12 @@ static int cx8800_initdev(struct pci_dev *pci_dev,
 
         /* initialize driver struct */
         spin_lock_init(&dev->slock);
-        core->tvnorm = V4L2_STD_NTSC_M;
 
         /* init video dma queues */
         INIT_LIST_HEAD(&dev->vidq.active);
-        INIT_LIST_HEAD(&dev->vidq.queued);
-        dev->vidq.timeout.function = cx8800_vid_timeout;
-        dev->vidq.timeout.data     = (unsigned long)dev;
-        init_timer(&dev->vidq.timeout);
-        cx88_risc_stopper(dev->pci,&dev->vidq.stopper,
-                          MO_VID_DMACNTRL,0x11,0x00);
 
         /* init vbi dma queues */
         INIT_LIST_HEAD(&dev->vbiq.active);
-        INIT_LIST_HEAD(&dev->vbiq.queued);
-        dev->vbiq.timeout.function = cx8800_vbi_timeout;
-        dev->vbiq.timeout.data     = (unsigned long)dev;
-        init_timer(&dev->vbiq.timeout);
-        cx88_risc_stopper(dev->pci,&dev->vbiq.stopper,
-                          MO_VID_DMACNTRL,0x88,0x00);
 
         /* get irq */
         err = request_irq(pci_dev->irq, cx8800_irq,
@@ -1820,9 +1442,10 @@ static int cx8800_initdev(struct pci_dev *pci_dev,
         /* Sets device info at pci_dev */
         pci_set_drvdata(pci_dev, dev);
 
-        dev->width   = 320;
-        dev->height  = 240;
-        dev->fmt     = format_by_fourcc(V4L2_PIX_FMT_BGR24);
+        dev->fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
+
+        /* Maintain a reference so cx88-blackbird can query the 8800 device. */
+        core->v4ldev = dev;
 
         /* initial device configuration */
         mutex_lock(&core->lock);
@@ -1831,11 +1454,44 @@ static int cx8800_initdev(struct pci_dev *pci_dev,
         v4l2_ctrl_handler_setup(&core->audio_hdl);
         cx88_video_mux(core, 0);
 
+        q = &dev->vb2_vidq;
+        q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
+        q->gfp_flags = GFP_DMA32;
+        q->min_buffers_needed = 2;
+        q->drv_priv = dev;
+        q->buf_struct_size = sizeof(struct cx88_buffer);
+        q->ops = &cx8800_video_qops;
+        q->mem_ops = &vb2_dma_sg_memops;
+        q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+        q->lock = &core->lock;
+
+        err = vb2_queue_init(q);
+        if (err < 0)
+                goto fail_unreg;
+
+        q = &dev->vb2_vbiq;
+        q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
+        q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
+        q->gfp_flags = GFP_DMA32;
+        q->min_buffers_needed = 2;
+        q->drv_priv = dev;
+        q->buf_struct_size = sizeof(struct cx88_buffer);
+        q->ops = &cx8800_vbi_qops;
+        q->mem_ops = &vb2_dma_sg_memops;
+        q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+        q->lock = &core->lock;
+
+        err = vb2_queue_init(q);
+        if (err < 0)
+                goto fail_unreg;
+
         /* register v4l devices */
         dev->video_dev = cx88_vdev_init(core,dev->pci,
                                         &cx8800_video_template,"video");
         video_set_drvdata(dev->video_dev, dev);
         dev->video_dev->ctrl_handler = &core->video_hdl;
+        dev->video_dev->queue = &dev->vb2_vidq;
         err = video_register_device(dev->video_dev,VFL_TYPE_GRABBER,
                                     video_nr[core->nr]);
         if (err < 0) {
@@ -1848,6 +1504,7 @@ static int cx8800_initdev(struct pci_dev *pci_dev,
 
         dev->vbi_dev = cx88_vdev_init(core,dev->pci,&cx8800_vbi_template,"vbi");
         video_set_drvdata(dev->vbi_dev, dev);
+        dev->vbi_dev->queue = &dev->vb2_vbiq;
         err = video_register_device(dev->vbi_dev,VFL_TYPE_VBI,
                                     vbi_nr[core->nr]);
         if (err < 0) {
@@ -1875,7 +1532,7 @@ static int cx8800_initdev(struct pci_dev *pci_dev,
         }
 
         /* start tvaudio thread */
-        if (core->board.tuner_type != TUNER_ABSENT) {
+        if (core->board.tuner_type != UNSET) {
                 core->kthread = kthread_run(cx88_audio_thread, core, "cx88 tvaudio");
                 if (IS_ERR(core->kthread)) {
                         err = PTR_ERR(core->kthread);
@@ -1892,6 +1549,7 @@ fail_unreg:
         free_irq(pci_dev->irq, dev);
         mutex_unlock(&core->lock);
 fail_core:
+        core->v4ldev = NULL;
         cx88_core_put(core,dev->pci);
 fail_free:
         kfree(dev);
@@ -1913,15 +1571,16 @@ static void cx8800_finidev(struct pci_dev *pci_dev)
                 cx88_ir_stop(core);
 
         cx88_shutdown(core); /* FIXME */
-        pci_disable_device(pci_dev);
 
         /* unregister stuff */
 
         free_irq(pci_dev->irq, dev);
         cx8800_unregister_video(dev);
+        pci_disable_device(pci_dev);
+
+        core->v4ldev = NULL;
 
         /* free memory */
-        btcx_riscmem_free(dev->pci,&dev->vidq.stopper);
         cx88_core_put(core,dev->pci);
         kfree(dev);
 }
@@ -1938,12 +1597,10 @@ static int cx8800_suspend(struct pci_dev *pci_dev, pm_message_t state)
         if (!list_empty(&dev->vidq.active)) {
                 printk("%s/0: suspend video\n", core->name);
                 stop_video_dma(dev);
-                del_timer(&dev->vidq.timeout);
         }
         if (!list_empty(&dev->vbiq.active)) {
                 printk("%s/0: suspend vbi\n", core->name);
                 cx8800_stop_vbi_dma(dev);
-                del_timer(&dev->vbiq.timeout);
         }
         spin_unlock_irqrestore(&dev->slock, flags);
 
diff --git a/drivers/media/pci/cx88/cx88.h b/drivers/media/pci/cx88/cx88.h
index 28893a6b249e..3b0ae754f165 100644
--- a/drivers/media/pci/cx88/cx88.h
+++ b/drivers/media/pci/cx88/cx88.h
@@ -29,19 +29,18 @@
 #include <media/v4l2-fh.h>
 #include <media/tuner.h>
 #include <media/tveeprom.h>
-#include <media/videobuf-dma-sg.h>
+#include <media/videobuf2-dma-sg.h>
 #include <media/cx2341x.h>
-#include <media/videobuf-dvb.h>
+#include <media/videobuf2-dvb.h>
 #include <media/ir-kbd-i2c.h>
 #include <media/wm8775.h>
 
-#include "btcx-risc.h"
 #include "cx88-reg.h"
 #include "tuner-xc2028.h"
 
 #include <linux/mutex.h>
 
-#define CX88_VERSION "0.0.9"
+#define CX88_VERSION "1.0.0"
 
 #define UNSET (-1U)
 
@@ -62,7 +61,8 @@
 #define FORMAT_FLAGS_PACKED       0x01
 #define FORMAT_FLAGS_PLANAR       0x02
 
-#define VBI_LINE_COUNT              17
+#define VBI_LINE_PAL_COUNT              18
+#define VBI_LINE_NTSC_COUNT             12
 #define VBI_LINE_LENGTH           2048
 
 #define AUD_RDS_LINES                4
@@ -95,13 +95,13 @@ enum cx8802_board_access {
 
 static inline unsigned int norm_maxw(v4l2_std_id norm)
 {
-        return (norm & (V4L2_STD_MN & ~V4L2_STD_PAL_Nc)) ? 720 : 768;
+        return 720;
 }
 
 
 static inline unsigned int norm_maxh(v4l2_std_id norm)
 {
-        return (norm & V4L2_STD_625_50) ? 576 : 480;
+        return (norm & V4L2_STD_525_60) ? 480 : 576;
 }
 
 /* ----------------------------------------------------------- */
@@ -311,26 +311,33 @@ enum cx88_tvaudio {
 
 #define BUFFER_TIMEOUT     msecs_to_jiffies(2000)
 
+struct cx88_riscmem {
+        unsigned int   size;
+        __le32         *cpu;
+        __le32         *jmp;
+        dma_addr_t     dma;
+};
+
 /* buffer for one video frame */
 struct cx88_buffer {
         /* common v4l buffer stuff -- must be first */
-        struct videobuf_buffer vb;
+        struct vb2_buffer vb;
+        struct list_head       list;
 
         /* cx88 specific */
         unsigned int           bpl;
-        struct btcx_riscmem    risc;
-        const struct cx8800_fmt *fmt;
+        struct cx88_riscmem    risc;
         u32                    count;
 };
 
 struct cx88_dmaqueue {
         struct list_head       active;
-        struct list_head       queued;
-        struct timer_list      timeout;
-        struct btcx_riscmem    stopper;
         u32                    count;
 };
 
+struct cx8800_dev;
+struct cx8802_dev;
+
 struct cx88_core {
         struct list_head           devlist;
         atomic_t                   refcount;
@@ -376,6 +383,8 @@ struct cx88_core {
         /* state info */
         struct task_struct         *kthread;
         v4l2_std_id                tvnorm;
+        unsigned                   width, height;
+        unsigned                   field;
         enum cx88_tvaudio          tvaudio;
         u32                        audiomode_manual;
         u32                        audiomode_current;
@@ -395,11 +404,14 @@ struct cx88_core {
         struct mutex               lock;
         /* various v4l controls */
         u32                        freq;
-        int                        users;
-        int                        mpeg_users;
 
-        /* cx88-video needs to access cx8802 for hybrid tuner pll access. */
+        /*
+         * cx88-video needs to access cx8802 for hybrid tuner pll access and
+         * for vb2_is_busy() checks.
+         */
         struct cx8802_dev          *dvbdev;
+        /* cx88-blackbird needs to access cx8800 for vb2_is_busy() checks */
+        struct cx8800_dev          *v4ldev;
         enum cx88_board_type       active_type_id;
         int                        active_ref;
         int                        active_fe_id;
@@ -453,24 +465,9 @@ static inline struct cx88_core *to_core(struct v4l2_device *v4l2_dev)
                 val;                                                            \
         })
 
-struct cx8800_dev;
-struct cx8802_dev;
-
 /* ----------------------------------------------------------- */
 /* function 0: video stuff                                     */
 
-struct cx8800_fh {
-        struct v4l2_fh             fh;
-        struct cx8800_dev          *dev;
-        unsigned int               resources;
-
-        /* video capture */
-        struct videobuf_queue      vidq;
-
-        /* vbi capture */
-        struct videobuf_queue      vbiq;
-};
-
 struct cx8800_suspend_state {
         int                        disabled;
 };
@@ -490,11 +487,12 @@ struct cx8800_dev {
         unsigned char              pci_rev,pci_lat;
 
         const struct cx8800_fmt    *fmt;
-        unsigned int               width, height;
 
         /* capture queues */
         struct cx88_dmaqueue       vidq;
+        struct vb2_queue           vb2_vidq;
         struct cx88_dmaqueue       vbiq;
+        struct vb2_queue           vb2_vbiq;
 
         /* various v4l controls */
 
@@ -510,12 +508,6 @@ struct cx8800_dev {
 /* ----------------------------------------------------------- */
 /* function 2: mpeg stuff                                      */
 
-struct cx8802_fh {
-        struct v4l2_fh             fh;
-        struct cx8802_dev          *dev;
-        struct videobuf_queue      mpegq;
-};
-
 struct cx8802_suspend_state {
         int                        disabled;
 };
@@ -559,6 +551,7 @@ struct cx8802_dev {
 
         /* dma queues */
         struct cx88_dmaqueue       mpegq;
+        struct vb2_queue           vb2_mpegq;
         u32                        ts_packet_size;
         u32                        ts_packet_count;
 
@@ -570,9 +563,6 @@ struct cx8802_dev {
 #if IS_ENABLED(CONFIG_VIDEO_CX88_BLACKBIRD)
         struct video_device        *mpeg_dev;
         u32                        mailbox;
-        int                        width;
-        int                        height;
-        unsigned char              mpeg_active; /* nonzero if mpeg encoder is active */
 
         /* mpeg params */
         struct cx2341x_handler     cxhdl;
@@ -580,7 +570,7 @@ struct cx8802_dev {
 
 #if IS_ENABLED(CONFIG_VIDEO_CX88_DVB)
         /* for dvb only */
-        struct videobuf_dvb_frontends frontends;
+        struct vb2_dvb_frontends frontends;
 #endif
 
 #if IS_ENABLED(CONFIG_VIDEO_CX88_VP3054)
@@ -634,22 +624,17 @@ extern void cx88_shutdown(struct cx88_core *core);
 extern int cx88_reset(struct cx88_core *core);
 
 extern int
-cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+cx88_risc_buffer(struct pci_dev *pci, struct cx88_riscmem *risc,
                  struct scatterlist *sglist,
                  unsigned int top_offset, unsigned int bottom_offset,
                  unsigned int bpl, unsigned int padding, unsigned int lines);
 extern int
-cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
+cx88_risc_databuffer(struct pci_dev *pci, struct cx88_riscmem *risc,
                      struct scatterlist *sglist, unsigned int bpl,
                      unsigned int lines, unsigned int lpi);
-extern int
-cx88_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
-                  u32 reg, u32 mask, u32 value);
-extern void
-cx88_free_buffer(struct videobuf_queue *q, struct cx88_buffer *buf);
 
 extern void cx88_risc_disasm(struct cx88_core *core,
-                             struct btcx_riscmem *risc);
+                             struct cx88_riscmem *risc);
 extern int cx88_sram_channel_setup(struct cx88_core *core,
                                    const struct sram_channel *ch,
                                    unsigned int bpl, u32 risc);
@@ -664,7 +649,7 @@ extern struct video_device *cx88_vdev_init(struct cx88_core *core,
                                            struct pci_dev *pci,
                                            const struct video_device *template_,
                                            const char *type);
-extern struct cx88_core* cx88_core_get(struct pci_dev *pci);
+extern struct cx88_core *cx88_core_get(struct pci_dev *pci);
 extern void cx88_core_put(struct cx88_core *core,
                           struct pci_dev *pci);
 
@@ -684,12 +669,10 @@ int cx8800_start_vbi_dma(struct cx8800_dev    *dev,
                          struct cx88_dmaqueue *q,
                          struct cx88_buffer   *buf);
 */
-int cx8800_stop_vbi_dma(struct cx8800_dev *dev);
-int cx8800_restart_vbi_queue(struct cx8800_dev    *dev,
-                             struct cx88_dmaqueue *q);
-void cx8800_vbi_timeout(unsigned long data);
+void cx8800_stop_vbi_dma(struct cx8800_dev *dev);
+int cx8800_restart_vbi_queue(struct cx8800_dev *dev, struct cx88_dmaqueue *q);
 
-extern const struct videobuf_queue_ops cx8800_vbi_qops;
+extern const struct vb2_ops cx8800_vbi_qops;
 
 /* ----------------------------------------------------------- */
 /* cx88-i2c.c                                                  */
@@ -739,14 +722,17 @@ extern void cx88_i2c_init_ir(struct cx88_core *core);
 /* ----------------------------------------------------------- */
 /* cx88-mpeg.c                                                 */
 
-int cx8802_buf_prepare(struct videobuf_queue *q,struct cx8802_dev *dev,
-                        struct cx88_buffer *buf, enum v4l2_field field);
+int cx8802_buf_prepare(struct vb2_queue *q, struct cx8802_dev *dev,
+                        struct cx88_buffer *buf);
 void cx8802_buf_queue(struct cx8802_dev *dev, struct cx88_buffer *buf);
 void cx8802_cancel_buffers(struct cx8802_dev *dev);
+int cx8802_start_dma(struct cx8802_dev    *dev,
+                            struct cx88_dmaqueue *q,
+                            struct cx88_buffer   *buf);
 
 /* ----------------------------------------------------------- */
 /* cx88-video.c*/
-int cx88_enum_input (struct cx88_core  *core,struct v4l2_input *i);
+int cx88_enum_input(struct cx88_core *core, struct v4l2_input *i);
 int cx88_set_freq(struct cx88_core  *core, const struct v4l2_frequency *f);
 int cx88_video_mux(struct cx88_core *core, unsigned int input);
 void cx88_querycap(struct file *file, struct cx88_core *core,
diff --git a/drivers/media/pci/ddbridge/ddbridge-core.c b/drivers/media/pci/ddbridge/ddbridge-core.c
index c82e855a0814..9e3492e20766 100644
--- a/drivers/media/pci/ddbridge/ddbridge-core.c
+++ b/drivers/media/pci/ddbridge/ddbridge-core.c
@@ -1118,8 +1118,7 @@ static void ddb_ports_detach(struct ddb *dev)
                         dvb_input_detach(port->input[1]);
                         break;
                 case DDB_PORT_CI:
-                        if (port->output->dev)
-                                dvb_unregister_device(port->output->dev);
+                        dvb_unregister_device(port->output->dev);
                         if (port->en) {
                                 ddb_input_stop(port->input[0]);
                                 ddb_output_stop(port->output);
diff --git a/drivers/media/pci/ivtv/ivtv-controls.c b/drivers/media/pci/ivtv/ivtv-controls.c
index 2b0ab26e11e8..ccf548c255f1 100644
--- a/drivers/media/pci/ivtv/ivtv-controls.c
+++ b/drivers/media/pci/ivtv/ivtv-controls.c
@@ -69,7 +69,7 @@ static int ivtv_s_video_encoding(struct cx2341x_handler *cxhdl, u32 val)
         /* fix videodecoder resolution */
         fmt.width = cxhdl->width / (is_mpeg1 ? 2 : 1);
         fmt.height = cxhdl->height;
-        fmt.code = V4L2_MBUS_FMT_FIXED;
+        fmt.code = MEDIA_BUS_FMT_FIXED;
         v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &fmt);
         return 0;
 }
diff --git a/drivers/media/pci/ivtv/ivtv-ioctl.c b/drivers/media/pci/ivtv/ivtv-ioctl.c
index 3e0cb77d5930..4d8ee18c3feb 100644
--- a/drivers/media/pci/ivtv/ivtv-ioctl.c
+++ b/drivers/media/pci/ivtv/ivtv-ioctl.c
@@ -595,7 +595,7 @@ static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f
                 fmt->fmt.pix.width /= 2;
         mbus_fmt.width = fmt->fmt.pix.width;
         mbus_fmt.height = h;
-        mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
+        mbus_fmt.code = MEDIA_BUS_FMT_FIXED;
         v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt);
         return ivtv_g_fmt_vid_cap(file, fh, fmt);
 }
diff --git a/drivers/media/pci/ivtv/ivtv-udma.c b/drivers/media/pci/ivtv/ivtv-udma.c
index 7338cb2d0a38..bee2329e0b2e 100644
--- a/drivers/media/pci/ivtv/ivtv-udma.c
+++ b/drivers/media/pci/ivtv/ivtv-udma.c
@@ -76,7 +76,7 @@ void ivtv_udma_fill_sg_array (struct ivtv_user_dma *dma, u32 buffer_offset, u32
         int i;
         struct scatterlist *sg;
 
-        for (i = 0, sg = dma->SGlist; i < dma->SG_length; i++, sg++) {
+        for (i = 0, sg = dma->SGlist; i < dma->SG_length; i++, sg = sg_next(sg)) {
                 dma->SGarray[i].size = cpu_to_le32(sg_dma_len(sg));
                 dma->SGarray[i].src = cpu_to_le32(sg_dma_address(sg));
                 dma->SGarray[i].dst = cpu_to_le32(buffer_offset);
diff --git a/drivers/media/pci/meye/meye.c b/drivers/media/pci/meye/meye.c
index aeae54708811..9d9f90cb7740 100644
--- a/drivers/media/pci/meye/meye.c
+++ b/drivers/media/pci/meye/meye.c
@@ -1031,9 +1031,6 @@ static int vidioc_querycap(struct file *file, void *fh,
         strcpy(cap->card, "meye");
         sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
 
-        cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
-                       MEYE_DRIVER_MINORVERSION;
-
         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
                             V4L2_CAP_STREAMING;
         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
diff --git a/drivers/media/pci/pt1/pt1.c b/drivers/media/pci/pt1/pt1.c
index db887b0c37b1..acc35b42e53c 100644
--- a/drivers/media/pci/pt1/pt1.c
+++ b/drivers/media/pci/pt1/pt1.c
@@ -109,9 +109,6 @@ struct pt1_adapter {
         int sleep;
 };
 
-#define pt1_printk(level, pt1, format, arg...)  \
-        dev_printk(level, &(pt1)->pdev->dev, format, ##arg)
-
 static void pt1_write_reg(struct pt1 *pt1, int reg, u32 data)
 {
         writel(data, pt1->regs + reg * 4);
@@ -154,7 +151,7 @@ static int pt1_sync(struct pt1 *pt1)
                         return 0;
                 pt1_write_reg(pt1, 0, 0x00000008);
         }
-        pt1_printk(KERN_ERR, pt1, "could not sync\n");
+        dev_err(&pt1->pdev->dev, "could not sync\n");
         return -EIO;
 }
 
@@ -179,7 +176,7 @@ static int pt1_unlock(struct pt1 *pt1)
                         return 0;
                 schedule_timeout_uninterruptible((HZ + 999) / 1000);
         }
-        pt1_printk(KERN_ERR, pt1, "could not unlock\n");
+        dev_err(&pt1->pdev->dev, "could not unlock\n");
         return -EIO;
 }
 
@@ -193,7 +190,7 @@ static int pt1_reset_pci(struct pt1 *pt1)
                         return 0;
                 schedule_timeout_uninterruptible((HZ + 999) / 1000);
         }
-        pt1_printk(KERN_ERR, pt1, "could not reset PCI\n");
+        dev_err(&pt1->pdev->dev, "could not reset PCI\n");
         return -EIO;
 }
 
@@ -207,7 +204,7 @@ static int pt1_reset_ram(struct pt1 *pt1)
                         return 0;
                 schedule_timeout_uninterruptible((HZ + 999) / 1000);
         }
-        pt1_printk(KERN_ERR, pt1, "could not reset RAM\n");
+        dev_err(&pt1->pdev->dev, "could not reset RAM\n");
         return -EIO;
 }
 
@@ -224,7 +221,7 @@ static int pt1_do_enable_ram(struct pt1 *pt1)
                 }
                 schedule_timeout_uninterruptible((HZ + 999) / 1000);
         }
-        pt1_printk(KERN_ERR, pt1, "could not enable RAM\n");
+        dev_err(&pt1->pdev->dev, "could not enable RAM\n");
         return -EIO;
 }
 
diff --git a/drivers/media/pci/pt3/pt3.c b/drivers/media/pci/pt3/pt3.c
index 1fdeac11501a..7a37e8fe2ee2 100644
--- a/drivers/media/pci/pt3/pt3.c
+++ b/drivers/media/pci/pt3/pt3.c
@@ -255,7 +255,7 @@ static int pt3_fe_init(struct pt3_board *pt3)
         pt3_i2c_reset(pt3);
         ret = pt3_init_all_demods(pt3);
         if (ret < 0) {
-                dev_warn(&pt3->pdev->dev, "Failed to init demod chips.");
+                dev_warn(&pt3->pdev->dev, "Failed to init demod chips\n");
                 return ret;
         }
 
@@ -271,7 +271,7 @@ static int pt3_fe_init(struct pt3_board *pt3)
                                               init0_ter, ARRAY_SIZE(init0_ter));
                 if (ret < 0) {
                         dev_warn(&pt3->pdev->dev,
-                                 "demod[%d] faild in init sequence0.", i);
+                                 "demod[%d] failed in init sequence0\n", i);
                         return ret;
                 }
                 ret = fe->ops.init(fe);
@@ -282,7 +282,7 @@ static int pt3_fe_init(struct pt3_board *pt3)
         usleep_range(2000, 4000);
         ret = pt3_set_tuner_power(pt3, true, false);
         if (ret < 0) {
-                dev_warn(&pt3->pdev->dev, "Failed to control tuner module.");
+                dev_warn(&pt3->pdev->dev, "Failed to control tuner module\n");
                 return ret;
         }
 
@@ -297,7 +297,7 @@ static int pt3_fe_init(struct pt3_board *pt3)
                                                 cfg_ter, ARRAY_SIZE(cfg_ter));
                 if (ret < 0) {
                         dev_warn(&pt3->pdev->dev,
-                                 "demod[%d] faild in init sequence1.", i);
+                                 "demod[%d] failed in init sequence1\n", i);
                         return ret;
                 }
         }
@@ -311,19 +311,19 @@ static int pt3_fe_init(struct pt3_board *pt3)
                 ret = fe->ops.tuner_ops.init(fe);
                 if (ret < 0) {
                         dev_warn(&pt3->pdev->dev,
-                                 "Failed to init SAT-tuner[%d].", i);
+                                 "Failed to init SAT-tuner[%d]\n", i);
                         return ret;
                 }
         }
         ret = pt3_init_all_mxl301rf(pt3);
         if (ret < 0) {
-                dev_warn(&pt3->pdev->dev, "Failed to init TERR-tuners.");
+                dev_warn(&pt3->pdev->dev, "Failed to init TERR-tuners\n");
                 return ret;
         }
 
         ret = pt3_set_tuner_power(pt3, true, true);
         if (ret < 0) {
-                dev_warn(&pt3->pdev->dev, "Failed to control tuner module.");
+                dev_warn(&pt3->pdev->dev, "Failed to control tuner module\n");
                 return ret;
         }
 
@@ -344,7 +344,7 @@ static int pt3_fe_init(struct pt3_board *pt3)
                 }
                 if (ret < 0) {
                         dev_warn(&pt3->pdev->dev,
-                                 "Failed in initial tuning of tuner[%d].", i);
+                                 "Failed in initial tuning of tuner[%d]\n", i);
                         return ret;
                 }
         }
@@ -366,7 +366,7 @@ static int pt3_fe_init(struct pt3_board *pt3)
                         fe->ops.set_lna = &pt3_set_lna;
         }
         if (i < PT3_NUM_FE) {
-                dev_warn(&pt3->pdev->dev, "FE[%d] failed to standby.", i);
+                dev_warn(&pt3->pdev->dev, "FE[%d] failed to standby\n", i);
                 return ret;
         }
         return 0;
@@ -453,8 +453,8 @@ static int pt3_fetch_thread(void *data)
         pt3_init_dmabuf(adap);
         adap->num_discard = PT3_INITIAL_BUF_DROPS;
 
-        dev_dbg(adap->dvb_adap.device,
-                "PT3: [%s] started.\n", adap->thread->comm);
+        dev_dbg(adap->dvb_adap.device, "PT3: [%s] started\n",
+                adap->thread->comm);
         set_freezable();
         while (!kthread_freezable_should_stop(&was_frozen)) {
                 if (was_frozen)
@@ -468,8 +468,8 @@ static int pt3_fetch_thread(void *data)
                                         PT3_FETCH_DELAY_DELTA * NSEC_PER_MSEC,
                                         HRTIMER_MODE_REL);
         }
-        dev_dbg(adap->dvb_adap.device,
-                "PT3: [%s] exited.\n", adap->thread->comm);
+        dev_dbg(adap->dvb_adap.device, "PT3: [%s] exited\n",
+                adap->thread->comm);
         adap->thread = NULL;
         return 0;
 }
@@ -485,8 +485,8 @@ static int pt3_start_streaming(struct pt3_adapter *adap)
                 int ret = PTR_ERR(thread);
 
                 dev_warn(adap->dvb_adap.device,
-                        "PT3 (adap:%d, dmx:%d): failed to start kthread.\n",
-                        adap->dvb_adap.num, adap->dmxdev.dvbdev->id);
+                         "PT3 (adap:%d, dmx:%d): failed to start kthread\n",
+                         adap->dvb_adap.num, adap->dmxdev.dvbdev->id);
                 return ret;
         }
         adap->thread = thread;
@@ -501,8 +501,8 @@ static int pt3_stop_streaming(struct pt3_adapter *adap)
         ret = pt3_stop_dma(adap);
         if (ret)
                 dev_warn(adap->dvb_adap.device,
-                        "PT3: failed to stop streaming of adap:%d/FE:%d\n",
-                        adap->dvb_adap.num, adap->fe->id);
+                         "PT3: failed to stop streaming of adap:%d/FE:%d\n",
+                         adap->dvb_adap.num, adap->fe->id);
 
         /* kill the fetching thread */
         ret = kthread_stop(adap->thread);
@@ -522,8 +522,8 @@ static int pt3_start_feed(struct dvb_demux_feed *feed)
                 return 0;
         if (adap->num_feeds != 1) {
                 dev_warn(adap->dvb_adap.device,
-                        "%s: unmatched start/stop_feed in adap:%i/dmx:%i.\n",
-                        __func__, adap->dvb_adap.num, adap->dmxdev.dvbdev->id);
+                         "%s: unmatched start/stop_feed in adap:%i/dmx:%i\n",
+                         __func__, adap->dvb_adap.num, adap->dmxdev.dvbdev->id);
                 adap->num_feeds = 1;
         }
 
@@ -553,10 +553,9 @@ static int pt3_alloc_adapter(struct pt3_board *pt3, int index)
         struct dvb_adapter *da;
 
         adap = kzalloc(sizeof(*adap), GFP_KERNEL);
-        if (!adap) {
-                dev_err(&pt3->pdev->dev, "failed to alloc mem for adapter.\n");
+        if (!adap)
                 return -ENOMEM;
-        }
+
         pt3->adaps[index] = adap;
         adap->adap_idx = index;
 
@@ -565,7 +564,7 @@ static int pt3_alloc_adapter(struct pt3_board *pt3, int index)
                                 THIS_MODULE, &pt3->pdev->dev, adapter_nr);
                 if (ret < 0) {
                         dev_err(&pt3->pdev->dev,
-                                "failed to register adapter dev.\n");
+                                "failed to register adapter dev\n");
                         goto err_mem;
                 }
                 da = &adap->dvb_adap;
@@ -581,7 +580,7 @@ static int pt3_alloc_adapter(struct pt3_board *pt3, int index)
         adap->demux.stop_feed = pt3_stop_feed;
         ret = dvb_dmx_init(&adap->demux);
         if (ret < 0) {
-                dev_err(&pt3->pdev->dev, "failed to init dmx dev.\n");
+                dev_err(&pt3->pdev->dev, "failed to init dmx dev\n");
                 goto err_adap;
         }
 
@@ -589,13 +588,13 @@ static int pt3_alloc_adapter(struct pt3_board *pt3, int index)
         adap->dmxdev.demux = &adap->demux.dmx;
         ret = dvb_dmxdev_init(&adap->dmxdev, da);
         if (ret < 0) {
-                dev_err(&pt3->pdev->dev, "failed to init dmxdev.\n");
+                dev_err(&pt3->pdev->dev, "failed to init dmxdev\n");
                 goto err_demux;
         }
 
         ret = pt3_alloc_dmabuf(adap);
         if (ret) {
-                dev_err(&pt3->pdev->dev, "failed to alloc DMA buffers.\n");
+                dev_err(&pt3->pdev->dev, "failed to alloc DMA buffers\n");
                 goto err_dmabuf;
         }
 
@@ -695,7 +694,7 @@ static int pt3_resume(struct device *dev)
                 dvb_frontend_resume(adap->fe);
                 ret = pt3_alloc_dmabuf(adap);
                 if (ret) {
-                        dev_err(&pt3->pdev->dev, "failed to alloc DMA bufs.\n");
+                        dev_err(&pt3->pdev->dev, "failed to alloc DMA bufs\n");
                         continue;
                 }
                 if (adap->num_feeds > 0)
@@ -753,15 +752,14 @@ static int pt3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 if (ret == 0)
                         dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                 else {
-                        dev_err(&pdev->dev, "Failed to set DMA mask.\n");
+                        dev_err(&pdev->dev, "Failed to set DMA mask\n");
                         goto err_release_regions;
                 }
-                dev_info(&pdev->dev, "Use 32bit DMA.\n");
+                dev_info(&pdev->dev, "Use 32bit DMA\n");
         }
 
         pt3 = kzalloc(sizeof(*pt3), GFP_KERNEL);
         if (!pt3) {
-                dev_err(&pdev->dev, "Failed to alloc mem for this dev.\n");
                 ret = -ENOMEM;
                 goto err_release_regions;
         }
@@ -771,15 +769,15 @@ static int pt3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         pt3->regs[0] = pci_ioremap_bar(pdev, 0);
         pt3->regs[1] = pci_ioremap_bar(pdev, 2);
         if (pt3->regs[0] == NULL || pt3->regs[1] == NULL) {
-                dev_err(&pdev->dev, "Failed to ioremap.\n");
+                dev_err(&pdev->dev, "Failed to ioremap\n");
                 ret = -ENOMEM;
                 goto err_kfree;
         }
 
         ver = ioread32(pt3->regs[0] + REG_VERSION);
         if ((ver >> 16) != 0x0301) {
-                dev_warn(&pdev->dev, "PT%d, I/F-ver.:%d not supported",
-                        ver >> 24, (ver & 0x00ff0000) >> 16);
+                dev_warn(&pdev->dev, "PT%d, I/F-ver.:%d not supported\n",
+                         ver >> 24, (ver & 0x00ff0000) >> 16);
                 ret = -ENODEV;
                 goto err_iounmap;
         }
@@ -788,7 +786,6 @@ static int pt3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         pt3->i2c_buf = kmalloc(sizeof(*pt3->i2c_buf), GFP_KERNEL);
         if (pt3->i2c_buf == NULL) {
-                dev_err(&pdev->dev, "Failed to alloc mem for i2c.\n");
                 ret = -ENOMEM;
                 goto err_iounmap;
         }
@@ -801,7 +798,7 @@ static int pt3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         i2c_set_adapdata(i2c, pt3);
         ret = i2c_add_adapter(i2c);
         if (ret < 0) {
-                dev_err(&pdev->dev, "Failed to add i2c adapter.\n");
+                dev_err(&pdev->dev, "Failed to add i2c adapter\n");
                 goto err_i2cbuf;
         }
 
@@ -815,20 +812,20 @@ static int pt3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         break;
         }
         if (i < PT3_NUM_FE) {
-                dev_err(&pdev->dev, "Failed to create FE%d.\n", i);
+                dev_err(&pdev->dev, "Failed to create FE%d\n", i);
                 goto err_cleanup_adapters;
         }
 
         ret = pt3_fe_init(pt3);
         if (ret < 0) {
-                dev_err(&pdev->dev, "Failed to init frontends.\n");
+                dev_err(&pdev->dev, "Failed to init frontends\n");
                 i = PT3_NUM_FE - 1;
                 goto err_cleanup_adapters;
         }
 
         dev_info(&pdev->dev,
-                "successfully init'ed PT%d (fw:0x%02x, I/F:0x%02x).\n",
-                ver >> 24, (ver >> 8) & 0xff, (ver >> 16) & 0xff);
+                 "successfully init'ed PT%d (fw:0x%02x, I/F:0x%02x)\n",
+                 ver >> 24, (ver >> 8) & 0xff, (ver >> 16) & 0xff);
         return 0;
 
 err_cleanup_adapters:
diff --git a/drivers/media/pci/saa7134/saa7134-core.c b/drivers/media/pci/saa7134/saa7134-core.c
index 236ed725f933..a349e964e0bc 100644
--- a/drivers/media/pci/saa7134/saa7134-core.c
+++ b/drivers/media/pci/saa7134/saa7134-core.c
@@ -1001,13 +1001,18 @@ static int saa7134_initdev(struct pci_dev *pci_dev,
         saa7134_board_init1(dev);
         saa7134_hwinit1(dev);
 
+        dev->alloc_ctx = vb2_dma_sg_init_ctx(&pci_dev->dev);
+        if (IS_ERR(dev->alloc_ctx)) {
+                err = PTR_ERR(dev->alloc_ctx);
+                goto fail3;
+        }
         /* get irq */
         err = request_irq(pci_dev->irq, saa7134_irq,
                           IRQF_SHARED, dev->name, dev);
         if (err < 0) {
                 printk(KERN_ERR "%s: can't get IRQ %d\n",
                        dev->name,pci_dev->irq);
-                goto fail3;
+                goto fail4;
         }
 
         /* wait a bit, register i2c bus */
@@ -1065,7 +1070,7 @@ static int saa7134_initdev(struct pci_dev *pci_dev,
         if (err < 0) {
                 printk(KERN_INFO "%s: can't register video device\n",
                        dev->name);
-                goto fail4;
+                goto fail5;
         }
         printk(KERN_INFO "%s: registered device %s [v4l2]\n",
                dev->name, video_device_node_name(dev->video_dev));
@@ -1078,7 +1083,7 @@ static int saa7134_initdev(struct pci_dev *pci_dev,
         err = video_register_device(dev->vbi_dev,VFL_TYPE_VBI,
                                     vbi_nr[dev->nr]);
         if (err < 0)
-                goto fail4;
+                goto fail5;
         printk(KERN_INFO "%s: registered device %s\n",
                dev->name, video_device_node_name(dev->vbi_dev));
 
@@ -1089,7 +1094,7 @@ static int saa7134_initdev(struct pci_dev *pci_dev,
                 err = video_register_device(dev->radio_dev,VFL_TYPE_RADIO,
                                             radio_nr[dev->nr]);
                 if (err < 0)
-                        goto fail4;
+                        goto fail5;
                 printk(KERN_INFO "%s: registered device %s\n",
                        dev->name, video_device_node_name(dev->radio_dev));
         }
@@ -1103,10 +1108,12 @@ static int saa7134_initdev(struct pci_dev *pci_dev,
         request_submodules(dev);
         return 0;
 
- fail4:
+ fail5:
         saa7134_unregister_video(dev);
         saa7134_i2c_unregister(dev);
         free_irq(pci_dev->irq, dev);
+ fail4:
+        vb2_dma_sg_cleanup_ctx(dev->alloc_ctx);
  fail3:
         saa7134_hwfini(dev);
         iounmap(dev->lmmio);
@@ -1173,6 +1180,7 @@ static void saa7134_finidev(struct pci_dev *pci_dev)
 
         /* release resources */
         free_irq(pci_dev->irq, dev);
+        vb2_dma_sg_cleanup_ctx(dev->alloc_ctx);
         iounmap(dev->lmmio);
         release_mem_region(pci_resource_start(pci_dev,0),
                            pci_resource_len(pci_dev,0));
diff --git a/drivers/media/pci/saa7134/saa7134-empress.c b/drivers/media/pci/saa7134/saa7134-empress.c
index e4ea85fd1b23..594dc3ad4750 100644
--- a/drivers/media/pci/saa7134/saa7134-empress.c
+++ b/drivers/media/pci/saa7134/saa7134-empress.c
@@ -96,7 +96,6 @@ static struct vb2_ops saa7134_empress_qops = {
         .queue_setup    = saa7134_ts_queue_setup,
         .buf_init       = saa7134_ts_buffer_init,
         .buf_prepare    = saa7134_ts_buffer_prepare,
-        .buf_finish     = saa7134_ts_buffer_finish,
         .buf_queue      = saa7134_vb2_buffer_queue,
         .wait_prepare   = vb2_ops_wait_prepare,
         .wait_finish    = vb2_ops_wait_finish,
@@ -140,7 +139,7 @@ static int empress_s_fmt_vid_cap(struct file *file, void *priv,
         struct saa7134_dev *dev = video_drvdata(file);
         struct v4l2_mbus_framefmt mbus_fmt;
 
-        v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, V4L2_MBUS_FMT_FIXED);
+        v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
         saa_call_all(dev, video, s_mbus_fmt, &mbus_fmt);
         v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt);
 
@@ -157,7 +156,7 @@ static int empress_try_fmt_vid_cap(struct file *file, void *priv,
         struct saa7134_dev *dev = video_drvdata(file);
         struct v4l2_mbus_framefmt mbus_fmt;
 
-        v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, V4L2_MBUS_FMT_FIXED);
+        v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
         saa_call_all(dev, video, try_mbus_fmt, &mbus_fmt);
         v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt);
 
diff --git a/drivers/media/pci/saa7134/saa7134-ts.c b/drivers/media/pci/saa7134/saa7134-ts.c
index bd25323bd947..2709b83d57b1 100644
--- a/drivers/media/pci/saa7134/saa7134-ts.c
+++ b/drivers/media/pci/saa7134/saa7134-ts.c
@@ -94,7 +94,6 @@ int saa7134_ts_buffer_prepare(struct vb2_buffer *vb2)
         struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2);
         struct sg_table *dma = vb2_dma_sg_plane_desc(vb2, 0);
         unsigned int lines, llength, size;
-        int ret;
 
         dprintk("buffer_prepare [%p]\n", buf);
 
@@ -108,25 +107,11 @@ int saa7134_ts_buffer_prepare(struct vb2_buffer *vb2)
         vb2_set_plane_payload(vb2, 0, size);
         vb2->v4l2_buf.field = dev->field;
 
-        ret = dma_map_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
-        if (!ret)
-                return -EIO;
         return saa7134_pgtable_build(dev->pci, &dmaq->pt, dma->sgl, dma->nents,
                                     saa7134_buffer_startpage(buf));
 }
 EXPORT_SYMBOL_GPL(saa7134_ts_buffer_prepare);
 
-void saa7134_ts_buffer_finish(struct vb2_buffer *vb2)
-{
-        struct saa7134_dmaqueue *dmaq = vb2->vb2_queue->drv_priv;
-        struct saa7134_dev *dev = dmaq->dev;
-        struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2);
-        struct sg_table *dma = vb2_dma_sg_plane_desc(&buf->vb2, 0);
-
-        dma_unmap_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
-}
-EXPORT_SYMBOL_GPL(saa7134_ts_buffer_finish);
-
 int saa7134_ts_queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
                            unsigned int *nbuffers, unsigned int *nplanes,
                            unsigned int sizes[], void *alloc_ctxs[])
@@ -142,6 +127,7 @@ int saa7134_ts_queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
                 *nbuffers = 3;
         *nplanes = 1;
         sizes[0] = size;
+        alloc_ctxs[0] = dev->alloc_ctx;
         return 0;
 }
 EXPORT_SYMBOL_GPL(saa7134_ts_queue_setup);
@@ -187,7 +173,6 @@ struct vb2_ops saa7134_ts_qops = {
         .queue_setup    = saa7134_ts_queue_setup,
         .buf_init       = saa7134_ts_buffer_init,
         .buf_prepare    = saa7134_ts_buffer_prepare,
-        .buf_finish     = saa7134_ts_buffer_finish,
         .buf_queue      = saa7134_vb2_buffer_queue,
         .wait_prepare   = vb2_ops_wait_prepare,
         .wait_finish    = vb2_ops_wait_finish,
diff --git a/drivers/media/pci/saa7134/saa7134-vbi.c b/drivers/media/pci/saa7134/saa7134-vbi.c
index 4f0b1012e4f3..5306e549e526 100644
--- a/drivers/media/pci/saa7134/saa7134-vbi.c
+++ b/drivers/media/pci/saa7134/saa7134-vbi.c
@@ -120,7 +120,6 @@ static int buffer_prepare(struct vb2_buffer *vb2)
         struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2);
         struct sg_table *dma = vb2_dma_sg_plane_desc(&buf->vb2, 0);
         unsigned int size;
-        int ret;
 
         if (dma->sgl->offset) {
                 pr_err("The buffer is not page-aligned\n");
@@ -132,9 +131,6 @@ static int buffer_prepare(struct vb2_buffer *vb2)
 
         vb2_set_plane_payload(vb2, 0, size);
 
-        ret = dma_map_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
-        if (!ret)
-                return -EIO;
         return saa7134_pgtable_build(dev->pci, &dmaq->pt, dma->sgl, dma->nents,
                                     saa7134_buffer_startpage(buf));
 }
@@ -156,6 +152,7 @@ static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
         *nbuffers = saa7134_buffer_count(size, *nbuffers);
         *nplanes = 1;
         sizes[0] = size;
+        alloc_ctxs[0] = dev->alloc_ctx;
         return 0;
 }
 
@@ -169,21 +166,10 @@ static int buffer_init(struct vb2_buffer *vb2)
         return 0;
 }
 
-static void buffer_finish(struct vb2_buffer *vb2)
-{
-        struct saa7134_dmaqueue *dmaq = vb2->vb2_queue->drv_priv;
-        struct saa7134_dev *dev = dmaq->dev;
-        struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2);
-        struct sg_table *dma = vb2_dma_sg_plane_desc(&buf->vb2, 0);
-
-        dma_unmap_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
-}
-
 struct vb2_ops saa7134_vbi_qops = {
         .queue_setup    = queue_setup,
         .buf_init       = buffer_init,
         .buf_prepare    = buffer_prepare,
-        .buf_finish     = buffer_finish,
         .buf_queue      = saa7134_vb2_buffer_queue,
         .wait_prepare   = vb2_ops_wait_prepare,
         .wait_finish    = vb2_ops_wait_finish,
diff --git a/drivers/media/pci/saa7134/saa7134-video.c b/drivers/media/pci/saa7134/saa7134-video.c
index fc4a427cb51f..701b52f34689 100644
--- a/drivers/media/pci/saa7134/saa7134-video.c
+++ b/drivers/media/pci/saa7134/saa7134-video.c
@@ -883,7 +883,6 @@ static int buffer_prepare(struct vb2_buffer *vb2)
         struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2);
         struct sg_table *dma = vb2_dma_sg_plane_desc(&buf->vb2, 0);
         unsigned int size;
-        int ret;
 
         if (dma->sgl->offset) {
                 pr_err("The buffer is not page-aligned\n");
@@ -896,23 +895,10 @@ static int buffer_prepare(struct vb2_buffer *vb2)
         vb2_set_plane_payload(vb2, 0, size);
         vb2->v4l2_buf.field = dev->field;
 
-        ret = dma_map_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
-        if (!ret)
-                return -EIO;
         return saa7134_pgtable_build(dev->pci, &dmaq->pt, dma->sgl, dma->nents,
                                     saa7134_buffer_startpage(buf));
 }
 
-static void buffer_finish(struct vb2_buffer *vb2)
-{
-        struct saa7134_dmaqueue *dmaq = vb2->vb2_queue->drv_priv;
-        struct saa7134_dev *dev = dmaq->dev;
-        struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2);
-        struct sg_table *dma = vb2_dma_sg_plane_desc(&buf->vb2, 0);
-
-        dma_unmap_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
-}
-
 static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
                            unsigned int *nbuffers, unsigned int *nplanes,
                            unsigned int sizes[], void *alloc_ctxs[])
@@ -932,6 +918,7 @@ static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
         *nbuffers = saa7134_buffer_count(size, *nbuffers);
         *nplanes = 1;
         sizes[0] = size;
+        alloc_ctxs[0] = dev->alloc_ctx;
         return 0;
 }
 
@@ -1004,7 +991,6 @@ static struct vb2_ops vb2_qops = {
         .queue_setup    = queue_setup,
         .buf_init       = buffer_init,
         .buf_prepare    = buffer_prepare,
-        .buf_finish     = buffer_finish,
         .buf_queue      = saa7134_vb2_buffer_queue,
         .wait_prepare   = vb2_ops_wait_prepare,
         .wait_finish    = vb2_ops_wait_finish,
diff --git a/drivers/media/pci/saa7134/saa7134.h b/drivers/media/pci/saa7134/saa7134.h
index 1a82dd07205b..8bf0553b8d2f 100644
--- a/drivers/media/pci/saa7134/saa7134.h
+++ b/drivers/media/pci/saa7134/saa7134.h
@@ -588,6 +588,7 @@ struct saa7134_dev {
 
 
         /* video+ts+vbi capture */
+        void                       *alloc_ctx;
         struct saa7134_dmaqueue    video_q;
         struct vb2_queue           video_vbq;
         struct saa7134_dmaqueue    vbi_q;
@@ -814,7 +815,6 @@ void saa7134_video_fini(struct saa7134_dev *dev);
 
 int saa7134_ts_buffer_init(struct vb2_buffer *vb2);
 int saa7134_ts_buffer_prepare(struct vb2_buffer *vb2);
-void saa7134_ts_buffer_finish(struct vb2_buffer *vb2);
 int saa7134_ts_queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
                            unsigned int *nbuffers, unsigned int *nplanes,
                            unsigned int sizes[], void *alloc_ctxs[]);
diff --git a/drivers/media/pci/saa7164/saa7164-buffer.c b/drivers/media/pci/saa7164/saa7164-buffer.c
index 66696fa8341d..9bd1f73f82da 100644
--- a/drivers/media/pci/saa7164/saa7164-buffer.c
+++ b/drivers/media/pci/saa7164/saa7164-buffer.c
@@ -130,9 +130,9 @@ struct saa7164_buffer *saa7164_buffer_alloc(struct saa7164_port *port,
                 goto fail2;
 
         /* init the buffers to a known pattern, easier during debugging */
-        memset_io(buf->cpu, 0xff, buf->pci_size);
+        memset(buf->cpu, 0xff, buf->pci_size);
         buf->crc = crc32(0, buf->cpu, buf->actual_size);
-        memset_io(buf->pt_cpu, 0xff, buf->pt_size);
+        memset(buf->pt_cpu, 0xff, buf->pt_size);
 
         dprintk(DBGLVL_BUF, "%s()   allocated buffer @ 0x%p (%d pageptrs)\n",
                 __func__, buf, params->numpagetables);
diff --git a/drivers/media/pci/saa7164/saa7164-bus.c b/drivers/media/pci/saa7164/saa7164-bus.c
index 5f6f3094c44e..6c73f5b155f6 100644
--- a/drivers/media/pci/saa7164/saa7164-bus.c
+++ b/drivers/media/pci/saa7164/saa7164-bus.c
@@ -33,12 +33,12 @@ int saa7164_bus_setup(struct saa7164_dev *dev)
         b->Type                 = TYPE_BUS_PCIe;
         b->m_wMaxReqSize        = SAA_DEVICE_MAXREQUESTSIZE;
 
-        b->m_pdwSetRing         = (u8 *)(dev->bmmio +
+        b->m_pdwSetRing         = (u8 __iomem *)(dev->bmmio +
                 ((u32)dev->busdesc.CommandRing));
 
         b->m_dwSizeSetRing      = SAA_DEVICE_BUFFERBLOCKSIZE;
 
-        b->m_pdwGetRing         = (u8 *)(dev->bmmio +
+        b->m_pdwGetRing         = (u8 __iomem *)(dev->bmmio +
                 ((u32)dev->busdesc.ResponseRing));
 
         b->m_dwSizeGetRing      = SAA_DEVICE_BUFFERBLOCKSIZE;
@@ -138,6 +138,7 @@ int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
         u32 bytes_to_write, free_write_space, timeout, curr_srp, curr_swp;
         u32 new_swp, space_rem;
         int ret = SAA_ERR_BAD_PARAMETER;
+        u16 size;
 
         if (!msg) {
                 printk(KERN_ERR "%s() !msg\n", __func__);
@@ -148,10 +149,6 @@ int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
 
         saa7164_bus_verify(dev);
 
-        msg->size = cpu_to_le16(msg->size);
-        msg->command = cpu_to_le32(msg->command);
-        msg->controlselector = cpu_to_le16(msg->controlselector);
-
         if (msg->size > dev->bus.m_wMaxReqSize) {
                 printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
                         __func__);
@@ -169,8 +166,8 @@ int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
         bytes_to_write = sizeof(*msg) + msg->size;
         free_write_space = 0;
         timeout = SAA_BUS_TIMEOUT;
-        curr_srp = le32_to_cpu(saa7164_readl(bus->m_dwSetReadPos));
-        curr_swp = le32_to_cpu(saa7164_readl(bus->m_dwSetWritePos));
+        curr_srp = saa7164_readl(bus->m_dwSetReadPos);
+        curr_swp = saa7164_readl(bus->m_dwSetWritePos);
 
         /* Deal with ring wrapping issues */
         if (curr_srp > curr_swp)
@@ -203,7 +200,7 @@ int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
                 mdelay(1);
 
                 /* Check the space usage again */
-                curr_srp = le32_to_cpu(saa7164_readl(bus->m_dwSetReadPos));
+                curr_srp = saa7164_readl(bus->m_dwSetReadPos);
 
                 /* Deal with ring wrapping issues */
                 if (curr_srp > curr_swp)
@@ -223,6 +220,16 @@ int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
         dprintk(DBGLVL_BUS, "%s() bus->m_dwSizeSetRing = %x\n", __func__,
                 bus->m_dwSizeSetRing);
 
+        /*
+         * Make a copy of msg->size before it is converted to le16 since it is
+         * used in the code below.
+         */
+        size = msg->size;
+        /* Convert to le16/le32 */
+        msg->size = (__force u16)cpu_to_le16(msg->size);
+        msg->command = (__force u32)cpu_to_le32(msg->command);
+        msg->controlselector = (__force u16)cpu_to_le16(msg->controlselector);
+
         /* Mental Note: line 462 tmmhComResBusPCIe.cpp */
 
         /* Check if we're going to wrap again */
@@ -243,28 +250,28 @@ int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
                         dprintk(DBGLVL_BUS, "%s() tr4\n", __func__);
 
                         /* Split the msg into pieces as the ring wraps */
-                        memcpy(bus->m_pdwSetRing + curr_swp, msg, space_rem);
-                        memcpy(bus->m_pdwSetRing, (u8 *)msg + space_rem,
+                        memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, space_rem);
+                        memcpy_toio(bus->m_pdwSetRing, (u8 *)msg + space_rem,
                                 sizeof(*msg) - space_rem);
 
-                        memcpy(bus->m_pdwSetRing + sizeof(*msg) - space_rem,
-                                buf, msg->size);
+                        memcpy_toio(bus->m_pdwSetRing + sizeof(*msg) - space_rem,
+                                buf, size);
 
                 } else if (space_rem == sizeof(*msg)) {
                         dprintk(DBGLVL_BUS, "%s() tr5\n", __func__);
 
                         /* Additional data at the beginning of the ring */
-                        memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
-                        memcpy(bus->m_pdwSetRing, buf, msg->size);
+                        memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                        memcpy_toio(bus->m_pdwSetRing, buf, size);
 
                 } else {
                         /* Additional data wraps around the ring */
-                        memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
-                        if (msg->size > 0) {
-                                memcpy(bus->m_pdwSetRing + curr_swp +
+                        memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                        if (size > 0) {
+                                memcpy_toio(bus->m_pdwSetRing + curr_swp +
                                         sizeof(*msg), buf, space_rem -
                                         sizeof(*msg));
-                                memcpy(bus->m_pdwSetRing, (u8 *)buf +
+                                memcpy_toio(bus->m_pdwSetRing, (u8 *)buf +
                                         space_rem - sizeof(*msg),
                                         bytes_to_write - space_rem);
                         }
@@ -276,15 +283,20 @@ int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
                 dprintk(DBGLVL_BUS, "%s() tr6\n", __func__);
 
                 /* The ring buffer doesn't wrap, two simple copies */
-                memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
-                memcpy(bus->m_pdwSetRing + curr_swp + sizeof(*msg), buf,
-                        msg->size);
+                memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                memcpy_toio(bus->m_pdwSetRing + curr_swp + sizeof(*msg), buf,
+                        size);
         }
 
         dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
 
         /* Update the bus write position */
-        saa7164_writel(bus->m_dwSetWritePos, cpu_to_le32(new_swp));
+        saa7164_writel(bus->m_dwSetWritePos, new_swp);
+
+        /* Convert back to cpu after writing the msg to the ringbuffer. */
+        msg->size = le16_to_cpu((__force __le16)msg->size);
+        msg->command = le32_to_cpu((__force __le32)msg->command);
+        msg->controlselector = le16_to_cpu((__force __le16)msg->controlselector);
         ret = SAA_OK;
 
 out:
@@ -336,8 +348,8 @@ int saa7164_bus_get(struct saa7164_dev *dev, struct tmComResInfo* msg,
         /* Peek the bus to see if a msg exists, if it's not what we're expecting
          * then return cleanly else read the message from the bus.
          */
-        curr_gwp = le32_to_cpu(saa7164_readl(bus->m_dwGetWritePos));
-        curr_grp = le32_to_cpu(saa7164_readl(bus->m_dwGetReadPos));
+        curr_gwp = saa7164_readl(bus->m_dwGetWritePos);
+        curr_grp = saa7164_readl(bus->m_dwGetReadPos);
 
         if (curr_gwp == curr_grp) {
                 ret = SAA_ERR_EMPTY;
@@ -369,14 +381,18 @@ int saa7164_bus_get(struct saa7164_dev *dev, struct tmComResInfo* msg,
                 new_grp -= bus->m_dwSizeGetRing;
                 space_rem = bus->m_dwSizeGetRing - curr_grp;
 
-                memcpy(&msg_tmp, bus->m_pdwGetRing + curr_grp, space_rem);
-                memcpy((u8 *)&msg_tmp + space_rem, bus->m_pdwGetRing,
+                memcpy_fromio(&msg_tmp, bus->m_pdwGetRing + curr_grp, space_rem);
+                memcpy_fromio((u8 *)&msg_tmp + space_rem, bus->m_pdwGetRing,
                         bytes_to_read - space_rem);
 
         } else {
                 /* No wrapping */
-                memcpy(&msg_tmp, bus->m_pdwGetRing + curr_grp, bytes_to_read);
+                memcpy_fromio(&msg_tmp, bus->m_pdwGetRing + curr_grp, bytes_to_read);
         }
+        /* Convert from little endian to CPU */
+        msg_tmp.size = le16_to_cpu((__force __le16)msg_tmp.size);
+        msg_tmp.command = le32_to_cpu((__force __le32)msg_tmp.command);
+        msg_tmp.controlselector = le16_to_cpu((__force __le16)msg_tmp.controlselector);
 
         /* No need to update the read positions, because this was a peek */
         /* If the caller specifically want to peek, return */
@@ -427,24 +443,24 @@ int saa7164_bus_get(struct saa7164_dev *dev, struct tmComResInfo* msg,
 
                 if (space_rem < sizeof(*msg)) {
                         /* msg wraps around the ring */
-                        memcpy(msg, bus->m_pdwGetRing + curr_grp, space_rem);
-                        memcpy((u8 *)msg + space_rem, bus->m_pdwGetRing,
+                        memcpy_fromio(msg, bus->m_pdwGetRing + curr_grp, space_rem);
+                        memcpy_fromio((u8 *)msg + space_rem, bus->m_pdwGetRing,
                                 sizeof(*msg) - space_rem);
                         if (buf)
-                                memcpy(buf, bus->m_pdwGetRing + sizeof(*msg) -
+                                memcpy_fromio(buf, bus->m_pdwGetRing + sizeof(*msg) -
                                         space_rem, buf_size);
 
                 } else if (space_rem == sizeof(*msg)) {
-                        memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                        memcpy_fromio(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
                         if (buf)
-                                memcpy(buf, bus->m_pdwGetRing, buf_size);
+                                memcpy_fromio(buf, bus->m_pdwGetRing, buf_size);
                 } else {
                         /* Additional data wraps around the ring */
-                        memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                        memcpy_fromio(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
                         if (buf) {
-                                memcpy(buf, bus->m_pdwGetRing + curr_grp +
+                                memcpy_fromio(buf, bus->m_pdwGetRing + curr_grp +
                                         sizeof(*msg), space_rem - sizeof(*msg));
-                                memcpy(buf + space_rem - sizeof(*msg),
+                                memcpy_fromio(buf + space_rem - sizeof(*msg),
                                         bus->m_pdwGetRing, bytes_to_read -
                                         space_rem);
                         }
@@ -453,19 +469,20 @@ int saa7164_bus_get(struct saa7164_dev *dev, struct tmComResInfo* msg,
 
         } else {
                 /* No wrapping */
-                memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                memcpy_fromio(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
                 if (buf)
-                        memcpy(buf, bus->m_pdwGetRing + curr_grp + sizeof(*msg),
+                        memcpy_fromio(buf, bus->m_pdwGetRing + curr_grp + sizeof(*msg),
                                 buf_size);
         }
+        /* Convert from little endian to CPU */
+        msg->size = le16_to_cpu((__force __le16)msg->size);
+        msg->command = le32_to_cpu((__force __le32)msg->command);
+        msg->controlselector = le16_to_cpu((__force __le16)msg->controlselector);
 
         /* Update the read positions, adjusting the ring */
-        saa7164_writel(bus->m_dwGetReadPos, cpu_to_le32(new_grp));
+        saa7164_writel(bus->m_dwGetReadPos, new_grp);
 
 peekout:
-        msg->size = le16_to_cpu(msg->size);
-        msg->command = le32_to_cpu(msg->command);
-        msg->controlselector = le16_to_cpu(msg->controlselector);
         ret = SAA_OK;
 out:
         mutex_unlock(&bus->lock);
diff --git a/drivers/media/pci/saa7164/saa7164-core.c b/drivers/media/pci/saa7164/saa7164-core.c
index cc1be8a7a451..4b0bec3766ed 100644
--- a/drivers/media/pci/saa7164/saa7164-core.c
+++ b/drivers/media/pci/saa7164/saa7164-core.c
@@ -119,7 +119,7 @@ static void saa7164_ts_verifier(struct saa7164_buffer *buf)
         u32 i;
         u8 cc, a;
         u16 pid;
-        u8 __iomem *bufcpu = (u8 *)buf->cpu;
+        u8 *bufcpu = (u8 *)buf->cpu;
 
         port->sync_errors = 0;
         port->v_cc_errors = 0;
@@ -260,7 +260,7 @@ static void saa7164_work_enchandler_helper(struct saa7164_port *port, int bufnr)
         struct saa7164_user_buffer *ubuf = NULL;
         struct list_head *c, *n;
         int i = 0;
-        u8 __iomem *p;
+        u8 *p;
 
         mutex_lock(&port->dmaqueue_lock);
         list_for_each_safe(c, n, &port->dmaqueue.list) {
@@ -318,8 +318,7 @@ static void saa7164_work_enchandler_helper(struct saa7164_port *port, int bufnr)
 
                                 if (buf->actual_size <= ubuf->actual_size) {
 
-                                        memcpy_fromio(ubuf->data, buf->cpu,
-                                                ubuf->actual_size);
+                                        memcpy(ubuf->data, buf->cpu, ubuf->actual_size);
 
                                         if (crc_checking) {
                                                 /* Throw a new checksum on the read buffer */
@@ -346,7 +345,7 @@ static void saa7164_work_enchandler_helper(struct saa7164_port *port, int bufnr)
                          * with known bad data. We check for this data at a later point
                          * in time. */
                         saa7164_buffer_zero_offsets(port, bufnr);
-                        memset_io(buf->cpu, 0xff, buf->pci_size);
+                        memset(buf->cpu, 0xff, buf->pci_size);
                         if (crc_checking) {
                                 /* Throw yet aanother new checksum on the dma buffer */
                                 buf->crc = crc32(0, buf->cpu, buf->actual_size);
@@ -1096,7 +1095,7 @@ static int saa7164_proc_show(struct seq_file *m, void *v)
                         if (c == 0)
                                 seq_printf(m, " %04x:", i);
 
-                        seq_printf(m, " %02x", *(b->m_pdwSetRing + i));
+                        seq_printf(m, " %02x", readb(b->m_pdwSetRing + i));
 
                         if (++c == 16) {
                                 seq_printf(m, "\n");
@@ -1111,7 +1110,7 @@ static int saa7164_proc_show(struct seq_file *m, void *v)
                         if (c == 0)
                                 seq_printf(m, " %04x:", i);
 
-                        seq_printf(m, " %02x", *(b->m_pdwGetRing + i));
+                        seq_printf(m, " %02x", readb(b->m_pdwGetRing + i));
 
                         if (++c == 16) {
                                 seq_printf(m, "\n");
diff --git a/drivers/media/pci/saa7164/saa7164-fw.c b/drivers/media/pci/saa7164/saa7164-fw.c
index 86763203d61d..add06ab5124d 100644
--- a/drivers/media/pci/saa7164/saa7164-fw.c
+++ b/drivers/media/pci/saa7164/saa7164-fw.c
@@ -72,7 +72,7 @@ static int saa7164_dl_wait_clr(struct saa7164_dev *dev, u32 reg)
 /* TODO: move dlflags into dev-> and change to write/readl/b */
 /* TODO: Excessive levels of debug */
 static int saa7164_downloadimage(struct saa7164_dev *dev, u8 *src, u32 srcsize,
-                                 u32 dlflags, u8 *dst, u32 dstsize)
+                                 u32 dlflags, u8 __iomem *dst, u32 dstsize)
 {
         u32 reg, timeout, offset;
         u8 *srcbuf = NULL;
@@ -136,7 +136,7 @@ static int saa7164_downloadimage(struct saa7164_dev *dev, u8 *src, u32 srcsize,
                 srcsize -= dstsize, offset += dstsize) {
 
                 dprintk(DBGLVL_FW, "%s() memcpy %d\n", __func__, dstsize);
-                memcpy(dst, srcbuf + offset, dstsize);
+                memcpy_toio(dst, srcbuf + offset, dstsize);
 
                 /* Flag the data as ready */
                 saa7164_writel(drflag, 1);
@@ -154,7 +154,7 @@ static int saa7164_downloadimage(struct saa7164_dev *dev, u8 *src, u32 srcsize,
 
         dprintk(DBGLVL_FW, "%s() memcpy(l) %d\n", __func__, dstsize);
         /* Write last block to the device */
-        memcpy(dst, srcbuf+offset, srcsize);
+        memcpy_toio(dst, srcbuf+offset, srcsize);
 
         /* Flag the data as ready */
         saa7164_writel(drflag, 1);
diff --git a/drivers/media/pci/saa7164/saa7164-types.h b/drivers/media/pci/saa7164/saa7164-types.h
index 1d2140a3eb38..f48ba978f835 100644
--- a/drivers/media/pci/saa7164/saa7164-types.h
+++ b/drivers/media/pci/saa7164/saa7164-types.h
@@ -78,9 +78,9 @@ enum tmBusType {
 struct tmComResBusInfo {
         enum tmBusType Type;
         u16     m_wMaxReqSize;
-        u8      *m_pdwSetRing;
+        u8 __iomem *m_pdwSetRing;
         u32     m_dwSizeSetRing;
-        u8      *m_pdwGetRing;
+        u8 __iomem *m_pdwGetRing;
         u32     m_dwSizeGetRing;
         u32     m_dwSetWritePos;
         u32     m_dwSetReadPos;
diff --git a/drivers/media/pci/saa7164/saa7164.h b/drivers/media/pci/saa7164/saa7164.h
index 8b29e8990301..cd1a07ce27cb 100644
--- a/drivers/media/pci/saa7164/saa7164.h
+++ b/drivers/media/pci/saa7164/saa7164.h
@@ -313,13 +313,13 @@ struct saa7164_buffer {
 
         /* A block of page align PCI memory */
         u32 pci_size;   /* PCI allocation size in bytes */
-        u64 __iomem *cpu;       /* Virtual address */
+        u64 *cpu;       /* Virtual address */
         dma_addr_t dma; /* Physical address */
         u32 crc;        /* Checksum for the entire buffer data */
 
         /* A page table that splits the block into a number of entries */
         u32 pt_size;            /* PCI allocation size in bytes */
-        u64 __iomem *pt_cpu;            /* Virtual address */
+        u64 *pt_cpu;            /* Virtual address */
         dma_addr_t pt_dma;      /* Physical address */
 
         /* Encoder fops */
diff --git a/drivers/media/pci/smipcie/Kconfig b/drivers/media/pci/smipcie/Kconfig
new file mode 100644
index 000000000000..c8de53f5ea28
--- /dev/null
+++ b/drivers/media/pci/smipcie/Kconfig
@@ -0,0 +1,17 @@
+config DVB_SMIPCIE
+        tristate "SMI PCIe DVBSky cards"
+        depends on DVB_CORE && PCI && I2C
+        select I2C_ALGOBIT
+        select DVB_M88DS3103 if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_SI2168 if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_M88TS2022 if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_M88RS6000T if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_SI2157 if MEDIA_SUBDRV_AUTOSELECT
+        help
+          Support for cards with SMI PCIe bridge:
+          - DVBSky S950 V3
+          - DVBSky S952 V3
+          - DVBSky T9580 V3
+
+          Say Y or M if you own such a device and want to use it.
+          If unsure say N.
diff --git a/drivers/media/pci/smipcie/Makefile b/drivers/media/pci/smipcie/Makefile
new file mode 100644
index 000000000000..be55481a6e95
--- /dev/null
+++ b/drivers/media/pci/smipcie/Makefile
@@ -0,0 +1,6 @@
+obj-$(CONFIG_DVB_SMIPCIE) += smipcie.o
+
+ccflags-y += -Idrivers/media/tuners
+ccflags-y += -Idrivers/media/dvb-core
+ccflags-y += -Idrivers/media/dvb-frontends
+
diff --git a/drivers/media/pci/smipcie/smipcie.c b/drivers/media/pci/smipcie/smipcie.c
new file mode 100644
index 000000000000..f773350e67b9
--- /dev/null
+++ b/drivers/media/pci/smipcie/smipcie.c
@@ -0,0 +1,1099 @@
+/*
+ * SMI PCIe driver for DVBSky cards.
+ *
+ * Copyright (C) 2014 Max nibble <nibble.max@gmail.com>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#include "smipcie.h"
+#include "m88ds3103.h"
+#include "m88ts2022.h"
+#include "m88rs6000t.h"
+#include "si2168.h"
+#include "si2157.h"
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int smi_hw_init(struct smi_dev *dev)
+{
+        u32 port_mux, port_ctrl, int_stat;
+
+        /* set port mux.*/
+        port_mux = smi_read(MUX_MODE_CTRL);
+        port_mux &= ~(rbPaMSMask);
+        port_mux |= rbPaMSDtvNoGpio;
+        port_mux &= ~(rbPbMSMask);
+        port_mux |= rbPbMSDtvNoGpio;
+        port_mux &= ~(0x0f0000);
+        port_mux |= 0x50000;
+        smi_write(MUX_MODE_CTRL, port_mux);
+
+        /* set DTV register.*/
+        /* Port A */
+        port_ctrl = smi_read(VIDEO_CTRL_STATUS_A);
+        port_ctrl &= ~0x01;
+        smi_write(VIDEO_CTRL_STATUS_A, port_ctrl);
+        port_ctrl = smi_read(MPEG2_CTRL_A);
+        port_ctrl &= ~0x40;
+        port_ctrl |= 0x80;
+        smi_write(MPEG2_CTRL_A, port_ctrl);
+        /* Port B */
+        port_ctrl = smi_read(VIDEO_CTRL_STATUS_B);
+        port_ctrl &= ~0x01;
+        smi_write(VIDEO_CTRL_STATUS_B, port_ctrl);
+        port_ctrl = smi_read(MPEG2_CTRL_B);
+        port_ctrl &= ~0x40;
+        port_ctrl |= 0x80;
+        smi_write(MPEG2_CTRL_B, port_ctrl);
+
+        /* disable and clear interrupt.*/
+        smi_write(MSI_INT_ENA_CLR, ALL_INT);
+        int_stat = smi_read(MSI_INT_STATUS);
+        smi_write(MSI_INT_STATUS_CLR, int_stat);
+
+        /* reset demod.*/
+        smi_clear(PERIPHERAL_CTRL, 0x0303);
+        msleep(50);
+        smi_set(PERIPHERAL_CTRL, 0x0101);
+        return 0;
+}
+
+/* i2c bit bus.*/
+static void smi_i2c_cfg(struct smi_dev *dev, u32 sw_ctl)
+{
+        u32 dwCtrl;
+
+        dwCtrl = smi_read(sw_ctl);
+        dwCtrl &= ~0x18; /* disable output.*/
+        dwCtrl |= 0x21; /* reset and software mode.*/
+        dwCtrl &= ~0xff00;
+        dwCtrl |= 0x6400;
+        smi_write(sw_ctl, dwCtrl);
+        msleep(20);
+        dwCtrl = smi_read(sw_ctl);
+        dwCtrl &= ~0x20;
+        smi_write(sw_ctl, dwCtrl);
+}
+
+static void smi_i2c_setsda(struct smi_dev *dev, int state, u32 sw_ctl)
+{
+        if (state) {
+                /* set as input.*/
+                smi_clear(sw_ctl, SW_I2C_MSK_DAT_EN);
+        } else {
+                smi_clear(sw_ctl, SW_I2C_MSK_DAT_OUT);
+                /* set as output.*/
+                smi_set(sw_ctl, SW_I2C_MSK_DAT_EN);
+        }
+}
+
+static void smi_i2c_setscl(void *data, int state, u32 sw_ctl)
+{
+        struct smi_dev *dev = data;
+
+        if (state) {
+                /* set as input.*/
+                smi_clear(sw_ctl, SW_I2C_MSK_CLK_EN);
+        } else {
+                smi_clear(sw_ctl, SW_I2C_MSK_CLK_OUT);
+                /* set as output.*/
+                smi_set(sw_ctl, SW_I2C_MSK_CLK_EN);
+        }
+}
+
+static int smi_i2c_getsda(void *data, u32 sw_ctl)
+{
+        struct smi_dev *dev = data;
+        /* set as input.*/
+        smi_clear(sw_ctl, SW_I2C_MSK_DAT_EN);
+        udelay(1);
+        return (smi_read(sw_ctl) & SW_I2C_MSK_DAT_IN) ? 1 : 0;
+}
+
+static int smi_i2c_getscl(void *data, u32 sw_ctl)
+{
+        struct smi_dev *dev = data;
+        /* set as input.*/
+        smi_clear(sw_ctl, SW_I2C_MSK_CLK_EN);
+        udelay(1);
+        return (smi_read(sw_ctl) & SW_I2C_MSK_CLK_IN) ? 1 : 0;
+}
+/* i2c 0.*/
+static void smi_i2c0_setsda(void *data, int state)
+{
+        struct smi_dev *dev = data;
+
+        smi_i2c_setsda(dev, state, I2C_A_SW_CTL);
+}
+
+static void smi_i2c0_setscl(void *data, int state)
+{
+        struct smi_dev *dev = data;
+
+        smi_i2c_setscl(dev, state, I2C_A_SW_CTL);
+}
+
+static int smi_i2c0_getsda(void *data)
+{
+        struct smi_dev *dev = data;
+
+        return  smi_i2c_getsda(dev, I2C_A_SW_CTL);
+}
+
+static int smi_i2c0_getscl(void *data)
+{
+        struct smi_dev *dev = data;
+
+        return  smi_i2c_getscl(dev, I2C_A_SW_CTL);
+}
+/* i2c 1.*/
+static void smi_i2c1_setsda(void *data, int state)
+{
+        struct smi_dev *dev = data;
+
+        smi_i2c_setsda(dev, state, I2C_B_SW_CTL);
+}
+
+static void smi_i2c1_setscl(void *data, int state)
+{
+        struct smi_dev *dev = data;
+
+        smi_i2c_setscl(dev, state, I2C_B_SW_CTL);
+}
+
+static int smi_i2c1_getsda(void *data)
+{
+        struct smi_dev *dev = data;
+
+        return  smi_i2c_getsda(dev, I2C_B_SW_CTL);
+}
+
+static int smi_i2c1_getscl(void *data)
+{
+        struct smi_dev *dev = data;
+
+        return  smi_i2c_getscl(dev, I2C_B_SW_CTL);
+}
+
+static int smi_i2c_init(struct smi_dev *dev)
+{
+        int ret;
+
+        /* i2c bus 0 */
+        smi_i2c_cfg(dev, I2C_A_SW_CTL);
+        i2c_set_adapdata(&dev->i2c_bus[0], dev);
+        strcpy(dev->i2c_bus[0].name, "SMI-I2C0");
+        dev->i2c_bus[0].owner = THIS_MODULE;
+        dev->i2c_bus[0].dev.parent = &dev->pci_dev->dev;
+        dev->i2c_bus[0].algo_data = &dev->i2c_bit[0];
+        dev->i2c_bit[0].data = dev;
+        dev->i2c_bit[0].setsda = smi_i2c0_setsda;
+        dev->i2c_bit[0].setscl = smi_i2c0_setscl;
+        dev->i2c_bit[0].getsda = smi_i2c0_getsda;
+        dev->i2c_bit[0].getscl = smi_i2c0_getscl;
+        dev->i2c_bit[0].udelay = 12;
+        dev->i2c_bit[0].timeout = 10;
+        /* Raise SCL and SDA */
+        smi_i2c0_setsda(dev, 1);
+        smi_i2c0_setscl(dev, 1);
+
+        ret = i2c_bit_add_bus(&dev->i2c_bus[0]);
+        if (ret < 0)
+                return ret;
+
+        /* i2c bus 1 */
+        smi_i2c_cfg(dev, I2C_B_SW_CTL);
+        i2c_set_adapdata(&dev->i2c_bus[1], dev);
+        strcpy(dev->i2c_bus[1].name, "SMI-I2C1");
+        dev->i2c_bus[1].owner = THIS_MODULE;
+        dev->i2c_bus[1].dev.parent = &dev->pci_dev->dev;
+        dev->i2c_bus[1].algo_data = &dev->i2c_bit[1];
+        dev->i2c_bit[1].data = dev;
+        dev->i2c_bit[1].setsda = smi_i2c1_setsda;
+        dev->i2c_bit[1].setscl = smi_i2c1_setscl;
+        dev->i2c_bit[1].getsda = smi_i2c1_getsda;
+        dev->i2c_bit[1].getscl = smi_i2c1_getscl;
+        dev->i2c_bit[1].udelay = 12;
+        dev->i2c_bit[1].timeout = 10;
+        /* Raise SCL and SDA */
+        smi_i2c1_setsda(dev, 1);
+        smi_i2c1_setscl(dev, 1);
+
+        ret = i2c_bit_add_bus(&dev->i2c_bus[1]);
+        if (ret < 0)
+                i2c_del_adapter(&dev->i2c_bus[0]);
+
+        return ret;
+}
+
+static void smi_i2c_exit(struct smi_dev *dev)
+{
+        i2c_del_adapter(&dev->i2c_bus[0]);
+        i2c_del_adapter(&dev->i2c_bus[1]);
+}
+
+static int smi_read_eeprom(struct i2c_adapter *i2c, u16 reg, u8 *data, u16 size)
+{
+        int ret;
+        u8 b0[2] = { (reg >> 8) & 0xff, reg & 0xff };
+
+        struct i2c_msg msg[] = {
+                { .addr = 0x50, .flags = 0,
+                        .buf = b0, .len = 2 },
+                { .addr = 0x50, .flags = I2C_M_RD,
+                        .buf = data, .len = size }
+        };
+
+        ret = i2c_transfer(i2c, msg, 2);
+
+        if (ret != 2) {
+                dev_err(&i2c->dev, "%s: reg=0x%x (error=%d)\n",
+                        __func__, reg, ret);
+                return ret;
+        }
+        return ret;
+}
+
+/* ts port interrupt operations */
+static void smi_port_disableInterrupt(struct smi_port *port)
+{
+        struct smi_dev *dev = port->dev;
+
+        smi_write(MSI_INT_ENA_CLR,
+                (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
+}
+
+static void smi_port_enableInterrupt(struct smi_port *port)
+{
+        struct smi_dev *dev = port->dev;
+
+        smi_write(MSI_INT_ENA_SET,
+                (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
+}
+
+static void smi_port_clearInterrupt(struct smi_port *port)
+{
+        struct smi_dev *dev = port->dev;
+
+        smi_write(MSI_INT_STATUS_CLR,
+                (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
+}
+
+/* tasklet handler: DMA data to dmx.*/
+static void smi_dma_xfer(unsigned long data)
+{
+        struct smi_port *port = (struct smi_port *) data;
+        struct smi_dev *dev = port->dev;
+        u32 intr_status, finishedData, dmaManagement;
+        u8 dmaChan0State, dmaChan1State;
+
+        intr_status = port->_int_status;
+        dmaManagement = smi_read(port->DMA_MANAGEMENT);
+        dmaChan0State = (u8)((dmaManagement & 0x00000030) >> 4);
+        dmaChan1State = (u8)((dmaManagement & 0x00300000) >> 20);
+
+        /* CH-0 DMA interrupt.*/
+        if ((intr_status & port->_dmaInterruptCH0) && (dmaChan0State == 0x01)) {
+                dev_dbg(&dev->pci_dev->dev,
+                        "Port[%d]-DMA CH0 engine complete successful !\n",
+                        port->idx);
+                finishedData = smi_read(port->DMA_CHAN0_TRANS_STATE);
+                finishedData &= 0x003FFFFF;
+                /* value of DMA_PORT0_CHAN0_TRANS_STATE register [21:0]
+                 * indicate dma total transfer length and
+                 * zero of [21:0] indicate dma total transfer length
+                 * equal to 0x400000 (4MB)*/
+                if (finishedData == 0)
+                        finishedData = 0x00400000;
+                if (finishedData != SMI_TS_DMA_BUF_SIZE) {
+                        dev_dbg(&dev->pci_dev->dev,
+                                "DMA CH0 engine complete length mismatched, finish data=%d !\n",
+                                finishedData);
+                }
+                dvb_dmx_swfilter_packets(&port->demux,
+                        port->cpu_addr[0], (finishedData / 188));
+                /*dvb_dmx_swfilter(&port->demux,
+                        port->cpu_addr[0], finishedData);*/
+        }
+        /* CH-1 DMA interrupt.*/
+        if ((intr_status & port->_dmaInterruptCH1) && (dmaChan1State == 0x01)) {
+                dev_dbg(&dev->pci_dev->dev,
+                        "Port[%d]-DMA CH1 engine complete successful !\n",
+                        port->idx);
+                finishedData = smi_read(port->DMA_CHAN1_TRANS_STATE);
+                finishedData &= 0x003FFFFF;
+                /* value of DMA_PORT0_CHAN0_TRANS_STATE register [21:0]
+                 * indicate dma total transfer length and
+                 * zero of [21:0] indicate dma total transfer length
+                 * equal to 0x400000 (4MB)*/
+                if (finishedData == 0)
+                        finishedData = 0x00400000;
+                if (finishedData != SMI_TS_DMA_BUF_SIZE) {
+                        dev_dbg(&dev->pci_dev->dev,
+                                "DMA CH1 engine complete length mismatched, finish data=%d !\n",
+                                finishedData);
+                }
+                dvb_dmx_swfilter_packets(&port->demux,
+                        port->cpu_addr[1], (finishedData / 188));
+                /*dvb_dmx_swfilter(&port->demux,
+                        port->cpu_addr[1], finishedData);*/
+        }
+        /* restart DMA.*/
+        if (intr_status & port->_dmaInterruptCH0)
+                dmaManagement |= 0x00000002;
+        if (intr_status & port->_dmaInterruptCH1)
+                dmaManagement |= 0x00020000;
+        smi_write(port->DMA_MANAGEMENT, dmaManagement);
+        /* Re-enable interrupts */
+        smi_port_enableInterrupt(port);
+}
+
+static void smi_port_dma_free(struct smi_port *port)
+{
+        if (port->cpu_addr[0]) {
+                pci_free_consistent(port->dev->pci_dev, SMI_TS_DMA_BUF_SIZE,
+                                    port->cpu_addr[0], port->dma_addr[0]);
+                port->cpu_addr[0] = NULL;
+        }
+        if (port->cpu_addr[1]) {
+                pci_free_consistent(port->dev->pci_dev, SMI_TS_DMA_BUF_SIZE,
+                                    port->cpu_addr[1], port->dma_addr[1]);
+                port->cpu_addr[1] = NULL;
+        }
+}
+
+static int smi_port_init(struct smi_port *port, int dmaChanUsed)
+{
+        dev_dbg(&port->dev->pci_dev->dev,
+                "%s, port %d, dmaused %d\n", __func__, port->idx, dmaChanUsed);
+        port->enable = 0;
+        if (port->idx == 0) {
+                /* Port A */
+                port->_dmaInterruptCH0 = dmaChanUsed & 0x01;
+                port->_dmaInterruptCH1 = dmaChanUsed & 0x02;
+
+                port->DMA_CHAN0_ADDR_LOW        = DMA_PORTA_CHAN0_ADDR_LOW;
+                port->DMA_CHAN0_ADDR_HI         = DMA_PORTA_CHAN0_ADDR_HI;
+                port->DMA_CHAN0_TRANS_STATE     = DMA_PORTA_CHAN0_TRANS_STATE;
+                port->DMA_CHAN0_CONTROL         = DMA_PORTA_CHAN0_CONTROL;
+                port->DMA_CHAN1_ADDR_LOW        = DMA_PORTA_CHAN1_ADDR_LOW;
+                port->DMA_CHAN1_ADDR_HI         = DMA_PORTA_CHAN1_ADDR_HI;
+                port->DMA_CHAN1_TRANS_STATE     = DMA_PORTA_CHAN1_TRANS_STATE;
+                port->DMA_CHAN1_CONTROL         = DMA_PORTA_CHAN1_CONTROL;
+                port->DMA_MANAGEMENT            = DMA_PORTA_MANAGEMENT;
+        } else {
+                /* Port B */
+                port->_dmaInterruptCH0 = (dmaChanUsed << 2) & 0x04;
+                port->_dmaInterruptCH1 = (dmaChanUsed << 2) & 0x08;
+
+                port->DMA_CHAN0_ADDR_LOW        = DMA_PORTB_CHAN0_ADDR_LOW;
+                port->DMA_CHAN0_ADDR_HI         = DMA_PORTB_CHAN0_ADDR_HI;
+                port->DMA_CHAN0_TRANS_STATE     = DMA_PORTB_CHAN0_TRANS_STATE;
+                port->DMA_CHAN0_CONTROL         = DMA_PORTB_CHAN0_CONTROL;
+                port->DMA_CHAN1_ADDR_LOW        = DMA_PORTB_CHAN1_ADDR_LOW;
+                port->DMA_CHAN1_ADDR_HI         = DMA_PORTB_CHAN1_ADDR_HI;
+                port->DMA_CHAN1_TRANS_STATE     = DMA_PORTB_CHAN1_TRANS_STATE;
+                port->DMA_CHAN1_CONTROL         = DMA_PORTB_CHAN1_CONTROL;
+                port->DMA_MANAGEMENT            = DMA_PORTB_MANAGEMENT;
+        }
+
+        if (port->_dmaInterruptCH0) {
+                port->cpu_addr[0] = pci_alloc_consistent(port->dev->pci_dev,
+                                        SMI_TS_DMA_BUF_SIZE,
+                                        &port->dma_addr[0]);
+                if (!port->cpu_addr[0]) {
+                        dev_err(&port->dev->pci_dev->dev,
+                                "Port[%d] DMA CH0 memory allocation failed!\n",
+                                port->idx);
+                        goto err;
+                }
+        }
+
+        if (port->_dmaInterruptCH1) {
+                port->cpu_addr[1] = pci_alloc_consistent(port->dev->pci_dev,
+                                        SMI_TS_DMA_BUF_SIZE,
+                                        &port->dma_addr[1]);
+                if (!port->cpu_addr[1]) {
+                        dev_err(&port->dev->pci_dev->dev,
+                                "Port[%d] DMA CH1 memory allocation failed!\n",
+                                port->idx);
+                        goto err;
+                }
+        }
+
+        smi_port_disableInterrupt(port);
+        tasklet_init(&port->tasklet, smi_dma_xfer, (unsigned long)port);
+        tasklet_disable(&port->tasklet);
+        port->enable = 1;
+        return 0;
+err:
+        smi_port_dma_free(port);
+        return -ENOMEM;
+}
+
+static void smi_port_exit(struct smi_port *port)
+{
+        smi_port_disableInterrupt(port);
+        tasklet_kill(&port->tasklet);
+        smi_port_dma_free(port);
+        port->enable = 0;
+}
+
+static void smi_port_irq(struct smi_port *port, u32 int_status)
+{
+        u32 port_req_irq = port->_dmaInterruptCH0 | port->_dmaInterruptCH1;
+
+        if (int_status & port_req_irq) {
+                smi_port_disableInterrupt(port);
+                port->_int_status = int_status;
+                smi_port_clearInterrupt(port);
+                tasklet_schedule(&port->tasklet);
+        }
+}
+
+static irqreturn_t smi_irq_handler(int irq, void *dev_id)
+{
+        struct smi_dev *dev = dev_id;
+        struct smi_port *port0 = &dev->ts_port[0];
+        struct smi_port *port1 = &dev->ts_port[1];
+
+        u32 intr_status = smi_read(MSI_INT_STATUS);
+
+        /* ts0 interrupt.*/
+        if (dev->info->ts_0)
+                smi_port_irq(port0, intr_status);
+
+        /* ts1 interrupt.*/
+        if (dev->info->ts_1)
+                smi_port_irq(port1, intr_status);
+
+        return IRQ_HANDLED;
+}
+
+static struct i2c_client *smi_add_i2c_client(struct i2c_adapter *adapter,
+                        struct i2c_board_info *info)
+{
+        struct i2c_client *client;
+
+        request_module(info->type);
+        client = i2c_new_device(adapter, info);
+        if (client == NULL || client->dev.driver == NULL)
+                goto err_add_i2c_client;
+
+        if (!try_module_get(client->dev.driver->owner)) {
+                i2c_unregister_device(client);
+                goto err_add_i2c_client;
+        }
+        return client;
+
+err_add_i2c_client:
+        client = NULL;
+        return client;
+}
+
+static void smi_del_i2c_client(struct i2c_client *client)
+{
+        module_put(client->dev.driver->owner);
+        i2c_unregister_device(client);
+}
+
+static const struct m88ds3103_config smi_dvbsky_m88ds3103_cfg = {
+        .i2c_addr = 0x68,
+        .clock = 27000000,
+        .i2c_wr_max = 33,
+        .clock_out = 0,
+        .ts_mode = M88DS3103_TS_PARALLEL,
+        .ts_clk = 16000,
+        .ts_clk_pol = 1,
+        .agc = 0x99,
+        .lnb_hv_pol = 0,
+        .lnb_en_pol = 1,
+};
+
+static int smi_dvbsky_m88ds3103_fe_attach(struct smi_port *port)
+{
+        int ret = 0;
+        struct smi_dev *dev = port->dev;
+        struct i2c_adapter *i2c;
+        /* tuner I2C module */
+        struct i2c_adapter *tuner_i2c_adapter;
+        struct i2c_client *tuner_client;
+        struct i2c_board_info tuner_info;
+        struct m88ts2022_config m88ts2022_config = {
+                .clock = 27000000,
+        };
+        memset(&tuner_info, 0, sizeof(struct i2c_board_info));
+        i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
+
+        /* attach demod */
+        port->fe = dvb_attach(m88ds3103_attach,
+                        &smi_dvbsky_m88ds3103_cfg, i2c, &tuner_i2c_adapter);
+        if (!port->fe) {
+                ret = -ENODEV;
+                return ret;
+        }
+        /* attach tuner */
+        m88ts2022_config.fe = port->fe;
+        strlcpy(tuner_info.type, "m88ts2022", I2C_NAME_SIZE);
+        tuner_info.addr = 0x60;
+        tuner_info.platform_data = &m88ts2022_config;
+        tuner_client = smi_add_i2c_client(tuner_i2c_adapter, &tuner_info);
+        if (!tuner_client) {
+                ret = -ENODEV;
+                goto err_tuner_i2c_device;
+        }
+
+        /* delegate signal strength measurement to tuner */
+        port->fe->ops.read_signal_strength =
+                        port->fe->ops.tuner_ops.get_rf_strength;
+
+        port->i2c_client_tuner = tuner_client;
+        return ret;
+
+err_tuner_i2c_device:
+        dvb_frontend_detach(port->fe);
+        return ret;
+}
+
+static const struct m88ds3103_config smi_dvbsky_m88rs6000_cfg = {
+        .i2c_addr = 0x69,
+        .clock = 27000000,
+        .i2c_wr_max = 33,
+        .ts_mode = M88DS3103_TS_PARALLEL,
+        .ts_clk = 16000,
+        .ts_clk_pol = 1,
+        .agc = 0x99,
+        .lnb_hv_pol = 0,
+        .lnb_en_pol = 1,
+};
+
+static int smi_dvbsky_m88rs6000_fe_attach(struct smi_port *port)
+{
+        int ret = 0;
+        struct smi_dev *dev = port->dev;
+        struct i2c_adapter *i2c;
+        /* tuner I2C module */
+        struct i2c_adapter *tuner_i2c_adapter;
+        struct i2c_client *tuner_client;
+        struct i2c_board_info tuner_info;
+        struct m88rs6000t_config m88rs6000t_config;
+
+        memset(&tuner_info, 0, sizeof(struct i2c_board_info));
+        i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
+
+        /* attach demod */
+        port->fe = dvb_attach(m88ds3103_attach,
+                        &smi_dvbsky_m88rs6000_cfg, i2c, &tuner_i2c_adapter);
+        if (!port->fe) {
+                ret = -ENODEV;
+                return ret;
+        }
+        /* attach tuner */
+        m88rs6000t_config.fe = port->fe;
+        strlcpy(tuner_info.type, "m88rs6000t", I2C_NAME_SIZE);
+        tuner_info.addr = 0x21;
+        tuner_info.platform_data = &m88rs6000t_config;
+        tuner_client = smi_add_i2c_client(tuner_i2c_adapter, &tuner_info);
+        if (!tuner_client) {
+                ret = -ENODEV;
+                goto err_tuner_i2c_device;
+        }
+
+        /* delegate signal strength measurement to tuner */
+        port->fe->ops.read_signal_strength =
+                        port->fe->ops.tuner_ops.get_rf_strength;
+
+        port->i2c_client_tuner = tuner_client;
+        return ret;
+
+err_tuner_i2c_device:
+        dvb_frontend_detach(port->fe);
+        return ret;
+}
+
+static int smi_dvbsky_sit2_fe_attach(struct smi_port *port)
+{
+        int ret = 0;
+        struct smi_dev *dev = port->dev;
+        struct i2c_adapter *i2c;
+        struct i2c_adapter *tuner_i2c_adapter;
+        struct i2c_client *client_tuner, *client_demod;
+        struct i2c_board_info client_info;
+        struct si2168_config si2168_config;
+        struct si2157_config si2157_config;
+
+        /* select i2c bus */
+        i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
+
+        /* attach demod */
+        memset(&si2168_config, 0, sizeof(si2168_config));
+        si2168_config.i2c_adapter = &tuner_i2c_adapter;
+        si2168_config.fe = &port->fe;
+        si2168_config.ts_mode = SI2168_TS_PARALLEL;
+
+        memset(&client_info, 0, sizeof(struct i2c_board_info));
+        strlcpy(client_info.type, "si2168", I2C_NAME_SIZE);
+        client_info.addr = 0x64;
+        client_info.platform_data = &si2168_config;
+
+        client_demod = smi_add_i2c_client(i2c, &client_info);
+        if (!client_demod) {
+                ret = -ENODEV;
+                return ret;
+        }
+        port->i2c_client_demod = client_demod;
+
+        /* attach tuner */
+        memset(&si2157_config, 0, sizeof(si2157_config));
+        si2157_config.fe = port->fe;
+
+        memset(&client_info, 0, sizeof(struct i2c_board_info));
+        strlcpy(client_info.type, "si2157", I2C_NAME_SIZE);
+        client_info.addr = 0x60;
+        client_info.platform_data = &si2157_config;
+
+        client_tuner = smi_add_i2c_client(tuner_i2c_adapter, &client_info);
+        if (!client_tuner) {
+                smi_del_i2c_client(port->i2c_client_demod);
+                port->i2c_client_demod = NULL;
+                ret = -ENODEV;
+                return ret;
+        }
+        port->i2c_client_tuner = client_tuner;
+        return ret;
+}
+
+static int smi_fe_init(struct smi_port *port)
+{
+        int ret = 0;
+        struct smi_dev *dev = port->dev;
+        struct dvb_adapter *adap = &port->dvb_adapter;
+        u8 mac_ee[16];
+
+        dev_dbg(&port->dev->pci_dev->dev,
+                "%s: port %d, fe_type = %d\n",
+                __func__, port->idx, port->fe_type);
+        switch (port->fe_type) {
+        case DVBSKY_FE_M88DS3103:
+                ret = smi_dvbsky_m88ds3103_fe_attach(port);
+                break;
+        case DVBSKY_FE_M88RS6000:
+                ret = smi_dvbsky_m88rs6000_fe_attach(port);
+                break;
+        case DVBSKY_FE_SIT2:
+                ret = smi_dvbsky_sit2_fe_attach(port);
+                break;
+        }
+        if (ret < 0)
+                return ret;
+
+        /* register dvb frontend */
+        ret = dvb_register_frontend(adap, port->fe);
+        if (ret < 0) {
+                if (port->i2c_client_tuner)
+                        smi_del_i2c_client(port->i2c_client_tuner);
+                if (port->i2c_client_demod)
+                        smi_del_i2c_client(port->i2c_client_demod);
+                dvb_frontend_detach(port->fe);
+                return ret;
+        }
+        /* init MAC.*/
+        ret = smi_read_eeprom(&dev->i2c_bus[0], 0xc0, mac_ee, 16);
+        dev_info(&port->dev->pci_dev->dev,
+                "DVBSky SMI PCIe MAC= %pM\n", mac_ee + (port->idx)*8);
+        memcpy(adap->proposed_mac, mac_ee + (port->idx)*8, 6);
+        return ret;
+}
+
+static void smi_fe_exit(struct smi_port *port)
+{
+        dvb_unregister_frontend(port->fe);
+        /* remove I2C demod and tuner */
+        if (port->i2c_client_tuner)
+                smi_del_i2c_client(port->i2c_client_tuner);
+        if (port->i2c_client_demod)
+                smi_del_i2c_client(port->i2c_client_demod);
+        dvb_frontend_detach(port->fe);
+}
+
+static int my_dvb_dmx_ts_card_init(struct dvb_demux *dvbdemux, char *id,
+                            int (*start_feed)(struct dvb_demux_feed *),
+                            int (*stop_feed)(struct dvb_demux_feed *),
+                            void *priv)
+{
+        dvbdemux->priv = priv;
+
+        dvbdemux->filternum = 256;
+        dvbdemux->feednum = 256;
+        dvbdemux->start_feed = start_feed;
+        dvbdemux->stop_feed = stop_feed;
+        dvbdemux->write_to_decoder = NULL;
+        dvbdemux->dmx.capabilities = (DMX_TS_FILTERING |
+                                      DMX_SECTION_FILTERING |
+                                      DMX_MEMORY_BASED_FILTERING);
+        return dvb_dmx_init(dvbdemux);
+}
+
+static int my_dvb_dmxdev_ts_card_init(struct dmxdev *dmxdev,
+                               struct dvb_demux *dvbdemux,
+                               struct dmx_frontend *hw_frontend,
+                               struct dmx_frontend *mem_frontend,
+                               struct dvb_adapter *dvb_adapter)
+{
+        int ret;
+
+        dmxdev->filternum = 256;
+        dmxdev->demux = &dvbdemux->dmx;
+        dmxdev->capabilities = 0;
+        ret = dvb_dmxdev_init(dmxdev, dvb_adapter);
+        if (ret < 0)
+                return ret;
+
+        hw_frontend->source = DMX_FRONTEND_0;
+        dvbdemux->dmx.add_frontend(&dvbdemux->dmx, hw_frontend);
+        mem_frontend->source = DMX_MEMORY_FE;
+        dvbdemux->dmx.add_frontend(&dvbdemux->dmx, mem_frontend);
+        return dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, hw_frontend);
+}
+
+static u32 smi_config_DMA(struct smi_port *port)
+{
+        struct smi_dev *dev = port->dev;
+        u32 totalLength = 0, dmaMemPtrLow, dmaMemPtrHi, dmaCtlReg;
+        u8 chanLatencyTimer = 0, dmaChanEnable = 1, dmaTransStart = 1;
+        u32 dmaManagement = 0, tlpTransUnit = DMA_TRANS_UNIT_188;
+        u8 tlpTc = 0, tlpTd = 1, tlpEp = 0, tlpAttr = 0;
+        u64 mem;
+
+        dmaManagement = smi_read(port->DMA_MANAGEMENT);
+        /* Setup Channel-0 */
+        if (port->_dmaInterruptCH0) {
+                totalLength = SMI_TS_DMA_BUF_SIZE;
+                mem = port->dma_addr[0];
+                dmaMemPtrLow = mem & 0xffffffff;
+                dmaMemPtrHi = mem >> 32;
+                dmaCtlReg = (totalLength) | (tlpTransUnit << 22) | (tlpTc << 25)
+                        | (tlpTd << 28) | (tlpEp << 29) | (tlpAttr << 30);
+                dmaManagement |= dmaChanEnable | (dmaTransStart << 1)
+                        | (chanLatencyTimer << 8);
+                /* write DMA register, start DMA engine */
+                smi_write(port->DMA_CHAN0_ADDR_LOW, dmaMemPtrLow);
+                smi_write(port->DMA_CHAN0_ADDR_HI, dmaMemPtrHi);
+                smi_write(port->DMA_CHAN0_CONTROL, dmaCtlReg);
+        }
+        /* Setup Channel-1 */
+        if (port->_dmaInterruptCH1) {
+                totalLength = SMI_TS_DMA_BUF_SIZE;
+                mem = port->dma_addr[1];
+                dmaMemPtrLow = mem & 0xffffffff;
+                dmaMemPtrHi = mem >> 32;
+                dmaCtlReg = (totalLength) | (tlpTransUnit << 22) | (tlpTc << 25)
+                        | (tlpTd << 28) | (tlpEp << 29) | (tlpAttr << 30);
+                dmaManagement |= (dmaChanEnable << 16) | (dmaTransStart << 17)
+                        | (chanLatencyTimer << 24);
+                /* write DMA register, start DMA engine */
+                smi_write(port->DMA_CHAN1_ADDR_LOW, dmaMemPtrLow);
+                smi_write(port->DMA_CHAN1_ADDR_HI, dmaMemPtrHi);
+                smi_write(port->DMA_CHAN1_CONTROL, dmaCtlReg);
+        }
+        return dmaManagement;
+}
+
+static int smi_start_feed(struct dvb_demux_feed *dvbdmxfeed)
+{
+        struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
+        struct smi_port *port = dvbdmx->priv;
+        struct smi_dev *dev = port->dev;
+        u32 dmaManagement;
+
+        if (port->users++ == 0) {
+                dmaManagement = smi_config_DMA(port);
+                smi_port_clearInterrupt(port);
+                smi_port_enableInterrupt(port);
+                smi_write(port->DMA_MANAGEMENT, dmaManagement);
+                tasklet_enable(&port->tasklet);
+        }
+        return port->users;
+}
+
+static int smi_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
+{
+        struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
+        struct smi_port *port = dvbdmx->priv;
+        struct smi_dev *dev = port->dev;
+
+        if (--port->users)
+                return port->users;
+
+        tasklet_disable(&port->tasklet);
+        smi_port_disableInterrupt(port);
+        smi_clear(port->DMA_MANAGEMENT, 0x30003);
+        return 0;
+}
+
+static int smi_dvb_init(struct smi_port *port)
+{
+        int ret;
+        struct dvb_adapter *adap = &port->dvb_adapter;
+        struct dvb_demux *dvbdemux = &port->demux;
+
+        dev_dbg(&port->dev->pci_dev->dev,
+                "%s, port %d\n", __func__, port->idx);
+
+        ret = dvb_register_adapter(adap, "SMI_DVB", THIS_MODULE,
+                                   &port->dev->pci_dev->dev,
+                                   adapter_nr);
+        if (ret < 0) {
+                dev_err(&port->dev->pci_dev->dev, "Fail to register DVB adapter.\n");
+                return ret;
+        }
+        ret = my_dvb_dmx_ts_card_init(dvbdemux, "SW demux",
+                                      smi_start_feed,
+                                      smi_stop_feed, port);
+        if (ret < 0)
+                goto err_del_dvb_register_adapter;
+
+        ret = my_dvb_dmxdev_ts_card_init(&port->dmxdev, &port->demux,
+                                         &port->hw_frontend,
+                                         &port->mem_frontend, adap);
+        if (ret < 0)
+                goto err_del_dvb_dmx;
+
+        ret = dvb_net_init(adap, &port->dvbnet, port->dmxdev.demux);
+        if (ret < 0)
+                goto err_del_dvb_dmxdev;
+        return 0;
+err_del_dvb_dmxdev:
+        dvbdemux->dmx.close(&dvbdemux->dmx);
+        dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->hw_frontend);
+        dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->mem_frontend);
+        dvb_dmxdev_release(&port->dmxdev);
+err_del_dvb_dmx:
+        dvb_dmx_release(&port->demux);
+err_del_dvb_register_adapter:
+        dvb_unregister_adapter(&port->dvb_adapter);
+        return ret;
+}
+
+static void smi_dvb_exit(struct smi_port *port)
+{
+        struct dvb_demux *dvbdemux = &port->demux;
+
+        dvb_net_release(&port->dvbnet);
+
+        dvbdemux->dmx.close(&dvbdemux->dmx);
+        dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->hw_frontend);
+        dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->mem_frontend);
+        dvb_dmxdev_release(&port->dmxdev);
+        dvb_dmx_release(&port->demux);
+
+        dvb_unregister_adapter(&port->dvb_adapter);
+}
+
+static int smi_port_attach(struct smi_dev *dev,
+                struct smi_port *port, int index)
+{
+        int ret, dmachs;
+
+        port->dev = dev;
+        port->idx = index;
+        port->fe_type = (index == 0) ? dev->info->fe_0 : dev->info->fe_1;
+        dmachs = (index == 0) ? dev->info->ts_0 : dev->info->ts_1;
+        /* port init.*/
+        ret = smi_port_init(port, dmachs);
+        if (ret < 0)
+                return ret;
+        /* dvb init.*/
+        ret = smi_dvb_init(port);
+        if (ret < 0)
+                goto err_del_port_init;
+        /* fe init.*/
+        ret = smi_fe_init(port);
+        if (ret < 0)
+                goto err_del_dvb_init;
+        return 0;
+err_del_dvb_init:
+        smi_dvb_exit(port);
+err_del_port_init:
+        smi_port_exit(port);
+        return ret;
+}
+
+static void smi_port_detach(struct smi_port *port)
+{
+        smi_fe_exit(port);
+        smi_dvb_exit(port);
+        smi_port_exit(port);
+}
+
+static int smi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        struct smi_dev *dev;
+        int ret = -ENOMEM;
+
+        if (pci_enable_device(pdev) < 0)
+                return -ENODEV;
+
+        dev = kzalloc(sizeof(struct smi_dev), GFP_KERNEL);
+        if (!dev) {
+                ret = -ENOMEM;
+                goto err_pci_disable_device;
+        }
+
+        dev->pci_dev = pdev;
+        pci_set_drvdata(pdev, dev);
+        dev->info = (struct smi_cfg_info *) id->driver_data;
+        dev_info(&dev->pci_dev->dev,
+                "card detected: %s\n", dev->info->name);
+
+        dev->nr = dev->info->type;
+        dev->lmmio = ioremap(pci_resource_start(dev->pci_dev, 0),
+                            pci_resource_len(dev->pci_dev, 0));
+        if (!dev->lmmio) {
+                ret = -ENOMEM;
+                goto err_kfree;
+        }
+
+        /* should we set to 32bit DMA? */
+        ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+        if (ret < 0)
+                goto err_pci_iounmap;
+
+        pci_set_master(pdev);
+
+        ret = smi_hw_init(dev);
+        if (ret < 0)
+                goto err_pci_iounmap;
+
+        ret = smi_i2c_init(dev);
+        if (ret < 0)
+                goto err_pci_iounmap;
+
+        if (dev->info->ts_0) {
+                ret = smi_port_attach(dev, &dev->ts_port[0], 0);
+                if (ret < 0)
+                        goto err_del_i2c_adaptor;
+        }
+
+        if (dev->info->ts_1) {
+                ret = smi_port_attach(dev, &dev->ts_port[1], 1);
+                if (ret < 0)
+                        goto err_del_port0_attach;
+        }
+
+#ifdef CONFIG_PCI_MSI /* to do msi interrupt.???*/
+        if (pci_msi_enabled())
+                ret = pci_enable_msi(dev->pci_dev);
+        if (ret)
+                dev_info(&dev->pci_dev->dev, "MSI not available.\n");
+#endif
+
+        ret = request_irq(dev->pci_dev->irq, smi_irq_handler,
+                           IRQF_SHARED, "SMI_PCIE", dev);
+        if (ret < 0)
+                goto err_del_port1_attach;
+
+        return 0;
+
+err_del_port1_attach:
+        if (dev->info->ts_1)
+                smi_port_detach(&dev->ts_port[1]);
+err_del_port0_attach:
+        if (dev->info->ts_0)
+                smi_port_detach(&dev->ts_port[0]);
+err_del_i2c_adaptor:
+        smi_i2c_exit(dev);
+err_pci_iounmap:
+        iounmap(dev->lmmio);
+err_kfree:
+        pci_set_drvdata(pdev, NULL);
+        kfree(dev);
+err_pci_disable_device:
+        pci_disable_device(pdev);
+        return ret;
+}
+
+static void smi_remove(struct pci_dev *pdev)
+{
+        struct smi_dev *dev = pci_get_drvdata(pdev);
+
+        smi_write(MSI_INT_ENA_CLR, ALL_INT);
+        free_irq(dev->pci_dev->irq, dev);
+#ifdef CONFIG_PCI_MSI
+        pci_disable_msi(dev->pci_dev);
+#endif
+        if (dev->info->ts_1)
+                smi_port_detach(&dev->ts_port[1]);
+        if (dev->info->ts_0)
+                smi_port_detach(&dev->ts_port[0]);
+
+        smi_i2c_exit(dev);
+        iounmap(dev->lmmio);
+        pci_set_drvdata(pdev, NULL);
+        pci_disable_device(pdev);
+        kfree(dev);
+}
+
+/* DVBSky cards */
+static struct smi_cfg_info dvbsky_s950_cfg = {
+        .type = SMI_DVBSKY_S950,
+        .name = "DVBSky S950 V3",
+        .ts_0 = SMI_TS_NULL,
+        .ts_1 = SMI_TS_DMA_BOTH,
+        .fe_0 = DVBSKY_FE_NULL,
+        .fe_1 = DVBSKY_FE_M88DS3103,
+};
+
+static struct smi_cfg_info dvbsky_s952_cfg = {
+        .type = SMI_DVBSKY_S952,
+        .name = "DVBSky S952 V3",
+        .ts_0 = SMI_TS_DMA_BOTH,
+        .ts_1 = SMI_TS_DMA_BOTH,
+        .fe_0 = DVBSKY_FE_M88RS6000,
+        .fe_1 = DVBSKY_FE_M88RS6000,
+};
+
+static struct smi_cfg_info dvbsky_t9580_cfg = {
+        .type = SMI_DVBSKY_T9580,
+        .name = "DVBSky T9580 V3",
+        .ts_0 = SMI_TS_DMA_BOTH,
+        .ts_1 = SMI_TS_DMA_BOTH,
+        .fe_0 = DVBSKY_FE_SIT2,
+        .fe_1 = DVBSKY_FE_M88DS3103,
+};
+
+/* PCI IDs */
+#define SMI_ID(_subvend, _subdev, _driverdata) {        \
+        .vendor      = SMI_VID,    .device    = SMI_PID, \
+        .subvendor   = _subvend, .subdevice = _subdev, \
+        .driver_data = (unsigned long)&_driverdata }
+
+static const struct pci_device_id smi_id_table[] = {
+        SMI_ID(0x4254, 0x0550, dvbsky_s950_cfg),
+        SMI_ID(0x4254, 0x0552, dvbsky_s952_cfg),
+        SMI_ID(0x4254, 0x5580, dvbsky_t9580_cfg),
+        {0}
+};
+MODULE_DEVICE_TABLE(pci, smi_id_table);
+
+static struct pci_driver smipcie_driver = {
+        .name = "SMI PCIe driver",
+        .id_table = smi_id_table,
+        .probe = smi_probe,
+        .remove = smi_remove,
+};
+
+module_pci_driver(smipcie_driver);
+
+MODULE_AUTHOR("Max nibble <nibble.max@gmail.com>");
+MODULE_DESCRIPTION("SMI PCIe driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/pci/smipcie/smipcie.h b/drivers/media/pci/smipcie/smipcie.h
new file mode 100644
index 000000000000..10cdf20f4839
--- /dev/null
+++ b/drivers/media/pci/smipcie/smipcie.h
@@ -0,0 +1,299 @@
+/*
+ * SMI PCIe driver for DVBSky cards.
+ *
+ * Copyright (C) 2014 Max nibble <nibble.max@gmail.com>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#ifndef _SMI_PCIE_H_
+#define _SMI_PCIE_H_
+
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <linux/slab.h>
+#include <media/rc-core.h>
+
+#include "demux.h"
+#include "dmxdev.h"
+#include "dvb_demux.h"
+#include "dvb_frontend.h"
+#include "dvb_net.h"
+#include "dvbdev.h"
+
+/* -------- Register Base -------- */
+#define    MSI_CONTROL_REG_BASE                 0x0800
+#define    SYSTEM_CONTROL_REG_BASE              0x0880
+#define    PCIE_EP_DEBUG_REG_BASE               0x08C0
+#define    IR_CONTROL_REG_BASE                  0x0900
+#define    I2C_A_CONTROL_REG_BASE               0x0940
+#define    I2C_B_CONTROL_REG_BASE               0x0980
+#define    ATV_PORTA_CONTROL_REG_BASE           0x09C0
+#define    DTV_PORTA_CONTROL_REG_BASE           0x0A00
+#define    AES_PORTA_CONTROL_REG_BASE           0x0A80
+#define    DMA_PORTA_CONTROL_REG_BASE           0x0AC0
+#define    ATV_PORTB_CONTROL_REG_BASE           0x0B00
+#define    DTV_PORTB_CONTROL_REG_BASE           0x0B40
+#define    AES_PORTB_CONTROL_REG_BASE           0x0BC0
+#define    DMA_PORTB_CONTROL_REG_BASE           0x0C00
+#define    UART_A_REGISTER_BASE                 0x0C40
+#define    UART_B_REGISTER_BASE                 0x0C80
+#define    GPS_CONTROL_REG_BASE                 0x0CC0
+#define    DMA_PORTC_CONTROL_REG_BASE           0x0D00
+#define    DMA_PORTD_CONTROL_REG_BASE           0x0D00
+#define    AES_RANDOM_DATA_BASE                 0x0D80
+#define    AES_KEY_IN_BASE                      0x0D90
+#define    RANDOM_DATA_LIB_BASE                 0x0E00
+#define    IR_DATA_BUFFER_BASE                  0x0F00
+#define    PORTA_TS_BUFFER_BASE                 0x1000
+#define    PORTA_I2S_BUFFER_BASE                0x1400
+#define    PORTB_TS_BUFFER_BASE                 0x1800
+#define    PORTB_I2S_BUFFER_BASE                0x1C00
+
+/* -------- MSI control and state register -------- */
+#define MSI_DELAY_TIMER             (MSI_CONTROL_REG_BASE + 0x00)
+#define MSI_INT_STATUS              (MSI_CONTROL_REG_BASE + 0x08)
+#define MSI_INT_STATUS_CLR          (MSI_CONTROL_REG_BASE + 0x0C)
+#define MSI_INT_STATUS_SET          (MSI_CONTROL_REG_BASE + 0x10)
+#define MSI_INT_ENA                 (MSI_CONTROL_REG_BASE + 0x14)
+#define MSI_INT_ENA_CLR             (MSI_CONTROL_REG_BASE + 0x18)
+#define MSI_INT_ENA_SET             (MSI_CONTROL_REG_BASE + 0x1C)
+#define MSI_SOFT_RESET              (MSI_CONTROL_REG_BASE + 0x20)
+#define MSI_CFG_SRC0                (MSI_CONTROL_REG_BASE + 0x24)
+
+/* -------- Hybird Controller System Control register -------- */
+#define MUX_MODE_CTRL         (SYSTEM_CONTROL_REG_BASE + 0x00)
+        #define rbPaMSMask        0x07
+        #define rbPaMSDtvNoGpio   0x00 /*[2:0], DTV Simple mode */
+        #define rbPaMSDtv4bitGpio 0x01 /*[2:0], DTV TS2 Serial mode)*/
+        #define rbPaMSDtv7bitGpio 0x02 /*[2:0], DTV TS0 Serial mode*/
+        #define rbPaMS8bitGpio    0x03 /*[2:0], GPIO mode selected;(8bit GPIO)*/
+        #define rbPaMSAtv         0x04 /*[2:0], 3'b1xx: ATV mode select*/
+        #define rbPbMSMask        0x38
+        #define rbPbMSDtvNoGpio   0x00 /*[5:3], DTV Simple mode */
+        #define rbPbMSDtv4bitGpio 0x08 /*[5:3], DTV TS2 Serial mode*/
+        #define rbPbMSDtv7bitGpio 0x10 /*[5:3], DTV TS0 Serial mode*/
+        #define rbPbMS8bitGpio    0x18 /*[5:3], GPIO mode selected;(8bit GPIO)*/
+        #define rbPbMSAtv         0x20 /*[5:3], 3'b1xx: ATV mode select*/
+        #define rbPaAESEN         0x40 /*[6], port A AES enable bit*/
+        #define rbPbAESEN         0x80 /*[7], port B AES enable bit*/
+
+#define INTERNAL_RST                (SYSTEM_CONTROL_REG_BASE + 0x04)
+#define PERIPHERAL_CTRL             (SYSTEM_CONTROL_REG_BASE + 0x08)
+#define GPIO_0to7_CTRL              (SYSTEM_CONTROL_REG_BASE + 0x0C)
+#define GPIO_8to15_CTRL             (SYSTEM_CONTROL_REG_BASE + 0x10)
+#define GPIO_16to24_CTRL            (SYSTEM_CONTROL_REG_BASE + 0x14)
+#define GPIO_INT_SRC_CFG            (SYSTEM_CONTROL_REG_BASE + 0x18)
+#define SYS_BUF_STATUS              (SYSTEM_CONTROL_REG_BASE + 0x1C)
+#define PCIE_IP_REG_ACS             (SYSTEM_CONTROL_REG_BASE + 0x20)
+#define PCIE_IP_REG_ACS_ADDR        (SYSTEM_CONTROL_REG_BASE + 0x24)
+#define PCIE_IP_REG_ACS_DATA        (SYSTEM_CONTROL_REG_BASE + 0x28)
+
+/* -------- IR Control register -------- */
+#define   IR_Init_Reg         (IR_CONTROL_REG_BASE + 0x00)
+#define   IR_Idle_Cnt_Low     (IR_CONTROL_REG_BASE + 0x04)
+#define   IR_Idle_Cnt_High    (IR_CONTROL_REG_BASE + 0x05)
+#define   IR_Unit_Cnt_Low     (IR_CONTROL_REG_BASE + 0x06)
+#define   IR_Unit_Cnt_High    (IR_CONTROL_REG_BASE + 0x07)
+#define   IR_Data_Cnt         (IR_CONTROL_REG_BASE + 0x08)
+#define   rbIRen            0x80
+#define   rbIRhighidle      0x10
+#define   rbIRlowidle       0x00
+#define   rbIRVld           0x04
+
+/* -------- I2C A control and state register -------- */
+#define I2C_A_CTL_STATUS                 (I2C_A_CONTROL_REG_BASE + 0x00)
+#define I2C_A_ADDR                       (I2C_A_CONTROL_REG_BASE + 0x04)
+#define I2C_A_SW_CTL                     (I2C_A_CONTROL_REG_BASE + 0x08)
+#define I2C_A_TIME_OUT_CNT               (I2C_A_CONTROL_REG_BASE + 0x0C)
+#define I2C_A_FIFO_STATUS                (I2C_A_CONTROL_REG_BASE + 0x10)
+#define I2C_A_FS_EN                      (I2C_A_CONTROL_REG_BASE + 0x14)
+#define I2C_A_FIFO_DATA                  (I2C_A_CONTROL_REG_BASE + 0x20)
+
+/* -------- I2C B control and state register -------- */
+#define I2C_B_CTL_STATUS                 (I2C_B_CONTROL_REG_BASE + 0x00)
+#define I2C_B_ADDR                       (I2C_B_CONTROL_REG_BASE + 0x04)
+#define I2C_B_SW_CTL                     (I2C_B_CONTROL_REG_BASE + 0x08)
+#define I2C_B_TIME_OUT_CNT               (I2C_B_CONTROL_REG_BASE + 0x0C)
+#define I2C_B_FIFO_STATUS                (I2C_B_CONTROL_REG_BASE + 0x10)
+#define I2C_B_FS_EN                      (I2C_B_CONTROL_REG_BASE + 0x14)
+#define I2C_B_FIFO_DATA                  (I2C_B_CONTROL_REG_BASE + 0x20)
+
+#define VIDEO_CTRL_STATUS_A     (ATV_PORTA_CONTROL_REG_BASE + 0x04)
+
+/* -------- Digital TV control register, Port A -------- */
+#define MPEG2_CTRL_A            (DTV_PORTA_CONTROL_REG_BASE + 0x00)
+#define SERIAL_IN_ADDR_A        (DTV_PORTA_CONTROL_REG_BASE + 0x4C)
+#define VLD_CNT_ADDR_A          (DTV_PORTA_CONTROL_REG_BASE + 0x60)
+#define ERR_CNT_ADDR_A          (DTV_PORTA_CONTROL_REG_BASE + 0x64)
+#define BRD_CNT_ADDR_A          (DTV_PORTA_CONTROL_REG_BASE + 0x68)
+
+/* -------- DMA Control Register, Port A  -------- */
+#define DMA_PORTA_CHAN0_ADDR_LOW        (DMA_PORTA_CONTROL_REG_BASE + 0x00)
+#define DMA_PORTA_CHAN0_ADDR_HI         (DMA_PORTA_CONTROL_REG_BASE + 0x04)
+#define DMA_PORTA_CHAN0_TRANS_STATE     (DMA_PORTA_CONTROL_REG_BASE + 0x08)
+#define DMA_PORTA_CHAN0_CONTROL         (DMA_PORTA_CONTROL_REG_BASE + 0x0C)
+#define DMA_PORTA_CHAN1_ADDR_LOW        (DMA_PORTA_CONTROL_REG_BASE + 0x10)
+#define DMA_PORTA_CHAN1_ADDR_HI         (DMA_PORTA_CONTROL_REG_BASE + 0x14)
+#define DMA_PORTA_CHAN1_TRANS_STATE     (DMA_PORTA_CONTROL_REG_BASE + 0x18)
+#define DMA_PORTA_CHAN1_CONTROL         (DMA_PORTA_CONTROL_REG_BASE + 0x1C)
+#define DMA_PORTA_MANAGEMENT            (DMA_PORTA_CONTROL_REG_BASE + 0x20)
+#define VIDEO_CTRL_STATUS_B             (ATV_PORTB_CONTROL_REG_BASE + 0x04)
+
+/* -------- Digital TV control register, Port B -------- */
+#define MPEG2_CTRL_B            (DTV_PORTB_CONTROL_REG_BASE + 0x00)
+#define SERIAL_IN_ADDR_B        (DTV_PORTB_CONTROL_REG_BASE + 0x4C)
+#define VLD_CNT_ADDR_B          (DTV_PORTB_CONTROL_REG_BASE + 0x60)
+#define ERR_CNT_ADDR_B          (DTV_PORTB_CONTROL_REG_BASE + 0x64)
+#define BRD_CNT_ADDR_B          (DTV_PORTB_CONTROL_REG_BASE + 0x68)
+
+/* -------- AES control register, Port B -------- */
+#define AES_CTRL_B              (AES_PORTB_CONTROL_REG_BASE + 0x00)
+#define AES_KEY_BASE_B  (AES_PORTB_CONTROL_REG_BASE + 0x04)
+
+/* -------- DMA Control Register, Port B  -------- */
+#define DMA_PORTB_CHAN0_ADDR_LOW        (DMA_PORTB_CONTROL_REG_BASE + 0x00)
+#define DMA_PORTB_CHAN0_ADDR_HI         (DMA_PORTB_CONTROL_REG_BASE + 0x04)
+#define DMA_PORTB_CHAN0_TRANS_STATE     (DMA_PORTB_CONTROL_REG_BASE + 0x08)
+#define DMA_PORTB_CHAN0_CONTROL         (DMA_PORTB_CONTROL_REG_BASE + 0x0C)
+#define DMA_PORTB_CHAN1_ADDR_LOW        (DMA_PORTB_CONTROL_REG_BASE + 0x10)
+#define DMA_PORTB_CHAN1_ADDR_HI         (DMA_PORTB_CONTROL_REG_BASE + 0x14)
+#define DMA_PORTB_CHAN1_TRANS_STATE     (DMA_PORTB_CONTROL_REG_BASE + 0x18)
+#define DMA_PORTB_CHAN1_CONTROL         (DMA_PORTB_CONTROL_REG_BASE + 0x1C)
+#define DMA_PORTB_MANAGEMENT            (DMA_PORTB_CONTROL_REG_BASE + 0x20)
+
+#define DMA_TRANS_UNIT_188 (0x00000007)
+
+/* -------- Macro define of 24 interrupt resource --------*/
+#define DMA_A_CHAN0_DONE_INT   (0x00000001)
+#define DMA_A_CHAN1_DONE_INT   (0x00000002)
+#define DMA_B_CHAN0_DONE_INT   (0x00000004)
+#define DMA_B_CHAN1_DONE_INT   (0x00000008)
+#define DMA_C_CHAN0_DONE_INT   (0x00000010)
+#define DMA_C_CHAN1_DONE_INT   (0x00000020)
+#define DMA_D_CHAN0_DONE_INT   (0x00000040)
+#define DMA_D_CHAN1_DONE_INT   (0x00000080)
+#define DATA_BUF_OVERFLOW_INT  (0x00000100)
+#define UART_0_X_INT           (0x00000200)
+#define UART_1_X_INT           (0x00000400)
+#define IR_X_INT               (0x00000800)
+#define GPIO_0_INT             (0x00001000)
+#define GPIO_1_INT             (0x00002000)
+#define GPIO_2_INT             (0x00004000)
+#define GPIO_3_INT             (0x00008000)
+#define ALL_INT                (0x0000FFFF)
+
+/* software I2C bit mask */
+#define SW_I2C_MSK_MODE         0x01
+#define SW_I2C_MSK_CLK_OUT      0x02
+#define SW_I2C_MSK_DAT_OUT      0x04
+#define SW_I2C_MSK_CLK_EN       0x08
+#define SW_I2C_MSK_DAT_EN       0x10
+#define SW_I2C_MSK_DAT_IN       0x40
+#define SW_I2C_MSK_CLK_IN       0x80
+
+#define SMI_VID         0x1ADE
+#define SMI_PID         0x3038
+#define SMI_TS_DMA_BUF_SIZE     (1024 * 188)
+
+struct smi_cfg_info {
+#define SMI_DVBSKY_S952         0
+#define SMI_DVBSKY_S950         1
+#define SMI_DVBSKY_T9580        2
+#define SMI_DVBSKY_T982         3
+        int type;
+        char *name;
+#define SMI_TS_NULL             0
+#define SMI_TS_DMA_SINGLE       1
+#define SMI_TS_DMA_BOTH         3
+/* SMI_TS_NULL: not use;
+ * SMI_TS_DMA_SINGLE: use DMA 0 only;
+ * SMI_TS_DMA_BOTH:use DMA 0 and 1.*/
+        int ts_0;
+        int ts_1;
+#define DVBSKY_FE_NULL          0
+#define DVBSKY_FE_M88RS6000     1
+#define DVBSKY_FE_M88DS3103     2
+#define DVBSKY_FE_SIT2          3
+        int fe_0;
+        int fe_1;
+};
+
+struct smi_port {
+        struct smi_dev *dev;
+        int idx;
+        int enable;
+        int fe_type;
+        /* regs */
+        u32 DMA_CHAN0_ADDR_LOW;
+        u32 DMA_CHAN0_ADDR_HI;
+        u32 DMA_CHAN0_TRANS_STATE;
+        u32 DMA_CHAN0_CONTROL;
+        u32 DMA_CHAN1_ADDR_LOW;
+        u32 DMA_CHAN1_ADDR_HI;
+        u32 DMA_CHAN1_TRANS_STATE;
+        u32 DMA_CHAN1_CONTROL;
+        u32 DMA_MANAGEMENT;
+        /* dma */
+        dma_addr_t dma_addr[2];
+        u8 *cpu_addr[2];
+        u32 _dmaInterruptCH0;
+        u32 _dmaInterruptCH1;
+        u32 _int_status;
+        struct tasklet_struct tasklet;
+        /* dvb */
+        struct dmx_frontend hw_frontend;
+        struct dmx_frontend mem_frontend;
+        struct dmxdev dmxdev;
+        struct dvb_adapter dvb_adapter;
+        struct dvb_demux demux;
+        struct dvb_net dvbnet;
+        int users;
+        struct dvb_frontend *fe;
+        /* frontend i2c module */
+        struct i2c_client *i2c_client_demod;
+        struct i2c_client *i2c_client_tuner;
+};
+
+struct smi_dev {
+        int nr;
+        struct smi_cfg_info *info;
+
+        /* pcie */
+        struct pci_dev *pci_dev;
+        u32 __iomem *lmmio;
+
+        /* ts port */
+        struct smi_port ts_port[2];
+
+        /* i2c */
+        struct i2c_adapter i2c_bus[2];
+        struct i2c_algo_bit_data i2c_bit[2];
+};
+
+#define smi_read(reg)             readl(dev->lmmio + ((reg)>>2))
+#define smi_write(reg, value)     writel((value), dev->lmmio + ((reg)>>2))
+
+#define smi_andor(reg, mask, value) \
+        writel((readl(dev->lmmio+((reg)>>2)) & ~(mask)) |\
+        ((value) & (mask)), dev->lmmio+((reg)>>2))
+
+#define smi_set(reg, bit)          smi_andor((reg), (bit), (bit))
+#define smi_clear(reg, bit)        smi_andor((reg), (bit), 0)
+
+#endif /* #ifndef _SMI_PCIE_H_ */
diff --git a/drivers/media/pci/solo6x10/solo6x10-core.c b/drivers/media/pci/solo6x10/solo6x10-core.c
index 172583d736fe..8cbe6b49f4c2 100644
--- a/drivers/media/pci/solo6x10/solo6x10-core.c
+++ b/drivers/media/pci/solo6x10/solo6x10-core.c
@@ -105,11 +105,8 @@ static irqreturn_t solo_isr(int irq, void *data)
         if (!status)
                 return IRQ_NONE;
 
-        if (status & ~solo_dev->irq_mask) {
-                solo_reg_write(solo_dev, SOLO_IRQ_STAT,
-                               status & ~solo_dev->irq_mask);
-                status &= solo_dev->irq_mask;
-        }
+        /* Acknowledge all interrupts immediately */
+        solo_reg_write(solo_dev, SOLO_IRQ_STAT, status);
 
         if (status & SOLO_IRQ_PCI_ERR)
                 solo_p2m_error_isr(solo_dev);
@@ -132,9 +129,6 @@ static irqreturn_t solo_isr(int irq, void *data)
         if (status & SOLO_IRQ_G723)
                 solo_g723_isr(solo_dev);
 
-        /* Clear all interrupts handled */
-        solo_reg_write(solo_dev, SOLO_IRQ_STAT, status);
-
         return IRQ_HANDLED;
 }
 
diff --git a/drivers/media/pci/solo6x10/solo6x10-v4l2-enc.c b/drivers/media/pci/solo6x10/solo6x10-v4l2-enc.c
index 28023f9f1dc7..6e933d383fa2 100644
--- a/drivers/media/pci/solo6x10/solo6x10-v4l2-enc.c
+++ b/drivers/media/pci/solo6x10/solo6x10-v4l2-enc.c
@@ -463,7 +463,6 @@ static int solo_fill_jpeg(struct solo_enc_dev *solo_enc,
         struct solo_dev *solo_dev = solo_enc->solo_dev;
         struct sg_table *vbuf = vb2_dma_sg_plane_desc(vb, 0);
         int frame_size;
-        int ret;
 
         vb->v4l2_buf.flags |= V4L2_BUF_FLAG_KEYFRAME;
 
@@ -473,22 +472,10 @@ static int solo_fill_jpeg(struct solo_enc_dev *solo_enc,
         frame_size = ALIGN(vop_jpeg_size(vh) + solo_enc->jpeg_len, DMA_ALIGN);
         vb2_set_plane_payload(vb, 0, vop_jpeg_size(vh) + solo_enc->jpeg_len);
 
-        /* may discard all previous data in vbuf->sgl */
-        if (!dma_map_sg(&solo_dev->pdev->dev, vbuf->sgl, vbuf->nents,
-                        DMA_FROM_DEVICE))
-                return -ENOMEM;
-        ret = solo_send_desc(solo_enc, solo_enc->jpeg_len, vbuf,
+        return solo_send_desc(solo_enc, solo_enc->jpeg_len, vbuf,
                              vop_jpeg_offset(vh) - SOLO_JPEG_EXT_ADDR(solo_dev),
                              frame_size, SOLO_JPEG_EXT_ADDR(solo_dev),
                              SOLO_JPEG_EXT_SIZE(solo_dev));
-        dma_unmap_sg(&solo_dev->pdev->dev, vbuf->sgl, vbuf->nents,
-                        DMA_FROM_DEVICE);
-
-        /* add the header only after dma_unmap_sg() */
-        sg_copy_from_buffer(vbuf->sgl, vbuf->nents,
-                            solo_enc->jpeg_header, solo_enc->jpeg_len);
-
-        return ret;
 }
 
 static int solo_fill_mpeg(struct solo_enc_dev *solo_enc,
@@ -498,7 +485,6 @@ static int solo_fill_mpeg(struct solo_enc_dev *solo_enc,
         struct sg_table *vbuf = vb2_dma_sg_plane_desc(vb, 0);
         int frame_off, frame_size;
         int skip = 0;
-        int ret;
 
         if (vb2_plane_size(vb, 0) < vop_mpeg_size(vh))
                 return -EIO;
@@ -521,21 +507,9 @@ static int solo_fill_mpeg(struct solo_enc_dev *solo_enc,
                 sizeof(*vh)) % SOLO_MP4E_EXT_SIZE(solo_dev);
         frame_size = ALIGN(vop_mpeg_size(vh) + skip, DMA_ALIGN);
 
-        /* may discard all previous data in vbuf->sgl */
-        if (!dma_map_sg(&solo_dev->pdev->dev, vbuf->sgl, vbuf->nents,
-                        DMA_FROM_DEVICE))
-                return -ENOMEM;
-        ret = solo_send_desc(solo_enc, skip, vbuf, frame_off, frame_size,
+        return solo_send_desc(solo_enc, skip, vbuf, frame_off, frame_size,
                         SOLO_MP4E_EXT_ADDR(solo_dev),
                         SOLO_MP4E_EXT_SIZE(solo_dev));
-        dma_unmap_sg(&solo_dev->pdev->dev, vbuf->sgl, vbuf->nents,
-                        DMA_FROM_DEVICE);
-
-        /* add the header only after dma_unmap_sg() */
-        if (!vop_type(vh))
-                sg_copy_from_buffer(vbuf->sgl, vbuf->nents,
-                                    solo_enc->vop, solo_enc->vop_len);
-        return ret;
 }
 
 static int solo_enc_fillbuf(struct solo_enc_dev *solo_enc,
@@ -703,9 +677,7 @@ static int solo_ring_thread(void *data)
 
                 if (timeout == -ERESTARTSYS || kthread_should_stop())
                         break;
-                solo_irq_off(solo_dev, SOLO_IRQ_ENCODER);
                 solo_handle_ring(solo_dev);
-                solo_irq_on(solo_dev, SOLO_IRQ_ENCODER);
                 try_to_freeze();
         }
 
@@ -720,7 +692,10 @@ static int solo_enc_queue_setup(struct vb2_queue *q,
                                 unsigned int *num_planes, unsigned int sizes[],
                                 void *alloc_ctxs[])
 {
+        struct solo_enc_dev *solo_enc = vb2_get_drv_priv(q);
+
         sizes[0] = FRAME_BUF_SIZE;
+        alloc_ctxs[0] = solo_enc->alloc_ctx;
         *num_planes = 1;
 
         if (*num_buffers < MIN_VID_BUFFERS)
@@ -770,26 +745,51 @@ static void solo_ring_stop(struct solo_dev *solo_dev)
 static int solo_enc_start_streaming(struct vb2_queue *q, unsigned int count)
 {
         struct solo_enc_dev *solo_enc = vb2_get_drv_priv(q);
-        int ret;
 
-        ret = solo_enc_on(solo_enc);
-        if (ret)
-                return ret;
-        return solo_ring_start(solo_enc->solo_dev);
+        return solo_enc_on(solo_enc);
 }
 
 static void solo_enc_stop_streaming(struct vb2_queue *q)
 {
         struct solo_enc_dev *solo_enc = vb2_get_drv_priv(q);
+        unsigned long flags;
 
+        spin_lock_irqsave(&solo_enc->av_lock, flags);
         solo_enc_off(solo_enc);
-        INIT_LIST_HEAD(&solo_enc->vidq_active);
-        solo_ring_stop(solo_enc->solo_dev);
+        while (!list_empty(&solo_enc->vidq_active)) {
+                struct solo_vb2_buf *buf = list_entry(
+                                solo_enc->vidq_active.next,
+                                struct solo_vb2_buf, list);
+
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+        }
+        spin_unlock_irqrestore(&solo_enc->av_lock, flags);
+}
+
+static void solo_enc_buf_finish(struct vb2_buffer *vb)
+{
+        struct solo_enc_dev *solo_enc = vb2_get_drv_priv(vb->vb2_queue);
+        struct sg_table *vbuf = vb2_dma_sg_plane_desc(vb, 0);
+
+        switch (solo_enc->fmt) {
+        case V4L2_PIX_FMT_MPEG4:
+        case V4L2_PIX_FMT_H264:
+                if (vb->v4l2_buf.flags & V4L2_BUF_FLAG_KEYFRAME)
+                        sg_copy_from_buffer(vbuf->sgl, vbuf->nents,
+                                        solo_enc->vop, solo_enc->vop_len);
+                break;
+        default: /* V4L2_PIX_FMT_MJPEG */
+                sg_copy_from_buffer(vbuf->sgl, vbuf->nents,
+                                solo_enc->jpeg_header, solo_enc->jpeg_len);
+                break;
+        }
 }
 
 static struct vb2_ops solo_enc_video_qops = {
         .queue_setup    = solo_enc_queue_setup,
         .buf_queue      = solo_enc_buf_queue,
+        .buf_finish     = solo_enc_buf_finish,
         .start_streaming = solo_enc_start_streaming,
         .stop_streaming = solo_enc_stop_streaming,
         .wait_prepare   = vb2_ops_wait_prepare,
@@ -1263,6 +1263,11 @@ static struct solo_enc_dev *solo_enc_alloc(struct solo_dev *solo_dev,
                 return ERR_PTR(-ENOMEM);
 
         hdl = &solo_enc->hdl;
+        solo_enc->alloc_ctx = vb2_dma_sg_init_ctx(&solo_dev->pdev->dev);
+        if (IS_ERR(solo_enc->alloc_ctx)) {
+                ret = PTR_ERR(solo_enc->alloc_ctx);
+                goto hdl_free;
+        }
         v4l2_ctrl_handler_init(hdl, 10);
         v4l2_ctrl_new_std(hdl, &solo_ctrl_ops,
                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
@@ -1366,6 +1371,7 @@ pci_free:
                         solo_enc->desc_items, solo_enc->desc_dma);
 hdl_free:
         v4l2_ctrl_handler_free(hdl);
+        vb2_dma_sg_cleanup_ctx(solo_enc->alloc_ctx);
         kfree(solo_enc);
         return ERR_PTR(ret);
 }
@@ -1375,8 +1381,12 @@ static void solo_enc_free(struct solo_enc_dev *solo_enc)
         if (solo_enc == NULL)
                 return;
 
+        pci_free_consistent(solo_enc->solo_dev->pdev,
+                        sizeof(struct solo_p2m_desc) * solo_enc->desc_nelts,
+                        solo_enc->desc_items, solo_enc->desc_dma);
         video_unregister_device(solo_enc->vfd);
         v4l2_ctrl_handler_free(&solo_enc->hdl);
+        vb2_dma_sg_cleanup_ctx(solo_enc->alloc_ctx);
         kfree(solo_enc);
 }
 
@@ -1419,13 +1429,15 @@ int solo_enc_v4l2_init(struct solo_dev *solo_dev, unsigned nr)
                  solo_dev->v4l2_enc[0]->vfd->num,
                  solo_dev->v4l2_enc[solo_dev->nr_chans - 1]->vfd->num);
 
-        return 0;
+        return solo_ring_start(solo_dev);
 }
 
 void solo_enc_v4l2_exit(struct solo_dev *solo_dev)
 {
         int i;
 
+        solo_ring_stop(solo_dev);
+
         for (i = 0; i < solo_dev->nr_chans; i++)
                 solo_enc_free(solo_dev->v4l2_enc[i]);
 
diff --git a/drivers/media/pci/solo6x10/solo6x10.h b/drivers/media/pci/solo6x10/solo6x10.h
index 72017b7f0a75..bd8edfa319b8 100644
--- a/drivers/media/pci/solo6x10/solo6x10.h
+++ b/drivers/media/pci/solo6x10/solo6x10.h
@@ -180,6 +180,7 @@ struct solo_enc_dev {
         u32                     sequence;
         struct vb2_queue        vidq;
         struct list_head        vidq_active;
+        void                    *alloc_ctx;
         int                     desc_count;
         int                     desc_nelts;
         struct solo_p2m_desc    *desc_items;
diff --git a/drivers/media/pci/tw68/tw68-core.c b/drivers/media/pci/tw68/tw68-core.c
index 63f0b64057cb..c135165a8b26 100644
--- a/drivers/media/pci/tw68/tw68-core.c
+++ b/drivers/media/pci/tw68/tw68-core.c
@@ -304,13 +304,19 @@ static int tw68_initdev(struct pci_dev *pci_dev,
         /* Then do any initialisation wanted before interrupts are on */
         tw68_hw_init1(dev);
 
+        dev->alloc_ctx = vb2_dma_sg_init_ctx(&pci_dev->dev);
+        if (IS_ERR(dev->alloc_ctx)) {
+                err = PTR_ERR(dev->alloc_ctx);
+                goto fail3;
+        }
+
         /* get irq */
         err = devm_request_irq(&pci_dev->dev, pci_dev->irq, tw68_irq,
                           IRQF_SHARED, dev->name, dev);
         if (err < 0) {
                 pr_err("%s: can't get IRQ %d\n",
                        dev->name, pci_dev->irq);
-                goto fail3;
+                goto fail4;
         }
 
         /*
@@ -324,7 +330,7 @@ static int tw68_initdev(struct pci_dev *pci_dev,
         if (err < 0) {
                 pr_err("%s: can't register video device\n",
                        dev->name);
-                goto fail4;
+                goto fail5;
         }
         tw_setl(TW68_INTMASK, dev->pci_irqmask);
 
@@ -333,8 +339,10 @@ static int tw68_initdev(struct pci_dev *pci_dev,
 
         return 0;
 
-fail4:
+fail5:
         video_unregister_device(&dev->vdev);
+fail4:
+        vb2_dma_sg_cleanup_ctx(dev->alloc_ctx);
 fail3:
         iounmap(dev->lmmio);
 fail2:
@@ -358,6 +366,7 @@ static void tw68_finidev(struct pci_dev *pci_dev)
         /* unregister */
         video_unregister_device(&dev->vdev);
         v4l2_ctrl_handler_free(&dev->hdl);
+        vb2_dma_sg_cleanup_ctx(dev->alloc_ctx);
 
         /* release resources */
         iounmap(dev->lmmio);
diff --git a/drivers/media/pci/tw68/tw68-video.c b/drivers/media/pci/tw68/tw68-video.c
index 5c94ac7c88d9..8355e55b4e8e 100644
--- a/drivers/media/pci/tw68/tw68-video.c
+++ b/drivers/media/pci/tw68/tw68-video.c
@@ -384,6 +384,7 @@ static int tw68_queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
         unsigned tot_bufs = q->num_buffers + *num_buffers;
 
         sizes[0] = (dev->fmt->depth * dev->width * dev->height) >> 3;
+        alloc_ctxs[0] = dev->alloc_ctx;
         /*
          * We allow create_bufs, but only if the sizeimage is the same as the
          * current sizeimage. The tw68_buffer_count calculation becomes quite
@@ -461,17 +462,12 @@ static int tw68_buf_prepare(struct vb2_buffer *vb)
         struct tw68_buf *buf = container_of(vb, struct tw68_buf, vb);
         struct sg_table *dma = vb2_dma_sg_plane_desc(vb, 0);
         unsigned size, bpl;
-        int rc;
 
         size = (dev->width * dev->height * dev->fmt->depth) >> 3;
         if (vb2_plane_size(vb, 0) < size)
                 return -EINVAL;
         vb2_set_plane_payload(vb, 0, size);
 
-        rc = dma_map_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
-        if (!rc)
-                return -EIO;
-
         bpl = (dev->width * dev->fmt->depth) >> 3;
         switch (dev->field) {
         case V4L2_FIELD_TOP:
@@ -505,11 +501,8 @@ static void tw68_buf_finish(struct vb2_buffer *vb)
 {
         struct vb2_queue *vq = vb->vb2_queue;
         struct tw68_dev *dev = vb2_get_drv_priv(vq);
-        struct sg_table *dma = vb2_dma_sg_plane_desc(vb, 0);
         struct tw68_buf *buf = container_of(vb, struct tw68_buf, vb);
 
-        dma_unmap_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE);
-
         pci_free_consistent(dev->pci, buf->size, buf->cpu, buf->dma);
 }
 
diff --git a/drivers/media/pci/tw68/tw68.h b/drivers/media/pci/tw68/tw68.h
index 2c8abe26b13b..7a7501bd165f 100644
--- a/drivers/media/pci/tw68/tw68.h
+++ b/drivers/media/pci/tw68/tw68.h
@@ -181,6 +181,7 @@ struct tw68_dev {
         unsigned                field;
         struct vb2_queue        vidq;
         struct list_head        active;
+        void                    *alloc_ctx;
 
         /* various v4l controls */
         const struct tw68_tvnorm *tvnorm;       /* video */
diff --git a/drivers/media/pci/zoran/zoran_driver.c b/drivers/media/pci/zoran/zoran_driver.c
index 099d5fbebb7c..2b25d31c46f6 100644
--- a/drivers/media/pci/zoran/zoran_driver.c
+++ b/drivers/media/pci/zoran/zoran_driver.c
@@ -1528,8 +1528,9 @@ static int zoran_querycap(struct file *file, void *__fh, struct v4l2_capability
         strncpy(cap->driver, "zoran", sizeof(cap->driver)-1);
         snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",
                  pci_name(zr->pci_dev));
-        cap->capabilities = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE |
-                            V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OVERLAY;
+        cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE |
+                           V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OVERLAY;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/pci/zoran/zoran_procfs.c b/drivers/media/pci/zoran/zoran_procfs.c
index f7ceee0cdefd..437652761093 100644
--- a/drivers/media/pci/zoran/zoran_procfs.c
+++ b/drivers/media/pci/zoran/zoran_procfs.c
@@ -157,8 +157,8 @@ static ssize_t zoran_write(struct file *file, const char __user *buffer,
                 return -EFAULT;
         }
         string[count] = 0;
-        dprintk(4, KERN_INFO "%s: write_proc: name=%s count=%zu zr=%p\n",
-                ZR_DEVNAME(zr), file->f_path.dentry->d_name.name, count, zr);
+        dprintk(4, KERN_INFO "%s: write_proc: name=%pD count=%zu zr=%p\n",
+                ZR_DEVNAME(zr), file, count, zr);
         ldelim = " \t\n";
         tdelim = "=";
         line = strpbrk(sp, ldelim);
diff --git a/drivers/media/platform/Kconfig b/drivers/media/platform/Kconfig
index 3aac88f1d54a..0c61155699f7 100644
--- a/drivers/media/platform/Kconfig
+++ b/drivers/media/platform/Kconfig
@@ -267,8 +267,8 @@ if V4L_TEST_DRIVERS
 
 source "drivers/media/platform/vivid/Kconfig"
 
-config VIDEO_MEM2MEM_TESTDEV
-        tristate "Virtual test device for mem2mem framework"
+config VIDEO_VIM2M
+        tristate "Virtual Memory-to-Memory Driver"
         depends on VIDEO_DEV && VIDEO_V4L2
         select VIDEOBUF2_VMALLOC
         select V4L2_MEM2MEM_DEV
diff --git a/drivers/media/platform/Makefile b/drivers/media/platform/Makefile
index 579046bc276f..b818afb4d336 100644
--- a/drivers/media/platform/Makefile
+++ b/drivers/media/platform/Makefile
@@ -17,7 +17,7 @@ obj-$(CONFIG_VIDEO_OMAP3)	+= omap3isp/
 obj-$(CONFIG_VIDEO_VIU) += fsl-viu.o
 
 obj-$(CONFIG_VIDEO_VIVID)               += vivid/
-obj-$(CONFIG_VIDEO_MEM2MEM_TESTDEV) += mem2mem_testdev.o
+obj-$(CONFIG_VIDEO_VIM2M)               += vim2m.o
 
 obj-$(CONFIG_VIDEO_TI_VPE)              += ti-vpe/
 
diff --git a/drivers/media/platform/blackfin/bfin_capture.c b/drivers/media/platform/blackfin/bfin_capture.c
index 9b5daa65841c..3112844e4fc1 100644
--- a/drivers/media/platform/blackfin/bfin_capture.c
+++ b/drivers/media/platform/blackfin/bfin_capture.c
@@ -49,7 +49,7 @@
 struct bcap_format {
         char *desc;
         u32 pixelformat;
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
         int bpp; /* bits per pixel */
         int dlen; /* data length for ppi in bits */
 };
@@ -116,35 +116,35 @@ static const struct bcap_format bcap_formats[] = {
         {
                 .desc        = "YCbCr 4:2:2 Interleaved UYVY",
                 .pixelformat = V4L2_PIX_FMT_UYVY,
-                .mbus_code   = V4L2_MBUS_FMT_UYVY8_2X8,
+                .mbus_code   = MEDIA_BUS_FMT_UYVY8_2X8,
                 .bpp         = 16,
                 .dlen        = 8,
         },
         {
                 .desc        = "YCbCr 4:2:2 Interleaved YUYV",
                 .pixelformat = V4L2_PIX_FMT_YUYV,
-                .mbus_code   = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code   = MEDIA_BUS_FMT_YUYV8_2X8,
                 .bpp         = 16,
                 .dlen        = 8,
         },
         {
                 .desc        = "YCbCr 4:2:2 Interleaved UYVY",
                 .pixelformat = V4L2_PIX_FMT_UYVY,
-                .mbus_code   = V4L2_MBUS_FMT_UYVY8_1X16,
+                .mbus_code   = MEDIA_BUS_FMT_UYVY8_1X16,
                 .bpp         = 16,
                 .dlen        = 16,
         },
         {
                 .desc        = "RGB 565",
                 .pixelformat = V4L2_PIX_FMT_RGB565,
-                .mbus_code   = V4L2_MBUS_FMT_RGB565_2X8_LE,
+                .mbus_code   = MEDIA_BUS_FMT_RGB565_2X8_LE,
                 .bpp         = 16,
                 .dlen        = 8,
         },
         {
                 .desc        = "RGB 444",
                 .pixelformat = V4L2_PIX_FMT_RGB444,
-                .mbus_code   = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
+                .mbus_code   = MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE,
                 .bpp         = 16,
                 .dlen        = 8,
         },
@@ -161,7 +161,7 @@ static struct bcap_buffer *to_bcap_vb(struct vb2_buffer *vb)
 
 static int bcap_init_sensor_formats(struct bcap_device *bcap_dev)
 {
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         struct bcap_format *sf;
         unsigned int num_formats = 0;
         int i, j;
@@ -349,18 +349,6 @@ static void bcap_buffer_cleanup(struct vb2_buffer *vb)
         spin_unlock_irqrestore(&bcap_dev->lock, flags);
 }
 
-static void bcap_lock(struct vb2_queue *vq)
-{
-        struct bcap_device *bcap_dev = vb2_get_drv_priv(vq);
-        mutex_lock(&bcap_dev->mutex);
-}
-
-static void bcap_unlock(struct vb2_queue *vq)
-{
-        struct bcap_device *bcap_dev = vb2_get_drv_priv(vq);
-        mutex_unlock(&bcap_dev->mutex);
-}
-
 static int bcap_start_streaming(struct vb2_queue *vq, unsigned int count)
 {
         struct bcap_device *bcap_dev = vb2_get_drv_priv(vq);
@@ -457,8 +445,8 @@ static struct vb2_ops bcap_video_qops = {
         .buf_prepare            = bcap_buffer_prepare,
         .buf_cleanup            = bcap_buffer_cleanup,
         .buf_queue              = bcap_buffer_queue,
-        .wait_prepare           = bcap_unlock,
-        .wait_finish            = bcap_lock,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
         .start_streaming        = bcap_start_streaming,
         .stop_streaming         = bcap_stop_streaming,
 };
@@ -841,7 +829,8 @@ static int bcap_querycap(struct file *file, void  *priv,
 {
         struct bcap_device *bcap_dev = video_drvdata(file);
 
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         strlcpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver));
         strlcpy(cap->bus_info, "Blackfin Platform", sizeof(cap->bus_info));
         strlcpy(cap->card, bcap_dev->cfg->card_name, sizeof(cap->card));
@@ -995,6 +984,7 @@ static int bcap_probe(struct platform_device *pdev)
         q->ops = &bcap_video_qops;
         q->mem_ops = &vb2_dma_contig_memops;
         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+        q->lock = &bcap_dev->mutex;
 
         ret = vb2_queue_init(q);
         if (ret)
diff --git a/drivers/media/platform/coda/Makefile b/drivers/media/platform/coda/Makefile
index 3543291e6273..25ce15561695 100644
--- a/drivers/media/platform/coda/Makefile
+++ b/drivers/media/platform/coda/Makefile
@@ -1,3 +1,3 @@
-coda-objs := coda-common.o coda-bit.o coda-h264.o
+coda-objs := coda-common.o coda-bit.o coda-h264.o coda-jpeg.o
 
 obj-$(CONFIG_VIDEO_CODA) += coda.o
diff --git a/drivers/media/platform/coda/coda-bit.c b/drivers/media/platform/coda/coda-bit.c
index 9b8ea8bbeb4e..b4029ae293d3 100644
--- a/drivers/media/platform/coda/coda-bit.c
+++ b/drivers/media/platform/coda/coda-bit.c
@@ -217,11 +217,34 @@ static bool coda_bitstream_try_queue(struct coda_ctx *ctx,
 void coda_fill_bitstream(struct coda_ctx *ctx)
 {
         struct vb2_buffer *src_buf;
-        struct coda_timestamp *ts;
+        struct coda_buffer_meta *meta;
+        u32 start;
 
         while (v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx) > 0) {
+                /*
+                 * Only queue a single JPEG into the bitstream buffer, except
+                 * to increase payload over 512 bytes or if in hold state.
+                 */
+                if (ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG &&
+                    (coda_get_bitstream_payload(ctx) >= 512) && !ctx->hold)
+                        break;
+
                 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 
+                /* Drop frames that do not start/end with a SOI/EOI markers */
+                if (ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG &&
+                    !coda_jpeg_check_buffer(ctx, src_buf)) {
+                        v4l2_err(&ctx->dev->v4l2_dev,
+                                 "dropping invalid JPEG frame\n");
+                        src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
+                        v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);
+                        continue;
+                }
+
+                /* Buffer start position */
+                start = ctx->bitstream_fifo.kfifo.in &
+                        ctx->bitstream_fifo.kfifo.mask;
+
                 if (coda_bitstream_try_queue(ctx, src_buf)) {
                         /*
                          * Source buffer is queued in the bitstream ringbuffer;
@@ -229,12 +252,16 @@ void coda_fill_bitstream(struct coda_ctx *ctx)
                          */
                         src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
 
-                        ts = kmalloc(sizeof(*ts), GFP_KERNEL);
-                        if (ts) {
-                                ts->sequence = src_buf->v4l2_buf.sequence;
-                                ts->timecode = src_buf->v4l2_buf.timecode;
-                                ts->timestamp = src_buf->v4l2_buf.timestamp;
-                                list_add_tail(&ts->list, &ctx->timestamp_list);
+                        meta = kmalloc(sizeof(*meta), GFP_KERNEL);
+                        if (meta) {
+                                meta->sequence = src_buf->v4l2_buf.sequence;
+                                meta->timecode = src_buf->v4l2_buf.timecode;
+                                meta->timestamp = src_buf->v4l2_buf.timestamp;
+                                meta->start = start;
+                                meta->end = ctx->bitstream_fifo.kfifo.in &
+                                            ctx->bitstream_fifo.kfifo.mask;
+                                list_add_tail(&meta->list,
+                                              &ctx->buffer_meta_list);
                         }
 
                         v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
@@ -691,6 +718,7 @@ static int coda_start_encoding(struct coda_ctx *ctx)
         struct vb2_buffer *buf;
         int gamma, ret, value;
         u32 dst_fourcc;
+        u32 stride;
 
         q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
         q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
@@ -710,6 +738,14 @@ static int coda_start_encoding(struct coda_ctx *ctx)
                 return -EFAULT;
         }
 
+        if (dst_fourcc == V4L2_PIX_FMT_JPEG) {
+                if (!ctx->params.jpeg_qmat_tab[0])
+                        ctx->params.jpeg_qmat_tab[0] = kmalloc(64, GFP_KERNEL);
+                if (!ctx->params.jpeg_qmat_tab[1])
+                        ctx->params.jpeg_qmat_tab[1] = kmalloc(64, GFP_KERNEL);
+                coda_set_jpeg_compression_quality(ctx, ctx->params.jpeg_quality);
+        }
+
         mutex_lock(&dev->coda_mutex);
 
         coda_write(dev, ctx->parabuf.paddr, CODA_REG_BIT_PARA_BUF_ADDR);
@@ -729,10 +765,10 @@ static int coda_start_encoding(struct coda_ctx *ctx)
                 break;
         }
 
-        value = coda_read(dev, CODA_REG_BIT_FRAME_MEM_CTRL);
-        value &= ~(1 << 2 | 0x7 << 9);
-        ctx->frame_mem_ctrl = value;
-        coda_write(dev, value, CODA_REG_BIT_FRAME_MEM_CTRL);
+        ctx->frame_mem_ctrl &= ~CODA_FRAME_CHROMA_INTERLEAVE;
+        if (q_data_src->fourcc == V4L2_PIX_FMT_NV12)
+                ctx->frame_mem_ctrl |= CODA_FRAME_CHROMA_INTERLEAVE;
+        coda_write(dev, ctx->frame_mem_ctrl, CODA_REG_BIT_FRAME_MEM_CTRL);
 
         if (dev->devtype->product == CODA_DX6) {
                 /* Configure the coda */
@@ -741,6 +777,7 @@ static int coda_start_encoding(struct coda_ctx *ctx)
         }
 
         /* Could set rotation here if needed */
+        value = 0;
         switch (dev->devtype->product) {
         case CODA_DX6:
                 value = (q_data_src->width & CODADX6_PICWIDTH_MASK)
@@ -764,6 +801,8 @@ static int coda_start_encoding(struct coda_ctx *ctx)
                          << CODA_PICHEIGHT_OFFSET;
         }
         coda_write(dev, value, CODA_CMD_ENC_SEQ_SRC_SIZE);
+        if (dst_fourcc == V4L2_PIX_FMT_JPEG)
+                ctx->params.framerate = 0;
         coda_write(dev, ctx->params.framerate,
                    CODA_CMD_ENC_SEQ_SRC_F_RATE);
 
@@ -797,6 +836,16 @@ static int coda_start_encoding(struct coda_ctx *ctx)
                 }
                 coda_write(dev, value, CODA_CMD_ENC_SEQ_264_PARA);
                 break;
+        case V4L2_PIX_FMT_JPEG:
+                coda_write(dev, 0, CODA_CMD_ENC_SEQ_JPG_PARA);
+                coda_write(dev, ctx->params.jpeg_restart_interval,
+                                CODA_CMD_ENC_SEQ_JPG_RST_INTERVAL);
+                coda_write(dev, 0, CODA_CMD_ENC_SEQ_JPG_THUMB_EN);
+                coda_write(dev, 0, CODA_CMD_ENC_SEQ_JPG_THUMB_SIZE);
+                coda_write(dev, 0, CODA_CMD_ENC_SEQ_JPG_THUMB_OFFSET);
+
+                coda_jpeg_write_tables(ctx);
+                break;
         default:
                 v4l2_err(v4l2_dev,
                          "dst format (0x%08x) invalid.\n", dst_fourcc);
@@ -804,28 +853,36 @@ static int coda_start_encoding(struct coda_ctx *ctx)
                 goto out;
         }
 
-        switch (ctx->params.slice_mode) {
-        case V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE:
-                value = 0;
-                break;
-        case V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB:
-                value  = (ctx->params.slice_max_mb & CODA_SLICING_SIZE_MASK)
-                         << CODA_SLICING_SIZE_OFFSET;
-                value |= (1 & CODA_SLICING_UNIT_MASK)
-                         << CODA_SLICING_UNIT_OFFSET;
-                value |=  1 & CODA_SLICING_MODE_MASK;
-                break;
-        case V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES:
-                value  = (ctx->params.slice_max_bits & CODA_SLICING_SIZE_MASK)
-                         << CODA_SLICING_SIZE_OFFSET;
-                value |= (0 & CODA_SLICING_UNIT_MASK)
-                         << CODA_SLICING_UNIT_OFFSET;
-                value |=  1 & CODA_SLICING_MODE_MASK;
-                break;
+        /*
+         * slice mode and GOP size registers are used for thumb size/offset
+         * in JPEG mode
+         */
+        if (dst_fourcc != V4L2_PIX_FMT_JPEG) {
+                switch (ctx->params.slice_mode) {
+                case V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE:
+                        value = 0;
+                        break;
+                case V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB:
+                        value  = (ctx->params.slice_max_mb &
+                                  CODA_SLICING_SIZE_MASK)
+                                 << CODA_SLICING_SIZE_OFFSET;
+                        value |= (1 & CODA_SLICING_UNIT_MASK)
+                                 << CODA_SLICING_UNIT_OFFSET;
+                        value |=  1 & CODA_SLICING_MODE_MASK;
+                        break;
+                case V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES:
+                        value  = (ctx->params.slice_max_bits &
+                                  CODA_SLICING_SIZE_MASK)
+                                 << CODA_SLICING_SIZE_OFFSET;
+                        value |= (0 & CODA_SLICING_UNIT_MASK)
+                                 << CODA_SLICING_UNIT_OFFSET;
+                        value |=  1 & CODA_SLICING_MODE_MASK;
+                        break;
+                }
+                coda_write(dev, value, CODA_CMD_ENC_SEQ_SLICE_MODE);
+                value = ctx->params.gop_size & CODA_GOP_SIZE_MASK;
+                coda_write(dev, value, CODA_CMD_ENC_SEQ_GOP_SIZE);
         }
-        coda_write(dev, value, CODA_CMD_ENC_SEQ_SLICE_MODE);
-        value = ctx->params.gop_size & CODA_GOP_SIZE_MASK;
-        coda_write(dev, value, CODA_CMD_ENC_SEQ_GOP_SIZE);
 
         if (ctx->params.bitrate) {
                 /* Rate control enabled */
@@ -916,19 +973,24 @@ static int coda_start_encoding(struct coda_ctx *ctx)
                 goto out;
         }
 
-        if (dev->devtype->product == CODA_960)
-                ctx->num_internal_frames = 4;
-        else
-                ctx->num_internal_frames = 2;
-        ret = coda_alloc_framebuffers(ctx, q_data_src, dst_fourcc);
-        if (ret < 0) {
-                v4l2_err(v4l2_dev, "failed to allocate framebuffers\n");
-                goto out;
+        if (dst_fourcc != V4L2_PIX_FMT_JPEG) {
+                if (dev->devtype->product == CODA_960)
+                        ctx->num_internal_frames = 4;
+                else
+                        ctx->num_internal_frames = 2;
+                ret = coda_alloc_framebuffers(ctx, q_data_src, dst_fourcc);
+                if (ret < 0) {
+                        v4l2_err(v4l2_dev, "failed to allocate framebuffers\n");
+                        goto out;
+                }
+                stride = q_data_src->bytesperline;
+        } else {
+                ctx->num_internal_frames = 0;
+                stride = 0;
         }
-
         coda_write(dev, ctx->num_internal_frames, CODA_CMD_SET_FRAME_BUF_NUM);
-        coda_write(dev, q_data_src->bytesperline,
-                        CODA_CMD_SET_FRAME_BUF_STRIDE);
+        coda_write(dev, stride, CODA_CMD_SET_FRAME_BUF_STRIDE);
+
         if (dev->devtype->product == CODA_7541) {
                 coda_write(dev, q_data_src->bytesperline,
                                 CODA7_CMD_SET_FRAME_SOURCE_BUF_STRIDE);
@@ -1036,9 +1098,10 @@ static int coda_prepare_encode(struct coda_ctx *ctx)
         struct coda_dev *dev = ctx->dev;
         int force_ipicture;
         int quant_param = 0;
-        u32 picture_y, picture_cb, picture_cr;
         u32 pic_stream_buffer_addr, pic_stream_buffer_size;
+        u32 rot_mode = 0;
         u32 dst_fourcc;
+        u32 reg;
 
         src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
         dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
@@ -1076,7 +1139,7 @@ static int coda_prepare_encode(struct coda_ctx *ctx)
                         ctx->vpu_header_size[0] +
                         ctx->vpu_header_size[1] +
                         ctx->vpu_header_size[2];
-                pic_stream_buffer_size = CODA_MAX_FRAME_SIZE -
+                pic_stream_buffer_size = q_data_dst->sizeimage -
                         ctx->vpu_header_size[0] -
                         ctx->vpu_header_size[1] -
                         ctx->vpu_header_size[2];
@@ -1090,7 +1153,7 @@ static int coda_prepare_encode(struct coda_ctx *ctx)
         } else {
                 pic_stream_buffer_addr =
                         vb2_dma_contig_plane_dma_addr(dst_buf, 0);
-                pic_stream_buffer_size = CODA_MAX_FRAME_SIZE;
+                pic_stream_buffer_size = q_data_dst->sizeimage;
         }
 
         if (src_buf->v4l2_buf.flags & V4L2_BUF_FLAG_KEYFRAME) {
@@ -1102,6 +1165,9 @@ static int coda_prepare_encode(struct coda_ctx *ctx)
                 case V4L2_PIX_FMT_MPEG4:
                         quant_param = ctx->params.mpeg4_intra_qp;
                         break;
+                case V4L2_PIX_FMT_JPEG:
+                        quant_param = 30;
+                        break;
                 default:
                         v4l2_warn(&ctx->dev->v4l2_dev,
                                 "cannot set intra qp, fmt not supported\n");
@@ -1124,42 +1190,22 @@ static int coda_prepare_encode(struct coda_ctx *ctx)
         }
 
         /* submit */
-        coda_write(dev, CODA_ROT_MIR_ENABLE | ctx->params.rot_mode,
-                   CODA_CMD_ENC_PIC_ROT_MODE);
+        if (ctx->params.rot_mode)
+                rot_mode = CODA_ROT_MIR_ENABLE | ctx->params.rot_mode;
+        coda_write(dev, rot_mode, CODA_CMD_ENC_PIC_ROT_MODE);
         coda_write(dev, quant_param, CODA_CMD_ENC_PIC_QS);
 
-
-        picture_y = vb2_dma_contig_plane_dma_addr(src_buf, 0);
-        switch (q_data_src->fourcc) {
-        case V4L2_PIX_FMT_YVU420:
-                /* Switch Cb and Cr for YVU420 format */
-                picture_cr = picture_y + q_data_src->bytesperline *
-                                q_data_src->height;
-                picture_cb = picture_cr + q_data_src->bytesperline / 2 *
-                                q_data_src->height / 2;
-                break;
-        case V4L2_PIX_FMT_YUV420:
-        default:
-                picture_cb = picture_y + q_data_src->bytesperline *
-                                q_data_src->height;
-                picture_cr = picture_cb + q_data_src->bytesperline / 2 *
-                                q_data_src->height / 2;
-                break;
-        }
-
         if (dev->devtype->product == CODA_960) {
                 coda_write(dev, 4/*FIXME: 0*/, CODA9_CMD_ENC_PIC_SRC_INDEX);
                 coda_write(dev, q_data_src->width, CODA9_CMD_ENC_PIC_SRC_STRIDE);
                 coda_write(dev, 0, CODA9_CMD_ENC_PIC_SUB_FRAME_SYNC);
 
-                coda_write(dev, picture_y, CODA9_CMD_ENC_PIC_SRC_ADDR_Y);
-                coda_write(dev, picture_cb, CODA9_CMD_ENC_PIC_SRC_ADDR_CB);
-                coda_write(dev, picture_cr, CODA9_CMD_ENC_PIC_SRC_ADDR_CR);
+                reg = CODA9_CMD_ENC_PIC_SRC_ADDR_Y;
         } else {
-                coda_write(dev, picture_y, CODA_CMD_ENC_PIC_SRC_ADDR_Y);
-                coda_write(dev, picture_cb, CODA_CMD_ENC_PIC_SRC_ADDR_CB);
-                coda_write(dev, picture_cr, CODA_CMD_ENC_PIC_SRC_ADDR_CR);
+                reg = CODA_CMD_ENC_PIC_SRC_ADDR_Y;
         }
+        coda_write_base(ctx, q_data_src, src_buf, reg);
+
         coda_write(dev, force_ipicture << 1 & 0x2,
                    CODA_CMD_ENC_PIC_OPTION);
 
@@ -1293,7 +1339,7 @@ static int __coda_start_decoding(struct coda_ctx *ctx)
         u32 bitstream_buf, bitstream_size;
         struct coda_dev *dev = ctx->dev;
         int width, height;
-        u32 src_fourcc;
+        u32 src_fourcc, dst_fourcc;
         u32 val;
         int ret;
 
@@ -1303,6 +1349,7 @@ static int __coda_start_decoding(struct coda_ctx *ctx)
         bitstream_buf = ctx->bitstream.paddr;
         bitstream_size = ctx->bitstream.size;
         src_fourcc = q_data_src->fourcc;
+        dst_fourcc = q_data_dst->fourcc;
 
         /* Allocate per-instance buffers */
         ret = coda_alloc_context_buffers(ctx, q_data_src);
@@ -1314,6 +1361,11 @@ static int __coda_start_decoding(struct coda_ctx *ctx)
         /* Update coda bitstream read and write pointers from kfifo */
         coda_kfifo_sync_to_device_full(ctx);
 
+        ctx->frame_mem_ctrl &= ~CODA_FRAME_CHROMA_INTERLEAVE;
+        if (dst_fourcc == V4L2_PIX_FMT_NV12)
+                ctx->frame_mem_ctrl |= CODA_FRAME_CHROMA_INTERLEAVE;
+        coda_write(dev, ctx->frame_mem_ctrl, CODA_REG_BIT_FRAME_MEM_CTRL);
+
         ctx->display_idx = -1;
         ctx->frm_dis_flg = 0;
         coda_write(dev, 0, CODA_REG_BIT_FRM_DIS_FLG(ctx->reg_idx));
@@ -1327,6 +1379,8 @@ static int __coda_start_decoding(struct coda_ctx *ctx)
         if ((dev->devtype->product == CODA_7541) ||
             (dev->devtype->product == CODA_960))
                 val |= CODA_REORDER_ENABLE;
+        if (ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG)
+                val |= CODA_NO_INT_ENABLE;
         coda_write(dev, val, CODA_CMD_DEC_SEQ_OPTION);
 
         ctx->params.codec_mode = ctx->codec->mode;
@@ -1442,13 +1496,23 @@ static int __coda_start_decoding(struct coda_ctx *ctx)
         }
 
         if (dev->devtype->product == CODA_960) {
-                coda_write(dev, -1, CODA9_CMD_SET_FRAME_DELAY);
+                int cbb_size, crb_size;
 
+                coda_write(dev, -1, CODA9_CMD_SET_FRAME_DELAY);
+                /* Luma 2x0 page, 2x6 cache, chroma 2x0 page, 2x4 cache size */
                 coda_write(dev, 0x20262024, CODA9_CMD_SET_FRAME_CACHE_SIZE);
+
+                if (dst_fourcc == V4L2_PIX_FMT_NV12) {
+                        cbb_size = 0;
+                        crb_size = 16;
+                } else {
+                        cbb_size = 8;
+                        crb_size = 8;
+                }
                 coda_write(dev, 2 << CODA9_CACHE_PAGEMERGE_OFFSET |
                                 32 << CODA9_CACHE_LUMA_BUFFER_SIZE_OFFSET |
-                                8 << CODA9_CACHE_CB_BUFFER_SIZE_OFFSET |
-                                8 << CODA9_CACHE_CR_BUFFER_SIZE_OFFSET,
+                                cbb_size << CODA9_CACHE_CB_BUFFER_SIZE_OFFSET |
+                                crb_size << CODA9_CACHE_CR_BUFFER_SIZE_OFFSET,
                                 CODA9_CMD_SET_FRAME_CACHE_CONFIG);
         }
 
@@ -1501,20 +1565,11 @@ static int coda_prepare_decode(struct coda_ctx *ctx)
         struct vb2_buffer *dst_buf;
         struct coda_dev *dev = ctx->dev;
         struct coda_q_data *q_data_dst;
-        u32 stridey, height;
-        u32 picture_y, picture_cb, picture_cr;
+        u32 reg_addr, reg_stride;
 
         dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
         q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
 
-        if (ctx->params.rot_mode & CODA_ROT_90) {
-                stridey = q_data_dst->height;
-                height = q_data_dst->width;
-        } else {
-                stridey = q_data_dst->width;
-                height = q_data_dst->height;
-        }
-
         /* Try to copy source buffer contents into the bitstream ringbuffer */
         mutex_lock(&ctx->bitstream_mutex);
         coda_fill_bitstream(ctx);
@@ -1545,17 +1600,6 @@ static int coda_prepare_decode(struct coda_ctx *ctx)
         if (dev->devtype->product == CODA_960)
                 coda_set_gdi_regs(ctx);
 
-        /* Set rotator output */
-        picture_y = vb2_dma_contig_plane_dma_addr(dst_buf, 0);
-        if (q_data_dst->fourcc == V4L2_PIX_FMT_YVU420) {
-                /* Switch Cr and Cb for YVU420 format */
-                picture_cr = picture_y + stridey * height;
-                picture_cb = picture_cr + stridey / 2 * height / 2;
-        } else {
-                picture_cb = picture_y + stridey * height;
-                picture_cr = picture_cb + stridey / 2 * height / 2;
-        }
-
         if (dev->devtype->product == CODA_960) {
                 /*
                  * The CODA960 seems to have an internal list of buffers with
@@ -1565,16 +1609,16 @@ static int coda_prepare_decode(struct coda_ctx *ctx)
                  */
                 coda_write(dev, CODA_MAX_FRAMEBUFFERS + dst_buf->v4l2_buf.index,
                                 CODA9_CMD_DEC_PIC_ROT_INDEX);
-                coda_write(dev, picture_y, CODA9_CMD_DEC_PIC_ROT_ADDR_Y);
-                coda_write(dev, picture_cb, CODA9_CMD_DEC_PIC_ROT_ADDR_CB);
-                coda_write(dev, picture_cr, CODA9_CMD_DEC_PIC_ROT_ADDR_CR);
-                coda_write(dev, stridey, CODA9_CMD_DEC_PIC_ROT_STRIDE);
+
+                reg_addr = CODA9_CMD_DEC_PIC_ROT_ADDR_Y;
+                reg_stride = CODA9_CMD_DEC_PIC_ROT_STRIDE;
         } else {
-                coda_write(dev, picture_y, CODA_CMD_DEC_PIC_ROT_ADDR_Y);
-                coda_write(dev, picture_cb, CODA_CMD_DEC_PIC_ROT_ADDR_CB);
-                coda_write(dev, picture_cr, CODA_CMD_DEC_PIC_ROT_ADDR_CR);
-                coda_write(dev, stridey, CODA_CMD_DEC_PIC_ROT_STRIDE);
+                reg_addr = CODA_CMD_DEC_PIC_ROT_ADDR_Y;
+                reg_stride = CODA_CMD_DEC_PIC_ROT_STRIDE;
         }
+        coda_write_base(ctx, q_data_dst, dst_buf, reg_addr);
+        coda_write(dev, q_data_dst->bytesperline, reg_stride);
+
         coda_write(dev, CODA_ROT_MIR_ENABLE | ctx->params.rot_mode,
                         CODA_CMD_DEC_PIC_ROT_MODE);
 
@@ -1599,6 +1643,26 @@ static int coda_prepare_decode(struct coda_ctx *ctx)
                 coda_write(dev, ctx->iram_info.axi_sram_use,
                                 CODA7_REG_BIT_AXI_SRAM_USE);
 
+        if (ctx->codec->src_fourcc == V4L2_PIX_FMT_JPEG) {
+                struct coda_buffer_meta *meta;
+
+                /* If this is the last buffer in the bitstream, add padding */
+                meta = list_first_entry(&ctx->buffer_meta_list,
+                                      struct coda_buffer_meta, list);
+                if (meta->end == (ctx->bitstream_fifo.kfifo.in &
+                                  ctx->bitstream_fifo.kfifo.mask)) {
+                        static unsigned char buf[512];
+                        unsigned int pad;
+
+                        /* Pad to multiple of 256 and then add 256 more */
+                        pad = ((0 - meta->end) & 0xff) + 256;
+
+                        memset(buf, 0xff, sizeof(buf));
+
+                        kfifo_in(&ctx->bitstream_fifo, buf, pad);
+                }
+        }
+
         coda_kfifo_sync_to_device_full(ctx);
 
         coda_command_async(ctx, CODA_COMMAND_PIC_RUN);
@@ -1612,7 +1676,8 @@ static void coda_finish_decode(struct coda_ctx *ctx)
         struct coda_q_data *q_data_src;
         struct coda_q_data *q_data_dst;
         struct vb2_buffer *dst_buf;
-        struct coda_timestamp *ts;
+        struct coda_buffer_meta *meta;
+        unsigned long payload;
         int width, height;
         int decoded_idx;
         int display_idx;
@@ -1739,23 +1804,23 @@ static void coda_finish_decode(struct coda_ctx *ctx)
                 val = coda_read(dev, CODA_RET_DEC_PIC_FRAME_NUM) - 1;
                 val -= ctx->sequence_offset;
                 mutex_lock(&ctx->bitstream_mutex);
-                if (!list_empty(&ctx->timestamp_list)) {
-                        ts = list_first_entry(&ctx->timestamp_list,
-                                              struct coda_timestamp, list);
-                        list_del(&ts->list);
-                        if (val != (ts->sequence & 0xffff)) {
+                if (!list_empty(&ctx->buffer_meta_list)) {
+                        meta = list_first_entry(&ctx->buffer_meta_list,
+                                              struct coda_buffer_meta, list);
+                        list_del(&meta->list);
+                        if (val != (meta->sequence & 0xffff)) {
                                 v4l2_err(&dev->v4l2_dev,
                                          "sequence number mismatch (%d(%d) != %d)\n",
                                          val, ctx->sequence_offset,
-                                         ts->sequence);
+                                         meta->sequence);
                         }
-                        ctx->frame_timestamps[decoded_idx] = *ts;
-                        kfree(ts);
+                        ctx->frame_metas[decoded_idx] = *meta;
+                        kfree(meta);
                 } else {
                         v4l2_err(&dev->v4l2_dev, "empty timestamp list!\n");
-                        memset(&ctx->frame_timestamps[decoded_idx], 0,
-                               sizeof(struct coda_timestamp));
-                        ctx->frame_timestamps[decoded_idx].sequence = val;
+                        memset(&ctx->frame_metas[decoded_idx], 0,
+                               sizeof(struct coda_buffer_meta));
+                        ctx->frame_metas[decoded_idx].sequence = val;
                 }
                 mutex_unlock(&ctx->bitstream_mutex);
 
@@ -1794,11 +1859,22 @@ static void coda_finish_decode(struct coda_ctx *ctx)
                                              V4L2_BUF_FLAG_PFRAME |
                                              V4L2_BUF_FLAG_BFRAME);
                 dst_buf->v4l2_buf.flags |= ctx->frame_types[ctx->display_idx];
-                ts = &ctx->frame_timestamps[ctx->display_idx];
-                dst_buf->v4l2_buf.timecode = ts->timecode;
-                dst_buf->v4l2_buf.timestamp = ts->timestamp;
-
-                vb2_set_plane_payload(dst_buf, 0, width * height * 3 / 2);
+                meta = &ctx->frame_metas[ctx->display_idx];
+                dst_buf->v4l2_buf.timecode = meta->timecode;
+                dst_buf->v4l2_buf.timestamp = meta->timestamp;
+
+                switch (q_data_dst->fourcc) {
+                case V4L2_PIX_FMT_YUV420:
+                case V4L2_PIX_FMT_YVU420:
+                case V4L2_PIX_FMT_NV12:
+                default:
+                        payload = width * height * 3 / 2;
+                        break;
+                case V4L2_PIX_FMT_YUV422P:
+                        payload = width * height * 2;
+                        break;
+                }
+                vb2_set_plane_payload(dst_buf, 0, payload);
 
                 v4l2_m2m_buf_done(dst_buf, ctx->frame_errors[display_idx] ?
                                   VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
diff --git a/drivers/media/platform/coda/coda-common.c b/drivers/media/platform/coda/coda-common.c
index ced47609f5ef..90b7791d36e1 100644
--- a/drivers/media/platform/coda/coda-common.c
+++ b/drivers/media/platform/coda/coda-common.c
@@ -43,6 +43,7 @@
 #define CODA_NAME               "coda"
 
 #define CODADX6_MAX_INSTANCES   4
+#define CODA_MAX_FORMATS        4
 
 #define CODA_PARA_BUF_SIZE      (10 * 1024)
 #define CODA_ISRAM_SIZE (2048 * 2)
@@ -82,6 +83,34 @@ unsigned int coda_read(struct coda_dev *dev, u32 reg)
         return data;
 }
 
+void coda_write_base(struct coda_ctx *ctx, struct coda_q_data *q_data,
+                     struct vb2_buffer *buf, unsigned int reg_y)
+{
+        u32 base_y = vb2_dma_contig_plane_dma_addr(buf, 0);
+        u32 base_cb, base_cr;
+
+        switch (q_data->fourcc) {
+        case V4L2_PIX_FMT_YVU420:
+                /* Switch Cb and Cr for YVU420 format */
+                base_cr = base_y + q_data->bytesperline * q_data->height;
+                base_cb = base_cr + q_data->bytesperline * q_data->height / 4;
+                break;
+        case V4L2_PIX_FMT_YUV420:
+        case V4L2_PIX_FMT_NV12:
+        default:
+                base_cb = base_y + q_data->bytesperline * q_data->height;
+                base_cr = base_cb + q_data->bytesperline * q_data->height / 4;
+                break;
+        case V4L2_PIX_FMT_YUV422P:
+                base_cb = base_y + q_data->bytesperline * q_data->height;
+                base_cr = base_cb + q_data->bytesperline * q_data->height / 2;
+        }
+
+        coda_write(ctx->dev, base_y, reg_y);
+        coda_write(ctx->dev, base_cb, reg_y + 4);
+        coda_write(ctx->dev, base_cr, reg_y + 8);
+}
+
 /*
  * Array of all formats supported by any version of Coda:
  */
@@ -95,6 +124,14 @@ static const struct coda_fmt coda_formats[] = {
                 .fourcc = V4L2_PIX_FMT_YVU420,
         },
         {
+                .name = "YUV 4:2:0 Partial interleaved Y/CbCr",
+                .fourcc = V4L2_PIX_FMT_NV12,
+        },
+        {
+                .name = "YUV 4:2:2 Planar, YCbCr",
+                .fourcc = V4L2_PIX_FMT_YUV422P,
+        },
+        {
                 .name = "H264 Encoded Stream",
                 .fourcc = V4L2_PIX_FMT_H264,
         },
@@ -102,6 +139,10 @@ static const struct coda_fmt coda_formats[] = {
                 .name = "MPEG4 Encoded Stream",
                 .fourcc = V4L2_PIX_FMT_MPEG4,
         },
+        {
+                .name = "JPEG Encoded Images",
+                .fourcc = V4L2_PIX_FMT_JPEG,
+        },
 };
 
 #define CODA_CODEC(mode, src_fourcc, dst_fourcc, max_w, max_h) \
@@ -122,8 +163,10 @@ static const struct coda_codec codadx6_codecs[] = {
 static const struct coda_codec coda7_codecs[] = {
         CODA_CODEC(CODA7_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264,   1280, 720),
         CODA_CODEC(CODA7_MODE_ENCODE_MP4,  V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4,  1280, 720),
+        CODA_CODEC(CODA7_MODE_ENCODE_MJPG, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_JPEG,   8192, 8192),
         CODA_CODEC(CODA7_MODE_DECODE_H264, V4L2_PIX_FMT_H264,   V4L2_PIX_FMT_YUV420, 1920, 1088),
         CODA_CODEC(CODA7_MODE_DECODE_MP4,  V4L2_PIX_FMT_MPEG4,  V4L2_PIX_FMT_YUV420, 1920, 1088),
+        CODA_CODEC(CODA7_MODE_DECODE_MJPG, V4L2_PIX_FMT_JPEG,   V4L2_PIX_FMT_YUV420, 8192, 8192),
 };
 
 static const struct coda_codec coda9_codecs[] = {
@@ -133,17 +176,115 @@ static const struct coda_codec coda9_codecs[] = {
         CODA_CODEC(CODA9_MODE_DECODE_MP4,  V4L2_PIX_FMT_MPEG4,  V4L2_PIX_FMT_YUV420, 1920, 1088),
 };
 
+struct coda_video_device {
+        const char *name;
+        enum coda_inst_type type;
+        const struct coda_context_ops *ops;
+        u32 src_formats[CODA_MAX_FORMATS];
+        u32 dst_formats[CODA_MAX_FORMATS];
+};
+
+static const struct coda_video_device coda_bit_encoder = {
+        .name = "coda-encoder",
+        .type = CODA_INST_ENCODER,
+        .ops = &coda_bit_encode_ops,
+        .src_formats = {
+                V4L2_PIX_FMT_YUV420,
+                V4L2_PIX_FMT_YVU420,
+                V4L2_PIX_FMT_NV12,
+        },
+        .dst_formats = {
+                V4L2_PIX_FMT_H264,
+                V4L2_PIX_FMT_MPEG4,
+        },
+};
+
+static const struct coda_video_device coda_bit_jpeg_encoder = {
+        .name = "coda-jpeg-encoder",
+        .type = CODA_INST_ENCODER,
+        .ops = &coda_bit_encode_ops,
+        .src_formats = {
+                V4L2_PIX_FMT_YUV420,
+                V4L2_PIX_FMT_YVU420,
+                V4L2_PIX_FMT_NV12,
+                V4L2_PIX_FMT_YUV422P,
+        },
+        .dst_formats = {
+                V4L2_PIX_FMT_JPEG,
+        },
+};
+
+static const struct coda_video_device coda_bit_decoder = {
+        .name = "coda-decoder",
+        .type = CODA_INST_DECODER,
+        .ops = &coda_bit_decode_ops,
+        .src_formats = {
+                V4L2_PIX_FMT_H264,
+                V4L2_PIX_FMT_MPEG4,
+        },
+        .dst_formats = {
+                V4L2_PIX_FMT_YUV420,
+                V4L2_PIX_FMT_YVU420,
+                V4L2_PIX_FMT_NV12,
+        },
+};
+
+static const struct coda_video_device coda_bit_jpeg_decoder = {
+        .name = "coda-jpeg-decoder",
+        .type = CODA_INST_DECODER,
+        .ops = &coda_bit_decode_ops,
+        .src_formats = {
+                V4L2_PIX_FMT_JPEG,
+        },
+        .dst_formats = {
+                V4L2_PIX_FMT_YUV420,
+                V4L2_PIX_FMT_YVU420,
+                V4L2_PIX_FMT_NV12,
+                V4L2_PIX_FMT_YUV422P,
+        },
+};
+
+static const struct coda_video_device *codadx6_video_devices[] = {
+        &coda_bit_encoder,
+};
+
+static const struct coda_video_device *coda7_video_devices[] = {
+        &coda_bit_jpeg_encoder,
+        &coda_bit_jpeg_decoder,
+        &coda_bit_encoder,
+        &coda_bit_decoder,
+};
+
+static const struct coda_video_device *coda9_video_devices[] = {
+        &coda_bit_encoder,
+        &coda_bit_decoder,
+};
+
 static bool coda_format_is_yuv(u32 fourcc)
 {
         switch (fourcc) {
         case V4L2_PIX_FMT_YUV420:
         case V4L2_PIX_FMT_YVU420:
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_YUV422P:
                 return true;
         default:
                 return false;
         }
 }
 
+static const char *coda_format_name(u32 fourcc)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(coda_formats); i++) {
+                if (coda_formats[i].fourcc == fourcc)
+                        return coda_formats[i].name;
+        }
+
+        return NULL;
+}
+
 /*
  * Normalize all supported YUV 4:2:0 formats to the value used in the codec
  * tables.
@@ -202,6 +343,17 @@ static void coda_get_max_dimensions(struct coda_dev *dev,
                 *max_h = h;
 }
 
+const struct coda_video_device *to_coda_video_device(struct video_device *vdev)
+{
+        struct coda_dev *dev = video_get_drvdata(vdev);
+        unsigned int i = vdev - dev->vfd;
+
+        if (i >= dev->devtype->num_vdevs)
+                return NULL;
+
+        return dev->devtype->vdevs[i];
+}
+
 const char *coda_product_name(int product)
 {
         static char buf[9];
@@ -240,58 +392,28 @@ static int coda_querycap(struct file *file, void *priv,
 static int coda_enum_fmt(struct file *file, void *priv,
                          struct v4l2_fmtdesc *f)
 {
-        struct coda_ctx *ctx = fh_to_ctx(priv);
-        const struct coda_codec *codecs = ctx->dev->devtype->codecs;
-        const struct coda_fmt *formats = coda_formats;
-        const struct coda_fmt *fmt;
-        int num_codecs = ctx->dev->devtype->num_codecs;
-        int num_formats = ARRAY_SIZE(coda_formats);
-        int i, k, num = 0;
-        bool yuv;
-
-        if (ctx->inst_type == CODA_INST_ENCODER)
-                yuv = (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT);
+        struct video_device *vdev = video_devdata(file);
+        const struct coda_video_device *cvd = to_coda_video_device(vdev);
+        const u32 *formats;
+        const char *name;
+
+        if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+                formats = cvd->src_formats;
+        else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                formats = cvd->dst_formats;
         else
-                yuv = (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE);
-
-        for (i = 0; i < num_formats; i++) {
-                /* Skip either raw or compressed formats */
-                if (yuv != coda_format_is_yuv(formats[i].fourcc))
-                        continue;
-                /* All uncompressed formats are always supported */
-                if (yuv) {
-                        if (num == f->index)
-                                break;
-                        ++num;
-                        continue;
-                }
-                /* Compressed formats may be supported, check the codec list */
-                for (k = 0; k < num_codecs; k++) {
-                        if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
-                            formats[i].fourcc == codecs[k].dst_fourcc)
-                                break;
-                        if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
-                            formats[i].fourcc == codecs[k].src_fourcc)
-                                break;
-                }
-                if (k < num_codecs) {
-                        if (num == f->index)
-                                break;
-                        ++num;
-                }
-        }
+                return -EINVAL;
 
-        if (i < num_formats) {
-                fmt = &formats[i];
-                strlcpy(f->description, fmt->name, sizeof(f->description));
-                f->pixelformat = fmt->fourcc;
-                if (!yuv)
-                        f->flags |= V4L2_FMT_FLAG_COMPRESSED;
-                return 0;
-        }
+        if (f->index >= CODA_MAX_FORMATS || formats[f->index] == 0)
+                return -EINVAL;
+
+        name = coda_format_name(formats[f->index]);
+        strlcpy(f->description, name, sizeof(f->description));
+        f->pixelformat = formats[f->index];
+        if (!coda_format_is_yuv(formats[f->index]))
+                f->flags |= V4L2_FMT_FLAG_COMPRESSED;
 
-        /* Format not found */
-        return -EINVAL;
+        return 0;
 }
 
 static int coda_g_fmt(struct file *file, void *priv,
@@ -311,7 +433,37 @@ static int coda_g_fmt(struct file *file, void *priv,
         f->fmt.pix.bytesperline = q_data->bytesperline;
 
         f->fmt.pix.sizeimage    = q_data->sizeimage;
-        f->fmt.pix.colorspace   = ctx->colorspace;
+        if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_JPEG)
+                f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
+        else
+                f->fmt.pix.colorspace = ctx->colorspace;
+
+        return 0;
+}
+
+static int coda_try_pixelformat(struct coda_ctx *ctx, struct v4l2_format *f)
+{
+        struct coda_q_data *q_data;
+        const u32 *formats;
+        int i;
+
+        if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+                formats = ctx->cvd->src_formats;
+        else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                formats = ctx->cvd->dst_formats;
+        else
+                return -EINVAL;
+
+        for (i = 0; i < CODA_MAX_FORMATS; i++) {
+                if (formats[i] == f->fmt.pix.pixelformat) {
+                        f->fmt.pix.pixelformat = formats[i];
+                        return 0;
+                }
+        }
+
+        /* Fall back to currently set pixelformat */
+        q_data = get_q_data(ctx, f->type);
+        f->fmt.pix.pixelformat = q_data->fourcc;
 
         return 0;
 }
@@ -320,7 +472,6 @@ static int coda_try_fmt(struct coda_ctx *ctx, const struct coda_codec *codec,
                         struct v4l2_format *f)
 {
         struct coda_dev *dev = ctx->dev;
-        struct coda_q_data *q_data;
         unsigned int max_w, max_h;
         enum v4l2_field field;
 
@@ -342,30 +493,35 @@ static int coda_try_fmt(struct coda_ctx *ctx, const struct coda_codec *codec,
         switch (f->fmt.pix.pixelformat) {
         case V4L2_PIX_FMT_YUV420:
         case V4L2_PIX_FMT_YVU420:
-        case V4L2_PIX_FMT_H264:
-        case V4L2_PIX_FMT_MPEG4:
-        case V4L2_PIX_FMT_JPEG:
-                break;
-        default:
-                q_data = get_q_data(ctx, f->type);
-                if (!q_data)
-                        return -EINVAL;
-                f->fmt.pix.pixelformat = q_data->fourcc;
-        }
-
-        switch (f->fmt.pix.pixelformat) {
-        case V4L2_PIX_FMT_YUV420:
-        case V4L2_PIX_FMT_YVU420:
-                /* Frame stride must be multiple of 8, but 16 for h.264 */
+        case V4L2_PIX_FMT_NV12:
+                /*
+                 * Frame stride must be at least multiple of 8,
+                 * but multiple of 16 for h.264 or JPEG 4:2:x
+                 */
                 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16);
                 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline *
                                         f->fmt.pix.height * 3 / 2;
                 break;
+        case V4L2_PIX_FMT_YUV422P:
+                f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16);
+                f->fmt.pix.sizeimage = f->fmt.pix.bytesperline *
+                                        f->fmt.pix.height * 2;
+                break;
+        case V4L2_PIX_FMT_JPEG:
+                f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
+                /* fallthrough */
         case V4L2_PIX_FMT_H264:
         case V4L2_PIX_FMT_MPEG4:
-        case V4L2_PIX_FMT_JPEG:
                 f->fmt.pix.bytesperline = 0;
-                f->fmt.pix.sizeimage = CODA_MAX_FRAME_SIZE;
+                /*
+                 * This is a rough estimate for sensible compressed buffer
+                 * sizes (between 1 and 16 bits per pixel). This could be
+                 * improved by better format specific worst case estimates.
+                 */
+                f->fmt.pix.sizeimage = round_up(clamp(f->fmt.pix.sizeimage,
+                                f->fmt.pix.width * f->fmt.pix.height / 8,
+                                f->fmt.pix.width * f->fmt.pix.height * 2),
+                                PAGE_SIZE);
                 break;
         default:
                 BUG();
@@ -378,34 +534,35 @@ static int coda_try_fmt_vid_cap(struct file *file, void *priv,
                                 struct v4l2_format *f)
 {
         struct coda_ctx *ctx = fh_to_ctx(priv);
-        const struct coda_codec *codec = NULL;
+        const struct coda_q_data *q_data_src;
+        const struct coda_codec *codec;
         struct vb2_queue *src_vq;
         int ret;
 
+        ret = coda_try_pixelformat(ctx, f);
+        if (ret < 0)
+                return ret;
+
+        q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
+
         /*
-         * If the source format is already fixed, try to find a codec that
-         * converts to the given destination format
+         * If the source format is already fixed, only allow the same output
+         * resolution
          */
         src_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
         if (vb2_is_streaming(src_vq)) {
-                struct coda_q_data *q_data_src;
-
-                q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
-                codec = coda_find_codec(ctx->dev, q_data_src->fourcc,
-                                        f->fmt.pix.pixelformat);
-                if (!codec)
-                        return -EINVAL;
-
                 f->fmt.pix.width = q_data_src->width;
                 f->fmt.pix.height = q_data_src->height;
-        } else {
-                /* Otherwise determine codec by encoded format, if possible */
-                codec = coda_find_codec(ctx->dev, V4L2_PIX_FMT_YUV420,
-                                        f->fmt.pix.pixelformat);
         }
 
         f->fmt.pix.colorspace = ctx->colorspace;
 
+        q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
+        codec = coda_find_codec(ctx->dev, q_data_src->fourcc,
+                                f->fmt.pix.pixelformat);
+        if (!codec)
+                return -EINVAL;
+
         ret = coda_try_fmt(ctx, codec, f);
         if (ret < 0)
                 return ret;
@@ -426,21 +583,24 @@ static int coda_try_fmt_vid_out(struct file *file, void *priv,
                                 struct v4l2_format *f)
 {
         struct coda_ctx *ctx = fh_to_ctx(priv);
-        const struct coda_codec *codec = NULL;
+        struct coda_dev *dev = ctx->dev;
+        const struct coda_q_data *q_data_dst;
+        const struct coda_codec *codec;
+        int ret;
 
-        /* Determine codec by encoded format, returns NULL if raw or invalid */
-        if (ctx->inst_type == CODA_INST_DECODER) {
-                codec = coda_find_codec(ctx->dev, f->fmt.pix.pixelformat,
-                                        V4L2_PIX_FMT_YUV420);
-                if (!codec)
-                        codec = coda_find_codec(ctx->dev, V4L2_PIX_FMT_H264,
-                                                V4L2_PIX_FMT_YUV420);
-                if (!codec)
-                        return -EINVAL;
+        ret = coda_try_pixelformat(ctx, f);
+        if (ret < 0)
+                return ret;
+
+        if (!f->fmt.pix.colorspace) {
+                if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_JPEG)
+                        f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
+                else
+                        f->fmt.pix.colorspace = V4L2_COLORSPACE_REC709;
         }
 
-        if (!f->fmt.pix.colorspace)
-                f->fmt.pix.colorspace = V4L2_COLORSPACE_REC709;
+        q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
+        codec = coda_find_codec(dev, f->fmt.pix.pixelformat, q_data_dst->fourcc);
 
         return coda_try_fmt(ctx, codec, f);
 }
@@ -781,6 +941,7 @@ static int coda_job_ready(void *m2m_priv)
 
         if (ctx->hold ||
             ((ctx->inst_type == CODA_INST_DECODER) &&
+             !v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx) &&
              (coda_get_bitstream_payload(ctx) < 512) &&
              !(ctx->bit_stream_param & CODA_BIT_STREAM_END_FLAG))) {
                 v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
@@ -862,25 +1023,17 @@ static void coda_set_tiled_map_type(struct coda_ctx *ctx, int tiled_map_type)
 
 static void set_default_params(struct coda_ctx *ctx)
 {
-        u32 src_fourcc, dst_fourcc;
-        int max_w;
-        int max_h;
+        unsigned int max_w, max_h, size;
 
-        if (ctx->inst_type == CODA_INST_ENCODER) {
-                src_fourcc = V4L2_PIX_FMT_YUV420;
-                dst_fourcc = V4L2_PIX_FMT_H264;
-        } else {
-                src_fourcc = V4L2_PIX_FMT_H264;
-                dst_fourcc = V4L2_PIX_FMT_YUV420;
-        }
-        ctx->codec = coda_find_codec(ctx->dev, src_fourcc, dst_fourcc);
-        max_w = ctx->codec->max_w;
-        max_h = ctx->codec->max_h;
+        ctx->codec = coda_find_codec(ctx->dev, ctx->cvd->src_formats[0],
+                                     ctx->cvd->dst_formats[0]);
+        max_w = min(ctx->codec->max_w, 1920U);
+        max_h = min(ctx->codec->max_h, 1088U);
+        size = max_w * max_h * 3 / 2;
 
         ctx->params.codec_mode = ctx->codec->mode;
         ctx->colorspace = V4L2_COLORSPACE_REC709;
         ctx->params.framerate = 30;
-        ctx->aborting = 0;
 
         /* Default formats for output and input queues */
         ctx->q_data[V4L2_M2M_SRC].fourcc = ctx->codec->src_fourcc;
@@ -891,14 +1044,14 @@ static void set_default_params(struct coda_ctx *ctx)
         ctx->q_data[V4L2_M2M_DST].height = max_h;
         if (ctx->codec->src_fourcc == V4L2_PIX_FMT_YUV420) {
                 ctx->q_data[V4L2_M2M_SRC].bytesperline = max_w;
-                ctx->q_data[V4L2_M2M_SRC].sizeimage = (max_w * max_h * 3) / 2;
+                ctx->q_data[V4L2_M2M_SRC].sizeimage = size;
                 ctx->q_data[V4L2_M2M_DST].bytesperline = 0;
-                ctx->q_data[V4L2_M2M_DST].sizeimage = CODA_MAX_FRAME_SIZE;
+                ctx->q_data[V4L2_M2M_DST].sizeimage = round_up(size, PAGE_SIZE);
         } else {
                 ctx->q_data[V4L2_M2M_SRC].bytesperline = 0;
-                ctx->q_data[V4L2_M2M_SRC].sizeimage = CODA_MAX_FRAME_SIZE;
+                ctx->q_data[V4L2_M2M_SRC].sizeimage = round_up(size, PAGE_SIZE);
                 ctx->q_data[V4L2_M2M_DST].bytesperline = max_w;
-                ctx->q_data[V4L2_M2M_DST].sizeimage = (max_w * max_h * 3) / 2;
+                ctx->q_data[V4L2_M2M_DST].sizeimage = size;
         }
         ctx->q_data[V4L2_M2M_SRC].rect.width = max_w;
         ctx->q_data[V4L2_M2M_SRC].rect.height = max_h;
@@ -964,7 +1117,7 @@ static void coda_buf_queue(struct vb2_buffer *vb)
          * In the decoder case, immediately try to copy the buffer into the
          * bitstream ringbuffer and mark it as ready to be dequeued.
          */
-        if (q_data->fourcc == V4L2_PIX_FMT_H264 &&
+        if (ctx->inst_type == CODA_INST_DECODER &&
             vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
                 /*
                  * For backwards compatibility, queuing an empty buffer marks
@@ -1027,12 +1180,13 @@ static int coda_start_streaming(struct vb2_queue *q, unsigned int count)
         struct v4l2_device *v4l2_dev = &ctx->dev->v4l2_dev;
         struct coda_q_data *q_data_src, *q_data_dst;
         struct vb2_buffer *buf;
-        u32 dst_fourcc;
         int ret = 0;
 
         q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
-                if (q_data_src->fourcc == V4L2_PIX_FMT_H264) {
+                if (q_data_src->fourcc == V4L2_PIX_FMT_H264 ||
+                    (q_data_src->fourcc == V4L2_PIX_FMT_JPEG &&
+                     ctx->dev->devtype->product == CODA_7541)) {
                         /* copy the buffers that where queued before streamon */
                         mutex_lock(&ctx->bitstream_mutex);
                         coda_fill_bitstream(ctx);
@@ -1063,13 +1217,12 @@ static int coda_start_streaming(struct vb2_queue *q, unsigned int count)
         if (!(ctx->streamon_out & ctx->streamon_cap))
                 return 0;
 
-        /* Allow decoder device_run with no new buffers queued */
+        /* Allow BIT decoder device_run with no new buffers queued */
         if (ctx->inst_type == CODA_INST_DECODER)
                 v4l2_m2m_set_src_buffered(ctx->fh.m2m_ctx, true);
 
         ctx->gopcounter = ctx->params.gop_size - 1;
         q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
-        dst_fourcc = q_data_dst->fourcc;
 
         ctx->codec = coda_find_codec(ctx->dev, q_data_src->fourcc,
                                      q_data_dst->fourcc);
@@ -1079,6 +1232,10 @@ static int coda_start_streaming(struct vb2_queue *q, unsigned int count)
                 goto err;
         }
 
+        if (q_data_dst->fourcc == V4L2_PIX_FMT_JPEG)
+                ctx->params.gop_size = 1;
+        ctx->gopcounter = ctx->params.gop_size - 1;
+
         ret = ctx->ops->start_streaming(ctx);
         if (ctx->inst_type == CODA_INST_DECODER) {
                 if (ret == -EAGAIN)
@@ -1093,10 +1250,10 @@ static int coda_start_streaming(struct vb2_queue *q, unsigned int count)
 err:
         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
                 while ((buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
-                        v4l2_m2m_buf_done(buf, VB2_BUF_STATE_DEQUEUED);
+                        v4l2_m2m_buf_done(buf, VB2_BUF_STATE_QUEUED);
         } else {
                 while ((buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx)))
-                        v4l2_m2m_buf_done(buf, VB2_BUF_STATE_DEQUEUED);
+                        v4l2_m2m_buf_done(buf, VB2_BUF_STATE_QUEUED);
         }
         return ret;
 }
@@ -1131,19 +1288,20 @@ static void coda_stop_streaming(struct vb2_queue *q)
         }
 
         if (!ctx->streamon_out && !ctx->streamon_cap) {
-                struct coda_timestamp *ts;
+                struct coda_buffer_meta *meta;
 
                 mutex_lock(&ctx->bitstream_mutex);
-                while (!list_empty(&ctx->timestamp_list)) {
-                        ts = list_first_entry(&ctx->timestamp_list,
-                                              struct coda_timestamp, list);
-                        list_del(&ts->list);
-                        kfree(ts);
+                while (!list_empty(&ctx->buffer_meta_list)) {
+                        meta = list_first_entry(&ctx->buffer_meta_list,
+                                                struct coda_buffer_meta, list);
+                        list_del(&meta->list);
+                        kfree(meta);
                 }
                 mutex_unlock(&ctx->bitstream_mutex);
                 kfifo_init(&ctx->bitstream_fifo,
                         ctx->bitstream.vaddr, ctx->bitstream.size);
                 ctx->runcounter = 0;
+                ctx->aborting = 0;
         }
 }
 
@@ -1226,6 +1384,12 @@ static int coda_s_ctrl(struct v4l2_ctrl *ctrl)
         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:
                 ctx->params.intra_refresh = ctrl->val;
                 break;
+        case V4L2_CID_JPEG_COMPRESSION_QUALITY:
+                coda_set_jpeg_compression_quality(ctx, ctrl->val);
+                break;
+        case V4L2_CID_JPEG_RESTART_INTERVAL:
+                ctx->params.jpeg_restart_interval = ctrl->val;
+                break;
         default:
                 v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
                         "Invalid control, id=%d, val=%d\n",
@@ -1240,14 +1404,8 @@ static const struct v4l2_ctrl_ops coda_ctrl_ops = {
         .s_ctrl = coda_s_ctrl,
 };
 
-static int coda_ctrls_setup(struct coda_ctx *ctx)
+static void coda_encode_ctrls(struct coda_ctx *ctx)
 {
-        v4l2_ctrl_handler_init(&ctx->ctrls, 9);
-
-        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
-                V4L2_CID_HFLIP, 0, 1, 1, 0);
-        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
-                V4L2_CID_VFLIP, 0, 1, 1, 0);
         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
                 V4L2_CID_MPEG_VIDEO_BITRATE, 0, 32767000, 1, 0);
         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
@@ -1291,6 +1449,30 @@ static int coda_ctrls_setup(struct coda_ctx *ctx)
         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
                 V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB, 0,
                 1920 * 1088 / 256, 1, 0);
+}
+
+static void coda_jpeg_encode_ctrls(struct coda_ctx *ctx)
+{
+        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
+                V4L2_CID_JPEG_COMPRESSION_QUALITY, 5, 100, 1, 50);
+        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
+                V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, 1, 0);
+}
+
+static int coda_ctrls_setup(struct coda_ctx *ctx)
+{
+        v4l2_ctrl_handler_init(&ctx->ctrls, 2);
+
+        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
+                V4L2_CID_HFLIP, 0, 1, 1, 0);
+        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
+                V4L2_CID_VFLIP, 0, 1, 1, 0);
+        if (ctx->inst_type == CODA_INST_ENCODER) {
+                if (ctx->cvd->dst_formats[0] == V4L2_PIX_FMT_JPEG)
+                        coda_jpeg_encode_ctrls(ctx);
+                else
+                        coda_encode_ctrls(ctx);
+        }
 
         if (ctx->ctrls.error) {
                 v4l2_err(&ctx->dev->v4l2_dev,
@@ -1364,10 +1546,14 @@ static int coda_next_free_instance(struct coda_dev *dev)
         return idx;
 }
 
-static int coda_open(struct file *file, enum coda_inst_type inst_type,
-                     const struct coda_context_ops *ctx_ops)
+/*
+ * File operations
+ */
+
+static int coda_open(struct file *file)
 {
-        struct coda_dev *dev = video_drvdata(file);
+        struct video_device *vdev = video_devdata(file);
+        struct coda_dev *dev = video_get_drvdata(vdev);
         struct coda_ctx *ctx = NULL;
         char *name;
         int ret;
@@ -1388,8 +1574,9 @@ static int coda_open(struct file *file, enum coda_inst_type inst_type,
         ctx->debugfs_entry = debugfs_create_dir(name, dev->debugfs_root);
         kfree(name);
 
-        ctx->inst_type = inst_type;
-        ctx->ops = ctx_ops;
+        ctx->cvd = to_coda_video_device(vdev);
+        ctx->inst_type = ctx->cvd->type;
+        ctx->ops = ctx->cvd->ops;
         init_completion(&ctx->completion);
         INIT_WORK(&ctx->pic_run_work, coda_pic_run_work);
         INIT_WORK(&ctx->seq_end_work, ctx->ops->seq_end_work);
@@ -1399,8 +1586,10 @@ static int coda_open(struct file *file, enum coda_inst_type inst_type,
         ctx->dev = dev;
         ctx->idx = idx;
         switch (dev->devtype->product) {
-        case CODA_7541:
         case CODA_960:
+                ctx->frame_mem_ctrl = 1 << 12;
+                /* fallthrough */
+        case CODA_7541:
                 ctx->reg_idx = 0;
                 break;
         default:
@@ -1441,16 +1630,17 @@ static int coda_open(struct file *file, enum coda_inst_type inst_type,
 
         ctx->fh.ctrl_handler = &ctx->ctrls;
 
-        ret = coda_alloc_context_buf(ctx, &ctx->parabuf, CODA_PARA_BUF_SIZE,
-                                     "parabuf");
+        ret = coda_alloc_context_buf(ctx, &ctx->parabuf,
+                                     CODA_PARA_BUF_SIZE, "parabuf");
         if (ret < 0) {
                 v4l2_err(&dev->v4l2_dev, "failed to allocate parabuf");
                 goto err_dma_alloc;
         }
 
         ctx->bitstream.size = CODA_MAX_FRAME_SIZE;
-        ctx->bitstream.vaddr = dma_alloc_writecombine(&dev->plat_dev->dev,
-                        ctx->bitstream.size, &ctx->bitstream.paddr, GFP_KERNEL);
+        ctx->bitstream.vaddr = dma_alloc_writecombine(
+                        &dev->plat_dev->dev, ctx->bitstream.size,
+                        &ctx->bitstream.paddr, GFP_KERNEL);
         if (!ctx->bitstream.vaddr) {
                 v4l2_err(&dev->v4l2_dev,
                          "failed to allocate bitstream ringbuffer");
@@ -1461,7 +1651,7 @@ static int coda_open(struct file *file, enum coda_inst_type inst_type,
                 ctx->bitstream.vaddr, ctx->bitstream.size);
         mutex_init(&ctx->bitstream_mutex);
         mutex_init(&ctx->buffer_mutex);
-        INIT_LIST_HEAD(&ctx->timestamp_list);
+        INIT_LIST_HEAD(&ctx->buffer_meta_list);
 
         coda_lock(ctx);
         list_add(&ctx->list, &dev->instances);
@@ -1495,16 +1685,6 @@ err_coda_max:
         return ret;
 }
 
-static int coda_encoder_open(struct file *file)
-{
-        return coda_open(file, CODA_INST_ENCODER, &coda_bit_encode_ops);
-}
-
-static int coda_decoder_open(struct file *file)
-{
-        return coda_open(file, CODA_INST_DECODER, &coda_bit_decode_ops);
-}
-
 static int coda_release(struct file *file)
 {
         struct coda_dev *dev = video_drvdata(file);
@@ -1515,6 +1695,9 @@ static int coda_release(struct file *file)
 
         debugfs_remove_recursive(ctx->debugfs_entry);
 
+        if (ctx->inst_type == CODA_INST_DECODER)
+                coda_bit_stream_end_flag(ctx);
+
         /* If this instance is running, call .job_abort and wait for it to end */
         v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
 
@@ -1528,8 +1711,10 @@ static int coda_release(struct file *file)
         list_del(&ctx->list);
         coda_unlock(ctx);
 
-        dma_free_writecombine(&dev->plat_dev->dev, ctx->bitstream.size,
-                ctx->bitstream.vaddr, ctx->bitstream.paddr);
+        if (ctx->bitstream.vaddr) {
+                dma_free_writecombine(&dev->plat_dev->dev, ctx->bitstream.size,
+                        ctx->bitstream.vaddr, ctx->bitstream.paddr);
+        }
         if (ctx->dev->devtype->product == CODA_DX6)
                 coda_free_aux_buf(dev, &ctx->workbuf);
 
@@ -1548,18 +1733,9 @@ static int coda_release(struct file *file)
         return 0;
 }
 
-static const struct v4l2_file_operations coda_encoder_fops = {
-        .owner          = THIS_MODULE,
-        .open           = coda_encoder_open,
-        .release        = coda_release,
-        .poll           = v4l2_m2m_fop_poll,
-        .unlocked_ioctl = video_ioctl2,
-        .mmap           = v4l2_m2m_fop_mmap,
-};
-
-static const struct v4l2_file_operations coda_decoder_fops = {
+static const struct v4l2_file_operations coda_fops = {
         .owner          = THIS_MODULE,
-        .open           = coda_decoder_open,
+        .open           = coda_open,
         .release        = coda_release,
         .poll           = v4l2_m2m_fop_poll,
         .unlocked_ioctl = video_ioctl2,
@@ -1664,8 +1840,16 @@ err_clk_per:
         return ret;
 }
 
-static int coda_register_device(struct coda_dev *dev, struct video_device *vfd)
+static int coda_register_device(struct coda_dev *dev, int i)
 {
+        struct video_device *vfd = &dev->vfd[i];
+
+        if (i > ARRAY_SIZE(dev->vfd))
+                return -EINVAL;
+
+        snprintf(vfd->name, sizeof(vfd->name), dev->devtype->vdevs[i]->name);
+        vfd->fops       = &coda_fops;
+        vfd->ioctl_ops  = &coda_ioctl_ops;
         vfd->release    = video_device_release_empty,
         vfd->lock       = &dev->dev_mutex;
         vfd->v4l2_dev   = &dev->v4l2_dev;
@@ -1684,7 +1868,7 @@ static void coda_fw_callback(const struct firmware *fw, void *context)
 {
         struct coda_dev *dev = context;
         struct platform_device *pdev = dev->plat_dev;
-        int ret;
+        int i, ret;
 
         if (!fw) {
                 v4l2_err(&dev->v4l2_dev, "firmware request failed\n");
@@ -1725,33 +1909,25 @@ static void coda_fw_callback(const struct firmware *fw, void *context)
                 goto rel_ctx;
         }
 
-        dev->vfd[0].fops      = &coda_encoder_fops,
-        dev->vfd[0].ioctl_ops = &coda_ioctl_ops;
-        snprintf(dev->vfd[0].name, sizeof(dev->vfd[0].name), "coda-encoder");
-        ret = coda_register_device(dev, &dev->vfd[0]);
-        if (ret) {
-                v4l2_err(&dev->v4l2_dev,
-                         "Failed to register encoder video device\n");
-                goto rel_m2m;
-        }
-
-        dev->vfd[1].fops      = &coda_decoder_fops,
-        dev->vfd[1].ioctl_ops = &coda_ioctl_ops;
-        snprintf(dev->vfd[1].name, sizeof(dev->vfd[1].name), "coda-decoder");
-        ret = coda_register_device(dev, &dev->vfd[1]);
-        if (ret) {
-                v4l2_err(&dev->v4l2_dev,
-                         "Failed to register decoder video device\n");
-                goto rel_m2m;
+        for (i = 0; i < dev->devtype->num_vdevs; i++) {
+                ret = coda_register_device(dev, i);
+                if (ret) {
+                        v4l2_err(&dev->v4l2_dev,
+                                 "Failed to register %s video device: %d\n",
+                                 dev->devtype->vdevs[i]->name, ret);
+                        goto rel_vfd;
+                }
         }
 
         v4l2_info(&dev->v4l2_dev, "codec registered as /dev/video[%d-%d]\n",
-                  dev->vfd[0].num, dev->vfd[1].num);
+                  dev->vfd[0].num, dev->vfd[i - 1].num);
 
         pm_runtime_put_sync(&pdev->dev);
         return;
 
-rel_m2m:
+rel_vfd:
+        while (--i >= 0)
+                video_unregister_device(&dev->vfd[i]);
         v4l2_m2m_release(dev->m2m_dev);
 rel_ctx:
         vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
@@ -1783,6 +1959,8 @@ static const struct coda_devtype coda_devdata[] = {
                 .product      = CODA_DX6,
                 .codecs       = codadx6_codecs,
                 .num_codecs   = ARRAY_SIZE(codadx6_codecs),
+                .vdevs        = codadx6_video_devices,
+                .num_vdevs    = ARRAY_SIZE(codadx6_video_devices),
                 .workbuf_size = 288 * 1024 + FMO_SLICE_SAVE_BUF_SIZE * 8 * 1024,
                 .iram_size    = 0xb000,
         },
@@ -1791,6 +1969,8 @@ static const struct coda_devtype coda_devdata[] = {
                 .product      = CODA_7541,
                 .codecs       = coda7_codecs,
                 .num_codecs   = ARRAY_SIZE(coda7_codecs),
+                .vdevs        = coda7_video_devices,
+                .num_vdevs    = ARRAY_SIZE(coda7_video_devices),
                 .workbuf_size = 128 * 1024,
                 .tempbuf_size = 304 * 1024,
                 .iram_size    = 0x14000,
@@ -1800,6 +1980,8 @@ static const struct coda_devtype coda_devdata[] = {
                 .product      = CODA_960,
                 .codecs       = coda9_codecs,
                 .num_codecs   = ARRAY_SIZE(coda9_codecs),
+                .vdevs        = coda9_video_devices,
+                .num_vdevs    = ARRAY_SIZE(coda9_video_devices),
                 .workbuf_size = 80 * 1024,
                 .tempbuf_size = 204 * 1024,
                 .iram_size    = 0x21000,
@@ -1809,6 +1991,8 @@ static const struct coda_devtype coda_devdata[] = {
                 .product      = CODA_960,
                 .codecs       = coda9_codecs,
                 .num_codecs   = ARRAY_SIZE(coda9_codecs),
+                .vdevs        = coda9_video_devices,
+                .num_vdevs    = ARRAY_SIZE(coda9_video_devices),
                 .workbuf_size = 80 * 1024,
                 .tempbuf_size = 204 * 1024,
                 .iram_size    = 0x20000,
@@ -1846,10 +2030,18 @@ static int coda_probe(struct platform_device *pdev)
         int ret, irq;
 
         dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
-        if (!dev) {
-                dev_err(&pdev->dev, "Not enough memory for %s\n",
-                        CODA_NAME);
+        if (!dev)
                 return -ENOMEM;
+
+        pdev_id = of_id ? of_id->data : platform_get_device_id(pdev);
+
+        if (of_id) {
+                dev->devtype = of_id->data;
+        } else if (pdev_id) {
+                dev->devtype = &coda_devdata[pdev_id->driver_data];
+        } else {
+                ret = -EINVAL;
+                goto err_v4l2_register;
         }
 
         spin_lock_init(&dev->irqlock);
@@ -1919,17 +2111,6 @@ static int coda_probe(struct platform_device *pdev)
         mutex_init(&dev->dev_mutex);
         mutex_init(&dev->coda_mutex);
 
-        pdev_id = of_id ? of_id->data : platform_get_device_id(pdev);
-
-        if (of_id) {
-                dev->devtype = of_id->data;
-        } else if (pdev_id) {
-                dev->devtype = &coda_devdata[pdev_id->driver_data];
-        } else {
-                v4l2_device_unregister(&dev->v4l2_dev);
-                return -EINVAL;
-        }
-
         dev->debugfs_root = debugfs_create_dir("coda", NULL);
         if (!dev->debugfs_root)
                 dev_warn(&pdev->dev, "failed to create debugfs root\n");
@@ -1941,8 +2122,7 @@ static int coda_probe(struct platform_device *pdev)
                                          dev->debugfs_root);
                 if (ret < 0) {
                         dev_err(&pdev->dev, "failed to allocate work buffer\n");
-                        v4l2_device_unregister(&dev->v4l2_dev);
-                        return ret;
+                        goto err_v4l2_register;
                 }
         }
 
@@ -1952,8 +2132,7 @@ static int coda_probe(struct platform_device *pdev)
                                          dev->debugfs_root);
                 if (ret < 0) {
                         dev_err(&pdev->dev, "failed to allocate temp buffer\n");
-                        v4l2_device_unregister(&dev->v4l2_dev);
-                        return ret;
+                        goto err_v4l2_register;
                 }
         }
 
@@ -1973,14 +2152,15 @@ static int coda_probe(struct platform_device *pdev)
         dev->workqueue = alloc_workqueue("coda", WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
         if (!dev->workqueue) {
                 dev_err(&pdev->dev, "unable to alloc workqueue\n");
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto err_v4l2_register;
         }
 
         platform_set_drvdata(pdev, dev);
 
         /*
          * Start activated so we can directly call coda_hw_init in
-         * coda_fw_callback regardless of whether CONFIG_PM_RUNTIME is
+         * coda_fw_callback regardless of whether CONFIG_PM is
          * enabled or whether the device is associated with a PM domain.
          */
         pm_runtime_get_noresume(&pdev->dev);
@@ -1988,14 +2168,21 @@ static int coda_probe(struct platform_device *pdev)
         pm_runtime_enable(&pdev->dev);
 
         return coda_firmware_request(dev);
+
+err_v4l2_register:
+        v4l2_device_unregister(&dev->v4l2_dev);
+        return ret;
 }
 
 static int coda_remove(struct platform_device *pdev)
 {
         struct coda_dev *dev = platform_get_drvdata(pdev);
+        int i;
 
-        video_unregister_device(&dev->vfd[0]);
-        video_unregister_device(&dev->vfd[1]);
+        for (i = 0; i < ARRAY_SIZE(dev->vfd); i++) {
+                if (video_get_drvdata(&dev->vfd[i]))
+                        video_unregister_device(&dev->vfd[i]);
+        }
         if (dev->m2m_dev)
                 v4l2_m2m_release(dev->m2m_dev);
         pm_runtime_disable(&pdev->dev);
@@ -2013,7 +2200,7 @@ static int coda_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int coda_runtime_resume(struct device *dev)
 {
         struct coda_dev *cdev = dev_get_drvdata(dev);
diff --git a/drivers/media/platform/coda/coda-jpeg.c b/drivers/media/platform/coda/coda-jpeg.c
new file mode 100644
index 000000000000..8fa3e353f9e2
--- /dev/null
+++ b/drivers/media/platform/coda/coda-jpeg.c
@@ -0,0 +1,238 @@
+/*
+ * Coda multi-standard codec IP - JPEG support functions
+ *
+ * Copyright (C) 2014 Philipp Zabel, Pengutronix
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/swab.h>
+
+#include "coda.h"
+
+#define SOI_MARKER      0xffd8
+#define EOI_MARKER      0xffd9
+
+/*
+ * Typical Huffman tables for 8-bit precision luminance and
+ * chrominance from JPEG ITU-T.81 (ISO/IEC 10918-1) Annex K.3
+ */
+
+static const unsigned char luma_dc_bits[16] = {
+        0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
+        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const unsigned char luma_dc_value[12] = {
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+        0x08, 0x09, 0x0a, 0x0b,
+};
+
+static const unsigned char chroma_dc_bits[16] = {
+        0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+        0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const unsigned char chroma_dc_value[12] = {
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+        0x08, 0x09, 0x0a, 0x0b,
+};
+
+static const unsigned char luma_ac_bits[16] = {
+        0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03,
+        0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d,
+};
+
+static const unsigned char luma_ac_value[162 + 2] = {
+        0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+        0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+        0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+        0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+        0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+        0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+        0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+        0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+        0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+        0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+        0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+        0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+        0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+        0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+        0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+        0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+        0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+        0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+        0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+        0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+        0xf9, 0xfa, /* padded to 32-bit */
+};
+
+static const unsigned char chroma_ac_bits[16] = {
+        0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
+        0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77,
+};
+
+static const unsigned char chroma_ac_value[162 + 2] = {
+        0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+        0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+        0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+        0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+        0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+        0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+        0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+        0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+        0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+        0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+        0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+        0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+        0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+        0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+        0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+        0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+        0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+        0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+        0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+        0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+        0xf9, 0xfa, /* padded to 32-bit */
+};
+
+/*
+ * Quantization tables for luminance and chrominance components in
+ * zig-zag scan order from the Freescale i.MX VPU libaries
+ */
+
+static unsigned char luma_q[64] = {
+        0x06, 0x04, 0x04, 0x04, 0x05, 0x04, 0x06, 0x05,
+        0x05, 0x06, 0x09, 0x06, 0x05, 0x06, 0x09, 0x0b,
+        0x08, 0x06, 0x06, 0x08, 0x0b, 0x0c, 0x0a, 0x0a,
+        0x0b, 0x0a, 0x0a, 0x0c, 0x10, 0x0c, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x10, 0x0c, 0x0c, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+};
+
+static unsigned char chroma_q[64] = {
+        0x07, 0x07, 0x07, 0x0d, 0x0c, 0x0d, 0x18, 0x10,
+        0x10, 0x18, 0x14, 0x0e, 0x0e, 0x0e, 0x14, 0x14,
+        0x0e, 0x0e, 0x0e, 0x0e, 0x14, 0x11, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x11, 0x11, 0x0c, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x11, 0x0c, 0x0c, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+        0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+};
+
+struct coda_memcpy_desc {
+        int offset;
+        const void *src;
+        size_t len;
+};
+
+static void coda_memcpy_parabuf(void *parabuf,
+                                const struct coda_memcpy_desc *desc)
+{
+        u32 *dst = parabuf + desc->offset;
+        const u32 *src = desc->src;
+        int len = desc->len / 4;
+        int i;
+
+        for (i = 0; i < len; i += 2) {
+                dst[i + 1] = swab32(src[i]);
+                dst[i] = swab32(src[i + 1]);
+        }
+}
+
+int coda_jpeg_write_tables(struct coda_ctx *ctx)
+{
+        int i;
+        static const struct coda_memcpy_desc huff[8] = {
+                { 0,   luma_dc_bits,    sizeof(luma_dc_bits)    },
+                { 16,  luma_dc_value,   sizeof(luma_dc_value)   },
+                { 32,  luma_ac_bits,    sizeof(luma_ac_bits)    },
+                { 48,  luma_ac_value,   sizeof(luma_ac_value)   },
+                { 216, chroma_dc_bits,  sizeof(chroma_dc_bits)  },
+                { 232, chroma_dc_value, sizeof(chroma_dc_value) },
+                { 248, chroma_ac_bits,  sizeof(chroma_ac_bits)  },
+                { 264, chroma_ac_value, sizeof(chroma_ac_value) },
+        };
+        struct coda_memcpy_desc qmat[3] = {
+                { 512, ctx->params.jpeg_qmat_tab[0], 64 },
+                { 576, ctx->params.jpeg_qmat_tab[1], 64 },
+                { 640, ctx->params.jpeg_qmat_tab[1], 64 },
+        };
+
+        /* Write huffman tables to parameter memory */
+        for (i = 0; i < ARRAY_SIZE(huff); i++)
+                coda_memcpy_parabuf(ctx->parabuf.vaddr, huff + i);
+
+        /* Write Q-matrix to parameter memory */
+        for (i = 0; i < ARRAY_SIZE(qmat); i++)
+                coda_memcpy_parabuf(ctx->parabuf.vaddr, qmat + i);
+
+        return 0;
+}
+
+bool coda_jpeg_check_buffer(struct coda_ctx *ctx, struct vb2_buffer *vb)
+{
+        void *vaddr = vb2_plane_vaddr(vb, 0);
+        u16 soi = be16_to_cpup((__be16 *)vaddr);
+        u16 eoi = be16_to_cpup((__be16 *)(vaddr +
+                                          vb2_get_plane_payload(vb, 0) - 2));
+
+        return soi == SOI_MARKER && eoi == EOI_MARKER;
+}
+
+/*
+ * Scale quantization table using nonlinear scaling factor
+ * u8 qtab[64], scale [50,190]
+ */
+static void coda_scale_quant_table(u8 *q_tab, int scale)
+{
+        unsigned int temp;
+        int i;
+
+        for (i = 0; i < 64; i++) {
+                temp = DIV_ROUND_CLOSEST((unsigned int)q_tab[i] * scale, 100);
+                if (temp <= 0)
+                        temp = 1;
+                if (temp > 255)
+                        temp = 255;
+                q_tab[i] = (unsigned char)temp;
+        }
+}
+
+void coda_set_jpeg_compression_quality(struct coda_ctx *ctx, int quality)
+{
+        unsigned int scale;
+
+        ctx->params.jpeg_quality = quality;
+
+        /* Clip quality setting to [5,100] interval */
+        if (quality > 100)
+                quality = 100;
+        if (quality < 5)
+                quality = 5;
+
+        /*
+         * Non-linear scaling factor:
+         * [5,50] -> [1000..100], [51,100] -> [98..0]
+         */
+        if (quality < 50)
+                scale = 5000 / quality;
+        else
+                scale = 200 - 2 * quality;
+
+        if (ctx->params.jpeg_qmat_tab[0]) {
+                memcpy(ctx->params.jpeg_qmat_tab[0], luma_q, 64);
+                coda_scale_quant_table(ctx->params.jpeg_qmat_tab[0], scale);
+        }
+        if (ctx->params.jpeg_qmat_tab[1]) {
+                memcpy(ctx->params.jpeg_qmat_tab[1], chroma_q, 64);
+                coda_scale_quant_table(ctx->params.jpeg_qmat_tab[1], scale);
+        }
+}
diff --git a/drivers/media/platform/coda/coda.h b/drivers/media/platform/coda/coda.h
index bbc18c0dacd9..5dd47e5f97c1 100644
--- a/drivers/media/platform/coda/coda.h
+++ b/drivers/media/platform/coda/coda.h
@@ -45,11 +45,15 @@ enum coda_product {
         CODA_960 = 0xf020,
 };
 
+struct coda_video_device;
+
 struct coda_devtype {
         char                    *firmware;
         enum coda_product       product;
         const struct coda_codec *codecs;
         unsigned int            num_codecs;
+        const struct coda_video_device **vdevs;
+        unsigned int            num_vdevs;
         size_t                  workbuf_size;
         size_t                  tempbuf_size;
         size_t                  iram_size;
@@ -65,7 +69,7 @@ struct coda_aux_buf {
 
 struct coda_dev {
         struct v4l2_device      v4l2_dev;
-        struct video_device     vfd[2];
+        struct video_device     vfd[5];
         struct platform_device  *plat_dev;
         const struct coda_devtype *devtype;
 
@@ -114,6 +118,9 @@ struct coda_params {
         u8                      mpeg4_inter_qp;
         u8                      gop_size;
         int                     intra_refresh;
+        u8                      jpeg_quality;
+        u8                      jpeg_restart_interval;
+        u8                      *jpeg_qmat_tab[3];
         int                     codec_mode;
         int                     codec_mode_aux;
         enum v4l2_mpeg_video_multi_slice_mode slice_mode;
@@ -123,11 +130,13 @@ struct coda_params {
         u32                     slice_max_mb;
 };
 
-struct coda_timestamp {
+struct coda_buffer_meta {
         struct list_head        list;
         u32                     sequence;
         struct v4l2_timecode    timecode;
         struct timeval          timestamp;
+        u32                     start;
+        u32                     end;
 };
 
 /* Per-queue, driver-specific private data */
@@ -183,6 +192,7 @@ struct coda_ctx {
         struct work_struct              pic_run_work;
         struct work_struct              seq_end_work;
         struct completion               completion;
+        const struct coda_video_device  *cvd;
         const struct coda_context_ops   *ops;
         int                             aborting;
         int                             initialized;
@@ -212,9 +222,9 @@ struct coda_ctx {
         struct coda_aux_buf             slicebuf;
         struct coda_aux_buf             internal_frames[CODA_MAX_FRAMEBUFFERS];
         u32                             frame_types[CODA_MAX_FRAMEBUFFERS];
-        struct coda_timestamp           frame_timestamps[CODA_MAX_FRAMEBUFFERS];
+        struct coda_buffer_meta         frame_metas[CODA_MAX_FRAMEBUFFERS];
         u32                             frame_errors[CODA_MAX_FRAMEBUFFERS];
-        struct list_head                timestamp_list;
+        struct list_head                buffer_meta_list;
         struct coda_aux_buf             workbuf;
         int                             num_internal_frames;
         int                             idx;
@@ -232,6 +242,8 @@ extern int coda_debug;
 
 void coda_write(struct coda_dev *dev, u32 data, u32 reg);
 unsigned int coda_read(struct coda_dev *dev, u32 reg);
+void coda_write_base(struct coda_ctx *ctx, struct coda_q_data *q_data,
+                     struct vb2_buffer *buf, unsigned int reg_y);
 
 int coda_alloc_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf,
                        size_t size, const char *name, struct dentry *parent);
@@ -281,6 +293,10 @@ void coda_bit_stream_end_flag(struct coda_ctx *ctx);
 
 int coda_h264_padding(int size, char *p);
 
+bool coda_jpeg_check_buffer(struct coda_ctx *ctx, struct vb2_buffer *vb);
+int coda_jpeg_write_tables(struct coda_ctx *ctx);
+void coda_set_jpeg_compression_quality(struct coda_ctx *ctx, int quality);
+
 extern const struct coda_context_ops coda_bit_encode_ops;
 extern const struct coda_context_ops coda_bit_decode_ops;
 
diff --git a/drivers/media/platform/coda/coda_regs.h b/drivers/media/platform/coda/coda_regs.h
index c791275e307b..8e015b8aa8fa 100644
--- a/drivers/media/platform/coda/coda_regs.h
+++ b/drivers/media/platform/coda/coda_regs.h
@@ -147,6 +147,7 @@
 #define CODA_CMD_DEC_SEQ_BB_START               0x180
 #define CODA_CMD_DEC_SEQ_BB_SIZE                0x184
 #define CODA_CMD_DEC_SEQ_OPTION                 0x188
+#define         CODA_NO_INT_ENABLE                      (1 << 10)
 #define         CODA_REORDER_ENABLE                     (1 << 1)
 #define         CODADX6_QP_REPORT                       (1 << 0)
 #define         CODA7_MP4_DEBLK_ENABLE                  (1 << 0)
@@ -332,6 +333,12 @@
 #define CODA9_CMD_ENC_SEQ_ME_OPTION                             0x1d8
 #define CODA_RET_ENC_SEQ_SUCCESS                                0x1c0
 
+#define CODA_CMD_ENC_SEQ_JPG_PARA                               0x198
+#define CODA_CMD_ENC_SEQ_JPG_RST_INTERVAL                       0x19C
+#define CODA_CMD_ENC_SEQ_JPG_THUMB_EN                           0x1a0
+#define CODA_CMD_ENC_SEQ_JPG_THUMB_SIZE                         0x1a4
+#define CODA_CMD_ENC_SEQ_JPG_THUMB_OFFSET                       0x1a8
+
 /* Encoder Picture Run */
 #define CODA9_CMD_ENC_PIC_SRC_INDEX             0x180
 #define CODA9_CMD_ENC_PIC_SRC_STRIDE            0x184
diff --git a/drivers/media/platform/davinci/vpbe.c b/drivers/media/platform/davinci/vpbe.c
index 33b9660b7f77..244d3d6c244c 100644
--- a/drivers/media/platform/davinci/vpbe.c
+++ b/drivers/media/platform/davinci/vpbe.c
@@ -227,7 +227,7 @@ static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index)
                         vpbe_current_encoder_info(vpbe_dev);
         struct vpbe_config *cfg = vpbe_dev->cfg;
         struct venc_platform_data *venc_device = vpbe_dev->venc_device;
-        enum v4l2_mbus_pixelcode if_params;
+        u32 if_params;
         int enc_out_index;
         int sd_index;
         int ret = 0;
@@ -341,7 +341,7 @@ static int vpbe_s_dv_timings(struct vpbe_device *vpbe_dev,
 
         if (!(cfg->outputs[out_index].output.capabilities &
             V4L2_OUT_CAP_DV_TIMINGS))
-                return -EINVAL;
+                return -ENODATA;
 
         for (i = 0; i < output->num_modes; i++) {
                 if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS &&
@@ -384,6 +384,13 @@ static int vpbe_s_dv_timings(struct vpbe_device *vpbe_dev,
 static int vpbe_g_dv_timings(struct vpbe_device *vpbe_dev,
                      struct v4l2_dv_timings *dv_timings)
 {
+        struct vpbe_config *cfg = vpbe_dev->cfg;
+        int out_index = vpbe_dev->current_out_index;
+
+        if (!(cfg->outputs[out_index].output.capabilities &
+                V4L2_OUT_CAP_DV_TIMINGS))
+                return -ENODATA;
+
         if (vpbe_dev->current_timings.timings_type &
           VPBE_ENC_DV_TIMINGS) {
                 *dv_timings = vpbe_dev->current_timings.dv_timings;
@@ -409,7 +416,7 @@ static int vpbe_enum_dv_timings(struct vpbe_device *vpbe_dev,
         int i;
 
         if (!(output->output.capabilities & V4L2_OUT_CAP_DV_TIMINGS))
-                return -EINVAL;
+                return -ENODATA;
 
         for (i = 0; i < output->num_modes; i++) {
                 if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS) {
@@ -440,7 +447,7 @@ static int vpbe_s_std(struct vpbe_device *vpbe_dev, v4l2_std_id std_id)
 
         if (!(cfg->outputs[out_index].output.capabilities &
                 V4L2_OUT_CAP_STD))
-                return -EINVAL;
+                return -ENODATA;
 
         ret = vpbe_get_std_info(vpbe_dev, std_id);
         if (ret)
@@ -473,6 +480,11 @@ static int vpbe_s_std(struct vpbe_device *vpbe_dev, v4l2_std_id std_id)
 static int vpbe_g_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)
 {
         struct vpbe_enc_mode_info *cur_timings = &vpbe_dev->current_timings;
+        struct vpbe_config *cfg = vpbe_dev->cfg;
+        int out_index = vpbe_dev->current_out_index;
+
+        if (!(cfg->outputs[out_index].output.capabilities & V4L2_OUT_CAP_STD))
+                return -ENODATA;
 
         if (cur_timings->timings_type & VPBE_ENC_STD) {
                 *std_id = cur_timings->std_id;
@@ -613,6 +625,7 @@ static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
                 }
                 if (clk_prepare_enable(vpbe_dev->dac_clk)) {
                         ret =  -ENODEV;
+                        clk_put(vpbe_dev->dac_clk);
                         goto fail_mutex_unlock;
                 }
         }
diff --git a/drivers/media/platform/davinci/vpbe_display.c b/drivers/media/platform/davinci/vpbe_display.c
index 73496d953ba0..21a5a56eb5ea 100644
--- a/drivers/media/platform/davinci/vpbe_display.c
+++ b/drivers/media/platform/davinci/vpbe_display.c
@@ -152,8 +152,8 @@ static irqreturn_t venc_isr(int irq, void *arg)
 
         for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
                 layer = disp_dev->dev[i];
-                /* If streaming is started in this layer */
-                if (!layer->started)
+
+                if (!vb2_start_streaming_called(&layer->buffer_queue))
                         continue;
 
                 if (layer->layer_first_int) {
@@ -207,31 +207,23 @@ static irqreturn_t venc_isr(int irq, void *arg)
  */
 static int vpbe_buffer_prepare(struct vb2_buffer *vb)
 {
-        struct vpbe_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
         struct vb2_queue *q = vb->vb2_queue;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = vb2_get_drv_priv(q);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         unsigned long addr;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
                                 "vpbe_buffer_prepare\n");
 
-        if (vb->state != VB2_BUF_STATE_ACTIVE &&
-                vb->state != VB2_BUF_STATE_PREPARED) {
-                vb2_set_plane_payload(vb, 0, layer->pix_fmt.sizeimage);
-                if (vb2_plane_vaddr(vb, 0) &&
-                vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0))
-                        return -EINVAL;
+        vb2_set_plane_payload(vb, 0, layer->pix_fmt.sizeimage);
+        if (vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0))
+                return -EINVAL;
 
-                addr = vb2_dma_contig_plane_dma_addr(vb, 0);
-                if (q->streaming) {
-                        if (!IS_ALIGNED(addr, 8)) {
-                                v4l2_err(&vpbe_dev->v4l2_dev,
-                                        "buffer_prepare:offset is \
-                                        not aligned to 32 bytes\n");
-                                return -EINVAL;
-                        }
-                }
+        addr = vb2_dma_contig_plane_dma_addr(vb, 0);
+        if (!IS_ALIGNED(addr, 8)) {
+                v4l2_err(&vpbe_dev->v4l2_dev,
+                         "buffer_prepare:offset is not aligned to 32 bytes\n");
+                return -EINVAL;
         }
         return 0;
 }
@@ -247,18 +239,20 @@ vpbe_buffer_queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
 
 {
         /* Get the file handle object and layer object */
-        struct vpbe_fh *fh = vb2_get_drv_priv(vq);
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = vb2_get_drv_priv(vq);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "vpbe_buffer_setup\n");
 
+        if (fmt && fmt->fmt.pix.sizeimage < layer->pix_fmt.sizeimage)
+                return -EINVAL;
+
         /* Store number of buffers allocated in numbuffer member */
-        if (*nbuffers < VPBE_DEFAULT_NUM_BUFS)
-                *nbuffers = layer->numbuffers = VPBE_DEFAULT_NUM_BUFS;
+        if (vq->num_buffers + *nbuffers < VPBE_DEFAULT_NUM_BUFS)
+                *nbuffers = VPBE_DEFAULT_NUM_BUFS - vq->num_buffers;
 
         *nplanes = 1;
-        sizes[0] = layer->pix_fmt.sizeimage;
+        sizes[0] = fmt ? fmt->fmt.pix.sizeimage : layer->pix_fmt.sizeimage;
         alloc_ctxs[0] = layer->alloc_ctx;
 
         return 0;
@@ -271,12 +265,11 @@ vpbe_buffer_queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
 static void vpbe_buffer_queue(struct vb2_buffer *vb)
 {
         /* Get the file handle object and layer object */
-        struct vpbe_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
         struct vpbe_disp_buffer *buf = container_of(vb,
                                 struct vpbe_disp_buffer, vb);
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_display *disp = fh->disp_dev;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = vb2_get_drv_priv(vb->vb2_queue);
+        struct vpbe_display *disp = layer->disp_dev;
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         unsigned long flags;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
@@ -288,61 +281,14 @@ static void vpbe_buffer_queue(struct vb2_buffer *vb)
         spin_unlock_irqrestore(&disp->dma_queue_lock, flags);
 }
 
-/*
- * vpbe_buf_cleanup()
- * This function is called from the vb2 layer to free memory allocated to
- * the buffers
- */
-static void vpbe_buf_cleanup(struct vb2_buffer *vb)
-{
-        /* Get the file handle object and layer object */
-        struct vpbe_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-        struct vpbe_disp_buffer *buf = container_of(vb,
-                                        struct vpbe_disp_buffer, vb);
-        unsigned long flags;
-
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
-                        "vpbe_buf_cleanup\n");
-
-        spin_lock_irqsave(&layer->irqlock, flags);
-        if (vb->state == VB2_BUF_STATE_ACTIVE)
-                list_del_init(&buf->list);
-        spin_unlock_irqrestore(&layer->irqlock, flags);
-}
-
-static void vpbe_wait_prepare(struct vb2_queue *vq)
-{
-        struct vpbe_fh *fh = vb2_get_drv_priv(vq);
-        struct vpbe_layer *layer = fh->layer;
-
-        mutex_unlock(&layer->opslock);
-}
-
-static void vpbe_wait_finish(struct vb2_queue *vq)
-{
-        struct vpbe_fh *fh = vb2_get_drv_priv(vq);
-        struct vpbe_layer *layer = fh->layer;
-
-        mutex_lock(&layer->opslock);
-}
-
-static int vpbe_buffer_init(struct vb2_buffer *vb)
-{
-        struct vpbe_disp_buffer *buf = container_of(vb,
-                                        struct vpbe_disp_buffer, vb);
-
-        INIT_LIST_HEAD(&buf->list);
-        return 0;
-}
-
 static int vpbe_start_streaming(struct vb2_queue *vq, unsigned int count)
 {
-        struct vpbe_fh *fh = vb2_get_drv_priv(vq);
-        struct vpbe_layer *layer = fh->layer;
+        struct vpbe_layer *layer = vb2_get_drv_priv(vq);
+        struct osd_state *osd_device = layer->disp_dev->osd_device;
         int ret;
 
+         osd_device->ops.disable_layer(osd_device, layer->layer_info.id);
+
         /* Get the next frame from the buffer queue */
         layer->next_frm = layer->cur_frm = list_entry(layer->dma_queue.next,
                                 struct vpbe_disp_buffer, list);
@@ -354,7 +300,7 @@ static int vpbe_start_streaming(struct vb2_queue *vq, unsigned int count)
         layer->field_id = 0;
 
         /* Set parameters in OSD and VENC */
-        ret = vpbe_set_osd_display_params(fh->disp_dev, layer);
+        ret = vpbe_set_osd_display_params(layer->disp_dev, layer);
         if (ret < 0) {
                 struct vpbe_disp_buffer *buf, *tmp;
 
@@ -371,7 +317,6 @@ static int vpbe_start_streaming(struct vb2_queue *vq, unsigned int count)
          * if request format is yuv420 semiplanar, need to
          * enable both video windows
          */
-        layer->started = 1;
         layer->layer_first_int = 1;
 
         return ret;
@@ -379,14 +324,16 @@ static int vpbe_start_streaming(struct vb2_queue *vq, unsigned int count)
 
 static void vpbe_stop_streaming(struct vb2_queue *vq)
 {
-        struct vpbe_fh *fh = vb2_get_drv_priv(vq);
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_display *disp = fh->disp_dev;
+        struct vpbe_layer *layer = vb2_get_drv_priv(vq);
+        struct osd_state *osd_device = layer->disp_dev->osd_device;
+        struct vpbe_display *disp = layer->disp_dev;
         unsigned long flags;
 
         if (!vb2_is_streaming(vq))
                 return;
 
+        osd_device->ops.disable_layer(osd_device, layer->layer_info.id);
+
         /* release all active buffers */
         spin_lock_irqsave(&disp->dma_queue_lock, flags);
         if (layer->cur_frm == layer->next_frm) {
@@ -411,13 +358,11 @@ static void vpbe_stop_streaming(struct vb2_queue *vq)
 
 static struct vb2_ops video_qops = {
         .queue_setup = vpbe_buffer_queue_setup,
-        .wait_prepare = vpbe_wait_prepare,
-        .wait_finish = vpbe_wait_finish,
-        .buf_init = vpbe_buffer_init,
+        .wait_prepare = vb2_ops_wait_prepare,
+        .wait_finish = vb2_ops_wait_finish,
         .buf_prepare = vpbe_buffer_prepare,
         .start_streaming = vpbe_start_streaming,
         .stop_streaming = vpbe_stop_streaming,
-        .buf_cleanup = vpbe_buf_cleanup,
         .buf_queue = vpbe_buffer_queue,
 };
 
@@ -691,10 +636,9 @@ static int vpbe_try_format(struct vpbe_display *disp_dev,
 static int vpbe_display_querycap(struct file *file, void  *priv,
                                struct v4l2_capability *cap)
 {
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
 
-        cap->version = VPBE_DISPLAY_VERSION_CODE;
         cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         snprintf(cap->driver, sizeof(cap->driver), "%s",
@@ -709,9 +653,8 @@ static int vpbe_display_querycap(struct file *file, void  *priv,
 static int vpbe_display_s_crop(struct file *file, void *priv,
                              const struct v4l2_crop *crop)
 {
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_display *disp_dev = fh->disp_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_display *disp_dev = layer->disp_dev;
         struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
         struct osd_layer_config *cfg = &layer->layer_info.config;
         struct osd_state *osd_device = disp_dev->osd_device;
@@ -778,11 +721,10 @@ static int vpbe_display_s_crop(struct file *file, void *priv,
 static int vpbe_display_g_crop(struct file *file, void *priv,
                              struct v4l2_crop *crop)
 {
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
+        struct vpbe_layer *layer = video_drvdata(file);
         struct osd_layer_config *cfg = &layer->layer_info.config;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-        struct osd_state *osd_device = fh->disp_dev->osd_device;
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
+        struct osd_state *osd_device = layer->disp_dev->osd_device;
         struct v4l2_rect *rect = &crop->c;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
@@ -806,8 +748,8 @@ static int vpbe_display_g_crop(struct file *file, void *priv,
 static int vpbe_display_cropcap(struct file *file, void *priv,
                               struct v4l2_cropcap *cropcap)
 {
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_CROPCAP ioctl\n");
 
@@ -824,9 +766,8 @@ static int vpbe_display_cropcap(struct file *file, void *priv,
 static int vpbe_display_g_fmt(struct file *file, void *priv,
                                 struct v4l2_format *fmt)
 {
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
                         "VIDIOC_G_FMT, layer id = %d\n",
@@ -846,9 +787,8 @@ static int vpbe_display_g_fmt(struct file *file, void *priv,
 static int vpbe_display_enum_fmt(struct file *file, void  *priv,
                                    struct v4l2_fmtdesc *fmt)
 {
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         unsigned int index = 0;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
@@ -878,9 +818,8 @@ static int vpbe_display_enum_fmt(struct file *file, void  *priv,
 static int vpbe_display_s_fmt(struct file *file, void *priv,
                                 struct v4l2_format *fmt)
 {
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_display *disp_dev = fh->disp_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_display *disp_dev = layer->disp_dev;
         struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
         struct osd_layer_config *cfg  = &layer->layer_info.config;
         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
@@ -891,11 +830,9 @@ static int vpbe_display_s_fmt(struct file *file, void *priv,
                         "VIDIOC_S_FMT, layer id = %d\n",
                         layer->device_id);
 
-        /* If streaming is started, return error */
-        if (layer->started) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Streaming is started\n");
+        if (vb2_is_busy(&layer->buffer_queue))
                 return -EBUSY;
-        }
+
         if (V4L2_BUF_TYPE_VIDEO_OUTPUT != fmt->type) {
                 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "invalid type\n");
                 return -EINVAL;
@@ -967,9 +904,9 @@ static int vpbe_display_s_fmt(struct file *file, void *priv,
 static int vpbe_display_try_fmt(struct file *file, void *priv,
                                   struct v4l2_format *fmt)
 {
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_display *disp_dev = fh->disp_dev;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_display *disp_dev = layer->disp_dev;
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_TRY_FMT\n");
@@ -993,18 +930,15 @@ static int vpbe_display_try_fmt(struct file *file, void *priv,
 static int vpbe_display_s_std(struct file *file, void *priv,
                                 v4l2_std_id std_id)
 {
-        struct vpbe_fh *fh = priv;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         int ret;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_S_STD\n");
 
-        /* If streaming is started, return error */
-        if (layer->started) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Streaming is started\n");
+        if (vb2_is_busy(&layer->buffer_queue))
                 return -EBUSY;
-        }
+
         if (NULL != vpbe_dev->ops.s_std) {
                 ret = vpbe_dev->ops.s_std(vpbe_dev, std_id);
                 if (ret) {
@@ -1028,8 +962,8 @@ static int vpbe_display_s_std(struct file *file, void *priv,
 static int vpbe_display_g_std(struct file *file, void *priv,
                                 v4l2_std_id *std_id)
 {
-        struct vpbe_fh *fh = priv;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_G_STD\n");
 
@@ -1051,8 +985,8 @@ static int vpbe_display_g_std(struct file *file, void *priv,
 static int vpbe_display_enum_output(struct file *file, void *priv,
                                     struct v4l2_output *output)
 {
-        struct vpbe_fh *fh = priv;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         int ret;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_ENUM_OUTPUT\n");
@@ -1079,17 +1013,15 @@ static int vpbe_display_enum_output(struct file *file, void *priv,
 static int vpbe_display_s_output(struct file *file, void *priv,
                                 unsigned int i)
 {
-        struct vpbe_fh *fh = priv;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         int ret;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_S_OUTPUT\n");
-        /* If streaming is started, return error */
-        if (layer->started) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Streaming is started\n");
+
+        if (vb2_is_busy(&layer->buffer_queue))
                 return -EBUSY;
-        }
+
         if (NULL == vpbe_dev->ops.set_output)
                 return -EINVAL;
 
@@ -1110,8 +1042,8 @@ static int vpbe_display_s_output(struct file *file, void *priv,
 static int vpbe_display_g_output(struct file *file, void *priv,
                                 unsigned int *i)
 {
-        struct vpbe_fh *fh = priv;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_G_OUTPUT\n");
         /* Get the standard from the current encoder */
@@ -1130,8 +1062,8 @@ static int
 vpbe_display_enum_dv_timings(struct file *file, void *priv,
                         struct v4l2_enum_dv_timings *timings)
 {
-        struct vpbe_fh *fh = priv;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         int ret;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_ENUM_DV_TIMINGS\n");
@@ -1160,19 +1092,14 @@ static int
 vpbe_display_s_dv_timings(struct file *file, void *priv,
                                 struct v4l2_dv_timings *timings)
 {
-        struct vpbe_fh *fh = priv;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
         int ret;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_S_DV_TIMINGS\n");
 
-
-        /* If streaming is started, return error */
-        if (layer->started) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Streaming is started\n");
+        if (vb2_is_busy(&layer->buffer_queue))
                 return -EBUSY;
-        }
 
         /* Set the given standard in the encoder */
         if (!vpbe_dev->ops.s_dv_timings)
@@ -1198,8 +1125,8 @@ static int
 vpbe_display_g_dv_timings(struct file *file, void *priv,
                                 struct v4l2_dv_timings *dv_timings)
 {
-        struct vpbe_fh *fh = priv;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
+        struct vpbe_layer *layer = video_drvdata(file);
+        struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_G_DV_TIMINGS\n");
 
@@ -1215,259 +1142,6 @@ vpbe_display_g_dv_timings(struct file *file, void *priv,
         return 0;
 }
 
-static int vpbe_display_streamoff(struct file *file, void *priv,
-                                enum v4l2_buf_type buf_type)
-{
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-        struct osd_state *osd_device = fh->disp_dev->osd_device;
-        int ret;
-
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
-                        "VIDIOC_STREAMOFF,layer id = %d\n",
-                        layer->device_id);
-
-        if (V4L2_BUF_TYPE_VIDEO_OUTPUT != buf_type) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Invalid buffer type\n");
-                return -EINVAL;
-        }
-
-        /* If io is allowed for this file handle, return error */
-        if (!fh->io_allowed) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "No io_allowed\n");
-                return -EACCES;
-        }
-
-        /* If streaming is not started, return error */
-        if (!layer->started) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "streaming not started in layer"
-                        " id = %d\n", layer->device_id);
-                return -EINVAL;
-        }
-
-        osd_device->ops.disable_layer(osd_device,
-                        layer->layer_info.id);
-        layer->started = 0;
-        ret = vb2_streamoff(&layer->buffer_queue, buf_type);
-
-        return ret;
-}
-
-static int vpbe_display_streamon(struct file *file, void *priv,
-                         enum v4l2_buf_type buf_type)
-{
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_display *disp_dev = fh->disp_dev;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-        struct osd_state *osd_device = disp_dev->osd_device;
-        int ret;
-
-        osd_device->ops.disable_layer(osd_device,
-                        layer->layer_info.id);
-
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_STREAMON, layerid=%d\n",
-                                                layer->device_id);
-
-        if (V4L2_BUF_TYPE_VIDEO_OUTPUT != buf_type) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Invalid buffer type\n");
-                return -EINVAL;
-        }
-
-        /* If file handle is not allowed IO, return error */
-        if (!fh->io_allowed) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "No io_allowed\n");
-                return -EACCES;
-        }
-        /* If Streaming is already started, return error */
-        if (layer->started) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "layer is already streaming\n");
-                return -EBUSY;
-        }
-
-        /*
-         * Call vb2_streamon to start streaming
-         * in videobuf
-         */
-        ret = vb2_streamon(&layer->buffer_queue, buf_type);
-        if (ret) {
-                v4l2_err(&vpbe_dev->v4l2_dev,
-                "error in vb2_streamon\n");
-                return ret;
-        }
-        return ret;
-}
-
-static int vpbe_display_dqbuf(struct file *file, void *priv,
-                      struct v4l2_buffer *buf)
-{
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-        int ret;
-
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
-                "VIDIOC_DQBUF, layer id = %d\n",
-                layer->device_id);
-
-        if (V4L2_BUF_TYPE_VIDEO_OUTPUT != buf->type) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Invalid buffer type\n");
-                return -EINVAL;
-        }
-        /* If this file handle is not allowed to do IO, return error */
-        if (!fh->io_allowed) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "No io_allowed\n");
-                return -EACCES;
-        }
-        if (file->f_flags & O_NONBLOCK)
-                /* Call videobuf_dqbuf for non blocking mode */
-                ret = vb2_dqbuf(&layer->buffer_queue, buf, 1);
-        else
-                /* Call videobuf_dqbuf for blocking mode */
-                ret = vb2_dqbuf(&layer->buffer_queue, buf, 0);
-
-        return ret;
-}
-
-static int vpbe_display_qbuf(struct file *file, void *priv,
-                     struct v4l2_buffer *p)
-{
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
-                "VIDIOC_QBUF, layer id = %d\n",
-                layer->device_id);
-
-        if (V4L2_BUF_TYPE_VIDEO_OUTPUT != p->type) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Invalid buffer type\n");
-                return -EINVAL;
-        }
-
-        /* If this file handle is not allowed to do IO, return error */
-        if (!fh->io_allowed) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "No io_allowed\n");
-                return -EACCES;
-        }
-
-        return vb2_qbuf(&layer->buffer_queue, p);
-}
-
-static int vpbe_display_querybuf(struct file *file, void *priv,
-                         struct v4l2_buffer *buf)
-{
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
-                "VIDIOC_QUERYBUF, layer id = %d\n",
-                layer->device_id);
-
-        if (V4L2_BUF_TYPE_VIDEO_OUTPUT != buf->type) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Invalid buffer type\n");
-                return -EINVAL;
-        }
-        /* Call vb2_querybuf to get information */
-        return vb2_querybuf(&layer->buffer_queue, buf);
-}
-
-static int vpbe_display_reqbufs(struct file *file, void *priv,
-                        struct v4l2_requestbuffers *req_buf)
-{
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-        struct vb2_queue *q;
-        int ret;
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "vpbe_display_reqbufs\n");
-
-        if (V4L2_BUF_TYPE_VIDEO_OUTPUT != req_buf->type) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Invalid buffer type\n");
-                return -EINVAL;
-        }
-
-        /* If io users of the layer is not zero, return error */
-        if (0 != layer->io_usrs) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "not IO user\n");
-                return -EBUSY;
-        }
-        /* Initialize videobuf queue as per the buffer type */
-        layer->alloc_ctx = vb2_dma_contig_init_ctx(vpbe_dev->pdev);
-        if (IS_ERR(layer->alloc_ctx)) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "Failed to get the context\n");
-                return PTR_ERR(layer->alloc_ctx);
-        }
-        q = &layer->buffer_queue;
-        memset(q, 0, sizeof(*q));
-        q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
-        q->io_modes = VB2_MMAP | VB2_USERPTR;
-        q->drv_priv = fh;
-        q->ops = &video_qops;
-        q->mem_ops = &vb2_dma_contig_memops;
-        q->buf_struct_size = sizeof(struct vpbe_disp_buffer);
-        q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
-        q->min_buffers_needed = 1;
-
-        ret = vb2_queue_init(q);
-        if (ret) {
-                v4l2_err(&vpbe_dev->v4l2_dev, "vb2_queue_init() failed\n");
-                vb2_dma_contig_cleanup_ctx(layer->alloc_ctx);
-                return ret;
-        }
-        /* Set io allowed member of file handle to TRUE */
-        fh->io_allowed = 1;
-        /* Increment io usrs member of layer object to 1 */
-        layer->io_usrs = 1;
-        /* Store type of memory requested in layer object */
-        layer->memory = req_buf->memory;
-        /* Initialize buffer queue */
-        INIT_LIST_HEAD(&layer->dma_queue);
-        /* Allocate buffers */
-        return vb2_reqbufs(q, req_buf);
-}
-
-/*
- * vpbe_display_mmap()
- * It is used to map kernel space buffers into user spaces
- */
-static int vpbe_display_mmap(struct file *filep, struct vm_area_struct *vma)
-{
-        /* Get the layer object and file handle object */
-        struct vpbe_fh *fh = filep->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-        int ret;
-
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "vpbe_display_mmap\n");
-
-        if (mutex_lock_interruptible(&layer->opslock))
-                return -ERESTARTSYS;
-        ret = vb2_mmap(&layer->buffer_queue, vma);
-        mutex_unlock(&layer->opslock);
-        return ret;
-}
-
-/* vpbe_display_poll(): It is used for select/poll system call
- */
-static unsigned int vpbe_display_poll(struct file *filep, poll_table *wait)
-{
-        struct vpbe_fh *fh = filep->private_data;
-        struct vpbe_layer *layer = fh->layer;
-        struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
-        unsigned int err = 0;
-
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "vpbe_display_poll\n");
-        if (layer->started) {
-                mutex_lock(&layer->opslock);
-                err = vb2_poll(&layer->buffer_queue, filep, wait);
-                mutex_unlock(&layer->opslock);
-        }
-        return err;
-}
-
 /*
  * vpbe_display_open()
  * It creates object of file handle structure and stores it in private_data
@@ -1475,30 +1149,22 @@ static unsigned int vpbe_display_poll(struct file *filep, poll_table *wait)
  */
 static int vpbe_display_open(struct file *file)
 {
-        struct vpbe_fh *fh = NULL;
         struct vpbe_layer *layer = video_drvdata(file);
-        struct video_device *vdev = video_devdata(file);
         struct vpbe_display *disp_dev = layer->disp_dev;
         struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
         struct osd_state *osd_device = disp_dev->osd_device;
         int err;
 
-        /* Allocate memory for the file handle object */
-        fh = kmalloc(sizeof(struct vpbe_fh), GFP_KERNEL);
-        if (fh == NULL) {
-                v4l2_err(&vpbe_dev->v4l2_dev,
-                        "unable to allocate memory for file handle object\n");
-                return -ENOMEM;
+        /* creating context for file descriptor */
+        err = v4l2_fh_open(file);
+        if (err) {
+                v4l2_err(&vpbe_dev->v4l2_dev, "v4l2_fh_open failed\n");
+                return err;
         }
-        v4l2_fh_init(&fh->fh, vdev);
-        v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
-                        "vpbe display open plane = %d\n",
-                        layer->device_id);
 
-        /* store pointer to fh in private_data member of filep */
-        file->private_data = fh;
-        fh->layer = layer;
-        fh->disp_dev = disp_dev;
+        /* leaving if layer is already initialized */
+        if (!v4l2_fh_is_singular_file(file))
+                return err;
 
         if (!layer->usrs) {
                 if (mutex_lock_interruptible(&layer->opslock))
@@ -1511,15 +1177,12 @@ static int vpbe_display_open(struct file *file)
                         /* Couldn't get layer */
                         v4l2_err(&vpbe_dev->v4l2_dev,
                                 "Display Manager failed to allocate layer\n");
-                        kfree(fh);
+                        v4l2_fh_release(file);
                         return -EINVAL;
                 }
         }
         /* Increment layer usrs counter */
         layer->usrs++;
-        /* Set io_allowed member to false */
-        fh->io_allowed = 0;
-        v4l2_fh_add(&fh->fh);
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
                         "vpbe display device opened successfully\n");
         return 0;
@@ -1532,30 +1195,18 @@ static int vpbe_display_open(struct file *file)
  */
 static int vpbe_display_release(struct file *file)
 {
-        /* Get the layer object and file handle object */
-        struct vpbe_fh *fh = file->private_data;
-        struct vpbe_layer *layer = fh->layer;
+        struct vpbe_layer *layer = video_drvdata(file);
         struct osd_layer_config *cfg  = &layer->layer_info.config;
-        struct vpbe_display *disp_dev = fh->disp_dev;
+        struct vpbe_display *disp_dev = layer->disp_dev;
         struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
         struct osd_state *osd_device = disp_dev->osd_device;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "vpbe_display_release\n");
 
         mutex_lock(&layer->opslock);
-        /* if this instance is doing IO */
-        if (fh->io_allowed) {
-                /* Reset io_usrs member of layer object */
-                layer->io_usrs = 0;
-
-                osd_device->ops.disable_layer(osd_device,
-                                layer->layer_info.id);
-                layer->started = 0;
-                /* Free buffers allocated */
-                vb2_queue_release(&layer->buffer_queue);
-                vb2_dma_contig_cleanup_ctx(&layer->buffer_queue);
-        }
 
+        osd_device->ops.disable_layer(osd_device,
+                        layer->layer_info.id);
         /* Decrement layer usrs counter */
         layer->usrs--;
         /* If this file handle has initialize encoder device, reset it */
@@ -1575,14 +1226,9 @@ static int vpbe_display_release(struct file *file)
                                 layer->layer_info.id);
         }
 
-        v4l2_fh_del(&fh->fh);
-        v4l2_fh_exit(&fh->fh);
-        file->private_data = NULL;
+        _vb2_fop_release(file, NULL);
         mutex_unlock(&layer->opslock);
 
-        /* Free memory allocated to file handle object */
-        kfree(fh);
-
         disp_dev->cbcr_ofst = 0;
 
         return 0;
@@ -1595,20 +1241,27 @@ static const struct v4l2_ioctl_ops vpbe_ioctl_ops = {
         .vidioc_enum_fmt_vid_out = vpbe_display_enum_fmt,
         .vidioc_s_fmt_vid_out    = vpbe_display_s_fmt,
         .vidioc_try_fmt_vid_out  = vpbe_display_try_fmt,
-        .vidioc_reqbufs          = vpbe_display_reqbufs,
-        .vidioc_querybuf         = vpbe_display_querybuf,
-        .vidioc_qbuf             = vpbe_display_qbuf,
-        .vidioc_dqbuf            = vpbe_display_dqbuf,
-        .vidioc_streamon         = vpbe_display_streamon,
-        .vidioc_streamoff        = vpbe_display_streamoff,
+
+        .vidioc_reqbufs          = vb2_ioctl_reqbufs,
+        .vidioc_create_bufs      = vb2_ioctl_create_bufs,
+        .vidioc_querybuf         = vb2_ioctl_querybuf,
+        .vidioc_qbuf             = vb2_ioctl_qbuf,
+        .vidioc_dqbuf            = vb2_ioctl_dqbuf,
+        .vidioc_streamon         = vb2_ioctl_streamon,
+        .vidioc_streamoff        = vb2_ioctl_streamoff,
+        .vidioc_expbuf           = vb2_ioctl_expbuf,
+
         .vidioc_cropcap          = vpbe_display_cropcap,
         .vidioc_g_crop           = vpbe_display_g_crop,
         .vidioc_s_crop           = vpbe_display_s_crop,
+
         .vidioc_s_std            = vpbe_display_s_std,
         .vidioc_g_std            = vpbe_display_g_std,
+
         .vidioc_enum_output      = vpbe_display_enum_output,
         .vidioc_s_output         = vpbe_display_s_output,
         .vidioc_g_output         = vpbe_display_g_output,
+
         .vidioc_s_dv_timings     = vpbe_display_s_dv_timings,
         .vidioc_g_dv_timings     = vpbe_display_g_dv_timings,
         .vidioc_enum_dv_timings  = vpbe_display_enum_dv_timings,
@@ -1619,8 +1272,8 @@ static struct v4l2_file_operations vpbe_fops = {
         .open = vpbe_display_open,
         .release = vpbe_display_release,
         .unlocked_ioctl = video_ioctl2,
-        .mmap = vpbe_display_mmap,
-        .poll = vpbe_display_poll
+        .mmap = vb2_fop_mmap,
+        .poll =  vb2_fop_poll,
 };
 
 static int vpbe_device_get(struct device *dev, void *data)
@@ -1700,6 +1353,7 @@ static int register_device(struct vpbe_layer *vpbe_display_layer,
                   (int)vpbe_display_layer,
                   (int)&vpbe_display_layer->video_dev);
 
+        vpbe_display_layer->video_dev.queue = &vpbe_display_layer->buffer_queue;
         err = video_register_device(&vpbe_display_layer->video_dev,
                                     VFL_TYPE_GRABBER,
                                     -1);
@@ -1724,9 +1378,10 @@ static int register_device(struct vpbe_layer *vpbe_display_layer,
  */
 static int vpbe_display_probe(struct platform_device *pdev)
 {
-        struct vpbe_layer *vpbe_display_layer;
         struct vpbe_display *disp_dev;
+        struct v4l2_device *v4l2_dev;
         struct resource *res = NULL;
+        struct vb2_queue *q;
         int k;
         int i;
         int err;
@@ -1748,13 +1403,14 @@ static int vpbe_display_probe(struct platform_device *pdev)
                         vpbe_device_get);
         if (err < 0)
                 return err;
+
+        v4l2_dev = &disp_dev->vpbe_dev->v4l2_dev;
         /* Initialize the vpbe display controller */
         if (NULL != disp_dev->vpbe_dev->ops.initialize) {
                 err = disp_dev->vpbe_dev->ops.initialize(&pdev->dev,
                                                          disp_dev->vpbe_dev);
                 if (err) {
-                        v4l2_err(&disp_dev->vpbe_dev->v4l2_dev,
-                                        "Error initing vpbe\n");
+                        v4l2_err(v4l2_dev, "Error initing vpbe\n");
                         err = -ENOMEM;
                         goto probe_out;
                 }
@@ -1769,8 +1425,7 @@ static int vpbe_display_probe(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (!res) {
-                v4l2_err(&disp_dev->vpbe_dev->v4l2_dev,
-                         "Unable to get VENC interrupt resource\n");
+                v4l2_err(v4l2_dev, "Unable to get VENC interrupt resource\n");
                 err = -ENODEV;
                 goto probe_out;
         }
@@ -1779,30 +1434,57 @@ static int vpbe_display_probe(struct platform_device *pdev)
         err = devm_request_irq(&pdev->dev, irq, venc_isr, 0,
                                VPBE_DISPLAY_DRIVER, disp_dev);
         if (err) {
-                v4l2_err(&disp_dev->vpbe_dev->v4l2_dev,
-                                "Unable to request interrupt\n");
+                v4l2_err(v4l2_dev, "VPBE IRQ request failed\n");
                 goto probe_out;
         }
 
         for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
+                /* initialize vb2 queue */
+                q = &disp_dev->dev[i]->buffer_queue;
+                memset(q, 0, sizeof(*q));
+                q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+                q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
+                q->drv_priv = disp_dev->dev[i];
+                q->ops = &video_qops;
+                q->mem_ops = &vb2_dma_contig_memops;
+                q->buf_struct_size = sizeof(struct vpbe_disp_buffer);
+                q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+                q->min_buffers_needed = 1;
+                q->lock = &disp_dev->dev[i]->opslock;
+                err = vb2_queue_init(q);
+                if (err) {
+                        v4l2_err(v4l2_dev, "vb2_queue_init() failed\n");
+                        goto probe_out;
+                }
+
+                disp_dev->dev[i]->alloc_ctx =
+                        vb2_dma_contig_init_ctx(disp_dev->vpbe_dev->pdev);
+                if (IS_ERR(disp_dev->dev[i]->alloc_ctx)) {
+                        v4l2_err(v4l2_dev, "Failed to get the context\n");
+                        err = PTR_ERR(disp_dev->dev[i]->alloc_ctx);
+                        goto probe_out;
+                }
+
+                INIT_LIST_HEAD(&disp_dev->dev[i]->dma_queue);
+
                 if (register_device(disp_dev->dev[i], disp_dev, pdev)) {
                         err = -ENODEV;
                         goto probe_out;
                 }
         }
 
-        printk(KERN_DEBUG "Successfully completed the probing of vpbe v4l2 device\n");
+        v4l2_dbg(1, debug, v4l2_dev,
+                 "Successfully completed the probing of vpbe v4l2 device\n");
+
         return 0;
 
 probe_out:
         for (k = 0; k < VPBE_DISPLAY_MAX_DEVICES; k++) {
-                /* Get the pointer to the layer object */
-                vpbe_display_layer = disp_dev->dev[k];
                 /* Unregister video device */
-                if (vpbe_display_layer) {
-                        video_unregister_device(
-                                &vpbe_display_layer->video_dev);
-                                kfree(disp_dev->dev[k]);
+                if (disp_dev->dev[k] != NULL) {
+                        vb2_dma_contig_cleanup_ctx(disp_dev->dev[k]->alloc_ctx);
+                        video_unregister_device(&disp_dev->dev[k]->video_dev);
+                        kfree(disp_dev->dev[k]);
                 }
         }
         return err;
@@ -1828,6 +1510,7 @@ static int vpbe_display_remove(struct platform_device *pdev)
         for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
                 /* Get the pointer to the layer object */
                 vpbe_display_layer = disp_dev->dev[i];
+                vb2_dma_contig_cleanup_ctx(vpbe_display_layer->alloc_ctx);
                 /* Unregister video device */
                 video_unregister_device(&vpbe_display_layer->video_dev);
 
diff --git a/drivers/media/platform/davinci/vpfe_capture.c b/drivers/media/platform/davinci/vpfe_capture.c
index de55f47a77db..271c4600432d 100644
--- a/drivers/media/platform/davinci/vpfe_capture.c
+++ b/drivers/media/platform/davinci/vpfe_capture.c
@@ -414,13 +414,13 @@ static int vpfe_config_image_format(struct vpfe_device *vpfe_dev,
                 /* assume V4L2_PIX_FMT_UYVY as default */
                 pix->pixelformat = V4L2_PIX_FMT_UYVY;
                 v4l2_fill_mbus_format(&mbus_fmt, pix,
-                                V4L2_MBUS_FMT_YUYV10_2X10);
+                                MEDIA_BUS_FMT_YUYV10_2X10);
         } else {
                 pix->field = V4L2_FIELD_NONE;
                 /* assume V4L2_PIX_FMT_SBGGR8 */
                 pix->pixelformat = V4L2_PIX_FMT_SBGGR8;
                 v4l2_fill_mbus_format(&mbus_fmt, pix,
-                                V4L2_MBUS_FMT_SBGGR8_1X8);
+                                MEDIA_BUS_FMT_SBGGR8_1X8);
         }
 
         /* if sub device supports g_mbus_fmt, override the defaults */
@@ -930,8 +930,8 @@ static int vpfe_querycap(struct file *file, void  *priv,
 
         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querycap\n");
 
-        cap->version = VPFE_CAPTURE_VERSION_CODE;
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         strlcpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver));
         strlcpy(cap->bus_info, "VPFE", sizeof(cap->bus_info));
         strlcpy(cap->card, vpfe_dev->cfg->card_name, sizeof(cap->card));
diff --git a/drivers/media/platform/davinci/vpif_capture.c b/drivers/media/platform/davinci/vpif_capture.c
index 3ccb26ff43c8..d8e1b98b7784 100644
--- a/drivers/media/platform/davinci/vpif_capture.c
+++ b/drivers/media/platform/davinci/vpif_capture.c
@@ -311,6 +311,8 @@ static struct vb2_ops video_qops = {
         .start_streaming        = vpif_start_streaming,
         .stop_streaming         = vpif_stop_streaming,
         .buf_queue              = vpif_buffer_queue,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
 };
 
 /**
diff --git a/drivers/media/platform/exynos-gsc/gsc-core.c b/drivers/media/platform/exynos-gsc/gsc-core.c
index b4c9f1d08968..3062e9fac6da 100644
--- a/drivers/media/platform/exynos-gsc/gsc-core.c
+++ b/drivers/media/platform/exynos-gsc/gsc-core.c
@@ -54,7 +54,7 @@ static const struct gsc_fmt gsc_formats[] = {
                 .corder         = GSC_CBCR,
                 .num_planes     = 1,
                 .num_comp       = 1,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
         }, {
                 .name           = "YUV 4:2:2 packed, CbYCrY",
                 .pixelformat    = V4L2_PIX_FMT_UYVY,
@@ -64,7 +64,7 @@ static const struct gsc_fmt gsc_formats[] = {
                 .corder         = GSC_CBCR,
                 .num_planes     = 1,
                 .num_comp       = 1,
-                .mbus_code      = V4L2_MBUS_FMT_UYVY8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_UYVY8_2X8,
         }, {
                 .name           = "YUV 4:2:2 packed, CrYCbY",
                 .pixelformat    = V4L2_PIX_FMT_VYUY,
@@ -74,7 +74,7 @@ static const struct gsc_fmt gsc_formats[] = {
                 .corder         = GSC_CRCB,
                 .num_planes     = 1,
                 .num_comp       = 1,
-                .mbus_code      = V4L2_MBUS_FMT_VYUY8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_VYUY8_2X8,
         }, {
                 .name           = "YUV 4:2:2 packed, YCrYCb",
                 .pixelformat    = V4L2_PIX_FMT_YVYU,
@@ -84,7 +84,7 @@ static const struct gsc_fmt gsc_formats[] = {
                 .corder         = GSC_CRCB,
                 .num_planes     = 1,
                 .num_comp       = 1,
-                .mbus_code      = V4L2_MBUS_FMT_YVYU8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YVYU8_2X8,
         }, {
                 .name           = "YUV 4:4:4 planar, YCbYCr",
                 .pixelformat    = V4L2_PIX_FMT_YUV32,
@@ -319,21 +319,22 @@ int gsc_enum_fmt_mplane(struct v4l2_fmtdesc *f)
         return 0;
 }
 
-static u32 get_plane_info(struct gsc_frame *frm, u32 addr, u32 *index)
+static int get_plane_info(struct gsc_frame *frm, u32 addr, u32 *index, u32 *ret_addr)
 {
         if (frm->addr.y == addr) {
                 *index = 0;
-                return frm->addr.y;
+                *ret_addr = frm->addr.y;
         } else if (frm->addr.cb == addr) {
                 *index = 1;
-                return frm->addr.cb;
+                *ret_addr = frm->addr.cb;
         } else if (frm->addr.cr == addr) {
                 *index = 2;
-                return frm->addr.cr;
+                *ret_addr = frm->addr.cr;
         } else {
                 pr_err("Plane address is wrong");
                 return -EINVAL;
         }
+        return 0;
 }
 
 void gsc_set_prefbuf(struct gsc_dev *gsc, struct gsc_frame *frm)
@@ -352,9 +353,11 @@ void gsc_set_prefbuf(struct gsc_dev *gsc, struct gsc_frame *frm)
                 u32 t_min, t_max;
 
                 t_min = min3(frm->addr.y, frm->addr.cb, frm->addr.cr);
-                low_addr = get_plane_info(frm, t_min, &low_plane);
+                if (get_plane_info(frm, t_min, &low_plane, &low_addr))
+                        return;
                 t_max = max3(frm->addr.y, frm->addr.cb, frm->addr.cr);
-                high_addr = get_plane_info(frm, t_max, &high_plane);
+                if (get_plane_info(frm, t_max, &high_plane, &high_addr))
+                        return;
 
                 mid_plane = 3 - (low_plane + high_plane);
                 if (mid_plane == 0)
diff --git a/drivers/media/platform/exynos-gsc/gsc-core.h b/drivers/media/platform/exynos-gsc/gsc-core.h
index ef0a6564cef9..0abdb17fb19c 100644
--- a/drivers/media/platform/exynos-gsc/gsc-core.h
+++ b/drivers/media/platform/exynos-gsc/gsc-core.h
@@ -117,7 +117,7 @@ enum gsc_yuv_fmt {
  * @flags: flags indicating which operation mode format applies to
  */
 struct gsc_fmt {
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
         char    *name;
         u32     pixelformat;
         u32     color;
diff --git a/drivers/media/platform/exynos4-is/fimc-capture.c b/drivers/media/platform/exynos4-is/fimc-capture.c
index 3d2babd5067a..8a2fd8c33d42 100644
--- a/drivers/media/platform/exynos4-is/fimc-capture.c
+++ b/drivers/media/platform/exynos4-is/fimc-capture.c
@@ -749,7 +749,7 @@ static int fimc_cap_enum_fmt_mplane(struct file *file, void *priv,
                 return -EINVAL;
         strncpy(f->description, fmt->name, sizeof(f->description) - 1);
         f->pixelformat = fmt->fourcc;
-        if (fmt->fourcc == V4L2_MBUS_FMT_JPEG_1X8)
+        if (fmt->fourcc == MEDIA_BUS_FMT_JPEG_1X8)
                 f->flags |= V4L2_FMT_FLAG_COMPRESSED;
         return 0;
 }
diff --git a/drivers/media/platform/exynos4-is/fimc-core.c b/drivers/media/platform/exynos4-is/fimc-core.c
index aee92d908e49..2acc19573b6b 100644
--- a/drivers/media/platform/exynos4-is/fimc-core.c
+++ b/drivers/media/platform/exynos4-is/fimc-core.c
@@ -81,7 +81,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .flags          = FMT_FLAGS_M2M_OUT | FMT_HAS_ALPHA,
         }, {
                 .name           = "YUV 4:4:4",
-                .mbus_code      = V4L2_MBUS_FMT_YUV10_1X30,
+                .mbus_code      = MEDIA_BUS_FMT_YUV10_1X30,
                 .flags          = FMT_FLAGS_WRITEBACK,
         }, {
                 .name           = "YUV 4:2:2 packed, YCbYCr",
@@ -90,7 +90,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .color          = FIMC_FMT_YCBYCR422,
                 .memplanes      = 1,
                 .colplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .flags          = FMT_FLAGS_M2M | FMT_FLAGS_CAM,
         }, {
                 .name           = "YUV 4:2:2 packed, CbYCrY",
@@ -99,7 +99,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .color          = FIMC_FMT_CBYCRY422,
                 .memplanes      = 1,
                 .colplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_UYVY8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_UYVY8_2X8,
                 .flags          = FMT_FLAGS_M2M | FMT_FLAGS_CAM,
         }, {
                 .name           = "YUV 4:2:2 packed, CrYCbY",
@@ -108,7 +108,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .color          = FIMC_FMT_CRYCBY422,
                 .memplanes      = 1,
                 .colplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_VYUY8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_VYUY8_2X8,
                 .flags          = FMT_FLAGS_M2M | FMT_FLAGS_CAM,
         }, {
                 .name           = "YUV 4:2:2 packed, YCrYCb",
@@ -117,7 +117,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .color          = FIMC_FMT_YCRYCB422,
                 .memplanes      = 1,
                 .colplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_YVYU8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YVYU8_2X8,
                 .flags          = FMT_FLAGS_M2M | FMT_FLAGS_CAM,
         }, {
                 .name           = "YUV 4:2:2 planar, Y/Cb/Cr",
@@ -190,7 +190,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .depth          = { 8 },
                 .memplanes      = 1,
                 .colplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_JPEG_1X8,
+                .mbus_code      = MEDIA_BUS_FMT_JPEG_1X8,
                 .flags          = FMT_FLAGS_CAM | FMT_FLAGS_COMPRESSED,
         }, {
                 .name           = "S5C73MX interleaved UYVY/JPEG",
@@ -200,7 +200,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .memplanes      = 2,
                 .colplanes      = 1,
                 .mdataplanes    = 0x2, /* plane 1 holds frame meta data */
-                .mbus_code      = V4L2_MBUS_FMT_S5C_UYVY_JPEG_1X8,
+                .mbus_code      = MEDIA_BUS_FMT_S5C_UYVY_JPEG_1X8,
                 .flags          = FMT_FLAGS_CAM | FMT_FLAGS_COMPRESSED,
         },
 };
@@ -832,7 +832,7 @@ err:
         return -ENXIO;
 }
 
-#if defined(CONFIG_PM_RUNTIME) || defined(CONFIG_PM_SLEEP)
+#ifdef CONFIG_PM
 static int fimc_m2m_suspend(struct fimc_dev *fimc)
 {
         unsigned long flags;
@@ -871,7 +871,7 @@ static int fimc_m2m_resume(struct fimc_dev *fimc)
 
         return 0;
 }
-#endif /* CONFIG_PM_RUNTIME || CONFIG_PM_SLEEP */
+#endif /* CONFIG_PM */
 
 static const struct of_device_id fimc_of_match[];
 
@@ -1039,7 +1039,7 @@ err_sclk:
         return ret;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int fimc_runtime_resume(struct device *dev)
 {
         struct fimc_dev *fimc = dev_get_drvdata(dev);
diff --git a/drivers/media/platform/exynos4-is/fimc-core.h b/drivers/media/platform/exynos4-is/fimc-core.h
index 6c75c6ced1f7..7328f0845065 100644
--- a/drivers/media/platform/exynos4-is/fimc-core.h
+++ b/drivers/media/platform/exynos4-is/fimc-core.h
@@ -579,8 +579,8 @@ static inline bool fimc_jpeg_fourcc(u32 pixelformat)
 
 static inline bool fimc_user_defined_mbus_fmt(u32 code)
 {
-        return (code == V4L2_MBUS_FMT_JPEG_1X8 ||
-                code == V4L2_MBUS_FMT_S5C_UYVY_JPEG_1X8);
+        return (code == MEDIA_BUS_FMT_JPEG_1X8 ||
+                code == MEDIA_BUS_FMT_S5C_UYVY_JPEG_1X8);
 }
 
 /* Return the alpha component bit mask */
diff --git a/drivers/media/platform/exynos4-is/fimc-is-i2c.c b/drivers/media/platform/exynos4-is/fimc-is-i2c.c
index 371cad4fcce9..d83033170789 100644
--- a/drivers/media/platform/exynos4-is/fimc-is-i2c.c
+++ b/drivers/media/platform/exynos4-is/fimc-is-i2c.c
@@ -81,7 +81,7 @@ static int fimc_is_i2c_remove(struct platform_device *pdev)
         return 0;
 }
 
-#if defined(CONFIG_PM_RUNTIME) || defined(CONFIG_PM_SLEEP)
+#ifdef CONFIG_PM
 static int fimc_is_i2c_runtime_suspend(struct device *dev)
 {
         struct fimc_is_i2c *isp_i2c = dev_get_drvdata(dev);
diff --git a/drivers/media/platform/exynos4-is/fimc-is.c b/drivers/media/platform/exynos4-is/fimc-is.c
index 22162b2567da..2a0cbeff0324 100644
--- a/drivers/media/platform/exynos4-is/fimc-is.c
+++ b/drivers/media/platform/exynos4-is/fimc-is.c
@@ -428,8 +428,7 @@ static void fimc_is_load_firmware(const struct firmware *fw, void *context)
          * needed around for copying to the IS working memory every
          * time before the Cortex-A5 is restarted.
          */
-        if (is->fw.f_w)
-                release_firmware(is->fw.f_w);
+        release_firmware(is->fw.f_w);
         is->fw.f_w = fw;
 done:
         mutex_unlock(&is->lock);
@@ -814,9 +813,9 @@ static int fimc_is_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         is->irq = irq_of_parse_and_map(dev->of_node, 0);
-        if (is->irq < 0) {
+        if (!is->irq) {
                 dev_err(dev, "no irq found\n");
-                return is->irq;
+                return -EINVAL;
         }
 
         ret = fimc_is_get_clocks(is);
@@ -937,8 +936,7 @@ static int fimc_is_remove(struct platform_device *pdev)
         vb2_dma_contig_cleanup_ctx(is->alloc_ctx);
         fimc_is_put_clocks(is);
         fimc_is_debugfs_remove(is);
-        if (is->fw.f_w)
-                release_firmware(is->fw.f_w);
+        release_firmware(is->fw.f_w);
         fimc_is_free_cpu_memory(is);
 
         return 0;
diff --git a/drivers/media/platform/exynos4-is/fimc-isp.c b/drivers/media/platform/exynos4-is/fimc-isp.c
index be62d6b9ac48..60c744915549 100644
--- a/drivers/media/platform/exynos4-is/fimc-isp.c
+++ b/drivers/media/platform/exynos4-is/fimc-isp.c
@@ -41,21 +41,21 @@ static const struct fimc_fmt fimc_isp_formats[FIMC_ISP_NUM_FORMATS] = {
                 .depth          = { 8 },
                 .color          = FIMC_FMT_RAW8,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_SGRBG8_1X8,
+                .mbus_code      = MEDIA_BUS_FMT_SGRBG8_1X8,
         }, {
                 .name           = "RAW10 (GRBG)",
                 .fourcc         = V4L2_PIX_FMT_SGRBG10,
                 .depth          = { 10 },
                 .color          = FIMC_FMT_RAW10,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_SGRBG10_1X10,
+                .mbus_code      = MEDIA_BUS_FMT_SGRBG10_1X10,
         }, {
                 .name           = "RAW12 (GRBG)",
                 .fourcc         = V4L2_PIX_FMT_SGRBG12,
                 .depth          = { 12 },
                 .color          = FIMC_FMT_RAW12,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_SGRBG12_1X12,
+                .mbus_code      = MEDIA_BUS_FMT_SGRBG12_1X12,
         },
 };
 
@@ -149,7 +149,7 @@ static int fimc_isp_subdev_get_fmt(struct v4l2_subdev *sd,
 
                 if (fmt->pad == FIMC_ISP_SD_PAD_SRC_FIFO) {
                         mf->colorspace = V4L2_COLORSPACE_JPEG;
-                        mf->code = V4L2_MBUS_FMT_YUV10_1X30;
+                        mf->code = MEDIA_BUS_FMT_YUV10_1X30;
                 }
         }
 
@@ -175,7 +175,7 @@ static void __isp_subdev_try_format(struct fimc_isp *isp,
                                 FIMC_ISP_SINK_WIDTH_MAX, 0,
                                 &mf->height, FIMC_ISP_SINK_HEIGHT_MIN,
                                 FIMC_ISP_SINK_HEIGHT_MAX, 0, 0);
-                mf->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                mf->code = MEDIA_BUS_FMT_SGRBG10_1X10;
         } else {
                 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
                         format = v4l2_subdev_get_try_format(fh,
@@ -188,7 +188,7 @@ static void __isp_subdev_try_format(struct fimc_isp *isp,
                 mf->height = format->height - FIMC_ISP_CAC_MARGIN_HEIGHT;
 
                 if (fmt->pad == FIMC_ISP_SD_PAD_SRC_FIFO) {
-                        mf->code = V4L2_MBUS_FMT_YUV10_1X30;
+                        mf->code = MEDIA_BUS_FMT_YUV10_1X30;
                         mf->colorspace = V4L2_COLORSPACE_JPEG;
                 } else {
                         mf->code = format->code;
@@ -680,11 +680,11 @@ static void __isp_subdev_set_default_format(struct fimc_isp *isp)
                                 FIMC_ISP_CAC_MARGIN_WIDTH;
         isp->sink_fmt.height = DEFAULT_PREVIEW_STILL_HEIGHT +
                                 FIMC_ISP_CAC_MARGIN_HEIGHT;
-        isp->sink_fmt.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        isp->sink_fmt.code = MEDIA_BUS_FMT_SGRBG10_1X10;
 
         isp->src_fmt.width = DEFAULT_PREVIEW_STILL_WIDTH;
         isp->src_fmt.height = DEFAULT_PREVIEW_STILL_HEIGHT;
-        isp->src_fmt.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        isp->src_fmt.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         __is_set_frame_size(is, &isp->src_fmt);
 }
 
diff --git a/drivers/media/platform/exynos4-is/fimc-lite-reg.c b/drivers/media/platform/exynos4-is/fimc-lite-reg.c
index bc3ec7d25a32..0477716a20db 100644
--- a/drivers/media/platform/exynos4-is/fimc-lite-reg.c
+++ b/drivers/media/platform/exynos4-is/fimc-lite-reg.c
@@ -112,24 +112,24 @@ void flite_hw_set_test_pattern(struct fimc_lite *dev, bool on)
 }
 
 static const u32 src_pixfmt_map[8][3] = {
-        { V4L2_MBUS_FMT_YUYV8_2X8, FLITE_REG_CISRCSIZE_ORDER422_IN_YCBYCR,
+        { MEDIA_BUS_FMT_YUYV8_2X8, FLITE_REG_CISRCSIZE_ORDER422_IN_YCBYCR,
           FLITE_REG_CIGCTRL_YUV422_1P },
-        { V4L2_MBUS_FMT_YVYU8_2X8, FLITE_REG_CISRCSIZE_ORDER422_IN_YCRYCB,
+        { MEDIA_BUS_FMT_YVYU8_2X8, FLITE_REG_CISRCSIZE_ORDER422_IN_YCRYCB,
           FLITE_REG_CIGCTRL_YUV422_1P },
-        { V4L2_MBUS_FMT_UYVY8_2X8, FLITE_REG_CISRCSIZE_ORDER422_IN_CBYCRY,
+        { MEDIA_BUS_FMT_UYVY8_2X8, FLITE_REG_CISRCSIZE_ORDER422_IN_CBYCRY,
           FLITE_REG_CIGCTRL_YUV422_1P },
-        { V4L2_MBUS_FMT_VYUY8_2X8, FLITE_REG_CISRCSIZE_ORDER422_IN_CRYCBY,
+        { MEDIA_BUS_FMT_VYUY8_2X8, FLITE_REG_CISRCSIZE_ORDER422_IN_CRYCBY,
           FLITE_REG_CIGCTRL_YUV422_1P },
-        { V4L2_MBUS_FMT_SGRBG8_1X8, 0, FLITE_REG_CIGCTRL_RAW8 },
-        { V4L2_MBUS_FMT_SGRBG10_1X10, 0, FLITE_REG_CIGCTRL_RAW10 },
-        { V4L2_MBUS_FMT_SGRBG12_1X12, 0, FLITE_REG_CIGCTRL_RAW12 },
-        { V4L2_MBUS_FMT_JPEG_1X8, 0, FLITE_REG_CIGCTRL_USER(1) },
+        { MEDIA_BUS_FMT_SGRBG8_1X8, 0, FLITE_REG_CIGCTRL_RAW8 },
+        { MEDIA_BUS_FMT_SGRBG10_1X10, 0, FLITE_REG_CIGCTRL_RAW10 },
+        { MEDIA_BUS_FMT_SGRBG12_1X12, 0, FLITE_REG_CIGCTRL_RAW12 },
+        { MEDIA_BUS_FMT_JPEG_1X8, 0, FLITE_REG_CIGCTRL_USER(1) },
 };
 
 /* Set camera input pixel format and resolution */
 void flite_hw_set_source_format(struct fimc_lite *dev, struct flite_frame *f)
 {
-        enum v4l2_mbus_pixelcode pixelcode = f->fmt->mbus_code;
+        u32 pixelcode = f->fmt->mbus_code;
         int i = ARRAY_SIZE(src_pixfmt_map);
         u32 cfg;
 
@@ -232,10 +232,10 @@ static void flite_hw_set_pack12(struct fimc_lite *dev, int on)
 static void flite_hw_set_out_order(struct fimc_lite *dev, struct flite_frame *f)
 {
         static const u32 pixcode[4][2] = {
-                { V4L2_MBUS_FMT_YUYV8_2X8, FLITE_REG_CIODMAFMT_YCBYCR },
-                { V4L2_MBUS_FMT_YVYU8_2X8, FLITE_REG_CIODMAFMT_YCRYCB },
-                { V4L2_MBUS_FMT_UYVY8_2X8, FLITE_REG_CIODMAFMT_CBYCRY },
-                { V4L2_MBUS_FMT_VYUY8_2X8, FLITE_REG_CIODMAFMT_CRYCBY },
+                { MEDIA_BUS_FMT_YUYV8_2X8, FLITE_REG_CIODMAFMT_YCBYCR },
+                { MEDIA_BUS_FMT_YVYU8_2X8, FLITE_REG_CIODMAFMT_YCRYCB },
+                { MEDIA_BUS_FMT_UYVY8_2X8, FLITE_REG_CIODMAFMT_CBYCRY },
+                { MEDIA_BUS_FMT_VYUY8_2X8, FLITE_REG_CIODMAFMT_CRYCBY },
         };
         u32 cfg = readl(dev->regs + FLITE_REG_CIODMAFMT);
         int i = ARRAY_SIZE(pixcode);
diff --git a/drivers/media/platform/exynos4-is/fimc-lite.c b/drivers/media/platform/exynos4-is/fimc-lite.c
index a97d2352f1d7..7e8687338155 100644
--- a/drivers/media/platform/exynos4-is/fimc-lite.c
+++ b/drivers/media/platform/exynos4-is/fimc-lite.c
@@ -48,7 +48,7 @@ static const struct fimc_fmt fimc_lite_formats[] = {
                 .depth          = { 16 },
                 .color          = FIMC_FMT_YCBYCR422,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .flags          = FMT_FLAGS_YUV,
         }, {
                 .name           = "YUV 4:2:2 packed, CbYCrY",
@@ -57,7 +57,7 @@ static const struct fimc_fmt fimc_lite_formats[] = {
                 .depth          = { 16 },
                 .color          = FIMC_FMT_CBYCRY422,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_UYVY8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_UYVY8_2X8,
                 .flags          = FMT_FLAGS_YUV,
         }, {
                 .name           = "YUV 4:2:2 packed, CrYCbY",
@@ -66,7 +66,7 @@ static const struct fimc_fmt fimc_lite_formats[] = {
                 .depth          = { 16 },
                 .color          = FIMC_FMT_CRYCBY422,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_VYUY8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_VYUY8_2X8,
                 .flags          = FMT_FLAGS_YUV,
         }, {
                 .name           = "YUV 4:2:2 packed, YCrYCb",
@@ -75,7 +75,7 @@ static const struct fimc_fmt fimc_lite_formats[] = {
                 .depth          = { 16 },
                 .color          = FIMC_FMT_YCRYCB422,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_YVYU8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YVYU8_2X8,
                 .flags          = FMT_FLAGS_YUV,
         }, {
                 .name           = "RAW8 (GRBG)",
@@ -84,7 +84,7 @@ static const struct fimc_fmt fimc_lite_formats[] = {
                 .depth          = { 8 },
                 .color          = FIMC_FMT_RAW8,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_SGRBG8_1X8,
+                .mbus_code      = MEDIA_BUS_FMT_SGRBG8_1X8,
                 .flags          = FMT_FLAGS_RAW_BAYER,
         }, {
                 .name           = "RAW10 (GRBG)",
@@ -93,7 +93,7 @@ static const struct fimc_fmt fimc_lite_formats[] = {
                 .depth          = { 16 },
                 .color          = FIMC_FMT_RAW10,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_SGRBG10_1X10,
+                .mbus_code      = MEDIA_BUS_FMT_SGRBG10_1X10,
                 .flags          = FMT_FLAGS_RAW_BAYER,
         }, {
                 .name           = "RAW12 (GRBG)",
@@ -102,7 +102,7 @@ static const struct fimc_fmt fimc_lite_formats[] = {
                 .depth          = { 16 },
                 .color          = FIMC_FMT_RAW12,
                 .memplanes      = 1,
-                .mbus_code      = V4L2_MBUS_FMT_SGRBG12_1X12,
+                .mbus_code      = MEDIA_BUS_FMT_SGRBG12_1X12,
                 .flags          = FMT_FLAGS_RAW_BAYER,
         },
 };
@@ -1588,7 +1588,7 @@ err_clk_put:
         return ret;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int fimc_lite_runtime_resume(struct device *dev)
 {
         struct fimc_lite *fimc = dev_get_drvdata(dev);
diff --git a/drivers/media/platform/exynos4-is/fimc-reg.c b/drivers/media/platform/exynos4-is/fimc-reg.c
index 2d77fd8f440a..df0cbcb69b6b 100644
--- a/drivers/media/platform/exynos4-is/fimc-reg.c
+++ b/drivers/media/platform/exynos4-is/fimc-reg.c
@@ -592,10 +592,10 @@ struct mbus_pixfmt_desc {
 };
 
 static const struct mbus_pixfmt_desc pix_desc[] = {
-        { V4L2_MBUS_FMT_YUYV8_2X8, FIMC_REG_CISRCFMT_ORDER422_YCBYCR, 8 },
-        { V4L2_MBUS_FMT_YVYU8_2X8, FIMC_REG_CISRCFMT_ORDER422_YCRYCB, 8 },
-        { V4L2_MBUS_FMT_VYUY8_2X8, FIMC_REG_CISRCFMT_ORDER422_CRYCBY, 8 },
-        { V4L2_MBUS_FMT_UYVY8_2X8, FIMC_REG_CISRCFMT_ORDER422_CBYCRY, 8 },
+        { MEDIA_BUS_FMT_YUYV8_2X8, FIMC_REG_CISRCFMT_ORDER422_YCBYCR, 8 },
+        { MEDIA_BUS_FMT_YVYU8_2X8, FIMC_REG_CISRCFMT_ORDER422_YCRYCB, 8 },
+        { MEDIA_BUS_FMT_VYUY8_2X8, FIMC_REG_CISRCFMT_ORDER422_CRYCBY, 8 },
+        { MEDIA_BUS_FMT_UYVY8_2X8, FIMC_REG_CISRCFMT_ORDER422_CBYCRY, 8 },
 };
 
 int fimc_hw_set_camera_source(struct fimc_dev *fimc,
@@ -689,11 +689,11 @@ int fimc_hw_set_camera_type(struct fimc_dev *fimc,
 
                 /* TODO: add remaining supported formats. */
                 switch (vid_cap->ci_fmt.code) {
-                case V4L2_MBUS_FMT_VYUY8_2X8:
+                case MEDIA_BUS_FMT_VYUY8_2X8:
                         tmp = FIMC_REG_CSIIMGFMT_YCBCR422_8BIT;
                         break;
-                case V4L2_MBUS_FMT_JPEG_1X8:
-                case V4L2_MBUS_FMT_S5C_UYVY_JPEG_1X8:
+                case MEDIA_BUS_FMT_JPEG_1X8:
+                case MEDIA_BUS_FMT_S5C_UYVY_JPEG_1X8:
                         tmp = FIMC_REG_CSIIMGFMT_USER(1);
                         cfg |= FIMC_REG_CIGCTRL_CAM_JPEG;
                         break;
diff --git a/drivers/media/platform/exynos4-is/mipi-csis.c b/drivers/media/platform/exynos4-is/mipi-csis.c
index db6fd14d1936..9e1056d60c7e 100644
--- a/drivers/media/platform/exynos4-is/mipi-csis.c
+++ b/drivers/media/platform/exynos4-is/mipi-csis.c
@@ -238,34 +238,34 @@ struct csis_state {
  */
 struct csis_pix_format {
         unsigned int pix_width_alignment;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         u32 fmt_reg;
         u8 data_alignment;
 };
 
 static const struct csis_pix_format s5pcsis_formats[] = {
         {
-                .code = V4L2_MBUS_FMT_VYUY8_2X8,
+                .code = MEDIA_BUS_FMT_VYUY8_2X8,
                 .fmt_reg = S5PCSIS_CFG_FMT_YCBCR422_8BIT,
                 .data_alignment = 32,
         }, {
-                .code = V4L2_MBUS_FMT_JPEG_1X8,
+                .code = MEDIA_BUS_FMT_JPEG_1X8,
                 .fmt_reg = S5PCSIS_CFG_FMT_USER(1),
                 .data_alignment = 32,
         }, {
-                .code = V4L2_MBUS_FMT_S5C_UYVY_JPEG_1X8,
+                .code = MEDIA_BUS_FMT_S5C_UYVY_JPEG_1X8,
                 .fmt_reg = S5PCSIS_CFG_FMT_USER(1),
                 .data_alignment = 32,
         }, {
-                .code = V4L2_MBUS_FMT_SGRBG8_1X8,
+                .code = MEDIA_BUS_FMT_SGRBG8_1X8,
                 .fmt_reg = S5PCSIS_CFG_FMT_RAW8,
                 .data_alignment = 24,
         }, {
-                .code = V4L2_MBUS_FMT_SGRBG10_1X10,
+                .code = MEDIA_BUS_FMT_SGRBG10_1X10,
                 .fmt_reg = S5PCSIS_CFG_FMT_RAW10,
                 .data_alignment = 24,
         }, {
-                .code = V4L2_MBUS_FMT_SGRBG12_1X12,
+                .code = MEDIA_BUS_FMT_SGRBG12_1X12,
                 .fmt_reg = S5PCSIS_CFG_FMT_RAW12,
                 .data_alignment = 24,
         }
@@ -978,7 +978,7 @@ static int s5pcsis_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int s5pcsis_runtime_suspend(struct device *dev)
 {
         return s5pcsis_pm_suspend(dev, true);
diff --git a/drivers/media/platform/fsl-viu.c b/drivers/media/platform/fsl-viu.c
index d5dc198502ef..8afee3c17c1c 100644
--- a/drivers/media/platform/fsl-viu.c
+++ b/drivers/media/platform/fsl-viu.c
@@ -604,10 +604,11 @@ static int vidioc_querycap(struct file *file, void *priv,
 {
         strcpy(cap->driver, "viu");
         strcpy(cap->card, "viu");
-        cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
+        cap->device_caps =      V4L2_CAP_VIDEO_CAPTURE |
                                 V4L2_CAP_STREAMING     |
                                 V4L2_CAP_VIDEO_OVERLAY |
                                 V4L2_CAP_READWRITE;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/platform/marvell-ccic/mcam-core.c b/drivers/media/platform/marvell-ccic/mcam-core.c
index 7a86c77bffa0..193373ff268d 100644
--- a/drivers/media/platform/marvell-ccic/mcam-core.c
+++ b/drivers/media/platform/marvell-ccic/mcam-core.c
@@ -106,61 +106,61 @@ static struct mcam_format_struct {
         __u32 pixelformat;
         int bpp;   /* Bytes per pixel */
         bool planar;
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
 } mcam_formats[] = {
         {
                 .desc           = "YUYV 4:2:2",
                 .pixelformat    = V4L2_PIX_FMT_YUYV,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .bpp            = 2,
                 .planar         = false,
         },
         {
                 .desc           = "UYVY 4:2:2",
                 .pixelformat    = V4L2_PIX_FMT_UYVY,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .bpp            = 2,
                 .planar         = false,
         },
         {
                 .desc           = "YUV 4:2:2 PLANAR",
                 .pixelformat    = V4L2_PIX_FMT_YUV422P,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .bpp            = 2,
                 .planar         = true,
         },
         {
                 .desc           = "YUV 4:2:0 PLANAR",
                 .pixelformat    = V4L2_PIX_FMT_YUV420,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .bpp            = 2,
                 .planar         = true,
         },
         {
                 .desc           = "YVU 4:2:0 PLANAR",
                 .pixelformat    = V4L2_PIX_FMT_YVU420,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .bpp            = 2,
                 .planar         = true,
         },
         {
                 .desc           = "RGB 444",
                 .pixelformat    = V4L2_PIX_FMT_RGB444,
-                .mbus_code      = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
+                .mbus_code      = MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE,
                 .bpp            = 2,
                 .planar         = false,
         },
         {
                 .desc           = "RGB 565",
                 .pixelformat    = V4L2_PIX_FMT_RGB565,
-                .mbus_code      = V4L2_MBUS_FMT_RGB565_2X8_LE,
+                .mbus_code      = MEDIA_BUS_FMT_RGB565_2X8_LE,
                 .bpp            = 2,
                 .planar         = false,
         },
         {
                 .desc           = "Raw RGB Bayer",
                 .pixelformat    = V4L2_PIX_FMT_SBGGR8,
-                .mbus_code      = V4L2_MBUS_FMT_SBGGR8_1X8,
+                .mbus_code      = MEDIA_BUS_FMT_SBGGR8_1X8,
                 .bpp            = 1,
                 .planar         = false,
         },
@@ -190,8 +190,7 @@ static const struct v4l2_pix_format mcam_def_pix_format = {
         .sizeimage      = VGA_WIDTH*VGA_HEIGHT*2,
 };
 
-static const enum v4l2_mbus_pixelcode mcam_def_mbus_code =
-                                        V4L2_MBUS_FMT_YUYV8_2X8;
+static const u32 mcam_def_mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
 
 
 /*
@@ -1080,6 +1079,8 @@ static int mcam_vb_queue_setup(struct vb2_queue *vq,
                 *nbufs = minbufs;
         if (cam->buffer_mode == B_DMA_contig)
                 alloc_ctxs[0] = cam->vb_alloc_ctx;
+        else if (cam->buffer_mode == B_DMA_sg)
+                alloc_ctxs[0] = cam->vb_alloc_ctx_sg;
         return 0;
 }
 
@@ -1101,26 +1102,6 @@ static void mcam_vb_buf_queue(struct vb2_buffer *vb)
                 mcam_read_setup(cam);
 }
 
-
-/*
- * vb2 uses these to release the mutex when waiting in dqbuf.  I'm
- * not actually sure we need to do this (I'm not sure that vb2_dqbuf() needs
- * to be called with the mutex held), but better safe than sorry.
- */
-static void mcam_vb_wait_prepare(struct vb2_queue *vq)
-{
-        struct mcam_camera *cam = vb2_get_drv_priv(vq);
-
-        mutex_unlock(&cam->s_mutex);
-}
-
-static void mcam_vb_wait_finish(struct vb2_queue *vq)
-{
-        struct mcam_camera *cam = vb2_get_drv_priv(vq);
-
-        mutex_lock(&cam->s_mutex);
-}
-
 /*
  * These need to be called with the mutex held from vb2
  */
@@ -1190,8 +1171,8 @@ static const struct vb2_ops mcam_vb2_ops = {
         .buf_queue              = mcam_vb_buf_queue,
         .start_streaming        = mcam_vb_start_streaming,
         .stop_streaming         = mcam_vb_stop_streaming,
-        .wait_prepare           = mcam_vb_wait_prepare,
-        .wait_finish            = mcam_vb_wait_finish,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
 };
 
 
@@ -1219,17 +1200,12 @@ static int mcam_vb_sg_buf_init(struct vb2_buffer *vb)
 static int mcam_vb_sg_buf_prepare(struct vb2_buffer *vb)
 {
         struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
-        struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
         struct sg_table *sg_table = vb2_dma_sg_plane_desc(vb, 0);
         struct mcam_dma_desc *desc = mvb->dma_desc;
         struct scatterlist *sg;
         int i;
 
-        mvb->dma_desc_nent = dma_map_sg(cam->dev, sg_table->sgl,
-                        sg_table->nents, DMA_FROM_DEVICE);
-        if (mvb->dma_desc_nent <= 0)
-                return -EIO;  /* Not sure what's right here */
-        for_each_sg(sg_table->sgl, sg, mvb->dma_desc_nent, i) {
+        for_each_sg(sg_table->sgl, sg, sg_table->nents, i) {
                 desc->dma_addr = sg_dma_address(sg);
                 desc->segment_len = sg_dma_len(sg);
                 desc++;
@@ -1237,16 +1213,6 @@ static int mcam_vb_sg_buf_prepare(struct vb2_buffer *vb)
         return 0;
 }
 
-static void mcam_vb_sg_buf_finish(struct vb2_buffer *vb)
-{
-        struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
-        struct sg_table *sg_table = vb2_dma_sg_plane_desc(vb, 0);
-
-        if (sg_table)
-                dma_unmap_sg(cam->dev, sg_table->sgl,
-                                sg_table->nents, DMA_FROM_DEVICE);
-}
-
 static void mcam_vb_sg_buf_cleanup(struct vb2_buffer *vb)
 {
         struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
@@ -1263,12 +1229,11 @@ static const struct vb2_ops mcam_vb2_sg_ops = {
         .buf_init               = mcam_vb_sg_buf_init,
         .buf_prepare            = mcam_vb_sg_buf_prepare,
         .buf_queue              = mcam_vb_buf_queue,
-        .buf_finish             = mcam_vb_sg_buf_finish,
         .buf_cleanup            = mcam_vb_sg_buf_cleanup,
         .start_streaming        = mcam_vb_start_streaming,
         .stop_streaming         = mcam_vb_stop_streaming,
-        .wait_prepare           = mcam_vb_wait_prepare,
-        .wait_finish            = mcam_vb_wait_finish,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
 };
 
 #endif /* MCAM_MODE_DMA_SG */
@@ -1280,6 +1245,7 @@ static int mcam_setup_vb2(struct mcam_camera *cam)
         memset(vq, 0, sizeof(*vq));
         vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         vq->drv_priv = cam;
+        vq->lock = &cam->s_mutex;
         INIT_LIST_HEAD(&cam->buffers);
         switch (cam->buffer_mode) {
         case B_DMA_contig:
@@ -1287,10 +1253,12 @@ static int mcam_setup_vb2(struct mcam_camera *cam)
                 vq->ops = &mcam_vb2_ops;
                 vq->mem_ops = &vb2_dma_contig_memops;
                 vq->buf_struct_size = sizeof(struct mcam_vb_buffer);
-                cam->vb_alloc_ctx = vb2_dma_contig_init_ctx(cam->dev);
                 vq->io_modes = VB2_MMAP | VB2_USERPTR;
                 cam->dma_setup = mcam_ctlr_dma_contig;
                 cam->frame_complete = mcam_dma_contig_done;
+                cam->vb_alloc_ctx = vb2_dma_contig_init_ctx(cam->dev);
+                if (IS_ERR(cam->vb_alloc_ctx))
+                        return PTR_ERR(cam->vb_alloc_ctx);
 #endif
                 break;
         case B_DMA_sg:
@@ -1301,6 +1269,9 @@ static int mcam_setup_vb2(struct mcam_camera *cam)
                 vq->io_modes = VB2_MMAP | VB2_USERPTR;
                 cam->dma_setup = mcam_ctlr_dma_sg;
                 cam->frame_complete = mcam_dma_sg_done;
+                cam->vb_alloc_ctx_sg = vb2_dma_sg_init_ctx(cam->dev);
+                if (IS_ERR(cam->vb_alloc_ctx_sg))
+                        return PTR_ERR(cam->vb_alloc_ctx_sg);
 #endif
                 break;
         case B_vmalloc:
@@ -1326,6 +1297,10 @@ static void mcam_cleanup_vb2(struct mcam_camera *cam)
         if (cam->buffer_mode == B_DMA_contig)
                 vb2_dma_contig_cleanup_ctx(cam->vb_alloc_ctx);
 #endif
+#ifdef MCAM_MODE_DMA_SG
+        if (cam->buffer_mode == B_DMA_sg)
+                vb2_dma_sg_cleanup_ctx(cam->vb_alloc_ctx_sg);
+#endif
 }
 
 
@@ -1414,9 +1389,9 @@ static int mcam_vidioc_querycap(struct file *file, void *priv,
 {
         strcpy(cap->driver, "marvell_ccic");
         strcpy(cap->card, "marvell_ccic");
-        cap->version = 1;
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
+        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
                 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/platform/marvell-ccic/mcam-core.h b/drivers/media/platform/marvell-ccic/mcam-core.h
index e0e628cb98f9..aa0c6eac254a 100644
--- a/drivers/media/platform/marvell-ccic/mcam-core.h
+++ b/drivers/media/platform/marvell-ccic/mcam-core.h
@@ -176,6 +176,7 @@ struct mcam_camera {
         /* DMA buffers - DMA modes */
         struct mcam_vb_buffer *vb_bufs[MAX_DMA_BUFS];
         struct vb2_alloc_ctx *vb_alloc_ctx;
+        struct vb2_alloc_ctx *vb_alloc_ctx_sg;
 
         /* Mode-specific ops, set at open time */
         void (*dma_setup)(struct mcam_camera *cam);
@@ -183,7 +184,7 @@ struct mcam_camera {
 
         /* Current operating parameters */
         struct v4l2_pix_format pix_format;
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
 
         /* Locks */
         struct mutex s_mutex; /* Access to this structure */
diff --git a/drivers/media/platform/mx2_emmaprp.c b/drivers/media/platform/mx2_emmaprp.c
index 4971ff21f82b..f923d1bc43a0 100644
--- a/drivers/media/platform/mx2_emmaprp.c
+++ b/drivers/media/platform/mx2_emmaprp.c
@@ -402,13 +402,8 @@ static int vidioc_querycap(struct file *file, void *priv,
 {
         strncpy(cap->driver, MEM2MEM_NAME, sizeof(cap->driver) - 1);
         strncpy(cap->card, MEM2MEM_NAME, sizeof(cap->card) - 1);
-        /*
-         * This is only a mem-to-mem video device. The capture and output
-         * device capability flags are left only for backward compatibility
-         * and are scheduled for removal.
-         */
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT |
-                            V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
+        cap->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/platform/omap/Kconfig b/drivers/media/platform/omap/Kconfig
index 05de442d24e4..dc2aaab54aef 100644
--- a/drivers/media/platform/omap/Kconfig
+++ b/drivers/media/platform/omap/Kconfig
@@ -3,7 +3,8 @@ config VIDEO_OMAP2_VOUT_VRFB
 
 config VIDEO_OMAP2_VOUT
         tristate "OMAP2/OMAP3 V4L2-Display driver"
-        depends on ARCH_OMAP2 || ARCH_OMAP3 || (COMPILE_TEST && HAS_MMU)
+        depends on MMU
+        depends on ARCH_OMAP2 || ARCH_OMAP3
         select VIDEOBUF_GEN
         select VIDEOBUF_DMA_CONTIG
         select OMAP2_DSS if HAS_IOMEM && ARCH_OMAP2PLUS
diff --git a/drivers/media/platform/omap/omap_vout.c b/drivers/media/platform/omap/omap_vout.c
index 64ab6fb06b9c..ba2d8f973d58 100644
--- a/drivers/media/platform/omap/omap_vout.c
+++ b/drivers/media/platform/omap/omap_vout.c
@@ -198,7 +198,7 @@ static int omap_vout_try_format(struct v4l2_pix_format *pix)
  * omap_vout_uservirt_to_phys: This inline function is used to convert user
  * space virtual address to physical address.
  */
-static u32 omap_vout_uservirt_to_phys(u32 virtp)
+static unsigned long omap_vout_uservirt_to_phys(unsigned long virtp)
 {
         unsigned long physp = 0;
         struct vm_area_struct *vma;
@@ -418,10 +418,10 @@ static int omapvid_setup_overlay(struct omap_vout_device *vout,
         }
 
         v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev,
-                "%s enable=%d addr=%x width=%d\n height=%d color_mode=%d\n"
+                "%s enable=%d addr=%pad width=%d\n height=%d color_mode=%d\n"
                 "rotation=%d mirror=%d posx=%d posy=%d out_width = %d \n"
                 "out_height=%d rotation_type=%d screen_width=%d\n",
-                __func__, ovl->is_enabled(ovl), info.paddr, info.width, info.height,
+                __func__, ovl->is_enabled(ovl), &info.paddr, info.width, info.height,
                 info.color_mode, info.rotation, info.mirror, info.pos_x,
                 info.pos_y, info.out_width, info.out_height, info.rotation_type,
                 info.screen_width);
@@ -794,7 +794,7 @@ static int omap_vout_buffer_prepare(struct videobuf_queue *q,
                 vout->queued_buf_addr[vb->i] = (u8 *)
                         omap_vout_uservirt_to_phys(vb->baddr);
         } else {
-                u32 addr, dma_addr;
+                unsigned long addr, dma_addr;
                 unsigned long size;
 
                 addr = (unsigned long) vout->buf_virt_addr[vb->i];
@@ -1054,8 +1054,9 @@ static int vidioc_querycap(struct file *file, void *fh,
         strlcpy(cap->driver, VOUT_NAME, sizeof(cap->driver));
         strlcpy(cap->card, vout->vfd->name, sizeof(cap->card));
         cap->bus_info[0] = '\0';
-        cap->capabilities = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT |
+        cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT |
                 V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 
         return 0;
 }
diff --git a/drivers/media/platform/omap3isp/ispccdc.c b/drivers/media/platform/omap3isp/ispccdc.c
index 81a9dc053d58..587489a072d5 100644
--- a/drivers/media/platform/omap3isp/ispccdc.c
+++ b/drivers/media/platform/omap3isp/ispccdc.c
@@ -36,23 +36,23 @@ __ccdc_get_format(struct isp_ccdc_device *ccdc, struct v4l2_subdev_fh *fh,
                   unsigned int pad, enum v4l2_subdev_format_whence which);
 
 static const unsigned int ccdc_fmts[] = {
-        V4L2_MBUS_FMT_Y8_1X8,
-        V4L2_MBUS_FMT_Y10_1X10,
-        V4L2_MBUS_FMT_Y12_1X12,
-        V4L2_MBUS_FMT_SGRBG8_1X8,
-        V4L2_MBUS_FMT_SRGGB8_1X8,
-        V4L2_MBUS_FMT_SBGGR8_1X8,
-        V4L2_MBUS_FMT_SGBRG8_1X8,
-        V4L2_MBUS_FMT_SGRBG10_1X10,
-        V4L2_MBUS_FMT_SRGGB10_1X10,
-        V4L2_MBUS_FMT_SBGGR10_1X10,
-        V4L2_MBUS_FMT_SGBRG10_1X10,
-        V4L2_MBUS_FMT_SGRBG12_1X12,
-        V4L2_MBUS_FMT_SRGGB12_1X12,
-        V4L2_MBUS_FMT_SBGGR12_1X12,
-        V4L2_MBUS_FMT_SGBRG12_1X12,
-        V4L2_MBUS_FMT_YUYV8_2X8,
-        V4L2_MBUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_Y8_1X8,
+        MEDIA_BUS_FMT_Y10_1X10,
+        MEDIA_BUS_FMT_Y12_1X12,
+        MEDIA_BUS_FMT_SGRBG8_1X8,
+        MEDIA_BUS_FMT_SRGGB8_1X8,
+        MEDIA_BUS_FMT_SBGGR8_1X8,
+        MEDIA_BUS_FMT_SGBRG8_1X8,
+        MEDIA_BUS_FMT_SGRBG10_1X10,
+        MEDIA_BUS_FMT_SRGGB10_1X10,
+        MEDIA_BUS_FMT_SBGGR10_1X10,
+        MEDIA_BUS_FMT_SGBRG10_1X10,
+        MEDIA_BUS_FMT_SGRBG12_1X12,
+        MEDIA_BUS_FMT_SRGGB12_1X12,
+        MEDIA_BUS_FMT_SBGGR12_1X12,
+        MEDIA_BUS_FMT_SGBRG12_1X12,
+        MEDIA_BUS_FMT_YUYV8_2X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
 };
 
 /*
@@ -266,10 +266,10 @@ static int __ccdc_lsc_enable(struct isp_ccdc_device *ccdc, int enable)
                 __ccdc_get_format(ccdc, NULL, CCDC_PAD_SINK,
                                   V4L2_SUBDEV_FORMAT_ACTIVE);
 
-        if ((format->code != V4L2_MBUS_FMT_SGRBG10_1X10) &&
-            (format->code != V4L2_MBUS_FMT_SRGGB10_1X10) &&
-            (format->code != V4L2_MBUS_FMT_SBGGR10_1X10) &&
-            (format->code != V4L2_MBUS_FMT_SGBRG10_1X10))
+        if ((format->code != MEDIA_BUS_FMT_SGRBG10_1X10) &&
+            (format->code != MEDIA_BUS_FMT_SRGGB10_1X10) &&
+            (format->code != MEDIA_BUS_FMT_SBGGR10_1X10) &&
+            (format->code != MEDIA_BUS_FMT_SGBRG10_1X10))
                 return -EINVAL;
 
         if (enable)
@@ -971,8 +971,8 @@ static void ccdc_config_sync_if(struct isp_ccdc_device *ccdc,
 
         format = &ccdc->formats[CCDC_PAD_SINK];
 
-        if (format->code == V4L2_MBUS_FMT_YUYV8_2X8 ||
-            format->code == V4L2_MBUS_FMT_UYVY8_2X8) {
+        if (format->code == MEDIA_BUS_FMT_YUYV8_2X8 ||
+            format->code == MEDIA_BUS_FMT_UYVY8_2X8) {
                 /* According to the OMAP3 TRM the input mode only affects SYNC
                  * mode, enabling BT.656 mode should take precedence. However,
                  * in practice setting the input mode to YCbCr data on 8 bits
@@ -1020,7 +1020,7 @@ static void ccdc_config_sync_if(struct isp_ccdc_device *ccdc,
         /* The CCDC_CFG.Y8POS bit is used in YCbCr8 input mode only. The
          * hardware seems to ignore it in all other input modes.
          */
-        if (format->code == V4L2_MBUS_FMT_UYVY8_2X8)
+        if (format->code == MEDIA_BUS_FMT_UYVY8_2X8)
                 isp_reg_set(isp, OMAP3_ISP_IOMEM_CCDC, ISPCCDC_CFG,
                             ISPCCDC_CFG_Y8POS);
         else
@@ -1168,9 +1168,9 @@ static void ccdc_configure(struct isp_ccdc_device *ccdc)
 
         if (ccdc->bt656)
                 bridge = ISPCTRL_PAR_BRIDGE_DISABLE;
-        else if (fmt_info->code == V4L2_MBUS_FMT_YUYV8_2X8)
+        else if (fmt_info->code == MEDIA_BUS_FMT_YUYV8_2X8)
                 bridge = ISPCTRL_PAR_BRIDGE_LENDIAN;
-        else if (fmt_info->code == V4L2_MBUS_FMT_UYVY8_2X8)
+        else if (fmt_info->code == MEDIA_BUS_FMT_UYVY8_2X8)
                 bridge = ISPCTRL_PAR_BRIDGE_BENDIAN;
         else
                 bridge = ISPCTRL_PAR_BRIDGE_DISABLE;
@@ -1199,16 +1199,16 @@ static void ccdc_configure(struct isp_ccdc_device *ccdc)
 
         /* Mosaic filter */
         switch (format->code) {
-        case V4L2_MBUS_FMT_SRGGB10_1X10:
-        case V4L2_MBUS_FMT_SRGGB12_1X12:
+        case MEDIA_BUS_FMT_SRGGB10_1X10:
+        case MEDIA_BUS_FMT_SRGGB12_1X12:
                 ccdc_pattern = ccdc_srggb_pattern;
                 break;
-        case V4L2_MBUS_FMT_SBGGR10_1X10:
-        case V4L2_MBUS_FMT_SBGGR12_1X12:
+        case MEDIA_BUS_FMT_SBGGR10_1X10:
+        case MEDIA_BUS_FMT_SBGGR12_1X12:
                 ccdc_pattern = ccdc_sbggr_pattern;
                 break;
-        case V4L2_MBUS_FMT_SGBRG10_1X10:
-        case V4L2_MBUS_FMT_SGBRG12_1X12:
+        case MEDIA_BUS_FMT_SGBRG10_1X10:
+        case MEDIA_BUS_FMT_SGBRG12_1X12:
                 ccdc_pattern = ccdc_sgbrg_pattern;
                 break;
         default:
@@ -1267,7 +1267,7 @@ static void ccdc_configure(struct isp_ccdc_device *ccdc)
         /* The CCDC outputs data in UYVY order by default. Swap bytes to get
          * YUYV.
          */
-        if (format->code == V4L2_MBUS_FMT_YUYV8_1X16)
+        if (format->code == MEDIA_BUS_FMT_YUYV8_1X16)
                 isp_reg_set(isp, OMAP3_ISP_IOMEM_CCDC, ISPCCDC_CFG,
                             ISPCCDC_CFG_BSWD);
         else
@@ -1967,7 +1967,7 @@ ccdc_try_format(struct isp_ccdc_device *ccdc, struct v4l2_subdev_fh *fh,
                 enum v4l2_subdev_format_whence which)
 {
         const struct isp_format_info *info;
-        enum v4l2_mbus_pixelcode pixelcode;
+        u32 pixelcode;
         unsigned int width = fmt->width;
         unsigned int height = fmt->height;
         struct v4l2_rect *crop;
@@ -1983,7 +1983,7 @@ ccdc_try_format(struct isp_ccdc_device *ccdc, struct v4l2_subdev_fh *fh,
 
                 /* If not found, use SGRBG10 as default */
                 if (i >= ARRAY_SIZE(ccdc_fmts))
-                        fmt->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                        fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
 
                 /* Clamp the input size. */
                 fmt->width = clamp_t(u32, width, 32, 4096);
@@ -2007,19 +2007,19 @@ ccdc_try_format(struct isp_ccdc_device *ccdc, struct v4l2_subdev_fh *fh,
                  * configured to pack bytes in BT.656, hiding the inaccuracy.
                  * In all cases bytes can be swapped.
                  */
-                if (fmt->code == V4L2_MBUS_FMT_YUYV8_2X8 ||
-                    fmt->code == V4L2_MBUS_FMT_UYVY8_2X8) {
+                if (fmt->code == MEDIA_BUS_FMT_YUYV8_2X8 ||
+                    fmt->code == MEDIA_BUS_FMT_UYVY8_2X8) {
                         /* Use the user requested format if YUV. */
-                        if (pixelcode == V4L2_MBUS_FMT_YUYV8_2X8 ||
-                            pixelcode == V4L2_MBUS_FMT_UYVY8_2X8 ||
-                            pixelcode == V4L2_MBUS_FMT_YUYV8_1X16 ||
-                            pixelcode == V4L2_MBUS_FMT_UYVY8_1X16)
+                        if (pixelcode == MEDIA_BUS_FMT_YUYV8_2X8 ||
+                            pixelcode == MEDIA_BUS_FMT_UYVY8_2X8 ||
+                            pixelcode == MEDIA_BUS_FMT_YUYV8_1X16 ||
+                            pixelcode == MEDIA_BUS_FMT_UYVY8_1X16)
                                 fmt->code = pixelcode;
 
-                        if (fmt->code == V4L2_MBUS_FMT_YUYV8_2X8)
-                                fmt->code = V4L2_MBUS_FMT_YUYV8_1X16;
-                        else if (fmt->code == V4L2_MBUS_FMT_UYVY8_2X8)
-                                fmt->code = V4L2_MBUS_FMT_UYVY8_1X16;
+                        if (fmt->code == MEDIA_BUS_FMT_YUYV8_2X8)
+                                fmt->code = MEDIA_BUS_FMT_YUYV8_1X16;
+                        else if (fmt->code == MEDIA_BUS_FMT_UYVY8_2X8)
+                                fmt->code = MEDIA_BUS_FMT_UYVY8_1X16;
                 }
 
                 /* Hardcode the output size to the crop rectangle size. */
@@ -2047,8 +2047,8 @@ ccdc_try_format(struct isp_ccdc_device *ccdc, struct v4l2_subdev_fh *fh,
                 fmt->code = info->truncated;
 
                 /* YUV formats are not supported by the video port. */
-                if (fmt->code == V4L2_MBUS_FMT_YUYV8_2X8 ||
-                    fmt->code == V4L2_MBUS_FMT_UYVY8_2X8)
+                if (fmt->code == MEDIA_BUS_FMT_YUYV8_2X8 ||
+                    fmt->code == MEDIA_BUS_FMT_UYVY8_2X8)
                         fmt->code = 0;
 
                 /* The number of lines that can be clocked out from the video
@@ -2083,7 +2083,7 @@ static void ccdc_try_crop(struct isp_ccdc_device *ccdc,
          * to keep the Bayer pattern.
          */
         info = omap3isp_video_format_info(sink->code);
-        if (info->flavor != V4L2_MBUS_FMT_Y8_1X8) {
+        if (info->flavor != MEDIA_BUS_FMT_Y8_1X8) {
                 crop->left &= ~1;
                 crop->top &= ~1;
         }
@@ -2103,7 +2103,7 @@ static void ccdc_try_crop(struct isp_ccdc_device *ccdc,
                                sink->height - crop->top);
 
         /* Odd width/height values don't make sense for Bayer formats. */
-        if (info->flavor != V4L2_MBUS_FMT_Y8_1X8) {
+        if (info->flavor != MEDIA_BUS_FMT_Y8_1X8) {
                 crop->width &= ~1;
                 crop->height &= ~1;
         }
@@ -2135,13 +2135,13 @@ static int ccdc_enum_mbus_code(struct v4l2_subdev *sd,
                 format = __ccdc_get_format(ccdc, fh, code->pad,
                                            V4L2_SUBDEV_FORMAT_TRY);
 
-                if (format->code == V4L2_MBUS_FMT_YUYV8_2X8 ||
-                    format->code == V4L2_MBUS_FMT_UYVY8_2X8) {
+                if (format->code == MEDIA_BUS_FMT_YUYV8_2X8 ||
+                    format->code == MEDIA_BUS_FMT_UYVY8_2X8) {
                         /* In YUV mode the CCDC can swap bytes. */
                         if (code->index == 0)
-                                code->code = V4L2_MBUS_FMT_YUYV8_1X16;
+                                code->code = MEDIA_BUS_FMT_YUYV8_1X16;
                         else if (code->index == 1)
-                                code->code = V4L2_MBUS_FMT_UYVY8_1X16;
+                                code->code = MEDIA_BUS_FMT_UYVY8_1X16;
                         else
                                 return -EINVAL;
                 } else {
@@ -2383,9 +2383,7 @@ static int ccdc_set_format(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
  * return true if the combination is possible
  * return false otherwise
  */
-static bool ccdc_is_shiftable(enum v4l2_mbus_pixelcode in,
-                              enum v4l2_mbus_pixelcode out,
-                              unsigned int additional_shift)
+static bool ccdc_is_shiftable(u32 in, u32 out, unsigned int additional_shift)
 {
         const struct isp_format_info *in_info, *out_info;
 
@@ -2452,7 +2450,7 @@ static int ccdc_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = CCDC_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        format.format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         format.format.width = 4096;
         format.format.height = 4096;
         ccdc_set_format(sd, fh, &format);
diff --git a/drivers/media/platform/omap3isp/ispccp2.c b/drivers/media/platform/omap3isp/ispccp2.c
index 9cb49b3c04bd..f4aedb37e41e 100644
--- a/drivers/media/platform/omap3isp/ispccp2.c
+++ b/drivers/media/platform/omap3isp/ispccp2.c
@@ -289,10 +289,10 @@ static void ccp2_lcx_config(struct isp_ccp2_device *ccp2,
         u32 val, format;
 
         switch (config->format) {
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
                 format = ISPCCP2_LCx_CTRL_FORMAT_RAW8_DPCM10_VP;
                 break;
-        case V4L2_MBUS_FMT_SGRBG10_1X10:
+        case MEDIA_BUS_FMT_SGRBG10_1X10:
         default:
                 format = ISPCCP2_LCx_CTRL_FORMAT_RAW10_VP;      /* RAW10+VP */
                 break;
@@ -438,7 +438,7 @@ static void ccp2_mem_configure(struct isp_ccp2_device *ccp2,
         u32 val, hwords;
 
         if (sink_pixcode != source_pixcode &&
-            sink_pixcode == V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8)
+            sink_pixcode == MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8)
                 dpcm_decompress = 1;
 
         ccp2_pwr_cfg(ccp2);
@@ -604,8 +604,8 @@ void omap3isp_ccp2_isr(struct isp_ccp2_device *ccp2)
  */
 
 static const unsigned int ccp2_fmts[] = {
-        V4L2_MBUS_FMT_SGRBG10_1X10,
-        V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SGRBG10_1X10,
+        MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
 };
 
 /*
@@ -643,8 +643,8 @@ static void ccp2_try_format(struct isp_ccp2_device *ccp2,
 
         switch (pad) {
         case CCP2_PAD_SINK:
-                if (fmt->code != V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8)
-                        fmt->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                if (fmt->code != MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8)
+                        fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
 
                 if (ccp2->input == CCP2_INPUT_SENSOR) {
                         fmt->width = clamp_t(u32, fmt->width,
@@ -671,7 +671,7 @@ static void ccp2_try_format(struct isp_ccp2_device *ccp2,
                  */
                 format = __ccp2_get_format(ccp2, fh, CCP2_PAD_SINK, which);
                 memcpy(fmt, format, sizeof(*fmt));
-                fmt->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
                 break;
         }
 
@@ -808,7 +808,7 @@ static int ccp2_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = CCP2_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        format.format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         format.format.width = 4096;
         format.format.height = 4096;
         ccp2_set_format(sd, fh, &format);
diff --git a/drivers/media/platform/omap3isp/ispcsi2.c b/drivers/media/platform/omap3isp/ispcsi2.c
index 6530b255f103..09c686d96ae8 100644
--- a/drivers/media/platform/omap3isp/ispcsi2.c
+++ b/drivers/media/platform/omap3isp/ispcsi2.c
@@ -78,15 +78,15 @@ static void csi2_recv_config(struct isp_device *isp,
 }
 
 static const unsigned int csi2_input_fmts[] = {
-        V4L2_MBUS_FMT_SGRBG10_1X10,
-        V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SRGGB10_1X10,
-        V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SBGGR10_1X10,
-        V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SGBRG10_1X10,
-        V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8,
-        V4L2_MBUS_FMT_YUYV8_2X8,
+        MEDIA_BUS_FMT_SGRBG10_1X10,
+        MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SRGGB10_1X10,
+        MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SBGGR10_1X10,
+        MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SGBRG10_1X10,
+        MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8,
+        MEDIA_BUS_FMT_YUYV8_2X8,
 };
 
 /* To set the format on the CSI2 requires a mapping function that takes
@@ -171,19 +171,19 @@ static u16 csi2_ctx_map_format(struct isp_csi2_device *csi2)
         int fmtidx, destidx, is_3630;
 
         switch (fmt->code) {
-        case V4L2_MBUS_FMT_SGRBG10_1X10:
-        case V4L2_MBUS_FMT_SRGGB10_1X10:
-        case V4L2_MBUS_FMT_SBGGR10_1X10:
-        case V4L2_MBUS_FMT_SGBRG10_1X10:
+        case MEDIA_BUS_FMT_SGRBG10_1X10:
+        case MEDIA_BUS_FMT_SRGGB10_1X10:
+        case MEDIA_BUS_FMT_SBGGR10_1X10:
+        case MEDIA_BUS_FMT_SGBRG10_1X10:
                 fmtidx = 0;
                 break;
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8:
                 fmtidx = 1;
                 break;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 fmtidx = 2;
                 break;
         default:
@@ -843,7 +843,7 @@ csi2_try_format(struct isp_csi2_device *csi2, struct v4l2_subdev_fh *fh,
                 unsigned int pad, struct v4l2_mbus_framefmt *fmt,
                 enum v4l2_subdev_format_whence which)
 {
-        enum v4l2_mbus_pixelcode pixelcode;
+        u32 pixelcode;
         struct v4l2_mbus_framefmt *format;
         const struct isp_format_info *info;
         unsigned int i;
@@ -858,7 +858,7 @@ csi2_try_format(struct isp_csi2_device *csi2, struct v4l2_subdev_fh *fh,
 
                 /* If not found, use SGRBG10 as default */
                 if (i >= ARRAY_SIZE(csi2_input_fmts))
-                        fmt->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                        fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
 
                 fmt->width = clamp_t(u32, fmt->width, 1, 8191);
                 fmt->height = clamp_t(u32, fmt->height, 1, 8191);
@@ -1029,7 +1029,7 @@ static int csi2_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = CSI2_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        format.format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         format.format.width = 4096;
         format.format.height = 4096;
         csi2_set_format(sd, fh, &format);
diff --git a/drivers/media/platform/omap3isp/isppreview.c b/drivers/media/platform/omap3isp/isppreview.c
index 605f57ef0a49..dd9eed45d853 100644
--- a/drivers/media/platform/omap3isp/isppreview.c
+++ b/drivers/media/platform/omap3isp/isppreview.c
@@ -964,18 +964,16 @@ static void preview_setup_hw(struct isp_prev_device *prev, u32 update,
  * @prev: pointer to previewer private structure
  * @pixelcode: pixel code
  */
-static void
-preview_config_ycpos(struct isp_prev_device *prev,
-                     enum v4l2_mbus_pixelcode pixelcode)
+static void preview_config_ycpos(struct isp_prev_device *prev, u32 pixelcode)
 {
         struct isp_device *isp = to_isp_device(prev);
         enum preview_ycpos_mode mode;
 
         switch (pixelcode) {
-        case V4L2_MBUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
                 mode = YCPOS_CrYCbY;
                 break;
-        case V4L2_MBUS_FMT_UYVY8_1X16:
+        case MEDIA_BUS_FMT_UYVY8_1X16:
                 mode = YCPOS_YCrYCb;
                 break;
         default:
@@ -1028,16 +1026,16 @@ static void preview_config_input_format(struct isp_prev_device *prev,
                             ISPPRV_PCR_WIDTH);
 
         switch (info->flavor) {
-        case V4L2_MBUS_FMT_SGRBG8_1X8:
+        case MEDIA_BUS_FMT_SGRBG8_1X8:
                 prev->params.cfa_order = 0;
                 break;
-        case V4L2_MBUS_FMT_SRGGB8_1X8:
+        case MEDIA_BUS_FMT_SRGGB8_1X8:
                 prev->params.cfa_order = 1;
                 break;
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
                 prev->params.cfa_order = 2;
                 break;
-        case V4L2_MBUS_FMT_SGBRG8_1X8:
+        case MEDIA_BUS_FMT_SGBRG8_1X8:
                 prev->params.cfa_order = 3;
                 break;
         default:
@@ -1078,8 +1076,8 @@ static void preview_config_input_size(struct isp_prev_device *prev, u32 active)
         unsigned int elv = prev->crop.top + prev->crop.height - 1;
         u32 features;
 
-        if (format->code != V4L2_MBUS_FMT_Y8_1X8 &&
-            format->code != V4L2_MBUS_FMT_Y10_1X10) {
+        if (format->code != MEDIA_BUS_FMT_Y8_1X8 &&
+            format->code != MEDIA_BUS_FMT_Y10_1X10) {
                 sph -= 2;
                 eph += 2;
                 slv -= 2;
@@ -1709,21 +1707,21 @@ __preview_get_crop(struct isp_prev_device *prev, struct v4l2_subdev_fh *fh,
 
 /* previewer format descriptions */
 static const unsigned int preview_input_fmts[] = {
-        V4L2_MBUS_FMT_Y8_1X8,
-        V4L2_MBUS_FMT_SGRBG8_1X8,
-        V4L2_MBUS_FMT_SRGGB8_1X8,
-        V4L2_MBUS_FMT_SBGGR8_1X8,
-        V4L2_MBUS_FMT_SGBRG8_1X8,
-        V4L2_MBUS_FMT_Y10_1X10,
-        V4L2_MBUS_FMT_SGRBG10_1X10,
-        V4L2_MBUS_FMT_SRGGB10_1X10,
-        V4L2_MBUS_FMT_SBGGR10_1X10,
-        V4L2_MBUS_FMT_SGBRG10_1X10,
+        MEDIA_BUS_FMT_Y8_1X8,
+        MEDIA_BUS_FMT_SGRBG8_1X8,
+        MEDIA_BUS_FMT_SRGGB8_1X8,
+        MEDIA_BUS_FMT_SBGGR8_1X8,
+        MEDIA_BUS_FMT_SGBRG8_1X8,
+        MEDIA_BUS_FMT_Y10_1X10,
+        MEDIA_BUS_FMT_SGRBG10_1X10,
+        MEDIA_BUS_FMT_SRGGB10_1X10,
+        MEDIA_BUS_FMT_SBGGR10_1X10,
+        MEDIA_BUS_FMT_SGBRG10_1X10,
 };
 
 static const unsigned int preview_output_fmts[] = {
-        V4L2_MBUS_FMT_UYVY8_1X16,
-        V4L2_MBUS_FMT_YUYV8_1X16,
+        MEDIA_BUS_FMT_UYVY8_1X16,
+        MEDIA_BUS_FMT_YUYV8_1X16,
 };
 
 /*
@@ -1742,7 +1740,7 @@ static void preview_try_format(struct isp_prev_device *prev,
                                struct v4l2_mbus_framefmt *fmt,
                                enum v4l2_subdev_format_whence which)
 {
-        enum v4l2_mbus_pixelcode pixelcode;
+        u32 pixelcode;
         struct v4l2_rect *crop;
         unsigned int i;
 
@@ -1774,7 +1772,7 @@ static void preview_try_format(struct isp_prev_device *prev,
 
                 /* If not found, use SGRBG10 as default */
                 if (i >= ARRAY_SIZE(preview_input_fmts))
-                        fmt->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                        fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
                 break;
 
         case PREV_PAD_SOURCE:
@@ -1782,13 +1780,13 @@ static void preview_try_format(struct isp_prev_device *prev,
                 *fmt = *__preview_get_format(prev, fh, PREV_PAD_SINK, which);
 
                 switch (pixelcode) {
-                case V4L2_MBUS_FMT_YUYV8_1X16:
-                case V4L2_MBUS_FMT_UYVY8_1X16:
+                case MEDIA_BUS_FMT_YUYV8_1X16:
+                case MEDIA_BUS_FMT_UYVY8_1X16:
                         fmt->code = pixelcode;
                         break;
 
                 default:
-                        fmt->code = V4L2_MBUS_FMT_YUYV8_1X16;
+                        fmt->code = MEDIA_BUS_FMT_YUYV8_1X16;
                         break;
                 }
 
@@ -1843,8 +1841,8 @@ static void preview_try_crop(struct isp_prev_device *prev,
          * and no columns in other modes. Increase the margins based on the sink
          * format.
          */
-        if (sink->code != V4L2_MBUS_FMT_Y8_1X8 &&
-            sink->code != V4L2_MBUS_FMT_Y10_1X10) {
+        if (sink->code != MEDIA_BUS_FMT_Y8_1X8 &&
+            sink->code != MEDIA_BUS_FMT_Y10_1X10) {
                 left += 2;
                 right -= 2;
                 top += 2;
@@ -2092,7 +2090,7 @@ static int preview_init_formats(struct v4l2_subdev *sd,
         memset(&format, 0, sizeof(format));
         format.pad = PREV_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        format.format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         format.format.width = 4096;
         format.format.height = 4096;
         preview_set_format(sd, fh, &format);
diff --git a/drivers/media/platform/omap3isp/ispresizer.c b/drivers/media/platform/omap3isp/ispresizer.c
index 05d1ace57451..2b9bc4839876 100644
--- a/drivers/media/platform/omap3isp/ispresizer.c
+++ b/drivers/media/platform/omap3isp/ispresizer.c
@@ -198,17 +198,16 @@ static void resizer_set_bilinear(struct isp_res_device *res,
  * @res: Device context.
  * @pixelcode: pixel code.
  */
-static void resizer_set_ycpos(struct isp_res_device *res,
-                              enum v4l2_mbus_pixelcode pixelcode)
+static void resizer_set_ycpos(struct isp_res_device *res, u32 pixelcode)
 {
         struct isp_device *isp = to_isp_device(res);
 
         switch (pixelcode) {
-        case V4L2_MBUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
                 isp_reg_set(isp, OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT,
                             ISPRSZ_CNT_YCPOS);
                 break;
-        case V4L2_MBUS_FMT_UYVY8_1X16:
+        case MEDIA_BUS_FMT_UYVY8_1X16:
                 isp_reg_clr(isp, OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT,
                             ISPRSZ_CNT_YCPOS);
                 break;
@@ -1348,8 +1347,8 @@ static int resizer_set_selection(struct v4l2_subdev *sd,
 
 /* resizer pixel formats */
 static const unsigned int resizer_formats[] = {
-        V4L2_MBUS_FMT_UYVY8_1X16,
-        V4L2_MBUS_FMT_YUYV8_1X16,
+        MEDIA_BUS_FMT_UYVY8_1X16,
+        MEDIA_BUS_FMT_YUYV8_1X16,
 };
 
 static unsigned int resizer_max_in_width(struct isp_res_device *res)
@@ -1385,9 +1384,9 @@ static void resizer_try_format(struct isp_res_device *res,
 
         switch (pad) {
         case RESZ_PAD_SINK:
-                if (fmt->code != V4L2_MBUS_FMT_YUYV8_1X16 &&
-                    fmt->code != V4L2_MBUS_FMT_UYVY8_1X16)
-                        fmt->code = V4L2_MBUS_FMT_YUYV8_1X16;
+                if (fmt->code != MEDIA_BUS_FMT_YUYV8_1X16 &&
+                    fmt->code != MEDIA_BUS_FMT_UYVY8_1X16)
+                        fmt->code = MEDIA_BUS_FMT_YUYV8_1X16;
 
                 fmt->width = clamp_t(u32, fmt->width, MIN_IN_WIDTH,
                                      resizer_max_in_width(res));
@@ -1571,7 +1570,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
         memset(&format, 0, sizeof(format));
         format.pad = RESZ_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_YUYV8_1X16;
+        format.format.code = MEDIA_BUS_FMT_YUYV8_1X16;
         format.format.width = 4096;
         format.format.height = 4096;
         resizer_set_format(sd, fh, &format);
diff --git a/drivers/media/platform/omap3isp/ispvideo.c b/drivers/media/platform/omap3isp/ispvideo.c
index bc38c88c7bd9..b463fe172d16 100644
--- a/drivers/media/platform/omap3isp/ispvideo.c
+++ b/drivers/media/platform/omap3isp/ispvideo.c
@@ -39,74 +39,74 @@
  * corresponding in-memory formats to the table below!!!
  */
 static struct isp_format_info formats[] = {
-        { V4L2_MBUS_FMT_Y8_1X8, V4L2_MBUS_FMT_Y8_1X8,
-          V4L2_MBUS_FMT_Y8_1X8, V4L2_MBUS_FMT_Y8_1X8,
+        { MEDIA_BUS_FMT_Y8_1X8, MEDIA_BUS_FMT_Y8_1X8,
+          MEDIA_BUS_FMT_Y8_1X8, MEDIA_BUS_FMT_Y8_1X8,
           V4L2_PIX_FMT_GREY, 8, 1, },
-        { V4L2_MBUS_FMT_Y10_1X10, V4L2_MBUS_FMT_Y10_1X10,
-          V4L2_MBUS_FMT_Y10_1X10, V4L2_MBUS_FMT_Y8_1X8,
+        { MEDIA_BUS_FMT_Y10_1X10, MEDIA_BUS_FMT_Y10_1X10,
+          MEDIA_BUS_FMT_Y10_1X10, MEDIA_BUS_FMT_Y8_1X8,
           V4L2_PIX_FMT_Y10, 10, 2, },
-        { V4L2_MBUS_FMT_Y12_1X12, V4L2_MBUS_FMT_Y10_1X10,
-          V4L2_MBUS_FMT_Y12_1X12, V4L2_MBUS_FMT_Y8_1X8,
+        { MEDIA_BUS_FMT_Y12_1X12, MEDIA_BUS_FMT_Y10_1X10,
+          MEDIA_BUS_FMT_Y12_1X12, MEDIA_BUS_FMT_Y8_1X8,
           V4L2_PIX_FMT_Y12, 12, 2, },
-        { V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_MBUS_FMT_SBGGR8_1X8,
-          V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_MBUS_FMT_SBGGR8_1X8,
+        { MEDIA_BUS_FMT_SBGGR8_1X8, MEDIA_BUS_FMT_SBGGR8_1X8,
+          MEDIA_BUS_FMT_SBGGR8_1X8, MEDIA_BUS_FMT_SBGGR8_1X8,
           V4L2_PIX_FMT_SBGGR8, 8, 1, },
-        { V4L2_MBUS_FMT_SGBRG8_1X8, V4L2_MBUS_FMT_SGBRG8_1X8,
-          V4L2_MBUS_FMT_SGBRG8_1X8, V4L2_MBUS_FMT_SGBRG8_1X8,
+        { MEDIA_BUS_FMT_SGBRG8_1X8, MEDIA_BUS_FMT_SGBRG8_1X8,
+          MEDIA_BUS_FMT_SGBRG8_1X8, MEDIA_BUS_FMT_SGBRG8_1X8,
           V4L2_PIX_FMT_SGBRG8, 8, 1, },
-        { V4L2_MBUS_FMT_SGRBG8_1X8, V4L2_MBUS_FMT_SGRBG8_1X8,
-          V4L2_MBUS_FMT_SGRBG8_1X8, V4L2_MBUS_FMT_SGRBG8_1X8,
+        { MEDIA_BUS_FMT_SGRBG8_1X8, MEDIA_BUS_FMT_SGRBG8_1X8,
+          MEDIA_BUS_FMT_SGRBG8_1X8, MEDIA_BUS_FMT_SGRBG8_1X8,
           V4L2_PIX_FMT_SGRBG8, 8, 1, },
-        { V4L2_MBUS_FMT_SRGGB8_1X8, V4L2_MBUS_FMT_SRGGB8_1X8,
-          V4L2_MBUS_FMT_SRGGB8_1X8, V4L2_MBUS_FMT_SRGGB8_1X8,
+        { MEDIA_BUS_FMT_SRGGB8_1X8, MEDIA_BUS_FMT_SRGGB8_1X8,
+          MEDIA_BUS_FMT_SRGGB8_1X8, MEDIA_BUS_FMT_SRGGB8_1X8,
           V4L2_PIX_FMT_SRGGB8, 8, 1, },
-        { V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8, V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8,
-          V4L2_MBUS_FMT_SBGGR10_1X10, 0,
+        { MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8,
+          MEDIA_BUS_FMT_SBGGR10_1X10, 0,
           V4L2_PIX_FMT_SBGGR10DPCM8, 8, 1, },
-        { V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8, V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8,
-          V4L2_MBUS_FMT_SGBRG10_1X10, 0,
+        { MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8,
+          MEDIA_BUS_FMT_SGBRG10_1X10, 0,
           V4L2_PIX_FMT_SGBRG10DPCM8, 8, 1, },
-        { V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8, V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
-          V4L2_MBUS_FMT_SGRBG10_1X10, 0,
+        { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
+          MEDIA_BUS_FMT_SGRBG10_1X10, 0,
           V4L2_PIX_FMT_SGRBG10DPCM8, 8, 1, },
-        { V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8, V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8,
-          V4L2_MBUS_FMT_SRGGB10_1X10, 0,
+        { MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8,
+          MEDIA_BUS_FMT_SRGGB10_1X10, 0,
           V4L2_PIX_FMT_SRGGB10DPCM8, 8, 1, },
-        { V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_MBUS_FMT_SBGGR10_1X10,
-          V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_MBUS_FMT_SBGGR8_1X8,
+        { MEDIA_BUS_FMT_SBGGR10_1X10, MEDIA_BUS_FMT_SBGGR10_1X10,
+          MEDIA_BUS_FMT_SBGGR10_1X10, MEDIA_BUS_FMT_SBGGR8_1X8,
           V4L2_PIX_FMT_SBGGR10, 10, 2, },
-        { V4L2_MBUS_FMT_SGBRG10_1X10, V4L2_MBUS_FMT_SGBRG10_1X10,
-          V4L2_MBUS_FMT_SGBRG10_1X10, V4L2_MBUS_FMT_SGBRG8_1X8,
+        { MEDIA_BUS_FMT_SGBRG10_1X10, MEDIA_BUS_FMT_SGBRG10_1X10,
+          MEDIA_BUS_FMT_SGBRG10_1X10, MEDIA_BUS_FMT_SGBRG8_1X8,
           V4L2_PIX_FMT_SGBRG10, 10, 2, },
-        { V4L2_MBUS_FMT_SGRBG10_1X10, V4L2_MBUS_FMT_SGRBG10_1X10,
-          V4L2_MBUS_FMT_SGRBG10_1X10, V4L2_MBUS_FMT_SGRBG8_1X8,
+        { MEDIA_BUS_FMT_SGRBG10_1X10, MEDIA_BUS_FMT_SGRBG10_1X10,
+          MEDIA_BUS_FMT_SGRBG10_1X10, MEDIA_BUS_FMT_SGRBG8_1X8,
           V4L2_PIX_FMT_SGRBG10, 10, 2, },
-        { V4L2_MBUS_FMT_SRGGB10_1X10, V4L2_MBUS_FMT_SRGGB10_1X10,
-          V4L2_MBUS_FMT_SRGGB10_1X10, V4L2_MBUS_FMT_SRGGB8_1X8,
+        { MEDIA_BUS_FMT_SRGGB10_1X10, MEDIA_BUS_FMT_SRGGB10_1X10,
+          MEDIA_BUS_FMT_SRGGB10_1X10, MEDIA_BUS_FMT_SRGGB8_1X8,
           V4L2_PIX_FMT_SRGGB10, 10, 2, },
-        { V4L2_MBUS_FMT_SBGGR12_1X12, V4L2_MBUS_FMT_SBGGR10_1X10,
-          V4L2_MBUS_FMT_SBGGR12_1X12, V4L2_MBUS_FMT_SBGGR8_1X8,
+        { MEDIA_BUS_FMT_SBGGR12_1X12, MEDIA_BUS_FMT_SBGGR10_1X10,
+          MEDIA_BUS_FMT_SBGGR12_1X12, MEDIA_BUS_FMT_SBGGR8_1X8,
           V4L2_PIX_FMT_SBGGR12, 12, 2, },
-        { V4L2_MBUS_FMT_SGBRG12_1X12, V4L2_MBUS_FMT_SGBRG10_1X10,
-          V4L2_MBUS_FMT_SGBRG12_1X12, V4L2_MBUS_FMT_SGBRG8_1X8,
+        { MEDIA_BUS_FMT_SGBRG12_1X12, MEDIA_BUS_FMT_SGBRG10_1X10,
+          MEDIA_BUS_FMT_SGBRG12_1X12, MEDIA_BUS_FMT_SGBRG8_1X8,
           V4L2_PIX_FMT_SGBRG12, 12, 2, },
-        { V4L2_MBUS_FMT_SGRBG12_1X12, V4L2_MBUS_FMT_SGRBG10_1X10,
-          V4L2_MBUS_FMT_SGRBG12_1X12, V4L2_MBUS_FMT_SGRBG8_1X8,
+        { MEDIA_BUS_FMT_SGRBG12_1X12, MEDIA_BUS_FMT_SGRBG10_1X10,
+          MEDIA_BUS_FMT_SGRBG12_1X12, MEDIA_BUS_FMT_SGRBG8_1X8,
           V4L2_PIX_FMT_SGRBG12, 12, 2, },
-        { V4L2_MBUS_FMT_SRGGB12_1X12, V4L2_MBUS_FMT_SRGGB10_1X10,
-          V4L2_MBUS_FMT_SRGGB12_1X12, V4L2_MBUS_FMT_SRGGB8_1X8,
+        { MEDIA_BUS_FMT_SRGGB12_1X12, MEDIA_BUS_FMT_SRGGB10_1X10,
+          MEDIA_BUS_FMT_SRGGB12_1X12, MEDIA_BUS_FMT_SRGGB8_1X8,
           V4L2_PIX_FMT_SRGGB12, 12, 2, },
-        { V4L2_MBUS_FMT_UYVY8_1X16, V4L2_MBUS_FMT_UYVY8_1X16,
-          V4L2_MBUS_FMT_UYVY8_1X16, 0,
+        { MEDIA_BUS_FMT_UYVY8_1X16, MEDIA_BUS_FMT_UYVY8_1X16,
+          MEDIA_BUS_FMT_UYVY8_1X16, 0,
           V4L2_PIX_FMT_UYVY, 16, 2, },
-        { V4L2_MBUS_FMT_YUYV8_1X16, V4L2_MBUS_FMT_YUYV8_1X16,
-          V4L2_MBUS_FMT_YUYV8_1X16, 0,
+        { MEDIA_BUS_FMT_YUYV8_1X16, MEDIA_BUS_FMT_YUYV8_1X16,
+          MEDIA_BUS_FMT_YUYV8_1X16, 0,
           V4L2_PIX_FMT_YUYV, 16, 2, },
-        { V4L2_MBUS_FMT_UYVY8_2X8, V4L2_MBUS_FMT_UYVY8_2X8,
-          V4L2_MBUS_FMT_UYVY8_2X8, 0,
+        { MEDIA_BUS_FMT_UYVY8_2X8, MEDIA_BUS_FMT_UYVY8_2X8,
+          MEDIA_BUS_FMT_UYVY8_2X8, 0,
           V4L2_PIX_FMT_UYVY, 8, 2, },
-        { V4L2_MBUS_FMT_YUYV8_2X8, V4L2_MBUS_FMT_YUYV8_2X8,
-          V4L2_MBUS_FMT_YUYV8_2X8, 0,
+        { MEDIA_BUS_FMT_YUYV8_2X8, MEDIA_BUS_FMT_YUYV8_2X8,
+          MEDIA_BUS_FMT_YUYV8_2X8, 0,
           V4L2_PIX_FMT_YUYV, 8, 2, },
         /* Empty entry to catch the unsupported pixel code (0) used by the CCDC
          * module and avoid NULL pointer dereferences.
@@ -114,8 +114,7 @@ static struct isp_format_info formats[] = {
         { 0, }
 };
 
-const struct isp_format_info *
-omap3isp_video_format_info(enum v4l2_mbus_pixelcode code)
+const struct isp_format_info *omap3isp_video_format_info(u32 code)
 {
         unsigned int i;
 
diff --git a/drivers/media/platform/omap3isp/ispvideo.h b/drivers/media/platform/omap3isp/ispvideo.h
index 0b7efedc3da9..4071dd7060ea 100644
--- a/drivers/media/platform/omap3isp/ispvideo.h
+++ b/drivers/media/platform/omap3isp/ispvideo.h
@@ -44,10 +44,10 @@ struct v4l2_pix_format;
  * @bpp: Bytes per pixel (when stored in memory)
  */
 struct isp_format_info {
-        enum v4l2_mbus_pixelcode code;
-        enum v4l2_mbus_pixelcode truncated;
-        enum v4l2_mbus_pixelcode uncompressed;
-        enum v4l2_mbus_pixelcode flavor;
+        u32 code;
+        u32 truncated;
+        u32 uncompressed;
+        u32 flavor;
         u32 pixelformat;
         unsigned int width;
         unsigned int bpp;
@@ -206,6 +206,6 @@ void omap3isp_video_resume(struct isp_video *video, int continuous);
 struct media_pad *omap3isp_video_remote_pad(struct isp_video *video);
 
 const struct isp_format_info *
-omap3isp_video_format_info(enum v4l2_mbus_pixelcode code);
+omap3isp_video_format_info(u32 code);
 
 #endif /* OMAP3_ISP_VIDEO_H */
diff --git a/drivers/media/platform/s3c-camif/camif-capture.c b/drivers/media/platform/s3c-camif/camif-capture.c
index 4f81b4c9d113..aa40c8269ab8 100644
--- a/drivers/media/platform/s3c-camif/camif-capture.c
+++ b/drivers/media/platform/s3c-camif/camif-capture.c
@@ -1218,11 +1218,11 @@ void s3c_camif_unregister_video_node(struct camif_dev *camif, int idx)
 }
 
 /* Media bus pixel formats supported at the camif input */
-static const enum v4l2_mbus_pixelcode camif_mbus_formats[] = {
-        V4L2_MBUS_FMT_YUYV8_2X8,
-        V4L2_MBUS_FMT_YVYU8_2X8,
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_VYUY8_2X8,
+static const u32 camif_mbus_formats[] = {
+        MEDIA_BUS_FMT_YUYV8_2X8,
+        MEDIA_BUS_FMT_YVYU8_2X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_VYUY8_2X8,
 };
 
 /*
diff --git a/drivers/media/platform/s3c-camif/camif-core.c b/drivers/media/platform/s3c-camif/camif-core.c
index b38574702fe9..3b09b5b6ad51 100644
--- a/drivers/media/platform/s3c-camif/camif-core.c
+++ b/drivers/media/platform/s3c-camif/camif-core.c
@@ -256,8 +256,7 @@ static void camif_unregister_sensor(struct camif_dev *camif)
         v4l2_device_unregister_subdev(sd);
         camif->sensor.sd = NULL;
         i2c_unregister_device(client);
-        if (adapter)
-                i2c_put_adapter(adapter);
+        i2c_put_adapter(adapter);
 }
 
 static int camif_create_media_links(struct camif_dev *camif)
diff --git a/drivers/media/platform/s3c-camif/camif-regs.c b/drivers/media/platform/s3c-camif/camif-regs.c
index 6e0c9988a191..812fb3a7c4e3 100644
--- a/drivers/media/platform/s3c-camif/camif-regs.c
+++ b/drivers/media/platform/s3c-camif/camif-regs.c
@@ -96,10 +96,10 @@ void camif_hw_set_effect(struct camif_dev *camif, unsigned int effect,
 }
 
 static const u32 src_pixfmt_map[8][2] = {
-        { V4L2_MBUS_FMT_YUYV8_2X8, CISRCFMT_ORDER422_YCBYCR },
-        { V4L2_MBUS_FMT_YVYU8_2X8, CISRCFMT_ORDER422_YCRYCB },
-        { V4L2_MBUS_FMT_UYVY8_2X8, CISRCFMT_ORDER422_CBYCRY },
-        { V4L2_MBUS_FMT_VYUY8_2X8, CISRCFMT_ORDER422_CRYCBY },
+        { MEDIA_BUS_FMT_YUYV8_2X8, CISRCFMT_ORDER422_YCBYCR },
+        { MEDIA_BUS_FMT_YVYU8_2X8, CISRCFMT_ORDER422_YCRYCB },
+        { MEDIA_BUS_FMT_UYVY8_2X8, CISRCFMT_ORDER422_CBYCRY },
+        { MEDIA_BUS_FMT_VYUY8_2X8, CISRCFMT_ORDER422_CRYCBY },
 };
 
 /* Set camera input pixel format and resolution */
diff --git a/drivers/media/platform/s5p-g2d/g2d.c b/drivers/media/platform/s5p-g2d/g2d.c
index d79e214ce8ce..51e4edc92d28 100644
--- a/drivers/media/platform/s5p-g2d/g2d.c
+++ b/drivers/media/platform/s5p-g2d/g2d.c
@@ -297,14 +297,8 @@ static int vidioc_querycap(struct file *file, void *priv,
         strncpy(cap->driver, G2D_NAME, sizeof(cap->driver) - 1);
         strncpy(cap->card, G2D_NAME, sizeof(cap->card) - 1);
         cap->bus_info[0] = 0;
-        cap->version = KERNEL_VERSION(1, 0, 0);
-        /*
-         * This is only a mem-to-mem video device. The capture and output
-         * device capability flags are left only for backward compatibility
-         * and are scheduled for removal.
-         */
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT |
-                            V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
+        cap->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/platform/s5p-jpeg/jpeg-core.c b/drivers/media/platform/s5p-jpeg/jpeg-core.c
index 6fcc7f072ace..3ecf0e06a4dd 100644
--- a/drivers/media/platform/s5p-jpeg/jpeg-core.c
+++ b/drivers/media/platform/s5p-jpeg/jpeg-core.c
@@ -1001,13 +1001,8 @@ static int s5p_jpeg_querycap(struct file *file, void *priv,
                         sizeof(cap->card));
         }
         cap->bus_info[0] = 0;
-        /*
-         * This is only a mem-to-mem video device. The capture and output
-         * device capability flags are left only for backward compatibility
-         * and are scheduled for removal.
-         */
-        cap->capabilities = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M |
-                            V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT;
+        cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
@@ -2632,7 +2627,7 @@ static int s5p_jpeg_remove(struct platform_device *pdev)
         return 0;
 }
 
-#if defined(CONFIG_PM_RUNTIME) || defined(CONFIG_PM_SLEEP)
+#ifdef CONFIG_PM
 static int s5p_jpeg_runtime_suspend(struct device *dev)
 {
         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
@@ -2682,7 +2677,7 @@ static int s5p_jpeg_runtime_resume(struct device *dev)
 
         return 0;
 }
-#endif /* CONFIG_PM_RUNTIME || CONFIG_PM_SLEEP */
+#endif /* CONFIG_PM */
 
 #ifdef CONFIG_PM_SLEEP
 static int s5p_jpeg_suspend(struct device *dev)
diff --git a/drivers/media/platform/s5p-mfc/regs-mfc-v6.h b/drivers/media/platform/s5p-mfc/regs-mfc-v6.h
index 51cb2dd0e13a..83e01f3466e9 100644
--- a/drivers/media/platform/s5p-mfc/regs-mfc-v6.h
+++ b/drivers/media/platform/s5p-mfc/regs-mfc-v6.h
@@ -71,6 +71,7 @@
 #define S5P_FIMV_R2H_CMD_ENC_BUFFER_FUL_RET_V6  16
 #define S5P_FIMV_R2H_CMD_ERR_RET_V6             32
 
+#define S5P_FIMV_MFC_BUS_RESET_CTRL            0x7110
 #define S5P_FIMV_FW_VERSION_V6                  0xf000
 
 #define S5P_FIMV_INSTANCE_ID_V6                 0xf008
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc.c b/drivers/media/platform/s5p-mfc/s5p_mfc.c
index 165bc86c5962..b80a576164f1 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc.c
@@ -159,6 +159,10 @@ static void s5p_mfc_watchdog_worker(struct work_struct *work)
         }
         clear_bit(0, &dev->hw_lock);
         spin_unlock_irqrestore(&dev->irqlock, flags);
+
+        /* De-init MFC */
+        s5p_mfc_deinit_hw(dev);
+
         /* Double check if there is at least one instance running.
          * If no instance is in memory than no firmware should be present */
         if (dev->num_inst > 0) {
@@ -220,11 +224,14 @@ static void s5p_mfc_handle_frame_copy_time(struct s5p_mfc_ctx *ctx)
         size_t dec_y_addr;
         unsigned int frame_type;
 
-        dec_y_addr = s5p_mfc_hw_call(dev->mfc_ops, get_dec_y_adr, dev);
+        /* Make sure we actually have a new frame before continuing. */
         frame_type = s5p_mfc_hw_call(dev->mfc_ops, get_dec_frame_type, dev);
+        if (frame_type == S5P_FIMV_DECODE_FRAME_SKIPPED)
+                return;
+        dec_y_addr = s5p_mfc_hw_call(dev->mfc_ops, get_dec_y_adr, dev);
 
         /* Copy timestamp / timecode from decoded src to dst and set
-           appropriate flags */
+           appropriate flags. */
         src_buf = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
         list_for_each_entry(dst_buf, &ctx->dst_queue, list) {
                 if (vb2_dma_contig_plane_dma_addr(dst_buf->b, 0) == dec_y_addr) {
@@ -250,6 +257,11 @@ static void s5p_mfc_handle_frame_copy_time(struct s5p_mfc_ctx *ctx)
                                 dst_buf->b->v4l2_buf.flags |=
                                                 V4L2_BUF_FLAG_BFRAME;
                                 break;
+                        default:
+                                /* Don't know how to handle
+                                   S5P_FIMV_DECODE_FRAME_OTHER_FRAME. */
+                                mfc_debug(2, "Unexpected frame type: %d\n",
+                                                frame_type);
                         }
                         break;
                 }
@@ -334,8 +346,7 @@ static void s5p_mfc_handle_frame(struct s5p_mfc_ctx *ctx,
                 ctx->state = MFCINST_RES_CHANGE_INIT;
                 s5p_mfc_hw_call_void(dev->mfc_ops, clear_int_flags, dev);
                 wake_up_ctx(ctx, reason, err);
-                if (test_and_clear_bit(0, &dev->hw_lock) == 0)
-                        BUG();
+                WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
                 s5p_mfc_clock_off();
                 s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
                 return;
@@ -407,8 +418,7 @@ leave_handle_frame:
                 clear_work_bit(ctx);
         s5p_mfc_hw_call_void(dev->mfc_ops, clear_int_flags, dev);
         wake_up_ctx(ctx, reason, err);
-        if (test_and_clear_bit(0, &dev->hw_lock) == 0)
-                BUG();
+        WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
         s5p_mfc_clock_off();
         /* if suspending, wake up device and do not try_run again*/
         if (test_bit(0, &dev->enter_suspend))
@@ -455,8 +465,7 @@ static void s5p_mfc_handle_error(struct s5p_mfc_dev *dev,
                         break;
                 }
         }
-        if (test_and_clear_bit(0, &dev->hw_lock) == 0)
-                BUG();
+        WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
         s5p_mfc_hw_call_void(dev->mfc_ops, clear_int_flags, dev);
         s5p_mfc_clock_off();
         wake_up_dev(dev, reason, err);
@@ -510,8 +519,7 @@ static void s5p_mfc_handle_seq_done(struct s5p_mfc_ctx *ctx,
         }
         s5p_mfc_hw_call_void(dev->mfc_ops, clear_int_flags, dev);
         clear_work_bit(ctx);
-        if (test_and_clear_bit(0, &dev->hw_lock) == 0)
-                BUG();
+        WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
         s5p_mfc_clock_off();
         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
         wake_up_ctx(ctx, reason, err);
@@ -549,16 +557,14 @@ static void s5p_mfc_handle_init_buffers(struct s5p_mfc_ctx *ctx,
                 } else {
                         ctx->dpb_flush_flag = 0;
                 }
-                if (test_and_clear_bit(0, &dev->hw_lock) == 0)
-                        BUG();
+                WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
 
                 s5p_mfc_clock_off();
 
                 wake_up(&ctx->queue);
                 s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
         } else {
-                if (test_and_clear_bit(0, &dev->hw_lock) == 0)
-                        BUG();
+                WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
 
                 s5p_mfc_clock_off();
 
@@ -635,8 +641,7 @@ static irqreturn_t s5p_mfc_irq(int irq, void *priv)
                                 mfc_err("post_frame_start() failed\n");
                         s5p_mfc_hw_call_void(dev->mfc_ops, clear_int_flags, dev);
                         wake_up_ctx(ctx, reason, err);
-                        if (test_and_clear_bit(0, &dev->hw_lock) == 0)
-                                BUG();
+                        WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
                         s5p_mfc_clock_off();
                         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
                 } else {
@@ -815,7 +820,7 @@ static int s5p_mfc_open(struct file *file)
                 ret = -ENOENT;
                 goto err_queue_init;
         }
-        q->mem_ops = (struct vb2_mem_ops *)&vb2_dma_contig_memops;
+        q->mem_ops = &vb2_dma_contig_memops;
         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
         ret = vb2_queue_init(q);
         if (ret) {
@@ -837,7 +842,7 @@ static int s5p_mfc_open(struct file *file)
                 ret = -ENOENT;
                 goto err_queue_init;
         }
-        q->mem_ops = (struct vb2_mem_ops *)&vb2_dma_contig_memops;
+        q->mem_ops = &vb2_dma_contig_memops;
         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
         ret = vb2_queue_init(q);
         if (ret) {
@@ -1284,11 +1289,17 @@ static int s5p_mfc_suspend(struct device *dev)
                         m_dev->int_cond, msecs_to_jiffies(MFC_INT_TIMEOUT));
                 if (ret == 0) {
                         mfc_err("Waiting for hardware to finish timed out\n");
+                        clear_bit(0, &m_dev->enter_suspend);
                         return -EIO;
                 }
         }
 
-        return s5p_mfc_sleep(m_dev);
+        ret = s5p_mfc_sleep(m_dev);
+        if (ret) {
+                clear_bit(0, &m_dev->enter_suspend);
+                clear_bit(0, &m_dev->hw_lock);
+        }
+        return ret;
 }
 
 static int s5p_mfc_resume(struct device *dev)
@@ -1302,7 +1313,7 @@ static int s5p_mfc_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int s5p_mfc_runtime_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_common.h b/drivers/media/platform/s5p-mfc/s5p_mfc_common.h
index 3e41ca1293ed..15f7663dd9f5 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_common.h
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_common.h
@@ -237,8 +237,6 @@ struct s5p_mfc_variant {
 
 /**
  * struct s5p_mfc_priv_buf - represents internal used buffer
- * @alloc:              allocation-specific context for each buffer
- *                      (videobuf2 allocator)
  * @ofs:                offset of each buffer, will be used for MFC
  * @virt:               kernel virtual address, only valid when the
  *                      buffer accessed by driver
@@ -246,7 +244,6 @@ struct s5p_mfc_variant {
  * @size:               size of the buffer
  */
 struct s5p_mfc_priv_buf {
-        void            *alloc;
         unsigned long   ofs;
         void            *virt;
         dma_addr_t      dma;
@@ -340,6 +337,7 @@ struct s5p_mfc_dev {
         struct s5p_mfc_hw_cmds *mfc_cmds;
         const struct s5p_mfc_regs *mfc_regs;
         enum s5p_mfc_fw_ver fw_ver;
+        bool risc_on; /* indicates if RISC is on or off */
 };
 
 /**
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.c b/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.c
index 0c885a8a0e9f..40d8a03a141d 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.c
@@ -129,6 +129,25 @@ int s5p_mfc_release_firmware(struct s5p_mfc_dev *dev)
         return 0;
 }
 
+static int s5p_mfc_bus_reset(struct s5p_mfc_dev *dev)
+{
+        unsigned int status;
+        unsigned long timeout;
+
+        /* Reset */
+        mfc_write(dev, 0x1, S5P_FIMV_MFC_BUS_RESET_CTRL);
+        timeout = jiffies + msecs_to_jiffies(MFC_BW_TIMEOUT);
+        /* Check bus status */
+        do {
+                if (time_after(jiffies, timeout)) {
+                        mfc_err("Timeout while resetting MFC.\n");
+                        return -EIO;
+                }
+                status = mfc_read(dev, S5P_FIMV_MFC_BUS_RESET_CTRL);
+        } while ((status & 0x2) == 0);
+        return 0;
+}
+
 /* Reset the device */
 int s5p_mfc_reset(struct s5p_mfc_dev *dev)
 {
@@ -139,12 +158,6 @@ int s5p_mfc_reset(struct s5p_mfc_dev *dev)
         mfc_debug_enter();
 
         if (IS_MFCV6_PLUS(dev)) {
-                /* Reset IP */
-                /*  except RISC, reset */
-                mfc_write(dev, 0xFEE, S5P_FIMV_MFC_RESET_V6);
-                /*  reset release */
-                mfc_write(dev, 0x0, S5P_FIMV_MFC_RESET_V6);
-
                 /* Zero Initialization of MFC registers */
                 mfc_write(dev, 0, S5P_FIMV_RISC2HOST_CMD_V6);
                 mfc_write(dev, 0, S5P_FIMV_HOST2RISC_CMD_V6);
@@ -153,8 +166,17 @@ int s5p_mfc_reset(struct s5p_mfc_dev *dev)
                 for (i = 0; i < S5P_FIMV_REG_CLEAR_COUNT_V6; i++)
                         mfc_write(dev, 0, S5P_FIMV_REG_CLEAR_BEGIN_V6 + (i*4));
 
-                /* Reset */
-                mfc_write(dev, 0, S5P_FIMV_RISC_ON_V6);
+                /* check bus reset control before reset */
+                if (dev->risc_on)
+                        if (s5p_mfc_bus_reset(dev))
+                                return -EIO;
+                /* Reset
+                 * set RISC_ON to 0 during power_on & wake_up.
+                 * V6 needs RISC_ON set to 0 during reset also.
+                 */
+                if ((!dev->risc_on) || (!IS_MFCV7_PLUS(dev)))
+                        mfc_write(dev, 0, S5P_FIMV_RISC_ON_V6);
+
                 mfc_write(dev, 0x1FFF, S5P_FIMV_MFC_RESET_V6);
                 mfc_write(dev, 0, S5P_FIMV_MFC_RESET_V6);
         } else {
@@ -226,6 +248,7 @@ int s5p_mfc_init_hw(struct s5p_mfc_dev *dev)
         /* 0. MFC reset */
         mfc_debug(2, "MFC reset..\n");
         s5p_mfc_clock_on();
+        dev->risc_on = 0;
         ret = s5p_mfc_reset(dev);
         if (ret) {
                 mfc_err("Failed to reset MFC - timeout\n");
@@ -238,8 +261,10 @@ int s5p_mfc_init_hw(struct s5p_mfc_dev *dev)
         s5p_mfc_clear_cmds(dev);
         /* 3. Release reset signal to the RISC */
         s5p_mfc_clean_dev_int_flags(dev);
-        if (IS_MFCV6_PLUS(dev))
+        if (IS_MFCV6_PLUS(dev)) {
+                dev->risc_on = 1;
                 mfc_write(dev, 0x1, S5P_FIMV_RISC_ON_V6);
+        }
         else
                 mfc_write(dev, 0x3ff, S5P_FIMV_SW_RESET);
         mfc_debug(2, "Will now wait for completion of firmware transfer\n");
@@ -328,6 +353,58 @@ int s5p_mfc_sleep(struct s5p_mfc_dev *dev)
         return ret;
 }
 
+static int s5p_mfc_v8_wait_wakeup(struct s5p_mfc_dev *dev)
+{
+        int ret;
+
+        /* Release reset signal to the RISC */
+        dev->risc_on = 1;
+        mfc_write(dev, 0x1, S5P_FIMV_RISC_ON_V6);
+
+        if (s5p_mfc_wait_for_done_dev(dev, S5P_MFC_R2H_CMD_FW_STATUS_RET)) {
+                mfc_err("Failed to reset MFCV8\n");
+                return -EIO;
+        }
+        mfc_debug(2, "Write command to wakeup MFCV8\n");
+        ret = s5p_mfc_hw_call(dev->mfc_cmds, wakeup_cmd, dev);
+        if (ret) {
+                mfc_err("Failed to send command to MFCV8 - timeout\n");
+                return ret;
+        }
+
+        if (s5p_mfc_wait_for_done_dev(dev, S5P_MFC_R2H_CMD_WAKEUP_RET)) {
+                mfc_err("Failed to wakeup MFC\n");
+                return -EIO;
+        }
+        return ret;
+}
+
+static int s5p_mfc_wait_wakeup(struct s5p_mfc_dev *dev)
+{
+        int ret;
+
+        /* Send MFC wakeup command */
+        ret = s5p_mfc_hw_call(dev->mfc_cmds, wakeup_cmd, dev);
+        if (ret) {
+                mfc_err("Failed to send command to MFC - timeout\n");
+                return ret;
+        }
+
+        /* Release reset signal to the RISC */
+        if (IS_MFCV6_PLUS(dev)) {
+                dev->risc_on = 1;
+                mfc_write(dev, 0x1, S5P_FIMV_RISC_ON_V6);
+        } else {
+                mfc_write(dev, 0x3ff, S5P_FIMV_SW_RESET);
+        }
+
+        if (s5p_mfc_wait_for_done_dev(dev, S5P_MFC_R2H_CMD_WAKEUP_RET)) {
+                mfc_err("Failed to wakeup MFC\n");
+                return -EIO;
+        }
+        return ret;
+}
+
 int s5p_mfc_wakeup(struct s5p_mfc_dev *dev)
 {
         int ret;
@@ -336,9 +413,11 @@ int s5p_mfc_wakeup(struct s5p_mfc_dev *dev)
         /* 0. MFC reset */
         mfc_debug(2, "MFC reset..\n");
         s5p_mfc_clock_on();
+        dev->risc_on = 0;
         ret = s5p_mfc_reset(dev);
         if (ret) {
                 mfc_err("Failed to reset MFC - timeout\n");
+                s5p_mfc_clock_off();
                 return ret;
         }
         mfc_debug(2, "Done MFC reset..\n");
@@ -347,23 +426,16 @@ int s5p_mfc_wakeup(struct s5p_mfc_dev *dev)
         /* 2. Initialize registers of channel I/F */
         s5p_mfc_clear_cmds(dev);
         s5p_mfc_clean_dev_int_flags(dev);
-        /* 3. Initialize firmware */
-        ret = s5p_mfc_hw_call(dev->mfc_cmds, wakeup_cmd, dev);
-        if (ret) {
-                mfc_err("Failed to send command to MFC - timeout\n");
-                return ret;
-        }
-        /* 4. Release reset signal to the RISC */
-        if (IS_MFCV6_PLUS(dev))
-                mfc_write(dev, 0x1, S5P_FIMV_RISC_ON_V6);
+        /* 3. Send MFC wakeup command and wait for completion*/
+        if (IS_MFCV8(dev))
+                ret = s5p_mfc_v8_wait_wakeup(dev);
         else
-                mfc_write(dev, 0x3ff, S5P_FIMV_SW_RESET);
-        mfc_debug(2, "Ok, now will write a command to wakeup the system\n");
-        if (s5p_mfc_wait_for_done_dev(dev, S5P_MFC_R2H_CMD_WAKEUP_RET)) {
-                mfc_err("Failed to load firmware\n");
-                return -EIO;
-        }
+                ret = s5p_mfc_wait_wakeup(dev);
+
         s5p_mfc_clock_off();
+        if (ret)
+                return ret;
+
         dev->int_cond = 0;
         if (dev->int_err != 0 || dev->int_type !=
                                                 S5P_MFC_R2H_CMD_WAKEUP_RET) {
@@ -396,7 +468,6 @@ int s5p_mfc_open_mfc_inst(struct s5p_mfc_dev *dev, struct s5p_mfc_ctx *ctx)
         }
 
         set_work_bit_irqsave(ctx);
-        s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
         if (s5p_mfc_wait_for_done_ctx(ctx,
                 S5P_MFC_R2H_CMD_OPEN_INSTANCE_RET, 0)) {
@@ -422,7 +493,6 @@ void s5p_mfc_close_mfc_inst(struct s5p_mfc_dev *dev, struct s5p_mfc_ctx *ctx)
 {
         ctx->state = MFCINST_RETURN_INST;
         set_work_bit_irqsave(ctx);
-        s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
         /* Wait until instance is returned or timeout occurred */
         if (s5p_mfc_wait_for_done_ctx(ctx,
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c b/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c
index a98fe023deaf..c6c3452ccca1 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c
@@ -269,15 +269,13 @@ static int vidioc_querycap(struct file *file, void *priv,
         strncpy(cap->driver, dev->plat_dev->name, sizeof(cap->driver) - 1);
         strncpy(cap->card, dev->plat_dev->name, sizeof(cap->card) - 1);
         cap->bus_info[0] = 0;
-        cap->version = KERNEL_VERSION(1, 0, 0);
         /*
          * This is only a mem-to-mem video device. The capture and output
          * device capability flags are left only for backward compatibility
          * and are scheduled for removal.
          */
-        cap->capabilities = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING |
-                            V4L2_CAP_VIDEO_CAPTURE_MPLANE |
-                            V4L2_CAP_VIDEO_OUTPUT_MPLANE;
+        cap->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
@@ -334,7 +332,6 @@ static int vidioc_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
                                                 MFCINST_RES_CHANGE_END)) {
                 /* If the MFC is parsing the header,
                  * so wait until it is finished */
-                s5p_mfc_clean_ctx_int_flags(ctx);
                 s5p_mfc_wait_for_done_ctx(ctx, S5P_MFC_R2H_CMD_SEQ_DONE_RET,
                                                                         0);
         }
@@ -740,12 +737,12 @@ static int s5p_mfc_dec_g_v_ctrl(struct v4l2_ctrl *ctrl)
                     ctx->state < MFCINST_ABORT) {
                         ctrl->val = ctx->pb_count;
                         break;
-                } else if (ctx->state != MFCINST_INIT) {
+                } else if (ctx->state != MFCINST_INIT &&
+                                ctx->state != MFCINST_RES_CHANGE_END) {
                         v4l2_err(&dev->v4l2_dev, "Decoding not initialised\n");
                         return -EINVAL;
                 }
                 /* Should wait for the header to be parsed */
-                s5p_mfc_clean_ctx_int_flags(ctx);
                 s5p_mfc_wait_for_done_ctx(ctx,
                                 S5P_MFC_R2H_CMD_SEQ_DONE_RET, 0);
                 if (ctx->state >= MFCINST_HEAD_PARSED &&
@@ -1057,7 +1054,6 @@ static void s5p_mfc_stop_streaming(struct vb2_queue *q)
                 if (IS_MFCV6_PLUS(dev) && (ctx->state == MFCINST_RUNNING)) {
                         ctx->state = MFCINST_FLUSH;
                         set_work_bit_irqsave(ctx);
-                        s5p_mfc_clean_ctx_int_flags(ctx);
                         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
                         if (s5p_mfc_wait_for_done_ctx(ctx,
                                 S5P_MFC_R2H_CMD_DPB_FLUSH_RET, 0))
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c b/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c
index a904a1c7bb21..bd64f1dcbdb5 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c
@@ -32,7 +32,7 @@
 #include "s5p_mfc_intr.h"
 #include "s5p_mfc_opr.h"
 
-#define DEF_SRC_FMT_ENC V4L2_PIX_FMT_NV12MT
+#define DEF_SRC_FMT_ENC V4L2_PIX_FMT_NV12M
 #define DEF_DST_FMT_ENC V4L2_PIX_FMT_H264
 
 static struct s5p_mfc_fmt formats[] = {
@@ -67,8 +67,7 @@ static struct s5p_mfc_fmt formats[] = {
                 .codec_mode     = S5P_MFC_CODEC_NONE,
                 .type           = MFC_FMT_RAW,
                 .num_planes     = 2,
-                .versions       = MFC_V5_BIT | MFC_V6_BIT | MFC_V7_BIT |
-                                                                MFC_V8_BIT,
+                .versions       = MFC_V6_BIT | MFC_V7_BIT | MFC_V8_BIT,
         },
         {
                 .name           = "H264 Encoded Stream",
@@ -690,6 +689,16 @@ static struct mfc_control controls[] = {
                 .step = 1,
                 .default_value = 0,
         },
+        {
+                .id = V4L2_CID_MIN_BUFFERS_FOR_OUTPUT,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Minimum number of output bufs",
+                .minimum = 1,
+                .maximum = 32,
+                .step = 1,
+                .default_value = 1,
+                .is_volatile = 1,
+        },
 };
 
 #define NUM_CTRLS ARRAY_SIZE(controls)
@@ -938,15 +947,13 @@ static int vidioc_querycap(struct file *file, void *priv,
         strncpy(cap->driver, dev->plat_dev->name, sizeof(cap->driver) - 1);
         strncpy(cap->card, dev->plat_dev->name, sizeof(cap->card) - 1);
         cap->bus_info[0] = 0;
-        cap->version = KERNEL_VERSION(1, 0, 0);
         /*
          * This is only a mem-to-mem video device. The capture and output
          * device capability flags are left only for backward compatibility
          * and are scheduled for removal.
          */
-        cap->capabilities = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING |
-                            V4L2_CAP_VIDEO_CAPTURE_MPLANE |
-                            V4L2_CAP_VIDEO_OUTPUT_MPLANE;
+        cap->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
@@ -1137,6 +1144,11 @@ static int vidioc_reqbufs(struct file *file, void *priv,
                 (reqbufs->memory != V4L2_MEMORY_USERPTR))
                 return -EINVAL;
         if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
+                if (reqbufs->count == 0) {
+                        ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
+                        ctx->capture_state = QUEUE_FREE;
+                        return ret;
+                }
                 if (ctx->capture_state != QUEUE_FREE) {
                         mfc_err("invalid capture state: %d\n",
                                                         ctx->capture_state);
@@ -1158,6 +1170,14 @@ static int vidioc_reqbufs(struct file *file, void *priv,
                         return -ENOMEM;
                 }
         } else if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
+                if (reqbufs->count == 0) {
+                        mfc_debug(2, "Freeing buffers\n");
+                        ret = vb2_reqbufs(&ctx->vq_src, reqbufs);
+                        s5p_mfc_hw_call_void(dev->mfc_ops, release_codec_buffers,
+                                        ctx);
+                        ctx->output_state = QUEUE_FREE;
+                        return ret;
+                }
                 if (ctx->output_state != QUEUE_FREE) {
                         mfc_err("invalid output state: %d\n",
                                                         ctx->output_state);
@@ -1624,8 +1644,39 @@ static int s5p_mfc_enc_s_ctrl(struct v4l2_ctrl *ctrl)
         return ret;
 }
 
+static int s5p_mfc_enc_g_v_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
+        struct s5p_mfc_dev *dev = ctx->dev;
+
+        switch (ctrl->id) {
+        case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
+                if (ctx->state >= MFCINST_HEAD_PARSED &&
+                    ctx->state < MFCINST_ABORT) {
+                        ctrl->val = ctx->pb_count;
+                        break;
+                } else if (ctx->state != MFCINST_INIT) {
+                        v4l2_err(&dev->v4l2_dev, "Encoding not initialised\n");
+                        return -EINVAL;
+                }
+                /* Should wait for the header to be produced */
+                s5p_mfc_wait_for_done_ctx(ctx,
+                                S5P_MFC_R2H_CMD_SEQ_DONE_RET, 0);
+                if (ctx->state >= MFCINST_HEAD_PARSED &&
+                    ctx->state < MFCINST_ABORT) {
+                        ctrl->val = ctx->pb_count;
+                } else {
+                        v4l2_err(&dev->v4l2_dev, "Encoding not initialised\n");
+                        return -EINVAL;
+                }
+                break;
+        }
+        return 0;
+}
+
 static const struct v4l2_ctrl_ops s5p_mfc_enc_ctrl_ops = {
         .s_ctrl = s5p_mfc_enc_s_ctrl,
+        .g_volatile_ctrl = s5p_mfc_enc_g_v_ctrl,
 };
 
 static int vidioc_s_parm(struct file *file, void *priv,
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v5.c b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v5.c
index 7cf07963187d..0c4fcf2dfd09 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v5.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v5.c
@@ -1178,7 +1178,6 @@ static void s5p_mfc_run_res_change(struct s5p_mfc_ctx *ctx)
 
         s5p_mfc_set_dec_stream_buffer_v5(ctx, 0, 0, 0);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_decode_one_frame_v5(ctx, MFC_DEC_RES_CHANGE);
 }
 
@@ -1192,7 +1191,6 @@ static int s5p_mfc_run_dec_frame(struct s5p_mfc_ctx *ctx, int last_frame)
                 last_frame = MFC_DEC_LAST_FRAME;
                 s5p_mfc_set_dec_stream_buffer_v5(ctx, 0, 0, 0);
                 dev->curr_ctx = ctx->num;
-                s5p_mfc_clean_ctx_int_flags(ctx);
                 s5p_mfc_decode_one_frame_v5(ctx, last_frame);
                 return 0;
         }
@@ -1212,7 +1210,6 @@ static int s5p_mfc_run_dec_frame(struct s5p_mfc_ctx *ctx, int last_frame)
                 ctx->consumed_stream, temp_vb->b->v4l2_planes[0].bytesused);
         spin_unlock_irqrestore(&dev->irqlock, flags);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         if (temp_vb->b->v4l2_planes[0].bytesused == 0) {
                 last_frame = MFC_DEC_LAST_FRAME;
                 mfc_debug(2, "Setting ctx->state to FINISHING\n");
@@ -1273,7 +1270,6 @@ static int s5p_mfc_run_enc_frame(struct s5p_mfc_ctx *ctx)
         s5p_mfc_set_enc_stream_buffer_v5(ctx, dst_addr, dst_size);
         spin_unlock_irqrestore(&dev->irqlock, flags);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         mfc_debug(2, "encoding buffer with index=%d state=%d\n",
                   src_mb ? src_mb->b->v4l2_buf.index : -1, ctx->state);
         s5p_mfc_encode_one_frame_v5(ctx);
@@ -1297,7 +1293,6 @@ static void s5p_mfc_run_init_dec(struct s5p_mfc_ctx *ctx)
                                 0, temp_vb->b->v4l2_planes[0].bytesused);
         spin_unlock_irqrestore(&dev->irqlock, flags);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_init_decode_v5(ctx);
 }
 
@@ -1317,7 +1312,6 @@ static void s5p_mfc_run_init_enc(struct s5p_mfc_ctx *ctx)
         s5p_mfc_set_enc_stream_buffer_v5(ctx, dst_addr, dst_size);
         spin_unlock_irqrestore(&dev->irqlock, flags);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_init_encode_v5(ctx);
 }
 
@@ -1352,7 +1346,6 @@ static int s5p_mfc_run_init_dec_buffers(struct s5p_mfc_ctx *ctx)
                                 0, temp_vb->b->v4l2_planes[0].bytesused);
         spin_unlock_irqrestore(&dev->irqlock, flags);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         ret = s5p_mfc_set_dec_frame_buffer_v5(ctx);
         if (ret) {
                 mfc_err("Failed to alloc frame mem\n");
@@ -1396,6 +1389,8 @@ static void s5p_mfc_try_run_v5(struct s5p_mfc_dev *dev)
          * Now obtaining frames from MFC buffer
          */
         s5p_mfc_clock_on();
+        s5p_mfc_clean_ctx_int_flags(ctx);
+
         if (ctx->type == MFCINST_DECODER) {
                 s5p_mfc_set_dec_desc_buffer(ctx);
                 switch (ctx->state) {
@@ -1406,12 +1401,10 @@ static void s5p_mfc_try_run_v5(struct s5p_mfc_dev *dev)
                         ret = s5p_mfc_run_dec_frame(ctx, MFC_DEC_FRAME);
                         break;
                 case MFCINST_INIT:
-                        s5p_mfc_clean_ctx_int_flags(ctx);
                         ret = s5p_mfc_hw_call(dev->mfc_cmds, open_inst_cmd,
                                         ctx);
                         break;
                 case MFCINST_RETURN_INST:
-                        s5p_mfc_clean_ctx_int_flags(ctx);
                         ret = s5p_mfc_hw_call(dev->mfc_cmds, close_inst_cmd,
                                         ctx);
                         break;
@@ -1444,12 +1437,10 @@ static void s5p_mfc_try_run_v5(struct s5p_mfc_dev *dev)
                         ret = s5p_mfc_run_enc_frame(ctx);
                         break;
                 case MFCINST_INIT:
-                        s5p_mfc_clean_ctx_int_flags(ctx);
                         ret = s5p_mfc_hw_call(dev->mfc_cmds, open_inst_cmd,
                                         ctx);
                         break;
                 case MFCINST_RETURN_INST:
-                        s5p_mfc_clean_ctx_int_flags(ctx);
                         ret = s5p_mfc_hw_call(dev->mfc_cmds, close_inst_cmd,
                                         ctx);
                         break;
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
index 8798b14bacce..9aea179943ce 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
@@ -1394,7 +1394,6 @@ static inline void s5p_mfc_set_flush(struct s5p_mfc_ctx *ctx, int flush)
 
         if (flush) {
                 dev->curr_ctx = ctx->num;
-                s5p_mfc_clean_ctx_int_flags(ctx);
                 writel(ctx->inst_no, mfc_regs->instance_id);
                 s5p_mfc_hw_call_void(dev->mfc_cmds, cmd_host2risc, dev,
                                 S5P_FIMV_H2R_CMD_FLUSH_V6, NULL);
@@ -1532,27 +1531,10 @@ static inline int s5p_mfc_get_new_ctx(struct s5p_mfc_dev *dev)
 static inline void s5p_mfc_run_dec_last_frames(struct s5p_mfc_ctx *ctx)
 {
         struct s5p_mfc_dev *dev = ctx->dev;
-        struct s5p_mfc_buf *temp_vb;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev->irqlock, flags);
-
-        /* Frames are being decoded */
-        if (list_empty(&ctx->src_queue)) {
-                mfc_debug(2, "No src buffers.\n");
-                spin_unlock_irqrestore(&dev->irqlock, flags);
-                return;
-        }
-        /* Get the next source buffer */
-        temp_vb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
-        temp_vb->flags |= MFC_BUF_FLAG_USED;
-        s5p_mfc_set_dec_stream_buffer_v6(ctx,
-                        vb2_dma_contig_plane_dma_addr(temp_vb->b, 0), 0, 0);
-        spin_unlock_irqrestore(&dev->irqlock, flags);
 
+        s5p_mfc_set_dec_stream_buffer_v6(ctx, 0, 0, 0);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
-        s5p_mfc_decode_one_frame_v6(ctx, 1);
+        s5p_mfc_decode_one_frame_v6(ctx, MFC_DEC_LAST_FRAME);
 }
 
 static inline int s5p_mfc_run_dec_frame(struct s5p_mfc_ctx *ctx)
@@ -1588,7 +1570,6 @@ static inline int s5p_mfc_run_dec_frame(struct s5p_mfc_ctx *ctx)
         spin_unlock_irqrestore(&dev->irqlock, flags);
 
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         if (temp_vb->b->v4l2_planes[0].bytesused == 0) {
                 last_frame = 1;
                 mfc_debug(2, "Setting ctx->state to FINISHING\n");
@@ -1645,7 +1626,6 @@ static inline int s5p_mfc_run_enc_frame(struct s5p_mfc_ctx *ctx)
         spin_unlock_irqrestore(&dev->irqlock, flags);
 
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_encode_one_frame_v6(ctx);
 
         return 0;
@@ -1667,7 +1647,6 @@ static inline void s5p_mfc_run_init_dec(struct s5p_mfc_ctx *ctx)
                         temp_vb->b->v4l2_planes[0].bytesused);
         spin_unlock_irqrestore(&dev->irqlock, flags);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_init_decode_v6(ctx);
 }
 
@@ -1687,7 +1666,6 @@ static inline void s5p_mfc_run_init_enc(struct s5p_mfc_ctx *ctx)
         s5p_mfc_set_enc_stream_buffer_v6(ctx, dst_addr, dst_size);
         spin_unlock_irqrestore(&dev->irqlock, flags);
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_init_encode_v6(ctx);
 }
 
@@ -1707,7 +1685,6 @@ static inline int s5p_mfc_run_init_dec_buffers(struct s5p_mfc_ctx *ctx)
         }
 
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         ret = s5p_mfc_set_dec_frame_buffer_v6(ctx);
         if (ret) {
                 mfc_err("Failed to alloc frame mem.\n");
@@ -1722,7 +1699,6 @@ static inline int s5p_mfc_run_init_enc_buffers(struct s5p_mfc_ctx *ctx)
         int ret;
 
         dev->curr_ctx = ctx->num;
-        s5p_mfc_clean_ctx_int_flags(ctx);
         ret = s5p_mfc_set_enc_ref_buffer_v6(ctx);
         if (ret) {
                 mfc_err("Failed to alloc frame mem.\n");
@@ -1771,6 +1747,8 @@ static void s5p_mfc_try_run_v6(struct s5p_mfc_dev *dev)
          * Now obtaining frames from MFC buffer */
 
         s5p_mfc_clock_on();
+        s5p_mfc_clean_ctx_int_flags(ctx);
+
         if (ctx->type == MFCINST_DECODER) {
                 switch (ctx->state) {
                 case MFCINST_FINISHING:
@@ -1780,12 +1758,10 @@ static void s5p_mfc_try_run_v6(struct s5p_mfc_dev *dev)
                         ret = s5p_mfc_run_dec_frame(ctx);
                         break;
                 case MFCINST_INIT:
-                        s5p_mfc_clean_ctx_int_flags(ctx);
                         ret = s5p_mfc_hw_call(dev->mfc_cmds, open_inst_cmd,
                                         ctx);
                         break;
                 case MFCINST_RETURN_INST:
-                        s5p_mfc_clean_ctx_int_flags(ctx);
                         ret = s5p_mfc_hw_call(dev->mfc_cmds, close_inst_cmd,
                                         ctx);
                         break;
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_pm.c b/drivers/media/platform/s5p-mfc/s5p_mfc_pm.c
index 826c48945bf5..5f97a3398c11 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_pm.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_pm.c
@@ -13,9 +13,7 @@
 #include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
-#ifdef CONFIG_PM_RUNTIME
 #include <linux/pm_runtime.h>
-#endif
 #include "s5p_mfc_common.h"
 #include "s5p_mfc_debug.h"
 #include "s5p_mfc_pm.h"
@@ -67,7 +65,7 @@ int s5p_mfc_init_pm(struct s5p_mfc_dev *dev)
         }
 
         atomic_set(&pm->power, 0);
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         pm->device = &dev->plat_dev->dev;
         pm_runtime_enable(pm->device);
 #endif
@@ -93,7 +91,7 @@ void s5p_mfc_final_pm(struct s5p_mfc_dev *dev)
         }
         clk_unprepare(pm->clock_gate);
         clk_put(pm->clock_gate);
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         pm_runtime_disable(pm->device);
 #endif
 }
@@ -120,7 +118,7 @@ void s5p_mfc_clock_off(void)
 
 int s5p_mfc_power_on(void)
 {
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         return pm_runtime_get_sync(pm->device);
 #else
         atomic_set(&pm->power, 1);
@@ -130,7 +128,7 @@ int s5p_mfc_power_on(void)
 
 int s5p_mfc_power_off(void)
 {
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         return pm_runtime_put_sync(pm->device);
 #else
         atomic_set(&pm->power, 0);
diff --git a/drivers/media/platform/s5p-tv/hdmi_drv.c b/drivers/media/platform/s5p-tv/hdmi_drv.c
index 37c8bd694c5f..1d1ef211e113 100644
--- a/drivers/media/platform/s5p-tv/hdmi_drv.c
+++ b/drivers/media/platform/s5p-tv/hdmi_drv.c
@@ -660,7 +660,7 @@ static int hdmi_g_mbus_fmt(struct v4l2_subdev *sd,
         memset(fmt, 0, sizeof(*fmt));
         fmt->width = t->hact.end - t->hact.beg;
         fmt->height = t->vact[0].end - t->vact[0].beg;
-        fmt->code = V4L2_MBUS_FMT_FIXED; /* means RGB888 */
+        fmt->code = MEDIA_BUS_FMT_FIXED; /* means RGB888 */
         fmt->colorspace = V4L2_COLORSPACE_SRGB;
         if (t->interlaced) {
                 fmt->field = V4L2_FIELD_INTERLACED;
diff --git a/drivers/media/platform/s5p-tv/sdo_drv.c b/drivers/media/platform/s5p-tv/sdo_drv.c
index 72cf892dd008..46f4d56aaa1b 100644
--- a/drivers/media/platform/s5p-tv/sdo_drv.c
+++ b/drivers/media/platform/s5p-tv/sdo_drv.c
@@ -170,7 +170,7 @@ static int sdo_g_mbus_fmt(struct v4l2_subdev *sd,
         /* all modes are 720 pixels wide */
         fmt->width = 720;
         fmt->height = sdev->fmt->height;
-        fmt->code = V4L2_MBUS_FMT_FIXED;
+        fmt->code = MEDIA_BUS_FMT_FIXED;
         fmt->field = V4L2_FIELD_INTERLACED;
         fmt->colorspace = V4L2_COLORSPACE_JPEG;
         return 0;
diff --git a/drivers/media/platform/sh_vou.c b/drivers/media/platform/sh_vou.c
index e5f1d4c14f2c..154ef0b6b8ab 100644
--- a/drivers/media/platform/sh_vou.c
+++ b/drivers/media/platform/sh_vou.c
@@ -396,7 +396,8 @@ static int sh_vou_querycap(struct file *file, void  *priv,
         dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         strlcpy(cap->card, "SuperH VOU", sizeof(cap->card));
-        cap->capabilities = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
+        cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
@@ -680,7 +681,7 @@ static int sh_vou_s_fmt_vid_out(struct file *file, void *priv,
         struct sh_vou_geometry geo;
         struct v4l2_mbus_framefmt mbfmt = {
                 /* Revisit: is this the correct code? */
-                .code = V4L2_MBUS_FMT_YUYV8_2X8,
+                .code = MEDIA_BUS_FMT_YUYV8_2X8,
                 .field = V4L2_FIELD_INTERLACED,
                 .colorspace = V4L2_COLORSPACE_SMPTE170M,
         };
@@ -733,7 +734,7 @@ static int sh_vou_s_fmt_vid_out(struct file *file, void *priv,
         /* Sanity checks */
         if ((unsigned)mbfmt.width > VOU_MAX_IMAGE_WIDTH ||
             (unsigned)mbfmt.height > img_height_max ||
-            mbfmt.code != V4L2_MBUS_FMT_YUYV8_2X8)
+            mbfmt.code != MEDIA_BUS_FMT_YUYV8_2X8)
                 return -EIO;
 
         if (mbfmt.width != geo.output.width ||
@@ -943,7 +944,7 @@ static int sh_vou_s_crop(struct file *file, void *fh, const struct v4l2_crop *a)
         struct sh_vou_geometry geo;
         struct v4l2_mbus_framefmt mbfmt = {
                 /* Revisit: is this the correct code? */
-                .code = V4L2_MBUS_FMT_YUYV8_2X8,
+                .code = MEDIA_BUS_FMT_YUYV8_2X8,
                 .field = V4L2_FIELD_INTERLACED,
                 .colorspace = V4L2_COLORSPACE_SMPTE170M,
         };
@@ -994,7 +995,7 @@ static int sh_vou_s_crop(struct file *file, void *fh, const struct v4l2_crop *a)
         /* Sanity checks */
         if ((unsigned)mbfmt.width > VOU_MAX_IMAGE_WIDTH ||
             (unsigned)mbfmt.height > img_height_max ||
-            mbfmt.code != V4L2_MBUS_FMT_YUYV8_2X8)
+            mbfmt.code != MEDIA_BUS_FMT_YUYV8_2X8)
                 return -EIO;
 
         geo.output.width = mbfmt.width;
diff --git a/drivers/media/platform/soc_camera/atmel-isi.c b/drivers/media/platform/soc_camera/atmel-isi.c
index c5291b001057..ee5650f4ea2d 100644
--- a/drivers/media/platform/soc_camera/atmel-isi.c
+++ b/drivers/media/platform/soc_camera/atmel-isi.c
@@ -105,25 +105,25 @@ static u32 isi_readl(struct atmel_isi *isi, u32 reg)
 }
 
 static int configure_geometry(struct atmel_isi *isi, u32 width,
-                        u32 height, enum v4l2_mbus_pixelcode code)
+                        u32 height, u32 code)
 {
         u32 cfg2, cr;
 
         switch (code) {
         /* YUV, including grey */
-        case V4L2_MBUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_Y8_1X8:
                 cr = ISI_CFG2_GRAYSCALE;
                 break;
-        case V4L2_MBUS_FMT_VYUY8_2X8:
+        case MEDIA_BUS_FMT_VYUY8_2X8:
                 cr = ISI_CFG2_YCC_SWAP_MODE_3;
                 break;
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 cr = ISI_CFG2_YCC_SWAP_MODE_2;
                 break;
-        case V4L2_MBUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
                 cr = ISI_CFG2_YCC_SWAP_MODE_1;
                 break;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 cr = ISI_CFG2_YCC_SWAP_DEFAULT;
                 break;
         /* RGB, TODO */
@@ -645,7 +645,7 @@ static int isi_camera_get_formats(struct soc_camera_device *icd,
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         int formats = 0, ret;
         /* sensor format */
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         /* soc camera host format */
         const struct soc_mbus_pixelfmt *fmt;
 
@@ -670,10 +670,10 @@ static int isi_camera_get_formats(struct soc_camera_device *icd,
         }
 
         switch (code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
-        case V4L2_MBUS_FMT_VYUY8_2X8:
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_VYUY8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
                 formats++;
                 if (xlate) {
                         xlate->host_fmt = &isi_camera_formats[0];
diff --git a/drivers/media/platform/soc_camera/mx2_camera.c b/drivers/media/platform/soc_camera/mx2_camera.c
index 2347612a4cc1..ce72bd26a6ac 100644
--- a/drivers/media/platform/soc_camera/mx2_camera.c
+++ b/drivers/media/platform/soc_camera/mx2_camera.c
@@ -211,7 +211,7 @@ struct emma_prp_resize {
 
 /* prp configuration for a client-host fmt pair */
 struct mx2_fmt_cfg {
-        enum v4l2_mbus_pixelcode        in_fmt;
+        u32     in_fmt;
         u32                             out_fmt;
         struct mx2_prp_cfg              cfg;
 };
@@ -309,7 +309,7 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
                 }
         },
         {
-                .in_fmt         = V4L2_MBUS_FMT_UYVY8_2X8,
+                .in_fmt         = MEDIA_BUS_FMT_UYVY8_2X8,
                 .out_fmt        = V4L2_PIX_FMT_YUYV,
                 .cfg            = {
                         .channel        = 1,
@@ -323,7 +323,7 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
                 }
         },
         {
-                .in_fmt         = V4L2_MBUS_FMT_YUYV8_2X8,
+                .in_fmt         = MEDIA_BUS_FMT_YUYV8_2X8,
                 .out_fmt        = V4L2_PIX_FMT_YUYV,
                 .cfg            = {
                         .channel        = 1,
@@ -337,7 +337,7 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
                 }
         },
         {
-                .in_fmt         = V4L2_MBUS_FMT_YUYV8_2X8,
+                .in_fmt         = MEDIA_BUS_FMT_YUYV8_2X8,
                 .out_fmt        = V4L2_PIX_FMT_YUV420,
                 .cfg            = {
                         .channel        = 2,
@@ -351,7 +351,7 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
                 }
         },
         {
-                .in_fmt         = V4L2_MBUS_FMT_UYVY8_2X8,
+                .in_fmt         = MEDIA_BUS_FMT_UYVY8_2X8,
                 .out_fmt        = V4L2_PIX_FMT_YUV420,
                 .cfg            = {
                         .channel        = 2,
@@ -366,9 +366,7 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
         },
 };
 
-static struct mx2_fmt_cfg *mx27_emma_prp_get_format(
-                                        enum v4l2_mbus_pixelcode in_fmt,
-                                        u32 out_fmt)
+static struct mx2_fmt_cfg *mx27_emma_prp_get_format(u32 in_fmt, u32 out_fmt)
 {
         int i;
 
@@ -945,7 +943,7 @@ static int mx2_camera_get_formats(struct soc_camera_device *icd,
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_mbus_pixelfmt *fmt;
         struct device *dev = icd->parent;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         int ret, formats = 0;
 
         ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
@@ -959,8 +957,8 @@ static int mx2_camera_get_formats(struct soc_camera_device *icd,
                 return 0;
         }
 
-        if (code == V4L2_MBUS_FMT_YUYV8_2X8 ||
-            code == V4L2_MBUS_FMT_UYVY8_2X8) {
+        if (code == MEDIA_BUS_FMT_YUYV8_2X8 ||
+            code == MEDIA_BUS_FMT_UYVY8_2X8) {
                 formats++;
                 if (xlate) {
                         /*
@@ -968,7 +966,7 @@ static int mx2_camera_get_formats(struct soc_camera_device *icd,
                          * soc_mediabus.c
                          */
                         xlate->host_fmt =
-                                soc_mbus_get_fmtdesc(V4L2_MBUS_FMT_YUYV8_1_5X8);
+                                soc_mbus_get_fmtdesc(MEDIA_BUS_FMT_YUYV8_1_5X8);
                         xlate->code     = code;
                         dev_dbg(dev, "Providing host format %s for sensor code %d\n",
                                xlate->host_fmt->name, code);
@@ -976,11 +974,11 @@ static int mx2_camera_get_formats(struct soc_camera_device *icd,
                 }
         }
 
-        if (code == V4L2_MBUS_FMT_UYVY8_2X8) {
+        if (code == MEDIA_BUS_FMT_UYVY8_2X8) {
                 formats++;
                 if (xlate) {
                         xlate->host_fmt =
-                                soc_mbus_get_fmtdesc(V4L2_MBUS_FMT_YUYV8_2X8);
+                                soc_mbus_get_fmtdesc(MEDIA_BUS_FMT_YUYV8_2X8);
                         xlate->code     = code;
                         dev_dbg(dev, "Providing host format %s for sensor code %d\n",
                                 xlate->host_fmt->name, code);
diff --git a/drivers/media/platform/soc_camera/mx3_camera.c b/drivers/media/platform/soc_camera/mx3_camera.c
index 7696a873510d..8e52ccce66de 100644
--- a/drivers/media/platform/soc_camera/mx3_camera.c
+++ b/drivers/media/platform/soc_camera/mx3_camera.c
@@ -656,7 +656,7 @@ static int mx3_camera_get_formats(struct soc_camera_device *icd, unsigned int id
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct device *dev = icd->parent;
         int formats = 0, ret;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         const struct soc_mbus_pixelfmt *fmt;
 
         ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
@@ -677,7 +677,7 @@ static int mx3_camera_get_formats(struct soc_camera_device *icd, unsigned int id
                 return 0;
 
         switch (code) {
-        case V4L2_MBUS_FMT_SBGGR10_1X10:
+        case MEDIA_BUS_FMT_SBGGR10_1X10:
                 formats++;
                 if (xlate) {
                         xlate->host_fmt = &mx3_camera_formats[0];
@@ -687,7 +687,7 @@ static int mx3_camera_get_formats(struct soc_camera_device *icd, unsigned int id
                                 mx3_camera_formats[0].name, code);
                 }
                 break;
-        case V4L2_MBUS_FMT_Y10_1X10:
+        case MEDIA_BUS_FMT_Y10_1X10:
                 formats++;
                 if (xlate) {
                         xlate->host_fmt = &mx3_camera_formats[1];
diff --git a/drivers/media/platform/soc_camera/omap1_camera.c b/drivers/media/platform/soc_camera/omap1_camera.c
index 74ce8b6b79fa..e6b93281f246 100644
--- a/drivers/media/platform/soc_camera/omap1_camera.c
+++ b/drivers/media/platform/soc_camera/omap1_camera.c
@@ -140,7 +140,7 @@
 /* buffer for one video frame */
 struct omap1_cam_buf {
         struct videobuf_buffer          vb;
-        enum v4l2_mbus_pixelcode        code;
+        u32     code;
         int                             inwork;
         struct scatterlist              *sgbuf;
         int                             sgcount;
@@ -980,7 +980,7 @@ static void omap1_cam_clock_stop(struct soc_camera_host *ici)
 /* Duplicate standard formats based on host capability of byte swapping */
 static const struct soc_mbus_lookup omap1_cam_formats[] = {
 {
-        .code = V4L2_MBUS_FMT_UYVY8_2X8,
+        .code = MEDIA_BUS_FMT_UYVY8_2X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_YUYV,
                 .name                   = "YUYV",
@@ -990,7 +990,7 @@ static const struct soc_mbus_lookup omap1_cam_formats[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_VYUY8_2X8,
+        .code = MEDIA_BUS_FMT_VYUY8_2X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_YVYU,
                 .name                   = "YVYU",
@@ -1000,7 +1000,7 @@ static const struct soc_mbus_lookup omap1_cam_formats[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_YUYV8_2X8,
+        .code = MEDIA_BUS_FMT_YUYV8_2X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_UYVY,
                 .name                   = "UYVY",
@@ -1010,7 +1010,7 @@ static const struct soc_mbus_lookup omap1_cam_formats[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_YVYU8_2X8,
+        .code = MEDIA_BUS_FMT_YVYU8_2X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_VYUY,
                 .name                   = "VYUY",
@@ -1020,7 +1020,7 @@ static const struct soc_mbus_lookup omap1_cam_formats[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE,
+        .code = MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB555,
                 .name                   = "RGB555",
@@ -1030,7 +1030,7 @@ static const struct soc_mbus_lookup omap1_cam_formats[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
+        .code = MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB555X,
                 .name                   = "RGB555X",
@@ -1040,7 +1040,7 @@ static const struct soc_mbus_lookup omap1_cam_formats[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB565_2X8_BE,
+        .code = MEDIA_BUS_FMT_RGB565_2X8_BE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB565,
                 .name                   = "RGB565",
@@ -1050,7 +1050,7 @@ static const struct soc_mbus_lookup omap1_cam_formats[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB565_2X8_LE,
+        .code = MEDIA_BUS_FMT_RGB565_2X8_LE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB565X,
                 .name                   = "RGB565X",
@@ -1068,7 +1068,7 @@ static int omap1_cam_get_formats(struct soc_camera_device *icd,
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct device *dev = icd->parent;
         int formats = 0, ret;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         const struct soc_mbus_pixelfmt *fmt;
 
         ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
@@ -1088,14 +1088,14 @@ static int omap1_cam_get_formats(struct soc_camera_device *icd,
                 return 0;
 
         switch (code) {
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_YVYU8_2X8:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
-        case V4L2_MBUS_FMT_VYUY8_2X8:
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE:
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_VYUY8_2X8:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
                 formats++;
                 if (xlate) {
                         xlate->host_fmt = soc_mbus_find_fmtdesc(code,
diff --git a/drivers/media/platform/soc_camera/pxa_camera.c b/drivers/media/platform/soc_camera/pxa_camera.c
index 66178fc9f9eb..951226af0eba 100644
--- a/drivers/media/platform/soc_camera/pxa_camera.c
+++ b/drivers/media/platform/soc_camera/pxa_camera.c
@@ -187,7 +187,7 @@ struct pxa_cam_dma {
 struct pxa_buffer {
         /* common v4l buffer stuff -- must be first */
         struct videobuf_buffer          vb;
-        enum v4l2_mbus_pixelcode        code;
+        u32     code;
         /* our descriptor lists for Y, U and V channels */
         struct pxa_cam_dma              dmas[3];
         int                             inwork;
@@ -1253,7 +1253,7 @@ static int pxa_camera_get_formats(struct soc_camera_device *icd, unsigned int id
         struct device *dev = icd->parent;
         int formats = 0, ret;
         struct pxa_cam *cam;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         const struct soc_mbus_pixelfmt *fmt;
 
         ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
@@ -1283,7 +1283,7 @@ static int pxa_camera_get_formats(struct soc_camera_device *icd, unsigned int id
         }
 
         switch (code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 formats++;
                 if (xlate) {
                         xlate->host_fmt = &pxa_camera_formats[0];
@@ -1292,11 +1292,11 @@ static int pxa_camera_get_formats(struct soc_camera_device *icd, unsigned int id
                         dev_dbg(dev, "Providing format %s using code %d\n",
                                 pxa_camera_formats[0].name, code);
                 }
-        case V4L2_MBUS_FMT_VYUY8_2X8:
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_YVYU8_2X8:
-        case V4L2_MBUS_FMT_RGB565_2X8_LE:
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
+        case MEDIA_BUS_FMT_VYUY8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_RGB565_2X8_LE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
                 if (xlate)
                         dev_dbg(dev, "Providing format %s packed\n",
                                 fmt->name);
diff --git a/drivers/media/platform/soc_camera/rcar_vin.c b/drivers/media/platform/soc_camera/rcar_vin.c
index 20defcb8b31b..8d8438b10b87 100644
--- a/drivers/media/platform/soc_camera/rcar_vin.c
+++ b/drivers/media/platform/soc_camera/rcar_vin.c
@@ -272,16 +272,16 @@ static int rcar_vin_setup(struct rcar_vin_priv *priv)
 
         /* input interface */
         switch (icd->current_fmt->code) {
-        case V4L2_MBUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
                 /* BT.601/BT.1358 16bit YCbCr422 */
                 vnmc |= VNMC_INF_YUV16;
                 break;
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 /* BT.656 8bit YCbCr422 or BT.601 8bit YCbCr422 */
                 vnmc |= priv->pdata_flags & RCAR_VIN_BT656 ?
                         VNMC_INF_YUV8_BT656 : VNMC_INF_YUV8_BT601;
                 break;
-        case V4L2_MBUS_FMT_YUYV10_2X10:
+        case MEDIA_BUS_FMT_YUYV10_2X10:
                 /* BT.656 10bit YCbCr422 or BT.601 10bit YCbCr422 */
                 vnmc |= priv->pdata_flags & RCAR_VIN_BT656 ?
                         VNMC_INF_YUV10_BT656 : VNMC_INF_YUV10_BT601;
@@ -921,7 +921,7 @@ static int rcar_vin_get_formats(struct soc_camera_device *icd, unsigned int idx,
         int ret, k, n;
         int formats = 0;
         struct rcar_vin_cam *cam;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         const struct soc_mbus_pixelfmt *fmt;
 
         ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
@@ -1010,9 +1010,9 @@ static int rcar_vin_get_formats(struct soc_camera_device *icd, unsigned int idx,
                 cam->extra_fmt = NULL;
 
         switch (code) {
-        case V4L2_MBUS_FMT_YUYV8_1X16:
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_YUYV10_2X10:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV10_2X10:
                 if (cam->extra_fmt)
                         break;
 
diff --git a/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c b/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
index 20ad4a571d37..5f58ed995320 100644
--- a/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
+++ b/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
@@ -149,7 +149,7 @@ struct sh_mobile_ceu_cam {
         /* Camera cropping rectangle */
         struct v4l2_rect rect;
         const struct soc_mbus_pixelfmt *extra_fmt;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
 };
 
 static struct sh_mobile_ceu_buffer *to_ceu_vb(struct vb2_buffer *vb)
@@ -861,16 +861,16 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd)
         case V4L2_PIX_FMT_NV16:
         case V4L2_PIX_FMT_NV61:
                 switch (cam->code) {
-                case V4L2_MBUS_FMT_UYVY8_2X8:
+                case MEDIA_BUS_FMT_UYVY8_2X8:
                         value = 0x00000000; /* Cb0, Y0, Cr0, Y1 */
                         break;
-                case V4L2_MBUS_FMT_VYUY8_2X8:
+                case MEDIA_BUS_FMT_VYUY8_2X8:
                         value = 0x00000100; /* Cr0, Y0, Cb0, Y1 */
                         break;
-                case V4L2_MBUS_FMT_YUYV8_2X8:
+                case MEDIA_BUS_FMT_YUYV8_2X8:
                         value = 0x00000200; /* Y0, Cb0, Y1, Cr0 */
                         break;
-                case V4L2_MBUS_FMT_YVYU8_2X8:
+                case MEDIA_BUS_FMT_YVYU8_2X8:
                         value = 0x00000300; /* Y0, Cr0, Y1, Cb0 */
                         break;
                 default:
@@ -1048,7 +1048,7 @@ static int sh_mobile_ceu_get_formats(struct soc_camera_device *icd, unsigned int
         int ret, k, n;
         int formats = 0;
         struct sh_mobile_ceu_cam *cam;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
         const struct soc_mbus_pixelfmt *fmt;
 
         ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
@@ -1141,10 +1141,10 @@ static int sh_mobile_ceu_get_formats(struct soc_camera_device *icd, unsigned int
                 cam->extra_fmt = NULL;
 
         switch (code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
-        case V4L2_MBUS_FMT_VYUY8_2X8:
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_YVYU8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_VYUY8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YVYU8_2X8:
                 if (cam->extra_fmt)
                         break;
 
diff --git a/drivers/media/platform/soc_camera/sh_mobile_csi2.c b/drivers/media/platform/soc_camera/sh_mobile_csi2.c
index 05dd21a35d63..c738e27a75d7 100644
--- a/drivers/media/platform/soc_camera/sh_mobile_csi2.c
+++ b/drivers/media/platform/soc_camera/sh_mobile_csi2.c
@@ -59,28 +59,28 @@ static int sh_csi2_try_fmt(struct v4l2_subdev *sd,
         switch (pdata->type) {
         case SH_CSI2C:
                 switch (mf->code) {
-                case V4L2_MBUS_FMT_UYVY8_2X8:           /* YUV422 */
-                case V4L2_MBUS_FMT_YUYV8_1_5X8:         /* YUV420 */
-                case V4L2_MBUS_FMT_Y8_1X8:              /* RAW8 */
-                case V4L2_MBUS_FMT_SBGGR8_1X8:
-                case V4L2_MBUS_FMT_SGRBG8_1X8:
+                case MEDIA_BUS_FMT_UYVY8_2X8:           /* YUV422 */
+                case MEDIA_BUS_FMT_YUYV8_1_5X8:         /* YUV420 */
+                case MEDIA_BUS_FMT_Y8_1X8:              /* RAW8 */
+                case MEDIA_BUS_FMT_SBGGR8_1X8:
+                case MEDIA_BUS_FMT_SGRBG8_1X8:
                         break;
                 default:
                         /* All MIPI CSI-2 devices must support one of primary formats */
-                        mf->code = V4L2_MBUS_FMT_YUYV8_2X8;
+                        mf->code = MEDIA_BUS_FMT_YUYV8_2X8;
                 }
                 break;
         case SH_CSI2I:
                 switch (mf->code) {
-                case V4L2_MBUS_FMT_Y8_1X8:              /* RAW8 */
-                case V4L2_MBUS_FMT_SBGGR8_1X8:
-                case V4L2_MBUS_FMT_SGRBG8_1X8:
-                case V4L2_MBUS_FMT_SBGGR10_1X10:        /* RAW10 */
-                case V4L2_MBUS_FMT_SBGGR12_1X12:        /* RAW12 */
+                case MEDIA_BUS_FMT_Y8_1X8:              /* RAW8 */
+                case MEDIA_BUS_FMT_SBGGR8_1X8:
+                case MEDIA_BUS_FMT_SGRBG8_1X8:
+                case MEDIA_BUS_FMT_SBGGR10_1X10:        /* RAW10 */
+                case MEDIA_BUS_FMT_SBGGR12_1X12:        /* RAW12 */
                         break;
                 default:
                         /* All MIPI CSI-2 devices must support one of primary formats */
-                        mf->code = V4L2_MBUS_FMT_SBGGR8_1X8;
+                        mf->code = MEDIA_BUS_FMT_SBGGR8_1X8;
                 }
                 break;
         }
@@ -104,21 +104,21 @@ static int sh_csi2_s_fmt(struct v4l2_subdev *sd,
                 return -EINVAL;
 
         switch (mf->code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 tmp |= 0x1e;    /* YUV422 8 bit */
                 break;
-        case V4L2_MBUS_FMT_YUYV8_1_5X8:
+        case MEDIA_BUS_FMT_YUYV8_1_5X8:
                 tmp |= 0x18;    /* YUV420 8 bit */
                 break;
-        case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE:
+        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE:
                 tmp |= 0x21;    /* RGB555 */
                 break;
-        case V4L2_MBUS_FMT_RGB565_2X8_BE:
+        case MEDIA_BUS_FMT_RGB565_2X8_BE:
                 tmp |= 0x22;    /* RGB565 */
                 break;
-        case V4L2_MBUS_FMT_Y8_1X8:
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
-        case V4L2_MBUS_FMT_SGRBG8_1X8:
+        case MEDIA_BUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_SGRBG8_1X8:
                 tmp |= 0x2a;    /* RAW8 */
                 break;
         default:
diff --git a/drivers/media/platform/soc_camera/soc_camera.c b/drivers/media/platform/soc_camera/soc_camera.c
index 8e61b976da19..f4be2a1c659a 100644
--- a/drivers/media/platform/soc_camera/soc_camera.c
+++ b/drivers/media/platform/soc_camera/soc_camera.c
@@ -460,7 +460,7 @@ static int soc_camera_init_user_formats(struct soc_camera_device *icd)
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
         unsigned int i, fmts = 0, raw_fmts = 0;
         int ret;
-        enum v4l2_mbus_pixelcode code;
+        u32 code;
 
         while (!v4l2_subdev_call(sd, video, enum_mbus_fmt, raw_fmts, &code))
                 raw_fmts++;
diff --git a/drivers/media/platform/soc_camera/soc_camera_platform.c b/drivers/media/platform/soc_camera/soc_camera_platform.c
index ceaddfb85e49..f2ce1ab06d53 100644
--- a/drivers/media/platform/soc_camera/soc_camera_platform.c
+++ b/drivers/media/platform/soc_camera/soc_camera_platform.c
@@ -62,7 +62,7 @@ static struct v4l2_subdev_core_ops platform_subdev_core_ops = {
 };
 
 static int soc_camera_platform_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
-                                        enum v4l2_mbus_pixelcode *code)
+                                        u32 *code)
 {
         struct soc_camera_platform_info *p = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/platform/soc_camera/soc_mediabus.c b/drivers/media/platform/soc_camera/soc_mediabus.c
index dc02deca7563..1dbcd426683c 100644
--- a/drivers/media/platform/soc_camera/soc_mediabus.c
+++ b/drivers/media/platform/soc_camera/soc_mediabus.c
@@ -17,7 +17,7 @@
 
 static const struct soc_mbus_lookup mbus_fmt[] = {
 {
-        .code = V4L2_MBUS_FMT_YUYV8_2X8,
+        .code = MEDIA_BUS_FMT_YUYV8_2X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_YUYV,
                 .name                   = "YUYV",
@@ -27,7 +27,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_YVYU8_2X8,
+        .code = MEDIA_BUS_FMT_YVYU8_2X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_YVYU,
                 .name                   = "YVYU",
@@ -37,7 +37,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_UYVY8_2X8,
+        .code = MEDIA_BUS_FMT_UYVY8_2X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_UYVY,
                 .name                   = "UYVY",
@@ -47,7 +47,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_VYUY8_2X8,
+        .code = MEDIA_BUS_FMT_VYUY8_2X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_VYUY,
                 .name                   = "VYUY",
@@ -57,7 +57,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
+        .code = MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB555,
                 .name                   = "RGB555",
@@ -67,7 +67,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE,
+        .code = MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB555X,
                 .name                   = "RGB555X",
@@ -77,7 +77,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB565_2X8_LE,
+        .code = MEDIA_BUS_FMT_RGB565_2X8_LE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB565,
                 .name                   = "RGB565",
@@ -87,7 +87,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB565_2X8_BE,
+        .code = MEDIA_BUS_FMT_RGB565_2X8_BE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB565X,
                 .name                   = "RGB565X",
@@ -97,7 +97,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB666_1X18,
+        .code = MEDIA_BUS_FMT_RGB666_1X18,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB32,
                 .name                   = "RGB666/32bpp",
@@ -106,7 +106,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .order                  = SOC_MBUS_ORDER_LE,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB888_1X24,
+        .code = MEDIA_BUS_FMT_RGB888_1X24,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB32,
                 .name                   = "RGB888/32bpp",
@@ -115,7 +115,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .order                  = SOC_MBUS_ORDER_LE,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB888_2X12_BE,
+        .code = MEDIA_BUS_FMT_RGB888_2X12_BE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB32,
                 .name                   = "RGB888/32bpp",
@@ -124,7 +124,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .order                  = SOC_MBUS_ORDER_BE,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB888_2X12_LE,
+        .code = MEDIA_BUS_FMT_RGB888_2X12_LE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB32,
                 .name                   = "RGB888/32bpp",
@@ -133,7 +133,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .order                  = SOC_MBUS_ORDER_LE,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SBGGR8_1X8,
+        .code = MEDIA_BUS_FMT_SBGGR8_1X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR8,
                 .name                   = "Bayer 8 BGGR",
@@ -143,7 +143,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SBGGR10_1X10,
+        .code = MEDIA_BUS_FMT_SBGGR10_1X10,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
@@ -153,7 +153,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_Y8_1X8,
+        .code = MEDIA_BUS_FMT_Y8_1X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_GREY,
                 .name                   = "Grey",
@@ -163,7 +163,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_Y10_1X10,
+        .code = MEDIA_BUS_FMT_Y10_1X10,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_Y10,
                 .name                   = "Grey 10bit",
@@ -173,7 +173,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE,
+        .code = MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
@@ -183,7 +183,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE,
+        .code = MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
@@ -193,7 +193,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE,
+        .code = MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
@@ -203,7 +203,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE,
+        .code = MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
                 .name                   = "Bayer 10 BGGR",
@@ -213,7 +213,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_JPEG_1X8,
+        .code = MEDIA_BUS_FMT_JPEG_1X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_JPEG,
                 .name                   = "JPEG",
@@ -223,7 +223,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_RGB444_2X8_PADHI_BE,
+        .code = MEDIA_BUS_FMT_RGB444_2X8_PADHI_BE,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_RGB444,
                 .name                   = "RGB444",
@@ -233,7 +233,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_YUYV8_1_5X8,
+        .code = MEDIA_BUS_FMT_YUYV8_1_5X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_YUV420,
                 .name                   = "YUYV 4:2:0",
@@ -243,7 +243,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_YVYU8_1_5X8,
+        .code = MEDIA_BUS_FMT_YVYU8_1_5X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_YVU420,
                 .name                   = "YVYU 4:2:0",
@@ -253,7 +253,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_UYVY8_1X16,
+        .code = MEDIA_BUS_FMT_UYVY8_1X16,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_UYVY,
                 .name                   = "UYVY 16bit",
@@ -263,7 +263,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_VYUY8_1X16,
+        .code = MEDIA_BUS_FMT_VYUY8_1X16,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_VYUY,
                 .name                   = "VYUY 16bit",
@@ -273,7 +273,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_YUYV8_1X16,
+        .code = MEDIA_BUS_FMT_YUYV8_1X16,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_YUYV,
                 .name                   = "YUYV 16bit",
@@ -283,7 +283,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_YVYU8_1X16,
+        .code = MEDIA_BUS_FMT_YVYU8_1X16,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_YVYU,
                 .name                   = "YVYU 16bit",
@@ -293,7 +293,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SGRBG8_1X8,
+        .code = MEDIA_BUS_FMT_SGRBG8_1X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SGRBG8,
                 .name                   = "Bayer 8 GRBG",
@@ -303,7 +303,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
+        .code = MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SGRBG10DPCM8,
                 .name                   = "Bayer 10 BGGR DPCM 8",
@@ -313,7 +313,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SGBRG10_1X10,
+        .code = MEDIA_BUS_FMT_SGBRG10_1X10,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SGBRG10,
                 .name                   = "Bayer 10 GBRG",
@@ -323,7 +323,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SGRBG10_1X10,
+        .code = MEDIA_BUS_FMT_SGRBG10_1X10,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SGRBG10,
                 .name                   = "Bayer 10 GRBG",
@@ -333,7 +333,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SRGGB10_1X10,
+        .code = MEDIA_BUS_FMT_SRGGB10_1X10,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SRGGB10,
                 .name                   = "Bayer 10 RGGB",
@@ -343,7 +343,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SBGGR12_1X12,
+        .code = MEDIA_BUS_FMT_SBGGR12_1X12,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SBGGR12,
                 .name                   = "Bayer 12 BGGR",
@@ -353,7 +353,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SGBRG12_1X12,
+        .code = MEDIA_BUS_FMT_SGBRG12_1X12,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SGBRG12,
                 .name                   = "Bayer 12 GBRG",
@@ -363,7 +363,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SGRBG12_1X12,
+        .code = MEDIA_BUS_FMT_SGRBG12_1X12,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SGRBG12,
                 .name                   = "Bayer 12 GRBG",
@@ -373,7 +373,7 @@ static const struct soc_mbus_lookup mbus_fmt[] = {
                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
         },
 }, {
-        .code = V4L2_MBUS_FMT_SRGGB12_1X12,
+        .code = MEDIA_BUS_FMT_SRGGB12_1X12,
         .fmt = {
                 .fourcc                 = V4L2_PIX_FMT_SRGGB12,
                 .name                   = "Bayer 12 RGGB",
@@ -458,7 +458,7 @@ s32 soc_mbus_image_size(const struct soc_mbus_pixelfmt *mf,
 EXPORT_SYMBOL(soc_mbus_image_size);
 
 const struct soc_mbus_pixelfmt *soc_mbus_find_fmtdesc(
-        enum v4l2_mbus_pixelcode code,
+        u32 code,
         const struct soc_mbus_lookup *lookup,
         int n)
 {
@@ -473,7 +473,7 @@ const struct soc_mbus_pixelfmt *soc_mbus_find_fmtdesc(
 EXPORT_SYMBOL(soc_mbus_find_fmtdesc);
 
 const struct soc_mbus_pixelfmt *soc_mbus_get_fmtdesc(
-        enum v4l2_mbus_pixelcode code)
+        u32 code)
 {
         return soc_mbus_find_fmtdesc(code, mbus_fmt, ARRAY_SIZE(mbus_fmt));
 }
diff --git a/drivers/media/platform/ti-vpe/csc.c b/drivers/media/platform/ti-vpe/csc.c
index 940df4000c42..bec674994752 100644
--- a/drivers/media/platform/ti-vpe/csc.c
+++ b/drivers/media/platform/ti-vpe/csc.c
@@ -93,12 +93,8 @@ void csc_dump_regs(struct csc_data *csc)
 {
         struct device *dev = &csc->pdev->dev;
 
-        u32 read_reg(struct csc_data *csc, int offset)
-        {
-                return ioread32(csc->base + offset);
-        }
-
-#define DUMPREG(r) dev_dbg(dev, "%-35s %08x\n", #r, read_reg(csc, CSC_##r))
+#define DUMPREG(r) dev_dbg(dev, "%-35s %08x\n", #r, \
+        ioread32(csc->base + CSC_##r))
 
         DUMPREG(CSC00);
         DUMPREG(CSC01);
@@ -189,7 +185,7 @@ struct csc_data *csc_create(struct platform_device *pdev)
         csc->base = devm_ioremap_resource(&pdev->dev, csc->res);
         if (IS_ERR(csc->base)) {
                 dev_err(&pdev->dev, "failed to ioremap\n");
-                return csc->base;
+                return ERR_CAST(csc->base);
         }
 
         return csc;
diff --git a/drivers/media/platform/ti-vpe/sc.c b/drivers/media/platform/ti-vpe/sc.c
index 6314171ffe9b..f82d1c7f667f 100644
--- a/drivers/media/platform/ti-vpe/sc.c
+++ b/drivers/media/platform/ti-vpe/sc.c
@@ -24,12 +24,8 @@ void sc_dump_regs(struct sc_data *sc)
 {
         struct device *dev = &sc->pdev->dev;
 
-        u32 read_reg(struct sc_data *sc, int offset)
-        {
-                return ioread32(sc->base + offset);
-        }
-
-#define DUMPREG(r) dev_dbg(dev, "%-35s %08x\n", #r, read_reg(sc, CFG_##r))
+#define DUMPREG(r) dev_dbg(dev, "%-35s %08x\n", #r, \
+        ioread32(sc->base + CFG_##r))
 
         DUMPREG(SC0);
         DUMPREG(SC1);
@@ -304,7 +300,7 @@ struct sc_data *sc_create(struct platform_device *pdev)
         sc->base = devm_ioremap_resource(&pdev->dev, sc->res);
         if (IS_ERR(sc->base)) {
                 dev_err(&pdev->dev, "failed to ioremap\n");
-                return sc->base;
+                return ERR_CAST(sc->base);
         }
 
         return sc;
diff --git a/drivers/media/platform/via-camera.c b/drivers/media/platform/via-camera.c
index ae6870cb8339..86989d86abfa 100644
--- a/drivers/media/platform/via-camera.c
+++ b/drivers/media/platform/via-camera.c
@@ -101,7 +101,7 @@ struct via_camera {
          */
         struct v4l2_pix_format sensor_format;
         struct v4l2_pix_format user_format;
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
 };
 
 /*
@@ -143,12 +143,12 @@ static struct via_format {
         __u8 *desc;
         __u32 pixelformat;
         int bpp;   /* Bytes per pixel */
-        enum v4l2_mbus_pixelcode mbus_code;
+        u32 mbus_code;
 } via_formats[] = {
         {
                 .desc           = "YUYV 4:2:2",
                 .pixelformat    = V4L2_PIX_FMT_YUYV,
-                .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
+                .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
                 .bpp            = 2,
         },
         /* RGB444 and Bayer should be doable, but have never been
@@ -849,7 +849,7 @@ static const struct v4l2_pix_format viacam_def_pix_format = {
         .sizeimage      = VGA_WIDTH * VGA_HEIGHT * 2,
 };
 
-static const enum v4l2_mbus_pixelcode via_def_mbus_code = V4L2_MBUS_FMT_YUYV8_2X8;
+static const u32 via_def_mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
 
 static int viacam_enum_fmt_vid_cap(struct file *filp, void *priv,
                 struct v4l2_fmtdesc *fmt)
@@ -985,9 +985,9 @@ static int viacam_querycap(struct file *filp, void *priv,
 {
         strcpy(cap->driver, "via-camera");
         strcpy(cap->card, "via-camera");
-        cap->version = 1;
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
+        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
                 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/platform/mem2mem_testdev.c b/drivers/media/platform/vim2m.c
index c1b03cfd6ded..1105c111cc10 100644
--- a/drivers/media/platform/mem2mem_testdev.c
+++ b/drivers/media/platform/vim2m.c
@@ -31,12 +31,11 @@
 #include <media/v4l2-event.h>
 #include <media/videobuf2-vmalloc.h>
 
-#define MEM2MEM_TEST_MODULE_NAME "mem2mem-testdev"
-
 MODULE_DESCRIPTION("Virtual device for mem2mem framework testing");
 MODULE_AUTHOR("Pawel Osciak, <pawel@osciak.com>");
 MODULE_LICENSE("GPL");
 MODULE_VERSION("0.1.1");
+MODULE_ALIAS("mem2mem_testdev");
 
 static unsigned debug;
 module_param(debug, uint, 0644);
@@ -52,7 +51,7 @@ MODULE_PARM_DESC(debug, "activates debug info");
 #define MEM2MEM_CAPTURE (1 << 0)
 #define MEM2MEM_OUTPUT  (1 << 1)
 
-#define MEM2MEM_NAME            "m2m-testdev"
+#define MEM2MEM_NAME            "vim2m"
 
 /* Per queue */
 #define MEM2MEM_DEF_NUM_BUFS    VIDEO_MAX_FRAME
@@ -72,15 +71,15 @@ MODULE_PARM_DESC(debug, "activates debug info");
         v4l2_dbg(1, debug, &dev->v4l2_dev, "%s: " fmt, __func__, ## arg)
 
 
-static void m2mtest_dev_release(struct device *dev)
+static void vim2m_dev_release(struct device *dev)
 {}
 
-static struct platform_device m2mtest_pdev = {
+static struct platform_device vim2m_pdev = {
         .name           = MEM2MEM_NAME,
-        .dev.release    = m2mtest_dev_release,
+        .dev.release    = vim2m_dev_release,
 };
 
-struct m2mtest_fmt {
+struct vim2m_fmt {
         char    *name;
         u32     fourcc;
         int     depth;
@@ -88,7 +87,7 @@ struct m2mtest_fmt {
         u32     types;
 };
 
-static struct m2mtest_fmt formats[] = {
+static struct vim2m_fmt formats[] = {
         {
                 .name   = "RGB565 (BE)",
                 .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
@@ -108,12 +107,12 @@ static struct m2mtest_fmt formats[] = {
 #define NUM_FORMATS ARRAY_SIZE(formats)
 
 /* Per-queue, driver-specific private data */
-struct m2mtest_q_data {
+struct vim2m_q_data {
         unsigned int            width;
         unsigned int            height;
         unsigned int            sizeimage;
         unsigned int            sequence;
-        struct m2mtest_fmt      *fmt;
+        struct vim2m_fmt        *fmt;
 };
 
 enum {
@@ -124,9 +123,9 @@ enum {
 #define V4L2_CID_TRANS_TIME_MSEC        (V4L2_CID_USER_BASE + 0x1000)
 #define V4L2_CID_TRANS_NUM_BUFS         (V4L2_CID_USER_BASE + 0x1001)
 
-static struct m2mtest_fmt *find_format(struct v4l2_format *f)
+static struct vim2m_fmt *find_format(struct v4l2_format *f)
 {
-        struct m2mtest_fmt *fmt;
+        struct vim2m_fmt *fmt;
         unsigned int k;
 
         for (k = 0; k < NUM_FORMATS; k++) {
@@ -141,7 +140,7 @@ static struct m2mtest_fmt *find_format(struct v4l2_format *f)
         return &formats[k];
 }
 
-struct m2mtest_dev {
+struct vim2m_dev {
         struct v4l2_device      v4l2_dev;
         struct video_device     *vfd;
 
@@ -154,9 +153,9 @@ struct m2mtest_dev {
         struct v4l2_m2m_dev     *m2m_dev;
 };
 
-struct m2mtest_ctx {
+struct vim2m_ctx {
         struct v4l2_fh          fh;
-        struct m2mtest_dev      *dev;
+        struct vim2m_dev        *dev;
 
         struct v4l2_ctrl_handler hdl;
 
@@ -177,15 +176,15 @@ struct m2mtest_ctx {
         enum v4l2_colorspace    colorspace;
 
         /* Source and destination queue data */
-        struct m2mtest_q_data   q_data[2];
+        struct vim2m_q_data   q_data[2];
 };
 
-static inline struct m2mtest_ctx *file2ctx(struct file *file)
+static inline struct vim2m_ctx *file2ctx(struct file *file)
 {
-        return container_of(file->private_data, struct m2mtest_ctx, fh);
+        return container_of(file->private_data, struct vim2m_ctx, fh);
 }
 
-static struct m2mtest_q_data *get_q_data(struct m2mtest_ctx *ctx,
+static struct vim2m_q_data *get_q_data(struct vim2m_ctx *ctx,
                                          enum v4l2_buf_type type)
 {
         switch (type) {
@@ -200,12 +199,12 @@ static struct m2mtest_q_data *get_q_data(struct m2mtest_ctx *ctx,
 }
 
 
-static int device_process(struct m2mtest_ctx *ctx,
+static int device_process(struct vim2m_ctx *ctx,
                           struct vb2_buffer *in_vb,
                           struct vb2_buffer *out_vb)
 {
-        struct m2mtest_dev *dev = ctx->dev;
-        struct m2mtest_q_data *q_data;
+        struct vim2m_dev *dev = ctx->dev;
+        struct vim2m_q_data *q_data;
         u8 *p_in, *p_out;
         int x, y, t, w;
         int tile_w, bytes_left;
@@ -334,7 +333,7 @@ static int device_process(struct m2mtest_ctx *ctx,
         return 0;
 }
 
-static void schedule_irq(struct m2mtest_dev *dev, int msec_timeout)
+static void schedule_irq(struct vim2m_dev *dev, int msec_timeout)
 {
         dprintk(dev, "Scheduling a simulated irq\n");
         mod_timer(&dev->timer, jiffies + msecs_to_jiffies(msec_timeout));
@@ -349,7 +348,7 @@ static void schedule_irq(struct m2mtest_dev *dev, int msec_timeout)
  */
 static int job_ready(void *priv)
 {
-        struct m2mtest_ctx *ctx = priv;
+        struct vim2m_ctx *ctx = priv;
 
         if (v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx) < ctx->translen
             || v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx) < ctx->translen) {
@@ -362,7 +361,7 @@ static int job_ready(void *priv)
 
 static void job_abort(void *priv)
 {
-        struct m2mtest_ctx *ctx = priv;
+        struct vim2m_ctx *ctx = priv;
 
         /* Will cancel the transaction in the next interrupt handler */
         ctx->aborting = 1;
@@ -376,8 +375,8 @@ static void job_abort(void *priv)
  */
 static void device_run(void *priv)
 {
-        struct m2mtest_ctx *ctx = priv;
-        struct m2mtest_dev *dev = ctx->dev;
+        struct vim2m_ctx *ctx = priv;
+        struct vim2m_dev *dev = ctx->dev;
         struct vb2_buffer *src_buf, *dst_buf;
 
         src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
@@ -391,12 +390,12 @@ static void device_run(void *priv)
 
 static void device_isr(unsigned long priv)
 {
-        struct m2mtest_dev *m2mtest_dev = (struct m2mtest_dev *)priv;
-        struct m2mtest_ctx *curr_ctx;
+        struct vim2m_dev *vim2m_dev = (struct vim2m_dev *)priv;
+        struct vim2m_ctx *curr_ctx;
         struct vb2_buffer *src_vb, *dst_vb;
         unsigned long flags;
 
-        curr_ctx = v4l2_m2m_get_curr_priv(m2mtest_dev->m2m_dev);
+        curr_ctx = v4l2_m2m_get_curr_priv(vim2m_dev->m2m_dev);
 
         if (NULL == curr_ctx) {
                 pr_err("Instance released before the end of transaction\n");
@@ -408,16 +407,16 @@ static void device_isr(unsigned long priv)
 
         curr_ctx->num_processed++;
 
-        spin_lock_irqsave(&m2mtest_dev->irqlock, flags);
+        spin_lock_irqsave(&vim2m_dev->irqlock, flags);
         v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
         v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
-        spin_unlock_irqrestore(&m2mtest_dev->irqlock, flags);
+        spin_unlock_irqrestore(&vim2m_dev->irqlock, flags);
 
         if (curr_ctx->num_processed == curr_ctx->translen
             || curr_ctx->aborting) {
                 dprintk(curr_ctx->dev, "Finishing transaction\n");
                 curr_ctx->num_processed = 0;
-                v4l2_m2m_job_finish(m2mtest_dev->m2m_dev, curr_ctx->fh.m2m_ctx);
+                v4l2_m2m_job_finish(vim2m_dev->m2m_dev, curr_ctx->fh.m2m_ctx);
         } else {
                 device_run(curr_ctx);
         }
@@ -441,7 +440,7 @@ static int vidioc_querycap(struct file *file, void *priv,
 static int enum_fmt(struct v4l2_fmtdesc *f, u32 type)
 {
         int i, num;
-        struct m2mtest_fmt *fmt;
+        struct vim2m_fmt *fmt;
 
         num = 0;
 
@@ -480,10 +479,10 @@ static int vidioc_enum_fmt_vid_out(struct file *file, void *priv,
         return enum_fmt(f, MEM2MEM_OUTPUT);
 }
 
-static int vidioc_g_fmt(struct m2mtest_ctx *ctx, struct v4l2_format *f)
+static int vidioc_g_fmt(struct vim2m_ctx *ctx, struct v4l2_format *f)
 {
         struct vb2_queue *vq;
-        struct m2mtest_q_data *q_data;
+        struct vim2m_q_data *q_data;
 
         vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
         if (!vq)
@@ -514,7 +513,7 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
         return vidioc_g_fmt(file2ctx(file), f);
 }
 
-static int vidioc_try_fmt(struct v4l2_format *f, struct m2mtest_fmt *fmt)
+static int vidioc_try_fmt(struct v4l2_format *f, struct vim2m_fmt *fmt)
 {
         /* V4L2 specification suggests the driver corrects the format struct
          * if any of the dimensions is unsupported */
@@ -539,8 +538,8 @@ static int vidioc_try_fmt(struct v4l2_format *f, struct m2mtest_fmt *fmt)
 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                                   struct v4l2_format *f)
 {
-        struct m2mtest_fmt *fmt;
-        struct m2mtest_ctx *ctx = file2ctx(file);
+        struct vim2m_fmt *fmt;
+        struct vim2m_ctx *ctx = file2ctx(file);
 
         fmt = find_format(f);
         if (!fmt) {
@@ -561,8 +560,8 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 static int vidioc_try_fmt_vid_out(struct file *file, void *priv,
                                   struct v4l2_format *f)
 {
-        struct m2mtest_fmt *fmt;
-        struct m2mtest_ctx *ctx = file2ctx(file);
+        struct vim2m_fmt *fmt;
+        struct vim2m_ctx *ctx = file2ctx(file);
 
         fmt = find_format(f);
         if (!fmt) {
@@ -581,9 +580,9 @@ static int vidioc_try_fmt_vid_out(struct file *file, void *priv,
         return vidioc_try_fmt(f, fmt);
 }
 
-static int vidioc_s_fmt(struct m2mtest_ctx *ctx, struct v4l2_format *f)
+static int vidioc_s_fmt(struct vim2m_ctx *ctx, struct v4l2_format *f)
 {
-        struct m2mtest_q_data *q_data;
+        struct vim2m_q_data *q_data;
         struct vb2_queue *vq;
 
         vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
@@ -627,7 +626,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 static int vidioc_s_fmt_vid_out(struct file *file, void *priv,
                                 struct v4l2_format *f)
 {
-        struct m2mtest_ctx *ctx = file2ctx(file);
+        struct vim2m_ctx *ctx = file2ctx(file);
         int ret;
 
         ret = vidioc_try_fmt_vid_out(file, priv, f);
@@ -640,10 +639,10 @@ static int vidioc_s_fmt_vid_out(struct file *file, void *priv,
         return ret;
 }
 
-static int m2mtest_s_ctrl(struct v4l2_ctrl *ctrl)
+static int vim2m_s_ctrl(struct v4l2_ctrl *ctrl)
 {
-        struct m2mtest_ctx *ctx =
-                container_of(ctrl->handler, struct m2mtest_ctx, hdl);
+        struct vim2m_ctx *ctx =
+                container_of(ctrl->handler, struct vim2m_ctx, hdl);
 
         switch (ctrl->id) {
         case V4L2_CID_HFLIP:
@@ -676,12 +675,12 @@ static int m2mtest_s_ctrl(struct v4l2_ctrl *ctrl)
         return 0;
 }
 
-static const struct v4l2_ctrl_ops m2mtest_ctrl_ops = {
-        .s_ctrl = m2mtest_s_ctrl,
+static const struct v4l2_ctrl_ops vim2m_ctrl_ops = {
+        .s_ctrl = vim2m_s_ctrl,
 };
 
 
-static const struct v4l2_ioctl_ops m2mtest_ioctl_ops = {
+static const struct v4l2_ioctl_ops vim2m_ioctl_ops = {
         .vidioc_querycap        = vidioc_querycap,
 
         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
@@ -698,6 +697,7 @@ static const struct v4l2_ioctl_ops m2mtest_ioctl_ops = {
         .vidioc_querybuf        = v4l2_m2m_ioctl_querybuf,
         .vidioc_qbuf            = v4l2_m2m_ioctl_qbuf,
         .vidioc_dqbuf           = v4l2_m2m_ioctl_dqbuf,
+        .vidioc_expbuf          = v4l2_m2m_ioctl_expbuf,
 
         .vidioc_streamon        = v4l2_m2m_ioctl_streamon,
         .vidioc_streamoff       = v4l2_m2m_ioctl_streamoff,
@@ -711,13 +711,13 @@ static const struct v4l2_ioctl_ops m2mtest_ioctl_ops = {
  * Queue operations
  */
 
-static int m2mtest_queue_setup(struct vb2_queue *vq,
+static int vim2m_queue_setup(struct vb2_queue *vq,
                                 const struct v4l2_format *fmt,
                                 unsigned int *nbuffers, unsigned int *nplanes,
                                 unsigned int sizes[], void *alloc_ctxs[])
 {
-        struct m2mtest_ctx *ctx = vb2_get_drv_priv(vq);
-        struct m2mtest_q_data *q_data;
+        struct vim2m_ctx *ctx = vb2_get_drv_priv(vq);
+        struct vim2m_q_data *q_data;
         unsigned int size, count = *nbuffers;
 
         q_data = get_q_data(ctx, vq->type);
@@ -741,10 +741,10 @@ static int m2mtest_queue_setup(struct vb2_queue *vq,
         return 0;
 }
 
-static int m2mtest_buf_prepare(struct vb2_buffer *vb)
+static int vim2m_buf_prepare(struct vb2_buffer *vb)
 {
-        struct m2mtest_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
-        struct m2mtest_q_data *q_data;
+        struct vim2m_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
+        struct vim2m_q_data *q_data;
 
         dprintk(ctx->dev, "type: %d\n", vb->vb2_queue->type);
 
@@ -770,25 +770,25 @@ static int m2mtest_buf_prepare(struct vb2_buffer *vb)
         return 0;
 }
 
-static void m2mtest_buf_queue(struct vb2_buffer *vb)
+static void vim2m_buf_queue(struct vb2_buffer *vb)
 {
-        struct m2mtest_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
+        struct vim2m_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
 
         v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vb);
 }
 
-static int m2mtest_start_streaming(struct vb2_queue *q, unsigned count)
+static int vim2m_start_streaming(struct vb2_queue *q, unsigned count)
 {
-        struct m2mtest_ctx *ctx = vb2_get_drv_priv(q);
-        struct m2mtest_q_data *q_data = get_q_data(ctx, q->type);
+        struct vim2m_ctx *ctx = vb2_get_drv_priv(q);
+        struct vim2m_q_data *q_data = get_q_data(ctx, q->type);
 
         q_data->sequence = 0;
         return 0;
 }
 
-static void m2mtest_stop_streaming(struct vb2_queue *q)
+static void vim2m_stop_streaming(struct vb2_queue *q)
 {
-        struct m2mtest_ctx *ctx = vb2_get_drv_priv(q);
+        struct vim2m_ctx *ctx = vb2_get_drv_priv(q);
         struct vb2_buffer *vb;
         unsigned long flags;
 
@@ -805,26 +805,26 @@ static void m2mtest_stop_streaming(struct vb2_queue *q)
         }
 }
 
-static struct vb2_ops m2mtest_qops = {
-        .queue_setup     = m2mtest_queue_setup,
-        .buf_prepare     = m2mtest_buf_prepare,
-        .buf_queue       = m2mtest_buf_queue,
-        .start_streaming = m2mtest_start_streaming,
-        .stop_streaming  = m2mtest_stop_streaming,
+static struct vb2_ops vim2m_qops = {
+        .queue_setup     = vim2m_queue_setup,
+        .buf_prepare     = vim2m_buf_prepare,
+        .buf_queue       = vim2m_buf_queue,
+        .start_streaming = vim2m_start_streaming,
+        .stop_streaming  = vim2m_stop_streaming,
         .wait_prepare    = vb2_ops_wait_prepare,
         .wait_finish     = vb2_ops_wait_finish,
 };
 
 static int queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq)
 {
-        struct m2mtest_ctx *ctx = priv;
+        struct vim2m_ctx *ctx = priv;
         int ret;
 
         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
         src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
         src_vq->drv_priv = ctx;
         src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
-        src_vq->ops = &m2mtest_qops;
+        src_vq->ops = &vim2m_qops;
         src_vq->mem_ops = &vb2_vmalloc_memops;
         src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
         src_vq->lock = &ctx->dev->dev_mutex;
@@ -837,7 +837,7 @@ static int queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *ds
         dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
         dst_vq->drv_priv = ctx;
         dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
-        dst_vq->ops = &m2mtest_qops;
+        dst_vq->ops = &vim2m_qops;
         dst_vq->mem_ops = &vb2_vmalloc_memops;
         dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
         dst_vq->lock = &ctx->dev->dev_mutex;
@@ -845,8 +845,8 @@ static int queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *ds
         return vb2_queue_init(dst_vq);
 }
 
-static const struct v4l2_ctrl_config m2mtest_ctrl_trans_time_msec = {
-        .ops = &m2mtest_ctrl_ops,
+static const struct v4l2_ctrl_config vim2m_ctrl_trans_time_msec = {
+        .ops = &vim2m_ctrl_ops,
         .id = V4L2_CID_TRANS_TIME_MSEC,
         .name = "Transaction Time (msec)",
         .type = V4L2_CTRL_TYPE_INTEGER,
@@ -856,8 +856,8 @@ static const struct v4l2_ctrl_config m2mtest_ctrl_trans_time_msec = {
         .step = 1,
 };
 
-static const struct v4l2_ctrl_config m2mtest_ctrl_trans_num_bufs = {
-        .ops = &m2mtest_ctrl_ops,
+static const struct v4l2_ctrl_config vim2m_ctrl_trans_num_bufs = {
+        .ops = &vim2m_ctrl_ops,
         .id = V4L2_CID_TRANS_NUM_BUFS,
         .name = "Buffers Per Transaction",
         .type = V4L2_CTRL_TYPE_INTEGER,
@@ -870,10 +870,10 @@ static const struct v4l2_ctrl_config m2mtest_ctrl_trans_num_bufs = {
 /*
  * File operations
  */
-static int m2mtest_open(struct file *file)
+static int vim2m_open(struct file *file)
 {
-        struct m2mtest_dev *dev = video_drvdata(file);
-        struct m2mtest_ctx *ctx = NULL;
+        struct vim2m_dev *dev = video_drvdata(file);
+        struct vim2m_ctx *ctx = NULL;
         struct v4l2_ctrl_handler *hdl;
         int rc = 0;
 
@@ -890,10 +890,10 @@ static int m2mtest_open(struct file *file)
         ctx->dev = dev;
         hdl = &ctx->hdl;
         v4l2_ctrl_handler_init(hdl, 4);
-        v4l2_ctrl_new_std(hdl, &m2mtest_ctrl_ops, V4L2_CID_HFLIP, 0, 1, 1, 0);
-        v4l2_ctrl_new_std(hdl, &m2mtest_ctrl_ops, V4L2_CID_VFLIP, 0, 1, 1, 0);
-        v4l2_ctrl_new_custom(hdl, &m2mtest_ctrl_trans_time_msec, NULL);
-        v4l2_ctrl_new_custom(hdl, &m2mtest_ctrl_trans_num_bufs, NULL);
+        v4l2_ctrl_new_std(hdl, &vim2m_ctrl_ops, V4L2_CID_HFLIP, 0, 1, 1, 0);
+        v4l2_ctrl_new_std(hdl, &vim2m_ctrl_ops, V4L2_CID_VFLIP, 0, 1, 1, 0);
+        v4l2_ctrl_new_custom(hdl, &vim2m_ctrl_trans_time_msec, NULL);
+        v4l2_ctrl_new_custom(hdl, &vim2m_ctrl_trans_num_bufs, NULL);
         if (hdl->error) {
                 rc = hdl->error;
                 v4l2_ctrl_handler_free(hdl);
@@ -933,10 +933,10 @@ open_unlock:
         return rc;
 }
 
-static int m2mtest_release(struct file *file)
+static int vim2m_release(struct file *file)
 {
-        struct m2mtest_dev *dev = video_drvdata(file);
-        struct m2mtest_ctx *ctx = file2ctx(file);
+        struct vim2m_dev *dev = video_drvdata(file);
+        struct vim2m_ctx *ctx = file2ctx(file);
 
         dprintk(dev, "Releasing instance %p\n", ctx);
 
@@ -953,20 +953,20 @@ static int m2mtest_release(struct file *file)
         return 0;
 }
 
-static const struct v4l2_file_operations m2mtest_fops = {
+static const struct v4l2_file_operations vim2m_fops = {
         .owner          = THIS_MODULE,
-        .open           = m2mtest_open,
-        .release        = m2mtest_release,
+        .open           = vim2m_open,
+        .release        = vim2m_release,
         .poll           = v4l2_m2m_fop_poll,
         .unlocked_ioctl = video_ioctl2,
         .mmap           = v4l2_m2m_fop_mmap,
 };
 
-static struct video_device m2mtest_videodev = {
+static struct video_device vim2m_videodev = {
         .name           = MEM2MEM_NAME,
         .vfl_dir        = VFL_DIR_M2M,
-        .fops           = &m2mtest_fops,
-        .ioctl_ops      = &m2mtest_ioctl_ops,
+        .fops           = &vim2m_fops,
+        .ioctl_ops      = &vim2m_ioctl_ops,
         .minor          = -1,
         .release        = video_device_release,
 };
@@ -977,9 +977,9 @@ static struct v4l2_m2m_ops m2m_ops = {
         .job_abort      = job_abort,
 };
 
-static int m2mtest_probe(struct platform_device *pdev)
+static int vim2m_probe(struct platform_device *pdev)
 {
-        struct m2mtest_dev *dev;
+        struct vim2m_dev *dev;
         struct video_device *vfd;
         int ret;
 
@@ -1003,7 +1003,7 @@ static int m2mtest_probe(struct platform_device *pdev)
                 goto unreg_dev;
         }
 
-        *vfd = m2mtest_videodev;
+        *vfd = vim2m_videodev;
         vfd->lock = &dev->dev_mutex;
         vfd->v4l2_dev = &dev->v4l2_dev;
 
@@ -1014,7 +1014,7 @@ static int m2mtest_probe(struct platform_device *pdev)
         }
 
         video_set_drvdata(vfd, dev);
-        snprintf(vfd->name, sizeof(vfd->name), "%s", m2mtest_videodev.name);
+        snprintf(vfd->name, sizeof(vfd->name), "%s", vim2m_videodev.name);
         dev->vfd = vfd;
         v4l2_info(&dev->v4l2_dev,
                         "Device registered as /dev/video%d\n", vfd->num);
@@ -1042,11 +1042,11 @@ unreg_dev:
         return ret;
 }
 
-static int m2mtest_remove(struct platform_device *pdev)
+static int vim2m_remove(struct platform_device *pdev)
 {
-        struct m2mtest_dev *dev = platform_get_drvdata(pdev);
+        struct vim2m_dev *dev = platform_get_drvdata(pdev);
 
-        v4l2_info(&dev->v4l2_dev, "Removing " MEM2MEM_TEST_MODULE_NAME);
+        v4l2_info(&dev->v4l2_dev, "Removing " MEM2MEM_NAME);
         v4l2_m2m_release(dev->m2m_dev);
         del_timer_sync(&dev->timer);
         video_unregister_device(dev->vfd);
@@ -1055,35 +1055,35 @@ static int m2mtest_remove(struct platform_device *pdev)
         return 0;
 }
 
-static struct platform_driver m2mtest_pdrv = {
-        .probe          = m2mtest_probe,
-        .remove         = m2mtest_remove,
+static struct platform_driver vim2m_pdrv = {
+        .probe          = vim2m_probe,
+        .remove         = vim2m_remove,
         .driver         = {
                 .name   = MEM2MEM_NAME,
                 .owner  = THIS_MODULE,
         },
 };
 
-static void __exit m2mtest_exit(void)
+static void __exit vim2m_exit(void)
 {
-        platform_driver_unregister(&m2mtest_pdrv);
-        platform_device_unregister(&m2mtest_pdev);
+        platform_driver_unregister(&vim2m_pdrv);
+        platform_device_unregister(&vim2m_pdev);
 }
 
-static int __init m2mtest_init(void)
+static int __init vim2m_init(void)
 {
         int ret;
 
-        ret = platform_device_register(&m2mtest_pdev);
+        ret = platform_device_register(&vim2m_pdev);
         if (ret)
                 return ret;
 
-        ret = platform_driver_register(&m2mtest_pdrv);
+        ret = platform_driver_register(&vim2m_pdrv);
         if (ret)
-                platform_device_unregister(&m2mtest_pdev);
+                platform_device_unregister(&vim2m_pdev);
 
         return 0;
 }
 
-module_init(m2mtest_init);
-module_exit(m2mtest_exit);
+module_init(vim2m_init);
+module_exit(vim2m_exit);
diff --git a/drivers/media/platform/vino.c b/drivers/media/platform/vino.c
index 91d44ea16f27..2c85357f774d 100644
--- a/drivers/media/platform/vino.c
+++ b/drivers/media/platform/vino.c
@@ -2932,10 +2932,8 @@ static int vino_querycap(struct file *file, void *__fh,
         strcpy(cap->driver, vino_driver_name);
         strcpy(cap->card, vino_driver_description);
         strcpy(cap->bus_info, vino_bus_name);
-        cap->capabilities =
-                V4L2_CAP_VIDEO_CAPTURE |
-                V4L2_CAP_STREAMING;
-        // V4L2_CAP_OVERLAY, V4L2_CAP_READWRITE
+        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/platform/vivid/vivid-core.c b/drivers/media/platform/vivid/vivid-core.c
index 686c3c2ad05b..a7e033a5d291 100644
--- a/drivers/media/platform/vivid/vivid-core.c
+++ b/drivers/media/platform/vivid/vivid-core.c
@@ -195,20 +195,6 @@ static const u8 vivid_hdmi_edid[256] = {
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd7
 };
 
-void vivid_lock(struct vb2_queue *vq)
-{
-        struct vivid_dev *dev = vb2_get_drv_priv(vq);
-
-        mutex_lock(&dev->mutex);
-}
-
-void vivid_unlock(struct vb2_queue *vq)
-{
-        struct vivid_dev *dev = vb2_get_drv_priv(vq);
-
-        mutex_unlock(&dev->mutex);
-}
-
 static int vidioc_querycap(struct file *file, void  *priv,
                                         struct v4l2_capability *cap)
 {
@@ -586,7 +572,7 @@ static const struct v4l2_ioctl_ops vivid_ioctl_ops = {
         .vidioc_querybuf                = vb2_ioctl_querybuf,
         .vidioc_qbuf                    = vb2_ioctl_qbuf,
         .vidioc_dqbuf                   = vb2_ioctl_dqbuf,
-/* Not yet      .vidioc_expbuf          = vb2_ioctl_expbuf,*/
+        .vidioc_expbuf                  = vb2_ioctl_expbuf,
         .vidioc_streamon                = vb2_ioctl_streamon,
         .vidioc_streamoff               = vb2_ioctl_streamoff,
 
@@ -1018,6 +1004,7 @@ static int __init vivid_create_instance(int inst)
                 q->mem_ops = &vb2_vmalloc_memops;
                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
                 q->min_buffers_needed = 2;
+                q->lock = &dev->mutex;
 
                 ret = vb2_queue_init(q);
                 if (ret)
@@ -1036,6 +1023,7 @@ static int __init vivid_create_instance(int inst)
                 q->mem_ops = &vb2_vmalloc_memops;
                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
                 q->min_buffers_needed = 2;
+                q->lock = &dev->mutex;
 
                 ret = vb2_queue_init(q);
                 if (ret)
@@ -1054,6 +1042,7 @@ static int __init vivid_create_instance(int inst)
                 q->mem_ops = &vb2_vmalloc_memops;
                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
                 q->min_buffers_needed = 2;
+                q->lock = &dev->mutex;
 
                 ret = vb2_queue_init(q);
                 if (ret)
@@ -1072,6 +1061,7 @@ static int __init vivid_create_instance(int inst)
                 q->mem_ops = &vb2_vmalloc_memops;
                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
                 q->min_buffers_needed = 2;
+                q->lock = &dev->mutex;
 
                 ret = vb2_queue_init(q);
                 if (ret)
@@ -1089,6 +1079,7 @@ static int __init vivid_create_instance(int inst)
                 q->mem_ops = &vb2_vmalloc_memops;
                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
                 q->min_buffers_needed = 8;
+                q->lock = &dev->mutex;
 
                 ret = vb2_queue_init(q);
                 if (ret)
diff --git a/drivers/media/platform/vivid/vivid-core.h b/drivers/media/platform/vivid/vivid-core.h
index 811c286491a5..4b497df4b6a4 100644
--- a/drivers/media/platform/vivid/vivid-core.h
+++ b/drivers/media/platform/vivid/vivid-core.h
@@ -116,6 +116,17 @@ enum vivid_signal_mode {
         CUSTOM_DV_TIMINGS,
 };
 
+enum vivid_colorspace {
+        VIVID_CS_170M,
+        VIVID_CS_709,
+        VIVID_CS_SRGB,
+        VIVID_CS_ADOBERGB,
+        VIVID_CS_2020,
+        VIVID_CS_240M,
+        VIVID_CS_SYS_M,
+        VIVID_CS_SYS_BG,
+};
+
 #define VIVID_INVALID_SIGNAL(mode) \
         ((mode) == NO_SIGNAL || (mode) == NO_LOCK || (mode) == OUT_OF_RANGE)
 
@@ -318,6 +329,8 @@ struct vivid_dev {
         v4l2_std_id                     std_out;
         struct v4l2_dv_timings          dv_timings_out;
         u32                             colorspace_out;
+        u32                             ycbcr_enc_out;
+        u32                             quantization_out;
         u32                             service_set_out;
         u32                             bytesperline_out[2];
         unsigned                        tv_field_out;
@@ -514,7 +527,4 @@ static inline bool vivid_is_hdmi_out(const struct vivid_dev *dev)
         return dev->output_type[dev->output] == HDMI;
 }
 
-void vivid_lock(struct vb2_queue *vq);
-void vivid_unlock(struct vb2_queue *vq);
-
 #endif
diff --git a/drivers/media/platform/vivid/vivid-ctrls.c b/drivers/media/platform/vivid/vivid-ctrls.c
index d5cbf0038f24..857e7866e8bc 100644
--- a/drivers/media/platform/vivid/vivid-ctrls.c
+++ b/drivers/media/platform/vivid/vivid-ctrls.c
@@ -40,6 +40,9 @@
 #define VIVID_CID_STRING                (VIVID_CID_CUSTOM_BASE + 5)
 #define VIVID_CID_BITMASK               (VIVID_CID_CUSTOM_BASE + 6)
 #define VIVID_CID_INTMENU               (VIVID_CID_CUSTOM_BASE + 7)
+#define VIVID_CID_U32_ARRAY             (VIVID_CID_CUSTOM_BASE + 8)
+#define VIVID_CID_U16_MATRIX            (VIVID_CID_CUSTOM_BASE + 9)
+#define VIVID_CID_U8_4D_ARRAY           (VIVID_CID_CUSTOM_BASE + 10)
 
 #define VIVID_CID_VIVID_BASE            (0x00f00000 | 0xf000)
 #define VIVID_CID_VIVID_CLASS           (0x00f00000 | 1)
@@ -59,19 +62,21 @@
 #define VIVID_CID_DV_TIMINGS_ASPECT_RATIO       (VIVID_CID_VIVID_BASE + 23)
 #define VIVID_CID_TSTAMP_SRC            (VIVID_CID_VIVID_BASE + 24)
 #define VIVID_CID_COLORSPACE            (VIVID_CID_VIVID_BASE + 25)
-#define VIVID_CID_LIMITED_RGB_RANGE     (VIVID_CID_VIVID_BASE + 26)
-#define VIVID_CID_ALPHA_MODE            (VIVID_CID_VIVID_BASE + 27)
-#define VIVID_CID_HAS_CROP_CAP          (VIVID_CID_VIVID_BASE + 28)
-#define VIVID_CID_HAS_COMPOSE_CAP       (VIVID_CID_VIVID_BASE + 29)
-#define VIVID_CID_HAS_SCALER_CAP        (VIVID_CID_VIVID_BASE + 30)
-#define VIVID_CID_HAS_CROP_OUT          (VIVID_CID_VIVID_BASE + 31)
-#define VIVID_CID_HAS_COMPOSE_OUT       (VIVID_CID_VIVID_BASE + 32)
-#define VIVID_CID_HAS_SCALER_OUT        (VIVID_CID_VIVID_BASE + 33)
-#define VIVID_CID_LOOP_VIDEO            (VIVID_CID_VIVID_BASE + 34)
-#define VIVID_CID_SEQ_WRAP              (VIVID_CID_VIVID_BASE + 35)
-#define VIVID_CID_TIME_WRAP             (VIVID_CID_VIVID_BASE + 36)
-#define VIVID_CID_MAX_EDID_BLOCKS       (VIVID_CID_VIVID_BASE + 37)
-#define VIVID_CID_PERCENTAGE_FILL       (VIVID_CID_VIVID_BASE + 38)
+#define VIVID_CID_YCBCR_ENC             (VIVID_CID_VIVID_BASE + 26)
+#define VIVID_CID_QUANTIZATION          (VIVID_CID_VIVID_BASE + 27)
+#define VIVID_CID_LIMITED_RGB_RANGE     (VIVID_CID_VIVID_BASE + 28)
+#define VIVID_CID_ALPHA_MODE            (VIVID_CID_VIVID_BASE + 29)
+#define VIVID_CID_HAS_CROP_CAP          (VIVID_CID_VIVID_BASE + 30)
+#define VIVID_CID_HAS_COMPOSE_CAP       (VIVID_CID_VIVID_BASE + 31)
+#define VIVID_CID_HAS_SCALER_CAP        (VIVID_CID_VIVID_BASE + 32)
+#define VIVID_CID_HAS_CROP_OUT          (VIVID_CID_VIVID_BASE + 33)
+#define VIVID_CID_HAS_COMPOSE_OUT       (VIVID_CID_VIVID_BASE + 34)
+#define VIVID_CID_HAS_SCALER_OUT        (VIVID_CID_VIVID_BASE + 35)
+#define VIVID_CID_LOOP_VIDEO            (VIVID_CID_VIVID_BASE + 36)
+#define VIVID_CID_SEQ_WRAP              (VIVID_CID_VIVID_BASE + 37)
+#define VIVID_CID_TIME_WRAP             (VIVID_CID_VIVID_BASE + 38)
+#define VIVID_CID_MAX_EDID_BLOCKS       (VIVID_CID_VIVID_BASE + 39)
+#define VIVID_CID_PERCENTAGE_FILL       (VIVID_CID_VIVID_BASE + 40)
 
 #define VIVID_CID_STD_SIGNAL_MODE       (VIVID_CID_VIVID_BASE + 60)
 #define VIVID_CID_STANDARD              (VIVID_CID_VIVID_BASE + 61)
@@ -163,6 +168,42 @@ static const struct v4l2_ctrl_config vivid_ctrl_int64 = {
         .step = 1,
 };
 
+static const struct v4l2_ctrl_config vivid_ctrl_u32_array = {
+        .ops = &vivid_user_gen_ctrl_ops,
+        .id = VIVID_CID_U32_ARRAY,
+        .name = "U32 1 Element Array",
+        .type = V4L2_CTRL_TYPE_U32,
+        .def = 0x18,
+        .min = 0x10,
+        .max = 0x20000,
+        .step = 1,
+        .dims = { 1 },
+};
+
+static const struct v4l2_ctrl_config vivid_ctrl_u16_matrix = {
+        .ops = &vivid_user_gen_ctrl_ops,
+        .id = VIVID_CID_U16_MATRIX,
+        .name = "U16 8x16 Matrix",
+        .type = V4L2_CTRL_TYPE_U16,
+        .def = 0x18,
+        .min = 0x10,
+        .max = 0x2000,
+        .step = 1,
+        .dims = { 8, 16 },
+};
+
+static const struct v4l2_ctrl_config vivid_ctrl_u8_4d_array = {
+        .ops = &vivid_user_gen_ctrl_ops,
+        .id = VIVID_CID_U8_4D_ARRAY,
+        .name = "U8 2x3x4x5 Array",
+        .type = V4L2_CTRL_TYPE_U8,
+        .def = 0x18,
+        .min = 0x10,
+        .max = 0x20,
+        .step = 1,
+        .dims = { 2, 3, 4, 5 },
+};
+
 static const char * const vivid_ctrl_menu_strings[] = {
         "Menu Item 0 (Skipped)",
         "Menu Item 1",
@@ -294,6 +335,16 @@ static const struct v4l2_ctrl_ops vivid_user_vid_ctrl_ops = {
 
 static int vivid_vid_cap_s_ctrl(struct v4l2_ctrl *ctrl)
 {
+        static const u32 colorspaces[] = {
+                V4L2_COLORSPACE_SMPTE170M,
+                V4L2_COLORSPACE_REC709,
+                V4L2_COLORSPACE_SRGB,
+                V4L2_COLORSPACE_ADOBERGB,
+                V4L2_COLORSPACE_BT2020,
+                V4L2_COLORSPACE_SMPTE240M,
+                V4L2_COLORSPACE_470_SYSTEM_M,
+                V4L2_COLORSPACE_470_SYSTEM_BG,
+        };
         struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vid_cap);
         unsigned i;
 
@@ -303,7 +354,21 @@ static int vivid_vid_cap_s_ctrl(struct v4l2_ctrl *ctrl)
                 tpg_s_pattern(&dev->tpg, ctrl->val);
                 break;
         case VIVID_CID_COLORSPACE:
-                tpg_s_colorspace(&dev->tpg, ctrl->val);
+                tpg_s_colorspace(&dev->tpg, colorspaces[ctrl->val]);
+                vivid_send_source_change(dev, TV);
+                vivid_send_source_change(dev, SVID);
+                vivid_send_source_change(dev, HDMI);
+                vivid_send_source_change(dev, WEBCAM);
+                break;
+        case VIVID_CID_YCBCR_ENC:
+                tpg_s_ycbcr_enc(&dev->tpg, ctrl->val);
+                vivid_send_source_change(dev, TV);
+                vivid_send_source_change(dev, SVID);
+                vivid_send_source_change(dev, HDMI);
+                vivid_send_source_change(dev, WEBCAM);
+                break;
+        case VIVID_CID_QUANTIZATION:
+                tpg_s_quantization(&dev->tpg, ctrl->val);
                 vivid_send_source_change(dev, TV);
                 vivid_send_source_change(dev, SVID);
                 vivid_send_source_change(dev, HDMI);
@@ -623,15 +688,14 @@ static const struct v4l2_ctrl_config vivid_ctrl_max_edid_blocks = {
 };
 
 static const char * const vivid_ctrl_colorspace_strings[] = {
-        "",
         "SMPTE 170M",
-        "SMPTE 240M",
         "REC 709",
-        "", /* Skip Bt878 entry */
+        "sRGB",
+        "AdobeRGB",
+        "BT.2020",
+        "SMPTE 240M",
         "470 System M",
         "470 System BG",
-        "", /* Skip JPEG entry */
-        "sRGB",
         NULL,
 };
 
@@ -640,13 +704,49 @@ static const struct v4l2_ctrl_config vivid_ctrl_colorspace = {
         .id = VIVID_CID_COLORSPACE,
         .name = "Colorspace",
         .type = V4L2_CTRL_TYPE_MENU,
-        .min = 1,
-        .max = 8,
-        .menu_skip_mask = (1 << 4) | (1 << 7),
-        .def = 8,
+        .max = 7,
+        .def = 2,
         .qmenu = vivid_ctrl_colorspace_strings,
 };
 
+static const char * const vivid_ctrl_ycbcr_enc_strings[] = {
+        "Default",
+        "ITU-R 601",
+        "Rec. 709",
+        "xvYCC 601",
+        "xvYCC 709",
+        "sYCC",
+        "BT.2020 Non-Constant Luminance",
+        "BT.2020 Constant Luminance",
+        "SMPTE 240M",
+        NULL,
+};
+
+static const struct v4l2_ctrl_config vivid_ctrl_ycbcr_enc = {
+        .ops = &vivid_vid_cap_ctrl_ops,
+        .id = VIVID_CID_YCBCR_ENC,
+        .name = "Y'CbCr Encoding",
+        .type = V4L2_CTRL_TYPE_MENU,
+        .max = 8,
+        .qmenu = vivid_ctrl_ycbcr_enc_strings,
+};
+
+static const char * const vivid_ctrl_quantization_strings[] = {
+        "Default",
+        "Full Range",
+        "Limited Range",
+        NULL,
+};
+
+static const struct v4l2_ctrl_config vivid_ctrl_quantization = {
+        .ops = &vivid_vid_cap_ctrl_ops,
+        .id = VIVID_CID_QUANTIZATION,
+        .name = "Quantization",
+        .type = V4L2_CTRL_TYPE_MENU,
+        .max = 2,
+        .qmenu = vivid_ctrl_quantization_strings,
+};
+
 static const struct v4l2_ctrl_config vivid_ctrl_alpha_mode = {
         .ops = &vivid_vid_cap_ctrl_ops,
         .id = VIVID_CID_ALPHA_MODE,
@@ -723,8 +823,12 @@ static int vivid_vid_out_s_ctrl(struct v4l2_ctrl *ctrl)
                                 dev->colorspace_out = V4L2_COLORSPACE_SMPTE170M;
                         else
                                 dev->colorspace_out = V4L2_COLORSPACE_REC709;
+                        dev->quantization_out = V4L2_QUANTIZATION_DEFAULT;
                 } else {
                         dev->colorspace_out = V4L2_COLORSPACE_SRGB;
+                        dev->quantization_out = dev->dvi_d_out ?
+                                        V4L2_QUANTIZATION_LIM_RANGE :
+                                        V4L2_QUANTIZATION_DEFAULT;
                 }
                 if (dev->loop_video)
                         vivid_send_source_change(dev, HDMI);
@@ -792,15 +896,15 @@ static int vivid_streaming_s_ctrl(struct v4l2_ctrl *ctrl)
                 dev->start_streaming_error = true;
                 break;
         case VIVID_CID_QUEUE_ERROR:
-                if (dev->vb_vid_cap_q.start_streaming_called)
+                if (vb2_start_streaming_called(&dev->vb_vid_cap_q))
                         vb2_queue_error(&dev->vb_vid_cap_q);
-                if (dev->vb_vbi_cap_q.start_streaming_called)
+                if (vb2_start_streaming_called(&dev->vb_vbi_cap_q))
                         vb2_queue_error(&dev->vb_vbi_cap_q);
-                if (dev->vb_vid_out_q.start_streaming_called)
+                if (vb2_start_streaming_called(&dev->vb_vid_out_q))
                         vb2_queue_error(&dev->vb_vid_out_q);
-                if (dev->vb_vbi_out_q.start_streaming_called)
+                if (vb2_start_streaming_called(&dev->vb_vbi_out_q))
                         vb2_queue_error(&dev->vb_vbi_out_q);
-                if (dev->vb_sdr_cap_q.start_streaming_called)
+                if (vb2_start_streaming_called(&dev->vb_sdr_cap_q))
                         vb2_queue_error(&dev->vb_sdr_cap_q);
                 break;
         case VIVID_CID_SEQ_WRAP:
@@ -1222,6 +1326,9 @@ int vivid_create_controls(struct vivid_dev *dev, bool show_ccs_cap,
         dev->string = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_string, NULL);
         dev->bitmask = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_bitmask, NULL);
         dev->int_menu = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int_menu, NULL);
+        v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u32_array, NULL);
+        v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u16_matrix, NULL);
+        v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u8_4d_array, NULL);
 
         if (dev->has_vid_cap) {
                 /* Image Processing Controls */
@@ -1258,6 +1365,8 @@ int vivid_create_controls(struct vivid_dev *dev, bool show_ccs_cap,
                 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_tstamp_src, NULL);
                 dev->colorspace = v4l2_ctrl_new_custom(hdl_vid_cap,
                         &vivid_ctrl_colorspace, NULL);
+                v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_ycbcr_enc, NULL);
+                v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_quantization, NULL);
                 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_alpha_mode, NULL);
         }
 
diff --git a/drivers/media/platform/vivid/vivid-sdr-cap.c b/drivers/media/platform/vivid/vivid-sdr-cap.c
index 8c5d661cfc49..4af55f18829f 100644
--- a/drivers/media/platform/vivid/vivid-sdr-cap.c
+++ b/drivers/media/platform/vivid/vivid-sdr-cap.c
@@ -297,8 +297,8 @@ const struct vb2_ops vivid_sdr_cap_qops = {
         .buf_queue              = sdr_cap_buf_queue,
         .start_streaming        = sdr_cap_start_streaming,
         .stop_streaming         = sdr_cap_stop_streaming,
-        .wait_prepare           = vivid_unlock,
-        .wait_finish            = vivid_lock,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
 };
 
 int vivid_sdr_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band)
diff --git a/drivers/media/platform/vivid/vivid-tpg-colors.c b/drivers/media/platform/vivid/vivid-tpg-colors.c
index 2adddc0ca662..424aa7abc723 100644
--- a/drivers/media/platform/vivid/vivid-tpg-colors.c
+++ b/drivers/media/platform/vivid/vivid-tpg-colors.c
@@ -12,7 +12,7 @@
  * This source also contains the code used to generate the tpg_csc_colors
  * table. Run the following command to compile it:
  *
- *      gcc vivid-colors.c -DCOMPILE_APP -o gen-colors -lm
+ *      gcc vivid-tpg-colors.c -DCOMPILE_APP -o gen-colors -lm
  *
  * and run the utility.
  *
@@ -78,22 +78,542 @@ const struct color tpg_colors[TPG_COLOR_MAX] = {
 #ifndef COMPILE_APP
 
 /* Generated table */
-const struct color16 tpg_csc_colors[V4L2_COLORSPACE_SRGB + 1][TPG_COLOR_CSC_BLACK + 1] = {
-        [V4L2_COLORSPACE_SMPTE170M][0] = { 2953, 2939, 2939 },
-        [V4L2_COLORSPACE_SMPTE170M][1] = { 2954, 2963, 585 },
-        [V4L2_COLORSPACE_SMPTE170M][2] = { 84, 2967, 2937 },
-        [V4L2_COLORSPACE_SMPTE170M][3] = { 93, 2990, 575 },
-        [V4L2_COLORSPACE_SMPTE170M][4] = { 3030, 259, 2933 },
-        [V4L2_COLORSPACE_SMPTE170M][5] = { 3031, 406, 557 },
-        [V4L2_COLORSPACE_SMPTE170M][6] = { 544, 428, 2931 },
-        [V4L2_COLORSPACE_SMPTE170M][7] = { 551, 547, 547 },
+const unsigned short tpg_rec709_to_linear[255 * 16 + 1] = {
+           0,    0,    0,    1,    1,    1,    1,    2,    2,    2,    2,    2,    3,    3,    3,    3,
+           4,    4,    4,    4,    4,    5,    5,    5,    5,    6,    6,    6,    6,    6,    7,    7,
+           7,    7,    8,    8,    8,    8,    8,    9,    9,    9,    9,   10,   10,   10,   10,   10,
+          11,   11,   11,   11,   12,   12,   12,   12,   12,   13,   13,   13,   13,   14,   14,   14,
+          14,   14,   15,   15,   15,   15,   16,   16,   16,   16,   16,   17,   17,   17,   17,   18,
+          18,   18,   18,   18,   19,   19,   19,   19,   20,   20,   20,   20,   20,   21,   21,   21,
+          21,   22,   22,   22,   22,   22,   23,   23,   23,   23,   24,   24,   24,   24,   24,   25,
+          25,   25,   25,   26,   26,   26,   26,   26,   27,   27,   27,   27,   28,   28,   28,   28,
+          28,   29,   29,   29,   29,   30,   30,   30,   30,   30,   31,   31,   31,   31,   32,   32,
+          32,   32,   32,   33,   33,   33,   33,   34,   34,   34,   34,   34,   35,   35,   35,   35,
+          36,   36,   36,   36,   36,   37,   37,   37,   37,   38,   38,   38,   38,   38,   39,   39,
+          39,   39,   40,   40,   40,   40,   40,   41,   41,   41,   41,   42,   42,   42,   42,   42,
+          43,   43,   43,   43,   44,   44,   44,   44,   44,   45,   45,   45,   45,   46,   46,   46,
+          46,   46,   47,   47,   47,   47,   48,   48,   48,   48,   48,   49,   49,   49,   49,   50,
+          50,   50,   50,   50,   51,   51,   51,   51,   52,   52,   52,   52,   52,   53,   53,   53,
+          53,   54,   54,   54,   54,   54,   55,   55,   55,   55,   56,   56,   56,   56,   56,   57,
+          57,   57,   57,   58,   58,   58,   58,   58,   59,   59,   59,   59,   60,   60,   60,   60,
+          60,   61,   61,   61,   61,   62,   62,   62,   62,   62,   63,   63,   63,   63,   64,   64,
+          64,   64,   64,   65,   65,   65,   65,   66,   66,   66,   66,   66,   67,   67,   67,   67,
+          68,   68,   68,   68,   68,   69,   69,   69,   69,   70,   70,   70,   70,   70,   71,   71,
+          71,   71,   72,   72,   72,   72,   72,   73,   73,   73,   73,   73,   74,   74,   74,   74,
+          74,   75,   75,   75,   75,   76,   76,   76,   76,   76,   77,   77,   77,   77,   78,   78,
+          78,   78,   79,   79,   79,   79,   79,   80,   80,   80,   80,   81,   81,   81,   81,   82,
+          82,   82,   82,   82,   83,   83,   83,   83,   84,   84,   84,   84,   85,   85,   85,   85,
+          86,   86,   86,   86,   87,   87,   87,   87,   88,   88,   88,   88,   89,   89,   89,   89,
+          90,   90,   90,   90,   91,   91,   91,   91,   92,   92,   92,   92,   93,   93,   93,   93,
+          94,   94,   94,   94,   95,   95,   95,   95,   96,   96,   96,   96,   97,   97,   97,   97,
+          98,   98,   98,   98,   99,   99,   99,   99,  100,  100,  100,  101,  101,  101,  101,  102,
+         102,  102,  102,  103,  103,  103,  103,  104,  104,  104,  105,  105,  105,  105,  106,  106,
+         106,  106,  107,  107,  107,  107,  108,  108,  108,  109,  109,  109,  109,  110,  110,  110,
+         111,  111,  111,  111,  112,  112,  112,  112,  113,  113,  113,  114,  114,  114,  114,  115,
+         115,  115,  116,  116,  116,  116,  117,  117,  117,  118,  118,  118,  118,  119,  119,  119,
+         120,  120,  120,  120,  121,  121,  121,  122,  122,  122,  123,  123,  123,  123,  124,  124,
+         124,  125,  125,  125,  125,  126,  126,  126,  127,  127,  127,  128,  128,  128,  128,  129,
+         129,  129,  130,  130,  130,  131,  131,  131,  132,  132,  132,  132,  133,  133,  133,  134,
+         134,  134,  135,  135,  135,  136,  136,  136,  136,  137,  137,  137,  138,  138,  138,  139,
+         139,  139,  140,  140,  140,  141,  141,  141,  142,  142,  142,  142,  143,  143,  143,  144,
+         144,  144,  145,  145,  145,  146,  146,  146,  147,  147,  147,  148,  148,  148,  149,  149,
+         149,  150,  150,  150,  151,  151,  151,  152,  152,  152,  153,  153,  153,  154,  154,  154,
+         155,  155,  155,  156,  156,  156,  157,  157,  157,  158,  158,  158,  159,  159,  159,  160,
+         160,  160,  161,  161,  161,  162,  162,  162,  163,  163,  163,  164,  164,  164,  165,  165,
+         165,  166,  166,  167,  167,  167,  168,  168,  168,  169,  169,  169,  170,  170,  170,  171,
+         171,  171,  172,  172,  172,  173,  173,  174,  174,  174,  175,  175,  175,  176,  176,  176,
+         177,  177,  177,  178,  178,  179,  179,  179,  180,  180,  180,  181,  181,  181,  182,  182,
+         183,  183,  183,  184,  184,  184,  185,  185,  186,  186,  186,  187,  187,  187,  188,  188,
+         188,  189,  189,  190,  190,  190,  191,  191,  191,  192,  192,  193,  193,  193,  194,  194,
+         194,  195,  195,  196,  196,  196,  197,  197,  198,  198,  198,  199,  199,  199,  200,  200,
+         201,  201,  201,  202,  202,  203,  203,  203,  204,  204,  204,  205,  205,  206,  206,  206,
+         207,  207,  208,  208,  208,  209,  209,  210,  210,  210,  211,  211,  212,  212,  212,  213,
+         213,  214,  214,  214,  215,  215,  216,  216,  216,  217,  217,  218,  218,  218,  219,  219,
+         220,  220,  220,  221,  221,  222,  222,  222,  223,  223,  224,  224,  224,  225,  225,  226,
+         226,  227,  227,  227,  228,  228,  229,  229,  229,  230,  230,  231,  231,  232,  232,  232,
+         233,  233,  234,  234,  234,  235,  235,  236,  236,  237,  237,  237,  238,  238,  239,  239,
+         240,  240,  240,  241,  241,  242,  242,  243,  243,  243,  244,  244,  245,  245,  246,  246,
+         246,  247,  247,  248,  248,  249,  249,  249,  250,  250,  251,  251,  252,  252,  252,  253,
+         253,  254,  254,  255,  255,  256,  256,  256,  257,  257,  258,  258,  259,  259,  260,  260,
+         260,  261,  261,  262,  262,  263,  263,  264,  264,  264,  265,  265,  266,  266,  267,  267,
+         268,  268,  269,  269,  269,  270,  270,  271,  271,  272,  272,  273,  273,  274,  274,  274,
+         275,  275,  276,  276,  277,  277,  278,  278,  279,  279,  279,  280,  280,  281,  281,  282,
+         282,  283,  283,  284,  284,  285,  285,  286,  286,  286,  287,  287,  288,  288,  289,  289,
+         290,  290,  291,  291,  292,  292,  293,  293,  294,  294,  295,  295,  295,  296,  296,  297,
+         297,  298,  298,  299,  299,  300,  300,  301,  301,  302,  302,  303,  303,  304,  304,  305,
+         305,  306,  306,  307,  307,  308,  308,  309,  309,  309,  310,  310,  311,  311,  312,  312,
+         313,  313,  314,  314,  315,  315,  316,  316,  317,  317,  318,  318,  319,  319,  320,  320,
+         321,  321,  322,  322,  323,  323,  324,  324,  325,  325,  326,  326,  327,  327,  328,  328,
+         329,  329,  330,  330,  331,  331,  332,  332,  333,  333,  334,  335,  335,  336,  336,  337,
+         337,  338,  338,  339,  339,  340,  340,  341,  341,  342,  342,  343,  343,  344,  344,  345,
+         345,  346,  346,  347,  347,  348,  348,  349,  349,  350,  351,  351,  352,  352,  353,  353,
+         354,  354,  355,  355,  356,  356,  357,  357,  358,  358,  359,  360,  360,  361,  361,  362,
+         362,  363,  363,  364,  364,  365,  365,  366,  366,  367,  368,  368,  369,  369,  370,  370,
+         371,  371,  372,  372,  373,  373,  374,  375,  375,  376,  376,  377,  377,  378,  378,  379,
+         379,  380,  381,  381,  382,  382,  383,  383,  384,  384,  385,  386,  386,  387,  387,  388,
+         388,  389,  389,  390,  391,  391,  392,  392,  393,  393,  394,  394,  395,  396,  396,  397,
+         397,  398,  398,  399,  399,  400,  401,  401,  402,  402,  403,  403,  404,  405,  405,  406,
+         406,  407,  407,  408,  409,  409,  410,  410,  411,  411,  412,  413,  413,  414,  414,  415,
+         415,  416,  417,  417,  418,  418,  419,  419,  420,  421,  421,  422,  422,  423,  424,  424,
+         425,  425,  426,  426,  427,  428,  428,  429,  429,  430,  431,  431,  432,  432,  433,  433,
+         434,  435,  435,  436,  436,  437,  438,  438,  439,  439,  440,  441,  441,  442,  442,  443,
+         444,  444,  445,  445,  446,  447,  447,  448,  448,  449,  450,  450,  451,  451,  452,  453,
+         453,  454,  454,  455,  456,  456,  457,  457,  458,  459,  459,  460,  460,  461,  462,  462,
+         463,  463,  464,  465,  465,  466,  467,  467,  468,  468,  469,  470,  470,  471,  471,  472,
+         473,  473,  474,  475,  475,  476,  476,  477,  478,  478,  479,  480,  480,  481,  481,  482,
+         483,  483,  484,  485,  485,  486,  486,  487,  488,  488,  489,  490,  490,  491,  491,  492,
+         493,  493,  494,  495,  495,  496,  497,  497,  498,  498,  499,  500,  500,  501,  502,  502,
+         503,  504,  504,  505,  505,  506,  507,  507,  508,  509,  509,  510,  511,  511,  512,  513,
+         513,  514,  514,  515,  516,  516,  517,  518,  518,  519,  520,  520,  521,  522,  522,  523,
+         524,  524,  525,  526,  526,  527,  528,  528,  529,  529,  530,  531,  531,  532,  533,  533,
+         534,  535,  535,  536,  537,  537,  538,  539,  539,  540,  541,  541,  542,  543,  543,  544,
+         545,  545,  546,  547,  547,  548,  549,  549,  550,  551,  551,  552,  553,  553,  554,  555,
+         555,  556,  557,  557,  558,  559,  560,  560,  561,  562,  562,  563,  564,  564,  565,  566,
+         566,  567,  568,  568,  569,  570,  570,  571,  572,  572,  573,  574,  575,  575,  576,  577,
+         577,  578,  579,  579,  580,  581,  581,  582,  583,  584,  584,  585,  586,  586,  587,  588,
+         588,  589,  590,  590,  591,  592,  593,  593,  594,  595,  595,  596,  597,  598,  598,  599,
+         600,  600,  601,  602,  602,  603,  604,  605,  605,  606,  607,  607,  608,  609,  610,  610,
+         611,  612,  612,  613,  614,  615,  615,  616,  617,  617,  618,  619,  620,  620,  621,  622,
+         622,  623,  624,  625,  625,  626,  627,  627,  628,  629,  630,  630,  631,  632,  632,  633,
+         634,  635,  635,  636,  637,  638,  638,  639,  640,  640,  641,  642,  643,  643,  644,  645,
+         646,  646,  647,  648,  649,  649,  650,  651,  652,  652,  653,  654,  654,  655,  656,  657,
+         657,  658,  659,  660,  660,  661,  662,  663,  663,  664,  665,  666,  666,  667,  668,  669,
+         669,  670,  671,  672,  672,  673,  674,  675,  675,  676,  677,  678,  678,  679,  680,  681,
+         681,  682,  683,  684,  684,  685,  686,  687,  687,  688,  689,  690,  690,  691,  692,  693,
+         694,  694,  695,  696,  697,  697,  698,  699,  700,  700,  701,  702,  703,  703,  704,  705,
+         706,  707,  707,  708,  709,  710,  710,  711,  712,  713,  714,  714,  715,  716,  717,  717,
+         718,  719,  720,  720,  721,  722,  723,  724,  724,  725,  726,  727,  728,  728,  729,  730,
+         731,  731,  732,  733,  734,  735,  735,  736,  737,  738,  739,  739,  740,  741,  742,  742,
+         743,  744,  745,  746,  746,  747,  748,  749,  750,  750,  751,  752,  753,  754,  754,  755,
+         756,  757,  758,  758,  759,  760,  761,  762,  762,  763,  764,  765,  766,  766,  767,  768,
+         769,  770,  771,  771,  772,  773,  774,  775,  775,  776,  777,  778,  779,  779,  780,  781,
+         782,  783,  783,  784,  785,  786,  787,  788,  788,  789,  790,  791,  792,  793,  793,  794,
+         795,  796,  797,  797,  798,  799,  800,  801,  802,  802,  803,  804,  805,  806,  807,  807,
+         808,  809,  810,  811,  812,  812,  813,  814,  815,  816,  817,  817,  818,  819,  820,  821,
+         822,  822,  823,  824,  825,  826,  827,  827,  828,  829,  830,  831,  832,  832,  833,  834,
+         835,  836,  837,  838,  838,  839,  840,  841,  842,  843,  843,  844,  845,  846,  847,  848,
+         849,  849,  850,  851,  852,  853,  854,  855,  855,  856,  857,  858,  859,  860,  861,  861,
+         862,  863,  864,  865,  866,  867,  867,  868,  869,  870,  871,  872,  873,  873,  874,  875,
+         876,  877,  878,  879,  880,  880,  881,  882,  883,  884,  885,  886,  887,  887,  888,  889,
+         890,  891,  892,  893,  894,  894,  895,  896,  897,  898,  899,  900,  901,  901,  902,  903,
+         904,  905,  906,  907,  908,  909,  909,  910,  911,  912,  913,  914,  915,  916,  916,  917,
+         918,  919,  920,  921,  922,  923,  924,  925,  925,  926,  927,  928,  929,  930,  931,  932,
+         933,  933,  934,  935,  936,  937,  938,  939,  940,  941,  942,  942,  943,  944,  945,  946,
+         947,  948,  949,  950,  951,  952,  952,  953,  954,  955,  956,  957,  958,  959,  960,  961,
+         962,  962,  963,  964,  965,  966,  967,  968,  969,  970,  971,  972,  973,  973,  974,  975,
+         976,  977,  978,  979,  980,  981,  982,  983,  984,  985,  985,  986,  987,  988,  989,  990,
+         991,  992,  993,  994,  995,  996,  997,  998,  998,  999, 1000, 1001, 1002, 1003, 1004, 1005,
+        1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020,
+        1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1030, 1031, 1032, 1033, 1034, 1035,
+        1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1050,
+        1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066,
+        1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1078, 1079, 1080, 1081,
+        1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097,
+        1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
+        1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129,
+        1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
+        1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
+        1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
+        1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1193, 1194,
+        1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210,
+        1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1223, 1224, 1225, 1226, 1227,
+        1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243,
+        1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260,
+        1261, 1262, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277,
+        1278, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1295,
+        1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1309, 1310, 1311, 1312,
+        1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329,
+        1330, 1331, 1332, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1345, 1346, 1347,
+        1348, 1349, 1350, 1351, 1352, 1353, 1354, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364,
+        1365, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1377, 1378, 1379, 1380, 1381, 1382,
+        1383, 1384, 1385, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1396, 1397, 1398, 1399, 1400,
+        1401, 1402, 1403, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1414, 1415, 1416, 1417, 1418,
+        1419, 1420, 1421, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1431, 1432, 1433, 1434, 1435, 1436,
+        1437, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1448, 1449, 1450, 1451, 1452, 1453, 1455,
+        1456, 1457, 1458, 1459, 1460, 1461, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1471, 1472, 1473,
+        1474, 1475, 1476, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1486, 1487, 1488, 1489, 1490, 1491,
+        1493, 1494, 1495, 1496, 1497, 1498, 1500, 1501, 1502, 1503, 1504, 1505, 1507, 1508, 1509, 1510,
+        1511, 1512, 1514, 1515, 1516, 1517, 1518, 1519, 1521, 1522, 1523, 1524, 1525, 1527, 1528, 1529,
+        1530, 1531, 1532, 1534, 1535, 1536, 1537, 1538, 1540, 1541, 1542, 1543, 1544, 1545, 1547, 1548,
+        1549, 1550, 1551, 1553, 1554, 1555, 1556, 1557, 1559, 1560, 1561, 1562, 1563, 1564, 1566, 1567,
+        1568, 1569, 1570, 1572, 1573, 1574, 1575, 1576, 1578, 1579, 1580, 1581, 1582, 1584, 1585, 1586,
+        1587, 1588, 1590, 1591, 1592, 1593, 1594, 1596, 1597, 1598, 1599, 1601, 1602, 1603, 1604, 1605,
+        1607, 1608, 1609, 1610, 1611, 1613, 1614, 1615, 1616, 1617, 1619, 1620, 1621, 1622, 1624, 1625,
+        1626, 1627, 1628, 1630, 1631, 1632, 1633, 1635, 1636, 1637, 1638, 1639, 1641, 1642, 1643, 1644,
+        1646, 1647, 1648, 1649, 1650, 1652, 1653, 1654, 1655, 1657, 1658, 1659, 1660, 1662, 1663, 1664,
+        1665, 1667, 1668, 1669, 1670, 1671, 1673, 1674, 1675, 1676, 1678, 1679, 1680, 1681, 1683, 1684,
+        1685, 1686, 1688, 1689, 1690, 1691, 1693, 1694, 1695, 1696, 1698, 1699, 1700, 1701, 1703, 1704,
+        1705, 1706, 1708, 1709, 1710, 1711, 1713, 1714, 1715, 1716, 1718, 1719, 1720, 1721, 1723, 1724,
+        1725, 1726, 1728, 1729, 1730, 1731, 1733, 1734, 1735, 1737, 1738, 1739, 1740, 1742, 1743, 1744,
+        1745, 1747, 1748, 1749, 1750, 1752, 1753, 1754, 1756, 1757, 1758, 1759, 1761, 1762, 1763, 1764,
+        1766, 1767, 1768, 1770, 1771, 1772, 1773, 1775, 1776, 1777, 1778, 1780, 1781, 1782, 1784, 1785,
+        1786, 1787, 1789, 1790, 1791, 1793, 1794, 1795, 1796, 1798, 1799, 1800, 1802, 1803, 1804, 1806,
+        1807, 1808, 1809, 1811, 1812, 1813, 1815, 1816, 1817, 1818, 1820, 1821, 1822, 1824, 1825, 1826,
+        1828, 1829, 1830, 1831, 1833, 1834, 1835, 1837, 1838, 1839, 1841, 1842, 1843, 1844, 1846, 1847,
+        1848, 1850, 1851, 1852, 1854, 1855, 1856, 1858, 1859, 1860, 1862, 1863, 1864, 1865, 1867, 1868,
+        1869, 1871, 1872, 1873, 1875, 1876, 1877, 1879, 1880, 1881, 1883, 1884, 1885, 1887, 1888, 1889,
+        1891, 1892, 1893, 1894, 1896, 1897, 1898, 1900, 1901, 1902, 1904, 1905, 1906, 1908, 1909, 1910,
+        1912, 1913, 1914, 1916, 1917, 1918, 1920, 1921, 1922, 1924, 1925, 1926, 1928, 1929, 1930, 1932,
+        1933, 1935, 1936, 1937, 1939, 1940, 1941, 1943, 1944, 1945, 1947, 1948, 1949, 1951, 1952, 1953,
+        1955, 1956, 1957, 1959, 1960, 1961, 1963, 1964, 1965, 1967, 1968, 1970, 1971, 1972, 1974, 1975,
+        1976, 1978, 1979, 1980, 1982, 1983, 1984, 1986, 1987, 1989, 1990, 1991, 1993, 1994, 1995, 1997,
+        1998, 1999, 2001, 2002, 2004, 2005, 2006, 2008, 2009, 2010, 2012, 2013, 2015, 2016, 2017, 2019,
+        2020, 2021, 2023, 2024, 2026, 2027, 2028, 2030, 2031, 2032, 2034, 2035, 2037, 2038, 2039, 2041,
+        2042, 2043, 2045, 2046, 2048, 2049, 2050, 2052, 2053, 2055, 2056, 2057, 2059, 2060, 2061, 2063,
+        2064, 2066, 2067, 2068, 2070, 2071, 2073, 2074, 2075, 2077, 2078, 2080, 2081, 2082, 2084, 2085,
+        2087, 2088, 2089, 2091, 2092, 2094, 2095, 2096, 2098, 2099, 2101, 2102, 2103, 2105, 2106, 2108,
+        2109, 2110, 2112, 2113, 2115, 2116, 2117, 2119, 2120, 2122, 2123, 2124, 2126, 2127, 2129, 2130,
+        2132, 2133, 2134, 2136, 2137, 2139, 2140, 2141, 2143, 2144, 2146, 2147, 2149, 2150, 2151, 2153,
+        2154, 2156, 2157, 2159, 2160, 2161, 2163, 2164, 2166, 2167, 2169, 2170, 2171, 2173, 2174, 2176,
+        2177, 2179, 2180, 2181, 2183, 2184, 2186, 2187, 2189, 2190, 2191, 2193, 2194, 2196, 2197, 2199,
+        2200, 2202, 2203, 2204, 2206, 2207, 2209, 2210, 2212, 2213, 2214, 2216, 2217, 2219, 2220, 2222,
+        2223, 2225, 2226, 2228, 2229, 2230, 2232, 2233, 2235, 2236, 2238, 2239, 2241, 2242, 2243, 2245,
+        2246, 2248, 2249, 2251, 2252, 2254, 2255, 2257, 2258, 2260, 2261, 2262, 2264, 2265, 2267, 2268,
+        2270, 2271, 2273, 2274, 2276, 2277, 2279, 2280, 2282, 2283, 2284, 2286, 2287, 2289, 2290, 2292,
+        2293, 2295, 2296, 2298, 2299, 2301, 2302, 2304, 2305, 2307, 2308, 2310, 2311, 2312, 2314, 2315,
+        2317, 2318, 2320, 2321, 2323, 2324, 2326, 2327, 2329, 2330, 2332, 2333, 2335, 2336, 2338, 2339,
+        2341, 2342, 2344, 2345, 2347, 2348, 2350, 2351, 2353, 2354, 2356, 2357, 2359, 2360, 2362, 2363,
+        2365, 2366, 2368, 2369, 2371, 2372, 2374, 2375, 2377, 2378, 2380, 2381, 2383, 2384, 2386, 2387,
+        2389, 2390, 2392, 2393, 2395, 2396, 2398, 2399, 2401, 2402, 2404, 2405, 2407, 2408, 2410, 2411,
+        2413, 2414, 2416, 2417, 2419, 2420, 2422, 2423, 2425, 2426, 2428, 2429, 2431, 2433, 2434, 2436,
+        2437, 2439, 2440, 2442, 2443, 2445, 2446, 2448, 2449, 2451, 2452, 2454, 2455, 2457, 2458, 2460,
+        2462, 2463, 2465, 2466, 2468, 2469, 2471, 2472, 2474, 2475, 2477, 2478, 2480, 2481, 2483, 2485,
+        2486, 2488, 2489, 2491, 2492, 2494, 2495, 2497, 2498, 2500, 2502, 2503, 2505, 2506, 2508, 2509,
+        2511, 2512, 2514, 2515, 2517, 2519, 2520, 2522, 2523, 2525, 2526, 2528, 2529, 2531, 2533, 2534,
+        2536, 2537, 2539, 2540, 2542, 2543, 2545, 2547, 2548, 2550, 2551, 2553, 2554, 2556, 2557, 2559,
+        2561, 2562, 2564, 2565, 2567, 2568, 2570, 2572, 2573, 2575, 2576, 2578, 2579, 2581, 2583, 2584,
+        2586, 2587, 2589, 2590, 2592, 2594, 2595, 2597, 2598, 2600, 2601, 2603, 2605, 2606, 2608, 2609,
+        2611, 2613, 2614, 2616, 2617, 2619, 2620, 2622, 2624, 2625, 2627, 2628, 2630, 2632, 2633, 2635,
+        2636, 2638, 2640, 2641, 2643, 2644, 2646, 2647, 2649, 2651, 2652, 2654, 2655, 2657, 2659, 2660,
+        2662, 2663, 2665, 2667, 2668, 2670, 2671, 2673, 2675, 2676, 2678, 2679, 2681, 2683, 2684, 2686,
+        2687, 2689, 2691, 2692, 2694, 2696, 2697, 2699, 2700, 2702, 2704, 2705, 2707, 2708, 2710, 2712,
+        2713, 2715, 2716, 2718, 2720, 2721, 2723, 2725, 2726, 2728, 2729, 2731, 2733, 2734, 2736, 2738,
+        2739, 2741, 2742, 2744, 2746, 2747, 2749, 2751, 2752, 2754, 2755, 2757, 2759, 2760, 2762, 2764,
+        2765, 2767, 2769, 2770, 2772, 2773, 2775, 2777, 2778, 2780, 2782, 2783, 2785, 2787, 2788, 2790,
+        2791, 2793, 2795, 2796, 2798, 2800, 2801, 2803, 2805, 2806, 2808, 2810, 2811, 2813, 2814, 2816,
+        2818, 2819, 2821, 2823, 2824, 2826, 2828, 2829, 2831, 2833, 2834, 2836, 2838, 2839, 2841, 2843,
+        2844, 2846, 2848, 2849, 2851, 2853, 2854, 2856, 2857, 2859, 2861, 2862, 2864, 2866, 2867, 2869,
+        2871, 2872, 2874, 2876, 2877, 2879, 2881, 2882, 2884, 2886, 2888, 2889, 2891, 2893, 2894, 2896,
+        2898, 2899, 2901, 2903, 2904, 2906, 2908, 2909, 2911, 2913, 2914, 2916, 2918, 2919, 2921, 2923,
+        2924, 2926, 2928, 2929, 2931, 2933, 2935, 2936, 2938, 2940, 2941, 2943, 2945, 2946, 2948, 2950,
+        2951, 2953, 2955, 2956, 2958, 2960, 2962, 2963, 2965, 2967, 2968, 2970, 2972, 2973, 2975, 2977,
+        2979, 2980, 2982, 2984, 2985, 2987, 2989, 2990, 2992, 2994, 2996, 2997, 2999, 3001, 3002, 3004,
+        3006, 3008, 3009, 3011, 3013, 3014, 3016, 3018, 3020, 3021, 3023, 3025, 3026, 3028, 3030, 3032,
+        3033, 3035, 3037, 3038, 3040, 3042, 3044, 3045, 3047, 3049, 3050, 3052, 3054, 3056, 3057, 3059,
+        3061, 3063, 3064, 3066, 3068, 3069, 3071, 3073, 3075, 3076, 3078, 3080, 3082, 3083, 3085, 3087,
+        3089, 3090, 3092, 3094, 3095, 3097, 3099, 3101, 3102, 3104, 3106, 3108, 3109, 3111, 3113, 3115,
+        3116, 3118, 3120, 3122, 3123, 3125, 3127, 3129, 3130, 3132, 3134, 3136, 3137, 3139, 3141, 3143,
+        3144, 3146, 3148, 3150, 3151, 3153, 3155, 3157, 3158, 3160, 3162, 3164, 3165, 3167, 3169, 3171,
+        3172, 3174, 3176, 3178, 3179, 3181, 3183, 3185, 3187, 3188, 3190, 3192, 3194, 3195, 3197, 3199,
+        3201, 3202, 3204, 3206, 3208, 3209, 3211, 3213, 3215, 3217, 3218, 3220, 3222, 3224, 3225, 3227,
+        3229, 3231, 3233, 3234, 3236, 3238, 3240, 3241, 3243, 3245, 3247, 3249, 3250, 3252, 3254, 3256,
+        3258, 3259, 3261, 3263, 3265, 3266, 3268, 3270, 3272, 3274, 3275, 3277, 3279, 3281, 3283, 3284,
+        3286, 3288, 3290, 3292, 3293, 3295, 3297, 3299, 3301, 3302, 3304, 3306, 3308, 3310, 3311, 3313,
+        3315, 3317, 3319, 3320, 3322, 3324, 3326, 3328, 3329, 3331, 3333, 3335, 3337, 3338, 3340, 3342,
+        3344, 3346, 3348, 3349, 3351, 3353, 3355, 3357, 3358, 3360, 3362, 3364, 3366, 3368, 3369, 3371,
+        3373, 3375, 3377, 3378, 3380, 3382, 3384, 3386, 3388, 3389, 3391, 3393, 3395, 3397, 3399, 3400,
+        3402, 3404, 3406, 3408, 3410, 3411, 3413, 3415, 3417, 3419, 3421, 3422, 3424, 3426, 3428, 3430,
+        3432, 3433, 3435, 3437, 3439, 3441, 3443, 3444, 3446, 3448, 3450, 3452, 3454, 3455, 3457, 3459,
+        3461, 3463, 3465, 3467, 3468, 3470, 3472, 3474, 3476, 3478, 3480, 3481, 3483, 3485, 3487, 3489,
+        3491, 3492, 3494, 3496, 3498, 3500, 3502, 3504, 3506, 3507, 3509, 3511, 3513, 3515, 3517, 3519,
+        3520, 3522, 3524, 3526, 3528, 3530, 3532, 3533, 3535, 3537, 3539, 3541, 3543, 3545, 3547, 3548,
+        3550, 3552, 3554, 3556, 3558, 3560, 3562, 3563, 3565, 3567, 3569, 3571, 3573, 3575, 3577, 3578,
+        3580, 3582, 3584, 3586, 3588, 3590, 3592, 3594, 3595, 3597, 3599, 3601, 3603, 3605, 3607, 3609,
+        3611, 3612, 3614, 3616, 3618, 3620, 3622, 3624, 3626, 3628, 3629, 3631, 3633, 3635, 3637, 3639,
+        3641, 3643, 3645, 3647, 3648, 3650, 3652, 3654, 3656, 3658, 3660, 3662, 3664, 3666, 3667, 3669,
+        3671, 3673, 3675, 3677, 3679, 3681, 3683, 3685, 3687, 3688, 3690, 3692, 3694, 3696, 3698, 3700,
+        3702, 3704, 3706, 3708, 3710, 3711, 3713, 3715, 3717, 3719, 3721, 3723, 3725, 3727, 3729, 3731,
+        3733, 3735, 3736, 3738, 3740, 3742, 3744, 3746, 3748, 3750, 3752, 3754, 3756, 3758, 3760, 3762,
+        3764, 3765, 3767, 3769, 3771, 3773, 3775, 3777, 3779, 3781, 3783, 3785, 3787, 3789, 3791, 3793,
+        3795, 3796, 3798, 3800, 3802, 3804, 3806, 3808, 3810, 3812, 3814, 3816, 3818, 3820, 3822, 3824,
+        3826, 3828, 3830, 3832, 3833, 3835, 3837, 3839, 3841, 3843, 3845, 3847, 3849, 3851, 3853, 3855,
+        3857, 3859, 3861, 3863, 3865, 3867, 3869, 3871, 3873, 3875, 3877, 3879, 3881, 3883, 3884, 3886,
+        3888, 3890, 3892, 3894, 3896, 3898, 3900, 3902, 3904, 3906, 3908, 3910, 3912, 3914, 3916, 3918,
+        3920, 3922, 3924, 3926, 3928, 3930, 3932, 3934, 3936, 3938, 3940, 3942, 3944, 3946, 3948, 3950,
+        3952, 3954, 3956, 3958, 3960, 3962, 3964, 3966, 3968, 3970, 3972, 3974, 3976, 3978, 3980, 3982,
+        3984, 3986, 3988, 3990, 3992, 3994, 3996, 3998, 4000, 4002, 4004, 4006, 4008, 4010, 4012, 4014,
+        4016, 4018, 4020, 4022, 4024, 4026, 4028, 4030, 4032, 4034, 4036, 4038, 4040, 4042, 4044, 4046,
+        4048, 4050, 4052, 4054, 4056, 4058, 4060, 4062, 4064, 4066, 4068, 4070, 4072, 4074, 4076, 4078,
+        4080,
+};
+
+/* Generated table */
+const unsigned short tpg_linear_to_rec709[255 * 16 + 1] = {
+           0,    5,    9,   14,   18,   22,   27,   32,   36,   41,   45,   50,   54,   59,   63,   68,
+          72,   77,   81,   86,   90,   95,   99,  104,  108,  113,  117,  122,  126,  131,  135,  139,
+         144,  149,  153,  158,  162,  167,  171,  176,  180,  185,  189,  194,  198,  203,  207,  212,
+         216,  221,  225,  230,  234,  239,  243,  248,  252,  257,  261,  266,  270,  275,  279,  284,
+         288,  293,  297,  302,  306,  311,  315,  320,  324,  328,  334,  338,  343,  347,  352,  356,
+         360,  365,  369,  373,  377,  381,  386,  390,  394,  398,  402,  406,  410,  414,  418,  422,
+         426,  430,  433,  437,  441,  445,  449,  452,  456,  460,  464,  467,  471,  475,  478,  482,
+         485,  489,  492,  496,  499,  503,  506,  510,  513,  517,  520,  524,  527,  530,  534,  537,
+         540,  544,  547,  550,  554,  557,  560,  563,  566,  570,  573,  576,  579,  582,  586,  589,
+         592,  595,  598,  601,  604,  607,  610,  613,  616,  619,  622,  625,  628,  631,  634,  637,
+         640,  643,  646,  649,  652,  655,  658,  660,  663,  666,  669,  672,  675,  677,  680,  683,
+         686,  689,  691,  694,  697,  700,  702,  705,  708,  711,  713,  716,  719,  721,  724,  727,
+         729,  732,  735,  737,  740,  743,  745,  748,  750,  753,  756,  758,  761,  763,  766,  768,
+         771,  773,  776,  779,  781,  784,  786,  789,  791,  794,  796,  799,  801,  803,  806,  808,
+         811,  813,  816,  818,  821,  823,  825,  828,  830,  833,  835,  837,  840,  842,  844,  847,
+         849,  851,  854,  856,  858,  861,  863,  865,  868,  870,  872,  875,  877,  879,  881,  884,
+         886,  888,  891,  893,  895,  897,  900,  902,  904,  906,  908,  911,  913,  915,  917,  919,
+         922,  924,  926,  928,  930,  933,  935,  937,  939,  941,  943,  946,  948,  950,  952,  954,
+         956,  958,  960,  963,  965,  967,  969,  971,  973,  975,  977,  979,  981,  984,  986,  988,
+         990,  992,  994,  996,  998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018, 1020,
+        1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, 1040, 1042, 1044, 1046, 1048, 1050, 1052,
+        1054, 1056, 1058, 1060, 1062, 1064, 1066, 1068, 1069, 1071, 1073, 1075, 1077, 1079, 1081, 1083,
+        1085, 1087, 1089, 1090, 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1106, 1107, 1109, 1111, 1113,
+        1115, 1117, 1119, 1120, 1122, 1124, 1126, 1128, 1130, 1131, 1133, 1135, 1137, 1139, 1141, 1142,
+        1144, 1146, 1148, 1150, 1151, 1153, 1155, 1157, 1159, 1160, 1162, 1164, 1166, 1168, 1169, 1171,
+        1173, 1175, 1176, 1178, 1180, 1182, 1184, 1185, 1187, 1189, 1191, 1192, 1194, 1196, 1198, 1199,
+        1201, 1203, 1204, 1206, 1208, 1210, 1211, 1213, 1215, 1217, 1218, 1220, 1222, 1223, 1225, 1227,
+        1228, 1230, 1232, 1234, 1235, 1237, 1239, 1240, 1242, 1244, 1245, 1247, 1249, 1250, 1252, 1254,
+        1255, 1257, 1259, 1260, 1262, 1264, 1265, 1267, 1269, 1270, 1272, 1274, 1275, 1277, 1279, 1280,
+        1282, 1283, 1285, 1287, 1288, 1290, 1292, 1293, 1295, 1296, 1298, 1300, 1301, 1303, 1305, 1306,
+        1308, 1309, 1311, 1313, 1314, 1316, 1317, 1319, 1321, 1322, 1324, 1325, 1327, 1328, 1330, 1332,
+        1333, 1335, 1336, 1338, 1339, 1341, 1343, 1344, 1346, 1347, 1349, 1350, 1352, 1354, 1355, 1357,
+        1358, 1360, 1361, 1363, 1364, 1366, 1367, 1369, 1371, 1372, 1374, 1375, 1377, 1378, 1380, 1381,
+        1383, 1384, 1386, 1387, 1389, 1390, 1392, 1393, 1395, 1396, 1398, 1399, 1401, 1402, 1404, 1405,
+        1407, 1408, 1410, 1411, 1413, 1414, 1416, 1417, 1419, 1420, 1422, 1423, 1425, 1426, 1428, 1429,
+        1431, 1432, 1434, 1435, 1437, 1438, 1440, 1441, 1442, 1444, 1445, 1447, 1448, 1450, 1451, 1453,
+        1454, 1456, 1457, 1458, 1460, 1461, 1463, 1464, 1466, 1467, 1469, 1470, 1471, 1473, 1474, 1476,
+        1477, 1479, 1480, 1481, 1483, 1484, 1486, 1487, 1489, 1490, 1491, 1493, 1494, 1496, 1497, 1498,
+        1500, 1501, 1503, 1504, 1505, 1507, 1508, 1510, 1511, 1512, 1514, 1515, 1517, 1518, 1519, 1521,
+        1522, 1524, 1525, 1526, 1528, 1529, 1531, 1532, 1533, 1535, 1536, 1537, 1539, 1540, 1542, 1543,
+        1544, 1546, 1547, 1548, 1550, 1551, 1553, 1554, 1555, 1557, 1558, 1559, 1561, 1562, 1563, 1565,
+        1566, 1567, 1569, 1570, 1571, 1573, 1574, 1576, 1577, 1578, 1580, 1581, 1582, 1584, 1585, 1586,
+        1588, 1589, 1590, 1592, 1593, 1594, 1596, 1597, 1598, 1600, 1601, 1602, 1603, 1605, 1606, 1607,
+        1609, 1610, 1611, 1613, 1614, 1615, 1617, 1618, 1619, 1621, 1622, 1623, 1624, 1626, 1627, 1628,
+        1630, 1631, 1632, 1634, 1635, 1636, 1637, 1639, 1640, 1641, 1643, 1644, 1645, 1647, 1648, 1649,
+        1650, 1652, 1653, 1654, 1655, 1657, 1658, 1659, 1661, 1662, 1663, 1664, 1666, 1667, 1668, 1670,
+        1671, 1672, 1673, 1675, 1676, 1677, 1678, 1680, 1681, 1682, 1683, 1685, 1686, 1687, 1688, 1690,
+        1691, 1692, 1693, 1695, 1696, 1697, 1698, 1700, 1701, 1702, 1703, 1705, 1706, 1707, 1708, 1710,
+        1711, 1712, 1713, 1715, 1716, 1717, 1718, 1720, 1721, 1722, 1723, 1724, 1726, 1727, 1728, 1729,
+        1731, 1732, 1733, 1734, 1736, 1737, 1738, 1739, 1740, 1742, 1743, 1744, 1745, 1746, 1748, 1749,
+        1750, 1751, 1753, 1754, 1755, 1756, 1757, 1759, 1760, 1761, 1762, 1763, 1765, 1766, 1767, 1768,
+        1769, 1771, 1772, 1773, 1774, 1775, 1777, 1778, 1779, 1780, 1781, 1783, 1784, 1785, 1786, 1787,
+        1788, 1790, 1791, 1792, 1793, 1794, 1796, 1797, 1798, 1799, 1800, 1801, 1803, 1804, 1805, 1806,
+        1807, 1809, 1810, 1811, 1812, 1813, 1814, 1816, 1817, 1818, 1819, 1820, 1821, 1823, 1824, 1825,
+        1826, 1827, 1828, 1829, 1831, 1832, 1833, 1834, 1835, 1836, 1838, 1839, 1840, 1841, 1842, 1843,
+        1845, 1846, 1847, 1848, 1849, 1850, 1851, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1861, 1862,
+        1863, 1864, 1865, 1866, 1867, 1868, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1878, 1879, 1880,
+        1881, 1882, 1883, 1884, 1885, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1896, 1897, 1898,
+        1899, 1900, 1901, 1902, 1903, 1904, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1916,
+        1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1927, 1928, 1929, 1930, 1931, 1932, 1933,
+        1934, 1935, 1936, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1950, 1951,
+        1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1963, 1964, 1965, 1966, 1967, 1968,
+        1969, 1970, 1971, 1972, 1973, 1974, 1975, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985,
+        1986, 1987, 1988, 1989, 1990, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+        2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
+        2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2031, 2032, 2033, 2034, 2035, 2036,
+        2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052,
+        2053, 2054, 2055, 2056, 2057, 2058, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069,
+        2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085,
+        2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101,
+        2102, 2103, 2104, 2105, 2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117,
+        2118, 2119, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133,
+        2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149,
+        2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165,
+        2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180,
+        2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196,
+        2197, 2198, 2199, 2200, 2201, 2202, 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211,
+        2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2224, 2225, 2226,
+        2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2241,
+        2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257,
+        2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2271,
+        2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2283, 2284, 2285, 2286,
+        2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2295, 2296, 2297, 2298, 2299, 2300, 2301,
+        2302, 2303, 2304, 2305, 2306, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316,
+        2317, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2327, 2328, 2329, 2330,
+        2331, 2332, 2333, 2334, 2335, 2336, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345,
+        2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2354, 2355, 2356, 2357, 2358, 2359,
+        2360, 2361, 2362, 2363, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2371, 2372, 2373,
+        2374, 2375, 2376, 2377, 2378, 2379, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2386, 2387,
+        2388, 2389, 2390, 2391, 2392, 2393, 2394, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2401,
+        2402, 2403, 2404, 2405, 2406, 2407, 2408, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415, 2415,
+        2416, 2417, 2418, 2419, 2420, 2421, 2422, 2422, 2423, 2424, 2425, 2426, 2427, 2428, 2428, 2429,
+        2430, 2431, 2432, 2433, 2434, 2435, 2435, 2436, 2437, 2438, 2439, 2440, 2441, 2441, 2442, 2443,
+        2444, 2445, 2446, 2447, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2453, 2454, 2455, 2456, 2457,
+        2458, 2459, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2465, 2466, 2467, 2468, 2469, 2470, 2471,
+        2471, 2472, 2473, 2474, 2475, 2476, 2477, 2477, 2478, 2479, 2480, 2481, 2482, 2482, 2483, 2484,
+        2485, 2486, 2487, 2488, 2488, 2489, 2490, 2491, 2492, 2493, 2493, 2494, 2495, 2496, 2497, 2498,
+        2499, 2499, 2500, 2501, 2502, 2503, 2504, 2504, 2505, 2506, 2507, 2508, 2509, 2509, 2510, 2511,
+        2512, 2513, 2514, 2514, 2515, 2516, 2517, 2518, 2519, 2519, 2520, 2521, 2522, 2523, 2524, 2524,
+        2525, 2526, 2527, 2528, 2529, 2529, 2530, 2531, 2532, 2533, 2534, 2534, 2535, 2536, 2537, 2538,
+        2539, 2539, 2540, 2541, 2542, 2543, 2544, 2544, 2545, 2546, 2547, 2548, 2548, 2549, 2550, 2551,
+        2552, 2553, 2553, 2554, 2555, 2556, 2557, 2558, 2558, 2559, 2560, 2561, 2562, 2562, 2563, 2564,
+        2565, 2566, 2567, 2567, 2568, 2569, 2570, 2571, 2571, 2572, 2573, 2574, 2575, 2576, 2576, 2577,
+        2578, 2579, 2580, 2580, 2581, 2582, 2583, 2584, 2584, 2585, 2586, 2587, 2588, 2589, 2589, 2590,
+        2591, 2592, 2593, 2593, 2594, 2595, 2596, 2597, 2597, 2598, 2599, 2600, 2601, 2601, 2602, 2603,
+        2604, 2605, 2605, 2606, 2607, 2608, 2609, 2610, 2610, 2611, 2612, 2613, 2614, 2614, 2615, 2616,
+        2617, 2618, 2618, 2619, 2620, 2621, 2622, 2622, 2623, 2624, 2625, 2626, 2626, 2627, 2628, 2629,
+        2630, 2630, 2631, 2632, 2633, 2634, 2634, 2635, 2636, 2637, 2637, 2638, 2639, 2640, 2641, 2641,
+        2642, 2643, 2644, 2645, 2645, 2646, 2647, 2648, 2649, 2649, 2650, 2651, 2652, 2653, 2653, 2654,
+        2655, 2656, 2656, 2657, 2658, 2659, 2660, 2660, 2661, 2662, 2663, 2664, 2664, 2665, 2666, 2667,
+        2668, 2668, 2669, 2670, 2671, 2671, 2672, 2673, 2674, 2675, 2675, 2676, 2677, 2678, 2678, 2679,
+        2680, 2681, 2682, 2682, 2683, 2684, 2685, 2686, 2686, 2687, 2688, 2689, 2689, 2690, 2691, 2692,
+        2693, 2693, 2694, 2695, 2696, 2696, 2697, 2698, 2699, 2700, 2700, 2701, 2702, 2703, 2703, 2704,
+        2705, 2706, 2706, 2707, 2708, 2709, 2710, 2710, 2711, 2712, 2713, 2713, 2714, 2715, 2716, 2717,
+        2717, 2718, 2719, 2720, 2720, 2721, 2722, 2723, 2723, 2724, 2725, 2726, 2727, 2727, 2728, 2729,
+        2730, 2730, 2731, 2732, 2733, 2733, 2734, 2735, 2736, 2736, 2737, 2738, 2739, 2740, 2740, 2741,
+        2742, 2743, 2743, 2744, 2745, 2746, 2746, 2747, 2748, 2749, 2749, 2750, 2751, 2752, 2752, 2753,
+        2754, 2755, 2755, 2756, 2757, 2758, 2759, 2759, 2760, 2761, 2762, 2762, 2763, 2764, 2765, 2765,
+        2766, 2767, 2768, 2768, 2769, 2770, 2771, 2771, 2772, 2773, 2774, 2774, 2775, 2776, 2777, 2777,
+        2778, 2779, 2780, 2780, 2781, 2782, 2783, 2783, 2784, 2785, 2786, 2786, 2787, 2788, 2789, 2789,
+        2790, 2791, 2792, 2792, 2793, 2794, 2795, 2795, 2796, 2797, 2798, 2798, 2799, 2800, 2801, 2801,
+        2802, 2803, 2804, 2804, 2805, 2806, 2807, 2807, 2808, 2809, 2810, 2810, 2811, 2812, 2813, 2813,
+        2814, 2815, 2815, 2816, 2817, 2818, 2818, 2819, 2820, 2821, 2821, 2822, 2823, 2824, 2824, 2825,
+        2826, 2827, 2827, 2828, 2829, 2830, 2830, 2831, 2832, 2832, 2833, 2834, 2835, 2835, 2836, 2837,
+        2838, 2838, 2839, 2840, 2841, 2841, 2842, 2843, 2844, 2844, 2845, 2846, 2846, 2847, 2848, 2849,
+        2849, 2850, 2851, 2852, 2852, 2853, 2854, 2855, 2855, 2856, 2857, 2857, 2858, 2859, 2860, 2860,
+        2861, 2862, 2863, 2863, 2864, 2865, 2865, 2866, 2867, 2868, 2868, 2869, 2870, 2871, 2871, 2872,
+        2873, 2873, 2874, 2875, 2876, 2876, 2877, 2878, 2879, 2879, 2880, 2881, 2881, 2882, 2883, 2884,
+        2884, 2885, 2886, 2886, 2887, 2888, 2889, 2889, 2890, 2891, 2892, 2892, 2893, 2894, 2894, 2895,
+        2896, 2897, 2897, 2898, 2899, 2899, 2900, 2901, 2902, 2902, 2903, 2904, 2904, 2905, 2906, 2907,
+        2907, 2908, 2909, 2909, 2910, 2911, 2912, 2912, 2913, 2914, 2914, 2915, 2916, 2917, 2917, 2918,
+        2919, 2919, 2920, 2921, 2922, 2922, 2923, 2924, 2924, 2925, 2926, 2927, 2927, 2928, 2929, 2929,
+        2930, 2931, 2932, 2932, 2933, 2934, 2934, 2935, 2936, 2937, 2937, 2938, 2939, 2939, 2940, 2941,
+        2941, 2942, 2943, 2944, 2944, 2945, 2946, 2946, 2947, 2948, 2949, 2949, 2950, 2951, 2951, 2952,
+        2953, 2953, 2954, 2955, 2956, 2956, 2957, 2958, 2958, 2959, 2960, 2961, 2961, 2962, 2963, 2963,
+        2964, 2965, 2965, 2966, 2967, 2968, 2968, 2969, 2970, 2970, 2971, 2972, 2972, 2973, 2974, 2975,
+        2975, 2976, 2977, 2977, 2978, 2979, 2979, 2980, 2981, 2982, 2982, 2983, 2984, 2984, 2985, 2986,
+        2986, 2987, 2988, 2988, 2989, 2990, 2991, 2991, 2992, 2993, 2993, 2994, 2995, 2995, 2996, 2997,
+        2998, 2998, 2999, 3000, 3000, 3001, 3002, 3002, 3003, 3004, 3004, 3005, 3006, 3006, 3007, 3008,
+        3009, 3009, 3010, 3011, 3011, 3012, 3013, 3013, 3014, 3015, 3015, 3016, 3017, 3018, 3018, 3019,
+        3020, 3020, 3021, 3022, 3022, 3023, 3024, 3024, 3025, 3026, 3026, 3027, 3028, 3029, 3029, 3030,
+        3031, 3031, 3032, 3033, 3033, 3034, 3035, 3035, 3036, 3037, 3037, 3038, 3039, 3039, 3040, 3041,
+        3042, 3042, 3043, 3044, 3044, 3045, 3046, 3046, 3047, 3048, 3048, 3049, 3050, 3050, 3051, 3052,
+        3052, 3053, 3054, 3054, 3055, 3056, 3056, 3057, 3058, 3059, 3059, 3060, 3061, 3061, 3062, 3063,
+        3063, 3064, 3065, 3065, 3066, 3067, 3067, 3068, 3069, 3069, 3070, 3071, 3071, 3072, 3073, 3073,
+        3074, 3075, 3075, 3076, 3077, 3077, 3078, 3079, 3079, 3080, 3081, 3081, 3082, 3083, 3084, 3084,
+        3085, 3086, 3086, 3087, 3088, 3088, 3089, 3090, 3090, 3091, 3092, 3092, 3093, 3094, 3094, 3095,
+        3096, 3096, 3097, 3098, 3098, 3099, 3100, 3100, 3101, 3102, 3102, 3103, 3104, 3104, 3105, 3106,
+        3106, 3107, 3108, 3108, 3109, 3110, 3110, 3111, 3112, 3112, 3113, 3114, 3114, 3115, 3116, 3116,
+        3117, 3118, 3118, 3119, 3120, 3120, 3121, 3122, 3122, 3123, 3124, 3124, 3125, 3126, 3126, 3127,
+        3128, 3128, 3129, 3130, 3130, 3131, 3132, 3132, 3133, 3134, 3134, 3135, 3135, 3136, 3137, 3137,
+        3138, 3139, 3139, 3140, 3141, 3141, 3142, 3143, 3143, 3144, 3145, 3145, 3146, 3147, 3147, 3148,
+        3149, 3149, 3150, 3151, 3151, 3152, 3153, 3153, 3154, 3155, 3155, 3156, 3157, 3157, 3158, 3159,
+        3159, 3160, 3160, 3161, 3162, 3162, 3163, 3164, 3164, 3165, 3166, 3166, 3167, 3168, 3168, 3169,
+        3170, 3170, 3171, 3172, 3172, 3173, 3174, 3174, 3175, 3175, 3176, 3177, 3177, 3178, 3179, 3179,
+        3180, 3181, 3181, 3182, 3183, 3183, 3184, 3185, 3185, 3186, 3187, 3187, 3188, 3188, 3189, 3190,
+        3190, 3191, 3192, 3192, 3193, 3194, 3194, 3195, 3196, 3196, 3197, 3198, 3198, 3199, 3199, 3200,
+        3201, 3201, 3202, 3203, 3203, 3204, 3205, 3205, 3206, 3207, 3207, 3208, 3209, 3209, 3210, 3210,
+        3211, 3212, 3212, 3213, 3214, 3214, 3215, 3216, 3216, 3217, 3218, 3218, 3219, 3219, 3220, 3221,
+        3221, 3222, 3223, 3223, 3224, 3225, 3225, 3226, 3227, 3227, 3228, 3228, 3229, 3230, 3230, 3231,
+        3232, 3232, 3233, 3234, 3234, 3235, 3235, 3236, 3237, 3237, 3238, 3239, 3239, 3240, 3241, 3241,
+        3242, 3242, 3243, 3244, 3244, 3245, 3246, 3246, 3247, 3248, 3248, 3249, 3249, 3250, 3251, 3251,
+        3252, 3253, 3253, 3254, 3255, 3255, 3256, 3256, 3257, 3258, 3258, 3259, 3260, 3260, 3261, 3262,
+        3262, 3263, 3263, 3264, 3265, 3265, 3266, 3267, 3267, 3268, 3268, 3269, 3270, 3270, 3271, 3272,
+        3272, 3273, 3274, 3274, 3275, 3275, 3276, 3277, 3277, 3278, 3279, 3279, 3280, 3280, 3281, 3282,
+        3282, 3283, 3284, 3284, 3285, 3285, 3286, 3287, 3287, 3288, 3289, 3289, 3290, 3290, 3291, 3292,
+        3292, 3293, 3294, 3294, 3295, 3295, 3296, 3297, 3297, 3298, 3299, 3299, 3300, 3300, 3301, 3302,
+        3302, 3303, 3304, 3304, 3305, 3305, 3306, 3307, 3307, 3308, 3309, 3309, 3310, 3310, 3311, 3312,
+        3312, 3313, 3314, 3314, 3315, 3315, 3316, 3317, 3317, 3318, 3319, 3319, 3320, 3320, 3321, 3322,
+        3322, 3323, 3323, 3324, 3325, 3325, 3326, 3327, 3327, 3328, 3328, 3329, 3330, 3330, 3331, 3332,
+        3332, 3333, 3333, 3334, 3335, 3335, 3336, 3336, 3337, 3338, 3338, 3339, 3340, 3340, 3341, 3341,
+        3342, 3343, 3343, 3344, 3345, 3345, 3346, 3346, 3347, 3348, 3348, 3349, 3349, 3350, 3351, 3351,
+        3352, 3352, 3353, 3354, 3354, 3355, 3356, 3356, 3357, 3357, 3358, 3359, 3359, 3360, 3360, 3361,
+        3362, 3362, 3363, 3364, 3364, 3365, 3365, 3366, 3367, 3367, 3368, 3368, 3369, 3370, 3370, 3371,
+        3371, 3372, 3373, 3373, 3374, 3375, 3375, 3376, 3376, 3377, 3378, 3378, 3379, 3379, 3380, 3381,
+        3381, 3382, 3382, 3383, 3384, 3384, 3385, 3385, 3386, 3387, 3387, 3388, 3389, 3389, 3390, 3390,
+        3391, 3392, 3392, 3393, 3393, 3394, 3395, 3395, 3396, 3396, 3397, 3398, 3398, 3399, 3399, 3400,
+        3401, 3401, 3402, 3402, 3403, 3404, 3404, 3405, 3405, 3406, 3407, 3407, 3408, 3408, 3409, 3410,
+        3410, 3411, 3411, 3412, 3413, 3413, 3414, 3414, 3415, 3416, 3416, 3417, 3418, 3418, 3419, 3419,
+        3420, 3421, 3421, 3422, 3422, 3423, 3424, 3424, 3425, 3425, 3426, 3427, 3427, 3428, 3428, 3429,
+        3430, 3430, 3431, 3431, 3432, 3433, 3433, 3434, 3434, 3435, 3435, 3436, 3437, 3437, 3438, 3438,
+        3439, 3440, 3440, 3441, 3441, 3442, 3443, 3443, 3444, 3444, 3445, 3446, 3446, 3447, 3447, 3448,
+        3449, 3449, 3450, 3450, 3451, 3452, 3452, 3453, 3453, 3454, 3455, 3455, 3456, 3456, 3457, 3458,
+        3458, 3459, 3459, 3460, 3461, 3461, 3462, 3462, 3463, 3463, 3464, 3465, 3465, 3466, 3466, 3467,
+        3468, 3468, 3469, 3469, 3470, 3471, 3471, 3472, 3472, 3473, 3474, 3474, 3475, 3475, 3476, 3476,
+        3477, 3478, 3478, 3479, 3479, 3480, 3481, 3481, 3482, 3482, 3483, 3484, 3484, 3485, 3485, 3486,
+        3486, 3487, 3488, 3488, 3489, 3489, 3490, 3491, 3491, 3492, 3492, 3493, 3494, 3494, 3495, 3495,
+        3496, 3496, 3497, 3498, 3498, 3499, 3499, 3500, 3501, 3501, 3502, 3502, 3503, 3504, 3504, 3505,
+        3505, 3506, 3506, 3507, 3508, 3508, 3509, 3509, 3510, 3511, 3511, 3512, 3512, 3513, 3513, 3514,
+        3515, 3515, 3516, 3516, 3517, 3518, 3518, 3519, 3519, 3520, 3520, 3521, 3522, 3522, 3523, 3523,
+        3524, 3525, 3525, 3526, 3526, 3527, 3527, 3528, 3529, 3529, 3530, 3530, 3531, 3531, 3532, 3533,
+        3533, 3534, 3534, 3535, 3536, 3536, 3537, 3537, 3538, 3538, 3539, 3540, 3540, 3541, 3541, 3542,
+        3542, 3543, 3544, 3544, 3545, 3545, 3546, 3547, 3547, 3548, 3548, 3549, 3549, 3550, 3551, 3551,
+        3552, 3552, 3553, 3553, 3554, 3555, 3555, 3556, 3556, 3557, 3557, 3558, 3559, 3559, 3560, 3560,
+        3561, 3561, 3562, 3563, 3563, 3564, 3564, 3565, 3566, 3566, 3567, 3567, 3568, 3568, 3569, 3570,
+        3570, 3571, 3571, 3572, 3572, 3573, 3574, 3574, 3575, 3575, 3576, 3576, 3577, 3578, 3578, 3579,
+        3579, 3580, 3580, 3581, 3582, 3582, 3583, 3583, 3584, 3584, 3585, 3586, 3586, 3587, 3587, 3588,
+        3588, 3589, 3590, 3590, 3591, 3591, 3592, 3592, 3593, 3594, 3594, 3595, 3595, 3596, 3596, 3597,
+        3597, 3598, 3599, 3599, 3600, 3600, 3601, 3601, 3602, 3603, 3603, 3604, 3604, 3605, 3605, 3606,
+        3607, 3607, 3608, 3608, 3609, 3609, 3610, 3611, 3611, 3612, 3612, 3613, 3613, 3614, 3615, 3615,
+        3616, 3616, 3617, 3617, 3618, 3618, 3619, 3620, 3620, 3621, 3621, 3622, 3622, 3623, 3624, 3624,
+        3625, 3625, 3626, 3626, 3627, 3627, 3628, 3629, 3629, 3630, 3630, 3631, 3631, 3632, 3633, 3633,
+        3634, 3634, 3635, 3635, 3636, 3636, 3637, 3638, 3638, 3639, 3639, 3640, 3640, 3641, 3642, 3642,
+        3643, 3643, 3644, 3644, 3645, 3645, 3646, 3647, 3647, 3648, 3648, 3649, 3649, 3650, 3650, 3651,
+        3652, 3652, 3653, 3653, 3654, 3654, 3655, 3656, 3656, 3657, 3657, 3658, 3658, 3659, 3659, 3660,
+        3661, 3661, 3662, 3662, 3663, 3663, 3664, 3664, 3665, 3666, 3666, 3667, 3667, 3668, 3668, 3669,
+        3669, 3670, 3671, 3671, 3672, 3672, 3673, 3673, 3674, 3674, 3675, 3676, 3676, 3677, 3677, 3678,
+        3678, 3679, 3679, 3680, 3681, 3681, 3682, 3682, 3683, 3683, 3684, 3684, 3685, 3686, 3686, 3687,
+        3687, 3688, 3688, 3689, 3689, 3690, 3691, 3691, 3692, 3692, 3693, 3693, 3694, 3694, 3695, 3695,
+        3696, 3697, 3697, 3698, 3698, 3699, 3699, 3700, 3700, 3701, 3702, 3702, 3703, 3703, 3704, 3704,
+        3705, 3705, 3706, 3707, 3707, 3708, 3708, 3709, 3709, 3710, 3710, 3711, 3711, 3712, 3713, 3713,
+        3714, 3714, 3715, 3715, 3716, 3716, 3717, 3717, 3718, 3719, 3719, 3720, 3720, 3721, 3721, 3722,
+        3722, 3723, 3724, 3724, 3725, 3725, 3726, 3726, 3727, 3727, 3728, 3728, 3729, 3730, 3730, 3731,
+        3731, 3732, 3732, 3733, 3733, 3734, 3734, 3735, 3736, 3736, 3737, 3737, 3738, 3738, 3739, 3739,
+        3740, 3740, 3741, 3742, 3742, 3743, 3743, 3744, 3744, 3745, 3745, 3746, 3746, 3747, 3748, 3748,
+        3749, 3749, 3750, 3750, 3751, 3751, 3752, 3752, 3753, 3753, 3754, 3755, 3755, 3756, 3756, 3757,
+        3757, 3758, 3758, 3759, 3759, 3760, 3761, 3761, 3762, 3762, 3763, 3763, 3764, 3764, 3765, 3765,
+        3766, 3766, 3767, 3768, 3768, 3769, 3769, 3770, 3770, 3771, 3771, 3772, 3772, 3773, 3773, 3774,
+        3775, 3775, 3776, 3776, 3777, 3777, 3778, 3778, 3779, 3779, 3780, 3781, 3781, 3782, 3782, 3783,
+        3783, 3784, 3784, 3785, 3785, 3786, 3786, 3787, 3787, 3788, 3789, 3789, 3790, 3790, 3791, 3791,
+        3792, 3792, 3793, 3793, 3794, 3794, 3795, 3796, 3796, 3797, 3797, 3798, 3798, 3799, 3799, 3800,
+        3800, 3801, 3801, 3802, 3802, 3803, 3804, 3804, 3805, 3805, 3806, 3806, 3807, 3807, 3808, 3808,
+        3809, 3809, 3810, 3811, 3811, 3812, 3812, 3813, 3813, 3814, 3814, 3815, 3815, 3816, 3816, 3817,
+        3817, 3818, 3819, 3819, 3820, 3820, 3821, 3821, 3822, 3822, 3823, 3823, 3824, 3824, 3825, 3825,
+        3826, 3826, 3827, 3828, 3828, 3829, 3829, 3830, 3830, 3831, 3831, 3832, 3832, 3833, 3833, 3834,
+        3834, 3835, 3835, 3836, 3837, 3837, 3838, 3838, 3839, 3839, 3840, 3840, 3841, 3841, 3842, 3842,
+        3843, 3843, 3844, 3844, 3845, 3846, 3846, 3847, 3847, 3848, 3848, 3849, 3849, 3850, 3850, 3851,
+        3851, 3852, 3852, 3853, 3853, 3854, 3855, 3855, 3856, 3856, 3857, 3857, 3858, 3858, 3859, 3859,
+        3860, 3860, 3861, 3861, 3862, 3862, 3863, 3863, 3864, 3864, 3865, 3866, 3866, 3867, 3867, 3868,
+        3868, 3869, 3869, 3870, 3870, 3871, 3871, 3872, 3872, 3873, 3873, 3874, 3874, 3875, 3876, 3876,
+        3877, 3877, 3878, 3878, 3879, 3879, 3880, 3880, 3881, 3881, 3882, 3882, 3883, 3883, 3884, 3884,
+        3885, 3885, 3886, 3886, 3887, 3888, 3888, 3889, 3889, 3890, 3890, 3891, 3891, 3892, 3892, 3893,
+        3893, 3894, 3894, 3895, 3895, 3896, 3896, 3897, 3897, 3898, 3898, 3899, 3900, 3900, 3901, 3901,
+        3902, 3902, 3903, 3903, 3904, 3904, 3905, 3905, 3906, 3906, 3907, 3907, 3908, 3908, 3909, 3909,
+        3910, 3910, 3911, 3911, 3912, 3912, 3913, 3914, 3914, 3915, 3915, 3916, 3916, 3917, 3917, 3918,
+        3918, 3919, 3919, 3920, 3920, 3921, 3921, 3922, 3922, 3923, 3923, 3924, 3924, 3925, 3925, 3926,
+        3926, 3927, 3927, 3928, 3929, 3929, 3930, 3930, 3931, 3931, 3932, 3932, 3933, 3933, 3934, 3934,
+        3935, 3935, 3936, 3936, 3937, 3937, 3938, 3938, 3939, 3939, 3940, 3940, 3941, 3941, 3942, 3942,
+        3943, 3943, 3944, 3944, 3945, 3945, 3946, 3947, 3947, 3948, 3948, 3949, 3949, 3950, 3950, 3951,
+        3951, 3952, 3952, 3953, 3953, 3954, 3954, 3955, 3955, 3956, 3956, 3957, 3957, 3958, 3958, 3959,
+        3959, 3960, 3960, 3961, 3961, 3962, 3962, 3963, 3963, 3964, 3964, 3965, 3965, 3966, 3966, 3967,
+        3967, 3968, 3969, 3969, 3970, 3970, 3971, 3971, 3972, 3972, 3973, 3973, 3974, 3974, 3975, 3975,
+        3976, 3976, 3977, 3977, 3978, 3978, 3979, 3979, 3980, 3980, 3981, 3981, 3982, 3982, 3983, 3983,
+        3984, 3984, 3985, 3985, 3986, 3986, 3987, 3987, 3988, 3988, 3989, 3989, 3990, 3990, 3991, 3991,
+        3992, 3992, 3993, 3993, 3994, 3994, 3995, 3995, 3996, 3996, 3997, 3997, 3998, 3998, 3999, 3999,
+        4000, 4001, 4001, 4002, 4002, 4003, 4003, 4004, 4004, 4005, 4005, 4006, 4006, 4007, 4007, 4008,
+        4008, 4009, 4009, 4010, 4010, 4011, 4011, 4012, 4012, 4013, 4013, 4014, 4014, 4015, 4015, 4016,
+        4016, 4017, 4017, 4018, 4018, 4019, 4019, 4020, 4020, 4021, 4021, 4022, 4022, 4023, 4023, 4024,
+        4024, 4025, 4025, 4026, 4026, 4027, 4027, 4028, 4028, 4029, 4029, 4030, 4030, 4031, 4031, 4032,
+        4032, 4033, 4033, 4034, 4034, 4035, 4035, 4036, 4036, 4037, 4037, 4038, 4038, 4039, 4039, 4040,
+        4040, 4041, 4041, 4042, 4042, 4043, 4043, 4044, 4044, 4045, 4045, 4046, 4046, 4047, 4047, 4048,
+        4048, 4049, 4049, 4050, 4050, 4051, 4051, 4052, 4052, 4053, 4053, 4054, 4054, 4055, 4055, 4056,
+        4056, 4057, 4057, 4058, 4058, 4059, 4059, 4060, 4060, 4061, 4061, 4062, 4062, 4063, 4063, 4064,
+        4064, 4065, 4065, 4066, 4066, 4067, 4067, 4068, 4068, 4069, 4069, 4070, 4070, 4071, 4071, 4072,
+        4072, 4073, 4073, 4074, 4074, 4075, 4075, 4076, 4076, 4077, 4077, 4078, 4078, 4079, 4079, 4080,
+        4080,
+};
+
+/* Generated table */
+const struct color16 tpg_csc_colors[V4L2_COLORSPACE_BT2020 + 1][TPG_COLOR_CSC_BLACK + 1] = {
+        [V4L2_COLORSPACE_SMPTE170M][0] = { 2939, 2939, 2939 },
+        [V4L2_COLORSPACE_SMPTE170M][1] = { 2953, 2963, 586 },
+        [V4L2_COLORSPACE_SMPTE170M][2] = { 0, 2967, 2937 },
+        [V4L2_COLORSPACE_SMPTE170M][3] = { 88, 2990, 575 },
+        [V4L2_COLORSPACE_SMPTE170M][4] = { 3016, 259, 2933 },
+        [V4L2_COLORSPACE_SMPTE170M][5] = { 3030, 405, 558 },
+        [V4L2_COLORSPACE_SMPTE170M][6] = { 478, 428, 2931 },
+        [V4L2_COLORSPACE_SMPTE170M][7] = { 547, 547, 547 },
         [V4L2_COLORSPACE_SMPTE240M][0] = { 2926, 2926, 2926 },
-        [V4L2_COLORSPACE_SMPTE240M][1] = { 2926, 2926, 857 },
-        [V4L2_COLORSPACE_SMPTE240M][2] = { 1594, 2901, 2901 },
-        [V4L2_COLORSPACE_SMPTE240M][3] = { 1594, 2901, 774 },
-        [V4L2_COLORSPACE_SMPTE240M][4] = { 2484, 618, 2858 },
-        [V4L2_COLORSPACE_SMPTE240M][5] = { 2484, 618, 617 },
-        [V4L2_COLORSPACE_SMPTE240M][6] = { 507, 507, 2832 },
+        [V4L2_COLORSPACE_SMPTE240M][1] = { 2941, 2950, 546 },
+        [V4L2_COLORSPACE_SMPTE240M][2] = { 0, 2954, 2924 },
+        [V4L2_COLORSPACE_SMPTE240M][3] = { 78, 2978, 536 },
+        [V4L2_COLORSPACE_SMPTE240M][4] = { 3004, 230, 2920 },
+        [V4L2_COLORSPACE_SMPTE240M][5] = { 3018, 363, 518 },
+        [V4L2_COLORSPACE_SMPTE240M][6] = { 437, 387, 2918 },
         [V4L2_COLORSPACE_SMPTE240M][7] = { 507, 507, 507 },
         [V4L2_COLORSPACE_REC709][0] = { 2939, 2939, 2939 },
         [V4L2_COLORSPACE_REC709][1] = { 2939, 2939, 547 },
@@ -103,21 +623,21 @@ const struct color16 tpg_csc_colors[V4L2_COLORSPACE_SRGB + 1][TPG_COLOR_CSC_BLAC
         [V4L2_COLORSPACE_REC709][5] = { 2939, 547, 547 },
         [V4L2_COLORSPACE_REC709][6] = { 547, 547, 2939 },
         [V4L2_COLORSPACE_REC709][7] = { 547, 547, 547 },
-        [V4L2_COLORSPACE_470_SYSTEM_M][0] = { 2894, 2988, 2808 },
-        [V4L2_COLORSPACE_470_SYSTEM_M][1] = { 2847, 3070, 843 },
+        [V4L2_COLORSPACE_470_SYSTEM_M][0] = { 2892, 2988, 2807 },
+        [V4L2_COLORSPACE_470_SYSTEM_M][1] = { 2846, 3070, 843 },
         [V4L2_COLORSPACE_470_SYSTEM_M][2] = { 1656, 2962, 2783 },
         [V4L2_COLORSPACE_470_SYSTEM_M][3] = { 1572, 3045, 763 },
-        [V4L2_COLORSPACE_470_SYSTEM_M][4] = { 2477, 229, 2743 },
-        [V4L2_COLORSPACE_470_SYSTEM_M][5] = { 2422, 672, 614 },
+        [V4L2_COLORSPACE_470_SYSTEM_M][4] = { 2476, 229, 2742 },
+        [V4L2_COLORSPACE_470_SYSTEM_M][5] = { 2420, 672, 614 },
         [V4L2_COLORSPACE_470_SYSTEM_M][6] = { 725, 63, 2718 },
         [V4L2_COLORSPACE_470_SYSTEM_M][7] = { 534, 561, 509 },
         [V4L2_COLORSPACE_470_SYSTEM_BG][0] = { 2939, 2939, 2939 },
-        [V4L2_COLORSPACE_470_SYSTEM_BG][1] = { 2939, 2939, 621 },
+        [V4L2_COLORSPACE_470_SYSTEM_BG][1] = { 2939, 2939, 464 },
         [V4L2_COLORSPACE_470_SYSTEM_BG][2] = { 786, 2939, 2939 },
-        [V4L2_COLORSPACE_470_SYSTEM_BG][3] = { 786, 2939, 621 },
-        [V4L2_COLORSPACE_470_SYSTEM_BG][4] = { 2879, 547, 2923 },
+        [V4L2_COLORSPACE_470_SYSTEM_BG][3] = { 786, 2939, 464 },
+        [V4L2_COLORSPACE_470_SYSTEM_BG][4] = { 2879, 547, 2956 },
         [V4L2_COLORSPACE_470_SYSTEM_BG][5] = { 2879, 547, 547 },
-        [V4L2_COLORSPACE_470_SYSTEM_BG][6] = { 547, 547, 2923 },
+        [V4L2_COLORSPACE_470_SYSTEM_BG][6] = { 547, 547, 2956 },
         [V4L2_COLORSPACE_470_SYSTEM_BG][7] = { 547, 547, 547 },
         [V4L2_COLORSPACE_SRGB][0] = { 3056, 3056, 3056 },
         [V4L2_COLORSPACE_SRGB][1] = { 3056, 3056, 800 },
@@ -127,6 +647,22 @@ const struct color16 tpg_csc_colors[V4L2_COLORSPACE_SRGB + 1][TPG_COLOR_CSC_BLAC
         [V4L2_COLORSPACE_SRGB][5] = { 3056, 800, 800 },
         [V4L2_COLORSPACE_SRGB][6] = { 800, 800, 3056 },
         [V4L2_COLORSPACE_SRGB][7] = { 800, 800, 800 },
+        [V4L2_COLORSPACE_ADOBERGB][0] = { 3033, 3033, 3033 },
+        [V4L2_COLORSPACE_ADOBERGB][1] = { 3033, 3033, 1063 },
+        [V4L2_COLORSPACE_ADOBERGB][2] = { 1828, 3033, 3033 },
+        [V4L2_COLORSPACE_ADOBERGB][3] = { 1828, 3033, 1063 },
+        [V4L2_COLORSPACE_ADOBERGB][4] = { 2633, 851, 2979 },
+        [V4L2_COLORSPACE_ADOBERGB][5] = { 2633, 851, 851 },
+        [V4L2_COLORSPACE_ADOBERGB][6] = { 851, 851, 2979 },
+        [V4L2_COLORSPACE_ADOBERGB][7] = { 851, 851, 851 },
+        [V4L2_COLORSPACE_BT2020][0] = { 2939, 2939, 2939 },
+        [V4L2_COLORSPACE_BT2020][1] = { 2877, 2923, 1058 },
+        [V4L2_COLORSPACE_BT2020][2] = { 1837, 2840, 2916 },
+        [V4L2_COLORSPACE_BT2020][3] = { 1734, 2823, 993 },
+        [V4L2_COLORSPACE_BT2020][4] = { 2427, 961, 2812 },
+        [V4L2_COLORSPACE_BT2020][5] = { 2351, 912, 648 },
+        [V4L2_COLORSPACE_BT2020][6] = { 792, 618, 2788 },
+        [V4L2_COLORSPACE_BT2020][7] = { 547, 547, 547 },
 };
 
 #else
@@ -138,29 +674,40 @@ const struct color16 tpg_csc_colors[V4L2_COLORSPACE_SRGB + 1][TPG_COLOR_CSC_BLAC
 #include <stdlib.h>
 
 static const double rec709_to_ntsc1953[3][3] = {
-        { 0.6698, 0.2678,  0.0323 },
-        { 0.0185, 1.0742, -0.0603 },
-        { 0.0162, 0.0432,  0.8551 }
+        { 0.6689794, 0.2678309, 0.0323187 },
+        { 0.0184901, 1.0742442, -0.0602820 },
+        { 0.0162259, 0.0431716, 0.8549253 }
 };
 
 static const double rec709_to_ebu[3][3] = {
-        { 0.9578, 0.0422, 0      },
-        { 0     , 1     , 0      },
-        { 0     , 0.0118, 0.9882 }
+        { 0.9578221, 0.0421779, -0.0000000 },
+        { -0.0000000, 1.0000000, 0.0000000 },
+        { -0.0000000, -0.0119367, 1.0119367 }
 };
 
 static const double rec709_to_170m[3][3] = {
-        {  1.0654, -0.0554, -0.0010 },
-        { -0.0196,  1.0364, -0.0167 },
-        {  0.0016,  0.0044,  0.9940 }
+        { 1.0653640, -0.0553900, -0.0099740 },
+        { -0.0196361, 1.0363630, -0.0167269 },
+        { 0.0016327, 0.0044133, 0.9939540 },
 };
 
 static const double rec709_to_240m[3][3] = {
-        { 0.7151, 0.2849, 0      },
-        { 0.0179, 0.9821, 0      },
-        { 0.0177, 0.0472, 0.9350 }
+        { 1.0653640, -0.0553900, -0.0099740 },
+        { -0.0196361, 1.0363630, -0.0167269 },
+        { 0.0016327, 0.0044133, 0.9939540 },
+};
+
+static const double rec709_to_adobergb[3][3] = {
+        { 0.7151627, 0.2848373, -0.0000000 },
+        { 0.0000000, 1.0000000, 0.0000000 },
+        { -0.0000000, 0.0411705, 0.9588295 },
 };
 
+static const double rec709_to_bt2020[3][3] = {
+        { 0.6274524, 0.3292485, 0.0432991 },
+        { 0.0691092, 0.9195311, 0.0113597 },
+        { 0.0163976, 0.0880301, 0.8955723 },
+};
 
 static void mult_matrix(double *r, double *g, double *b, const double m[3][3])
 {
@@ -176,7 +723,18 @@ static void mult_matrix(double *r, double *g, double *b, const double m[3][3])
 
 static double transfer_srgb_to_rgb(double v)
 {
-        return (v <= 0.03928) ? v / 12.92 : pow((v + 0.055) / 1.055, 2.4);
+        if (v < -0.04045)
+                return pow((-v + 0.055) / 1.055, 2.4);
+        return (v <= 0.04045) ? v / 12.92 : pow((v + 0.055) / 1.055, 2.4);
+}
+
+static double transfer_rgb_to_srgb(double v)
+{
+        if (v <= -0.0031308)
+                return -1.055 * pow(-v, 1.0 / 2.4) + 0.055;
+        if (v <= 0.0031308)
+                return v * 12.92;
+        return 1.055 * pow(v, 1.0 / 2.4) - 0.055;
 }
 
 static double transfer_rgb_to_smpte240m(double v)
@@ -186,9 +744,21 @@ static double transfer_rgb_to_smpte240m(double v)
 
 static double transfer_rgb_to_rec709(double v)
 {
+        if (v <= -0.018)
+                return -1.099 * pow(-v, 0.45) + 0.099;
         return (v < 0.018) ? v * 4.5 : 1.099 * pow(v, 0.45) - 0.099;
 }
 
+static double transfer_rec709_to_rgb(double v)
+{
+        return (v < 0.081) ? v / 4.5 : pow((v + 0.099) / 1.099, 1.0 / 0.45);
+}
+
+static double transfer_rgb_to_adobergb(double v)
+{
+        return pow(v, 1.0 / 2.19921875);
+}
+
 static double transfer_srgb_to_rec709(double v)
 {
         return transfer_rgb_to_rec709(transfer_srgb_to_rgb(v));
@@ -196,6 +766,8 @@ static double transfer_srgb_to_rec709(double v)
 
 static void csc(enum v4l2_colorspace colorspace, double *r, double *g, double *b)
 {
+        int clamp = 1;
+
         /* Convert the primaries of Rec. 709 Linear RGB */
         switch (colorspace) {
         case V4L2_COLORSPACE_SMPTE240M:
@@ -222,15 +794,29 @@ static void csc(enum v4l2_colorspace colorspace, double *r, double *g, double *b
                 *b = transfer_srgb_to_rgb(*b);
                 mult_matrix(r, g, b, rec709_to_ntsc1953);
                 break;
+        case V4L2_COLORSPACE_ADOBERGB:
+                *r = transfer_srgb_to_rgb(*r);
+                *g = transfer_srgb_to_rgb(*g);
+                *b = transfer_srgb_to_rgb(*b);
+                mult_matrix(r, g, b, rec709_to_adobergb);
+                break;
+        case V4L2_COLORSPACE_BT2020:
+                *r = transfer_srgb_to_rgb(*r);
+                *g = transfer_srgb_to_rgb(*g);
+                *b = transfer_srgb_to_rgb(*b);
+                mult_matrix(r, g, b, rec709_to_bt2020);
+                break;
         case V4L2_COLORSPACE_SRGB:
         case V4L2_COLORSPACE_REC709:
         default:
                 break;
         }
 
-        *r = ((*r) < 0) ? 0 : (((*r) > 1) ? 1 : (*r));
-        *g = ((*g) < 0) ? 0 : (((*g) > 1) ? 1 : (*g));
-        *b = ((*b) < 0) ? 0 : (((*b) > 1) ? 1 : (*b));
+        if (clamp) {
+                *r = ((*r) < 0) ? 0 : (((*r) > 1) ? 1 : (*r));
+                *g = ((*g) < 0) ? 0 : (((*g) > 1) ? 1 : (*g));
+                *b = ((*b) < 0) ? 0 : (((*b) > 1) ? 1 : (*b));
+        }
 
         /* Encode to gamma corrected colorspace */
         switch (colorspace) {
@@ -242,12 +828,18 @@ static void csc(enum v4l2_colorspace colorspace, double *r, double *g, double *b
         case V4L2_COLORSPACE_SMPTE170M:
         case V4L2_COLORSPACE_470_SYSTEM_M:
         case V4L2_COLORSPACE_470_SYSTEM_BG:
+        case V4L2_COLORSPACE_BT2020:
                 *r = transfer_rgb_to_rec709(*r);
                 *g = transfer_rgb_to_rec709(*g);
                 *b = transfer_rgb_to_rec709(*b);
                 break;
         case V4L2_COLORSPACE_SRGB:
                 break;
+        case V4L2_COLORSPACE_ADOBERGB:
+                *r = transfer_rgb_to_adobergb(*r);
+                *g = transfer_rgb_to_adobergb(*g);
+                *b = transfer_rgb_to_adobergb(*b);
+                break;
         case V4L2_COLORSPACE_REC709:
         default:
                 *r = transfer_srgb_to_rec709(*r);
@@ -269,6 +861,8 @@ int main(int argc, char **argv)
                 V4L2_COLORSPACE_470_SYSTEM_BG,
                 0,
                 V4L2_COLORSPACE_SRGB,
+                V4L2_COLORSPACE_ADOBERGB,
+                V4L2_COLORSPACE_BT2020,
         };
         static const char * const colorspace_names[] = {
                 "",
@@ -280,13 +874,39 @@ int main(int argc, char **argv)
                 "V4L2_COLORSPACE_470_SYSTEM_BG",
                 "",
                 "V4L2_COLORSPACE_SRGB",
+                "V4L2_COLORSPACE_ADOBERGB",
+                "V4L2_COLORSPACE_BT2020",
         };
         int i;
         int c;
 
         printf("/* Generated table */\n");
-        printf("const struct color16 tpg_csc_colors[V4L2_COLORSPACE_SRGB + 1][TPG_COLOR_CSC_BLACK + 1] = {\n");
-        for (c = 0; c <= V4L2_COLORSPACE_SRGB; c++) {
+        printf("const unsigned short tpg_rec709_to_linear[255 * 16 + 1] = {");
+        for (i = 0; i <= 255 * 16; i++) {
+                if (i % 16 == 0)
+                        printf("\n\t");
+                printf("%4d,%s",
+                        (int)(0.5 + 16.0 * 255.0 *
+                                transfer_rec709_to_rgb(i / (16.0 * 255.0))),
+                        i % 16 == 15 || i == 255 * 16 ? "" : " ");
+        }
+        printf("\n};\n\n");
+
+        printf("/* Generated table */\n");
+        printf("const unsigned short tpg_linear_to_rec709[255 * 16 + 1] = {");
+        for (i = 0; i <= 255 * 16; i++) {
+                if (i % 16 == 0)
+                        printf("\n\t");
+                printf("%4d,%s",
+                        (int)(0.5 + 16.0 * 255.0 *
+                                transfer_rgb_to_rec709(i / (16.0 * 255.0))),
+                        i % 16 == 15 || i == 255 * 16 ? "" : " ");
+        }
+        printf("\n};\n\n");
+
+        printf("/* Generated table */\n");
+        printf("const struct color16 tpg_csc_colors[V4L2_COLORSPACE_BT2020 + 1][TPG_COLOR_CSC_BLACK + 1] = {\n");
+        for (c = 0; c <= V4L2_COLORSPACE_BT2020; c++) {
                 for (i = 0; i <= TPG_COLOR_CSC_BLACK; i++) {
                         double r, g, b;
 
diff --git a/drivers/media/platform/vivid/vivid-tpg-colors.h b/drivers/media/platform/vivid/vivid-tpg-colors.h
index a2678fbec256..2c333356451c 100644
--- a/drivers/media/platform/vivid/vivid-tpg-colors.h
+++ b/drivers/media/platform/vivid/vivid-tpg-colors.h
@@ -59,6 +59,8 @@ enum tpg_color {
 };
 
 extern const struct color tpg_colors[TPG_COLOR_MAX];
-extern const struct color16 tpg_csc_colors[V4L2_COLORSPACE_SRGB + 1][TPG_COLOR_CSC_BLACK + 1];
+extern const unsigned short tpg_rec709_to_linear[255 * 16 + 1];
+extern const unsigned short tpg_linear_to_rec709[255 * 16 + 1];
+extern const struct color16 tpg_csc_colors[V4L2_COLORSPACE_BT2020 + 1][TPG_COLOR_CSC_BLACK + 1];
 
 #endif
diff --git a/drivers/media/platform/vivid/vivid-tpg.c b/drivers/media/platform/vivid/vivid-tpg.c
index cbcd6250e7b2..fc9c6536ba02 100644
--- a/drivers/media/platform/vivid/vivid-tpg.c
+++ b/drivers/media/platform/vivid/vivid-tpg.c
@@ -296,127 +296,193 @@ static enum tpg_color tpg_get_textfg_color(struct tpg_data *tpg)
         }
 }
 
-static u16 color_to_y(struct tpg_data *tpg, int r, int g, int b)
+static inline int rec709_to_linear(int v)
 {
-        switch (tpg->colorspace) {
-        case V4L2_COLORSPACE_SMPTE170M:
-        case V4L2_COLORSPACE_470_SYSTEM_M:
-        case V4L2_COLORSPACE_470_SYSTEM_BG:
-                return ((16829 * r + 33039 * g + 6416 * b + 16 * 32768) >> 16) + (16 << 4);
-        case V4L2_COLORSPACE_SMPTE240M:
-                return ((11932 * r + 39455 * g + 4897 * b + 16 * 32768) >> 16) + (16 << 4);
-        case V4L2_COLORSPACE_REC709:
-        case V4L2_COLORSPACE_SRGB:
-        default:
-                return ((11966 * r + 40254 * g + 4064 * b + 16 * 32768) >> 16) + (16 << 4);
-        }
+        v = clamp(v, 0, 0xff0);
+        return tpg_rec709_to_linear[v];
 }
 
-static u16 color_to_cb(struct tpg_data *tpg, int r, int g, int b)
+static inline int linear_to_rec709(int v)
 {
-        switch (tpg->colorspace) {
-        case V4L2_COLORSPACE_SMPTE170M:
-        case V4L2_COLORSPACE_470_SYSTEM_M:
-        case V4L2_COLORSPACE_470_SYSTEM_BG:
-                return ((-9714 * r - 19070 * g + 28784 * b + 16 * 32768) >> 16) + (128 << 4);
-        case V4L2_COLORSPACE_SMPTE240M:
-                return ((-6684 * r - 22100 * g + 28784 * b + 16 * 32768) >> 16) + (128 << 4);
-        case V4L2_COLORSPACE_REC709:
-        case V4L2_COLORSPACE_SRGB:
-        default:
-                return ((-6596 * r - 22189 * g + 28784 * b + 16 * 32768) >> 16) + (128 << 4);
-        }
+        v = clamp(v, 0, 0xff0);
+        return tpg_linear_to_rec709[v];
 }
 
-static u16 color_to_cr(struct tpg_data *tpg, int r, int g, int b)
+static void rgb2ycbcr(const int m[3][3], int r, int g, int b,
+                        int y_offset, int *y, int *cb, int *cr)
 {
-        switch (tpg->colorspace) {
-        case V4L2_COLORSPACE_SMPTE170M:
-        case V4L2_COLORSPACE_470_SYSTEM_M:
-        case V4L2_COLORSPACE_470_SYSTEM_BG:
-                return ((28784 * r - 24103 * g - 4681 * b + 16 * 32768) >> 16) + (128 << 4);
-        case V4L2_COLORSPACE_SMPTE240M:
-                return ((28784 * r - 25606 * g - 3178 * b + 16 * 32768) >> 16) + (128 << 4);
-        case V4L2_COLORSPACE_REC709:
-        case V4L2_COLORSPACE_SRGB:
-        default:
-                return ((28784 * r - 26145 * g - 2639 * b + 16 * 32768) >> 16) + (128 << 4);
-        }
+        *y  = ((m[0][0] * r + m[0][1] * g + m[0][2] * b) >> 16) + (y_offset << 4);
+        *cb = ((m[1][0] * r + m[1][1] * g + m[1][2] * b) >> 16) + (128 << 4);
+        *cr = ((m[2][0] * r + m[2][1] * g + m[2][2] * b) >> 16) + (128 << 4);
 }
 
-static u16 ycbcr_to_r(struct tpg_data *tpg, int y, int cb, int cr)
+static void color_to_ycbcr(struct tpg_data *tpg, int r, int g, int b,
+                           int *y, int *cb, int *cr)
 {
-        int r;
+#define COEFF(v, r) ((int)(0.5 + (v) * (r) * 256.0))
 
-        y -= 16 << 4;
-        cb -= 128 << 4;
-        cr -= 128 << 4;
-        switch (tpg->colorspace) {
-        case V4L2_COLORSPACE_SMPTE170M:
-        case V4L2_COLORSPACE_470_SYSTEM_M:
-        case V4L2_COLORSPACE_470_SYSTEM_BG:
-                r = 4769 * y + 6537 * cr;
+        static const int bt601[3][3] = {
+                { COEFF(0.299, 219),  COEFF(0.587, 219),  COEFF(0.114, 219)  },
+                { COEFF(-0.169, 224), COEFF(-0.331, 224), COEFF(0.5, 224)    },
+                { COEFF(0.5, 224),    COEFF(-0.419, 224), COEFF(-0.081, 224) },
+        };
+        static const int bt601_full[3][3] = {
+                { COEFF(0.299, 255),  COEFF(0.587, 255),  COEFF(0.114, 255)  },
+                { COEFF(-0.169, 255), COEFF(-0.331, 255), COEFF(0.5, 255)    },
+                { COEFF(0.5, 255),    COEFF(-0.419, 255), COEFF(-0.081, 255) },
+        };
+        static const int rec709[3][3] = {
+                { COEFF(0.2126, 219),  COEFF(0.7152, 219),  COEFF(0.0722, 219)  },
+                { COEFF(-0.1146, 224), COEFF(-0.3854, 224), COEFF(0.5, 224)     },
+                { COEFF(0.5, 224),     COEFF(-0.4542, 224), COEFF(-0.0458, 224) },
+        };
+        static const int rec709_full[3][3] = {
+                { COEFF(0.2126, 255),  COEFF(0.7152, 255),  COEFF(0.0722, 255)  },
+                { COEFF(-0.1146, 255), COEFF(-0.3854, 255), COEFF(0.5, 255)     },
+                { COEFF(0.5, 255),     COEFF(-0.4542, 255), COEFF(-0.0458, 255) },
+        };
+        static const int smpte240m[3][3] = {
+                { COEFF(0.212, 219),  COEFF(0.701, 219),  COEFF(0.087, 219)  },
+                { COEFF(-0.116, 224), COEFF(-0.384, 224), COEFF(0.5, 224)    },
+                { COEFF(0.5, 224),    COEFF(-0.445, 224), COEFF(-0.055, 224) },
+        };
+        static const int bt2020[3][3] = {
+                { COEFF(0.2726, 219),  COEFF(0.6780, 219),  COEFF(0.0593, 219)  },
+                { COEFF(-0.1396, 224), COEFF(-0.3604, 224), COEFF(0.5, 224)     },
+                { COEFF(0.5, 224),     COEFF(-0.4629, 224), COEFF(-0.0405, 224) },
+        };
+        bool full = tpg->real_quantization == V4L2_QUANTIZATION_FULL_RANGE;
+        int lin_y, yc;
+
+        switch (tpg->real_ycbcr_enc) {
+        case V4L2_YCBCR_ENC_601:
+        case V4L2_YCBCR_ENC_XV601:
+        case V4L2_YCBCR_ENC_SYCC:
+                rgb2ycbcr(full ? bt601_full : bt601, r, g, b, 16, y, cb, cr);
+                break;
+        case V4L2_YCBCR_ENC_BT2020:
+                rgb2ycbcr(bt2020, r, g, b, 16, y, cb, cr);
                 break;
-        case V4L2_COLORSPACE_SMPTE240M:
-                r = 4769 * y + 7376 * cr;
+        case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
+                lin_y = (COEFF(0.2627, 255) * rec709_to_linear(r) +
+                         COEFF(0.6780, 255) * rec709_to_linear(g) +
+                         COEFF(0.0593, 255) * rec709_to_linear(b)) >> 16;
+                yc = linear_to_rec709(lin_y);
+                *y = (yc * 219) / 255 + (16 << 4);
+                if (b <= yc)
+                        *cb = (((b - yc) * COEFF(1.0 / 1.9404, 224)) >> 16) + (128 << 4);
+                else
+                        *cb = (((b - yc) * COEFF(1.0 / 1.5816, 224)) >> 16) + (128 << 4);
+                if (r <= yc)
+                        *cr = (((r - yc) * COEFF(1.0 / 1.7184, 224)) >> 16) + (128 << 4);
+                else
+                        *cr = (((r - yc) * COEFF(1.0 / 0.9936, 224)) >> 16) + (128 << 4);
                 break;
-        case V4L2_COLORSPACE_REC709:
-        case V4L2_COLORSPACE_SRGB:
+        case V4L2_YCBCR_ENC_SMPTE240M:
+                rgb2ycbcr(smpte240m, r, g, b, 16, y, cb, cr);
+                break;
+        case V4L2_YCBCR_ENC_709:
+        case V4L2_YCBCR_ENC_XV709:
         default:
-                r = 4769 * y + 7343 * cr;
+                rgb2ycbcr(full ? rec709_full : rec709, r, g, b, 0, y, cb, cr);
                 break;
         }
-        return clamp(r >> 12, 0, 0xff0);
 }
 
-static u16 ycbcr_to_g(struct tpg_data *tpg, int y, int cb, int cr)
+static void ycbcr2rgb(const int m[3][3], int y, int cb, int cr,
+                        int y_offset, int *r, int *g, int *b)
 {
-        int g;
-
-        y -= 16 << 4;
+        y -= y_offset << 4;
         cb -= 128 << 4;
         cr -= 128 << 4;
-        switch (tpg->colorspace) {
-        case V4L2_COLORSPACE_SMPTE170M:
-        case V4L2_COLORSPACE_470_SYSTEM_M:
-        case V4L2_COLORSPACE_470_SYSTEM_BG:
-                g = 4769 * y - 1605 * cb - 3330 * cr;
-                break;
-        case V4L2_COLORSPACE_SMPTE240M:
-                g = 4769 * y - 1055 * cb - 2341 * cr;
-                break;
-        case V4L2_COLORSPACE_REC709:
-        case V4L2_COLORSPACE_SRGB:
-        default:
-                g = 4769 * y - 873 * cb - 2183 * cr;
-                break;
-        }
-        return clamp(g >> 12, 0, 0xff0);
+        *r = m[0][0] * y + m[0][1] * cb + m[0][2] * cr;
+        *g = m[1][0] * y + m[1][1] * cb + m[1][2] * cr;
+        *b = m[2][0] * y + m[2][1] * cb + m[2][2] * cr;
+        *r = clamp(*r >> 12, 0, 0xff0);
+        *g = clamp(*g >> 12, 0, 0xff0);
+        *b = clamp(*b >> 12, 0, 0xff0);
 }
 
-static u16 ycbcr_to_b(struct tpg_data *tpg, int y, int cb, int cr)
+static void ycbcr_to_color(struct tpg_data *tpg, int y, int cb, int cr,
+                           int *r, int *g, int *b)
 {
-        int b;
+#undef COEFF
+#define COEFF(v, r) ((int)(0.5 + (v) * ((255.0 * 255.0 * 16.0) / (r))))
+        static const int bt601[3][3] = {
+                { COEFF(1, 219), COEFF(0, 224),       COEFF(1.4020, 224)  },
+                { COEFF(1, 219), COEFF(-0.3441, 224), COEFF(-0.7141, 224) },
+                { COEFF(1, 219), COEFF(1.7720, 224),  COEFF(0, 224)       },
+        };
+        static const int bt601_full[3][3] = {
+                { COEFF(1, 255), COEFF(0, 255),       COEFF(1.4020, 255)  },
+                { COEFF(1, 255), COEFF(-0.3441, 255), COEFF(-0.7141, 255) },
+                { COEFF(1, 255), COEFF(1.7720, 255),  COEFF(0, 255)       },
+        };
+        static const int rec709[3][3] = {
+                { COEFF(1, 219), COEFF(0, 224),       COEFF(1.5748, 224)  },
+                { COEFF(1, 219), COEFF(-0.1873, 224), COEFF(-0.4681, 224) },
+                { COEFF(1, 219), COEFF(1.8556, 224),  COEFF(0, 224)       },
+        };
+        static const int rec709_full[3][3] = {
+                { COEFF(1, 255), COEFF(0, 255),       COEFF(1.5748, 255)  },
+                { COEFF(1, 255), COEFF(-0.1873, 255), COEFF(-0.4681, 255) },
+                { COEFF(1, 255), COEFF(1.8556, 255),  COEFF(0, 255)       },
+        };
+        static const int smpte240m[3][3] = {
+                { COEFF(1, 219), COEFF(0, 224),       COEFF(1.5756, 224)  },
+                { COEFF(1, 219), COEFF(-0.2253, 224), COEFF(-0.4767, 224) },
+                { COEFF(1, 219), COEFF(1.8270, 224),  COEFF(0, 224)       },
+        };
+        static const int bt2020[3][3] = {
+                { COEFF(1, 219), COEFF(0, 224),       COEFF(1.4746, 224)  },
+                { COEFF(1, 219), COEFF(-0.1646, 224), COEFF(-0.5714, 224) },
+                { COEFF(1, 219), COEFF(1.8814, 224),  COEFF(0, 224)       },
+        };
+        bool full = tpg->real_quantization == V4L2_QUANTIZATION_FULL_RANGE;
+        int lin_r, lin_g, lin_b, lin_y;
+
+        switch (tpg->real_ycbcr_enc) {
+        case V4L2_YCBCR_ENC_601:
+        case V4L2_YCBCR_ENC_XV601:
+        case V4L2_YCBCR_ENC_SYCC:
+                ycbcr2rgb(full ? bt601_full : bt601, y, cb, cr, 16, r, g, b);
+                break;
+        case V4L2_YCBCR_ENC_BT2020:
+                ycbcr2rgb(bt2020, y, cb, cr, 16, r, g, b);
+                break;
+        case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
+                y -= 16 << 4;
+                cb -= 128 << 4;
+                cr -= 128 << 4;
 
-        y -= 16 << 4;
-        cb -= 128 << 4;
-        cr -= 128 << 4;
-        switch (tpg->colorspace) {
-        case V4L2_COLORSPACE_SMPTE170M:
-        case V4L2_COLORSPACE_470_SYSTEM_M:
-        case V4L2_COLORSPACE_470_SYSTEM_BG:
-                b = 4769 * y + 7343 * cb;
+                if (cb <= 0)
+                        *b = COEFF(1.0, 219) * y + COEFF(1.9404, 224) * cb;
+                else
+                        *b = COEFF(1.0, 219) * y + COEFF(1.5816, 224) * cb;
+                *b = *b >> 12;
+                if (cr <= 0)
+                        *r = COEFF(1.0, 219) * y + COEFF(1.7184, 224) * cr;
+                else
+                        *r = COEFF(1.0, 219) * y + COEFF(0.9936, 224) * cr;
+                *r = *r >> 12;
+                lin_r = rec709_to_linear(*r);
+                lin_b = rec709_to_linear(*b);
+                lin_y = rec709_to_linear((y * 255) / 219);
+
+                lin_g = COEFF(1.0 / 0.6780, 255) * lin_y -
+                        COEFF(0.2627 / 0.6780, 255) * lin_r -
+                        COEFF(0.0593 / 0.6780, 255) * lin_b;
+                *g = linear_to_rec709(lin_g >> 12);
                 break;
-        case V4L2_COLORSPACE_SMPTE240M:
-                b = 4769 * y + 8552 * cb;
+        case V4L2_YCBCR_ENC_SMPTE240M:
+                ycbcr2rgb(smpte240m, y, cb, cr, 16, r, g, b);
                 break;
-        case V4L2_COLORSPACE_REC709:
-        case V4L2_COLORSPACE_SRGB:
+        case V4L2_YCBCR_ENC_709:
+        case V4L2_YCBCR_ENC_XV709:
         default:
-                b = 4769 * y + 8652 * cb;
+                ycbcr2rgb(full ? rec709_full : rec709, y, cb, cr, 16, r, g, b);
                 break;
         }
-        return clamp(b >> 12, 0, 0xff0);
 }
 
 /* precalculate color bar values to speed up rendering */
@@ -456,18 +522,17 @@ static void precalculate_color(struct tpg_data *tpg, int k)
                 g <<= 4;
                 b <<= 4;
         }
-        if (tpg->qual == TPG_QUAL_GRAY)
-                r = g = b = color_to_y(tpg, r, g, b);
+        if (tpg->qual == TPG_QUAL_GRAY) {
+                /* Rec. 709 Luma function */
+                /* (0.2126, 0.7152, 0.0722) * (255 * 256) */
+                r = g = b = ((13879 * r + 46688 * g + 4713 * b) >> 16) + (16 << 4);
+        }
 
         /*
          * The assumption is that the RGB output is always full range,
          * so only if the rgb_range overrides the 'real' rgb range do
          * we need to convert the RGB values.
          *
-         * Currently there is no way of signalling to userspace if you
-         * are actually giving it limited range RGB (or full range
-         * YUV for that matter).
-         *
          * Remember that r, g and b are still in the 0 - 0xff0 range.
          */
         if (tpg->real_rgb_range == V4L2_DV_RGB_RANGE_LIMITED &&
@@ -497,12 +562,12 @@ static void precalculate_color(struct tpg_data *tpg, int k)
         if (tpg->brightness != 128 || tpg->contrast != 128 ||
             tpg->saturation != 128 || tpg->hue) {
                 /* Implement these operations */
+                int y, cb, cr;
+                int tmp_cb, tmp_cr;
 
                 /* First convert to YCbCr */
-                int y = color_to_y(tpg, r, g, b);       /* Luma */
-                int cb = color_to_cb(tpg, r, g, b);     /* Cb */
-                int cr = color_to_cr(tpg, r, g, b);     /* Cr */
-                int tmp_cb, tmp_cr;
+
+                color_to_ycbcr(tpg, r, g, b, &y, &cb, &cr);
 
                 y = (16 << 4) + ((y - (16 << 4)) * tpg->contrast) / 128;
                 y += (tpg->brightness << 4) - (128 << 4);
@@ -520,21 +585,29 @@ static void precalculate_color(struct tpg_data *tpg, int k)
                         tpg->colors[k][2] = clamp(cr >> 4, 1, 254);
                         return;
                 }
-                r = ycbcr_to_r(tpg, y, cb, cr);
-                g = ycbcr_to_g(tpg, y, cb, cr);
-                b = ycbcr_to_b(tpg, y, cb, cr);
+                ycbcr_to_color(tpg, y, cb, cr, &r, &g, &b);
         }
 
         if (tpg->is_yuv) {
                 /* Convert to YCbCr */
-                u16 y = color_to_y(tpg, r, g, b);       /* Luma */
-                u16 cb = color_to_cb(tpg, r, g, b);     /* Cb */
-                u16 cr = color_to_cr(tpg, r, g, b);     /* Cr */
+                int y, cb, cr;
+
+                color_to_ycbcr(tpg, r, g, b, &y, &cb, &cr);
 
+                if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE) {
+                        y = clamp(y, 16 << 4, 235 << 4);
+                        cb = clamp(cb, 16 << 4, 240 << 4);
+                        cr = clamp(cr, 16 << 4, 240 << 4);
+                }
                 tpg->colors[k][0] = clamp(y >> 4, 1, 254);
                 tpg->colors[k][1] = clamp(cb >> 4, 1, 254);
                 tpg->colors[k][2] = clamp(cr >> 4, 1, 254);
         } else {
+                if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE) {
+                        r = (r * 219) / 255 + (16 << 4);
+                        g = (g * 219) / 255 + (16 << 4);
+                        b = (b * 219) / 255 + (16 << 4);
+                }
                 switch (tpg->fourcc) {
                 case V4L2_PIX_FMT_RGB565:
                 case V4L2_PIX_FMT_RGB565X:
@@ -1152,6 +1225,46 @@ static void tpg_recalc(struct tpg_data *tpg)
         if (tpg->recalc_colors) {
                 tpg->recalc_colors = false;
                 tpg->recalc_lines = true;
+                tpg->real_ycbcr_enc = tpg->ycbcr_enc;
+                tpg->real_quantization = tpg->quantization;
+                if (tpg->ycbcr_enc == V4L2_YCBCR_ENC_DEFAULT) {
+                        switch (tpg->colorspace) {
+                        case V4L2_COLORSPACE_REC709:
+                                tpg->real_ycbcr_enc = V4L2_YCBCR_ENC_709;
+                                break;
+                        case V4L2_COLORSPACE_SRGB:
+                                tpg->real_ycbcr_enc = V4L2_YCBCR_ENC_SYCC;
+                                break;
+                        case V4L2_COLORSPACE_BT2020:
+                                tpg->real_ycbcr_enc = V4L2_YCBCR_ENC_BT2020;
+                                break;
+                        case V4L2_COLORSPACE_SMPTE240M:
+                                tpg->real_ycbcr_enc = V4L2_YCBCR_ENC_SMPTE240M;
+                                break;
+                        case V4L2_COLORSPACE_SMPTE170M:
+                        case V4L2_COLORSPACE_470_SYSTEM_M:
+                        case V4L2_COLORSPACE_470_SYSTEM_BG:
+                        case V4L2_COLORSPACE_ADOBERGB:
+                        default:
+                                tpg->real_ycbcr_enc = V4L2_YCBCR_ENC_601;
+                                break;
+                        }
+                }
+                if (tpg->quantization == V4L2_QUANTIZATION_DEFAULT) {
+                        tpg->real_quantization = V4L2_QUANTIZATION_FULL_RANGE;
+                        if (tpg->is_yuv) {
+                                switch (tpg->real_ycbcr_enc) {
+                                case V4L2_YCBCR_ENC_SYCC:
+                                case V4L2_YCBCR_ENC_XV601:
+                                case V4L2_YCBCR_ENC_XV709:
+                                        break;
+                                default:
+                                        tpg->real_quantization =
+                                                V4L2_QUANTIZATION_LIM_RANGE;
+                                        break;
+                                }
+                        }
+                }
                 tpg_precalculate_colors(tpg);
         }
         if (tpg->recalc_square_border) {
diff --git a/drivers/media/platform/vivid/vivid-tpg.h b/drivers/media/platform/vivid/vivid-tpg.h
index 8ef3e52ba3be..9dc463a40ed3 100644
--- a/drivers/media/platform/vivid/vivid-tpg.h
+++ b/drivers/media/platform/vivid/vivid-tpg.h
@@ -119,6 +119,18 @@ struct tpg_data {
         u32                             fourcc;
         bool                            is_yuv;
         u32                             colorspace;
+        u32                             ycbcr_enc;
+        /*
+         * Stores the actual Y'CbCr encoding, i.e. will never be
+         * V4L2_YCBCR_ENC_DEFAULT.
+         */
+        u32                             real_ycbcr_enc;
+        u32                             quantization;
+        /*
+         * Stores the actual quantization, i.e. will never be
+         * V4L2_QUANTIZATION_DEFAULT.
+         */
+        u32                             real_quantization;
         enum tpg_video_aspect           vid_aspect;
         enum tpg_pixel_aspect           pix_aspect;
         unsigned                        rgb_range;
@@ -286,6 +298,32 @@ static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
         return tpg->colorspace;
 }
 
+static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
+{
+        if (tpg->ycbcr_enc == ycbcr_enc)
+                return;
+        tpg->ycbcr_enc = ycbcr_enc;
+        tpg->recalc_colors = true;
+}
+
+static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
+{
+        return tpg->ycbcr_enc;
+}
+
+static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
+{
+        if (tpg->quantization == quantization)
+                return;
+        tpg->quantization = quantization;
+        tpg->recalc_colors = true;
+}
+
+static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
+{
+        return tpg->quantization;
+}
+
 static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
 {
         return tpg->planes;
diff --git a/drivers/media/platform/vivid/vivid-vbi-cap.c b/drivers/media/platform/vivid/vivid-vbi-cap.c
index 2166d0bf6fe2..ef81b01b53d2 100644
--- a/drivers/media/platform/vivid/vivid-vbi-cap.c
+++ b/drivers/media/platform/vivid/vivid-vbi-cap.c
@@ -236,8 +236,8 @@ const struct vb2_ops vivid_vbi_cap_qops = {
         .buf_queue              = vbi_cap_buf_queue,
         .start_streaming        = vbi_cap_start_streaming,
         .stop_streaming         = vbi_cap_stop_streaming,
-        .wait_prepare           = vivid_unlock,
-        .wait_finish            = vivid_lock,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
 };
 
 int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
diff --git a/drivers/media/platform/vivid/vivid-vbi-out.c b/drivers/media/platform/vivid/vivid-vbi-out.c
index 9d00a07ecdcd..4e4c70e1e04a 100644
--- a/drivers/media/platform/vivid/vivid-vbi-out.c
+++ b/drivers/media/platform/vivid/vivid-vbi-out.c
@@ -131,8 +131,8 @@ const struct vb2_ops vivid_vbi_out_qops = {
         .buf_queue              = vbi_out_buf_queue,
         .start_streaming        = vbi_out_start_streaming,
         .stop_streaming         = vbi_out_stop_streaming,
-        .wait_prepare           = vivid_unlock,
-        .wait_finish            = vivid_lock,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
 };
 
 int vidioc_g_fmt_vbi_out(struct file *file, void *priv,
diff --git a/drivers/media/platform/vivid/vivid-vid-cap.c b/drivers/media/platform/vivid/vivid-vid-cap.c
index 331c54429b40..867a29a6d18f 100644
--- a/drivers/media/platform/vivid/vivid-vid-cap.c
+++ b/drivers/media/platform/vivid/vivid-vid-cap.c
@@ -288,8 +288,8 @@ const struct vb2_ops vivid_vid_cap_qops = {
         .buf_queue              = vid_cap_buf_queue,
         .start_streaming        = vid_cap_start_streaming,
         .stop_streaming         = vid_cap_stop_streaming,
-        .wait_prepare           = vivid_unlock,
-        .wait_finish            = vivid_lock,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
 };
 
 /*
@@ -443,12 +443,12 @@ void vivid_update_format_cap(struct vivid_dev *dev, bool keep_controls)
                         break;
                 if (bt->standards & V4L2_DV_BT_STD_CEA861) {
                         if (bt->width == 720 && bt->height <= 576)
-                                v4l2_ctrl_s_ctrl(dev->colorspace, V4L2_COLORSPACE_SMPTE170M);
+                                v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
                         else
-                                v4l2_ctrl_s_ctrl(dev->colorspace, V4L2_COLORSPACE_REC709);
+                                v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_709);
                         v4l2_ctrl_s_ctrl(dev->real_rgb_range_cap, 1);
                 } else {
-                        v4l2_ctrl_s_ctrl(dev->colorspace, V4L2_COLORSPACE_SRGB);
+                        v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
                         v4l2_ctrl_s_ctrl(dev->real_rgb_range_cap, 0);
                 }
                 tpg_s_rgb_range(&dev->tpg, v4l2_ctrl_g_ctrl(dev->rgb_range_cap));
@@ -498,6 +498,20 @@ static unsigned vivid_colorspace_cap(struct vivid_dev *dev)
         return dev->colorspace_out;
 }
 
+static unsigned vivid_ycbcr_enc_cap(struct vivid_dev *dev)
+{
+        if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
+                return tpg_g_ycbcr_enc(&dev->tpg);
+        return dev->ycbcr_enc_out;
+}
+
+static unsigned vivid_quantization_cap(struct vivid_dev *dev)
+{
+        if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
+                return tpg_g_quantization(&dev->tpg);
+        return dev->quantization_out;
+}
+
 int vivid_g_fmt_vid_cap(struct file *file, void *priv,
                                         struct v4l2_format *f)
 {
@@ -510,6 +524,8 @@ int vivid_g_fmt_vid_cap(struct file *file, void *priv,
         mp->field        = dev->field_cap;
         mp->pixelformat  = dev->fmt_cap->fourcc;
         mp->colorspace   = vivid_colorspace_cap(dev);
+        mp->ycbcr_enc    = vivid_ycbcr_enc_cap(dev);
+        mp->quantization = vivid_quantization_cap(dev);
         mp->num_planes = dev->fmt_cap->planes;
         for (p = 0; p < mp->num_planes; p++) {
                 mp->plane_fmt[p].bytesperline = tpg_g_bytesperline(&dev->tpg, p);
@@ -595,6 +611,8 @@ int vivid_try_fmt_vid_cap(struct file *file, void *priv,
                 memset(pfmt[p].reserved, 0, sizeof(pfmt[p].reserved));
         }
         mp->colorspace = vivid_colorspace_cap(dev);
+        mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
+        mp->quantization = vivid_quantization_cap(dev);
         memset(mp->reserved, 0, sizeof(mp->reserved));
         return 0;
 }
@@ -1307,20 +1325,20 @@ int vidioc_s_input(struct file *file, void *priv, unsigned i)
         if (dev->colorspace) {
                 switch (dev->input_type[i]) {
                 case WEBCAM:
-                        v4l2_ctrl_s_ctrl(dev->colorspace, V4L2_COLORSPACE_SRGB);
+                        v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
                         break;
                 case TV:
                 case SVID:
-                        v4l2_ctrl_s_ctrl(dev->colorspace, V4L2_COLORSPACE_SMPTE170M);
+                        v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
                         break;
                 case HDMI:
                         if (bt->standards & V4L2_DV_BT_STD_CEA861) {
                                 if (dev->src_rect.width == 720 && dev->src_rect.height <= 576)
-                                        v4l2_ctrl_s_ctrl(dev->colorspace, V4L2_COLORSPACE_SMPTE170M);
+                                        v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
                                 else
-                                        v4l2_ctrl_s_ctrl(dev->colorspace, V4L2_COLORSPACE_REC709);
+                                        v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_709);
                         } else {
-                                v4l2_ctrl_s_ctrl(dev->colorspace, V4L2_COLORSPACE_SRGB);
+                                v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
                         }
                         break;
                 }
diff --git a/drivers/media/platform/vivid/vivid-vid-common.c b/drivers/media/platform/vivid/vivid-vid-common.c
index 16cd6d2d2ed6..6bef1e6d6788 100644
--- a/drivers/media/platform/vivid/vivid-vid-common.c
+++ b/drivers/media/platform/vivid/vivid-vid-common.c
@@ -259,6 +259,8 @@ void fmt_sp2mp(const struct v4l2_format *sp_fmt, struct v4l2_format *mp_fmt)
         mp->pixelformat = pix->pixelformat;
         mp->field = pix->field;
         mp->colorspace = pix->colorspace;
+        mp->ycbcr_enc = pix->ycbcr_enc;
+        mp->quantization = pix->quantization;
         mp->num_planes = 1;
         mp->flags = pix->flags;
         ppix->sizeimage = pix->sizeimage;
@@ -285,6 +287,8 @@ int fmt_sp2mp_func(struct file *file, void *priv,
         pix->pixelformat = mp->pixelformat;
         pix->field = mp->field;
         pix->colorspace = mp->colorspace;
+        pix->ycbcr_enc = mp->ycbcr_enc;
+        pix->quantization = mp->quantization;
         pix->sizeimage = ppix->sizeimage;
         pix->bytesperline = ppix->bytesperline;
         pix->flags = mp->flags;
diff --git a/drivers/media/platform/vivid/vivid-vid-out.c b/drivers/media/platform/vivid/vivid-vid-out.c
index 69c2dbd2d165..ee5c3992b276 100644
--- a/drivers/media/platform/vivid/vivid-vid-out.c
+++ b/drivers/media/platform/vivid/vivid-vid-out.c
@@ -209,8 +209,8 @@ const struct vb2_ops vivid_vid_out_qops = {
         .buf_queue              = vid_out_buf_queue,
         .start_streaming        = vid_out_start_streaming,
         .stop_streaming         = vid_out_stop_streaming,
-        .wait_prepare           = vivid_unlock,
-        .wait_finish            = vivid_lock,
+        .wait_prepare           = vb2_ops_wait_prepare,
+        .wait_finish            = vb2_ops_wait_finish,
 };
 
 /*
@@ -259,6 +259,8 @@ void vivid_update_format_out(struct vivid_dev *dev)
                 }
                 break;
         }
+        dev->ycbcr_enc_out = V4L2_YCBCR_ENC_DEFAULT;
+        dev->quantization_out = V4L2_QUANTIZATION_DEFAULT;
         dev->compose_out = dev->sink_rect;
         dev->compose_bounds_out = dev->sink_rect;
         dev->crop_out = dev->compose_out;
@@ -318,6 +320,8 @@ int vivid_g_fmt_vid_out(struct file *file, void *priv,
         mp->field        = dev->field_out;
         mp->pixelformat  = dev->fmt_out->fourcc;
         mp->colorspace   = dev->colorspace_out;
+        mp->ycbcr_enc    = dev->ycbcr_enc_out;
+        mp->quantization = dev->quantization_out;
         mp->num_planes = dev->fmt_out->planes;
         for (p = 0; p < mp->num_planes; p++) {
                 mp->plane_fmt[p].bytesperline = dev->bytesperline_out[p];
@@ -394,16 +398,23 @@ int vivid_try_fmt_vid_out(struct file *file, void *priv,
                 pfmt[p].sizeimage = pfmt[p].bytesperline * mp->height;
                 memset(pfmt[p].reserved, 0, sizeof(pfmt[p].reserved));
         }
-        if (vivid_is_svid_out(dev))
+        mp->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
+        mp->quantization = V4L2_QUANTIZATION_DEFAULT;
+        if (vivid_is_svid_out(dev)) {
                 mp->colorspace = V4L2_COLORSPACE_SMPTE170M;
-        else if (dev->dvi_d_out || !(bt->standards & V4L2_DV_BT_STD_CEA861))
+        } else if (dev->dvi_d_out || !(bt->standards & V4L2_DV_BT_STD_CEA861)) {
                 mp->colorspace = V4L2_COLORSPACE_SRGB;
-        else if (bt->width == 720 && bt->height <= 576)
+                if (dev->dvi_d_out)
+                        mp->quantization = V4L2_QUANTIZATION_LIM_RANGE;
+        } else if (bt->width == 720 && bt->height <= 576) {
                 mp->colorspace = V4L2_COLORSPACE_SMPTE170M;
-        else if (mp->colorspace != V4L2_COLORSPACE_SMPTE170M &&
-                 mp->colorspace != V4L2_COLORSPACE_REC709 &&
-                 mp->colorspace != V4L2_COLORSPACE_SRGB)
+        } else if (mp->colorspace != V4L2_COLORSPACE_SMPTE170M &&
+                   mp->colorspace != V4L2_COLORSPACE_REC709 &&
+                   mp->colorspace != V4L2_COLORSPACE_ADOBERGB &&
+                   mp->colorspace != V4L2_COLORSPACE_BT2020 &&
+                   mp->colorspace != V4L2_COLORSPACE_SRGB) {
                 mp->colorspace = V4L2_COLORSPACE_REC709;
+        }
         memset(mp->reserved, 0, sizeof(mp->reserved));
         return 0;
 }
@@ -522,6 +533,8 @@ int vivid_s_fmt_vid_out(struct file *file, void *priv,
 
 set_colorspace:
         dev->colorspace_out = mp->colorspace;
+        dev->ycbcr_enc_out = mp->ycbcr_enc;
+        dev->quantization_out = mp->quantization;
         if (dev->loop_video) {
                 vivid_send_source_change(dev, SVID);
                 vivid_send_source_change(dev, HDMI);
diff --git a/drivers/media/platform/vsp1/vsp1_bru.c b/drivers/media/platform/vsp1/vsp1_bru.c
index a0c1984c733e..b21f381a9862 100644
--- a/drivers/media/platform/vsp1/vsp1_bru.c
+++ b/drivers/media/platform/vsp1/vsp1_bru.c
@@ -187,8 +187,8 @@ static int bru_enum_mbus_code(struct v4l2_subdev *subdev,
                               struct v4l2_subdev_mbus_code_enum *code)
 {
         static const unsigned int codes[] = {
-                V4L2_MBUS_FMT_ARGB8888_1X32,
-                V4L2_MBUS_FMT_AYUV8_1X32,
+                MEDIA_BUS_FMT_ARGB8888_1X32,
+                MEDIA_BUS_FMT_AYUV8_1X32,
         };
         struct v4l2_mbus_framefmt *format;
 
@@ -215,8 +215,8 @@ static int bru_enum_frame_size(struct v4l2_subdev *subdev,
         if (fse->index)
                 return -EINVAL;
 
-        if (fse->code != V4L2_MBUS_FMT_ARGB8888_1X32 &&
-            fse->code != V4L2_MBUS_FMT_AYUV8_1X32)
+        if (fse->code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
+            fse->code != MEDIA_BUS_FMT_AYUV8_1X32)
                 return -EINVAL;
 
         fse->min_width = BRU_MIN_SIZE;
@@ -261,9 +261,9 @@ static void bru_try_format(struct vsp1_bru *bru, struct v4l2_subdev_fh *fh,
         switch (pad) {
         case BRU_PAD_SINK(0):
                 /* Default to YUV if the requested format is not supported. */
-                if (fmt->code != V4L2_MBUS_FMT_ARGB8888_1X32 &&
-                    fmt->code != V4L2_MBUS_FMT_AYUV8_1X32)
-                        fmt->code = V4L2_MBUS_FMT_AYUV8_1X32;
+                if (fmt->code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
+                    fmt->code != MEDIA_BUS_FMT_AYUV8_1X32)
+                        fmt->code = MEDIA_BUS_FMT_AYUV8_1X32;
                 break;
 
         default:
diff --git a/drivers/media/platform/vsp1/vsp1_hsit.c b/drivers/media/platform/vsp1/vsp1_hsit.c
index db2950a73c60..80bedc554ee3 100644
--- a/drivers/media/platform/vsp1/vsp1_hsit.c
+++ b/drivers/media/platform/vsp1/vsp1_hsit.c
@@ -70,9 +70,9 @@ static int hsit_enum_mbus_code(struct v4l2_subdev *subdev,
 
         if ((code->pad == HSIT_PAD_SINK && !hsit->inverse) |
             (code->pad == HSIT_PAD_SOURCE && hsit->inverse))
-                code->code = V4L2_MBUS_FMT_ARGB8888_1X32;
+                code->code = MEDIA_BUS_FMT_ARGB8888_1X32;
         else
-                code->code = V4L2_MBUS_FMT_AHSV8888_1X32;
+                code->code = MEDIA_BUS_FMT_AHSV8888_1X32;
 
         return 0;
 }
@@ -136,8 +136,8 @@ static int hsit_set_format(struct v4l2_subdev *subdev,
                 return 0;
         }
 
-        format->code = hsit->inverse ? V4L2_MBUS_FMT_AHSV8888_1X32
-                     : V4L2_MBUS_FMT_ARGB8888_1X32;
+        format->code = hsit->inverse ? MEDIA_BUS_FMT_AHSV8888_1X32
+                     : MEDIA_BUS_FMT_ARGB8888_1X32;
         format->width = clamp_t(unsigned int, fmt->format.width,
                                 HSIT_MIN_SIZE, HSIT_MAX_SIZE);
         format->height = clamp_t(unsigned int, fmt->format.height,
@@ -151,8 +151,8 @@ static int hsit_set_format(struct v4l2_subdev *subdev,
         format = vsp1_entity_get_pad_format(&hsit->entity, fh, HSIT_PAD_SOURCE,
                                             fmt->which);
         *format = fmt->format;
-        format->code = hsit->inverse ? V4L2_MBUS_FMT_ARGB8888_1X32
-                     : V4L2_MBUS_FMT_AHSV8888_1X32;
+        format->code = hsit->inverse ? MEDIA_BUS_FMT_ARGB8888_1X32
+                     : MEDIA_BUS_FMT_AHSV8888_1X32;
 
         return 0;
 }
diff --git a/drivers/media/platform/vsp1/vsp1_lif.c b/drivers/media/platform/vsp1/vsp1_lif.c
index d4fb23e9c4a8..17a6ca7dafe6 100644
--- a/drivers/media/platform/vsp1/vsp1_lif.c
+++ b/drivers/media/platform/vsp1/vsp1_lif.c
@@ -78,8 +78,8 @@ static int lif_enum_mbus_code(struct v4l2_subdev *subdev,
                               struct v4l2_subdev_mbus_code_enum *code)
 {
         static const unsigned int codes[] = {
-                V4L2_MBUS_FMT_ARGB8888_1X32,
-                V4L2_MBUS_FMT_AYUV8_1X32,
+                MEDIA_BUS_FMT_ARGB8888_1X32,
+                MEDIA_BUS_FMT_AYUV8_1X32,
         };
 
         if (code->pad == LIF_PAD_SINK) {
@@ -147,9 +147,9 @@ static int lif_set_format(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh,
         struct v4l2_mbus_framefmt *format;
 
         /* Default to YUV if the requested format is not supported. */
-        if (fmt->format.code != V4L2_MBUS_FMT_ARGB8888_1X32 &&
-            fmt->format.code != V4L2_MBUS_FMT_AYUV8_1X32)
-                fmt->format.code = V4L2_MBUS_FMT_AYUV8_1X32;
+        if (fmt->format.code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
+            fmt->format.code != MEDIA_BUS_FMT_AYUV8_1X32)
+                fmt->format.code = MEDIA_BUS_FMT_AYUV8_1X32;
 
         format = vsp1_entity_get_pad_format(&lif->entity, fh, fmt->pad,
                                             fmt->which);
diff --git a/drivers/media/platform/vsp1/vsp1_lut.c b/drivers/media/platform/vsp1/vsp1_lut.c
index fea36ebe2565..6f185c3621fe 100644
--- a/drivers/media/platform/vsp1/vsp1_lut.c
+++ b/drivers/media/platform/vsp1/vsp1_lut.c
@@ -86,9 +86,9 @@ static int lut_enum_mbus_code(struct v4l2_subdev *subdev,
                               struct v4l2_subdev_mbus_code_enum *code)
 {
         static const unsigned int codes[] = {
-                V4L2_MBUS_FMT_ARGB8888_1X32,
-                V4L2_MBUS_FMT_AHSV8888_1X32,
-                V4L2_MBUS_FMT_AYUV8_1X32,
+                MEDIA_BUS_FMT_ARGB8888_1X32,
+                MEDIA_BUS_FMT_AHSV8888_1X32,
+                MEDIA_BUS_FMT_AYUV8_1X32,
         };
         struct v4l2_mbus_framefmt *format;
 
@@ -158,10 +158,10 @@ static int lut_set_format(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh,
         struct v4l2_mbus_framefmt *format;
 
         /* Default to YUV if the requested format is not supported. */
-        if (fmt->format.code != V4L2_MBUS_FMT_ARGB8888_1X32 &&
-            fmt->format.code != V4L2_MBUS_FMT_AHSV8888_1X32 &&
-            fmt->format.code != V4L2_MBUS_FMT_AYUV8_1X32)
-                fmt->format.code = V4L2_MBUS_FMT_AYUV8_1X32;
+        if (fmt->format.code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
+            fmt->format.code != MEDIA_BUS_FMT_AHSV8888_1X32 &&
+            fmt->format.code != MEDIA_BUS_FMT_AYUV8_1X32)
+                fmt->format.code = MEDIA_BUS_FMT_AYUV8_1X32;
 
         format = vsp1_entity_get_pad_format(&lut->entity, fh, fmt->pad,
                                             fmt->which);
diff --git a/drivers/media/platform/vsp1/vsp1_rwpf.c b/drivers/media/platform/vsp1/vsp1_rwpf.c
index ec3dab6a9b9b..1f1ba26a834a 100644
--- a/drivers/media/platform/vsp1/vsp1_rwpf.c
+++ b/drivers/media/platform/vsp1/vsp1_rwpf.c
@@ -29,8 +29,8 @@ int vsp1_rwpf_enum_mbus_code(struct v4l2_subdev *subdev,
                              struct v4l2_subdev_mbus_code_enum *code)
 {
         static const unsigned int codes[] = {
-                V4L2_MBUS_FMT_ARGB8888_1X32,
-                V4L2_MBUS_FMT_AYUV8_1X32,
+                MEDIA_BUS_FMT_ARGB8888_1X32,
+                MEDIA_BUS_FMT_AYUV8_1X32,
         };
 
         if (code->index >= ARRAY_SIZE(codes))
@@ -103,9 +103,9 @@ int vsp1_rwpf_set_format(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh,
         struct v4l2_rect *crop;
 
         /* Default to YUV if the requested format is not supported. */
-        if (fmt->format.code != V4L2_MBUS_FMT_ARGB8888_1X32 &&
-            fmt->format.code != V4L2_MBUS_FMT_AYUV8_1X32)
-                fmt->format.code = V4L2_MBUS_FMT_AYUV8_1X32;
+        if (fmt->format.code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
+            fmt->format.code != MEDIA_BUS_FMT_AYUV8_1X32)
+                fmt->format.code = MEDIA_BUS_FMT_AYUV8_1X32;
 
         format = vsp1_entity_get_pad_format(&rwpf->entity, fh, fmt->pad,
                                             fmt->which);
diff --git a/drivers/media/platform/vsp1/vsp1_sru.c b/drivers/media/platform/vsp1/vsp1_sru.c
index b7d3c8b9f189..1129494c7cfc 100644
--- a/drivers/media/platform/vsp1/vsp1_sru.c
+++ b/drivers/media/platform/vsp1/vsp1_sru.c
@@ -139,7 +139,7 @@ static int sru_s_stream(struct v4l2_subdev *subdev, int enable)
         input = &sru->entity.formats[SRU_PAD_SINK];
         output = &sru->entity.formats[SRU_PAD_SOURCE];
 
-        if (input->code == V4L2_MBUS_FMT_ARGB8888_1X32)
+        if (input->code == MEDIA_BUS_FMT_ARGB8888_1X32)
                 ctrl0 = VI6_SRU_CTRL0_PARAM2 | VI6_SRU_CTRL0_PARAM3
                       | VI6_SRU_CTRL0_PARAM4;
         else
@@ -170,8 +170,8 @@ static int sru_enum_mbus_code(struct v4l2_subdev *subdev,
                               struct v4l2_subdev_mbus_code_enum *code)
 {
         static const unsigned int codes[] = {
-                V4L2_MBUS_FMT_ARGB8888_1X32,
-                V4L2_MBUS_FMT_AYUV8_1X32,
+                MEDIA_BUS_FMT_ARGB8888_1X32,
+                MEDIA_BUS_FMT_AYUV8_1X32,
         };
         struct v4l2_mbus_framefmt *format;
 
@@ -248,9 +248,9 @@ static void sru_try_format(struct vsp1_sru *sru, struct v4l2_subdev_fh *fh,
         switch (pad) {
         case SRU_PAD_SINK:
                 /* Default to YUV if the requested format is not supported. */
-                if (fmt->code != V4L2_MBUS_FMT_ARGB8888_1X32 &&
-                    fmt->code != V4L2_MBUS_FMT_AYUV8_1X32)
-                        fmt->code = V4L2_MBUS_FMT_AYUV8_1X32;
+                if (fmt->code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
+                    fmt->code != MEDIA_BUS_FMT_AYUV8_1X32)
+                        fmt->code = MEDIA_BUS_FMT_AYUV8_1X32;
 
                 fmt->width = clamp(fmt->width, SRU_MIN_SIZE, SRU_MAX_SIZE);
                 fmt->height = clamp(fmt->height, SRU_MIN_SIZE, SRU_MAX_SIZE);
diff --git a/drivers/media/platform/vsp1/vsp1_uds.c b/drivers/media/platform/vsp1/vsp1_uds.c
index de92ef4944b3..a4afec133800 100644
--- a/drivers/media/platform/vsp1/vsp1_uds.c
+++ b/drivers/media/platform/vsp1/vsp1_uds.c
@@ -173,8 +173,8 @@ static int uds_enum_mbus_code(struct v4l2_subdev *subdev,
                               struct v4l2_subdev_mbus_code_enum *code)
 {
         static const unsigned int codes[] = {
-                V4L2_MBUS_FMT_ARGB8888_1X32,
-                V4L2_MBUS_FMT_AYUV8_1X32,
+                MEDIA_BUS_FMT_ARGB8888_1X32,
+                MEDIA_BUS_FMT_AYUV8_1X32,
         };
 
         if (code->pad == UDS_PAD_SINK) {
@@ -246,9 +246,9 @@ static void uds_try_format(struct vsp1_uds *uds, struct v4l2_subdev_fh *fh,
         switch (pad) {
         case UDS_PAD_SINK:
                 /* Default to YUV if the requested format is not supported. */
-                if (fmt->code != V4L2_MBUS_FMT_ARGB8888_1X32 &&
-                    fmt->code != V4L2_MBUS_FMT_AYUV8_1X32)
-                        fmt->code = V4L2_MBUS_FMT_AYUV8_1X32;
+                if (fmt->code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
+                    fmt->code != MEDIA_BUS_FMT_AYUV8_1X32)
+                        fmt->code = MEDIA_BUS_FMT_AYUV8_1X32;
 
                 fmt->width = clamp(fmt->width, UDS_MIN_SIZE, UDS_MAX_SIZE);
                 fmt->height = clamp(fmt->height, UDS_MIN_SIZE, UDS_MAX_SIZE);
diff --git a/drivers/media/platform/vsp1/vsp1_video.c b/drivers/media/platform/vsp1/vsp1_video.c
index 915a20eb003e..d91f19a9e1c1 100644
--- a/drivers/media/platform/vsp1/vsp1_video.c
+++ b/drivers/media/platform/vsp1/vsp1_video.c
@@ -48,85 +48,85 @@
  */
 
 static const struct vsp1_format_info vsp1_video_formats[] = {
-        { V4L2_PIX_FMT_RGB332, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_RGB332, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_RGB_332, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 8, 0, 0 }, false, false, 1, 1, false },
-        { V4L2_PIX_FMT_ARGB444, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_ARGB444, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_ARGB_4444, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS,
           1, { 16, 0, 0 }, false, false, 1, 1, true },
-        { V4L2_PIX_FMT_XRGB444, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_XRGB444, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_XRGB_4444, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS,
           1, { 16, 0, 0 }, false, false, 1, 1, true },
-        { V4L2_PIX_FMT_ARGB555, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_ARGB555, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_ARGB_1555, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS,
           1, { 16, 0, 0 }, false, false, 1, 1, true },
-        { V4L2_PIX_FMT_XRGB555, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_XRGB555, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_XRGB_1555, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS,
           1, { 16, 0, 0 }, false, false, 1, 1, false },
-        { V4L2_PIX_FMT_RGB565, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_RGB565, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_RGB_565, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS,
           1, { 16, 0, 0 }, false, false, 1, 1, false },
-        { V4L2_PIX_FMT_BGR24, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_BGR24, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_BGR_888, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 24, 0, 0 }, false, false, 1, 1, false },
-        { V4L2_PIX_FMT_RGB24, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_RGB24, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_RGB_888, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 24, 0, 0 }, false, false, 1, 1, false },
-        { V4L2_PIX_FMT_ABGR32, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_ABGR32, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_ARGB_8888, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS,
           1, { 32, 0, 0 }, false, false, 1, 1, true },
-        { V4L2_PIX_FMT_XBGR32, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_XBGR32, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_ARGB_8888, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS,
           1, { 32, 0, 0 }, false, false, 1, 1, false },
-        { V4L2_PIX_FMT_ARGB32, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_ARGB32, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_ARGB_8888, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 32, 0, 0 }, false, false, 1, 1, true },
-        { V4L2_PIX_FMT_XRGB32, V4L2_MBUS_FMT_ARGB8888_1X32,
+        { V4L2_PIX_FMT_XRGB32, MEDIA_BUS_FMT_ARGB8888_1X32,
           VI6_FMT_ARGB_8888, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 32, 0, 0 }, false, false, 1, 1, false },
-        { V4L2_PIX_FMT_UYVY, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_UYVY, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_YUYV_422, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 16, 0, 0 }, false, false, 2, 1, false },
-        { V4L2_PIX_FMT_VYUY, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_VYUY, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_YUYV_422, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 16, 0, 0 }, false, true, 2, 1, false },
-        { V4L2_PIX_FMT_YUYV, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_YUYV, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_YUYV_422, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 16, 0, 0 }, true, false, 2, 1, false },
-        { V4L2_PIX_FMT_YVYU, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_YVYU, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_YUYV_422, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           1, { 16, 0, 0 }, true, true, 2, 1, false },
-        { V4L2_PIX_FMT_NV12M, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_NV12M, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_Y_UV_420, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           2, { 8, 16, 0 }, false, false, 2, 2, false },
-        { V4L2_PIX_FMT_NV21M, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_NV21M, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_Y_UV_420, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           2, { 8, 16, 0 }, false, true, 2, 2, false },
-        { V4L2_PIX_FMT_NV16M, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_NV16M, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_Y_UV_422, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           2, { 8, 16, 0 }, false, false, 2, 1, false },
-        { V4L2_PIX_FMT_NV61M, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_NV61M, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_Y_UV_422, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           2, { 8, 16, 0 }, false, true, 2, 1, false },
-        { V4L2_PIX_FMT_YUV420M, V4L2_MBUS_FMT_AYUV8_1X32,
+        { V4L2_PIX_FMT_YUV420M, MEDIA_BUS_FMT_AYUV8_1X32,
           VI6_FMT_Y_U_V_420, VI6_RPF_DSWAP_P_LLS | VI6_RPF_DSWAP_P_LWS |
           VI6_RPF_DSWAP_P_WDS | VI6_RPF_DSWAP_P_BTS,
           3, { 8, 8, 8 }, false, false, 2, 2, false },
diff --git a/drivers/media/radio/radio-wl1273.c b/drivers/media/radio/radio-wl1273.c
index 9cf6731fb816..284f789265e0 100644
--- a/drivers/media/radio/radio-wl1273.c
+++ b/drivers/media/radio/radio-wl1273.c
@@ -1279,10 +1279,12 @@ static int wl1273_fm_vidioc_querycap(struct file *file, void *priv,
         strlcpy(capability->bus_info, radio->bus_type,
                 sizeof(capability->bus_info));
 
-        capability->capabilities = V4L2_CAP_HW_FREQ_SEEK |
+        capability->device_caps = V4L2_CAP_HW_FREQ_SEEK |
                 V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_AUDIO |
                 V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR |
                 V4L2_CAP_RDS_OUTPUT;
+        capability->capabilities = capability->device_caps |
+                V4L2_CAP_DEVICE_CAPS;
 
         return 0;
 }
diff --git a/drivers/media/radio/si4713/radio-platform-si4713.c b/drivers/media/radio/si4713/radio-platform-si4713.c
index a47502a330f0..2de5439b9c79 100644
--- a/drivers/media/radio/si4713/radio-platform-si4713.c
+++ b/drivers/media/radio/si4713/radio-platform-si4713.c
@@ -34,7 +34,7 @@
 #include <media/v4l2-fh.h>
 #include <media/v4l2-ctrls.h>
 #include <media/v4l2-event.h>
-#include <media/radio-si4713.h>
+#include "si4713.h"
 
 /* module parameters */
 static int radio_nr = -1;       /* radio device minor (-1 ==> auto assign) */
@@ -153,7 +153,6 @@ static int radio_si4713_pdriver_probe(struct platform_device *pdev)
 {
         struct radio_si4713_platform_data *pdata = pdev->dev.platform_data;
         struct radio_si4713_device *rsdev;
-        struct i2c_adapter *adapter;
         struct v4l2_subdev *sd;
         int rval = 0;
 
@@ -177,20 +176,11 @@ static int radio_si4713_pdriver_probe(struct platform_device *pdev)
                 goto exit;
         }
 
-        adapter = i2c_get_adapter(pdata->i2c_bus);
-        if (!adapter) {
-                dev_err(&pdev->dev, "Cannot get i2c adapter %d\n",
-                        pdata->i2c_bus);
-                rval = -ENODEV;
-                goto unregister_v4l2_dev;
-        }
-
-        sd = v4l2_i2c_new_subdev_board(&rsdev->v4l2_dev, adapter,
-                                       pdata->subdev_board_info, NULL);
-        if (!sd) {
+        sd = i2c_get_clientdata(pdata->subdev);
+        rval = v4l2_device_register_subdev(&rsdev->v4l2_dev, sd);
+        if (rval) {
                 dev_err(&pdev->dev, "Cannot get v4l2 subdevice\n");
-                rval = -ENODEV;
-                goto put_adapter;
+                goto unregister_v4l2_dev;
         }
 
         rsdev->radio_dev = radio_si4713_vdev_template;
@@ -202,14 +192,12 @@ static int radio_si4713_pdriver_probe(struct platform_device *pdev)
         if (video_register_device(&rsdev->radio_dev, VFL_TYPE_RADIO, radio_nr)) {
                 dev_err(&pdev->dev, "Could not register video device.\n");
                 rval = -EIO;
-                goto put_adapter;
+                goto unregister_v4l2_dev;
         }
         dev_info(&pdev->dev, "New device successfully probed\n");
 
         goto exit;
 
-put_adapter:
-        i2c_put_adapter(adapter);
 unregister_v4l2_dev:
         v4l2_device_unregister(&rsdev->v4l2_dev);
 exit:
@@ -220,14 +208,10 @@ exit:
 static int radio_si4713_pdriver_remove(struct platform_device *pdev)
 {
         struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
-        struct v4l2_subdev *sd = list_entry(v4l2_dev->subdevs.next,
-                                            struct v4l2_subdev, list);
-        struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct radio_si4713_device *rsdev;
 
         rsdev = container_of(v4l2_dev, struct radio_si4713_device, v4l2_dev);
         video_unregister_device(&rsdev->radio_dev);
-        i2c_put_adapter(client->adapter);
         v4l2_device_unregister(&rsdev->v4l2_dev);
 
         return 0;
diff --git a/drivers/media/radio/si4713/si4713.c b/drivers/media/radio/si4713/si4713.c
index b5765557ea3d..c90004dac170 100644
--- a/drivers/media/radio/si4713/si4713.c
+++ b/drivers/media/radio/si4713/si4713.c
@@ -23,6 +23,7 @@
 
 #include <linux/completion.h>
 #include <linux/delay.h>
+#include <linux/err.h>
 #include <linux/interrupt.h>
 #include <linux/i2c.h>
 #include <linux/slab.h>
@@ -366,16 +367,25 @@ static int si4713_powerup(struct si4713_device *sdev)
         if (sdev->power_state)
                 return 0;
 
-        if (sdev->supplies) {
-                err = regulator_bulk_enable(sdev->supplies, sdev->supply_data);
+        if (sdev->vdd) {
+                err = regulator_enable(sdev->vdd);
                 if (err) {
-                        v4l2_err(&sdev->sd, "Failed to enable supplies: %d\n", err);
+                        v4l2_err(&sdev->sd, "Failed to enable vdd: %d\n", err);
                         return err;
                 }
         }
-        if (gpio_is_valid(sdev->gpio_reset)) {
+
+        if (sdev->vio) {
+                err = regulator_enable(sdev->vio);
+                if (err) {
+                        v4l2_err(&sdev->sd, "Failed to enable vio: %d\n", err);
+                        return err;
+                }
+        }
+
+        if (!IS_ERR(sdev->gpio_reset)) {
                 udelay(50);
-                gpio_set_value(sdev->gpio_reset, 1);
+                gpiod_set_value(sdev->gpio_reset, 1);
         }
 
         if (client->irq)
@@ -397,13 +407,20 @@ static int si4713_powerup(struct si4713_device *sdev)
                                                 SI4713_STC_INT | SI4713_CTS);
                 return err;
         }
-        if (gpio_is_valid(sdev->gpio_reset))
-                gpio_set_value(sdev->gpio_reset, 0);
-        if (sdev->supplies) {
-                err = regulator_bulk_disable(sdev->supplies, sdev->supply_data);
+        if (!IS_ERR(sdev->gpio_reset))
+                gpiod_set_value(sdev->gpio_reset, 0);
+
+
+        if (sdev->vdd) {
+                err = regulator_disable(sdev->vdd);
                 if (err)
-                        v4l2_err(&sdev->sd,
-                                 "Failed to disable supplies: %d\n", err);
+                        v4l2_err(&sdev->sd, "Failed to disable vdd: %d\n", err);
+        }
+
+        if (sdev->vio) {
+                err = regulator_disable(sdev->vio);
+                if (err)
+                        v4l2_err(&sdev->sd, "Failed to disable vio: %d\n", err);
         }
 
         return err;
@@ -430,14 +447,23 @@ static int si4713_powerdown(struct si4713_device *sdev)
                 v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n",
                                 resp[0]);
                 v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n");
-                if (gpio_is_valid(sdev->gpio_reset))
-                        gpio_set_value(sdev->gpio_reset, 0);
-                if (sdev->supplies) {
-                        err = regulator_bulk_disable(sdev->supplies,
-                                                     sdev->supply_data);
-                        if (err)
+                if (!IS_ERR(sdev->gpio_reset))
+                        gpiod_set_value(sdev->gpio_reset, 0);
+
+                if (sdev->vdd) {
+                        err = regulator_disable(sdev->vdd);
+                        if (err) {
                                 v4l2_err(&sdev->sd,
-                                         "Failed to disable supplies: %d\n", err);
+                                        "Failed to disable vdd: %d\n", err);
+                        }
+                }
+
+                if (sdev->vio) {
+                        err = regulator_disable(sdev->vio);
+                        if (err) {
+                                v4l2_err(&sdev->sd,
+                                        "Failed to disable vio: %d\n", err);
+                        }
                 }
                 sdev->power_state = POWER_OFF;
         }
@@ -1420,38 +1446,51 @@ static int si4713_probe(struct i2c_client *client,
                                         const struct i2c_device_id *id)
 {
         struct si4713_device *sdev;
-        struct si4713_platform_data *pdata = client->dev.platform_data;
         struct v4l2_ctrl_handler *hdl;
-        int rval, i;
+        struct si4713_platform_data *pdata = client->dev.platform_data;
+        struct device_node *np = client->dev.of_node;
+        struct radio_si4713_platform_data si4713_pdev_pdata;
+        struct platform_device *si4713_pdev;
+        int rval;
 
-        sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
+        sdev = devm_kzalloc(&client->dev, sizeof(*sdev), GFP_KERNEL);
         if (!sdev) {
                 dev_err(&client->dev, "Failed to alloc video device.\n");
                 rval = -ENOMEM;
                 goto exit;
         }
 
-        sdev->gpio_reset = -1;
-        if (pdata && gpio_is_valid(pdata->gpio_reset)) {
-                rval = gpio_request(pdata->gpio_reset, "si4713 reset");
-                if (rval) {
-                        dev_err(&client->dev,
-                                "Failed to request gpio: %d\n", rval);
-                        goto free_sdev;
-                }
-                sdev->gpio_reset = pdata->gpio_reset;
-                gpio_direction_output(sdev->gpio_reset, 0);
-                sdev->supplies = pdata->supplies;
+        sdev->gpio_reset = devm_gpiod_get(&client->dev, "reset");
+        if (!IS_ERR(sdev->gpio_reset)) {
+                gpiod_direction_output(sdev->gpio_reset, 0);
+        } else if (PTR_ERR(sdev->gpio_reset) == -ENOENT) {
+                dev_dbg(&client->dev, "No reset GPIO assigned\n");
+        } else if (PTR_ERR(sdev->gpio_reset) == -ENOSYS) {
+                dev_dbg(&client->dev, "No reset GPIO support\n");
+        } else {
+                rval = PTR_ERR(sdev->gpio_reset);
+                dev_err(&client->dev, "Failed to request gpio: %d\n", rval);
+                goto exit;
         }
 
-        for (i = 0; i < sdev->supplies; i++)
-                sdev->supply_data[i].supply = pdata->supply_names[i];
+        sdev->vdd = devm_regulator_get_optional(&client->dev, "vdd");
+        if (IS_ERR(sdev->vdd)) {
+                rval = PTR_ERR(sdev->vdd);
+                if (rval == -EPROBE_DEFER)
+                        goto exit;
 
-        rval = regulator_bulk_get(&client->dev, sdev->supplies,
-                                  sdev->supply_data);
-        if (rval) {
-                dev_err(&client->dev, "Cannot get regulators: %d\n", rval);
-                goto free_gpio;
+                dev_dbg(&client->dev, "no vdd regulator found: %d\n", rval);
+                sdev->vdd = NULL;
+        }
+
+        sdev->vio = devm_regulator_get_optional(&client->dev, "vio");
+        if (IS_ERR(sdev->vio)) {
+                rval = PTR_ERR(sdev->vio);
+                if (rval == -EPROBE_DEFER)
+                        goto exit;
+
+                dev_dbg(&client->dev, "no vio regulator found: %d\n", rval);
+                sdev->vio = NULL;
         }
 
         v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
@@ -1554,12 +1593,12 @@ static int si4713_probe(struct i2c_client *client,
         sdev->sd.ctrl_handler = hdl;
 
         if (client->irq) {
-                rval = request_irq(client->irq,
+                rval = devm_request_irq(&client->dev, client->irq,
                         si4713_handler, IRQF_TRIGGER_FALLING,
                         client->name, sdev);
                 if (rval < 0) {
                         v4l2_err(&sdev->sd, "Could not request IRQ\n");
-                        goto put_reg;
+                        goto free_ctrls;
                 }
                 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
         } else {
@@ -1569,23 +1608,35 @@ static int si4713_probe(struct i2c_client *client,
         rval = si4713_initialize(sdev);
         if (rval < 0) {
                 v4l2_err(&sdev->sd, "Failed to probe device information.\n");
-                goto free_irq;
+                goto free_ctrls;
         }
 
+        if (!np && (!pdata || !pdata->is_platform_device))
+                return 0;
+
+        si4713_pdev = platform_device_alloc("radio-si4713", -1);
+        if (!si4713_pdev)
+                goto put_main_pdev;
+
+        si4713_pdev_pdata.subdev = client;
+        rval = platform_device_add_data(si4713_pdev, &si4713_pdev_pdata,
+                                        sizeof(si4713_pdev_pdata));
+        if (rval)
+                goto put_main_pdev;
+
+        rval = platform_device_add(si4713_pdev);
+        if (rval)
+                goto put_main_pdev;
+
+        sdev->pd = si4713_pdev;
+
         return 0;
 
-free_irq:
-        if (client->irq)
-                free_irq(client->irq, sdev);
+put_main_pdev:
+        platform_device_put(si4713_pdev);
+        v4l2_device_unregister_subdev(&sdev->sd);
 free_ctrls:
         v4l2_ctrl_handler_free(hdl);
-put_reg:
-        regulator_bulk_free(sdev->supplies, sdev->supply_data);
-free_gpio:
-        if (gpio_is_valid(sdev->gpio_reset))
-                gpio_free(sdev->gpio_reset);
-free_sdev:
-        kfree(sdev);
 exit:
         return rval;
 }
@@ -1596,18 +1647,13 @@ static int si4713_remove(struct i2c_client *client)
         struct v4l2_subdev *sd = i2c_get_clientdata(client);
         struct si4713_device *sdev = to_si4713_device(sd);
 
+        platform_device_unregister(sdev->pd);
+
         if (sdev->power_state)
                 si4713_set_power_state(sdev, POWER_DOWN);
 
-        if (client->irq > 0)
-                free_irq(client->irq, sdev);
-
         v4l2_device_unregister_subdev(sd);
         v4l2_ctrl_handler_free(sd->ctrl_handler);
-        regulator_bulk_free(sdev->supplies, sdev->supply_data);
-        if (gpio_is_valid(sdev->gpio_reset))
-                gpio_free(sdev->gpio_reset);
-        kfree(sdev);
 
         return 0;
 }
diff --git a/drivers/media/radio/si4713/si4713.h b/drivers/media/radio/si4713/si4713.h
index ed700e387605..8a376e142188 100644
--- a/drivers/media/radio/si4713/si4713.h
+++ b/drivers/media/radio/si4713/si4713.h
@@ -15,7 +15,9 @@
 #ifndef SI4713_I2C_H
 #define SI4713_I2C_H
 
+#include <linux/platform_device.h>
 #include <linux/regulator/consumer.h>
+#include <linux/gpio/consumer.h>
 #include <media/v4l2-subdev.h>
 #include <media/v4l2-ctrls.h>
 #include <media/si4713.h>
@@ -190,8 +192,6 @@
 #define MIN_ACOMP_THRESHOLD             (-40)
 #define MAX_ACOMP_GAIN                  20
 
-#define SI4713_NUM_SUPPLIES             2
-
 /*
  * si4713_device - private data
  */
@@ -236,9 +236,10 @@ struct si4713_device {
                 struct v4l2_ctrl *tune_ant_cap;
         };
         struct completion work;
-        unsigned supplies;
-        struct regulator_bulk_data supply_data[SI4713_NUM_SUPPLIES];
-        int gpio_reset;
+        struct regulator *vdd;
+        struct regulator *vio;
+        struct gpio_desc *gpio_reset;
+        struct platform_device *pd;
         u32 power_state;
         u32 rds_enabled;
         u32 frequency;
@@ -246,4 +247,8 @@ struct si4713_device {
         u32 stereo;
         u32 tune_rnl;
 };
+
+struct radio_si4713_platform_data {
+        struct i2c_client *subdev;
+};
 #endif /* ifndef SI4713_I2C_H */
diff --git a/drivers/media/radio/wl128x/fmdrv_v4l2.c b/drivers/media/radio/wl128x/fmdrv_v4l2.c
index b55012c11842..a5bd3f674bbd 100644
--- a/drivers/media/radio/wl128x/fmdrv_v4l2.c
+++ b/drivers/media/radio/wl128x/fmdrv_v4l2.c
@@ -198,10 +198,12 @@ static int fm_v4l2_vidioc_querycap(struct file *file, void *priv,
         strlcpy(capability->card, FM_DRV_CARD_SHORT_NAME,
                         sizeof(capability->card));
         sprintf(capability->bus_info, "UART");
-        capability->capabilities = V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
+        capability->device_caps = V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
                 V4L2_CAP_RADIO | V4L2_CAP_MODULATOR |
                 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE |
                 V4L2_CAP_RDS_CAPTURE;
+        capability->capabilities = capability->device_caps |
+                V4L2_CAP_DEVICE_CAPS;
 
         return 0;
 }
diff --git a/drivers/media/rc/Kconfig b/drivers/media/rc/Kconfig
index 8ce08107a69d..ddfab256b9a5 100644
--- a/drivers/media/rc/Kconfig
+++ b/drivers/media/rc/Kconfig
@@ -223,6 +223,17 @@ config IR_FINTEK
            To compile this driver as a module, choose M here: the
            module will be called fintek-cir.
 
+config IR_MESON
+        tristate "Amlogic Meson IR remote receiver"
+        depends on RC_CORE
+        depends on ARCH_MESON || COMPILE_TEST
+        ---help---
+           Say Y if you want to use the IR remote receiver available
+           on Amlogic Meson SoCs.
+
+           To compile this driver as a module, choose M here: the
+           module will be called meson-ir.
+
 config IR_NUVOTON
         tristate "Nuvoton w836x7hg Consumer Infrared Transceiver"
         depends on PNP
@@ -277,6 +288,21 @@ config IR_WINBOND_CIR
            To compile this driver as a module, choose M here: the module will
            be called winbond_cir.
 
+config IR_IGORPLUGUSB
+        tristate "IgorPlug-USB IR Receiver"
+        depends on USB_ARCH_HAS_HCD
+        depends on RC_CORE
+        select USB
+        ---help---
+           Say Y here if you want to use the IgorPlug-USB IR Receiver by
+           Igor Cesko. This device is included on the Fit-PC2.
+
+           Note that this device can only record bursts of 36 IR pulses and
+           spaces, which is not enough for the NEC, Sanyo and RC-6 protocol.
+
+           To compile this driver as a module, choose M here: the module will
+           be called igorplugusb.
+
 config IR_IGUANA
         tristate "IguanaWorks USB IR Transceiver"
         depends on USB_ARCH_HAS_HCD
diff --git a/drivers/media/rc/Makefile b/drivers/media/rc/Makefile
index 0989f940e9cf..379a5c0f1379 100644
--- a/drivers/media/rc/Makefile
+++ b/drivers/media/rc/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_IR_IMON) += imon.o
 obj-$(CONFIG_IR_ITE_CIR) += ite-cir.o
 obj-$(CONFIG_IR_MCEUSB) += mceusb.o
 obj-$(CONFIG_IR_FINTEK) += fintek-cir.o
+obj-$(CONFIG_IR_MESON) += meson-ir.o
 obj-$(CONFIG_IR_NUVOTON) += nuvoton-cir.o
 obj-$(CONFIG_IR_ENE) += ene_ir.o
 obj-$(CONFIG_IR_REDRAT3) += redrat3.o
@@ -30,6 +31,7 @@ obj-$(CONFIG_IR_STREAMZAP) += streamzap.o
 obj-$(CONFIG_IR_WINBOND_CIR) += winbond-cir.o
 obj-$(CONFIG_RC_LOOPBACK) += rc-loopback.o
 obj-$(CONFIG_IR_GPIO_CIR) += gpio-ir-recv.o
+obj-$(CONFIG_IR_IGORPLUGUSB) += igorplugusb.o
 obj-$(CONFIG_IR_IGUANA) += iguanair.o
 obj-$(CONFIG_IR_TTUSBIR) += ttusbir.o
 obj-$(CONFIG_RC_ST) += st_rc.o
diff --git a/drivers/media/rc/igorplugusb.c b/drivers/media/rc/igorplugusb.c
new file mode 100644
index 000000000000..b36e51576f8e
--- /dev/null
+++ b/drivers/media/rc/igorplugusb.c
@@ -0,0 +1,261 @@
+/*
+ * IgorPlug-USB IR Receiver
+ *
+ * Copyright (C) 2014 Sean Young <sean@mess.org>
+ *
+ * Supports the standard homebrew IgorPlugUSB receiver with Igor's firmware.
+ * See http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20(AVR)_eng.htm
+ *
+ * Based on the lirc_igorplugusb.c driver:
+ *      Copyright (C) 2004 Jan M. Hochstein
+ *      <hochstein@algo.informatik.tu-darmstadt.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/input.h>
+#include <media/rc-core.h>
+
+#define DRIVER_DESC             "IgorPlug-USB IR Receiver"
+#define DRIVER_NAME             "igorplugusb"
+
+#define HEADERLEN               3
+#define BUFLEN                  36
+#define MAX_PACKET              (HEADERLEN + BUFLEN)
+
+#define SET_INFRABUFFER_EMPTY   1
+#define GET_INFRACODE           2
+
+
+struct igorplugusb {
+        struct rc_dev *rc;
+        struct device *dev;
+
+        struct urb *urb;
+        struct usb_ctrlrequest request;
+
+        struct timer_list timer;
+
+        uint8_t buf_in[MAX_PACKET];
+
+        char phys[64];
+};
+
+static void igorplugusb_cmd(struct igorplugusb *ir, int cmd);
+
+static void igorplugusb_irdata(struct igorplugusb *ir, unsigned len)
+{
+        DEFINE_IR_RAW_EVENT(rawir);
+        unsigned i, start, overflow;
+
+        dev_dbg(ir->dev, "irdata: %*ph (len=%u)", len, ir->buf_in, len);
+
+        /*
+         * If more than 36 pulses and spaces follow each other, the igorplugusb
+         * overwrites its buffer from the beginning. The overflow value is the
+         * last offset which was not overwritten. Everything from this offset
+         * onwards occurred before everything until this offset.
+         */
+        overflow = ir->buf_in[2];
+        i = start = overflow + HEADERLEN;
+
+        if (start >= len) {
+                dev_err(ir->dev, "receive overflow invalid: %u", overflow);
+        } else {
+                if (overflow > 0)
+                        dev_warn(ir->dev, "receive overflow, at least %u lost",
+                                                                overflow);
+
+                do {
+                        rawir.duration = ir->buf_in[i] * 85333;
+                        rawir.pulse = i & 1;
+
+                        ir_raw_event_store_with_filter(ir->rc, &rawir);
+
+                        if (++i == len)
+                                i = HEADERLEN;
+                } while (i != start);
+
+                /* add a trailing space */
+                rawir.duration = ir->rc->timeout;
+                rawir.pulse = false;
+                ir_raw_event_store_with_filter(ir->rc, &rawir);
+
+                ir_raw_event_handle(ir->rc);
+        }
+
+        igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);
+}
+
+static void igorplugusb_callback(struct urb *urb)
+{
+        struct usb_ctrlrequest *req;
+        struct igorplugusb *ir = urb->context;
+
+        req = (struct usb_ctrlrequest *)urb->setup_packet;
+
+        switch (urb->status) {
+        case 0:
+                if (req->bRequest == GET_INFRACODE &&
+                                        urb->actual_length > HEADERLEN)
+                        igorplugusb_irdata(ir, urb->actual_length);
+                else /* request IR */
+                        mod_timer(&ir->timer, jiffies + msecs_to_jiffies(50));
+                break;
+        case -EPROTO:
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                usb_unlink_urb(urb);
+                return;
+        default:
+                dev_warn(ir->dev, "Error: urb status = %d\n", urb->status);
+                igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);
+                break;
+        }
+}
+
+static void igorplugusb_cmd(struct igorplugusb *ir, int cmd)
+{
+        int ret;
+
+        ir->request.bRequest = cmd;
+        ir->urb->transfer_flags = 0;
+        ret = usb_submit_urb(ir->urb, GFP_ATOMIC);
+        if (ret)
+                dev_err(ir->dev, "submit urb failed: %d", ret);
+}
+
+static void igorplugusb_timer(unsigned long data)
+{
+        struct igorplugusb *ir = (struct igorplugusb *)data;
+
+        igorplugusb_cmd(ir, GET_INFRACODE);
+}
+
+static int igorplugusb_probe(struct usb_interface *intf,
+                                        const struct usb_device_id *id)
+{
+        struct usb_device *udev;
+        struct usb_host_interface *idesc;
+        struct usb_endpoint_descriptor *ep;
+        struct igorplugusb *ir;
+        struct rc_dev *rc;
+        int ret;
+
+        udev = interface_to_usbdev(intf);
+        idesc = intf->cur_altsetting;
+
+        if (idesc->desc.bNumEndpoints != 1) {
+                dev_err(&intf->dev, "incorrect number of endpoints");
+                return -ENODEV;
+        }
+
+        ep = &idesc->endpoint[0].desc;
+        if (!usb_endpoint_dir_in(ep) || !usb_endpoint_xfer_control(ep)) {
+                dev_err(&intf->dev, "endpoint incorrect");
+                return -ENODEV;
+        }
+
+        ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);
+        if (!ir)
+                return -ENOMEM;
+
+        ir->dev = &intf->dev;
+
+        setup_timer(&ir->timer, igorplugusb_timer, (unsigned long)ir);
+
+        ir->request.bRequest = GET_INFRACODE;
+        ir->request.bRequestType = USB_TYPE_VENDOR | USB_DIR_IN;
+        ir->request.wLength = cpu_to_le16(sizeof(ir->buf_in));
+
+        ir->urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!ir->urb)
+                return -ENOMEM;
+
+        usb_fill_control_urb(ir->urb, udev,
+                usb_rcvctrlpipe(udev, 0), (uint8_t *)&ir->request,
+                ir->buf_in, sizeof(ir->buf_in), igorplugusb_callback, ir);
+
+        usb_make_path(udev, ir->phys, sizeof(ir->phys));
+
+        rc = rc_allocate_device();
+        rc->input_name = DRIVER_DESC;
+        rc->input_phys = ir->phys;
+        usb_to_input_id(udev, &rc->input_id);
+        rc->dev.parent = &intf->dev;
+        rc->driver_type = RC_DRIVER_IR_RAW;
+        /*
+         * This device can only store 36 pulses + spaces, which is not enough
+         * for the NEC protocol and many others.
+         */
+        rc->allowed_protocols = RC_BIT_ALL & ~(RC_BIT_NEC | RC_BIT_RC6_6A_20 |
+                        RC_BIT_RC6_6A_24 | RC_BIT_RC6_6A_32 | RC_BIT_RC6_MCE |
+                        RC_BIT_SONY20 | RC_BIT_MCE_KBD | RC_BIT_SANYO);
+
+        rc->priv = ir;
+        rc->driver_name = DRIVER_NAME;
+        rc->map_name = RC_MAP_HAUPPAUGE;
+        rc->timeout = MS_TO_NS(100);
+        rc->rx_resolution = 85333;
+
+        ir->rc = rc;
+        ret = rc_register_device(rc);
+        if (ret) {
+                dev_err(&intf->dev, "failed to register rc device: %d", ret);
+                rc_free_device(rc);
+                usb_free_urb(ir->urb);
+                return ret;
+        }
+
+        usb_set_intfdata(intf, ir);
+
+        igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);
+
+        return 0;
+}
+
+static void igorplugusb_disconnect(struct usb_interface *intf)
+{
+        struct igorplugusb *ir = usb_get_intfdata(intf);
+
+        rc_unregister_device(ir->rc);
+        del_timer_sync(&ir->timer);
+        usb_set_intfdata(intf, NULL);
+        usb_kill_urb(ir->urb);
+        usb_free_urb(ir->urb);
+}
+
+static struct usb_device_id igorplugusb_table[] = {
+        /* Igor Plug USB (Atmel's Manufact. ID) */
+        { USB_DEVICE(0x03eb, 0x0002) },
+        /* Fit PC2 Infrared Adapter */
+        { USB_DEVICE(0x03eb, 0x21fe) },
+        /* Terminating entry */
+        { }
+};
+
+static struct usb_driver igorplugusb_driver = {
+        .name = DRIVER_NAME,
+        .probe = igorplugusb_probe,
+        .disconnect = igorplugusb_disconnect,
+        .id_table = igorplugusb_table
+};
+
+module_usb_driver(igorplugusb_driver);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Sean Young <sean@mess.org>");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(usb, igorplugusb_table);
diff --git a/drivers/media/rc/img-ir/Kconfig b/drivers/media/rc/img-ir/Kconfig
index 03ba9fc170fb..580715c7fc5e 100644
--- a/drivers/media/rc/img-ir/Kconfig
+++ b/drivers/media/rc/img-ir/Kconfig
@@ -1,6 +1,7 @@
 config IR_IMG
         tristate "ImgTec IR Decoder"
         depends on RC_CORE
+        depends on METAG || MIPS || COMPILE_TEST
         select IR_IMG_HW if !IR_IMG_RAW
         help
            Say Y or M here if you want to use the ImgTec infrared decoder
diff --git a/drivers/media/rc/img-ir/img-ir-core.c b/drivers/media/rc/img-ir/img-ir-core.c
index a0cac2f09109..77c78de4f5bf 100644
--- a/drivers/media/rc/img-ir/img-ir-core.c
+++ b/drivers/media/rc/img-ir/img-ir-core.c
@@ -166,7 +166,6 @@ MODULE_DEVICE_TABLE(of, img_ir_match);
 static struct platform_driver img_ir_driver = {
         .driver = {
                 .name = "img-ir",
-                .owner  = THIS_MODULE,
                 .of_match_table = img_ir_match,
                 .pm = &img_ir_pmops,
         },
diff --git a/drivers/media/rc/img-ir/img-ir-hw.c b/drivers/media/rc/img-ir/img-ir-hw.c
index ec49f94425fc..2fd47c9bf5d8 100644
--- a/drivers/media/rc/img-ir/img-ir-hw.c
+++ b/drivers/media/rc/img-ir/img-ir-hw.c
@@ -530,6 +530,22 @@ static void img_ir_set_decoder(struct img_ir_priv *priv,
         u32 ir_status, irq_en;
         spin_lock_irq(&priv->lock);
 
+        /*
+         * First record that the protocol is being stopped so that the end timer
+         * isn't restarted while we're trying to stop it.
+         */
+        hw->stopping = true;
+
+        /*
+         * Release the lock to stop the end timer, since the end timer handler
+         * acquires the lock and we don't want to deadlock waiting for it.
+         */
+        spin_unlock_irq(&priv->lock);
+        del_timer_sync(&hw->end_timer);
+        spin_lock_irq(&priv->lock);
+
+        hw->stopping = false;
+
         /* switch off and disable interrupts */
         img_ir_write(priv, IMG_IR_CONTROL, 0);
         irq_en = img_ir_read(priv, IMG_IR_IRQ_ENABLE);
@@ -541,12 +557,13 @@ static void img_ir_set_decoder(struct img_ir_priv *priv,
         if (ir_status & (IMG_IR_RXDVAL | IMG_IR_RXDVALD2)) {
                 ir_status &= ~(IMG_IR_RXDVAL | IMG_IR_RXDVALD2);
                 img_ir_write(priv, IMG_IR_STATUS, ir_status);
-                img_ir_read(priv, IMG_IR_DATA_LW);
-                img_ir_read(priv, IMG_IR_DATA_UP);
         }
 
-        /* stop the end timer and switch back to normal mode */
-        del_timer_sync(&hw->end_timer);
+        /* always read data to clear buffer if IR wakes the device */
+        img_ir_read(priv, IMG_IR_DATA_LW);
+        img_ir_read(priv, IMG_IR_DATA_UP);
+
+        /* switch back to normal mode */
         hw->mode = IMG_IR_M_NORMAL;
 
         /* clear the wakeup scancode filter */
@@ -817,7 +834,8 @@ static void img_ir_handle_data(struct img_ir_priv *priv, u32 len, u64 raw)
         }
 
 
-        if (dec->repeat) {
+        /* we mustn't update the end timer while trying to stop it */
+        if (dec->repeat && !hw->stopping) {
                 unsigned long interval;
 
                 img_ir_begin_repeat(priv);
diff --git a/drivers/media/rc/img-ir/img-ir-hw.h b/drivers/media/rc/img-ir/img-ir-hw.h
index 8fcc16c32c5b..5c2b216c5fe3 100644
--- a/drivers/media/rc/img-ir/img-ir-hw.h
+++ b/drivers/media/rc/img-ir/img-ir-hw.h
@@ -186,9 +186,6 @@ struct img_ir_reg_timings {
         struct img_ir_timing_regvals    rtimings;
 };
 
-int img_ir_register_decoder(struct img_ir_decoder *dec);
-void img_ir_unregister_decoder(struct img_ir_decoder *dec);
-
 struct img_ir_priv;
 
 #ifdef CONFIG_IR_IMG_HW
@@ -214,6 +211,8 @@ enum img_ir_mode {
  * @flags:              IMG_IR_F_*.
  * @filters:            HW filters (derived from scancode filters).
  * @mode:               Current decode mode.
+ * @stopping:           Indicates that decoder is being taken down and timers
+ *                      should not be restarted.
  * @suspend_irqen:      Saved IRQ enable mask over suspend.
  */
 struct img_ir_priv_hw {
@@ -229,6 +228,7 @@ struct img_ir_priv_hw {
         struct img_ir_filter            filters[RC_FILTER_MAX];
 
         enum img_ir_mode                mode;
+        bool                            stopping;
         u32                             suspend_irqen;
 };
 
diff --git a/drivers/media/rc/ir-lirc-codec.c b/drivers/media/rc/ir-lirc-codec.c
index ed2c8a1ed8ca..98893a8332c7 100644
--- a/drivers/media/rc/ir-lirc-codec.c
+++ b/drivers/media/rc/ir-lirc-codec.c
@@ -42,11 +42,17 @@ static int ir_lirc_decode(struct rc_dev *dev, struct ir_raw_event ev)
                 return -EINVAL;
 
         /* Packet start */
-        if (ev.reset)
-                return 0;
+        if (ev.reset) {
+                /* Userspace expects a long space event before the start of
+                 * the signal to use as a sync.  This may be done with repeat
+                 * packets and normal samples.  But if a reset has been sent
+                 * then we assume that a long time has passed, so we send a
+                 * space with the maximum time value. */
+                sample = LIRC_SPACE(LIRC_VALUE_MASK);
+                IR_dprintk(2, "delivering reset sync space to lirc_dev\n");
 
         /* Carrier reports */
-        if (ev.carrier_report) {
+        } else if (ev.carrier_report) {
                 sample = LIRC_FREQUENCY(ev.carrier);
                 IR_dprintk(2, "carrier report (freq: %d)\n", sample);
 
diff --git a/drivers/media/rc/ir-rc6-decoder.c b/drivers/media/rc/ir-rc6-decoder.c
index f1f098e22f7e..d16bc67af732 100644
--- a/drivers/media/rc/ir-rc6-decoder.c
+++ b/drivers/media/rc/ir-rc6-decoder.c
@@ -259,8 +259,8 @@ again:
                         case 32:
                                 if ((scancode & RC6_6A_LCC_MASK) == RC6_6A_MCE_CC) {
                                         protocol = RC_TYPE_RC6_MCE;
-                                        scancode &= ~RC6_6A_MCE_TOGGLE_MASK;
                                         toggle = !!(scancode & RC6_6A_MCE_TOGGLE_MASK);
+                                        scancode &= ~RC6_6A_MCE_TOGGLE_MASK;
                                 } else {
                                         protocol = RC_BIT_RC6_6A_32;
                                         toggle = 0;
diff --git a/drivers/media/rc/lirc_dev.c b/drivers/media/rc/lirc_dev.c
index 249d2fbc8f37..1e0545a67959 100644
--- a/drivers/media/rc/lirc_dev.c
+++ b/drivers/media/rc/lirc_dev.c
@@ -518,8 +518,7 @@ int lirc_dev_fop_close(struct inode *inode, struct file *file)
 
         WARN_ON(mutex_lock_killable(&lirc_dev_lock));
 
-        if (ir->d.rdev)
-                rc_close(ir->d.rdev);
+        rc_close(ir->d.rdev);
 
         ir->open--;
         if (ir->attached) {
diff --git a/drivers/media/rc/meson-ir.c b/drivers/media/rc/meson-ir.c
new file mode 100644
index 000000000000..fcc3b82d1454
--- /dev/null
+++ b/drivers/media/rc/meson-ir.c
@@ -0,0 +1,216 @@
+/*
+ * Driver for Amlogic Meson IR remote receiver
+ *
+ * Copyright (C) 2014 Beniamino Galvani <b.galvani@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+
+#include <media/rc-core.h>
+
+#define DRIVER_NAME             "meson-ir"
+
+#define IR_DEC_LDR_ACTIVE       0x00
+#define IR_DEC_LDR_IDLE         0x04
+#define IR_DEC_LDR_REPEAT       0x08
+#define IR_DEC_BIT_0            0x0c
+#define IR_DEC_REG0             0x10
+#define IR_DEC_FRAME            0x14
+#define IR_DEC_STATUS           0x18
+#define IR_DEC_REG1             0x1c
+
+#define REG0_RATE_MASK          (BIT(11) - 1)
+
+#define REG1_MODE_MASK          (BIT(7) | BIT(8))
+#define REG1_MODE_NEC           (0 << 7)
+#define REG1_MODE_GENERAL       (2 << 7)
+
+#define REG1_TIME_IV_SHIFT      16
+#define REG1_TIME_IV_MASK       ((BIT(13) - 1) << REG1_TIME_IV_SHIFT)
+
+#define REG1_IRQSEL_MASK        (BIT(2) | BIT(3))
+#define REG1_IRQSEL_NEC_MODE    (0 << 2)
+#define REG1_IRQSEL_RISE_FALL   (1 << 2)
+#define REG1_IRQSEL_FALL        (2 << 2)
+#define REG1_IRQSEL_RISE        (3 << 2)
+
+#define REG1_RESET              BIT(0)
+#define REG1_ENABLE             BIT(15)
+
+#define STATUS_IR_DEC_IN        BIT(8)
+
+#define MESON_TRATE             10      /* us */
+
+struct meson_ir {
+        void __iomem    *reg;
+        struct rc_dev   *rc;
+        int             irq;
+        spinlock_t      lock;
+};
+
+static void meson_ir_set_mask(struct meson_ir *ir, unsigned int reg,
+                              u32 mask, u32 value)
+{
+        u32 data;
+
+        data = readl(ir->reg + reg);
+        data &= ~mask;
+        data |= (value & mask);
+        writel(data, ir->reg + reg);
+}
+
+static irqreturn_t meson_ir_irq(int irqno, void *dev_id)
+{
+        struct meson_ir *ir = dev_id;
+        u32 duration;
+        DEFINE_IR_RAW_EVENT(rawir);
+
+        spin_lock(&ir->lock);
+
+        duration = readl(ir->reg + IR_DEC_REG1);
+        duration = (duration & REG1_TIME_IV_MASK) >> REG1_TIME_IV_SHIFT;
+        rawir.duration = US_TO_NS(duration * MESON_TRATE);
+
+        rawir.pulse = !!(readl(ir->reg + IR_DEC_STATUS) & STATUS_IR_DEC_IN);
+
+        ir_raw_event_store_with_filter(ir->rc, &rawir);
+        ir_raw_event_handle(ir->rc);
+
+        spin_unlock(&ir->lock);
+
+        return IRQ_HANDLED;
+}
+
+static int meson_ir_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct device_node *node = dev->of_node;
+        struct resource *res;
+        const char *map_name;
+        struct meson_ir *ir;
+        int ret;
+
+        ir = devm_kzalloc(dev, sizeof(struct meson_ir), GFP_KERNEL);
+        if (!ir)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        ir->reg = devm_ioremap_resource(dev, res);
+        if (IS_ERR(ir->reg)) {
+                dev_err(dev, "failed to map registers\n");
+                return PTR_ERR(ir->reg);
+        }
+
+        ir->irq = platform_get_irq(pdev, 0);
+        if (ir->irq < 0) {
+                dev_err(dev, "no irq resource\n");
+                return ir->irq;
+        }
+
+        ir->rc = rc_allocate_device();
+        if (!ir->rc) {
+                dev_err(dev, "failed to allocate rc device\n");
+                return -ENOMEM;
+        }
+
+        ir->rc->priv = ir;
+        ir->rc->input_name = DRIVER_NAME;
+        ir->rc->input_phys = DRIVER_NAME "/input0";
+        ir->rc->input_id.bustype = BUS_HOST;
+        map_name = of_get_property(node, "linux,rc-map-name", NULL);
+        ir->rc->map_name = map_name ? map_name : RC_MAP_EMPTY;
+        ir->rc->dev.parent = dev;
+        ir->rc->driver_type = RC_DRIVER_IR_RAW;
+        ir->rc->allowed_protocols = RC_BIT_ALL;
+        ir->rc->rx_resolution = US_TO_NS(MESON_TRATE);
+        ir->rc->timeout = MS_TO_NS(200);
+        ir->rc->driver_name = DRIVER_NAME;
+
+        spin_lock_init(&ir->lock);
+        platform_set_drvdata(pdev, ir);
+
+        ret = rc_register_device(ir->rc);
+        if (ret) {
+                dev_err(dev, "failed to register rc device\n");
+                goto out_free;
+        }
+
+        ret = devm_request_irq(dev, ir->irq, meson_ir_irq, 0, "ir-meson", ir);
+        if (ret) {
+                dev_err(dev, "failed to request irq\n");
+                goto out_unreg;
+        }
+
+        /* Reset the decoder */
+        meson_ir_set_mask(ir, IR_DEC_REG1, REG1_RESET, REG1_RESET);
+        meson_ir_set_mask(ir, IR_DEC_REG1, REG1_RESET, 0);
+        /* Set general operation mode */
+        meson_ir_set_mask(ir, IR_DEC_REG1, REG1_MODE_MASK, REG1_MODE_GENERAL);
+        /* Set rate */
+        meson_ir_set_mask(ir, IR_DEC_REG0, REG0_RATE_MASK, MESON_TRATE - 1);
+        /* IRQ on rising and falling edges */
+        meson_ir_set_mask(ir, IR_DEC_REG1, REG1_IRQSEL_MASK,
+                          REG1_IRQSEL_RISE_FALL);
+        /* Enable the decoder */
+        meson_ir_set_mask(ir, IR_DEC_REG1, REG1_ENABLE, REG1_ENABLE);
+
+        dev_info(dev, "receiver initialized\n");
+
+        return 0;
+out_unreg:
+        rc_unregister_device(ir->rc);
+        ir->rc = NULL;
+out_free:
+        rc_free_device(ir->rc);
+
+        return ret;
+}
+
+static int meson_ir_remove(struct platform_device *pdev)
+{
+        struct meson_ir *ir = platform_get_drvdata(pdev);
+        unsigned long flags;
+
+        /* Disable the decoder */
+        spin_lock_irqsave(&ir->lock, flags);
+        meson_ir_set_mask(ir, IR_DEC_REG1, REG1_ENABLE, 0);
+        spin_unlock_irqrestore(&ir->lock, flags);
+
+        rc_unregister_device(ir->rc);
+
+        return 0;
+}
+
+static const struct of_device_id meson_ir_match[] = {
+        { .compatible = "amlogic,meson6-ir" },
+        { },
+};
+
+static struct platform_driver meson_ir_driver = {
+        .probe          = meson_ir_probe,
+        .remove         = meson_ir_remove,
+        .driver = {
+                .name           = DRIVER_NAME,
+                .of_match_table = meson_ir_match,
+        },
+};
+
+module_platform_driver(meson_ir_driver);
+
+MODULE_DESCRIPTION("Amlogic Meson IR remote receiver driver");
+MODULE_AUTHOR("Beniamino Galvani <b.galvani@gmail.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/rc/rc-main.c b/drivers/media/rc/rc-main.c
index 8d3b74c5a717..86ffcd54339e 100644
--- a/drivers/media/rc/rc-main.c
+++ b/drivers/media/rc/rc-main.c
@@ -1298,8 +1298,7 @@ void rc_free_device(struct rc_dev *dev)
         if (!dev)
                 return;
 
-        if (dev->input_dev)
-                input_free_device(dev->input_dev);
+        input_free_device(dev->input_dev);
 
         put_device(&dev->dev);
 
@@ -1414,13 +1413,16 @@ int rc_register_device(struct rc_dev *dev)
                         ir_raw_init();
                         raw_init = true;
                 }
+                /* calls ir_register_device so unlock mutex here*/
+                mutex_unlock(&dev->lock);
                 rc = ir_raw_event_register(dev);
+                mutex_lock(&dev->lock);
                 if (rc < 0)
                         goto out_input;
         }
 
         if (dev->change_protocol) {
-                u64 rc_type = (1 << rc_map->rc_type);
+                u64 rc_type = (1ll << rc_map->rc_type);
                 if (dev->driver_type == RC_DRIVER_IR_RAW)
                         rc_type |= RC_BIT_LIRC;
                 rc = dev->change_protocol(dev, &rc_type);
diff --git a/drivers/media/rc/redrat3.c b/drivers/media/rc/redrat3.c
index 795b394a5d84..c4def66f9aa2 100644
--- a/drivers/media/rc/redrat3.c
+++ b/drivers/media/rc/redrat3.c
@@ -966,7 +966,7 @@ static int redrat3_dev_probe(struct usb_interface *intf,
 
         rr3->ep_in = ep_in;
         rr3->bulk_in_buf = usb_alloc_coherent(udev,
-                le16_to_cpu(ep_in->wMaxPacketSize), GFP_ATOMIC, &rr3->dma_in);
+                le16_to_cpu(ep_in->wMaxPacketSize), GFP_KERNEL, &rr3->dma_in);
         if (!rr3->bulk_in_buf) {
                 dev_err(dev, "Read buffer allocation failure\n");
                 goto error;
@@ -975,6 +975,8 @@ static int redrat3_dev_probe(struct usb_interface *intf,
         pipe = usb_rcvbulkpipe(udev, ep_in->bEndpointAddress);
         usb_fill_bulk_urb(rr3->read_urb, udev, pipe, rr3->bulk_in_buf,
                 le16_to_cpu(ep_in->wMaxPacketSize), redrat3_handle_async, rr3);
+        rr3->read_urb->transfer_dma = rr3->dma_in;
+        rr3->read_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
         rr3->ep_out = ep_out;
         rr3->udev = udev;
diff --git a/drivers/media/tuners/Kconfig b/drivers/media/tuners/Kconfig
index f039dc2a21cf..42e5a01b9192 100644
--- a/drivers/media/tuners/Kconfig
+++ b/drivers/media/tuners/Kconfig
@@ -232,6 +232,14 @@ config MEDIA_TUNER_M88TS2022
         help
           Montage M88TS2022 silicon tuner driver.
 
+config MEDIA_TUNER_M88RS6000T
+        tristate "Montage M88RS6000 internal tuner"
+        depends on MEDIA_SUPPORT && I2C
+        select REGMAP_I2C
+        default m if !MEDIA_SUBDRV_AUTOSELECT
+        help
+          Montage M88RS6000 internal tuner.
+
 config MEDIA_TUNER_TUA9001
         tristate "Infineon TUA 9001 silicon tuner"
         depends on MEDIA_SUPPORT && I2C
diff --git a/drivers/media/tuners/Makefile b/drivers/media/tuners/Makefile
index 49fcf8033848..da4fe6ef73e7 100644
--- a/drivers/media/tuners/Makefile
+++ b/drivers/media/tuners/Makefile
@@ -41,6 +41,7 @@ obj-$(CONFIG_MEDIA_TUNER_IT913X) += it913x.o
 obj-$(CONFIG_MEDIA_TUNER_R820T) += r820t.o
 obj-$(CONFIG_MEDIA_TUNER_MXL301RF) += mxl301rf.o
 obj-$(CONFIG_MEDIA_TUNER_QM1D1C0042) += qm1d1c0042.o
+obj-$(CONFIG_MEDIA_TUNER_M88RS6000T) += m88rs6000t.o
 
 ccflags-y += -I$(srctree)/drivers/media/dvb-core
 ccflags-y += -I$(srctree)/drivers/media/dvb-frontends
diff --git a/drivers/media/tuners/m88rs6000t.c b/drivers/media/tuners/m88rs6000t.c
new file mode 100644
index 000000000000..d4c13fe6e7b3
--- /dev/null
+++ b/drivers/media/tuners/m88rs6000t.c
@@ -0,0 +1,744 @@
+/*
+ * Driver for the internal tuner of Montage M88RS6000
+ *
+ * Copyright (C) 2014 Max nibble <nibble.max@gmail.com>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#include "m88rs6000t.h"
+#include <linux/regmap.h>
+
+struct m88rs6000t_dev {
+        struct m88rs6000t_config cfg;
+        struct i2c_client *client;
+        struct regmap *regmap;
+        u32 frequency_khz;
+};
+
+struct m88rs6000t_reg_val {
+        u8 reg;
+        u8 val;
+};
+
+/* set demod main mclk and ts mclk */
+static int m88rs6000t_set_demod_mclk(struct dvb_frontend *fe)
+{
+        struct m88rs6000t_dev *dev = fe->tuner_priv;
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        u8 reg11, reg15, reg16, reg1D, reg1E, reg1F;
+        u8 N, f0 = 0, f1 = 0, f2 = 0, f3 = 0;
+        u16 pll_div_fb;
+        u32 div, ts_mclk;
+        unsigned int utmp;
+        int ret;
+
+        /* select demod main mclk */
+        ret = regmap_read(dev->regmap, 0x15, &utmp);
+        if (ret)
+                goto err;
+        reg15 = utmp;
+        if (c->symbol_rate > 45010000) {
+                reg11 = 0x0E;
+                reg15 |= 0x02;
+                reg16 = 115; /* mclk = 110.25MHz */
+        } else {
+                reg11 = 0x0A;
+                reg15 &= ~0x02;
+                reg16 = 96; /* mclk = 96MHz */
+        }
+
+        /* set ts mclk */
+        if (c->delivery_system == SYS_DVBS)
+                ts_mclk = 96000;
+        else
+                ts_mclk = 144000;
+
+        pll_div_fb = (reg15 & 0x01) << 8;
+        pll_div_fb += reg16;
+        pll_div_fb += 32;
+
+        div = 36000 * pll_div_fb;
+        div /= ts_mclk;
+
+        if (div <= 32) {
+                N = 2;
+                f0 = 0;
+                f1 = div / 2;
+                f2 = div - f1;
+                f3 = 0;
+        } else if (div <= 48) {
+                N = 3;
+                f0 = div / 3;
+                f1 = (div - f0) / 2;
+                f2 = div - f0 - f1;
+                f3 = 0;
+        } else if (div <= 64) {
+                N = 4;
+                f0 = div / 4;
+                f1 = (div - f0) / 3;
+                f2 = (div - f0 - f1) / 2;
+                f3 = div - f0 - f1 - f2;
+        } else {
+                N = 4;
+                f0 = 16;
+                f1 = 16;
+                f2 = 16;
+                f3 = 16;
+        }
+
+        if (f0 == 16)
+                f0 = 0;
+        if (f1 == 16)
+                f1 = 0;
+        if (f2 == 16)
+                f2 = 0;
+        if (f3 == 16)
+                f3 = 0;
+
+        ret = regmap_read(dev->regmap, 0x1D, &utmp);
+        if (ret)
+                goto err;
+        reg1D = utmp;
+        reg1D &= ~0x03;
+        reg1D |= N - 1;
+        reg1E = ((f3 << 4) + f2) & 0xFF;
+        reg1F = ((f1 << 4) + f0) & 0xFF;
+
+        /* program and recalibrate demod PLL */
+        ret = regmap_write(dev->regmap, 0x05, 0x40);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x11, 0x08);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x15, reg15);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x16, reg16);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x1D, reg1D);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x1E, reg1E);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x1F, reg1F);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x17, 0xc1);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x17, 0x81);
+        if (ret)
+                goto err;
+        usleep_range(5000, 50000);
+        ret = regmap_write(dev->regmap, 0x05, 0x00);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x11, reg11);
+        if (ret)
+                goto err;
+        usleep_range(5000, 50000);
+err:
+        if (ret)
+                dev_dbg(&dev->client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int m88rs6000t_set_pll_freq(struct m88rs6000t_dev *dev,
+                        u32 tuner_freq_MHz)
+{
+        u32 fcry_KHz, ulNDiv1, ulNDiv2, ulNDiv;
+        u8 refDiv, ucLoDiv1, ucLomod1, ucLoDiv2, ucLomod2, ucLoDiv, ucLomod;
+        u8 reg27, reg29, reg42, reg42buf;
+        unsigned int utmp;
+        int ret;
+
+        fcry_KHz = 27000; /* in kHz */
+        refDiv = 27;
+
+        ret = regmap_write(dev->regmap, 0x36, (refDiv - 8));
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x31, 0x00);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x2c, 0x02);
+        if (ret)
+                goto err;
+
+        if (tuner_freq_MHz >= 1550) {
+                ucLoDiv1 = 2;
+                ucLomod1 = 0;
+                ucLoDiv2 = 2;
+                ucLomod2 = 0;
+        } else if (tuner_freq_MHz >= 1380) {
+                ucLoDiv1 = 3;
+                ucLomod1 = 16;
+                ucLoDiv2 = 2;
+                ucLomod2 = 0;
+        } else if (tuner_freq_MHz >= 1070) {
+                ucLoDiv1 = 3;
+                ucLomod1 = 16;
+                ucLoDiv2 = 3;
+                ucLomod2 = 16;
+        } else if (tuner_freq_MHz >= 1000) {
+                ucLoDiv1 = 3;
+                ucLomod1 = 16;
+                ucLoDiv2 = 4;
+                ucLomod2 = 64;
+        } else if (tuner_freq_MHz >= 775) {
+                ucLoDiv1 = 4;
+                ucLomod1 = 64;
+                ucLoDiv2 = 4;
+                ucLomod2 = 64;
+        } else if (tuner_freq_MHz >= 700) {
+                ucLoDiv1 = 6;
+                ucLomod1 = 48;
+                ucLoDiv2 = 4;
+                ucLomod2 = 64;
+        } else if (tuner_freq_MHz >= 520) {
+                ucLoDiv1 = 6;
+                ucLomod1 = 48;
+                ucLoDiv2 = 6;
+                ucLomod2 = 48;
+        } else {
+                ucLoDiv1 = 8;
+                ucLomod1 = 96;
+                ucLoDiv2 = 8;
+                ucLomod2 = 96;
+        }
+
+        ulNDiv1 = ((tuner_freq_MHz * ucLoDiv1 * 1000) * refDiv
+                        / fcry_KHz - 1024) / 2;
+        ulNDiv2 = ((tuner_freq_MHz * ucLoDiv2 * 1000) * refDiv
+                        / fcry_KHz - 1024) / 2;
+
+        reg27 = (((ulNDiv1 >> 8) & 0x0F) + ucLomod1) & 0x7F;
+        ret = regmap_write(dev->regmap, 0x27, reg27);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x28, (u8)(ulNDiv1 & 0xFF));
+        if (ret)
+                goto err;
+        reg29 = (((ulNDiv2 >> 8) & 0x0F) + ucLomod2) & 0x7f;
+        ret = regmap_write(dev->regmap, 0x29, reg29);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x2a, (u8)(ulNDiv2 & 0xFF));
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x2F, 0xf5);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x30, 0x05);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x08, 0x1f);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x08, 0x3f);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x09, 0x20);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x09, 0x00);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x3e, 0x11);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x08, 0x2f);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x08, 0x3f);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x09, 0x10);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x09, 0x00);
+        if (ret)
+                goto err;
+        usleep_range(2000, 50000);
+
+        ret = regmap_read(dev->regmap, 0x42, &utmp);
+        if (ret)
+                goto err;
+        reg42 = utmp;
+
+        ret = regmap_write(dev->regmap, 0x3e, 0x10);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x08, 0x2f);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x08, 0x3f);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x09, 0x10);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x09, 0x00);
+        if (ret)
+                goto err;
+        usleep_range(2000, 50000);
+
+        ret = regmap_read(dev->regmap, 0x42, &utmp);
+        if (ret)
+                goto err;
+        reg42buf = utmp;
+        if (reg42buf < reg42) {
+                ret = regmap_write(dev->regmap, 0x3e, 0x11);
+                if (ret)
+                        goto err;
+        }
+        usleep_range(5000, 50000);
+
+        ret = regmap_read(dev->regmap, 0x2d, &utmp);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x2d, utmp);
+        if (ret)
+                goto err;
+        ret = regmap_read(dev->regmap, 0x2e, &utmp);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x2e, utmp);
+        if (ret)
+                goto err;
+
+        ret = regmap_read(dev->regmap, 0x27, &utmp);
+        if (ret)
+                goto err;
+        reg27 = utmp & 0x70;
+        ret = regmap_read(dev->regmap, 0x83, &utmp);
+        if (ret)
+                goto err;
+        if (reg27 == (utmp & 0x70)) {
+                ucLoDiv = ucLoDiv1;
+                ulNDiv = ulNDiv1;
+                ucLomod = ucLomod1 / 16;
+        } else {
+                ucLoDiv = ucLoDiv2;
+                ulNDiv = ulNDiv2;
+                ucLomod = ucLomod2 / 16;
+        }
+
+        if ((ucLoDiv == 3) || (ucLoDiv == 6)) {
+                refDiv = 18;
+                ret = regmap_write(dev->regmap, 0x36, (refDiv - 8));
+                if (ret)
+                        goto err;
+                ulNDiv = ((tuner_freq_MHz * ucLoDiv * 1000) * refDiv
+                                / fcry_KHz - 1024) / 2;
+        }
+
+        reg27 = (0x80 + ((ucLomod << 4) & 0x70)
+                        + ((ulNDiv >> 8) & 0x0F)) & 0xFF;
+        ret = regmap_write(dev->regmap, 0x27, reg27);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x28, (u8)(ulNDiv & 0xFF));
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x29, 0x80);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x31, 0x03);
+        if (ret)
+                goto err;
+
+        if (ucLoDiv == 3)
+                utmp = 0xCE;
+        else
+                utmp = 0x8A;
+        ret = regmap_write(dev->regmap, 0x3b, utmp);
+        if (ret)
+                goto err;
+
+        dev->frequency_khz = fcry_KHz * (ulNDiv * 2 + 1024) / refDiv / ucLoDiv;
+
+        dev_dbg(&dev->client->dev,
+                "actual tune frequency=%d\n", dev->frequency_khz);
+err:
+        if (ret)
+                dev_dbg(&dev->client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int m88rs6000t_set_bb(struct m88rs6000t_dev *dev,
+                u32 symbol_rate_KSs, s32 lpf_offset_KHz)
+{
+        u32 f3dB;
+        u8  reg40;
+
+        f3dB = symbol_rate_KSs * 9 / 14 + 2000;
+        f3dB += lpf_offset_KHz;
+        f3dB = clamp_val(f3dB, 6000U, 43000U);
+        reg40 = f3dB / 1000;
+        return regmap_write(dev->regmap, 0x40, reg40);
+}
+
+static int m88rs6000t_set_params(struct dvb_frontend *fe)
+{
+        struct m88rs6000t_dev *dev = fe->tuner_priv;
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        int ret;
+        s32 lpf_offset_KHz;
+        u32 realFreq, freq_MHz;
+
+        dev_dbg(&dev->client->dev,
+                        "frequency=%d symbol_rate=%d\n",
+                        c->frequency, c->symbol_rate);
+
+        if (c->symbol_rate < 5000000)
+                lpf_offset_KHz = 3000;
+        else
+                lpf_offset_KHz = 0;
+
+        realFreq = c->frequency + lpf_offset_KHz;
+        /* set tuner pll.*/
+        freq_MHz = (realFreq + 500) / 1000;
+        ret = m88rs6000t_set_pll_freq(dev, freq_MHz);
+        if (ret)
+                goto err;
+        ret = m88rs6000t_set_bb(dev, c->symbol_rate / 1000, lpf_offset_KHz);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x00, 0x01);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x00, 0x00);
+        if (ret)
+                goto err;
+        /* set demod mlck */
+        ret = m88rs6000t_set_demod_mclk(fe);
+err:
+        if (ret)
+                dev_dbg(&dev->client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int m88rs6000t_init(struct dvb_frontend *fe)
+{
+        struct m88rs6000t_dev *dev = fe->tuner_priv;
+        int ret;
+
+        dev_dbg(&dev->client->dev, "%s:\n", __func__);
+
+        ret = regmap_update_bits(dev->regmap, 0x11, 0x08, 0x08);
+        if (ret)
+                goto err;
+        usleep_range(5000, 50000);
+        ret = regmap_update_bits(dev->regmap, 0x10, 0x01, 0x01);
+        if (ret)
+                goto err;
+        usleep_range(10000, 50000);
+        ret = regmap_write(dev->regmap, 0x07, 0x7d);
+err:
+        if (ret)
+                dev_dbg(&dev->client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int m88rs6000t_sleep(struct dvb_frontend *fe)
+{
+        struct m88rs6000t_dev *dev = fe->tuner_priv;
+        int ret;
+
+        dev_dbg(&dev->client->dev, "%s:\n", __func__);
+
+        ret = regmap_write(dev->regmap, 0x07, 0x6d);
+        if (ret)
+                goto err;
+        usleep_range(5000, 10000);
+err:
+        if (ret)
+                dev_dbg(&dev->client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int m88rs6000t_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+        struct m88rs6000t_dev *dev = fe->tuner_priv;
+
+        dev_dbg(&dev->client->dev, "\n");
+
+        *frequency = dev->frequency_khz;
+        return 0;
+}
+
+static int m88rs6000t_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+        struct m88rs6000t_dev *dev = fe->tuner_priv;
+
+        dev_dbg(&dev->client->dev, "\n");
+
+        *frequency = 0; /* Zero-IF */
+        return 0;
+}
+
+
+static int m88rs6000t_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
+{
+        struct m88rs6000t_dev *dev = fe->tuner_priv;
+        unsigned int val, i;
+        int ret;
+        u16 gain;
+        u32 PGA2_cri_GS = 46, PGA2_crf_GS = 290, TIA_GS = 290;
+        u32 RF_GC = 1200, IF_GC = 1100, BB_GC = 300;
+        u32 PGA2_GC = 300, TIA_GC = 300, PGA2_cri = 0, PGA2_crf = 0;
+        u32 RFG = 0, IFG = 0, BBG = 0, PGA2G = 0, TIAG = 0;
+        u32 RFGS[13] = {0, 245, 266, 268, 270, 285,
+                        298, 295, 283, 285, 285, 300, 300};
+        u32 IFGS[12] = {0, 300, 230, 270, 270, 285,
+                        295, 285, 290, 295, 295, 310};
+        u32 BBGS[14] = {0, 286, 275, 290, 294, 300, 290,
+                        290, 285, 283, 260, 295, 290, 260};
+
+        ret = regmap_read(dev->regmap, 0x5A, &val);
+        if (ret)
+                goto err;
+        RF_GC = val & 0x0f;
+
+        ret = regmap_read(dev->regmap, 0x5F, &val);
+        if (ret)
+                goto err;
+        IF_GC = val & 0x0f;
+
+        ret = regmap_read(dev->regmap, 0x3F, &val);
+        if (ret)
+                goto err;
+        TIA_GC = (val >> 4) & 0x07;
+
+        ret = regmap_read(dev->regmap, 0x77, &val);
+        if (ret)
+                goto err;
+        BB_GC = (val >> 4) & 0x0f;
+
+        ret = regmap_read(dev->regmap, 0x76, &val);
+        if (ret)
+                goto err;
+        PGA2_GC = val & 0x3f;
+        PGA2_cri = PGA2_GC >> 2;
+        PGA2_crf = PGA2_GC & 0x03;
+
+        for (i = 0; i <= RF_GC; i++)
+                RFG += RFGS[i];
+
+        if (RF_GC == 0)
+                RFG += 400;
+        if (RF_GC == 1)
+                RFG += 300;
+        if (RF_GC == 2)
+                RFG += 200;
+        if (RF_GC == 3)
+                RFG += 100;
+
+        for (i = 0; i <= IF_GC; i++)
+                IFG += IFGS[i];
+
+        TIAG = TIA_GC * TIA_GS;
+
+        for (i = 0; i <= BB_GC; i++)
+                BBG += BBGS[i];
+
+        PGA2G = PGA2_cri * PGA2_cri_GS + PGA2_crf * PGA2_crf_GS;
+
+        gain = RFG + IFG - TIAG + BBG + PGA2G;
+
+        /* scale value to 0x0000-0xffff */
+        gain = clamp_val(gain, 1000U, 10500U);
+        *strength = (10500 - gain) * 0xffff / (10500 - 1000);
+err:
+        if (ret)
+                dev_dbg(&dev->client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static const struct dvb_tuner_ops m88rs6000t_tuner_ops = {
+        .info = {
+                .name          = "Montage M88RS6000 Internal Tuner",
+                .frequency_min = 950000,
+                .frequency_max = 2150000,
+        },
+
+        .init = m88rs6000t_init,
+        .sleep = m88rs6000t_sleep,
+        .set_params = m88rs6000t_set_params,
+        .get_frequency = m88rs6000t_get_frequency,
+        .get_if_frequency = m88rs6000t_get_if_frequency,
+        .get_rf_strength = m88rs6000t_get_rf_strength,
+};
+
+static int m88rs6000t_probe(struct i2c_client *client,
+                const struct i2c_device_id *id)
+{
+        struct m88rs6000t_config *cfg = client->dev.platform_data;
+        struct dvb_frontend *fe = cfg->fe;
+        struct m88rs6000t_dev *dev;
+        int ret, i;
+        unsigned int utmp;
+        static const struct regmap_config regmap_config = {
+                .reg_bits = 8,
+                .val_bits = 8,
+        };
+        static const struct m88rs6000t_reg_val reg_vals[] = {
+                {0x10, 0xfb},
+                {0x24, 0x38},
+                {0x11, 0x0a},
+                {0x12, 0x00},
+                {0x2b, 0x1c},
+                {0x44, 0x48},
+                {0x54, 0x24},
+                {0x55, 0x06},
+                {0x59, 0x00},
+                {0x5b, 0x4c},
+                {0x60, 0x8b},
+                {0x61, 0xf4},
+                {0x65, 0x07},
+                {0x6d, 0x6f},
+                {0x6e, 0x31},
+                {0x3c, 0xf3},
+                {0x37, 0x0f},
+                {0x48, 0x28},
+                {0x49, 0xd8},
+                {0x70, 0x66},
+                {0x71, 0xCF},
+                {0x72, 0x81},
+                {0x73, 0xA7},
+                {0x74, 0x4F},
+                {0x75, 0xFC},
+        };
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (!dev) {
+                ret = -ENOMEM;
+                dev_err(&client->dev, "kzalloc() failed\n");
+                goto err;
+        }
+
+        memcpy(&dev->cfg, cfg, sizeof(struct m88rs6000t_config));
+        dev->client = client;
+        dev->regmap = devm_regmap_init_i2c(client, &regmap_config);
+        if (IS_ERR(dev->regmap)) {
+                ret = PTR_ERR(dev->regmap);
+                goto err;
+        }
+
+        ret = regmap_update_bits(dev->regmap, 0x11, 0x08, 0x08);
+        if (ret)
+                goto err;
+        usleep_range(5000, 50000);
+        ret = regmap_update_bits(dev->regmap, 0x10, 0x01, 0x01);
+        if (ret)
+                goto err;
+        usleep_range(10000, 50000);
+        ret = regmap_write(dev->regmap, 0x07, 0x7d);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x04, 0x01);
+        if (ret)
+                goto err;
+
+        /* check tuner chip id */
+        ret = regmap_read(dev->regmap, 0x01, &utmp);
+        if (ret)
+                goto err;
+        dev_info(&dev->client->dev, "chip_id=%02x\n", utmp);
+        if (utmp != 0x64) {
+                ret = -ENODEV;
+                goto err;
+        }
+
+        /* tuner init. */
+        ret = regmap_write(dev->regmap, 0x05, 0x40);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x11, 0x08);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x15, 0x6c);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x17, 0xc1);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x17, 0x81);
+        if (ret)
+                goto err;
+        usleep_range(10000, 50000);
+        ret = regmap_write(dev->regmap, 0x05, 0x00);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap, 0x11, 0x0a);
+        if (ret)
+                goto err;
+
+        for (i = 0; i < ARRAY_SIZE(reg_vals); i++) {
+                ret = regmap_write(dev->regmap,
+                                reg_vals[i].reg, reg_vals[i].val);
+                if (ret)
+                        goto err;
+        }
+
+        dev_info(&dev->client->dev, "Montage M88RS6000 internal tuner successfully identified\n");
+
+        fe->tuner_priv = dev;
+        memcpy(&fe->ops.tuner_ops, &m88rs6000t_tuner_ops,
+                        sizeof(struct dvb_tuner_ops));
+        i2c_set_clientdata(client, dev);
+        return 0;
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        kfree(dev);
+        return ret;
+}
+
+static int m88rs6000t_remove(struct i2c_client *client)
+{
+        struct m88rs6000t_dev *dev = i2c_get_clientdata(client);
+        struct dvb_frontend *fe = dev->cfg.fe;
+
+        dev_dbg(&client->dev, "\n");
+
+        memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
+        fe->tuner_priv = NULL;
+        kfree(dev);
+
+        return 0;
+}
+
+static const struct i2c_device_id m88rs6000t_id[] = {
+        {"m88rs6000t", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, m88rs6000t_id);
+
+static struct i2c_driver m88rs6000t_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "m88rs6000t",
+        },
+        .probe          = m88rs6000t_probe,
+        .remove         = m88rs6000t_remove,
+        .id_table       = m88rs6000t_id,
+};
+
+module_i2c_driver(m88rs6000t_driver);
+
+MODULE_AUTHOR("Max nibble <nibble.max@gmail.com>");
+MODULE_DESCRIPTION("Montage M88RS6000 internal tuner driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/tuners/m88rs6000t.h b/drivers/media/tuners/m88rs6000t.h
new file mode 100644
index 000000000000..264c13e2cd39
--- /dev/null
+++ b/drivers/media/tuners/m88rs6000t.h
@@ -0,0 +1,29 @@
+/*
+ * Driver for the internal tuner of Montage M88RS6000
+ *
+ * Copyright (C) 2014 Max nibble <nibble.max@gmail.com>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#ifndef _M88RS6000T_H_
+#define _M88RS6000T_H_
+
+#include "dvb_frontend.h"
+
+struct m88rs6000t_config {
+        /*
+         * pointer to DVB frontend
+         */
+        struct dvb_frontend *fe;
+};
+
+#endif
diff --git a/drivers/media/tuners/m88ts2022.c b/drivers/media/tuners/m88ts2022.c
index caa542346891..066e5431da93 100644
--- a/drivers/media/tuners/m88ts2022.c
+++ b/drivers/media/tuners/m88ts2022.c
@@ -488,6 +488,7 @@ static int m88ts2022_probe(struct i2c_client *client,
         case 0x83:
                 break;
         default:
+                ret = -ENODEV;
                 goto err;
         }
 
@@ -505,6 +506,7 @@ static int m88ts2022_probe(struct i2c_client *client,
                 u8tmp = 0x6c;
                 break;
         default:
+                ret = -EINVAL;
                 goto err;
         }
 
diff --git a/drivers/media/tuners/mxl5007t.c b/drivers/media/tuners/mxl5007t.c
index 69e453ef0a1a..1810ad66888e 100644
--- a/drivers/media/tuners/mxl5007t.c
+++ b/drivers/media/tuners/mxl5007t.c
@@ -374,7 +374,6 @@ static struct reg_pair_t *mxl5007t_calc_init_regs(struct mxl5007t_state *state,
         mxl5007t_set_if_freq_bits(state, cfg->if_freq_hz, cfg->invert_if);
         mxl5007t_set_xtal_freq_bits(state, cfg->xtal_freq_hz);
 
-        set_reg_bits(state->tab_init, 0x04, 0x01, cfg->loop_thru_enable);
         set_reg_bits(state->tab_init, 0x03, 0x08, cfg->clk_out_enable << 3);
         set_reg_bits(state->tab_init, 0x03, 0x07, cfg->clk_out_amp);
 
@@ -531,10 +530,6 @@ static int mxl5007t_tuner_init(struct mxl5007t_state *state,
         struct reg_pair_t *init_regs;
         int ret;
 
-        ret = mxl5007t_soft_reset(state);
-        if (mxl_fail(ret))
-                goto fail;
-
         /* calculate initialization reg array */
         init_regs = mxl5007t_calc_init_regs(state, mode);
 
@@ -900,7 +895,32 @@ struct dvb_frontend *mxl5007t_attach(struct dvb_frontend *fe,
                 /* existing tuner instance */
                 break;
         }
+
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
+
+        ret = mxl5007t_soft_reset(state);
+
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 0);
+
+        if (mxl_fail(ret))
+                goto fail;
+
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
+
+        ret = mxl5007t_write_reg(state, 0x04,
+                state->config->loop_thru_enable);
+
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 0);
+
+        if (mxl_fail(ret))
+                goto fail;
+
         fe->tuner_priv = state;
+
         mutex_unlock(&mxl5007t_list_mutex);
 
         memcpy(&fe->ops.tuner_ops, &mxl5007t_tuner_ops,
diff --git a/drivers/media/tuners/r820t.c b/drivers/media/tuners/r820t.c
index a759742cae7b..8e040cf9cf13 100644
--- a/drivers/media/tuners/r820t.c
+++ b/drivers/media/tuners/r820t.c
@@ -959,6 +959,18 @@ static int r820t_set_tv_standard(struct r820t_priv *priv,
                 lt_att = 0x00;          /* r31[7], lt att enable */
                 flt_ext_widest = 0x00;  /* r15[7]: flt_ext_wide off */
                 polyfil_cur = 0x60;     /* r25[6:5]:min */
+        } else if (delsys == SYS_DVBC_ANNEX_A) {
+                if_khz = 5070;
+                filt_cal_lo = 73500;
+                filt_gain = 0x10;       /* +3db, 6mhz on */
+                img_r = 0x00;           /* image negative */
+                filt_q = 0x10;          /* r10[4]:low q(1'b1) */
+                hp_cor = 0x0b;          /* 1.7m disable, +0cap, 1.0mhz */
+                ext_enable = 0x40;      /* r30[6]=1 ext enable; r30[5]:1 ext at lna max-1 */
+                loop_through = 0x00;    /* r5[7], lt on */
+                lt_att = 0x00;          /* r31[7], lt att enable */
+                flt_ext_widest = 0x00;  /* r15[7]: flt_ext_wide off */
+                polyfil_cur = 0x60;     /* r25[6:5]:min */
         } else {
                 if (bw <= 6) {
                         if_khz = 3570;
diff --git a/drivers/media/tuners/si2157.c b/drivers/media/tuners/si2157.c
index cf97142e01e6..2180de9d654a 100644
--- a/drivers/media/tuners/si2157.c
+++ b/drivers/media/tuners/si2157.c
@@ -1,5 +1,5 @@
 /*
- * Silicon Labs Si2147/2157/2158 silicon tuner driver
+ * Silicon Labs Si2146/2147/2148/2157/2158 silicon tuner driver
  *
  * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
  *
@@ -93,8 +93,13 @@ static int si2157_init(struct dvb_frontend *fe)
                 goto warm;
 
         /* power up */
-        memcpy(cmd.args, "\xc0\x00\x0c\x00\x00\x01\x01\x01\x01\x01\x01\x02\x00\x00\x01", 15);
-        cmd.wlen = 15;
+        if (s->chiptype == SI2157_CHIPTYPE_SI2146) {
+                memcpy(cmd.args, "\xc0\x05\x01\x00\x00\x0b\x00\x00\x01", 9);
+                cmd.wlen = 9;
+        } else {
+                memcpy(cmd.args, "\xc0\x00\x0c\x00\x00\x01\x01\x01\x01\x01\x01\x02\x00\x00\x01", 15);
+                cmd.wlen = 15;
+        }
         cmd.rlen = 1;
         ret = si2157_cmd_execute(s, &cmd);
         if (ret)
@@ -112,17 +117,20 @@ static int si2157_init(struct dvb_frontend *fe)
                         cmd.args[4] << 0;
 
         #define SI2158_A20 ('A' << 24 | 58 << 16 | '2' << 8 | '0' << 0)
+        #define SI2148_A20 ('A' << 24 | 48 << 16 | '2' << 8 | '0' << 0)
         #define SI2157_A30 ('A' << 24 | 57 << 16 | '3' << 8 | '0' << 0)
         #define SI2147_A30 ('A' << 24 | 47 << 16 | '3' << 8 | '0' << 0)
+        #define SI2146_A10 ('A' << 24 | 46 << 16 | '1' << 8 | '0' << 0)
 
         switch (chip_id) {
         case SI2158_A20:
+        case SI2148_A20:
                 fw_file = SI2158_A20_FIRMWARE;
                 break;
         case SI2157_A30:
         case SI2147_A30:
+        case SI2146_A10:
                 goto skip_fw_download;
-                break;
         default:
                 dev_err(&s->client->dev,
                                 "unknown chip version Si21%d-%c%c%c\n",
@@ -149,7 +157,7 @@ static int si2157_init(struct dvb_frontend *fe)
                 dev_err(&s->client->dev, "firmware file '%s' is invalid\n",
                                 fw_file);
                 ret = -EINVAL;
-                goto err;
+                goto fw_release_exit;
         }
 
         dev_info(&s->client->dev, "downloading firmware from file '%s'\n",
@@ -165,7 +173,7 @@ static int si2157_init(struct dvb_frontend *fe)
                         dev_err(&s->client->dev,
                                         "firmware download failed=%d\n",
                                         ret);
-                        goto err;
+                        goto fw_release_exit;
                 }
         }
 
@@ -187,10 +195,9 @@ warm:
         s->active = true;
         return 0;
 
+fw_release_exit:
+        release_firmware(fw);
 err:
-        if (fw)
-                release_firmware(fw);
-
         dev_dbg(&s->client->dev, "failed=%d\n", ret);
         return ret;
 }
@@ -250,6 +257,9 @@ static int si2157_set_params(struct dvb_frontend *fe)
         case SYS_ATSC:
                         delivery_system = 0x00;
                         break;
+        case SYS_DVBC_ANNEX_B:
+                        delivery_system = 0x10;
+                        break;
         case SYS_DVBT:
         case SYS_DVBT2: /* it seems DVB-T and DVB-T2 both are 0x20 here */
                         delivery_system = 0x20;
@@ -272,7 +282,10 @@ static int si2157_set_params(struct dvb_frontend *fe)
         if (ret)
                 goto err;
 
-        memcpy(cmd.args, "\x14\x00\x02\x07\x01\x00", 6);
+        if (s->chiptype == SI2157_CHIPTYPE_SI2146)
+                memcpy(cmd.args, "\x14\x00\x02\x07\x00\x01", 6);
+        else
+                memcpy(cmd.args, "\x14\x00\x02\x07\x01\x00", 6);
         cmd.wlen = 6;
         cmd.rlen = 4;
         ret = si2157_cmd_execute(s, &cmd);
@@ -305,7 +318,7 @@ static int si2157_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
 
 static const struct dvb_tuner_ops si2157_ops = {
         .info = {
-                .name           = "Silicon Labs Si2157/Si2158",
+                .name           = "Silicon Labs Si2146/2147/2148/2157/2158",
                 .frequency_min  = 110000000,
                 .frequency_max  = 862000000,
         },
@@ -336,6 +349,7 @@ static int si2157_probe(struct i2c_client *client,
         s->fe = cfg->fe;
         s->inversion = cfg->inversion;
         s->fw_loaded = false;
+        s->chiptype = (u8)id->driver_data;
         mutex_init(&s->i2c_mutex);
 
         /* check if the tuner is there */
@@ -352,7 +366,10 @@ static int si2157_probe(struct i2c_client *client,
         i2c_set_clientdata(client, s);
 
         dev_info(&s->client->dev,
-                        "Silicon Labs Si2157/Si2158 successfully attached\n");
+                        "Silicon Labs %s successfully attached\n",
+                        s->chiptype == SI2157_CHIPTYPE_SI2146 ?
+                        "Si2146" : "Si2147/2148/2157/2158");
+
         return 0;
 err:
         dev_dbg(&client->dev, "failed=%d\n", ret);
@@ -377,6 +394,7 @@ static int si2157_remove(struct i2c_client *client)
 
 static const struct i2c_device_id si2157_id[] = {
         {"si2157", 0},
+        {"si2146", 1},
         {}
 };
 MODULE_DEVICE_TABLE(i2c, si2157_id);
@@ -393,7 +411,7 @@ static struct i2c_driver si2157_driver = {
 
 module_i2c_driver(si2157_driver);
 
-MODULE_DESCRIPTION("Silicon Labs Si2157/Si2158 silicon tuner driver");
+MODULE_DESCRIPTION("Silicon Labs Si2146/2147/2148/2157/2158 silicon tuner driver");
 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 MODULE_LICENSE("GPL");
 MODULE_FIRMWARE(SI2158_A20_FIRMWARE);
diff --git a/drivers/media/tuners/si2157.h b/drivers/media/tuners/si2157.h
index d3b19cadb4a1..a564c4a9fba7 100644
--- a/drivers/media/tuners/si2157.h
+++ b/drivers/media/tuners/si2157.h
@@ -1,5 +1,5 @@
 /*
- * Silicon Labs Si2147/2157/2158 silicon tuner driver
+ * Silicon Labs Si2146/2147/2148/2157/2158 silicon tuner driver
  *
  * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
  *
diff --git a/drivers/media/tuners/si2157_priv.h b/drivers/media/tuners/si2157_priv.h
index e71ffafed951..d6e07cdd2a07 100644
--- a/drivers/media/tuners/si2157_priv.h
+++ b/drivers/media/tuners/si2157_priv.h
@@ -1,5 +1,5 @@
 /*
- * Silicon Labs Si2147/2157/2158 silicon tuner driver
+ * Silicon Labs Si2146/2147/2148/2157/2158 silicon tuner driver
  *
  * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
  *
@@ -28,9 +28,13 @@ struct si2157 {
         bool active;
         bool fw_loaded;
         bool inversion;
+        u8 chiptype;
 };
 
-/* firmare command struct */
+#define SI2157_CHIPTYPE_SI2157 0
+#define SI2157_CHIPTYPE_SI2146 1
+
+/* firmware command struct */
 #define SI2157_ARGLEN      30
 struct si2157_cmd {
         u8 args[SI2157_ARGLEN];
diff --git a/drivers/media/tuners/tda18271-common.c b/drivers/media/tuners/tda18271-common.c
index 86e5e3110118..a26bb33102b8 100644
--- a/drivers/media/tuners/tda18271-common.c
+++ b/drivers/media/tuners/tda18271-common.c
@@ -178,7 +178,7 @@ int tda18271_read_extended(struct dvb_frontend *fe)
                     (i != R_EB17) &&
                     (i != R_EB19) &&
                     (i != R_EB20))
-                regs[i] = regdump[i];
+                        regs[i] = regdump[i];
         }
 
         if (tda18271_debug & DBG_REG)
diff --git a/drivers/media/tuners/xc5000.c b/drivers/media/tuners/xc5000.c
index 803a0e63d47e..2a039de8ab9a 100644
--- a/drivers/media/tuners/xc5000.c
+++ b/drivers/media/tuners/xc5000.c
@@ -62,6 +62,7 @@ struct xc5000_priv {
         unsigned int mode;
         u8  rf_mode;
         u8  radio_input;
+        u16  output_amp;
 
         int chip_id;
         u16 pll_register_no;
@@ -744,7 +745,9 @@ static int xc5000_tune_digital(struct dvb_frontend *fe)
                 return -EIO;
         }
 
-        xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
+        dprintk(1, "%s() setting OUTPUT_AMP to 0x%x\n",
+                __func__, priv->output_amp);
+        xc_write_reg(priv, XREG_OUTPUT_AMP, priv->output_amp);
 
         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
 
@@ -1333,8 +1336,7 @@ static int xc5000_release(struct dvb_frontend *fe)
 
         if (priv) {
                 cancel_delayed_work(&priv->timer_sleep);
-                if (priv->firmware)
-                        release_firmware(priv->firmware);
+                release_firmware(priv->firmware);
                 hybrid_tuner_release_state(priv);
         }
 
@@ -1358,6 +1360,9 @@ static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
         if (p->radio_input)
                 priv->radio_input = p->radio_input;
 
+        if (p->output_amp)
+                priv->output_amp = p->output_amp;
+
         return 0;
 }
 
@@ -1438,6 +1443,12 @@ struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
                    it can be overridden if this is a hybrid driver */
                 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
 
+        /* don't override output_amp if it's already been set
+           unless explicitly specified */
+        if ((priv->output_amp == 0) || (cfg->output_amp))
+                /* use default output_amp value if none specified */
+                priv->output_amp = (cfg->output_amp) ? cfg->output_amp : 0x8a;
+
         /* Check if firmware has been loaded. It is possible that another
            instance of the driver has loaded the firmware.
          */
diff --git a/drivers/media/tuners/xc5000.h b/drivers/media/tuners/xc5000.h
index 7245cae19f0c..6aa534f17a30 100644
--- a/drivers/media/tuners/xc5000.h
+++ b/drivers/media/tuners/xc5000.h
@@ -36,6 +36,7 @@ struct xc5000_config {
         u32  if_khz;
         u8   radio_input;
         u16  xtal_khz;
+        u16  output_amp;
 
         int chip_id;
 };
diff --git a/drivers/media/usb/au0828/au0828-cards.c b/drivers/media/usb/au0828/au0828-cards.c
index 9eb77ac2153b..da87f1cc31a9 100644
--- a/drivers/media/usb/au0828/au0828-cards.c
+++ b/drivers/media/usb/au0828/au0828-cards.c
@@ -36,6 +36,11 @@ static void hvr950q_cs5340_audio(void *priv, int enable)
                 au0828_clear(dev, REG_000, 0x10);
 }
 
+/*
+ * WARNING: There's a quirks table at sound/usb/quirks-table.h
+ * that should also be updated every time a new device with V4L2 support
+ * is added here.
+ */
 struct au0828_board au0828_boards[] = {
         [AU0828_BOARD_UNKNOWN] = {
                 .name   = "Unknown board",
diff --git a/drivers/media/usb/au0828/au0828-core.c b/drivers/media/usb/au0828/au0828-core.c
index bc064803b6c7..082ae6ba492f 100644
--- a/drivers/media/usb/au0828/au0828-core.c
+++ b/drivers/media/usb/au0828/au0828-core.c
@@ -153,6 +153,14 @@ static void au0828_usb_disconnect(struct usb_interface *interface)
 
         dprintk(1, "%s()\n", __func__);
 
+        /* there is a small window after disconnect, before
+           dev->usbdev is NULL, for poll (e.g: IR) try to access
+           the device and fill the dmesg with error messages.
+           Set the status so poll routines can check and avoid
+           access after disconnect.
+        */
+        dev->dev_state = DEV_DISCONNECTED;
+
         au0828_rc_unregister(dev);
         /* Digital TV */
         au0828_dvb_unregister(dev);
diff --git a/drivers/media/usb/au0828/au0828-dvb.c b/drivers/media/usb/au0828/au0828-dvb.c
index 00ab1563d142..c267d76f5b3c 100644
--- a/drivers/media/usb/au0828/au0828-dvb.c
+++ b/drivers/media/usb/au0828/au0828-dvb.c
@@ -88,12 +88,14 @@ static struct xc5000_config hauppauge_xc5000a_config = {
         .i2c_address      = 0x61,
         .if_khz           = 6000,
         .chip_id          = XC5000A,
+        .output_amp       = 0x8f,
 };
 
 static struct xc5000_config hauppauge_xc5000c_config = {
         .i2c_address      = 0x61,
         .if_khz           = 6000,
         .chip_id          = XC5000C,
+        .output_amp       = 0x8f,
 };
 
 static struct mxl5007t_config mxl5007t_hvr950q_config = {
diff --git a/drivers/media/usb/au0828/au0828-input.c b/drivers/media/usb/au0828/au0828-input.c
index 63995f97dc65..b0f067971979 100644
--- a/drivers/media/usb/au0828/au0828-input.c
+++ b/drivers/media/usb/au0828/au0828-input.c
@@ -129,6 +129,10 @@ static int au0828_get_key_au8522(struct au0828_rc *ir)
         int prv_bit, bit, width;
         bool first = true;
 
+        /* do nothing if device is disconnected */
+        if (ir->dev->dev_state == DEV_DISCONNECTED)
+                return 0;
+
         /* Check IR int */
         rc = au8522_rc_read(ir, 0xe1, -1, buf, 1);
         if (rc < 0 || !(buf[0] & (1 << 4))) {
@@ -255,8 +259,11 @@ static void au0828_rc_stop(struct rc_dev *rc)
 
         cancel_delayed_work_sync(&ir->work);
 
-        /* Disable IR */
-        au8522_rc_clear(ir, 0xe0, 1 << 4);
+        /* do nothing if device is disconnected */
+        if (ir->dev->dev_state != DEV_DISCONNECTED) {
+                /* Disable IR */
+                au8522_rc_clear(ir, 0xe0, 1 << 4);
+        }
 }
 
 static int au0828_probe_i2c_ir(struct au0828_dev *dev)
@@ -363,8 +370,7 @@ void au0828_rc_unregister(struct au0828_dev *dev)
         if (!ir)
                 return;
 
-        if (ir->rc)
-                rc_unregister_device(ir->rc);
+        rc_unregister_device(ir->rc);
 
         /* done */
         kfree(ir);
diff --git a/drivers/media/usb/cx231xx/Kconfig b/drivers/media/usb/cx231xx/Kconfig
index 569aa298c03f..173c0e287a08 100644
--- a/drivers/media/usb/cx231xx/Kconfig
+++ b/drivers/media/usb/cx231xx/Kconfig
@@ -7,6 +7,7 @@ config VIDEO_CX231XX
         select VIDEOBUF_VMALLOC
         select VIDEO_CX25840
         select VIDEO_CX2341X
+        select I2C_MUX
 
         ---help---
           This is a video4linux driver for Conexant 231xx USB based TV cards.
diff --git a/drivers/media/usb/cx231xx/cx231xx-417.c b/drivers/media/usb/cx231xx/cx231xx-417.c
index 459bb0e98971..3f295b4d1a3d 100644
--- a/drivers/media/usb/cx231xx/cx231xx-417.c
+++ b/drivers/media/usb/cx231xx/cx231xx-417.c
@@ -24,6 +24,8 @@
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
+
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/init.h>
@@ -37,9 +39,6 @@
 #include <media/v4l2-event.h>
 #include <media/cx2341x.h>
 #include <media/tuner.h>
-#include <linux/usb.h>
-
-#include "cx231xx.h"
 
 #define CX231xx_FIRM_IMAGE_SIZE 376836
 #define CX231xx_FIRM_IMAGE_NAME "v4l-cx23885-enc.fw"
@@ -90,10 +89,10 @@ static unsigned int v4l_debug = 1;
 module_param(v4l_debug, int, 0644);
 MODULE_PARM_DESC(v4l_debug, "enable V4L debug messages");
 
-#define dprintk(level, fmt, arg...)\
-        do { if (v4l_debug >= level) \
-                pr_info("%s: " fmt, \
-                (dev) ? dev->name : "cx231xx[?]", ## arg); \
+#define dprintk(level, fmt, arg...)     \
+        do {                            \
+                if (v4l_debug >= level) \
+                        printk(KERN_DEBUG pr_fmt(fmt), ## arg); \
         } while (0)
 
 static struct cx231xx_tvnorm cx231xx_tvnorms[] = {
@@ -988,29 +987,34 @@ static int cx231xx_load_firmware(struct cx231xx *dev)
                 IVTV_REG_APU, 0);
 
         if (retval != 0) {
-                pr_err("%s: Error with mc417_register_write\n", __func__);
+                dev_err(dev->dev,
+                        "%s: Error with mc417_register_write\n", __func__);
                 return -1;
         }
 
         retval = request_firmware(&firmware, CX231xx_FIRM_IMAGE_NAME,
-                                  &dev->udev->dev);
+                                  dev->dev);
 
         if (retval != 0) {
-                pr_err("ERROR: Hotplug firmware request failed (%s).\n",
+                dev_err(dev->dev,
+                        "ERROR: Hotplug firmware request failed (%s).\n",
                         CX231xx_FIRM_IMAGE_NAME);
-                pr_err("Please fix your hotplug setup, the board will not work without firmware loaded!\n");
+                dev_err(dev->dev,
+                        "Please fix your hotplug setup, the board will not work without firmware loaded!\n");
                 return -1;
         }
 
         if (firmware->size != CX231xx_FIRM_IMAGE_SIZE) {
-                pr_err("ERROR: Firmware size mismatch (have %zd, expected %d)\n",
+                dev_err(dev->dev,
+                        "ERROR: Firmware size mismatch (have %zd, expected %d)\n",
                         firmware->size, CX231xx_FIRM_IMAGE_SIZE);
                 release_firmware(firmware);
                 return -1;
         }
 
         if (0 != memcmp(firmware->data, magic, 8)) {
-                pr_err("ERROR: Firmware magic mismatch, wrong file?\n");
+                dev_err(dev->dev,
+                        "ERROR: Firmware magic mismatch, wrong file?\n");
                 release_firmware(firmware);
                 return -1;
         }
@@ -1057,7 +1061,8 @@ static int cx231xx_load_firmware(struct cx231xx *dev)
         retval |= mc417_register_write(dev, IVTV_REG_HW_BLOCKS,
                 IVTV_CMD_HW_BLOCKS_RST);
         if (retval < 0) {
-                pr_err("%s: Error with mc417_register_write\n",
+                dev_err(dev->dev,
+                        "%s: Error with mc417_register_write\n",
                         __func__);
                 return retval;
         }
@@ -1069,7 +1074,8 @@ static int cx231xx_load_firmware(struct cx231xx *dev)
         retval |= mc417_register_write(dev, IVTV_REG_VPU, value & 0xFFFFFFE8);
 
         if (retval < 0) {
-                pr_err("%s: Error with mc417_register_write\n",
+                dev_err(dev->dev,
+                        "%s: Error with mc417_register_write\n",
                         __func__);
                 return retval;
         }
@@ -1114,28 +1120,31 @@ static int cx231xx_initialize_codec(struct cx231xx *dev)
         cx231xx_disable656(dev);
         retval = cx231xx_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
         if (retval < 0) {
-                dprintk(2, "%s() PING OK\n", __func__);
+                dprintk(2, "%s: PING OK\n", __func__);
                 retval = cx231xx_load_firmware(dev);
                 if (retval < 0) {
-                        pr_err("%s() f/w load failed\n", __func__);
+                        dev_err(dev->dev,
+                                "%s: f/w load failed\n", __func__);
                         return retval;
                 }
                 retval = cx231xx_find_mailbox(dev);
                 if (retval < 0) {
-                        pr_err("%s() mailbox < 0, error\n",
+                        dev_err(dev->dev, "%s: mailbox < 0, error\n",
                                 __func__);
                         return -1;
                 }
                 dev->cx23417_mailbox = retval;
                 retval = cx231xx_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0);
                 if (retval < 0) {
-                        pr_err("ERROR: cx23417 firmware ping failed!\n");
+                        dev_err(dev->dev,
+                                "ERROR: cx23417 firmware ping failed!\n");
                         return -1;
                 }
                 retval = cx231xx_api_cmd(dev, CX2341X_ENC_GET_VERSION, 0, 1,
                         &version);
                 if (retval < 0) {
-                        pr_err("ERROR: cx23417 firmware get encoder: version failed!\n");
+                        dev_err(dev->dev,
+                                "ERROR: cx23417 firmware get encoder: version failed!\n");
                         return -1;
                 }
                 dprintk(1, "cx23417 firmware version is 0x%08x\n", version);
@@ -1416,8 +1425,9 @@ static int bb_buf_prepare(struct videobuf_queue *q,
                 if (!dev->video_mode.bulk_ctl.num_bufs)
                         urb_init = 1;
         }
-        /*cx231xx_info("urb_init=%d dev->video_mode.max_pkt_size=%d\n",
-                urb_init, dev->video_mode.max_pkt_size);*/
+        dev_dbg(dev->dev,
+                "urb_init=%d dev->video_mode.max_pkt_size=%d\n",
+                urb_init, dev->video_mode.max_pkt_size);
         dev->mode_tv = 1;
 
         if (urb_init) {
@@ -1688,7 +1698,7 @@ static int mpeg_open(struct file *file)
                             sizeof(struct cx231xx_buffer), fh, &dev->lock);
 /*
         videobuf_queue_sg_init(&fh->vidq, &cx231xx_qops,
-                            &dev->udev->dev, &dev->ts1.slock,
+                            dev->dev, &dev->ts1.slock,
                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
                             V4L2_FIELD_INTERLACED,
                             sizeof(struct cx231xx_buffer),
@@ -1798,7 +1808,6 @@ static unsigned int mpeg_poll(struct file *file,
 static int mpeg_mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct cx231xx_fh *fh = file->private_data;
-        struct cx231xx *dev = fh->dev;
 
         dprintk(2, "%s()\n", __func__);
 
@@ -1878,7 +1887,7 @@ static int cx231xx_s_video_encoding(struct cx2341x_handler *cxhdl, u32 val)
         /* fix videodecoder resolution */
         fmt.width = cxhdl->width / (is_mpeg1 ? 2 : 1);
         fmt.height = cxhdl->height;
-        fmt.code = V4L2_MBUS_FMT_FIXED;
+        fmt.code = MEDIA_BUS_FMT_FIXED;
         v4l2_subdev_call(dev->sd_cx25840, video, s_mbus_fmt, &fmt);
         return 0;
 }
diff --git a/drivers/media/usb/cx231xx/cx231xx-audio.c b/drivers/media/usb/cx231xx/cx231xx-audio.c
index 9b925874d392..de4ae5eb4830 100644
--- a/drivers/media/usb/cx231xx/cx231xx-audio.c
+++ b/drivers/media/usb/cx231xx/cx231xx-audio.c
@@ -20,8 +20,8 @@
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
 #include <linux/kernel.h>
-#include <linux/usb.h>
 #include <linux/init.h>
 #include <linux/sound.h>
 #include <linux/spinlock.h>
@@ -37,25 +37,18 @@
 #include <sound/initval.h>
 #include <sound/control.h>
 #include <media/v4l2-common.h>
-#include "cx231xx.h"
 
 static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "activates debug info");
 
-#define dprintk(fmt, arg...) do {                                       \
-                if (debug)                                              \
-                        printk(KERN_INFO "cx231xx-audio %s: " fmt,      \
-                                __func__, ##arg);                       \
-        } while (0)
-
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 
 static int cx231xx_isoc_audio_deinit(struct cx231xx *dev)
 {
         int i;
 
-        dprintk("Stopping isoc\n");
+        dev_dbg(dev->dev, "Stopping isoc\n");
 
         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
                 if (dev->adev.urb[i]) {
@@ -79,7 +72,7 @@ static int cx231xx_bulk_audio_deinit(struct cx231xx *dev)
 {
         int i;
 
-        dprintk("Stopping bulk\n");
+        dev_dbg(dev->dev, "Stopping bulk\n");
 
         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
                 if (dev->adev.urb[i]) {
@@ -123,7 +116,8 @@ static void cx231xx_audio_isocirq(struct urb *urb)
         case -ESHUTDOWN:
                 return;
         default:                /* error */
-                dprintk("urb completition error %d.\n", urb->status);
+                dev_dbg(dev->dev, "urb completition error %d.\n",
+                        urb->status);
                 break;
         }
 
@@ -182,8 +176,9 @@ static void cx231xx_audio_isocirq(struct urb *urb)
 
         status = usb_submit_urb(urb, GFP_ATOMIC);
         if (status < 0) {
-                cx231xx_errdev("resubmit of audio urb failed (error=%i)\n",
-                               status);
+                dev_err(dev->dev,
+                        "resubmit of audio urb failed (error=%i)\n",
+                        status);
         }
         return;
 }
@@ -211,7 +206,8 @@ static void cx231xx_audio_bulkirq(struct urb *urb)
         case -ESHUTDOWN:
                 return;
         default:                /* error */
-                dprintk("urb completition error %d.\n", urb->status);
+                dev_dbg(dev->dev, "urb completition error %d.\n",
+                        urb->status);
                 break;
         }
 
@@ -266,8 +262,9 @@ static void cx231xx_audio_bulkirq(struct urb *urb)
 
         status = usb_submit_urb(urb, GFP_ATOMIC);
         if (status < 0) {
-                cx231xx_errdev("resubmit of audio urb failed (error=%i)\n",
-                               status);
+                dev_err(dev->dev,
+                        "resubmit of audio urb failed (error=%i)\n",
+                        status);
         }
         return;
 }
@@ -277,7 +274,8 @@ static int cx231xx_init_audio_isoc(struct cx231xx *dev)
         int i, errCode;
         int sb_size;
 
-        cx231xx_info("%s: Starting ISO AUDIO transfers\n", __func__);
+        dev_dbg(dev->dev,
+                "%s: Starting ISO AUDIO transfers\n", __func__);
 
         if (dev->state & DEV_DISCONNECTED)
                 return -ENODEV;
@@ -295,7 +293,7 @@ static int cx231xx_init_audio_isoc(struct cx231xx *dev)
                 memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
                 urb = usb_alloc_urb(CX231XX_ISO_NUM_AUDIO_PACKETS, GFP_ATOMIC);
                 if (!urb) {
-                        cx231xx_errdev("usb_alloc_urb failed!\n");
+                        dev_err(dev->dev, "usb_alloc_urb failed!\n");
                         for (j = 0; j < i; j++) {
                                 usb_free_urb(dev->adev.urb[j]);
                                 kfree(dev->adev.transfer_buffer[j]);
@@ -338,7 +336,8 @@ static int cx231xx_init_audio_bulk(struct cx231xx *dev)
         int i, errCode;
         int sb_size;
 
-        cx231xx_info("%s: Starting BULK AUDIO transfers\n", __func__);
+        dev_dbg(dev->dev,
+                "%s: Starting BULK AUDIO transfers\n", __func__);
 
         if (dev->state & DEV_DISCONNECTED)
                 return -ENODEV;
@@ -356,7 +355,7 @@ static int cx231xx_init_audio_bulk(struct cx231xx *dev)
                 memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
                 urb = usb_alloc_urb(CX231XX_NUM_AUDIO_PACKETS, GFP_ATOMIC);
                 if (!urb) {
-                        cx231xx_errdev("usb_alloc_urb failed!\n");
+                        dev_err(dev->dev, "usb_alloc_urb failed!\n");
                         for (j = 0; j < i; j++) {
                                 usb_free_urb(dev->adev.urb[j]);
                                 kfree(dev->adev.transfer_buffer[j]);
@@ -392,8 +391,9 @@ static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs,
                                         size_t size)
 {
         struct snd_pcm_runtime *runtime = subs->runtime;
+        struct cx231xx *dev = snd_pcm_substream_chip(subs);
 
-        dprintk("Allocating vbuffer\n");
+        dev_dbg(dev->dev, "Allocating vbuffer\n");
         if (runtime->dma_area) {
                 if (runtime->dma_bytes > size)
                         return 0;
@@ -436,16 +436,12 @@ static int snd_cx231xx_capture_open(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         int ret = 0;
 
-        dprintk("opening device and trying to acquire exclusive lock\n");
-
-        if (!dev) {
-                cx231xx_errdev("BUG: cx231xx can't find device struct."
-                               " Can't proceed with open\n");
-                return -ENODEV;
-        }
+        dev_dbg(dev->dev,
+                "opening device and trying to acquire exclusive lock\n");
 
         if (dev->state & DEV_DISCONNECTED) {
-                cx231xx_errdev("Can't open. the device was removed.\n");
+                dev_err(dev->dev,
+                        "Can't open. the device was removed.\n");
                 return -ENODEV;
         }
 
@@ -458,7 +454,8 @@ static int snd_cx231xx_capture_open(struct snd_pcm_substream *substream)
                 ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 0);
         mutex_unlock(&dev->lock);
         if (ret < 0) {
-                cx231xx_errdev("failed to set alternate setting !\n");
+                dev_err(dev->dev,
+                        "failed to set alternate setting !\n");
 
                 return ret;
         }
@@ -484,7 +481,7 @@ static int snd_cx231xx_pcm_close(struct snd_pcm_substream *substream)
         int ret;
         struct cx231xx *dev = snd_pcm_substream_chip(substream);
 
-        dprintk("closing device\n");
+        dev_dbg(dev->dev, "closing device\n");
 
         /* inform hardware to stop streaming */
         mutex_lock(&dev->lock);
@@ -494,7 +491,8 @@ static int snd_cx231xx_pcm_close(struct snd_pcm_substream *substream)
         /* 1 - 48000 samples per sec */
         ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 0);
         if (ret < 0) {
-                cx231xx_errdev("failed to set alternate setting !\n");
+                dev_err(dev->dev,
+                        "failed to set alternate setting !\n");
 
                 mutex_unlock(&dev->lock);
                 return ret;
@@ -504,10 +502,10 @@ static int snd_cx231xx_pcm_close(struct snd_pcm_substream *substream)
         mutex_unlock(&dev->lock);
 
         if (dev->adev.users == 0 && dev->adev.shutdown == 1) {
-                dprintk("audio users: %d\n", dev->adev.users);
-                dprintk("disabling audio stream!\n");
+                dev_dbg(dev->dev, "audio users: %d\n", dev->adev.users);
+                dev_dbg(dev->dev, "disabling audio stream!\n");
                 dev->adev.shutdown = 0;
-                dprintk("released lock\n");
+                dev_dbg(dev->dev, "released lock\n");
                 if (atomic_read(&dev->stream_started) > 0) {
                         atomic_set(&dev->stream_started, 0);
                         schedule_work(&dev->wq_trigger);
@@ -519,9 +517,10 @@ static int snd_cx231xx_pcm_close(struct snd_pcm_substream *substream)
 static int snd_cx231xx_hw_capture_params(struct snd_pcm_substream *substream,
                                          struct snd_pcm_hw_params *hw_params)
 {
+        struct cx231xx *dev = snd_pcm_substream_chip(substream);
         int ret;
 
-        dprintk("Setting capture parameters\n");
+        dev_dbg(dev->dev, "Setting capture parameters\n");
 
         ret = snd_pcm_alloc_vmalloc_buffer(substream,
                                            params_buffer_bytes(hw_params));
@@ -543,7 +542,7 @@ static int snd_cx231xx_hw_capture_free(struct snd_pcm_substream *substream)
 {
         struct cx231xx *dev = snd_pcm_substream_chip(substream);
 
-        dprintk("Stop capture, if needed\n");
+        dev_dbg(dev->dev, "Stop capture, if needed\n");
 
         if (atomic_read(&dev->stream_started) > 0) {
                 atomic_set(&dev->stream_started, 0);
@@ -568,7 +567,7 @@ static void audio_trigger(struct work_struct *work)
         struct cx231xx *dev = container_of(work, struct cx231xx, wq_trigger);
 
         if (atomic_read(&dev->stream_started)) {
-                dprintk("starting capture");
+                dev_dbg(dev->dev, "starting capture");
                 if (is_fw_load(dev) == 0)
                         cx25840_call(dev, core, load_fw);
                 if (dev->USE_ISO)
@@ -576,7 +575,7 @@ static void audio_trigger(struct work_struct *work)
                 else
                         cx231xx_init_audio_bulk(dev);
         } else {
-                dprintk("stopping capture");
+                dev_dbg(dev->dev, "stopping capture");
                 cx231xx_isoc_audio_deinit(dev);
         }
 }
@@ -662,10 +661,10 @@ static int cx231xx_audio_init(struct cx231xx *dev)
                 return 0;
         }
 
-        cx231xx_info("cx231xx-audio.c: probing for cx231xx "
-                     "non standard usbaudio\n");
+        dev_dbg(dev->dev,
+                "probing for cx231xx non standard usbaudio\n");
 
-        err = snd_card_new(&dev->udev->dev, index[devnr], "Cx231xx Audio",
+        err = snd_card_new(dev->dev, index[devnr], "Cx231xx Audio",
                            THIS_MODULE, 0, &card);
         if (err < 0)
                 return err;
@@ -707,14 +706,13 @@ static int cx231xx_audio_init(struct cx231xx *dev)
                         bEndpointAddress;
 
         adev->num_alt = uif->num_altsetting;
-        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
-                     adev->end_point_addr, adev->num_alt);
+        dev_info(dev->dev,
+                "audio EndPoint Addr 0x%x, Alternate settings: %i\n",
+                adev->end_point_addr, adev->num_alt);
         adev->alt_max_pkt_size = kmalloc(32 * adev->num_alt, GFP_KERNEL);
 
-        if (adev->alt_max_pkt_size == NULL) {
-                cx231xx_errdev("out of memory!\n");
+        if (adev->alt_max_pkt_size == NULL)
                 return -ENOMEM;
-        }
 
         for (i = 0; i < adev->num_alt; i++) {
                 u16 tmp =
@@ -722,8 +720,9 @@ static int cx231xx_audio_init(struct cx231xx *dev)
                                 wMaxPacketSize);
                 adev->alt_max_pkt_size[i] =
                     (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
-                cx231xx_info("Alternate setting %i, max size= %i\n", i,
-                             adev->alt_max_pkt_size[i]);
+                dev_dbg(dev->dev,
+                        "audio alternate setting %i, max size= %i\n", i,
+                        adev->alt_max_pkt_size[i]);
         }
 
         return 0;
diff --git a/drivers/media/usb/cx231xx/cx231xx-avcore.c b/drivers/media/usb/cx231xx/cx231xx-avcore.c
index 40a69879fc0a..39e887925e3d 100644
--- a/drivers/media/usb/cx231xx/cx231xx-avcore.c
+++ b/drivers/media/usb/cx231xx/cx231xx-avcore.c
@@ -22,12 +22,12 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/bitmap.h>
-#include <linux/usb.h>
 #include <linux/i2c.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>
@@ -36,7 +36,6 @@
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
 
-#include "cx231xx.h"
 #include "cx231xx-dif.h"
 
 #define TUNER_MODE_FM_RADIO 0
@@ -83,10 +82,10 @@ void initGPIO(struct cx231xx *dev)
         cx231xx_send_gpio_cmd(dev, _gpio_direction, (u8 *)&value, 4, 0, 0);
 
         verve_read_byte(dev, 0x07, &val);
-        cx231xx_info(" verve_read_byte address0x07=0x%x\n", val);
+        dev_dbg(dev->dev, "verve_read_byte address0x07=0x%x\n", val);
         verve_write_byte(dev, 0x07, 0xF4);
         verve_read_byte(dev, 0x07, &val);
-        cx231xx_info(" verve_read_byte address0x07=0x%x\n", val);
+        dev_dbg(dev->dev, "verve_read_byte address0x07=0x%x\n", val);
 
         cx231xx_capture_start(dev, 1, Vbi);
 
@@ -156,22 +155,25 @@ int cx231xx_afe_init_super_block(struct cx231xx *dev, u32 ref_count)
         while (afe_power_status != 0x18) {
                 status = afe_write_byte(dev, SUP_BLK_PWRDN, 0x18);
                 if (status < 0) {
-                        cx231xx_info(
-                        ": Init Super Block failed in send cmd\n");
+                        dev_dbg(dev->dev,
+                                "%s: Init Super Block failed in send cmd\n",
+                                __func__);
                         break;
                 }
 
                 status = afe_read_byte(dev, SUP_BLK_PWRDN, &afe_power_status);
                 afe_power_status &= 0xff;
                 if (status < 0) {
-                        cx231xx_info(
-                        ": Init Super Block failed in receive cmd\n");
+                        dev_dbg(dev->dev,
+                                "%s: Init Super Block failed in receive cmd\n",
+                                __func__);
                         break;
                 }
                 i++;
                 if (i == 10) {
-                        cx231xx_info(
-                        ": Init Super Block force break in loop !!!!\n");
+                        dev_dbg(dev->dev,
+                                "%s: Init Super Block force break in loop !!!!\n",
+                                __func__);
                         status = -1;
                         break;
                 }
@@ -410,7 +412,7 @@ int cx231xx_afe_update_power_control(struct cx231xx *dev,
                         status |= afe_write_byte(dev, ADC_PWRDN_CLAMP_CH3,
                                                 0x00);
                 } else {
-                        cx231xx_info("Invalid AV mode input\n");
+                        dev_dbg(dev->dev, "Invalid AV mode input\n");
                         status = -1;
                 }
                 break;
@@ -467,7 +469,7 @@ int cx231xx_afe_update_power_control(struct cx231xx *dev,
                         status |= afe_write_byte(dev, ADC_PWRDN_CLAMP_CH3,
                                                         0x40);
                 } else {
-                        cx231xx_info("Invalid AV mode input\n");
+                        dev_dbg(dev->dev, "Invalid AV mode input\n");
                         status = -1;
                 }
         }                       /* switch  */
@@ -573,9 +575,9 @@ int cx231xx_set_video_input_mux(struct cx231xx *dev, u8 input)
                         status = cx231xx_set_power_mode(dev,
                                         POLARIS_AVMODE_ENXTERNAL_AV);
                         if (status < 0) {
-                                cx231xx_errdev("%s: set_power_mode : Failed to"
-                                                " set Power - errCode [%d]!\n",
-                                                __func__, status);
+                                dev_err(dev->dev,
+                                        "%s: Failed to set Power - errCode [%d]!\n",
+                                        __func__, status);
                                 return status;
                         }
                 }
@@ -591,8 +593,8 @@ int cx231xx_set_video_input_mux(struct cx231xx *dev, u8 input)
                         status = cx231xx_set_power_mode(dev,
                                                 POLARIS_AVMODE_ANALOGT_TV);
                         if (status < 0) {
-                                cx231xx_errdev("%s: set_power_mode:Failed"
-                                        " to set Power - errCode [%d]!\n",
+                                dev_err(dev->dev,
+                                        "%s: Failed to set Power - errCode [%d]!\n",
                                         __func__, status);
                                 return status;
                         }
@@ -608,8 +610,8 @@ int cx231xx_set_video_input_mux(struct cx231xx *dev, u8 input)
 
                 break;
         default:
-                cx231xx_errdev("%s: set_power_mode : Unknown Input %d !\n",
-                     __func__, INPUT(input)->type);
+                dev_err(dev->dev, "%s: Unknown Input %d !\n",
+                        __func__, INPUT(input)->type);
                 break;
         }
 
@@ -628,8 +630,8 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev,
         if (pin_type != dev->video_input) {
                 status = cx231xx_afe_adjust_ref_count(dev, pin_type);
                 if (status < 0) {
-                        cx231xx_errdev("%s: adjust_ref_count :Failed to set"
-                                "AFE input mux - errCode [%d]!\n",
+                        dev_err(dev->dev,
+                                "%s: adjust_ref_count :Failed to set AFE input mux - errCode [%d]!\n",
                                 __func__, status);
                         return status;
                 }
@@ -638,9 +640,9 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev,
         /* call afe block to set video inputs */
         status = cx231xx_afe_set_input_mux(dev, input);
         if (status < 0) {
-                cx231xx_errdev("%s: set_input_mux :Failed to set"
-                                " AFE input mux - errCode [%d]!\n",
-                                __func__, status);
+                dev_err(dev->dev,
+                        "%s: set_input_mux :Failed to set AFE input mux - errCode [%d]!\n",
+                        __func__, status);
                 return status;
         }
 
@@ -670,8 +672,8 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev,
                 /* Tell DIF object to go to baseband mode  */
                 status = cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND);
                 if (status < 0) {
-                        cx231xx_errdev("%s: cx231xx_dif set to By pass"
-                                                   " mode- errCode [%d]!\n",
+                        dev_err(dev->dev,
+                                "%s: cx231xx_dif set to By pass mode- errCode [%d]!\n",
                                 __func__, status);
                         return status;
                 }
@@ -715,8 +717,8 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev,
                 /* Tell DIF object to go to baseband mode */
                 status = cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND);
                 if (status < 0) {
-                        cx231xx_errdev("%s: cx231xx_dif set to By pass"
-                                                   " mode- errCode [%d]!\n",
+                        dev_err(dev->dev,
+                                "%s: cx231xx_dif set to By pass mode- errCode [%d]!\n",
                                 __func__, status);
                         return status;
                 }
@@ -790,9 +792,9 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev,
                         status = cx231xx_dif_set_standard(dev,
                                                           DIF_USE_BASEBAND);
                         if (status < 0) {
-                                cx231xx_errdev("%s: cx231xx_dif set to By pass"
-                                                " mode- errCode [%d]!\n",
-                                                __func__, status);
+                                dev_err(dev->dev,
+                                        "%s: cx231xx_dif set to By pass mode- errCode [%d]!\n",
+                                       __func__, status);
                                 return status;
                         }
 
@@ -826,9 +828,9 @@ int cx231xx_set_decoder_video_input(struct cx231xx *dev,
                         /* Reinitialize the DIF */
                         status = cx231xx_dif_set_standard(dev, dev->norm);
                         if (status < 0) {
-                                cx231xx_errdev("%s: cx231xx_dif set to By pass"
-                                                " mode- errCode [%d]!\n",
-                                                __func__, status);
+                                dev_err(dev->dev,
+                                        "%s: cx231xx_dif set to By pass mode- errCode [%d]!\n",
+                                        __func__, status);
                                 return status;
                         }
 
@@ -970,14 +972,14 @@ int cx231xx_do_mode_ctrl_overrides(struct cx231xx *dev)
 {
         int status = 0;
 
-        cx231xx_info("do_mode_ctrl_overrides : 0x%x\n",
-                     (unsigned int)dev->norm);
+        dev_dbg(dev->dev, "%s: 0x%x\n",
+                __func__, (unsigned int)dev->norm);
 
         /* Change the DFE_CTRL3 bp_percent to fix flagging */
         status = vid_blk_write_word(dev, DFE_CTRL3, 0xCD3F0280);
 
         if (dev->norm & (V4L2_STD_NTSC | V4L2_STD_PAL_M)) {
-                cx231xx_info("do_mode_ctrl_overrides NTSC\n");
+                dev_dbg(dev->dev, "%s: NTSC\n", __func__);
 
                 /* Move the close caption lines out of active video,
                    adjust the active video start point */
@@ -1004,7 +1006,7 @@ int cx231xx_do_mode_ctrl_overrides(struct cx231xx *dev)
                                                         (FLD_HBLANK_CNT, 0x79));
 
         } else if (dev->norm & V4L2_STD_SECAM) {
-                cx231xx_info("do_mode_ctrl_overrides SECAM\n");
+                dev_dbg(dev->dev, "%s: SECAM\n", __func__);
                 status =  cx231xx_read_modify_write_i2c_dword(dev,
                                                         VID_BLK_I2C_ADDRESS,
                                                         VERT_TIM_CTRL,
@@ -1031,7 +1033,7 @@ int cx231xx_do_mode_ctrl_overrides(struct cx231xx *dev)
                                                         cx231xx_set_field
                                                         (FLD_HBLANK_CNT, 0x85));
         } else {
-                cx231xx_info("do_mode_ctrl_overrides PAL\n");
+                dev_dbg(dev->dev, "%s: PAL\n", __func__);
                 status = cx231xx_read_modify_write_i2c_dword(dev,
                                                         VID_BLK_I2C_ADDRESS,
                                                         VERT_TIM_CTRL,
@@ -1206,7 +1208,8 @@ int cx231xx_set_audio_decoder_input(struct cx231xx *dev,
                         /* This is just a casual suggestion to people adding
                            new boards in case they use a tuner type we don't
                            currently know about */
-                        printk(KERN_INFO "Unknown tuner type configuring SIF");
+                        dev_info(dev->dev,
+                                 "Unknown tuner type configuring SIF");
                         break;
                 }
                 break;
@@ -1270,8 +1273,13 @@ int cx231xx_enable_i2c_port_3(struct cx231xx *dev, bool is_port_3)
         int status = 0;
         bool current_is_port_3;
 
-        if (dev->board.dont_use_port_3)
-                is_port_3 = false;
+        /*
+         * Should this code check dev->port_3_switch_enabled first
+         * to skip unnecessary reading of the register?
+         * If yes, the flag dev->port_3_switch_enabled must be initialized
+         * correctly.
+         */
+
         status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER,
                                        PWR_CTL_EN, value, 4);
         if (status < 0)
@@ -1288,12 +1296,13 @@ int cx231xx_enable_i2c_port_3(struct cx231xx *dev, bool is_port_3)
         else
                 value[0] &= ~I2C_DEMOD_EN;
 
-        cx231xx_info("Changing the i2c master port to %d\n",
-                     is_port_3 ?  3 : 1);
-
         status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
                                         PWR_CTL_EN, value, 4);
 
+        /* remember status of the switch for usage in is_tuner */
+        if (status >= 0)
+                dev->port_3_switch_enabled = is_port_3;
+
         return status;
 
 }
@@ -1325,113 +1334,131 @@ void cx231xx_dump_HH_reg(struct cx231xx *dev)
 
         for (i = 0x100; i < 0x140; i++) {
                 vid_blk_read_word(dev, i, &value);
-                cx231xx_info("reg0x%x=0x%x\n", i, value);
+                dev_dbg(dev->dev, "reg0x%x=0x%x\n", i, value);
                 i = i+3;
         }
 
         for (i = 0x300; i < 0x400; i++) {
                 vid_blk_read_word(dev, i, &value);
-                cx231xx_info("reg0x%x=0x%x\n", i, value);
+                dev_dbg(dev->dev, "reg0x%x=0x%x\n", i, value);
                 i = i+3;
         }
 
         for (i = 0x400; i < 0x440; i++) {
                 vid_blk_read_word(dev, i,  &value);
-                cx231xx_info("reg0x%x=0x%x\n", i, value);
+                dev_dbg(dev->dev, "reg0x%x=0x%x\n", i, value);
                 i = i+3;
         }
 
         vid_blk_read_word(dev, AFE_CTRL_C2HH_SRC_CTRL, &value);
-        cx231xx_info("AFE_CTRL_C2HH_SRC_CTRL=0x%x\n", value);
+        dev_dbg(dev->dev, "AFE_CTRL_C2HH_SRC_CTRL=0x%x\n", value);
         vid_blk_write_word(dev, AFE_CTRL_C2HH_SRC_CTRL, 0x4485D390);
         vid_blk_read_word(dev, AFE_CTRL_C2HH_SRC_CTRL, &value);
-        cx231xx_info("AFE_CTRL_C2HH_SRC_CTRL=0x%x\n", value);
+        dev_dbg(dev->dev, "AFE_CTRL_C2HH_SRC_CTRL=0x%x\n", value);
 }
 
-void cx231xx_dump_SC_reg(struct cx231xx *dev)
+#if 0
+static void cx231xx_dump_SC_reg(struct cx231xx *dev)
 {
         u8 value[4] = { 0, 0, 0, 0 };
-        cx231xx_info("cx231xx_dump_SC_reg!\n");
+        dev_dbg(dev->dev, "%s!\n", __func__);
 
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, BOARD_CFG_STAT,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", BOARD_CFG_STAT, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", BOARD_CFG_STAT, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, TS_MODE_REG,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS_MODE_REG, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS_MODE_REG, value[0],
+                 value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, TS1_CFG_REG,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS1_CFG_REG, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS1_CFG_REG, value[0],
+                 value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, TS1_LENGTH_REG,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS1_LENGTH_REG, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS1_LENGTH_REG, value[0],
+                value[1], value[2], value[3]);
 
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, TS2_CFG_REG,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS2_CFG_REG, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS2_CFG_REG, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, TS2_LENGTH_REG,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS2_LENGTH_REG, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", TS2_LENGTH_REG, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, EP_MODE_SET,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", EP_MODE_SET, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", EP_MODE_SET, value[0],
+                 value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_PWR_PTN1,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN1, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN1, value[0],
+                value[1], value[2], value[3]);
 
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_PWR_PTN2,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN2, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN2, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_PWR_PTN3,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN3, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_PTN3, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_PWR_MASK0,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK0, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK0, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_PWR_MASK1,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK1, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK1, value[0],
+                value[1], value[2], value[3]);
 
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_PWR_MASK2,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK2, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_PWR_MASK2, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_GAIN,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_GAIN, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_GAIN, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_CAR_REG,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_CAR_REG, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_CAR_REG, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_OT_CFG1,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_OT_CFG1, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_OT_CFG1, value[0],
+                value[1], value[2], value[3]);
 
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, CIR_OT_CFG2,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_OT_CFG2, value[0],
-                                 value[1], value[2], value[3]);
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", CIR_OT_CFG2, value[0],
+                value[1], value[2], value[3]);
         cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN,
                                  value, 4);
-        cx231xx_info("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", PWR_CTL_EN, value[0],
-                                 value[1], value[2], value[3]);
-
-
+        dev_dbg(dev->dev,
+                "reg0x%x=0x%x 0x%x 0x%x 0x%x\n", PWR_CTL_EN, value[0],
+                value[1], value[2], value[3]);
 }
+#endif
 
 void cx231xx_Setup_AFE_for_LowIF(struct cx231xx *dev)
 
@@ -1497,7 +1524,7 @@ void cx231xx_set_Colibri_For_LowIF(struct cx231xx *dev, u32 if_freq,
         u32 standard = 0;
         u8 value[4] = { 0, 0, 0, 0 };
 
-        cx231xx_info("Enter cx231xx_set_Colibri_For_LowIF()\n");
+        dev_dbg(dev->dev, "Enter cx231xx_set_Colibri_For_LowIF()\n");
         value[0] = (u8) 0x6F;
         value[1] = (u8) 0x6F;
         value[2] = (u8) 0x6F;
@@ -1517,7 +1544,7 @@ void cx231xx_set_Colibri_For_LowIF(struct cx231xx *dev, u32 if_freq,
         colibri_carrier_offset = cx231xx_Get_Colibri_CarrierOffset(mode,
                                                                    standard);
 
-        cx231xx_info("colibri_carrier_offset=%d, standard=0x%x\n",
+        dev_dbg(dev->dev, "colibri_carrier_offset=%d, standard=0x%x\n",
                      colibri_carrier_offset, standard);
 
         /* Set the band Pass filter for DIF*/
@@ -1551,8 +1578,8 @@ void cx231xx_set_DIF_bandpass(struct cx231xx *dev, u32 if_freq,
         u64 pll_freq_u64 = 0;
         u32 i = 0;
 
-        cx231xx_info("if_freq=%d;spectral_invert=0x%x;mode=0x%x\n",
-                         if_freq, spectral_invert, mode);
+        dev_dbg(dev->dev, "if_freq=%d;spectral_invert=0x%x;mode=0x%x\n",
+                if_freq, spectral_invert, mode);
 
 
         if (mode == TUNER_MODE_FM_RADIO) {
@@ -1595,8 +1622,7 @@ void cx231xx_set_DIF_bandpass(struct cx231xx *dev, u32 if_freq,
                 if_freq = 16000000;
         }
 
-        cx231xx_info("Enter IF=%zu\n",
-                        ARRAY_SIZE(Dif_set_array));
+        dev_dbg(dev->dev, "Enter IF=%zu\n", ARRAY_SIZE(Dif_set_array));
         for (i = 0; i < ARRAY_SIZE(Dif_set_array); i++) {
                 if (Dif_set_array[i].if_freq == if_freq) {
                         vid_blk_write_word(dev,
@@ -1708,7 +1734,7 @@ int cx231xx_dif_set_standard(struct cx231xx *dev, u32 standard)
         u32 dif_misc_ctrl_value = 0;
         u32 func_mode = 0;
 
-        cx231xx_info("%s: setStandard to %x\n", __func__, standard);
+        dev_dbg(dev->dev, "%s: setStandard to %x\n", __func__, standard);
 
         status = vid_blk_read_word(dev, DIF_MISC_CTRL, &dif_misc_ctrl_value);
         if (standard != DIF_USE_BASEBAND)
@@ -2111,8 +2137,8 @@ int cx231xx_tuner_post_channel_change(struct cx231xx *dev)
 {
         int status = 0;
         u32 dwval;
-        cx231xx_info("cx231xx_tuner_post_channel_change  dev->tuner_type =0%d\n",
-                     dev->tuner_type);
+        dev_dbg(dev->dev, "%s: dev->tuner_type =0%d\n",
+                __func__, dev->tuner_type);
         /* Set the RF and IF k_agc values to 4 for PAL/NTSC and 8 for
          * SECAM L/B/D standards */
         status = vid_blk_read_word(dev, DIF_AGC_IF_REF, &dwval);
@@ -2213,8 +2239,8 @@ int cx231xx_set_power_mode(struct cx231xx *dev, enum AV_MODE mode)
         if (dev->power_mode != mode)
                 dev->power_mode = mode;
         else {
-                cx231xx_info(" setPowerMode::mode = %d, No Change req.\n",
-                             mode);
+                dev_dbg(dev->dev, "%s: mode = %d, No Change req.\n",
+                         __func__, mode);
                 return 0;
         }
 
@@ -2264,7 +2290,6 @@ int cx231xx_set_power_mode(struct cx231xx *dev, enum AV_MODE mode)
         case POLARIS_AVMODE_ANALOGT_TV:
 
                 tmp |= PWR_DEMOD_EN;
-                tmp |= (I2C_DEMOD_EN);
                 value[0] = (u8) tmp;
                 value[1] = (u8) (tmp >> 8);
                 value[2] = (u8) (tmp >> 16);
@@ -2317,9 +2342,6 @@ int cx231xx_set_power_mode(struct cx231xx *dev, enum AV_MODE mode)
                 }
 
                 if (dev->board.tuner_type != TUNER_ABSENT) {
-                        /* Enable tuner */
-                        cx231xx_enable_i2c_port_3(dev, true);
-
                         /* reset the Tuner */
                         if (dev->board.tuner_gpio)
                                 cx231xx_gpio_set(dev, dev->board.tuner_gpio);
@@ -2363,7 +2385,7 @@ int cx231xx_set_power_mode(struct cx231xx *dev, enum AV_MODE mode)
                 }
 
                 tmp &= (~PWR_AV_MODE);
-                tmp |= POLARIS_AVMODE_DIGITAL | I2C_DEMOD_EN;
+                tmp |= POLARIS_AVMODE_DIGITAL;
                 value[0] = (u8) tmp;
                 value[1] = (u8) (tmp >> 8);
                 value[2] = (u8) (tmp >> 16);
@@ -2384,15 +2406,6 @@ int cx231xx_set_power_mode(struct cx231xx *dev, enum AV_MODE mode)
                 }
 
                 if (dev->board.tuner_type != TUNER_ABSENT) {
-                        /*
-                         * Enable tuner
-                         *      Hauppauge Exeter seems to need to do something different!
-                         */
-                        if (dev->model == CX231XX_BOARD_HAUPPAUGE_EXETER)
-                                cx231xx_enable_i2c_port_3(dev, false);
-                        else
-                                cx231xx_enable_i2c_port_3(dev, true);
-
                         /* reset the Tuner */
                         if (dev->board.tuner_gpio)
                                 cx231xx_gpio_set(dev, dev->board.tuner_gpio);
@@ -2466,7 +2479,7 @@ int cx231xx_start_stream(struct cx231xx *dev, u32 ep_mask)
         u32 tmp = 0;
         int status = 0;
 
-        cx231xx_info("cx231xx_start_stream():: ep_mask = %x\n", ep_mask);
+        dev_dbg(dev->dev, "%s: ep_mask = %x\n", __func__, ep_mask);
         status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, EP_MODE_SET,
                                        value, 4);
         if (status < 0)
@@ -2491,7 +2504,7 @@ int cx231xx_stop_stream(struct cx231xx *dev, u32 ep_mask)
         u32 tmp = 0;
         int status = 0;
 
-        cx231xx_info("cx231xx_stop_stream():: ep_mask = %x\n", ep_mask);
+        dev_dbg(dev->dev, "%s: ep_mask = %x\n", __func__, ep_mask);
         status =
             cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, EP_MODE_SET, value, 4);
         if (status < 0)
@@ -2519,61 +2532,72 @@ int cx231xx_initialize_stream_xfer(struct cx231xx *dev, u32 media_type)
         if (dev->udev->speed == USB_SPEED_HIGH) {
                 switch (media_type) {
                 case Audio:
-                        cx231xx_info("%s: Audio enter HANC\n", __func__);
+                        dev_dbg(dev->dev,
+                                "%s: Audio enter HANC\n", __func__);
                         status =
                             cx231xx_mode_register(dev, TS_MODE_REG, 0x9300);
                         break;
 
                 case Vbi:
-                        cx231xx_info("%s: set vanc registers\n", __func__);
+                        dev_dbg(dev->dev,
+                                "%s: set vanc registers\n", __func__);
                         status = cx231xx_mode_register(dev, TS_MODE_REG, 0x300);
                         break;
 
                 case Sliced_cc:
-                        cx231xx_info("%s: set hanc registers\n", __func__);
+                        dev_dbg(dev->dev,
+                                "%s: set hanc registers\n", __func__);
                         status =
                             cx231xx_mode_register(dev, TS_MODE_REG, 0x1300);
                         break;
 
                 case Raw_Video:
-                        cx231xx_info("%s: set video registers\n", __func__);
+                        dev_dbg(dev->dev,
+                                "%s: set video registers\n", __func__);
                         status = cx231xx_mode_register(dev, TS_MODE_REG, 0x100);
                         break;
 
                 case TS1_serial_mode:
-                        cx231xx_info("%s: set ts1 registers", __func__);
-
-                if (dev->board.has_417) {
-                        cx231xx_info(" MPEG\n");
-                        value &= 0xFFFFFFFC;
-                        value |= 0x3;
-
-                        status = cx231xx_mode_register(dev, TS_MODE_REG, value);
-
-                        val[0] = 0x04;
-                        val[1] = 0xA3;
-                        val[2] = 0x3B;
-                        val[3] = 0x00;
-                        status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-                                 TS1_CFG_REG, val, 4);
-
-                        val[0] = 0x00;
-                        val[1] = 0x08;
-                        val[2] = 0x00;
-                        val[3] = 0x08;
-                        status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
-                                 TS1_LENGTH_REG, val, 4);
-
-                } else {
-                        cx231xx_info(" BDA\n");
-                        status = cx231xx_mode_register(dev, TS_MODE_REG, 0x101);
-                        status = cx231xx_mode_register(dev, TS1_CFG_REG, 0x010);
-                }
+                        dev_dbg(dev->dev,
+                                "%s: set ts1 registers", __func__);
+
+                        if (dev->board.has_417) {
+                                dev_dbg(dev->dev,
+                                        "%s: MPEG\n", __func__);
+                                value &= 0xFFFFFFFC;
+                                value |= 0x3;
+
+                                status = cx231xx_mode_register(dev,
+                                                         TS_MODE_REG, value);
+
+                                val[0] = 0x04;
+                                val[1] = 0xA3;
+                                val[2] = 0x3B;
+                                val[3] = 0x00;
+                                status = cx231xx_write_ctrl_reg(dev,
+                                                        VRT_SET_REGISTER,
+                                                        TS1_CFG_REG, val, 4);
+
+                                val[0] = 0x00;
+                                val[1] = 0x08;
+                                val[2] = 0x00;
+                                val[3] = 0x08;
+                                status = cx231xx_write_ctrl_reg(dev,
+                                                        VRT_SET_REGISTER,
+                                                        TS1_LENGTH_REG, val, 4);
+                        } else {
+                                dev_dbg(dev->dev, "%s: BDA\n", __func__);
+                                status = cx231xx_mode_register(dev,
+                                                         TS_MODE_REG, 0x101);
+                                status = cx231xx_mode_register(dev,
+                                                        TS1_CFG_REG, 0x010);
+                        }
                         break;
 
                 case TS1_parallel_mode:
-                        cx231xx_info("%s: set ts1 parallel mode registers\n",
-                                     __func__);
+                        dev_dbg(dev->dev,
+                                "%s: set ts1 parallel mode registers\n",
+                                __func__);
                         status = cx231xx_mode_register(dev, TS_MODE_REG, 0x100);
                         status = cx231xx_mode_register(dev, TS1_CFG_REG, 0x400);
                         break;
@@ -2926,8 +2950,9 @@ int cx231xx_gpio_i2c_read_ack(struct cx231xx *dev)
                          (nCnt > 0));
 
         if (nCnt == 0)
-                cx231xx_info("No ACK after %d msec -GPIO I2C failed!",
-                             nInit * 10);
+                dev_dbg(dev->dev,
+                        "No ACK after %d msec -GPIO I2C failed!",
+                        nInit * 10);
 
         /*
          * readAck
diff --git a/drivers/media/usb/cx231xx/cx231xx-cards.c b/drivers/media/usb/cx231xx/cx231xx-cards.c
index 791f00c6276b..ae05d591f228 100644
--- a/drivers/media/usb/cx231xx/cx231xx-cards.c
+++ b/drivers/media/usb/cx231xx/cx231xx-cards.c
@@ -20,12 +20,12 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/i2c.h>
-#include <linux/usb.h>
 #include <media/tuner.h>
 #include <media/tveeprom.h>
 #include <media/v4l2-common.h>
@@ -35,7 +35,6 @@
 #include "xc5000.h"
 #include "tda18271.h"
 
-#include "cx231xx.h"
 
 static int tuner = -1;
 module_param(tuner, int, 0444);
@@ -104,8 +103,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_3,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x02,
                 .norm = V4L2_STD_PAL,
@@ -144,8 +143,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_3,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x32,
                 .norm = V4L2_STD_NTSC,
@@ -184,8 +183,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x1c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_3,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x02,
                 .norm = V4L2_STD_PAL,
@@ -225,8 +224,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x1c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_3,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x02,
                 .norm = V4L2_STD_PAL,
@@ -262,7 +261,6 @@ struct cx231xx_board cx231xx_boards[] = {
                 .norm = V4L2_STD_PAL,
                 .no_alt_vanc = 1,
                 .external_av = 1,
-                .dont_use_port_3 = 1,
                 /* Actually, it has a 417, but it isn't working correctly.
                  * So set to 0 for now until someone can manage to get this
                  * to work reliably. */
@@ -297,8 +295,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_3,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x02,
                 .norm = V4L2_STD_PAL,
@@ -325,8 +323,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_3,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x32,
                 .norm = V4L2_STD_NTSC,
@@ -353,8 +351,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_1,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x0e,
                 .norm = V4L2_STD_NTSC,
@@ -390,7 +388,6 @@ struct cx231xx_board cx231xx_boards[] = {
                 .norm = V4L2_STD_NTSC,
                 .no_alt_vanc = 1,
                 .external_av = 1,
-                .dont_use_port_3 = 1,
                 .input = {{
                         .type = CX231XX_VMUX_COMPOSITE1,
                         .vmux = CX231XX_VIN_2_1,
@@ -418,9 +415,9 @@ struct cx231xx_board cx231xx_boards[] = {
                 .tuner_scl_gpio = -1,
                 .tuner_sda_gpio = -1,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 2,
-                .demod_i2c_master = 1,
-                .ir_i2c_master = 2,
+                .tuner_i2c_master = I2C_2,
+                .demod_i2c_master = I2C_1_MUX_3,
+                .ir_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x10,
                 .norm = V4L2_STD_PAL_M,
@@ -456,9 +453,9 @@ struct cx231xx_board cx231xx_boards[] = {
                 .tuner_scl_gpio = -1,
                 .tuner_sda_gpio = -1,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 2,
-                .demod_i2c_master = 1,
-                .ir_i2c_master = 2,
+                .tuner_i2c_master = I2C_2,
+                .demod_i2c_master = I2C_1_MUX_3,
+                .ir_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x10,
                 .norm = V4L2_STD_NTSC_M,
@@ -494,9 +491,9 @@ struct cx231xx_board cx231xx_boards[] = {
                 .tuner_scl_gpio = -1,
                 .tuner_sda_gpio = -1,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 2,
-                .demod_i2c_master = 1,
-                .ir_i2c_master = 2,
+                .tuner_i2c_master = I2C_2,
+                .demod_i2c_master = I2C_1_MUX_3,
+                .ir_i2c_master = I2C_2,
                 .rc_map_name = RC_MAP_PIXELVIEW_002T,
                 .has_dvb = 1,
                 .demod_addr = 0x10,
@@ -532,7 +529,6 @@ struct cx231xx_board cx231xx_boards[] = {
                 .norm = V4L2_STD_NTSC,
                 .no_alt_vanc = 1,
                 .external_av = 1,
-                .dont_use_port_3 = 1,
 
                 .input = {{
                                 .type = CX231XX_VMUX_COMPOSITE1,
@@ -587,7 +583,7 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
+                .tuner_i2c_master = I2C_1_MUX_3,
                 .norm = V4L2_STD_PAL,
 
                 .input = {{
@@ -622,7 +618,7 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
+                .tuner_i2c_master = I2C_1_MUX_3,
                 .norm = V4L2_STD_NTSC,
 
                 .input = {{
@@ -656,7 +652,6 @@ struct cx231xx_board cx231xx_boards[] = {
                 .norm = V4L2_STD_NTSC,
                 .no_alt_vanc = 1,
                 .external_av = 1,
-                .dont_use_port_3 = 1,
                 .input = {{
                         .type = CX231XX_VMUX_COMPOSITE1,
                         .vmux = CX231XX_VIN_2_1,
@@ -677,13 +672,12 @@ struct cx231xx_board cx231xx_boards[] = {
                 .decoder = CX231XX_AVDECODER,
                 .output_mode = OUT_MODE_VIP11,
                 .ctl_pin_status_mask = 0xFFFFFFC4,
-                .agc_analog_digital_select_gpio = 0x0c, 
+                .agc_analog_digital_select_gpio = 0x0c,
                         /* According with PV CxPlrCAP.inf file */
                 .gpio_pin_status_mask = 0x4001000,
                 .norm = V4L2_STD_NTSC,
                 .no_alt_vanc = 1,
                 .external_av = 1,
-                .dont_use_port_3 = 1,
                 /*.has_417 = 1, */
                 /* This board is believed to have a hardware encoding chip
                  * supporting mpeg1/2/4, but as the 417 is apparently not
@@ -718,8 +712,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_3,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x0e,
                 .norm = V4L2_STD_PAL,
@@ -757,8 +751,8 @@ struct cx231xx_board cx231xx_boards[] = {
                 .ctl_pin_status_mask = 0xFFFFFFC4,
                 .agc_analog_digital_select_gpio = 0x0c,
                 .gpio_pin_status_mask = 0x4001000,
-                .tuner_i2c_master = 1,
-                .demod_i2c_master = 2,
+                .tuner_i2c_master = I2C_1_MUX_3,
+                .demod_i2c_master = I2C_2,
                 .has_dvb = 1,
                 .demod_addr = 0x0e,
                 .norm = V4L2_STD_PAL,
@@ -861,9 +855,9 @@ int cx231xx_tuner_callback(void *ptr, int component, int command, int arg)
 
         if (dev->tuner_type == TUNER_XC5000) {
                 if (command == XC5000_TUNER_RESET) {
-                        cx231xx_info
-                                ("Tuner CB: RESET: cmd %d : tuner type %d \n",
-                                 command, dev->tuner_type);
+                        dev_dbg(dev->dev,
+                                "Tuner CB: RESET: cmd %d : tuner type %d\n",
+                                command, dev->tuner_type);
                         cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
                                                1);
                         msleep(10);
@@ -921,8 +915,8 @@ void cx231xx_pre_card_setup(struct cx231xx *dev)
 
         cx231xx_set_model(dev);
 
-        cx231xx_info("Identified as %s (card=%d)\n",
-                     dev->board.name, dev->model);
+        dev_info(dev->dev, "Identified as %s (card=%d)\n",
+                dev->board.name, dev->model);
 
         /* set the direction for GPIO pins */
         if (dev->board.tuner_gpio) {
@@ -980,25 +974,22 @@ static void cx231xx_config_tuner(struct cx231xx *dev)
 
 }
 
-static int read_eeprom(struct cx231xx *dev, u8 *eedata, int len)
+static int read_eeprom(struct cx231xx *dev, struct i2c_client *client,
+                       u8 *eedata, int len)
 {
         int ret = 0;
-        u8 addr = 0xa0 >> 1;
         u8 start_offset = 0;
         int len_todo = len;
         u8 *eedata_cur = eedata;
         int i;
-        struct i2c_msg msg_write = { .addr = addr, .flags = 0,
+        struct i2c_msg msg_write = { .addr = client->addr, .flags = 0,
                 .buf = &start_offset, .len = 1 };
-        struct i2c_msg msg_read = { .addr = addr, .flags = I2C_M_RD };
-
-        /* mutex_lock(&dev->i2c_lock); */
-        cx231xx_enable_i2c_port_3(dev, false);
+        struct i2c_msg msg_read = { .addr = client->addr, .flags = I2C_M_RD };
 
         /* start reading at offset 0 */
-        ret = i2c_transfer(&dev->i2c_bus[1].i2c_adap, &msg_write, 1);
+        ret = i2c_transfer(client->adapter, &msg_write, 1);
         if (ret < 0) {
-                cx231xx_err("Can't read eeprom\n");
+                dev_err(dev->dev, "Can't read eeprom\n");
                 return ret;
         }
 
@@ -1006,20 +997,18 @@ static int read_eeprom(struct cx231xx *dev, u8 *eedata, int len)
                 msg_read.len = (len_todo > 64) ? 64 : len_todo;
                 msg_read.buf = eedata_cur;
 
-                ret = i2c_transfer(&dev->i2c_bus[1].i2c_adap, &msg_read, 1);
+                ret = i2c_transfer(client->adapter, &msg_read, 1);
                 if (ret < 0) {
-                        cx231xx_err("Can't read eeprom\n");
+                        dev_err(dev->dev, "Can't read eeprom\n");
                         return ret;
                 }
                 eedata_cur += msg_read.len;
                 len_todo -= msg_read.len;
         }
 
-        cx231xx_enable_i2c_port_3(dev, true);
-        /* mutex_unlock(&dev->i2c_lock); */
-
         for (i = 0; i + 15 < len; i += 16)
-                cx231xx_info("i2c eeprom %02x: %*ph\n", i, 16, &eedata[i]);
+                dev_dbg(dev->dev, "i2c eeprom %02x: %*ph\n",
+                        i, 16, &eedata[i]);
 
         return 0;
 }
@@ -1036,22 +1025,26 @@ void cx231xx_card_setup(struct cx231xx *dev)
         /* request some modules */
         if (dev->board.decoder == CX231XX_AVDECODER) {
                 dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
-                                        &dev->i2c_bus[0].i2c_adap,
+                                        cx231xx_get_i2c_adap(dev, I2C_0),
                                         "cx25840", 0x88 >> 1, NULL);
                 if (dev->sd_cx25840 == NULL)
-                        cx231xx_info("cx25840 subdev registration failure\n");
+                        dev_err(dev->dev,
+                                "cx25840 subdev registration failure\n");
                 cx25840_call(dev, core, load_fw);
 
         }
 
         /* Initialize the tuner */
         if (dev->board.tuner_type != TUNER_ABSENT) {
+                struct i2c_adapter *tuner_i2c = cx231xx_get_i2c_adap(dev,
+                                                dev->board.tuner_i2c_master);
                 dev->sd_tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev,
-                                                    &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                                                    tuner_i2c,
                                                     "tuner",
                                                     dev->tuner_addr, NULL);
                 if (dev->sd_tuner == NULL)
-                        cx231xx_info("tuner subdev registration failure\n");
+                        dev_err(dev->dev,
+                                "tuner subdev registration failure\n");
                 else
                         cx231xx_config_tuner(dev);
         }
@@ -1062,9 +1055,14 @@ void cx231xx_card_setup(struct cx231xx *dev)
                 {
                         struct tveeprom tvee;
                         static u8 eeprom[256];
+                        struct i2c_client client;
+
+                        memset(&client, 0, sizeof(client));
+                        client.adapter = cx231xx_get_i2c_adap(dev, I2C_1_MUX_1);
+                        client.addr = 0xa0 >> 1;
 
-                        read_eeprom(dev, eeprom, sizeof(eeprom));
-                        tveeprom_hauppauge_analog(&dev->i2c_bus[1].i2c_client,
+                        read_eeprom(dev, &client, eeprom, sizeof(eeprom));
+                        tveeprom_hauppauge_analog(&client,
                                                 &tvee, eeprom + 0xc0);
                         break;
                 }
@@ -1152,7 +1150,7 @@ static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
         /* Query cx231xx to find what pcb config it is related to */
         retval = initialize_cx231xx(dev);
         if (retval < 0) {
-                cx231xx_errdev("Failed to read PCB config\n");
+                dev_err(dev->dev, "Failed to read PCB config\n");
                 return retval;
         }
 
@@ -1168,7 +1166,7 @@ static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
 
         retval = cx231xx_config(dev);
         if (retval) {
-                cx231xx_errdev("error configuring device\n");
+                dev_err(dev->dev, "error configuring device\n");
                 return -ENOMEM;
         }
 
@@ -1178,8 +1176,9 @@ static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
         /* register i2c bus */
         retval = cx231xx_dev_init(dev);
         if (retval) {
-                cx231xx_errdev("%s: cx231xx_i2c_register - errCode [%d]!\n",
-                               __func__, retval);
+                dev_err(dev->dev,
+                        "%s: cx231xx_i2c_register - errCode [%d]!\n",
+                        __func__, retval);
                 goto err_dev_init;
         }
 
@@ -1200,8 +1199,8 @@ static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
 
         retval = cx231xx_config(dev);
         if (retval) {
-                cx231xx_errdev("%s: cx231xx_config - errCode [%d]!\n",
-                               __func__, retval);
+                dev_err(dev->dev, "%s: cx231xx_config - errCode [%d]!\n",
+                        __func__, retval);
                 goto err_dev_init;
         }
 
@@ -1217,11 +1216,11 @@ static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
         cx231xx_add_into_devlist(dev);
 
         if (dev->board.has_417) {
-                printk(KERN_INFO "attach 417 %d\n", dev->model);
+                dev_info(dev->dev, "attach 417 %d\n", dev->model);
                 if (cx231xx_417_register(dev) < 0) {
-                        printk(KERN_ERR
+                        dev_err(dev->dev,
                                 "%s() Failed to register 417 on VID_B\n",
-                               __func__);
+                                __func__);
                 }
         }
 
@@ -1285,7 +1284,8 @@ static int cx231xx_init_v4l2(struct cx231xx *dev,
         /* compute alternate max packet sizes for video */
         idx = dev->current_pcb_config.hs_config_info[0].interface_info.video_index + 1;
         if (idx >= dev->max_iad_interface_count) {
-                cx231xx_errdev("Video PCB interface #%d doesn't exist\n", idx);
+                dev_err(dev->dev,
+                        "Video PCB interface #%d doesn't exist\n", idx);
                 return -ENODEV;
         }
 
@@ -1294,28 +1294,29 @@ static int cx231xx_init_v4l2(struct cx231xx *dev,
         dev->video_mode.end_point_addr = uif->altsetting[0].endpoint[isoc_pipe].desc.bEndpointAddress;
         dev->video_mode.num_alt = uif->num_altsetting;
 
-        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
-                     dev->video_mode.end_point_addr,
-                     dev->video_mode.num_alt);
+        dev_info(dev->dev,
+                 "video EndPoint Addr 0x%x, Alternate settings: %i\n",
+                 dev->video_mode.end_point_addr,
+                 dev->video_mode.num_alt);
 
         dev->video_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->video_mode.num_alt, GFP_KERNEL);
-        if (dev->video_mode.alt_max_pkt_size == NULL) {
-                cx231xx_errdev("out of memory!\n");
+        if (dev->video_mode.alt_max_pkt_size == NULL)
                 return -ENOMEM;
-        }
 
         for (i = 0; i < dev->video_mode.num_alt; i++) {
                 u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].desc.wMaxPacketSize);
                 dev->video_mode.alt_max_pkt_size[i] = (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
-                cx231xx_info("Alternate setting %i, max size= %i\n", i,
-                             dev->video_mode.alt_max_pkt_size[i]);
+                dev_dbg(dev->dev,
+                        "Alternate setting %i, max size= %i\n", i,
+                        dev->video_mode.alt_max_pkt_size[i]);
         }
 
         /* VBI Init */
 
         idx = dev->current_pcb_config.hs_config_info[0].interface_info.vanc_index + 1;
         if (idx >= dev->max_iad_interface_count) {
-                cx231xx_errdev("VBI PCB interface #%d doesn't exist\n", idx);
+                dev_err(dev->dev,
+                        "VBI PCB interface #%d doesn't exist\n", idx);
                 return -ENODEV;
         }
         uif = udev->actconfig->interface[idx];
@@ -1325,16 +1326,15 @@ static int cx231xx_init_v4l2(struct cx231xx *dev,
                         bEndpointAddress;
 
         dev->vbi_mode.num_alt = uif->num_altsetting;
-        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
-                     dev->vbi_mode.end_point_addr,
-                     dev->vbi_mode.num_alt);
+        dev_info(dev->dev,
+                 "VBI EndPoint Addr 0x%x, Alternate settings: %i\n",
+                 dev->vbi_mode.end_point_addr,
+                 dev->vbi_mode.num_alt);
 
         /* compute alternate max packet sizes for vbi */
         dev->vbi_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->vbi_mode.num_alt, GFP_KERNEL);
-        if (dev->vbi_mode.alt_max_pkt_size == NULL) {
-                cx231xx_errdev("out of memory!\n");
+        if (dev->vbi_mode.alt_max_pkt_size == NULL)
                 return -ENOMEM;
-        }
 
         for (i = 0; i < dev->vbi_mode.num_alt; i++) {
                 u16 tmp =
@@ -1342,8 +1342,9 @@ static int cx231xx_init_v4l2(struct cx231xx *dev,
                                 desc.wMaxPacketSize);
                 dev->vbi_mode.alt_max_pkt_size[i] =
                     (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
-                cx231xx_info("Alternate setting %i, max size= %i\n", i,
-                             dev->vbi_mode.alt_max_pkt_size[i]);
+                dev_dbg(dev->dev,
+                        "Alternate setting %i, max size= %i\n", i,
+                        dev->vbi_mode.alt_max_pkt_size[i]);
         }
 
         /* Sliced CC VBI init */
@@ -1351,7 +1352,8 @@ static int cx231xx_init_v4l2(struct cx231xx *dev,
         /* compute alternate max packet sizes for sliced CC */
         idx = dev->current_pcb_config.hs_config_info[0].interface_info.hanc_index + 1;
         if (idx >= dev->max_iad_interface_count) {
-                cx231xx_errdev("Sliced CC PCB interface #%d doesn't exist\n", idx);
+                dev_err(dev->dev,
+                        "Sliced CC PCB interface #%d doesn't exist\n", idx);
                 return -ENODEV;
         }
         uif = udev->actconfig->interface[idx];
@@ -1361,23 +1363,22 @@ static int cx231xx_init_v4l2(struct cx231xx *dev,
                         bEndpointAddress;
 
         dev->sliced_cc_mode.num_alt = uif->num_altsetting;
-        cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
-                     dev->sliced_cc_mode.end_point_addr,
-                     dev->sliced_cc_mode.num_alt);
+        dev_info(dev->dev,
+                 "sliced CC EndPoint Addr 0x%x, Alternate settings: %i\n",
+                 dev->sliced_cc_mode.end_point_addr,
+                 dev->sliced_cc_mode.num_alt);
         dev->sliced_cc_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->sliced_cc_mode.num_alt, GFP_KERNEL);
-
-        if (dev->sliced_cc_mode.alt_max_pkt_size == NULL) {
-                cx231xx_errdev("out of memory!\n");
+        if (dev->sliced_cc_mode.alt_max_pkt_size == NULL)
                 return -ENOMEM;
-        }
 
         for (i = 0; i < dev->sliced_cc_mode.num_alt; i++) {
                 u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
                                 desc.wMaxPacketSize);
                 dev->sliced_cc_mode.alt_max_pkt_size[i] =
                     (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
-                cx231xx_info("Alternate setting %i, max size= %i\n", i,
-                             dev->sliced_cc_mode.alt_max_pkt_size[i]);
+                dev_dbg(dev->dev,
+                        "Alternate setting %i, max size= %i\n", i,
+                        dev->sliced_cc_mode.alt_max_pkt_size[i]);
         }
 
         return 0;
@@ -1391,6 +1392,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                              const struct usb_device_id *id)
 {
         struct usb_device *udev;
+        struct device *d = &interface->dev;
         struct usb_interface *uif;
         struct cx231xx *dev = NULL;
         int retval = -ENODEV;
@@ -1401,6 +1403,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         struct usb_interface_assoc_descriptor *assoc_desc;
 
         ifnum = interface->altsetting[0].desc.bInterfaceNumber;
+        udev = usb_get_dev(interface_to_usbdev(interface));
 
         /*
          * Interface number 0 - IR interface (handled by mceusb driver)
@@ -1414,18 +1417,16 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                 nr = find_first_zero_bit(&cx231xx_devused, CX231XX_MAXBOARDS);
                 if (nr >= CX231XX_MAXBOARDS) {
                         /* No free device slots */
-                        cx231xx_err(DRIVER_NAME ": Supports only %i devices.\n",
-                                        CX231XX_MAXBOARDS);
+                        dev_err(d,
+                                "Supports only %i devices.\n",
+                                CX231XX_MAXBOARDS);
                         return -ENOMEM;
                 }
         } while (test_and_set_bit(nr, &cx231xx_devused));
 
-        udev = usb_get_dev(interface_to_usbdev(interface));
-
         /* allocate memory for our device state and initialize it */
         dev = devm_kzalloc(&udev->dev, sizeof(*dev), GFP_KERNEL);
         if (dev == NULL) {
-                cx231xx_err(DRIVER_NAME ": out of memory!\n");
                 clear_bit(nr, &cx231xx_devused);
                 return -ENOMEM;
         }
@@ -1434,6 +1435,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         dev->devno = nr;
         dev->model = id->driver_info;
         dev->video_mode.alt = -1;
+        dev->dev = d;
 
         dev->interface_count++;
         /* reset gpio dir and value */
@@ -1472,14 +1474,14 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                 speed = "unknown";
         }
 
-        cx231xx_info("New device %s %s @ %s Mbps "
-             "(%04x:%04x) with %d interfaces\n",
-             udev->manufacturer ? udev->manufacturer : "",
-             udev->product ? udev->product : "",
-             speed,
-             le16_to_cpu(udev->descriptor.idVendor),
-             le16_to_cpu(udev->descriptor.idProduct),
-             dev->max_iad_interface_count);
+        dev_info(d,
+                 "New device %s %s @ %s Mbps (%04x:%04x) with %d interfaces\n",
+                 udev->manufacturer ? udev->manufacturer : "",
+                 udev->product ? udev->product : "",
+                 speed,
+                 le16_to_cpu(udev->descriptor.idVendor),
+                 le16_to_cpu(udev->descriptor.idProduct),
+                 dev->max_iad_interface_count);
 
         /* increment interface count */
         dev->interface_count++;
@@ -1489,13 +1491,12 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
 
         assoc_desc = udev->actconfig->intf_assoc[0];
         if (assoc_desc->bFirstInterface != ifnum) {
-                cx231xx_err(DRIVER_NAME ": Not found "
-                            "matching IAD interface\n");
+                dev_err(d, "Not found matching IAD interface\n");
                 retval = -ENODEV;
                 goto err_if;
         }
 
-        cx231xx_info("registering interface %d\n", ifnum);
+        dev_dbg(d, "registering interface %d\n", ifnum);
 
         /* save our data pointer in this interface device */
         usb_set_intfdata(interface, dev);
@@ -1503,7 +1504,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         /* Create v4l2 device */
         retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
         if (retval) {
-                cx231xx_errdev("v4l2_device_register failed\n");
+                dev_err(d, "v4l2_device_register failed\n");
                 goto err_v4l2;
         }
 
@@ -1520,7 +1521,8 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                 /* compute alternate max packet sizes for TS1 */
                 idx = dev->current_pcb_config.hs_config_info[0].interface_info.ts1_index + 1;
                 if (idx >= dev->max_iad_interface_count) {
-                        cx231xx_errdev("TS1 PCB interface #%d doesn't exist\n", idx);
+                        dev_err(d, "TS1 PCB interface #%d doesn't exist\n",
+                                idx);
                         retval = -ENODEV;
                         goto err_video_alt;
                 }
@@ -1531,13 +1533,13 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                                 desc.bEndpointAddress;
 
                 dev->ts1_mode.num_alt = uif->num_altsetting;
-                cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
-                             dev->ts1_mode.end_point_addr,
-                             dev->ts1_mode.num_alt);
+                dev_info(d,
+                         "TS EndPoint Addr 0x%x, Alternate settings: %i\n",
+                         dev->ts1_mode.end_point_addr,
+                         dev->ts1_mode.num_alt);
 
                 dev->ts1_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->ts1_mode.num_alt, GFP_KERNEL);
                 if (dev->ts1_mode.alt_max_pkt_size == NULL) {
-                        cx231xx_errdev("out of memory!\n");
                         retval = -ENOMEM;
                         goto err_video_alt;
                 }
@@ -1548,8 +1550,8 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                                                 wMaxPacketSize);
                         dev->ts1_mode.alt_max_pkt_size[i] =
                             (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
-                        cx231xx_info("Alternate setting %i, max size= %i\n", i,
-                                     dev->ts1_mode.alt_max_pkt_size[i]);
+                        dev_dbg(d, "Alternate setting %i, max size= %i\n",
+                                i, dev->ts1_mode.alt_max_pkt_size[i]);
                 }
         }
 
@@ -1613,10 +1615,9 @@ static void cx231xx_usb_disconnect(struct usb_interface *interface)
         wake_up_interruptible_all(&dev->open);
 
         if (dev->users) {
-                cx231xx_warn
-                    ("device %s is open! Deregistration and memory "
-                     "deallocation are deferred on close.\n",
-                     video_device_node_name(dev->vdev));
+                dev_warn(dev->dev,
+                         "device %s is open! Deregistration and memory deallocation are deferred on close.\n",
+                         video_device_node_name(dev->vdev));
 
                 /* Even having users, it is safe to remove the RC i2c driver */
                 cx231xx_ir_exit(dev);
diff --git a/drivers/media/usb/cx231xx/cx231xx-core.c b/drivers/media/usb/cx231xx/cx231xx-core.c
index 180103e48036..4a3f28c4e8d3 100644
--- a/drivers/media/usb/cx231xx/cx231xx-core.c
+++ b/drivers/media/usb/cx231xx/cx231xx-core.c
@@ -20,16 +20,15 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include <linux/vmalloc.h>
 #include <media/v4l2-common.h>
 #include <media/tuner.h>
 
-#include "cx231xx.h"
 #include "cx231xx-reg.h"
 
 /* #define ENABLE_DEBUG_ISOC_FRAMES */
@@ -99,10 +98,10 @@ int cx231xx_register_extension(struct cx231xx_ops *ops)
 
         mutex_lock(&cx231xx_devlist_mutex);
         list_add_tail(&ops->next, &cx231xx_extension_devlist);
-        list_for_each_entry(dev, &cx231xx_devlist, devlist)
+        list_for_each_entry(dev, &cx231xx_devlist, devlist) {
                 ops->init(dev);
-
-        printk(KERN_INFO DRIVER_NAME ": %s initialized\n", ops->name);
+                dev_info(dev->dev, "%s initialized\n", ops->name);
+        }
         mutex_unlock(&cx231xx_devlist_mutex);
         return 0;
 }
@@ -113,11 +112,11 @@ void cx231xx_unregister_extension(struct cx231xx_ops *ops)
         struct cx231xx *dev = NULL;
 
         mutex_lock(&cx231xx_devlist_mutex);
-        list_for_each_entry(dev, &cx231xx_devlist, devlist)
+        list_for_each_entry(dev, &cx231xx_devlist, devlist) {
                 ops->fini(dev);
+                dev_info(dev->dev, "%s removed\n", ops->name);
+        }
 
-
-        printk(KERN_INFO DRIVER_NAME ": %s removed\n", ops->name);
         list_del(&ops->next);
         mutex_unlock(&cx231xx_devlist_mutex);
 }
@@ -227,10 +226,9 @@ int cx231xx_send_usb_command(struct cx231xx_i2c *i2c_bus,
 
         /* call common vendor command request */
         status = cx231xx_send_vendor_cmd(dev, &ven_req);
-        if (status < 0) {
-                cx231xx_info
-                    ("UsbInterface::sendCommand, failed with status -%d\n",
-                     status);
+        if (status < 0 && !dev->i2c_scan_running) {
+                dev_err(dev->dev, "%s: failed with status -%d\n",
+                        __func__, status);
         }
 
         return status;
@@ -524,9 +522,9 @@ int cx231xx_set_video_alternate(struct cx231xx *dev)
                     usb_set_interface(dev->udev, usb_interface_index,
                                       dev->video_mode.alt);
                 if (errCode < 0) {
-                        cx231xx_errdev
-                            ("cannot change alt number to %d (error=%i)\n",
-                             dev->video_mode.alt, errCode);
+                        dev_err(dev->dev,
+                                "cannot change alt number to %d (error=%i)\n",
+                                dev->video_mode.alt, errCode);
                         return errCode;
                 }
         }
@@ -600,9 +598,9 @@ int cx231xx_set_alt_setting(struct cx231xx *dev, u8 index, u8 alt)
         }
 
         if (alt > 0 && max_pkt_size == 0) {
-                cx231xx_errdev
-                ("can't change interface %d alt no. to %d: Max. Pkt size = 0\n",
-                usb_interface_index, alt);
+                dev_err(dev->dev,
+                        "can't change interface %d alt no. to %d: Max. Pkt size = 0\n",
+                        usb_interface_index, alt);
                 /*To workaround error number=-71 on EP0 for videograbber,
                  need add following codes.*/
                 if (dev->board.no_alt_vanc)
@@ -616,9 +614,9 @@ int cx231xx_set_alt_setting(struct cx231xx *dev, u8 index, u8 alt)
         if (usb_interface_index > 0) {
                 status = usb_set_interface(dev->udev, usb_interface_index, alt);
                 if (status < 0) {
-                        cx231xx_errdev
-                        ("can't change interface %d alt no. to %d (err=%i)\n",
-                        usb_interface_index, alt, status);
+                        dev_err(dev->dev,
+                                "can't change interface %d alt no. to %d (err=%i)\n",
+                                usb_interface_index, alt, status);
                         return status;
                 }
         }
@@ -767,18 +765,17 @@ int cx231xx_ep5_bulkout(struct cx231xx *dev, u8 *firmware, u16 size)
         u32 *buffer;
 
         buffer = kzalloc(4096, GFP_KERNEL);
-        if (buffer == NULL) {
-                cx231xx_info("out of mem\n");
+        if (buffer == NULL)
                 return -ENOMEM;
-        }
         memcpy(&buffer[0], firmware, 4096);
 
         ret = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 5),
                         buffer, 4096, &actlen, 2000);
 
         if (ret)
-                cx231xx_info("bulk message failed: %d (%d/%d)", ret,
-                                size, actlen);
+                dev_err(dev->dev,
+                        "bulk message failed: %d (%d/%d)", ret,
+                        size, actlen);
         else {
                 errCode = actlen != size ? -1 : 0;
         }
@@ -987,12 +984,8 @@ int cx231xx_init_isoc(struct cx231xx *dev, int max_packets,
         cx231xx_uninit_isoc(dev);
 
         dma_q->p_left_data = kzalloc(4096, GFP_KERNEL);
-        if (dma_q->p_left_data == NULL) {
-                cx231xx_info("out of mem\n");
+        if (dma_q->p_left_data == NULL)
                 return -ENOMEM;
-        }
-
-
 
         dev->video_mode.isoc_ctl.isoc_copy = isoc_copy;
         dev->video_mode.isoc_ctl.num_bufs = num_bufs;
@@ -1018,14 +1011,16 @@ int cx231xx_init_isoc(struct cx231xx *dev, int max_packets,
         dev->video_mode.isoc_ctl.urb =
             kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
         if (!dev->video_mode.isoc_ctl.urb) {
-                cx231xx_errdev("cannot alloc memory for usb buffers\n");
+                dev_err(dev->dev,
+                        "cannot alloc memory for usb buffers\n");
                 return -ENOMEM;
         }
 
         dev->video_mode.isoc_ctl.transfer_buffer =
             kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
         if (!dev->video_mode.isoc_ctl.transfer_buffer) {
-                cx231xx_errdev("cannot allocate memory for usbtransfer\n");
+                dev_err(dev->dev,
+                        "cannot allocate memory for usbtransfer\n");
                 kfree(dev->video_mode.isoc_ctl.urb);
                 return -ENOMEM;
         }
@@ -1045,7 +1040,8 @@ int cx231xx_init_isoc(struct cx231xx *dev, int max_packets,
         for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) {
                 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
                 if (!urb) {
-                        cx231xx_err("cannot alloc isoc_ctl.urb %i\n", i);
+                        dev_err(dev->dev,
+                                "cannot alloc isoc_ctl.urb %i\n", i);
                         cx231xx_uninit_isoc(dev);
                         return -ENOMEM;
                 }
@@ -1055,10 +1051,10 @@ int cx231xx_init_isoc(struct cx231xx *dev, int max_packets,
                     usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL,
                                        &urb->transfer_dma);
                 if (!dev->video_mode.isoc_ctl.transfer_buffer[i]) {
-                        cx231xx_err("unable to allocate %i bytes for transfer"
-                                    " buffer %i%s\n",
-                                    sb_size, i,
-                                    in_interrupt() ? " while in int" : "");
+                        dev_err(dev->dev,
+                                "unable to allocate %i bytes for transfer buffer %i%s\n",
+                                sb_size, i,
+                                in_interrupt() ? " while in int" : "");
                         cx231xx_uninit_isoc(dev);
                         return -ENOMEM;
                 }
@@ -1090,8 +1086,9 @@ int cx231xx_init_isoc(struct cx231xx *dev, int max_packets,
                 rc = usb_submit_urb(dev->video_mode.isoc_ctl.urb[i],
                                     GFP_ATOMIC);
                 if (rc) {
-                        cx231xx_err("submit of urb %i failed (error=%i)\n", i,
-                                    rc);
+                        dev_err(dev->dev,
+                                "submit of urb %i failed (error=%i)\n", i,
+                                rc);
                         cx231xx_uninit_isoc(dev);
                         return rc;
                 }
@@ -1151,14 +1148,16 @@ int cx231xx_init_bulk(struct cx231xx *dev, int max_packets,
         dev->video_mode.bulk_ctl.urb =
             kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
         if (!dev->video_mode.bulk_ctl.urb) {
-                cx231xx_errdev("cannot alloc memory for usb buffers\n");
+                dev_err(dev->dev,
+                        "cannot alloc memory for usb buffers\n");
                 return -ENOMEM;
         }
 
         dev->video_mode.bulk_ctl.transfer_buffer =
             kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
         if (!dev->video_mode.bulk_ctl.transfer_buffer) {
-                cx231xx_errdev("cannot allocate memory for usbtransfer\n");
+                dev_err(dev->dev,
+                        "cannot allocate memory for usbtransfer\n");
                 kfree(dev->video_mode.bulk_ctl.urb);
                 return -ENOMEM;
         }
@@ -1178,7 +1177,8 @@ int cx231xx_init_bulk(struct cx231xx *dev, int max_packets,
         for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) {
                 urb = usb_alloc_urb(0, GFP_KERNEL);
                 if (!urb) {
-                        cx231xx_err("cannot alloc bulk_ctl.urb %i\n", i);
+                        dev_err(dev->dev,
+                                "cannot alloc bulk_ctl.urb %i\n", i);
                         cx231xx_uninit_bulk(dev);
                         return -ENOMEM;
                 }
@@ -1189,10 +1189,10 @@ int cx231xx_init_bulk(struct cx231xx *dev, int max_packets,
                     usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL,
                                      &urb->transfer_dma);
                 if (!dev->video_mode.bulk_ctl.transfer_buffer[i]) {
-                        cx231xx_err("unable to allocate %i bytes for transfer"
-                                    " buffer %i%s\n",
-                                    sb_size, i,
-                                    in_interrupt() ? " while in int" : "");
+                        dev_err(dev->dev,
+                                "unable to allocate %i bytes for transfer buffer %i%s\n",
+                                sb_size, i,
+                                in_interrupt() ? " while in int" : "");
                         cx231xx_uninit_bulk(dev);
                         return -ENOMEM;
                 }
@@ -1212,8 +1212,8 @@ int cx231xx_init_bulk(struct cx231xx *dev, int max_packets,
                 rc = usb_submit_urb(dev->video_mode.bulk_ctl.urb[i],
                                     GFP_ATOMIC);
                 if (rc) {
-                        cx231xx_err("submit of urb %i failed (error=%i)\n", i,
-                                    rc);
+                        dev_err(dev->dev,
+                                "submit of urb %i failed (error=%i)\n", i, rc);
                         cx231xx_uninit_bulk(dev);
                         return rc;
                 }
@@ -1300,6 +1300,15 @@ int cx231xx_dev_init(struct cx231xx *dev)
         cx231xx_i2c_register(&dev->i2c_bus[1]);
         cx231xx_i2c_register(&dev->i2c_bus[2]);
 
+        cx231xx_i2c_mux_register(dev, 0);
+        cx231xx_i2c_mux_register(dev, 1);
+
+        /* scan the real bus segments in the order of physical port numbers */
+        cx231xx_do_i2c_scan(dev, I2C_0);
+        cx231xx_do_i2c_scan(dev, I2C_1_MUX_1);
+        cx231xx_do_i2c_scan(dev, I2C_2);
+        cx231xx_do_i2c_scan(dev, I2C_1_MUX_3);
+
         /* init hardware */
         /* Note : with out calling set power mode function,
         afe can not be set up correctly */
@@ -1307,18 +1316,18 @@ int cx231xx_dev_init(struct cx231xx *dev)
                 errCode = cx231xx_set_power_mode(dev,
                                  POLARIS_AVMODE_ENXTERNAL_AV);
                 if (errCode < 0) {
-                        cx231xx_errdev
-                        ("%s: Failed to set Power - errCode [%d]!\n",
-                        __func__, errCode);
+                        dev_err(dev->dev,
+                                "%s: Failed to set Power - errCode [%d]!\n",
+                                __func__, errCode);
                         return errCode;
                 }
         } else {
                 errCode = cx231xx_set_power_mode(dev,
                                  POLARIS_AVMODE_ANALOGT_TV);
                 if (errCode < 0) {
-                        cx231xx_errdev
-                        ("%s: Failed to set Power - errCode [%d]!\n",
-                        __func__, errCode);
+                        dev_err(dev->dev,
+                                "%s: Failed to set Power - errCode [%d]!\n",
+                                __func__, errCode);
                         return errCode;
                 }
         }
@@ -1331,42 +1340,43 @@ int cx231xx_dev_init(struct cx231xx *dev)
         /* initialize Colibri block */
         errCode = cx231xx_afe_init_super_block(dev, 0x23c);
         if (errCode < 0) {
-                cx231xx_errdev
-                    ("%s: cx231xx_afe init super block - errCode [%d]!\n",
-                     __func__, errCode);
+                dev_err(dev->dev,
+                        "%s: cx231xx_afe init super block - errCode [%d]!\n",
+                        __func__, errCode);
                 return errCode;
         }
         errCode = cx231xx_afe_init_channels(dev);
         if (errCode < 0) {
-                cx231xx_errdev
-                    ("%s: cx231xx_afe init channels - errCode [%d]!\n",
-                     __func__, errCode);
+                dev_err(dev->dev,
+                        "%s: cx231xx_afe init channels - errCode [%d]!\n",
+                        __func__, errCode);
                 return errCode;
         }
 
         /* Set DIF in By pass mode */
         errCode = cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND);
         if (errCode < 0) {
-                cx231xx_errdev
-                    ("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
-                     __func__, errCode);
+                dev_err(dev->dev,
+                        "%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
+                        __func__, errCode);
                 return errCode;
         }
 
         /* I2S block related functions */
         errCode = cx231xx_i2s_blk_initialize(dev);
         if (errCode < 0) {
-                cx231xx_errdev
-                    ("%s: cx231xx_i2s block initialize - errCode [%d]!\n",
-                     __func__, errCode);
+                dev_err(dev->dev,
+                        "%s: cx231xx_i2s block initialize - errCode [%d]!\n",
+                        __func__, errCode);
                 return errCode;
         }
 
         /* init control pins */
         errCode = cx231xx_init_ctrl_pin_status(dev);
         if (errCode < 0) {
-                cx231xx_errdev("%s: cx231xx_init ctrl pins - errCode [%d]!\n",
-                               __func__, errCode);
+                dev_err(dev->dev,
+                        "%s: cx231xx_init ctrl pins - errCode [%d]!\n",
+                        __func__, errCode);
                 return errCode;
         }
 
@@ -1391,9 +1401,9 @@ int cx231xx_dev_init(struct cx231xx *dev)
                 break;
         }
         if (errCode < 0) {
-                cx231xx_errdev
-                    ("%s: cx231xx_AGC mode to Analog - errCode [%d]!\n",
-                     __func__, errCode);
+                dev_err(dev->dev,
+                        "%s: cx231xx_AGC mode to Analog - errCode [%d]!\n",
+                        __func__, errCode);
                 return errCode;
         }
 
@@ -1404,9 +1414,7 @@ int cx231xx_dev_init(struct cx231xx *dev)
         if (dev->board.has_dvb)
                 cx231xx_set_alt_setting(dev, INDEX_TS1, 0);
 
-        /* set the I2C master port to 3 on channel 1 */
-        errCode = cx231xx_enable_i2c_port_3(dev, true);
-
+        errCode = 0;
         return errCode;
 }
 EXPORT_SYMBOL_GPL(cx231xx_dev_init);
@@ -1414,6 +1422,8 @@ EXPORT_SYMBOL_GPL(cx231xx_dev_init);
 void cx231xx_dev_uninit(struct cx231xx *dev)
 {
         /* Un Initialize I2C bus */
+        cx231xx_i2c_mux_unregister(dev, 1);
+        cx231xx_i2c_mux_unregister(dev, 0);
         cx231xx_i2c_unregister(&dev->i2c_bus[2]);
         cx231xx_i2c_unregister(&dev->i2c_bus[1]);
         cx231xx_i2c_unregister(&dev->i2c_bus[0]);
@@ -1468,9 +1478,8 @@ int cx231xx_send_gpio_cmd(struct cx231xx *dev, u32 gpio_bit, u8 *gpio_val,
         /* call common vendor command request */
         status = cx231xx_send_vendor_cmd(dev, &ven_req);
         if (status < 0) {
-                cx231xx_info
-                    ("UsbInterface::sendCommand, failed with status -%d\n",
-                     status);
+                dev_err(dev->dev, "%s: failed with status -%d\n",
+                        __func__, status);
         }
 
         return status;
diff --git a/drivers/media/usb/cx231xx/cx231xx-dvb.c b/drivers/media/usb/cx231xx/cx231xx-dvb.c
index 6c7b5e250eed..dd600b994e69 100644
--- a/drivers/media/usb/cx231xx/cx231xx-dvb.c
+++ b/drivers/media/usb/cx231xx/cx231xx-dvb.c
@@ -19,11 +19,10 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
 #include <linux/kernel.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 
-#include "cx231xx.h"
 #include <media/v4l2-common.h>
 #include <media/videobuf-vmalloc.h>
 
@@ -46,11 +45,6 @@ MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
 
 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 
-#define dprintk(level, fmt, arg...) do {                        \
-if (debug >= level)                                             \
-        printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \
-} while (0)
-
 #define CX231XX_DVB_NUM_BUFS 5
 #define CX231XX_DVB_MAX_PACKETSIZE 564
 #define CX231XX_DVB_MAX_PACKETS 64
@@ -197,9 +191,11 @@ static inline void print_err_status(struct cx231xx *dev, int packet, int status)
                 break;
         }
         if (packet < 0) {
-                dprintk(1, "URB status %d [%s].\n", status, errmsg);
+                dev_dbg(dev->dev,
+                        "URB status %d [%s].\n", status, errmsg);
         } else {
-                dprintk(1, "URB packet %d, status %d [%s].\n",
+                dev_dbg(dev->dev,
+                        "URB packet %d, status %d [%s].\n",
                         packet, status, errmsg);
         }
 }
@@ -265,12 +261,8 @@ static int start_streaming(struct cx231xx_dvb *dvb)
         struct cx231xx *dev = dvb->adapter.priv;
 
         if (dev->USE_ISO) {
-                cx231xx_info("DVB transfer mode is ISO.\n");
-                mutex_lock(&dev->i2c_lock);
-                cx231xx_enable_i2c_port_3(dev, false);
+                dev_dbg(dev->dev, "DVB transfer mode is ISO.\n");
                 cx231xx_set_alt_setting(dev, INDEX_TS1, 4);
-                cx231xx_enable_i2c_port_3(dev, true);
-                mutex_unlock(&dev->i2c_lock);
                 rc = cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
                 if (rc < 0)
                         return rc;
@@ -280,7 +272,7 @@ static int start_streaming(struct cx231xx_dvb *dvb)
                                         dev->ts1_mode.max_pkt_size,
                                         dvb_isoc_copy);
         } else {
-                cx231xx_info("DVB transfer mode is BULK.\n");
+                dev_dbg(dev->dev, "DVB transfer mode is BULK.\n");
                 cx231xx_set_alt_setting(dev, INDEX_TS1, 0);
                 rc = cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
                 if (rc < 0)
@@ -378,24 +370,24 @@ static int attach_xc5000(u8 addr, struct cx231xx *dev)
         struct xc5000_config cfg;
 
         memset(&cfg, 0, sizeof(cfg));
-        cfg.i2c_adap = &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap;
+        cfg.i2c_adap = cx231xx_get_i2c_adap(dev, dev->board.tuner_i2c_master);
         cfg.i2c_addr = addr;
 
         if (!dev->dvb->frontend) {
-                printk(KERN_ERR "%s/2: dvb frontend not attached. "
+                dev_err(dev->dev, "%s/2: dvb frontend not attached. "
                        "Can't attach xc5000\n", dev->name);
                 return -EINVAL;
         }
 
         fe = dvb_attach(xc5000_attach, dev->dvb->frontend, &cfg);
         if (!fe) {
-                printk(KERN_ERR "%s/2: xc5000 attach failed\n", dev->name);
+                dev_err(dev->dev, "%s/2: xc5000 attach failed\n", dev->name);
                 dvb_frontend_detach(dev->dvb->frontend);
                 dev->dvb->frontend = NULL;
                 return -EINVAL;
         }
 
-        printk(KERN_INFO "%s/2: xc5000 attached\n", dev->name);
+        dev_info(dev->dev, "%s/2: xc5000 attached\n", dev->name);
 
         return 0;
 }
@@ -434,16 +426,17 @@ int cx231xx_reset_analog_tuner(struct cx231xx *dev)
 
                 if (dops->init != NULL && !dev->xc_fw_load_done) {
 
-                        cx231xx_info("Reloading firmware for XC5000\n");
+                        dev_dbg(dev->dev,
+                                "Reloading firmware for XC5000\n");
                         status = dops->init(dev->dvb->frontend);
                         if (status == 0) {
                                 dev->xc_fw_load_done = 1;
-                                cx231xx_info
-                                    ("XC5000 firmware download completed\n");
+                                dev_dbg(dev->dev,
+                                        "XC5000 firmware download completed\n");
                         } else {
                                 dev->xc_fw_load_done = 0;
-                                cx231xx_info
-                                    ("XC5000 firmware download failed !!!\n");
+                                dev_dbg(dev->dev,
+                                        "XC5000 firmware download failed !!!\n");
                         }
                 }
 
@@ -466,7 +459,7 @@ static int register_dvb(struct cx231xx_dvb *dvb,
         result = dvb_register_adapter(&dvb->adapter, dev->name, module, device,
                                       adapter_nr);
         if (result < 0) {
-                printk(KERN_WARNING
+                dev_warn(dev->dev,
                        "%s: dvb_register_adapter failed (errno = %d)\n",
                        dev->name, result);
                 goto fail_adapter;
@@ -480,7 +473,7 @@ static int register_dvb(struct cx231xx_dvb *dvb,
         /* register frontend */
         result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
         if (result < 0) {
-                printk(KERN_WARNING
+                dev_warn(dev->dev,
                        "%s: dvb_register_frontend failed (errno = %d)\n",
                        dev->name, result);
                 goto fail_frontend;
@@ -498,7 +491,8 @@ static int register_dvb(struct cx231xx_dvb *dvb,
 
         result = dvb_dmx_init(&dvb->demux);
         if (result < 0) {
-                printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n",
+                dev_warn(dev->dev,
+                         "%s: dvb_dmx_init failed (errno = %d)\n",
                        dev->name, result);
                 goto fail_dmx;
         }
@@ -508,15 +502,16 @@ static int register_dvb(struct cx231xx_dvb *dvb,
         dvb->dmxdev.capabilities = 0;
         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
         if (result < 0) {
-                printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n",
-                       dev->name, result);
+                dev_warn(dev->dev,
+                         "%s: dvb_dmxdev_init failed (errno = %d)\n",
+                         dev->name, result);
                 goto fail_dmxdev;
         }
 
         dvb->fe_hw.source = DMX_FRONTEND_0;
         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
         if (result < 0) {
-                printk(KERN_WARNING
+                dev_warn(dev->dev,
                        "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
                        dev->name, result);
                 goto fail_fe_hw;
@@ -525,17 +520,17 @@ static int register_dvb(struct cx231xx_dvb *dvb,
         dvb->fe_mem.source = DMX_MEMORY_FE;
         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
         if (result < 0) {
-                printk(KERN_WARNING
-                       "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
-                       dev->name, result);
+                dev_warn(dev->dev,
+                         "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
+                         dev->name, result);
                 goto fail_fe_mem;
         }
 
         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
         if (result < 0) {
-                printk(KERN_WARNING
-                       "%s: connect_frontend failed (errno = %d)\n", dev->name,
-                       result);
+                dev_warn(dev->dev,
+                         "%s: connect_frontend failed (errno = %d)\n",
+                         dev->name, result);
                 goto fail_fe_conn;
         }
 
@@ -583,6 +578,8 @@ static int dvb_init(struct cx231xx *dev)
 {
         int result = 0;
         struct cx231xx_dvb *dvb;
+        struct i2c_adapter *tuner_i2c;
+        struct i2c_adapter *demod_i2c;
 
         if (!dev->board.has_dvb) {
                 /* This device does not support the extension */
@@ -592,13 +589,16 @@ static int dvb_init(struct cx231xx *dev)
         dvb = kzalloc(sizeof(struct cx231xx_dvb), GFP_KERNEL);
 
         if (dvb == NULL) {
-                printk(KERN_INFO "cx231xx_dvb: memory allocation failed\n");
+                dev_info(dev->dev,
+                         "cx231xx_dvb: memory allocation failed\n");
                 return -ENOMEM;
         }
         dev->dvb = dvb;
         dev->cx231xx_set_analog_freq = cx231xx_set_analog_freq;
         dev->cx231xx_reset_analog_tuner = cx231xx_reset_analog_tuner;
 
+        tuner_i2c = cx231xx_get_i2c_adap(dev, dev->board.tuner_i2c_master);
+        demod_i2c = cx231xx_get_i2c_adap(dev, dev->board.demod_i2c_master);
         mutex_lock(&dev->lock);
         cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
         cx231xx_demod_reset(dev);
@@ -609,11 +609,11 @@ static int dvb_init(struct cx231xx *dev)
 
                 dev->dvb->frontend = dvb_attach(s5h1432_attach,
                                         &dvico_s5h1432_config,
-                                        &dev->i2c_bus[dev->board.demod_i2c_master].i2c_adap);
+                                        demod_i2c);
 
                 if (dev->dvb->frontend == NULL) {
-                        printk(DRIVER_NAME
-                               ": Failed to attach s5h1432 front end\n");
+                        dev_err(dev->dev,
+                                "Failed to attach s5h1432 front end\n");
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -622,7 +622,7 @@ static int dvb_init(struct cx231xx *dev)
                 dvb->frontend->callback = cx231xx_tuner_callback;
 
                 if (!dvb_attach(xc5000_attach, dev->dvb->frontend,
-                               &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                               tuner_i2c,
                                &cnxt_rde250_tunerconfig)) {
                         result = -EINVAL;
                         goto out_free;
@@ -634,11 +634,11 @@ static int dvb_init(struct cx231xx *dev)
 
                 dev->dvb->frontend = dvb_attach(s5h1411_attach,
                                                &xc5000_s5h1411_config,
-                                               &dev->i2c_bus[dev->board.demod_i2c_master].i2c_adap);
+                                               demod_i2c);
 
                 if (dev->dvb->frontend == NULL) {
-                        printk(DRIVER_NAME
-                               ": Failed to attach s5h1411 front end\n");
+                        dev_err(dev->dev,
+                                "Failed to attach s5h1411 front end\n");
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -647,7 +647,7 @@ static int dvb_init(struct cx231xx *dev)
                 dvb->frontend->callback = cx231xx_tuner_callback;
 
                 if (!dvb_attach(xc5000_attach, dev->dvb->frontend,
-                               &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                               tuner_i2c,
                                &cnxt_rdu250_tunerconfig)) {
                         result = -EINVAL;
                         goto out_free;
@@ -657,11 +657,11 @@ static int dvb_init(struct cx231xx *dev)
 
                 dev->dvb->frontend = dvb_attach(s5h1432_attach,
                                         &dvico_s5h1432_config,
-                                        &dev->i2c_bus[dev->board.demod_i2c_master].i2c_adap);
+                                        demod_i2c);
 
                 if (dev->dvb->frontend == NULL) {
-                        printk(DRIVER_NAME
-                               ": Failed to attach s5h1432 front end\n");
+                        dev_err(dev->dev,
+                                "Failed to attach s5h1432 front end\n");
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -670,7 +670,7 @@ static int dvb_init(struct cx231xx *dev)
                 dvb->frontend->callback = cx231xx_tuner_callback;
 
                 if (!dvb_attach(tda18271_attach, dev->dvb->frontend,
-                               0x60, &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                               0x60, tuner_i2c,
                                &cnxt_rde253s_tunerconfig)) {
                         result = -EINVAL;
                         goto out_free;
@@ -681,11 +681,11 @@ static int dvb_init(struct cx231xx *dev)
 
                 dev->dvb->frontend = dvb_attach(s5h1411_attach,
                                                &tda18271_s5h1411_config,
-                                               &dev->i2c_bus[dev->board.demod_i2c_master].i2c_adap);
+                                               demod_i2c);
 
                 if (dev->dvb->frontend == NULL) {
-                        printk(DRIVER_NAME
-                               ": Failed to attach s5h1411 front end\n");
+                        dev_err(dev->dev,
+                                "Failed to attach s5h1411 front end\n");
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -694,7 +694,7 @@ static int dvb_init(struct cx231xx *dev)
                 dvb->frontend->callback = cx231xx_tuner_callback;
 
                 if (!dvb_attach(tda18271_attach, dev->dvb->frontend,
-                               0x60, &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                               0x60, tuner_i2c,
                                &cnxt_rde253s_tunerconfig)) {
                         result = -EINVAL;
                         goto out_free;
@@ -702,16 +702,17 @@ static int dvb_init(struct cx231xx *dev)
                 break;
         case CX231XX_BOARD_HAUPPAUGE_EXETER:
 
-                printk(KERN_INFO "%s: looking for tuner / demod on i2c bus: %d\n",
-                       __func__, i2c_adapter_id(&dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap));
+                dev_info(dev->dev,
+                         "%s: looking for tuner / demod on i2c bus: %d\n",
+                       __func__, i2c_adapter_id(tuner_i2c));
 
                 dev->dvb->frontend = dvb_attach(lgdt3305_attach,
                                                 &hcw_lgdt3305_config,
-                                                &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap);
+                                                tuner_i2c);
 
                 if (dev->dvb->frontend == NULL) {
-                        printk(DRIVER_NAME
-                               ": Failed to attach LG3305 front end\n");
+                        dev_err(dev->dev,
+                                "Failed to attach LG3305 front end\n");
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -720,7 +721,7 @@ static int dvb_init(struct cx231xx *dev)
                 dvb->frontend->callback = cx231xx_tuner_callback;
 
                 dvb_attach(tda18271_attach, dev->dvb->frontend,
-                           0x60, &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                           0x60, tuner_i2c,
                            &hcw_tda18271_config);
                 break;
 
@@ -728,12 +729,12 @@ static int dvb_init(struct cx231xx *dev)
 
                 dev->dvb->frontend = dvb_attach(si2165_attach,
                         &hauppauge_930C_HD_1113xx_si2165_config,
-                        &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap
+                        tuner_i2c
                         );
 
                 if (dev->dvb->frontend == NULL) {
-                        printk(DRIVER_NAME
-                               ": Failed to attach SI2165 front end\n");
+                        dev_err(dev->dev,
+                                "Failed to attach SI2165 front end\n");
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -745,7 +746,7 @@ static int dvb_init(struct cx231xx *dev)
 
                 dvb_attach(tda18271_attach, dev->dvb->frontend,
                         0x60,
-                        &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                        tuner_i2c,
                         &hcw_tda18271_config);
 
                 dev->cx231xx_reset_analog_tuner = NULL;
@@ -761,12 +762,12 @@ static int dvb_init(struct cx231xx *dev)
 
                 dev->dvb->frontend = dvb_attach(si2165_attach,
                         &pctv_quatro_stick_1114xx_si2165_config,
-                        &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap
+                        tuner_i2c
                         );
 
                 if (dev->dvb->frontend == NULL) {
-                        printk(DRIVER_NAME
-                               ": Failed to attach SI2165 front end\n");
+                        dev_err(dev->dev,
+                                "Failed to attach SI2165 front end\n");
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -786,7 +787,7 @@ static int dvb_init(struct cx231xx *dev)
                 request_module("si2157");
 
                 client = i2c_new_device(
-                        &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                        tuner_i2c,
                         &info);
                 if (client == NULL || client->dev.driver == NULL) {
                         dvb_frontend_detach(dev->dvb->frontend);
@@ -810,16 +811,17 @@ static int dvb_init(struct cx231xx *dev)
         case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID:
         case CX231XX_BOARD_KWORLD_UB430_USB_HYBRID:
 
-                printk(KERN_INFO "%s: looking for demod on i2c bus: %d\n",
-                       __func__, i2c_adapter_id(&dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap));
+                dev_info(dev->dev,
+                         "%s: looking for demod on i2c bus: %d\n",
+                         __func__, i2c_adapter_id(tuner_i2c));
 
                 dev->dvb->frontend = dvb_attach(mb86a20s_attach,
                                                 &pv_mb86a20s_config,
-                                                &dev->i2c_bus[dev->board.demod_i2c_master].i2c_adap);
+                                                demod_i2c);
 
                 if (dev->dvb->frontend == NULL) {
-                        printk(DRIVER_NAME
-                               ": Failed to attach mb86a20s demod\n");
+                        dev_err(dev->dev,
+                                "Failed to attach mb86a20s demod\n");
                         result = -EINVAL;
                         goto out_free;
                 }
@@ -828,30 +830,31 @@ static int dvb_init(struct cx231xx *dev)
                 dvb->frontend->callback = cx231xx_tuner_callback;
 
                 dvb_attach(tda18271_attach, dev->dvb->frontend,
-                           0x60, &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
+                           0x60, tuner_i2c,
                            &pv_tda18271_config);
                 break;
 
         default:
-                printk(KERN_ERR "%s/2: The frontend of your DVB/ATSC card"
-                       " isn't supported yet\n", dev->name);
+                dev_err(dev->dev,
+                        "%s/2: The frontend of your DVB/ATSC card isn't supported yet\n",
+                        dev->name);
                 break;
         }
         if (NULL == dvb->frontend) {
-                printk(KERN_ERR
+                dev_err(dev->dev,
                        "%s/2: frontend initialization failed\n", dev->name);
                 result = -EINVAL;
                 goto out_free;
         }
 
         /* register everything */
-        result = register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
+        result = register_dvb(dvb, THIS_MODULE, dev, dev->dev);
 
         if (result < 0)
                 goto out_free;
 
 
-        printk(KERN_INFO "Successfully loaded cx231xx-dvb\n");
+        dev_info(dev->dev, "Successfully loaded cx231xx-dvb\n");
 
 ret:
         cx231xx_set_mode(dev, CX231XX_SUSPEND);
diff --git a/drivers/media/usb/cx231xx/cx231xx-i2c.c b/drivers/media/usb/cx231xx/cx231xx-i2c.c
index 7c0f797f1057..a29c345b027d 100644
--- a/drivers/media/usb/cx231xx/cx231xx-i2c.c
+++ b/drivers/media/usb/cx231xx/cx231xx-i2c.c
@@ -20,14 +20,14 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/usb.h>
 #include <linux/i2c.h>
+#include <linux/i2c-mux.h>
 #include <media/v4l2-common.h>
 #include <media/tuner.h>
 
-#include "cx231xx.h"
 
 /* ----------------------------------------------------------- */
 
@@ -54,10 +54,19 @@ do {							\
       }                                                 \
 } while (0)
 
+static inline int get_real_i2c_port(struct cx231xx *dev, int bus_nr)
+{
+        if (bus_nr == 1)
+                return dev->port_3_switch_enabled ? I2C_1_MUX_3 : I2C_1_MUX_1;
+        return bus_nr;
+}
+
 static inline bool is_tuner(struct cx231xx *dev, struct cx231xx_i2c *bus,
                         const struct i2c_msg *msg, int tuner_type)
 {
-        if (bus->nr != dev->board.tuner_i2c_master)
+        int i2c_port = get_real_i2c_port(dev, bus->nr);
+
+        if (i2c_port != dev->board.tuner_i2c_master)
                 return false;
 
         if (msg->addr != dev->board.tuner_addr)
@@ -340,14 +349,15 @@ static int cx231xx_i2c_check_for_device(struct i2c_adapter *i2c_adap,
         struct cx231xx *dev = bus->dev;
         struct cx231xx_i2c_xfer_data req_data;
         int status = 0;
+        u8 buf[1];
 
         /* prepare xfer_data struct */
         req_data.dev_addr = msg->addr;
-        req_data.direction = msg->flags;
+        req_data.direction = I2C_M_RD;
         req_data.saddr_len = 0;
         req_data.saddr_dat = 0;
-        req_data.buf_size = 0;
-        req_data.p_buffer = NULL;
+        req_data.buf_size = 1;
+        req_data.p_buffer = buf;
 
         /* usb send command */
         status = dev->cx231xx_send_usb_command(bus, &req_data);
@@ -455,17 +465,14 @@ static struct i2c_adapter cx231xx_adap_template = {
         .algo = &cx231xx_algo,
 };
 
-static struct i2c_client cx231xx_client_template = {
-        .name = "cx231xx internal",
-};
-
 /* ----------------------------------------------------------- */
 
 /*
  * i2c_devs
  * incomplete list of known devices
  */
-static char *i2c_devs[128] = {
+static const char *i2c_devs[128] = {
+        [0x20 >> 1] = "demod",
         [0x60 >> 1] = "colibri",
         [0x88 >> 1] = "hammerhead",
         [0x8e >> 1] = "CIR",
@@ -480,22 +487,34 @@ static char *i2c_devs[128] = {
  * cx231xx_do_i2c_scan()
  * check i2c address range for devices
  */
-void cx231xx_do_i2c_scan(struct cx231xx *dev, struct i2c_client *c)
+void cx231xx_do_i2c_scan(struct cx231xx *dev, int i2c_port)
 {
         unsigned char buf;
         int i, rc;
+        struct i2c_client client;
+
+        if (!i2c_scan)
+                return;
+
+        /* Don't generate I2C errors during scan */
+        dev->i2c_scan_running = true;
+
+        memset(&client, 0, sizeof(client));
+        client.adapter = cx231xx_get_i2c_adap(dev, i2c_port);
 
-        cx231xx_info(": Checking for I2C devices ..\n");
         for (i = 0; i < 128; i++) {
-                c->addr = i;
-                rc = i2c_master_recv(c, &buf, 0);
+                client.addr = i;
+                rc = i2c_master_recv(&client, &buf, 0);
                 if (rc < 0)
                         continue;
-                cx231xx_info("%s: i2c scan: found device @ 0x%x  [%s]\n",
-                             dev->name, i << 1,
-                             i2c_devs[i] ? i2c_devs[i] : "???");
+                dev_info(dev->dev,
+                         "i2c scan: found device @ port %d addr 0x%x  [%s]\n",
+                         i2c_port,
+                         i << 1,
+                         i2c_devs[i] ? i2c_devs[i] : "???");
         }
-        cx231xx_info(": Completed Checking for I2C devices.\n");
+
+        dev->i2c_scan_running = false;
 }
 
 /*
@@ -509,23 +528,17 @@ int cx231xx_i2c_register(struct cx231xx_i2c *bus)
         BUG_ON(!dev->cx231xx_send_usb_command);
 
         bus->i2c_adap = cx231xx_adap_template;
-        bus->i2c_client = cx231xx_client_template;
-        bus->i2c_adap.dev.parent = &dev->udev->dev;
+        bus->i2c_adap.dev.parent = dev->dev;
 
-        strlcpy(bus->i2c_adap.name, bus->dev->name, sizeof(bus->i2c_adap.name));
+        snprintf(bus->i2c_adap.name, sizeof(bus->i2c_adap.name), "%s-%d", bus->dev->name, bus->nr);
 
         bus->i2c_adap.algo_data = bus;
         i2c_set_adapdata(&bus->i2c_adap, &dev->v4l2_dev);
         i2c_add_adapter(&bus->i2c_adap);
 
-        bus->i2c_client.adapter = &bus->i2c_adap;
-
-        if (0 == bus->i2c_rc) {
-                if (i2c_scan)
-                        cx231xx_do_i2c_scan(dev, &bus->i2c_client);
-        } else
-                cx231xx_warn("%s: i2c bus %d register FAILED\n",
-                             dev->name, bus->nr);
+        if (0 != bus->i2c_rc)
+                dev_warn(dev->dev,
+                         "i2c bus %d register FAILED\n", bus->nr);
 
         return bus->i2c_rc;
 }
@@ -539,3 +552,62 @@ int cx231xx_i2c_unregister(struct cx231xx_i2c *bus)
         i2c_del_adapter(&bus->i2c_adap);
         return 0;
 }
+
+/*
+ * cx231xx_i2c_mux_select()
+ * switch i2c master number 1 between port1 and port3
+ */
+static int cx231xx_i2c_mux_select(struct i2c_adapter *adap,
+                        void *mux_priv, u32 chan_id)
+{
+        struct cx231xx *dev = mux_priv;
+
+        return cx231xx_enable_i2c_port_3(dev, chan_id);
+}
+
+int cx231xx_i2c_mux_register(struct cx231xx *dev, int mux_no)
+{
+        struct i2c_adapter *i2c_parent = &dev->i2c_bus[1].i2c_adap;
+        /* what is the correct mux_dev? */
+        struct device *mux_dev = dev->dev;
+
+        dev->i2c_mux_adap[mux_no] = i2c_add_mux_adapter(i2c_parent,
+                                mux_dev,
+                                dev /* mux_priv */,
+                                0,
+                                mux_no /* chan_id */,
+                                0 /* class */,
+                                &cx231xx_i2c_mux_select,
+                                NULL);
+
+        if (!dev->i2c_mux_adap[mux_no])
+                dev_warn(dev->dev,
+                         "i2c mux %d register FAILED\n", mux_no);
+
+        return 0;
+}
+
+void cx231xx_i2c_mux_unregister(struct cx231xx *dev, int mux_no)
+{
+        i2c_del_mux_adapter(dev->i2c_mux_adap[mux_no]);
+        dev->i2c_mux_adap[mux_no] = NULL;
+}
+
+struct i2c_adapter *cx231xx_get_i2c_adap(struct cx231xx *dev, int i2c_port)
+{
+        switch (i2c_port) {
+        case I2C_0:
+                return &dev->i2c_bus[0].i2c_adap;
+        case I2C_1:
+                return &dev->i2c_bus[1].i2c_adap;
+        case I2C_2:
+                return &dev->i2c_bus[2].i2c_adap;
+        case I2C_1_MUX_1:
+                return dev->i2c_mux_adap[0];
+        case I2C_1_MUX_3:
+                return dev->i2c_mux_adap[1];
+        default:
+                return NULL;
+        }
+}
+EXPORT_SYMBOL_GPL(cx231xx_get_i2c_adap);
diff --git a/drivers/media/usb/cx231xx/cx231xx-input.c b/drivers/media/usb/cx231xx/cx231xx-input.c
index 05f0434919d4..15d8d1b5f05c 100644
--- a/drivers/media/usb/cx231xx/cx231xx-input.c
+++ b/drivers/media/usb/cx231xx/cx231xx-input.c
@@ -19,7 +19,6 @@
  */
 
 #include "cx231xx.h"
-#include <linux/usb.h>
 #include <linux/slab.h>
 #include <linux/bitrev.h>
 
@@ -63,7 +62,7 @@ int cx231xx_ir_init(struct cx231xx *dev)
         struct i2c_board_info info;
         u8 ir_i2c_bus;
 
-        dev_dbg(&dev->udev->dev, "%s\n", __func__);
+        dev_dbg(dev->dev, "%s\n", __func__);
 
         /* Only initialize if a rc keycode map is defined */
         if (!cx231xx_boards[dev->model].rc_map_name)
@@ -98,9 +97,10 @@ int cx231xx_ir_init(struct cx231xx *dev)
 
         /* Load and bind ir-kbd-i2c */
         ir_i2c_bus = cx231xx_boards[dev->model].ir_i2c_master;
-        dev_dbg(&dev->udev->dev, "Trying to bind ir at bus %d, addr 0x%02x\n",
+        dev_dbg(dev->dev, "Trying to bind ir at bus %d, addr 0x%02x\n",
                 ir_i2c_bus, info.addr);
-        dev->ir_i2c_client = i2c_new_device(&dev->i2c_bus[ir_i2c_bus].i2c_adap, &info);
+        dev->ir_i2c_client = i2c_new_device(
+                cx231xx_get_i2c_adap(dev, ir_i2c_bus), &info);
 
         return 0;
 }
diff --git a/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.c b/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.c
index 3052c4c20229..5bc74149fcb9 100644
--- a/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.c
+++ b/drivers/media/usb/cx231xx/cx231xx-pcb-cfg.c
@@ -703,9 +703,9 @@ int initialize_cx231xx(struct cx231xx *dev)
                         _current_scenario_idx = INDEX_BUSPOWER_DIF_ONLY;
                         break;
                 default:
-                        cx231xx_info("bad config in buspower!!!!\n");
-                        cx231xx_info("config_info=%x\n",
-                                     (config_info & BUSPOWER_MASK));
+                        dev_err(dev->dev,
+                                "bad config in buspower!!!!\nconfig_info=%x\n",
+                                config_info & BUSPOWER_MASK);
                         return 1;
                 }
         } else {                /* self-power */
@@ -768,9 +768,9 @@ int initialize_cx231xx(struct cx231xx *dev)
                         _current_scenario_idx = INDEX_SELFPOWER_COMPRESSOR;
                         break;
                 default:
-                        cx231xx_info("bad senario!!!!!\n");
-                        cx231xx_info("config_info=%x\n",
-                                     (config_info & SELFPOWER_MASK));
+                        dev_err(dev->dev,
+                                "bad senario!!!!!\nconfig_info=%x\n",
+                                config_info & SELFPOWER_MASK);
                         return -ENODEV;
                 }
         }
@@ -781,18 +781,29 @@ int initialize_cx231xx(struct cx231xx *dev)
                    sizeof(struct pcb_config));
 
         if (pcb_debug) {
-                cx231xx_info("SC(0x00) register = 0x%x\n", config_info);
-                cx231xx_info("scenario %d\n",
-                            (dev->current_pcb_config.index) + 1);
-                cx231xx_info("type=%x\n", dev->current_pcb_config.type);
-                cx231xx_info("mode=%x\n", dev->current_pcb_config.mode);
-                cx231xx_info("speed=%x\n", dev->current_pcb_config.speed);
-                cx231xx_info("ts1_source=%x\n",
-                             dev->current_pcb_config.ts1_source);
-                cx231xx_info("ts2_source=%x\n",
-                             dev->current_pcb_config.ts2_source);
-                cx231xx_info("analog_source=%x\n",
-                             dev->current_pcb_config.analog_source);
+                dev_info(dev->dev,
+                         "SC(0x00) register = 0x%x\n", config_info);
+                dev_info(dev->dev,
+                         "scenario %d\n",
+                         (dev->current_pcb_config.index) + 1);
+                dev_info(dev->dev,
+                        "type=%x\n",
+                         dev->current_pcb_config.type);
+                dev_info(dev->dev,
+                         "mode=%x\n",
+                         dev->current_pcb_config.mode);
+                dev_info(dev->dev,
+                         "speed=%x\n",
+                         dev->current_pcb_config.speed);
+                dev_info(dev->dev,
+                         "ts1_source=%x\n",
+                         dev->current_pcb_config.ts1_source);
+                dev_info(dev->dev,
+                         "ts2_source=%x\n",
+                         dev->current_pcb_config.ts2_source);
+                dev_info(dev->dev,
+                         "analog_source=%x\n",
+                         dev->current_pcb_config.analog_source);
         }
 
         return 0;
diff --git a/drivers/media/usb/cx231xx/cx231xx-vbi.c b/drivers/media/usb/cx231xx/cx231xx-vbi.c
index c02794274f51..80261ac40208 100644
--- a/drivers/media/usb/cx231xx/cx231xx-vbi.c
+++ b/drivers/media/usb/cx231xx/cx231xx-vbi.c
@@ -19,12 +19,12 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/bitmap.h>
-#include <linux/usb.h>
 #include <linux/i2c.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>
@@ -35,7 +35,6 @@
 #include <media/msp3400.h>
 #include <media/tuner.h>
 
-#include "cx231xx.h"
 #include "cx231xx-vbi.h"
 
 static inline void print_err_status(struct cx231xx *dev, int packet, int status)
@@ -69,11 +68,12 @@ static inline void print_err_status(struct cx231xx *dev, int packet, int status)
                 break;
         }
         if (packet < 0) {
-                cx231xx_err("URB status %d [%s].\n", status,
-                            errmsg);
+                dev_err(dev->dev,
+                        "URB status %d [%s].\n", status, errmsg);
         } else {
-                cx231xx_err("URB packet %d, status %d [%s].\n",
-                            packet, status, errmsg);
+                dev_err(dev->dev,
+                        "URB packet %d, status %d [%s].\n",
+                        packet, status, errmsg);
         }
 }
 
@@ -316,8 +316,8 @@ static void cx231xx_irq_vbi_callback(struct urb *urb)
         case -ESHUTDOWN:
                 return;
         default:                /* error */
-                cx231xx_err("urb completition error %d.\n",
-                            urb->status);
+                dev_err(dev->dev,
+                        "urb completition error %d.\n", urb->status);
                 break;
         }
 
@@ -331,8 +331,8 @@ static void cx231xx_irq_vbi_callback(struct urb *urb)
 
         urb->status = usb_submit_urb(urb, GFP_ATOMIC);
         if (urb->status) {
-                cx231xx_err("urb resubmit failed (error=%i)\n",
-                            urb->status);
+                dev_err(dev->dev, "urb resubmit failed (error=%i)\n",
+                        urb->status);
         }
 }
 
@@ -344,7 +344,7 @@ void cx231xx_uninit_vbi_isoc(struct cx231xx *dev)
         struct urb *urb;
         int i;
 
-        cx231xx_info("called cx231xx_uninit_vbi_isoc\n");
+        dev_dbg(dev->dev, "called cx231xx_uninit_vbi_isoc\n");
 
         dev->vbi_mode.bulk_ctl.nfields = -1;
         for (i = 0; i < dev->vbi_mode.bulk_ctl.num_bufs; i++) {
@@ -393,7 +393,7 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
         struct urb *urb;
         int rc;
 
-        cx231xx_info("called cx231xx_vbi_isoc\n");
+        dev_dbg(dev->dev, "called cx231xx_vbi_isoc\n");
 
         /* De-allocates all pending stuff */
         cx231xx_uninit_vbi_isoc(dev);
@@ -419,14 +419,16 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
         dev->vbi_mode.bulk_ctl.urb = kzalloc(sizeof(void *) * num_bufs,
                                              GFP_KERNEL);
         if (!dev->vbi_mode.bulk_ctl.urb) {
-                cx231xx_errdev("cannot alloc memory for usb buffers\n");
+                dev_err(dev->dev,
+                        "cannot alloc memory for usb buffers\n");
                 return -ENOMEM;
         }
 
         dev->vbi_mode.bulk_ctl.transfer_buffer =
             kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
         if (!dev->vbi_mode.bulk_ctl.transfer_buffer) {
-                cx231xx_errdev("cannot allocate memory for usbtransfer\n");
+                dev_err(dev->dev,
+                        "cannot allocate memory for usbtransfer\n");
                 kfree(dev->vbi_mode.bulk_ctl.urb);
                 return -ENOMEM;
         }
@@ -441,7 +443,8 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
 
                 urb = usb_alloc_urb(0, GFP_KERNEL);
                 if (!urb) {
-                        cx231xx_err("cannot alloc bulk_ctl.urb %i\n", i);
+                        dev_err(dev->dev,
+                                "cannot alloc bulk_ctl.urb %i\n", i);
                         cx231xx_uninit_vbi_isoc(dev);
                         return -ENOMEM;
                 }
@@ -451,9 +454,10 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
                 dev->vbi_mode.bulk_ctl.transfer_buffer[i] =
                     kzalloc(sb_size, GFP_KERNEL);
                 if (!dev->vbi_mode.bulk_ctl.transfer_buffer[i]) {
-                        cx231xx_err("unable to allocate %i bytes for transfer"
-                                    " buffer %i%s\n", sb_size, i,
-                                    in_interrupt() ? " while in int" : "");
+                        dev_err(dev->dev,
+                                "unable to allocate %i bytes for transfer buffer %i%s\n",
+                                sb_size, i,
+                                in_interrupt() ? " while in int" : "");
                         cx231xx_uninit_vbi_isoc(dev);
                         return -ENOMEM;
                 }
@@ -470,8 +474,8 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
         for (i = 0; i < dev->vbi_mode.bulk_ctl.num_bufs; i++) {
                 rc = usb_submit_urb(dev->vbi_mode.bulk_ctl.urb[i], GFP_ATOMIC);
                 if (rc) {
-                        cx231xx_err("submit of urb %i failed (error=%i)\n", i,
-                                    rc);
+                        dev_err(dev->dev,
+                                "submit of urb %i failed (error=%i)\n", i, rc);
                         cx231xx_uninit_vbi_isoc(dev);
                         return rc;
                 }
@@ -522,7 +526,7 @@ static inline void vbi_buffer_filled(struct cx231xx *dev,
                                      struct cx231xx_buffer *buf)
 {
         /* Advice that buffer was filled */
-        /* cx231xx_info("[%p/%d] wakeup\n", buf, buf->vb.i); */
+        /* dev_dbg(dev->dev, "[%p/%d] wakeup\n", buf, buf->vb.i); */
 
         buf->vb.state = VIDEOBUF_DONE;
         buf->vb.field_count++;
@@ -614,7 +618,7 @@ static inline void get_next_vbi_buf(struct cx231xx_dmaqueue *dma_q,
         char *outp;
 
         if (list_empty(&dma_q->active)) {
-                cx231xx_err("No active queue to serve\n");
+                dev_err(dev->dev, "No active queue to serve\n");
                 dev->vbi_mode.bulk_ctl.buf = NULL;
                 *buf = NULL;
                 return;
diff --git a/drivers/media/usb/cx231xx/cx231xx-video.c b/drivers/media/usb/cx231xx/cx231xx-video.c
index 3b3ada6562ca..53ca12c1ff69 100644
--- a/drivers/media/usb/cx231xx/cx231xx-video.c
+++ b/drivers/media/usb/cx231xx/cx231xx-video.c
@@ -22,12 +22,12 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "cx231xx.h"
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/bitmap.h>
-#include <linux/usb.h>
 #include <linux/i2c.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>
@@ -41,10 +41,9 @@
 
 #include "dvb_frontend.h"
 
-#include "cx231xx.h"
 #include "cx231xx-vbi.h"
 
-#define CX231XX_VERSION "0.0.2"
+#define CX231XX_VERSION "0.0.3"
 
 #define DRIVER_AUTHOR   "Srinivasa Deevi <srinivasa.deevi@conexant.com>"
 #define DRIVER_DESC     "Conexant cx231xx based USB video device driver"
@@ -737,8 +736,9 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
                 if (!dev->video_mode.bulk_ctl.num_bufs)
                         urb_init = 1;
         }
-        /*cx231xx_info("urb_init=%d dev->video_mode.max_pkt_size=%d\n",
-                urb_init, dev->video_mode.max_pkt_size);*/
+        dev_dbg(dev->dev,
+                "urb_init=%d dev->video_mode.max_pkt_size=%d\n",
+                urb_init, dev->video_mode.max_pkt_size);
         if (urb_init) {
                 dev->mode_tv = 0;
                 if (dev->USE_ISO)
@@ -809,7 +809,7 @@ void video_mux(struct cx231xx *dev, int index)
 
         cx231xx_set_audio_input(dev, dev->ctl_ainput);
 
-        cx231xx_info("video_mux : %d\n", index);
+        dev_dbg(dev->dev, "video_mux : %d\n", index);
 
         /* do mode control overrides if required */
         cx231xx_do_mode_ctrl_overrides(dev);
@@ -861,7 +861,7 @@ static void res_free(struct cx231xx_fh *fh)
 static int check_dev(struct cx231xx *dev)
 {
         if (dev->state & DEV_DISCONNECTED) {
-                cx231xx_errdev("v4l2 ioctl: device not present\n");
+                dev_err(dev->dev, "v4l2 ioctl: device not present\n");
                 return -ENODEV;
         }
         return 0;
@@ -953,12 +953,13 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                 return -EINVAL;
 
         if (videobuf_queue_is_busy(&fh->vb_vidq)) {
-                cx231xx_errdev("%s queue busy\n", __func__);
+                dev_err(dev->dev, "%s: queue busy\n", __func__);
                 return -EBUSY;
         }
 
         if (dev->stream_on && !fh->stream_on) {
-                cx231xx_errdev("%s device in use by another fh\n", __func__);
+                dev_err(dev->dev,
+                        "%s: device in use by another fh\n", __func__);
                 return -EBUSY;
         }
 
@@ -967,7 +968,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
         dev->height = f->fmt.pix.height;
         dev->format = fmt;
 
-        v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, V4L2_MBUS_FMT_FIXED);
+        v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
         call_all(dev, video, s_mbus_fmt, &mbus_fmt);
         v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt);
 
@@ -1012,7 +1013,7 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
            resolution (since a standard change effects things like the number
            of lines in VACT, etc) */
         memset(&mbus_fmt, 0, sizeof(mbus_fmt));
-        mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
+        mbus_fmt.code = MEDIA_BUS_FMT_FIXED;
         mbus_fmt.width = dev->width;
         mbus_fmt.height = dev->height;
         call_all(dev, video, s_mbus_fmt, &mbus_fmt);
@@ -1176,9 +1177,9 @@ int cx231xx_s_frequency(struct file *file, void *priv,
         int rc;
         u32 if_frequency = 5400000;
 
-        cx231xx_info("Enter vidioc_s_frequency()f->frequency=%d;f->type=%d\n",
-                 f->frequency, f->type);
-        /*cx231xx_info("f->type:  1-radio 2-analogTV 3-digitalTV\n");*/
+        dev_dbg(dev->dev,
+                "Enter vidioc_s_frequency()f->frequency=%d;f->type=%d\n",
+                f->frequency, f->type);
 
         rc = check_dev(dev);
         if (rc < 0)
@@ -1213,13 +1214,14 @@ int cx231xx_s_frequency(struct file *file, void *priv,
                 else if (dev->norm & V4L2_STD_SECAM_LC)
                         if_frequency = 1250000;  /*1.25MHz      */
 
-                cx231xx_info("if_frequency is set to %d\n", if_frequency);
+                dev_dbg(dev->dev,
+                        "if_frequency is set to %d\n", if_frequency);
                 cx231xx_set_Colibri_For_LowIF(dev, if_frequency, 1, 1);
 
                 update_HH_register_after_set_DIF(dev);
         }
 
-        cx231xx_info("Set New FREQUENCY to %d\n", f->frequency);
+        dev_dbg(dev->dev, "Set New FREQUENCY to %d\n", f->frequency);
 
         return rc;
 }
@@ -1523,7 +1525,8 @@ static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
         struct cx231xx *dev = fh->dev;
 
         if (dev->vbi_stream_on && !fh->stream_on) {
-                cx231xx_errdev("%s device in use by another fh\n", __func__);
+                dev_err(dev->dev,
+                        "%s device in use by another fh\n", __func__);
                 return -EBUSY;
         }
         return vidioc_try_fmt_vbi_cap(file, priv, f);
@@ -1642,17 +1645,15 @@ static int cx231xx_v4l2_open(struct file *filp)
 #if 0
         errCode = cx231xx_set_mode(dev, CX231XX_ANALOG_MODE);
         if (errCode < 0) {
-                cx231xx_errdev
-                    ("Device locked on digital mode. Can't open analog\n");
+                dev_err(dev->dev,
+                        "Device locked on digital mode. Can't open analog\n");
                 return -EBUSY;
         }
 #endif
 
         fh = kzalloc(sizeof(struct cx231xx_fh), GFP_KERNEL);
-        if (!fh) {
-                cx231xx_errdev("cx231xx-video.c: Out of memory?!\n");
+        if (!fh)
                 return -ENOMEM;
-        }
         if (mutex_lock_interruptible(&dev->lock)) {
                 kfree(fh);
                 return -ERESTARTSYS;
@@ -1736,8 +1737,8 @@ void cx231xx_release_analog_resources(struct cx231xx *dev)
                 dev->radio_dev = NULL;
         }
         if (dev->vbi_dev) {
-                cx231xx_info("V4L2 device %s deregistered\n",
-                             video_device_node_name(dev->vbi_dev));
+                dev_info(dev->dev, "V4L2 device %s deregistered\n",
+                        video_device_node_name(dev->vbi_dev));
                 if (video_is_registered(dev->vbi_dev))
                         video_unregister_device(dev->vbi_dev);
                 else
@@ -1745,8 +1746,8 @@ void cx231xx_release_analog_resources(struct cx231xx *dev)
                 dev->vbi_dev = NULL;
         }
         if (dev->vdev) {
-                cx231xx_info("V4L2 device %s deregistered\n",
-                             video_device_node_name(dev->vdev));
+                dev_info(dev->dev, "V4L2 device %s deregistered\n",
+                        video_device_node_name(dev->vdev));
 
                 if (dev->board.has_417)
                         cx231xx_417_unregister(dev);
@@ -2080,8 +2081,7 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
 {
         int ret;
 
-        cx231xx_info("%s: v4l2 driver version %s\n",
-                     dev->name, CX231XX_VERSION);
+        dev_info(dev->dev, "v4l2 driver version %s\n", CX231XX_VERSION);
 
         /* set default norm */
         dev->norm = V4L2_STD_PAL;
@@ -2119,7 +2119,7 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
         /* allocate and fill video video_device struct */
         dev->vdev = cx231xx_vdev_init(dev, &cx231xx_video_template, "video");
         if (!dev->vdev) {
-                cx231xx_errdev("cannot allocate video_device.\n");
+                dev_err(dev->dev, "cannot allocate video_device.\n");
                 return -ENODEV;
         }
 
@@ -2128,13 +2128,14 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
         ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
                                     video_nr[dev->devno]);
         if (ret) {
-                cx231xx_errdev("unable to register video device (error=%i).\n",
-                               ret);
+                dev_err(dev->dev,
+                        "unable to register video device (error=%i).\n",
+                        ret);
                 return ret;
         }
 
-        cx231xx_info("%s/0: registered device %s [v4l2]\n",
-                     dev->name, video_device_node_name(dev->vdev));
+        dev_info(dev->dev, "Registered video device %s [v4l2]\n",
+                video_device_node_name(dev->vdev));
 
         /* Initialize VBI template */
         cx231xx_vbi_template = cx231xx_video_template;
@@ -2144,7 +2145,7 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
         dev->vbi_dev = cx231xx_vdev_init(dev, &cx231xx_vbi_template, "vbi");
 
         if (!dev->vbi_dev) {
-                cx231xx_errdev("cannot allocate video_device.\n");
+                dev_err(dev->dev, "cannot allocate video_device.\n");
                 return -ENODEV;
         }
         dev->vbi_dev->ctrl_handler = &dev->ctrl_handler;
@@ -2152,34 +2153,32 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
         ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
                                     vbi_nr[dev->devno]);
         if (ret < 0) {
-                cx231xx_errdev("unable to register vbi device\n");
+                dev_err(dev->dev, "unable to register vbi device\n");
                 return ret;
         }
 
-        cx231xx_info("%s/0: registered device %s\n",
-                     dev->name, video_device_node_name(dev->vbi_dev));
+        dev_info(dev->dev, "Registered VBI device %s\n",
+                video_device_node_name(dev->vbi_dev));
 
         if (cx231xx_boards[dev->model].radio.type == CX231XX_RADIO) {
                 dev->radio_dev = cx231xx_vdev_init(dev, &cx231xx_radio_template,
                                                    "radio");
                 if (!dev->radio_dev) {
-                        cx231xx_errdev("cannot allocate video_device.\n");
+                        dev_err(dev->dev,
+                                "cannot allocate video_device.\n");
                         return -ENODEV;
                 }
                 dev->radio_dev->ctrl_handler = &dev->radio_ctrl_handler;
                 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
                                             radio_nr[dev->devno]);
                 if (ret < 0) {
-                        cx231xx_errdev("can't register radio device\n");
+                        dev_err(dev->dev,
+                                "can't register radio device\n");
                         return ret;
                 }
-                cx231xx_info("Registered radio device as %s\n",
-                             video_device_node_name(dev->radio_dev));
+                dev_info(dev->dev, "Registered radio device as %s\n",
+                        video_device_node_name(dev->radio_dev));
         }
 
-        cx231xx_info("V4L2 device registered as %s and %s\n",
-                     video_device_node_name(dev->vdev),
-                     video_device_node_name(dev->vbi_dev));
-
         return 0;
 }
diff --git a/drivers/media/usb/cx231xx/cx231xx.h b/drivers/media/usb/cx231xx/cx231xx.h
index aeb1bf42b88d..f9e262eb0db9 100644
--- a/drivers/media/usb/cx231xx/cx231xx.h
+++ b/drivers/media/usb/cx231xx/cx231xx.h
@@ -28,6 +28,7 @@
 #include <linux/i2c.h>
 #include <linux/workqueue.h>
 #include <linux/mutex.h>
+#include <linux/usb.h>
 
 #include <media/cx2341x.h>
 
@@ -322,10 +323,11 @@ enum cx231xx_decoder {
 };
 
 enum CX231XX_I2C_MASTER_PORT {
-        I2C_0 = 0,
-        I2C_1 = 1,
-        I2C_2 = 2,
-        I2C_3 = 3
+        I2C_0 = 0,       /* master 0 - internal connection */
+        I2C_1 = 1,       /* master 1 - used with mux */
+        I2C_2 = 2,       /* master 2 */
+        I2C_1_MUX_1 = 3, /* master 1 - port 1 (I2C_DEMOD_EN = 0) */
+        I2C_1_MUX_3 = 4  /* master 1 - port 3 (I2C_DEMOD_EN = 1) */
 };
 
 struct cx231xx_board {
@@ -367,7 +369,6 @@ struct cx231xx_board {
         unsigned int valid:1;
         unsigned int no_alt_vanc:1;
         unsigned int external_av:1;
-        unsigned int dont_use_port_3:1;
 
         unsigned char xclk, i2c_speed;
 
@@ -472,7 +473,6 @@ struct cx231xx_i2c {
 
         /* i2c i/o */
         struct i2c_adapter i2c_adap;
-        struct i2c_client i2c_client;
         u32 i2c_rc;
 
         /* different settings for each bus */
@@ -597,6 +597,7 @@ struct cx231xx {
         char name[30];          /* name (including minor) of the device */
         int model;              /* index in the device_data struct */
         int devno;              /* marks the number of this device */
+        struct device *dev;     /* pointer to USB interface's dev */
 
         struct cx231xx_board board;
 
@@ -609,6 +610,8 @@ struct cx231xx {
         unsigned int has_audio_class:1;
         unsigned int has_alsa_audio:1;
 
+        unsigned int i2c_scan_running:1; /* true only during i2c_scan */
+
         struct cx231xx_fmt *format;
 
         struct v4l2_device v4l2_dev;
@@ -628,7 +631,10 @@ struct cx231xx {
 
         /* I2C adapters: Master 1 & 2 (External) & Master 3 (Internal only) */
         struct cx231xx_i2c i2c_bus[3];
+        struct i2c_adapter *i2c_mux_adap[2];
+
         unsigned int xc_fw_load_done:1;
+        unsigned int port_3_switch_enabled:1;
         /* locks */
         struct mutex gpio_i2c_lock;
         struct mutex i2c_lock;
@@ -751,9 +757,12 @@ int cx231xx_set_analog_freq(struct cx231xx *dev, u32 freq);
 int cx231xx_reset_analog_tuner(struct cx231xx *dev);
 
 /* Provided by cx231xx-i2c.c */
-void cx231xx_do_i2c_scan(struct cx231xx *dev, struct i2c_client *c);
+void cx231xx_do_i2c_scan(struct cx231xx *dev, int i2c_port);
 int cx231xx_i2c_register(struct cx231xx_i2c *bus);
 int cx231xx_i2c_unregister(struct cx231xx_i2c *bus);
+int cx231xx_i2c_mux_register(struct cx231xx *dev, int mux_no);
+void cx231xx_i2c_mux_unregister(struct cx231xx *dev, int mux_no);
+struct i2c_adapter *cx231xx_get_i2c_adap(struct cx231xx *dev, int i2c_port);
 
 /* Internal block control functions */
 int cx231xx_read_i2c_master(struct cx231xx *dev, u8 dev_addr, u16 saddr,
@@ -802,7 +811,6 @@ void cx231xx_Setup_AFE_for_LowIF(struct cx231xx *dev);
 void reset_s5h1432_demod(struct cx231xx *dev);
 void cx231xx_dump_HH_reg(struct cx231xx *dev);
 void update_HH_register_after_set_DIF(struct cx231xx *dev);
-void cx231xx_dump_SC_reg(struct cx231xx *dev);
 
 
 
@@ -976,23 +984,6 @@ void cx231xx_ir_exit(struct cx231xx *dev);
 #define cx231xx_ir_exit(dev)    (0)
 #endif
 
-
-/* printk macros */
-
-#define cx231xx_err(fmt, arg...) do {\
-        printk(KERN_ERR fmt , ##arg); } while (0)
-
-#define cx231xx_errdev(fmt, arg...) do {\
-        printk(KERN_ERR "%s: "fmt,\
-                        dev->name , ##arg); } while (0)
-
-#define cx231xx_info(fmt, arg...) do {\
-        printk(KERN_INFO "%s: "fmt,\
-                        dev->name , ##arg); } while (0)
-#define cx231xx_warn(fmt, arg...) do {\
-        printk(KERN_WARNING "%s: "fmt,\
-                        dev->name , ##arg); } while (0)
-
 static inline unsigned int norm_maxw(struct cx231xx *dev)
 {
         if (dev->board.max_range_640_480)
diff --git a/drivers/media/usb/dvb-usb-v2/Kconfig b/drivers/media/usb/dvb-usb-v2/Kconfig
index 5b34323ad207..0982e734fab5 100644
--- a/drivers/media/usb/dvb-usb-v2/Kconfig
+++ b/drivers/media/usb/dvb-usb-v2/Kconfig
@@ -145,6 +145,9 @@ config DVB_USB_DVBSKY
         tristate "DVBSky USB support"
         depends on DVB_USB_V2
         select DVB_M88DS3103 if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_SI2168 if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_M88TS2022 if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_SI2157 if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_SP2 if MEDIA_SUBDRV_AUTOSELECT
         help
           Say Y here to support the USB receivers from DVBSky.
diff --git a/drivers/media/usb/dvb-usb-v2/af9035.c b/drivers/media/usb/dvb-usb-v2/af9035.c
index 1896ab218b11..80a29f5377ea 100644
--- a/drivers/media/usb/dvb-usb-v2/af9035.c
+++ b/drivers/media/usb/dvb-usb-v2/af9035.c
@@ -1171,6 +1171,7 @@ static int it930x_frontend_attach(struct dvb_usb_adapter *adap)
 
         dev_dbg(&d->udev->dev, "adap->id=%d\n", adap->id);
 
+        memset(&si2168_config, 0, sizeof(si2168_config));
         si2168_config.i2c_adapter = &adapter;
         si2168_config.fe = &adap->fe[0];
         si2168_config.ts_mode = SI2168_TS_SERIAL;
diff --git a/drivers/media/usb/dvb-usb-v2/dvbsky.c b/drivers/media/usb/dvb-usb-v2/dvbsky.c
index 34688c89df11..9b5add4499e3 100644
--- a/drivers/media/usb/dvb-usb-v2/dvbsky.c
+++ b/drivers/media/usb/dvb-usb-v2/dvbsky.c
@@ -21,10 +21,17 @@
 #include "dvb_usb.h"
 #include "m88ds3103.h"
 #include "m88ts2022.h"
+#include "sp2.h"
+#include "si2168.h"
+#include "si2157.h"
 
 #define DVBSKY_MSG_DELAY        0/*2000*/
 #define DVBSKY_BUF_LEN  64
 
+static int dvb_usb_dvbsky_disable_rc;
+module_param_named(disable_rc, dvb_usb_dvbsky_disable_rc, int, 0644);
+MODULE_PARM_DESC(disable_rc, "Disable inbuilt IR receiver.");
+
 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 
 struct dvbsky_state {
@@ -32,7 +39,9 @@ struct dvbsky_state {
         u8 ibuf[DVBSKY_BUF_LEN];
         u8 obuf[DVBSKY_BUF_LEN];
         u8 last_lock;
+        struct i2c_client *i2c_client_demod;
         struct i2c_client *i2c_client_tuner;
+        struct i2c_client *i2c_client_ci;
 
         /* fe hook functions*/
         int (*fe_set_voltage)(struct dvb_frontend *fe,
@@ -96,8 +105,7 @@ static int dvbsky_gpio_ctrl(struct dvb_usb_device *d, u8 gport, u8 value)
         obuf[2] = value;
         ret = dvbsky_usb_generic_rw(d, obuf, 3, ibuf, 1);
         if (ret)
-                dev_err(&d->udev->dev, "%s: %s() failed=%d\n",
-                        KBUILD_MODNAME, __func__, ret);
+                dev_err(&d->udev->dev, "failed=%d\n", ret);
         return ret;
 }
 
@@ -114,7 +122,7 @@ static int dvbsky_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 
         if (num > 2) {
                 dev_err(&d->udev->dev,
-                "dvbsky_usb: too many i2c messages[%d] than 2.", num);
+                "too many i2c messages[%d], max 2.", num);
                 ret = -EOPNOTSUPP;
                 goto i2c_error;
         }
@@ -122,7 +130,7 @@ static int dvbsky_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
         if (num == 1) {
                 if (msg[0].len > 60) {
                         dev_err(&d->udev->dev,
-                        "dvbsky_usb: too many i2c bytes[%d] than 60.",
+                        "too many i2c bytes[%d], max 60.",
                         msg[0].len);
                         ret = -EOPNOTSUPP;
                         goto i2c_error;
@@ -136,8 +144,7 @@ static int dvbsky_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
                         ret = dvbsky_usb_generic_rw(d, obuf, 4,
                                         ibuf, msg[0].len + 1);
                         if (ret)
-                                dev_err(&d->udev->dev, "%s: %s() failed=%d\n",
-                                        KBUILD_MODNAME, __func__, ret);
+                                dev_err(&d->udev->dev, "failed=%d\n", ret);
                         if (!ret)
                                 memcpy(msg[0].buf, &ibuf[1], msg[0].len);
                 } else {
@@ -149,13 +156,12 @@ static int dvbsky_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
                         ret = dvbsky_usb_generic_rw(d, obuf,
                                         msg[0].len + 3, ibuf, 1);
                         if (ret)
-                                dev_err(&d->udev->dev, "%s: %s() failed=%d\n",
-                                        KBUILD_MODNAME, __func__, ret);
+                                dev_err(&d->udev->dev, "failed=%d\n", ret);
                 }
         } else {
                 if ((msg[0].len > 60) || (msg[1].len > 60)) {
                         dev_err(&d->udev->dev,
-                        "dvbsky_usb: too many i2c bytes[w-%d][r-%d] than 60.",
+                        "too many i2c bytes[w-%d][r-%d], max 60.",
                         msg[0].len, msg[1].len);
                         ret = -EOPNOTSUPP;
                         goto i2c_error;
@@ -169,8 +175,7 @@ static int dvbsky_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
                 ret = dvbsky_usb_generic_rw(d, obuf,
                         msg[0].len + 4, ibuf, msg[1].len + 1);
                 if (ret)
-                        dev_err(&d->udev->dev, "%s: %s() failed=%d\n",
-                                KBUILD_MODNAME, __func__, ret);
+                        dev_err(&d->udev->dev, "failed=%d\n", ret);
 
                 if (!ret)
                         memcpy(msg[1].buf, &ibuf[1], msg[1].len);
@@ -201,8 +206,7 @@ static int dvbsky_rc_query(struct dvb_usb_device *d)
         obuf[0] = 0x10;
         ret = dvbsky_usb_generic_rw(d, obuf, 1, ibuf, 2);
         if (ret)
-                dev_err(&d->udev->dev, "%s: %s() failed=%d\n",
-                        KBUILD_MODNAME, __func__, ret);
+                dev_err(&d->udev->dev, "failed=%d\n", ret);
         if (ret == 0)
                 code = (ibuf[0] << 8) | ibuf[1];
         if (code != 0xffff) {
@@ -218,6 +222,11 @@ static int dvbsky_rc_query(struct dvb_usb_device *d)
 
 static int dvbsky_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
 {
+        if (dvb_usb_dvbsky_disable_rc) {
+                rc->map_name = NULL;
+                return 0;
+        }
+
         rc->allowed_protos = RC_BIT_RC5;
         rc->query          = dvbsky_rc_query;
         rc->interval       = 300;
@@ -265,8 +274,6 @@ static int dvbsky_read_mac_addr(struct dvb_usb_adapter *adap, u8 mac[6])
         if (i2c_transfer(&d->i2c_adap, msg, 2) == 2)
                 memcpy(mac, ibuf, 6);
 
-        dev_info(&d->udev->dev, "dvbsky_usb MAC address=%pM\n", mac);
-
         return 0;
 }
 
@@ -362,6 +369,300 @@ fail_attach:
         return ret;
 }
 
+static int dvbsky_usb_ci_set_voltage(struct dvb_frontend *fe,
+        fe_sec_voltage_t voltage)
+{
+        struct dvb_usb_device *d = fe_to_d(fe);
+        struct dvbsky_state *state = d_to_priv(d);
+        u8 value;
+
+        if (voltage == SEC_VOLTAGE_OFF)
+                value = 0;
+        else
+                value = 1;
+        dvbsky_gpio_ctrl(d, 0x00, value);
+
+        return state->fe_set_voltage(fe, voltage);
+}
+
+static int dvbsky_ci_ctrl(void *priv, u8 read, int addr,
+                                        u8 data, int *mem)
+{
+        struct dvb_usb_device *d = priv;
+        int ret = 0;
+        u8 command[4], respond[2], command_size, respond_size;
+
+        command[1] = (u8)((addr >> 8) & 0xff); /*high part of address*/
+        command[2] = (u8)(addr & 0xff); /*low part of address*/
+        if (read) {
+                command[0] = 0x71;
+                command_size = 3;
+                respond_size = 2;
+        } else {
+                command[0] = 0x70;
+                command[3] = data;
+                command_size = 4;
+                respond_size = 1;
+        }
+        ret = dvbsky_usb_generic_rw(d, command, command_size,
+                        respond, respond_size);
+        if (ret)
+                goto err;
+        if (read)
+                *mem = respond[1];
+        return ret;
+err:
+        dev_err(&d->udev->dev, "ci control failed=%d\n", ret);
+        return ret;
+}
+
+static const struct m88ds3103_config dvbsky_s960c_m88ds3103_config = {
+        .i2c_addr = 0x68,
+        .clock = 27000000,
+        .i2c_wr_max = 33,
+        .clock_out = 0,
+        .ts_mode = M88DS3103_TS_CI,
+        .ts_clk = 10000,
+        .ts_clk_pol = 1,
+        .agc = 0x99,
+        .lnb_hv_pol = 0,
+        .lnb_en_pol = 1,
+};
+
+static int dvbsky_s960c_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvbsky_state *state = adap_to_priv(adap);
+        struct dvb_usb_device *d = adap_to_d(adap);
+        int ret = 0;
+        /* demod I2C adapter */
+        struct i2c_adapter *i2c_adapter;
+        struct i2c_client *client_tuner, *client_ci;
+        struct i2c_board_info info;
+        struct sp2_config sp2_config;
+        struct m88ts2022_config m88ts2022_config = {
+                        .clock = 27000000,
+                };
+        memset(&info, 0, sizeof(struct i2c_board_info));
+
+        /* attach demod */
+        adap->fe[0] = dvb_attach(m88ds3103_attach,
+                        &dvbsky_s960c_m88ds3103_config,
+                        &d->i2c_adap,
+                        &i2c_adapter);
+        if (!adap->fe[0]) {
+                dev_err(&d->udev->dev, "dvbsky_s960ci_attach fail.\n");
+                ret = -ENODEV;
+                goto fail_attach;
+        }
+
+        /* attach tuner */
+        m88ts2022_config.fe = adap->fe[0];
+        strlcpy(info.type, "m88ts2022", I2C_NAME_SIZE);
+        info.addr = 0x60;
+        info.platform_data = &m88ts2022_config;
+        request_module("m88ts2022");
+        client_tuner = i2c_new_device(i2c_adapter, &info);
+        if (client_tuner == NULL || client_tuner->dev.driver == NULL) {
+                ret = -ENODEV;
+                goto fail_tuner_device;
+        }
+
+        if (!try_module_get(client_tuner->dev.driver->owner)) {
+                ret = -ENODEV;
+                goto fail_tuner_module;
+        }
+
+        /* attach ci controller */
+        memset(&sp2_config, 0, sizeof(sp2_config));
+        sp2_config.dvb_adap = &adap->dvb_adap;
+        sp2_config.priv = d;
+        sp2_config.ci_control = dvbsky_ci_ctrl;
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "sp2", I2C_NAME_SIZE);
+        info.addr = 0x40;
+        info.platform_data = &sp2_config;
+        request_module("sp2");
+        client_ci = i2c_new_device(&d->i2c_adap, &info);
+        if (client_ci == NULL || client_ci->dev.driver == NULL) {
+                ret = -ENODEV;
+                goto fail_ci_device;
+        }
+
+        if (!try_module_get(client_ci->dev.driver->owner)) {
+                ret = -ENODEV;
+                goto fail_ci_module;
+        }
+
+        /* delegate signal strength measurement to tuner */
+        adap->fe[0]->ops.read_signal_strength =
+                        adap->fe[0]->ops.tuner_ops.get_rf_strength;
+
+        /* hook fe: need to resync the slave fifo when signal locks. */
+        state->fe_read_status = adap->fe[0]->ops.read_status;
+        adap->fe[0]->ops.read_status = dvbsky_usb_read_status;
+
+        /* hook fe: LNB off/on is control by Cypress usb chip. */
+        state->fe_set_voltage = adap->fe[0]->ops.set_voltage;
+        adap->fe[0]->ops.set_voltage = dvbsky_usb_ci_set_voltage;
+
+        state->i2c_client_tuner = client_tuner;
+        state->i2c_client_ci = client_ci;
+        return ret;
+fail_ci_module:
+        i2c_unregister_device(client_ci);
+fail_ci_device:
+        module_put(client_tuner->dev.driver->owner);
+fail_tuner_module:
+        i2c_unregister_device(client_tuner);
+fail_tuner_device:
+        dvb_frontend_detach(adap->fe[0]);
+fail_attach:
+        return ret;
+}
+
+static int dvbsky_t680c_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvbsky_state *state = adap_to_priv(adap);
+        struct dvb_usb_device *d = adap_to_d(adap);
+        int ret = 0;
+        struct i2c_adapter *i2c_adapter;
+        struct i2c_client *client_demod, *client_tuner, *client_ci;
+        struct i2c_board_info info;
+        struct si2168_config si2168_config;
+        struct si2157_config si2157_config;
+        struct sp2_config sp2_config;
+
+        /* attach demod */
+        memset(&si2168_config, 0, sizeof(si2168_config));
+        si2168_config.i2c_adapter = &i2c_adapter;
+        si2168_config.fe = &adap->fe[0];
+        si2168_config.ts_mode = SI2168_TS_PARALLEL;
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "si2168", I2C_NAME_SIZE);
+        info.addr = 0x64;
+        info.platform_data = &si2168_config;
+
+        request_module(info.type);
+        client_demod = i2c_new_device(&d->i2c_adap, &info);
+        if (client_demod == NULL ||
+                        client_demod->dev.driver == NULL)
+                goto fail_demod_device;
+        if (!try_module_get(client_demod->dev.driver->owner))
+                goto fail_demod_module;
+
+        /* attach tuner */
+        memset(&si2157_config, 0, sizeof(si2157_config));
+        si2157_config.fe = adap->fe[0];
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "si2157", I2C_NAME_SIZE);
+        info.addr = 0x60;
+        info.platform_data = &si2157_config;
+
+        request_module(info.type);
+        client_tuner = i2c_new_device(i2c_adapter, &info);
+        if (client_tuner == NULL ||
+                        client_tuner->dev.driver == NULL)
+                goto fail_tuner_device;
+        if (!try_module_get(client_tuner->dev.driver->owner))
+                goto fail_tuner_module;
+
+        /* attach ci controller */
+        memset(&sp2_config, 0, sizeof(sp2_config));
+        sp2_config.dvb_adap = &adap->dvb_adap;
+        sp2_config.priv = d;
+        sp2_config.ci_control = dvbsky_ci_ctrl;
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "sp2", I2C_NAME_SIZE);
+        info.addr = 0x40;
+        info.platform_data = &sp2_config;
+
+        request_module(info.type);
+        client_ci = i2c_new_device(&d->i2c_adap, &info);
+
+        if (client_ci == NULL || client_ci->dev.driver == NULL)
+                goto fail_ci_device;
+
+        if (!try_module_get(client_ci->dev.driver->owner))
+                goto fail_ci_module;
+
+        state->i2c_client_demod = client_demod;
+        state->i2c_client_tuner = client_tuner;
+        state->i2c_client_ci = client_ci;
+        return ret;
+fail_ci_module:
+        i2c_unregister_device(client_ci);
+fail_ci_device:
+        module_put(client_tuner->dev.driver->owner);
+fail_tuner_module:
+        i2c_unregister_device(client_tuner);
+fail_tuner_device:
+        module_put(client_demod->dev.driver->owner);
+fail_demod_module:
+        i2c_unregister_device(client_demod);
+fail_demod_device:
+        ret = -ENODEV;
+        return ret;
+}
+
+static int dvbsky_t330_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvbsky_state *state = adap_to_priv(adap);
+        struct dvb_usb_device *d = adap_to_d(adap);
+        int ret = 0;
+        struct i2c_adapter *i2c_adapter;
+        struct i2c_client *client_demod, *client_tuner;
+        struct i2c_board_info info;
+        struct si2168_config si2168_config;
+        struct si2157_config si2157_config;
+
+        /* attach demod */
+        memset(&si2168_config, 0, sizeof(si2168_config));
+        si2168_config.i2c_adapter = &i2c_adapter;
+        si2168_config.fe = &adap->fe[0];
+        si2168_config.ts_mode = SI2168_TS_PARALLEL | 0x40;
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "si2168", I2C_NAME_SIZE);
+        info.addr = 0x64;
+        info.platform_data = &si2168_config;
+
+        request_module(info.type);
+        client_demod = i2c_new_device(&d->i2c_adap, &info);
+        if (client_demod == NULL ||
+                        client_demod->dev.driver == NULL)
+                goto fail_demod_device;
+        if (!try_module_get(client_demod->dev.driver->owner))
+                goto fail_demod_module;
+
+        /* attach tuner */
+        memset(&si2157_config, 0, sizeof(si2157_config));
+        si2157_config.fe = adap->fe[0];
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "si2157", I2C_NAME_SIZE);
+        info.addr = 0x60;
+        info.platform_data = &si2157_config;
+
+        request_module(info.type);
+        client_tuner = i2c_new_device(i2c_adapter, &info);
+        if (client_tuner == NULL ||
+                        client_tuner->dev.driver == NULL)
+                goto fail_tuner_device;
+        if (!try_module_get(client_tuner->dev.driver->owner))
+                goto fail_tuner_module;
+
+        state->i2c_client_demod = client_demod;
+        state->i2c_client_tuner = client_tuner;
+        return ret;
+fail_tuner_module:
+        i2c_unregister_device(client_tuner);
+fail_tuner_device:
+        module_put(client_demod->dev.driver->owner);
+fail_demod_module:
+        i2c_unregister_device(client_demod);
+fail_demod_device:
+        ret = -ENODEV;
+        return ret;
+}
+
 static int dvbsky_identify_state(struct dvb_usb_device *d, const char **name)
 {
         dvbsky_gpio_ctrl(d, 0x04, 1);
@@ -404,6 +705,18 @@ static void dvbsky_exit(struct dvb_usb_device *d)
                 module_put(client->dev.driver->owner);
                 i2c_unregister_device(client);
         }
+        client = state->i2c_client_demod;
+        /* remove I2C demod */
+        if (client) {
+                module_put(client->dev.driver->owner);
+                i2c_unregister_device(client);
+        }
+        client = state->i2c_client_ci;
+        /* remove I2C ci */
+        if (client) {
+                module_put(client->dev.driver->owner);
+                i2c_unregister_device(client);
+        }
 }
 
 /* DVB USB Driver stuff */
@@ -434,9 +747,104 @@ static struct dvb_usb_device_properties dvbsky_s960_props = {
         }
 };
 
+static struct dvb_usb_device_properties dvbsky_s960c_props = {
+        .driver_name = KBUILD_MODNAME,
+        .owner = THIS_MODULE,
+        .adapter_nr = adapter_nr,
+        .size_of_priv = sizeof(struct dvbsky_state),
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+        .generic_bulk_ctrl_endpoint_response = 0x81,
+        .generic_bulk_ctrl_delay = DVBSKY_MSG_DELAY,
+
+        .i2c_algo         = &dvbsky_i2c_algo,
+        .frontend_attach  = dvbsky_s960c_attach,
+        .init             = dvbsky_init,
+        .get_rc_config    = dvbsky_get_rc_config,
+        .streaming_ctrl   = dvbsky_streaming_ctrl,
+        .identify_state   = dvbsky_identify_state,
+        .exit             = dvbsky_exit,
+        .read_mac_address = dvbsky_read_mac_addr,
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .stream = DVB_USB_STREAM_BULK(0x82, 8, 4096),
+                }
+        }
+};
+
+static struct dvb_usb_device_properties dvbsky_t680c_props = {
+        .driver_name = KBUILD_MODNAME,
+        .owner = THIS_MODULE,
+        .adapter_nr = adapter_nr,
+        .size_of_priv = sizeof(struct dvbsky_state),
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+        .generic_bulk_ctrl_endpoint_response = 0x81,
+        .generic_bulk_ctrl_delay = DVBSKY_MSG_DELAY,
+
+        .i2c_algo         = &dvbsky_i2c_algo,
+        .frontend_attach  = dvbsky_t680c_attach,
+        .init             = dvbsky_init,
+        .get_rc_config    = dvbsky_get_rc_config,
+        .streaming_ctrl   = dvbsky_streaming_ctrl,
+        .identify_state   = dvbsky_identify_state,
+        .exit             = dvbsky_exit,
+        .read_mac_address = dvbsky_read_mac_addr,
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .stream = DVB_USB_STREAM_BULK(0x82, 8, 4096),
+                }
+        }
+};
+
+static struct dvb_usb_device_properties dvbsky_t330_props = {
+        .driver_name = KBUILD_MODNAME,
+        .owner = THIS_MODULE,
+        .adapter_nr = adapter_nr,
+        .size_of_priv = sizeof(struct dvbsky_state),
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+        .generic_bulk_ctrl_endpoint_response = 0x81,
+        .generic_bulk_ctrl_delay = DVBSKY_MSG_DELAY,
+
+        .i2c_algo         = &dvbsky_i2c_algo,
+        .frontend_attach  = dvbsky_t330_attach,
+        .init             = dvbsky_init,
+        .get_rc_config    = dvbsky_get_rc_config,
+        .streaming_ctrl   = dvbsky_streaming_ctrl,
+        .identify_state   = dvbsky_identify_state,
+        .exit             = dvbsky_exit,
+        .read_mac_address = dvbsky_read_mac_addr,
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .stream = DVB_USB_STREAM_BULK(0x82, 8, 4096),
+                }
+        }
+};
+
 static const struct usb_device_id dvbsky_id_table[] = {
         { DVB_USB_DEVICE(0x0572, 0x6831,
                 &dvbsky_s960_props, "DVBSky S960/S860", RC_MAP_DVBSKY) },
+        { DVB_USB_DEVICE(0x0572, 0x960c,
+                &dvbsky_s960c_props, "DVBSky S960CI", RC_MAP_DVBSKY) },
+        { DVB_USB_DEVICE(0x0572, 0x680c,
+                &dvbsky_t680c_props, "DVBSky T680CI", RC_MAP_DVBSKY) },
+        { DVB_USB_DEVICE(0x0572, 0x0320,
+                &dvbsky_t330_props, "DVBSky T330", RC_MAP_DVBSKY) },
+        { DVB_USB_DEVICE(USB_VID_TECHNOTREND,
+                USB_PID_TECHNOTREND_TVSTICK_CT2_4400,
+                &dvbsky_t330_props, "TechnoTrend TVStick CT2-4400",
+                RC_MAP_TT_1500) },
+        { DVB_USB_DEVICE(USB_VID_TECHNOTREND,
+                USB_PID_TECHNOTREND_CONNECT_CT2_4650_CI,
+                &dvbsky_t680c_props, "TechnoTrend TT-connect CT2-4650 CI",
+                RC_MAP_TT_1500) },
         { }
 };
 MODULE_DEVICE_TABLE(usb, dvbsky_id_table);
diff --git a/drivers/media/usb/dvb-usb-v2/lmedm04.c b/drivers/media/usb/dvb-usb-v2/lmedm04.c
index 9f2c5459b73a..994de53a574b 100644
--- a/drivers/media/usb/dvb-usb-v2/lmedm04.c
+++ b/drivers/media/usb/dvb-usb-v2/lmedm04.c
@@ -817,20 +817,22 @@ static const char *lme_firmware_switch(struct dvb_usb_device *d, int cold)
         case 0x1122:
                 switch (st->dvb_usb_lme2510_firmware) {
                 default:
-                        st->dvb_usb_lme2510_firmware = TUNER_S0194;
                 case TUNER_S0194:
                         fw_lme = fw_s0194;
                         ret = request_firmware(&fw, fw_lme, &udev->dev);
                         if (ret == 0) {
+                                st->dvb_usb_lme2510_firmware = TUNER_S0194;
                                 cold = 0;
                                 break;
                         }
-                        st->dvb_usb_lme2510_firmware = TUNER_LG;
+                        /* fall through */
                 case TUNER_LG:
                         fw_lme = fw_lg;
                         ret = request_firmware(&fw, fw_lme, &udev->dev);
-                        if (ret == 0)
+                        if (ret == 0) {
+                                st->dvb_usb_lme2510_firmware = TUNER_LG;
                                 break;
+                        }
                         st->dvb_usb_lme2510_firmware = TUNER_DEFAULT;
                         break;
                 }
@@ -838,26 +840,30 @@ static const char *lme_firmware_switch(struct dvb_usb_device *d, int cold)
         case 0x1120:
                 switch (st->dvb_usb_lme2510_firmware) {
                 default:
-                        st->dvb_usb_lme2510_firmware = TUNER_S7395;
                 case TUNER_S7395:
                         fw_lme = fw_c_s7395;
                         ret = request_firmware(&fw, fw_lme, &udev->dev);
                         if (ret == 0) {
+                                st->dvb_usb_lme2510_firmware = TUNER_S7395;
                                 cold = 0;
                                 break;
                         }
-                        st->dvb_usb_lme2510_firmware = TUNER_LG;
+                        /* fall through */
                 case TUNER_LG:
                         fw_lme = fw_c_lg;
                         ret = request_firmware(&fw, fw_lme, &udev->dev);
-                        if (ret == 0)
+                        if (ret == 0) {
+                                st->dvb_usb_lme2510_firmware = TUNER_LG;
                                 break;
-                        st->dvb_usb_lme2510_firmware = TUNER_S0194;
+                        }
+                        /* fall through */
                 case TUNER_S0194:
                         fw_lme = fw_c_s0194;
                         ret = request_firmware(&fw, fw_lme, &udev->dev);
-                        if (ret == 0)
+                        if (ret == 0) {
+                                st->dvb_usb_lme2510_firmware = TUNER_S0194;
                                 break;
+                        }
                         st->dvb_usb_lme2510_firmware = TUNER_DEFAULT;
                         cold = 0;
                         break;
diff --git a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
index 27b1e0397e71..896a225ee011 100644
--- a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
+++ b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
@@ -24,6 +24,9 @@
 
 #include "rtl2830.h"
 #include "rtl2832.h"
+#include "rtl2832_sdr.h"
+#include "mn88472.h"
+#include "mn88473.h"
 
 #include "qt1010.h"
 #include "mt2060.h"
@@ -35,25 +38,6 @@
 #include "tua9001.h"
 #include "r820t.h"
 
-/*
- * RTL2832_SDR module is in staging. That logic is added in order to avoid any
- * hard dependency to drivers/staging/ directory as we want compile mainline
- * driver even whole staging directory is missing.
- */
-#include <media/v4l2-subdev.h>
-
-#if IS_ENABLED(CONFIG_DVB_RTL2832_SDR)
-struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
-        struct i2c_adapter *i2c, const struct rtl2832_config *cfg,
-        struct v4l2_subdev *sd);
-#else
-static inline struct dvb_frontend *rtl2832_sdr_attach(struct dvb_frontend *fe,
-        struct i2c_adapter *i2c, const struct rtl2832_config *cfg,
-        struct v4l2_subdev *sd)
-{
-        return NULL;
-}
-#endif
 
 #ifdef CONFIG_MEDIA_ATTACH
 #define dvb_attach_sdr(FUNCTION, ARGS...) ({ \
@@ -420,6 +404,8 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         struct rtl28xxu_req req_tda18272 = {0x00c0, CMD_I2C_RD, 2, buf};
         struct rtl28xxu_req req_r820t = {0x0034, CMD_I2C_RD, 1, buf};
         struct rtl28xxu_req req_r828d = {0x0074, CMD_I2C_RD, 1, buf};
+        struct rtl28xxu_req req_mn88472 = {0xff38, CMD_I2C_RD, 1, buf};
+        struct rtl28xxu_req req_mn88473 = {0xff38, CMD_I2C_RD, 1, buf};
 
         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 
@@ -449,7 +435,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0xa1) {
                 priv->tuner = TUNER_RTL2832_FC0012;
                 priv->tuner_name = "FC0012";
-                goto found;
+                goto tuner_found;
         }
 
         /* check FC0013 ID register; reg=00 val=a3 */
@@ -457,7 +443,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0xa3) {
                 priv->tuner = TUNER_RTL2832_FC0013;
                 priv->tuner_name = "FC0013";
-                goto found;
+                goto tuner_found;
         }
 
         /* check MT2266 ID register; reg=00 val=85 */
@@ -465,7 +451,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0x85) {
                 priv->tuner = TUNER_RTL2832_MT2266;
                 priv->tuner_name = "MT2266";
-                goto found;
+                goto tuner_found;
         }
 
         /* check FC2580 ID register; reg=01 val=56 */
@@ -473,7 +459,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0x56) {
                 priv->tuner = TUNER_RTL2832_FC2580;
                 priv->tuner_name = "FC2580";
-                goto found;
+                goto tuner_found;
         }
 
         /* check MT2063 ID register; reg=00 val=9e || 9c */
@@ -481,7 +467,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && (buf[0] == 0x9e || buf[0] == 0x9c)) {
                 priv->tuner = TUNER_RTL2832_MT2063;
                 priv->tuner_name = "MT2063";
-                goto found;
+                goto tuner_found;
         }
 
         /* check MAX3543 ID register; reg=00 val=38 */
@@ -489,7 +475,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0x38) {
                 priv->tuner = TUNER_RTL2832_MAX3543;
                 priv->tuner_name = "MAX3543";
-                goto found;
+                goto tuner_found;
         }
 
         /* check TUA9001 ID register; reg=7e val=2328 */
@@ -497,7 +483,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0x23 && buf[1] == 0x28) {
                 priv->tuner = TUNER_RTL2832_TUA9001;
                 priv->tuner_name = "TUA9001";
-                goto found;
+                goto tuner_found;
         }
 
         /* check MXL5007R ID register; reg=d9 val=14 */
@@ -505,7 +491,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0x14) {
                 priv->tuner = TUNER_RTL2832_MXL5007T;
                 priv->tuner_name = "MXL5007T";
-                goto found;
+                goto tuner_found;
         }
 
         /* check E4000 ID register; reg=02 val=40 */
@@ -513,7 +499,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0x40) {
                 priv->tuner = TUNER_RTL2832_E4000;
                 priv->tuner_name = "E4000";
-                goto found;
+                goto tuner_found;
         }
 
         /* check TDA18272 ID register; reg=00 val=c760  */
@@ -521,7 +507,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && (buf[0] == 0xc7 || buf[1] == 0x60)) {
                 priv->tuner = TUNER_RTL2832_TDA18272;
                 priv->tuner_name = "TDA18272";
-                goto found;
+                goto tuner_found;
         }
 
         /* check R820T ID register; reg=00 val=69 */
@@ -529,7 +515,7 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0x69) {
                 priv->tuner = TUNER_RTL2832_R820T;
                 priv->tuner_name = "R820T";
-                goto found;
+                goto tuner_found;
         }
 
         /* check R828D ID register; reg=00 val=69 */
@@ -537,13 +523,44 @@ static int rtl2832u_read_config(struct dvb_usb_device *d)
         if (ret == 0 && buf[0] == 0x69) {
                 priv->tuner = TUNER_RTL2832_R828D;
                 priv->tuner_name = "R828D";
-                goto found;
+                goto tuner_found;
         }
 
-
-found:
+tuner_found:
         dev_dbg(&d->udev->dev, "%s: tuner=%s\n", __func__, priv->tuner_name);
 
+        /* probe slave demod */
+        if (priv->tuner == TUNER_RTL2832_R828D) {
+                /* power on MN88472 demod on GPIO0 */
+                ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_VAL, 0x01, 0x01);
+                if (ret)
+                        goto err;
+
+                ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x01);
+                if (ret)
+                        goto err;
+
+                ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x01, 0x01);
+                if (ret)
+                        goto err;
+
+                /* check MN88472 answers */
+                ret = rtl28xxu_ctrl_msg(d, &req_mn88472);
+                if (ret == 0 && buf[0] == 0x02) {
+                        dev_dbg(&d->udev->dev, "%s: MN88472 found\n", __func__);
+                        priv->slave_demod = SLAVE_DEMOD_MN88472;
+                        goto demod_found;
+                }
+
+                ret = rtl28xxu_ctrl_msg(d, &req_mn88473);
+                if (ret == 0 && buf[0] == 0x03) {
+                        dev_dbg(&d->udev->dev, "%s: MN88473 found\n", __func__);
+                        priv->slave_demod = SLAVE_DEMOD_MN88473;
+                        goto demod_found;
+                }
+        }
+
+demod_found:
         /* close demod I2C gate */
         ret = rtl28xxu_ctrl_msg(d, &req_gate_close);
         if (ret < 0)
@@ -818,7 +835,66 @@ static int rtl2832u_frontend_attach(struct dvb_usb_adapter *adap)
         /* set fe callback */
         adap->fe[0]->callback = rtl2832u_frontend_callback;
 
+        if (priv->slave_demod) {
+                struct i2c_board_info info = {};
+                struct i2c_client *client;
+
+                /*
+                 * We continue on reduced mode, without DVB-T2/C, using master
+                 * demod, when slave demod fails.
+                 */
+                ret = 0;
+
+                /* attach slave demodulator */
+                if (priv->slave_demod == SLAVE_DEMOD_MN88472) {
+                        struct mn88472_config mn88472_config = {};
+
+                        mn88472_config.fe = &adap->fe[1];
+                        mn88472_config.i2c_wr_max = 22,
+                        strlcpy(info.type, "mn88472", I2C_NAME_SIZE);
+                        info.addr = 0x18;
+                        info.platform_data = &mn88472_config;
+                        request_module(info.type);
+                        client = i2c_new_device(priv->demod_i2c_adapter, &info);
+                        if (client == NULL || client->dev.driver == NULL) {
+                                priv->slave_demod = SLAVE_DEMOD_NONE;
+                                goto err_slave_demod_failed;
+                        }
+
+                        if (!try_module_get(client->dev.driver->owner)) {
+                                i2c_unregister_device(client);
+                                priv->slave_demod = SLAVE_DEMOD_NONE;
+                                goto err_slave_demod_failed;
+                        }
+
+                        priv->i2c_client_slave_demod = client;
+                } else {
+                        struct mn88473_config mn88473_config = {};
+
+                        mn88473_config.fe = &adap->fe[1];
+                        mn88473_config.i2c_wr_max = 22,
+                        strlcpy(info.type, "mn88473", I2C_NAME_SIZE);
+                        info.addr = 0x18;
+                        info.platform_data = &mn88473_config;
+                        request_module(info.type);
+                        client = i2c_new_device(priv->demod_i2c_adapter, &info);
+                        if (client == NULL || client->dev.driver == NULL) {
+                                priv->slave_demod = SLAVE_DEMOD_NONE;
+                                goto err_slave_demod_failed;
+                        }
+
+                        if (!try_module_get(client->dev.driver->owner)) {
+                                i2c_unregister_device(client);
+                                priv->slave_demod = SLAVE_DEMOD_NONE;
+                                goto err_slave_demod_failed;
+                        }
+
+                        priv->i2c_client_slave_demod = client;
+                }
+        }
+
         return 0;
+err_slave_demod_failed:
 err:
         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
         return ret;
@@ -984,7 +1060,7 @@ static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap)
                                 break;
                         }
 
-                        priv->client = client;
+                        priv->i2c_client_tuner = client;
                         sd = i2c_get_clientdata(client);
                         i2c_set_adapdata(i2c_adap_internal, d);
 
@@ -1024,32 +1100,30 @@ static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap)
                                 &rtl28xxu_rtl2832_r820t_config, NULL);
                 break;
         case TUNER_RTL2832_R828D:
-                /* power off mn88472 demod on GPIO0 */
-                ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_VAL, 0x00, 0x01);
-                if (ret)
-                        goto err;
-
-                ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x01);
-                if (ret)
-                        goto err;
-
-                ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x01, 0x01);
-                if (ret)
-                        goto err;
-
-                fe = dvb_attach(r820t_attach, adap->fe[0], &d->i2c_adap,
+                fe = dvb_attach(r820t_attach, adap->fe[0],
+                                priv->demod_i2c_adapter,
                                 &rtl2832u_r828d_config);
-
-                /* Use tuner to get the signal strength */
                 adap->fe[0]->ops.read_signal_strength =
                                 adap->fe[0]->ops.tuner_ops.get_rf_strength;
+
+                if (adap->fe[1]) {
+                        fe = dvb_attach(r820t_attach, adap->fe[1],
+                                        priv->demod_i2c_adapter,
+                                        &rtl2832u_r828d_config);
+                        adap->fe[1]->ops.read_signal_strength =
+                                        adap->fe[1]->ops.tuner_ops.get_rf_strength;
+                }
+
+                /* attach SDR */
+                dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap,
+                                &rtl28xxu_rtl2832_r820t_config, NULL);
                 break;
         default:
                 dev_err(&d->udev->dev, "%s: unknown tuner=%d\n", KBUILD_MODNAME,
                                 priv->tuner);
         }
 
-        if (fe == NULL && priv->client == NULL) {
+        if (fe == NULL && priv->i2c_client_tuner == NULL) {
                 ret = -ENODEV;
                 goto err;
         }
@@ -1097,11 +1171,19 @@ err:
 static void rtl28xxu_exit(struct dvb_usb_device *d)
 {
         struct rtl28xxu_priv *priv = d->priv;
-        struct i2c_client *client = priv->client;
+        struct i2c_client *client;
 
         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 
         /* remove I2C tuner */
+        client = priv->i2c_client_tuner;
+        if (client) {
+                module_put(client->dev.driver->owner);
+                i2c_unregister_device(client);
+        }
+
+        /* remove I2C slave demod */
+        client = priv->i2c_client_slave_demod;
         if (client) {
                 module_put(client->dev.driver->owner);
                 i2c_unregister_device(client);
@@ -1201,13 +1283,6 @@ static int rtl2832u_power_ctrl(struct dvb_usb_device *d, int onoff)
                 if (ret)
                         goto err;
 
-                mdelay(5);
-
-                /* enable ADC */
-                ret = rtl28xx_wr_reg_mask(d, SYS_DEMOD_CTL, 0x48, 0x48);
-                if (ret)
-                        goto err;
-
                 /* streaming EP: clear stall & reset */
                 ret = rtl28xx_wr_regs(d, USB_EPA_CTL, "\x00\x00", 2);
                 if (ret)
@@ -1222,11 +1297,6 @@ static int rtl2832u_power_ctrl(struct dvb_usb_device *d, int onoff)
                 if (ret)
                         goto err;
 
-                /* disable ADC */
-                ret = rtl28xx_wr_reg_mask(d, SYS_DEMOD_CTL, 0x00, 0x48);
-                if (ret)
-                        goto err;
-
                 /* disable PLL */
                 ret = rtl28xx_wr_reg_mask(d, SYS_DEMOD_CTL, 0x00, 0x80);
                 if (ret)
@@ -1244,6 +1314,38 @@ err:
         return ret;
 }
 
+static int rtl2832u_frontend_ctrl(struct dvb_frontend *fe, int onoff)
+{
+        struct dvb_usb_device *d = fe_to_d(fe);
+        struct dvb_usb_adapter *adap = fe_to_adap(fe);
+        int ret;
+        u8 val;
+
+        dev_dbg(&d->udev->dev, "%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
+
+        /* control internal demod ADC */
+        if (fe->id == 0 && onoff)
+                val = 0x48; /* enable ADC */
+        else
+                val = 0x00; /* disable ADC */
+
+        ret = rtl28xx_wr_reg_mask(d, SYS_DEMOD_CTL, val, 0x48);
+        if (ret)
+                goto err;
+
+        /* bypass slave demod TS through master demod */
+        if (fe->id == 1 && onoff) {
+                ret = rtl2832_enable_external_ts_if(adap->fe[0]);
+                if (ret)
+                        goto err;
+        }
+
+        return 0;
+err:
+        dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
+        return ret;
+}
+
 #if IS_ENABLED(CONFIG_RC_CORE)
 static int rtl2831u_rc_query(struct dvb_usb_device *d)
 {
@@ -1467,6 +1569,7 @@ static const struct dvb_usb_device_properties rtl2832u_props = {
         .size_of_priv = sizeof(struct rtl28xxu_priv),
 
         .power_ctrl = rtl2832u_power_ctrl,
+        .frontend_ctrl = rtl2832u_frontend_ctrl,
         .i2c_algo = &rtl28xxu_i2c_algo,
         .read_config = rtl2832u_read_config,
         .frontend_attach = rtl2832u_frontend_attach,
diff --git a/drivers/media/usb/dvb-usb-v2/rtl28xxu.h b/drivers/media/usb/dvb-usb-v2/rtl28xxu.h
index a26cab10f382..3e3ea9d64a38 100644
--- a/drivers/media/usb/dvb-usb-v2/rtl28xxu.h
+++ b/drivers/media/usb/dvb-usb-v2/rtl28xxu.h
@@ -57,7 +57,12 @@ struct rtl28xxu_priv {
         u8 page; /* integrated demod active register page */
         struct i2c_adapter *demod_i2c_adapter;
         bool rc_active;
-        struct i2c_client *client;
+        struct i2c_client *i2c_client_tuner;
+        struct i2c_client *i2c_client_slave_demod;
+        #define SLAVE_DEMOD_NONE           0
+        #define SLAVE_DEMOD_MN88472        1
+        #define SLAVE_DEMOD_MN88473        2
+        unsigned int slave_demod:2;
 };
 
 enum rtl28xxu_chip_id {
diff --git a/drivers/media/usb/dvb-usb/Kconfig b/drivers/media/usb/dvb-usb/Kconfig
index 41d3eb922a00..3364200db093 100644
--- a/drivers/media/usb/dvb-usb/Kconfig
+++ b/drivers/media/usb/dvb-usb/Kconfig
@@ -130,7 +130,6 @@ config DVB_USB_CXUSB
 
           Medion MD95700 hybrid USB2.0 device.
           DViCO FusionHDTV (Bluebird) USB2.0 devices
-          TechnoTrend TVStick CT2-4400 and CT2-4650 CI devices
 
 config DVB_USB_M920X
         tristate "Uli m920x DVB-T USB2.0 support"
diff --git a/drivers/media/usb/dvb-usb/af9005.c b/drivers/media/usb/dvb-usb/af9005.c
index 3f4361e48a32..efa782ed6e2d 100644
--- a/drivers/media/usb/dvb-usb/af9005.c
+++ b/drivers/media/usb/dvb-usb/af9005.c
@@ -1081,9 +1081,12 @@ static int __init af9005_usb_module_init(void)
                 err("usb_register failed. (%d)", result);
                 return result;
         }
+#if IS_MODULE(CONFIG_DVB_USB_AF9005) || defined(CONFIG_DVB_USB_AF9005_REMOTE)
+        /* FIXME: convert to todays kernel IR infrastructure */
         rc_decode = symbol_request(af9005_rc_decode);
         rc_keys = symbol_request(rc_map_af9005_table);
         rc_keys_size = symbol_request(rc_map_af9005_table_size);
+#endif
         if (rc_decode == NULL || rc_keys == NULL || rc_keys_size == NULL) {
                 err("af9005_rc_decode function not found, disabling remote");
                 af9005_properties.rc.legacy.rc_query = NULL;
diff --git a/drivers/media/usb/dvb-usb/cxusb.c b/drivers/media/usb/dvb-usb/cxusb.c
index 356abb369c20..0f345b1f9014 100644
--- a/drivers/media/usb/dvb-usb/cxusb.c
+++ b/drivers/media/usb/dvb-usb/cxusb.c
@@ -44,7 +44,6 @@
 #include "atbm8830.h"
 #include "si2168.h"
 #include "si2157.h"
-#include "sp2.h"
 
 /* Max transfer size done by I2C transfer functions */
 #define MAX_XFER_SIZE  80
@@ -147,22 +146,6 @@ static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d,
         }
 }
 
-static int cxusb_tt_ct2_4400_gpio_tuner(struct dvb_usb_device *d, int onoff)
-{
-        u8 o[2], i;
-        int rc;
-
-        o[0] = 0x83;
-        o[1] = onoff;
-        rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
-
-        if (rc) {
-                deb_info("gpio_write failed.\n");
-                return -EIO;
-        }
-        return 0;
-}
-
 /* I2C */
 static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
                           int num)
@@ -524,30 +507,6 @@ static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
         return 0;
 }
 
-static int cxusb_tt_ct2_4400_rc_query(struct dvb_usb_device *d)
-{
-        u8 i[2];
-        int ret;
-        u32 cmd, keycode;
-        u8 rc5_cmd, rc5_addr, rc5_toggle;
-
-        ret = cxusb_ctrl_msg(d, 0x10, NULL, 0, i, 2);
-        if (ret)
-                return ret;
-
-        cmd = (i[0] << 8) | i[1];
-
-        if (cmd != 0xffff) {
-                rc5_cmd = cmd & 0x3F; /* bits 1-6 for command */
-                rc5_addr = (cmd & 0x07C0) >> 6; /* bits 7-11 for address */
-                rc5_toggle = (cmd & 0x0800) >> 11; /* bit 12 for toggle */
-                keycode = (rc5_addr << 8) | rc5_cmd;
-                rc_keydown(d->rc_dev, RC_BIT_RC5, keycode, rc5_toggle);
-        }
-
-        return 0;
-}
-
 static struct rc_map_table rc_map_dvico_mce_table[] = {
         { 0xfe02, KEY_TV },
         { 0xfe0e, KEY_MP3 },
@@ -673,70 +632,6 @@ static struct rc_map_table rc_map_d680_dmb_table[] = {
         { 0x0025, KEY_POWER },
 };
 
-static int cxusb_tt_ct2_4400_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
-{
-        u8 wbuf[2];
-        u8 rbuf[6];
-        int ret;
-        struct i2c_msg msg[] = {
-                {
-                        .addr = 0x51,
-                        .flags = 0,
-                        .buf = wbuf,
-                        .len = 2,
-                }, {
-                        .addr = 0x51,
-                        .flags = I2C_M_RD,
-                        .buf = rbuf,
-                        .len = 6,
-                }
-        };
-
-        wbuf[0] = 0x1e;
-        wbuf[1] = 0x00;
-        ret = cxusb_i2c_xfer(&d->i2c_adap, msg, 2);
-
-        if (ret == 2) {
-                memcpy(mac, rbuf, 6);
-                return 0;
-        } else {
-                if (ret < 0)
-                        return ret;
-                return -EIO;
-        }
-}
-
-static int cxusb_tt_ct2_4650_ci_ctrl(void *priv, u8 read, int addr,
-                                        u8 data, int *mem)
-{
-        struct dvb_usb_device *d = priv;
-        u8 wbuf[3];
-        u8 rbuf[2];
-        int ret;
-
-        wbuf[0] = (addr >> 8) & 0xff;
-        wbuf[1] = addr & 0xff;
-
-        if (read) {
-                ret = cxusb_ctrl_msg(d, CMD_SP2_CI_READ, wbuf, 2, rbuf, 2);
-        } else {
-                wbuf[2] = data;
-                ret = cxusb_ctrl_msg(d, CMD_SP2_CI_WRITE, wbuf, 3, rbuf, 1);
-        }
-
-        if (ret)
-                goto err;
-
-        if (read)
-                *mem = rbuf[1];
-
-        return 0;
-err:
-        deb_info("%s: ci usb write returned %d\n", __func__, ret);
-        return ret;
-
-}
-
 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
 {
         static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x28 };
@@ -1408,36 +1303,34 @@ static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
         return 0;
 }
 
-static int cxusb_tt_ct2_4400_attach(struct dvb_usb_adapter *adap)
+static int cxusb_mygica_t230_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct dvb_usb_device *d = adap->dev;
         struct cxusb_state *st = d->priv;
         struct i2c_adapter *adapter;
         struct i2c_client *client_demod;
         struct i2c_client *client_tuner;
-        struct i2c_client *client_ci;
         struct i2c_board_info info;
         struct si2168_config si2168_config;
         struct si2157_config si2157_config;
-        struct sp2_config sp2_config;
-        u8 o[2], i;
 
-        /* reset the tuner */
-        if (cxusb_tt_ct2_4400_gpio_tuner(d, 0) < 0) {
-                err("clear tuner gpio failed");
-                return -EIO;
-        }
-        msleep(100);
-        if (cxusb_tt_ct2_4400_gpio_tuner(d, 1) < 0) {
-                err("set tuner gpio failed");
-                return -EIO;
-        }
-        msleep(100);
+        /* Select required USB configuration */
+        if (usb_set_interface(d->udev, 0, 0) < 0)
+                err("set interface failed");
+
+        /* Unblock all USB pipes */
+        usb_clear_halt(d->udev,
+                usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
+        usb_clear_halt(d->udev,
+                usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
+        usb_clear_halt(d->udev,
+                usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
 
         /* attach frontend */
         si2168_config.i2c_adapter = &adapter;
         si2168_config.fe = &adap->fe_adap[0].fe;
         si2168_config.ts_mode = SI2168_TS_PARALLEL;
+        si2168_config.ts_clock_inv = 1;
         memset(&info, 0, sizeof(struct i2c_board_info));
         strlcpy(info.type, "si2168", I2C_NAME_SIZE);
         info.addr = 0x64;
@@ -1477,48 +1370,6 @@ static int cxusb_tt_ct2_4400_attach(struct dvb_usb_adapter *adap)
 
         st->i2c_client_tuner = client_tuner;
 
-        /* initialize CI */
-        if (d->udev->descriptor.idProduct ==
-                USB_PID_TECHNOTREND_CONNECT_CT2_4650_CI) {
-
-                memcpy(o, "\xc0\x01", 2);
-                cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
-                msleep(100);
-
-                memcpy(o, "\xc0\x00", 2);
-                cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
-                msleep(100);
-
-                memset(&sp2_config, 0, sizeof(sp2_config));
-                sp2_config.dvb_adap = &adap->dvb_adap;
-                sp2_config.priv = d;
-                sp2_config.ci_control = cxusb_tt_ct2_4650_ci_ctrl;
-                memset(&info, 0, sizeof(struct i2c_board_info));
-                strlcpy(info.type, "sp2", I2C_NAME_SIZE);
-                info.addr = 0x40;
-                info.platform_data = &sp2_config;
-                request_module(info.type);
-                client_ci = i2c_new_device(&d->i2c_adap, &info);
-                if (client_ci == NULL || client_ci->dev.driver == NULL) {
-                        module_put(client_tuner->dev.driver->owner);
-                        i2c_unregister_device(client_tuner);
-                        module_put(client_demod->dev.driver->owner);
-                        i2c_unregister_device(client_demod);
-                        return -ENODEV;
-                }
-                if (!try_module_get(client_ci->dev.driver->owner)) {
-                        i2c_unregister_device(client_ci);
-                        module_put(client_tuner->dev.driver->owner);
-                        i2c_unregister_device(client_tuner);
-                        module_put(client_demod->dev.driver->owner);
-                        i2c_unregister_device(client_demod);
-                        return -ENODEV;
-                }
-
-                st->i2c_client_ci = client_ci;
-
-        }
-
         return 0;
 }
 
@@ -1603,7 +1454,7 @@ static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_prope
 static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
 static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
 static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
-static struct dvb_usb_device_properties cxusb_tt_ct2_4400_properties;
+static struct dvb_usb_device_properties cxusb_mygica_t230_properties;
 
 static int cxusb_probe(struct usb_interface *intf,
                        const struct usb_device_id *id)
@@ -1634,7 +1485,7 @@ static int cxusb_probe(struct usb_interface *intf,
                                      THIS_MODULE, NULL, adapter_nr) ||
             0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
                                      THIS_MODULE, NULL, adapter_nr) ||
-            0 == dvb_usb_device_init(intf, &cxusb_tt_ct2_4400_properties,
+            0 == dvb_usb_device_init(intf, &cxusb_mygica_t230_properties,
                                      THIS_MODULE, NULL, adapter_nr) ||
             0)
                 return 0;
@@ -1648,13 +1499,6 @@ static void cxusb_disconnect(struct usb_interface *intf)
         struct cxusb_state *st = d->priv;
         struct i2c_client *client;
 
-        /* remove I2C client for CI */
-        client = st->i2c_client_ci;
-        if (client) {
-                module_put(client->dev.driver->owner);
-                i2c_unregister_device(client);
-        }
-
         /* remove I2C client for tuner */
         client = st->i2c_client_tuner;
         if (client) {
@@ -1693,8 +1537,7 @@ static struct usb_device_id cxusb_table [] = {
         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
         { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
         { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) },
-        { USB_DEVICE(USB_VID_TECHNOTREND, USB_PID_TECHNOTREND_TVSTICK_CT2_4400) },
-        { USB_DEVICE(USB_VID_TECHNOTREND, USB_PID_TECHNOTREND_CONNECT_CT2_4650_CI) },
+        { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_T230) },
         {}              /* Terminating entry */
 };
 MODULE_DEVICE_TABLE (usb, cxusb_table);
@@ -2341,7 +2184,7 @@ static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
         }
 };
 
-static struct dvb_usb_device_properties cxusb_tt_ct2_4400_properties = {
+static struct dvb_usb_device_properties cxusb_mygica_t230_properties = {
         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 
         .usb_ctrl         = CYPRESS_FX2,
@@ -2349,25 +2192,21 @@ static struct dvb_usb_device_properties cxusb_tt_ct2_4400_properties = {
         .size_of_priv     = sizeof(struct cxusb_state),
 
         .num_adapters = 1,
-        .read_mac_address = cxusb_tt_ct2_4400_read_mac_address,
-
         .adapter = {
                 {
                 .num_frontends = 1,
                 .fe = {{
                         .streaming_ctrl   = cxusb_streaming_ctrl,
-                        /* both frontend and tuner attached in the
-                           same function */
-                        .frontend_attach  = cxusb_tt_ct2_4400_attach,
+                        .frontend_attach  = cxusb_mygica_t230_frontend_attach,
 
                         /* parameter for the MPEG2-data transfer */
                         .stream = {
                                 .type = USB_BULK,
-                                .count = 8,
-                                .endpoint = 0x82,
+                                .count = 5,
+                                .endpoint = 0x02,
                                 .u = {
                                         .bulk = {
-                                                .buffersize = 4096,
+                                                .buffersize = 8192,
                                         }
                                 }
                         },
@@ -2375,28 +2214,25 @@ static struct dvb_usb_device_properties cxusb_tt_ct2_4400_properties = {
                 },
         },
 
-        .i2c_algo = &cxusb_i2c_algo,
+        .power_ctrl       = cxusb_d680_dmb_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
         .generic_bulk_ctrl_endpoint = 0x01,
-        .generic_bulk_ctrl_endpoint_response = 0x81,
 
-        .rc.core = {
-                .rc_codes       = RC_MAP_TT_1500,
-                .allowed_protos = RC_BIT_RC5,
-                .rc_query       = cxusb_tt_ct2_4400_rc_query,
-                .rc_interval    = 150,
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_d680_dmb_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_d680_dmb_table),
+                .rc_query         = cxusb_d680_dmb_rc_query,
         },
 
-        .num_device_descs = 2,
+        .num_device_descs = 1,
         .devices = {
                 {
-                        "TechnoTrend TVStick CT2-4400",
-                        { NULL },
-                        { &cxusb_table[20], NULL },
-                },
-                {
-                        "TechnoTrend TT-connect CT2-4650 CI",
+                        "Mygica T230 DVB-T/T2/C",
                         { NULL },
-                        { &cxusb_table[21], NULL },
+                        { &cxusb_table[22], NULL },
                 },
         }
 };
diff --git a/drivers/media/usb/dvb-usb/cxusb.h b/drivers/media/usb/dvb-usb/cxusb.h
index 29f3e2ea2476..527ff7905e15 100644
--- a/drivers/media/usb/dvb-usb/cxusb.h
+++ b/drivers/media/usb/dvb-usb/cxusb.h
@@ -28,14 +28,10 @@
 #define CMD_ANALOG        0x50
 #define CMD_DIGITAL       0x51
 
-#define CMD_SP2_CI_WRITE  0x70
-#define CMD_SP2_CI_READ   0x71
-
 struct cxusb_state {
         u8 gpio_write_state[3];
         struct i2c_client *i2c_client_demod;
         struct i2c_client *i2c_client_tuner;
-        struct i2c_client *i2c_client_ci;
 };
 
 #endif
diff --git a/drivers/media/usb/dvb-usb/technisat-usb2.c b/drivers/media/usb/dvb-usb/technisat-usb2.c
index 6b0b8b6b9e2a..5801ae7f672a 100644
--- a/drivers/media/usb/dvb-usb/technisat-usb2.c
+++ b/drivers/media/usb/dvb-usb/technisat-usb2.c
@@ -449,6 +449,8 @@ static int technisat_usb2_read_mac_address(struct dvb_usb_device *d,
         return 0;
 }
 
+static struct stv090x_config technisat_usb2_stv090x_config;
+
 /* frontend attach */
 static int technisat_usb2_set_voltage(struct dvb_frontend *fe,
                 fe_sec_voltage_t voltage)
@@ -472,7 +474,8 @@ static int technisat_usb2_set_voltage(struct dvb_frontend *fe,
         }
 
         for (i = 0; i < 3; i++)
-                if (stv090x_set_gpio(fe, i+2, 0, gpio[i], 0) != 0)
+                if (technisat_usb2_stv090x_config.set_gpio(fe, i+2, 0,
+                                                           gpio[i], 0) != 0)
                         return -EREMOTEIO;
         return 0;
 }
diff --git a/drivers/media/usb/em28xx/em28xx-audio.c b/drivers/media/usb/em28xx/em28xx-audio.c
index 957c7ae30efe..44ae1e0661e6 100644
--- a/drivers/media/usb/em28xx/em28xx-audio.c
+++ b/drivers/media/usb/em28xx/em28xx-audio.c
@@ -56,7 +56,7 @@ MODULE_PARM_DESC(debug, "activates debug info");
 #define dprintk(fmt, arg...) do {                                       \
             if (debug)                                                  \
                 printk(KERN_INFO "em28xx-audio %s: " fmt,               \
-                                  __func__, ##arg);             \
+                                  __func__, ##arg);             \
         } while (0)
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
@@ -232,7 +232,6 @@ static struct snd_pcm_hardware snd_em28xx_hw_capture = {
         .channels_max = 2,
         .buffer_bytes_max = 62720 * 8,  /* just about the value in usbaudio.c */
 
-
         /*
          * The period is 12.288 bytes. Allow a 10% of variation along its
          * value, in order to avoid overruns/underruns due to some clock
@@ -361,7 +360,7 @@ static int snd_em28xx_hw_capture_params(struct snd_pcm_substream *substream,
         dprintk("Setting capture parameters\n");
 
         ret = snd_pcm_alloc_vmalloc_buffer(substream,
-                                params_buffer_bytes(hw_params));
+                                           params_buffer_bytes(hw_params));
         if (ret < 0)
                 return ret;
 #if 0
@@ -478,7 +477,7 @@ static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
  * AC97 volume control support
  */
 static int em28xx_vol_info(struct snd_kcontrol *kcontrol,
-                                struct snd_ctl_elem_info *info)
+                           struct snd_ctl_elem_info *info)
 {
         struct em28xx *dev = snd_kcontrol_chip(kcontrol);
 
@@ -494,7 +493,7 @@ static int em28xx_vol_info(struct snd_kcontrol *kcontrol,
 }
 
 static int em28xx_vol_put(struct snd_kcontrol *kcontrol,
-                               struct snd_ctl_elem_value *value)
+                          struct snd_ctl_elem_value *value)
 {
         struct em28xx *dev = snd_kcontrol_chip(kcontrol);
         struct snd_pcm_substream *substream = dev->adev.capture_pcm_substream;
@@ -534,7 +533,7 @@ err:
 }
 
 static int em28xx_vol_get(struct snd_kcontrol *kcontrol,
-                               struct snd_ctl_elem_value *value)
+                          struct snd_ctl_elem_value *value)
 {
         struct em28xx *dev = snd_kcontrol_chip(kcontrol);
         struct snd_pcm_substream *substream = dev->adev.capture_pcm_substream;
@@ -655,7 +654,7 @@ static int em28xx_cvol_new(struct snd_card *card, struct em28xx *dev,
         struct snd_kcontrol *kctl;
         struct snd_kcontrol_new tmp;
 
-        memset (&tmp, 0, sizeof(tmp));
+        memset(&tmp, 0, sizeof(tmp));
         tmp.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         tmp.private_value = id,
         tmp.name  = ctl_name,
@@ -672,7 +671,7 @@ static int em28xx_cvol_new(struct snd_card *card, struct em28xx *dev,
         dprintk("Added control %s for ac97 volume control 0x%04x\n",
                 ctl_name, id);
 
-        memset (&tmp, 0, sizeof(tmp));
+        memset(&tmp, 0, sizeof(tmp));
         tmp.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         tmp.private_value = id,
         tmp.name  = ctl_name,
@@ -731,7 +730,7 @@ static void em28xx_audio_free_urb(struct em28xx *dev)
 
 /* high bandwidth multiplier, as encoded in highspeed endpoint descriptors */
 static int em28xx_audio_ep_packet_size(struct usb_device *udev,
-                                        struct usb_endpoint_descriptor *e)
+                                       struct usb_endpoint_descriptor *e)
 {
         int size = le16_to_cpu(e->wMaxPacketSize);
 
@@ -781,7 +780,7 @@ static int em28xx_audio_urb_init(struct em28xx *dev)
         interval = 1 << (ep->bInterval - 1);
 
         em28xx_info("Endpoint 0x%02x %s on intf %d alt %d interval = %d, size %d\n",
-                     EM28XX_EP_AUDIO, usb_speed_string(dev->udev->speed),
+                    EM28XX_EP_AUDIO, usb_speed_string(dev->udev->speed),
                      dev->ifnum, alt,
                      interval,
                      ep_size);
diff --git a/drivers/media/usb/em28xx/em28xx-camera.c b/drivers/media/usb/em28xx/em28xx-camera.c
index 6d2ea9afd57b..7be661f73930 100644
--- a/drivers/media/usb/em28xx/em28xx-camera.c
+++ b/drivers/media/usb/em28xx/em28xx-camera.c
@@ -27,7 +27,6 @@
 
 #include "em28xx.h"
 
-
 /* Possible i2c addresses of Micron sensors */
 static unsigned short micron_sensor_addrs[] = {
         0xb8 >> 1,   /* MT9V111, MT9V403 */
@@ -43,7 +42,6 @@ static unsigned short omnivision_sensor_addrs[] = {
         I2C_CLIENT_END
 };
 
-
 static struct soc_camera_link camlink = {
         .bus_id = 0,
         .flags = 0,
@@ -51,7 +49,6 @@ static struct soc_camera_link camlink = {
         .unbalanced_power = true,
 };
 
-
 /* FIXME: Should be replaced by a proper mt9m111 driver */
 static int em28xx_initialize_mt9m111(struct em28xx *dev)
 {
@@ -70,7 +67,6 @@ static int em28xx_initialize_mt9m111(struct em28xx *dev)
         return 0;
 }
 
-
 /* FIXME: Should be replaced by a proper mt9m001 driver */
 static int em28xx_initialize_mt9m001(struct em28xx *dev)
 {
@@ -98,7 +94,6 @@ static int em28xx_initialize_mt9m001(struct em28xx *dev)
         return 0;
 }
 
-
 /*
  * Probes Micron sensors with 8 bit address and 16 bit register width
  */
@@ -430,7 +425,7 @@ int em28xx_init_camera(struct em28xx *dev)
                         break;
                 }
 
-                fmt.code = V4L2_MBUS_FMT_YUYV8_2X8;
+                fmt.code = MEDIA_BUS_FMT_YUYV8_2X8;
                 fmt.width = 640;
                 fmt.height = 480;
                 v4l2_subdev_call(subdev, video, s_mbus_fmt, &fmt);
diff --git a/drivers/media/usb/em28xx/em28xx-cards.c b/drivers/media/usb/em28xx/em28xx-cards.c
index 71fa51e7984e..d9704e66b8c9 100644
--- a/drivers/media/usb/em28xx/em28xx-cards.c
+++ b/drivers/media/usb/em28xx/em28xx-cards.c
@@ -64,7 +64,6 @@ module_param(usb_xfer_mode, int, 0444);
 MODULE_PARM_DESC(usb_xfer_mode,
                  "USB transfer mode for frame data (-1 = auto, 0 = prefer isoc, 1 = prefer bulk)");
 
-
 /* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS - 1 */
 static DECLARE_BITMAP(em28xx_devused, EM28XX_MAXBOARDS);
 
@@ -190,8 +189,8 @@ static struct em28xx_reg_seq kworld_a340_digital[] = {
 };
 
 static struct em28xx_reg_seq kworld_ub435q_v3_digital[] = {
-        {EM2874_R80_GPIO_P0_CTRL,       0xff,   0xff,   100},
-        {EM2874_R80_GPIO_P0_CTRL,       0xfe,   0xff,   100},
+        {EM2874_R80_GPIO_P0_CTRL,       0xff,   0xff,   100},
+        {EM2874_R80_GPIO_P0_CTRL,       0xfe,   0xff,   100},
         {EM2874_R80_GPIO_P0_CTRL,       0xbe,   0xff,   100},
         {EM2874_R80_GPIO_P0_CTRL,       0xfe,   0xff,   100},
         {       -1,                     -1,     -1,     -1},
@@ -301,7 +300,6 @@ static struct em28xx_reg_seq dikom_dk300_digital[] = {
         {       -1,             -1,     -1,             -1},
 };
 
-
 /* Reset for the most [digital] boards */
 static struct em28xx_reg_seq leadership_digital[] = {
         {EM2874_R80_GPIO_P0_CTRL,       0x70,   0xff,   10},
@@ -479,6 +477,20 @@ static struct em28xx_reg_seq pctv_292e[] = {
         {-1,                             -1,   -1,     -1},
 };
 
+static struct em28xx_reg_seq terratec_t2_stick_hd[] = {
+        {EM2874_R80_GPIO_P0_CTRL,       0xff,   0xff,   0},
+        {0x0d,                          0xff,   0xff,   600},
+        {EM2874_R80_GPIO_P0_CTRL,       0xfc,   0xff,   10},
+        {EM2874_R80_GPIO_P0_CTRL,       0xbc,   0xff,   100},
+        {EM2874_R80_GPIO_P0_CTRL,       0xfc,   0xff,   100},
+        {EM2874_R80_GPIO_P0_CTRL,       0x00,   0xff,   300},
+        {EM2874_R80_GPIO_P0_CTRL,       0xf8,   0xff,   100},
+        {EM2874_R80_GPIO_P0_CTRL,       0xfc,   0xff,   300},
+        {0x0d,                          0x42,   0xff,   1000},
+        {EM2874_R5F_TS_ENABLE,          0x85,   0xff,   0},
+        {-1,                             -1,   -1,     -1},
+};
+
 /*
  *  Button definitions
  */
@@ -548,7 +560,6 @@ static struct em28xx_led pctv_80e_leds[] = {
         {-1, 0, 0, 0},
 };
 
-
 /*
  *  Board definitions
  */
@@ -1514,7 +1525,7 @@ struct em28xx_board em28xx_boards[] = {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = SAA7115_COMPOSITE2,
                         .amux     = EM28XX_AMUX_VIDEO,
-                        .aout     = EM28XX_AOUT_MONO |  /* I2S */
+                        .aout     = EM28XX_AOUT_MONO |  /* I2S */
                                     EM28XX_AOUT_MASTER, /* Line out pin */
                 }, {
                         .type     = EM28XX_VMUX_COMPOSITE1,
@@ -1536,7 +1547,7 @@ struct em28xx_board em28xx_boards[] = {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = SAA7115_COMPOSITE2,
                         .amux     = EM28XX_AMUX_VIDEO,
-                        .aout     = EM28XX_AOUT_MONO |  /* I2S */
+                        .aout     = EM28XX_AOUT_MONO |  /* I2S */
                                     EM28XX_AOUT_MASTER, /* Line out pin */
                 }, {
                         .type     = EM28XX_VMUX_COMPOSITE1,
@@ -2243,6 +2254,31 @@ struct em28xx_board em28xx_boards[] = {
                 .has_dvb       = 1,
                 .ir_codes      = RC_MAP_PINNACLE_PCTV_HD,
         },
+        [EM2861_BOARD_LEADTEK_VC100] = {
+                .name          = "Leadtek VC100",
+                .tuner_type    = TUNER_ABSENT,  /* Capture only device */
+                .decoder       = EM28XX_TVP5150,
+                .input         = { {
+                        .type     = EM28XX_VMUX_COMPOSITE1,
+                        .vmux     = TVP5150_COMPOSITE1,
+                        .amux     = EM28XX_AMUX_LINE_IN,
+                }, {
+                        .type     = EM28XX_VMUX_SVIDEO,
+                        .vmux     = TVP5150_SVIDEO,
+                        .amux     = EM28XX_AMUX_LINE_IN,
+                } },
+        },
+        /* eb1a:8179 Terratec Cinergy T2 Stick HD.
+         * Empia EM28178, Silicon Labs Si2168, Silicon Labs Si2146 */
+        [EM28178_BOARD_TERRATEC_T2_STICK_HD] = {
+                .name          = "Terratec Cinergy T2 Stick HD",
+                .def_i2c_bus   = 1,
+                .i2c_speed     = EM28XX_I2C_CLK_WAIT_ENABLE | EM28XX_I2C_FREQ_400_KHZ,
+                .tuner_type    = TUNER_ABSENT,
+                .tuner_gpio    = terratec_t2_stick_hd,
+                .has_dvb       = 1,
+                .ir_codes      = RC_MAP_TERRATEC_SLIM_2,
+        },
 };
 EXPORT_SYMBOL_GPL(em28xx_boards);
 
@@ -2424,6 +2460,10 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM28178_BOARD_PCTV_461E },
         { USB_DEVICE(0x2013, 0x025f),
                         .driver_info = EM28178_BOARD_PCTV_292E },
+        { USB_DEVICE(0x0413, 0x6f07),
+                        .driver_info = EM2861_BOARD_LEADTEK_VC100 },
+        { USB_DEVICE(0xeb1a, 0x8179),
+                        .driver_info = EM28178_BOARD_TERRATEC_T2_STICK_HD },
         { },
 };
 MODULE_DEVICE_TABLE(usb, em28xx_id_table);
@@ -2453,6 +2493,7 @@ static struct em28xx_hash_table em28xx_i2c_hash[] = {
         {0x4ba50080, EM2861_BOARD_GADMEI_UTV330PLUS, TUNER_TNF_5335MF},
         {0x6b800080, EM2874_BOARD_LEADERSHIP_ISDBT, TUNER_ABSENT},
 };
+
 /* NOTE: introduce a separate hash table for devices with 16 bit eeproms */
 
 int em28xx_tuner_callback(void *ptr, int component, int command, int arg)
@@ -2695,7 +2736,7 @@ static int em28xx_hint_board(struct em28xx *dev)
                       " insmod option:\n");
         for (i = 0; i < em28xx_bcount; i++) {
                 em28xx_errdev("    card=%d -> %s\n",
-                                i, em28xx_boards[i].name);
+                              i, em28xx_boards[i].name);
         }
         return -1;
 }
@@ -3051,6 +3092,7 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
                         if (le16_to_cpu(dev->udev->descriptor.idVendor)
                                                                     == 0xeb1a) {
                                 __le16 idProd = dev->udev->descriptor.idProduct;
+
                                 if (le16_to_cpu(idProd) == 0x2710)
                                         chip_name = "em2710";
                                 else if (le16_to_cpu(idProd) == 0x2820)
@@ -3139,7 +3181,7 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
                 retval = em28xx_i2c_register(dev, 0, EM28XX_I2C_ALGO_EM28XX);
         if (retval < 0) {
                 em28xx_errdev("%s: em28xx_i2c_register bus 0 - error [%d]!\n",
-                        __func__, retval);
+                              __func__, retval);
                 return retval;
         }
 
@@ -3147,13 +3189,13 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
         if (dev->def_i2c_bus) {
                 if (dev->is_em25xx)
                         retval = em28xx_i2c_register(dev, 1,
-                                                  EM28XX_I2C_ALGO_EM25XX_BUS_B);
+                                                     EM28XX_I2C_ALGO_EM25XX_BUS_B);
                 else
                         retval = em28xx_i2c_register(dev, 1,
-                                                        EM28XX_I2C_ALGO_EM28XX);
+                                                     EM28XX_I2C_ALGO_EM28XX);
                 if (retval < 0) {
                         em28xx_errdev("%s: em28xx_i2c_register bus 1 - error [%d]!\n",
-                                __func__, retval);
+                                      __func__, retval);
 
                         em28xx_i2c_unregister(dev, 0);
 
@@ -3193,7 +3235,7 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 if (nr >= EM28XX_MAXBOARDS) {
                         /* No free device slots */
                         printk(DRIVER_NAME ": Supports only %i em28xx boards.\n",
-                                        EM28XX_MAXBOARDS);
+                               EM28XX_MAXBOARDS);
                         retval = -ENOMEM;
                         goto err_no_slot;
                 }
@@ -3377,6 +3419,7 @@ static int em28xx_usb_probe(struct usb_interface *interface,
         /* Checks if audio is provided by a USB Audio Class interface */
         for (i = 0; i < udev->config->desc.bNumInterfaces; i++) {
                 struct usb_interface *uif = udev->config->interface[i];
+
                 if (uif->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
                         if (has_vendor_audio)
                                 em28xx_err("em28xx: device seems to have vendor AND usb audio class interfaces !\n"
@@ -3487,7 +3530,7 @@ static void em28xx_usb_disconnect(struct usb_interface *interface)
 }
 
 static int em28xx_usb_suspend(struct usb_interface *interface,
-                                pm_message_t message)
+                              pm_message_t message)
 {
         struct em28xx *dev;
 
diff --git a/drivers/media/usb/em28xx/em28xx-core.c b/drivers/media/usb/em28xx/em28xx-core.c
index 901cf2b952d7..86461a708abe 100644
--- a/drivers/media/usb/em28xx/em28xx-core.c
+++ b/drivers/media/usb/em28xx/em28xx-core.c
@@ -75,7 +75,7 @@ MODULE_PARM_DESC(reg_debug, "enable debug messages [URB reg]");
  * reads data from the usb device specifying bRequest
  */
 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
-                                   char *buf, int len)
+                            char *buf, int len)
 {
         int ret;
         int pipe = usb_rcvctrlpipe(dev->udev, 0);
@@ -151,7 +151,7 @@ EXPORT_SYMBOL_GPL(em28xx_read_reg);
  * sends data to the usb device, specifying bRequest
  */
 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
-                                 int len)
+                          int len)
 {
         int ret;
         int pipe = usb_sndctrlpipe(dev->udev, 0);
@@ -213,7 +213,7 @@ EXPORT_SYMBOL_GPL(em28xx_write_reg);
  * the actual value
  */
 int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
-                                 u8 bitmask)
+                          u8 bitmask)
 {
         int oldval;
         u8 newval;
@@ -222,7 +222,7 @@ int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
         if (oldval < 0)
                 return oldval;
 
-        newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
+        newval = (((u8)oldval) & ~bitmask) | (val & bitmask);
 
         return em28xx_write_regs(dev, reg, &newval, 1);
 }
@@ -314,7 +314,7 @@ int em28xx_write_ac97(struct em28xx *dev, u8 reg, u16 val)
         if (ret < 0)
                 return ret;
 
-        ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, (u8 *) &value, 2);
+        ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, (u8 *)&value, 2);
         if (ret < 0)
                 return ret;
 
@@ -361,7 +361,7 @@ static int set_ac97_input(struct em28xx *dev)
 
                 if (ret < 0)
                         em28xx_warn("couldn't setup AC97 register %d\n",
-                                     inputs[i].reg);
+                                    inputs[i].reg);
         }
         return 0;
 }
@@ -445,7 +445,7 @@ int em28xx_audio_analog_set(struct em28xx *dev)
                         ret = em28xx_write_ac97(dev, outputs[i].reg, 0x8000);
                         if (ret < 0)
                                 em28xx_warn("couldn't setup AC97 register %d\n",
-                                     outputs[i].reg);
+                                            outputs[i].reg);
                 }
         }
 
@@ -483,7 +483,7 @@ int em28xx_audio_analog_set(struct em28xx *dev)
                                                         vol);
                         if (ret < 0)
                                 em28xx_warn("couldn't setup AC97 register %d\n",
-                                     outputs[i].reg);
+                                            outputs[i].reg);
                 }
 
                 if (dev->ctl_aoutput & EM28XX_AOUT_PCM_IN) {
@@ -531,7 +531,7 @@ int em28xx_audio_setup(struct em28xx *dev)
         } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) != EM28XX_CHIPCFG_AC97) {
                 dev->int_audio_type = EM28XX_INT_AUDIO_I2S;
                 if (dev->chip_id < CHIP_ID_EM2860 &&
-                    (cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
+                    (cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
                     EM2820_CHIPCFG_I2S_1_SAMPRATE)
                         i2s_samplerates = 1;
                 else if (dev->chip_id >= CHIP_ID_EM2860 &&
@@ -541,7 +541,7 @@ int em28xx_audio_setup(struct em28xx *dev)
                 else
                         i2s_samplerates = 3;
                 em28xx_info("I2S Audio (%d sample rate(s))\n",
-                                               i2s_samplerates);
+                            i2s_samplerates);
                 /* Skip the code that does AC97 vendor detection */
                 dev->audio_mode.ac97 = EM28XX_NO_AC97;
                 goto init_audio;
@@ -614,8 +614,9 @@ const struct em28xx_led *em28xx_find_led(struct em28xx *dev,
 {
         if (dev->board.leds) {
                 u8 k = 0;
+
                 while (dev->board.leds[k].role >= 0 &&
-                               dev->board.leds[k].role < EM28XX_NUM_LED_ROLES) {
+                       dev->board.leds[k].role < EM28XX_NUM_LED_ROLES) {
                         if (dev->board.leds[k].role == role)
                                 return &dev->board.leds[k];
                         k++;
@@ -658,10 +659,12 @@ int em28xx_capture_start(struct em28xx *dev, int start)
 
                         if (dev->mode == EM28XX_ANALOG_MODE)
                                 rc = em28xx_write_reg(dev,
-                                                    EM28XX_R12_VINENABLE, 0x67);
+                                                      EM28XX_R12_VINENABLE,
+                                                      0x67);
                         else
                                 rc = em28xx_write_reg(dev,
-                                                    EM28XX_R12_VINENABLE, 0x37);
+                                                      EM28XX_R12_VINENABLE,
+                                                      0x37);
                         if (rc < 0)
                                 return rc;
 
@@ -815,9 +818,9 @@ void em28xx_uninit_usb_xfer(struct em28xx *dev, enum em28xx_mode mode)
 
                         if (usb_bufs->transfer_buffer[i]) {
                                 usb_free_coherent(dev->udev,
-                                        urb->transfer_buffer_length,
-                                        usb_bufs->transfer_buffer[i],
-                                        urb->transfer_dma);
+                                                  urb->transfer_buffer_length,
+                                                  usb_bufs->transfer_buffer[i],
+                                                  urb->transfer_dma);
                         }
                         usb_free_urb(urb);
                         usb_bufs->urb[i] = NULL;
@@ -889,7 +892,7 @@ int em28xx_alloc_urbs(struct em28xx *dev, enum em28xx_mode mode, int xfer_bulk,
                 if ((xfer_bulk && !dev->analog_ep_bulk) ||
                     (!xfer_bulk && !dev->analog_ep_isoc)) {
                         em28xx_errdev("no endpoint for analog mode and transfer type %d\n",
-                                       xfer_bulk > 0);
+                                      xfer_bulk > 0);
                         return -EINVAL;
                 }
                 usb_bufs = &dev->usb_ctl.analog_bufs;
@@ -988,9 +991,9 @@ EXPORT_SYMBOL_GPL(em28xx_alloc_urbs);
  * Allocate URBs and start IRQ
  */
 int em28xx_init_usb_xfer(struct em28xx *dev, enum em28xx_mode mode,
-                    int xfer_bulk, int num_bufs, int max_pkt_size,
+                         int xfer_bulk, int num_bufs, int max_pkt_size,
                     int packet_multiplier,
-                    int (*urb_data_copy) (struct em28xx *dev, struct urb *urb))
+                    int (*urb_data_copy)(struct em28xx *dev, struct urb *urb))
 {
         struct em28xx_dmaqueue *dma_q = &dev->vidq;
         struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
diff --git a/drivers/media/usb/em28xx/em28xx-dvb.c b/drivers/media/usb/em28xx/em28xx-dvb.c
index 9682c52d67d1..9877b699c6bc 100644
--- a/drivers/media/usb/em28xx/em28xx-dvb.c
+++ b/drivers/media/usb/em28xx/em28xx-dvb.c
@@ -63,7 +63,6 @@ MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION(DRIVER_DESC " - digital TV interface");
 MODULE_VERSION(EM28XX_VERSION);
 
-
 static unsigned int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
@@ -71,7 +70,7 @@ MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 
 #define dprintk(level, fmt, arg...) do {                        \
-if (debug >= level)                                             \
+if (debug >= level)                                             \
         printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \
 } while (0)
 
@@ -99,9 +98,8 @@ struct em28xx_dvb {
         struct i2c_client       *i2c_client_tuner;
 };
 
-
 static inline void print_err_status(struct em28xx *dev,
-                                     int packet, int status)
+                                    int packet, int status)
 {
         char *errmsg = "Unknown";
 
@@ -169,7 +167,7 @@ static inline int em28xx_dvb_urb_data_copy(struct em28xx *dev, struct urb *urb)
                         if (!urb->actual_length)
                                 continue;
                         dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer,
-                                        urb->actual_length);
+                                         urb->actual_length);
                 } else {
                         if (urb->iso_frame_desc[i].status < 0) {
                                 print_err_status(dev, i,
@@ -280,7 +278,6 @@ static int em28xx_stop_feed(struct dvb_demux_feed *feed)
 }
 
 
-
 /* ------------------------------------------------------------------ */
 static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
 {
@@ -740,7 +737,7 @@ static int em28xx_pctv_290e_set_lna(struct dvb_frontend *fe)
         return ret;
 #else
         dev_warn(&dev->udev->dev, "%s: LNA control is disabled (lna=%u)\n",
-                        KBUILD_MODNAME, c->lna);
+                 KBUILD_MODNAME, c->lna);
         return 0;
 #endif
 }
@@ -830,6 +827,7 @@ static struct zl10353_config em28xx_zl10353_no_i2c_gate_dev = {
         .no_tuner = 1,
         .parallel_ts = 1,
 };
+
 static struct qt1010_config em28xx_qt1010_config = {
         .i2c_address = 0x62
 };
@@ -861,7 +859,6 @@ static const struct m88ds3103_config pctv_461e_m88ds3103_config = {
         .agc = 0x99,
 };
 
-
 static struct tda18271_std_map drx_j_std_map = {
         .atsc_6   = { .if_freq = 5000, .agc_mode = 3, .std = 0, .if_lvl = 1,
                       .rfagc_top = 0x37, },
@@ -948,7 +945,7 @@ static int em28xx_register_dvb(struct em28xx_dvb *dvb, struct module *module,
                 result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]);
                 if (result < 0) {
                         printk(KERN_WARNING "%s: 2nd dvb_register_frontend failed (errno = %d)\n",
-                                dev->name, result);
+                               dev->name, result);
                         goto fail_frontend1;
                 }
         }
@@ -1047,7 +1044,7 @@ static void em28xx_unregister_dvb(struct em28xx_dvb *dvb)
 
 static int em28xx_dvb_init(struct em28xx *dev)
 {
-        int result = 0, mfe_shared = 0;
+        int result = 0;
         struct em28xx_dvb *dvb;
 
         if (dev->is_audio_only) {
@@ -1182,7 +1179,8 @@ static int em28xx_dvb_init(struct em28xx *dev)
                                            &dev->i2c_adap[dev->def_i2c_bus]);
                 if (dvb->fe[0] != NULL) {
                         if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
-                                &dev->i2c_adap[dev->def_i2c_bus], 0x61, TUNER_THOMSON_DTT761X)) {
+                                        &dev->i2c_adap[dev->def_i2c_bus],
+                                        0x61, TUNER_THOMSON_DTT761X)) {
                                 result = -EINVAL;
                                 goto out_free;
                         }
@@ -1204,7 +1202,8 @@ static int em28xx_dvb_init(struct em28xx *dev)
                         &dev->i2c_adap[dev->def_i2c_bus], 0x48);
                 if (dvb->fe[0]) {
                         if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
-                                &dev->i2c_adap[dev->def_i2c_bus], 0x60, TUNER_PHILIPS_CU1216L)) {
+                                        &dev->i2c_adap[dev->def_i2c_bus],
+                                        0x60, TUNER_PHILIPS_CU1216L)) {
                                 result = -EINVAL;
                                 goto out_free;
                         }
@@ -1219,7 +1218,7 @@ static int em28xx_dvb_init(struct em28xx *dev)
                         goto out_free;
                 }
                 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
-                        &dev->i2c_adap[dev->def_i2c_bus],
+                                &dev->i2c_adap[dev->def_i2c_bus],
                         &kworld_a340_config)) {
                                 dvb_frontend_detach(dvb->fe[0]);
                                 result = -EINVAL;
@@ -1250,10 +1249,10 @@ static int em28xx_dvb_init(struct em28xx *dev)
 #ifdef CONFIG_GPIOLIB
                         /* enable LNA for DVB-T, DVB-T2 and DVB-C */
                         result = gpio_request_one(dvb->lna_gpio,
-                                        GPIOF_OUT_INIT_LOW, NULL);
+                                                  GPIOF_OUT_INIT_LOW, NULL);
                         if (result)
                                 em28xx_errdev("gpio request failed %d\n",
-                                                result);
+                                              result);
                         else
                                 gpio_free(dvb->lna_gpio);
 
@@ -1266,6 +1265,7 @@ static int em28xx_dvb_init(struct em28xx *dev)
         case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C:
         {
                 struct xc5000_config cfg;
+
                 hauppauge_hvr930c_init(dev);
 
                 dvb->fe[0] = dvb_attach(drxk_attach,
@@ -1339,7 +1339,7 @@ static int em28xx_dvb_init(struct em28xx *dev)
                 /* attach SEC */
                 if (dvb->fe[0])
                         dvb_attach(a8293_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus],
-                                &em28xx_a8293_config);
+                                   &em28xx_a8293_config);
                 break;
         case EM2874_BOARD_DELOCK_61959:
         case EM2874_BOARD_MAXMEDIA_UB425_TC:
@@ -1553,6 +1553,7 @@ static int em28xx_dvb_init(struct em28xx *dev)
                         struct si2157_config si2157_config;
 
                         /* attach demod */
+                        memset(&si2168_config, 0, sizeof(si2168_config));
                         si2168_config.i2c_adapter = &adapter;
                         si2168_config.fe = &dvb->fe[0];
                         si2168_config.ts_mode = SI2168_TS_PARALLEL;
@@ -1603,6 +1604,65 @@ static int em28xx_dvb_init(struct em28xx *dev)
                         dvb->fe[0]->ops.set_lna = em28xx_pctv_292e_set_lna;
                 }
                 break;
+        case EM28178_BOARD_TERRATEC_T2_STICK_HD:
+                {
+                        struct i2c_adapter *adapter;
+                        struct i2c_client *client;
+                        struct i2c_board_info info;
+                        struct si2168_config si2168_config;
+                        struct si2157_config si2157_config;
+
+                        /* attach demod */
+                        memset(&si2168_config, 0, sizeof(si2168_config));
+                        si2168_config.i2c_adapter = &adapter;
+                        si2168_config.fe = &dvb->fe[0];
+                        si2168_config.ts_mode = SI2168_TS_PARALLEL;
+                        memset(&info, 0, sizeof(struct i2c_board_info));
+                        strlcpy(info.type, "si2168", I2C_NAME_SIZE);
+                        info.addr = 0x64;
+                        info.platform_data = &si2168_config;
+                        request_module(info.type);
+                        client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
+                        if (client == NULL || client->dev.driver == NULL) {
+                                result = -ENODEV;
+                                goto out_free;
+                        }
+
+                        if (!try_module_get(client->dev.driver->owner)) {
+                                i2c_unregister_device(client);
+                                result = -ENODEV;
+                                goto out_free;
+                        }
+
+                        dvb->i2c_client_demod = client;
+
+                        /* attach tuner */
+                        memset(&si2157_config, 0, sizeof(si2157_config));
+                        si2157_config.fe = dvb->fe[0];
+                        memset(&info, 0, sizeof(struct i2c_board_info));
+                        strlcpy(info.type, "si2146", I2C_NAME_SIZE);
+                        info.addr = 0x60;
+                        info.platform_data = &si2157_config;
+                        request_module("si2157");
+                        client = i2c_new_device(adapter, &info);
+                        if (client == NULL || client->dev.driver == NULL) {
+                                module_put(dvb->i2c_client_demod->dev.driver->owner);
+                                i2c_unregister_device(dvb->i2c_client_demod);
+                                result = -ENODEV;
+                                goto out_free;
+                        }
+
+                        if (!try_module_get(client->dev.driver->owner)) {
+                                i2c_unregister_device(client);
+                                module_put(dvb->i2c_client_demod->dev.driver->owner);
+                                i2c_unregister_device(dvb->i2c_client_demod);
+                                result = -ENODEV;
+                                goto out_free;
+                        }
+
+                        dvb->i2c_client_tuner = client;
+                }
+                break;
         default:
                 em28xx_errdev("/2: The frontend of your DVB/ATSC card"
                                 " isn't supported yet\n");
@@ -1624,9 +1684,6 @@ static int em28xx_dvb_init(struct em28xx *dev)
         if (result < 0)
                 goto out_free;
 
-        /* MFE lock */
-        dvb->adapter.mfe_shared = mfe_shared;
-
         em28xx_info("DVB extension successfully initialized\n");
 
         kref_get(&dev->ref);
diff --git a/drivers/media/usb/em28xx/em28xx-i2c.c b/drivers/media/usb/em28xx/em28xx-i2c.c
index 1048c1a23fb6..a19b5c8b56ff 100644
--- a/drivers/media/usb/em28xx/em28xx-i2c.c
+++ b/drivers/media/usb/em28xx/em28xx-i2c.c
@@ -593,6 +593,7 @@ static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
         unsigned long l = 0;
         int len = 0;
         unsigned char c;
+
         do {
                 if (len == length) {
                         c = (char)len;
@@ -877,6 +878,7 @@ static struct i2c_client em28xx_client_template = {
  * incomplete list of known devices
  */
 static char *i2c_devs[128] = {
+       [0x1c >> 1] = "lgdt330x",
         [0x3e >> 1] = "remote IR sensor",
         [0x4a >> 1] = "saa7113h",
         [0x52 >> 1] = "drxk",
@@ -949,7 +951,7 @@ int em28xx_i2c_register(struct em28xx *dev, unsigned bus,
         retval = i2c_add_adapter(&dev->i2c_adap[bus]);
         if (retval < 0) {
                 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
-                        __func__, retval);
+                              __func__, retval);
                 return retval;
         }
 
@@ -961,7 +963,7 @@ int em28xx_i2c_register(struct em28xx *dev, unsigned bus,
                 retval = em28xx_i2c_eeprom(dev, bus, &dev->eedata, &dev->eedata_len);
                 if ((retval < 0) && (retval != -ENODEV)) {
                         em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
-                                __func__, retval);
+                                      __func__, retval);
 
                         return retval;
                 }
diff --git a/drivers/media/usb/em28xx/em28xx-input.c b/drivers/media/usb/em28xx/em28xx-input.c
index 23f8f6afa2e0..d8dc03aadfbd 100644
--- a/drivers/media/usb/em28xx/em28xx-input.c
+++ b/drivers/media/usb/em28xx/em28xx-input.c
@@ -459,7 +459,7 @@ static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type)
                 return em2874_ir_change_protocol(rc_dev, rc_type);
         default:
                 printk("Unrecognized em28xx chip id 0x%02x: IR not supported\n",
-                        dev->chip_id);
+                       dev->chip_id);
                 return -EINVAL;
         }
 }
@@ -505,7 +505,7 @@ static void em28xx_query_buttons(struct work_struct *work)
                 /* Check states of the buttons and act */
                 j = 0;
                 while (dev->board.buttons[j].role >= 0 &&
-                         dev->board.buttons[j].role < EM28XX_NUM_BUTTON_ROLES) {
+                       dev->board.buttons[j].role < EM28XX_NUM_BUTTON_ROLES) {
                         struct em28xx_button *button = &dev->board.buttons[j];
                         /* Check if button uses the current address */
                         if (button->reg_r != dev->button_polling_addresses[i]) {
@@ -607,7 +607,7 @@ static void em28xx_init_buttons(struct em28xx *dev)
 
         dev->button_polling_interval = EM28XX_BUTTONS_DEBOUNCED_QUERY_INTERVAL;
         while (dev->board.buttons[i].role >= 0 &&
-                         dev->board.buttons[i].role < EM28XX_NUM_BUTTON_ROLES) {
+               dev->board.buttons[i].role < EM28XX_NUM_BUTTON_ROLES) {
                 struct em28xx_button *button = &dev->board.buttons[i];
                 /* Check if polling address is already on the list */
                 addr_new = true;
@@ -653,11 +653,11 @@ next_button:
         /* Start polling */
         if (dev->num_button_polling_addresses) {
                 memset(dev->button_polling_last_values, 0,
-                                               EM28XX_NUM_BUTTON_ADDRESSES_MAX);
+                       EM28XX_NUM_BUTTON_ADDRESSES_MAX);
                 INIT_DELAYED_WORK(&dev->buttons_query_work,
-                                                          em28xx_query_buttons);
+                                  em28xx_query_buttons);
                 schedule_delayed_work(&dev->buttons_query_work,
-                               msecs_to_jiffies(dev->button_polling_interval));
+                                      msecs_to_jiffies(dev->button_polling_interval));
         }
 }
 
@@ -841,8 +841,7 @@ static int em28xx_ir_fini(struct em28xx *dev)
         if (!ir)
                 goto ref_put;
 
-        if (ir->rc)
-                rc_unregister_device(ir->rc);
+        rc_unregister_device(ir->rc);
 
         kfree(ir->i2c_client);
 
@@ -887,7 +886,7 @@ static int em28xx_ir_resume(struct em28xx *dev)
                 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
         if (dev->num_button_polling_addresses)
                 schedule_delayed_work(&dev->buttons_query_work,
-                               msecs_to_jiffies(dev->button_polling_interval));
+                                      msecs_to_jiffies(dev->button_polling_interval));
         return 0;
 }
 
diff --git a/drivers/media/usb/em28xx/em28xx-reg.h b/drivers/media/usb/em28xx/em28xx-reg.h
index 311fb349dafa..13cbb7f3ea10 100644
--- a/drivers/media/usb/em28xx/em28xx-reg.h
+++ b/drivers/media/usb/em28xx/em28xx-reg.h
@@ -49,7 +49,6 @@
 #define EM28XX_CHIPCFG2_TS_PACKETSIZE_564       0x02
 #define EM28XX_CHIPCFG2_TS_PACKETSIZE_752       0x03
 
-
 /* GPIO/GPO registers */
 #define EM2880_R04_GPO          0x04    /* em2880-em2883 only */
 #define EM2820_R08_GPIO_CTRL    0x08    /* em2820-em2873/83 only */
@@ -68,7 +67,6 @@
 #define EM28XX_I2C_FREQ_400_KHZ         0x01
 #define EM28XX_I2C_FREQ_100_KHZ         0x00
 
-
 #define EM28XX_R0A_CHIPID       0x0a
 #define EM28XX_R0C_USBSUSP      0x0c
 #define   EM28XX_R0C_USBSUSP_SNAPSHOT   0x20 /* 1=button pressed, needs reset */
@@ -157,7 +155,6 @@
 #define EM28XX_OUTFMT_YUV422_Y1UY0V     0x15
 #define EM28XX_OUTFMT_YUV411            0x18
 
-
 #define EM28XX_R28_XMIN 0x28
 #define EM28XX_R29_XMAX 0x29
 #define EM28XX_R2A_YMIN 0x2a
diff --git a/drivers/media/usb/em28xx/em28xx-v4l.h b/drivers/media/usb/em28xx/em28xx-v4l.h
index 432862c20bbf..8dfcb56bf4b3 100644
--- a/drivers/media/usb/em28xx/em28xx-v4l.h
+++ b/drivers/media/usb/em28xx/em28xx-v4l.h
@@ -14,7 +14,6 @@
    GNU General Public License for more details.
  */
 
-
 int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count);
 void em28xx_stop_vbi_streaming(struct vb2_queue *vq);
 extern struct vb2_ops em28xx_vbi_qops;
diff --git a/drivers/media/usb/em28xx/em28xx-vbi.c b/drivers/media/usb/em28xx/em28xx-vbi.c
index 34ee1e03a732..744e7ed743e1 100644
--- a/drivers/media/usb/em28xx/em28xx-vbi.c
+++ b/drivers/media/usb/em28xx/em28xx-vbi.c
@@ -92,7 +92,6 @@ vbi_buffer_queue(struct vb2_buffer *vb)
         spin_unlock_irqrestore(&dev->slock, flags);
 }
 
-
 struct vb2_ops em28xx_vbi_qops = {
         .queue_setup    = vbi_queue_setup,
         .buf_prepare    = vbi_buffer_prepare,
diff --git a/drivers/media/usb/em28xx/em28xx-video.c b/drivers/media/usb/em28xx/em28xx-video.c
index 03d5ece0319c..cf7f58b76292 100644
--- a/drivers/media/usb/em28xx/em28xx-video.c
+++ b/drivers/media/usb/em28xx/em28xx-video.c
@@ -81,7 +81,6 @@ MODULE_DESCRIPTION(DRIVER_DESC " - v4l2 interface");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(EM28XX_VERSION);
 
-
 #define EM25XX_FRMDATAHDR_BYTE1                 0x02
 #define EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE     0x20
 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_END       0x02
@@ -90,7 +89,6 @@ MODULE_VERSION(EM28XX_VERSION);
                                          EM25XX_FRMDATAHDR_BYTE2_FRAME_END |   \
                                          EM25XX_FRMDATAHDR_BYTE2_FRAME_ID)
 
-
 static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
 static unsigned int vbi_nr[]   = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
 static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
@@ -194,9 +192,10 @@ static int em28xx_vbi_supported(struct em28xx *dev)
 static void em28xx_wake_i2c(struct em28xx *dev)
 {
         struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
+
         v4l2_device_call_all(v4l2_dev, 0, core,  reset, 0);
         v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
-                        INPUT(dev->ctl_input)->vmux, 0, 0);
+                             INPUT(dev->ctl_input)->vmux, 0, 0);
         v4l2_device_call_all(v4l2_dev, 0, video, s_stream, 0);
 }
 
@@ -275,7 +274,7 @@ static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
 }
 
 static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
-                                   u16 width, u16 height)
+                                    u16 width, u16 height)
 {
         u8 cwidth = width >> 2;
         u8 cheight = height >> 2;
@@ -283,7 +282,7 @@ static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
         /* NOTE: size limit: 2047x1023 = 2MPix */
 
         em28xx_videodbg("capture area set to (%d,%d): %dx%d\n",
-                       hstart, vstart,
+                        hstart, vstart,
                        ((overflow & 2) << 9 | cwidth << 2),
                        ((overflow & 1) << 10 | cheight << 2));
 
@@ -406,13 +405,13 @@ set_alt:
                 dev->packet_multiplier = EM28XX_BULK_PACKET_MULTIPLIER;
         } else { /* isoc */
                 em28xx_videodbg("minimum isoc packet size: %u (alt=%d)\n",
-                               min_pkt_size, dev->alt);
+                                min_pkt_size, dev->alt);
                 dev->max_pkt_size =
                                   dev->alt_max_pkt_size_isoc[dev->alt];
                 dev->packet_multiplier = EM28XX_NUM_ISOC_PACKETS;
         }
         em28xx_videodbg("setting alternate %d with wMaxPacketSize=%u\n",
-                       dev->alt, dev->max_pkt_size);
+                        dev->alt, dev->max_pkt_size);
         errCode = usb_set_interface(dev->udev, dev->ifnum, dev->alt);
         if (errCode < 0) {
                 em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
@@ -482,7 +481,7 @@ static void em28xx_copy_video(struct em28xx *dev,
 
         if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) {
                 em28xx_isocdbg("Overflow of %zu bytes past buffer end (1)\n",
-                              ((char *)startwrite + lencopy) -
+                               ((char *)startwrite + lencopy) -
                               ((char *)buf->vb_buf + buf->length));
                 remain = (char *)buf->vb_buf + buf->length -
                          (char *)startwrite;
@@ -548,7 +547,7 @@ static void em28xx_copy_vbi(struct em28xx *dev,
 }
 
 static inline void print_err_status(struct em28xx *dev,
-                                     int packet, int status)
+                                    int packet, int status)
 {
         char *errmsg = "Unknown";
 
@@ -831,7 +830,6 @@ static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb)
         return 1;
 }
 
-
 static int get_ressource(enum v4l2_buf_type f_type)
 {
         switch (f_type) {
@@ -1003,6 +1001,7 @@ static void em28xx_stop_streaming(struct vb2_queue *vq)
         }
         while (!list_empty(&vidq->active)) {
                 struct em28xx_buffer *buf;
+
                 buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
                 list_del(&buf->list);
                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
@@ -1033,6 +1032,7 @@ void em28xx_stop_vbi_streaming(struct vb2_queue *vq)
         }
         while (!list_empty(&vbiq->active)) {
                 struct em28xx_buffer *buf;
+
                 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
                 list_del(&buf->list);
                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
@@ -1109,6 +1109,7 @@ static int em28xx_vb2_setup(struct em28xx *dev)
 static void video_mux(struct em28xx *dev, int index)
 {
         struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
+
         dev->ctl_input = index;
         dev->ctl_ainput = INPUT(index)->amux;
         dev->ctl_aoutput = INPUT(index)->aout;
@@ -1117,21 +1118,22 @@ static void video_mux(struct em28xx *dev, int index)
                 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
 
         v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
-                        INPUT(index)->vmux, 0, 0);
+                             INPUT(index)->vmux, 0, 0);
 
         if (dev->board.has_msp34xx) {
                 if (dev->i2s_speed) {
                         v4l2_device_call_all(v4l2_dev, 0, audio,
-                                s_i2s_clock_freq, dev->i2s_speed);
+                                             s_i2s_clock_freq, dev->i2s_speed);
                 }
                 /* Note: this is msp3400 specific */
                 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
-                         dev->ctl_ainput, MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
+                                     dev->ctl_ainput,
+                                     MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
         }
 
         if (dev->board.adecoder != EM28XX_NOADECODER) {
                 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
-                        dev->ctl_ainput, dev->ctl_aoutput, 0);
+                                     dev->ctl_ainput, dev->ctl_aoutput, 0);
         }
 
         em28xx_audio_analog_set(dev);
@@ -1203,7 +1205,7 @@ static const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
 };
 
 static void size_to_scale(struct em28xx *dev,
-                        unsigned int width, unsigned int height,
+                          unsigned int width, unsigned int height,
                         unsigned int *hscale, unsigned int *vscale)
 {
         unsigned int          maxw = norm_maxw(dev);
@@ -1234,7 +1236,7 @@ static void scale_to_size(struct em28xx *dev,
    ------------------------------------------------------------------*/
 
 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
-                                        struct v4l2_format *f)
+                                struct v4l2_format *f)
 {
         struct em28xx         *dev = video_drvdata(file);
         struct em28xx_v4l2    *v4l2 = dev->v4l2;
@@ -1267,7 +1269,7 @@ static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
 }
 
 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
-                        struct v4l2_format *f)
+                                  struct v4l2_format *f)
 {
         struct em28xx         *dev   = video_drvdata(file);
         struct em28xx_v4l2    *v4l2  = dev->v4l2;
@@ -1338,7 +1340,7 @@ static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
 
         /* set new image size */
         size_to_scale(dev, v4l2->width, v4l2->height,
-                           &v4l2->hscale, &v4l2->vscale);
+                      &v4l2->hscale, &v4l2->vscale);
 
         em28xx_resolution_set(dev);
 
@@ -1346,7 +1348,7 @@ static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
 }
 
 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
-                        struct v4l2_format *f)
+                                struct v4l2_format *f)
 {
         struct em28xx *dev = video_drvdata(file);
         struct em28xx_v4l2 *v4l2 = dev->v4l2;
@@ -1401,7 +1403,7 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
         v4l2->width = f.fmt.pix.width;
         v4l2->height = f.fmt.pix.height;
         size_to_scale(dev, v4l2->width, v4l2->height,
-                           &v4l2->hscale, &v4l2->vscale);
+                      &v4l2->hscale, &v4l2->vscale);
 
         em28xx_resolution_set(dev);
         v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
@@ -1422,7 +1424,7 @@ static int vidioc_g_parm(struct file *file, void *priv,
                                                 video, g_parm, p);
         else
                 v4l2_video_std_frame_period(v4l2->norm,
-                                                 &p->parm.capture.timeperframe);
+                                            &p->parm.capture.timeperframe);
 
         return rc;
 }
@@ -1450,7 +1452,7 @@ static const char *iname[] = {
 };
 
 static int vidioc_enum_input(struct file *file, void *priv,
-                                struct v4l2_input *i)
+                             struct v4l2_input *i)
 {
         struct em28xx *dev = video_drvdata(file);
         unsigned int       n;
@@ -1467,7 +1469,7 @@ static int vidioc_enum_input(struct file *file, void *priv,
         strcpy(i->name, iname[INPUT(n)->type]);
 
         if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
-                (EM28XX_VMUX_CABLE == INPUT(n)->type))
+            (EM28XX_VMUX_CABLE == INPUT(n)->type))
                 i->type = V4L2_INPUT_TYPE_TUNER;
 
         i->std = dev->v4l2->vdev->tvnorms;
@@ -1558,7 +1560,7 @@ static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio
 }
 
 static int vidioc_g_tuner(struct file *file, void *priv,
-                                struct v4l2_tuner *t)
+                          struct v4l2_tuner *t)
 {
         struct em28xx *dev = video_drvdata(file);
 
@@ -1572,7 +1574,7 @@ static int vidioc_g_tuner(struct file *file, void *priv,
 }
 
 static int vidioc_s_tuner(struct file *file, void *priv,
-                                const struct v4l2_tuner *t)
+                          const struct v4l2_tuner *t)
 {
         struct em28xx *dev = video_drvdata(file);
 
@@ -1584,7 +1586,7 @@ static int vidioc_s_tuner(struct file *file, void *priv,
 }
 
 static int vidioc_g_frequency(struct file *file, void *priv,
-                                struct v4l2_frequency *f)
+                              struct v4l2_frequency *f)
 {
         struct em28xx         *dev = video_drvdata(file);
         struct em28xx_v4l2    *v4l2 = dev->v4l2;
@@ -1597,7 +1599,7 @@ static int vidioc_g_frequency(struct file *file, void *priv,
 }
 
 static int vidioc_s_frequency(struct file *file, void *priv,
-                                const struct v4l2_frequency *f)
+                              const struct v4l2_frequency *f)
 {
         struct v4l2_frequency  new_freq = *f;
         struct em28xx             *dev  = video_drvdata(file);
@@ -1615,7 +1617,7 @@ static int vidioc_s_frequency(struct file *file, void *priv,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_chip_info(struct file *file, void *priv,
-               struct v4l2_dbg_chip_info *chip)
+                              struct v4l2_dbg_chip_info *chip)
 {
         struct em28xx *dev = video_drvdata(file);
 
@@ -1670,6 +1672,7 @@ static int vidioc_g_register(struct file *file, void *priv,
                 reg->val = ret;
         } else {
                 __le16 val = 0;
+
                 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
                                                    reg->reg, (char *)&val, 2);
                 if (ret < 0)
@@ -1700,9 +1703,8 @@ static int vidioc_s_register(struct file *file, void *priv,
 }
 #endif
 
-
 static int vidioc_querycap(struct file *file, void  *priv,
-                                        struct v4l2_capability *cap)
+                           struct v4l2_capability *cap)
 {
         struct video_device   *vdev = video_devdata(file);
         struct em28xx         *dev  = video_drvdata(file);
@@ -1736,7 +1738,7 @@ static int vidioc_querycap(struct file *file, void  *priv,
 }
 
 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
-                                        struct v4l2_fmtdesc *f)
+                                   struct v4l2_fmtdesc *f)
 {
         if (unlikely(f->index >= ARRAY_SIZE(format)))
                 return -EINVAL;
@@ -2177,9 +2179,10 @@ static unsigned short msp3400_addrs[] = {
 
 /******************************** usb interface ******************************/
 
-static struct video_device *em28xx_vdev_init(struct em28xx *dev,
-                                        const struct video_device *template,
-                                        const char *type_name)
+static struct video_device
+*em28xx_vdev_init(struct em28xx *dev,
+                  const struct video_device *template,
+                  const char *type_name)
 {
         struct video_device *vfd;
 
@@ -2344,21 +2347,24 @@ static int em28xx_v4l2_init(struct em28xx *dev)
 
                 if (dev->board.radio.type)
                         v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
-                                          &dev->i2c_adap[dev->def_i2c_bus],
-                                          "tuner", dev->board.radio_addr, NULL);
+                                            &dev->i2c_adap[dev->def_i2c_bus],
+                                            "tuner", dev->board.radio_addr,
+                                            NULL);
 
                 if (has_demod)
                         v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
-                                &dev->i2c_adap[dev->def_i2c_bus], "tuner",
-                                0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
+                                            &dev->i2c_adap[dev->def_i2c_bus],
+                                            "tuner", 0,
+                                            v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
                 if (tuner_addr == 0) {
                         enum v4l2_i2c_tuner_type type =
                                 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
                         struct v4l2_subdev *sd;
 
                         sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
-                                &dev->i2c_adap[dev->def_i2c_bus], "tuner",
-                                0, v4l2_i2c_tuner_addrs(type));
+                                                 &dev->i2c_adap[dev->def_i2c_bus],
+                                                 "tuner", 0,
+                                                 v4l2_i2c_tuner_addrs(type));
 
                         if (sd)
                                 tuner_addr = v4l2_i2c_subdev_addr(sd);
@@ -2378,20 +2384,20 @@ static int em28xx_v4l2_init(struct em28xx *dev)
         ret = em28xx_audio_setup(dev);
         if (ret < 0) {
                 em28xx_errdev("%s: Error while setting audio - error [%d]!\n",
-                        __func__, ret);
+                              __func__, ret);
                 goto unregister_dev;
         }
         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
-                        V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
+                                  V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
-                        V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
+                                  V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
         } else {
                 /* install the em28xx notify callback */
                 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
-                                em28xx_ctrl_notify, dev);
+                                 em28xx_ctrl_notify, dev);
                 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
-                                em28xx_ctrl_notify, dev);
+                                 em28xx_ctrl_notify, dev);
         }
 
         /* wake i2c devices */
@@ -2518,7 +2524,7 @@ static int em28xx_v4l2_init(struct em28xx *dev)
 
         /* register v4l2 video video_device */
         ret = video_register_device(v4l2->vdev, VFL_TYPE_GRABBER,
-                                       video_nr[dev->devno]);
+                                    video_nr[dev->devno]);
         if (ret) {
                 em28xx_errdev("unable to register video device (error=%i).\n",
                               ret);
diff --git a/drivers/media/usb/em28xx/em28xx.h b/drivers/media/usb/em28xx/em28xx.h
index a21a7463b557..9c7075344109 100644
--- a/drivers/media/usb/em28xx/em28xx.h
+++ b/drivers/media/usb/em28xx/em28xx.h
@@ -141,6 +141,8 @@
 #define EM28178_BOARD_PCTV_461E                   92
 #define EM2874_BOARD_KWORLD_UB435Q_V3             93
 #define EM28178_BOARD_PCTV_292E                   94
+#define EM2861_BOARD_LEADTEK_VC100                95
+#define EM28178_BOARD_TERRATEC_T2_STICK_HD        96
 
 /* Limits minimum and default number of buffers */
 #define EM28XX_MIN_BUF 4
@@ -215,7 +217,6 @@ enum em28xx_mode {
         EM28XX_DIGITAL_MODE,
 };
 
-
 struct em28xx;
 
 struct em28xx_usb_bufs {
@@ -243,11 +244,11 @@ struct em28xx_usb_ctl {
         struct em28xx_usb_bufs          digital_bufs;
 
                 /* Stores already requested buffers */
-        struct em28xx_buffer            *vid_buf;
-        struct em28xx_buffer            *vbi_buf;
+        struct em28xx_buffer    *vid_buf;
+        struct em28xx_buffer    *vbi_buf;
 
                 /* copy data from URB */
-        int (*urb_data_copy) (struct em28xx *dev, struct urb *urb);
+        int (*urb_data_copy)(struct em28xx *dev, struct urb *urb);
 
 };
 
@@ -695,14 +696,14 @@ struct em28xx {
         char urb_buf[URB_MAX_CTRL_SIZE];        /* urb control msg buffer */
 
         /* helper funcs that call usb_control_msg */
-        int (*em28xx_write_regs) (struct em28xx *dev, u16 reg,
-                                        char *buf, int len);
-        int (*em28xx_read_reg) (struct em28xx *dev, u16 reg);
-        int (*em28xx_read_reg_req_len) (struct em28xx *dev, u8 req, u16 reg,
-                                        char *buf, int len);
-        int (*em28xx_write_regs_req) (struct em28xx *dev, u8 req, u16 reg,
-                                      char *buf, int len);
-        int (*em28xx_read_reg_req) (struct em28xx *dev, u8 req, u16 reg);
+        int (*em28xx_write_regs)(struct em28xx *dev, u16 reg,
+                                 char *buf, int len);
+        int (*em28xx_read_reg)(struct em28xx *dev, u16 reg);
+        int (*em28xx_read_reg_req_len)(struct em28xx *dev, u8 req, u16 reg,
+                                       char *buf, int len);
+        int (*em28xx_write_regs_req)(struct em28xx *dev, u8 req, u16 reg,
+                                     char *buf, int len);
+        int (*em28xx_read_reg_req)(struct em28xx *dev, u8 req, u16 reg);
 
         enum em28xx_mode mode;
 
@@ -745,7 +746,7 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len);
 int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val);
 int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
-                                 u8 bitmask);
+                          u8 bitmask);
 int em28xx_toggle_reg_bits(struct em28xx *dev, u16 reg, u8 bitmask);
 
 int em28xx_read_ac97(struct em28xx *dev, u8 reg);
diff --git a/drivers/media/usb/go7007/go7007-v4l2.c b/drivers/media/usb/go7007/go7007-v4l2.c
index ec799b4d88be..d6bf982efa42 100644
--- a/drivers/media/usb/go7007/go7007-v4l2.c
+++ b/drivers/media/usb/go7007/go7007-v4l2.c
@@ -252,7 +252,7 @@ static int set_capture_size(struct go7007 *go, struct v4l2_format *fmt, int try)
         if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
                 struct v4l2_mbus_framefmt mbus_fmt;
 
-                mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
+                mbus_fmt.code = MEDIA_BUS_FMT_FIXED;
                 mbus_fmt.width = fmt ? fmt->fmt.pix.width : width;
                 mbus_fmt.height = height;
                 go->encoder_h_halve = 0;
diff --git a/drivers/media/usb/pvrusb2/pvrusb2-context.c b/drivers/media/usb/pvrusb2/pvrusb2-context.c
index 7c19ff72e6b3..c8761c71c9d2 100644
--- a/drivers/media/usb/pvrusb2/pvrusb2-context.c
+++ b/drivers/media/usb/pvrusb2/pvrusb2-context.c
@@ -80,7 +80,7 @@ static void pvr2_context_set_notify(struct pvr2_context *mp, int fl)
 static void pvr2_context_destroy(struct pvr2_context *mp)
 {
         pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context %p (destroy)",mp);
-        if (mp->hdw) pvr2_hdw_destroy(mp->hdw);
+        pvr2_hdw_destroy(mp->hdw);
         pvr2_context_set_notify(mp, 0);
         mutex_lock(&pvr2_context_mutex);
         if (mp->exist_next) {
diff --git a/drivers/media/usb/pvrusb2/pvrusb2-hdw.c b/drivers/media/usb/pvrusb2/pvrusb2-hdw.c
index 9623b6218214..2fd9b5e0e2a9 100644
--- a/drivers/media/usb/pvrusb2/pvrusb2-hdw.c
+++ b/drivers/media/usb/pvrusb2/pvrusb2-hdw.c
@@ -2966,7 +2966,7 @@ static void pvr2_subdev_update(struct pvr2_hdw *hdw)
                 memset(&fmt, 0, sizeof(fmt));
                 fmt.width = hdw->res_hor_val;
                 fmt.height = hdw->res_ver_val;
-                fmt.code = V4L2_MBUS_FMT_FIXED;
+                fmt.code = MEDIA_BUS_FMT_FIXED;
                 pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 set_size(%dx%d)",
                            fmt.width, fmt.height);
                 v4l2_device_call_all(&hdw->v4l2_dev, 0, video, s_mbus_fmt, &fmt);
diff --git a/drivers/media/usb/s2255/s2255drv.c b/drivers/media/usb/s2255/s2255drv.c
index ccc00099b261..de55e96fed15 100644
--- a/drivers/media/usb/s2255/s2255drv.c
+++ b/drivers/media/usb/s2255/s2255drv.c
@@ -558,27 +558,30 @@ static void s2255_fwchunk_complete(struct urb *urb)
 
 }
 
-static int s2255_got_frame(struct s2255_vc *vc, int jpgsize)
+static void s2255_got_frame(struct s2255_vc *vc, int jpgsize)
 {
         struct s2255_buffer *buf;
         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
         unsigned long flags = 0;
-        int rc = 0;
+
         spin_lock_irqsave(&vc->qlock, flags);
         if (list_empty(&vc->buf_list)) {
                 dprintk(dev, 1, "No active queue to serve\n");
-                rc = -1;
-                goto unlock;
+                spin_unlock_irqrestore(&vc->qlock, flags);
+                return;
         }
         buf = list_entry(vc->buf_list.next,
                          struct s2255_buffer, list);
         list_del(&buf->list);
         v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
+        buf->vb.v4l2_buf.field = vc->field;
+        buf->vb.v4l2_buf.sequence = vc->frame_count;
+        spin_unlock_irqrestore(&vc->qlock, flags);
+
         s2255_fillbuff(vc, buf, jpgsize);
+        /* tell v4l buffer was filled */
+        vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
         dprintk(dev, 2, "%s: [buf] [%p]\n", __func__, buf);
-unlock:
-        spin_unlock_irqrestore(&vc->qlock, flags);
-        return rc;
 }
 
 static const struct s2255_fmt *format_by_fourcc(int fourcc)
@@ -632,7 +635,7 @@ static void s2255_fillbuff(struct s2255_vc *vc,
                         break;
                 case V4L2_PIX_FMT_JPEG:
                 case V4L2_PIX_FMT_MJPEG:
-                        buf->vb.v4l2_buf.length = jpgsize;
+                        vb2_set_plane_payload(&buf->vb, 0, jpgsize);
                         memcpy(vbuf, tmpbuf, jpgsize);
                         break;
                 case V4L2_PIX_FMT_YUV422P:
@@ -649,11 +652,6 @@ static void s2255_fillbuff(struct s2255_vc *vc,
         }
         dprintk(dev, 2, "s2255fill at : Buffer 0x%08lx size= %d\n",
                 (unsigned long)vbuf, pos);
-        /* tell v4l buffer was filled */
-        buf->vb.v4l2_buf.field = vc->field;
-        buf->vb.v4l2_buf.sequence = vc->frame_count;
-        v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
-        vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 }
 
 
@@ -1976,8 +1974,7 @@ static int s2255_release_sys_buffers(struct s2255_vc *vc)
 {
         unsigned long i;
         for (i = 0; i < SYS_FRAMES; i++) {
-                if (vc->buffer.frame[i].lpvbits)
-                        vfree(vc->buffer.frame[i].lpvbits);
+                vfree(vc->buffer.frame[i].lpvbits);
                 vc->buffer.frame[i].lpvbits = NULL;
         }
         return 0;
diff --git a/drivers/media/usb/stk1160/stk1160-v4l.c b/drivers/media/usb/stk1160/stk1160-v4l.c
index 233054311a62..a47629108c1b 100644
--- a/drivers/media/usb/stk1160/stk1160-v4l.c
+++ b/drivers/media/usb/stk1160/stk1160-v4l.c
@@ -475,7 +475,7 @@ static int vidioc_s_register(struct file *file, void *priv,
         struct stk1160 *dev = video_drvdata(file);
 
         /* Match host */
-        return stk1160_write_reg(dev, reg->reg, cpu_to_le16(reg->val));
+        return stk1160_write_reg(dev, reg->reg, reg->val);
 }
 #endif
 
diff --git a/drivers/media/usb/usbvision/usbvision-video.c b/drivers/media/usb/usbvision/usbvision-video.c
index 9bfa041e3316..693d5f409138 100644
--- a/drivers/media/usb/usbvision/usbvision-video.c
+++ b/drivers/media/usb/usbvision/usbvision-video.c
@@ -509,11 +509,12 @@ static int vidioc_querycap(struct file *file, void  *priv,
                 usbvision_device_data[usbvision->dev_model].model_string,
                 sizeof(vc->card));
         usb_make_path(usbvision->dev, vc->bus_info, sizeof(vc->bus_info));
-        vc->capabilities = V4L2_CAP_VIDEO_CAPTURE |
+        vc->device_caps = V4L2_CAP_VIDEO_CAPTURE |
                 V4L2_CAP_AUDIO |
                 V4L2_CAP_READWRITE |
                 V4L2_CAP_STREAMING |
                 (usbvision->have_tuner ? V4L2_CAP_TUNER : 0);
+        vc->capabilities = vc->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index 7c8322d4fc63..6a4b0b8cd270 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -331,6 +331,7 @@ static int uvc_parse_format(struct uvc_device *dev,
         struct uvc_format_desc *fmtdesc;
         struct uvc_frame *frame;
         const unsigned char *start = buffer;
+        unsigned int width_multiplier = 1;
         unsigned int interval;
         unsigned int i, n;
         __u8 ftype;
@@ -366,6 +367,20 @@ static int uvc_parse_format(struct uvc_device *dev,
                 }
 
                 format->bpp = buffer[21];
+
+                /* Some devices report a format that doesn't match what they
+                 * really send.
+                 */
+                if (dev->quirks & UVC_QUIRK_FORCE_Y8) {
+                        if (format->fcc == V4L2_PIX_FMT_YUYV) {
+                                strlcpy(format->name, "Greyscale 8-bit (Y8  )",
+                                        sizeof(format->name));
+                                format->fcc = V4L2_PIX_FMT_GREY;
+                                format->bpp = 8;
+                                width_multiplier = 2;
+                        }
+                }
+
                 if (buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED) {
                         ftype = UVC_VS_FRAME_UNCOMPRESSED;
                 } else {
@@ -474,7 +489,8 @@ static int uvc_parse_format(struct uvc_device *dev,
 
                 frame->bFrameIndex = buffer[3];
                 frame->bmCapabilities = buffer[4];
-                frame->wWidth = get_unaligned_le16(&buffer[5]);
+                frame->wWidth = get_unaligned_le16(&buffer[5])
+                              * width_multiplier;
                 frame->wHeight = get_unaligned_le16(&buffer[7]);
                 frame->dwMinBitRate = get_unaligned_le32(&buffer[9]);
                 frame->dwMaxBitRate = get_unaligned_le32(&buffer[13]);
@@ -1623,12 +1639,12 @@ static void uvc_delete(struct uvc_device *dev)
 {
         struct list_head *p, *n;
 
-        usb_put_intf(dev->intf);
-        usb_put_dev(dev->udev);
-
         uvc_status_cleanup(dev);
         uvc_ctrl_cleanup_device(dev);
 
+        usb_put_intf(dev->intf);
+        usb_put_dev(dev->udev);
+
         if (dev->vdev.dev)
                 v4l2_device_unregister(&dev->vdev);
 #ifdef CONFIG_MEDIA_CONTROLLER
@@ -1718,6 +1734,11 @@ static int uvc_register_video(struct uvc_device *dev,
         struct video_device *vdev;
         int ret;
 
+        /* Initialize the video buffers queue. */
+        ret = uvc_queue_init(&stream->queue, stream->type, !uvc_no_drop_param);
+        if (ret)
+                return ret;
+
         /* Initialize the streaming interface with default streaming
          * parameters.
          */
@@ -1744,6 +1765,7 @@ static int uvc_register_video(struct uvc_device *dev,
          */
         vdev->v4l2_dev = &dev->vdev;
         vdev->fops = &uvc_fops;
+        vdev->ioctl_ops = &uvc_ioctl_ops;
         vdev->release = uvc_release;
         vdev->prio = &stream->chain->prio;
         if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
@@ -1991,14 +2013,13 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
 {
         struct uvc_device *dev = usb_get_intfdata(intf);
         struct uvc_streaming *stream;
+        int ret = 0;
 
         uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
                 intf->cur_altsetting->desc.bInterfaceNumber);
 
         if (intf->cur_altsetting->desc.bInterfaceSubClass ==
             UVC_SC_VIDEOCONTROL) {
-                int ret = 0;
-
                 if (reset) {
                         ret = uvc_ctrl_restore_values(dev);
                         if (ret < 0)
@@ -2014,8 +2035,13 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
         }
 
         list_for_each_entry(stream, &dev->streams, list) {
-                if (stream->intf == intf)
-                        return uvc_video_resume(stream, reset);
+                if (stream->intf == intf) {
+                        ret = uvc_video_resume(stream, reset);
+                        if (ret < 0)
+                                uvc_queue_streamoff(&stream->queue,
+                                                    stream->queue.queue.type);
+                        return ret;
+                }
         }
 
         uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB interface "
@@ -2504,6 +2530,15 @@ static struct usb_device_id uvc_ids[] = {
           .bInterfaceProtocol   = 0,
           .driver_info          = UVC_QUIRK_PROBE_MINMAX
                                 | UVC_QUIRK_IGNORE_SELECTOR_UNIT },
+        /* Oculus VR Positional Tracker DK2 */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x2833,
+          .idProduct            = 0x0201,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_FORCE_Y8 },
         /* Generic USB Video Class */
         { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, 0) },
         {}
diff --git a/drivers/media/usb/uvc/uvc_queue.c b/drivers/media/usb/uvc/uvc_queue.c
index 6e92d2080255..cc960723b926 100644
--- a/drivers/media/usb/uvc/uvc_queue.c
+++ b/drivers/media/usb/uvc/uvc_queue.c
@@ -36,6 +36,34 @@
  * the driver.
  */
 
+static inline struct uvc_streaming *
+uvc_queue_to_stream(struct uvc_video_queue *queue)
+{
+        return container_of(queue, struct uvc_streaming, queue);
+}
+
+/*
+ * Return all queued buffers to videobuf2 in the requested state.
+ *
+ * This function must be called with the queue spinlock held.
+ */
+static void uvc_queue_return_buffers(struct uvc_video_queue *queue,
+                               enum uvc_buffer_state state)
+{
+        enum vb2_buffer_state vb2_state = state == UVC_BUF_STATE_ERROR
+                                        ? VB2_BUF_STATE_ERROR
+                                        : VB2_BUF_STATE_QUEUED;
+
+        while (!list_empty(&queue->irqqueue)) {
+                struct uvc_buffer *buf = list_first_entry(&queue->irqqueue,
+                                                          struct uvc_buffer,
+                                                          queue);
+                list_del(&buf->queue);
+                buf->state = state;
+                vb2_buffer_done(&buf->buf, vb2_state);
+        }
+}
+
 /* -----------------------------------------------------------------------------
  * videobuf2 queue operations
  */
@@ -45,8 +73,7 @@ static int uvc_queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
                            unsigned int sizes[], void *alloc_ctxs[])
 {
         struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
-        struct uvc_streaming *stream =
-                        container_of(queue, struct uvc_streaming, queue);
+        struct uvc_streaming *stream = uvc_queue_to_stream(queue);
 
         /* Make sure the image size is large enough. */
         if (fmt && fmt->fmt.pix.sizeimage < stream->ctrl.dwMaxVideoFrameSize)
@@ -109,8 +136,7 @@ static void uvc_buffer_queue(struct vb2_buffer *vb)
 static void uvc_buffer_finish(struct vb2_buffer *vb)
 {
         struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
-        struct uvc_streaming *stream =
-                        container_of(queue, struct uvc_streaming, queue);
+        struct uvc_streaming *stream = uvc_queue_to_stream(queue);
         struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
 
         if (vb->state == VB2_BUF_STATE_DONE)
@@ -131,6 +157,39 @@ static void uvc_wait_finish(struct vb2_queue *vq)
         mutex_lock(&queue->mutex);
 }
 
+static int uvc_start_streaming(struct vb2_queue *vq, unsigned int count)
+{
+        struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
+        struct uvc_streaming *stream = uvc_queue_to_stream(queue);
+        unsigned long flags;
+        int ret;
+
+        queue->buf_used = 0;
+
+        ret = uvc_video_enable(stream, 1);
+        if (ret == 0)
+                return 0;
+
+        spin_lock_irqsave(&queue->irqlock, flags);
+        uvc_queue_return_buffers(queue, UVC_BUF_STATE_QUEUED);
+        spin_unlock_irqrestore(&queue->irqlock, flags);
+
+        return ret;
+}
+
+static void uvc_stop_streaming(struct vb2_queue *vq)
+{
+        struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
+        struct uvc_streaming *stream = uvc_queue_to_stream(queue);
+        unsigned long flags;
+
+        uvc_video_enable(stream, 0);
+
+        spin_lock_irqsave(&queue->irqlock, flags);
+        uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
+        spin_unlock_irqrestore(&queue->irqlock, flags);
+}
+
 static struct vb2_ops uvc_queue_qops = {
         .queue_setup = uvc_queue_setup,
         .buf_prepare = uvc_buffer_prepare,
@@ -138,6 +197,8 @@ static struct vb2_ops uvc_queue_qops = {
         .buf_finish = uvc_buffer_finish,
         .wait_prepare = uvc_wait_prepare,
         .wait_finish = uvc_wait_finish,
+        .start_streaming = uvc_start_streaming,
+        .stop_streaming = uvc_stop_streaming,
 };
 
 int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
@@ -165,12 +226,19 @@ int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
         return 0;
 }
 
+void uvc_queue_release(struct uvc_video_queue *queue)
+{
+        mutex_lock(&queue->mutex);
+        vb2_queue_release(&queue->queue);
+        mutex_unlock(&queue->mutex);
+}
+
 /* -----------------------------------------------------------------------------
  * V4L2 queue operations
  */
 
-int uvc_alloc_buffers(struct uvc_video_queue *queue,
-                      struct v4l2_requestbuffers *rb)
+int uvc_request_buffers(struct uvc_video_queue *queue,
+                        struct v4l2_requestbuffers *rb)
 {
         int ret;
 
@@ -181,13 +249,6 @@ int uvc_alloc_buffers(struct uvc_video_queue *queue,
         return ret ? ret : rb->count;
 }
 
-void uvc_free_buffers(struct uvc_video_queue *queue)
-{
-        mutex_lock(&queue->mutex);
-        vb2_queue_release(&queue->queue);
-        mutex_unlock(&queue->mutex);
-}
-
 int uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
 {
         int ret;
@@ -234,6 +295,28 @@ int uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
         return ret;
 }
 
+int uvc_queue_streamon(struct uvc_video_queue *queue, enum v4l2_buf_type type)
+{
+        int ret;
+
+        mutex_lock(&queue->mutex);
+        ret = vb2_streamon(&queue->queue, type);
+        mutex_unlock(&queue->mutex);
+
+        return ret;
+}
+
+int uvc_queue_streamoff(struct uvc_video_queue *queue, enum v4l2_buf_type type)
+{
+        int ret;
+
+        mutex_lock(&queue->mutex);
+        ret = vb2_streamoff(&queue->queue, type);
+        mutex_unlock(&queue->mutex);
+
+        return ret;
+}
+
 int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
 {
         int ret;
@@ -289,49 +372,6 @@ int uvc_queue_allocated(struct uvc_video_queue *queue)
 }
 
 /*
- * Enable or disable the video buffers queue.
- *
- * The queue must be enabled before starting video acquisition and must be
- * disabled after stopping it. This ensures that the video buffers queue
- * state can be properly initialized before buffers are accessed from the
- * interrupt handler.
- *
- * Enabling the video queue returns -EBUSY if the queue is already enabled.
- *
- * Disabling the video queue cancels the queue and removes all buffers from
- * the main queue.
- *
- * This function can't be called from interrupt context. Use
- * uvc_queue_cancel() instead.
- */
-int uvc_queue_enable(struct uvc_video_queue *queue, int enable)
-{
-        unsigned long flags;
-        int ret;
-
-        mutex_lock(&queue->mutex);
-        if (enable) {
-                ret = vb2_streamon(&queue->queue, queue->queue.type);
-                if (ret < 0)
-                        goto done;
-
-                queue->buf_used = 0;
-        } else {
-                ret = vb2_streamoff(&queue->queue, queue->queue.type);
-                if (ret < 0)
-                        goto done;
-
-                spin_lock_irqsave(&queue->irqlock, flags);
-                INIT_LIST_HEAD(&queue->irqqueue);
-                spin_unlock_irqrestore(&queue->irqlock, flags);
-        }
-
-done:
-        mutex_unlock(&queue->mutex);
-        return ret;
-}
-
-/*
  * Cancel the video buffers queue.
  *
  * Cancelling the queue marks all buffers on the irq queue as erroneous,
@@ -345,17 +385,10 @@ done:
  */
 void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
 {
-        struct uvc_buffer *buf;
         unsigned long flags;
 
         spin_lock_irqsave(&queue->irqlock, flags);
-        while (!list_empty(&queue->irqqueue)) {
-                buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
-                                       queue);
-                list_del(&buf->queue);
-                buf->state = UVC_BUF_STATE_ERROR;
-                vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
-        }
+        uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
         /* This must be protected by the irqlock spinlock to avoid race
          * conditions between uvc_buffer_queue and the disconnection event that
          * could result in an interruptible wait in uvc_dequeue_buffer. Do not
diff --git a/drivers/media/usb/uvc/uvc_v4l2.c b/drivers/media/usb/uvc/uvc_v4l2.c
index 378ae02e593b..9c5cbcf16529 100644
--- a/drivers/media/usb/uvc/uvc_v4l2.c
+++ b/drivers/media/usb/uvc/uvc_v4l2.c
@@ -530,10 +530,8 @@ static int uvc_v4l2_release(struct file *file)
         uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_release\n");
 
         /* Only free resources if this is a privileged handle. */
-        if (uvc_has_privileges(handle)) {
-                uvc_video_enable(stream, 0);
-                uvc_free_buffers(&stream->queue);
-        }
+        if (uvc_has_privileges(handle))
+                uvc_queue_release(&stream->queue);
 
         /* Release the file handle. */
         uvc_dismiss_privileges(handle);
@@ -551,553 +549,628 @@ static int uvc_v4l2_release(struct file *file)
         return 0;
 }
 
-static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static int uvc_ioctl_querycap(struct file *file, void *fh,
+                              struct v4l2_capability *cap)
 {
         struct video_device *vdev = video_devdata(file);
         struct uvc_fh *handle = file->private_data;
         struct uvc_video_chain *chain = handle->chain;
         struct uvc_streaming *stream = handle->stream;
-        long ret = 0;
 
-        switch (cmd) {
-        /* Query capabilities */
-        case VIDIOC_QUERYCAP:
-        {
-                struct v4l2_capability *cap = arg;
-
-                memset(cap, 0, sizeof *cap);
-                strlcpy(cap->driver, "uvcvideo", sizeof cap->driver);
-                strlcpy(cap->card, vdev->name, sizeof cap->card);
-                usb_make_path(stream->dev->udev,
-                              cap->bus_info, sizeof(cap->bus_info));
-                cap->version = LINUX_VERSION_CODE;
-                cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_STREAMING
-                                  | chain->caps;
-                if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE
-                                         | V4L2_CAP_STREAMING;
-                else
-                        cap->device_caps = V4L2_CAP_VIDEO_OUTPUT
-                                         | V4L2_CAP_STREAMING;
-                break;
-        }
+        strlcpy(cap->driver, "uvcvideo", sizeof(cap->driver));
+        strlcpy(cap->card, vdev->name, sizeof(cap->card));
+        usb_make_path(stream->dev->udev, cap->bus_info, sizeof(cap->bus_info));
+        cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_STREAMING
+                          | chain->caps;
+        if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        else
+                cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
 
-        /* Priority */
-        case VIDIOC_G_PRIORITY:
-                *(u32 *)arg = v4l2_prio_max(vdev->prio);
-                break;
+        return 0;
+}
 
-        case VIDIOC_S_PRIORITY:
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
+static int uvc_ioctl_enum_fmt(struct uvc_streaming *stream,
+                              struct v4l2_fmtdesc *fmt)
+{
+        struct uvc_format *format;
+        enum v4l2_buf_type type = fmt->type;
+        __u32 index = fmt->index;
 
-                return v4l2_prio_change(vdev->prio, &handle->vfh.prio,
-                                        *(u32 *)arg);
+        if (fmt->type != stream->type || fmt->index >= stream->nformats)
+                return -EINVAL;
 
-        /* Get, Set & Query control */
-        case VIDIOC_QUERYCTRL:
-                return uvc_query_v4l2_ctrl(chain, arg);
+        memset(fmt, 0, sizeof(*fmt));
+        fmt->index = index;
+        fmt->type = type;
+
+        format = &stream->format[fmt->index];
+        fmt->flags = 0;
+        if (format->flags & UVC_FMT_FLAG_COMPRESSED)
+                fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
+        strlcpy(fmt->description, format->name, sizeof(fmt->description));
+        fmt->description[sizeof(fmt->description) - 1] = 0;
+        fmt->pixelformat = format->fcc;
+        return 0;
+}
 
-        case VIDIOC_G_CTRL:
-        {
-                struct v4l2_control *ctrl = arg;
-                struct v4l2_ext_control xctrl;
+static int uvc_ioctl_enum_fmt_vid_cap(struct file *file, void *fh,
+                                      struct v4l2_fmtdesc *fmt)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
 
-                memset(&xctrl, 0, sizeof xctrl);
-                xctrl.id = ctrl->id;
+        return uvc_ioctl_enum_fmt(stream, fmt);
+}
 
-                ret = uvc_ctrl_begin(chain);
-                if (ret < 0)
-                        return ret;
+static int uvc_ioctl_enum_fmt_vid_out(struct file *file, void *fh,
+                                      struct v4l2_fmtdesc *fmt)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
 
-                ret = uvc_ctrl_get(chain, &xctrl);
-                uvc_ctrl_rollback(handle);
-                if (ret >= 0)
-                        ctrl->value = xctrl.value;
-                break;
-        }
+        return uvc_ioctl_enum_fmt(stream, fmt);
+}
 
-        case VIDIOC_S_CTRL:
-        {
-                struct v4l2_control *ctrl = arg;
-                struct v4l2_ext_control xctrl;
+static int uvc_ioctl_g_fmt_vid_cap(struct file *file, void *fh,
+                                   struct v4l2_format *fmt)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
 
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
+        return uvc_v4l2_get_format(stream, fmt);
+}
 
-                memset(&xctrl, 0, sizeof xctrl);
-                xctrl.id = ctrl->id;
-                xctrl.value = ctrl->value;
+static int uvc_ioctl_g_fmt_vid_out(struct file *file, void *fh,
+                                   struct v4l2_format *fmt)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
 
-                ret = uvc_ctrl_begin(chain);
-                if (ret < 0)
-                        return ret;
+        return uvc_v4l2_get_format(stream, fmt);
+}
 
-                ret = uvc_ctrl_set(chain, &xctrl);
-                if (ret < 0) {
-                        uvc_ctrl_rollback(handle);
-                        return ret;
-                }
-                ret = uvc_ctrl_commit(handle, &xctrl, 1);
-                if (ret == 0)
-                        ctrl->value = xctrl.value;
-                break;
-        }
+static int uvc_ioctl_s_fmt_vid_cap(struct file *file, void *fh,
+                                   struct v4l2_format *fmt)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        int ret;
 
-        case VIDIOC_QUERYMENU:
-                return uvc_query_v4l2_menu(chain, arg);
+        ret = uvc_acquire_privileges(handle);
+        if (ret < 0)
+                return ret;
 
-        case VIDIOC_G_EXT_CTRLS:
-        {
-                struct v4l2_ext_controls *ctrls = arg;
-                struct v4l2_ext_control *ctrl = ctrls->controls;
-                unsigned int i;
+        return uvc_v4l2_set_format(stream, fmt);
+}
 
-                ret = uvc_ctrl_begin(chain);
-                if (ret < 0)
-                        return ret;
+static int uvc_ioctl_s_fmt_vid_out(struct file *file, void *fh,
+                                   struct v4l2_format *fmt)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        int ret;
 
-                for (i = 0; i < ctrls->count; ++ctrl, ++i) {
-                        ret = uvc_ctrl_get(chain, ctrl);
-                        if (ret < 0) {
-                                uvc_ctrl_rollback(handle);
-                                ctrls->error_idx = i;
-                                return ret;
-                        }
-                }
-                ctrls->error_idx = 0;
-                ret = uvc_ctrl_rollback(handle);
-                break;
-        }
+        ret = uvc_acquire_privileges(handle);
+        if (ret < 0)
+                return ret;
 
-        case VIDIOC_S_EXT_CTRLS:
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
-                /* Fall through */
-        case VIDIOC_TRY_EXT_CTRLS:
-        {
-                struct v4l2_ext_controls *ctrls = arg;
-                struct v4l2_ext_control *ctrl = ctrls->controls;
-                unsigned int i;
-
-                ret = uvc_ctrl_begin(chain);
-                if (ret < 0)
-                        return ret;
+        return uvc_v4l2_set_format(stream, fmt);
+}
 
-                for (i = 0; i < ctrls->count; ++ctrl, ++i) {
-                        ret = uvc_ctrl_set(chain, ctrl);
-                        if (ret < 0) {
-                                uvc_ctrl_rollback(handle);
-                                ctrls->error_idx = cmd == VIDIOC_S_EXT_CTRLS
-                                                 ? ctrls->count : i;
-                                return ret;
-                        }
-                }
+static int uvc_ioctl_try_fmt_vid_cap(struct file *file, void *fh,
+                                     struct v4l2_format *fmt)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        struct uvc_streaming_control probe;
 
-                ctrls->error_idx = 0;
+        return uvc_v4l2_try_format(stream, fmt, &probe, NULL, NULL);
+}
 
-                if (cmd == VIDIOC_S_EXT_CTRLS)
-                        ret = uvc_ctrl_commit(handle,
-                                              ctrls->controls, ctrls->count);
-                else
-                        ret = uvc_ctrl_rollback(handle);
-                break;
-        }
+static int uvc_ioctl_try_fmt_vid_out(struct file *file, void *fh,
+                                     struct v4l2_format *fmt)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        struct uvc_streaming_control probe;
 
-        /* Get, Set & Enum input */
-        case VIDIOC_ENUMINPUT:
-        {
-                const struct uvc_entity *selector = chain->selector;
-                struct v4l2_input *input = arg;
-                struct uvc_entity *iterm = NULL;
-                u32 index = input->index;
-                int pin = 0;
-
-                if (selector == NULL ||
-                    (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
-                        if (index != 0)
-                                return -EINVAL;
-                        list_for_each_entry(iterm, &chain->entities, chain) {
-                                if (UVC_ENTITY_IS_ITERM(iterm))
-                                        break;
-                        }
-                        pin = iterm->id;
-                } else if (index < selector->bNrInPins) {
-                        pin = selector->baSourceID[index];
-                        list_for_each_entry(iterm, &chain->entities, chain) {
-                                if (!UVC_ENTITY_IS_ITERM(iterm))
-                                        continue;
-                                if (iterm->id == pin)
-                                        break;
-                        }
-                }
+        return uvc_v4l2_try_format(stream, fmt, &probe, NULL, NULL);
+}
 
-                if (iterm == NULL || iterm->id != pin)
-                        return -EINVAL;
+static int uvc_ioctl_reqbufs(struct file *file, void *fh,
+                             struct v4l2_requestbuffers *rb)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        int ret;
 
-                memset(input, 0, sizeof *input);
-                input->index = index;
-                strlcpy(input->name, iterm->name, sizeof input->name);
-                if (UVC_ENTITY_TYPE(iterm) == UVC_ITT_CAMERA)
-                        input->type = V4L2_INPUT_TYPE_CAMERA;
-                break;
-        }
+        ret = uvc_acquire_privileges(handle);
+        if (ret < 0)
+                return ret;
 
-        case VIDIOC_G_INPUT:
-        {
-                u8 input;
+        mutex_lock(&stream->mutex);
+        ret = uvc_request_buffers(&stream->queue, rb);
+        mutex_unlock(&stream->mutex);
+        if (ret < 0)
+                return ret;
 
-                if (chain->selector == NULL ||
-                    (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
-                        *(int *)arg = 0;
-                        break;
-                }
+        if (ret == 0)
+                uvc_dismiss_privileges(handle);
 
-                ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR,
-                        chain->selector->id, chain->dev->intfnum,
-                        UVC_SU_INPUT_SELECT_CONTROL, &input, 1);
-                if (ret < 0)
-                        return ret;
+        return 0;
+}
 
-                *(int *)arg = input - 1;
-                break;
-        }
+static int uvc_ioctl_querybuf(struct file *file, void *fh,
+                              struct v4l2_buffer *buf)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
 
-        case VIDIOC_S_INPUT:
-        {
-                u32 input = *(u32 *)arg + 1;
+        if (!uvc_has_privileges(handle))
+                return -EBUSY;
 
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
+        return uvc_query_buffer(&stream->queue, buf);
+}
 
-                if ((ret = uvc_acquire_privileges(handle)) < 0)
-                        return ret;
+static int uvc_ioctl_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
 
-                if (chain->selector == NULL ||
-                    (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
-                        if (input != 1)
-                                return -EINVAL;
-                        break;
-                }
+        if (!uvc_has_privileges(handle))
+                return -EBUSY;
 
-                if (input == 0 || input > chain->selector->bNrInPins)
-                        return -EINVAL;
+        return uvc_queue_buffer(&stream->queue, buf);
+}
 
-                return uvc_query_ctrl(chain->dev, UVC_SET_CUR,
-                        chain->selector->id, chain->dev->intfnum,
-                        UVC_SU_INPUT_SELECT_CONTROL, &input, 1);
-        }
+static int uvc_ioctl_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
 
-        /* Try, Get, Set & Enum format */
-        case VIDIOC_ENUM_FMT:
-        {
-                struct v4l2_fmtdesc *fmt = arg;
-                struct uvc_format *format;
-                enum v4l2_buf_type type = fmt->type;
-                __u32 index = fmt->index;
+        if (!uvc_has_privileges(handle))
+                return -EBUSY;
 
-                if (fmt->type != stream->type ||
-                    fmt->index >= stream->nformats)
-                        return -EINVAL;
+        return uvc_dequeue_buffer(&stream->queue, buf,
+                                  file->f_flags & O_NONBLOCK);
+}
 
-                memset(fmt, 0, sizeof(*fmt));
-                fmt->index = index;
-                fmt->type = type;
-
-                format = &stream->format[fmt->index];
-                fmt->flags = 0;
-                if (format->flags & UVC_FMT_FLAG_COMPRESSED)
-                        fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
-                strlcpy(fmt->description, format->name,
-                        sizeof fmt->description);
-                fmt->description[sizeof fmt->description - 1] = 0;
-                fmt->pixelformat = format->fcc;
-                break;
-        }
+static int uvc_ioctl_create_bufs(struct file *file, void *fh,
+                                  struct v4l2_create_buffers *cb)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        int ret;
 
-        case VIDIOC_TRY_FMT:
-        {
-                struct uvc_streaming_control probe;
+        ret = uvc_acquire_privileges(handle);
+        if (ret < 0)
+                return ret;
 
-                return uvc_v4l2_try_format(stream, arg, &probe, NULL, NULL);
-        }
+        return uvc_create_buffers(&stream->queue, cb);
+}
 
-        case VIDIOC_S_FMT:
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
+static int uvc_ioctl_streamon(struct file *file, void *fh,
+                              enum v4l2_buf_type type)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        int ret;
 
-                if ((ret = uvc_acquire_privileges(handle)) < 0)
-                        return ret;
+        if (!uvc_has_privileges(handle))
+                return -EBUSY;
 
-                return uvc_v4l2_set_format(stream, arg);
+        mutex_lock(&stream->mutex);
+        ret = uvc_queue_streamon(&stream->queue, type);
+        mutex_unlock(&stream->mutex);
 
-        case VIDIOC_G_FMT:
-                return uvc_v4l2_get_format(stream, arg);
+        return ret;
+}
 
-        /* Frame size enumeration */
-        case VIDIOC_ENUM_FRAMESIZES:
-        {
-                struct v4l2_frmsizeenum *fsize = arg;
-                struct uvc_format *format = NULL;
-                struct uvc_frame *frame;
-                int i;
+static int uvc_ioctl_streamoff(struct file *file, void *fh,
+                               enum v4l2_buf_type type)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
 
-                /* Look for the given pixel format */
-                for (i = 0; i < stream->nformats; i++) {
-                        if (stream->format[i].fcc ==
-                                        fsize->pixel_format) {
-                                format = &stream->format[i];
-                                break;
-                        }
-                }
-                if (format == NULL)
-                        return -EINVAL;
+        if (!uvc_has_privileges(handle))
+                return -EBUSY;
 
-                if (fsize->index >= format->nframes)
-                        return -EINVAL;
+        mutex_lock(&stream->mutex);
+        uvc_queue_streamoff(&stream->queue, type);
+        mutex_unlock(&stream->mutex);
 
-                frame = &format->frame[fsize->index];
-                fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
-                fsize->discrete.width = frame->wWidth;
-                fsize->discrete.height = frame->wHeight;
-                break;
-        }
+        return 0;
+}
 
-        /* Frame interval enumeration */
-        case VIDIOC_ENUM_FRAMEINTERVALS:
-        {
-                struct v4l2_frmivalenum *fival = arg;
-                struct uvc_format *format = NULL;
-                struct uvc_frame *frame = NULL;
-                int i;
-
-                /* Look for the given pixel format and frame size */
-                for (i = 0; i < stream->nformats; i++) {
-                        if (stream->format[i].fcc ==
-                                        fival->pixel_format) {
-                                format = &stream->format[i];
-                                break;
-                        }
-                }
-                if (format == NULL)
+static int uvc_ioctl_enum_input(struct file *file, void *fh,
+                                struct v4l2_input *input)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
+        const struct uvc_entity *selector = chain->selector;
+        struct uvc_entity *iterm = NULL;
+        u32 index = input->index;
+        int pin = 0;
+
+        if (selector == NULL ||
+            (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                if (index != 0)
                         return -EINVAL;
-
-                for (i = 0; i < format->nframes; i++) {
-                        if (format->frame[i].wWidth == fival->width &&
-                            format->frame[i].wHeight == fival->height) {
-                                frame = &format->frame[i];
+                list_for_each_entry(iterm, &chain->entities, chain) {
+                        if (UVC_ENTITY_IS_ITERM(iterm))
                                 break;
-                        }
                 }
-                if (frame == NULL)
-                        return -EINVAL;
-
-                if (frame->bFrameIntervalType) {
-                        if (fival->index >= frame->bFrameIntervalType)
-                                return -EINVAL;
-
-                        fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
-                        fival->discrete.numerator =
-                                frame->dwFrameInterval[fival->index];
-                        fival->discrete.denominator = 10000000;
-                        uvc_simplify_fraction(&fival->discrete.numerator,
-                                &fival->discrete.denominator, 8, 333);
-                } else {
-                        fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
-                        fival->stepwise.min.numerator =
-                                frame->dwFrameInterval[0];
-                        fival->stepwise.min.denominator = 10000000;
-                        fival->stepwise.max.numerator =
-                                frame->dwFrameInterval[1];
-                        fival->stepwise.max.denominator = 10000000;
-                        fival->stepwise.step.numerator =
-                                frame->dwFrameInterval[2];
-                        fival->stepwise.step.denominator = 10000000;
-                        uvc_simplify_fraction(&fival->stepwise.min.numerator,
-                                &fival->stepwise.min.denominator, 8, 333);
-                        uvc_simplify_fraction(&fival->stepwise.max.numerator,
-                                &fival->stepwise.max.denominator, 8, 333);
-                        uvc_simplify_fraction(&fival->stepwise.step.numerator,
-                                &fival->stepwise.step.denominator, 8, 333);
+                pin = iterm->id;
+        } else if (index < selector->bNrInPins) {
+                pin = selector->baSourceID[index];
+                list_for_each_entry(iterm, &chain->entities, chain) {
+                        if (!UVC_ENTITY_IS_ITERM(iterm))
+                                continue;
+                        if (iterm->id == pin)
+                                break;
                 }
-                break;
         }
 
-        /* Get & Set streaming parameters */
-        case VIDIOC_G_PARM:
-                return uvc_v4l2_get_streamparm(stream, arg);
+        if (iterm == NULL || iterm->id != pin)
+                return -EINVAL;
 
-        case VIDIOC_S_PARM:
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
+        memset(input, 0, sizeof(*input));
+        input->index = index;
+        strlcpy(input->name, iterm->name, sizeof(input->name));
+        if (UVC_ENTITY_TYPE(iterm) == UVC_ITT_CAMERA)
+                input->type = V4L2_INPUT_TYPE_CAMERA;
 
-                if ((ret = uvc_acquire_privileges(handle)) < 0)
-                        return ret;
+        return 0;
+}
 
-                return uvc_v4l2_set_streamparm(stream, arg);
+static int uvc_ioctl_g_input(struct file *file, void *fh, unsigned int *input)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
+        int ret;
+        u8 i;
 
-        /* Cropping and scaling */
-        case VIDIOC_CROPCAP:
-        {
-                struct v4l2_cropcap *ccap = arg;
+        if (chain->selector == NULL ||
+            (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                *input = 0;
+                return 0;
+        }
 
-                if (ccap->type != stream->type)
-                        return -EINVAL;
+        ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, chain->selector->id,
+                             chain->dev->intfnum,  UVC_SU_INPUT_SELECT_CONTROL,
+                             &i, 1);
+        if (ret < 0)
+                return ret;
 
-                ccap->bounds.left = 0;
-                ccap->bounds.top = 0;
+        *input = i - 1;
+        return 0;
+}
 
-                mutex_lock(&stream->mutex);
-                ccap->bounds.width = stream->cur_frame->wWidth;
-                ccap->bounds.height = stream->cur_frame->wHeight;
-                mutex_unlock(&stream->mutex);
+static int uvc_ioctl_s_input(struct file *file, void *fh, unsigned int input)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
+        int ret;
+        u32 i;
 
-                ccap->defrect = ccap->bounds;
+        ret = uvc_acquire_privileges(handle);
+        if (ret < 0)
+                return ret;
 
-                ccap->pixelaspect.numerator = 1;
-                ccap->pixelaspect.denominator = 1;
-                break;
+        if (chain->selector == NULL ||
+            (chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                if (input)
+                        return -EINVAL;
+                return 0;
         }
 
-        case VIDIOC_G_CROP:
-        case VIDIOC_S_CROP:
-                return -ENOTTY;
+        if (input >= chain->selector->bNrInPins)
+                return -EINVAL;
 
-        /* Buffers & streaming */
-        case VIDIOC_REQBUFS:
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
+        i = input + 1;
+        return uvc_query_ctrl(chain->dev, UVC_SET_CUR, chain->selector->id,
+                              chain->dev->intfnum, UVC_SU_INPUT_SELECT_CONTROL,
+                              &i, 1);
+}
 
-                if ((ret = uvc_acquire_privileges(handle)) < 0)
-                        return ret;
+static int uvc_ioctl_queryctrl(struct file *file, void *fh,
+                               struct v4l2_queryctrl *qc)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
 
-                mutex_lock(&stream->mutex);
-                ret = uvc_alloc_buffers(&stream->queue, arg);
-                mutex_unlock(&stream->mutex);
-                if (ret < 0)
-                        return ret;
+        return uvc_query_v4l2_ctrl(chain, qc);
+}
 
-                if (ret == 0)
-                        uvc_dismiss_privileges(handle);
+static int uvc_ioctl_g_ctrl(struct file *file, void *fh,
+                            struct v4l2_control *ctrl)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
+        struct v4l2_ext_control xctrl;
+        int ret;
 
-                ret = 0;
-                break;
+        memset(&xctrl, 0, sizeof(xctrl));
+        xctrl.id = ctrl->id;
+
+        ret = uvc_ctrl_begin(chain);
+        if (ret < 0)
+                return ret;
 
-        case VIDIOC_QUERYBUF:
-        {
-                struct v4l2_buffer *buf = arg;
+        ret = uvc_ctrl_get(chain, &xctrl);
+        uvc_ctrl_rollback(handle);
+        if (ret < 0)
+                return ret;
 
-                if (!uvc_has_privileges(handle))
-                        return -EBUSY;
+        ctrl->value = xctrl.value;
+        return 0;
+}
 
-                return uvc_query_buffer(&stream->queue, buf);
-        }
+static int uvc_ioctl_s_ctrl(struct file *file, void *fh,
+                            struct v4l2_control *ctrl)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
+        struct v4l2_ext_control xctrl;
+        int ret;
 
-        case VIDIOC_CREATE_BUFS:
-        {
-                struct v4l2_create_buffers *cb = arg;
+        memset(&xctrl, 0, sizeof(xctrl));
+        xctrl.id = ctrl->id;
+        xctrl.value = ctrl->value;
 
-                ret = uvc_acquire_privileges(handle);
-                if (ret < 0)
-                        return ret;
+        ret = uvc_ctrl_begin(chain);
+        if (ret < 0)
+                return ret;
 
-                return uvc_create_buffers(&stream->queue, cb);
+        ret = uvc_ctrl_set(chain, &xctrl);
+        if (ret < 0) {
+                uvc_ctrl_rollback(handle);
+                return ret;
         }
 
-        case VIDIOC_QBUF:
-                if (!uvc_has_privileges(handle))
-                        return -EBUSY;
+        ret = uvc_ctrl_commit(handle, &xctrl, 1);
+        if (ret < 0)
+                return ret;
 
-                return uvc_queue_buffer(&stream->queue, arg);
+        ctrl->value = xctrl.value;
+        return 0;
+}
+
+static int uvc_ioctl_g_ext_ctrls(struct file *file, void *fh,
+                                 struct v4l2_ext_controls *ctrls)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
+        struct v4l2_ext_control *ctrl = ctrls->controls;
+        unsigned int i;
+        int ret;
 
-        case VIDIOC_DQBUF:
-                if (!uvc_has_privileges(handle))
-                        return -EBUSY;
+        ret = uvc_ctrl_begin(chain);
+        if (ret < 0)
+                return ret;
 
-                return uvc_dequeue_buffer(&stream->queue, arg,
-                        file->f_flags & O_NONBLOCK);
+        for (i = 0; i < ctrls->count; ++ctrl, ++i) {
+                ret = uvc_ctrl_get(chain, ctrl);
+                if (ret < 0) {
+                        uvc_ctrl_rollback(handle);
+                        ctrls->error_idx = i;
+                        return ret;
+                }
+        }
 
-        case VIDIOC_STREAMON:
-        {
-                int *type = arg;
+        ctrls->error_idx = 0;
 
-                if (*type != stream->type)
-                        return -EINVAL;
+        return uvc_ctrl_rollback(handle);
+}
 
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
+static int uvc_ioctl_s_try_ext_ctrls(struct uvc_fh *handle,
+                                     struct v4l2_ext_controls *ctrls,
+                                     bool commit)
+{
+        struct v4l2_ext_control *ctrl = ctrls->controls;
+        struct uvc_video_chain *chain = handle->chain;
+        unsigned int i;
+        int ret;
 
-                if (!uvc_has_privileges(handle))
-                        return -EBUSY;
+        ret = uvc_ctrl_begin(chain);
+        if (ret < 0)
+                return ret;
 
-                mutex_lock(&stream->mutex);
-                ret = uvc_video_enable(stream, 1);
-                mutex_unlock(&stream->mutex);
-                if (ret < 0)
+        for (i = 0; i < ctrls->count; ++ctrl, ++i) {
+                ret = uvc_ctrl_set(chain, ctrl);
+                if (ret < 0) {
+                        uvc_ctrl_rollback(handle);
+                        ctrls->error_idx = commit ? ctrls->count : i;
                         return ret;
-                break;
+                }
         }
 
-        case VIDIOC_STREAMOFF:
-        {
-                int *type = arg;
+        ctrls->error_idx = 0;
 
-                if (*type != stream->type)
-                        return -EINVAL;
+        if (commit)
+                return uvc_ctrl_commit(handle, ctrls->controls, ctrls->count);
+        else
+                return uvc_ctrl_rollback(handle);
+}
 
-                ret = v4l2_prio_check(vdev->prio, handle->vfh.prio);
-                if (ret < 0)
-                        return ret;
+static int uvc_ioctl_s_ext_ctrls(struct file *file, void *fh,
+                                 struct v4l2_ext_controls *ctrls)
+{
+        struct uvc_fh *handle = fh;
+
+        return uvc_ioctl_s_try_ext_ctrls(handle, ctrls, true);
+}
 
-                if (!uvc_has_privileges(handle))
-                        return -EBUSY;
+static int uvc_ioctl_try_ext_ctrls(struct file *file, void *fh,
+                                   struct v4l2_ext_controls *ctrls)
+{
+        struct uvc_fh *handle = fh;
 
-                return uvc_video_enable(stream, 0);
+        return uvc_ioctl_s_try_ext_ctrls(handle, ctrls, false);
+}
+
+static int uvc_ioctl_querymenu(struct file *file, void *fh,
+                               struct v4l2_querymenu *qm)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
+
+        return uvc_query_v4l2_menu(chain, qm);
+}
+
+static int uvc_ioctl_cropcap(struct file *file, void *fh,
+                             struct v4l2_cropcap *ccap)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+
+        if (ccap->type != stream->type)
+                return -EINVAL;
+
+        ccap->bounds.left = 0;
+        ccap->bounds.top = 0;
+        mutex_lock(&stream->mutex);
+        ccap->bounds.width = stream->cur_frame->wWidth;
+        ccap->bounds.height = stream->cur_frame->wHeight;
+        mutex_unlock(&stream->mutex);
+
+        ccap->defrect = ccap->bounds;
+
+        ccap->pixelaspect.numerator = 1;
+        ccap->pixelaspect.denominator = 1;
+        return 0;
+}
+
+static int uvc_ioctl_g_parm(struct file *file, void *fh,
+                            struct v4l2_streamparm *parm)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+
+        return uvc_v4l2_get_streamparm(stream, parm);
+}
+
+static int uvc_ioctl_s_parm(struct file *file, void *fh,
+                            struct v4l2_streamparm *parm)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        int ret;
+
+        ret = uvc_acquire_privileges(handle);
+        if (ret < 0)
+                return ret;
+
+        return uvc_v4l2_set_streamparm(stream, parm);
+}
+
+static int uvc_ioctl_enum_framesizes(struct file *file, void *fh,
+                                     struct v4l2_frmsizeenum *fsize)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        struct uvc_format *format = NULL;
+        struct uvc_frame *frame;
+        int i;
+
+        /* Look for the given pixel format */
+        for (i = 0; i < stream->nformats; i++) {
+                if (stream->format[i].fcc == fsize->pixel_format) {
+                        format = &stream->format[i];
+                        break;
+                }
         }
+        if (format == NULL)
+                return -EINVAL;
 
-        case VIDIOC_SUBSCRIBE_EVENT:
-        {
-                struct v4l2_event_subscription *sub = arg;
+        if (fsize->index >= format->nframes)
+                return -EINVAL;
 
-                switch (sub->type) {
-                case V4L2_EVENT_CTRL:
-                        return v4l2_event_subscribe(&handle->vfh, sub, 0,
-                                                    &uvc_ctrl_sub_ev_ops);
-                default:
-                        return -EINVAL;
+        frame = &format->frame[fsize->index];
+        fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+        fsize->discrete.width = frame->wWidth;
+        fsize->discrete.height = frame->wHeight;
+        return 0;
+}
+
+static int uvc_ioctl_enum_frameintervals(struct file *file, void *fh,
+                                         struct v4l2_frmivalenum *fival)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_streaming *stream = handle->stream;
+        struct uvc_format *format = NULL;
+        struct uvc_frame *frame = NULL;
+        int i;
+
+        /* Look for the given pixel format and frame size */
+        for (i = 0; i < stream->nformats; i++) {
+                if (stream->format[i].fcc == fival->pixel_format) {
+                        format = &stream->format[i];
+                        break;
                 }
         }
+        if (format == NULL)
+                return -EINVAL;
 
-        case VIDIOC_UNSUBSCRIBE_EVENT:
-                return v4l2_event_unsubscribe(&handle->vfh, arg);
+        for (i = 0; i < format->nframes; i++) {
+                if (format->frame[i].wWidth == fival->width &&
+                    format->frame[i].wHeight == fival->height) {
+                        frame = &format->frame[i];
+                        break;
+                }
+        }
+        if (frame == NULL)
+                return -EINVAL;
 
-        case VIDIOC_DQEVENT:
-                return v4l2_event_dequeue(&handle->vfh, arg,
-                                          file->f_flags & O_NONBLOCK);
+        if (frame->bFrameIntervalType) {
+                if (fival->index >= frame->bFrameIntervalType)
+                        return -EINVAL;
 
-        /* Analog video standards make no sense for digital cameras. */
-        case VIDIOC_ENUMSTD:
-        case VIDIOC_QUERYSTD:
-        case VIDIOC_G_STD:
-        case VIDIOC_S_STD:
+                fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
+                fival->discrete.numerator =
+                        frame->dwFrameInterval[fival->index];
+                fival->discrete.denominator = 10000000;
+                uvc_simplify_fraction(&fival->discrete.numerator,
+                        &fival->discrete.denominator, 8, 333);
+        } else {
+                fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
+                fival->stepwise.min.numerator = frame->dwFrameInterval[0];
+                fival->stepwise.min.denominator = 10000000;
+                fival->stepwise.max.numerator = frame->dwFrameInterval[1];
+                fival->stepwise.max.denominator = 10000000;
+                fival->stepwise.step.numerator = frame->dwFrameInterval[2];
+                fival->stepwise.step.denominator = 10000000;
+                uvc_simplify_fraction(&fival->stepwise.min.numerator,
+                        &fival->stepwise.min.denominator, 8, 333);
+                uvc_simplify_fraction(&fival->stepwise.max.numerator,
+                        &fival->stepwise.max.denominator, 8, 333);
+                uvc_simplify_fraction(&fival->stepwise.step.numerator,
+                        &fival->stepwise.step.denominator, 8, 333);
+        }
 
-        case VIDIOC_OVERLAY:
+        return 0;
+}
 
-        case VIDIOC_ENUMAUDIO:
-        case VIDIOC_ENUMAUDOUT:
+static int uvc_ioctl_subscribe_event(struct v4l2_fh *fh,
+                                     const struct v4l2_event_subscription *sub)
+{
+        switch (sub->type) {
+        case V4L2_EVENT_CTRL:
+                return v4l2_event_subscribe(fh, sub, 0, &uvc_ctrl_sub_ev_ops);
+        default:
+                return -EINVAL;
+        }
+}
 
-        case VIDIOC_ENUMOUTPUT:
-                uvc_trace(UVC_TRACE_IOCTL, "Unsupported ioctl 0x%08x\n", cmd);
-                return -ENOTTY;
+static long uvc_ioctl_default(struct file *file, void *fh, bool valid_prio,
+                              unsigned int cmd, void *arg)
+{
+        struct uvc_fh *handle = fh;
+        struct uvc_video_chain *chain = handle->chain;
 
+        switch (cmd) {
+        /* Dynamic controls. */
         case UVCIOC_CTRL_MAP:
                 return uvc_ioctl_ctrl_map(chain, arg);
 
@@ -1105,23 +1178,8 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 return uvc_xu_ctrl_query(chain, arg);
 
         default:
-                uvc_trace(UVC_TRACE_IOCTL, "Unknown ioctl 0x%08x\n", cmd);
                 return -ENOTTY;
         }
-
-        return ret;
-}
-
-static long uvc_v4l2_ioctl(struct file *file,
-                     unsigned int cmd, unsigned long arg)
-{
-        if (uvc_trace_param & UVC_TRACE_IOCTL) {
-                uvc_printk(KERN_DEBUG, "uvc_v4l2_ioctl(");
-                v4l_printk_ioctl(NULL, cmd);
-                printk(")\n");
-        }
-
-        return video_usercopy(file, cmd, arg, uvc_v4l2_do_ioctl);
 }
 
 #ifdef CONFIG_COMPAT
@@ -1304,7 +1362,7 @@ static long uvc_v4l2_compat_ioctl32(struct file *file,
 
         old_fs = get_fs();
         set_fs(KERNEL_DS);
-        ret = uvc_v4l2_ioctl(file, cmd, (unsigned long)&karg);
+        ret = video_ioctl2(file, cmd, (unsigned long)&karg);
         set_fs(old_fs);
 
         if (ret < 0)
@@ -1365,11 +1423,48 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
 }
 #endif
 
+const struct v4l2_ioctl_ops uvc_ioctl_ops = {
+        .vidioc_querycap = uvc_ioctl_querycap,
+        .vidioc_enum_fmt_vid_cap = uvc_ioctl_enum_fmt_vid_cap,
+        .vidioc_enum_fmt_vid_out = uvc_ioctl_enum_fmt_vid_out,
+        .vidioc_g_fmt_vid_cap = uvc_ioctl_g_fmt_vid_cap,
+        .vidioc_g_fmt_vid_out = uvc_ioctl_g_fmt_vid_out,
+        .vidioc_s_fmt_vid_cap = uvc_ioctl_s_fmt_vid_cap,
+        .vidioc_s_fmt_vid_out = uvc_ioctl_s_fmt_vid_out,
+        .vidioc_try_fmt_vid_cap = uvc_ioctl_try_fmt_vid_cap,
+        .vidioc_try_fmt_vid_out = uvc_ioctl_try_fmt_vid_out,
+        .vidioc_reqbufs = uvc_ioctl_reqbufs,
+        .vidioc_querybuf = uvc_ioctl_querybuf,
+        .vidioc_qbuf = uvc_ioctl_qbuf,
+        .vidioc_dqbuf = uvc_ioctl_dqbuf,
+        .vidioc_create_bufs = uvc_ioctl_create_bufs,
+        .vidioc_streamon = uvc_ioctl_streamon,
+        .vidioc_streamoff = uvc_ioctl_streamoff,
+        .vidioc_enum_input = uvc_ioctl_enum_input,
+        .vidioc_g_input = uvc_ioctl_g_input,
+        .vidioc_s_input = uvc_ioctl_s_input,
+        .vidioc_queryctrl = uvc_ioctl_queryctrl,
+        .vidioc_g_ctrl = uvc_ioctl_g_ctrl,
+        .vidioc_s_ctrl = uvc_ioctl_s_ctrl,
+        .vidioc_g_ext_ctrls = uvc_ioctl_g_ext_ctrls,
+        .vidioc_s_ext_ctrls = uvc_ioctl_s_ext_ctrls,
+        .vidioc_try_ext_ctrls = uvc_ioctl_try_ext_ctrls,
+        .vidioc_querymenu = uvc_ioctl_querymenu,
+        .vidioc_cropcap = uvc_ioctl_cropcap,
+        .vidioc_g_parm = uvc_ioctl_g_parm,
+        .vidioc_s_parm = uvc_ioctl_s_parm,
+        .vidioc_enum_framesizes = uvc_ioctl_enum_framesizes,
+        .vidioc_enum_frameintervals = uvc_ioctl_enum_frameintervals,
+        .vidioc_subscribe_event = uvc_ioctl_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
+        .vidioc_default = uvc_ioctl_default,
+};
+
 const struct v4l2_file_operations uvc_fops = {
         .owner          = THIS_MODULE,
         .open           = uvc_v4l2_open,
         .release        = uvc_v4l2_release,
-        .unlocked_ioctl = uvc_v4l2_ioctl,
+        .unlocked_ioctl = video_ioctl2,
 #ifdef CONFIG_COMPAT
         .compat_ioctl32 = uvc_v4l2_compat_ioctl32,
 #endif
diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c
index df81b9c4faf1..9637e8b86949 100644
--- a/drivers/media/usb/uvc/uvc_video.c
+++ b/drivers/media/usb/uvc/uvc_video.c
@@ -1021,6 +1021,7 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
 
                 uvc_video_get_ts(&ts);
 
+                buf->buf.v4l2_buf.field = V4L2_FIELD_NONE;
                 buf->buf.v4l2_buf.sequence = stream->sequence;
                 buf->buf.v4l2_buf.timestamp.tv_sec = ts.tv_sec;
                 buf->buf.v4l2_buf.timestamp.tv_usec =
@@ -1734,19 +1735,13 @@ int uvc_video_resume(struct uvc_streaming *stream, int reset)
         uvc_video_clock_reset(stream);
 
         ret = uvc_commit_video(stream, &stream->ctrl);
-        if (ret < 0) {
-                uvc_queue_enable(&stream->queue, 0);
+        if (ret < 0)
                 return ret;
-        }
 
         if (!uvc_queue_streaming(&stream->queue))
                 return 0;
 
-        ret = uvc_init_video(stream, GFP_NOIO);
-        if (ret < 0)
-                uvc_queue_enable(&stream->queue, 0);
-
-        return ret;
+        return uvc_init_video(stream, GFP_NOIO);
 }
 
 /* ------------------------------------------------------------------------
@@ -1778,11 +1773,6 @@ int uvc_video_init(struct uvc_streaming *stream)
 
         atomic_set(&stream->active, 0);
 
-        /* Initialize the video buffers queue. */
-        ret = uvc_queue_init(&stream->queue, stream->type, !uvc_no_drop_param);
-        if (ret)
-                return ret;
-
         /* Alternate setting 0 should be the default, yet the XBox Live Vision
          * Cam (and possibly other devices) crash or otherwise misbehave if
          * they don't receive a SET_INTERFACE request before any other video
@@ -1889,7 +1879,6 @@ int uvc_video_enable(struct uvc_streaming *stream, int enable)
                         usb_clear_halt(stream->dev->udev, pipe);
                 }
 
-                uvc_queue_enable(&stream->queue, 0);
                 uvc_video_clock_cleanup(stream);
                 return 0;
         }
@@ -1898,10 +1887,6 @@ int uvc_video_enable(struct uvc_streaming *stream, int enable)
         if (ret < 0)
                 return ret;
 
-        ret = uvc_queue_enable(&stream->queue, 1);
-        if (ret < 0)
-                goto error_queue;
-
         /* Commit the streaming parameters. */
         ret = uvc_commit_video(stream, &stream->ctrl);
         if (ret < 0)
@@ -1916,8 +1901,6 @@ int uvc_video_enable(struct uvc_streaming *stream, int enable)
 error_video:
         usb_set_interface(stream->dev->udev, stream->intfnum, 0);
 error_commit:
-        uvc_queue_enable(&stream->queue, 0);
-error_queue:
         uvc_video_clock_cleanup(stream);
 
         return ret;
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index 864ada740360..f0a04b532ede 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -148,6 +148,7 @@
 #define UVC_QUIRK_PROBE_DEF             0x00000100
 #define UVC_QUIRK_RESTRICT_FRAME_RATE   0x00000200
 #define UVC_QUIRK_RESTORE_CTRLS_ON_INIT 0x00000400
+#define UVC_QUIRK_FORCE_Y8              0x00000800
 
 /* Format flags */
 #define UVC_FMT_FLAG_COMPRESSED         0x00000001
@@ -579,7 +580,6 @@ struct uvc_driver {
 #define UVC_TRACE_FORMAT        (1 << 3)
 #define UVC_TRACE_CAPTURE       (1 << 4)
 #define UVC_TRACE_CALLS         (1 << 5)
-#define UVC_TRACE_IOCTL         (1 << 6)
 #define UVC_TRACE_FRAME         (1 << 7)
 #define UVC_TRACE_SUSPEND       (1 << 8)
 #define UVC_TRACE_STATUS        (1 << 9)
@@ -623,9 +623,9 @@ extern struct uvc_entity *uvc_entity_by_id(struct uvc_device *dev, int id);
 /* Video buffers queue management. */
 extern int uvc_queue_init(struct uvc_video_queue *queue,
                 enum v4l2_buf_type type, int drop_corrupted);
-extern int uvc_alloc_buffers(struct uvc_video_queue *queue,
+extern void uvc_queue_release(struct uvc_video_queue *queue);
+extern int uvc_request_buffers(struct uvc_video_queue *queue,
                 struct v4l2_requestbuffers *rb);
-extern void uvc_free_buffers(struct uvc_video_queue *queue);
 extern int uvc_query_buffer(struct uvc_video_queue *queue,
                 struct v4l2_buffer *v4l2_buf);
 extern int uvc_create_buffers(struct uvc_video_queue *queue,
@@ -634,7 +634,10 @@ extern int uvc_queue_buffer(struct uvc_video_queue *queue,
                 struct v4l2_buffer *v4l2_buf);
 extern int uvc_dequeue_buffer(struct uvc_video_queue *queue,
                 struct v4l2_buffer *v4l2_buf, int nonblocking);
-extern int uvc_queue_enable(struct uvc_video_queue *queue, int enable);
+extern int uvc_queue_streamon(struct uvc_video_queue *queue,
+                              enum v4l2_buf_type type);
+extern int uvc_queue_streamoff(struct uvc_video_queue *queue,
+                               enum v4l2_buf_type type);
 extern void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect);
 extern struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
                 struct uvc_buffer *buf);
@@ -653,6 +656,7 @@ static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
 }
 
 /* V4L2 interface */
+extern const struct v4l2_ioctl_ops uvc_ioctl_ops;
 extern const struct v4l2_file_operations uvc_fops;
 
 /* Media controller */
diff --git a/drivers/media/v4l2-core/v4l2-common.c b/drivers/media/v4l2-core/v4l2-common.c
index 2e9d81f4c1a5..5b808500e7e7 100644
--- a/drivers/media/v4l2-core/v4l2-common.c
+++ b/drivers/media/v4l2-core/v4l2-common.c
@@ -80,36 +80,6 @@ MODULE_LICENSE("GPL");
 
 /* Helper functions for control handling                             */
 
-/* Check for correctness of the ctrl's value based on the data from
-   struct v4l2_queryctrl and the available menu items. Note that
-   menu_items may be NULL, in that case it is ignored. */
-int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
-                const char * const *menu_items)
-{
-        if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
-                return -EINVAL;
-        if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
-                return -EBUSY;
-        if (qctrl->type == V4L2_CTRL_TYPE_STRING)
-                return 0;
-        if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
-            qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
-            qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
-                return 0;
-        if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
-                return -ERANGE;
-        if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
-                if (menu_items[ctrl->value] == NULL ||
-                    menu_items[ctrl->value][0] == '\0')
-                        return -EINVAL;
-        }
-        if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
-                        (ctrl->value & ~qctrl->maximum))
-                return -ERANGE;
-        return 0;
-}
-EXPORT_SYMBOL(v4l2_ctrl_check);
-
 /* Fill in a struct v4l2_queryctrl */
 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 _min, s32 _max, s32 _step, s32 _def)
 {
@@ -135,101 +105,6 @@ int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 _min, s32 _max, s32 _
 }
 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
 
-/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
-   the menu. The qctrl pointer may be NULL, in which case it is ignored.
-   If menu_items is NULL, then the menu items are retrieved using
-   v4l2_ctrl_get_menu. */
-int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
-               const char * const *menu_items)
-{
-        int i;
-
-        qmenu->reserved = 0;
-        if (menu_items == NULL)
-                menu_items = v4l2_ctrl_get_menu(qmenu->id);
-        if (menu_items == NULL ||
-            (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
-                return -EINVAL;
-        for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
-        if (menu_items[i] == NULL || menu_items[i][0] == '\0')
-                return -EINVAL;
-        strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
-        return 0;
-}
-EXPORT_SYMBOL(v4l2_ctrl_query_menu);
-
-/* Fill in a struct v4l2_querymenu based on the specified array of valid
-   menu items (terminated by V4L2_CTRL_MENU_IDS_END).
-   Use this if there are 'holes' in the list of valid menu items. */
-int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
-{
-        const char * const *menu_items = v4l2_ctrl_get_menu(qmenu->id);
-
-        qmenu->reserved = 0;
-        if (menu_items == NULL || ids == NULL)
-                return -EINVAL;
-        while (*ids != V4L2_CTRL_MENU_IDS_END) {
-                if (*ids++ == qmenu->index) {
-                        strlcpy(qmenu->name, menu_items[qmenu->index],
-                                        sizeof(qmenu->name));
-                        return 0;
-                }
-        }
-        return -EINVAL;
-}
-EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
-
-/* ctrl_classes points to an array of u32 pointers, the last element is
-   a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
-   Each array must be sorted low to high and belong to the same control
-   class. The array of u32 pointers must also be sorted, from low class IDs
-   to high class IDs.
-
-   This function returns the first ID that follows after the given ID.
-   When no more controls are available 0 is returned. */
-u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
-{
-        u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
-        const u32 *pctrl;
-
-        if (ctrl_classes == NULL)
-                return 0;
-
-        /* if no query is desired, then check if the ID is part of ctrl_classes */
-        if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
-                /* find class */
-                while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
-                        ctrl_classes++;
-                if (*ctrl_classes == NULL)
-                        return 0;
-                pctrl = *ctrl_classes;
-                /* find control ID */
-                while (*pctrl && *pctrl != id) pctrl++;
-                return *pctrl ? id : 0;
-        }
-        id &= V4L2_CTRL_ID_MASK;
-        id++;   /* select next control */
-        /* find first class that matches (or is greater than) the class of
-           the ID */
-        while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
-                ctrl_classes++;
-        /* no more classes */
-        if (*ctrl_classes == NULL)
-                return 0;
-        pctrl = *ctrl_classes;
-        /* find first ctrl within the class that is >= ID */
-        while (*pctrl && *pctrl < id) pctrl++;
-        if (*pctrl)
-                return *pctrl;
-        /* we are at the end of the controls of the current class. */
-        /* continue with next class if available */
-        ctrl_classes++;
-        if (*ctrl_classes == NULL)
-                return 0;
-        return **ctrl_classes;
-}
-EXPORT_SYMBOL(v4l2_ctrl_next);
-
 /* I2C Helper functions */
 
 #if IS_ENABLED(CONFIG_I2C)
diff --git a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c
index e502a5fb2994..af635430524e 100644
--- a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c
+++ b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c
@@ -222,6 +222,9 @@ static int get_v4l2_create32(struct v4l2_create_buffers *kp, struct v4l2_create_
 
 static int __put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
 {
+        if (put_user(kp->type, &up->type))
+                return -EFAULT;
+
         switch (kp->type) {
         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
@@ -248,8 +251,7 @@ static int __put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __us
 
 static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
 {
-        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_format32)) ||
-                put_user(kp->type, &up->type))
+        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_format32)))
                 return -EFAULT;
         return __put_v4l2_format32(kp, up);
 }
@@ -257,8 +259,8 @@ static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user
 static int put_v4l2_create32(struct v4l2_create_buffers *kp, struct v4l2_create_buffers32 __user *up)
 {
         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_create_buffers32)) ||
-            copy_to_user(up, kp, offsetof(struct v4l2_create_buffers32, format.fmt)))
-                        return -EFAULT;
+            copy_to_user(up, kp, offsetof(struct v4l2_create_buffers32, format)))
+                return -EFAULT;
         return __put_v4l2_format32(&kp->format, &up->format);
 }
 
diff --git a/drivers/media/v4l2-core/v4l2-ctrls.c b/drivers/media/v4l2-core/v4l2-ctrls.c
index 86012140923f..45c5b4710601 100644
--- a/drivers/media/v4l2-core/v4l2-ctrls.c
+++ b/drivers/media/v4l2-core/v4l2-ctrls.c
@@ -1658,10 +1658,8 @@ static int check_range(enum v4l2_ctrl_type type,
 }
 
 /* Validate a new control */
-static int validate_new(const struct v4l2_ctrl *ctrl,
-                        struct v4l2_ext_control *c)
+static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
 {
-        union v4l2_ctrl_ptr ptr;
         unsigned idx;
         int err = 0;
 
@@ -1674,19 +1672,14 @@ static int validate_new(const struct v4l2_ctrl *ctrl,
                 case V4L2_CTRL_TYPE_BOOLEAN:
                 case V4L2_CTRL_TYPE_BUTTON:
                 case V4L2_CTRL_TYPE_CTRL_CLASS:
-                        ptr.p_s32 = &c->value;
-                        return ctrl->type_ops->validate(ctrl, 0, ptr);
-
                 case V4L2_CTRL_TYPE_INTEGER64:
-                        ptr.p_s64 = &c->value64;
-                        return ctrl->type_ops->validate(ctrl, 0, ptr);
+                        return ctrl->type_ops->validate(ctrl, 0, p_new);
                 default:
                         break;
                 }
         }
-        ptr.p = c->ptr;
-        for (idx = 0; !err && idx < c->size / ctrl->elem_size; idx++)
-                err = ctrl->type_ops->validate(ctrl, idx, ptr);
+        for (idx = 0; !err && idx < ctrl->elems; idx++)
+                err = ctrl->type_ops->validate(ctrl, idx, p_new);
         return err;
 }
 
@@ -3012,6 +3005,7 @@ static int validate_ctrls(struct v4l2_ext_controls *cs,
         cs->error_idx = cs->count;
         for (i = 0; i < cs->count; i++) {
                 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
+                union v4l2_ctrl_ptr p_new;
 
                 cs->error_idx = i;
 
@@ -3025,7 +3019,17 @@ static int validate_ctrls(struct v4l2_ext_controls *cs,
                    best-effort to avoid that. */
                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
                         return -EBUSY;
-                ret = validate_new(ctrl, &cs->controls[i]);
+                /*
+                 * Skip validation for now if the payload needs to be copied
+                 * from userspace into kernelspace. We'll validate those later.
+                 */
+                if (ctrl->is_ptr)
+                        continue;
+                if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
+                        p_new.p_s64 = &cs->controls[i].value64;
+                else
+                        p_new.p_s32 = &cs->controls[i].value;
+                ret = validate_new(ctrl, p_new);
                 if (ret)
                         return ret;
         }
@@ -3120,7 +3124,11 @@ static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
                 /* Copy the new caller-supplied control values.
                    user_to_new() sets 'is_new' to 1. */
                 do {
-                        ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
+                        struct v4l2_ctrl *ctrl = helpers[idx].ctrl;
+
+                        ret = user_to_new(cs->controls + idx, ctrl);
+                        if (!ret && ctrl->is_ptr)
+                                ret = validate_new(ctrl, ctrl->p_new);
                         idx = helpers[idx].next;
                 } while (!ret && idx);
 
@@ -3170,10 +3178,10 @@ int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs
 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
 
 /* Helper function for VIDIOC_S_CTRL compatibility */
-static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
-                    struct v4l2_ext_control *c, u32 ch_flags)
+static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
 {
         struct v4l2_ctrl *master = ctrl->cluster[0];
+        int ret;
         int i;
 
         /* Reset the 'is_new' flags of the cluster */
@@ -3181,8 +3189,9 @@ static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
                 if (master->cluster[i])
                         master->cluster[i]->is_new = 0;
 
-        if (c)
-                user_to_new(c, ctrl);
+        ret = validate_new(ctrl, ctrl->p_new);
+        if (ret)
+                return ret;
 
         /* For autoclusters with volatiles that are switched from auto to
            manual mode we have to update the current volatile values since
@@ -3199,15 +3208,14 @@ static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
                          struct v4l2_ext_control *c)
 {
-        int ret = validate_new(ctrl, c);
+        int ret;
 
-        if (!ret) {
-                v4l2_ctrl_lock(ctrl);
-                ret = set_ctrl(fh, ctrl, c, 0);
-                if (!ret)
-                        cur_to_user(c, ctrl);
-                v4l2_ctrl_unlock(ctrl);
-        }
+        v4l2_ctrl_lock(ctrl);
+        user_to_new(c, ctrl);
+        ret = set_ctrl(fh, ctrl, 0);
+        if (!ret)
+                cur_to_user(c, ctrl);
+        v4l2_ctrl_unlock(ctrl);
         return ret;
 }
 
@@ -3215,7 +3223,7 @@ int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
                                         struct v4l2_control *control)
 {
         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
-        struct v4l2_ext_control c;
+        struct v4l2_ext_control c = { control->id };
         int ret;
 
         if (ctrl == NULL || !ctrl->is_int)
@@ -3244,7 +3252,7 @@ int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
         /* It's a driver bug if this happens. */
         WARN_ON(!ctrl->is_int);
         ctrl->val = val;
-        return set_ctrl(NULL, ctrl, NULL, 0);
+        return set_ctrl(NULL, ctrl, 0);
 }
 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
 
@@ -3255,7 +3263,7 @@ int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
         /* It's a driver bug if this happens. */
         WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
         *ctrl->p_new.p_s64 = val;
-        return set_ctrl(NULL, ctrl, NULL, 0);
+        return set_ctrl(NULL, ctrl, 0);
 }
 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
 
@@ -3266,7 +3274,7 @@ int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
         /* It's a driver bug if this happens. */
         WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING);
         strlcpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
-        return set_ctrl(NULL, ctrl, NULL, 0);
+        return set_ctrl(NULL, ctrl, 0);
 }
 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
 
@@ -3289,8 +3297,8 @@ EXPORT_SYMBOL(v4l2_ctrl_notify);
 int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
                         s64 min, s64 max, u64 step, s64 def)
 {
+        bool changed;
         int ret;
-        struct v4l2_ext_control c;
 
         lockdep_assert_held(ctrl->handler->lock);
 
@@ -3317,11 +3325,20 @@ int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
         ctrl->maximum = max;
         ctrl->step = step;
         ctrl->default_value = def;
-        c.value = *ctrl->p_cur.p_s32;
-        if (validate_new(ctrl, &c))
-                c.value = def;
-        if (c.value != *ctrl->p_cur.p_s32)
-                ret = set_ctrl(NULL, ctrl, &c, V4L2_EVENT_CTRL_CH_RANGE);
+        cur_to_new(ctrl);
+        if (validate_new(ctrl, ctrl->p_new)) {
+                if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
+                        *ctrl->p_new.p_s64 = def;
+                else
+                        *ctrl->p_new.p_s32 = def;
+        }
+
+        if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
+                changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
+        else
+                changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
+        if (changed)
+                ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
         else
                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
         return ret;
diff --git a/drivers/media/v4l2-core/v4l2-dev.c b/drivers/media/v4l2-core/v4l2-dev.c
index 33617c365acc..9aa530a8bea9 100644
--- a/drivers/media/v4l2-core/v4l2-dev.c
+++ b/drivers/media/v4l2-core/v4l2-dev.c
@@ -194,7 +194,7 @@ static void v4l2_device_release(struct device *cd)
         mutex_unlock(&videodev_lock);
 
 #if defined(CONFIG_MEDIA_CONTROLLER)
-        if (v4l2_dev && v4l2_dev->mdev &&
+        if (v4l2_dev->mdev &&
             vdev->vfl_type != VFL_TYPE_SUBDEV)
                 media_device_unregister_entity(&vdev->entity);
 #endif
@@ -207,7 +207,7 @@ static void v4l2_device_release(struct device *cd)
          * TODO: In the long run all drivers that use v4l2_device should use the
          * v4l2_device release callback. This check will then be unnecessary.
          */
-        if (v4l2_dev && v4l2_dev->release == NULL)
+        if (v4l2_dev->release == NULL)
                 v4l2_dev = NULL;
 
         /* Release video_device and perform other
@@ -360,27 +360,22 @@ static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                  * hack but it will have to do for those drivers that are not
                  * yet converted to use unlocked_ioctl.
                  *
-                 * There are two options: if the driver implements struct
-                 * v4l2_device, then the lock defined there is used to
-                 * serialize the ioctls. Otherwise the v4l2 core lock defined
-                 * below is used. This lock is really bad since it serializes
-                 * completely independent devices.
+                 * All drivers implement struct v4l2_device, so we use the
+                 * lock defined there to serialize the ioctls.
                  *
-                 * Both variants suffer from the same problem: if the driver
-                 * sleeps, then it blocks all ioctls since the lock is still
-                 * held. This is very common for VIDIOC_DQBUF since that
-                 * normally waits for a frame to arrive. As a result any other
-                 * ioctl calls will proceed very, very slowly since each call
-                 * will have to wait for the VIDIOC_QBUF to finish. Things that
-                 * should take 0.01s may now take 10-20 seconds.
+                 * However, if the driver sleeps, then it blocks all ioctls
+                 * since the lock is still held. This is very common for
+                 * VIDIOC_DQBUF since that normally waits for a frame to arrive.
+                 * As a result any other ioctl calls will proceed very, very
+                 * slowly since each call will have to wait for the VIDIOC_QBUF
+                 * to finish. Things that should take 0.01s may now take 10-20
+                 * seconds.
                  *
                  * The workaround is to *not* take the lock for VIDIOC_DQBUF.
                  * This actually works OK for videobuf-based drivers, since
                  * videobuf will take its own internal lock.
                  */
-                static DEFINE_MUTEX(v4l2_ioctl_mutex);
-                struct mutex *m = vdev->v4l2_dev ?
-                        &vdev->v4l2_dev->ioctl_lock : &v4l2_ioctl_mutex;
+                struct mutex *m = &vdev->v4l2_dev->ioctl_lock;
 
                 if (cmd != VIDIOC_DQBUF && mutex_lock_interruptible(m))
                         return -ERESTARTSYS;
@@ -938,12 +933,11 @@ int __video_register_device(struct video_device *vdev, int type, int nr,
                         name_base, nr, video_device_node_name(vdev));
 
         /* Increase v4l2_device refcount */
-        if (vdev->v4l2_dev)
-                v4l2_device_get(vdev->v4l2_dev);
+        v4l2_device_get(vdev->v4l2_dev);
 
 #if defined(CONFIG_MEDIA_CONTROLLER)
         /* Part 5: Register the entity. */
-        if (vdev->v4l2_dev && vdev->v4l2_dev->mdev &&
+        if (vdev->v4l2_dev->mdev &&
             vdev->vfl_type != VFL_TYPE_SUBDEV) {
                 vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
                 vdev->entity.name = vdev->name;
diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index 9ccb19a435ef..75658717961f 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -257,7 +257,7 @@ static void v4l_print_format(const void *arg, bool write_only)
                 pr_cont(", width=%u, height=%u, "
                         "pixelformat=%c%c%c%c, field=%s, "
                         "bytesperline=%u, sizeimage=%u, colorspace=%d, "
-                        "flags %u\n",
+                        "flags %x, ycbcr_enc=%u, quantization=%u\n",
                         pix->width, pix->height,
                         (pix->pixelformat & 0xff),
                         (pix->pixelformat >>  8) & 0xff,
@@ -265,21 +265,24 @@ static void v4l_print_format(const void *arg, bool write_only)
                         (pix->pixelformat >> 24) & 0xff,
                         prt_names(pix->field, v4l2_field_names),
                         pix->bytesperline, pix->sizeimage,
-                        pix->colorspace, pix->flags);
+                        pix->colorspace, pix->flags, pix->ycbcr_enc,
+                        pix->quantization);
                 break;
         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
                 mp = &p->fmt.pix_mp;
                 pr_cont(", width=%u, height=%u, "
                         "format=%c%c%c%c, field=%s, "
-                        "colorspace=%d, num_planes=%u\n",
+                        "colorspace=%d, num_planes=%u, flags=%x, "
+                        "ycbcr_enc=%u, quantization=%u\n",
                         mp->width, mp->height,
                         (mp->pixelformat & 0xff),
                         (mp->pixelformat >>  8) & 0xff,
                         (mp->pixelformat >> 16) & 0xff,
                         (mp->pixelformat >> 24) & 0xff,
                         prt_names(mp->field, v4l2_field_names),
-                        mp->colorspace, mp->num_planes);
+                        mp->colorspace, mp->num_planes, mp->flags,
+                        mp->ycbcr_enc, mp->quantization);
                 for (i = 0; i < mp->num_planes; i++)
                         printk(KERN_DEBUG "plane %u: bytesperline=%u sizeimage=%u\n", i,
                                         mp->plane_fmt[i].bytesperline,
@@ -1040,7 +1043,7 @@ static int v4l_g_priority(const struct v4l2_ioctl_ops *ops,
         if (ops->vidioc_g_priority)
                 return ops->vidioc_g_priority(file, fh, arg);
         vfd = video_devdata(file);
-        *p = v4l2_prio_max(&vfd->v4l2_dev->prio);
+        *p = v4l2_prio_max(vfd->prio);
         return 0;
 }
 
@@ -1055,7 +1058,7 @@ static int v4l_s_priority(const struct v4l2_ioctl_ops *ops,
                 return ops->vidioc_s_priority(file, fh, *p);
         vfd = video_devdata(file);
         vfh = file->private_data;
-        return v4l2_prio_change(&vfd->v4l2_dev->prio, &vfh->prio, *p);
+        return v4l2_prio_change(vfd->prio, &vfh->prio, *p);
 }
 
 static int v4l_enuminput(const struct v4l2_ioctl_ops *ops,
diff --git a/drivers/media/v4l2-core/videobuf-core.c b/drivers/media/v4l2-core/videobuf-core.c
index b91a266d0b7e..926836d1813a 100644
--- a/drivers/media/v4l2-core/videobuf-core.c
+++ b/drivers/media/v4l2-core/videobuf-core.c
@@ -51,6 +51,8 @@ MODULE_LICENSE("GPL");
 
 #define CALL(q, f, arg...)                                              \
         ((q->int_ops->f) ? q->int_ops->f(arg) : 0)
+#define CALLPTR(q, f, arg...)                                           \
+        ((q->int_ops->f) ? q->int_ops->f(arg) : NULL)
 
 struct videobuf_buffer *videobuf_alloc_vb(struct videobuf_queue *q)
 {
@@ -831,7 +833,7 @@ static int __videobuf_copy_to_user(struct videobuf_queue *q,
                                    char __user *data, size_t count,
                                    int nonblocking)
 {
-        void *vaddr = CALL(q, vaddr, buf);
+        void *vaddr = CALLPTR(q, vaddr, buf);
 
         /* copy to userspace */
         if (count > buf->size - q->read_off)
@@ -848,7 +850,7 @@ static int __videobuf_copy_stream(struct videobuf_queue *q,
                                   char __user *data, size_t count, size_t pos,
                                   int vbihack, int nonblocking)
 {
-        unsigned int *fc = CALL(q, vaddr, buf);
+        unsigned int *fc = CALLPTR(q, vaddr, buf);
 
         if (vbihack) {
                 /* dirty, undocumented hack -- pass the frame counter
diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c
index f2e43de3dd87..d09a8916e940 100644
--- a/drivers/media/v4l2-core/videobuf2-core.c
+++ b/drivers/media/v4l2-core/videobuf2-core.c
@@ -189,6 +189,8 @@ static void __vb2_queue_cancel(struct vb2_queue *q);
 static int __vb2_buf_mem_alloc(struct vb2_buffer *vb)
 {
         struct vb2_queue *q = vb->vb2_queue;
+        enum dma_data_direction dma_dir =
+                V4L2_TYPE_IS_OUTPUT(q->type) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
         void *mem_priv;
         int plane;
 
@@ -200,7 +202,7 @@ static int __vb2_buf_mem_alloc(struct vb2_buffer *vb)
                 unsigned long size = PAGE_ALIGN(q->plane_sizes[plane]);
 
                 mem_priv = call_ptr_memop(vb, alloc, q->alloc_ctx[plane],
-                                      size, q->gfp_flags);
+                                      size, dma_dir, q->gfp_flags);
                 if (IS_ERR_OR_NULL(mem_priv))
                         goto free;
 
@@ -1358,7 +1360,8 @@ static int __qbuf_userptr(struct vb2_buffer *vb, const struct v4l2_buffer *b)
         void *mem_priv;
         unsigned int plane;
         int ret;
-        int write = !V4L2_TYPE_IS_OUTPUT(q->type);
+        enum dma_data_direction dma_dir =
+                V4L2_TYPE_IS_OUTPUT(q->type) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
         bool reacquired = vb->planes[0].mem_priv == NULL;
 
         memset(planes, 0, sizeof(planes[0]) * vb->num_planes);
@@ -1400,7 +1403,7 @@ static int __qbuf_userptr(struct vb2_buffer *vb, const struct v4l2_buffer *b)
                 /* Acquire each plane's memory */
                 mem_priv = call_ptr_memop(vb, get_userptr, q->alloc_ctx[plane],
                                       planes[plane].m.userptr,
-                                      planes[plane].length, write);
+                                      planes[plane].length, dma_dir);
                 if (IS_ERR_OR_NULL(mem_priv)) {
                         dprintk(1, "failed acquiring userspace "
                                                 "memory for plane %d\n", plane);
@@ -1461,7 +1464,8 @@ static int __qbuf_dmabuf(struct vb2_buffer *vb, const struct v4l2_buffer *b)
         void *mem_priv;
         unsigned int plane;
         int ret;
-        int write = !V4L2_TYPE_IS_OUTPUT(q->type);
+        enum dma_data_direction dma_dir =
+                V4L2_TYPE_IS_OUTPUT(q->type) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
         bool reacquired = vb->planes[0].mem_priv == NULL;
 
         memset(planes, 0, sizeof(planes[0]) * vb->num_planes);
@@ -1509,7 +1513,7 @@ static int __qbuf_dmabuf(struct vb2_buffer *vb, const struct v4l2_buffer *b)
 
                 /* Acquire each plane's memory */
                 mem_priv = call_ptr_memop(vb, attach_dmabuf, q->alloc_ctx[plane],
-                        dbuf, planes[plane].length, write);
+                        dbuf, planes[plane].length, dma_dir);
                 if (IS_ERR(mem_priv)) {
                         dprintk(1, "failed to attach dmabuf\n");
                         ret = PTR_ERR(mem_priv);
@@ -3385,14 +3389,14 @@ int _vb2_fop_release(struct file *file, struct mutex *lock)
 {
         struct video_device *vdev = video_devdata(file);
 
+        if (lock)
+                mutex_lock(lock);
         if (file->private_data == vdev->queue->owner) {
-                if (lock)
-                        mutex_lock(lock);
                 vb2_queue_release(vdev->queue);
                 vdev->queue->owner = NULL;
-                if (lock)
-                        mutex_unlock(lock);
         }
+        if (lock)
+                mutex_unlock(lock);
         return v4l2_fh_release(file);
 }
 EXPORT_SYMBOL_GPL(_vb2_fop_release);
@@ -3455,27 +3459,16 @@ unsigned int vb2_fop_poll(struct file *file, poll_table *wait)
         struct video_device *vdev = video_devdata(file);
         struct vb2_queue *q = vdev->queue;
         struct mutex *lock = q->lock ? q->lock : vdev->lock;
-        unsigned long req_events = poll_requested_events(wait);
         unsigned res;
         void *fileio;
-        bool must_lock = false;
-
-        /* Try to be smart: only lock if polling might start fileio,
-           otherwise locking will only introduce unwanted delays. */
-        if (q->num_buffers == 0 && !vb2_fileio_is_active(q)) {
-                if (!V4L2_TYPE_IS_OUTPUT(q->type) && (q->io_modes & VB2_READ) &&
-                                (req_events & (POLLIN | POLLRDNORM)))
-                        must_lock = true;
-                else if (V4L2_TYPE_IS_OUTPUT(q->type) && (q->io_modes & VB2_WRITE) &&
-                                (req_events & (POLLOUT | POLLWRNORM)))
-                        must_lock = true;
-        }
 
-        /* If locking is needed, but this helper doesn't know how, then you
-           shouldn't be using this helper but you should write your own. */
-        WARN_ON(must_lock && !lock);
+        /*
+         * If this helper doesn't know how to lock, then you shouldn't be using
+         * it but you should write your own.
+         */
+        WARN_ON(!lock);
 
-        if (must_lock && lock && mutex_lock_interruptible(lock))
+        if (lock && mutex_lock_interruptible(lock))
                 return POLLERR;
 
         fileio = q->fileio;
@@ -3483,9 +3476,9 @@ unsigned int vb2_fop_poll(struct file *file, poll_table *wait)
         res = vb2_poll(vdev->queue, file, wait);
 
         /* If fileio was started, then we have a new queue owner. */
-        if (must_lock && !fileio && q->fileio)
+        if (!fileio && q->fileio)
                 q->owner = file->private_data;
-        if (must_lock && lock)
+        if (lock)
                 mutex_unlock(lock);
         return res;
 }
diff --git a/drivers/media/v4l2-core/videobuf2-dma-contig.c b/drivers/media/v4l2-core/videobuf2-dma-contig.c
index 4a02ade14b4f..b481d20c8372 100644
--- a/drivers/media/v4l2-core/videobuf2-dma-contig.c
+++ b/drivers/media/v4l2-core/videobuf2-dma-contig.c
@@ -155,7 +155,8 @@ static void vb2_dc_put(void *buf_priv)
         kfree(buf);
 }
 
-static void *vb2_dc_alloc(void *alloc_ctx, unsigned long size, gfp_t gfp_flags)
+static void *vb2_dc_alloc(void *alloc_ctx, unsigned long size,
+                          enum dma_data_direction dma_dir, gfp_t gfp_flags)
 {
         struct vb2_dc_conf *conf = alloc_ctx;
         struct device *dev = conf->dev;
@@ -176,6 +177,7 @@ static void *vb2_dc_alloc(void *alloc_ctx, unsigned long size, gfp_t gfp_flags)
         /* Prevent the device from being released while the buffer is used */
         buf->dev = get_device(dev);
         buf->size = size;
+        buf->dma_dir = dma_dir;
 
         buf->handler.refcount = &buf->refcount;
         buf->handler.put = vb2_dc_put;
@@ -229,7 +231,7 @@ static int vb2_dc_mmap(void *buf_priv, struct vm_area_struct *vma)
 
 struct vb2_dc_attachment {
         struct sg_table sgt;
-        enum dma_data_direction dir;
+        enum dma_data_direction dma_dir;
 };
 
 static int vb2_dc_dmabuf_ops_attach(struct dma_buf *dbuf, struct device *dev,
@@ -264,7 +266,7 @@ static int vb2_dc_dmabuf_ops_attach(struct dma_buf *dbuf, struct device *dev,
                 wr = sg_next(wr);
         }
 
-        attach->dir = DMA_NONE;
+        attach->dma_dir = DMA_NONE;
         dbuf_attach->priv = attach;
 
         return 0;
@@ -282,16 +284,16 @@ static void vb2_dc_dmabuf_ops_detach(struct dma_buf *dbuf,
         sgt = &attach->sgt;
 
         /* release the scatterlist cache */
-        if (attach->dir != DMA_NONE)
+        if (attach->dma_dir != DMA_NONE)
                 dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
-                        attach->dir);
+                        attach->dma_dir);
         sg_free_table(sgt);
         kfree(attach);
         db_attach->priv = NULL;
 }
 
 static struct sg_table *vb2_dc_dmabuf_ops_map(
-        struct dma_buf_attachment *db_attach, enum dma_data_direction dir)
+        struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
 {
         struct vb2_dc_attachment *attach = db_attach->priv;
         /* stealing dmabuf mutex to serialize map/unmap operations */
@@ -303,27 +305,27 @@ static struct sg_table *vb2_dc_dmabuf_ops_map(
 
         sgt = &attach->sgt;
         /* return previously mapped sg table */
-        if (attach->dir == dir) {
+        if (attach->dma_dir == dma_dir) {
                 mutex_unlock(lock);
                 return sgt;
         }
 
         /* release any previous cache */
-        if (attach->dir != DMA_NONE) {
+        if (attach->dma_dir != DMA_NONE) {
                 dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
-                        attach->dir);
-                attach->dir = DMA_NONE;
+                        attach->dma_dir);
+                attach->dma_dir = DMA_NONE;
         }
 
         /* mapping to the client with new direction */
-        ret = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents, dir);
+        ret = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents, dma_dir);
         if (ret <= 0) {
                 pr_err("failed to map scatterlist\n");
                 mutex_unlock(lock);
                 return ERR_PTR(-EIO);
         }
 
-        attach->dir = dir;
+        attach->dma_dir = dma_dir;
 
         mutex_unlock(lock);
 
@@ -331,7 +333,7 @@ static struct sg_table *vb2_dc_dmabuf_ops_map(
 }
 
 static void vb2_dc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
-        struct sg_table *sgt, enum dma_data_direction dir)
+        struct sg_table *sgt, enum dma_data_direction dma_dir)
 {
         /* nothing to be done here */
 }
@@ -460,7 +462,8 @@ static int vb2_dc_get_user_pfn(unsigned long start, int n_pages,
 }
 
 static int vb2_dc_get_user_pages(unsigned long start, struct page **pages,
-        int n_pages, struct vm_area_struct *vma, int write)
+        int n_pages, struct vm_area_struct *vma,
+        enum dma_data_direction dma_dir)
 {
         if (vma_is_io(vma)) {
                 unsigned int i;
@@ -482,7 +485,7 @@ static int vb2_dc_get_user_pages(unsigned long start, struct page **pages,
                 int n;
 
                 n = get_user_pages(current, current->mm, start & PAGE_MASK,
-                        n_pages, write, 1, pages, NULL);
+                        n_pages, dma_dir == DMA_FROM_DEVICE, 1, pages, NULL);
                 /* negative error means that no page was pinned */
                 n = max(n, 0);
                 if (n != n_pages) {
@@ -508,7 +511,15 @@ static void vb2_dc_put_userptr(void *buf_priv)
         struct sg_table *sgt = buf->dma_sgt;
 
         if (sgt) {
-                dma_unmap_sg(buf->dev, sgt->sgl, sgt->orig_nents, buf->dma_dir);
+                DEFINE_DMA_ATTRS(attrs);
+
+                dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
+                /*
+                 * No need to sync to CPU, it's already synced to the CPU
+                 * since the finish() memop will have been called before this.
+                 */
+                dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
+                                   buf->dma_dir, &attrs);
                 if (!vma_is_io(buf->vma))
                         vb2_dc_sgt_foreach_page(sgt, vb2_dc_put_dirty_page);
 
@@ -551,7 +562,7 @@ static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev, unsigned long pfn
 #endif
 
 static void *vb2_dc_get_userptr(void *alloc_ctx, unsigned long vaddr,
-        unsigned long size, int write)
+        unsigned long size, enum dma_data_direction dma_dir)
 {
         struct vb2_dc_conf *conf = alloc_ctx;
         struct vb2_dc_buf *buf;
@@ -565,6 +576,9 @@ static void *vb2_dc_get_userptr(void *alloc_ctx, unsigned long vaddr,
         struct sg_table *sgt;
         unsigned long contig_size;
         unsigned long dma_align = dma_get_cache_alignment();
+        DEFINE_DMA_ATTRS(attrs);
+
+        dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
 
         /* Only cache aligned DMA transfers are reliable */
         if (!IS_ALIGNED(vaddr | size, dma_align)) {
@@ -582,7 +596,7 @@ static void *vb2_dc_get_userptr(void *alloc_ctx, unsigned long vaddr,
                 return ERR_PTR(-ENOMEM);
 
         buf->dev = conf->dev;
-        buf->dma_dir = write ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+        buf->dma_dir = dma_dir;
 
         start = vaddr & PAGE_MASK;
         offset = vaddr & ~PAGE_MASK;
@@ -618,7 +632,8 @@ static void *vb2_dc_get_userptr(void *alloc_ctx, unsigned long vaddr,
         }
 
         /* extract page list from userspace mapping */
-        ret = vb2_dc_get_user_pages(start, pages, n_pages, vma, write);
+        ret = vb2_dc_get_user_pages(start, pages, n_pages, vma,
+                                    dma_dir == DMA_FROM_DEVICE);
         if (ret) {
                 unsigned long pfn;
                 if (vb2_dc_get_user_pfn(start, n_pages, vma, &pfn) == 0) {
@@ -650,8 +665,12 @@ static void *vb2_dc_get_userptr(void *alloc_ctx, unsigned long vaddr,
         kfree(pages);
         pages = NULL;
 
-        sgt->nents = dma_map_sg(buf->dev, sgt->sgl, sgt->orig_nents,
-                buf->dma_dir);
+        /*
+         * No need to sync to the device, this will happen later when the
+         * prepare() memop is called.
+         */
+        sgt->nents = dma_map_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
+                                      buf->dma_dir, &attrs);
         if (sgt->nents <= 0) {
                 pr_err("failed to map scatterlist\n");
                 ret = -EIO;
@@ -673,7 +692,8 @@ static void *vb2_dc_get_userptr(void *alloc_ctx, unsigned long vaddr,
         return buf;
 
 fail_map_sg:
-        dma_unmap_sg(buf->dev, sgt->sgl, sgt->orig_nents, buf->dma_dir);
+        dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
+                           buf->dma_dir, &attrs);
 
 fail_sgt_init:
         if (!vma_is_io(buf->vma))
@@ -782,7 +802,7 @@ static void vb2_dc_detach_dmabuf(void *mem_priv)
 }
 
 static void *vb2_dc_attach_dmabuf(void *alloc_ctx, struct dma_buf *dbuf,
-        unsigned long size, int write)
+        unsigned long size, enum dma_data_direction dma_dir)
 {
         struct vb2_dc_conf *conf = alloc_ctx;
         struct vb2_dc_buf *buf;
@@ -804,7 +824,7 @@ static void *vb2_dc_attach_dmabuf(void *alloc_ctx, struct dma_buf *dbuf,
                 return dba;
         }
 
-        buf->dma_dir = write ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+        buf->dma_dir = dma_dir;
         buf->size = size;
         buf->db_attach = dba;
 
@@ -850,7 +870,8 @@ EXPORT_SYMBOL_GPL(vb2_dma_contig_init_ctx);
 
 void vb2_dma_contig_cleanup_ctx(void *alloc_ctx)
 {
-        kfree(alloc_ctx);
+        if (!IS_ERR_OR_NULL(alloc_ctx))
+                kfree(alloc_ctx);
 }
 EXPORT_SYMBOL_GPL(vb2_dma_contig_cleanup_ctx);
 
diff --git a/drivers/media/v4l2-core/videobuf2-dma-sg.c b/drivers/media/v4l2-core/videobuf2-dma-sg.c
index 9b163a440f89..b1838abb6d00 100644
--- a/drivers/media/v4l2-core/videobuf2-dma-sg.c
+++ b/drivers/media/v4l2-core/videobuf2-dma-sg.c
@@ -30,17 +30,30 @@ module_param(debug, int, 0644);
                         printk(KERN_DEBUG "vb2-dma-sg: " fmt, ## arg);  \
         } while (0)
 
+struct vb2_dma_sg_conf {
+        struct device           *dev;
+};
+
 struct vb2_dma_sg_buf {
+        struct device                   *dev;
         void                            *vaddr;
         struct page                     **pages;
-        int                             write;
         int                             offset;
+        enum dma_data_direction         dma_dir;
         struct sg_table                 sg_table;
+        /*
+         * This will point to sg_table when used with the MMAP or USERPTR
+         * memory model, and to the dma_buf sglist when used with the
+         * DMABUF memory model.
+         */
+        struct sg_table                 *dma_sgt;
         size_t                          size;
         unsigned int                    num_pages;
         atomic_t                        refcount;
         struct vb2_vmarea_handler       handler;
         struct vm_area_struct           *vma;
+
+        struct dma_buf_attachment       *db_attach;
 };
 
 static void vb2_dma_sg_put(void *buf_priv);
@@ -86,22 +99,31 @@ static int vb2_dma_sg_alloc_compacted(struct vb2_dma_sg_buf *buf,
         return 0;
 }
 
-static void *vb2_dma_sg_alloc(void *alloc_ctx, unsigned long size, gfp_t gfp_flags)
+static void *vb2_dma_sg_alloc(void *alloc_ctx, unsigned long size,
+                              enum dma_data_direction dma_dir, gfp_t gfp_flags)
 {
+        struct vb2_dma_sg_conf *conf = alloc_ctx;
         struct vb2_dma_sg_buf *buf;
+        struct sg_table *sgt;
         int ret;
         int num_pages;
+        DEFINE_DMA_ATTRS(attrs);
 
+        dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
+
+        if (WARN_ON(alloc_ctx == NULL))
+                return NULL;
         buf = kzalloc(sizeof *buf, GFP_KERNEL);
         if (!buf)
                 return NULL;
 
         buf->vaddr = NULL;
-        buf->write = 0;
+        buf->dma_dir = dma_dir;
         buf->offset = 0;
         buf->size = size;
         /* size is already page aligned */
         buf->num_pages = size >> PAGE_SHIFT;
+        buf->dma_sgt = &buf->sg_table;
 
         buf->pages = kzalloc(buf->num_pages * sizeof(struct page *),
                              GFP_KERNEL);
@@ -112,11 +134,23 @@ static void *vb2_dma_sg_alloc(void *alloc_ctx, unsigned long size, gfp_t gfp_fla
         if (ret)
                 goto fail_pages_alloc;
 
-        ret = sg_alloc_table_from_pages(&buf->sg_table, buf->pages,
+        ret = sg_alloc_table_from_pages(buf->dma_sgt, buf->pages,
                         buf->num_pages, 0, size, GFP_KERNEL);
         if (ret)
                 goto fail_table_alloc;
 
+        /* Prevent the device from being released while the buffer is used */
+        buf->dev = get_device(conf->dev);
+
+        sgt = &buf->sg_table;
+        /*
+         * No need to sync to the device, this will happen later when the
+         * prepare() memop is called.
+         */
+        if (dma_map_sg_attrs(buf->dev, sgt->sgl, sgt->nents,
+                             buf->dma_dir, &attrs) == 0)
+                goto fail_map;
+
         buf->handler.refcount = &buf->refcount;
         buf->handler.put = vb2_dma_sg_put;
         buf->handler.arg = buf;
@@ -127,6 +161,9 @@ static void *vb2_dma_sg_alloc(void *alloc_ctx, unsigned long size, gfp_t gfp_fla
                 __func__, buf->num_pages);
         return buf;
 
+fail_map:
+        put_device(buf->dev);
+        sg_free_table(buf->dma_sgt);
 fail_table_alloc:
         num_pages = buf->num_pages;
         while (num_pages--)
@@ -141,42 +178,81 @@ fail_pages_array_alloc:
 static void vb2_dma_sg_put(void *buf_priv)
 {
         struct vb2_dma_sg_buf *buf = buf_priv;
+        struct sg_table *sgt = &buf->sg_table;
         int i = buf->num_pages;
 
         if (atomic_dec_and_test(&buf->refcount)) {
+                DEFINE_DMA_ATTRS(attrs);
+
+                dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
                 dprintk(1, "%s: Freeing buffer of %d pages\n", __func__,
                         buf->num_pages);
+                dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->nents,
+                                   buf->dma_dir, &attrs);
                 if (buf->vaddr)
                         vm_unmap_ram(buf->vaddr, buf->num_pages);
-                sg_free_table(&buf->sg_table);
+                sg_free_table(buf->dma_sgt);
                 while (--i >= 0)
                         __free_page(buf->pages[i]);
                 kfree(buf->pages);
+                put_device(buf->dev);
                 kfree(buf);
         }
 }
 
+static void vb2_dma_sg_prepare(void *buf_priv)
+{
+        struct vb2_dma_sg_buf *buf = buf_priv;
+        struct sg_table *sgt = buf->dma_sgt;
+
+        /* DMABUF exporter will flush the cache for us */
+        if (buf->db_attach)
+                return;
+
+        dma_sync_sg_for_device(buf->dev, sgt->sgl, sgt->nents, buf->dma_dir);
+}
+
+static void vb2_dma_sg_finish(void *buf_priv)
+{
+        struct vb2_dma_sg_buf *buf = buf_priv;
+        struct sg_table *sgt = buf->dma_sgt;
+
+        /* DMABUF exporter will flush the cache for us */
+        if (buf->db_attach)
+                return;
+
+        dma_sync_sg_for_cpu(buf->dev, sgt->sgl, sgt->nents, buf->dma_dir);
+}
+
 static inline int vma_is_io(struct vm_area_struct *vma)
 {
         return !!(vma->vm_flags & (VM_IO | VM_PFNMAP));
 }
 
 static void *vb2_dma_sg_get_userptr(void *alloc_ctx, unsigned long vaddr,
-                                    unsigned long size, int write)
+                                    unsigned long size,
+                                    enum dma_data_direction dma_dir)
 {
+        struct vb2_dma_sg_conf *conf = alloc_ctx;
         struct vb2_dma_sg_buf *buf;
         unsigned long first, last;
         int num_pages_from_user;
         struct vm_area_struct *vma;
+        struct sg_table *sgt;
+        DEFINE_DMA_ATTRS(attrs);
+
+        dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
 
         buf = kzalloc(sizeof *buf, GFP_KERNEL);
         if (!buf)
                 return NULL;
 
         buf->vaddr = NULL;
-        buf->write = write;
+        buf->dev = conf->dev;
+        buf->dma_dir = dma_dir;
         buf->offset = vaddr & ~PAGE_MASK;
         buf->size = size;
+        buf->dma_sgt = &buf->sg_table;
 
         first = (vaddr           & PAGE_MASK) >> PAGE_SHIFT;
         last  = ((vaddr + size - 1) & PAGE_MASK) >> PAGE_SHIFT;
@@ -221,7 +297,7 @@ static void *vb2_dma_sg_get_userptr(void *alloc_ctx, unsigned long vaddr,
                 num_pages_from_user = get_user_pages(current, current->mm,
                                              vaddr & PAGE_MASK,
                                              buf->num_pages,
-                                             write,
+                                             buf->dma_dir == DMA_FROM_DEVICE,
                                              1, /* force */
                                              buf->pages,
                                              NULL);
@@ -229,12 +305,22 @@ static void *vb2_dma_sg_get_userptr(void *alloc_ctx, unsigned long vaddr,
         if (num_pages_from_user != buf->num_pages)
                 goto userptr_fail_get_user_pages;
 
-        if (sg_alloc_table_from_pages(&buf->sg_table, buf->pages,
+        if (sg_alloc_table_from_pages(buf->dma_sgt, buf->pages,
                         buf->num_pages, buf->offset, size, 0))
                 goto userptr_fail_alloc_table_from_pages;
 
+        sgt = &buf->sg_table;
+        /*
+         * No need to sync to the device, this will happen later when the
+         * prepare() memop is called.
+         */
+        if (dma_map_sg_attrs(buf->dev, sgt->sgl, sgt->nents,
+                             buf->dma_dir, &attrs) == 0)
+                goto userptr_fail_map;
         return buf;
 
+userptr_fail_map:
+        sg_free_table(&buf->sg_table);
 userptr_fail_alloc_table_from_pages:
 userptr_fail_get_user_pages:
         dprintk(1, "get_user_pages requested/got: %d/%d]\n",
@@ -257,15 +343,20 @@ userptr_fail_alloc_pages:
 static void vb2_dma_sg_put_userptr(void *buf_priv)
 {
         struct vb2_dma_sg_buf *buf = buf_priv;
+        struct sg_table *sgt = &buf->sg_table;
         int i = buf->num_pages;
+        DEFINE_DMA_ATTRS(attrs);
+
+        dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
 
         dprintk(1, "%s: Releasing userspace buffer of %d pages\n",
                __func__, buf->num_pages);
+        dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->nents, buf->dma_dir, &attrs);
         if (buf->vaddr)
                 vm_unmap_ram(buf->vaddr, buf->num_pages);
-        sg_free_table(&buf->sg_table);
+        sg_free_table(buf->dma_sgt);
         while (--i >= 0) {
-                if (buf->write)
+                if (buf->dma_dir == DMA_FROM_DEVICE)
                         set_page_dirty_lock(buf->pages[i]);
                 if (!vma_is_io(buf->vma))
                         put_page(buf->pages[i]);
@@ -281,14 +372,16 @@ static void *vb2_dma_sg_vaddr(void *buf_priv)
 
         BUG_ON(!buf);
 
-        if (!buf->vaddr)
-                buf->vaddr = vm_map_ram(buf->pages,
-                                        buf->num_pages,
-                                        -1,
-                                        PAGE_KERNEL);
+        if (!buf->vaddr) {
+                if (buf->db_attach)
+                        buf->vaddr = dma_buf_vmap(buf->db_attach->dmabuf);
+                else
+                        buf->vaddr = vm_map_ram(buf->pages,
+                                        buf->num_pages, -1, PAGE_KERNEL);
+        }
 
         /* add offset in case userptr is not page-aligned */
-        return buf->vaddr + buf->offset;
+        return buf->vaddr ? buf->vaddr + buf->offset : NULL;
 }
 
 static unsigned int vb2_dma_sg_num_users(void *buf_priv)
@@ -335,11 +428,279 @@ static int vb2_dma_sg_mmap(void *buf_priv, struct vm_area_struct *vma)
         return 0;
 }
 
+/*********************************************/
+/*         DMABUF ops for exporters          */
+/*********************************************/
+
+struct vb2_dma_sg_attachment {
+        struct sg_table sgt;
+        enum dma_data_direction dma_dir;
+};
+
+static int vb2_dma_sg_dmabuf_ops_attach(struct dma_buf *dbuf, struct device *dev,
+        struct dma_buf_attachment *dbuf_attach)
+{
+        struct vb2_dma_sg_attachment *attach;
+        unsigned int i;
+        struct scatterlist *rd, *wr;
+        struct sg_table *sgt;
+        struct vb2_dma_sg_buf *buf = dbuf->priv;
+        int ret;
+
+        attach = kzalloc(sizeof(*attach), GFP_KERNEL);
+        if (!attach)
+                return -ENOMEM;
+
+        sgt = &attach->sgt;
+        /* Copy the buf->base_sgt scatter list to the attachment, as we can't
+         * map the same scatter list to multiple attachments at the same time.
+         */
+        ret = sg_alloc_table(sgt, buf->dma_sgt->orig_nents, GFP_KERNEL);
+        if (ret) {
+                kfree(attach);
+                return -ENOMEM;
+        }
+
+        rd = buf->dma_sgt->sgl;
+        wr = sgt->sgl;
+        for (i = 0; i < sgt->orig_nents; ++i) {
+                sg_set_page(wr, sg_page(rd), rd->length, rd->offset);
+                rd = sg_next(rd);
+                wr = sg_next(wr);
+        }
+
+        attach->dma_dir = DMA_NONE;
+        dbuf_attach->priv = attach;
+
+        return 0;
+}
+
+static void vb2_dma_sg_dmabuf_ops_detach(struct dma_buf *dbuf,
+        struct dma_buf_attachment *db_attach)
+{
+        struct vb2_dma_sg_attachment *attach = db_attach->priv;
+        struct sg_table *sgt;
+
+        if (!attach)
+                return;
+
+        sgt = &attach->sgt;
+
+        /* release the scatterlist cache */
+        if (attach->dma_dir != DMA_NONE)
+                dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
+                        attach->dma_dir);
+        sg_free_table(sgt);
+        kfree(attach);
+        db_attach->priv = NULL;
+}
+
+static struct sg_table *vb2_dma_sg_dmabuf_ops_map(
+        struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
+{
+        struct vb2_dma_sg_attachment *attach = db_attach->priv;
+        /* stealing dmabuf mutex to serialize map/unmap operations */
+        struct mutex *lock = &db_attach->dmabuf->lock;
+        struct sg_table *sgt;
+        int ret;
+
+        mutex_lock(lock);
+
+        sgt = &attach->sgt;
+        /* return previously mapped sg table */
+        if (attach->dma_dir == dma_dir) {
+                mutex_unlock(lock);
+                return sgt;
+        }
+
+        /* release any previous cache */
+        if (attach->dma_dir != DMA_NONE) {
+                dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
+                        attach->dma_dir);
+                attach->dma_dir = DMA_NONE;
+        }
+
+        /* mapping to the client with new direction */
+        ret = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents, dma_dir);
+        if (ret <= 0) {
+                pr_err("failed to map scatterlist\n");
+                mutex_unlock(lock);
+                return ERR_PTR(-EIO);
+        }
+
+        attach->dma_dir = dma_dir;
+
+        mutex_unlock(lock);
+
+        return sgt;
+}
+
+static void vb2_dma_sg_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
+        struct sg_table *sgt, enum dma_data_direction dma_dir)
+{
+        /* nothing to be done here */
+}
+
+static void vb2_dma_sg_dmabuf_ops_release(struct dma_buf *dbuf)
+{
+        /* drop reference obtained in vb2_dma_sg_get_dmabuf */
+        vb2_dma_sg_put(dbuf->priv);
+}
+
+static void *vb2_dma_sg_dmabuf_ops_kmap(struct dma_buf *dbuf, unsigned long pgnum)
+{
+        struct vb2_dma_sg_buf *buf = dbuf->priv;
+
+        return buf->vaddr ? buf->vaddr + pgnum * PAGE_SIZE : NULL;
+}
+
+static void *vb2_dma_sg_dmabuf_ops_vmap(struct dma_buf *dbuf)
+{
+        struct vb2_dma_sg_buf *buf = dbuf->priv;
+
+        return vb2_dma_sg_vaddr(buf);
+}
+
+static int vb2_dma_sg_dmabuf_ops_mmap(struct dma_buf *dbuf,
+        struct vm_area_struct *vma)
+{
+        return vb2_dma_sg_mmap(dbuf->priv, vma);
+}
+
+static struct dma_buf_ops vb2_dma_sg_dmabuf_ops = {
+        .attach = vb2_dma_sg_dmabuf_ops_attach,
+        .detach = vb2_dma_sg_dmabuf_ops_detach,
+        .map_dma_buf = vb2_dma_sg_dmabuf_ops_map,
+        .unmap_dma_buf = vb2_dma_sg_dmabuf_ops_unmap,
+        .kmap = vb2_dma_sg_dmabuf_ops_kmap,
+        .kmap_atomic = vb2_dma_sg_dmabuf_ops_kmap,
+        .vmap = vb2_dma_sg_dmabuf_ops_vmap,
+        .mmap = vb2_dma_sg_dmabuf_ops_mmap,
+        .release = vb2_dma_sg_dmabuf_ops_release,
+};
+
+static struct dma_buf *vb2_dma_sg_get_dmabuf(void *buf_priv, unsigned long flags)
+{
+        struct vb2_dma_sg_buf *buf = buf_priv;
+        struct dma_buf *dbuf;
+
+        if (WARN_ON(!buf->dma_sgt))
+                return NULL;
+
+        dbuf = dma_buf_export(buf, &vb2_dma_sg_dmabuf_ops, buf->size, flags, NULL);
+        if (IS_ERR(dbuf))
+                return NULL;
+
+        /* dmabuf keeps reference to vb2 buffer */
+        atomic_inc(&buf->refcount);
+
+        return dbuf;
+}
+
+/*********************************************/
+/*       callbacks for DMABUF buffers        */
+/*********************************************/
+
+static int vb2_dma_sg_map_dmabuf(void *mem_priv)
+{
+        struct vb2_dma_sg_buf *buf = mem_priv;
+        struct sg_table *sgt;
+
+        if (WARN_ON(!buf->db_attach)) {
+                pr_err("trying to pin a non attached buffer\n");
+                return -EINVAL;
+        }
+
+        if (WARN_ON(buf->dma_sgt)) {
+                pr_err("dmabuf buffer is already pinned\n");
+                return 0;
+        }
+
+        /* get the associated scatterlist for this buffer */
+        sgt = dma_buf_map_attachment(buf->db_attach, buf->dma_dir);
+        if (IS_ERR(sgt)) {
+                pr_err("Error getting dmabuf scatterlist\n");
+                return -EINVAL;
+        }
+
+        buf->dma_sgt = sgt;
+        buf->vaddr = NULL;
+
+        return 0;
+}
+
+static void vb2_dma_sg_unmap_dmabuf(void *mem_priv)
+{
+        struct vb2_dma_sg_buf *buf = mem_priv;
+        struct sg_table *sgt = buf->dma_sgt;
+
+        if (WARN_ON(!buf->db_attach)) {
+                pr_err("trying to unpin a not attached buffer\n");
+                return;
+        }
+
+        if (WARN_ON(!sgt)) {
+                pr_err("dmabuf buffer is already unpinned\n");
+                return;
+        }
+
+        if (buf->vaddr) {
+                dma_buf_vunmap(buf->db_attach->dmabuf, buf->vaddr);
+                buf->vaddr = NULL;
+        }
+        dma_buf_unmap_attachment(buf->db_attach, sgt, buf->dma_dir);
+
+        buf->dma_sgt = NULL;
+}
+
+static void vb2_dma_sg_detach_dmabuf(void *mem_priv)
+{
+        struct vb2_dma_sg_buf *buf = mem_priv;
+
+        /* if vb2 works correctly you should never detach mapped buffer */
+        if (WARN_ON(buf->dma_sgt))
+                vb2_dma_sg_unmap_dmabuf(buf);
+
+        /* detach this attachment */
+        dma_buf_detach(buf->db_attach->dmabuf, buf->db_attach);
+        kfree(buf);
+}
+
+static void *vb2_dma_sg_attach_dmabuf(void *alloc_ctx, struct dma_buf *dbuf,
+        unsigned long size, enum dma_data_direction dma_dir)
+{
+        struct vb2_dma_sg_conf *conf = alloc_ctx;
+        struct vb2_dma_sg_buf *buf;
+        struct dma_buf_attachment *dba;
+
+        if (dbuf->size < size)
+                return ERR_PTR(-EFAULT);
+
+        buf = kzalloc(sizeof(*buf), GFP_KERNEL);
+        if (!buf)
+                return ERR_PTR(-ENOMEM);
+
+        buf->dev = conf->dev;
+        /* create attachment for the dmabuf with the user device */
+        dba = dma_buf_attach(dbuf, buf->dev);
+        if (IS_ERR(dba)) {
+                pr_err("failed to attach dmabuf\n");
+                kfree(buf);
+                return dba;
+        }
+
+        buf->dma_dir = dma_dir;
+        buf->size = size;
+        buf->db_attach = dba;
+
+        return buf;
+}
+
 static void *vb2_dma_sg_cookie(void *buf_priv)
 {
         struct vb2_dma_sg_buf *buf = buf_priv;
 
-        return &buf->sg_table;
+        return buf->dma_sgt;
 }
 
 const struct vb2_mem_ops vb2_dma_sg_memops = {
@@ -347,13 +708,41 @@ const struct vb2_mem_ops vb2_dma_sg_memops = {
         .put            = vb2_dma_sg_put,
         .get_userptr    = vb2_dma_sg_get_userptr,
         .put_userptr    = vb2_dma_sg_put_userptr,
+        .prepare        = vb2_dma_sg_prepare,
+        .finish         = vb2_dma_sg_finish,
         .vaddr          = vb2_dma_sg_vaddr,
         .mmap           = vb2_dma_sg_mmap,
         .num_users      = vb2_dma_sg_num_users,
+        .get_dmabuf     = vb2_dma_sg_get_dmabuf,
+        .map_dmabuf     = vb2_dma_sg_map_dmabuf,
+        .unmap_dmabuf   = vb2_dma_sg_unmap_dmabuf,
+        .attach_dmabuf  = vb2_dma_sg_attach_dmabuf,
+        .detach_dmabuf  = vb2_dma_sg_detach_dmabuf,
         .cookie         = vb2_dma_sg_cookie,
 };
 EXPORT_SYMBOL_GPL(vb2_dma_sg_memops);
 
+void *vb2_dma_sg_init_ctx(struct device *dev)
+{
+        struct vb2_dma_sg_conf *conf;
+
+        conf = kzalloc(sizeof(*conf), GFP_KERNEL);
+        if (!conf)
+                return ERR_PTR(-ENOMEM);
+
+        conf->dev = dev;
+
+        return conf;
+}
+EXPORT_SYMBOL_GPL(vb2_dma_sg_init_ctx);
+
+void vb2_dma_sg_cleanup_ctx(void *alloc_ctx)
+{
+        if (!IS_ERR_OR_NULL(alloc_ctx))
+                kfree(alloc_ctx);
+}
+EXPORT_SYMBOL_GPL(vb2_dma_sg_cleanup_ctx);
+
 MODULE_DESCRIPTION("dma scatter/gather memory handling routines for videobuf2");
 MODULE_AUTHOR("Andrzej Pietrasiewicz");
 MODULE_LICENSE("GPL");
diff --git a/drivers/media/v4l2-core/videobuf2-vmalloc.c b/drivers/media/v4l2-core/videobuf2-vmalloc.c
index 313d9771b2bc..fba944e50227 100644
--- a/drivers/media/v4l2-core/videobuf2-vmalloc.c
+++ b/drivers/media/v4l2-core/videobuf2-vmalloc.c
@@ -25,7 +25,7 @@ struct vb2_vmalloc_buf {
         void                            *vaddr;
         struct page                     **pages;
         struct vm_area_struct           *vma;
-        int                             write;
+        enum dma_data_direction         dma_dir;
         unsigned long                   size;
         unsigned int                    n_pages;
         atomic_t                        refcount;
@@ -35,7 +35,8 @@ struct vb2_vmalloc_buf {
 
 static void vb2_vmalloc_put(void *buf_priv);
 
-static void *vb2_vmalloc_alloc(void *alloc_ctx, unsigned long size, gfp_t gfp_flags)
+static void *vb2_vmalloc_alloc(void *alloc_ctx, unsigned long size,
+                               enum dma_data_direction dma_dir, gfp_t gfp_flags)
 {
         struct vb2_vmalloc_buf *buf;
 
@@ -45,6 +46,7 @@ static void *vb2_vmalloc_alloc(void *alloc_ctx, unsigned long size, gfp_t gfp_fl
 
         buf->size = size;
         buf->vaddr = vmalloc_user(buf->size);
+        buf->dma_dir = dma_dir;
         buf->handler.refcount = &buf->refcount;
         buf->handler.put = vb2_vmalloc_put;
         buf->handler.arg = buf;
@@ -70,7 +72,8 @@ static void vb2_vmalloc_put(void *buf_priv)
 }
 
 static void *vb2_vmalloc_get_userptr(void *alloc_ctx, unsigned long vaddr,
-                                     unsigned long size, int write)
+                                     unsigned long size,
+                                     enum dma_data_direction dma_dir)
 {
         struct vb2_vmalloc_buf *buf;
         unsigned long first, last;
@@ -82,7 +85,7 @@ static void *vb2_vmalloc_get_userptr(void *alloc_ctx, unsigned long vaddr,
         if (!buf)
                 return NULL;
 
-        buf->write = write;
+        buf->dma_dir = dma_dir;
         offset = vaddr & ~PAGE_MASK;
         buf->size = size;
 
@@ -107,7 +110,8 @@ static void *vb2_vmalloc_get_userptr(void *alloc_ctx, unsigned long vaddr,
                 /* current->mm->mmap_sem is taken by videobuf2 core */
                 n_pages = get_user_pages(current, current->mm,
                                          vaddr & PAGE_MASK, buf->n_pages,
-                                         write, 1, /* force */
+                                         dma_dir == DMA_FROM_DEVICE,
+                                         1, /* force */
                                          buf->pages, NULL);
                 if (n_pages != buf->n_pages)
                         goto fail_get_user_pages;
@@ -144,14 +148,13 @@ static void vb2_vmalloc_put_userptr(void *buf_priv)
                 if (vaddr)
                         vm_unmap_ram((void *)vaddr, buf->n_pages);
                 for (i = 0; i < buf->n_pages; ++i) {
-                        if (buf->write)
+                        if (buf->dma_dir == DMA_FROM_DEVICE)
                                 set_page_dirty_lock(buf->pages[i]);
                         put_page(buf->pages[i]);
                 }
                 kfree(buf->pages);
         } else {
-                if (buf->vma)
-                        vb2_put_vma(buf->vma);
+                vb2_put_vma(buf->vma);
                 iounmap(buf->vaddr);
         }
         kfree(buf);
@@ -209,6 +212,176 @@ static int vb2_vmalloc_mmap(void *buf_priv, struct vm_area_struct *vma)
 }
 
 /*********************************************/
+/*         DMABUF ops for exporters          */
+/*********************************************/
+
+struct vb2_vmalloc_attachment {
+        struct sg_table sgt;
+        enum dma_data_direction dma_dir;
+};
+
+static int vb2_vmalloc_dmabuf_ops_attach(struct dma_buf *dbuf, struct device *dev,
+        struct dma_buf_attachment *dbuf_attach)
+{
+        struct vb2_vmalloc_attachment *attach;
+        struct vb2_vmalloc_buf *buf = dbuf->priv;
+        int num_pages = PAGE_ALIGN(buf->size) / PAGE_SIZE;
+        struct sg_table *sgt;
+        struct scatterlist *sg;
+        void *vaddr = buf->vaddr;
+        int ret;
+        int i;
+
+        attach = kzalloc(sizeof(*attach), GFP_KERNEL);
+        if (!attach)
+                return -ENOMEM;
+
+        sgt = &attach->sgt;
+        ret = sg_alloc_table(sgt, num_pages, GFP_KERNEL);
+        if (ret) {
+                kfree(attach);
+                return ret;
+        }
+        for_each_sg(sgt->sgl, sg, sgt->nents, i) {
+                struct page *page = vmalloc_to_page(vaddr);
+
+                if (!page) {
+                        sg_free_table(sgt);
+                        kfree(attach);
+                        return -ENOMEM;
+                }
+                sg_set_page(sg, page, PAGE_SIZE, 0);
+                vaddr += PAGE_SIZE;
+        }
+
+        attach->dma_dir = DMA_NONE;
+        dbuf_attach->priv = attach;
+        return 0;
+}
+
+static void vb2_vmalloc_dmabuf_ops_detach(struct dma_buf *dbuf,
+        struct dma_buf_attachment *db_attach)
+{
+        struct vb2_vmalloc_attachment *attach = db_attach->priv;
+        struct sg_table *sgt;
+
+        if (!attach)
+                return;
+
+        sgt = &attach->sgt;
+
+        /* release the scatterlist cache */
+        if (attach->dma_dir != DMA_NONE)
+                dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
+                        attach->dma_dir);
+        sg_free_table(sgt);
+        kfree(attach);
+        db_attach->priv = NULL;
+}
+
+static struct sg_table *vb2_vmalloc_dmabuf_ops_map(
+        struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
+{
+        struct vb2_vmalloc_attachment *attach = db_attach->priv;
+        /* stealing dmabuf mutex to serialize map/unmap operations */
+        struct mutex *lock = &db_attach->dmabuf->lock;
+        struct sg_table *sgt;
+        int ret;
+
+        mutex_lock(lock);
+
+        sgt = &attach->sgt;
+        /* return previously mapped sg table */
+        if (attach->dma_dir == dma_dir) {
+                mutex_unlock(lock);
+                return sgt;
+        }
+
+        /* release any previous cache */
+        if (attach->dma_dir != DMA_NONE) {
+                dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
+                        attach->dma_dir);
+                attach->dma_dir = DMA_NONE;
+        }
+
+        /* mapping to the client with new direction */
+        ret = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents, dma_dir);
+        if (ret <= 0) {
+                pr_err("failed to map scatterlist\n");
+                mutex_unlock(lock);
+                return ERR_PTR(-EIO);
+        }
+
+        attach->dma_dir = dma_dir;
+
+        mutex_unlock(lock);
+
+        return sgt;
+}
+
+static void vb2_vmalloc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
+        struct sg_table *sgt, enum dma_data_direction dma_dir)
+{
+        /* nothing to be done here */
+}
+
+static void vb2_vmalloc_dmabuf_ops_release(struct dma_buf *dbuf)
+{
+        /* drop reference obtained in vb2_vmalloc_get_dmabuf */
+        vb2_vmalloc_put(dbuf->priv);
+}
+
+static void *vb2_vmalloc_dmabuf_ops_kmap(struct dma_buf *dbuf, unsigned long pgnum)
+{
+        struct vb2_vmalloc_buf *buf = dbuf->priv;
+
+        return buf->vaddr + pgnum * PAGE_SIZE;
+}
+
+static void *vb2_vmalloc_dmabuf_ops_vmap(struct dma_buf *dbuf)
+{
+        struct vb2_vmalloc_buf *buf = dbuf->priv;
+
+        return buf->vaddr;
+}
+
+static int vb2_vmalloc_dmabuf_ops_mmap(struct dma_buf *dbuf,
+        struct vm_area_struct *vma)
+{
+        return vb2_vmalloc_mmap(dbuf->priv, vma);
+}
+
+static struct dma_buf_ops vb2_vmalloc_dmabuf_ops = {
+        .attach = vb2_vmalloc_dmabuf_ops_attach,
+        .detach = vb2_vmalloc_dmabuf_ops_detach,
+        .map_dma_buf = vb2_vmalloc_dmabuf_ops_map,
+        .unmap_dma_buf = vb2_vmalloc_dmabuf_ops_unmap,
+        .kmap = vb2_vmalloc_dmabuf_ops_kmap,
+        .kmap_atomic = vb2_vmalloc_dmabuf_ops_kmap,
+        .vmap = vb2_vmalloc_dmabuf_ops_vmap,
+        .mmap = vb2_vmalloc_dmabuf_ops_mmap,
+        .release = vb2_vmalloc_dmabuf_ops_release,
+};
+
+static struct dma_buf *vb2_vmalloc_get_dmabuf(void *buf_priv, unsigned long flags)
+{
+        struct vb2_vmalloc_buf *buf = buf_priv;
+        struct dma_buf *dbuf;
+
+        if (WARN_ON(!buf->vaddr))
+                return NULL;
+
+        dbuf = dma_buf_export(buf, &vb2_vmalloc_dmabuf_ops, buf->size, flags, NULL);
+        if (IS_ERR(dbuf))
+                return NULL;
+
+        /* dmabuf keeps reference to vb2 buffer */
+        atomic_inc(&buf->refcount);
+
+        return dbuf;
+}
+
+/*********************************************/
 /*       callbacks for DMABUF buffers        */
 /*********************************************/
 
@@ -240,7 +413,7 @@ static void vb2_vmalloc_detach_dmabuf(void *mem_priv)
 }
 
 static void *vb2_vmalloc_attach_dmabuf(void *alloc_ctx, struct dma_buf *dbuf,
-        unsigned long size, int write)
+        unsigned long size, enum dma_data_direction dma_dir)
 {
         struct vb2_vmalloc_buf *buf;
 
@@ -252,7 +425,7 @@ static void *vb2_vmalloc_attach_dmabuf(void *alloc_ctx, struct dma_buf *dbuf,
                 return ERR_PTR(-ENOMEM);
 
         buf->dbuf = dbuf;
-        buf->write = write;
+        buf->dma_dir = dma_dir;
         buf->size = size;
 
         return buf;
@@ -264,6 +437,7 @@ const struct vb2_mem_ops vb2_vmalloc_memops = {
         .put            = vb2_vmalloc_put,
         .get_userptr    = vb2_vmalloc_get_userptr,
         .put_userptr    = vb2_vmalloc_put_userptr,
+        .get_dmabuf     = vb2_vmalloc_get_dmabuf,
         .map_dmabuf     = vb2_vmalloc_map_dmabuf,
         .unmap_dmabuf   = vb2_vmalloc_unmap_dmabuf,
         .attach_dmabuf  = vb2_vmalloc_attach_dmabuf,
diff --git a/drivers/memory/Kconfig b/drivers/memory/Kconfig
index 6d91c27fd4c8..191383d8c94d 100644
--- a/drivers/memory/Kconfig
+++ b/drivers/memory/Kconfig
@@ -41,6 +41,14 @@ config TI_EMIF
           parameters and other settings during frequency, voltage and
           temperature changes
 
+config OMAP_GPMC
+        bool
+        help
+          This driver is for the General Purpose Memory Controller (GPMC)
+          present on Texas Instruments SoCs (e.g. OMAP2+). GPMC allows
+          interfacing to a variety of asynchronous as well as synchronous
+          memory drives like NOR, NAND, OneNAND, SRAM.
+
 config MVEBU_DEVBUS
         bool "Marvell EBU Device Bus Controller"
         default y
@@ -61,16 +69,6 @@ config TEGRA20_MC
           analysis, especially for IOMMU/GART(Graphics Address
           Relocation Table) module.
 
-config TEGRA30_MC
-        bool "Tegra30 Memory Controller(MC) driver"
-        default y
-        depends on ARCH_TEGRA_3x_SOC
-        help
-          This driver is for the Memory Controller(MC) module available
-          in Tegra30 SoCs, mainly for a address translation fault
-          analysis, especially for IOMMU/SMMU(System Memory Management
-          Unit) module.
-
 config FSL_CORENET_CF
         tristate "Freescale CoreNet Error Reporting"
         depends on FSL_SOC_BOOKE
@@ -85,4 +83,6 @@ config FSL_IFC
         bool
         depends on FSL_SOC
 
+source "drivers/memory/tegra/Kconfig"
+
 endif
diff --git a/drivers/memory/Makefile b/drivers/memory/Makefile
index c32d31981be3..6b6548124473 100644
--- a/drivers/memory/Makefile
+++ b/drivers/memory/Makefile
@@ -8,8 +8,10 @@ endif
 obj-$(CONFIG_ATMEL_SDRAMC)      += atmel-sdramc.o
 obj-$(CONFIG_TI_AEMIF)          += ti-aemif.o
 obj-$(CONFIG_TI_EMIF)           += emif.o
+obj-$(CONFIG_OMAP_GPMC)         += omap-gpmc.o
 obj-$(CONFIG_FSL_CORENET_CF)    += fsl-corenet-cf.o
 obj-$(CONFIG_FSL_IFC)           += fsl_ifc.o
 obj-$(CONFIG_MVEBU_DEVBUS)      += mvebu-devbus.o
 obj-$(CONFIG_TEGRA20_MC)        += tegra20-mc.o
-obj-$(CONFIG_TEGRA30_MC)        += tegra30-mc.o
+
+obj-$(CONFIG_TEGRA_MC)          += tegra/
diff --git a/drivers/memory/omap-gpmc.c b/drivers/memory/omap-gpmc.c
new file mode 100644
index 000000000000..ffc5e60c0664
--- /dev/null
+++ b/drivers/memory/omap-gpmc.c
@@ -0,0 +1,2092 @@
+/*
+ * GPMC support functions
+ *
+ * Copyright (C) 2005-2006 Nokia Corporation
+ *
+ * Author: Juha Yrjola
+ *
+ * Copyright (C) 2009 Texas Instruments
+ * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#undef DEBUG
+
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/clk.h>
+#include <linux/ioport.h>
+#include <linux/spinlock.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_mtd.h>
+#include <linux/of_device.h>
+#include <linux/omap-gpmc.h>
+#include <linux/mtd/nand.h>
+#include <linux/pm_runtime.h>
+
+#include <linux/platform_data/mtd-nand-omap2.h>
+#include <linux/platform_data/mtd-onenand-omap2.h>
+
+#include <asm/mach-types.h>
+
+#define DEVICE_NAME             "omap-gpmc"
+
+/* GPMC register offsets */
+#define GPMC_REVISION           0x00
+#define GPMC_SYSCONFIG          0x10
+#define GPMC_SYSSTATUS          0x14
+#define GPMC_IRQSTATUS          0x18
+#define GPMC_IRQENABLE          0x1c
+#define GPMC_TIMEOUT_CONTROL    0x40
+#define GPMC_ERR_ADDRESS        0x44
+#define GPMC_ERR_TYPE           0x48
+#define GPMC_CONFIG             0x50
+#define GPMC_STATUS             0x54
+#define GPMC_PREFETCH_CONFIG1   0x1e0
+#define GPMC_PREFETCH_CONFIG2   0x1e4
+#define GPMC_PREFETCH_CONTROL   0x1ec
+#define GPMC_PREFETCH_STATUS    0x1f0
+#define GPMC_ECC_CONFIG         0x1f4
+#define GPMC_ECC_CONTROL        0x1f8
+#define GPMC_ECC_SIZE_CONFIG    0x1fc
+#define GPMC_ECC1_RESULT        0x200
+#define GPMC_ECC_BCH_RESULT_0   0x240   /* not available on OMAP2 */
+#define GPMC_ECC_BCH_RESULT_1   0x244   /* not available on OMAP2 */
+#define GPMC_ECC_BCH_RESULT_2   0x248   /* not available on OMAP2 */
+#define GPMC_ECC_BCH_RESULT_3   0x24c   /* not available on OMAP2 */
+#define GPMC_ECC_BCH_RESULT_4   0x300   /* not available on OMAP2 */
+#define GPMC_ECC_BCH_RESULT_5   0x304   /* not available on OMAP2 */
+#define GPMC_ECC_BCH_RESULT_6   0x308   /* not available on OMAP2 */
+
+/* GPMC ECC control settings */
+#define GPMC_ECC_CTRL_ECCCLEAR          0x100
+#define GPMC_ECC_CTRL_ECCDISABLE        0x000
+#define GPMC_ECC_CTRL_ECCREG1           0x001
+#define GPMC_ECC_CTRL_ECCREG2           0x002
+#define GPMC_ECC_CTRL_ECCREG3           0x003
+#define GPMC_ECC_CTRL_ECCREG4           0x004
+#define GPMC_ECC_CTRL_ECCREG5           0x005
+#define GPMC_ECC_CTRL_ECCREG6           0x006
+#define GPMC_ECC_CTRL_ECCREG7           0x007
+#define GPMC_ECC_CTRL_ECCREG8           0x008
+#define GPMC_ECC_CTRL_ECCREG9           0x009
+
+#define GPMC_CONFIG_LIMITEDADDRESS              BIT(1)
+
+#define GPMC_CONFIG2_CSEXTRADELAY               BIT(7)
+#define GPMC_CONFIG3_ADVEXTRADELAY              BIT(7)
+#define GPMC_CONFIG4_OEEXTRADELAY               BIT(7)
+#define GPMC_CONFIG4_WEEXTRADELAY               BIT(23)
+#define GPMC_CONFIG6_CYCLE2CYCLEDIFFCSEN        BIT(6)
+#define GPMC_CONFIG6_CYCLE2CYCLESAMECSEN        BIT(7)
+
+#define GPMC_CS0_OFFSET         0x60
+#define GPMC_CS_SIZE            0x30
+#define GPMC_BCH_SIZE           0x10
+
+#define GPMC_MEM_END            0x3FFFFFFF
+
+#define GPMC_CHUNK_SHIFT        24              /* 16 MB */
+#define GPMC_SECTION_SHIFT      28              /* 128 MB */
+
+#define CS_NUM_SHIFT            24
+#define ENABLE_PREFETCH         (0x1 << 7)
+#define DMA_MPU_MODE            2
+
+#define GPMC_REVISION_MAJOR(l)          ((l >> 4) & 0xf)
+#define GPMC_REVISION_MINOR(l)          (l & 0xf)
+
+#define GPMC_HAS_WR_ACCESS              0x1
+#define GPMC_HAS_WR_DATA_MUX_BUS        0x2
+#define GPMC_HAS_MUX_AAD                0x4
+
+#define GPMC_NR_WAITPINS                4
+
+#define GPMC_CS_CONFIG1         0x00
+#define GPMC_CS_CONFIG2         0x04
+#define GPMC_CS_CONFIG3         0x08
+#define GPMC_CS_CONFIG4         0x0c
+#define GPMC_CS_CONFIG5         0x10
+#define GPMC_CS_CONFIG6         0x14
+#define GPMC_CS_CONFIG7         0x18
+#define GPMC_CS_NAND_COMMAND    0x1c
+#define GPMC_CS_NAND_ADDRESS    0x20
+#define GPMC_CS_NAND_DATA       0x24
+
+/* Control Commands */
+#define GPMC_CONFIG_RDY_BSY     0x00000001
+#define GPMC_CONFIG_DEV_SIZE    0x00000002
+#define GPMC_CONFIG_DEV_TYPE    0x00000003
+#define GPMC_SET_IRQ_STATUS     0x00000004
+
+#define GPMC_CONFIG1_WRAPBURST_SUPP     (1 << 31)
+#define GPMC_CONFIG1_READMULTIPLE_SUPP  (1 << 30)
+#define GPMC_CONFIG1_READTYPE_ASYNC     (0 << 29)
+#define GPMC_CONFIG1_READTYPE_SYNC      (1 << 29)
+#define GPMC_CONFIG1_WRITEMULTIPLE_SUPP (1 << 28)
+#define GPMC_CONFIG1_WRITETYPE_ASYNC    (0 << 27)
+#define GPMC_CONFIG1_WRITETYPE_SYNC     (1 << 27)
+#define GPMC_CONFIG1_CLKACTIVATIONTIME(val) ((val & 3) << 25)
+#define GPMC_CONFIG1_PAGE_LEN(val)      ((val & 3) << 23)
+#define GPMC_CONFIG1_WAIT_READ_MON      (1 << 22)
+#define GPMC_CONFIG1_WAIT_WRITE_MON     (1 << 21)
+#define GPMC_CONFIG1_WAIT_MON_IIME(val) ((val & 3) << 18)
+#define GPMC_CONFIG1_WAIT_PIN_SEL(val)  ((val & 3) << 16)
+#define GPMC_CONFIG1_DEVICESIZE(val)    ((val & 3) << 12)
+#define GPMC_CONFIG1_DEVICESIZE_16      GPMC_CONFIG1_DEVICESIZE(1)
+#define GPMC_CONFIG1_DEVICETYPE(val)    ((val & 3) << 10)
+#define GPMC_CONFIG1_DEVICETYPE_NOR     GPMC_CONFIG1_DEVICETYPE(0)
+#define GPMC_CONFIG1_MUXTYPE(val)       ((val & 3) << 8)
+#define GPMC_CONFIG1_TIME_PARA_GRAN     (1 << 4)
+#define GPMC_CONFIG1_FCLK_DIV(val)      (val & 3)
+#define GPMC_CONFIG1_FCLK_DIV2          (GPMC_CONFIG1_FCLK_DIV(1))
+#define GPMC_CONFIG1_FCLK_DIV3          (GPMC_CONFIG1_FCLK_DIV(2))
+#define GPMC_CONFIG1_FCLK_DIV4          (GPMC_CONFIG1_FCLK_DIV(3))
+#define GPMC_CONFIG7_CSVALID            (1 << 6)
+
+#define GPMC_DEVICETYPE_NOR             0
+#define GPMC_DEVICETYPE_NAND            2
+#define GPMC_CONFIG_WRITEPROTECT        0x00000010
+#define WR_RD_PIN_MONITORING            0x00600000
+
+#define GPMC_ENABLE_IRQ         0x0000000d
+
+/* ECC commands */
+#define GPMC_ECC_READ           0 /* Reset Hardware ECC for read */
+#define GPMC_ECC_WRITE          1 /* Reset Hardware ECC for write */
+#define GPMC_ECC_READSYN        2 /* Reset before syndrom is read back */
+
+/* XXX: Only NAND irq has been considered,currently these are the only ones used
+ */
+#define GPMC_NR_IRQ             2
+
+struct gpmc_cs_data {
+        const char *name;
+
+#define GPMC_CS_RESERVED        (1 << 0)
+        u32 flags;
+
+        struct resource mem;
+};
+
+struct gpmc_client_irq  {
+        unsigned                irq;
+        u32                     bitmask;
+};
+
+/* Structure to save gpmc cs context */
+struct gpmc_cs_config {
+        u32 config1;
+        u32 config2;
+        u32 config3;
+        u32 config4;
+        u32 config5;
+        u32 config6;
+        u32 config7;
+        int is_valid;
+};
+
+/*
+ * Structure to save/restore gpmc context
+ * to support core off on OMAP3
+ */
+struct omap3_gpmc_regs {
+        u32 sysconfig;
+        u32 irqenable;
+        u32 timeout_ctrl;
+        u32 config;
+        u32 prefetch_config1;
+        u32 prefetch_config2;
+        u32 prefetch_control;
+        struct gpmc_cs_config cs_context[GPMC_CS_NUM];
+};
+
+static struct gpmc_client_irq gpmc_client_irq[GPMC_NR_IRQ];
+static struct irq_chip gpmc_irq_chip;
+static int gpmc_irq_start;
+
+static struct resource  gpmc_mem_root;
+static struct gpmc_cs_data gpmc_cs[GPMC_CS_NUM];
+static DEFINE_SPINLOCK(gpmc_mem_lock);
+/* Define chip-selects as reserved by default until probe completes */
+static unsigned int gpmc_cs_num = GPMC_CS_NUM;
+static unsigned int gpmc_nr_waitpins;
+static struct device *gpmc_dev;
+static int gpmc_irq;
+static resource_size_t phys_base, mem_size;
+static unsigned gpmc_capability;
+static void __iomem *gpmc_base;
+
+static struct clk *gpmc_l3_clk;
+
+static irqreturn_t gpmc_handle_irq(int irq, void *dev);
+
+static void gpmc_write_reg(int idx, u32 val)
+{
+        writel_relaxed(val, gpmc_base + idx);
+}
+
+static u32 gpmc_read_reg(int idx)
+{
+        return readl_relaxed(gpmc_base + idx);
+}
+
+void gpmc_cs_write_reg(int cs, int idx, u32 val)
+{
+        void __iomem *reg_addr;
+
+        reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+        writel_relaxed(val, reg_addr);
+}
+
+static u32 gpmc_cs_read_reg(int cs, int idx)
+{
+        void __iomem *reg_addr;
+
+        reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+        return readl_relaxed(reg_addr);
+}
+
+/* TODO: Add support for gpmc_fck to clock framework and use it */
+static unsigned long gpmc_get_fclk_period(void)
+{
+        unsigned long rate = clk_get_rate(gpmc_l3_clk);
+
+        rate /= 1000;
+        rate = 1000000000 / rate;       /* In picoseconds */
+
+        return rate;
+}
+
+static unsigned int gpmc_ns_to_ticks(unsigned int time_ns)
+{
+        unsigned long tick_ps;
+
+        /* Calculate in picosecs to yield more exact results */
+        tick_ps = gpmc_get_fclk_period();
+
+        return (time_ns * 1000 + tick_ps - 1) / tick_ps;
+}
+
+static unsigned int gpmc_ps_to_ticks(unsigned int time_ps)
+{
+        unsigned long tick_ps;
+
+        /* Calculate in picosecs to yield more exact results */
+        tick_ps = gpmc_get_fclk_period();
+
+        return (time_ps + tick_ps - 1) / tick_ps;
+}
+
+unsigned int gpmc_ticks_to_ns(unsigned int ticks)
+{
+        return ticks * gpmc_get_fclk_period() / 1000;
+}
+
+static unsigned int gpmc_ticks_to_ps(unsigned int ticks)
+{
+        return ticks * gpmc_get_fclk_period();
+}
+
+static unsigned int gpmc_round_ps_to_ticks(unsigned int time_ps)
+{
+        unsigned long ticks = gpmc_ps_to_ticks(time_ps);
+
+        return ticks * gpmc_get_fclk_period();
+}
+
+static inline void gpmc_cs_modify_reg(int cs, int reg, u32 mask, bool value)
+{
+        u32 l;
+
+        l = gpmc_cs_read_reg(cs, reg);
+        if (value)
+                l |= mask;
+        else
+                l &= ~mask;
+        gpmc_cs_write_reg(cs, reg, l);
+}
+
+static void gpmc_cs_bool_timings(int cs, const struct gpmc_bool_timings *p)
+{
+        gpmc_cs_modify_reg(cs, GPMC_CS_CONFIG1,
+                           GPMC_CONFIG1_TIME_PARA_GRAN,
+                           p->time_para_granularity);
+        gpmc_cs_modify_reg(cs, GPMC_CS_CONFIG2,
+                           GPMC_CONFIG2_CSEXTRADELAY, p->cs_extra_delay);
+        gpmc_cs_modify_reg(cs, GPMC_CS_CONFIG3,
+                           GPMC_CONFIG3_ADVEXTRADELAY, p->adv_extra_delay);
+        gpmc_cs_modify_reg(cs, GPMC_CS_CONFIG4,
+                           GPMC_CONFIG4_OEEXTRADELAY, p->oe_extra_delay);
+        gpmc_cs_modify_reg(cs, GPMC_CS_CONFIG4,
+                           GPMC_CONFIG4_OEEXTRADELAY, p->we_extra_delay);
+        gpmc_cs_modify_reg(cs, GPMC_CS_CONFIG6,
+                           GPMC_CONFIG6_CYCLE2CYCLESAMECSEN,
+                           p->cycle2cyclesamecsen);
+        gpmc_cs_modify_reg(cs, GPMC_CS_CONFIG6,
+                           GPMC_CONFIG6_CYCLE2CYCLEDIFFCSEN,
+                           p->cycle2cyclediffcsen);
+}
+
+#ifdef DEBUG
+static int get_gpmc_timing_reg(int cs, int reg, int st_bit, int end_bit,
+                               bool raw, bool noval, int shift,
+                               const char *name)
+{
+        u32 l;
+        int nr_bits, max_value, mask;
+
+        l = gpmc_cs_read_reg(cs, reg);
+        nr_bits = end_bit - st_bit + 1;
+        max_value = (1 << nr_bits) - 1;
+        mask = max_value << st_bit;
+        l = (l & mask) >> st_bit;
+        if (shift)
+                l = (shift << l);
+        if (noval && (l == 0))
+                return 0;
+        if (!raw) {
+                unsigned int time_ns_min, time_ns, time_ns_max;
+
+                time_ns_min = gpmc_ticks_to_ns(l ? l - 1 : 0);
+                time_ns = gpmc_ticks_to_ns(l);
+                time_ns_max = gpmc_ticks_to_ns(l + 1 > max_value ?
+                                               max_value : l + 1);
+                pr_info("gpmc,%s = <%u> (%u - %u ns, %i ticks)\n",
+                        name, time_ns, time_ns_min, time_ns_max, l);
+        } else {
+                pr_info("gpmc,%s = <%u>\n", name, l);
+        }
+
+        return l;
+}
+
+#define GPMC_PRINT_CONFIG(cs, config) \
+        pr_info("cs%i %s: 0x%08x\n", cs, #config, \
+                gpmc_cs_read_reg(cs, config))
+#define GPMC_GET_RAW(reg, st, end, field) \
+        get_gpmc_timing_reg(cs, (reg), (st), (end), 1, 0, 0, field)
+#define GPMC_GET_RAW_BOOL(reg, st, end, field) \
+        get_gpmc_timing_reg(cs, (reg), (st), (end), 1, 1, 0, field)
+#define GPMC_GET_RAW_SHIFT(reg, st, end, shift, field) \
+        get_gpmc_timing_reg(cs, (reg), (st), (end), 1, 1, (shift), field)
+#define GPMC_GET_TICKS(reg, st, end, field) \
+        get_gpmc_timing_reg(cs, (reg), (st), (end), 0, 0, 0, field)
+
+static void gpmc_show_regs(int cs, const char *desc)
+{
+        pr_info("gpmc cs%i %s:\n", cs, desc);
+        GPMC_PRINT_CONFIG(cs, GPMC_CS_CONFIG1);
+        GPMC_PRINT_CONFIG(cs, GPMC_CS_CONFIG2);
+        GPMC_PRINT_CONFIG(cs, GPMC_CS_CONFIG3);
+        GPMC_PRINT_CONFIG(cs, GPMC_CS_CONFIG4);
+        GPMC_PRINT_CONFIG(cs, GPMC_CS_CONFIG5);
+        GPMC_PRINT_CONFIG(cs, GPMC_CS_CONFIG6);
+}
+
+/*
+ * Note that gpmc,wait-pin handing wrongly assumes bit 8 is available,
+ * see commit c9fb809.
+ */
+static void gpmc_cs_show_timings(int cs, const char *desc)
+{
+        gpmc_show_regs(cs, desc);
+
+        pr_info("gpmc cs%i access configuration:\n", cs);
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1,  4,  4, "time-para-granularity");
+        GPMC_GET_RAW(GPMC_CS_CONFIG1,  8,  9, "mux-add-data");
+        GPMC_GET_RAW(GPMC_CS_CONFIG1, 12, 13, "device-width");
+        GPMC_GET_RAW(GPMC_CS_CONFIG1, 16, 17, "wait-pin");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1, 21, 21, "wait-on-write");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1, 22, 22, "wait-on-read");
+        GPMC_GET_RAW_SHIFT(GPMC_CS_CONFIG1, 23, 24, 4, "burst-length");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1, 27, 27, "sync-write");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1, 28, 28, "burst-write");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1, 29, 29, "gpmc,sync-read");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1, 30, 30, "burst-read");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG1, 31, 31, "burst-wrap");
+
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG2,  7,  7, "cs-extra-delay");
+
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG3,  7,  7, "adv-extra-delay");
+
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG4, 23, 23, "we-extra-delay");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG4,  7,  7, "oe-extra-delay");
+
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG6,  7,  7, "cycle2cycle-samecsen");
+        GPMC_GET_RAW_BOOL(GPMC_CS_CONFIG6,  6,  6, "cycle2cycle-diffcsen");
+
+        pr_info("gpmc cs%i timings configuration:\n", cs);
+        GPMC_GET_TICKS(GPMC_CS_CONFIG2,  0,  3, "cs-on-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG2,  8, 12, "cs-rd-off-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG2, 16, 20, "cs-wr-off-ns");
+
+        GPMC_GET_TICKS(GPMC_CS_CONFIG3,  0,  3, "adv-on-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG3,  8, 12, "adv-rd-off-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG3, 16, 20, "adv-wr-off-ns");
+
+        GPMC_GET_TICKS(GPMC_CS_CONFIG4,  0,  3, "oe-on-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG4,  8, 12, "oe-off-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG4, 16, 19, "we-on-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG4, 24, 28, "we-off-ns");
+
+        GPMC_GET_TICKS(GPMC_CS_CONFIG5,  0,  4, "rd-cycle-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG5,  8, 12, "wr-cycle-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG5, 16, 20, "access-ns");
+
+        GPMC_GET_TICKS(GPMC_CS_CONFIG5, 24, 27, "page-burst-access-ns");
+
+        GPMC_GET_TICKS(GPMC_CS_CONFIG6, 0, 3, "bus-turnaround-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG6, 8, 11, "cycle2cycle-delay-ns");
+
+        GPMC_GET_TICKS(GPMC_CS_CONFIG1, 18, 19, "wait-monitoring-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG1, 25, 26, "clk-activation-ns");
+
+        GPMC_GET_TICKS(GPMC_CS_CONFIG6, 16, 19, "wr-data-mux-bus-ns");
+        GPMC_GET_TICKS(GPMC_CS_CONFIG6, 24, 28, "wr-access-ns");
+}
+#else
+static inline void gpmc_cs_show_timings(int cs, const char *desc)
+{
+}
+#endif
+
+static int set_gpmc_timing_reg(int cs, int reg, int st_bit, int end_bit,
+                               int time, const char *name)
+{
+        u32 l;
+        int ticks, mask, nr_bits;
+
+        if (time == 0)
+                ticks = 0;
+        else
+                ticks = gpmc_ns_to_ticks(time);
+        nr_bits = end_bit - st_bit + 1;
+        mask = (1 << nr_bits) - 1;
+
+        if (ticks > mask) {
+                pr_err("%s: GPMC error! CS%d: %s: %d ns, %d ticks > %d\n",
+                       __func__, cs, name, time, ticks, mask);
+
+                return -1;
+        }
+
+        l = gpmc_cs_read_reg(cs, reg);
+#ifdef DEBUG
+        printk(KERN_INFO
+                "GPMC CS%d: %-10s: %3d ticks, %3lu ns (was %3i ticks) %3d ns\n",
+               cs, name, ticks, gpmc_get_fclk_period() * ticks / 1000,
+                        (l >> st_bit) & mask, time);
+#endif
+        l &= ~(mask << st_bit);
+        l |= ticks << st_bit;
+        gpmc_cs_write_reg(cs, reg, l);
+
+        return 0;
+}
+
+#define GPMC_SET_ONE(reg, st, end, field) \
+        if (set_gpmc_timing_reg(cs, (reg), (st), (end),         \
+                        t->field, #field) < 0)                  \
+                return -1
+
+int gpmc_calc_divider(unsigned int sync_clk)
+{
+        int div;
+        u32 l;
+
+        l = sync_clk + (gpmc_get_fclk_period() - 1);
+        div = l / gpmc_get_fclk_period();
+        if (div > 4)
+                return -1;
+        if (div <= 0)
+                div = 1;
+
+        return div;
+}
+
+int gpmc_cs_set_timings(int cs, const struct gpmc_timings *t)
+{
+        int div;
+        u32 l;
+
+        gpmc_cs_show_timings(cs, "before gpmc_cs_set_timings");
+        div = gpmc_calc_divider(t->sync_clk);
+        if (div < 0)
+                return div;
+
+        GPMC_SET_ONE(GPMC_CS_CONFIG2,  0,  3, cs_on);
+        GPMC_SET_ONE(GPMC_CS_CONFIG2,  8, 12, cs_rd_off);
+        GPMC_SET_ONE(GPMC_CS_CONFIG2, 16, 20, cs_wr_off);
+
+        GPMC_SET_ONE(GPMC_CS_CONFIG3,  0,  3, adv_on);
+        GPMC_SET_ONE(GPMC_CS_CONFIG3,  8, 12, adv_rd_off);
+        GPMC_SET_ONE(GPMC_CS_CONFIG3, 16, 20, adv_wr_off);
+
+        GPMC_SET_ONE(GPMC_CS_CONFIG4,  0,  3, oe_on);
+        GPMC_SET_ONE(GPMC_CS_CONFIG4,  8, 12, oe_off);
+        GPMC_SET_ONE(GPMC_CS_CONFIG4, 16, 19, we_on);
+        GPMC_SET_ONE(GPMC_CS_CONFIG4, 24, 28, we_off);
+
+        GPMC_SET_ONE(GPMC_CS_CONFIG5,  0,  4, rd_cycle);
+        GPMC_SET_ONE(GPMC_CS_CONFIG5,  8, 12, wr_cycle);
+        GPMC_SET_ONE(GPMC_CS_CONFIG5, 16, 20, access);
+
+        GPMC_SET_ONE(GPMC_CS_CONFIG5, 24, 27, page_burst_access);
+
+        GPMC_SET_ONE(GPMC_CS_CONFIG6, 0, 3, bus_turnaround);
+        GPMC_SET_ONE(GPMC_CS_CONFIG6, 8, 11, cycle2cycle_delay);
+
+        GPMC_SET_ONE(GPMC_CS_CONFIG1, 18, 19, wait_monitoring);
+        GPMC_SET_ONE(GPMC_CS_CONFIG1, 25, 26, clk_activation);
+
+        if (gpmc_capability & GPMC_HAS_WR_DATA_MUX_BUS)
+                GPMC_SET_ONE(GPMC_CS_CONFIG6, 16, 19, wr_data_mux_bus);
+        if (gpmc_capability & GPMC_HAS_WR_ACCESS)
+                GPMC_SET_ONE(GPMC_CS_CONFIG6, 24, 28, wr_access);
+
+        /* caller is expected to have initialized CONFIG1 to cover
+         * at least sync vs async
+         */
+        l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
+        if (l & (GPMC_CONFIG1_READTYPE_SYNC | GPMC_CONFIG1_WRITETYPE_SYNC)) {
+#ifdef DEBUG
+                printk(KERN_INFO "GPMC CS%d CLK period is %lu ns (div %d)\n",
+                                cs, (div * gpmc_get_fclk_period()) / 1000, div);
+#endif
+                l &= ~0x03;
+                l |= (div - 1);
+                gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, l);
+        }
+
+        gpmc_cs_bool_timings(cs, &t->bool_timings);
+        gpmc_cs_show_timings(cs, "after gpmc_cs_set_timings");
+
+        return 0;
+}
+
+static int gpmc_cs_set_memconf(int cs, u32 base, u32 size)
+{
+        u32 l;
+        u32 mask;
+
+        /*
+         * Ensure that base address is aligned on a
+         * boundary equal to or greater than size.
+         */
+        if (base & (size - 1))
+                return -EINVAL;
+
+        mask = (1 << GPMC_SECTION_SHIFT) - size;
+        l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
+        l &= ~0x3f;
+        l = (base >> GPMC_CHUNK_SHIFT) & 0x3f;
+        l &= ~(0x0f << 8);
+        l |= ((mask >> GPMC_CHUNK_SHIFT) & 0x0f) << 8;
+        l |= GPMC_CONFIG7_CSVALID;
+        gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
+
+        return 0;
+}
+
+static void gpmc_cs_enable_mem(int cs)
+{
+        u32 l;
+
+        l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
+        l |= GPMC_CONFIG7_CSVALID;
+        gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
+}
+
+static void gpmc_cs_disable_mem(int cs)
+{
+        u32 l;
+
+        l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
+        l &= ~GPMC_CONFIG7_CSVALID;
+        gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
+}
+
+static void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
+{
+        u32 l;
+        u32 mask;
+
+        l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
+        *base = (l & 0x3f) << GPMC_CHUNK_SHIFT;
+        mask = (l >> 8) & 0x0f;
+        *size = (1 << GPMC_SECTION_SHIFT) - (mask << GPMC_CHUNK_SHIFT);
+}
+
+static int gpmc_cs_mem_enabled(int cs)
+{
+        u32 l;
+
+        l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
+        return l & GPMC_CONFIG7_CSVALID;
+}
+
+static void gpmc_cs_set_reserved(int cs, int reserved)
+{
+        struct gpmc_cs_data *gpmc = &gpmc_cs[cs];
+
+        gpmc->flags |= GPMC_CS_RESERVED;
+}
+
+static bool gpmc_cs_reserved(int cs)
+{
+        struct gpmc_cs_data *gpmc = &gpmc_cs[cs];
+
+        return gpmc->flags & GPMC_CS_RESERVED;
+}
+
+static void gpmc_cs_set_name(int cs, const char *name)
+{
+        struct gpmc_cs_data *gpmc = &gpmc_cs[cs];
+
+        gpmc->name = name;
+}
+
+const char *gpmc_cs_get_name(int cs)
+{
+        struct gpmc_cs_data *gpmc = &gpmc_cs[cs];
+
+        return gpmc->name;
+}
+
+static unsigned long gpmc_mem_align(unsigned long size)
+{
+        int order;
+
+        size = (size - 1) >> (GPMC_CHUNK_SHIFT - 1);
+        order = GPMC_CHUNK_SHIFT - 1;
+        do {
+                size >>= 1;
+                order++;
+        } while (size);
+        size = 1 << order;
+        return size;
+}
+
+static int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
+{
+        struct gpmc_cs_data *gpmc = &gpmc_cs[cs];
+        struct resource *res = &gpmc->mem;
+        int r;
+
+        size = gpmc_mem_align(size);
+        spin_lock(&gpmc_mem_lock);
+        res->start = base;
+        res->end = base + size - 1;
+        r = request_resource(&gpmc_mem_root, res);
+        spin_unlock(&gpmc_mem_lock);
+
+        return r;
+}
+
+static int gpmc_cs_delete_mem(int cs)
+{
+        struct gpmc_cs_data *gpmc = &gpmc_cs[cs];
+        struct resource *res = &gpmc->mem;
+        int r;
+
+        spin_lock(&gpmc_mem_lock);
+        r = release_resource(res);
+        res->start = 0;
+        res->end = 0;
+        spin_unlock(&gpmc_mem_lock);
+
+        return r;
+}
+
+/**
+ * gpmc_cs_remap - remaps a chip-select physical base address
+ * @cs:         chip-select to remap
+ * @base:       physical base address to re-map chip-select to
+ *
+ * Re-maps a chip-select to a new physical base address specified by
+ * "base". Returns 0 on success and appropriate negative error code
+ * on failure.
+ */
+static int gpmc_cs_remap(int cs, u32 base)
+{
+        int ret;
+        u32 old_base, size;
+
+        if (cs > gpmc_cs_num) {
+                pr_err("%s: requested chip-select is disabled\n", __func__);
+                return -ENODEV;
+        }
+
+        /*
+         * Make sure we ignore any device offsets from the GPMC partition
+         * allocated for the chip select and that the new base confirms
+         * to the GPMC 16MB minimum granularity.
+         */ 
+        base &= ~(SZ_16M - 1);
+
+        gpmc_cs_get_memconf(cs, &old_base, &size);
+        if (base == old_base)
+                return 0;
+
+        ret = gpmc_cs_delete_mem(cs);
+        if (ret < 0)
+                return ret;
+
+        ret = gpmc_cs_insert_mem(cs, base, size);
+        if (ret < 0)
+                return ret;
+
+        ret = gpmc_cs_set_memconf(cs, base, size);
+
+        return ret;
+}
+
+int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
+{
+        struct gpmc_cs_data *gpmc = &gpmc_cs[cs];
+        struct resource *res = &gpmc->mem;
+        int r = -1;
+
+        if (cs > gpmc_cs_num) {
+                pr_err("%s: requested chip-select is disabled\n", __func__);
+                return -ENODEV;
+        }
+        size = gpmc_mem_align(size);
+        if (size > (1 << GPMC_SECTION_SHIFT))
+                return -ENOMEM;
+
+        spin_lock(&gpmc_mem_lock);
+        if (gpmc_cs_reserved(cs)) {
+                r = -EBUSY;
+                goto out;
+        }
+        if (gpmc_cs_mem_enabled(cs))
+                r = adjust_resource(res, res->start & ~(size - 1), size);
+        if (r < 0)
+                r = allocate_resource(&gpmc_mem_root, res, size, 0, ~0,
+                                      size, NULL, NULL);
+        if (r < 0)
+                goto out;
+
+        /* Disable CS while changing base address and size mask */
+        gpmc_cs_disable_mem(cs);
+
+        r = gpmc_cs_set_memconf(cs, res->start, resource_size(res));
+        if (r < 0) {
+                release_resource(res);
+                goto out;
+        }
+
+        /* Enable CS */
+        gpmc_cs_enable_mem(cs);
+        *base = res->start;
+        gpmc_cs_set_reserved(cs, 1);
+out:
+        spin_unlock(&gpmc_mem_lock);
+        return r;
+}
+EXPORT_SYMBOL(gpmc_cs_request);
+
+void gpmc_cs_free(int cs)
+{
+        struct gpmc_cs_data *gpmc = &gpmc_cs[cs];
+        struct resource *res = &gpmc->mem;
+
+        spin_lock(&gpmc_mem_lock);
+        if (cs >= gpmc_cs_num || cs < 0 || !gpmc_cs_reserved(cs)) {
+                printk(KERN_ERR "Trying to free non-reserved GPMC CS%d\n", cs);
+                BUG();
+                spin_unlock(&gpmc_mem_lock);
+                return;
+        }
+        gpmc_cs_disable_mem(cs);
+        if (res->flags)
+                release_resource(res);
+        gpmc_cs_set_reserved(cs, 0);
+        spin_unlock(&gpmc_mem_lock);
+}
+EXPORT_SYMBOL(gpmc_cs_free);
+
+/**
+ * gpmc_configure - write request to configure gpmc
+ * @cmd: command type
+ * @wval: value to write
+ * @return status of the operation
+ */
+int gpmc_configure(int cmd, int wval)
+{
+        u32 regval;
+
+        switch (cmd) {
+        case GPMC_ENABLE_IRQ:
+                gpmc_write_reg(GPMC_IRQENABLE, wval);
+                break;
+
+        case GPMC_SET_IRQ_STATUS:
+                gpmc_write_reg(GPMC_IRQSTATUS, wval);
+                break;
+
+        case GPMC_CONFIG_WP:
+                regval = gpmc_read_reg(GPMC_CONFIG);
+                if (wval)
+                        regval &= ~GPMC_CONFIG_WRITEPROTECT; /* WP is ON */
+                else
+                        regval |= GPMC_CONFIG_WRITEPROTECT;  /* WP is OFF */
+                gpmc_write_reg(GPMC_CONFIG, regval);
+                break;
+
+        default:
+                pr_err("%s: command not supported\n", __func__);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(gpmc_configure);
+
+void gpmc_update_nand_reg(struct gpmc_nand_regs *reg, int cs)
+{
+        int i;
+
+        reg->gpmc_status = gpmc_base + GPMC_STATUS;
+        reg->gpmc_nand_command = gpmc_base + GPMC_CS0_OFFSET +
+                                GPMC_CS_NAND_COMMAND + GPMC_CS_SIZE * cs;
+        reg->gpmc_nand_address = gpmc_base + GPMC_CS0_OFFSET +
+                                GPMC_CS_NAND_ADDRESS + GPMC_CS_SIZE * cs;
+        reg->gpmc_nand_data = gpmc_base + GPMC_CS0_OFFSET +
+                                GPMC_CS_NAND_DATA + GPMC_CS_SIZE * cs;
+        reg->gpmc_prefetch_config1 = gpmc_base + GPMC_PREFETCH_CONFIG1;
+        reg->gpmc_prefetch_config2 = gpmc_base + GPMC_PREFETCH_CONFIG2;
+        reg->gpmc_prefetch_control = gpmc_base + GPMC_PREFETCH_CONTROL;
+        reg->gpmc_prefetch_status = gpmc_base + GPMC_PREFETCH_STATUS;
+        reg->gpmc_ecc_config = gpmc_base + GPMC_ECC_CONFIG;
+        reg->gpmc_ecc_control = gpmc_base + GPMC_ECC_CONTROL;
+        reg->gpmc_ecc_size_config = gpmc_base + GPMC_ECC_SIZE_CONFIG;
+        reg->gpmc_ecc1_result = gpmc_base + GPMC_ECC1_RESULT;
+
+        for (i = 0; i < GPMC_BCH_NUM_REMAINDER; i++) {
+                reg->gpmc_bch_result0[i] = gpmc_base + GPMC_ECC_BCH_RESULT_0 +
+                                           GPMC_BCH_SIZE * i;
+                reg->gpmc_bch_result1[i] = gpmc_base + GPMC_ECC_BCH_RESULT_1 +
+                                           GPMC_BCH_SIZE * i;
+                reg->gpmc_bch_result2[i] = gpmc_base + GPMC_ECC_BCH_RESULT_2 +
+                                           GPMC_BCH_SIZE * i;
+                reg->gpmc_bch_result3[i] = gpmc_base + GPMC_ECC_BCH_RESULT_3 +
+                                           GPMC_BCH_SIZE * i;
+                reg->gpmc_bch_result4[i] = gpmc_base + GPMC_ECC_BCH_RESULT_4 +
+                                           i * GPMC_BCH_SIZE;
+                reg->gpmc_bch_result5[i] = gpmc_base + GPMC_ECC_BCH_RESULT_5 +
+                                           i * GPMC_BCH_SIZE;
+                reg->gpmc_bch_result6[i] = gpmc_base + GPMC_ECC_BCH_RESULT_6 +
+                                           i * GPMC_BCH_SIZE;
+        }
+}
+
+int gpmc_get_client_irq(unsigned irq_config)
+{
+        int i;
+
+        if (hweight32(irq_config) > 1)
+                return 0;
+
+        for (i = 0; i < GPMC_NR_IRQ; i++)
+                if (gpmc_client_irq[i].bitmask & irq_config)
+                        return gpmc_client_irq[i].irq;
+
+        return 0;
+}
+
+static int gpmc_irq_endis(unsigned irq, bool endis)
+{
+        int i;
+        u32 regval;
+
+        for (i = 0; i < GPMC_NR_IRQ; i++)
+                if (irq == gpmc_client_irq[i].irq) {
+                        regval = gpmc_read_reg(GPMC_IRQENABLE);
+                        if (endis)
+                                regval |= gpmc_client_irq[i].bitmask;
+                        else
+                                regval &= ~gpmc_client_irq[i].bitmask;
+                        gpmc_write_reg(GPMC_IRQENABLE, regval);
+                        break;
+                }
+
+        return 0;
+}
+
+static void gpmc_irq_disable(struct irq_data *p)
+{
+        gpmc_irq_endis(p->irq, false);
+}
+
+static void gpmc_irq_enable(struct irq_data *p)
+{
+        gpmc_irq_endis(p->irq, true);
+}
+
+static void gpmc_irq_noop(struct irq_data *data) { }
+
+static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
+
+static int gpmc_setup_irq(void)
+{
+        int i;
+        u32 regval;
+
+        if (!gpmc_irq)
+                return -EINVAL;
+
+        gpmc_irq_start = irq_alloc_descs(-1, 0, GPMC_NR_IRQ, 0);
+        if (gpmc_irq_start < 0) {
+                pr_err("irq_alloc_descs failed\n");
+                return gpmc_irq_start;
+        }
+
+        gpmc_irq_chip.name = "gpmc";
+        gpmc_irq_chip.irq_startup = gpmc_irq_noop_ret;
+        gpmc_irq_chip.irq_enable = gpmc_irq_enable;
+        gpmc_irq_chip.irq_disable = gpmc_irq_disable;
+        gpmc_irq_chip.irq_shutdown = gpmc_irq_noop;
+        gpmc_irq_chip.irq_ack = gpmc_irq_noop;
+        gpmc_irq_chip.irq_mask = gpmc_irq_noop;
+        gpmc_irq_chip.irq_unmask = gpmc_irq_noop;
+
+        gpmc_client_irq[0].bitmask = GPMC_IRQ_FIFOEVENTENABLE;
+        gpmc_client_irq[1].bitmask = GPMC_IRQ_COUNT_EVENT;
+
+        for (i = 0; i < GPMC_NR_IRQ; i++) {
+                gpmc_client_irq[i].irq = gpmc_irq_start + i;
+                irq_set_chip_and_handler(gpmc_client_irq[i].irq,
+                                        &gpmc_irq_chip, handle_simple_irq);
+                set_irq_flags(gpmc_client_irq[i].irq,
+                                IRQF_VALID | IRQF_NOAUTOEN);
+        }
+
+        /* Disable interrupts */
+        gpmc_write_reg(GPMC_IRQENABLE, 0);
+
+        /* clear interrupts */
+        regval = gpmc_read_reg(GPMC_IRQSTATUS);
+        gpmc_write_reg(GPMC_IRQSTATUS, regval);
+
+        return request_irq(gpmc_irq, gpmc_handle_irq, 0, "gpmc", NULL);
+}
+
+static int gpmc_free_irq(void)
+{
+        int i;
+
+        if (gpmc_irq)
+                free_irq(gpmc_irq, NULL);
+
+        for (i = 0; i < GPMC_NR_IRQ; i++) {
+                irq_set_handler(gpmc_client_irq[i].irq, NULL);
+                irq_set_chip(gpmc_client_irq[i].irq, &no_irq_chip);
+                irq_modify_status(gpmc_client_irq[i].irq, 0, 0);
+        }
+
+        irq_free_descs(gpmc_irq_start, GPMC_NR_IRQ);
+
+        return 0;
+}
+
+static void gpmc_mem_exit(void)
+{
+        int cs;
+
+        for (cs = 0; cs < gpmc_cs_num; cs++) {
+                if (!gpmc_cs_mem_enabled(cs))
+                        continue;
+                gpmc_cs_delete_mem(cs);
+        }
+
+}
+
+static void gpmc_mem_init(void)
+{
+        int cs;
+
+        /*
+         * The first 1MB of GPMC address space is typically mapped to
+         * the internal ROM. Never allocate the first page, to
+         * facilitate bug detection; even if we didn't boot from ROM.
+         */
+        gpmc_mem_root.start = SZ_1M;
+        gpmc_mem_root.end = GPMC_MEM_END;
+
+        /* Reserve all regions that has been set up by bootloader */
+        for (cs = 0; cs < gpmc_cs_num; cs++) {
+                u32 base, size;
+
+                if (!gpmc_cs_mem_enabled(cs))
+                        continue;
+                gpmc_cs_get_memconf(cs, &base, &size);
+                if (gpmc_cs_insert_mem(cs, base, size)) {
+                        pr_warn("%s: disabling cs %d mapped at 0x%x-0x%x\n",
+                                __func__, cs, base, base + size);
+                        gpmc_cs_disable_mem(cs);
+                }
+        }
+}
+
+static u32 gpmc_round_ps_to_sync_clk(u32 time_ps, u32 sync_clk)
+{
+        u32 temp;
+        int div;
+
+        div = gpmc_calc_divider(sync_clk);
+        temp = gpmc_ps_to_ticks(time_ps);
+        temp = (temp + div - 1) / div;
+        return gpmc_ticks_to_ps(temp * div);
+}
+
+/* XXX: can the cycles be avoided ? */
+static int gpmc_calc_sync_read_timings(struct gpmc_timings *gpmc_t,
+                                       struct gpmc_device_timings *dev_t,
+                                       bool mux)
+{
+        u32 temp;
+
+        /* adv_rd_off */
+        temp = dev_t->t_avdp_r;
+        /* XXX: mux check required ? */
+        if (mux) {
+                /* XXX: t_avdp not to be required for sync, only added for tusb
+                 * this indirectly necessitates requirement of t_avdp_r and
+                 * t_avdp_w instead of having a single t_avdp
+                 */
+                temp = max_t(u32, temp, gpmc_t->clk_activation + dev_t->t_avdh);
+                temp = max_t(u32, gpmc_t->adv_on + gpmc_ticks_to_ps(1), temp);
+        }
+        gpmc_t->adv_rd_off = gpmc_round_ps_to_ticks(temp);
+
+        /* oe_on */
+        temp = dev_t->t_oeasu; /* XXX: remove this ? */
+        if (mux) {
+                temp = max_t(u32, temp, gpmc_t->clk_activation + dev_t->t_ach);
+                temp = max_t(u32, temp, gpmc_t->adv_rd_off +
+                                gpmc_ticks_to_ps(dev_t->cyc_aavdh_oe));
+        }
+        gpmc_t->oe_on = gpmc_round_ps_to_ticks(temp);
+
+        /* access */
+        /* XXX: any scope for improvement ?, by combining oe_on
+         * and clk_activation, need to check whether
+         * access = clk_activation + round to sync clk ?
+         */
+        temp = max_t(u32, dev_t->t_iaa, dev_t->cyc_iaa * gpmc_t->sync_clk);
+        temp += gpmc_t->clk_activation;
+        if (dev_t->cyc_oe)
+                temp = max_t(u32, temp, gpmc_t->oe_on +
+                                gpmc_ticks_to_ps(dev_t->cyc_oe));
+        gpmc_t->access = gpmc_round_ps_to_ticks(temp);
+
+        gpmc_t->oe_off = gpmc_t->access + gpmc_ticks_to_ps(1);
+        gpmc_t->cs_rd_off = gpmc_t->oe_off;
+
+        /* rd_cycle */
+        temp = max_t(u32, dev_t->t_cez_r, dev_t->t_oez);
+        temp = gpmc_round_ps_to_sync_clk(temp, gpmc_t->sync_clk) +
+                                                        gpmc_t->access;
+        /* XXX: barter t_ce_rdyz with t_cez_r ? */
+        if (dev_t->t_ce_rdyz)
+                temp = max_t(u32, temp, gpmc_t->cs_rd_off + dev_t->t_ce_rdyz);
+        gpmc_t->rd_cycle = gpmc_round_ps_to_ticks(temp);
+
+        return 0;
+}
+
+static int gpmc_calc_sync_write_timings(struct gpmc_timings *gpmc_t,
+                                        struct gpmc_device_timings *dev_t,
+                                        bool mux)
+{
+        u32 temp;
+
+        /* adv_wr_off */
+        temp = dev_t->t_avdp_w;
+        if (mux) {
+                temp = max_t(u32, temp,
+                        gpmc_t->clk_activation + dev_t->t_avdh);
+                temp = max_t(u32, gpmc_t->adv_on + gpmc_ticks_to_ps(1), temp);
+        }
+        gpmc_t->adv_wr_off = gpmc_round_ps_to_ticks(temp);
+
+        /* wr_data_mux_bus */
+        temp = max_t(u32, dev_t->t_weasu,
+                        gpmc_t->clk_activation + dev_t->t_rdyo);
+        /* XXX: shouldn't mux be kept as a whole for wr_data_mux_bus ?,
+         * and in that case remember to handle we_on properly
+         */
+        if (mux) {
+                temp = max_t(u32, temp,
+                        gpmc_t->adv_wr_off + dev_t->t_aavdh);
+                temp = max_t(u32, temp, gpmc_t->adv_wr_off +
+                                gpmc_ticks_to_ps(dev_t->cyc_aavdh_we));
+        }
+        gpmc_t->wr_data_mux_bus = gpmc_round_ps_to_ticks(temp);
+
+        /* we_on */
+        if (gpmc_capability & GPMC_HAS_WR_DATA_MUX_BUS)
+                gpmc_t->we_on = gpmc_round_ps_to_ticks(dev_t->t_weasu);
+        else
+                gpmc_t->we_on = gpmc_t->wr_data_mux_bus;
+
+        /* wr_access */
+        /* XXX: gpmc_capability check reqd ? , even if not, will not harm */
+        gpmc_t->wr_access = gpmc_t->access;
+
+        /* we_off */
+        temp = gpmc_t->we_on + dev_t->t_wpl;
+        temp = max_t(u32, temp,
+                        gpmc_t->wr_access + gpmc_ticks_to_ps(1));
+        temp = max_t(u32, temp,
+                gpmc_t->we_on + gpmc_ticks_to_ps(dev_t->cyc_wpl));
+        gpmc_t->we_off = gpmc_round_ps_to_ticks(temp);
+
+        gpmc_t->cs_wr_off = gpmc_round_ps_to_ticks(gpmc_t->we_off +
+                                                        dev_t->t_wph);
+
+        /* wr_cycle */
+        temp = gpmc_round_ps_to_sync_clk(dev_t->t_cez_w, gpmc_t->sync_clk);
+        temp += gpmc_t->wr_access;
+        /* XXX: barter t_ce_rdyz with t_cez_w ? */
+        if (dev_t->t_ce_rdyz)
+                temp = max_t(u32, temp,
+                                 gpmc_t->cs_wr_off + dev_t->t_ce_rdyz);
+        gpmc_t->wr_cycle = gpmc_round_ps_to_ticks(temp);
+
+        return 0;
+}
+
+static int gpmc_calc_async_read_timings(struct gpmc_timings *gpmc_t,
+                                        struct gpmc_device_timings *dev_t,
+                                        bool mux)
+{
+        u32 temp;
+
+        /* adv_rd_off */
+        temp = dev_t->t_avdp_r;
+        if (mux)
+                temp = max_t(u32, gpmc_t->adv_on + gpmc_ticks_to_ps(1), temp);
+        gpmc_t->adv_rd_off = gpmc_round_ps_to_ticks(temp);
+
+        /* oe_on */
+        temp = dev_t->t_oeasu;
+        if (mux)
+                temp = max_t(u32, temp,
+                        gpmc_t->adv_rd_off + dev_t->t_aavdh);
+        gpmc_t->oe_on = gpmc_round_ps_to_ticks(temp);
+
+        /* access */
+        temp = max_t(u32, dev_t->t_iaa, /* XXX: remove t_iaa in async ? */
+                                gpmc_t->oe_on + dev_t->t_oe);
+        temp = max_t(u32, temp,
+                                gpmc_t->cs_on + dev_t->t_ce);
+        temp = max_t(u32, temp,
+                                gpmc_t->adv_on + dev_t->t_aa);
+        gpmc_t->access = gpmc_round_ps_to_ticks(temp);
+
+        gpmc_t->oe_off = gpmc_t->access + gpmc_ticks_to_ps(1);
+        gpmc_t->cs_rd_off = gpmc_t->oe_off;
+
+        /* rd_cycle */
+        temp = max_t(u32, dev_t->t_rd_cycle,
+                        gpmc_t->cs_rd_off + dev_t->t_cez_r);
+        temp = max_t(u32, temp, gpmc_t->oe_off + dev_t->t_oez);
+        gpmc_t->rd_cycle = gpmc_round_ps_to_ticks(temp);
+
+        return 0;
+}
+
+static int gpmc_calc_async_write_timings(struct gpmc_timings *gpmc_t,
+                                         struct gpmc_device_timings *dev_t,
+                                         bool mux)
+{
+        u32 temp;
+
+        /* adv_wr_off */
+        temp = dev_t->t_avdp_w;
+        if (mux)
+                temp = max_t(u32, gpmc_t->adv_on + gpmc_ticks_to_ps(1), temp);
+        gpmc_t->adv_wr_off = gpmc_round_ps_to_ticks(temp);
+
+        /* wr_data_mux_bus */
+        temp = dev_t->t_weasu;
+        if (mux) {
+                temp = max_t(u32, temp, gpmc_t->adv_wr_off + dev_t->t_aavdh);
+                temp = max_t(u32, temp, gpmc_t->adv_wr_off +
+                                gpmc_ticks_to_ps(dev_t->cyc_aavdh_we));
+        }
+        gpmc_t->wr_data_mux_bus = gpmc_round_ps_to_ticks(temp);
+
+        /* we_on */
+        if (gpmc_capability & GPMC_HAS_WR_DATA_MUX_BUS)
+                gpmc_t->we_on = gpmc_round_ps_to_ticks(dev_t->t_weasu);
+        else
+                gpmc_t->we_on = gpmc_t->wr_data_mux_bus;
+
+        /* we_off */
+        temp = gpmc_t->we_on + dev_t->t_wpl;
+        gpmc_t->we_off = gpmc_round_ps_to_ticks(temp);
+
+        gpmc_t->cs_wr_off = gpmc_round_ps_to_ticks(gpmc_t->we_off +
+                                                        dev_t->t_wph);
+
+        /* wr_cycle */
+        temp = max_t(u32, dev_t->t_wr_cycle,
+                                gpmc_t->cs_wr_off + dev_t->t_cez_w);
+        gpmc_t->wr_cycle = gpmc_round_ps_to_ticks(temp);
+
+        return 0;
+}
+
+static int gpmc_calc_sync_common_timings(struct gpmc_timings *gpmc_t,
+                        struct gpmc_device_timings *dev_t)
+{
+        u32 temp;
+
+        gpmc_t->sync_clk = gpmc_calc_divider(dev_t->clk) *
+                                                gpmc_get_fclk_period();
+
+        gpmc_t->page_burst_access = gpmc_round_ps_to_sync_clk(
+                                        dev_t->t_bacc,
+                                        gpmc_t->sync_clk);
+
+        temp = max_t(u32, dev_t->t_ces, dev_t->t_avds);
+        gpmc_t->clk_activation = gpmc_round_ps_to_ticks(temp);
+
+        if (gpmc_calc_divider(gpmc_t->sync_clk) != 1)
+                return 0;
+
+        if (dev_t->ce_xdelay)
+                gpmc_t->bool_timings.cs_extra_delay = true;
+        if (dev_t->avd_xdelay)
+                gpmc_t->bool_timings.adv_extra_delay = true;
+        if (dev_t->oe_xdelay)
+                gpmc_t->bool_timings.oe_extra_delay = true;
+        if (dev_t->we_xdelay)
+                gpmc_t->bool_timings.we_extra_delay = true;
+
+        return 0;
+}
+
+static int gpmc_calc_common_timings(struct gpmc_timings *gpmc_t,
+                                    struct gpmc_device_timings *dev_t,
+                                    bool sync)
+{
+        u32 temp;
+
+        /* cs_on */
+        gpmc_t->cs_on = gpmc_round_ps_to_ticks(dev_t->t_ceasu);
+
+        /* adv_on */
+        temp = dev_t->t_avdasu;
+        if (dev_t->t_ce_avd)
+                temp = max_t(u32, temp,
+                                gpmc_t->cs_on + dev_t->t_ce_avd);
+        gpmc_t->adv_on = gpmc_round_ps_to_ticks(temp);
+
+        if (sync)
+                gpmc_calc_sync_common_timings(gpmc_t, dev_t);
+
+        return 0;
+}
+
+/* TODO: remove this function once all peripherals are confirmed to
+ * work with generic timing. Simultaneously gpmc_cs_set_timings()
+ * has to be modified to handle timings in ps instead of ns
+*/
+static void gpmc_convert_ps_to_ns(struct gpmc_timings *t)
+{
+        t->cs_on /= 1000;
+        t->cs_rd_off /= 1000;
+        t->cs_wr_off /= 1000;
+        t->adv_on /= 1000;
+        t->adv_rd_off /= 1000;
+        t->adv_wr_off /= 1000;
+        t->we_on /= 1000;
+        t->we_off /= 1000;
+        t->oe_on /= 1000;
+        t->oe_off /= 1000;
+        t->page_burst_access /= 1000;
+        t->access /= 1000;
+        t->rd_cycle /= 1000;
+        t->wr_cycle /= 1000;
+        t->bus_turnaround /= 1000;
+        t->cycle2cycle_delay /= 1000;
+        t->wait_monitoring /= 1000;
+        t->clk_activation /= 1000;
+        t->wr_access /= 1000;
+        t->wr_data_mux_bus /= 1000;
+}
+
+int gpmc_calc_timings(struct gpmc_timings *gpmc_t,
+                      struct gpmc_settings *gpmc_s,
+                      struct gpmc_device_timings *dev_t)
+{
+        bool mux = false, sync = false;
+
+        if (gpmc_s) {
+                mux = gpmc_s->mux_add_data ? true : false;
+                sync = (gpmc_s->sync_read || gpmc_s->sync_write);
+        }
+
+        memset(gpmc_t, 0, sizeof(*gpmc_t));
+
+        gpmc_calc_common_timings(gpmc_t, dev_t, sync);
+
+        if (gpmc_s && gpmc_s->sync_read)
+                gpmc_calc_sync_read_timings(gpmc_t, dev_t, mux);
+        else
+                gpmc_calc_async_read_timings(gpmc_t, dev_t, mux);
+
+        if (gpmc_s && gpmc_s->sync_write)
+                gpmc_calc_sync_write_timings(gpmc_t, dev_t, mux);
+        else
+                gpmc_calc_async_write_timings(gpmc_t, dev_t, mux);
+
+        /* TODO: remove, see function definition */
+        gpmc_convert_ps_to_ns(gpmc_t);
+
+        return 0;
+}
+
+/**
+ * gpmc_cs_program_settings - programs non-timing related settings
+ * @cs:         GPMC chip-select to program
+ * @p:          pointer to GPMC settings structure
+ *
+ * Programs non-timing related settings for a GPMC chip-select, such as
+ * bus-width, burst configuration, etc. Function should be called once
+ * for each chip-select that is being used and must be called before
+ * calling gpmc_cs_set_timings() as timing parameters in the CONFIG1
+ * register will be initialised to zero by this function. Returns 0 on
+ * success and appropriate negative error code on failure.
+ */
+int gpmc_cs_program_settings(int cs, struct gpmc_settings *p)
+{
+        u32 config1;
+
+        if ((!p->device_width) || (p->device_width > GPMC_DEVWIDTH_16BIT)) {
+                pr_err("%s: invalid width %d!", __func__, p->device_width);
+                return -EINVAL;
+        }
+
+        /* Address-data multiplexing not supported for NAND devices */
+        if (p->device_nand && p->mux_add_data) {
+                pr_err("%s: invalid configuration!\n", __func__);
+                return -EINVAL;
+        }
+
+        if ((p->mux_add_data > GPMC_MUX_AD) ||
+            ((p->mux_add_data == GPMC_MUX_AAD) &&
+             !(gpmc_capability & GPMC_HAS_MUX_AAD))) {
+                pr_err("%s: invalid multiplex configuration!\n", __func__);
+                return -EINVAL;
+        }
+
+        /* Page/burst mode supports lengths of 4, 8 and 16 bytes */
+        if (p->burst_read || p->burst_write) {
+                switch (p->burst_len) {
+                case GPMC_BURST_4:
+                case GPMC_BURST_8:
+                case GPMC_BURST_16:
+                        break;
+                default:
+                        pr_err("%s: invalid page/burst-length (%d)\n",
+                               __func__, p->burst_len);
+                        return -EINVAL;
+                }
+        }
+
+        if (p->wait_pin > gpmc_nr_waitpins) {
+                pr_err("%s: invalid wait-pin (%d)\n", __func__, p->wait_pin);
+                return -EINVAL;
+        }
+
+        config1 = GPMC_CONFIG1_DEVICESIZE((p->device_width - 1));
+
+        if (p->sync_read)
+                config1 |= GPMC_CONFIG1_READTYPE_SYNC;
+        if (p->sync_write)
+                config1 |= GPMC_CONFIG1_WRITETYPE_SYNC;
+        if (p->wait_on_read)
+                config1 |= GPMC_CONFIG1_WAIT_READ_MON;
+        if (p->wait_on_write)
+                config1 |= GPMC_CONFIG1_WAIT_WRITE_MON;
+        if (p->wait_on_read || p->wait_on_write)
+                config1 |= GPMC_CONFIG1_WAIT_PIN_SEL(p->wait_pin);
+        if (p->device_nand)
+                config1 |= GPMC_CONFIG1_DEVICETYPE(GPMC_DEVICETYPE_NAND);
+        if (p->mux_add_data)
+                config1 |= GPMC_CONFIG1_MUXTYPE(p->mux_add_data);
+        if (p->burst_read)
+                config1 |= GPMC_CONFIG1_READMULTIPLE_SUPP;
+        if (p->burst_write)
+                config1 |= GPMC_CONFIG1_WRITEMULTIPLE_SUPP;
+        if (p->burst_read || p->burst_write) {
+                config1 |= GPMC_CONFIG1_PAGE_LEN(p->burst_len >> 3);
+                config1 |= p->burst_wrap ? GPMC_CONFIG1_WRAPBURST_SUPP : 0;
+        }
+
+        gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, config1);
+
+        return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id gpmc_dt_ids[] = {
+        { .compatible = "ti,omap2420-gpmc" },
+        { .compatible = "ti,omap2430-gpmc" },
+        { .compatible = "ti,omap3430-gpmc" },   /* omap3430 & omap3630 */
+        { .compatible = "ti,omap4430-gpmc" },   /* omap4430 & omap4460 & omap543x */
+        { .compatible = "ti,am3352-gpmc" },     /* am335x devices */
+        { }
+};
+MODULE_DEVICE_TABLE(of, gpmc_dt_ids);
+
+/**
+ * gpmc_read_settings_dt - read gpmc settings from device-tree
+ * @np:         pointer to device-tree node for a gpmc child device
+ * @p:          pointer to gpmc settings structure
+ *
+ * Reads the GPMC settings for a GPMC child device from device-tree and
+ * stores them in the GPMC settings structure passed. The GPMC settings
+ * structure is initialised to zero by this function and so any
+ * previously stored settings will be cleared.
+ */
+void gpmc_read_settings_dt(struct device_node *np, struct gpmc_settings *p)
+{
+        memset(p, 0, sizeof(struct gpmc_settings));
+
+        p->sync_read = of_property_read_bool(np, "gpmc,sync-read");
+        p->sync_write = of_property_read_bool(np, "gpmc,sync-write");
+        of_property_read_u32(np, "gpmc,device-width", &p->device_width);
+        of_property_read_u32(np, "gpmc,mux-add-data", &p->mux_add_data);
+
+        if (!of_property_read_u32(np, "gpmc,burst-length", &p->burst_len)) {
+                p->burst_wrap = of_property_read_bool(np, "gpmc,burst-wrap");
+                p->burst_read = of_property_read_bool(np, "gpmc,burst-read");
+                p->burst_write = of_property_read_bool(np, "gpmc,burst-write");
+                if (!p->burst_read && !p->burst_write)
+                        pr_warn("%s: page/burst-length set but not used!\n",
+                                __func__);
+        }
+
+        if (!of_property_read_u32(np, "gpmc,wait-pin", &p->wait_pin)) {
+                p->wait_on_read = of_property_read_bool(np,
+                                                        "gpmc,wait-on-read");
+                p->wait_on_write = of_property_read_bool(np,
+                                                         "gpmc,wait-on-write");
+                if (!p->wait_on_read && !p->wait_on_write)
+                        pr_debug("%s: rd/wr wait monitoring not enabled!\n",
+                                 __func__);
+        }
+}
+
+static void __maybe_unused gpmc_read_timings_dt(struct device_node *np,
+                                                struct gpmc_timings *gpmc_t)
+{
+        struct gpmc_bool_timings *p;
+
+        if (!np || !gpmc_t)
+                return;
+
+        memset(gpmc_t, 0, sizeof(*gpmc_t));
+
+        /* minimum clock period for syncronous mode */
+        of_property_read_u32(np, "gpmc,sync-clk-ps", &gpmc_t->sync_clk);
+
+        /* chip select timtings */
+        of_property_read_u32(np, "gpmc,cs-on-ns", &gpmc_t->cs_on);
+        of_property_read_u32(np, "gpmc,cs-rd-off-ns", &gpmc_t->cs_rd_off);
+        of_property_read_u32(np, "gpmc,cs-wr-off-ns", &gpmc_t->cs_wr_off);
+
+        /* ADV signal timings */
+        of_property_read_u32(np, "gpmc,adv-on-ns", &gpmc_t->adv_on);
+        of_property_read_u32(np, "gpmc,adv-rd-off-ns", &gpmc_t->adv_rd_off);
+        of_property_read_u32(np, "gpmc,adv-wr-off-ns", &gpmc_t->adv_wr_off);
+
+        /* WE signal timings */
+        of_property_read_u32(np, "gpmc,we-on-ns", &gpmc_t->we_on);
+        of_property_read_u32(np, "gpmc,we-off-ns", &gpmc_t->we_off);
+
+        /* OE signal timings */
+        of_property_read_u32(np, "gpmc,oe-on-ns", &gpmc_t->oe_on);
+        of_property_read_u32(np, "gpmc,oe-off-ns", &gpmc_t->oe_off);
+
+        /* access and cycle timings */
+        of_property_read_u32(np, "gpmc,page-burst-access-ns",
+                             &gpmc_t->page_burst_access);
+        of_property_read_u32(np, "gpmc,access-ns", &gpmc_t->access);
+        of_property_read_u32(np, "gpmc,rd-cycle-ns", &gpmc_t->rd_cycle);
+        of_property_read_u32(np, "gpmc,wr-cycle-ns", &gpmc_t->wr_cycle);
+        of_property_read_u32(np, "gpmc,bus-turnaround-ns",
+                             &gpmc_t->bus_turnaround);
+        of_property_read_u32(np, "gpmc,cycle2cycle-delay-ns",
+                             &gpmc_t->cycle2cycle_delay);
+        of_property_read_u32(np, "gpmc,wait-monitoring-ns",
+                             &gpmc_t->wait_monitoring);
+        of_property_read_u32(np, "gpmc,clk-activation-ns",
+                             &gpmc_t->clk_activation);
+
+        /* only applicable to OMAP3+ */
+        of_property_read_u32(np, "gpmc,wr-access-ns", &gpmc_t->wr_access);
+        of_property_read_u32(np, "gpmc,wr-data-mux-bus-ns",
+                             &gpmc_t->wr_data_mux_bus);
+
+        /* bool timing parameters */
+        p = &gpmc_t->bool_timings;
+
+        p->cycle2cyclediffcsen =
+                of_property_read_bool(np, "gpmc,cycle2cycle-diffcsen");
+        p->cycle2cyclesamecsen =
+                of_property_read_bool(np, "gpmc,cycle2cycle-samecsen");
+        p->we_extra_delay = of_property_read_bool(np, "gpmc,we-extra-delay");
+        p->oe_extra_delay = of_property_read_bool(np, "gpmc,oe-extra-delay");
+        p->adv_extra_delay = of_property_read_bool(np, "gpmc,adv-extra-delay");
+        p->cs_extra_delay = of_property_read_bool(np, "gpmc,cs-extra-delay");
+        p->time_para_granularity =
+                of_property_read_bool(np, "gpmc,time-para-granularity");
+}
+
+#if IS_ENABLED(CONFIG_MTD_NAND)
+
+static const char * const nand_xfer_types[] = {
+        [NAND_OMAP_PREFETCH_POLLED]             = "prefetch-polled",
+        [NAND_OMAP_POLLED]                      = "polled",
+        [NAND_OMAP_PREFETCH_DMA]                = "prefetch-dma",
+        [NAND_OMAP_PREFETCH_IRQ]                = "prefetch-irq",
+};
+
+static int gpmc_probe_nand_child(struct platform_device *pdev,
+                                 struct device_node *child)
+{
+        u32 val;
+        const char *s;
+        struct gpmc_timings gpmc_t;
+        struct omap_nand_platform_data *gpmc_nand_data;
+
+        if (of_property_read_u32(child, "reg", &val) < 0) {
+                dev_err(&pdev->dev, "%s has no 'reg' property\n",
+                        child->full_name);
+                return -ENODEV;
+        }
+
+        gpmc_nand_data = devm_kzalloc(&pdev->dev, sizeof(*gpmc_nand_data),
+                                      GFP_KERNEL);
+        if (!gpmc_nand_data)
+                return -ENOMEM;
+
+        gpmc_nand_data->cs = val;
+        gpmc_nand_data->of_node = child;
+
+        /* Detect availability of ELM module */
+        gpmc_nand_data->elm_of_node = of_parse_phandle(child, "ti,elm-id", 0);
+        if (gpmc_nand_data->elm_of_node == NULL)
+                gpmc_nand_data->elm_of_node =
+                                        of_parse_phandle(child, "elm_id", 0);
+
+        /* select ecc-scheme for NAND */
+        if (of_property_read_string(child, "ti,nand-ecc-opt", &s)) {
+                pr_err("%s: ti,nand-ecc-opt not found\n", __func__);
+                return -ENODEV;
+        }
+
+        if (!strcmp(s, "sw"))
+                gpmc_nand_data->ecc_opt = OMAP_ECC_HAM1_CODE_SW;
+        else if (!strcmp(s, "ham1") ||
+                 !strcmp(s, "hw") || !strcmp(s, "hw-romcode"))
+                gpmc_nand_data->ecc_opt =
+                                OMAP_ECC_HAM1_CODE_HW;
+        else if (!strcmp(s, "bch4"))
+                if (gpmc_nand_data->elm_of_node)
+                        gpmc_nand_data->ecc_opt =
+                                OMAP_ECC_BCH4_CODE_HW;
+                else
+                        gpmc_nand_data->ecc_opt =
+                                OMAP_ECC_BCH4_CODE_HW_DETECTION_SW;
+        else if (!strcmp(s, "bch8"))
+                if (gpmc_nand_data->elm_of_node)
+                        gpmc_nand_data->ecc_opt =
+                                OMAP_ECC_BCH8_CODE_HW;
+                else
+                        gpmc_nand_data->ecc_opt =
+                                OMAP_ECC_BCH8_CODE_HW_DETECTION_SW;
+        else if (!strcmp(s, "bch16"))
+                if (gpmc_nand_data->elm_of_node)
+                        gpmc_nand_data->ecc_opt =
+                                OMAP_ECC_BCH16_CODE_HW;
+                else
+                        pr_err("%s: BCH16 requires ELM support\n", __func__);
+        else
+                pr_err("%s: ti,nand-ecc-opt invalid value\n", __func__);
+
+        /* select data transfer mode for NAND controller */
+        if (!of_property_read_string(child, "ti,nand-xfer-type", &s))
+                for (val = 0; val < ARRAY_SIZE(nand_xfer_types); val++)
+                        if (!strcasecmp(s, nand_xfer_types[val])) {
+                                gpmc_nand_data->xfer_type = val;
+                                break;
+                        }
+
+        gpmc_nand_data->flash_bbt = of_get_nand_on_flash_bbt(child);
+
+        val = of_get_nand_bus_width(child);
+        if (val == 16)
+                gpmc_nand_data->devsize = NAND_BUSWIDTH_16;
+
+        gpmc_read_timings_dt(child, &gpmc_t);
+        gpmc_nand_init(gpmc_nand_data, &gpmc_t);
+
+        return 0;
+}
+#else
+static int gpmc_probe_nand_child(struct platform_device *pdev,
+                                 struct device_node *child)
+{
+        return 0;
+}
+#endif
+
+#if IS_ENABLED(CONFIG_MTD_ONENAND)
+static int gpmc_probe_onenand_child(struct platform_device *pdev,
+                                 struct device_node *child)
+{
+        u32 val;
+        struct omap_onenand_platform_data *gpmc_onenand_data;
+
+        if (of_property_read_u32(child, "reg", &val) < 0) {
+                dev_err(&pdev->dev, "%s has no 'reg' property\n",
+                        child->full_name);
+                return -ENODEV;
+        }
+
+        gpmc_onenand_data = devm_kzalloc(&pdev->dev, sizeof(*gpmc_onenand_data),
+                                         GFP_KERNEL);
+        if (!gpmc_onenand_data)
+                return -ENOMEM;
+
+        gpmc_onenand_data->cs = val;
+        gpmc_onenand_data->of_node = child;
+        gpmc_onenand_data->dma_channel = -1;
+
+        if (!of_property_read_u32(child, "dma-channel", &val))
+                gpmc_onenand_data->dma_channel = val;
+
+        gpmc_onenand_init(gpmc_onenand_data);
+
+        return 0;
+}
+#else
+static int gpmc_probe_onenand_child(struct platform_device *pdev,
+                                    struct device_node *child)
+{
+        return 0;
+}
+#endif
+
+/**
+ * gpmc_probe_generic_child - configures the gpmc for a child device
+ * @pdev:       pointer to gpmc platform device
+ * @child:      pointer to device-tree node for child device
+ *
+ * Allocates and configures a GPMC chip-select for a child device.
+ * Returns 0 on success and appropriate negative error code on failure.
+ */
+static int gpmc_probe_generic_child(struct platform_device *pdev,
+                                struct device_node *child)
+{
+        struct gpmc_settings gpmc_s;
+        struct gpmc_timings gpmc_t;
+        struct resource res;
+        unsigned long base;
+        const char *name;
+        int ret, cs;
+        u32 val;
+
+        if (of_property_read_u32(child, "reg", &cs) < 0) {
+                dev_err(&pdev->dev, "%s has no 'reg' property\n",
+                        child->full_name);
+                return -ENODEV;
+        }
+
+        if (of_address_to_resource(child, 0, &res) < 0) {
+                dev_err(&pdev->dev, "%s has malformed 'reg' property\n",
+                        child->full_name);
+                return -ENODEV;
+        }
+
+        /*
+         * Check if we have multiple instances of the same device
+         * on a single chip select. If so, use the already initialized
+         * timings.
+         */
+        name = gpmc_cs_get_name(cs);
+        if (name && child->name && of_node_cmp(child->name, name) == 0)
+                        goto no_timings;
+
+        ret = gpmc_cs_request(cs, resource_size(&res), &base);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "cannot request GPMC CS %d\n", cs);
+                return ret;
+        }
+        gpmc_cs_set_name(cs, child->name);
+
+        gpmc_read_settings_dt(child, &gpmc_s);
+        gpmc_read_timings_dt(child, &gpmc_t);
+
+        /*
+         * For some GPMC devices we still need to rely on the bootloader
+         * timings because the devices can be connected via FPGA.
+         * REVISIT: Add timing support from slls644g.pdf.
+         */
+        if (!gpmc_t.cs_rd_off) {
+                WARN(1, "enable GPMC debug to configure .dts timings for CS%i\n",
+                        cs);
+                gpmc_cs_show_timings(cs,
+                                     "please add GPMC bootloader timings to .dts");
+                goto no_timings;
+        }
+
+        /* CS must be disabled while making changes to gpmc configuration */
+        gpmc_cs_disable_mem(cs);
+
+        /*
+         * FIXME: gpmc_cs_request() will map the CS to an arbitary
+         * location in the gpmc address space. When booting with
+         * device-tree we want the NOR flash to be mapped to the
+         * location specified in the device-tree blob. So remap the
+         * CS to this location. Once DT migration is complete should
+         * just make gpmc_cs_request() map a specific address.
+         */
+        ret = gpmc_cs_remap(cs, res.start);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "cannot remap GPMC CS %d to %pa\n",
+                        cs, &res.start);
+                goto err;
+        }
+
+        ret = of_property_read_u32(child, "bank-width", &gpmc_s.device_width);
+        if (ret < 0)
+                goto err;
+
+        ret = gpmc_cs_program_settings(cs, &gpmc_s);
+        if (ret < 0)
+                goto err;
+
+        ret = gpmc_cs_set_timings(cs, &gpmc_t);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to set gpmc timings for: %s\n",
+                        child->name);
+                goto err;
+        }
+
+        /* Clear limited address i.e. enable A26-A11 */
+        val = gpmc_read_reg(GPMC_CONFIG);
+        val &= ~GPMC_CONFIG_LIMITEDADDRESS;
+        gpmc_write_reg(GPMC_CONFIG, val);
+
+        /* Enable CS region */
+        gpmc_cs_enable_mem(cs);
+
+no_timings:
+        if (of_platform_device_create(child, NULL, &pdev->dev))
+                return 0;
+
+        dev_err(&pdev->dev, "failed to create gpmc child %s\n", child->name);
+        ret = -ENODEV;
+
+err:
+        gpmc_cs_free(cs);
+
+        return ret;
+}
+
+static int gpmc_probe_dt(struct platform_device *pdev)
+{
+        int ret;
+        struct device_node *child;
+        const struct of_device_id *of_id =
+                of_match_device(gpmc_dt_ids, &pdev->dev);
+
+        if (!of_id)
+                return 0;
+
+        ret = of_property_read_u32(pdev->dev.of_node, "gpmc,num-cs",
+                                   &gpmc_cs_num);
+        if (ret < 0) {
+                pr_err("%s: number of chip-selects not defined\n", __func__);
+                return ret;
+        } else if (gpmc_cs_num < 1) {
+                pr_err("%s: all chip-selects are disabled\n", __func__);
+                return -EINVAL;
+        } else if (gpmc_cs_num > GPMC_CS_NUM) {
+                pr_err("%s: number of supported chip-selects cannot be > %d\n",
+                                         __func__, GPMC_CS_NUM);
+                return -EINVAL;
+        }
+
+        ret = of_property_read_u32(pdev->dev.of_node, "gpmc,num-waitpins",
+                                   &gpmc_nr_waitpins);
+        if (ret < 0) {
+                pr_err("%s: number of wait pins not found!\n", __func__);
+                return ret;
+        }
+
+        for_each_available_child_of_node(pdev->dev.of_node, child) {
+
+                if (!child->name)
+                        continue;
+
+                if (of_node_cmp(child->name, "nand") == 0)
+                        ret = gpmc_probe_nand_child(pdev, child);
+                else if (of_node_cmp(child->name, "onenand") == 0)
+                        ret = gpmc_probe_onenand_child(pdev, child);
+                else if (of_node_cmp(child->name, "ethernet") == 0 ||
+                         of_node_cmp(child->name, "nor") == 0 ||
+                         of_node_cmp(child->name, "uart") == 0)
+                        ret = gpmc_probe_generic_child(pdev, child);
+
+                if (WARN(ret < 0, "%s: probing gpmc child %s failed\n",
+                         __func__, child->full_name))
+                        of_node_put(child);
+        }
+
+        return 0;
+}
+#else
+static int gpmc_probe_dt(struct platform_device *pdev)
+{
+        return 0;
+}
+#endif
+
+static int gpmc_probe(struct platform_device *pdev)
+{
+        int rc;
+        u32 l;
+        struct resource *res;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL)
+                return -ENOENT;
+
+        phys_base = res->start;
+        mem_size = resource_size(res);
+
+        gpmc_base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(gpmc_base))
+                return PTR_ERR(gpmc_base);
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (res == NULL)
+                dev_warn(&pdev->dev, "Failed to get resource: irq\n");
+        else
+                gpmc_irq = res->start;
+
+        gpmc_l3_clk = devm_clk_get(&pdev->dev, "fck");
+        if (IS_ERR(gpmc_l3_clk)) {
+                dev_err(&pdev->dev, "Failed to get GPMC fck\n");
+                gpmc_irq = 0;
+                return PTR_ERR(gpmc_l3_clk);
+        }
+
+        if (!clk_get_rate(gpmc_l3_clk)) {
+                dev_err(&pdev->dev, "Invalid GPMC fck clock rate\n");
+                return -EINVAL;
+        }
+
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_get_sync(&pdev->dev);
+
+        gpmc_dev = &pdev->dev;
+
+        l = gpmc_read_reg(GPMC_REVISION);
+
+        /*
+         * FIXME: Once device-tree migration is complete the below flags
+         * should be populated based upon the device-tree compatible
+         * string. For now just use the IP revision. OMAP3+ devices have
+         * the wr_access and wr_data_mux_bus register fields. OMAP4+
+         * devices support the addr-addr-data multiplex protocol.
+         *
+         * GPMC IP revisions:
+         * - OMAP24xx                   = 2.0
+         * - OMAP3xxx                   = 5.0
+         * - OMAP44xx/54xx/AM335x       = 6.0
+         */
+        if (GPMC_REVISION_MAJOR(l) > 0x4)
+                gpmc_capability = GPMC_HAS_WR_ACCESS | GPMC_HAS_WR_DATA_MUX_BUS;
+        if (GPMC_REVISION_MAJOR(l) > 0x5)
+                gpmc_capability |= GPMC_HAS_MUX_AAD;
+        dev_info(gpmc_dev, "GPMC revision %d.%d\n", GPMC_REVISION_MAJOR(l),
+                 GPMC_REVISION_MINOR(l));
+
+        gpmc_mem_init();
+
+        if (gpmc_setup_irq() < 0)
+                dev_warn(gpmc_dev, "gpmc_setup_irq failed\n");
+
+        if (!pdev->dev.of_node) {
+                gpmc_cs_num      = GPMC_CS_NUM;
+                gpmc_nr_waitpins = GPMC_NR_WAITPINS;
+        }
+
+        rc = gpmc_probe_dt(pdev);
+        if (rc < 0) {
+                pm_runtime_put_sync(&pdev->dev);
+                dev_err(gpmc_dev, "failed to probe DT parameters\n");
+                return rc;
+        }
+
+        return 0;
+}
+
+static int gpmc_remove(struct platform_device *pdev)
+{
+        gpmc_free_irq();
+        gpmc_mem_exit();
+        pm_runtime_put_sync(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
+        gpmc_dev = NULL;
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int gpmc_suspend(struct device *dev)
+{
+        omap3_gpmc_save_context();
+        pm_runtime_put_sync(dev);
+        return 0;
+}
+
+static int gpmc_resume(struct device *dev)
+{
+        pm_runtime_get_sync(dev);
+        omap3_gpmc_restore_context();
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(gpmc_pm_ops, gpmc_suspend, gpmc_resume);
+
+static struct platform_driver gpmc_driver = {
+        .probe          = gpmc_probe,
+        .remove         = gpmc_remove,
+        .driver         = {
+                .name   = DEVICE_NAME,
+                .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(gpmc_dt_ids),
+                .pm     = &gpmc_pm_ops,
+        },
+};
+
+static __init int gpmc_init(void)
+{
+        return platform_driver_register(&gpmc_driver);
+}
+
+static __exit void gpmc_exit(void)
+{
+        platform_driver_unregister(&gpmc_driver);
+
+}
+
+postcore_initcall(gpmc_init);
+module_exit(gpmc_exit);
+
+static irqreturn_t gpmc_handle_irq(int irq, void *dev)
+{
+        int i;
+        u32 regval;
+
+        regval = gpmc_read_reg(GPMC_IRQSTATUS);
+
+        if (!regval)
+                return IRQ_NONE;
+
+        for (i = 0; i < GPMC_NR_IRQ; i++)
+                if (regval & gpmc_client_irq[i].bitmask)
+                        generic_handle_irq(gpmc_client_irq[i].irq);
+
+        gpmc_write_reg(GPMC_IRQSTATUS, regval);
+
+        return IRQ_HANDLED;
+}
+
+static struct omap3_gpmc_regs gpmc_context;
+
+void omap3_gpmc_save_context(void)
+{
+        int i;
+
+        gpmc_context.sysconfig = gpmc_read_reg(GPMC_SYSCONFIG);
+        gpmc_context.irqenable = gpmc_read_reg(GPMC_IRQENABLE);
+        gpmc_context.timeout_ctrl = gpmc_read_reg(GPMC_TIMEOUT_CONTROL);
+        gpmc_context.config = gpmc_read_reg(GPMC_CONFIG);
+        gpmc_context.prefetch_config1 = gpmc_read_reg(GPMC_PREFETCH_CONFIG1);
+        gpmc_context.prefetch_config2 = gpmc_read_reg(GPMC_PREFETCH_CONFIG2);
+        gpmc_context.prefetch_control = gpmc_read_reg(GPMC_PREFETCH_CONTROL);
+        for (i = 0; i < gpmc_cs_num; i++) {
+                gpmc_context.cs_context[i].is_valid = gpmc_cs_mem_enabled(i);
+                if (gpmc_context.cs_context[i].is_valid) {
+                        gpmc_context.cs_context[i].config1 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG1);
+                        gpmc_context.cs_context[i].config2 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG2);
+                        gpmc_context.cs_context[i].config3 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG3);
+                        gpmc_context.cs_context[i].config4 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG4);
+                        gpmc_context.cs_context[i].config5 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG5);
+                        gpmc_context.cs_context[i].config6 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG6);
+                        gpmc_context.cs_context[i].config7 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG7);
+                }
+        }
+}
+
+void omap3_gpmc_restore_context(void)
+{
+        int i;
+
+        gpmc_write_reg(GPMC_SYSCONFIG, gpmc_context.sysconfig);
+        gpmc_write_reg(GPMC_IRQENABLE, gpmc_context.irqenable);
+        gpmc_write_reg(GPMC_TIMEOUT_CONTROL, gpmc_context.timeout_ctrl);
+        gpmc_write_reg(GPMC_CONFIG, gpmc_context.config);
+        gpmc_write_reg(GPMC_PREFETCH_CONFIG1, gpmc_context.prefetch_config1);
+        gpmc_write_reg(GPMC_PREFETCH_CONFIG2, gpmc_context.prefetch_config2);
+        gpmc_write_reg(GPMC_PREFETCH_CONTROL, gpmc_context.prefetch_control);
+        for (i = 0; i < gpmc_cs_num; i++) {
+                if (gpmc_context.cs_context[i].is_valid) {
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG1,
+                                gpmc_context.cs_context[i].config1);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG2,
+                                gpmc_context.cs_context[i].config2);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG3,
+                                gpmc_context.cs_context[i].config3);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG4,
+                                gpmc_context.cs_context[i].config4);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG5,
+                                gpmc_context.cs_context[i].config5);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG6,
+                                gpmc_context.cs_context[i].config6);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG7,
+                                gpmc_context.cs_context[i].config7);
+                }
+        }
+}
diff --git a/drivers/memory/tegra/Kconfig b/drivers/memory/tegra/Kconfig
new file mode 100644
index 000000000000..571087621827
--- /dev/null
+++ b/drivers/memory/tegra/Kconfig
@@ -0,0 +1,7 @@
+config TEGRA_MC
+        bool "NVIDIA Tegra Memory Controller support"
+        default y
+        depends on ARCH_TEGRA
+        help
+          This driver supports the Memory Controller (MC) hardware found on
+          NVIDIA Tegra SoCs.
diff --git a/drivers/memory/tegra/Makefile b/drivers/memory/tegra/Makefile
new file mode 100644
index 000000000000..0d9f497b786c
--- /dev/null
+++ b/drivers/memory/tegra/Makefile
@@ -0,0 +1,7 @@
+tegra-mc-y := mc.o
+
+tegra-mc-$(CONFIG_ARCH_TEGRA_3x_SOC)  += tegra30.o
+tegra-mc-$(CONFIG_ARCH_TEGRA_114_SOC) += tegra114.o
+tegra-mc-$(CONFIG_ARCH_TEGRA_124_SOC) += tegra124.o
+
+obj-$(CONFIG_TEGRA_MC) += tegra-mc.o
diff --git a/drivers/memory/tegra/mc.c b/drivers/memory/tegra/mc.c
new file mode 100644
index 000000000000..fe3c44e7e1d1
--- /dev/null
+++ b/drivers/memory/tegra/mc.c
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2014 NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/clk.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include "mc.h"
+
+#define MC_INTSTATUS 0x000
+#define  MC_INT_DECERR_MTS (1 << 16)
+#define  MC_INT_SECERR_SEC (1 << 13)
+#define  MC_INT_DECERR_VPR (1 << 12)
+#define  MC_INT_INVALID_APB_ASID_UPDATE (1 << 11)
+#define  MC_INT_INVALID_SMMU_PAGE (1 << 10)
+#define  MC_INT_ARBITRATION_EMEM (1 << 9)
+#define  MC_INT_SECURITY_VIOLATION (1 << 8)
+#define  MC_INT_DECERR_EMEM (1 << 6)
+
+#define MC_INTMASK 0x004
+
+#define MC_ERR_STATUS 0x08
+#define  MC_ERR_STATUS_TYPE_SHIFT 28
+#define  MC_ERR_STATUS_TYPE_INVALID_SMMU_PAGE (6 << MC_ERR_STATUS_TYPE_SHIFT)
+#define  MC_ERR_STATUS_TYPE_MASK (0x7 << MC_ERR_STATUS_TYPE_SHIFT)
+#define  MC_ERR_STATUS_READABLE (1 << 27)
+#define  MC_ERR_STATUS_WRITABLE (1 << 26)
+#define  MC_ERR_STATUS_NONSECURE (1 << 25)
+#define  MC_ERR_STATUS_ADR_HI_SHIFT 20
+#define  MC_ERR_STATUS_ADR_HI_MASK 0x3
+#define  MC_ERR_STATUS_SECURITY (1 << 17)
+#define  MC_ERR_STATUS_RW (1 << 16)
+#define  MC_ERR_STATUS_CLIENT_MASK 0x7f
+
+#define MC_ERR_ADR 0x0c
+
+#define MC_EMEM_ARB_CFG 0x90
+#define  MC_EMEM_ARB_CFG_CYCLES_PER_UPDATE(x)   (((x) & 0x1ff) << 0)
+#define  MC_EMEM_ARB_CFG_CYCLES_PER_UPDATE_MASK 0x1ff
+#define MC_EMEM_ARB_MISC0 0xd8
+
+static const struct of_device_id tegra_mc_of_match[] = {
+#ifdef CONFIG_ARCH_TEGRA_3x_SOC
+        { .compatible = "nvidia,tegra30-mc", .data = &tegra30_mc_soc },
+#endif
+#ifdef CONFIG_ARCH_TEGRA_114_SOC
+        { .compatible = "nvidia,tegra114-mc", .data = &tegra114_mc_soc },
+#endif
+#ifdef CONFIG_ARCH_TEGRA_124_SOC
+        { .compatible = "nvidia,tegra124-mc", .data = &tegra124_mc_soc },
+#endif
+        { }
+};
+MODULE_DEVICE_TABLE(of, tegra_mc_of_match);
+
+static int tegra_mc_setup_latency_allowance(struct tegra_mc *mc)
+{
+        unsigned long long tick;
+        unsigned int i;
+        u32 value;
+
+        /* compute the number of MC clock cycles per tick */
+        tick = mc->tick * clk_get_rate(mc->clk);
+        do_div(tick, NSEC_PER_SEC);
+
+        value = readl(mc->regs + MC_EMEM_ARB_CFG);
+        value &= ~MC_EMEM_ARB_CFG_CYCLES_PER_UPDATE_MASK;
+        value |= MC_EMEM_ARB_CFG_CYCLES_PER_UPDATE(tick);
+        writel(value, mc->regs + MC_EMEM_ARB_CFG);
+
+        /* write latency allowance defaults */
+        for (i = 0; i < mc->soc->num_clients; i++) {
+                const struct tegra_mc_la *la = &mc->soc->clients[i].la;
+                u32 value;
+
+                value = readl(mc->regs + la->reg);
+                value &= ~(la->mask << la->shift);
+                value |= (la->def & la->mask) << la->shift;
+                writel(value, mc->regs + la->reg);
+        }
+
+        return 0;
+}
+
+static const char *const status_names[32] = {
+        [ 1] = "External interrupt",
+        [ 6] = "EMEM address decode error",
+        [ 8] = "Security violation",
+        [ 9] = "EMEM arbitration error",
+        [10] = "Page fault",
+        [11] = "Invalid APB ASID update",
+        [12] = "VPR violation",
+        [13] = "Secure carveout violation",
+        [16] = "MTS carveout violation",
+};
+
+static const char *const error_names[8] = {
+        [2] = "EMEM decode error",
+        [3] = "TrustZone violation",
+        [4] = "Carveout violation",
+        [6] = "SMMU translation error",
+};
+
+static irqreturn_t tegra_mc_irq(int irq, void *data)
+{
+        struct tegra_mc *mc = data;
+        unsigned long status, mask;
+        unsigned int bit;
+
+        /* mask all interrupts to avoid flooding */
+        status = mc_readl(mc, MC_INTSTATUS);
+        mask = mc_readl(mc, MC_INTMASK);
+
+        for_each_set_bit(bit, &status, 32) {
+                const char *error = status_names[bit] ?: "unknown";
+                const char *client = "unknown", *desc;
+                const char *direction, *secure;
+                phys_addr_t addr = 0;
+                unsigned int i;
+                char perm[7];
+                u8 id, type;
+                u32 value;
+
+                value = mc_readl(mc, MC_ERR_STATUS);
+
+#ifdef CONFIG_PHYS_ADDR_T_64BIT
+                if (mc->soc->num_address_bits > 32) {
+                        addr = ((value >> MC_ERR_STATUS_ADR_HI_SHIFT) &
+                                MC_ERR_STATUS_ADR_HI_MASK);
+                        addr <<= 32;
+                }
+#endif
+
+                if (value & MC_ERR_STATUS_RW)
+                        direction = "write";
+                else
+                        direction = "read";
+
+                if (value & MC_ERR_STATUS_SECURITY)
+                        secure = "secure ";
+                else
+                        secure = "";
+
+                id = value & MC_ERR_STATUS_CLIENT_MASK;
+
+                for (i = 0; i < mc->soc->num_clients; i++) {
+                        if (mc->soc->clients[i].id == id) {
+                                client = mc->soc->clients[i].name;
+                                break;
+                        }
+                }
+
+                type = (value & MC_ERR_STATUS_TYPE_MASK) >>
+                       MC_ERR_STATUS_TYPE_SHIFT;
+                desc = error_names[type];
+
+                switch (value & MC_ERR_STATUS_TYPE_MASK) {
+                case MC_ERR_STATUS_TYPE_INVALID_SMMU_PAGE:
+                        perm[0] = ' ';
+                        perm[1] = '[';
+
+                        if (value & MC_ERR_STATUS_READABLE)
+                                perm[2] = 'R';
+                        else
+                                perm[2] = '-';
+
+                        if (value & MC_ERR_STATUS_WRITABLE)
+                                perm[3] = 'W';
+                        else
+                                perm[3] = '-';
+
+                        if (value & MC_ERR_STATUS_NONSECURE)
+                                perm[4] = '-';
+                        else
+                                perm[4] = 'S';
+
+                        perm[5] = ']';
+                        perm[6] = '\0';
+                        break;
+
+                default:
+                        perm[0] = '\0';
+                        break;
+                }
+
+                value = mc_readl(mc, MC_ERR_ADR);
+                addr |= value;
+
+                dev_err_ratelimited(mc->dev, "%s: %s%s @%pa: %s (%s%s)\n",
+                                    client, secure, direction, &addr, error,
+                                    desc, perm);
+        }
+
+        /* clear interrupts */
+        mc_writel(mc, status, MC_INTSTATUS);
+
+        return IRQ_HANDLED;
+}
+
+static int tegra_mc_probe(struct platform_device *pdev)
+{
+        const struct of_device_id *match;
+        struct resource *res;
+        struct tegra_mc *mc;
+        u32 value;
+        int err;
+
+        match = of_match_node(tegra_mc_of_match, pdev->dev.of_node);
+        if (!match)
+                return -ENODEV;
+
+        mc = devm_kzalloc(&pdev->dev, sizeof(*mc), GFP_KERNEL);
+        if (!mc)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, mc);
+        mc->soc = match->data;
+        mc->dev = &pdev->dev;
+
+        /* length of MC tick in nanoseconds */
+        mc->tick = 30;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        mc->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(mc->regs))
+                return PTR_ERR(mc->regs);
+
+        mc->clk = devm_clk_get(&pdev->dev, "mc");
+        if (IS_ERR(mc->clk)) {
+                dev_err(&pdev->dev, "failed to get MC clock: %ld\n",
+                        PTR_ERR(mc->clk));
+                return PTR_ERR(mc->clk);
+        }
+
+        err = tegra_mc_setup_latency_allowance(mc);
+        if (err < 0) {
+                dev_err(&pdev->dev, "failed to setup latency allowance: %d\n",
+                        err);
+                return err;
+        }
+
+        if (IS_ENABLED(CONFIG_TEGRA_IOMMU_SMMU)) {
+                mc->smmu = tegra_smmu_probe(&pdev->dev, mc->soc->smmu, mc);
+                if (IS_ERR(mc->smmu)) {
+                        dev_err(&pdev->dev, "failed to probe SMMU: %ld\n",
+                                PTR_ERR(mc->smmu));
+                        return PTR_ERR(mc->smmu);
+                }
+        }
+
+        mc->irq = platform_get_irq(pdev, 0);
+        if (mc->irq < 0) {
+                dev_err(&pdev->dev, "interrupt not specified\n");
+                return mc->irq;
+        }
+
+        err = devm_request_irq(&pdev->dev, mc->irq, tegra_mc_irq, IRQF_SHARED,
+                               dev_name(&pdev->dev), mc);
+        if (err < 0) {
+                dev_err(&pdev->dev, "failed to request IRQ#%u: %d\n", mc->irq,
+                        err);
+                return err;
+        }
+
+        value = MC_INT_DECERR_MTS | MC_INT_SECERR_SEC | MC_INT_DECERR_VPR |
+                MC_INT_INVALID_APB_ASID_UPDATE | MC_INT_INVALID_SMMU_PAGE |
+                MC_INT_ARBITRATION_EMEM | MC_INT_SECURITY_VIOLATION |
+                MC_INT_DECERR_EMEM;
+        mc_writel(mc, value, MC_INTMASK);
+
+        return 0;
+}
+
+static struct platform_driver tegra_mc_driver = {
+        .driver = {
+                .name = "tegra-mc",
+                .of_match_table = tegra_mc_of_match,
+                .suppress_bind_attrs = true,
+        },
+        .prevent_deferred_probe = true,
+        .probe = tegra_mc_probe,
+};
+
+static int tegra_mc_init(void)
+{
+        return platform_driver_register(&tegra_mc_driver);
+}
+arch_initcall(tegra_mc_init);
+
+MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
+MODULE_DESCRIPTION("NVIDIA Tegra Memory Controller driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/memory/tegra/mc.h b/drivers/memory/tegra/mc.h
new file mode 100644
index 000000000000..d5d21147fc77
--- /dev/null
+++ b/drivers/memory/tegra/mc.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2014 NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef MEMORY_TEGRA_MC_H
+#define MEMORY_TEGRA_MC_H
+
+#include <linux/io.h>
+#include <linux/types.h>
+
+#include <soc/tegra/mc.h>
+
+static inline u32 mc_readl(struct tegra_mc *mc, unsigned long offset)
+{
+        return readl(mc->regs + offset);
+}
+
+static inline void mc_writel(struct tegra_mc *mc, u32 value,
+                             unsigned long offset)
+{
+        writel(value, mc->regs + offset);
+}
+
+#ifdef CONFIG_ARCH_TEGRA_3x_SOC
+extern const struct tegra_mc_soc tegra30_mc_soc;
+#endif
+
+#ifdef CONFIG_ARCH_TEGRA_114_SOC
+extern const struct tegra_mc_soc tegra114_mc_soc;
+#endif
+
+#ifdef CONFIG_ARCH_TEGRA_124_SOC
+extern const struct tegra_mc_soc tegra124_mc_soc;
+#endif
+
+#endif /* MEMORY_TEGRA_MC_H */
diff --git a/drivers/memory/tegra/tegra114.c b/drivers/memory/tegra/tegra114.c
new file mode 100644
index 000000000000..511e9a25c151
--- /dev/null
+++ b/drivers/memory/tegra/tegra114.c
@@ -0,0 +1,948 @@
+/*
+ * Copyright (C) 2014 NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/of.h>
+#include <linux/mm.h>
+
+#include <asm/cacheflush.h>
+
+#include <dt-bindings/memory/tegra114-mc.h>
+
+#include "mc.h"
+
+static const struct tegra_mc_client tegra114_mc_clients[] = {
+        {
+                .id = 0x00,
+                .name = "ptcr",
+                .swgroup = TEGRA_SWGROUP_PTC,
+        }, {
+                .id = 0x01,
+                .name = "display0a",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 1,
+                },
+                .la = {
+                        .reg = 0x2e8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x02,
+                .name = "display0ab",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 2,
+                },
+                .la = {
+                        .reg = 0x2f4,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x03,
+                .name = "display0b",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 3,
+                },
+                .la = {
+                        .reg = 0x2e8,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x04,
+                .name = "display0bb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 4,
+                },
+                .la = {
+                        .reg = 0x2f4,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x05,
+                .name = "display0c",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 5,
+                },
+                .la = {
+                        .reg = 0x2ec,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x06,
+                .name = "display0cb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 6,
+                },
+                .la = {
+                        .reg = 0x2f8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x09,
+                .name = "eppup",
+                .swgroup = TEGRA_SWGROUP_EPP,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 9,
+                },
+                .la = {
+                        .reg = 0x300,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x33,
+                },
+        }, {
+                .id = 0x0a,
+                .name = "g2pr",
+                .swgroup = TEGRA_SWGROUP_G2,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 10,
+                },
+                .la = {
+                        .reg = 0x308,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x09,
+                },
+        }, {
+                .id = 0x0b,
+                .name = "g2sr",
+                .swgroup = TEGRA_SWGROUP_G2,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 11,
+                },
+                .la = {
+                        .reg = 0x308,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x09,
+                },
+        }, {
+                .id = 0x0f,
+                .name = "avpcarm7r",
+                .swgroup = TEGRA_SWGROUP_AVPC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 15,
+                },
+                .la = {
+                        .reg = 0x2e4,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x10,
+                .name = "displayhc",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 16,
+                },
+                .la = {
+                        .reg = 0x2f0,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x68,
+                },
+        }, {
+                .id = 0x11,
+                .name = "displayhcb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 17,
+                },
+                .la = {
+                        .reg = 0x2fc,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x68,
+                },
+        }, {
+                .id = 0x12,
+                .name = "fdcdrd",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 18,
+                },
+                .la = {
+                        .reg = 0x334,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x0c,
+                },
+        }, {
+                .id = 0x13,
+                .name = "fdcdrd2",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 19,
+                },
+                .la = {
+                        .reg = 0x33c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x0c,
+                },
+        }, {
+                .id = 0x14,
+                .name = "g2dr",
+                .swgroup = TEGRA_SWGROUP_G2,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 20,
+                },
+                .la = {
+                        .reg = 0x30c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x0a,
+                },
+        }, {
+                .id = 0x15,
+                .name = "hdar",
+                .swgroup = TEGRA_SWGROUP_HDA,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 21,
+                },
+                .la = {
+                        .reg = 0x318,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x16,
+                .name = "host1xdmar",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 22,
+                },
+                .la = {
+                        .reg = 0x310,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x17,
+                .name = "host1xr",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 23,
+                },
+                .la = {
+                        .reg = 0x310,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xa5,
+                },
+        }, {
+                .id = 0x18,
+                .name = "idxsrd",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 24,
+                },
+                .la = {
+                        .reg = 0x334,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0b,
+                },
+        }, {
+                .id = 0x1c,
+                .name = "msencsrd",
+                .swgroup = TEGRA_SWGROUP_MSENC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 28,
+                },
+                .la = {
+                        .reg = 0x328,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x1d,
+                .name = "ppcsahbdmar",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 29,
+                },
+                .la = {
+                        .reg = 0x344,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x1e,
+                .name = "ppcsahbslvr",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 30,
+                },
+                .la = {
+                        .reg = 0x344,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xe8,
+                },
+        }, {
+                .id = 0x20,
+                .name = "texl2srd",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 0,
+                },
+                .la = {
+                        .reg = 0x338,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x0c,
+                },
+        }, {
+                .id = 0x22,
+                .name = "vdebsevr",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 2,
+                },
+                .la = {
+                        .reg = 0x354,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x23,
+                .name = "vdember",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 3,
+                },
+                .la = {
+                        .reg = 0x354,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x24,
+                .name = "vdemcer",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 4,
+                },
+                .la = {
+                        .reg = 0x358,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xb8,
+                },
+        }, {
+                .id = 0x25,
+                .name = "vdetper",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 5,
+                },
+                .la = {
+                        .reg = 0x358,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xee,
+                },
+        }, {
+                .id = 0x26,
+                .name = "mpcorelpr",
+                .swgroup = TEGRA_SWGROUP_MPCORELP,
+                .la = {
+                        .reg = 0x324,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x27,
+                .name = "mpcorer",
+                .swgroup = TEGRA_SWGROUP_MPCORE,
+                .la = {
+                        .reg = 0x320,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x28,
+                .name = "eppu",
+                .swgroup = TEGRA_SWGROUP_EPP,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 8,
+                },
+                .la = {
+                        .reg = 0x300,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x33,
+                },
+        }, {
+                .id = 0x29,
+                .name = "eppv",
+                .swgroup = TEGRA_SWGROUP_EPP,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 9,
+                },
+                .la = {
+                        .reg = 0x304,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x6c,
+                },
+        }, {
+                .id = 0x2a,
+                .name = "eppy",
+                .swgroup = TEGRA_SWGROUP_EPP,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 10,
+                },
+                .la = {
+                        .reg = 0x304,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x6c,
+                },
+        }, {
+                .id = 0x2b,
+                .name = "msencswr",
+                .swgroup = TEGRA_SWGROUP_MSENC,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 11,
+                },
+                .la = {
+                        .reg = 0x328,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x2c,
+                .name = "viwsb",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 12,
+                },
+                .la = {
+                        .reg = 0x364,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x47,
+                },
+        }, {
+                .id = 0x2d,
+                .name = "viwu",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 13,
+                },
+                .la = {
+                        .reg = 0x368,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x2e,
+                .name = "viwv",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 14,
+                },
+                .la = {
+                        .reg = 0x368,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x2f,
+                .name = "viwy",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 15,
+                },
+                .la = {
+                        .reg = 0x36c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x47,
+                },
+        }, {
+                .id = 0x30,
+                .name = "g2dw",
+                .swgroup = TEGRA_SWGROUP_G2,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 16,
+                },
+                .la = {
+                        .reg = 0x30c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x9,
+                },
+        }, {
+                .id = 0x32,
+                .name = "avpcarm7w",
+                .swgroup = TEGRA_SWGROUP_AVPC,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 18,
+                },
+                .la = {
+                        .reg = 0x2e4,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0e,
+                },
+        }, {
+                .id = 0x33,
+                .name = "fdcdwr",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 19,
+                },
+                .la = {
+                        .reg = 0x338,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x34,
+                .name = "fdcwr2",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 20,
+                },
+                .la = {
+                        .reg = 0x340,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x35,
+                .name = "hdaw",
+                .swgroup = TEGRA_SWGROUP_HDA,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 21,
+                },
+                .la = {
+                        .reg = 0x318,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x36,
+                .name = "host1xw",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 22,
+                },
+                .la = {
+                        .reg = 0x314,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x25,
+                },
+        }, {
+                .id = 0x37,
+                .name = "ispw",
+                .swgroup = TEGRA_SWGROUP_ISP,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 23,
+                },
+                .la = {
+                        .reg = 0x31c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x38,
+                .name = "mpcorelpw",
+                .swgroup = TEGRA_SWGROUP_MPCORELP,
+                .la = {
+                        .reg = 0x324,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x39,
+                .name = "mpcorew",
+                .swgroup = TEGRA_SWGROUP_MPCORE,
+                .la = {
+                        .reg = 0x320,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0e,
+                },
+        }, {
+                .id = 0x3b,
+                .name = "ppcsahbdmaw",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 27,
+                },
+                .la = {
+                        .reg = 0x348,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xa5,
+                },
+        }, {
+                .id = 0x3c,
+                .name = "ppcsahbslvw",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 28,
+                },
+                .la = {
+                        .reg = 0x348,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xe8,
+                },
+        }, {
+                .id = 0x3e,
+                .name = "vdebsevw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 30,
+                },
+                .la = {
+                        .reg = 0x35c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x3f,
+                .name = "vdedbgw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 31,
+                },
+                .la = {
+                        .reg = 0x35c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x40,
+                .name = "vdembew",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 0,
+                },
+                .la = {
+                        .reg = 0x360,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x89,
+                },
+        }, {
+                .id = 0x41,
+                .name = "vdetpmw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 1,
+                },
+                .la = {
+                        .reg = 0x360,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x59,
+                },
+        }, {
+                .id = 0x4a,
+                .name = "xusb_hostr",
+                .swgroup = TEGRA_SWGROUP_XUSB_HOST,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 10,
+                },
+                .la = {
+                        .reg = 0x37c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xa5,
+                },
+        }, {
+                .id = 0x4b,
+                .name = "xusb_hostw",
+                .swgroup = TEGRA_SWGROUP_XUSB_HOST,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 11,
+                },
+                .la = {
+                        .reg = 0x37c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xa5,
+                },
+        }, {
+                .id = 0x4c,
+                .name = "xusb_devr",
+                .swgroup = TEGRA_SWGROUP_XUSB_DEV,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 12,
+                },
+                .la = {
+                        .reg = 0x380,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xa5,
+                },
+        }, {
+                .id = 0x4d,
+                .name = "xusb_devw",
+                .swgroup = TEGRA_SWGROUP_XUSB_DEV,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 13,
+                },
+                .la = {
+                        .reg = 0x380,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xa5,
+                },
+        }, {
+                .id = 0x4e,
+                .name = "fdcdwr3",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 14,
+                },
+                .la = {
+                        .reg = 0x388,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x4f,
+                .name = "fdcdrd3",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 15,
+                },
+                .la = {
+                        .reg = 0x384,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x0c,
+                },
+        }, {
+                .id = 0x50,
+                .name = "fdcwr4",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 16,
+                },
+                .la = {
+                        .reg = 0x388,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x51,
+                .name = "fdcrd4",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 17,
+                },
+                .la = {
+                        .reg = 0x384,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0c,
+                },
+        }, {
+                .id = 0x52,
+                .name = "emucifr",
+                .swgroup = TEGRA_SWGROUP_EMUCIF,
+                .la = {
+                        .reg = 0x38c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x53,
+                .name = "emucifw",
+                .swgroup = TEGRA_SWGROUP_EMUCIF,
+                .la = {
+                        .reg = 0x38c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0e,
+                },
+        }, {
+                .id = 0x54,
+                .name = "tsecsrd",
+                .swgroup = TEGRA_SWGROUP_TSEC,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 20,
+                },
+                .la = {
+                        .reg = 0x390,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x55,
+                .name = "tsecswr",
+                .swgroup = TEGRA_SWGROUP_TSEC,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 21,
+                },
+                .la = {
+                        .reg = 0x390,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        },
+};
+
+static const struct tegra_smmu_swgroup tegra114_swgroups[] = {
+        { .swgroup = TEGRA_SWGROUP_DC,        .reg = 0x240 },
+        { .swgroup = TEGRA_SWGROUP_DCB,       .reg = 0x244 },
+        { .swgroup = TEGRA_SWGROUP_EPP,       .reg = 0x248 },
+        { .swgroup = TEGRA_SWGROUP_G2,        .reg = 0x24c },
+        { .swgroup = TEGRA_SWGROUP_AVPC,      .reg = 0x23c },
+        { .swgroup = TEGRA_SWGROUP_NV,        .reg = 0x268 },
+        { .swgroup = TEGRA_SWGROUP_HDA,       .reg = 0x254 },
+        { .swgroup = TEGRA_SWGROUP_HC,        .reg = 0x250 },
+        { .swgroup = TEGRA_SWGROUP_MSENC,     .reg = 0x264 },
+        { .swgroup = TEGRA_SWGROUP_PPCS,      .reg = 0x270 },
+        { .swgroup = TEGRA_SWGROUP_VDE,       .reg = 0x27c },
+        { .swgroup = TEGRA_SWGROUP_VI,        .reg = 0x280 },
+        { .swgroup = TEGRA_SWGROUP_ISP,       .reg = 0x258 },
+        { .swgroup = TEGRA_SWGROUP_XUSB_HOST, .reg = 0x288 },
+        { .swgroup = TEGRA_SWGROUP_XUSB_DEV,  .reg = 0x28c },
+        { .swgroup = TEGRA_SWGROUP_TSEC,      .reg = 0x294 },
+};
+
+static void tegra114_flush_dcache(struct page *page, unsigned long offset,
+                                  size_t size)
+{
+        phys_addr_t phys = page_to_phys(page) + offset;
+        void *virt = page_address(page) + offset;
+
+        __cpuc_flush_dcache_area(virt, size);
+        outer_flush_range(phys, phys + size);
+}
+
+static const struct tegra_smmu_ops tegra114_smmu_ops = {
+        .flush_dcache = tegra114_flush_dcache,
+};
+
+static const struct tegra_smmu_soc tegra114_smmu_soc = {
+        .clients = tegra114_mc_clients,
+        .num_clients = ARRAY_SIZE(tegra114_mc_clients),
+        .swgroups = tegra114_swgroups,
+        .num_swgroups = ARRAY_SIZE(tegra114_swgroups),
+        .supports_round_robin_arbitration = false,
+        .supports_request_limit = false,
+        .num_asids = 4,
+        .ops = &tegra114_smmu_ops,
+};
+
+const struct tegra_mc_soc tegra114_mc_soc = {
+        .clients = tegra114_mc_clients,
+        .num_clients = ARRAY_SIZE(tegra114_mc_clients),
+        .num_address_bits = 32,
+        .atom_size = 32,
+        .smmu = &tegra114_smmu_soc,
+};
diff --git a/drivers/memory/tegra/tegra124.c b/drivers/memory/tegra/tegra124.c
new file mode 100644
index 000000000000..278d40b854c1
--- /dev/null
+++ b/drivers/memory/tegra/tegra124.c
@@ -0,0 +1,995 @@
+/*
+ * Copyright (C) 2014 NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/of.h>
+#include <linux/mm.h>
+
+#include <asm/cacheflush.h>
+
+#include <dt-bindings/memory/tegra124-mc.h>
+
+#include "mc.h"
+
+static const struct tegra_mc_client tegra124_mc_clients[] = {
+        {
+                .id = 0x00,
+                .name = "ptcr",
+                .swgroup = TEGRA_SWGROUP_PTC,
+        }, {
+                .id = 0x01,
+                .name = "display0a",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 1,
+                },
+                .la = {
+                        .reg = 0x2e8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xc2,
+                },
+        }, {
+                .id = 0x02,
+                .name = "display0ab",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 2,
+                },
+                .la = {
+                        .reg = 0x2f4,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xc6,
+                },
+        }, {
+                .id = 0x03,
+                .name = "display0b",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 3,
+                },
+                .la = {
+                        .reg = 0x2e8,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x04,
+                .name = "display0bb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 4,
+                },
+                .la = {
+                        .reg = 0x2f4,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x05,
+                .name = "display0c",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 5,
+                },
+                .la = {
+                        .reg = 0x2ec,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x06,
+                .name = "display0cb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 6,
+                },
+                .la = {
+                        .reg = 0x2f8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x0e,
+                .name = "afir",
+                .swgroup = TEGRA_SWGROUP_AFI,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 14,
+                },
+                .la = {
+                        .reg = 0x2e0,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x13,
+                },
+        }, {
+                .id = 0x0f,
+                .name = "avpcarm7r",
+                .swgroup = TEGRA_SWGROUP_AVPC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 15,
+                },
+                .la = {
+                        .reg = 0x2e4,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x10,
+                .name = "displayhc",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 16,
+                },
+                .la = {
+                        .reg = 0x2f0,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x11,
+                .name = "displayhcb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 17,
+                },
+                .la = {
+                        .reg = 0x2fc,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x15,
+                .name = "hdar",
+                .swgroup = TEGRA_SWGROUP_HDA,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 21,
+                },
+                .la = {
+                        .reg = 0x318,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x24,
+                },
+        }, {
+                .id = 0x16,
+                .name = "host1xdmar",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 22,
+                },
+                .la = {
+                        .reg = 0x310,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x1e,
+                },
+        }, {
+                .id = 0x17,
+                .name = "host1xr",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 23,
+                },
+                .la = {
+                        .reg = 0x310,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x1c,
+                .name = "msencsrd",
+                .swgroup = TEGRA_SWGROUP_MSENC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 28,
+                },
+                .la = {
+                        .reg = 0x328,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x23,
+                },
+        }, {
+                .id = 0x1d,
+                .name = "ppcsahbdmar",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 29,
+                },
+                .la = {
+                        .reg = 0x344,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x49,
+                },
+        }, {
+                .id = 0x1e,
+                .name = "ppcsahbslvr",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 30,
+                },
+                .la = {
+                        .reg = 0x344,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x1a,
+                },
+        }, {
+                .id = 0x1f,
+                .name = "satar",
+                .swgroup = TEGRA_SWGROUP_SATA,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 31,
+                },
+                .la = {
+                        .reg = 0x350,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x65,
+                },
+        }, {
+                .id = 0x22,
+                .name = "vdebsevr",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 2,
+                },
+                .la = {
+                        .reg = 0x354,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4f,
+                },
+        }, {
+                .id = 0x23,
+                .name = "vdember",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 3,
+                },
+                .la = {
+                        .reg = 0x354,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x3d,
+                },
+        }, {
+                .id = 0x24,
+                .name = "vdemcer",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 4,
+                },
+                .la = {
+                        .reg = 0x358,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x66,
+                },
+        }, {
+                .id = 0x25,
+                .name = "vdetper",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 5,
+                },
+                .la = {
+                        .reg = 0x358,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xa5,
+                },
+        }, {
+                .id = 0x26,
+                .name = "mpcorelpr",
+                .swgroup = TEGRA_SWGROUP_MPCORELP,
+                .la = {
+                        .reg = 0x324,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x27,
+                .name = "mpcorer",
+                .swgroup = TEGRA_SWGROUP_MPCORE,
+                .la = {
+                        .reg = 0x320,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x2b,
+                .name = "msencswr",
+                .swgroup = TEGRA_SWGROUP_MSENC,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 11,
+                },
+                .la = {
+                        .reg = 0x328,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x31,
+                .name = "afiw",
+                .swgroup = TEGRA_SWGROUP_AFI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 17,
+                },
+                .la = {
+                        .reg = 0x2e0,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x32,
+                .name = "avpcarm7w",
+                .swgroup = TEGRA_SWGROUP_AVPC,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 18,
+                },
+                .la = {
+                        .reg = 0x2e4,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x35,
+                .name = "hdaw",
+                .swgroup = TEGRA_SWGROUP_HDA,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 21,
+                },
+                .la = {
+                        .reg = 0x318,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x36,
+                .name = "host1xw",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 22,
+                },
+                .la = {
+                        .reg = 0x314,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x38,
+                .name = "mpcorelpw",
+                .swgroup = TEGRA_SWGROUP_MPCORELP,
+                .la = {
+                        .reg = 0x324,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x39,
+                .name = "mpcorew",
+                .swgroup = TEGRA_SWGROUP_MPCORE,
+                .la = {
+                        .reg = 0x320,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x3b,
+                .name = "ppcsahbdmaw",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 27,
+                },
+                .la = {
+                        .reg = 0x348,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x3c,
+                .name = "ppcsahbslvw",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 28,
+                },
+                .la = {
+                        .reg = 0x348,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x3d,
+                .name = "sataw",
+                .swgroup = TEGRA_SWGROUP_SATA,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 29,
+                },
+                .la = {
+                        .reg = 0x350,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x65,
+                },
+        }, {
+                .id = 0x3e,
+                .name = "vdebsevw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 30,
+                },
+                .la = {
+                        .reg = 0x35c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x3f,
+                .name = "vdedbgw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 31,
+                },
+                .la = {
+                        .reg = 0x35c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x40,
+                .name = "vdembew",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 0,
+                },
+                .la = {
+                        .reg = 0x360,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x41,
+                .name = "vdetpmw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 1,
+                },
+                .la = {
+                        .reg = 0x360,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x44,
+                .name = "ispra",
+                .swgroup = TEGRA_SWGROUP_ISP2,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 4,
+                },
+                .la = {
+                        .reg = 0x370,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x18,
+                },
+        }, {
+                .id = 0x46,
+                .name = "ispwa",
+                .swgroup = TEGRA_SWGROUP_ISP2,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 6,
+                },
+                .la = {
+                        .reg = 0x374,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x47,
+                .name = "ispwb",
+                .swgroup = TEGRA_SWGROUP_ISP2,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 7,
+                },
+                .la = {
+                        .reg = 0x374,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x4a,
+                .name = "xusb_hostr",
+                .swgroup = TEGRA_SWGROUP_XUSB_HOST,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 10,
+                },
+                .la = {
+                        .reg = 0x37c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x39,
+                },
+        }, {
+                .id = 0x4b,
+                .name = "xusb_hostw",
+                .swgroup = TEGRA_SWGROUP_XUSB_HOST,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 11,
+                },
+                .la = {
+                        .reg = 0x37c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x4c,
+                .name = "xusb_devr",
+                .swgroup = TEGRA_SWGROUP_XUSB_DEV,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 12,
+                },
+                .la = {
+                        .reg = 0x380,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x39,
+                },
+        }, {
+                .id = 0x4d,
+                .name = "xusb_devw",
+                .swgroup = TEGRA_SWGROUP_XUSB_DEV,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 13,
+                },
+                .la = {
+                        .reg = 0x380,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x4e,
+                .name = "isprab",
+                .swgroup = TEGRA_SWGROUP_ISP2B,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 14,
+                },
+                .la = {
+                        .reg = 0x384,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x18,
+                },
+        }, {
+                .id = 0x50,
+                .name = "ispwab",
+                .swgroup = TEGRA_SWGROUP_ISP2B,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 16,
+                },
+                .la = {
+                        .reg = 0x388,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x51,
+                .name = "ispwbb",
+                .swgroup = TEGRA_SWGROUP_ISP2B,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 17,
+                },
+                .la = {
+                        .reg = 0x388,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x54,
+                .name = "tsecsrd",
+                .swgroup = TEGRA_SWGROUP_TSEC,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 20,
+                },
+                .la = {
+                        .reg = 0x390,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x9b,
+                },
+        }, {
+                .id = 0x55,
+                .name = "tsecswr",
+                .swgroup = TEGRA_SWGROUP_TSEC,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 21,
+                },
+                .la = {
+                        .reg = 0x390,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x56,
+                .name = "a9avpscr",
+                .swgroup = TEGRA_SWGROUP_A9AVP,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 22,
+                },
+                .la = {
+                        .reg = 0x3a4,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x57,
+                .name = "a9avpscw",
+                .swgroup = TEGRA_SWGROUP_A9AVP,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 23,
+                },
+                .la = {
+                        .reg = 0x3a4,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x58,
+                .name = "gpusrd",
+                .swgroup = TEGRA_SWGROUP_GPU,
+                .smmu = {
+                        /* read-only */
+                        .reg = 0x230,
+                        .bit = 24,
+                },
+                .la = {
+                        .reg = 0x3c8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x1a,
+                },
+        }, {
+                .id = 0x59,
+                .name = "gpuswr",
+                .swgroup = TEGRA_SWGROUP_GPU,
+                .smmu = {
+                        /* read-only */
+                        .reg = 0x230,
+                        .bit = 25,
+                },
+                .la = {
+                        .reg = 0x3c8,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x5a,
+                .name = "displayt",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 26,
+                },
+                .la = {
+                        .reg = 0x2f0,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x60,
+                .name = "sdmmcra",
+                .swgroup = TEGRA_SWGROUP_SDMMC1A,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 0,
+                },
+                .la = {
+                        .reg = 0x3b8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x49,
+                },
+        }, {
+                .id = 0x61,
+                .name = "sdmmcraa",
+                .swgroup = TEGRA_SWGROUP_SDMMC2A,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 1,
+                },
+                .la = {
+                        .reg = 0x3bc,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x49,
+                },
+        }, {
+                .id = 0x62,
+                .name = "sdmmcr",
+                .swgroup = TEGRA_SWGROUP_SDMMC3A,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 2,
+                },
+                .la = {
+                        .reg = 0x3c0,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x49,
+                },
+        }, {
+                .id = 0x63,
+                .swgroup = TEGRA_SWGROUP_SDMMC4A,
+                .name = "sdmmcrab",
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 3,
+                },
+                .la = {
+                        .reg = 0x3c4,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x49,
+                },
+        }, {
+                .id = 0x64,
+                .name = "sdmmcwa",
+                .swgroup = TEGRA_SWGROUP_SDMMC1A,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 4,
+                },
+                .la = {
+                        .reg = 0x3b8,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x65,
+                .name = "sdmmcwaa",
+                .swgroup = TEGRA_SWGROUP_SDMMC2A,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 5,
+                },
+                .la = {
+                        .reg = 0x3bc,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x66,
+                .name = "sdmmcw",
+                .swgroup = TEGRA_SWGROUP_SDMMC3A,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 6,
+                },
+                .la = {
+                        .reg = 0x3c0,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x67,
+                .name = "sdmmcwab",
+                .swgroup = TEGRA_SWGROUP_SDMMC4A,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 7,
+                },
+                .la = {
+                        .reg = 0x3c4,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x6c,
+                .name = "vicsrd",
+                .swgroup = TEGRA_SWGROUP_VIC,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 12,
+                },
+                .la = {
+                        .reg = 0x394,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x1a,
+                },
+        }, {
+                .id = 0x6d,
+                .name = "vicswr",
+                .swgroup = TEGRA_SWGROUP_VIC,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 13,
+                },
+                .la = {
+                        .reg = 0x394,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x72,
+                .name = "viw",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 18,
+                },
+                .la = {
+                        .reg = 0x398,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x73,
+                .name = "displayd",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x234,
+                        .bit = 19,
+                },
+                .la = {
+                        .reg = 0x3c8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        },
+};
+
+static const struct tegra_smmu_swgroup tegra124_swgroups[] = {
+        { .swgroup = TEGRA_SWGROUP_DC,        .reg = 0x240 },
+        { .swgroup = TEGRA_SWGROUP_DCB,       .reg = 0x244 },
+        { .swgroup = TEGRA_SWGROUP_AFI,       .reg = 0x238 },
+        { .swgroup = TEGRA_SWGROUP_AVPC,      .reg = 0x23c },
+        { .swgroup = TEGRA_SWGROUP_HDA,       .reg = 0x254 },
+        { .swgroup = TEGRA_SWGROUP_HC,        .reg = 0x250 },
+        { .swgroup = TEGRA_SWGROUP_MSENC,     .reg = 0x264 },
+        { .swgroup = TEGRA_SWGROUP_PPCS,      .reg = 0x270 },
+        { .swgroup = TEGRA_SWGROUP_SATA,      .reg = 0x274 },
+        { .swgroup = TEGRA_SWGROUP_VDE,       .reg = 0x27c },
+        { .swgroup = TEGRA_SWGROUP_ISP2,      .reg = 0x258 },
+        { .swgroup = TEGRA_SWGROUP_XUSB_HOST, .reg = 0x288 },
+        { .swgroup = TEGRA_SWGROUP_XUSB_DEV,  .reg = 0x28c },
+        { .swgroup = TEGRA_SWGROUP_ISP2B,     .reg = 0xaa4 },
+        { .swgroup = TEGRA_SWGROUP_TSEC,      .reg = 0x294 },
+        { .swgroup = TEGRA_SWGROUP_A9AVP,     .reg = 0x290 },
+        { .swgroup = TEGRA_SWGROUP_GPU,       .reg = 0xaac },
+        { .swgroup = TEGRA_SWGROUP_SDMMC1A,   .reg = 0xa94 },
+        { .swgroup = TEGRA_SWGROUP_SDMMC2A,   .reg = 0xa98 },
+        { .swgroup = TEGRA_SWGROUP_SDMMC3A,   .reg = 0xa9c },
+        { .swgroup = TEGRA_SWGROUP_SDMMC4A,   .reg = 0xaa0 },
+        { .swgroup = TEGRA_SWGROUP_VIC,       .reg = 0x284 },
+        { .swgroup = TEGRA_SWGROUP_VI,        .reg = 0x280 },
+};
+
+#ifdef CONFIG_ARCH_TEGRA_124_SOC
+static void tegra124_flush_dcache(struct page *page, unsigned long offset,
+                                  size_t size)
+{
+        phys_addr_t phys = page_to_phys(page) + offset;
+        void *virt = page_address(page) + offset;
+
+        __cpuc_flush_dcache_area(virt, size);
+        outer_flush_range(phys, phys + size);
+}
+
+static const struct tegra_smmu_ops tegra124_smmu_ops = {
+        .flush_dcache = tegra124_flush_dcache,
+};
+
+static const struct tegra_smmu_soc tegra124_smmu_soc = {
+        .clients = tegra124_mc_clients,
+        .num_clients = ARRAY_SIZE(tegra124_mc_clients),
+        .swgroups = tegra124_swgroups,
+        .num_swgroups = ARRAY_SIZE(tegra124_swgroups),
+        .supports_round_robin_arbitration = true,
+        .supports_request_limit = true,
+        .num_asids = 128,
+        .ops = &tegra124_smmu_ops,
+};
+
+const struct tegra_mc_soc tegra124_mc_soc = {
+        .clients = tegra124_mc_clients,
+        .num_clients = ARRAY_SIZE(tegra124_mc_clients),
+        .num_address_bits = 34,
+        .atom_size = 32,
+        .smmu = &tegra124_smmu_soc,
+};
+#endif /* CONFIG_ARCH_TEGRA_124_SOC */
diff --git a/drivers/memory/tegra/tegra30.c b/drivers/memory/tegra/tegra30.c
new file mode 100644
index 000000000000..71fe9376fe53
--- /dev/null
+++ b/drivers/memory/tegra/tegra30.c
@@ -0,0 +1,970 @@
+/*
+ * Copyright (C) 2014 NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/of.h>
+#include <linux/mm.h>
+
+#include <asm/cacheflush.h>
+
+#include <dt-bindings/memory/tegra30-mc.h>
+
+#include "mc.h"
+
+static const struct tegra_mc_client tegra30_mc_clients[] = {
+        {
+                .id = 0x00,
+                .name = "ptcr",
+                .swgroup = TEGRA_SWGROUP_PTC,
+        }, {
+                .id = 0x01,
+                .name = "display0a",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 1,
+                },
+                .la = {
+                        .reg = 0x2e8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x02,
+                .name = "display0ab",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 2,
+                },
+                .la = {
+                        .reg = 0x2f4,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x03,
+                .name = "display0b",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 3,
+                },
+                .la = {
+                        .reg = 0x2e8,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x04,
+                .name = "display0bb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 4,
+                },
+                .la = {
+                        .reg = 0x2f4,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x05,
+                .name = "display0c",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 5,
+                },
+                .la = {
+                        .reg = 0x2ec,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x06,
+                .name = "display0cb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 6,
+                },
+                .la = {
+                        .reg = 0x2f8,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x07,
+                .name = "display1b",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 7,
+                },
+                .la = {
+                        .reg = 0x2ec,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x08,
+                .name = "display1bb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 8,
+                },
+                .la = {
+                        .reg = 0x2f8,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x4e,
+                },
+        }, {
+                .id = 0x09,
+                .name = "eppup",
+                .swgroup = TEGRA_SWGROUP_EPP,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 9,
+                },
+                .la = {
+                        .reg = 0x300,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x17,
+                },
+        }, {
+                .id = 0x0a,
+                .name = "g2pr",
+                .swgroup = TEGRA_SWGROUP_G2,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 10,
+                },
+                .la = {
+                        .reg = 0x308,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x09,
+                },
+        }, {
+                .id = 0x0b,
+                .name = "g2sr",
+                .swgroup = TEGRA_SWGROUP_G2,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 11,
+                },
+                .la = {
+                        .reg = 0x308,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x09,
+                },
+        }, {
+                .id = 0x0c,
+                .name = "mpeunifbr",
+                .swgroup = TEGRA_SWGROUP_MPE,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 12,
+                },
+                .la = {
+                        .reg = 0x328,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x0d,
+                .name = "viruv",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 13,
+                },
+                .la = {
+                        .reg = 0x364,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x2c,
+                },
+        }, {
+                .id = 0x0e,
+                .name = "afir",
+                .swgroup = TEGRA_SWGROUP_AFI,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 14,
+                },
+                .la = {
+                        .reg = 0x2e0,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x0f,
+                .name = "avpcarm7r",
+                .swgroup = TEGRA_SWGROUP_AVPC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 15,
+                },
+                .la = {
+                        .reg = 0x2e4,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x10,
+                .name = "displayhc",
+                .swgroup = TEGRA_SWGROUP_DC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 16,
+                },
+                .la = {
+                        .reg = 0x2f0,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x11,
+                .name = "displayhcb",
+                .swgroup = TEGRA_SWGROUP_DCB,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 17,
+                },
+                .la = {
+                        .reg = 0x2fc,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x12,
+                .name = "fdcdrd",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 18,
+                },
+                .la = {
+                        .reg = 0x334,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x0a,
+                },
+        }, {
+                .id = 0x13,
+                .name = "fdcdrd2",
+                .swgroup = TEGRA_SWGROUP_NV2,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 19,
+                },
+                .la = {
+                        .reg = 0x33c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x0a,
+                },
+        }, {
+                .id = 0x14,
+                .name = "g2dr",
+                .swgroup = TEGRA_SWGROUP_G2,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 20,
+                },
+                .la = {
+                        .reg = 0x30c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x0a,
+                },
+        }, {
+                .id = 0x15,
+                .name = "hdar",
+                .swgroup = TEGRA_SWGROUP_HDA,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 21,
+                },
+                .la = {
+                        .reg = 0x318,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x16,
+                .name = "host1xdmar",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 22,
+                },
+                .la = {
+                        .reg = 0x310,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x05,
+                },
+        }, {
+                .id = 0x17,
+                .name = "host1xr",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 23,
+                },
+                .la = {
+                        .reg = 0x310,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x50,
+                },
+        }, {
+                .id = 0x18,
+                .name = "idxsrd",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 24,
+                },
+                .la = {
+                        .reg = 0x334,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x13,
+                },
+        }, {
+                .id = 0x19,
+                .name = "idxsrd2",
+                .swgroup = TEGRA_SWGROUP_NV2,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 25,
+                },
+                .la = {
+                        .reg = 0x33c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x13,
+                },
+        }, {
+                .id = 0x1a,
+                .name = "mpe_ipred",
+                .swgroup = TEGRA_SWGROUP_MPE,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 26,
+                },
+                .la = {
+                        .reg = 0x328,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x80,
+                },
+        }, {
+                .id = 0x1b,
+                .name = "mpeamemrd",
+                .swgroup = TEGRA_SWGROUP_MPE,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 27,
+                },
+                .la = {
+                        .reg = 0x32c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x42,
+                },
+        }, {
+                .id = 0x1c,
+                .name = "mpecsrd",
+                .swgroup = TEGRA_SWGROUP_MPE,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 28,
+                },
+                .la = {
+                        .reg = 0x32c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x1d,
+                .name = "ppcsahbdmar",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 29,
+                },
+                .la = {
+                        .reg = 0x344,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x1e,
+                .name = "ppcsahbslvr",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 30,
+                },
+                .la = {
+                        .reg = 0x344,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x12,
+                },
+        }, {
+                .id = 0x1f,
+                .name = "satar",
+                .swgroup = TEGRA_SWGROUP_SATA,
+                .smmu = {
+                        .reg = 0x228,
+                        .bit = 31,
+                },
+                .la = {
+                        .reg = 0x350,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x33,
+                },
+        }, {
+                .id = 0x20,
+                .name = "texsrd",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 0,
+                },
+                .la = {
+                        .reg = 0x338,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x13,
+                },
+        }, {
+                .id = 0x21,
+                .name = "texsrd2",
+                .swgroup = TEGRA_SWGROUP_NV2,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 1,
+                },
+                .la = {
+                        .reg = 0x340,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x13,
+                },
+        }, {
+                .id = 0x22,
+                .name = "vdebsevr",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 2,
+                },
+                .la = {
+                        .reg = 0x354,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x23,
+                .name = "vdember",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 3,
+                },
+                .la = {
+                        .reg = 0x354,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xd0,
+                },
+        }, {
+                .id = 0x24,
+                .name = "vdemcer",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 4,
+                },
+                .la = {
+                        .reg = 0x358,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x2a,
+                },
+        }, {
+                .id = 0x25,
+                .name = "vdetper",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 5,
+                },
+                .la = {
+                        .reg = 0x358,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x74,
+                },
+        }, {
+                .id = 0x26,
+                .name = "mpcorelpr",
+                .swgroup = TEGRA_SWGROUP_MPCORELP,
+                .la = {
+                        .reg = 0x324,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x27,
+                .name = "mpcorer",
+                .swgroup = TEGRA_SWGROUP_MPCORE,
+                .la = {
+                        .reg = 0x320,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x04,
+                },
+        }, {
+                .id = 0x28,
+                .name = "eppu",
+                .swgroup = TEGRA_SWGROUP_EPP,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 8,
+                },
+                .la = {
+                        .reg = 0x300,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x6c,
+                },
+        }, {
+                .id = 0x29,
+                .name = "eppv",
+                .swgroup = TEGRA_SWGROUP_EPP,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 9,
+                },
+                .la = {
+                        .reg = 0x304,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x6c,
+                },
+        }, {
+                .id = 0x2a,
+                .name = "eppy",
+                .swgroup = TEGRA_SWGROUP_EPP,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 10,
+                },
+                .la = {
+                        .reg = 0x304,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x6c,
+                },
+        }, {
+                .id = 0x2b,
+                .name = "mpeunifbw",
+                .swgroup = TEGRA_SWGROUP_MPE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 11,
+                },
+                .la = {
+                        .reg = 0x330,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x13,
+                },
+        }, {
+                .id = 0x2c,
+                .name = "viwsb",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 12,
+                },
+                .la = {
+                        .reg = 0x364,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x12,
+                },
+        }, {
+                .id = 0x2d,
+                .name = "viwu",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 13,
+                },
+                .la = {
+                        .reg = 0x368,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xb2,
+                },
+        }, {
+                .id = 0x2e,
+                .name = "viwv",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 14,
+                },
+                .la = {
+                        .reg = 0x368,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xb2,
+                },
+        }, {
+                .id = 0x2f,
+                .name = "viwy",
+                .swgroup = TEGRA_SWGROUP_VI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 15,
+                },
+                .la = {
+                        .reg = 0x36c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x12,
+                },
+        }, {
+                .id = 0x30,
+                .name = "g2dw",
+                .swgroup = TEGRA_SWGROUP_G2,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 16,
+                },
+                .la = {
+                        .reg = 0x30c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x9,
+                },
+        }, {
+                .id = 0x31,
+                .name = "afiw",
+                .swgroup = TEGRA_SWGROUP_AFI,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 17,
+                },
+                .la = {
+                        .reg = 0x2e0,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0c,
+                },
+        }, {
+                .id = 0x32,
+                .name = "avpcarm7w",
+                .swgroup = TEGRA_SWGROUP_AVPC,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 18,
+                },
+                .la = {
+                        .reg = 0x2e4,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0e,
+                },
+        }, {
+                .id = 0x33,
+                .name = "fdcdwr",
+                .swgroup = TEGRA_SWGROUP_NV,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 19,
+                },
+                .la = {
+                        .reg = 0x338,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0a,
+                },
+        }, {
+                .id = 0x34,
+                .name = "fdcwr2",
+                .swgroup = TEGRA_SWGROUP_NV2,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 20,
+                },
+                .la = {
+                        .reg = 0x340,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0a,
+                },
+        }, {
+                .id = 0x35,
+                .name = "hdaw",
+                .swgroup = TEGRA_SWGROUP_HDA,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 21,
+                },
+                .la = {
+                        .reg = 0x318,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x36,
+                .name = "host1xw",
+                .swgroup = TEGRA_SWGROUP_HC,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 22,
+                },
+                .la = {
+                        .reg = 0x314,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x37,
+                .name = "ispw",
+                .swgroup = TEGRA_SWGROUP_ISP,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 23,
+                },
+                .la = {
+                        .reg = 0x31c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x38,
+                .name = "mpcorelpw",
+                .swgroup = TEGRA_SWGROUP_MPCORELP,
+                .la = {
+                        .reg = 0x324,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0e,
+                },
+        }, {
+                .id = 0x39,
+                .name = "mpcorew",
+                .swgroup = TEGRA_SWGROUP_MPCORE,
+                .la = {
+                        .reg = 0x320,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x0e,
+                },
+        }, {
+                .id = 0x3a,
+                .name = "mpecswr",
+                .swgroup = TEGRA_SWGROUP_MPE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 26,
+                },
+                .la = {
+                        .reg = 0x330,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x3b,
+                .name = "ppcsahbdmaw",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 27,
+                },
+                .la = {
+                        .reg = 0x348,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x10,
+                },
+        }, {
+                .id = 0x3c,
+                .name = "ppcsahbslvw",
+                .swgroup = TEGRA_SWGROUP_PPCS,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 28,
+                },
+                .la = {
+                        .reg = 0x348,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x06,
+                },
+        }, {
+                .id = 0x3d,
+                .name = "sataw",
+                .swgroup = TEGRA_SWGROUP_SATA,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 29,
+                },
+                .la = {
+                        .reg = 0x350,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x33,
+                },
+        }, {
+                .id = 0x3e,
+                .name = "vdebsevw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 30,
+                },
+                .la = {
+                        .reg = 0x35c,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x3f,
+                .name = "vdedbgw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x22c,
+                        .bit = 31,
+                },
+                .la = {
+                        .reg = 0x35c,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0xff,
+                },
+        }, {
+                .id = 0x40,
+                .name = "vdembew",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 0,
+                },
+                .la = {
+                        .reg = 0x360,
+                        .shift = 0,
+                        .mask = 0xff,
+                        .def = 0x42,
+                },
+        }, {
+                .id = 0x41,
+                .name = "vdetpmw",
+                .swgroup = TEGRA_SWGROUP_VDE,
+                .smmu = {
+                        .reg = 0x230,
+                        .bit = 1,
+                },
+                .la = {
+                        .reg = 0x360,
+                        .shift = 16,
+                        .mask = 0xff,
+                        .def = 0x2a,
+                },
+        },
+};
+
+static const struct tegra_smmu_swgroup tegra30_swgroups[] = {
+        { .swgroup = TEGRA_SWGROUP_DC,   .reg = 0x240 },
+        { .swgroup = TEGRA_SWGROUP_DCB,  .reg = 0x244 },
+        { .swgroup = TEGRA_SWGROUP_EPP,  .reg = 0x248 },
+        { .swgroup = TEGRA_SWGROUP_G2,   .reg = 0x24c },
+        { .swgroup = TEGRA_SWGROUP_MPE,  .reg = 0x264 },
+        { .swgroup = TEGRA_SWGROUP_VI,   .reg = 0x280 },
+        { .swgroup = TEGRA_SWGROUP_AFI,  .reg = 0x238 },
+        { .swgroup = TEGRA_SWGROUP_AVPC, .reg = 0x23c },
+        { .swgroup = TEGRA_SWGROUP_NV,   .reg = 0x268 },
+        { .swgroup = TEGRA_SWGROUP_NV2,  .reg = 0x26c },
+        { .swgroup = TEGRA_SWGROUP_HDA,  .reg = 0x254 },
+        { .swgroup = TEGRA_SWGROUP_HC,   .reg = 0x250 },
+        { .swgroup = TEGRA_SWGROUP_PPCS, .reg = 0x270 },
+        { .swgroup = TEGRA_SWGROUP_SATA, .reg = 0x278 },
+        { .swgroup = TEGRA_SWGROUP_VDE,  .reg = 0x27c },
+        { .swgroup = TEGRA_SWGROUP_ISP,  .reg = 0x258 },
+};
+
+static void tegra30_flush_dcache(struct page *page, unsigned long offset,
+                                 size_t size)
+{
+        phys_addr_t phys = page_to_phys(page) + offset;
+        void *virt = page_address(page) + offset;
+
+        __cpuc_flush_dcache_area(virt, size);
+        outer_flush_range(phys, phys + size);
+}
+
+static const struct tegra_smmu_ops tegra30_smmu_ops = {
+        .flush_dcache = tegra30_flush_dcache,
+};
+
+static const struct tegra_smmu_soc tegra30_smmu_soc = {
+        .clients = tegra30_mc_clients,
+        .num_clients = ARRAY_SIZE(tegra30_mc_clients),
+        .swgroups = tegra30_swgroups,
+        .num_swgroups = ARRAY_SIZE(tegra30_swgroups),
+        .supports_round_robin_arbitration = false,
+        .supports_request_limit = false,
+        .num_asids = 4,
+        .ops = &tegra30_smmu_ops,
+};
+
+const struct tegra_mc_soc tegra30_mc_soc = {
+        .clients = tegra30_mc_clients,
+        .num_clients = ARRAY_SIZE(tegra30_mc_clients),
+        .num_address_bits = 32,
+        .atom_size = 16,
+        .smmu = &tegra30_smmu_soc,
+};
diff --git a/drivers/memory/tegra30-mc.c b/drivers/memory/tegra30-mc.c
deleted file mode 100644
index ef7934535fd1..000000000000
--- a/drivers/memory/tegra30-mc.c
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- * Tegra30 Memory Controller
- *
- * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include <linux/err.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/ratelimit.h>
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-
-#define DRV_NAME "tegra30-mc"
-
-#define MC_INTSTATUS                    0x0
-#define MC_INTMASK                      0x4
-
-#define MC_INT_ERR_SHIFT                6
-#define MC_INT_ERR_MASK                 (0x1f << MC_INT_ERR_SHIFT)
-#define MC_INT_DECERR_EMEM              BIT(MC_INT_ERR_SHIFT)
-#define MC_INT_SECURITY_VIOLATION       BIT(MC_INT_ERR_SHIFT + 2)
-#define MC_INT_ARBITRATION_EMEM         BIT(MC_INT_ERR_SHIFT + 3)
-#define MC_INT_INVALID_SMMU_PAGE        BIT(MC_INT_ERR_SHIFT + 4)
-
-#define MC_ERR_STATUS                   0x8
-#define MC_ERR_ADR                      0xc
-
-#define MC_ERR_TYPE_SHIFT               28
-#define MC_ERR_TYPE_MASK                (7 << MC_ERR_TYPE_SHIFT)
-#define MC_ERR_TYPE_DECERR_EMEM         2
-#define MC_ERR_TYPE_SECURITY_TRUSTZONE  3
-#define MC_ERR_TYPE_SECURITY_CARVEOUT   4
-#define MC_ERR_TYPE_INVALID_SMMU_PAGE   6
-
-#define MC_ERR_INVALID_SMMU_PAGE_SHIFT  25
-#define MC_ERR_INVALID_SMMU_PAGE_MASK   (7 << MC_ERR_INVALID_SMMU_PAGE_SHIFT)
-#define MC_ERR_RW_SHIFT                 16
-#define MC_ERR_RW                       BIT(MC_ERR_RW_SHIFT)
-#define MC_ERR_SECURITY                 BIT(MC_ERR_RW_SHIFT + 1)
-
-#define SECURITY_VIOLATION_TYPE         BIT(30) /* 0=TRUSTZONE, 1=CARVEOUT */
-
-#define MC_EMEM_ARB_CFG                 0x90
-#define MC_EMEM_ARB_OUTSTANDING_REQ     0x94
-#define MC_EMEM_ARB_TIMING_RCD          0x98
-#define MC_EMEM_ARB_TIMING_RP           0x9c
-#define MC_EMEM_ARB_TIMING_RC           0xa0
-#define MC_EMEM_ARB_TIMING_RAS          0xa4
-#define MC_EMEM_ARB_TIMING_FAW          0xa8
-#define MC_EMEM_ARB_TIMING_RRD          0xac
-#define MC_EMEM_ARB_TIMING_RAP2PRE      0xb0
-#define MC_EMEM_ARB_TIMING_WAP2PRE      0xb4
-#define MC_EMEM_ARB_TIMING_R2R          0xb8
-#define MC_EMEM_ARB_TIMING_W2W          0xbc
-#define MC_EMEM_ARB_TIMING_R2W          0xc0
-#define MC_EMEM_ARB_TIMING_W2R          0xc4
-
-#define MC_EMEM_ARB_DA_TURNS            0xd0
-#define MC_EMEM_ARB_DA_COVERS           0xd4
-#define MC_EMEM_ARB_MISC0               0xd8
-#define MC_EMEM_ARB_MISC1               0xdc
-
-#define MC_EMEM_ARB_RING3_THROTTLE      0xe4
-#define MC_EMEM_ARB_OVERRIDE            0xe8
-
-#define MC_TIMING_CONTROL               0xfc
-
-#define MC_CLIENT_ID_MASK               0x7f
-
-#define NUM_MC_REG_BANKS                4
-
-struct tegra30_mc {
-        void __iomem *regs[NUM_MC_REG_BANKS];
-        struct device *dev;
-        u32 ctx[0];
-};
-
-static inline u32 mc_readl(struct tegra30_mc *mc, u32 offs)
-{
-        u32 val = 0;
-
-        if (offs < 0x10)
-                val = readl(mc->regs[0] + offs);
-        else if (offs < 0x1f0)
-                val = readl(mc->regs[1] + offs - 0x3c);
-        else if (offs < 0x228)
-                val = readl(mc->regs[2] + offs - 0x200);
-        else if (offs < 0x400)
-                val = readl(mc->regs[3] + offs - 0x284);
-
-        return val;
-}
-
-static inline void mc_writel(struct tegra30_mc *mc, u32 val, u32 offs)
-{
-        if (offs < 0x10)
-                writel(val, mc->regs[0] + offs);
-        else if (offs < 0x1f0)
-                writel(val, mc->regs[1] + offs - 0x3c);
-        else if (offs < 0x228)
-                writel(val, mc->regs[2] + offs - 0x200);
-        else if (offs < 0x400)
-                writel(val, mc->regs[3] + offs - 0x284);
-}
-
-static const char * const tegra30_mc_client[] = {
-        "csr_ptcr",
-        "cbr_display0a",
-        "cbr_display0ab",
-        "cbr_display0b",
-        "cbr_display0bb",
-        "cbr_display0c",
-        "cbr_display0cb",
-        "cbr_display1b",
-        "cbr_display1bb",
-        "cbr_eppup",
-        "cbr_g2pr",
-        "cbr_g2sr",
-        "cbr_mpeunifbr",
-        "cbr_viruv",
-        "csr_afir",
-        "csr_avpcarm7r",
-        "csr_displayhc",
-        "csr_displayhcb",
-        "csr_fdcdrd",
-        "csr_fdcdrd2",
-        "csr_g2dr",
-        "csr_hdar",
-        "csr_host1xdmar",
-        "csr_host1xr",
-        "csr_idxsrd",
-        "csr_idxsrd2",
-        "csr_mpe_ipred",
-        "csr_mpeamemrd",
-        "csr_mpecsrd",
-        "csr_ppcsahbdmar",
-        "csr_ppcsahbslvr",
-        "csr_satar",
-        "csr_texsrd",
-        "csr_texsrd2",
-        "csr_vdebsevr",
-        "csr_vdember",
-        "csr_vdemcer",
-        "csr_vdetper",
-        "csr_mpcorelpr",
-        "csr_mpcorer",
-        "cbw_eppu",
-        "cbw_eppv",
-        "cbw_eppy",
-        "cbw_mpeunifbw",
-        "cbw_viwsb",
-        "cbw_viwu",
-        "cbw_viwv",
-        "cbw_viwy",
-        "ccw_g2dw",
-        "csw_afiw",
-        "csw_avpcarm7w",
-        "csw_fdcdwr",
-        "csw_fdcdwr2",
-        "csw_hdaw",
-        "csw_host1xw",
-        "csw_ispw",
-        "csw_mpcorelpw",
-        "csw_mpcorew",
-        "csw_mpecswr",
-        "csw_ppcsahbdmaw",
-        "csw_ppcsahbslvw",
-        "csw_sataw",
-        "csw_vdebsevw",
-        "csw_vdedbgw",
-        "csw_vdembew",
-        "csw_vdetpmw",
-};
-
-static void tegra30_mc_decode(struct tegra30_mc *mc, int n)
-{
-        u32 err, addr;
-        const char * const mc_int_err[] = {
-                "MC_DECERR",
-                "Unknown",
-                "MC_SECURITY_ERR",
-                "MC_ARBITRATION_EMEM",
-                "MC_SMMU_ERR",
-        };
-        const char * const err_type[] = {
-                "Unknown",
-                "Unknown",
-                "DECERR_EMEM",
-                "SECURITY_TRUSTZONE",
-                "SECURITY_CARVEOUT",
-                "Unknown",
-                "INVALID_SMMU_PAGE",
-                "Unknown",
-        };
-        char attr[6];
-        int cid, perm, type, idx;
-        const char *client = "Unknown";
-
-        idx = n - MC_INT_ERR_SHIFT;
-        if ((idx < 0) || (idx >= ARRAY_SIZE(mc_int_err)) || (idx == 1)) {
-                dev_err_ratelimited(mc->dev, "Unknown interrupt status %08lx\n",
-                                    BIT(n));
-                return;
-        }
-
-        err = mc_readl(mc, MC_ERR_STATUS);
-
-        type = (err & MC_ERR_TYPE_MASK) >> MC_ERR_TYPE_SHIFT;
-        perm = (err & MC_ERR_INVALID_SMMU_PAGE_MASK) >>
-                MC_ERR_INVALID_SMMU_PAGE_SHIFT;
-        if (type == MC_ERR_TYPE_INVALID_SMMU_PAGE)
-                sprintf(attr, "%c-%c-%c",
-                        (perm & BIT(2)) ? 'R' : '-',
-                        (perm & BIT(1)) ? 'W' : '-',
-                        (perm & BIT(0)) ? 'S' : '-');
-        else
-                attr[0] = '\0';
-
-        cid = err & MC_CLIENT_ID_MASK;
-        if (cid < ARRAY_SIZE(tegra30_mc_client))
-                client = tegra30_mc_client[cid];
-
-        addr = mc_readl(mc, MC_ERR_ADR);
-
-        dev_err_ratelimited(mc->dev, "%s (0x%08x): 0x%08x %s (%s %s %s %s)\n",
-                           mc_int_err[idx], err, addr, client,
-                           (err & MC_ERR_SECURITY) ? "secure" : "non-secure",
-                           (err & MC_ERR_RW) ? "write" : "read",
-                           err_type[type], attr);
-}
-
-static const u32 tegra30_mc_ctx[] = {
-        MC_EMEM_ARB_CFG,
-        MC_EMEM_ARB_OUTSTANDING_REQ,
-        MC_EMEM_ARB_TIMING_RCD,
-        MC_EMEM_ARB_TIMING_RP,
-        MC_EMEM_ARB_TIMING_RC,
-        MC_EMEM_ARB_TIMING_RAS,
-        MC_EMEM_ARB_TIMING_FAW,
-        MC_EMEM_ARB_TIMING_RRD,
-        MC_EMEM_ARB_TIMING_RAP2PRE,
-        MC_EMEM_ARB_TIMING_WAP2PRE,
-        MC_EMEM_ARB_TIMING_R2R,
-        MC_EMEM_ARB_TIMING_W2W,
-        MC_EMEM_ARB_TIMING_R2W,
-        MC_EMEM_ARB_TIMING_W2R,
-        MC_EMEM_ARB_DA_TURNS,
-        MC_EMEM_ARB_DA_COVERS,
-        MC_EMEM_ARB_MISC0,
-        MC_EMEM_ARB_MISC1,
-        MC_EMEM_ARB_RING3_THROTTLE,
-        MC_EMEM_ARB_OVERRIDE,
-        MC_INTMASK,
-};
-
-#ifdef CONFIG_PM
-static int tegra30_mc_suspend(struct device *dev)
-{
-        int i;
-        struct tegra30_mc *mc = dev_get_drvdata(dev);
-
-        for (i = 0; i < ARRAY_SIZE(tegra30_mc_ctx); i++)
-                mc->ctx[i] = mc_readl(mc, tegra30_mc_ctx[i]);
-        return 0;
-}
-
-static int tegra30_mc_resume(struct device *dev)
-{
-        int i;
-        struct tegra30_mc *mc = dev_get_drvdata(dev);
-
-        for (i = 0; i < ARRAY_SIZE(tegra30_mc_ctx); i++)
-                mc_writel(mc, mc->ctx[i], tegra30_mc_ctx[i]);
-
-        mc_writel(mc, 1, MC_TIMING_CONTROL);
-        /* Read-back to ensure that write reached */
-        mc_readl(mc, MC_TIMING_CONTROL);
-        return 0;
-}
-#endif
-
-static UNIVERSAL_DEV_PM_OPS(tegra30_mc_pm,
-                            tegra30_mc_suspend,
-                            tegra30_mc_resume, NULL);
-
-static const struct of_device_id tegra30_mc_of_match[] = {
-        { .compatible = "nvidia,tegra30-mc", },
-        {},
-};
-
-static irqreturn_t tegra30_mc_isr(int irq, void *data)
-{
-        u32 stat, mask, bit;
-        struct tegra30_mc *mc = data;
-
-        stat = mc_readl(mc, MC_INTSTATUS);
-        mask = mc_readl(mc, MC_INTMASK);
-        mask &= stat;
-        if (!mask)
-                return IRQ_NONE;
-        while ((bit = ffs(mask)) != 0) {
-                tegra30_mc_decode(mc, bit - 1);
-                mask &= ~BIT(bit - 1);
-        }
-
-        mc_writel(mc, stat, MC_INTSTATUS);
-        return IRQ_HANDLED;
-}
-
-static int tegra30_mc_probe(struct platform_device *pdev)
-{
-        struct resource *irq;
-        struct tegra30_mc *mc;
-        size_t bytes;
-        int err, i;
-        u32 intmask;
-
-        bytes = sizeof(*mc) + sizeof(u32) * ARRAY_SIZE(tegra30_mc_ctx);
-        mc = devm_kzalloc(&pdev->dev, bytes, GFP_KERNEL);
-        if (!mc)
-                return -ENOMEM;
-        mc->dev = &pdev->dev;
-
-        for (i = 0; i < ARRAY_SIZE(mc->regs); i++) {
-                struct resource *res;
-
-                res = platform_get_resource(pdev, IORESOURCE_MEM, i);
-                mc->regs[i] = devm_ioremap_resource(&pdev->dev, res);
-                if (IS_ERR(mc->regs[i]))
-                        return PTR_ERR(mc->regs[i]);
-        }
-
-        irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
-        if (!irq)
-                return -ENODEV;
-        err = devm_request_irq(&pdev->dev, irq->start, tegra30_mc_isr,
-                               IRQF_SHARED, dev_name(&pdev->dev), mc);
-        if (err)
-                return -ENODEV;
-
-        platform_set_drvdata(pdev, mc);
-
-        intmask = MC_INT_INVALID_SMMU_PAGE |
-                MC_INT_DECERR_EMEM | MC_INT_SECURITY_VIOLATION;
-        mc_writel(mc, intmask, MC_INTMASK);
-        return 0;
-}
-
-static struct platform_driver tegra30_mc_driver = {
-        .probe = tegra30_mc_probe,
-        .driver = {
-                .name = DRV_NAME,
-                .owner = THIS_MODULE,
-                .of_match_table = tegra30_mc_of_match,
-                .pm = &tegra30_mc_pm,
-        },
-};
-module_platform_driver(tegra30_mc_driver);
-
-MODULE_AUTHOR("Hiroshi DOYU <hdoyu@nvidia.com>");
-MODULE_DESCRIPTION("Tegra30 MC driver");
-MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index 0707fa2c701b..5bdaae15a742 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -1994,6 +1994,7 @@ static struct scsi_host_template mptsas_driver_template = {
         .cmd_per_lun                    = 7,
         .use_clustering                 = ENABLE_CLUSTERING,
         .shost_attrs                    = mptscsih_host_attrs,
+        .use_blk_tags                   = 1,
 };
 
 static int mptsas_get_linkerrors(struct sas_phy *phy)
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index e7dcb2583369..6c9fc11efb87 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -2311,26 +2311,21 @@ mptscsih_slave_destroy(struct scsi_device *sdev)
  *      mptscsih_change_queue_depth - This function will set a devices queue depth
  *      @sdev: per scsi_device pointer
  *      @qdepth: requested queue depth
- *      @reason: calling context
  *
  *      Adding support for new 'change_queue_depth' api.
 */
 int
-mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
+mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
         MPT_SCSI_HOST           *hd = shost_priv(sdev->host);
         VirtTarget              *vtarget;
         struct scsi_target      *starget;
         int                     max_depth;
-        int                     tagged;
         MPT_ADAPTER             *ioc = hd->ioc;
 
         starget = scsi_target(sdev);
         vtarget = starget->hostdata;
 
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (ioc->bus_type == SPI) {
                 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
                         max_depth = 1;
@@ -2347,13 +2342,8 @@ mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 
         if (qdepth > max_depth)
                 qdepth = max_depth;
-        if (qdepth == 1)
-                tagged = 0;
-        else
-                tagged = MSG_SIMPLE_TAG;
 
-        scsi_adjust_queue_depth(sdev, tagged, qdepth);
-        return sdev->queue_depth;
+        return scsi_change_queue_depth(sdev, qdepth);
 }
 
 /*
@@ -2397,12 +2387,10 @@ mptscsih_slave_configure(struct scsi_device *sdev)
                     ioc->name, vtarget->negoFlags, vtarget->maxOffset,
                     vtarget->minSyncFactor));
 
-        mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH,
-                                    SCSI_QDEPTH_DEFAULT);
+        mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
         dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
-                "tagged %d, simple %d, ordered %d\n",
-                ioc->name,sdev->tagged_supported, sdev->simple_tags,
-                sdev->ordered_tags));
+                "tagged %d, simple %d\n",
+                ioc->name,sdev->tagged_supported, sdev->simple_tags));
 
         blk_queue_dma_alignment (sdev->request_queue, 512 - 1);
 
diff --git a/drivers/message/fusion/mptscsih.h b/drivers/message/fusion/mptscsih.h
index e1b1a198a62a..2baeefd9be7a 100644
--- a/drivers/message/fusion/mptscsih.h
+++ b/drivers/message/fusion/mptscsih.h
@@ -128,8 +128,7 @@ extern int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_F
 extern int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
 extern int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
 extern int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
-extern int mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth,
-                                       int reason);
+extern int mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth);
 extern u8 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id);
 extern int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id);
 extern struct device_attribute *mptscsih_host_attrs[];
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 1456ea70bbc7..2e6b7311fabc 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -59,6 +59,17 @@ config MFD_AAT2870_CORE
           additional drivers must be enabled in order to use the
           functionality of the device.
 
+config MFD_ATMEL_HLCDC
+        tristate "Atmel HLCDC (High-end LCD Controller)"
+        select MFD_CORE
+        select REGMAP_MMIO
+        depends on OF
+        help
+          If you say yes here you get support for the HLCDC block.
+          This driver provides common support for accessing the device,
+          additional drivers must be enabled in order to use the
+          functionality of the device.
+
 config MFD_BCM590XX
         tristate "Broadcom BCM590xx PMUs"
         select MFD_CORE
@@ -74,7 +85,8 @@ config MFD_AXP20X
         select REGMAP_IRQ
         depends on I2C=y
         help
-          If you say Y here you get support for the X-Powers AXP202 and AXP209.
+          If you say Y here you get support for the X-Powers AXP202, AXP209 and
+          AXP288 power management IC (PMIC).
           This driver include only the core APIs. You have to select individual
           components like regulators or the PEK (Power Enable Key) under the
           corresponding menus.
@@ -183,6 +195,16 @@ config MFD_DA9063
           Additional drivers must be enabled in order to use the functionality
           of the device.
 
+config MFD_DLN2
+        tristate "Diolan DLN2 support"
+        select MFD_CORE
+        depends on USB
+        help
+          This adds support for Diolan USB-I2C/SPI/GPIO Master Adapter
+          DLN-2. Additional drivers such as I2C_DLN2, GPIO_DLN2,
+          etc. must be enabled in order to use the functionality of
+          the device.
+
 config MFD_MC13XXX
         tristate
         depends on (SPI_MASTER || I2C)
@@ -655,7 +677,6 @@ config MFD_SEC_CORE
         select MFD_CORE
         select REGMAP_I2C
         select REGMAP_IRQ
-        select REGULATOR
         help
          Support for the Samsung Electronics MFD series.
          This driver provides common support for accessing the device,
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 8bd54b1253af..53467e211381 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -13,7 +13,7 @@ obj-$(CONFIG_MFD_CROS_EC)	+= cros_ec.o
 obj-$(CONFIG_MFD_CROS_EC_I2C)   += cros_ec_i2c.o
 obj-$(CONFIG_MFD_CROS_EC_SPI)   += cros_ec_spi.o
 
-rtsx_pci-objs                   := rtsx_pcr.o rts5209.o rts5229.o rtl8411.o rts5227.o rts5249.o
+rtsx_pci-objs                   := rtsx_pcr.o rtsx_gops.o rts5209.o rts5229.o rtl8411.o rts5227.o rts5249.o
 obj-$(CONFIG_MFD_RTSX_PCI)      += rtsx_pci.o
 obj-$(CONFIG_MFD_RTSX_USB)      += rtsx_usb.o
 
@@ -157,6 +157,7 @@ obj-$(CONFIG_MFD_SPMI_PMIC)	+= qcom-spmi-pmic.o
 obj-$(CONFIG_TPS65911_COMPARATOR)       += tps65911-comparator.o
 obj-$(CONFIG_MFD_TPS65090)      += tps65090.o
 obj-$(CONFIG_MFD_AAT2870_CORE)  += aat2870-core.o
+obj-$(CONFIG_MFD_ATMEL_HLCDC)   += atmel-hlcdc.o
 obj-$(CONFIG_MFD_INTEL_MSIC)    += intel_msic.o
 obj-$(CONFIG_MFD_PALMAS)        += palmas.o
 obj-$(CONFIG_MFD_VIPERBOARD)    += viperboard.o
@@ -174,6 +175,7 @@ obj-$(CONFIG_MFD_STW481X)	+= stw481x.o
 obj-$(CONFIG_MFD_IPAQ_MICRO)    += ipaq-micro.o
 obj-$(CONFIG_MFD_MENF21BMC)     += menf21bmc.o
 obj-$(CONFIG_MFD_HI6421_PMIC)   += hi6421-pmic-core.o
+obj-$(CONFIG_MFD_DLN2)          += dln2.o
 
 intel-soc-pmic-objs             := intel_soc_pmic_core.o intel_soc_pmic_crc.o
 obj-$(CONFIG_INTEL_SOC_PMIC)    += intel-soc-pmic.o
diff --git a/drivers/mfd/ab8500-gpadc.c b/drivers/mfd/ab8500-gpadc.c
index 36000f920981..8e3168d160b2 100644
--- a/drivers/mfd/ab8500-gpadc.c
+++ b/drivers/mfd/ab8500-gpadc.c
@@ -867,7 +867,7 @@ static void ab8500_gpadc_read_calibration_data(struct ab8500_gpadc *gpadc)
                 gpadc->cal_data[ADC_INPUT_VBAT].offset);
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int ab8500_gpadc_runtime_suspend(struct device *dev)
 {
         struct ab8500_gpadc *gpadc = dev_get_drvdata(dev);
diff --git a/drivers/mfd/ab8500-sysctrl.c b/drivers/mfd/ab8500-sysctrl.c
index 8e0dae59844d..94dbcdd2a1ff 100644
--- a/drivers/mfd/ab8500-sysctrl.c
+++ b/drivers/mfd/ab8500-sysctrl.c
@@ -85,63 +85,6 @@ shutdown:
         }
 }
 
-/*
- * Use the AB WD to reset the platform. It will perform a hard
- * reset instead of a soft reset. Write the reset reason to
- * the AB before reset, which can be read upon restart.
- */
-void ab8500_restart(char mode, const char *cmd)
-{
-        struct ab8500_platform_data *plat;
-        struct ab8500_sysctrl_platform_data *pdata;
-        u16 reason = 0;
-        u8 val;
-
-        if (sysctrl_dev == NULL) {
-                pr_err("%s: sysctrl not initialized\n", __func__);
-                return;
-        }
-
-        plat = dev_get_platdata(sysctrl_dev->parent);
-        pdata = plat->sysctrl;
-        if (pdata && pdata->reboot_reason_code)
-                reason = pdata->reboot_reason_code(cmd);
-        else
-                pr_warn("[%s] No reboot reason set. Default reason %d\n",
-                        __func__, reason);
-
-        /*
-         * Disable RTC alarm, just a precaution so that no alarm
-         * is running when WD reset is executed.
-         */
-        abx500_get_register_interruptible(sysctrl_dev, AB8500_RTC,
-                RTC_CTRL , &val);
-        abx500_set_register_interruptible(sysctrl_dev, AB8500_RTC,
-                RTC_CTRL , (val & ~RTC_ALARM_ENABLE));
-
-        /*
-         * Android is not using the RTC alarm registers during reboot
-         * so we borrow them for writing the reason of reset
-         */
-
-        /* reason[8 LSB] */
-        val = reason & 0xFF;
-        abx500_set_register_interruptible(sysctrl_dev, AB8500_RTC,
-                AB8500_ALARM_MIN_LOW , val);
-
-        /* reason[8 MSB] */
-        val = (reason>>8) & 0xFF;
-        abx500_set_register_interruptible(sysctrl_dev, AB8500_RTC,
-                AB8500_ALARM_MIN_MID , val);
-
-        /* Setting WD timeout to 0 */
-        ab8500_sysctrl_write(AB8500_MAINWDOGTIMER, 0xFF, 0x0);
-
-        /* Setting the parameters to AB8500 WD*/
-        ab8500_sysctrl_write(AB8500_MAINWDOGCTRL, 0xFF, (AB8500_ENABLE_WD |
-                AB8500_WD_RESTART_ON_EXPIRE | AB8500_KICK_WD));
-}
-
 static inline bool valid_bank(u8 bank)
 {
         return ((bank == AB8500_SYS_CTRL1_BLOCK) ||
diff --git a/drivers/mfd/arizona-core.c b/drivers/mfd/arizona-core.c
index bce7c0784b6b..09ba8f186e6a 100644
--- a/drivers/mfd/arizona-core.c
+++ b/drivers/mfd/arizona-core.c
@@ -330,7 +330,7 @@ err_fll:
                 return err;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int arizona_runtime_resume(struct device *dev)
 {
         struct arizona *arizona = dev_get_drvdata(dev);
@@ -1024,7 +1024,7 @@ int arizona_dev_init(struct arizona *arizona)
                 goto err_irq;
         }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         regulator_disable(arizona->dcvdd);
 #endif
 
diff --git a/drivers/mfd/arizona-spi.c b/drivers/mfd/arizona-spi.c
index 5145d78bf07e..8ef58bcff193 100644
--- a/drivers/mfd/arizona-spi.c
+++ b/drivers/mfd/arizona-spi.c
@@ -75,7 +75,9 @@ static int arizona_spi_probe(struct spi_device *spi)
 static int arizona_spi_remove(struct spi_device *spi)
 {
         struct arizona *arizona = spi_get_drvdata(spi);
+
         arizona_dev_exit(arizona);
+
         return 0;
 }
 
diff --git a/drivers/mfd/atmel-hlcdc.c b/drivers/mfd/atmel-hlcdc.c
new file mode 100644
index 000000000000..cfd58f4cc5c3
--- /dev/null
+++ b/drivers/mfd/atmel-hlcdc.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2014 Free Electrons
+ * Copyright (C) 2014 Atmel
+ *
+ * Author: Boris BREZILLON <boris.brezillon@free-electrons.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/clk.h>
+#include <linux/mfd/atmel-hlcdc.h>
+#include <linux/mfd/core.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+
+#define ATMEL_HLCDC_REG_MAX             (0x4000 - 0x4)
+
+static const struct mfd_cell atmel_hlcdc_cells[] = {
+        {
+                .name = "atmel-hlcdc-pwm",
+                .of_compatible = "atmel,hlcdc-pwm",
+        },
+        {
+                .name = "atmel-hlcdc-dc",
+                .of_compatible = "atmel,hlcdc-display-controller",
+        },
+};
+
+static const struct regmap_config atmel_hlcdc_regmap_config = {
+        .reg_bits = 32,
+        .val_bits = 32,
+        .reg_stride = 4,
+        .max_register = ATMEL_HLCDC_REG_MAX,
+};
+
+static int atmel_hlcdc_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct atmel_hlcdc *hlcdc;
+        struct resource *res;
+        void __iomem *regs;
+
+        hlcdc = devm_kzalloc(dev, sizeof(*hlcdc), GFP_KERNEL);
+        if (!hlcdc)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        regs = devm_ioremap_resource(dev, res);
+        if (IS_ERR(regs))
+                return PTR_ERR(regs);
+
+        hlcdc->irq = platform_get_irq(pdev, 0);
+        if (hlcdc->irq < 0)
+                return hlcdc->irq;
+
+        hlcdc->periph_clk = devm_clk_get(dev, "periph_clk");
+        if (IS_ERR(hlcdc->periph_clk)) {
+                dev_err(dev, "failed to get peripheral clock\n");
+                return PTR_ERR(hlcdc->periph_clk);
+        }
+
+        hlcdc->sys_clk = devm_clk_get(dev, "sys_clk");
+        if (IS_ERR(hlcdc->sys_clk)) {
+                dev_err(dev, "failed to get system clock\n");
+                return PTR_ERR(hlcdc->sys_clk);
+        }
+
+        hlcdc->slow_clk = devm_clk_get(dev, "slow_clk");
+        if (IS_ERR(hlcdc->slow_clk)) {
+                dev_err(dev, "failed to get slow clock\n");
+                return PTR_ERR(hlcdc->slow_clk);
+        }
+
+        hlcdc->regmap = devm_regmap_init_mmio(dev, regs,
+                                              &atmel_hlcdc_regmap_config);
+        if (IS_ERR(hlcdc->regmap))
+                return PTR_ERR(hlcdc->regmap);
+
+        dev_set_drvdata(dev, hlcdc);
+
+        return mfd_add_devices(dev, -1, atmel_hlcdc_cells,
+                               ARRAY_SIZE(atmel_hlcdc_cells),
+                               NULL, 0, NULL);
+}
+
+static int atmel_hlcdc_remove(struct platform_device *pdev)
+{
+        mfd_remove_devices(&pdev->dev);
+
+        return 0;
+}
+
+static const struct of_device_id atmel_hlcdc_match[] = {
+        { .compatible = "atmel,sama5d3-hlcdc" },
+        { /* sentinel */ },
+};
+
+static struct platform_driver atmel_hlcdc_driver = {
+        .probe = atmel_hlcdc_probe,
+        .remove = atmel_hlcdc_remove,
+        .driver = {
+                .name = "atmel-hlcdc",
+                .of_match_table = atmel_hlcdc_match,
+        },
+};
+module_platform_driver(atmel_hlcdc_driver);
+
+MODULE_ALIAS("platform:atmel-hlcdc");
+MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
+MODULE_DESCRIPTION("Atmel HLCDC driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/axp20x.c b/drivers/mfd/axp20x.c
index 6231adbb295d..b1b580a88654 100644
--- a/drivers/mfd/axp20x.c
+++ b/drivers/mfd/axp20x.c
@@ -1,9 +1,9 @@
 /*
- * axp20x.c - MFD core driver for the X-Powers AXP202 and AXP209
+ * axp20x.c - MFD core driver for the X-Powers' Power Management ICs
  *
- * AXP20x comprises an adaptive USB-Compatible PWM charger, 2 BUCK DC-DC
- * converters, 5 LDOs, multiple 12-bit ADCs of voltage, current and temperature
- * as well as 4 configurable GPIOs.
+ * AXP20x typically comprises an adaptive USB-Compatible PWM charger, BUCK DC-DC
+ * converters, LDOs, multiple 12-bit ADCs of voltage, current and temperature
+ * as well as configurable GPIOs.
  *
  * Author: Carlo Caione <carlo@caione.org>
  *
@@ -25,9 +25,16 @@
 #include <linux/mfd/core.h>
 #include <linux/of_device.h>
 #include <linux/of_irq.h>
+#include <linux/acpi.h>
 
 #define AXP20X_OFF      0x80
 
+static const char const *axp20x_model_names[] = {
+        "AXP202",
+        "AXP209",
+        "AXP288",
+};
+
 static const struct regmap_range axp20x_writeable_ranges[] = {
         regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ5_STATE),
         regmap_reg_range(AXP20X_DCDC_MODE, AXP20X_FG_RES),
@@ -47,6 +54,25 @@ static const struct regmap_access_table axp20x_volatile_table = {
         .n_yes_ranges   = ARRAY_SIZE(axp20x_volatile_ranges),
 };
 
+static const struct regmap_range axp288_writeable_ranges[] = {
+        regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ6_STATE),
+        regmap_reg_range(AXP20X_DCDC_MODE, AXP288_FG_TUNE5),
+};
+
+static const struct regmap_range axp288_volatile_ranges[] = {
+        regmap_reg_range(AXP20X_IRQ1_EN, AXP20X_IPSOUT_V_HIGH_L),
+};
+
+static const struct regmap_access_table axp288_writeable_table = {
+        .yes_ranges     = axp288_writeable_ranges,
+        .n_yes_ranges   = ARRAY_SIZE(axp288_writeable_ranges),
+};
+
+static const struct regmap_access_table axp288_volatile_table = {
+        .yes_ranges     = axp288_volatile_ranges,
+        .n_yes_ranges   = ARRAY_SIZE(axp288_volatile_ranges),
+};
+
 static struct resource axp20x_pek_resources[] = {
         {
                 .name   = "PEK_DBR",
@@ -61,6 +87,39 @@ static struct resource axp20x_pek_resources[] = {
         },
 };
 
+static struct resource axp288_battery_resources[] = {
+        {
+                .start = AXP288_IRQ_QWBTU,
+                .end   = AXP288_IRQ_QWBTU,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_WBTU,
+                .end   = AXP288_IRQ_WBTU,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_QWBTO,
+                .end   = AXP288_IRQ_QWBTO,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_WBTO,
+                .end   = AXP288_IRQ_WBTO,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_WL2,
+                .end   = AXP288_IRQ_WL2,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_WL1,
+                .end   = AXP288_IRQ_WL1,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
 static const struct regmap_config axp20x_regmap_config = {
         .reg_bits       = 8,
         .val_bits       = 8,
@@ -70,47 +129,96 @@ static const struct regmap_config axp20x_regmap_config = {
         .cache_type     = REGCACHE_RBTREE,
 };
 
-#define AXP20X_IRQ(_irq, _off, _mask) \
-        [AXP20X_IRQ_##_irq] = { .reg_offset = (_off), .mask = BIT(_mask) }
+static const struct regmap_config axp288_regmap_config = {
+        .reg_bits       = 8,
+        .val_bits       = 8,
+        .wr_table       = &axp288_writeable_table,
+        .volatile_table = &axp288_volatile_table,
+        .max_register   = AXP288_FG_TUNE5,
+        .cache_type     = REGCACHE_RBTREE,
+};
+
+#define INIT_REGMAP_IRQ(_variant, _irq, _off, _mask)                    \
+        [_variant##_IRQ_##_irq] = { .reg_offset = (_off), .mask = BIT(_mask) }
 
 static const struct regmap_irq axp20x_regmap_irqs[] = {
-        AXP20X_IRQ(ACIN_OVER_V,         0, 7),
-        AXP20X_IRQ(ACIN_PLUGIN,         0, 6),
-        AXP20X_IRQ(ACIN_REMOVAL,        0, 5),
-        AXP20X_IRQ(VBUS_OVER_V,         0, 4),
-        AXP20X_IRQ(VBUS_PLUGIN,         0, 3),
-        AXP20X_IRQ(VBUS_REMOVAL,        0, 2),
-        AXP20X_IRQ(VBUS_V_LOW,          0, 1),
-        AXP20X_IRQ(BATT_PLUGIN,         1, 7),
-        AXP20X_IRQ(BATT_REMOVAL,        1, 6),
-        AXP20X_IRQ(BATT_ENT_ACT_MODE,   1, 5),
-        AXP20X_IRQ(BATT_EXIT_ACT_MODE,  1, 4),
-        AXP20X_IRQ(CHARG,               1, 3),
-        AXP20X_IRQ(CHARG_DONE,          1, 2),
-        AXP20X_IRQ(BATT_TEMP_HIGH,      1, 1),
-        AXP20X_IRQ(BATT_TEMP_LOW,       1, 0),
-        AXP20X_IRQ(DIE_TEMP_HIGH,       2, 7),
-        AXP20X_IRQ(CHARG_I_LOW,         2, 6),
-        AXP20X_IRQ(DCDC1_V_LONG,        2, 5),
-        AXP20X_IRQ(DCDC2_V_LONG,        2, 4),
-        AXP20X_IRQ(DCDC3_V_LONG,        2, 3),
-        AXP20X_IRQ(PEK_SHORT,           2, 1),
-        AXP20X_IRQ(PEK_LONG,            2, 0),
-        AXP20X_IRQ(N_OE_PWR_ON,         3, 7),
-        AXP20X_IRQ(N_OE_PWR_OFF,        3, 6),
-        AXP20X_IRQ(VBUS_VALID,          3, 5),
-        AXP20X_IRQ(VBUS_NOT_VALID,      3, 4),
-        AXP20X_IRQ(VBUS_SESS_VALID,     3, 3),
-        AXP20X_IRQ(VBUS_SESS_END,       3, 2),
-        AXP20X_IRQ(LOW_PWR_LVL1,        3, 1),
-        AXP20X_IRQ(LOW_PWR_LVL2,        3, 0),
-        AXP20X_IRQ(TIMER,               4, 7),
-        AXP20X_IRQ(PEK_RIS_EDGE,        4, 6),
-        AXP20X_IRQ(PEK_FAL_EDGE,        4, 5),
-        AXP20X_IRQ(GPIO3_INPUT,         4, 3),
-        AXP20X_IRQ(GPIO2_INPUT,         4, 2),
-        AXP20X_IRQ(GPIO1_INPUT,         4, 1),
-        AXP20X_IRQ(GPIO0_INPUT,         4, 0),
+        INIT_REGMAP_IRQ(AXP20X, ACIN_OVER_V,            0, 7),
+        INIT_REGMAP_IRQ(AXP20X, ACIN_PLUGIN,            0, 6),
+        INIT_REGMAP_IRQ(AXP20X, ACIN_REMOVAL,           0, 5),
+        INIT_REGMAP_IRQ(AXP20X, VBUS_OVER_V,            0, 4),
+        INIT_REGMAP_IRQ(AXP20X, VBUS_PLUGIN,            0, 3),
+        INIT_REGMAP_IRQ(AXP20X, VBUS_REMOVAL,           0, 2),
+        INIT_REGMAP_IRQ(AXP20X, VBUS_V_LOW,             0, 1),
+        INIT_REGMAP_IRQ(AXP20X, BATT_PLUGIN,            1, 7),
+        INIT_REGMAP_IRQ(AXP20X, BATT_REMOVAL,           1, 6),
+        INIT_REGMAP_IRQ(AXP20X, BATT_ENT_ACT_MODE,      1, 5),
+        INIT_REGMAP_IRQ(AXP20X, BATT_EXIT_ACT_MODE,     1, 4),
+        INIT_REGMAP_IRQ(AXP20X, CHARG,                  1, 3),
+        INIT_REGMAP_IRQ(AXP20X, CHARG_DONE,             1, 2),
+        INIT_REGMAP_IRQ(AXP20X, BATT_TEMP_HIGH,         1, 1),
+        INIT_REGMAP_IRQ(AXP20X, BATT_TEMP_LOW,          1, 0),
+        INIT_REGMAP_IRQ(AXP20X, DIE_TEMP_HIGH,          2, 7),
+        INIT_REGMAP_IRQ(AXP20X, CHARG_I_LOW,            2, 6),
+        INIT_REGMAP_IRQ(AXP20X, DCDC1_V_LONG,           2, 5),
+        INIT_REGMAP_IRQ(AXP20X, DCDC2_V_LONG,           2, 4),
+        INIT_REGMAP_IRQ(AXP20X, DCDC3_V_LONG,           2, 3),
+        INIT_REGMAP_IRQ(AXP20X, PEK_SHORT,              2, 1),
+        INIT_REGMAP_IRQ(AXP20X, PEK_LONG,               2, 0),
+        INIT_REGMAP_IRQ(AXP20X, N_OE_PWR_ON,            3, 7),
+        INIT_REGMAP_IRQ(AXP20X, N_OE_PWR_OFF,           3, 6),
+        INIT_REGMAP_IRQ(AXP20X, VBUS_VALID,             3, 5),
+        INIT_REGMAP_IRQ(AXP20X, VBUS_NOT_VALID,         3, 4),
+        INIT_REGMAP_IRQ(AXP20X, VBUS_SESS_VALID,        3, 3),
+        INIT_REGMAP_IRQ(AXP20X, VBUS_SESS_END,          3, 2),
+        INIT_REGMAP_IRQ(AXP20X, LOW_PWR_LVL1,           3, 1),
+        INIT_REGMAP_IRQ(AXP20X, LOW_PWR_LVL2,           3, 0),
+        INIT_REGMAP_IRQ(AXP20X, TIMER,                  4, 7),
+        INIT_REGMAP_IRQ(AXP20X, PEK_RIS_EDGE,           4, 6),
+        INIT_REGMAP_IRQ(AXP20X, PEK_FAL_EDGE,           4, 5),
+        INIT_REGMAP_IRQ(AXP20X, GPIO3_INPUT,            4, 3),
+        INIT_REGMAP_IRQ(AXP20X, GPIO2_INPUT,            4, 2),
+        INIT_REGMAP_IRQ(AXP20X, GPIO1_INPUT,            4, 1),
+        INIT_REGMAP_IRQ(AXP20X, GPIO0_INPUT,            4, 0),
+};
+
+/* some IRQs are compatible with axp20x models */
+static const struct regmap_irq axp288_regmap_irqs[] = {
+        INIT_REGMAP_IRQ(AXP288, VBUS_FALL,              0, 2),
+        INIT_REGMAP_IRQ(AXP288, VBUS_RISE,              0, 3),
+        INIT_REGMAP_IRQ(AXP288, OV,                     0, 4),
+
+        INIT_REGMAP_IRQ(AXP288, DONE,                   1, 2),
+        INIT_REGMAP_IRQ(AXP288, CHARGING,               1, 3),
+        INIT_REGMAP_IRQ(AXP288, SAFE_QUIT,              1, 4),
+        INIT_REGMAP_IRQ(AXP288, SAFE_ENTER,             1, 5),
+        INIT_REGMAP_IRQ(AXP288, ABSENT,                 1, 6),
+        INIT_REGMAP_IRQ(AXP288, APPEND,                 1, 7),
+
+        INIT_REGMAP_IRQ(AXP288, QWBTU,                  2, 0),
+        INIT_REGMAP_IRQ(AXP288, WBTU,                   2, 1),
+        INIT_REGMAP_IRQ(AXP288, QWBTO,                  2, 2),
+        INIT_REGMAP_IRQ(AXP288, WBTO,                   2, 3),
+        INIT_REGMAP_IRQ(AXP288, QCBTU,                  2, 4),
+        INIT_REGMAP_IRQ(AXP288, CBTU,                   2, 5),
+        INIT_REGMAP_IRQ(AXP288, QCBTO,                  2, 6),
+        INIT_REGMAP_IRQ(AXP288, CBTO,                   2, 7),
+
+        INIT_REGMAP_IRQ(AXP288, WL2,                    3, 0),
+        INIT_REGMAP_IRQ(AXP288, WL1,                    3, 1),
+        INIT_REGMAP_IRQ(AXP288, GPADC,                  3, 2),
+        INIT_REGMAP_IRQ(AXP288, OT,                     3, 7),
+
+        INIT_REGMAP_IRQ(AXP288, GPIO0,                  4, 0),
+        INIT_REGMAP_IRQ(AXP288, GPIO1,                  4, 1),
+        INIT_REGMAP_IRQ(AXP288, POKO,                   4, 2),
+        INIT_REGMAP_IRQ(AXP288, POKL,                   4, 3),
+        INIT_REGMAP_IRQ(AXP288, POKS,                   4, 4),
+        INIT_REGMAP_IRQ(AXP288, POKN,                   4, 5),
+        INIT_REGMAP_IRQ(AXP288, POKP,                   4, 6),
+        INIT_REGMAP_IRQ(AXP288, TIMER,                  4, 7),
+
+        INIT_REGMAP_IRQ(AXP288, MV_CHNG,                5, 0),
+        INIT_REGMAP_IRQ(AXP288, BC_USB_CHNG,            5, 1),
 };
 
 static const struct of_device_id axp20x_of_match[] = {
@@ -128,16 +236,39 @@ static const struct i2c_device_id axp20x_i2c_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, axp20x_i2c_id);
 
+static const struct acpi_device_id axp20x_acpi_match[] = {
+        {
+                .id = "INT33F4",
+                .driver_data = AXP288_ID,
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(acpi, axp20x_acpi_match);
+
 static const struct regmap_irq_chip axp20x_regmap_irq_chip = {
         .name                   = "axp20x_irq_chip",
         .status_base            = AXP20X_IRQ1_STATE,
         .ack_base               = AXP20X_IRQ1_STATE,
         .mask_base              = AXP20X_IRQ1_EN,
-        .num_regs               = 5,
+        .mask_invert            = true,
+        .init_ack_masked        = true,
         .irqs                   = axp20x_regmap_irqs,
         .num_irqs               = ARRAY_SIZE(axp20x_regmap_irqs),
+        .num_regs               = 5,
+
+};
+
+static const struct regmap_irq_chip axp288_regmap_irq_chip = {
+        .name                   = "axp288_irq_chip",
+        .status_base            = AXP20X_IRQ1_STATE,
+        .ack_base               = AXP20X_IRQ1_STATE,
+        .mask_base              = AXP20X_IRQ1_EN,
         .mask_invert            = true,
         .init_ack_masked        = true,
+        .irqs                   = axp288_regmap_irqs,
+        .num_irqs               = ARRAY_SIZE(axp288_regmap_irqs),
+        .num_regs               = 6,
+
 };
 
 static struct mfd_cell axp20x_cells[] = {
@@ -150,36 +281,158 @@ static struct mfd_cell axp20x_cells[] = {
         },
 };
 
+static struct resource axp288_adc_resources[] = {
+        {
+                .name  = "GPADC",
+                .start = AXP288_IRQ_GPADC,
+                .end   = AXP288_IRQ_GPADC,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource axp288_charger_resources[] = {
+        {
+                .start = AXP288_IRQ_OV,
+                .end   = AXP288_IRQ_OV,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_DONE,
+                .end   = AXP288_IRQ_DONE,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_CHARGING,
+                .end   = AXP288_IRQ_CHARGING,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_SAFE_QUIT,
+                .end   = AXP288_IRQ_SAFE_QUIT,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_SAFE_ENTER,
+                .end   = AXP288_IRQ_SAFE_ENTER,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_QCBTU,
+                .end   = AXP288_IRQ_QCBTU,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_CBTU,
+                .end   = AXP288_IRQ_CBTU,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_QCBTO,
+                .end   = AXP288_IRQ_QCBTO,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .start = AXP288_IRQ_CBTO,
+                .end   = AXP288_IRQ_CBTO,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct mfd_cell axp288_cells[] = {
+        {
+                .name = "axp288_adc",
+                .num_resources = ARRAY_SIZE(axp288_adc_resources),
+                .resources = axp288_adc_resources,
+        },
+        {
+                .name = "axp288_charger",
+                .num_resources = ARRAY_SIZE(axp288_charger_resources),
+                .resources = axp288_charger_resources,
+        },
+        {
+                .name = "axp288_battery",
+                .num_resources = ARRAY_SIZE(axp288_battery_resources),
+                .resources = axp288_battery_resources,
+        },
+        {
+                .name = "axp288_pmic_acpi",
+        },
+};
+
 static struct axp20x_dev *axp20x_pm_power_off;
 static void axp20x_power_off(void)
 {
+        if (axp20x_pm_power_off->variant == AXP288_ID)
+                return;
+
         regmap_write(axp20x_pm_power_off->regmap, AXP20X_OFF_CTRL,
                      AXP20X_OFF);
 }
 
+static int axp20x_match_device(struct axp20x_dev *axp20x, struct device *dev)
+{
+        const struct acpi_device_id *acpi_id;
+        const struct of_device_id *of_id;
+
+        if (dev->of_node) {
+                of_id = of_match_device(axp20x_of_match, dev);
+                if (!of_id) {
+                        dev_err(dev, "Unable to match OF ID\n");
+                        return -ENODEV;
+                }
+                axp20x->variant = (long) of_id->data;
+        } else {
+                acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);
+                if (!acpi_id || !acpi_id->driver_data) {
+                        dev_err(dev, "Unable to match ACPI ID and data\n");
+                        return -ENODEV;
+                }
+                axp20x->variant = (long) acpi_id->driver_data;
+        }
+
+        switch (axp20x->variant) {
+        case AXP202_ID:
+        case AXP209_ID:
+                axp20x->nr_cells = ARRAY_SIZE(axp20x_cells);
+                axp20x->cells = axp20x_cells;
+                axp20x->regmap_cfg = &axp20x_regmap_config;
+                axp20x->regmap_irq_chip = &axp20x_regmap_irq_chip;
+                break;
+        case AXP288_ID:
+                axp20x->cells = axp288_cells;
+                axp20x->nr_cells = ARRAY_SIZE(axp288_cells);
+                axp20x->regmap_cfg = &axp288_regmap_config;
+                axp20x->regmap_irq_chip = &axp288_regmap_irq_chip;
+                break;
+        default:
+                dev_err(dev, "unsupported AXP20X ID %lu\n", axp20x->variant);
+                return -EINVAL;
+        }
+        dev_info(dev, "AXP20x variant %s found\n",
+                axp20x_model_names[axp20x->variant]);
+
+        return 0;
+}
+
 static int axp20x_i2c_probe(struct i2c_client *i2c,
                          const struct i2c_device_id *id)
 {
         struct axp20x_dev *axp20x;
-        const struct of_device_id *of_id;
         int ret;
 
         axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL);
         if (!axp20x)
                 return -ENOMEM;
 
-        of_id = of_match_device(axp20x_of_match, &i2c->dev);
-        if (!of_id) {
-                dev_err(&i2c->dev, "Unable to setup AXP20X data\n");
-                return -ENODEV;
-        }
-        axp20x->variant = (long) of_id->data;
+        ret = axp20x_match_device(axp20x, &i2c->dev);
+        if (ret)
+                return ret;
 
         axp20x->i2c_client = i2c;
         axp20x->dev = &i2c->dev;
         dev_set_drvdata(axp20x->dev, axp20x);
 
-        axp20x->regmap = devm_regmap_init_i2c(i2c, &axp20x_regmap_config);
+        axp20x->regmap = devm_regmap_init_i2c(i2c, axp20x->regmap_cfg);
         if (IS_ERR(axp20x->regmap)) {
                 ret = PTR_ERR(axp20x->regmap);
                 dev_err(&i2c->dev, "regmap init failed: %d\n", ret);
@@ -188,15 +441,15 @@ static int axp20x_i2c_probe(struct i2c_client *i2c,
 
         ret = regmap_add_irq_chip(axp20x->regmap, i2c->irq,
                                   IRQF_ONESHOT | IRQF_SHARED, -1,
-                                  &axp20x_regmap_irq_chip,
+                                  axp20x->regmap_irq_chip,
                                   &axp20x->regmap_irqc);
         if (ret) {
                 dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret);
                 return ret;
         }
 
-        ret = mfd_add_devices(axp20x->dev, -1, axp20x_cells,
-                              ARRAY_SIZE(axp20x_cells), NULL, 0, NULL);
+        ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells,
+                        axp20x->nr_cells, NULL, 0, NULL);
 
         if (ret) {
                 dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret);
@@ -234,6 +487,7 @@ static struct i2c_driver axp20x_i2c_driver = {
                 .name   = "axp20x",
                 .owner  = THIS_MODULE,
                 .of_match_table = of_match_ptr(axp20x_of_match),
+                .acpi_match_table = ACPI_PTR(axp20x_acpi_match),
         },
         .probe          = axp20x_i2c_probe,
         .remove         = axp20x_i2c_remove,
diff --git a/drivers/mfd/da9063-core.c b/drivers/mfd/da9063-core.c
index 93db8bb8c8f0..f38bc98a3c57 100644
--- a/drivers/mfd/da9063-core.c
+++ b/drivers/mfd/da9063-core.c
@@ -118,7 +118,7 @@ int da9063_device_init(struct da9063 *da9063, unsigned int irq)
                 da9063->irq_base = pdata->irq_base;
         } else {
                 da9063->flags = 0;
-                da9063->irq_base = 0;
+                da9063->irq_base = -1;
         }
         da9063->chip_irq = irq;
 
@@ -168,6 +168,8 @@ int da9063_device_init(struct da9063 *da9063, unsigned int irq)
                 return ret;
         }
 
+        da9063->irq_base = regmap_irq_chip_get_base(da9063->regmap_irq);
+
         ret = mfd_add_devices(da9063->dev, -1, da9063_devs,
                               ARRAY_SIZE(da9063_devs), NULL, da9063->irq_base,
                               NULL);
diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index 193cf168ba84..a8204730f01c 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -3150,23 +3150,28 @@ static int db8500_prcmu_probe(struct platform_device *pdev)
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "prcmu");
         if (!res) {
                 dev_err(&pdev->dev, "no prcmu memory region provided\n");
-                return -ENOENT;
+                return -EINVAL;
         }
         prcmu_base = devm_ioremap(&pdev->dev, res->start, resource_size(res));
         if (!prcmu_base) {
                 dev_err(&pdev->dev,
                         "failed to ioremap prcmu register memory\n");
-                return -ENOENT;
+                return -ENOMEM;
         }
         init_prcm_registers();
         dbx500_fw_version_init(pdev, pdata->version_offset);
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "prcmu-tcdm");
         if (!res) {
                 dev_err(&pdev->dev, "no prcmu tcdm region provided\n");
-                return -ENOENT;
+                return -EINVAL;
         }
         tcdm_base = devm_ioremap(&pdev->dev, res->start,
                         resource_size(res));
+        if (!tcdm_base) {
+                dev_err(&pdev->dev,
+                        "failed to ioremap prcmu-tcdm register memory\n");
+                return -ENOMEM;
+        }
 
         /* Clean up the mailbox interrupts after pre-kernel code. */
         writel(ALL_MBOX_BITS, PRCM_ARM_IT1_CLR);
@@ -3174,15 +3179,14 @@ static int db8500_prcmu_probe(struct platform_device *pdev)
         irq = platform_get_irq(pdev, 0);
         if (irq <= 0) {
                 dev_err(&pdev->dev, "no prcmu irq provided\n");
-                return -ENOENT;
+                return irq;
         }
 
         err = request_threaded_irq(irq, prcmu_irq_handler,
                 prcmu_irq_thread_fn, IRQF_NO_SUSPEND, "prcmu", NULL);
         if (err < 0) {
                 pr_err("prcmu: Failed to allocate IRQ_DB8500_PRCMU1.\n");
-                err = -EBUSY;
-                goto no_irq_return;
+                return err;
         }
 
         db8500_irq_init(np);
@@ -3206,7 +3210,7 @@ static int db8500_prcmu_probe(struct platform_device *pdev)
                 if (err) {
                         mfd_remove_devices(&pdev->dev);
                         pr_err("prcmu: Failed to add subdevices\n");
-                        goto no_irq_return;
+                        return err;
                 }
         }
 
@@ -3214,12 +3218,10 @@ static int db8500_prcmu_probe(struct platform_device *pdev)
         if (err) {
                 mfd_remove_devices(&pdev->dev);
                 pr_err("prcmu: Failed to add ab8500 subdevice\n");
-                goto no_irq_return;
+                return err;
         }
 
         pr_info("DB8500 PRCMU initialized\n");
-
-no_irq_return:
         return err;
 }
 static const struct of_device_id db8500_prcmu_match[] = {
diff --git a/drivers/mfd/dln2.c b/drivers/mfd/dln2.c
new file mode 100644
index 000000000000..6d49685d4ee4
--- /dev/null
+++ b/drivers/mfd/dln2.c
@@ -0,0 +1,781 @@
+/*
+ * Driver for the Diolan DLN-2 USB adapter
+ *
+ * Copyright (c) 2014 Intel Corporation
+ *
+ * Derived from:
+ *  i2c-diolan-u2c.c
+ *  Copyright (c) 2010-2011 Ericsson AB
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/dln2.h>
+#include <linux/rculist.h>
+
+struct dln2_header {
+        __le16 size;
+        __le16 id;
+        __le16 echo;
+        __le16 handle;
+};
+
+struct dln2_response {
+        struct dln2_header hdr;
+        __le16 result;
+};
+
+#define DLN2_GENERIC_MODULE_ID          0x00
+#define DLN2_GENERIC_CMD(cmd)           DLN2_CMD(cmd, DLN2_GENERIC_MODULE_ID)
+#define CMD_GET_DEVICE_VER              DLN2_GENERIC_CMD(0x30)
+#define CMD_GET_DEVICE_SN               DLN2_GENERIC_CMD(0x31)
+
+#define DLN2_HW_ID                      0x200
+#define DLN2_USB_TIMEOUT                200     /* in ms */
+#define DLN2_MAX_RX_SLOTS               16
+#define DLN2_MAX_URBS                   16
+#define DLN2_RX_BUF_SIZE                512
+
+enum dln2_handle {
+        DLN2_HANDLE_EVENT = 0,          /* don't change, hardware defined */
+        DLN2_HANDLE_CTRL,
+        DLN2_HANDLE_GPIO,
+        DLN2_HANDLE_I2C,
+        DLN2_HANDLE_SPI,
+        DLN2_HANDLES
+};
+
+/*
+ * Receive context used between the receive demultiplexer and the transfer
+ * routine. While sending a request the transfer routine will look for a free
+ * receive context and use it to wait for a response and to receive the URB and
+ * thus the response data.
+ */
+struct dln2_rx_context {
+        /* completion used to wait for a response */
+        struct completion done;
+
+        /* if non-NULL the URB contains the response */
+        struct urb *urb;
+
+        /* if true then this context is used to wait for a response */
+        bool in_use;
+};
+
+/*
+ * Receive contexts for a particular DLN2 module (i2c, gpio, etc.). We use the
+ * handle header field to identify the module in dln2_dev.mod_rx_slots and then
+ * the echo header field to index the slots field and find the receive context
+ * for a particular request.
+ */
+struct dln2_mod_rx_slots {
+        /* RX slots bitmap */
+        DECLARE_BITMAP(bmap, DLN2_MAX_RX_SLOTS);
+
+        /* used to wait for a free RX slot */
+        wait_queue_head_t wq;
+
+        /* used to wait for an RX operation to complete */
+        struct dln2_rx_context slots[DLN2_MAX_RX_SLOTS];
+
+        /* avoid races between alloc/free_rx_slot and dln2_rx_transfer */
+        spinlock_t lock;
+};
+
+struct dln2_dev {
+        struct usb_device *usb_dev;
+        struct usb_interface *interface;
+        u8 ep_in;
+        u8 ep_out;
+
+        struct urb *rx_urb[DLN2_MAX_URBS];
+        void *rx_buf[DLN2_MAX_URBS];
+
+        struct dln2_mod_rx_slots mod_rx_slots[DLN2_HANDLES];
+
+        struct list_head event_cb_list;
+        spinlock_t event_cb_lock;
+
+        bool disconnect;
+        int active_transfers;
+        wait_queue_head_t disconnect_wq;
+        spinlock_t disconnect_lock;
+};
+
+struct dln2_event_cb_entry {
+        struct list_head list;
+        u16 id;
+        struct platform_device *pdev;
+        dln2_event_cb_t callback;
+};
+
+int dln2_register_event_cb(struct platform_device *pdev, u16 id,
+                           dln2_event_cb_t event_cb)
+{
+        struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
+        struct dln2_event_cb_entry *i, *entry;
+        unsigned long flags;
+        int ret = 0;
+
+        entry = kzalloc(sizeof(*entry), GFP_KERNEL);
+        if (!entry)
+                return -ENOMEM;
+
+        entry->id = id;
+        entry->callback = event_cb;
+        entry->pdev = pdev;
+
+        spin_lock_irqsave(&dln2->event_cb_lock, flags);
+
+        list_for_each_entry(i, &dln2->event_cb_list, list) {
+                if (i->id == id) {
+                        ret = -EBUSY;
+                        break;
+                }
+        }
+
+        if (!ret)
+                list_add_rcu(&entry->list, &dln2->event_cb_list);
+
+        spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
+
+        if (ret)
+                kfree(entry);
+
+        return ret;
+}
+EXPORT_SYMBOL(dln2_register_event_cb);
+
+void dln2_unregister_event_cb(struct platform_device *pdev, u16 id)
+{
+        struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
+        struct dln2_event_cb_entry *i;
+        unsigned long flags;
+        bool found = false;
+
+        spin_lock_irqsave(&dln2->event_cb_lock, flags);
+
+        list_for_each_entry(i, &dln2->event_cb_list, list) {
+                if (i->id == id) {
+                        list_del_rcu(&i->list);
+                        found = true;
+                        break;
+                }
+        }
+
+        spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
+
+        if (found) {
+                synchronize_rcu();
+                kfree(i);
+        }
+}
+EXPORT_SYMBOL(dln2_unregister_event_cb);
+
+/*
+ * Returns true if a valid transfer slot is found. In this case the URB must not
+ * be resubmitted immediately in dln2_rx as we need the data when dln2_transfer
+ * is woke up. It will be resubmitted there.
+ */
+static bool dln2_transfer_complete(struct dln2_dev *dln2, struct urb *urb,
+                                   u16 handle, u16 rx_slot)
+{
+        struct device *dev = &dln2->interface->dev;
+        struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
+        struct dln2_rx_context *rxc;
+        bool valid_slot = false;
+
+        if (rx_slot >= DLN2_MAX_RX_SLOTS)
+                goto out;
+
+        rxc = &rxs->slots[rx_slot];
+
+        /*
+         * No need to disable interrupts as this lock is not taken in interrupt
+         * context elsewhere in this driver. This function (or its callers) are
+         * also not exported to other modules.
+         */
+        spin_lock(&rxs->lock);
+        if (rxc->in_use && !rxc->urb) {
+                rxc->urb = urb;
+                complete(&rxc->done);
+                valid_slot = true;
+        }
+        spin_unlock(&rxs->lock);
+
+out:
+        if (!valid_slot)
+                dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot);
+
+        return valid_slot;
+}
+
+static void dln2_run_event_callbacks(struct dln2_dev *dln2, u16 id, u16 echo,
+                                     void *data, int len)
+{
+        struct dln2_event_cb_entry *i;
+
+        rcu_read_lock();
+
+        list_for_each_entry_rcu(i, &dln2->event_cb_list, list) {
+                if (i->id == id) {
+                        i->callback(i->pdev, echo, data, len);
+                        break;
+                }
+        }
+
+        rcu_read_unlock();
+}
+
+static void dln2_rx(struct urb *urb)
+{
+        struct dln2_dev *dln2 = urb->context;
+        struct dln2_header *hdr = urb->transfer_buffer;
+        struct device *dev = &dln2->interface->dev;
+        u16 id, echo, handle, size;
+        u8 *data;
+        int len;
+        int err;
+
+        switch (urb->status) {
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+        case -EPIPE:
+                /* this urb is terminated, clean up */
+                dev_dbg(dev, "urb shutting down with status %d\n", urb->status);
+                return;
+        default:
+                dev_dbg(dev, "nonzero urb status received %d\n", urb->status);
+                goto out;
+        }
+
+        if (urb->actual_length < sizeof(struct dln2_header)) {
+                dev_err(dev, "short response: %d\n", urb->actual_length);
+                goto out;
+        }
+
+        handle = le16_to_cpu(hdr->handle);
+        id = le16_to_cpu(hdr->id);
+        echo = le16_to_cpu(hdr->echo);
+        size = le16_to_cpu(hdr->size);
+
+        if (size != urb->actual_length) {
+                dev_err(dev, "size mismatch: handle %x cmd %x echo %x size %d actual %d\n",
+                        handle, id, echo, size, urb->actual_length);
+                goto out;
+        }
+
+        if (handle >= DLN2_HANDLES) {
+                dev_warn(dev, "invalid handle %d\n", handle);
+                goto out;
+        }
+
+        data = urb->transfer_buffer + sizeof(struct dln2_header);
+        len = urb->actual_length - sizeof(struct dln2_header);
+
+        if (handle == DLN2_HANDLE_EVENT) {
+                dln2_run_event_callbacks(dln2, id, echo, data, len);
+        } else {
+                /* URB will be re-submitted in _dln2_transfer (free_rx_slot) */
+                if (dln2_transfer_complete(dln2, urb, handle, echo))
+                        return;
+        }
+
+out:
+        err = usb_submit_urb(urb, GFP_ATOMIC);
+        if (err < 0)
+                dev_err(dev, "failed to resubmit RX URB: %d\n", err);
+}
+
+static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf,
+                           int *obuf_len, gfp_t gfp)
+{
+        int len;
+        void *buf;
+        struct dln2_header *hdr;
+
+        len = *obuf_len + sizeof(*hdr);
+        buf = kmalloc(len, gfp);
+        if (!buf)
+                return NULL;
+
+        hdr = (struct dln2_header *)buf;
+        hdr->id = cpu_to_le16(cmd);
+        hdr->size = cpu_to_le16(len);
+        hdr->echo = cpu_to_le16(echo);
+        hdr->handle = cpu_to_le16(handle);
+
+        memcpy(buf + sizeof(*hdr), obuf, *obuf_len);
+
+        *obuf_len = len;
+
+        return buf;
+}
+
+static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo,
+                          const void *obuf, int obuf_len)
+{
+        int ret = 0;
+        int len = obuf_len;
+        void *buf;
+        int actual;
+
+        buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        ret = usb_bulk_msg(dln2->usb_dev,
+                           usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out),
+                           buf, len, &actual, DLN2_USB_TIMEOUT);
+
+        kfree(buf);
+
+        return ret;
+}
+
+static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot)
+{
+        struct dln2_mod_rx_slots *rxs;
+        unsigned long flags;
+
+        if (dln2->disconnect) {
+                *slot = -ENODEV;
+                return true;
+        }
+
+        rxs = &dln2->mod_rx_slots[handle];
+
+        spin_lock_irqsave(&rxs->lock, flags);
+
+        *slot = find_first_zero_bit(rxs->bmap, DLN2_MAX_RX_SLOTS);
+
+        if (*slot < DLN2_MAX_RX_SLOTS) {
+                struct dln2_rx_context *rxc = &rxs->slots[*slot];
+
+                set_bit(*slot, rxs->bmap);
+                rxc->in_use = true;
+        }
+
+        spin_unlock_irqrestore(&rxs->lock, flags);
+
+        return *slot < DLN2_MAX_RX_SLOTS;
+}
+
+static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle)
+{
+        int ret;
+        int slot;
+
+        /*
+         * No need to timeout here, the wait is bounded by the timeout in
+         * _dln2_transfer.
+         */
+        ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq,
+                                       find_free_slot(dln2, handle, &slot));
+        if (ret < 0)
+                return ret;
+
+        return slot;
+}
+
+static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot)
+{
+        struct dln2_mod_rx_slots *rxs;
+        struct urb *urb = NULL;
+        unsigned long flags;
+        struct dln2_rx_context *rxc;
+
+        rxs = &dln2->mod_rx_slots[handle];
+
+        spin_lock_irqsave(&rxs->lock, flags);
+
+        clear_bit(slot, rxs->bmap);
+
+        rxc = &rxs->slots[slot];
+        rxc->in_use = false;
+        urb = rxc->urb;
+        rxc->urb = NULL;
+        reinit_completion(&rxc->done);
+
+        spin_unlock_irqrestore(&rxs->lock, flags);
+
+        if (urb) {
+                int err;
+                struct device *dev = &dln2->interface->dev;
+
+                err = usb_submit_urb(urb, GFP_KERNEL);
+                if (err < 0)
+                        dev_err(dev, "failed to resubmit RX URB: %d\n", err);
+        }
+
+        wake_up_interruptible(&rxs->wq);
+}
+
+static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd,
+                          const void *obuf, unsigned obuf_len,
+                          void *ibuf, unsigned *ibuf_len)
+{
+        int ret = 0;
+        int rx_slot;
+        struct dln2_response *rsp;
+        struct dln2_rx_context *rxc;
+        struct device *dev = &dln2->interface->dev;
+        const unsigned long timeout = DLN2_USB_TIMEOUT * HZ / 1000;
+        struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
+        int size;
+
+        spin_lock(&dln2->disconnect_lock);
+        if (!dln2->disconnect)
+                dln2->active_transfers++;
+        else
+                ret = -ENODEV;
+        spin_unlock(&dln2->disconnect_lock);
+
+        if (ret)
+                return ret;
+
+        rx_slot = alloc_rx_slot(dln2, handle);
+        if (rx_slot < 0) {
+                ret = rx_slot;
+                goto out_decr;
+        }
+
+        ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len);
+        if (ret < 0) {
+                dev_err(dev, "USB write failed: %d\n", ret);
+                goto out_free_rx_slot;
+        }
+
+        rxc = &rxs->slots[rx_slot];
+
+        ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout);
+        if (ret <= 0) {
+                if (!ret)
+                        ret = -ETIMEDOUT;
+                goto out_free_rx_slot;
+        } else {
+                ret = 0;
+        }
+
+        if (dln2->disconnect) {
+                ret = -ENODEV;
+                goto out_free_rx_slot;
+        }
+
+        /* if we got here we know that the response header has been checked */
+        rsp = rxc->urb->transfer_buffer;
+        size = le16_to_cpu(rsp->hdr.size);
+
+        if (size < sizeof(*rsp)) {
+                ret = -EPROTO;
+                goto out_free_rx_slot;
+        }
+
+        if (le16_to_cpu(rsp->result) > 0x80) {
+                dev_dbg(dev, "%d received response with error %d\n",
+                        handle, le16_to_cpu(rsp->result));
+                ret = -EREMOTEIO;
+                goto out_free_rx_slot;
+        }
+
+        if (!ibuf)
+                goto out_free_rx_slot;
+
+        if (*ibuf_len > size - sizeof(*rsp))
+                *ibuf_len = size - sizeof(*rsp);
+
+        memcpy(ibuf, rsp + 1, *ibuf_len);
+
+out_free_rx_slot:
+        free_rx_slot(dln2, handle, rx_slot);
+out_decr:
+        spin_lock(&dln2->disconnect_lock);
+        dln2->active_transfers--;
+        spin_unlock(&dln2->disconnect_lock);
+        if (dln2->disconnect)
+                wake_up(&dln2->disconnect_wq);
+
+        return ret;
+}
+
+int dln2_transfer(struct platform_device *pdev, u16 cmd,
+                  const void *obuf, unsigned obuf_len,
+                  void *ibuf, unsigned *ibuf_len)
+{
+        struct dln2_platform_data *dln2_pdata;
+        struct dln2_dev *dln2;
+        u16 handle;
+
+        dln2 = dev_get_drvdata(pdev->dev.parent);
+        dln2_pdata = dev_get_platdata(&pdev->dev);
+        handle = dln2_pdata->handle;
+
+        return _dln2_transfer(dln2, handle, cmd, obuf, obuf_len, ibuf,
+                              ibuf_len);
+}
+EXPORT_SYMBOL(dln2_transfer);
+
+static int dln2_check_hw(struct dln2_dev *dln2)
+{
+        int ret;
+        __le32 hw_type;
+        int len = sizeof(hw_type);
+
+        ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER,
+                             NULL, 0, &hw_type, &len);
+        if (ret < 0)
+                return ret;
+        if (len < sizeof(hw_type))
+                return -EREMOTEIO;
+
+        if (le32_to_cpu(hw_type) != DLN2_HW_ID) {
+                dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n",
+                        le32_to_cpu(hw_type));
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int dln2_print_serialno(struct dln2_dev *dln2)
+{
+        int ret;
+        __le32 serial_no;
+        int len = sizeof(serial_no);
+        struct device *dev = &dln2->interface->dev;
+
+        ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0,
+                             &serial_no, &len);
+        if (ret < 0)
+                return ret;
+        if (len < sizeof(serial_no))
+                return -EREMOTEIO;
+
+        dev_info(dev, "Diolan DLN2 serial %u\n", le32_to_cpu(serial_no));
+
+        return 0;
+}
+
+static int dln2_hw_init(struct dln2_dev *dln2)
+{
+        int ret;
+
+        ret = dln2_check_hw(dln2);
+        if (ret < 0)
+                return ret;
+
+        return dln2_print_serialno(dln2);
+}
+
+static void dln2_free_rx_urbs(struct dln2_dev *dln2)
+{
+        int i;
+
+        for (i = 0; i < DLN2_MAX_URBS; i++) {
+                usb_kill_urb(dln2->rx_urb[i]);
+                usb_free_urb(dln2->rx_urb[i]);
+                kfree(dln2->rx_buf[i]);
+        }
+}
+
+static void dln2_free(struct dln2_dev *dln2)
+{
+        dln2_free_rx_urbs(dln2);
+        usb_put_dev(dln2->usb_dev);
+        kfree(dln2);
+}
+
+static int dln2_setup_rx_urbs(struct dln2_dev *dln2,
+                              struct usb_host_interface *hostif)
+{
+        int i;
+        int ret;
+        const int rx_max_size = DLN2_RX_BUF_SIZE;
+        struct device *dev = &dln2->interface->dev;
+
+        for (i = 0; i < DLN2_MAX_URBS; i++) {
+                dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL);
+                if (!dln2->rx_buf[i])
+                        return -ENOMEM;
+
+                dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
+                if (!dln2->rx_urb[i])
+                        return -ENOMEM;
+
+                usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev,
+                                  usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in),
+                                  dln2->rx_buf[i], rx_max_size, dln2_rx, dln2);
+
+                ret = usb_submit_urb(dln2->rx_urb[i], GFP_KERNEL);
+                if (ret < 0) {
+                        dev_err(dev, "failed to submit RX URB: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static struct dln2_platform_data dln2_pdata_gpio = {
+        .handle = DLN2_HANDLE_GPIO,
+};
+
+/* Only one I2C port seems to be supported on current hardware */
+static struct dln2_platform_data dln2_pdata_i2c = {
+        .handle = DLN2_HANDLE_I2C,
+        .port = 0,
+};
+
+/* Only one SPI port supported */
+static struct dln2_platform_data dln2_pdata_spi = {
+        .handle = DLN2_HANDLE_SPI,
+        .port = 0,
+};
+
+static const struct mfd_cell dln2_devs[] = {
+        {
+                .name = "dln2-gpio",
+                .platform_data = &dln2_pdata_gpio,
+                .pdata_size = sizeof(struct dln2_platform_data),
+        },
+        {
+                .name = "dln2-i2c",
+                .platform_data = &dln2_pdata_i2c,
+                .pdata_size = sizeof(struct dln2_platform_data),
+        },
+        {
+                .name = "dln2-spi",
+                .platform_data = &dln2_pdata_spi,
+                .pdata_size = sizeof(struct dln2_platform_data),
+        },
+};
+
+static void dln2_disconnect(struct usb_interface *interface)
+{
+        struct dln2_dev *dln2 = usb_get_intfdata(interface);
+        int i, j;
+
+        /* don't allow starting new transfers */
+        spin_lock(&dln2->disconnect_lock);
+        dln2->disconnect = true;
+        spin_unlock(&dln2->disconnect_lock);
+
+        /* cancel in progress transfers */
+        for (i = 0; i < DLN2_HANDLES; i++) {
+                struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i];
+                unsigned long flags;
+
+                spin_lock_irqsave(&rxs->lock, flags);
+
+                /* cancel all response waiters */
+                for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) {
+                        struct dln2_rx_context *rxc = &rxs->slots[j];
+
+                        if (rxc->in_use)
+                                complete(&rxc->done);
+                }
+
+                spin_unlock_irqrestore(&rxs->lock, flags);
+        }
+
+        /* wait for transfers to end */
+        wait_event(dln2->disconnect_wq, !dln2->active_transfers);
+
+        mfd_remove_devices(&interface->dev);
+
+        dln2_free(dln2);
+}
+
+static int dln2_probe(struct usb_interface *interface,
+                      const struct usb_device_id *usb_id)
+{
+        struct usb_host_interface *hostif = interface->cur_altsetting;
+        struct device *dev = &interface->dev;
+        struct dln2_dev *dln2;
+        int ret;
+        int i, j;
+
+        if (hostif->desc.bInterfaceNumber != 0 ||
+            hostif->desc.bNumEndpoints < 2)
+                return -ENODEV;
+
+        dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL);
+        if (!dln2)
+                return -ENOMEM;
+
+        dln2->ep_out = hostif->endpoint[0].desc.bEndpointAddress;
+        dln2->ep_in = hostif->endpoint[1].desc.bEndpointAddress;
+        dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface));
+        dln2->interface = interface;
+        usb_set_intfdata(interface, dln2);
+        init_waitqueue_head(&dln2->disconnect_wq);
+
+        for (i = 0; i < DLN2_HANDLES; i++) {
+                init_waitqueue_head(&dln2->mod_rx_slots[i].wq);
+                spin_lock_init(&dln2->mod_rx_slots[i].lock);
+                for (j = 0; j < DLN2_MAX_RX_SLOTS; j++)
+                        init_completion(&dln2->mod_rx_slots[i].slots[j].done);
+        }
+
+        spin_lock_init(&dln2->event_cb_lock);
+        spin_lock_init(&dln2->disconnect_lock);
+        INIT_LIST_HEAD(&dln2->event_cb_list);
+
+        ret = dln2_setup_rx_urbs(dln2, hostif);
+        if (ret)
+                goto out_cleanup;
+
+        ret = dln2_hw_init(dln2);
+        if (ret < 0) {
+                dev_err(dev, "failed to initialize hardware\n");
+                goto out_cleanup;
+        }
+
+        ret = mfd_add_hotplug_devices(dev, dln2_devs, ARRAY_SIZE(dln2_devs));
+        if (ret != 0) {
+                dev_err(dev, "failed to add mfd devices to core\n");
+                goto out_cleanup;
+        }
+
+        return 0;
+
+out_cleanup:
+        dln2_free(dln2);
+
+        return ret;
+}
+
+static const struct usb_device_id dln2_table[] = {
+        { USB_DEVICE(0xa257, 0x2013) },
+        { }
+};
+
+MODULE_DEVICE_TABLE(usb, dln2_table);
+
+static struct usb_driver dln2_driver = {
+        .name = "dln2",
+        .probe = dln2_probe,
+        .disconnect = dln2_disconnect,
+        .id_table = dln2_table,
+};
+
+module_usb_driver(dln2_driver);
+
+MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>");
+MODULE_DESCRIPTION("Core driver for the Diolan DLN2 interface adapter");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/intel_soc_pmic_crc.c b/drivers/mfd/intel_soc_pmic_crc.c
index 7107cab832e6..c85e2ecb868a 100644
--- a/drivers/mfd/intel_soc_pmic_crc.c
+++ b/drivers/mfd/intel_soc_pmic_crc.c
@@ -106,6 +106,9 @@ static struct mfd_cell crystal_cove_dev[] = {
                 .num_resources = ARRAY_SIZE(gpio_resources),
                 .resources = gpio_resources,
         },
+        {
+                .name = "crystal_cove_pmic",
+        },
 };
 
 static struct regmap_config crystal_cove_regmap_config = {
diff --git a/drivers/mfd/lpc_sch.c b/drivers/mfd/lpc_sch.c
index c980da479a35..5c38df35a84d 100644
--- a/drivers/mfd/lpc_sch.c
+++ b/drivers/mfd/lpc_sch.c
@@ -193,11 +193,7 @@ static int lpc_sch_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 return -ENODEV;
         }
 
-        ret = mfd_add_devices(&dev->dev, 0, lpc_sch_cells, cells, NULL, 0, NULL);
-        if (ret)
-                mfd_remove_devices(&dev->dev);
-
-        return ret;
+        return mfd_add_devices(&dev->dev, 0, lpc_sch_cells, cells, NULL, 0, NULL);
 }
 
 static void lpc_sch_remove(struct pci_dev *dev)
diff --git a/drivers/mfd/max14577.c b/drivers/mfd/max14577.c
index de96b7fb1f6d..3bf8def82f1e 100644
--- a/drivers/mfd/max14577.c
+++ b/drivers/mfd/max14577.c
@@ -1,7 +1,7 @@
 /*
  * max14577.c - mfd core driver for the Maxim 14577/77836
  *
- * Copyright (C) 2014 Samsung Electrnoics
+ * Copyright (C) 2014 Samsung Electronics
  * Chanwoo Choi <cw00.choi@samsung.com>
  * Krzysztof Kozlowski <k.kozlowski@samsung.com>
  *
diff --git a/drivers/mfd/max77693.c b/drivers/mfd/max77693.c
index 711773e8e64b..a159593e27a0 100644
--- a/drivers/mfd/max77693.c
+++ b/drivers/mfd/max77693.c
@@ -43,9 +43,15 @@
 
 static const struct mfd_cell max77693_devs[] = {
         { .name = "max77693-pmic", },
-        { .name = "max77693-charger", },
+        {
+                .name = "max77693-charger",
+                .of_compatible = "maxim,max77693-charger",
+        },
         { .name = "max77693-muic", },
-        { .name = "max77693-haptic", },
+        {
+                .name = "max77693-haptic",
+                .of_compatible = "maxim,max77693-haptic",
+        },
         {
                 .name = "max77693-flash",
                 .of_compatible = "maxim,max77693-flash",
@@ -147,6 +153,12 @@ static const struct regmap_irq_chip max77693_muic_irq_chip = {
         .num_irqs               = ARRAY_SIZE(max77693_muic_irqs),
 };
 
+static const struct regmap_config max77693_regmap_haptic_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = MAX77693_HAPTIC_REG_END,
+};
+
 static int max77693_i2c_probe(struct i2c_client *i2c,
                               const struct i2c_device_id *id)
 {
@@ -196,6 +208,15 @@ static int max77693_i2c_probe(struct i2c_client *i2c,
         }
         i2c_set_clientdata(max77693->haptic, max77693);
 
+        max77693->regmap_haptic = devm_regmap_init_i2c(max77693->haptic,
+                                        &max77693_regmap_haptic_config);
+        if (IS_ERR(max77693->regmap_haptic)) {
+                ret = PTR_ERR(max77693->regmap_haptic);
+                dev_err(max77693->dev,
+                        "failed to initialize haptic register map: %d\n", ret);
+                goto err_regmap;
+        }
+
         /*
          * Initialize register map for MUIC device because use regmap-muic
          * instance of MUIC device when irq of max77693 is initialized
@@ -207,7 +228,7 @@ static int max77693_i2c_probe(struct i2c_client *i2c,
                 ret = PTR_ERR(max77693->regmap_muic);
                 dev_err(max77693->dev,
                         "failed to allocate register map: %d\n", ret);
-                goto err_regmap_muic;
+                goto err_regmap;
         }
 
         ret = regmap_add_irq_chip(max77693->regmap, max77693->irq,
@@ -217,7 +238,7 @@ static int max77693_i2c_probe(struct i2c_client *i2c,
                                 &max77693->irq_data_led);
         if (ret) {
                 dev_err(max77693->dev, "failed to add irq chip: %d\n", ret);
-                goto err_regmap_muic;
+                goto err_regmap;
         }
 
         ret = regmap_add_irq_chip(max77693->regmap, max77693->irq,
@@ -280,7 +301,7 @@ err_irq_charger:
         regmap_del_irq_chip(max77693->irq, max77693->irq_data_topsys);
 err_irq_topsys:
         regmap_del_irq_chip(max77693->irq, max77693->irq_data_led);
-err_regmap_muic:
+err_regmap:
         i2c_unregister_device(max77693->haptic);
 err_i2c_haptic:
         i2c_unregister_device(max77693->muic);
diff --git a/drivers/mfd/mfd-core.c b/drivers/mfd/mfd-core.c
index f3338fe9d069..2a87f69be53d 100644
--- a/drivers/mfd/mfd-core.c
+++ b/drivers/mfd/mfd-core.c
@@ -125,9 +125,15 @@ static int mfd_add_device(struct device *parent, int id,
         struct platform_device *pdev;
         struct device_node *np = NULL;
         int ret = -ENOMEM;
+        int platform_id;
         int r;
 
-        pdev = platform_device_alloc(cell->name, id + cell->id);
+        if (id < 0)
+                platform_id = id;
+        else
+                platform_id = id + cell->id;
+
+        pdev = platform_device_alloc(cell->name, platform_id);
         if (!pdev)
                 goto fail_alloc;
 
diff --git a/drivers/mfd/rts5227.c b/drivers/mfd/rts5227.c
index 9c8eec80ceed..32407404d838 100644
--- a/drivers/mfd/rts5227.c
+++ b/drivers/mfd/rts5227.c
@@ -130,6 +130,12 @@ static int rts5227_extra_init_hw(struct rtsx_pcr *pcr)
 
 static int rts5227_optimize_phy(struct rtsx_pcr *pcr)
 {
+        int err;
+
+        err = rtsx_gops_pm_reset(pcr);
+        if (err < 0)
+                return err;
+
         /* Optimize RX sensitivity */
         return rtsx_pci_write_phy_register(pcr, 0x00, 0xBA42);
 }
diff --git a/drivers/mfd/rts5249.c b/drivers/mfd/rts5249.c
index 573de7bfcced..cf425cc959d5 100644
--- a/drivers/mfd/rts5249.c
+++ b/drivers/mfd/rts5249.c
@@ -130,6 +130,10 @@ static int rts5249_optimize_phy(struct rtsx_pcr *pcr)
 {
         int err;
 
+        err = rtsx_gops_pm_reset(pcr);
+        if (err < 0)
+                return err;
+
         err = rtsx_pci_write_phy_register(pcr, PHY_REG_REV,
                         PHY_REG_REV_RESV | PHY_REG_REV_RXIDLE_LATCHED |
                         PHY_REG_REV_P1_EN | PHY_REG_REV_RXIDLE_EN |
diff --git a/drivers/mfd/rtsx_gops.c b/drivers/mfd/rtsx_gops.c
new file mode 100644
index 000000000000..b1a98c678593
--- /dev/null
+++ b/drivers/mfd/rtsx_gops.c
@@ -0,0 +1,37 @@
+/* Driver for Realtek PCI-Express card reader
+ *
+ * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   Micky Ching <micky_ching@realsil.com.cn>
+ */
+
+#include <linux/mfd/rtsx_pci.h>
+#include "rtsx_pcr.h"
+
+int rtsx_gops_pm_reset(struct rtsx_pcr *pcr)
+{
+        int err;
+
+        /* init aspm */
+        rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, 0xFF, 0x00);
+        err = rtsx_pci_update_cfg_byte(pcr, LCTLR, ~LCTLR_ASPM_CTL_MASK, 0x00);
+        if (err < 0)
+                return err;
+
+        /* reset PM_CTRL3 before send buffer cmd */
+        return rtsx_pci_write_register(pcr, PM_CTRL3, D3_DELINK_MODE_EN, 0x00);
+}
diff --git a/drivers/mfd/rtsx_pcr.h b/drivers/mfd/rtsx_pcr.h
index 07e4c2ebf05a..fe2bbb67defc 100644
--- a/drivers/mfd/rtsx_pcr.h
+++ b/drivers/mfd/rtsx_pcr.h
@@ -72,4 +72,7 @@ do {									\
         pcr->ms_pull_ctl_disable_tbl = __device##_ms_pull_ctl_disable_tbl; \
 } while (0)
 
+/* generic operations */
+int rtsx_gops_pm_reset(struct rtsx_pcr *pcr);
+
 #endif
diff --git a/drivers/mfd/rtsx_usb.c b/drivers/mfd/rtsx_usb.c
index 9cf98d142d9a..dbdd0faeb6ce 100644
--- a/drivers/mfd/rtsx_usb.c
+++ b/drivers/mfd/rtsx_usb.c
@@ -647,8 +647,8 @@ static int rtsx_usb_probe(struct usb_interface *intf,
         /* initialize USB SG transfer timer */
         setup_timer(&ucr->sg_timer, rtsx_usb_sg_timed_out, (unsigned long) ucr);
 
-        ret = mfd_add_devices(&intf->dev, usb_dev->devnum, rtsx_usb_cells,
-                        ARRAY_SIZE(rtsx_usb_cells), NULL, 0, NULL);
+        ret = mfd_add_hotplug_devices(&intf->dev, rtsx_usb_cells,
+                                      ARRAY_SIZE(rtsx_usb_cells));
         if (ret)
                 goto out_init_fail;
 
diff --git a/drivers/mfd/sec-core.c b/drivers/mfd/sec-core.c
index dba7e2b6f8e9..0a7bc43db4e4 100644
--- a/drivers/mfd/sec-core.c
+++ b/drivers/mfd/sec-core.c
@@ -27,11 +27,11 @@
 #include <linux/mfd/samsung/irq.h>
 #include <linux/mfd/samsung/s2mpa01.h>
 #include <linux/mfd/samsung/s2mps11.h>
+#include <linux/mfd/samsung/s2mps13.h>
 #include <linux/mfd/samsung/s2mps14.h>
 #include <linux/mfd/samsung/s2mpu02.h>
 #include <linux/mfd/samsung/s5m8763.h>
 #include <linux/mfd/samsung/s5m8767.h>
-#include <linux/regulator/machine.h>
 #include <linux/regmap.h>
 
 static const struct mfd_cell s5m8751_devs[] = {
@@ -74,6 +74,15 @@ static const struct mfd_cell s2mps11_devs[] = {
         }
 };
 
+static const struct mfd_cell s2mps13_devs[] = {
+        { .name = "s2mps13-pmic", },
+        { .name = "s2mps13-rtc", },
+        {
+                .name = "s2mps13-clk",
+                .of_compatible = "samsung,s2mps13-clk",
+        },
+};
+
 static const struct mfd_cell s2mps14_devs[] = {
         {
                 .name = "s2mps14-pmic",
@@ -108,6 +117,9 @@ static const struct of_device_id sec_dt_match[] = {
                 .compatible = "samsung,s2mps11-pmic",
                 .data = (void *)S2MPS11X,
         }, {
+                .compatible = "samsung,s2mps13-pmic",
+                .data = (void *)S2MPS13X,
+        }, {
                 .compatible = "samsung,s2mps14-pmic",
                 .data = (void *)S2MPS14X,
         }, {
@@ -194,6 +206,15 @@ static const struct regmap_config s2mps11_regmap_config = {
         .cache_type = REGCACHE_FLAT,
 };
 
+static const struct regmap_config s2mps13_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+
+        .max_register = S2MPS13_REG_LDODSCH5,
+        .volatile_reg = s2mps11_volatile,
+        .cache_type = REGCACHE_FLAT,
+};
+
 static const struct regmap_config s2mps14_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
@@ -325,6 +346,9 @@ static int sec_pmic_probe(struct i2c_client *i2c,
         case S2MPS11X:
                 regmap = &s2mps11_regmap_config;
                 break;
+        case S2MPS13X:
+                regmap = &s2mps13_regmap_config;
+                break;
         case S2MPS14X:
                 regmap = &s2mps14_regmap_config;
                 break;
@@ -378,6 +402,10 @@ static int sec_pmic_probe(struct i2c_client *i2c,
                 sec_devs = s2mps11_devs;
                 num_sec_devs = ARRAY_SIZE(s2mps11_devs);
                 break;
+        case S2MPS13X:
+                sec_devs = s2mps13_devs;
+                num_sec_devs = ARRAY_SIZE(s2mps13_devs);
+                break;
         case S2MPS14X:
                 sec_devs = s2mps14_devs;
                 num_sec_devs = ARRAY_SIZE(s2mps14_devs);
@@ -432,15 +460,6 @@ static int sec_pmic_suspend(struct device *dev)
          */
         disable_irq(sec_pmic->irq);
 
-        switch (sec_pmic->device_type) {
-        case S2MPS14X:
-        case S2MPU02:
-                regulator_suspend_prepare(PM_SUSPEND_MEM);
-                break;
-        default:
-                break;
-        }
-
         return 0;
 }
 
diff --git a/drivers/mfd/sec-irq.c b/drivers/mfd/sec-irq.c
index f9a57869e3ec..ba86a918c2da 100644
--- a/drivers/mfd/sec-irq.c
+++ b/drivers/mfd/sec-irq.c
@@ -389,14 +389,22 @@ static const struct regmap_irq_chip s2mps11_irq_chip = {
         .ack_base = S2MPS11_REG_INT1,
 };
 
+#define S2MPS1X_IRQ_CHIP_COMMON_DATA            \
+        .irqs = s2mps14_irqs,                   \
+        .num_irqs = ARRAY_SIZE(s2mps14_irqs),   \
+        .num_regs = 3,                          \
+        .status_base = S2MPS14_REG_INT1,        \
+        .mask_base = S2MPS14_REG_INT1M,         \
+        .ack_base = S2MPS14_REG_INT1            \
+
+static const struct regmap_irq_chip s2mps13_irq_chip = {
+        .name = "s2mps13",
+        S2MPS1X_IRQ_CHIP_COMMON_DATA,
+};
+
 static const struct regmap_irq_chip s2mps14_irq_chip = {
         .name = "s2mps14",
-        .irqs = s2mps14_irqs,
-        .num_irqs = ARRAY_SIZE(s2mps14_irqs),
-        .num_regs = 3,
-        .status_base = S2MPS14_REG_INT1,
-        .mask_base = S2MPS14_REG_INT1M,
-        .ack_base = S2MPS14_REG_INT1,
+        S2MPS1X_IRQ_CHIP_COMMON_DATA,
 };
 
 static const struct regmap_irq_chip s2mpu02_irq_chip = {
@@ -452,6 +460,9 @@ int sec_irq_init(struct sec_pmic_dev *sec_pmic)
         case S2MPS11X:
                 sec_irq_chip = &s2mps11_irq_chip;
                 break;
+        case S2MPS13X:
+                sec_irq_chip = &s2mps13_irq_chip;
+                break;
         case S2MPS14X:
                 sec_irq_chip = &s2mps14_irq_chip;
                 break;
diff --git a/drivers/mfd/syscon.c b/drivers/mfd/syscon.c
index ca15878ce5c0..72373b113885 100644
--- a/drivers/mfd/syscon.c
+++ b/drivers/mfd/syscon.c
@@ -15,6 +15,7 @@
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/module.h>
+#include <linux/list.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/of_platform.h>
@@ -22,31 +23,94 @@
 #include <linux/platform_device.h>
 #include <linux/regmap.h>
 #include <linux/mfd/syscon.h>
+#include <linux/slab.h>
 
 static struct platform_driver syscon_driver;
 
+static DEFINE_SPINLOCK(syscon_list_slock);
+static LIST_HEAD(syscon_list);
+
 struct syscon {
+        struct device_node *np;
         struct regmap *regmap;
+        struct list_head list;
+};
+
+static struct regmap_config syscon_regmap_config = {
+        .reg_bits = 32,
+        .val_bits = 32,
+        .reg_stride = 4,
 };
 
-static int syscon_match_node(struct device *dev, void *data)
+static struct syscon *of_syscon_register(struct device_node *np)
 {
-        struct device_node *dn = data;
+        struct syscon *syscon;
+        struct regmap *regmap;
+        void __iomem *base;
+        int ret;
+        struct regmap_config syscon_config = syscon_regmap_config;
+
+        if (!of_device_is_compatible(np, "syscon"))
+                return ERR_PTR(-EINVAL);
+
+        syscon = kzalloc(sizeof(*syscon), GFP_KERNEL);
+        if (!syscon)
+                return ERR_PTR(-ENOMEM);
+
+        base = of_iomap(np, 0);
+        if (!base) {
+                ret = -ENOMEM;
+                goto err_map;
+        }
+
+        /* Parse the device's DT node for an endianness specification */
+        if (of_property_read_bool(np, "big-endian"))
+                syscon_config.val_format_endian = REGMAP_ENDIAN_BIG;
+         else if (of_property_read_bool(np, "little-endian"))
+                syscon_config.val_format_endian = REGMAP_ENDIAN_LITTLE;
+
+        regmap = regmap_init_mmio(NULL, base, &syscon_config);
+        if (IS_ERR(regmap)) {
+                pr_err("regmap init failed\n");
+                ret = PTR_ERR(regmap);
+                goto err_regmap;
+        }
+
+        syscon->regmap = regmap;
+        syscon->np = np;
+
+        spin_lock(&syscon_list_slock);
+        list_add_tail(&syscon->list, &syscon_list);
+        spin_unlock(&syscon_list_slock);
 
-        return (dev->of_node == dn) ? 1 : 0;
+        return syscon;
+
+err_regmap:
+        iounmap(base);
+err_map:
+        kfree(syscon);
+        return ERR_PTR(ret);
 }
 
 struct regmap *syscon_node_to_regmap(struct device_node *np)
 {
-        struct syscon *syscon;
-        struct device *dev;
+        struct syscon *entry, *syscon = NULL;
 
-        dev = driver_find_device(&syscon_driver.driver, NULL, np,
-                                 syscon_match_node);
-        if (!dev)
-                return ERR_PTR(-EPROBE_DEFER);
+        spin_lock(&syscon_list_slock);
 
-        syscon = dev_get_drvdata(dev);
+        list_for_each_entry(entry, &syscon_list, list)
+                if (entry->np == np) {
+                        syscon = entry;
+                        break;
+                }
+
+        spin_unlock(&syscon_list_slock);
+
+        if (!syscon)
+                syscon = of_syscon_register(np);
+
+        if (IS_ERR(syscon))
+                return ERR_CAST(syscon);
 
         return syscon->regmap;
 }
@@ -110,17 +174,6 @@ struct regmap *syscon_regmap_lookup_by_phandle(struct device_node *np,
 }
 EXPORT_SYMBOL_GPL(syscon_regmap_lookup_by_phandle);
 
-static const struct of_device_id of_syscon_match[] = {
-        { .compatible = "syscon", },
-        { },
-};
-
-static struct regmap_config syscon_regmap_config = {
-        .reg_bits = 32,
-        .val_bits = 32,
-        .reg_stride = 4,
-};
-
 static int syscon_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
@@ -167,7 +220,6 @@ static struct platform_driver syscon_driver = {
         .driver = {
                 .name = "syscon",
                 .owner = THIS_MODULE,
-                .of_match_table = of_syscon_match,
         },
         .probe          = syscon_probe,
         .id_table       = syscon_ids,
diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
index 9e04a7485981..439d905bb219 100644
--- a/drivers/mfd/t7l66xb.c
+++ b/drivers/mfd/t7l66xb.c
@@ -87,7 +87,7 @@ static int t7l66xb_mmc_enable(struct platform_device *mmc)
         unsigned long flags;
         u8 dev_ctl;
 
-        clk_enable(t7l66xb->clk32k);
+        clk_prepare_enable(t7l66xb->clk32k);
 
         spin_lock_irqsave(&t7l66xb->lock, flags);
 
@@ -118,7 +118,7 @@ static int t7l66xb_mmc_disable(struct platform_device *mmc)
 
         spin_unlock_irqrestore(&t7l66xb->lock, flags);
 
-        clk_disable(t7l66xb->clk32k);
+        clk_disable_unprepare(t7l66xb->clk32k);
 
         return 0;
 }
@@ -285,7 +285,7 @@ static int t7l66xb_suspend(struct platform_device *dev, pm_message_t state)
 
         if (pdata && pdata->suspend)
                 pdata->suspend(dev);
-        clk_disable(t7l66xb->clk48m);
+        clk_disable_unprepare(t7l66xb->clk48m);
 
         return 0;
 }
@@ -295,7 +295,7 @@ static int t7l66xb_resume(struct platform_device *dev)
         struct t7l66xb *t7l66xb = platform_get_drvdata(dev);
         struct t7l66xb_platform_data *pdata = dev_get_platdata(&dev->dev);
 
-        clk_enable(t7l66xb->clk48m);
+        clk_prepare_enable(t7l66xb->clk48m);
         if (pdata && pdata->resume)
                 pdata->resume(dev);
 
@@ -369,7 +369,7 @@ static int t7l66xb_probe(struct platform_device *dev)
                 goto err_ioremap;
         }
 
-        clk_enable(t7l66xb->clk48m);
+        clk_prepare_enable(t7l66xb->clk48m);
 
         if (pdata && pdata->enable)
                 pdata->enable(dev);
@@ -414,9 +414,9 @@ static int t7l66xb_remove(struct platform_device *dev)
         int ret;
 
         ret = pdata->disable(dev);
-        clk_disable(t7l66xb->clk48m);
+        clk_disable_unprepare(t7l66xb->clk48m);
         clk_put(t7l66xb->clk48m);
-        clk_disable(t7l66xb->clk32k);
+        clk_disable_unprepare(t7l66xb->clk32k);
         clk_put(t7l66xb->clk32k);
         t7l66xb_detach_irq(dev);
         iounmap(t7l66xb->scr);
diff --git a/drivers/mfd/tc3589x.c b/drivers/mfd/tc3589x.c
index 0072e668c208..aacb3720065c 100644
--- a/drivers/mfd/tc3589x.c
+++ b/drivers/mfd/tc3589x.c
@@ -241,10 +241,8 @@ static struct irq_domain_ops tc3589x_irq_ops = {
 
 static int tc3589x_irq_init(struct tc3589x *tc3589x, struct device_node *np)
 {
-        int base = tc3589x->irq_base;
-
         tc3589x->domain = irq_domain_add_simple(
-                np, TC3589x_NR_INTERNAL_IRQS, base,
+                np, TC3589x_NR_INTERNAL_IRQS, 0,
                 &tc3589x_irq_ops, tc3589x);
 
         if (!tc3589x->domain) {
@@ -298,7 +296,7 @@ static int tc3589x_device_init(struct tc3589x *tc3589x)
         if (blocks & TC3589x_BLOCK_GPIO) {
                 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_gpio,
                                       ARRAY_SIZE(tc3589x_dev_gpio), NULL,
-                                      tc3589x->irq_base, tc3589x->domain);
+                                      0, tc3589x->domain);
                 if (ret) {
                         dev_err(tc3589x->dev, "failed to add gpio child\n");
                         return ret;
@@ -309,7 +307,7 @@ static int tc3589x_device_init(struct tc3589x *tc3589x)
         if (blocks & TC3589x_BLOCK_KEYPAD) {
                 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_keypad,
                                       ARRAY_SIZE(tc3589x_dev_keypad), NULL,
-                                      tc3589x->irq_base, tc3589x->domain);
+                                      0, tc3589x->domain);
                 if (ret) {
                         dev_err(tc3589x->dev, "failed to keypad child\n");
                         return ret;
@@ -404,7 +402,6 @@ static int tc3589x_probe(struct i2c_client *i2c,
         tc3589x->dev = &i2c->dev;
         tc3589x->i2c = i2c;
         tc3589x->pdata = pdata;
-        tc3589x->irq_base = pdata->irq_base;
 
         switch (version) {
         case TC3589X_TC35893:
diff --git a/drivers/mfd/tc6387xb.c b/drivers/mfd/tc6387xb.c
index e71f88000ae5..85fab3729102 100644
--- a/drivers/mfd/tc6387xb.c
+++ b/drivers/mfd/tc6387xb.c
@@ -52,7 +52,7 @@ static int tc6387xb_suspend(struct platform_device *dev, pm_message_t state)
 
         if (pdata && pdata->suspend)
                 pdata->suspend(dev);
-        clk_disable(tc6387xb->clk32k);
+        clk_disable_unprepare(tc6387xb->clk32k);
 
         return 0;
 }
@@ -62,7 +62,7 @@ static int tc6387xb_resume(struct platform_device *dev)
         struct tc6387xb *tc6387xb = platform_get_drvdata(dev);
         struct tc6387xb_platform_data *pdata = dev_get_platdata(&dev->dev);
 
-        clk_enable(tc6387xb->clk32k);
+        clk_prepare_enable(tc6387xb->clk32k);
         if (pdata && pdata->resume)
                 pdata->resume(dev);
 
@@ -100,7 +100,7 @@ static int tc6387xb_mmc_enable(struct platform_device *mmc)
         struct platform_device *dev      = to_platform_device(mmc->dev.parent);
         struct tc6387xb *tc6387xb = platform_get_drvdata(dev);
 
-        clk_enable(tc6387xb->clk32k);
+        clk_prepare_enable(tc6387xb->clk32k);
 
         tmio_core_mmc_enable(tc6387xb->scr + 0x200, 0,
                 tc6387xb_mmc_resources[0].start & 0xfffe);
@@ -113,7 +113,7 @@ static int tc6387xb_mmc_disable(struct platform_device *mmc)
         struct platform_device *dev      = to_platform_device(mmc->dev.parent);
         struct tc6387xb *tc6387xb = platform_get_drvdata(dev);
 
-        clk_disable(tc6387xb->clk32k);
+        clk_disable_unprepare(tc6387xb->clk32k);
 
         return 0;
 }
@@ -214,7 +214,7 @@ static int tc6387xb_remove(struct platform_device *dev)
         mfd_remove_devices(&dev->dev);
         iounmap(tc6387xb->scr);
         release_resource(&tc6387xb->rscr);
-        clk_disable(tc6387xb->clk32k);
+        clk_disable_unprepare(tc6387xb->clk32k);
         clk_put(tc6387xb->clk32k);
         kfree(tc6387xb);
 
diff --git a/drivers/mfd/tc6393xb.c b/drivers/mfd/tc6393xb.c
index 4fac16bcd732..d35f11fbeab7 100644
--- a/drivers/mfd/tc6393xb.c
+++ b/drivers/mfd/tc6393xb.c
@@ -263,6 +263,17 @@ static int tc6393xb_ohci_disable(struct platform_device *dev)
         return 0;
 }
 
+static int tc6393xb_ohci_suspend(struct platform_device *dev)
+{
+        struct tc6393xb_platform_data *tcpd = dev_get_platdata(dev->dev.parent);
+
+        /* We can't properly store/restore OHCI state, so fail here */
+        if (tcpd->resume_restore)
+                return -EBUSY;
+
+        return tc6393xb_ohci_disable(dev);
+}
+
 static int tc6393xb_fb_enable(struct platform_device *dev)
 {
         struct tc6393xb *tc6393xb = dev_get_drvdata(dev->dev.parent);
@@ -403,7 +414,7 @@ static struct mfd_cell tc6393xb_cells[] = {
                 .num_resources = ARRAY_SIZE(tc6393xb_ohci_resources),
                 .resources = tc6393xb_ohci_resources,
                 .enable = tc6393xb_ohci_enable,
-                .suspend = tc6393xb_ohci_disable,
+                .suspend = tc6393xb_ohci_suspend,
                 .resume = tc6393xb_ohci_enable,
                 .disable = tc6393xb_ohci_disable,
         },
@@ -654,7 +665,7 @@ static int tc6393xb_probe(struct platform_device *dev)
                 goto err_ioremap;
         }
 
-        ret = clk_enable(tc6393xb->clk);
+        ret = clk_prepare_enable(tc6393xb->clk);
         if (ret)
                 goto err_clk_enable;
 
@@ -717,7 +728,7 @@ err_gpio_add:
                 gpiochip_remove(&tc6393xb->gpio);
         tcpd->disable(dev);
 err_enable:
-        clk_disable(tc6393xb->clk);
+        clk_disable_unprepare(tc6393xb->clk);
 err_clk_enable:
         iounmap(tc6393xb->scr);
 err_ioremap:
@@ -748,7 +759,7 @@ static int tc6393xb_remove(struct platform_device *dev)
                 gpiochip_remove(&tc6393xb->gpio);
 
         ret = tcpd->disable(dev);
-        clk_disable(tc6393xb->clk);
+        clk_disable_unprepare(tc6393xb->clk);
         iounmap(tc6393xb->scr);
         release_resource(&tc6393xb->rscr);
         clk_put(tc6393xb->clk);
@@ -776,7 +787,7 @@ static int tc6393xb_suspend(struct platform_device *dev, pm_message_t state)
                         ioread8(tc6393xb->scr + SCR_GPI_BCR(i));
         }
         ret = tcpd->suspend(dev);
-        clk_disable(tc6393xb->clk);
+        clk_disable_unprepare(tc6393xb->clk);
 
         return ret;
 }
@@ -788,7 +799,7 @@ static int tc6393xb_resume(struct platform_device *dev)
         int ret;
         int i;
 
-        clk_enable(tc6393xb->clk);
+        clk_prepare_enable(tc6393xb->clk);
 
         ret = tcpd->resume(dev);
         if (ret)
diff --git a/drivers/mfd/tps65090.c b/drivers/mfd/tps65090.c
index 1c3e6e2efe41..14b62e11aff4 100644
--- a/drivers/mfd/tps65090.c
+++ b/drivers/mfd/tps65090.c
@@ -76,58 +76,58 @@ static struct mfd_cell tps65090s[] = {
 static const struct regmap_irq tps65090_irqs[] = {
         /* INT1 IRQs*/
         [TPS65090_IRQ_VAC_STATUS_CHANGE] = {
-                        .mask = TPS65090_INT1_MASK_VAC_STATUS_CHANGE,
+                .mask = TPS65090_INT1_MASK_VAC_STATUS_CHANGE,
         },
         [TPS65090_IRQ_VSYS_STATUS_CHANGE] = {
-                        .mask = TPS65090_INT1_MASK_VSYS_STATUS_CHANGE,
+                .mask = TPS65090_INT1_MASK_VSYS_STATUS_CHANGE,
         },
         [TPS65090_IRQ_BAT_STATUS_CHANGE] = {
-                        .mask = TPS65090_INT1_MASK_BAT_STATUS_CHANGE,
+                .mask = TPS65090_INT1_MASK_BAT_STATUS_CHANGE,
         },
         [TPS65090_IRQ_CHARGING_STATUS_CHANGE] = {
-                        .mask = TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE,
+                .mask = TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE,
         },
         [TPS65090_IRQ_CHARGING_COMPLETE] = {
-                        .mask = TPS65090_INT1_MASK_CHARGING_COMPLETE,
+                .mask = TPS65090_INT1_MASK_CHARGING_COMPLETE,
         },
         [TPS65090_IRQ_OVERLOAD_DCDC1] = {
-                        .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC1,
+                .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC1,
         },
         [TPS65090_IRQ_OVERLOAD_DCDC2] = {
-                        .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC2,
+                .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC2,
         },
         /* INT2 IRQs*/
         [TPS65090_IRQ_OVERLOAD_DCDC3] = {
-                        .reg_offset = 1,
-                        .mask = TPS65090_INT2_MASK_OVERLOAD_DCDC3,
+                .reg_offset = 1,
+                .mask = TPS65090_INT2_MASK_OVERLOAD_DCDC3,
         },
         [TPS65090_IRQ_OVERLOAD_FET1] = {
-                        .reg_offset = 1,
-                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET1,
+                .reg_offset = 1,
+                .mask = TPS65090_INT2_MASK_OVERLOAD_FET1,
         },
         [TPS65090_IRQ_OVERLOAD_FET2] = {
-                        .reg_offset = 1,
-                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET2,
+                .reg_offset = 1,
+                .mask = TPS65090_INT2_MASK_OVERLOAD_FET2,
         },
         [TPS65090_IRQ_OVERLOAD_FET3] = {
-                        .reg_offset = 1,
-                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET3,
+                .reg_offset = 1,
+                .mask = TPS65090_INT2_MASK_OVERLOAD_FET3,
         },
         [TPS65090_IRQ_OVERLOAD_FET4] = {
-                        .reg_offset = 1,
-                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET4,
+                .reg_offset = 1,
+                .mask = TPS65090_INT2_MASK_OVERLOAD_FET4,
         },
         [TPS65090_IRQ_OVERLOAD_FET5] = {
-                        .reg_offset = 1,
-                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET5,
+                .reg_offset = 1,
+                .mask = TPS65090_INT2_MASK_OVERLOAD_FET5,
         },
         [TPS65090_IRQ_OVERLOAD_FET6] = {
-                        .reg_offset = 1,
-                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET6,
+                .reg_offset = 1,
+                .mask = TPS65090_INT2_MASK_OVERLOAD_FET6,
         },
         [TPS65090_IRQ_OVERLOAD_FET7] = {
-                        .reg_offset = 1,
-                        .mask = TPS65090_INT2_MASK_OVERLOAD_FET7,
+                .reg_offset = 1,
+                .mask = TPS65090_INT2_MASK_OVERLOAD_FET7,
         },
 };
 
@@ -176,7 +176,7 @@ MODULE_DEVICE_TABLE(of, tps65090_of_match);
 #endif
 
 static int tps65090_i2c_probe(struct i2c_client *client,
-                                        const struct i2c_device_id *id)
+                              const struct i2c_device_id *id)
 {
         struct tps65090_platform_data *pdata = dev_get_platdata(&client->dev);
         int irq_base = 0;
@@ -210,11 +210,11 @@ static int tps65090_i2c_probe(struct i2c_client *client,
 
         if (client->irq) {
                 ret = regmap_add_irq_chip(tps65090->rmap, client->irq,
-                        IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base,
-                        &tps65090_irq_chip, &tps65090->irq_data);
-                        if (ret) {
-                                dev_err(&client->dev,
-                                        "IRQ init failed with err: %d\n", ret);
+                                          IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base,
+                                          &tps65090_irq_chip, &tps65090->irq_data);
+                if (ret) {
+                        dev_err(&client->dev,
+                                "IRQ init failed with err: %d\n", ret);
                         return ret;
                 }
         } else {
@@ -223,8 +223,8 @@ static int tps65090_i2c_probe(struct i2c_client *client,
         }
 
         ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
-                ARRAY_SIZE(tps65090s), NULL,
-                0, regmap_irq_get_domain(tps65090->irq_data));
+                              ARRAY_SIZE(tps65090s), NULL,
+                              0, regmap_irq_get_domain(tps65090->irq_data));
         if (ret) {
                 dev_err(&client->dev, "add mfd devices failed with err: %d\n",
                         ret);
diff --git a/drivers/mfd/tps65217.c b/drivers/mfd/tps65217.c
index a8ee52c95f2f..80a919a8ca97 100644
--- a/drivers/mfd/tps65217.c
+++ b/drivers/mfd/tps65217.c
@@ -33,9 +33,11 @@
 static const struct mfd_cell tps65217s[] = {
         {
                 .name = "tps65217-pmic",
+                .of_compatible = "ti,tps65217-pmic",
         },
         {
                 .name = "tps65217-bl",
+                .of_compatible = "ti,tps65217-bl",
         },
 };
 
diff --git a/drivers/mfd/twl4030-power.c b/drivers/mfd/twl4030-power.c
index 50f9091bcd38..7d63e324e6a8 100644
--- a/drivers/mfd/twl4030-power.c
+++ b/drivers/mfd/twl4030-power.c
@@ -831,6 +831,9 @@ static struct twl4030_power_data osc_off_idle = {
 
 static struct of_device_id twl4030_power_of_match[] = {
         {
+                .compatible = "ti,twl4030-power",
+        },
+        {
                 .compatible = "ti,twl4030-power-reset",
                 .data = &omap3_reset,
         },
diff --git a/drivers/mfd/viperboard.c b/drivers/mfd/viperboard.c
index 3c2b8f9e3c84..e6b3c70aeb22 100644
--- a/drivers/mfd/viperboard.c
+++ b/drivers/mfd/viperboard.c
@@ -93,9 +93,8 @@ static int vprbrd_probe(struct usb_interface *interface,
                  version >> 8, version & 0xff,
                  vb->usb_dev->bus->busnum, vb->usb_dev->devnum);
 
-        ret = mfd_add_devices(&interface->dev, PLATFORM_DEVID_AUTO,
-                                vprbrd_devs, ARRAY_SIZE(vprbrd_devs), NULL, 0,
-                                NULL);
+        ret = mfd_add_hotplug_devices(&interface->dev, vprbrd_devs,
+                                      ARRAY_SIZE(vprbrd_devs));
         if (ret != 0) {
                 dev_err(&interface->dev, "Failed to add mfd devices to core.");
                 goto error;
diff --git a/drivers/mfd/wm5102-tables.c b/drivers/mfd/wm5102-tables.c
index d6f35bbf795b..b326a82017ee 100644
--- a/drivers/mfd/wm5102-tables.c
+++ b/drivers/mfd/wm5102-tables.c
@@ -336,8 +336,6 @@ static const struct reg_default wm5102_reg_default[] = {
         { 0x00000218, 0x01A6 },   /* R536   - Mic Bias Ctrl 1 */ 
         { 0x00000219, 0x01A6 },   /* R537   - Mic Bias Ctrl 2 */ 
         { 0x0000021A, 0x01A6 },   /* R538   - Mic Bias Ctrl 3 */ 
-        { 0x00000225, 0x0400 },   /* R549   - HP Ctrl 1L */
-        { 0x00000226, 0x0400 },   /* R550   - HP Ctrl 1R */
         { 0x00000293, 0x0000 },   /* R659   - Accessory Detect Mode 1 */ 
         { 0x0000029B, 0x0020 },   /* R667   - Headphone Detect 1 */ 
         { 0x0000029C, 0x0000 },   /* R668   - Headphone Detect 2 */
@@ -1112,6 +1110,8 @@ static bool wm5102_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_MIC_BIAS_CTRL_1:
         case ARIZONA_MIC_BIAS_CTRL_2:
         case ARIZONA_MIC_BIAS_CTRL_3:
+        case ARIZONA_HP_CTRL_1L:
+        case ARIZONA_HP_CTRL_1R:
         case ARIZONA_ACCESSORY_DETECT_MODE_1:
         case ARIZONA_HEADPHONE_DETECT_1:
         case ARIZONA_HEADPHONE_DETECT_2:
@@ -1949,6 +1949,8 @@ static bool wm5102_volatile_register(struct device *dev, unsigned int reg)
         case ARIZONA_DSP1_SCRATCH_1:
         case ARIZONA_DSP1_SCRATCH_2:
         case ARIZONA_DSP1_SCRATCH_3:
+        case ARIZONA_HP_CTRL_1L:
+        case ARIZONA_HP_CTRL_1R:
         case ARIZONA_HEADPHONE_DETECT_2:
         case ARIZONA_HP_DACVAL:
         case ARIZONA_MIC_DETECT_3:
diff --git a/drivers/mfd/wm5110-tables.c b/drivers/mfd/wm5110-tables.c
index 4642b5b816a0..12cad94b4035 100644
--- a/drivers/mfd/wm5110-tables.c
+++ b/drivers/mfd/wm5110-tables.c
@@ -895,8 +895,16 @@ static const struct reg_default wm5110_reg_default[] = {
         { 0x00000548, 0x1818 },    /* R1352  - AIF2 Frame Ctrl 2 */
         { 0x00000549, 0x0000 },    /* R1353  - AIF2 Frame Ctrl 3 */
         { 0x0000054A, 0x0001 },    /* R1354  - AIF2 Frame Ctrl 4 */
+        { 0x0000054B, 0x0002 },    /* R1355  - AIF2 Frame Ctrl 5 */
+        { 0x0000054C, 0x0003 },    /* R1356  - AIF2 Frame Ctrl 6 */
+        { 0x0000054D, 0x0004 },    /* R1357  - AIF2 Frame Ctrl 7 */
+        { 0x0000054E, 0x0005 },    /* R1358  - AIF2 Frame Ctrl 8 */
         { 0x00000551, 0x0000 },    /* R1361  - AIF2 Frame Ctrl 11 */
         { 0x00000552, 0x0001 },    /* R1362  - AIF2 Frame Ctrl 12 */
+        { 0x00000553, 0x0002 },    /* R1363  - AIF2 Frame Ctrl 13 */
+        { 0x00000554, 0x0003 },    /* R1364  - AIF2 Frame Ctrl 14 */
+        { 0x00000555, 0x0004 },    /* R1365  - AIF2 Frame Ctrl 15 */
+        { 0x00000556, 0x0005 },    /* R1366  - AIF2 Frame Ctrl 16 */
         { 0x00000559, 0x0000 },    /* R1369  - AIF2 Tx Enables */
         { 0x0000055A, 0x0000 },    /* R1370  - AIF2 Rx Enables */
         { 0x00000580, 0x000C },    /* R1408  - AIF3 BCLK Ctrl */
@@ -1790,6 +1798,8 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_MIC_BIAS_CTRL_1:
         case ARIZONA_MIC_BIAS_CTRL_2:
         case ARIZONA_MIC_BIAS_CTRL_3:
+        case ARIZONA_HP_CTRL_1L:
+        case ARIZONA_HP_CTRL_1R:
         case ARIZONA_ACCESSORY_DETECT_MODE_1:
         case ARIZONA_HEADPHONE_DETECT_1:
         case ARIZONA_HEADPHONE_DETECT_2:
@@ -1934,8 +1944,16 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_AIF2_FRAME_CTRL_2:
         case ARIZONA_AIF2_FRAME_CTRL_3:
         case ARIZONA_AIF2_FRAME_CTRL_4:
+        case ARIZONA_AIF2_FRAME_CTRL_5:
+        case ARIZONA_AIF2_FRAME_CTRL_6:
+        case ARIZONA_AIF2_FRAME_CTRL_7:
+        case ARIZONA_AIF2_FRAME_CTRL_8:
         case ARIZONA_AIF2_FRAME_CTRL_11:
         case ARIZONA_AIF2_FRAME_CTRL_12:
+        case ARIZONA_AIF2_FRAME_CTRL_13:
+        case ARIZONA_AIF2_FRAME_CTRL_14:
+        case ARIZONA_AIF2_FRAME_CTRL_15:
+        case ARIZONA_AIF2_FRAME_CTRL_16:
         case ARIZONA_AIF2_TX_ENABLES:
         case ARIZONA_AIF2_RX_ENABLES:
         case ARIZONA_AIF3_BCLK_CTRL:
@@ -2825,6 +2843,8 @@ static bool wm5110_volatile_register(struct device *dev, unsigned int reg)
         case ARIZONA_ASYNC_SAMPLE_RATE_1_STATUS:
         case ARIZONA_ASYNC_SAMPLE_RATE_2_STATUS:
         case ARIZONA_MIC_DETECT_3:
+        case ARIZONA_HP_CTRL_1L:
+        case ARIZONA_HP_CTRL_1R:
         case ARIZONA_HEADPHONE_DETECT_2:
         case ARIZONA_INPUT_ENABLES_STATUS:
         case ARIZONA_OUTPUT_STATUS_1:
diff --git a/drivers/mfd/wm8350-core.c b/drivers/mfd/wm8350-core.c
index 4ab527f5c53b..f5124a8acad8 100644
--- a/drivers/mfd/wm8350-core.c
+++ b/drivers/mfd/wm8350-core.c
@@ -308,7 +308,7 @@ int wm8350_device_init(struct wm8350 *wm8350, int irq,
                 goto err;
         }
 
-        mode = id2 & WM8350_CONF_STS_MASK >> 10;
+        mode = (id2 & WM8350_CONF_STS_MASK) >> 10;
         cust_id = id2 & WM8350_CUST_ID_MASK;
         chip_rev = (id2 & WM8350_CHIP_REV_MASK) >> 12;
         dev_info(wm8350->dev,
diff --git a/drivers/mfd/wm8994-core.c b/drivers/mfd/wm8994-core.c
index e6fab94e2c8a..6ca9d25cc3f0 100644
--- a/drivers/mfd/wm8994-core.c
+++ b/drivers/mfd/wm8994-core.c
@@ -116,7 +116,7 @@ static const char *wm8958_main_supplies[] = {
         "SPKVDD2",
 };
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int wm8994_suspend(struct device *dev)
 {
         struct wm8994 *wm8994 = dev_get_drvdata(dev);
diff --git a/drivers/mfd/wm8997-tables.c b/drivers/mfd/wm8997-tables.c
index 510da3b52324..c0c25d75aacc 100644
--- a/drivers/mfd/wm8997-tables.c
+++ b/drivers/mfd/wm8997-tables.c
@@ -670,6 +670,7 @@ static const struct reg_default wm8997_reg_default[] = {
         { 0x00000C23, 0x0000 },    /* R3107  - Misc Pad Ctrl 4 */
         { 0x00000C24, 0x0000 },    /* R3108  - Misc Pad Ctrl 5 */
         { 0x00000D08, 0xFFFF },    /* R3336  - Interrupt Status 1 Mask */
+        { 0x00000D09, 0xFFFF },    /* R3337  - Interrupt Status 2 Mask */
         { 0x00000D0A, 0xFFFF },    /* R3338  - Interrupt Status 3 Mask */
         { 0x00000D0B, 0xFFFF },    /* R3339  - Interrupt Status 4 Mask */
         { 0x00000D0C, 0xFEFF },    /* R3340  - Interrupt Status 5 Mask */
@@ -886,6 +887,8 @@ static bool wm8997_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_MIC_BIAS_CTRL_1:
         case ARIZONA_MIC_BIAS_CTRL_2:
         case ARIZONA_MIC_BIAS_CTRL_3:
+        case ARIZONA_HP_CTRL_1L:
+        case ARIZONA_HP_CTRL_1R:
         case ARIZONA_ACCESSORY_DETECT_MODE_1:
         case ARIZONA_HEADPHONE_DETECT_1:
         case ARIZONA_HEADPHONE_DETECT_2:
@@ -1328,6 +1331,7 @@ static bool wm8997_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_INTERRUPT_STATUS_4:
         case ARIZONA_INTERRUPT_STATUS_5:
         case ARIZONA_INTERRUPT_STATUS_1_MASK:
+        case ARIZONA_INTERRUPT_STATUS_2_MASK:
         case ARIZONA_INTERRUPT_STATUS_3_MASK:
         case ARIZONA_INTERRUPT_STATUS_4_MASK:
         case ARIZONA_INTERRUPT_STATUS_5_MASK:
@@ -1477,6 +1481,8 @@ static bool wm8997_volatile_register(struct device *dev, unsigned int reg)
         case ARIZONA_SAMPLE_RATE_3_STATUS:
         case ARIZONA_ASYNC_SAMPLE_RATE_1_STATUS:
         case ARIZONA_MIC_DETECT_3:
+        case ARIZONA_HP_CTRL_1L:
+        case ARIZONA_HP_CTRL_1R:
         case ARIZONA_HEADPHONE_DETECT_2:
         case ARIZONA_INPUT_ENABLES_STATUS:
         case ARIZONA_OUTPUT_STATUS_1:
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index bbeb4516facf..006242c8bca0 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -75,7 +75,7 @@ config ATMEL_TCB_CLKSRC
 config ATMEL_TCB_CLKSRC_BLOCK
         int
         depends on ATMEL_TCB_CLKSRC
-        prompt "TC Block" if ARCH_AT91RM9200 || ARCH_AT91SAM9260 || CPU_AT32AP700X
+        prompt "TC Block" if CPU_AT32AP700X
         default 0
         range 0 1
         help
diff --git a/drivers/misc/apds990x.c b/drivers/misc/apds990x.c
index 868a30a1b417..3739ffa9cdf1 100644
--- a/drivers/misc/apds990x.c
+++ b/drivers/misc/apds990x.c
@@ -609,7 +609,7 @@ static int apds990x_detect(struct apds990x_chip *chip)
         return ret;
 }
 
-#if defined(CONFIG_PM) || defined(CONFIG_PM_RUNTIME)
+#ifdef CONFIG_PM
 static int apds990x_chip_on(struct apds990x_chip *chip)
 {
         int err  = regulator_bulk_enable(ARRAY_SIZE(chip->regs),
@@ -1237,7 +1237,7 @@ static int apds990x_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int apds990x_runtime_suspend(struct device *dev)
 {
         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
diff --git a/drivers/misc/bh1770glc.c b/drivers/misc/bh1770glc.c
index 7b55f8a152d4..b756381b8250 100644
--- a/drivers/misc/bh1770glc.c
+++ b/drivers/misc/bh1770glc.c
@@ -1358,7 +1358,7 @@ static int bh1770_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int bh1770_runtime_suspend(struct device *dev)
 {
         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
diff --git a/drivers/misc/eeprom/at25.c b/drivers/misc/eeprom/at25.c
index 634f72929e12..0a1af93ec638 100644
--- a/drivers/misc/eeprom/at25.c
+++ b/drivers/misc/eeprom/at25.c
@@ -18,7 +18,7 @@
 
 #include <linux/spi/spi.h>
 #include <linux/spi/eeprom.h>
-#include <linux/of.h>
+#include <linux/property.h>
 
 /*
  * NOTE: this is an *EEPROM* driver.  The vagaries of product naming
@@ -301,35 +301,33 @@ static ssize_t at25_mem_write(struct memory_accessor *mem, const char *buf,
 
 /*-------------------------------------------------------------------------*/
 
-static int at25_np_to_chip(struct device *dev,
-                           struct device_node *np,
-                           struct spi_eeprom *chip)
+static int at25_fw_to_chip(struct device *dev, struct spi_eeprom *chip)
 {
         u32 val;
 
         memset(chip, 0, sizeof(*chip));
-        strncpy(chip->name, np->name, sizeof(chip->name));
+        strncpy(chip->name, "at25", sizeof(chip->name));
 
-        if (of_property_read_u32(np, "size", &val) == 0 ||
-            of_property_read_u32(np, "at25,byte-len", &val) == 0) {
+        if (device_property_read_u32(dev, "size", &val) == 0 ||
+            device_property_read_u32(dev, "at25,byte-len", &val) == 0) {
                 chip->byte_len = val;
         } else {
                 dev_err(dev, "Error: missing \"size\" property\n");
                 return -ENODEV;
         }
 
-        if (of_property_read_u32(np, "pagesize", &val) == 0 ||
-            of_property_read_u32(np, "at25,page-size", &val) == 0) {
+        if (device_property_read_u32(dev, "pagesize", &val) == 0 ||
+            device_property_read_u32(dev, "at25,page-size", &val) == 0) {
                 chip->page_size = (u16)val;
         } else {
                 dev_err(dev, "Error: missing \"pagesize\" property\n");
                 return -ENODEV;
         }
 
-        if (of_property_read_u32(np, "at25,addr-mode", &val) == 0) {
+        if (device_property_read_u32(dev, "at25,addr-mode", &val) == 0) {
                 chip->flags = (u16)val;
         } else {
-                if (of_property_read_u32(np, "address-width", &val)) {
+                if (device_property_read_u32(dev, "address-width", &val)) {
                         dev_err(dev,
                                 "Error: missing \"address-width\" property\n");
                         return -ENODEV;
@@ -350,7 +348,7 @@ static int at25_np_to_chip(struct device *dev,
                                 val);
                         return -ENODEV;
                 }
-                if (of_find_property(np, "read-only", NULL))
+                if (device_property_present(dev, "read-only"))
                         chip->flags |= EE_READONLY;
         }
         return 0;
@@ -360,21 +358,15 @@ static int at25_probe(struct spi_device *spi)
 {
         struct at25_data        *at25 = NULL;
         struct spi_eeprom       chip;
-        struct device_node      *np = spi->dev.of_node;
         int                     err;
         int                     sr;
         int                     addrlen;
 
         /* Chip description */
         if (!spi->dev.platform_data) {
-                if (np) {
-                        err = at25_np_to_chip(&spi->dev, np, &chip);
-                        if (err)
-                                return err;
-                } else {
-                        dev_err(&spi->dev, "Error: no chip description\n");
-                        return -ENODEV;
-                }
+                err = at25_fw_to_chip(&spi->dev, &chip);
+                if (err)
+                        return err;
         } else
                 chip = *(struct spi_eeprom *)spi->dev.platform_data;
 
diff --git a/drivers/misc/eeprom/eeprom_93cx6.c b/drivers/misc/eeprom/eeprom_93cx6.c
index 0ff4b02177be..0cf2c9d676be 100644
--- a/drivers/misc/eeprom/eeprom_93cx6.c
+++ b/drivers/misc/eeprom/eeprom_93cx6.c
@@ -170,7 +170,7 @@ static void eeprom_93cx6_read_bits(struct eeprom_93cx6 *eeprom,
 }
 
 /**
- * eeprom_93cx6_read - Read multiple words from eeprom
+ * eeprom_93cx6_read - Read a word from eeprom
  * @eeprom: Pointer to eeprom structure
  * @word: Word index from where we should start reading
  * @data: target pointer where the information will have to be stored
@@ -235,6 +235,66 @@ void eeprom_93cx6_multiread(struct eeprom_93cx6 *eeprom, const u8 word,
 EXPORT_SYMBOL_GPL(eeprom_93cx6_multiread);
 
 /**
+ * eeprom_93cx6_readb - Read a byte from eeprom
+ * @eeprom: Pointer to eeprom structure
+ * @word: Byte index from where we should start reading
+ * @data: target pointer where the information will have to be stored
+ *
+ * This function will read a byte of the eeprom data
+ * into the given data pointer.
+ */
+void eeprom_93cx6_readb(struct eeprom_93cx6 *eeprom, const u8 byte,
+        u8 *data)
+{
+        u16 command;
+        u16 tmp;
+
+        /*
+         * Initialize the eeprom register
+         */
+        eeprom_93cx6_startup(eeprom);
+
+        /*
+         * Select the read opcode and the byte to be read.
+         */
+        command = (PCI_EEPROM_READ_OPCODE << (eeprom->width + 1)) | byte;
+        eeprom_93cx6_write_bits(eeprom, command,
+                PCI_EEPROM_WIDTH_OPCODE + eeprom->width + 1);
+
+        /*
+         * Read the requested 8 bits.
+         */
+        eeprom_93cx6_read_bits(eeprom, &tmp, 8);
+        *data = tmp & 0xff;
+
+        /*
+         * Cleanup eeprom register.
+         */
+        eeprom_93cx6_cleanup(eeprom);
+}
+EXPORT_SYMBOL_GPL(eeprom_93cx6_readb);
+
+/**
+ * eeprom_93cx6_multireadb - Read multiple bytes from eeprom
+ * @eeprom: Pointer to eeprom structure
+ * @byte: Index from where we should start reading
+ * @data: target pointer where the information will have to be stored
+ * @words: Number of bytes that should be read.
+ *
+ * This function will read all requested bytes from the eeprom,
+ * this is done by calling eeprom_93cx6_readb() multiple times.
+ */
+void eeprom_93cx6_multireadb(struct eeprom_93cx6 *eeprom, const u8 byte,
+        u8 *data, const u16 bytes)
+{
+        unsigned int i;
+
+        for (i = 0; i < bytes; i++)
+                eeprom_93cx6_readb(eeprom, byte + i, &data[i]);
+}
+EXPORT_SYMBOL_GPL(eeprom_93cx6_multireadb);
+
+/**
  * eeprom_93cx6_wren - set the write enable state
  * @eeprom: Pointer to eeprom structure
  * @enable: true to enable writes, otherwise disable writes
diff --git a/drivers/misc/enclosure.c b/drivers/misc/enclosure.c
index 2cf2bbc0b927..180a5442fd4b 100644
--- a/drivers/misc/enclosure.c
+++ b/drivers/misc/enclosure.c
@@ -187,6 +187,7 @@ void enclosure_unregister(struct enclosure_device *edev)
 EXPORT_SYMBOL_GPL(enclosure_unregister);
 
 #define ENCLOSURE_NAME_SIZE     64
+#define COMPONENT_NAME_SIZE     64
 
 static void enclosure_link_name(struct enclosure_component *cdev, char *name)
 {
@@ -246,6 +247,29 @@ static void enclosure_component_release(struct device *dev)
         put_device(dev->parent);
 }
 
+static struct enclosure_component *
+enclosure_component_find_by_name(struct enclosure_device *edev,
+                                const char *name)
+{
+        int i;
+        const char *cname;
+        struct enclosure_component *ecomp;
+
+        if (!edev || !name || !name[0])
+                return NULL;
+
+        for (i = 0; i < edev->components; i++) {
+                ecomp = &edev->component[i];
+                cname = dev_name(&ecomp->cdev);
+                if (ecomp->number != -1 &&
+                    cname && cname[0] &&
+                    !strcmp(cname, name))
+                        return ecomp;
+        }
+
+        return NULL;
+}
+
 static const struct attribute_group *enclosure_component_groups[];
 
 /**
@@ -269,7 +293,8 @@ enclosure_component_register(struct enclosure_device *edev,
 {
         struct enclosure_component *ecomp;
         struct device *cdev;
-        int err;
+        int err, i;
+        char newname[COMPONENT_NAME_SIZE];
 
         if (number >= edev->components)
                 return ERR_PTR(-EINVAL);
@@ -283,9 +308,20 @@ enclosure_component_register(struct enclosure_device *edev,
         ecomp->number = number;
         cdev = &ecomp->cdev;
         cdev->parent = get_device(&edev->edev);
-        if (name && name[0])
-                dev_set_name(cdev, "%s", name);
-        else
+
+        if (name && name[0]) {
+                /* Some hardware (e.g. enclosure in RX300 S6) has components
+                 * with non unique names. Registering duplicates in sysfs
+                 * will lead to warnings during bootup. So make the names
+                 * unique by appending consecutive numbers -1, -2, ... */
+                i = 1;
+                snprintf(newname, COMPONENT_NAME_SIZE,
+                         "%s", name);
+                while (enclosure_component_find_by_name(edev, newname))
+                        snprintf(newname, COMPONENT_NAME_SIZE,
+                                 "%s-%i", name, i++);
+                dev_set_name(cdev, "%s", newname);
+        } else
                 dev_set_name(cdev, "%u", number);
 
         cdev->release = enclosure_component_release;
diff --git a/drivers/misc/genwqe/card_dev.c b/drivers/misc/genwqe/card_dev.c
index 5918586f2f76..c49d244265ec 100644
--- a/drivers/misc/genwqe/card_dev.c
+++ b/drivers/misc/genwqe/card_dev.c
@@ -395,7 +395,7 @@ static void genwqe_vma_open(struct vm_area_struct *vma)
 static void genwqe_vma_close(struct vm_area_struct *vma)
 {
         unsigned long vsize = vma->vm_end - vma->vm_start;
-        struct inode *inode = vma->vm_file->f_dentry->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         struct dma_mapping *dma_map;
         struct genwqe_dev *cd = container_of(inode->i_cdev, struct genwqe_dev,
                                             cdev_genwqe);
diff --git a/drivers/misc/lis3lv02d/lis3lv02d_i2c.c b/drivers/misc/lis3lv02d/lis3lv02d_i2c.c
index d324f8a97b88..63fe096d4462 100644
--- a/drivers/misc/lis3lv02d/lis3lv02d_i2c.c
+++ b/drivers/misc/lis3lv02d/lis3lv02d_i2c.c
@@ -235,7 +235,7 @@ static int lis3lv02d_i2c_resume(struct device *dev)
 }
 #endif /* CONFIG_PM_SLEEP */
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int lis3_i2c_runtime_suspend(struct device *dev)
 {
         struct i2c_client *client = container_of(dev, struct i2c_client, dev);
@@ -253,7 +253,7 @@ static int lis3_i2c_runtime_resume(struct device *dev)
         lis3lv02d_poweron(lis3);
         return 0;
 }
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
 static const struct i2c_device_id lis3lv02d_id[] = {
         {"lis3lv02d", LIS3LV02D},
diff --git a/drivers/misc/mei/mei_dev.h b/drivers/misc/mei/mei_dev.h
index 71744b16cc8c..61b04d7646f1 100644
--- a/drivers/misc/mei/mei_dev.h
+++ b/drivers/misc/mei/mei_dev.h
@@ -530,9 +530,9 @@ struct mei_device {
          * Power Gating support
          */
         enum mei_pg_event pg_event;
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         struct dev_pm_domain pg_domain;
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
         unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE];
         u32 rd_msg_hdr;
diff --git a/drivers/misc/mei/pci-me.c b/drivers/misc/mei/pci-me.c
index f3225b1643ab..cf20d397068a 100644
--- a/drivers/misc/mei/pci-me.c
+++ b/drivers/misc/mei/pci-me.c
@@ -89,13 +89,13 @@ static const struct pci_device_id mei_me_pci_tbl[] = {
 
 MODULE_DEVICE_TABLE(pci, mei_me_pci_tbl);
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static inline void mei_me_set_pm_domain(struct mei_device *dev);
 static inline void mei_me_unset_pm_domain(struct mei_device *dev);
 #else
 static inline void mei_me_set_pm_domain(struct mei_device *dev) {}
 static inline void mei_me_unset_pm_domain(struct mei_device *dev) {}
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
 /**
  * mei_me_quirk_probe - probe for devices that doesn't valid ME interface
@@ -357,7 +357,7 @@ static int mei_me_pci_resume(struct device *device)
 }
 #endif /* CONFIG_PM_SLEEP */
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int mei_me_pm_runtime_idle(struct device *device)
 {
         struct pci_dev *pdev = to_pci_dev(device);
@@ -453,9 +453,7 @@ static inline void mei_me_unset_pm_domain(struct mei_device *dev)
         /* stop using pm callbacks if any */
         dev->dev->pm_domain = NULL;
 }
-#endif /* CONFIG_PM_RUNTIME */
 
-#ifdef CONFIG_PM
 static const struct dev_pm_ops mei_me_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(mei_me_pci_suspend,
                                 mei_me_pci_resume)
diff --git a/drivers/misc/mei/pci-txe.c b/drivers/misc/mei/pci-txe.c
index bee1c6fb7e75..1f572deacf54 100644
--- a/drivers/misc/mei/pci-txe.c
+++ b/drivers/misc/mei/pci-txe.c
@@ -42,13 +42,13 @@ static const struct pci_device_id mei_txe_pci_tbl[] = {
 };
 MODULE_DEVICE_TABLE(pci, mei_txe_pci_tbl);
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static inline void mei_txe_set_pm_domain(struct mei_device *dev);
 static inline void mei_txe_unset_pm_domain(struct mei_device *dev);
 #else
 static inline void mei_txe_set_pm_domain(struct mei_device *dev) {}
 static inline void mei_txe_unset_pm_domain(struct mei_device *dev) {}
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
 static void mei_txe_pci_iounmap(struct pci_dev *pdev, struct mei_txe_hw *hw)
 {
@@ -295,7 +295,7 @@ static int mei_txe_pci_resume(struct device *device)
 }
 #endif /* CONFIG_PM_SLEEP */
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int mei_txe_pm_runtime_idle(struct device *device)
 {
         struct pci_dev *pdev = to_pci_dev(device);
@@ -401,9 +401,7 @@ static inline void mei_txe_unset_pm_domain(struct mei_device *dev)
         /* stop using pm callbacks if any */
         dev->dev->pm_domain = NULL;
 }
-#endif /* CONFIG_PM_RUNTIME */
 
-#ifdef CONFIG_PM
 static const struct dev_pm_ops mei_txe_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(mei_txe_pci_suspend,
                                 mei_txe_pci_resume)
diff --git a/drivers/misc/mic/card/mic_virtio.c b/drivers/misc/mic/card/mic_virtio.c
index e64794730e21..e486a0c26267 100644
--- a/drivers/misc/mic/card/mic_virtio.c
+++ b/drivers/misc/mic/card/mic_virtio.c
@@ -68,7 +68,7 @@ static inline struct device *mic_dev(struct mic_vdev *mvdev)
 }
 
 /* This gets the device's feature bits. */
-static u32 mic_get_features(struct virtio_device *vdev)
+static u64 mic_get_features(struct virtio_device *vdev)
 {
         unsigned int i, bits;
         u32 features = 0;
@@ -76,8 +76,7 @@ static u32 mic_get_features(struct virtio_device *vdev)
         u8 __iomem *in_features = mic_vq_features(desc);
         int feature_len = ioread8(&desc->feature_len);
 
-        bits = min_t(unsigned, feature_len,
-                sizeof(vdev->features)) * 8;
+        bits = min_t(unsigned, feature_len, sizeof(features)) * 8;
         for (i = 0; i < bits; i++)
                 if (ioread8(&in_features[i / 8]) & (BIT(i % 8)))
                         features |= BIT(i);
@@ -85,7 +84,7 @@ static u32 mic_get_features(struct virtio_device *vdev)
         return features;
 }
 
-static void mic_finalize_features(struct virtio_device *vdev)
+static int mic_finalize_features(struct virtio_device *vdev)
 {
         unsigned int i, bits;
         struct mic_device_desc __iomem *desc = to_micvdev(vdev)->desc;
@@ -97,14 +96,19 @@ static void mic_finalize_features(struct virtio_device *vdev)
         /* Give virtio_ring a chance to accept features. */
         vring_transport_features(vdev);
 
+        /* Make sure we don't have any features > 32 bits! */
+        BUG_ON((u32)vdev->features != vdev->features);
+
         memset_io(out_features, 0, feature_len);
         bits = min_t(unsigned, feature_len,
                 sizeof(vdev->features)) * 8;
         for (i = 0; i < bits; i++) {
-                if (test_bit(i, vdev->features))
+                if (__virtio_test_bit(vdev, i))
                         iowrite8(ioread8(&out_features[i / 8]) | (1 << (i % 8)),
                                  &out_features[i / 8]);
         }
+
+        return 0;
 }
 
 /*
diff --git a/drivers/misc/vexpress-syscfg.c b/drivers/misc/vexpress-syscfg.c
index b3a812384a6f..c344483fa7d6 100644
--- a/drivers/misc/vexpress-syscfg.c
+++ b/drivers/misc/vexpress-syscfg.c
@@ -145,7 +145,7 @@ static struct regmap_config vexpress_syscfg_regmap_config = {
 static struct regmap *vexpress_syscfg_regmap_init(struct device *dev,
                 void *context)
 {
-        struct platform_device *pdev = to_platform_device(dev);
+        int err;
         struct vexpress_syscfg *syscfg = context;
         struct vexpress_syscfg_func *func;
         struct property *prop;
@@ -155,32 +155,18 @@ static struct regmap *vexpress_syscfg_regmap_init(struct device *dev,
         u32 site, position, dcc;
         int i;
 
-        if (dev->of_node) {
-                int err = vexpress_config_get_topo(dev->of_node, &site,
+        err = vexpress_config_get_topo(dev->of_node, &site,
                                 &position, &dcc);
+        if (err)
+                return ERR_PTR(err);
 
-                if (err)
-                        return ERR_PTR(err);
-
-                prop = of_find_property(dev->of_node,
-                                "arm,vexpress-sysreg,func", NULL);
-                if (!prop)
-                        return ERR_PTR(-EINVAL);
-
-                num = prop->length / sizeof(u32) / 2;
-                val = prop->value;
-        } else {
-                if (pdev->num_resources != 1 ||
-                                pdev->resource[0].flags != IORESOURCE_BUS)
-                        return ERR_PTR(-EFAULT);
-
-                site = pdev->resource[0].start;
-                if (site == VEXPRESS_SITE_MASTER)
-                        site = vexpress_config_get_master();
-                position = 0;
-                dcc = 0;
-                num = 1;
-        }
+        prop = of_find_property(dev->of_node,
+                        "arm,vexpress-sysreg,func", NULL);
+        if (!prop)
+                return ERR_PTR(-EINVAL);
+
+        num = prop->length / sizeof(u32) / 2;
+        val = prop->value;
 
         /*
          * "arm,vexpress-energy" function used to be described
@@ -207,13 +193,8 @@ static struct regmap *vexpress_syscfg_regmap_init(struct device *dev,
         for (i = 0; i < num; i++) {
                 u32 function, device;
 
-                if (dev->of_node) {
-                        function = be32_to_cpup(val++);
-                        device = be32_to_cpup(val++);
-                } else {
-                        function = pdev->resource[0].end;
-                        device = pdev->id;
-                }
+                function = be32_to_cpup(val++);
+                device = be32_to_cpup(val++);
 
                 dev_dbg(dev, "func %p: %u/%u/%u/%u/%u\n",
                                 func, site, position, dcc,
@@ -265,17 +246,6 @@ static struct vexpress_config_bridge_ops vexpress_syscfg_bridge_ops = {
 };
 
 
-/* Non-DT hack, to be gone... */
-static struct device *vexpress_syscfg_bridge;
-
-int vexpress_syscfg_device_register(struct platform_device *pdev)
-{
-        pdev->dev.parent = vexpress_syscfg_bridge;
-
-        return platform_device_register(pdev);
-}
-
-
 static int vexpress_syscfg_probe(struct platform_device *pdev)
 {
         struct vexpress_syscfg *syscfg;
@@ -303,10 +273,6 @@ static int vexpress_syscfg_probe(struct platform_device *pdev)
         if (IS_ERR(bridge))
                 return PTR_ERR(bridge);
 
-        /* Non-DT case */
-        if (!pdev->dev.of_node)
-                vexpress_syscfg_bridge = bridge;
-
         return 0;
 }
 
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 1fa4c80ff886..4409d79ed650 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -78,13 +78,16 @@ static int perdev_minors = CONFIG_MMC_BLOCK_MINORS;
 
 /*
  * We've only got one major, so number of mmcblk devices is
- * limited to 256 / number of minors per device.
+ * limited to (1 << 20) / number of minors per device.  It is also
+ * currently limited by the size of the static bitmaps below.
  */
 static int max_devices;
 
-/* 256 minors, so at most 256 separate devices */
-static DECLARE_BITMAP(dev_use, 256);
-static DECLARE_BITMAP(name_use, 256);
+#define MAX_DEVICES 256
+
+/* TODO: Replace these with struct ida */
+static DECLARE_BITMAP(dev_use, MAX_DEVICES);
+static DECLARE_BITMAP(name_use, MAX_DEVICES);
 
 /*
  * There is one mmc_blk_data per slot.
@@ -112,7 +115,7 @@ struct mmc_blk_data {
 
         /*
          * Only set in main mmc_blk_data associated
-         * with mmc_card with mmc_set_drvdata, and keeps
+         * with mmc_card with dev_set_drvdata, and keeps
          * track of the current selected device partition.
          */
         unsigned int    part_curr;
@@ -260,7 +263,7 @@ static ssize_t force_ro_show(struct device *dev, struct device_attribute *attr,
         int ret;
         struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
 
-        ret = snprintf(buf, PAGE_SIZE, "%d",
+        ret = snprintf(buf, PAGE_SIZE, "%d\n",
                        get_disk_ro(dev_to_disk(dev)) ^
                        md->read_only);
         mmc_blk_put(md);
@@ -642,7 +645,7 @@ static inline int mmc_blk_part_switch(struct mmc_card *card,
                                       struct mmc_blk_data *md)
 {
         int ret;
-        struct mmc_blk_data *main_md = mmc_get_drvdata(card);
+        struct mmc_blk_data *main_md = dev_get_drvdata(&card->dev);
 
         if (main_md->part_curr == md->part_type)
                 return 0;
@@ -1004,7 +1007,8 @@ static int mmc_blk_reset(struct mmc_blk_data *md, struct mmc_host *host,
         err = mmc_hw_reset(host);
         /* Ensure we switch back to the correct partition */
         if (err != -EOPNOTSUPP) {
-                struct mmc_blk_data *main_md = mmc_get_drvdata(host->card);
+                struct mmc_blk_data *main_md =
+                        dev_get_drvdata(&host->card->dev);
                 int part_err;
 
                 main_md->part_curr = main_md->part_type;
@@ -1308,19 +1312,11 @@ static int mmc_blk_packed_err_check(struct mmc_card *card,
         }
 
         if (status & R1_EXCEPTION_EVENT) {
-                ext_csd = kzalloc(512, GFP_KERNEL);
-                if (!ext_csd) {
-                        pr_err("%s: unable to allocate buffer for ext_csd\n",
-                               req->rq_disk->disk_name);
-                        return -ENOMEM;
-                }
-
-                err = mmc_send_ext_csd(card, ext_csd);
+                err = mmc_get_ext_csd(card, &ext_csd);
                 if (err) {
                         pr_err("%s: error %d sending ext_csd\n",
                                req->rq_disk->disk_name, err);
-                        check = MMC_BLK_ABORT;
-                        goto free;
+                        return MMC_BLK_ABORT;
                 }
 
                 if ((ext_csd[EXT_CSD_EXP_EVENTS_STATUS] &
@@ -1338,7 +1334,6 @@ static int mmc_blk_packed_err_check(struct mmc_card *card,
                                req->rq_disk->disk_name, packed->nr_entries,
                                packed->blocks, packed->idx_failure);
                 }
-free:
                 kfree(ext_csd);
         }
 
@@ -2093,7 +2088,7 @@ static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
 
         /*
          * !subname implies we are creating main mmc_blk_data that will be
-         * associated with mmc_card with mmc_set_drvdata. Due to device
+         * associated with mmc_card with dev_set_drvdata. Due to device
          * partitions, devidx will not coincide with a per-physical card
          * index anymore so we keep track of a name index.
          */
@@ -2425,8 +2420,9 @@ static const struct mmc_fixup blk_fixups[] =
         END_FIXUP
 };
 
-static int mmc_blk_probe(struct mmc_card *card)
+static int mmc_blk_probe(struct device *dev)
 {
+        struct mmc_card *card = mmc_dev_to_card(dev);
         struct mmc_blk_data *md, *part_md;
         char cap_str[10];
 
@@ -2451,7 +2447,7 @@ static int mmc_blk_probe(struct mmc_card *card)
         if (mmc_blk_alloc_parts(card, md))
                 goto out;
 
-        mmc_set_drvdata(card, md);
+        dev_set_drvdata(dev, md);
 
         if (mmc_add_disk(md))
                 goto out;
@@ -2481,9 +2477,10 @@ static int mmc_blk_probe(struct mmc_card *card)
         return 0;
 }
 
-static void mmc_blk_remove(struct mmc_card *card)
+static int mmc_blk_remove(struct device *dev)
 {
-        struct mmc_blk_data *md = mmc_get_drvdata(card);
+        struct mmc_card *card = mmc_dev_to_card(dev);
+        struct mmc_blk_data *md = dev_get_drvdata(dev);
 
         mmc_blk_remove_parts(card, md);
         pm_runtime_get_sync(&card->dev);
@@ -2494,13 +2491,15 @@ static void mmc_blk_remove(struct mmc_card *card)
                 pm_runtime_disable(&card->dev);
         pm_runtime_put_noidle(&card->dev);
         mmc_blk_remove_req(md);
-        mmc_set_drvdata(card, NULL);
+        dev_set_drvdata(dev, NULL);
+
+        return 0;
 }
 
-static int _mmc_blk_suspend(struct mmc_card *card)
+static int _mmc_blk_suspend(struct device *dev)
 {
         struct mmc_blk_data *part_md;
-        struct mmc_blk_data *md = mmc_get_drvdata(card);
+        struct mmc_blk_data *md = dev_get_drvdata(dev);
 
         if (md) {
                 mmc_queue_suspend(&md->queue);
@@ -2511,21 +2510,21 @@ static int _mmc_blk_suspend(struct mmc_card *card)
         return 0;
 }
 
-static void mmc_blk_shutdown(struct mmc_card *card)
+static void mmc_blk_shutdown(struct device *dev)
 {
-        _mmc_blk_suspend(card);
+        _mmc_blk_suspend(dev);
 }
 
-#ifdef CONFIG_PM
-static int mmc_blk_suspend(struct mmc_card *card)
+#ifdef CONFIG_PM_SLEEP
+static int mmc_blk_suspend(struct device *dev)
 {
-        return _mmc_blk_suspend(card);
+        return _mmc_blk_suspend(dev);
 }
 
-static int mmc_blk_resume(struct mmc_card *card)
+static int mmc_blk_resume(struct device *dev)
 {
         struct mmc_blk_data *part_md;
-        struct mmc_blk_data *md = mmc_get_drvdata(card);
+        struct mmc_blk_data *md = dev_get_drvdata(dev);
 
         if (md) {
                 /*
@@ -2540,19 +2539,15 @@ static int mmc_blk_resume(struct mmc_card *card)
         }
         return 0;
 }
-#else
-#define mmc_blk_suspend NULL
-#define mmc_blk_resume  NULL
 #endif
 
-static struct mmc_driver mmc_driver = {
-        .drv            = {
-                .name   = "mmcblk",
-        },
+static SIMPLE_DEV_PM_OPS(mmc_blk_pm_ops, mmc_blk_suspend, mmc_blk_resume);
+
+static struct device_driver mmc_driver = {
+        .name           = "mmcblk",
+        .pm             = &mmc_blk_pm_ops,
         .probe          = mmc_blk_probe,
         .remove         = mmc_blk_remove,
-        .suspend        = mmc_blk_suspend,
-        .resume         = mmc_blk_resume,
         .shutdown       = mmc_blk_shutdown,
 };
 
@@ -2563,7 +2558,7 @@ static int __init mmc_blk_init(void)
         if (perdev_minors != CONFIG_MMC_BLOCK_MINORS)
                 pr_info("mmcblk: using %d minors per device\n", perdev_minors);
 
-        max_devices = 256 / perdev_minors;
+        max_devices = min(MAX_DEVICES, (1 << MINORBITS) / perdev_minors);
 
         res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
         if (res)
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 0c0fc52d42c5..0a7430f94d29 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -14,6 +14,7 @@
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
 #include <linux/slab.h>
+#include <linux/device.h>
 
 #include <linux/scatterlist.h>
 #include <linux/swap.h>         /* For nr_free_buffer_pages() */
@@ -32,6 +33,8 @@
 #define BUFFER_ORDER            2
 #define BUFFER_SIZE             (PAGE_SIZE << BUFFER_ORDER)
 
+#define TEST_ALIGN_END          8
+
 /*
  * Limit the test area size to the maximum MMC HC erase group size.  Note that
  * the maximum SD allocation unit size is just 4MiB.
@@ -1174,7 +1177,7 @@ static int mmc_test_align_write(struct mmc_test_card *test)
         int ret, i;
         struct scatterlist sg;
 
-        for (i = 1;i < 4;i++) {
+        for (i = 1; i < TEST_ALIGN_END; i++) {
                 sg_init_one(&sg, test->buffer + i, 512);
                 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
                 if (ret)
@@ -1189,7 +1192,7 @@ static int mmc_test_align_read(struct mmc_test_card *test)
         int ret, i;
         struct scatterlist sg;
 
-        for (i = 1;i < 4;i++) {
+        for (i = 1; i < TEST_ALIGN_END; i++) {
                 sg_init_one(&sg, test->buffer + i, 512);
                 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
                 if (ret)
@@ -1216,7 +1219,7 @@ static int mmc_test_align_multi_write(struct mmc_test_card *test)
         if (size < 1024)
                 return RESULT_UNSUP_HOST;
 
-        for (i = 1;i < 4;i++) {
+        for (i = 1; i < TEST_ALIGN_END; i++) {
                 sg_init_one(&sg, test->buffer + i, size);
                 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
                 if (ret)
@@ -1243,7 +1246,7 @@ static int mmc_test_align_multi_read(struct mmc_test_card *test)
         if (size < 1024)
                 return RESULT_UNSUP_HOST;
 
-        for (i = 1;i < 4;i++) {
+        for (i = 1; i < TEST_ALIGN_END; i++) {
                 sg_init_one(&sg, test->buffer + i, size);
                 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
                 if (ret)
@@ -2997,8 +3000,9 @@ err:
         return ret;
 }
 
-static int mmc_test_probe(struct mmc_card *card)
+static int mmc_test_probe(struct device *dev)
 {
+        struct mmc_card *card = mmc_dev_to_card(dev);
         int ret;
 
         if (!mmc_card_mmc(card) && !mmc_card_sd(card))
@@ -3013,20 +3017,22 @@ static int mmc_test_probe(struct mmc_card *card)
         return 0;
 }
 
-static void mmc_test_remove(struct mmc_card *card)
+static int mmc_test_remove(struct device *dev)
 {
+        struct mmc_card *card = mmc_dev_to_card(dev);
+
         mmc_test_free_result(card);
         mmc_test_free_dbgfs_file(card);
+
+        return 0;
 }
 
-static void mmc_test_shutdown(struct mmc_card *card)
+static void mmc_test_shutdown(struct device *dev)
 {
 }
 
-static struct mmc_driver mmc_driver = {
-        .drv            = {
-                .name   = "mmc_test",
-        },
+static struct device_driver mmc_driver = {
+        .name   = "mmc_test",
         .probe          = mmc_test_probe,
         .remove         = mmc_test_remove,
         .shutdown       = mmc_test_shutdown,
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index cfa6110632c3..236d194c2883 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -232,13 +232,15 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
                         if (!mqrq_cur->bounce_buf) {
                                 pr_warn("%s: unable to allocate bounce cur buffer\n",
                                         mmc_card_name(card));
-                        }
-                        mqrq_prev->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
-                        if (!mqrq_prev->bounce_buf) {
-                                pr_warn("%s: unable to allocate bounce prev buffer\n",
-                                        mmc_card_name(card));
-                                kfree(mqrq_cur->bounce_buf);
-                                mqrq_cur->bounce_buf = NULL;
+                        } else {
+                                mqrq_prev->bounce_buf =
+                                                kmalloc(bouncesz, GFP_KERNEL);
+                                if (!mqrq_prev->bounce_buf) {
+                                        pr_warn("%s: unable to allocate bounce prev buffer\n",
+                                                mmc_card_name(card));
+                                        kfree(mqrq_cur->bounce_buf);
+                                        mqrq_cur->bounce_buf = NULL;
+                                }
                         }
                 }
 
diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
index 8a1f1240e058..86d271148528 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -25,8 +25,6 @@
 #include "sdio_cis.h"
 #include "bus.h"
 
-#define to_mmc_driver(d)        container_of(d, struct mmc_driver, drv)
-
 static ssize_t type_show(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
@@ -106,33 +104,14 @@ mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
         return retval;
 }
 
-static int mmc_bus_probe(struct device *dev)
-{
-        struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = mmc_dev_to_card(dev);
-
-        return drv->probe(card);
-}
-
-static int mmc_bus_remove(struct device *dev)
-{
-        struct mmc_driver *drv = to_mmc_driver(dev->driver);
-        struct mmc_card *card = mmc_dev_to_card(dev);
-
-        drv->remove(card);
-
-        return 0;
-}
-
 static void mmc_bus_shutdown(struct device *dev)
 {
-        struct mmc_driver *drv = to_mmc_driver(dev->driver);
         struct mmc_card *card = mmc_dev_to_card(dev);
         struct mmc_host *host = card->host;
         int ret;
 
-        if (dev->driver && drv->shutdown)
-                drv->shutdown(card);
+        if (dev->driver && dev->driver->shutdown)
+                dev->driver->shutdown(dev);
 
         if (host->bus_ops->shutdown) {
                 ret = host->bus_ops->shutdown(host);
@@ -145,16 +124,13 @@ static void mmc_bus_shutdown(struct device *dev)
 #ifdef CONFIG_PM_SLEEP
 static int mmc_bus_suspend(struct device *dev)
 {
-        struct mmc_driver *drv = to_mmc_driver(dev->driver);
         struct mmc_card *card = mmc_dev_to_card(dev);
         struct mmc_host *host = card->host;
         int ret;
 
-        if (dev->driver && drv->suspend) {
-                ret = drv->suspend(card);
-                if (ret)
-                        return ret;
-        }
+        ret = pm_generic_suspend(dev);
+        if (ret)
+                return ret;
 
         ret = host->bus_ops->suspend(host);
         return ret;
@@ -162,7 +138,6 @@ static int mmc_bus_suspend(struct device *dev)
 
 static int mmc_bus_resume(struct device *dev)
 {
-        struct mmc_driver *drv = to_mmc_driver(dev->driver);
         struct mmc_card *card = mmc_dev_to_card(dev);
         struct mmc_host *host = card->host;
         int ret;
@@ -172,14 +147,12 @@ static int mmc_bus_resume(struct device *dev)
                 pr_warn("%s: error %d during resume (card was removed?)\n",
                         mmc_hostname(host), ret);
 
-        if (dev->driver && drv->resume)
-                ret = drv->resume(card);
-
+        ret = pm_generic_resume(dev);
         return ret;
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int mmc_runtime_suspend(struct device *dev)
 {
         struct mmc_card *card = mmc_dev_to_card(dev);
@@ -195,7 +168,7 @@ static int mmc_runtime_resume(struct device *dev)
 
         return host->bus_ops->runtime_resume(host);
 }
-#endif /* !CONFIG_PM_RUNTIME */
+#endif /* !CONFIG_PM */
 
 static const struct dev_pm_ops mmc_bus_pm_ops = {
         SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, NULL)
@@ -207,8 +180,6 @@ static struct bus_type mmc_bus_type = {
         .dev_groups     = mmc_dev_groups,
         .match          = mmc_bus_match,
         .uevent         = mmc_bus_uevent,
-        .probe          = mmc_bus_probe,
-        .remove         = mmc_bus_remove,
         .shutdown       = mmc_bus_shutdown,
         .pm             = &mmc_bus_pm_ops,
 };
@@ -227,24 +198,22 @@ void mmc_unregister_bus(void)
  *      mmc_register_driver - register a media driver
  *      @drv: MMC media driver
  */
-int mmc_register_driver(struct mmc_driver *drv)
+int mmc_register_driver(struct device_driver *drv)
 {
-        drv->drv.bus = &mmc_bus_type;
-        return driver_register(&drv->drv);
+        drv->bus = &mmc_bus_type;
+        return driver_register(drv);
 }
-
 EXPORT_SYMBOL(mmc_register_driver);
 
 /**
  *      mmc_unregister_driver - unregister a media driver
  *      @drv: MMC media driver
  */
-void mmc_unregister_driver(struct mmc_driver *drv)
+void mmc_unregister_driver(struct device_driver *drv)
 {
-        drv->drv.bus = &mmc_bus_type;
-        driver_unregister(&drv->drv);
+        drv->bus = &mmc_bus_type;
+        driver_unregister(drv);
 }
-
 EXPORT_SYMBOL(mmc_unregister_driver);
 
 static void mmc_release_card(struct device *dev)
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index f26a5f1d926d..9584bffa8b22 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -149,6 +149,14 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
 
                 led_trigger_event(host->led, LED_OFF);
 
+                if (mrq->sbc) {
+                        pr_debug("%s: req done <CMD%u>: %d: %08x %08x %08x %08x\n",
+                                mmc_hostname(host), mrq->sbc->opcode,
+                                mrq->sbc->error,
+                                mrq->sbc->resp[0], mrq->sbc->resp[1],
+                                mrq->sbc->resp[2], mrq->sbc->resp[3]);
+                }
+
                 pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
                         mmc_hostname(host), cmd->opcode, err,
                         cmd->resp[0], cmd->resp[1],
@@ -214,6 +222,10 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 
         mrq->cmd->error = 0;
         mrq->cmd->mrq = mrq;
+        if (mrq->sbc) {
+                mrq->sbc->error = 0;
+                mrq->sbc->mrq = mrq;
+        }
         if (mrq->data) {
                 BUG_ON(mrq->data->blksz > host->max_blk_size);
                 BUG_ON(mrq->data->blocks > host->max_blk_count);
@@ -538,8 +550,18 @@ struct mmc_async_req *mmc_start_req(struct mmc_host *host,
                 if (host->card && mmc_card_mmc(host->card) &&
                     ((mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1) ||
                      (mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1B)) &&
-                    (host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT))
+                    (host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT)) {
+
+                        /* Cancel the prepared request */
+                        if (areq)
+                                mmc_post_req(host, areq->mrq, -EINVAL);
+
                         mmc_start_bkops(host->card, true);
+
+                        /* prepare the request again */
+                        if (areq)
+                                mmc_pre_req(host, areq->mrq, !host->areq);
+                }
         }
 
         if (!err && areq)
@@ -709,27 +731,16 @@ int mmc_read_bkops_status(struct mmc_card *card)
         int err;
         u8 *ext_csd;
 
-        /*
-         * In future work, we should consider storing the entire ext_csd.
-         */
-        ext_csd = kmalloc(512, GFP_KERNEL);
-        if (!ext_csd) {
-                pr_err("%s: could not allocate buffer to receive the ext_csd.\n",
-                       mmc_hostname(card->host));
-                return -ENOMEM;
-        }
-
         mmc_claim_host(card->host);
-        err = mmc_send_ext_csd(card, ext_csd);
+        err = mmc_get_ext_csd(card, &ext_csd);
         mmc_release_host(card->host);
         if (err)
-                goto out;
+                return err;
 
         card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS];
         card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS];
-out:
         kfree(ext_csd);
-        return err;
+        return 0;
 }
 EXPORT_SYMBOL(mmc_read_bkops_status);
 
@@ -1088,6 +1099,22 @@ void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
         mmc_host_clk_release(host);
 }
 
+/*
+ * Set initial state after a power cycle or a hw_reset.
+ */
+void mmc_set_initial_state(struct mmc_host *host)
+{
+        if (mmc_host_is_spi(host))
+                host->ios.chip_select = MMC_CS_HIGH;
+        else
+                host->ios.chip_select = MMC_CS_DONTCARE;
+        host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
+        host->ios.bus_width = MMC_BUS_WIDTH_1;
+        host->ios.timing = MMC_TIMING_LEGACY;
+
+        mmc_set_ios(host);
+}
+
 /**
  * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number
  * @vdd:        voltage (mV)
@@ -1420,18 +1447,20 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, u32 ocr)
                 pr_warn("%s: cannot verify signal voltage switch\n",
                         mmc_hostname(host));
 
+        mmc_host_clk_hold(host);
+
         cmd.opcode = SD_SWITCH_VOLTAGE;
         cmd.arg = 0;
         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
         err = mmc_wait_for_cmd(host, &cmd, 0);
         if (err)
-                return err;
+                goto err_command;
 
-        if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
-                return -EIO;
-
-        mmc_host_clk_hold(host);
+        if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR)) {
+                err = -EIO;
+                goto err_command;
+        }
         /*
          * The card should drive cmd and dat[0:3] low immediately
          * after the response of cmd11, but wait 1 ms to be sure
@@ -1480,6 +1509,7 @@ power_cycle:
                 mmc_power_cycle(host, ocr);
         }
 
+err_command:
         mmc_host_clk_release(host);
 
         return err;
@@ -1526,15 +1556,9 @@ void mmc_power_up(struct mmc_host *host, u32 ocr)
         mmc_host_clk_hold(host);
 
         host->ios.vdd = fls(ocr) - 1;
-        if (mmc_host_is_spi(host))
-                host->ios.chip_select = MMC_CS_HIGH;
-        else
-                host->ios.chip_select = MMC_CS_DONTCARE;
-        host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
         host->ios.power_mode = MMC_POWER_UP;
-        host->ios.bus_width = MMC_BUS_WIDTH_1;
-        host->ios.timing = MMC_TIMING_LEGACY;
-        mmc_set_ios(host);
+        /* Set initial state and call mmc_set_ios */
+        mmc_set_initial_state(host);
 
         /* Try to set signal voltage to 3.3V but fall back to 1.8v or 1.2v */
         if (__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330) == 0)
@@ -1574,14 +1598,9 @@ void mmc_power_off(struct mmc_host *host)
         host->ios.clock = 0;
         host->ios.vdd = 0;
 
-        if (!mmc_host_is_spi(host)) {
-                host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
-                host->ios.chip_select = MMC_CS_DONTCARE;
-        }
         host->ios.power_mode = MMC_POWER_OFF;
-        host->ios.bus_width = MMC_BUS_WIDTH_1;
-        host->ios.timing = MMC_TIMING_LEGACY;
-        mmc_set_ios(host);
+        /* Set initial state and call mmc_set_ios */
+        mmc_set_initial_state(host);
 
         /*
          * Some configurations, such as the 802.11 SDIO card in the OLPC
@@ -2259,30 +2278,16 @@ static int mmc_do_hw_reset(struct mmc_host *host, int check)
 
         /* If the reset has happened, then a status command will fail */
         if (check) {
-                struct mmc_command cmd = {0};
-                int err;
+                u32 status;
 
-                cmd.opcode = MMC_SEND_STATUS;
-                if (!mmc_host_is_spi(card->host))
-                        cmd.arg = card->rca << 16;
-                cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
-                err = mmc_wait_for_cmd(card->host, &cmd, 0);
-                if (!err) {
+                if (!mmc_send_status(card, &status)) {
                         mmc_host_clk_release(host);
                         return -ENOSYS;
                 }
         }
 
-        if (mmc_host_is_spi(host)) {
-                host->ios.chip_select = MMC_CS_HIGH;
-                host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
-        } else {
-                host->ios.chip_select = MMC_CS_DONTCARE;
-                host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
-        }
-        host->ios.bus_width = MMC_BUS_WIDTH_1;
-        host->ios.timing = MMC_TIMING_LEGACY;
-        mmc_set_ios(host);
+        /* Set initial state and call mmc_set_ios */
+        mmc_set_initial_state(host);
 
         mmc_host_clk_release(host);
 
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index 443a584660f0..d76597c65e3a 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -49,6 +49,7 @@ void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type);
 void mmc_power_up(struct mmc_host *host, u32 ocr);
 void mmc_power_off(struct mmc_host *host);
 void mmc_power_cycle(struct mmc_host *host, u32 ocr);
+void mmc_set_initial_state(struct mmc_host *host);
 
 static inline void mmc_delay(unsigned int ms)
 {
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
index 91eb16223246..e9142108a6c6 100644
--- a/drivers/mmc/core/debugfs.c
+++ b/drivers/mmc/core/debugfs.c
@@ -291,14 +291,8 @@ static int mmc_ext_csd_open(struct inode *inode, struct file *filp)
         if (!buf)
                 return -ENOMEM;
 
-        ext_csd = kmalloc(512, GFP_KERNEL);
-        if (!ext_csd) {
-                err = -ENOMEM;
-                goto out_free;
-        }
-
         mmc_get_card(card);
-        err = mmc_send_ext_csd(card, ext_csd);
+        err = mmc_get_ext_csd(card, &ext_csd);
         mmc_put_card(card);
         if (err)
                 goto out_free;
@@ -314,7 +308,6 @@ static int mmc_ext_csd_open(struct inode *inode, struct file *filp)
 
 out_free:
         kfree(buf);
-        kfree(ext_csd);
         return err;
 }
 
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index a301a78a2bd1..02ad79229f65 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -177,65 +177,6 @@ static int mmc_decode_csd(struct mmc_card *card)
         return 0;
 }
 
-/*
- * Read extended CSD.
- */
-static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
-{
-        int err;
-        u8 *ext_csd;
-
-        BUG_ON(!card);
-        BUG_ON(!new_ext_csd);
-
-        *new_ext_csd = NULL;
-
-        if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
-                return 0;
-
-        /*
-         * As the ext_csd is so large and mostly unused, we don't store the
-         * raw block in mmc_card.
-         */
-        ext_csd = kmalloc(512, GFP_KERNEL);
-        if (!ext_csd) {
-                pr_err("%s: could not allocate a buffer to "
-                        "receive the ext_csd.\n", mmc_hostname(card->host));
-                return -ENOMEM;
-        }
-
-        err = mmc_send_ext_csd(card, ext_csd);
-        if (err) {
-                kfree(ext_csd);
-                *new_ext_csd = NULL;
-
-                /* If the host or the card can't do the switch,
-                 * fail more gracefully. */
-                if ((err != -EINVAL)
-                 && (err != -ENOSYS)
-                 && (err != -EFAULT))
-                        return err;
-
-                /*
-                 * High capacity cards should have this "magic" size
-                 * stored in their CSD.
-                 */
-                if (card->csd.capacity == (4096 * 512)) {
-                        pr_err("%s: unable to read EXT_CSD "
-                                "on a possible high capacity card. "
-                                "Card will be ignored.\n",
-                                mmc_hostname(card->host));
-                } else {
-                        pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",
-                                mmc_hostname(card->host));
-                        err = 0;
-                }
-        } else
-                *new_ext_csd = ext_csd;
-
-        return err;
-}
-
 static void mmc_select_card_type(struct mmc_card *card)
 {
         struct mmc_host *host = card->host;
@@ -391,16 +332,11 @@ static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)
 /*
  * Decode extended CSD.
  */
-static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
+static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
 {
         int err = 0, idx;
         unsigned int part_size;
 
-        BUG_ON(!card);
-
-        if (!ext_csd)
-                return 0;
-
         /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
         card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
         if (card->csd.structure == 3) {
@@ -628,16 +564,56 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
                 card->ext_csd.data_sector_size = 512;
         }
 
+        /* eMMC v5 or later */
+        if (card->ext_csd.rev >= 7) {
+                memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],
+                       MMC_FIRMWARE_LEN);
+                card->ext_csd.ffu_capable =
+                        (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&
+                        !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1);
+        }
 out:
         return err;
 }
 
-static inline void mmc_free_ext_csd(u8 *ext_csd)
+static int mmc_read_ext_csd(struct mmc_card *card)
 {
+        u8 *ext_csd;
+        int err;
+
+        if (!mmc_can_ext_csd(card))
+                return 0;
+
+        err = mmc_get_ext_csd(card, &ext_csd);
+        if (err) {
+                /* If the host or the card can't do the switch,
+                 * fail more gracefully. */
+                if ((err != -EINVAL)
+                 && (err != -ENOSYS)
+                 && (err != -EFAULT))
+                        return err;
+
+                /*
+                 * High capacity cards should have this "magic" size
+                 * stored in their CSD.
+                 */
+                if (card->csd.capacity == (4096 * 512)) {
+                        pr_err("%s: unable to read EXT_CSD on a possible high capacity card. Card will be ignored.\n",
+                                mmc_hostname(card->host));
+                } else {
+                        pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",
+                                mmc_hostname(card->host));
+                        err = 0;
+                }
+
+                return err;
+        }
+
+        err = mmc_decode_ext_csd(card, ext_csd);
         kfree(ext_csd);
+        return err;
 }
 
-
 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
 {
         u8 *bw_ext_csd;
@@ -647,11 +623,8 @@ static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
                 return 0;
 
         err = mmc_get_ext_csd(card, &bw_ext_csd);
-
-        if (err || bw_ext_csd == NULL) {
-                err = -EINVAL;
-                goto out;
-        }
+        if (err)
+                return err;
 
         /* only compare read only fields */
         err = !((card->ext_csd.raw_partition_support ==
@@ -710,8 +683,7 @@ static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
         if (err)
                 err = -EINVAL;
 
-out:
-        mmc_free_ext_csd(bw_ext_csd);
+        kfree(bw_ext_csd);
         return err;
 }
 
@@ -722,7 +694,7 @@ MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
-MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
+MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
@@ -735,6 +707,22 @@ MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
 
+static ssize_t mmc_fwrev_show(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        struct mmc_card *card = mmc_dev_to_card(dev);
+
+        if (card->ext_csd.rev < 7) {
+                return sprintf(buf, "0x%x\n", card->cid.fwrev);
+        } else {
+                return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
+                               card->ext_csd.fwrev);
+        }
+}
+
+static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
+
 static struct attribute *mmc_std_attrs[] = {
         &dev_attr_cid.attr,
         &dev_attr_csd.attr,
@@ -742,6 +730,7 @@ static struct attribute *mmc_std_attrs[] = {
         &dev_attr_erase_size.attr,
         &dev_attr_preferred_erase_size.attr,
         &dev_attr_fwrev.attr,
+        &dev_attr_ffu_capable.attr,
         &dev_attr_hwrev.attr,
         &dev_attr_manfid.attr,
         &dev_attr_name.attr,
@@ -774,14 +763,6 @@ static int __mmc_select_powerclass(struct mmc_card *card,
         unsigned int pwrclass_val = 0;
         int err = 0;
 
-        /* Power class selection is supported for versions >= 4.0 */
-        if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
-                return 0;
-
-        /* Power class values are defined only for 4/8 bit bus */
-        if (bus_width == EXT_CSD_BUS_WIDTH_1)
-                return 0;
-
         switch (1 << host->ios.vdd) {
         case MMC_VDD_165_195:
                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
@@ -844,7 +825,7 @@ static int mmc_select_powerclass(struct mmc_card *card)
         int err, ddr;
 
         /* Power class selection is supported for versions >= 4.0 */
-        if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
+        if (!mmc_can_ext_csd(card))
                 return 0;
 
         bus_width = host->ios.bus_width;
@@ -905,7 +886,7 @@ static int mmc_select_bus_width(struct mmc_card *card)
         unsigned idx, bus_width = 0;
         int err = 0;
 
-        if ((card->csd.mmca_vsn < CSD_SPEC_VER_4) &&
+        if (!mmc_can_ext_csd(card) &&
             !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
                 return 0;
 
@@ -998,7 +979,7 @@ static int mmc_select_hs_ddr(struct mmc_card *card)
                         ext_csd_bits,
                         card->ext_csd.generic_cmd6_time);
         if (err) {
-                pr_warn("%s: switch to bus width %d ddr failed\n",
+                pr_err("%s: switch to bus width %d ddr failed\n",
                         mmc_hostname(host), 1 << bus_width);
                 return err;
         }
@@ -1069,7 +1050,7 @@ static int mmc_select_hs400(struct mmc_card *card)
                            card->ext_csd.generic_cmd6_time,
                            true, true, true);
         if (err) {
-                pr_warn("%s: switch to high-speed from hs200 failed, err:%d\n",
+                pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
                         mmc_hostname(host), err);
                 return err;
         }
@@ -1079,7 +1060,7 @@ static int mmc_select_hs400(struct mmc_card *card)
                          EXT_CSD_DDR_BUS_WIDTH_8,
                          card->ext_csd.generic_cmd6_time);
         if (err) {
-                pr_warn("%s: switch to bus width for hs400 failed, err:%d\n",
+                pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
                         mmc_hostname(host), err);
                 return err;
         }
@@ -1089,7 +1070,7 @@ static int mmc_select_hs400(struct mmc_card *card)
                            card->ext_csd.generic_cmd6_time,
                            true, true, true);
         if (err) {
-                pr_warn("%s: switch to hs400 failed, err:%d\n",
+                pr_err("%s: switch to hs400 failed, err:%d\n",
                          mmc_hostname(host), err);
                 return err;
         }
@@ -1146,8 +1127,7 @@ static int mmc_select_timing(struct mmc_card *card)
 {
         int err = 0;
 
-        if ((card->csd.mmca_vsn < CSD_SPEC_VER_4 &&
-             card->ext_csd.hs_max_dtr == 0))
+        if (!mmc_can_ext_csd(card))
                 goto bus_speed;
 
         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
@@ -1232,7 +1212,7 @@ static int mmc_hs200_tuning(struct mmc_card *card)
                 mmc_host_clk_release(host);
 
                 if (err)
-                        pr_warn("%s: tuning execution failed\n",
+                        pr_err("%s: tuning execution failed\n",
                                 mmc_hostname(host));
         }
 
@@ -1252,7 +1232,6 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         int err;
         u32 cid[4];
         u32 rocr;
-        u8 *ext_csd = NULL;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
@@ -1361,14 +1340,8 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         }
 
         if (!oldcard) {
-                /*
-                 * Fetch and process extended CSD.
-                 */
-
-                err = mmc_get_ext_csd(card, &ext_csd);
-                if (err)
-                        goto free_card;
-                err = mmc_read_ext_csd(card, ext_csd);
+                /* Read extended CSD. */
+                err = mmc_read_ext_csd(card);
                 if (err)
                         goto free_card;
 
@@ -1458,18 +1431,18 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         if (mmc_card_hs200(card)) {
                 err = mmc_hs200_tuning(card);
                 if (err)
-                        goto err;
+                        goto free_card;
 
                 err = mmc_select_hs400(card);
                 if (err)
-                        goto err;
+                        goto free_card;
         } else if (mmc_card_hs(card)) {
                 /* Select the desired bus width optionally */
                 err = mmc_select_bus_width(card);
                 if (!IS_ERR_VALUE(err)) {
                         err = mmc_select_hs_ddr(card);
                         if (err)
-                                goto err;
+                                goto free_card;
                 }
         }
 
@@ -1545,15 +1518,12 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         if (!oldcard)
                 host->card = card;
 
-        mmc_free_ext_csd(ext_csd);
         return 0;
 
 free_card:
         if (!oldcard)
                 mmc_remove_card(card);
 err:
-        mmc_free_ext_csd(ext_csd);
-
         return err;
 }
 
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 7911e0510a1d..3b044c5b029c 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -264,20 +264,6 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
         struct mmc_command cmd = {0};
         struct mmc_data data = {0};
         struct scatterlist sg;
-        void *data_buf;
-        int is_on_stack;
-
-        is_on_stack = object_is_on_stack(buf);
-        if (is_on_stack) {
-                /*
-                 * dma onto stack is unsafe/nonportable, but callers to this
-                 * routine normally provide temporary on-stack buffers ...
-                 */
-                data_buf = kmalloc(len, GFP_KERNEL);
-                if (!data_buf)
-                        return -ENOMEM;
-        } else
-                data_buf = buf;
 
         mrq.cmd = &cmd;
         mrq.data = &data;
@@ -298,7 +284,7 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
         data.sg = &sg;
         data.sg_len = 1;
 
-        sg_init_one(&sg, data_buf, len);
+        sg_init_one(&sg, buf, len);
 
         if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
                 /*
@@ -312,11 +298,6 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
 
         mmc_wait_for_req(host, &mrq);
 
-        if (is_on_stack) {
-                memcpy(buf, data_buf, len);
-                kfree(data_buf);
-        }
-
         if (cmd.error)
                 return cmd.error;
         if (data.error)
@@ -334,7 +315,7 @@ int mmc_send_csd(struct mmc_card *card, u32 *csd)
                 return mmc_send_cxd_native(card->host, card->rca << 16,
                                 csd, MMC_SEND_CSD);
 
-        csd_tmp = kmalloc(16, GFP_KERNEL);
+        csd_tmp = kzalloc(16, GFP_KERNEL);
         if (!csd_tmp)
                 return -ENOMEM;
 
@@ -362,7 +343,7 @@ int mmc_send_cid(struct mmc_host *host, u32 *cid)
                                 cid, MMC_SEND_CID);
         }
 
-        cid_tmp = kmalloc(16, GFP_KERNEL);
+        cid_tmp = kzalloc(16, GFP_KERNEL);
         if (!cid_tmp)
                 return -ENOMEM;
 
@@ -378,12 +359,35 @@ err:
         return ret;
 }
 
-int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
+int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
 {
-        return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD,
-                        ext_csd, 512);
+        int err;
+        u8 *ext_csd;
+
+        if (!card || !new_ext_csd)
+                return -EINVAL;
+
+        if (!mmc_can_ext_csd(card))
+                return -EOPNOTSUPP;
+
+        /*
+         * As the ext_csd is so large and mostly unused, we don't store the
+         * raw block in mmc_card.
+         */
+        ext_csd = kzalloc(512, GFP_KERNEL);
+        if (!ext_csd)
+                return -ENOMEM;
+
+        err = mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, ext_csd,
+                                512);
+        if (err)
+                kfree(ext_csd);
+        else
+                *new_ext_csd = ext_csd;
+
+        return err;
 }
-EXPORT_SYMBOL_GPL(mmc_send_ext_csd);
+EXPORT_SYMBOL_GPL(mmc_get_ext_csd);
 
 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
 {
@@ -543,6 +547,75 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
 }
 EXPORT_SYMBOL_GPL(mmc_switch);
 
+int mmc_send_tuning(struct mmc_host *host)
+{
+        struct mmc_request mrq = {NULL};
+        struct mmc_command cmd = {0};
+        struct mmc_data data = {0};
+        struct scatterlist sg;
+        struct mmc_ios *ios = &host->ios;
+        const u8 *tuning_block_pattern;
+        int size, err = 0;
+        u8 *data_buf;
+        u32 opcode;
+
+        if (ios->bus_width == MMC_BUS_WIDTH_8) {
+                tuning_block_pattern = tuning_blk_pattern_8bit;
+                size = sizeof(tuning_blk_pattern_8bit);
+                opcode = MMC_SEND_TUNING_BLOCK_HS200;
+        } else if (ios->bus_width == MMC_BUS_WIDTH_4) {
+                tuning_block_pattern = tuning_blk_pattern_4bit;
+                size = sizeof(tuning_blk_pattern_4bit);
+                opcode = MMC_SEND_TUNING_BLOCK;
+        } else
+                return -EINVAL;
+
+        data_buf = kzalloc(size, GFP_KERNEL);
+        if (!data_buf)
+                return -ENOMEM;
+
+        mrq.cmd = &cmd;
+        mrq.data = &data;
+
+        cmd.opcode = opcode;
+        cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
+
+        data.blksz = size;
+        data.blocks = 1;
+        data.flags = MMC_DATA_READ;
+
+        /*
+         * According to the tuning specs, Tuning process
+         * is normally shorter 40 executions of CMD19,
+         * and timeout value should be shorter than 150 ms
+         */
+        data.timeout_ns = 150 * NSEC_PER_MSEC;
+
+        data.sg = &sg;
+        data.sg_len = 1;
+        sg_init_one(&sg, data_buf, size);
+
+        mmc_wait_for_req(host, &mrq);
+
+        if (cmd.error) {
+                err = cmd.error;
+                goto out;
+        }
+
+        if (data.error) {
+                err = data.error;
+                goto out;
+        }
+
+        if (memcmp(data_buf, tuning_block_pattern, size))
+                err = -EIO;
+
+out:
+        kfree(data_buf);
+        return err;
+}
+EXPORT_SYMBOL_GPL(mmc_send_tuning);
+
 static int
 mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
                   u8 len)
@@ -675,3 +748,8 @@ int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status)
 
         return 0;
 }
+
+int mmc_can_ext_csd(struct mmc_card *card)
+{
+        return (card && card->csd.mmca_vsn > CSD_SPEC_VER_3);
+}
diff --git a/drivers/mmc/core/mmc_ops.h b/drivers/mmc/core/mmc_ops.h
index 390dac665b2a..6f4b00ed93de 100644
--- a/drivers/mmc/core/mmc_ops.h
+++ b/drivers/mmc/core/mmc_ops.h
@@ -20,13 +20,13 @@ int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr);
 int mmc_all_send_cid(struct mmc_host *host, u32 *cid);
 int mmc_set_relative_addr(struct mmc_card *card);
 int mmc_send_csd(struct mmc_card *card, u32 *csd);
-int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd);
 int mmc_send_status(struct mmc_card *card, u32 *status);
 int mmc_send_cid(struct mmc_host *host, u32 *cid);
 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp);
 int mmc_spi_set_crc(struct mmc_host *host, int use_crc);
 int mmc_bus_test(struct mmc_card *card, u8 bus_width);
 int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status);
+int mmc_can_ext_csd(struct mmc_card *card);
 
 #endif
 
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index 2439e717655b..fd0750b5a634 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -980,8 +980,12 @@ static int mmc_sdio_resume(struct mmc_host *host)
         if (mmc_card_is_removable(host) || !mmc_card_keep_power(host)) {
                 sdio_reset(host);
                 mmc_go_idle(host);
-                err = mmc_sdio_init_card(host, host->card->ocr, host->card,
-                                        mmc_card_keep_power(host));
+                mmc_send_if_cond(host, host->card->ocr);
+                err = mmc_send_io_op_cond(host, 0, NULL);
+                if (!err)
+                        err = mmc_sdio_init_card(host, host->card->ocr,
+                                                 host->card,
+                                                 mmc_card_keep_power(host));
         } else if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
                 /* We may have switched to 1-bit mode during suspend */
                 err = sdio_enable_4bit_bus(host->card);
@@ -1035,7 +1039,7 @@ static int mmc_sdio_power_restore(struct mmc_host *host)
 
         sdio_reset(host);
         mmc_go_idle(host);
-        mmc_send_if_cond(host, host->ocr_avail);
+        mmc_send_if_cond(host, host->card->ocr);
 
         ret = mmc_send_io_op_cond(host, 0, NULL);
         if (ret)
diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 6da97b170563..60885316afba 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -26,6 +26,8 @@
 #include "sdio_cis.h"
 #include "sdio_bus.h"
 
+#define to_sdio_driver(d)       container_of(d, struct sdio_driver, drv)
+
 /* show configuration fields */
 #define sdio_config_attr(field, format_string)                          \
 static ssize_t                                                          \
@@ -196,8 +198,6 @@ static int sdio_bus_remove(struct device *dev)
         return ret;
 }
 
-#ifdef CONFIG_PM
-
 static const struct dev_pm_ops sdio_bus_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(pm_generic_suspend, pm_generic_resume)
         SET_RUNTIME_PM_OPS(
@@ -207,14 +207,6 @@ static const struct dev_pm_ops sdio_bus_pm_ops = {
         )
 };
 
-#define SDIO_PM_OPS_PTR (&sdio_bus_pm_ops)
-
-#else /* !CONFIG_PM */
-
-#define SDIO_PM_OPS_PTR NULL
-
-#endif /* !CONFIG_PM */
-
 static struct bus_type sdio_bus_type = {
         .name           = "sdio",
         .dev_groups     = sdio_dev_groups,
@@ -222,7 +214,7 @@ static struct bus_type sdio_bus_type = {
         .uevent         = sdio_bus_uevent,
         .probe          = sdio_bus_probe,
         .remove         = sdio_bus_remove,
-        .pm             = SDIO_PM_OPS_PTR,
+        .pm             = &sdio_bus_pm_ops,
 };
 
 int sdio_register_bus(void)
@@ -295,7 +287,7 @@ struct sdio_func *sdio_alloc_func(struct mmc_card *card)
 static void sdio_acpi_set_handle(struct sdio_func *func)
 {
         struct mmc_host *host = func->card->host;
-        u64 addr = (host->slotno << 16) | func->num;
+        u64 addr = ((u64)host->slotno << 16) | func->num;
 
         acpi_preset_companion(&func->dev, ACPI_COMPANION(host->parent), addr);
 }
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 13860656104b..2d6fbdd11803 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -580,7 +580,7 @@ config SDH_BFIN_MISSING_CMD_PULLUP_WORKAROUND
 config MMC_DW
         tristate "Synopsys DesignWare Memory Card Interface"
         depends on HAS_DMA
-        depends on ARC || ARM || MIPS || COMPILE_TEST
+        depends on ARC || ARM || ARM64 || MIPS || COMPILE_TEST
         help
           This selects support for the Synopsys DesignWare Mobile Storage IP
           block, this provides host support for SD and MMC interfaces, in both
@@ -748,3 +748,8 @@ config MMC_SUNXI
         help
           This selects support for the SD/MMC Host Controller on
           Allwinner sunxi SoCs.
+
+config MMC_TOSHIBA_PCI
+        tristate "Toshiba Type A SD/MMC Card Interface Driver"
+        depends on PCI
+        help
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index b09ecfb88269..f7b0a77cf419 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -55,6 +55,7 @@ obj-$(CONFIG_MMC_WMT)		+= wmt-sdmmc.o
 obj-$(CONFIG_MMC_MOXART)        += moxart-mmc.o
 obj-$(CONFIG_MMC_SUNXI)         += sunxi-mmc.o
 obj-$(CONFIG_MMC_USDHI6ROL0)    += usdhi6rol0.o
+obj-$(CONFIG_MMC_TOSHIBA_PCI)   += toshsd.o
 
 obj-$(CONFIG_MMC_REALTEK_PCI)   += rtsx_pci_sdmmc.o
 obj-$(CONFIG_MMC_REALTEK_USB)   += rtsx_usb_sdmmc.o
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 77250d4b1979..62aba9af19f4 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -30,13 +30,16 @@
 #include <linux/stat.h>
 #include <linux/types.h>
 #include <linux/platform_data/atmel.h>
+#include <linux/platform_data/mmc-atmel-mci.h>
 
 #include <linux/mmc/host.h>
 #include <linux/mmc/sdio.h>
 
-#include <mach/atmel-mci.h>
 #include <linux/atmel-mci.h>
 #include <linux/atmel_pdc.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/pinctrl/consumer.h>
 
 #include <asm/cacheflush.h>
 #include <asm/io.h>
@@ -44,6 +47,8 @@
 
 #include "atmel-mci-regs.h"
 
+#define AUTOSUSPEND_DELAY       50
+
 #define ATMCI_DATA_ERROR_FLAGS  (ATMCI_DCRCE | ATMCI_DTOE | ATMCI_OVRE | ATMCI_UNRE)
 #define ATMCI_DMA_THRESHOLD     16
 
@@ -386,20 +391,19 @@ static int atmci_regs_show(struct seq_file *s, void *v)
         if (!buf)
                 return -ENOMEM;
 
+        pm_runtime_get_sync(&host->pdev->dev);
+
         /*
          * Grab a more or less consistent snapshot. Note that we're
          * not disabling interrupts, so IMR and SR may not be
          * consistent.
          */
-        ret = clk_prepare_enable(host->mck);
-        if (ret)
-                goto out;
-
         spin_lock_bh(&host->lock);
         memcpy_fromio(buf, host->regs, ATMCI_REGS_SIZE);
         spin_unlock_bh(&host->lock);
 
-        clk_disable_unprepare(host->mck);
+        pm_runtime_mark_last_busy(&host->pdev->dev);
+        pm_runtime_put_autosuspend(&host->pdev->dev);
 
         seq_printf(s, "MR:\t0x%08x%s%s ",
                         buf[ATMCI_MR / 4],
@@ -449,7 +453,6 @@ static int atmci_regs_show(struct seq_file *s, void *v)
                                 val & ATMCI_CFG_LSYNC ? " LSYNC" : "");
         }
 
-out:
         kfree(buf);
 
         return ret;
@@ -560,6 +563,9 @@ atmci_of_init(struct platform_device *pdev)
                 pdata->slot[slot_id].detect_is_active_high =
                         of_property_read_bool(cnp, "cd-inverted");
 
+                pdata->slot[slot_id].non_removable =
+                        of_property_read_bool(cnp, "non-removable");
+
                 pdata->slot[slot_id].wp_pin =
                         of_get_named_gpio(cnp, "wp-gpios", 0);
         }
@@ -1252,6 +1258,8 @@ static void atmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
         WARN_ON(slot->mrq);
         dev_dbg(&host->pdev->dev, "MRQ: cmd %u\n", mrq->cmd->opcode);
 
+        pm_runtime_get_sync(&host->pdev->dev);
+
         /*
          * We may "know" the card is gone even though there's still an
          * electrical connection. If so, we really need to communicate
@@ -1281,7 +1289,8 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         struct atmel_mci_slot   *slot = mmc_priv(mmc);
         struct atmel_mci        *host = slot->host;
         unsigned int            i;
-        bool                    unprepare_clk;
+
+        pm_runtime_get_sync(&host->pdev->dev);
 
         slot->sdc_reg &= ~ATMCI_SDCBUS_MASK;
         switch (ios->bus_width) {
@@ -1297,13 +1306,8 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 unsigned int clock_min = ~0U;
                 u32 clkdiv;
 
-                clk_prepare(host->mck);
-                unprepare_clk = true;
-
                 spin_lock_bh(&host->lock);
                 if (!host->mode_reg) {
-                        clk_enable(host->mck);
-                        unprepare_clk = false;
                         atmci_writel(host, ATMCI_CR, ATMCI_CR_SWRST);
                         atmci_writel(host, ATMCI_CR, ATMCI_CR_MCIEN);
                         if (host->caps.has_cfg_reg)
@@ -1371,8 +1375,6 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         } else {
                 bool any_slot_active = false;
 
-                unprepare_clk = false;
-
                 spin_lock_bh(&host->lock);
                 slot->clock = 0;
                 for (i = 0; i < ATMCI_MAX_NR_SLOTS; i++) {
@@ -1385,17 +1387,12 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                         atmci_writel(host, ATMCI_CR, ATMCI_CR_MCIDIS);
                         if (host->mode_reg) {
                                 atmci_readl(host, ATMCI_MR);
-                                clk_disable(host->mck);
-                                unprepare_clk = true;
                         }
                         host->mode_reg = 0;
                 }
                 spin_unlock_bh(&host->lock);
         }
 
-        if (unprepare_clk)
-                clk_unprepare(host->mck);
-
         switch (ios->power_mode) {
         case MMC_POWER_OFF:
                 if (!IS_ERR(mmc->supply.vmmc))
@@ -1421,6 +1418,9 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                  */
                 break;
         }
+
+        pm_runtime_mark_last_busy(&host->pdev->dev);
+        pm_runtime_put_autosuspend(&host->pdev->dev);
 }
 
 static int atmci_get_ro(struct mmc_host *mmc)
@@ -1512,6 +1512,9 @@ static void atmci_request_end(struct atmel_mci *host, struct mmc_request *mrq)
         spin_unlock(&host->lock);
         mmc_request_done(prev_mmc, mrq);
         spin_lock(&host->lock);
+
+        pm_runtime_mark_last_busy(&host->pdev->dev);
+        pm_runtime_put_autosuspend(&host->pdev->dev);
 }
 
 static void atmci_command_complete(struct atmel_mci *host,
@@ -2137,7 +2140,7 @@ static irqreturn_t atmci_detect_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int __init atmci_init_slot(struct atmel_mci *host,
+static int atmci_init_slot(struct atmel_mci *host,
                 struct mci_slot_pdata *slot_data, unsigned int id,
                 u32 sdc_reg, u32 sdio_irq)
 {
@@ -2206,8 +2209,12 @@ static int __init atmci_init_slot(struct atmel_mci *host,
                 }
         }
 
-        if (!gpio_is_valid(slot->detect_pin))
-                mmc->caps |= MMC_CAP_NEEDS_POLL;
+        if (!gpio_is_valid(slot->detect_pin)) {
+                if (slot_data->non_removable)
+                        mmc->caps |= MMC_CAP_NONREMOVABLE;
+                else
+                        mmc->caps |= MMC_CAP_NEEDS_POLL;
+        }
 
         if (gpio_is_valid(slot->wp_pin)) {
                 if (devm_gpio_request(&host->pdev->dev, slot->wp_pin,
@@ -2265,55 +2272,25 @@ static void atmci_cleanup_slot(struct atmel_mci_slot *slot,
         mmc_free_host(slot->mmc);
 }
 
-static bool atmci_filter(struct dma_chan *chan, void *pdata)
+static int atmci_configure_dma(struct atmel_mci *host)
 {
-        struct mci_platform_data *sl_pdata = pdata;
-        struct mci_dma_data *sl;
-
-        if (!sl_pdata)
-                return false;
+        host->dma.chan = dma_request_slave_channel_reason(&host->pdev->dev,
+                                                        "rxtx");
+        if (IS_ERR(host->dma.chan))
+                return PTR_ERR(host->dma.chan);
+
+        dev_info(&host->pdev->dev, "using %s for DMA transfers\n",
+                 dma_chan_name(host->dma.chan));
+
+        host->dma_conf.src_addr = host->mapbase + ATMCI_RDR;
+        host->dma_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        host->dma_conf.src_maxburst = 1;
+        host->dma_conf.dst_addr = host->mapbase + ATMCI_TDR;
+        host->dma_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        host->dma_conf.dst_maxburst = 1;
+        host->dma_conf.device_fc = false;
 
-        sl = sl_pdata->dma_slave;
-        if (sl && find_slave_dev(sl) == chan->device->dev) {
-                chan->private = slave_data_ptr(sl);
-                return true;
-        } else {
-                return false;
-        }
-}
-
-static bool atmci_configure_dma(struct atmel_mci *host)
-{
-        struct mci_platform_data        *pdata;
-        dma_cap_mask_t mask;
-
-        if (host == NULL)
-                return false;
-
-        pdata = host->pdev->dev.platform_data;
-
-        dma_cap_zero(mask);
-        dma_cap_set(DMA_SLAVE, mask);
-
-        host->dma.chan = dma_request_slave_channel_compat(mask, atmci_filter, pdata,
-                                                          &host->pdev->dev, "rxtx");
-        if (!host->dma.chan) {
-                dev_warn(&host->pdev->dev, "no DMA channel available\n");
-                return false;
-        } else {
-                dev_info(&host->pdev->dev,
-                                        "using %s for DMA transfers\n",
-                                        dma_chan_name(host->dma.chan));
-
-                host->dma_conf.src_addr = host->mapbase + ATMCI_RDR;
-                host->dma_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-                host->dma_conf.src_maxburst = 1;
-                host->dma_conf.dst_addr = host->mapbase + ATMCI_TDR;
-                host->dma_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-                host->dma_conf.dst_maxburst = 1;
-                host->dma_conf.device_fc = false;
-                return true;
-        }
+        return 0;
 }
 
 /*
@@ -2321,7 +2298,7 @@ static bool atmci_configure_dma(struct atmel_mci *host)
  * HSMCI provides DMA support and a new config register but no more supports
  * PDC.
  */
-static void __init atmci_get_cap(struct atmel_mci *host)
+static void atmci_get_cap(struct atmel_mci *host)
 {
         unsigned int version;
 
@@ -2370,7 +2347,7 @@ static void __init atmci_get_cap(struct atmel_mci *host)
         }
 }
 
-static int __init atmci_probe(struct platform_device *pdev)
+static int atmci_probe(struct platform_device *pdev)
 {
         struct mci_platform_data        *pdata;
         struct atmel_mci                *host;
@@ -2417,19 +2394,23 @@ static int __init atmci_probe(struct platform_device *pdev)
 
         atmci_writel(host, ATMCI_CR, ATMCI_CR_SWRST);
         host->bus_hz = clk_get_rate(host->mck);
-        clk_disable_unprepare(host->mck);
 
         host->mapbase = regs->start;
 
         tasklet_init(&host->tasklet, atmci_tasklet_func, (unsigned long)host);
 
         ret = request_irq(irq, atmci_interrupt, 0, dev_name(&pdev->dev), host);
-        if (ret)
+        if (ret) {
+                clk_disable_unprepare(host->mck);
                 return ret;
+        }
 
         /* Get MCI capabilities and set operations according to it */
         atmci_get_cap(host);
-        if (atmci_configure_dma(host)) {
+        ret = atmci_configure_dma(host);
+        if (ret == -EPROBE_DEFER)
+                goto err_dma_probe_defer;
+        if (ret == 0) {
                 host->prepare_data = &atmci_prepare_data_dma;
                 host->submit_data = &atmci_submit_data_dma;
                 host->stop_transfer = &atmci_stop_transfer_dma;
@@ -2449,6 +2430,12 @@ static int __init atmci_probe(struct platform_device *pdev)
 
         setup_timer(&host->timer, atmci_timeout_timer, (unsigned long)host);
 
+        pm_runtime_get_noresume(&pdev->dev);
+        pm_runtime_set_active(&pdev->dev);
+        pm_runtime_set_autosuspend_delay(&pdev->dev, AUTOSUSPEND_DELAY);
+        pm_runtime_use_autosuspend(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
         /* We need at least one slot to succeed */
         nr_slots = 0;
         ret = -ENODEV;
@@ -2491,6 +2478,9 @@ static int __init atmci_probe(struct platform_device *pdev)
                         "Atmel MCI controller at 0x%08lx irq %d, %u slots\n",
                         host->mapbase, irq, nr_slots);
 
+        pm_runtime_mark_last_busy(&host->pdev->dev);
+        pm_runtime_put_autosuspend(&pdev->dev);
+
         return 0;
 
 err_dma_alloc:
@@ -2499,18 +2489,26 @@ err_dma_alloc:
                         atmci_cleanup_slot(host->slot[i], i);
         }
 err_init_slot:
+        clk_disable_unprepare(host->mck);
+
+        pm_runtime_disable(&pdev->dev);
+        pm_runtime_put_noidle(&pdev->dev);
+
         del_timer_sync(&host->timer);
-        if (host->dma.chan)
+        if (!IS_ERR(host->dma.chan))
                 dma_release_channel(host->dma.chan);
+err_dma_probe_defer:
         free_irq(irq, host);
         return ret;
 }
 
-static int __exit atmci_remove(struct platform_device *pdev)
+static int atmci_remove(struct platform_device *pdev)
 {
         struct atmel_mci        *host = platform_get_drvdata(pdev);
         unsigned int            i;
 
+        pm_runtime_get_sync(&pdev->dev);
+
         if (host->buffer)
                 dma_free_coherent(&pdev->dev, host->buf_size,
                                   host->buffer, host->buf_phys_addr);
@@ -2520,41 +2518,62 @@ static int __exit atmci_remove(struct platform_device *pdev)
                         atmci_cleanup_slot(host->slot[i], i);
         }
 
-        clk_prepare_enable(host->mck);
         atmci_writel(host, ATMCI_IDR, ~0UL);
         atmci_writel(host, ATMCI_CR, ATMCI_CR_MCIDIS);
         atmci_readl(host, ATMCI_SR);
-        clk_disable_unprepare(host->mck);
 
         del_timer_sync(&host->timer);
-        if (host->dma.chan)
+        if (!IS_ERR(host->dma.chan))
                 dma_release_channel(host->dma.chan);
 
         free_irq(platform_get_irq(pdev, 0), host);
 
+        clk_disable_unprepare(host->mck);
+
+        pm_runtime_disable(&pdev->dev);
+        pm_runtime_put_noidle(&pdev->dev);
+
         return 0;
 }
 
-static struct platform_driver atmci_driver = {
-        .remove         = __exit_p(atmci_remove),
-        .driver         = {
-                .name           = "atmel_mci",
-                .of_match_table = of_match_ptr(atmci_dt_ids),
-        },
-};
-
-static int __init atmci_init(void)
+#ifdef CONFIG_PM
+static int atmci_runtime_suspend(struct device *dev)
 {
-        return platform_driver_probe(&atmci_driver, atmci_probe);
+        struct atmel_mci *host = dev_get_drvdata(dev);
+
+        clk_disable_unprepare(host->mck);
+
+        pinctrl_pm_select_sleep_state(dev);
+
+        return 0;
 }
 
-static void __exit atmci_exit(void)
+static int atmci_runtime_resume(struct device *dev)
 {
-        platform_driver_unregister(&atmci_driver);
+        struct atmel_mci *host = dev_get_drvdata(dev);
+
+        pinctrl_pm_select_default_state(dev);
+
+        return clk_prepare_enable(host->mck);
 }
+#endif
 
-late_initcall(atmci_init); /* try to load after dma driver when built-in */
-module_exit(atmci_exit);
+static const struct dev_pm_ops atmci_dev_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+                                pm_runtime_force_resume)
+        SET_PM_RUNTIME_PM_OPS(atmci_runtime_suspend, atmci_runtime_resume, NULL)
+};
+
+static struct platform_driver atmci_driver = {
+        .probe          = atmci_probe,
+        .remove         = atmci_remove,
+        .driver         = {
+                .name           = "atmel_mci",
+                .of_match_table = of_match_ptr(atmci_dt_ids),
+                .pm             = &atmci_dev_pm_ops,
+        },
+};
+module_platform_driver(atmci_driver);
 
 MODULE_DESCRIPTION("Atmel Multimedia Card Interface driver");
 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
diff --git a/drivers/mmc/host/dw_mmc-exynos.c b/drivers/mmc/host/dw_mmc-exynos.c
index 0fbc53ac7eae..509365cb22c6 100644
--- a/drivers/mmc/host/dw_mmc-exynos.c
+++ b/drivers/mmc/host/dw_mmc-exynos.c
@@ -25,6 +25,7 @@
 #define NUM_PINS(x)                     (x + 2)
 
 #define SDMMC_CLKSEL                    0x09C
+#define SDMMC_CLKSEL64                  0x0A8
 #define SDMMC_CLKSEL_CCLK_SAMPLE(x)     (((x) & 7) << 0)
 #define SDMMC_CLKSEL_CCLK_DRIVE(x)      (((x) & 7) << 16)
 #define SDMMC_CLKSEL_CCLK_DIVIDER(x)    (((x) & 7) << 24)
@@ -65,6 +66,8 @@ enum dw_mci_exynos_type {
         DW_MCI_TYPE_EXYNOS5250,
         DW_MCI_TYPE_EXYNOS5420,
         DW_MCI_TYPE_EXYNOS5420_SMU,
+        DW_MCI_TYPE_EXYNOS7,
+        DW_MCI_TYPE_EXYNOS7_SMU,
 };
 
 /* Exynos implementation specific driver private data */
@@ -95,6 +98,12 @@ static struct dw_mci_exynos_compatible {
         }, {
                 .compatible     = "samsung,exynos5420-dw-mshc-smu",
                 .ctrl_type      = DW_MCI_TYPE_EXYNOS5420_SMU,
+        }, {
+                .compatible     = "samsung,exynos7-dw-mshc",
+                .ctrl_type      = DW_MCI_TYPE_EXYNOS7,
+        }, {
+                .compatible     = "samsung,exynos7-dw-mshc-smu",
+                .ctrl_type      = DW_MCI_TYPE_EXYNOS7_SMU,
         },
 };
 
@@ -102,7 +111,8 @@ static int dw_mci_exynos_priv_init(struct dw_mci *host)
 {
         struct dw_mci_exynos_priv_data *priv = host->priv;
 
-        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS5420_SMU) {
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS5420_SMU ||
+                priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU) {
                 mci_writel(host, MPSBEGIN0, 0);
                 mci_writel(host, MPSEND0, DWMCI_BLOCK_NUM);
                 mci_writel(host, MPSCTRL0, DWMCI_MPSCTRL_SECURE_WRITE_BIT |
@@ -153,11 +163,22 @@ static int dw_mci_exynos_resume(struct device *dev)
 static int dw_mci_exynos_resume_noirq(struct device *dev)
 {
         struct dw_mci *host = dev_get_drvdata(dev);
+        struct dw_mci_exynos_priv_data *priv = host->priv;
         u32 clksel;
 
-        clksel = mci_readl(host, CLKSEL);
-        if (clksel & SDMMC_CLKSEL_WAKEUP_INT)
-                mci_writel(host, CLKSEL, clksel);
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                clksel = mci_readl(host, CLKSEL64);
+        else
+                clksel = mci_readl(host, CLKSEL);
+
+        if (clksel & SDMMC_CLKSEL_WAKEUP_INT) {
+                if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                        priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                        mci_writel(host, CLKSEL64, clksel);
+                else
+                        mci_writel(host, CLKSEL, clksel);
+        }
 
         return 0;
 }
@@ -169,6 +190,7 @@ static int dw_mci_exynos_resume_noirq(struct device *dev)
 
 static void dw_mci_exynos_prepare_command(struct dw_mci *host, u32 *cmdr)
 {
+        struct dw_mci_exynos_priv_data *priv = host->priv;
         /*
          * Exynos4412 and Exynos5250 extends the use of CMD register with the
          * use of bit 29 (which is reserved on standard MSHC controllers) for
@@ -176,8 +198,14 @@ static void dw_mci_exynos_prepare_command(struct dw_mci *host, u32 *cmdr)
          * HOLD register should be bypassed in case there is no phase shift
          * applied on CMD/DATA that is sent to the card.
          */
-        if (SDMMC_CLKSEL_GET_DRV_WD3(mci_readl(host, CLKSEL)))
-                *cmdr |= SDMMC_CMD_USE_HOLD_REG;
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU) {
+                if (SDMMC_CLKSEL_GET_DRV_WD3(mci_readl(host, CLKSEL64)))
+                        *cmdr |= SDMMC_CMD_USE_HOLD_REG;
+         } else {
+                if (SDMMC_CLKSEL_GET_DRV_WD3(mci_readl(host, CLKSEL)))
+                        *cmdr |= SDMMC_CMD_USE_HOLD_REG;
+        }
 }
 
 static void dw_mci_exynos_set_ios(struct dw_mci *host, struct mmc_ios *ios)
@@ -188,12 +216,20 @@ static void dw_mci_exynos_set_ios(struct dw_mci *host, struct mmc_ios *ios)
         u8 div = priv->ciu_div + 1;
 
         if (ios->timing == MMC_TIMING_MMC_DDR52) {
-                mci_writel(host, CLKSEL, priv->ddr_timing);
+                if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                        priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                        mci_writel(host, CLKSEL64, priv->ddr_timing);
+                else
+                        mci_writel(host, CLKSEL, priv->ddr_timing);
                 /* Should be double rate for DDR mode */
                 if (ios->bus_width == MMC_BUS_WIDTH_8)
                         wanted <<= 1;
         } else {
-                mci_writel(host, CLKSEL, priv->sdr_timing);
+                if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                        priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                        mci_writel(host, CLKSEL64, priv->sdr_timing);
+                else
+                        mci_writel(host, CLKSEL, priv->sdr_timing);
         }
 
         /* Don't care if wanted clock is zero */
@@ -265,26 +301,51 @@ static int dw_mci_exynos_parse_dt(struct dw_mci *host)
 
 static inline u8 dw_mci_exynos_get_clksmpl(struct dw_mci *host)
 {
-        return SDMMC_CLKSEL_CCLK_SAMPLE(mci_readl(host, CLKSEL));
+        struct dw_mci_exynos_priv_data *priv = host->priv;
+
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                return SDMMC_CLKSEL_CCLK_SAMPLE(mci_readl(host, CLKSEL64));
+        else
+                return SDMMC_CLKSEL_CCLK_SAMPLE(mci_readl(host, CLKSEL));
 }
 
 static inline void dw_mci_exynos_set_clksmpl(struct dw_mci *host, u8 sample)
 {
         u32 clksel;
-        clksel = mci_readl(host, CLKSEL);
+        struct dw_mci_exynos_priv_data *priv = host->priv;
+
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                clksel = mci_readl(host, CLKSEL64);
+        else
+                clksel = mci_readl(host, CLKSEL);
         clksel = (clksel & ~0x7) | SDMMC_CLKSEL_CCLK_SAMPLE(sample);
-        mci_writel(host, CLKSEL, clksel);
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                mci_writel(host, CLKSEL64, clksel);
+        else
+                mci_writel(host, CLKSEL, clksel);
 }
 
 static inline u8 dw_mci_exynos_move_next_clksmpl(struct dw_mci *host)
 {
+        struct dw_mci_exynos_priv_data *priv = host->priv;
         u32 clksel;
         u8 sample;
 
-        clksel = mci_readl(host, CLKSEL);
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                clksel = mci_readl(host, CLKSEL64);
+        else
+                clksel = mci_readl(host, CLKSEL);
         sample = (clksel + 1) & 0x7;
         clksel = (clksel & ~0x7) | sample;
-        mci_writel(host, CLKSEL, clksel);
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
+                priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
+                mci_writel(host, CLKSEL64, clksel);
+        else
+                mci_writel(host, CLKSEL, clksel);
         return sample;
 }
 
@@ -411,6 +472,10 @@ static const struct of_device_id dw_mci_exynos_match[] = {
                         .data = &exynos_drv_data, },
         { .compatible = "samsung,exynos5420-dw-mshc-smu",
                         .data = &exynos_drv_data, },
+        { .compatible = "samsung,exynos7-dw-mshc",
+                        .data = &exynos_drv_data, },
+        { .compatible = "samsung,exynos7-dw-mshc-smu",
+                        .data = &exynos_drv_data, },
         {},
 };
 MODULE_DEVICE_TABLE(of, dw_mci_exynos_match);
diff --git a/drivers/mmc/host/dw_mmc-pltfm.c b/drivers/mmc/host/dw_mmc-pltfm.c
index 8b6572162ed9..ec6dbcdec693 100644
--- a/drivers/mmc/host/dw_mmc-pltfm.c
+++ b/drivers/mmc/host/dw_mmc-pltfm.c
@@ -35,6 +35,10 @@ static const struct dw_mci_drv_data socfpga_drv_data = {
         .prepare_command        = dw_mci_pltfm_prepare_command,
 };
 
+static const struct dw_mci_drv_data pistachio_drv_data = {
+        .prepare_command        = dw_mci_pltfm_prepare_command,
+};
+
 int dw_mci_pltfm_register(struct platform_device *pdev,
                           const struct dw_mci_drv_data *drv_data)
 {
@@ -90,6 +94,8 @@ static const struct of_device_id dw_mci_pltfm_match[] = {
         { .compatible = "snps,dw-mshc", },
         { .compatible = "altr,socfpga-dw-mshc",
                 .data = &socfpga_drv_data },
+        { .compatible = "img,pistachio-dw-mshc",
+                .data = &pistachio_drv_data },
         {},
 };
 MODULE_DEVICE_TABLE(of, dw_mci_pltfm_match);
diff --git a/drivers/mmc/host/dw_mmc-rockchip.c b/drivers/mmc/host/dw_mmc-rockchip.c
index f0c2cb1a210d..5650ac488cf3 100644
--- a/drivers/mmc/host/dw_mmc-rockchip.c
+++ b/drivers/mmc/host/dw_mmc-rockchip.c
@@ -37,6 +37,9 @@ static void dw_mci_rk3288_set_ios(struct dw_mci *host, struct mmc_ios *ios)
         unsigned int cclkin;
         u32 bus_hz;
 
+        if (ios->clock == 0)
+                return;
+
         /*
          * cclkin: source clock of mmc controller
          * bus_hz: card interface clock generated by CLKGEN
@@ -65,14 +68,24 @@ static void dw_mci_rk3288_set_ios(struct dw_mci *host, struct mmc_ios *ios)
         }
 }
 
+static int dw_mci_rockchip_init(struct dw_mci *host)
+{
+        /* It is slot 8 on Rockchip SoCs */
+        host->sdio_id0 = 8;
+
+        return 0;
+}
+
 static const struct dw_mci_drv_data rk2928_drv_data = {
         .prepare_command        = dw_mci_rockchip_prepare_command,
+        .init                   = dw_mci_rockchip_init,
 };
 
 static const struct dw_mci_drv_data rk3288_drv_data = {
         .prepare_command        = dw_mci_rockchip_prepare_command,
         .set_ios                = dw_mci_rk3288_set_ios,
         .setup_clock    = dw_mci_rk3288_setup_clock,
+        .init                   = dw_mci_rockchip_init,
 };
 
 static const struct of_device_id dw_mci_rockchip_match[] = {
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 69f0cc68d5b2..67c04518ec4c 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -34,7 +34,6 @@
 #include <linux/mmc/dw_mmc.h>
 #include <linux/bitops.h>
 #include <linux/regulator/consumer.h>
-#include <linux/workqueue.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
 #include <linux/mmc/slot-gpio.h>
@@ -62,6 +61,24 @@
                                  SDMMC_IDMAC_INT_FBE | SDMMC_IDMAC_INT_RI | \
                                  SDMMC_IDMAC_INT_TI)
 
+struct idmac_desc_64addr {
+        u32             des0;   /* Control Descriptor */
+
+        u32             des1;   /* Reserved */
+
+        u32             des2;   /*Buffer sizes */
+#define IDMAC_64ADDR_SET_BUFFER1_SIZE(d, s) \
+        ((d)->des2 = ((d)->des2 & 0x03ffe000) | ((s) & 0x1fff))
+
+        u32             des3;   /* Reserved */
+
+        u32             des4;   /* Lower 32-bits of Buffer Address Pointer 1*/
+        u32             des5;   /* Upper 32-bits of Buffer Address Pointer 1*/
+
+        u32             des6;   /* Lower 32-bits of Next Descriptor Address */
+        u32             des7;   /* Upper 32-bits of Next Descriptor Address */
+};
+
 struct idmac_desc {
         u32             des0;   /* Control Descriptor */
 #define IDMAC_DES0_DIC  BIT(1)
@@ -83,6 +100,7 @@ struct idmac_desc {
 #endif /* CONFIG_MMC_DW_IDMAC */
 
 static bool dw_mci_reset(struct dw_mci *host);
+static bool dw_mci_ctrl_reset(struct dw_mci *host, u32 reset);
 
 #if defined(CONFIG_DEBUG_FS)
 static int dw_mci_req_show(struct seq_file *s, void *v)
@@ -414,30 +432,66 @@ static void dw_mci_translate_sglist(struct dw_mci *host, struct mmc_data *data,
                                     unsigned int sg_len)
 {
         int i;
-        struct idmac_desc *desc = host->sg_cpu;
+        if (host->dma_64bit_address == 1) {
+                struct idmac_desc_64addr *desc = host->sg_cpu;
 
-        for (i = 0; i < sg_len; i++, desc++) {
-                unsigned int length = sg_dma_len(&data->sg[i]);
-                u32 mem_addr = sg_dma_address(&data->sg[i]);
+                for (i = 0; i < sg_len; i++, desc++) {
+                        unsigned int length = sg_dma_len(&data->sg[i]);
+                        u64 mem_addr = sg_dma_address(&data->sg[i]);
 
-                /* Set the OWN bit and disable interrupts for this descriptor */
-                desc->des0 = IDMAC_DES0_OWN | IDMAC_DES0_DIC | IDMAC_DES0_CH;
+                        /*
+                         * Set the OWN bit and disable interrupts for this
+                         * descriptor
+                         */
+                        desc->des0 = IDMAC_DES0_OWN | IDMAC_DES0_DIC |
+                                                IDMAC_DES0_CH;
+                        /* Buffer length */
+                        IDMAC_64ADDR_SET_BUFFER1_SIZE(desc, length);
+
+                        /* Physical address to DMA to/from */
+                        desc->des4 = mem_addr & 0xffffffff;
+                        desc->des5 = mem_addr >> 32;
+                }
 
-                /* Buffer length */
-                IDMAC_SET_BUFFER1_SIZE(desc, length);
+                /* Set first descriptor */
+                desc = host->sg_cpu;
+                desc->des0 |= IDMAC_DES0_FD;
 
-                /* Physical address to DMA to/from */
-                desc->des2 = mem_addr;
-        }
+                /* Set last descriptor */
+                desc = host->sg_cpu + (i - 1) *
+                                sizeof(struct idmac_desc_64addr);
+                desc->des0 &= ~(IDMAC_DES0_CH | IDMAC_DES0_DIC);
+                desc->des0 |= IDMAC_DES0_LD;
 
-        /* Set first descriptor */
-        desc = host->sg_cpu;
-        desc->des0 |= IDMAC_DES0_FD;
+        } else {
+                struct idmac_desc *desc = host->sg_cpu;
+
+                for (i = 0; i < sg_len; i++, desc++) {
+                        unsigned int length = sg_dma_len(&data->sg[i]);
+                        u32 mem_addr = sg_dma_address(&data->sg[i]);
+
+                        /*
+                         * Set the OWN bit and disable interrupts for this
+                         * descriptor
+                         */
+                        desc->des0 = IDMAC_DES0_OWN | IDMAC_DES0_DIC |
+                                                IDMAC_DES0_CH;
+                        /* Buffer length */
+                        IDMAC_SET_BUFFER1_SIZE(desc, length);
 
-        /* Set last descriptor */
-        desc = host->sg_cpu + (i - 1) * sizeof(struct idmac_desc);
-        desc->des0 &= ~(IDMAC_DES0_CH | IDMAC_DES0_DIC);
-        desc->des0 |= IDMAC_DES0_LD;
+                        /* Physical address to DMA to/from */
+                        desc->des2 = mem_addr;
+                }
+
+                /* Set first descriptor */
+                desc = host->sg_cpu;
+                desc->des0 |= IDMAC_DES0_FD;
+
+                /* Set last descriptor */
+                desc = host->sg_cpu + (i - 1) * sizeof(struct idmac_desc);
+                desc->des0 &= ~(IDMAC_DES0_CH | IDMAC_DES0_DIC);
+                desc->des0 |= IDMAC_DES0_LD;
+        }
 
         wmb();
 }
@@ -448,6 +502,10 @@ static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
 
         dw_mci_translate_sglist(host, host->data, sg_len);
 
+        /* Make sure to reset DMA in case we did PIO before this */
+        dw_mci_ctrl_reset(host, SDMMC_CTRL_DMA_RESET);
+        dw_mci_idmac_reset(host);
+
         /* Select IDMAC interface */
         temp = mci_readl(host, CTRL);
         temp |= SDMMC_CTRL_USE_IDMAC;
@@ -466,29 +524,71 @@ static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
 
 static int dw_mci_idmac_init(struct dw_mci *host)
 {
-        struct idmac_desc *p;
         int i;
 
-        /* Number of descriptors in the ring buffer */
-        host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc);
+        if (host->dma_64bit_address == 1) {
+                struct idmac_desc_64addr *p;
+                /* Number of descriptors in the ring buffer */
+                host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc_64addr);
+
+                /* Forward link the descriptor list */
+                for (i = 0, p = host->sg_cpu; i < host->ring_size - 1;
+                                                                i++, p++) {
+                        p->des6 = (host->sg_dma +
+                                        (sizeof(struct idmac_desc_64addr) *
+                                                        (i + 1))) & 0xffffffff;
+
+                        p->des7 = (u64)(host->sg_dma +
+                                        (sizeof(struct idmac_desc_64addr) *
+                                                        (i + 1))) >> 32;
+                        /* Initialize reserved and buffer size fields to "0" */
+                        p->des1 = 0;
+                        p->des2 = 0;
+                        p->des3 = 0;
+                }
+
+                /* Set the last descriptor as the end-of-ring descriptor */
+                p->des6 = host->sg_dma & 0xffffffff;
+                p->des7 = (u64)host->sg_dma >> 32;
+                p->des0 = IDMAC_DES0_ER;
+
+        } else {
+                struct idmac_desc *p;
+                /* Number of descriptors in the ring buffer */
+                host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc);
 
-        /* Forward link the descriptor list */
-        for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
-                p->des3 = host->sg_dma + (sizeof(struct idmac_desc) * (i + 1));
+                /* Forward link the descriptor list */
+                for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
+                        p->des3 = host->sg_dma + (sizeof(struct idmac_desc) *
+                                                                (i + 1));
 
-        /* Set the last descriptor as the end-of-ring descriptor */
-        p->des3 = host->sg_dma;
-        p->des0 = IDMAC_DES0_ER;
+                /* Set the last descriptor as the end-of-ring descriptor */
+                p->des3 = host->sg_dma;
+                p->des0 = IDMAC_DES0_ER;
+        }
 
         dw_mci_idmac_reset(host);
 
-        /* Mask out interrupts - get Tx & Rx complete only */
-        mci_writel(host, IDSTS, IDMAC_INT_CLR);
-        mci_writel(host, IDINTEN, SDMMC_IDMAC_INT_NI | SDMMC_IDMAC_INT_RI |
-                   SDMMC_IDMAC_INT_TI);
+        if (host->dma_64bit_address == 1) {
+                /* Mask out interrupts - get Tx & Rx complete only */
+                mci_writel(host, IDSTS64, IDMAC_INT_CLR);
+                mci_writel(host, IDINTEN64, SDMMC_IDMAC_INT_NI |
+                                SDMMC_IDMAC_INT_RI | SDMMC_IDMAC_INT_TI);
+
+                /* Set the descriptor base address */
+                mci_writel(host, DBADDRL, host->sg_dma & 0xffffffff);
+                mci_writel(host, DBADDRU, (u64)host->sg_dma >> 32);
+
+        } else {
+                /* Mask out interrupts - get Tx & Rx complete only */
+                mci_writel(host, IDSTS, IDMAC_INT_CLR);
+                mci_writel(host, IDINTEN, SDMMC_IDMAC_INT_NI |
+                                SDMMC_IDMAC_INT_RI | SDMMC_IDMAC_INT_TI);
+
+                /* Set the descriptor base address */
+                mci_writel(host, DBADDR, host->sg_dma);
+        }
 
-        /* Set the descriptor base address */
-        mci_writel(host, DBADDR, host->sg_dma);
         return 0;
 }
 
@@ -626,6 +726,13 @@ static void dw_mci_ctrl_rd_thld(struct dw_mci *host, struct mmc_data *data)
 
         WARN_ON(!(data->flags & MMC_DATA_READ));
 
+        /*
+         * CDTHRCTL doesn't exist prior to 240A (in fact that register offset is
+         * in the FIFO region, so we really shouldn't access it).
+         */
+        if (host->verid < DW_MMC_240A)
+                return;
+
         if (host->timing != MMC_TIMING_MMC_HS200 &&
             host->timing != MMC_TIMING_UHS_SDR104)
                 goto disable;
@@ -819,7 +926,7 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)
 
                 /* enable clock; only low power if no SDIO */
                 clk_en_a = SDMMC_CLKEN_ENABLE << slot->id;
-                if (!(mci_readl(host, INTMASK) & SDMMC_INT_SDIO(slot->id)))
+                if (!(mci_readl(host, INTMASK) & SDMMC_INT_SDIO(slot->sdio_id)))
                         clk_en_a |= SDMMC_CLKEN_LOW_PWR << slot->id;
                 mci_writel(host, CLKENA, clk_en_a);
 
@@ -1075,7 +1182,7 @@ static int dw_mci_switch_voltage(struct mmc_host *mmc, struct mmc_ios *ios)
                 ret = regulator_set_voltage(mmc->supply.vqmmc, min_uv, max_uv);
 
                 if (ret) {
-                        dev_err(&mmc->class_dev,
+                        dev_dbg(&mmc->class_dev,
                                          "Regulator set error %d: %d - %d\n",
                                          ret, min_uv, max_uv);
                         return ret;
@@ -1180,10 +1287,10 @@ static void dw_mci_enable_sdio_irq(struct mmc_host *mmc, int enb)
                 dw_mci_disable_low_power(slot);
 
                 mci_writel(host, INTMASK,
-                           (int_mask | SDMMC_INT_SDIO(slot->id)));
+                           (int_mask | SDMMC_INT_SDIO(slot->sdio_id)));
         } else {
                 mci_writel(host, INTMASK,
-                           (int_mask & ~SDMMC_INT_SDIO(slot->id)));
+                           (int_mask & ~SDMMC_INT_SDIO(slot->sdio_id)));
         }
 }
 
@@ -1954,6 +2061,23 @@ static void dw_mci_cmd_interrupt(struct dw_mci *host, u32 status)
         tasklet_schedule(&host->tasklet);
 }
 
+static void dw_mci_handle_cd(struct dw_mci *host)
+{
+        int i;
+
+        for (i = 0; i < host->num_slots; i++) {
+                struct dw_mci_slot *slot = host->slot[i];
+
+                if (!slot)
+                        continue;
+
+                if (slot->mmc->ops->card_event)
+                        slot->mmc->ops->card_event(slot->mmc);
+                mmc_detect_change(slot->mmc,
+                        msecs_to_jiffies(host->pdata->detect_delay_ms));
+        }
+}
+
 static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 {
         struct dw_mci *host = dev_id;
@@ -2029,14 +2153,15 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 
                 if (pending & SDMMC_INT_CD) {
                         mci_writel(host, RINTSTS, SDMMC_INT_CD);
-                        queue_work(host->card_workqueue, &host->card_work);
+                        dw_mci_handle_cd(host);
                 }
 
                 /* Handle SDIO Interrupts */
                 for (i = 0; i < host->num_slots; i++) {
                         struct dw_mci_slot *slot = host->slot[i];
-                        if (pending & SDMMC_INT_SDIO(i)) {
-                                mci_writel(host, RINTSTS, SDMMC_INT_SDIO(i));
+                        if (pending & SDMMC_INT_SDIO(slot->sdio_id)) {
+                                mci_writel(host, RINTSTS,
+                                           SDMMC_INT_SDIO(slot->sdio_id));
                                 mmc_signal_sdio_irq(slot->mmc);
                         }
                 }
@@ -2045,99 +2170,28 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 
 #ifdef CONFIG_MMC_DW_IDMAC
         /* Handle DMA interrupts */
-        pending = mci_readl(host, IDSTS);
-        if (pending & (SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI)) {
-                mci_writel(host, IDSTS, SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI);
-                mci_writel(host, IDSTS, SDMMC_IDMAC_INT_NI);
-                host->dma_ops->complete(host);
+        if (host->dma_64bit_address == 1) {
+                pending = mci_readl(host, IDSTS64);
+                if (pending & (SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI)) {
+                        mci_writel(host, IDSTS64, SDMMC_IDMAC_INT_TI |
+                                                        SDMMC_IDMAC_INT_RI);
+                        mci_writel(host, IDSTS64, SDMMC_IDMAC_INT_NI);
+                        host->dma_ops->complete(host);
+                }
+        } else {
+                pending = mci_readl(host, IDSTS);
+                if (pending & (SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI)) {
+                        mci_writel(host, IDSTS, SDMMC_IDMAC_INT_TI |
+                                                        SDMMC_IDMAC_INT_RI);
+                        mci_writel(host, IDSTS, SDMMC_IDMAC_INT_NI);
+                        host->dma_ops->complete(host);
+                }
         }
 #endif
 
         return IRQ_HANDLED;
 }
 
-static void dw_mci_work_routine_card(struct work_struct *work)
-{
-        struct dw_mci *host = container_of(work, struct dw_mci, card_work);
-        int i;
-
-        for (i = 0; i < host->num_slots; i++) {
-                struct dw_mci_slot *slot = host->slot[i];
-                struct mmc_host *mmc = slot->mmc;
-                struct mmc_request *mrq;
-                int present;
-
-                present = dw_mci_get_cd(mmc);
-                while (present != slot->last_detect_state) {
-                        dev_dbg(&slot->mmc->class_dev, "card %s\n",
-                                present ? "inserted" : "removed");
-
-                        spin_lock_bh(&host->lock);
-
-                        /* Card change detected */
-                        slot->last_detect_state = present;
-
-                        /* Clean up queue if present */
-                        mrq = slot->mrq;
-                        if (mrq) {
-                                if (mrq == host->mrq) {
-                                        host->data = NULL;
-                                        host->cmd = NULL;
-
-                                        switch (host->state) {
-                                        case STATE_IDLE:
-                                        case STATE_WAITING_CMD11_DONE:
-                                                break;
-                                        case STATE_SENDING_CMD11:
-                                        case STATE_SENDING_CMD:
-                                                mrq->cmd->error = -ENOMEDIUM;
-                                                if (!mrq->data)
-                                                        break;
-                                                /* fall through */
-                                        case STATE_SENDING_DATA:
-                                                mrq->data->error = -ENOMEDIUM;
-                                                dw_mci_stop_dma(host);
-                                                break;
-                                        case STATE_DATA_BUSY:
-                                        case STATE_DATA_ERROR:
-                                                if (mrq->data->error == -EINPROGRESS)
-                                                        mrq->data->error = -ENOMEDIUM;
-                                                /* fall through */
-                                        case STATE_SENDING_STOP:
-                                                if (mrq->stop)
-                                                        mrq->stop->error = -ENOMEDIUM;
-                                                break;
-                                        }
-
-                                        dw_mci_request_end(host, mrq);
-                                } else {
-                                        list_del(&slot->queue_node);
-                                        mrq->cmd->error = -ENOMEDIUM;
-                                        if (mrq->data)
-                                                mrq->data->error = -ENOMEDIUM;
-                                        if (mrq->stop)
-                                                mrq->stop->error = -ENOMEDIUM;
-
-                                        spin_unlock(&host->lock);
-                                        mmc_request_done(slot->mmc, mrq);
-                                        spin_lock(&host->lock);
-                                }
-                        }
-
-                        /* Power down slot */
-                        if (present == 0)
-                                dw_mci_reset(host);
-
-                        spin_unlock_bh(&host->lock);
-
-                        present = dw_mci_get_cd(mmc);
-                }
-
-                mmc_detect_change(slot->mmc,
-                        msecs_to_jiffies(host->pdata->detect_delay_ms));
-        }
-}
-
 #ifdef CONFIG_OF
 /* given a slot id, find out the device node representing that slot */
 static struct device_node *dw_mci_of_find_slot_node(struct device *dev, u8 slot)
@@ -2206,6 +2260,7 @@ static int dw_mci_init_slot(struct dw_mci *host, unsigned int id)
 
         slot = mmc_priv(mmc);
         slot->id = id;
+        slot->sdio_id = host->sdio_id0 + id;
         slot->mmc = mmc;
         slot->host = host;
         host->slot[id] = slot;
@@ -2289,9 +2344,6 @@ static int dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         dw_mci_init_debugfs(slot);
 #endif
 
-        /* Card initially undetected */
-        slot->last_detect_state = 0;
-
         return 0;
 
 err_host_allocated:
@@ -2309,6 +2361,22 @@ static void dw_mci_cleanup_slot(struct dw_mci_slot *slot, unsigned int id)
 
 static void dw_mci_init_dma(struct dw_mci *host)
 {
+        int addr_config;
+        /* Check ADDR_CONFIG bit in HCON to find IDMAC address bus width */
+        addr_config = (mci_readl(host, HCON) >> 27) & 0x01;
+
+        if (addr_config == 1) {
+                /* host supports IDMAC in 64-bit address mode */
+                host->dma_64bit_address = 1;
+                dev_info(host->dev, "IDMAC supports 64-bit address mode.\n");
+                if (!dma_set_mask(host->dev, DMA_BIT_MASK(64)))
+                        dma_set_coherent_mask(host->dev, DMA_BIT_MASK(64));
+        } else {
+                /* host supports IDMAC in 32-bit address mode */
+                host->dma_64bit_address = 0;
+                dev_info(host->dev, "IDMAC supports 32-bit address mode.\n");
+        }
+
         /* Alloc memory for sg translation */
         host->sg_cpu = dmam_alloc_coherent(host->dev, PAGE_SIZE,
                                           &host->sg_dma, GFP_KERNEL);
@@ -2672,17 +2740,10 @@ int dw_mci_probe(struct dw_mci *host)
                 host->data_offset = DATA_240A_OFFSET;
 
         tasklet_init(&host->tasklet, dw_mci_tasklet_func, (unsigned long)host);
-        host->card_workqueue = alloc_workqueue("dw-mci-card",
-                        WQ_MEM_RECLAIM, 1);
-        if (!host->card_workqueue) {
-                ret = -ENOMEM;
-                goto err_dmaunmap;
-        }
-        INIT_WORK(&host->card_work, dw_mci_work_routine_card);
         ret = devm_request_irq(host->dev, host->irq, dw_mci_interrupt,
                                host->irq_flags, "dw-mci", host);
         if (ret)
-                goto err_workqueue;
+                goto err_dmaunmap;
 
         if (host->pdata->num_slots)
                 host->num_slots = host->pdata->num_slots;
@@ -2718,7 +2779,7 @@ int dw_mci_probe(struct dw_mci *host)
         } else {
                 dev_dbg(host->dev, "attempted to initialize %d slots, "
                                         "but failed on all\n", host->num_slots);
-                goto err_workqueue;
+                goto err_dmaunmap;
         }
 
         if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
@@ -2726,9 +2787,6 @@ int dw_mci_probe(struct dw_mci *host)
 
         return 0;
 
-err_workqueue:
-        destroy_workqueue(host->card_workqueue);
-
 err_dmaunmap:
         if (host->use_dma && host->dma_ops->exit)
                 host->dma_ops->exit(host);
@@ -2762,8 +2820,6 @@ void dw_mci_remove(struct dw_mci *host)
         mci_writel(host, CLKENA, 0);
         mci_writel(host, CLKSRC, 0);
 
-        destroy_workqueue(host->card_workqueue);
-
         if (host->use_dma && host->dma_ops->exit)
                 host->dma_ops->exit(host);
 
diff --git a/drivers/mmc/host/dw_mmc.h b/drivers/mmc/host/dw_mmc.h
index 01b99e8a9190..0d0f7a271d63 100644
--- a/drivers/mmc/host/dw_mmc.h
+++ b/drivers/mmc/host/dw_mmc.h
@@ -55,6 +55,17 @@
 #define SDMMC_BUFADDR           0x098
 #define SDMMC_CDTHRCTL          0x100
 #define SDMMC_DATA(x)           (x)
+/*
+* Registers to support idmac 64-bit address mode
+*/
+#define SDMMC_DBADDRL           0x088
+#define SDMMC_DBADDRU           0x08c
+#define SDMMC_IDSTS64           0x090
+#define SDMMC_IDINTEN64         0x094
+#define SDMMC_DSCADDRL          0x098
+#define SDMMC_DSCADDRU          0x09c
+#define SDMMC_BUFADDRL          0x0A0
+#define SDMMC_BUFADDRU          0x0A4
 
 /*
  * Data offset is difference according to Version
@@ -214,7 +225,7 @@ extern int dw_mci_resume(struct dw_mci *host);
  *      with CONFIG_MMC_CLKGATE.
  * @flags: Random state bits associated with the slot.
  * @id: Number of this slot.
- * @last_detect_state: Most recently observed card detect state.
+ * @sdio_id: Number of this slot in the SDIO interrupt registers.
  */
 struct dw_mci_slot {
         struct mmc_host         *mmc;
@@ -234,7 +245,7 @@ struct dw_mci_slot {
 #define DW_MMC_CARD_PRESENT     0
 #define DW_MMC_CARD_NEED_INIT   1
         int                     id;
-        int                     last_detect_state;
+        int                     sdio_id;
 };
 
 struct dw_mci_tuning_data {
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 43af791e2e45..8232e9a02d40 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -736,8 +736,15 @@ static void mmci_post_request(struct mmc_host *mmc, struct mmc_request *mrq,
                         chan = host->dma_tx_channel;
                 dmaengine_terminate_all(chan);
 
+                if (host->dma_desc_current == next->dma_desc)
+                        host->dma_desc_current = NULL;
+
+                if (host->dma_current == next->dma_chan)
+                        host->dma_current = NULL;
+
                 next->dma_desc = NULL;
                 next->dma_chan = NULL;
+                data->host_cookie = 0;
         }
 }
 
@@ -1843,7 +1850,7 @@ static int mmci_runtime_resume(struct device *dev)
 static const struct dev_pm_ops mmci_dev_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
                                 pm_runtime_force_resume)
-        SET_PM_RUNTIME_PM_OPS(mmci_runtime_suspend, mmci_runtime_resume, NULL)
+        SET_RUNTIME_PM_OPS(mmci_runtime_suspend, mmci_runtime_resume, NULL)
 };
 
 static struct amba_id mmci_ids[] = {
diff --git a/drivers/mmc/host/msm_sdcc.c b/drivers/mmc/host/msm_sdcc.c
index 9405ecdaf6cf..90c60fd4ff6e 100644
--- a/drivers/mmc/host/msm_sdcc.c
+++ b/drivers/mmc/host/msm_sdcc.c
@@ -1360,7 +1360,7 @@ msmsdcc_probe(struct platform_device *pdev)
         if (ret)
                 goto cmd_irq_free;
 
-        mmc_set_drvdata(pdev, mmc);
+        platform_set_drvdata(pdev, mmc);
         mmc_add_host(mmc);
 
         pr_info("%s: Qualcomm MSM SDCC at 0x%016llx irq %d,%d dma %d\n",
@@ -1419,7 +1419,7 @@ ioremap_free:
 static int
 msmsdcc_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct mmc_host *mmc = mmc_get_drvdata(dev);
+        struct mmc_host *mmc = platform_get_drvdata(dev);
 
         if (mmc) {
                 struct msmsdcc_host *host = mmc_priv(mmc);
@@ -1437,7 +1437,7 @@ msmsdcc_suspend(struct platform_device *dev, pm_message_t state)
 static int
 msmsdcc_resume(struct platform_device *dev)
 {
-        struct mmc_host *mmc = mmc_get_drvdata(dev);
+        struct mmc_host *mmc = platform_get_drvdata(dev);
 
         if (mmc) {
                 struct msmsdcc_host *host = mmc_priv(mmc);
diff --git a/drivers/mmc/host/mvsdio.c b/drivers/mmc/host/mvsdio.c
index 6b4c5ad3b393..4f8618f4522d 100644
--- a/drivers/mmc/host/mvsdio.c
+++ b/drivers/mmc/host/mvsdio.c
@@ -111,10 +111,15 @@ static int mvsd_setup_data(struct mvsd_host *host, struct mmc_data *data)
         mvsd_write(MVSD_BLK_COUNT, data->blocks);
         mvsd_write(MVSD_BLK_SIZE, data->blksz);
 
-        if (nodma || (data->blksz | data->sg->offset) & 3) {
+        if (nodma || (data->blksz | data->sg->offset) & 3 ||
+            ((!(data->flags & MMC_DATA_READ) && data->sg->offset & 0x3f))) {
                 /*
                  * We cannot do DMA on a buffer which offset or size
                  * is not aligned on a 4-byte boundary.
+                 *
+                 * It also appears the host to card DMA can corrupt
+                 * data when the buffer is not aligned on a 64 byte
+                 * boundary.
                  */
                 host->pio_size = data->blocks * data->blksz;
                 host->pio_ptr = sg_virt(data->sg);
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index ad111422ad55..5316d9b9e7b4 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -373,13 +373,9 @@ static void mxcmci_dma_callback(void *data)
         del_timer(&host->watchdog);
 
         stat = mxcmci_readl(host, MMC_REG_STATUS);
-        mxcmci_writel(host, stat & ~STATUS_DATA_TRANS_DONE, MMC_REG_STATUS);
 
         dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat);
 
-        if (stat & STATUS_READ_OP_DONE)
-                mxcmci_writel(host, STATUS_READ_OP_DONE, MMC_REG_STATUS);
-
         mxcmci_data_done(host, stat);
 }
 
@@ -743,10 +739,8 @@ static irqreturn_t mxcmci_irq(int irq, void *devid)
         sdio_irq = (stat & STATUS_SDIO_INT_ACTIVE) && host->use_sdio;
         spin_unlock_irqrestore(&host->lock, flags);
 
-        if (mxcmci_use_dma(host) &&
-            (stat & (STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE)))
-                mxcmci_writel(host, STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE,
-                        MMC_REG_STATUS);
+        if (mxcmci_use_dma(host) && (stat & (STATUS_WRITE_OP_DONE)))
+                mxcmci_writel(host, STATUS_WRITE_OP_DONE, MMC_REG_STATUS);
 
         if (sdio_irq) {
                 mxcmci_writel(host, STATUS_SDIO_INT_ACTIVE, MMC_REG_STATUS);
@@ -756,8 +750,7 @@ static irqreturn_t mxcmci_irq(int irq, void *devid)
         if (stat & STATUS_END_CMD_RESP)
                 mxcmci_cmd_done(host, stat);
 
-        if (mxcmci_use_dma(host) &&
-                  (stat & (STATUS_DATA_TRANS_DONE | STATUS_WRITE_OP_DONE))) {
+        if (mxcmci_use_dma(host) && (stat & STATUS_WRITE_OP_DONE)) {
                 del_timer(&host->watchdog);
                 mxcmci_data_done(host, stat);
         }
@@ -1084,12 +1077,14 @@ static int mxcmci_probe(struct platform_device *pdev)
                 dat3_card_detect = true;
 
         ret = mmc_regulator_get_supply(mmc);
-        if (ret) {
-                if (pdata && ret != -EPROBE_DEFER)
-                        mmc->ocr_avail = pdata->ocr_avail ? :
-                                MMC_VDD_32_33 | MMC_VDD_33_34;
+        if (ret == -EPROBE_DEFER)
+                goto out_free;
+
+        if (!mmc->ocr_avail) {
+                if (pdata && pdata->ocr_avail)
+                        mmc->ocr_avail = pdata->ocr_avail;
                 else
-                        goto out_free;
+                        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
         }
 
         if (dat3_card_detect)
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index cd74e5143c36..60c4ca97a727 100644
--- a/drivers/mmc/host/mxs-mmc.c
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -581,10 +581,9 @@ static int mxs_mmc_probe(struct platform_device *pdev)
         struct regulator *reg_vmmc;
         struct mxs_ssp *ssp;
 
-        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq_err = platform_get_irq(pdev, 0);
-        if (!iores || irq_err < 0)
-                return -EINVAL;
+        if (irq_err < 0)
+                return irq_err;
 
         mmc = mmc_alloc_host(sizeof(struct mxs_mmc_host), &pdev->dev);
         if (!mmc)
@@ -593,6 +592,7 @@ static int mxs_mmc_probe(struct platform_device *pdev)
         host = mmc_priv(mmc);
         ssp = &host->ssp;
         ssp->dev = &pdev->dev;
+        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         ssp->base = devm_ioremap_resource(&pdev->dev, iores);
         if (IS_ERR(ssp->base)) {
                 ret = PTR_ERR(ssp->base);
@@ -619,7 +619,9 @@ static int mxs_mmc_probe(struct platform_device *pdev)
                 ret = PTR_ERR(ssp->clk);
                 goto out_mmc_free;
         }
-        clk_prepare_enable(ssp->clk);
+        ret = clk_prepare_enable(ssp->clk);
+        if (ret)
+                goto out_mmc_free;
 
         ret = mxs_mmc_reset(host);
         if (ret) {
@@ -660,7 +662,7 @@ static int mxs_mmc_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, mmc);
 
         ret = devm_request_irq(&pdev->dev, irq_err, mxs_mmc_irq_handler, 0,
-                               DRIVER_NAME, host);
+                               dev_name(&pdev->dev), host);
         if (ret)
                 goto out_free_dma;
 
@@ -702,7 +704,7 @@ static int mxs_mmc_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int mxs_mmc_suspend(struct device *dev)
 {
         struct mmc_host *mmc = dev_get_drvdata(dev);
@@ -719,25 +721,19 @@ static int mxs_mmc_resume(struct device *dev)
         struct mxs_mmc_host *host = mmc_priv(mmc);
         struct mxs_ssp *ssp = &host->ssp;
 
-        clk_prepare_enable(ssp->clk);
-        return 0;
+        return clk_prepare_enable(ssp->clk);
 }
-
-static const struct dev_pm_ops mxs_mmc_pm_ops = {
-        .suspend        = mxs_mmc_suspend,
-        .resume         = mxs_mmc_resume,
-};
 #endif
 
+static SIMPLE_DEV_PM_OPS(mxs_mmc_pm_ops, mxs_mmc_suspend, mxs_mmc_resume);
+
 static struct platform_driver mxs_mmc_driver = {
         .probe          = mxs_mmc_probe,
         .remove         = mxs_mmc_remove,
         .id_table       = mxs_ssp_ids,
         .driver         = {
                 .name   = DRIVER_NAME,
-#ifdef CONFIG_PM
                 .pm     = &mxs_mmc_pm_ops,
-#endif
                 .of_match_table = mxs_mmc_dt_ids,
         },
 };
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index df27bb4fc098..7c71dcdcba8b 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -42,7 +42,7 @@
 #include <linux/regulator/consumer.h>
 #include <linux/pinctrl/consumer.h>
 #include <linux/pm_runtime.h>
-#include <linux/platform_data/mmc-omap.h>
+#include <linux/platform_data/hsmmc-omap.h>
 
 /* OMAP HSMMC Host Controller Registers */
 #define OMAP_HSMMC_SYSSTATUS    0x0014
@@ -155,7 +155,7 @@
  * omap.c controller driver. Luckily this is not currently done on any known
  * omap_hsmmc.c device.
  */
-#define mmc_slot(host)          (host->pdata->slots[host->slot_id])
+#define mmc_pdata(host)         host->pdata
 
 /*
  * MMC Host controller read/write API's
@@ -207,7 +207,6 @@ struct omap_hsmmc_host {
         int                     use_dma, dma_ch;
         struct dma_chan         *tx_chan;
         struct dma_chan         *rx_chan;
-        int                     slot_id;
         int                     response_busy;
         int                     context_loss;
         int                     protect_card;
@@ -220,7 +219,26 @@ struct omap_hsmmc_host {
 #define HSMMC_SDIO_IRQ_ENABLED  (1 << 1)        /* SDIO irq enabled */
 #define HSMMC_WAKE_IRQ_ENABLED  (1 << 2)
         struct omap_hsmmc_next  next_data;
-        struct  omap_mmc_platform_data  *pdata;
+        struct  omap_hsmmc_platform_data        *pdata;
+
+        /* To handle board related suspend/resume functionality for MMC */
+        int (*suspend)(struct device *dev);
+        int (*resume)(struct device *dev);
+
+        /* return MMC cover switch state, can be NULL if not supported.
+         *
+         * possible return values:
+         *   0 - closed
+         *   1 - open
+         */
+        int (*get_cover_state)(struct device *dev);
+
+        /* Card detection IRQs */
+        int card_detect_irq;
+
+        int (*card_detect)(struct device *dev);
+        int (*get_ro)(struct device *dev);
+
 };
 
 struct omap_mmc_of_data {
@@ -230,50 +248,48 @@ struct omap_mmc_of_data {
 
 static void omap_hsmmc_start_dma_transfer(struct omap_hsmmc_host *host);
 
-static int omap_hsmmc_card_detect(struct device *dev, int slot)
+static int omap_hsmmc_card_detect(struct device *dev)
 {
         struct omap_hsmmc_host *host = dev_get_drvdata(dev);
-        struct omap_mmc_platform_data *mmc = host->pdata;
+        struct omap_hsmmc_platform_data *mmc = host->pdata;
 
         /* NOTE: assumes card detect signal is active-low */
-        return !gpio_get_value_cansleep(mmc->slots[0].switch_pin);
+        return !gpio_get_value_cansleep(mmc->switch_pin);
 }
 
-static int omap_hsmmc_get_wp(struct device *dev, int slot)
+static int omap_hsmmc_get_wp(struct device *dev)
 {
         struct omap_hsmmc_host *host = dev_get_drvdata(dev);
-        struct omap_mmc_platform_data *mmc = host->pdata;
+        struct omap_hsmmc_platform_data *mmc = host->pdata;
 
         /* NOTE: assumes write protect signal is active-high */
-        return gpio_get_value_cansleep(mmc->slots[0].gpio_wp);
+        return gpio_get_value_cansleep(mmc->gpio_wp);
 }
 
-static int omap_hsmmc_get_cover_state(struct device *dev, int slot)
+static int omap_hsmmc_get_cover_state(struct device *dev)
 {
         struct omap_hsmmc_host *host = dev_get_drvdata(dev);
-        struct omap_mmc_platform_data *mmc = host->pdata;
+        struct omap_hsmmc_platform_data *mmc = host->pdata;
 
         /* NOTE: assumes card detect signal is active-low */
-        return !gpio_get_value_cansleep(mmc->slots[0].switch_pin);
+        return !gpio_get_value_cansleep(mmc->switch_pin);
 }
 
 #ifdef CONFIG_PM
 
-static int omap_hsmmc_suspend_cdirq(struct device *dev, int slot)
+static int omap_hsmmc_suspend_cdirq(struct device *dev)
 {
         struct omap_hsmmc_host *host = dev_get_drvdata(dev);
-        struct omap_mmc_platform_data *mmc = host->pdata;
 
-        disable_irq(mmc->slots[0].card_detect_irq);
+        disable_irq(host->card_detect_irq);
         return 0;
 }
 
-static int omap_hsmmc_resume_cdirq(struct device *dev, int slot)
+static int omap_hsmmc_resume_cdirq(struct device *dev)
 {
         struct omap_hsmmc_host *host = dev_get_drvdata(dev);
-        struct omap_mmc_platform_data *mmc = host->pdata;
 
-        enable_irq(mmc->slots[0].card_detect_irq);
+        enable_irq(host->card_detect_irq);
         return 0;
 }
 
@@ -286,8 +302,7 @@ static int omap_hsmmc_resume_cdirq(struct device *dev, int slot)
 
 #ifdef CONFIG_REGULATOR
 
-static int omap_hsmmc_set_power(struct device *dev, int slot, int power_on,
-                                   int vdd)
+static int omap_hsmmc_set_power(struct device *dev, int power_on, int vdd)
 {
         struct omap_hsmmc_host *host =
                 platform_get_drvdata(to_platform_device(dev));
@@ -300,8 +315,8 @@ static int omap_hsmmc_set_power(struct device *dev, int slot, int power_on,
         if (!host->vcc)
                 return 0;
 
-        if (mmc_slot(host).before_set_reg)
-                mmc_slot(host).before_set_reg(dev, slot, power_on, vdd);
+        if (mmc_pdata(host)->before_set_reg)
+                mmc_pdata(host)->before_set_reg(dev, power_on, vdd);
 
         if (host->pbias) {
                 if (host->pbias_enabled == 1) {
@@ -363,8 +378,8 @@ static int omap_hsmmc_set_power(struct device *dev, int slot, int power_on,
                 }
         }
 
-        if (mmc_slot(host).after_set_reg)
-                mmc_slot(host).after_set_reg(dev, slot, power_on, vdd);
+        if (mmc_pdata(host)->after_set_reg)
+                mmc_pdata(host)->after_set_reg(dev, power_on, vdd);
 
 error_set_power:
         return ret;
@@ -383,18 +398,18 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
         } else {
                 host->vcc = reg;
                 ocr_value = mmc_regulator_get_ocrmask(reg);
-                if (!mmc_slot(host).ocr_mask) {
-                        mmc_slot(host).ocr_mask = ocr_value;
+                if (!mmc_pdata(host)->ocr_mask) {
+                        mmc_pdata(host)->ocr_mask = ocr_value;
                 } else {
-                        if (!(mmc_slot(host).ocr_mask & ocr_value)) {
+                        if (!(mmc_pdata(host)->ocr_mask & ocr_value)) {
                                 dev_err(host->dev, "ocrmask %x is not supported\n",
-                                        mmc_slot(host).ocr_mask);
-                                mmc_slot(host).ocr_mask = 0;
+                                        mmc_pdata(host)->ocr_mask);
+                                mmc_pdata(host)->ocr_mask = 0;
                                 return -EINVAL;
                         }
                 }
         }
-        mmc_slot(host).set_power = omap_hsmmc_set_power;
+        mmc_pdata(host)->set_power = omap_hsmmc_set_power;
 
         /* Allow an aux regulator */
         reg = devm_regulator_get_optional(host->dev, "vmmc_aux");
@@ -404,7 +419,7 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
         host->pbias = IS_ERR(reg) ? NULL : reg;
 
         /* For eMMC do not power off when not in sleep state */
-        if (mmc_slot(host).no_regulator_off_init)
+        if (mmc_pdata(host)->no_regulator_off_init)
                 return 0;
         /*
          * To disable boot_on regulator, enable regulator
@@ -412,10 +427,10 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
          */
         if ((host->vcc && regulator_is_enabled(host->vcc) > 0) ||
             (host->vcc_aux && regulator_is_enabled(host->vcc_aux))) {
-                int vdd = ffs(mmc_slot(host).ocr_mask) - 1;
+                int vdd = ffs(mmc_pdata(host)->ocr_mask) - 1;
 
-                mmc_slot(host).set_power(host->dev, host->slot_id, 1, vdd);
-                mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);
+                mmc_pdata(host)->set_power(host->dev, 1, vdd);
+                mmc_pdata(host)->set_power(host->dev, 0, 0);
         }
 
         return 0;
@@ -423,7 +438,7 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
 
 static void omap_hsmmc_reg_put(struct omap_hsmmc_host *host)
 {
-        mmc_slot(host).set_power = NULL;
+        mmc_pdata(host)->set_power = NULL;
 }
 
 static inline int omap_hsmmc_have_reg(void)
@@ -449,55 +464,59 @@ static inline int omap_hsmmc_have_reg(void)
 
 #endif
 
-static int omap_hsmmc_gpio_init(struct omap_mmc_platform_data *pdata)
+static int omap_hsmmc_gpio_init(struct omap_hsmmc_host *host,
+                                struct omap_hsmmc_platform_data *pdata)
 {
         int ret;
 
-        if (gpio_is_valid(pdata->slots[0].switch_pin)) {
-                if (pdata->slots[0].cover)
-                        pdata->slots[0].get_cover_state =
-                                        omap_hsmmc_get_cover_state;
+        if (gpio_is_valid(pdata->switch_pin)) {
+                if (pdata->cover)
+                        host->get_cover_state =
+                                omap_hsmmc_get_cover_state;
                 else
-                        pdata->slots[0].card_detect = omap_hsmmc_card_detect;
-                pdata->slots[0].card_detect_irq =
-                                gpio_to_irq(pdata->slots[0].switch_pin);
-                ret = gpio_request(pdata->slots[0].switch_pin, "mmc_cd");
+                        host->card_detect = omap_hsmmc_card_detect;
+                host->card_detect_irq =
+                                gpio_to_irq(pdata->switch_pin);
+                ret = gpio_request(pdata->switch_pin, "mmc_cd");
                 if (ret)
                         return ret;
-                ret = gpio_direction_input(pdata->slots[0].switch_pin);
+                ret = gpio_direction_input(pdata->switch_pin);
                 if (ret)
                         goto err_free_sp;
-        } else
-                pdata->slots[0].switch_pin = -EINVAL;
+        } else {
+                pdata->switch_pin = -EINVAL;
+        }
 
-        if (gpio_is_valid(pdata->slots[0].gpio_wp)) {
-                pdata->slots[0].get_ro = omap_hsmmc_get_wp;
-                ret = gpio_request(pdata->slots[0].gpio_wp, "mmc_wp");
+        if (gpio_is_valid(pdata->gpio_wp)) {
+                host->get_ro = omap_hsmmc_get_wp;
+                ret = gpio_request(pdata->gpio_wp, "mmc_wp");
                 if (ret)
                         goto err_free_cd;
-                ret = gpio_direction_input(pdata->slots[0].gpio_wp);
+                ret = gpio_direction_input(pdata->gpio_wp);
                 if (ret)
                         goto err_free_wp;
-        } else
-                pdata->slots[0].gpio_wp = -EINVAL;
+        } else {
+                pdata->gpio_wp = -EINVAL;
+        }
 
         return 0;
 
 err_free_wp:
-        gpio_free(pdata->slots[0].gpio_wp);
+        gpio_free(pdata->gpio_wp);
 err_free_cd:
-        if (gpio_is_valid(pdata->slots[0].switch_pin))
+        if (gpio_is_valid(pdata->switch_pin))
 err_free_sp:
-                gpio_free(pdata->slots[0].switch_pin);
+                gpio_free(pdata->switch_pin);
         return ret;
 }
 
-static void omap_hsmmc_gpio_free(struct omap_mmc_platform_data *pdata)
+static void omap_hsmmc_gpio_free(struct omap_hsmmc_host *host,
+                                 struct omap_hsmmc_platform_data *pdata)
 {
-        if (gpio_is_valid(pdata->slots[0].gpio_wp))
-                gpio_free(pdata->slots[0].gpio_wp);
-        if (gpio_is_valid(pdata->slots[0].switch_pin))
-                gpio_free(pdata->slots[0].switch_pin);
+        if (gpio_is_valid(pdata->gpio_wp))
+                gpio_free(pdata->gpio_wp);
+        if (gpio_is_valid(pdata->switch_pin))
+                gpio_free(pdata->switch_pin);
 }
 
 /*
@@ -607,8 +626,9 @@ static void omap_hsmmc_set_clock(struct omap_hsmmc_host *host)
          *        in capabilities register
          *      - MMC/SD clock coming out of controller > 25MHz
          */
-        if ((mmc_slot(host).features & HSMMC_HAS_HSPE_SUPPORT) &&
+        if ((mmc_pdata(host)->features & HSMMC_HAS_HSPE_SUPPORT) &&
             (ios->timing != MMC_TIMING_MMC_DDR52) &&
+            (ios->timing != MMC_TIMING_UHS_DDR50) &&
             ((OMAP_HSMMC_READ(host->base, CAPA) & HSS) == HSS)) {
                 regval = OMAP_HSMMC_READ(host->base, HCTL);
                 if (clkdiv && (clk_get_rate(host->fclk)/clkdiv) > 25000000)
@@ -628,7 +648,8 @@ static void omap_hsmmc_set_bus_width(struct omap_hsmmc_host *host)
         u32 con;
 
         con = OMAP_HSMMC_READ(host->base, CON);
-        if (ios->timing == MMC_TIMING_MMC_DDR52)
+        if (ios->timing == MMC_TIMING_MMC_DDR52 ||
+            ios->timing == MMC_TIMING_UHS_DDR50)
                 con |= DDR;     /* configure in DDR mode */
         else
                 con &= ~DDR;
@@ -791,8 +812,8 @@ int omap_hsmmc_cover_is_closed(struct omap_hsmmc_host *host)
 {
         int r = 1;
 
-        if (mmc_slot(host).get_cover_state)
-                r = mmc_slot(host).get_cover_state(host->dev, host->slot_id);
+        if (host->get_cover_state)
+                r = host->get_cover_state(host->dev);
         return r;
 }
 
@@ -816,7 +837,7 @@ omap_hsmmc_show_slot_name(struct device *dev, struct device_attribute *attr,
         struct mmc_host *mmc = container_of(dev, struct mmc_host, class_dev);
         struct omap_hsmmc_host *host = mmc_priv(mmc);
 
-        return sprintf(buf, "%s\n", mmc_slot(host).name);
+        return sprintf(buf, "%s\n", mmc_pdata(host)->name);
 }
 
 static DEVICE_ATTR(slot_name, S_IRUGO, omap_hsmmc_show_slot_name, NULL);
@@ -1061,7 +1082,7 @@ static inline void omap_hsmmc_reset_controller_fsm(struct omap_hsmmc_host *host,
          * OMAP4 ES2 and greater has an updated reset logic.
          * Monitor a 0->1 transition first
          */
-        if (mmc_slot(host).features & HSMMC_HAS_UPDATED_RESET) {
+        if (mmc_pdata(host)->features & HSMMC_HAS_UPDATED_RESET) {
                 while ((!(OMAP_HSMMC_READ(host->base, SYSCTL) & bit))
                                         && (i++ < limit))
                         udelay(1);
@@ -1210,12 +1231,11 @@ static int omap_hsmmc_switch_opcond(struct omap_hsmmc_host *host, int vdd)
                 clk_disable_unprepare(host->dbclk);
 
         /* Turn the power off */
-        ret = mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);
+        ret = mmc_pdata(host)->set_power(host->dev, 0, 0);
 
         /* Turn the power ON with given VDD 1.8 or 3.0v */
         if (!ret)
-                ret = mmc_slot(host).set_power(host->dev, host->slot_id, 1,
-                                               vdd);
+                ret = mmc_pdata(host)->set_power(host->dev, 1, vdd);
         pm_runtime_get_sync(host->dev);
         if (host->dbclk)
                 clk_prepare_enable(host->dbclk);
@@ -1259,11 +1279,11 @@ err:
 /* Protect the card while the cover is open */
 static void omap_hsmmc_protect_card(struct omap_hsmmc_host *host)
 {
-        if (!mmc_slot(host).get_cover_state)
+        if (!host->get_cover_state)
                 return;
 
         host->reqs_blocked = 0;
-        if (mmc_slot(host).get_cover_state(host->dev, host->slot_id)) {
+        if (host->get_cover_state(host->dev)) {
                 if (host->protect_card) {
                         dev_info(host->dev, "%s: cover is closed, "
                                          "card is now accessible\n",
@@ -1286,13 +1306,12 @@ static void omap_hsmmc_protect_card(struct omap_hsmmc_host *host)
 static irqreturn_t omap_hsmmc_detect(int irq, void *dev_id)
 {
         struct omap_hsmmc_host *host = dev_id;
-        struct omap_mmc_slot_data *slot = &mmc_slot(host);
         int carddetect;
 
         sysfs_notify(&host->mmc->class_dev.kobj, NULL, "cover_switch");
 
-        if (slot->card_detect)
-                carddetect = slot->card_detect(host->dev, host->slot_id);
+        if (host->card_detect)
+                carddetect = host->card_detect(host->dev);
         else {
                 omap_hsmmc_protect_card(host);
                 carddetect = -ENOSYS;
@@ -1618,12 +1637,10 @@ static void omap_hsmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         if (ios->power_mode != host->power_mode) {
                 switch (ios->power_mode) {
                 case MMC_POWER_OFF:
-                        mmc_slot(host).set_power(host->dev, host->slot_id,
-                                                 0, 0);
+                        mmc_pdata(host)->set_power(host->dev, 0, 0);
                         break;
                 case MMC_POWER_UP:
-                        mmc_slot(host).set_power(host->dev, host->slot_id,
-                                                 1, ios->vdd);
+                        mmc_pdata(host)->set_power(host->dev, 1, ios->vdd);
                         break;
                 case MMC_POWER_ON:
                         do_send_init_stream = 1;
@@ -1668,26 +1685,26 @@ static int omap_hsmmc_get_cd(struct mmc_host *mmc)
 {
         struct omap_hsmmc_host *host = mmc_priv(mmc);
 
-        if (!mmc_slot(host).card_detect)
+        if (!host->card_detect)
                 return -ENOSYS;
-        return mmc_slot(host).card_detect(host->dev, host->slot_id);
+        return host->card_detect(host->dev);
 }
 
 static int omap_hsmmc_get_ro(struct mmc_host *mmc)
 {
         struct omap_hsmmc_host *host = mmc_priv(mmc);
 
-        if (!mmc_slot(host).get_ro)
+        if (!host->get_ro)
                 return -ENOSYS;
-        return mmc_slot(host).get_ro(host->dev, 0);
+        return host->get_ro(host->dev);
 }
 
 static void omap_hsmmc_init_card(struct mmc_host *mmc, struct mmc_card *card)
 {
         struct omap_hsmmc_host *host = mmc_priv(mmc);
 
-        if (mmc_slot(host).init_card)
-                mmc_slot(host).init_card(card);
+        if (mmc_pdata(host)->init_card)
+                mmc_pdata(host)->init_card(card);
 }
 
 static void omap_hsmmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
@@ -1957,9 +1974,9 @@ static const struct of_device_id omap_mmc_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, omap_mmc_of_match);
 
-static struct omap_mmc_platform_data *of_get_hsmmc_pdata(struct device *dev)
+static struct omap_hsmmc_platform_data *of_get_hsmmc_pdata(struct device *dev)
 {
-        struct omap_mmc_platform_data *pdata;
+        struct omap_hsmmc_platform_data *pdata;
         struct device_node *np = dev->of_node;
         u32 bus_width, max_freq;
         int cd_gpio, wp_gpio;
@@ -1976,40 +1993,38 @@ static struct omap_mmc_platform_data *of_get_hsmmc_pdata(struct device *dev)
         if (of_find_property(np, "ti,dual-volt", NULL))
                 pdata->controller_flags |= OMAP_HSMMC_SUPPORTS_DUAL_VOLT;
 
-        /* This driver only supports 1 slot */
-        pdata->nr_slots = 1;
-        pdata->slots[0].switch_pin = cd_gpio;
-        pdata->slots[0].gpio_wp = wp_gpio;
+        pdata->switch_pin = cd_gpio;
+        pdata->gpio_wp = wp_gpio;
 
         if (of_find_property(np, "ti,non-removable", NULL)) {
-                pdata->slots[0].nonremovable = true;
-                pdata->slots[0].no_regulator_off_init = true;
+                pdata->nonremovable = true;
+                pdata->no_regulator_off_init = true;
         }
         of_property_read_u32(np, "bus-width", &bus_width);
         if (bus_width == 4)
-                pdata->slots[0].caps |= MMC_CAP_4_BIT_DATA;
+                pdata->caps |= MMC_CAP_4_BIT_DATA;
         else if (bus_width == 8)
-                pdata->slots[0].caps |= MMC_CAP_8_BIT_DATA;
+                pdata->caps |= MMC_CAP_8_BIT_DATA;
 
         if (of_find_property(np, "ti,needs-special-reset", NULL))
-                pdata->slots[0].features |= HSMMC_HAS_UPDATED_RESET;
+                pdata->features |= HSMMC_HAS_UPDATED_RESET;
 
         if (!of_property_read_u32(np, "max-frequency", &max_freq))
                 pdata->max_freq = max_freq;
 
         if (of_find_property(np, "ti,needs-special-hs-handling", NULL))
-                pdata->slots[0].features |= HSMMC_HAS_HSPE_SUPPORT;
+                pdata->features |= HSMMC_HAS_HSPE_SUPPORT;
 
         if (of_find_property(np, "keep-power-in-suspend", NULL))
-                pdata->slots[0].pm_caps |= MMC_PM_KEEP_POWER;
+                pdata->pm_caps |= MMC_PM_KEEP_POWER;
 
         if (of_find_property(np, "enable-sdio-wakeup", NULL))
-                pdata->slots[0].pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
+                pdata->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
 
         return pdata;
 }
 #else
-static inline struct omap_mmc_platform_data
+static inline struct omap_hsmmc_platform_data
                         *of_get_hsmmc_pdata(struct device *dev)
 {
         return ERR_PTR(-EINVAL);
@@ -2018,7 +2033,7 @@ static inline struct omap_mmc_platform_data
 
 static int omap_hsmmc_probe(struct platform_device *pdev)
 {
-        struct omap_mmc_platform_data *pdata = pdev->dev.platform_data;
+        struct omap_hsmmc_platform_data *pdata = pdev->dev.platform_data;
         struct mmc_host *mmc;
         struct omap_hsmmc_host *host = NULL;
         struct resource *res;
@@ -2048,11 +2063,6 @@ static int omap_hsmmc_probe(struct platform_device *pdev)
                 return -ENXIO;
         }
 
-        if (pdata->nr_slots == 0) {
-                dev_err(&pdev->dev, "No Slots\n");
-                return -ENXIO;
-        }
-
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
         if (res == NULL || irq < 0)
@@ -2062,14 +2072,10 @@ static int omap_hsmmc_probe(struct platform_device *pdev)
         if (IS_ERR(base))
                 return PTR_ERR(base);
 
-        ret = omap_hsmmc_gpio_init(pdata);
-        if (ret)
-                goto err;
-
         mmc = mmc_alloc_host(sizeof(struct omap_hsmmc_host), &pdev->dev);
         if (!mmc) {
                 ret = -ENOMEM;
-                goto err_alloc;
+                goto err;
         }
 
         host            = mmc_priv(mmc);
@@ -2079,13 +2085,16 @@ static int omap_hsmmc_probe(struct platform_device *pdev)
         host->use_dma   = 1;
         host->dma_ch    = -1;
         host->irq       = irq;
-        host->slot_id   = 0;
         host->mapbase   = res->start + pdata->reg_offset;
         host->base      = base + pdata->reg_offset;
         host->power_mode = MMC_POWER_OFF;
         host->next_data.cookie = 1;
         host->pbias_enabled = 0;
 
+        ret = omap_hsmmc_gpio_init(host, pdata);
+        if (ret)
+                goto err_gpio;
+
         platform_set_drvdata(pdev, host);
 
         if (pdev->dev.of_node)
@@ -2144,14 +2153,14 @@ static int omap_hsmmc_probe(struct platform_device *pdev)
         mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED |
                      MMC_CAP_WAIT_WHILE_BUSY | MMC_CAP_ERASE;
 
-        mmc->caps |= mmc_slot(host).caps;
+        mmc->caps |= mmc_pdata(host)->caps;
         if (mmc->caps & MMC_CAP_8_BIT_DATA)
                 mmc->caps |= MMC_CAP_4_BIT_DATA;
 
-        if (mmc_slot(host).nonremovable)
+        if (mmc_pdata(host)->nonremovable)
                 mmc->caps |= MMC_CAP_NONREMOVABLE;
 
-        mmc->pm_caps = mmc_slot(host).pm_caps;
+        mmc->pm_caps = mmc_pdata(host)->pm_caps;
 
         omap_hsmmc_conf_bus_power(host);
 
@@ -2204,27 +2213,19 @@ static int omap_hsmmc_probe(struct platform_device *pdev)
                 goto err_irq;
         }
 
-        if (pdata->init != NULL) {
-                if (pdata->init(&pdev->dev) != 0) {
-                        dev_err(mmc_dev(host->mmc),
-                                "Unable to configure MMC IRQs\n");
-                        goto err_irq;
-                }
-        }
-
-        if (omap_hsmmc_have_reg() && !mmc_slot(host).set_power) {
+        if (omap_hsmmc_have_reg() && !mmc_pdata(host)->set_power) {
                 ret = omap_hsmmc_reg_get(host);
                 if (ret)
-                        goto err_reg;
+                        goto err_irq;
                 host->use_reg = 1;
         }
 
-        mmc->ocr_avail = mmc_slot(host).ocr_mask;
+        mmc->ocr_avail = mmc_pdata(host)->ocr_mask;
 
         /* Request IRQ for card detect */
-        if ((mmc_slot(host).card_detect_irq)) {
+        if (host->card_detect_irq) {
                 ret = devm_request_threaded_irq(&pdev->dev,
-                                                mmc_slot(host).card_detect_irq,
+                                                host->card_detect_irq,
                                                 NULL, omap_hsmmc_detect,
                                            IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                            mmc_hostname(mmc), host);
@@ -2233,8 +2234,8 @@ static int omap_hsmmc_probe(struct platform_device *pdev)
                                 "Unable to grab MMC CD IRQ\n");
                         goto err_irq_cd;
                 }
-                pdata->suspend = omap_hsmmc_suspend_cdirq;
-                pdata->resume = omap_hsmmc_resume_cdirq;
+                host->suspend = omap_hsmmc_suspend_cdirq;
+                host->resume = omap_hsmmc_resume_cdirq;
         }
 
         omap_hsmmc_disable_irq(host);
@@ -2255,12 +2256,12 @@ static int omap_hsmmc_probe(struct platform_device *pdev)
 
         mmc_add_host(mmc);
 
-        if (mmc_slot(host).name != NULL) {
+        if (mmc_pdata(host)->name != NULL) {
                 ret = device_create_file(&mmc->class_dev, &dev_attr_slot_name);
                 if (ret < 0)
                         goto err_slot_name;
         }
-        if (mmc_slot(host).card_detect_irq && mmc_slot(host).get_cover_state) {
+        if (host->card_detect_irq && host->get_cover_state) {
                 ret = device_create_file(&mmc->class_dev,
                                         &dev_attr_cover_switch);
                 if (ret < 0)
@@ -2278,9 +2279,6 @@ err_slot_name:
 err_irq_cd:
         if (host->use_reg)
                 omap_hsmmc_reg_put(host);
-err_reg:
-        if (host->pdata->cleanup)
-                host->pdata->cleanup(&pdev->dev);
 err_irq:
         if (host->tx_chan)
                 dma_release_channel(host->tx_chan);
@@ -2291,9 +2289,9 @@ err_irq:
         if (host->dbclk)
                 clk_disable_unprepare(host->dbclk);
 err1:
+        omap_hsmmc_gpio_free(host, pdata);
+err_gpio:
         mmc_free_host(mmc);
-err_alloc:
-        omap_hsmmc_gpio_free(pdata);
 err:
         return ret;
 }
@@ -2306,8 +2304,6 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
         mmc_remove_host(host->mmc);
         if (host->use_reg)
                 omap_hsmmc_reg_put(host);
-        if (host->pdata->cleanup)
-                host->pdata->cleanup(&pdev->dev);
 
         if (host->tx_chan)
                 dma_release_channel(host->tx_chan);
@@ -2319,7 +2315,7 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
         if (host->dbclk)
                 clk_disable_unprepare(host->dbclk);
 
-        omap_hsmmc_gpio_free(host->pdata);
+        omap_hsmmc_gpio_free(host, host->pdata);
         mmc_free_host(host->mmc);
 
         return 0;
@@ -2330,8 +2326,8 @@ static int omap_hsmmc_prepare(struct device *dev)
 {
         struct omap_hsmmc_host *host = dev_get_drvdata(dev);
 
-        if (host->pdata->suspend)
-                return host->pdata->suspend(dev, host->slot_id);
+        if (host->suspend)
+                return host->suspend(dev);
 
         return 0;
 }
@@ -2340,8 +2336,8 @@ static void omap_hsmmc_complete(struct device *dev)
 {
         struct omap_hsmmc_host *host = dev_get_drvdata(dev);
 
-        if (host->pdata->resume)
-                host->pdata->resume(dev, host->slot_id);
+        if (host->resume)
+                host->resume(dev);
 
 }
 
diff --git a/drivers/mmc/host/sdhci-acpi.c b/drivers/mmc/host/sdhci-acpi.c
index 9cccc0e89b04..c01eac7c8196 100644
--- a/drivers/mmc/host/sdhci-acpi.c
+++ b/drivers/mmc/host/sdhci-acpi.c
@@ -76,6 +76,7 @@ struct sdhci_acpi_host {
         const struct sdhci_acpi_slot    *slot;
         struct platform_device          *pdev;
         bool                            use_runtime_pm;
+        bool                            dma_setup;
 };
 
 static inline bool sdhci_acpi_flag(struct sdhci_acpi_host *c, unsigned int flag)
@@ -85,7 +86,29 @@ static inline bool sdhci_acpi_flag(struct sdhci_acpi_host *c, unsigned int flag)
 
 static int sdhci_acpi_enable_dma(struct sdhci_host *host)
 {
-        return 0;
+        struct sdhci_acpi_host *c = sdhci_priv(host);
+        struct device *dev = &c->pdev->dev;
+        int err = -1;
+
+        if (c->dma_setup)
+                return 0;
+
+        if (host->flags & SDHCI_USE_64_BIT_DMA) {
+                if (host->quirks2 & SDHCI_QUIRK2_BROKEN_64_BIT_DMA) {
+                        host->flags &= ~SDHCI_USE_64_BIT_DMA;
+                } else {
+                        err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
+                        if (err)
+                                dev_warn(dev, "Failed to set 64-bit DMA mask\n");
+                }
+        }
+
+        if (err)
+                err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
+
+        c->dma_setup = !err;
+
+        return err;
 }
 
 static void sdhci_acpi_int_hw_reset(struct sdhci_host *host)
@@ -180,17 +203,21 @@ static int sdhci_acpi_sd_probe_slot(struct platform_device *pdev,
 static const struct sdhci_acpi_slot sdhci_acpi_slot_int_emmc = {
         .chip    = &sdhci_acpi_chip_int,
         .caps    = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE |
-                   MMC_CAP_HW_RESET | MMC_CAP_1_8V_DDR,
+                   MMC_CAP_HW_RESET | MMC_CAP_1_8V_DDR |
+                   MMC_CAP_BUS_WIDTH_TEST | MMC_CAP_WAIT_WHILE_BUSY,
         .caps2   = MMC_CAP2_HC_ERASE_SZ,
         .flags   = SDHCI_ACPI_RUNTIME_PM,
+        .quirks  = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN | SDHCI_QUIRK2_STOP_WITH_TC,
         .probe_slot     = sdhci_acpi_emmc_probe_slot,
 };
 
 static const struct sdhci_acpi_slot sdhci_acpi_slot_int_sdio = {
-        .quirks  = SDHCI_QUIRK_BROKEN_CARD_DETECTION,
+        .quirks  = SDHCI_QUIRK_BROKEN_CARD_DETECTION |
+                   SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .quirks2 = SDHCI_QUIRK2_HOST_OFF_CARD_ON,
-        .caps    = MMC_CAP_NONREMOVABLE | MMC_CAP_POWER_OFF_CARD,
+        .caps    = MMC_CAP_NONREMOVABLE | MMC_CAP_POWER_OFF_CARD |
+                   MMC_CAP_BUS_WIDTH_TEST | MMC_CAP_WAIT_WHILE_BUSY,
         .flags   = SDHCI_ACPI_RUNTIME_PM,
         .pm_caps = MMC_PM_KEEP_POWER,
         .probe_slot     = sdhci_acpi_sdio_probe_slot,
@@ -199,8 +226,10 @@ static const struct sdhci_acpi_slot sdhci_acpi_slot_int_sdio = {
 static const struct sdhci_acpi_slot sdhci_acpi_slot_int_sd = {
         .flags   = SDHCI_ACPI_SD_CD | SDHCI_ACPI_SD_CD_OVERRIDE_LEVEL |
                    SDHCI_ACPI_RUNTIME_PM,
+        .quirks  = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .quirks2 = SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON |
                    SDHCI_QUIRK2_STOP_WITH_TC,
+        .caps    = MMC_CAP_BUS_WIDTH_TEST | MMC_CAP_WAIT_WHILE_BUSY,
         .probe_slot     = sdhci_acpi_sd_probe_slot,
 };
 
@@ -305,21 +334,6 @@ static int sdhci_acpi_probe(struct platform_device *pdev)
                 goto err_free;
         }
 
-        if (!dev->dma_mask) {
-                u64 dma_mask;
-
-                if (sdhci_readl(host, SDHCI_CAPABILITIES) & SDHCI_CAN_64BIT) {
-                        /* 64-bit DMA is not supported at present */
-                        dma_mask = DMA_BIT_MASK(32);
-                } else {
-                        dma_mask = DMA_BIT_MASK(32);
-                }
-
-                err = dma_coerce_mask_and_coherent(dev, dma_mask);
-                if (err)
-                        goto err_free;
-        }
-
         if (c->slot) {
                 if (c->slot->probe_slot) {
                         err = c->slot->probe_slot(pdev, hid, uid);
@@ -416,7 +430,7 @@ static int sdhci_acpi_resume(struct device *dev)
 
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 
 static int sdhci_acpi_runtime_suspend(struct device *dev)
 {
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index 587ee0edeb57..af1f7c0f9545 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -65,8 +65,6 @@
 /* NOTE: the minimum valid tuning start tap for mx6sl is 1 */
 #define ESDHC_TUNING_START_TAP          0x1
 
-#define ESDHC_TUNING_BLOCK_PATTERN_LEN  64
-
 /* pinctrl state */
 #define ESDHC_PINCTRL_STATE_100MHZ      "state_100mhz"
 #define ESDHC_PINCTRL_STATE_200MHZ      "state_200mhz"
@@ -692,8 +690,6 @@ static void esdhc_prepare_tuning(struct sdhci_host *host, u32 val)
         /* FIXME: delay a bit for card to be ready for next tuning due to errors */
         mdelay(1);
 
-        /* This is balanced by the runtime put in sdhci_tasklet_finish */
-        pm_runtime_get_sync(host->mmc->parent);
         reg = readl(host->ioaddr + ESDHC_MIX_CTRL);
         reg |= ESDHC_MIX_CTRL_EXE_TUNE | ESDHC_MIX_CTRL_SMPCLK_SEL |
                         ESDHC_MIX_CTRL_FBCLK_SEL;
@@ -704,54 +700,6 @@ static void esdhc_prepare_tuning(struct sdhci_host *host, u32 val)
                         val, readl(host->ioaddr + ESDHC_TUNE_CTRL_STATUS));
 }
 
-static void esdhc_request_done(struct mmc_request *mrq)
-{
-        complete(&mrq->completion);
-}
-
-static int esdhc_send_tuning_cmd(struct sdhci_host *host, u32 opcode,
-                                 struct scatterlist *sg)
-{
-        struct mmc_command cmd = {0};
-        struct mmc_request mrq = {NULL};
-        struct mmc_data data = {0};
-
-        cmd.opcode = opcode;
-        cmd.arg = 0;
-        cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
-
-        data.blksz = ESDHC_TUNING_BLOCK_PATTERN_LEN;
-        data.blocks = 1;
-        data.flags = MMC_DATA_READ;
-        data.sg = sg;
-        data.sg_len = 1;
-
-        mrq.cmd = &cmd;
-        mrq.cmd->mrq = &mrq;
-        mrq.data = &data;
-        mrq.data->mrq = &mrq;
-        mrq.cmd->data = mrq.data;
-
-        mrq.done = esdhc_request_done;
-        init_completion(&(mrq.completion));
-
-        spin_lock_irq(&host->lock);
-        host->mrq = &mrq;
-
-        sdhci_send_command(host, mrq.cmd);
-
-        spin_unlock_irq(&host->lock);
-
-        wait_for_completion(&mrq.completion);
-
-        if (cmd.error)
-                return cmd.error;
-        if (data.error)
-                return data.error;
-
-        return 0;
-}
-
 static void esdhc_post_tuning(struct sdhci_host *host)
 {
         u32 reg;
@@ -763,21 +711,13 @@ static void esdhc_post_tuning(struct sdhci_host *host)
 
 static int esdhc_executing_tuning(struct sdhci_host *host, u32 opcode)
 {
-        struct scatterlist sg;
-        char *tuning_pattern;
         int min, max, avg, ret;
 
-        tuning_pattern = kmalloc(ESDHC_TUNING_BLOCK_PATTERN_LEN, GFP_KERNEL);
-        if (!tuning_pattern)
-                return -ENOMEM;
-
-        sg_init_one(&sg, tuning_pattern, ESDHC_TUNING_BLOCK_PATTERN_LEN);
-
         /* find the mininum delay first which can pass tuning */
         min = ESDHC_TUNE_CTRL_MIN;
         while (min < ESDHC_TUNE_CTRL_MAX) {
                 esdhc_prepare_tuning(host, min);
-                if (!esdhc_send_tuning_cmd(host, opcode, &sg))
+                if (!mmc_send_tuning(host->mmc))
                         break;
                 min += ESDHC_TUNE_CTRL_STEP;
         }
@@ -786,7 +726,7 @@ static int esdhc_executing_tuning(struct sdhci_host *host, u32 opcode)
         max = min + ESDHC_TUNE_CTRL_STEP;
         while (max < ESDHC_TUNE_CTRL_MAX) {
                 esdhc_prepare_tuning(host, max);
-                if (esdhc_send_tuning_cmd(host, opcode, &sg)) {
+                if (mmc_send_tuning(host->mmc)) {
                         max -= ESDHC_TUNE_CTRL_STEP;
                         break;
                 }
@@ -796,11 +736,9 @@ static int esdhc_executing_tuning(struct sdhci_host *host, u32 opcode)
         /* use average delay to get the best timing */
         avg = (min + max) / 2;
         esdhc_prepare_tuning(host, avg);
-        ret = esdhc_send_tuning_cmd(host, opcode, &sg);
+        ret = mmc_send_tuning(host->mmc);
         esdhc_post_tuning(host);
 
-        kfree(tuning_pattern);
-
         dev_dbg(mmc_dev(host->mmc), "tunning %s at 0x%x ret %d\n",
                 ret ? "failed" : "passed", avg, ret);
 
@@ -1031,11 +969,8 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
 
         imx_data->pins_default = pinctrl_lookup_state(imx_data->pinctrl,
                                                 PINCTRL_STATE_DEFAULT);
-        if (IS_ERR(imx_data->pins_default)) {
-                err = PTR_ERR(imx_data->pins_default);
-                dev_err(mmc_dev(host->mmc), "could not get default state\n");
-                goto disable_clk;
-        }
+        if (IS_ERR(imx_data->pins_default))
+                dev_warn(mmc_dev(host->mmc), "could not get default state\n");
 
         host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
 
@@ -1123,7 +1058,8 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
         }
 
         /* sdr50 and sdr104 needs work on 1.8v signal voltage */
-        if ((boarddata->support_vsel) && esdhc_is_usdhc(imx_data)) {
+        if ((boarddata->support_vsel) && esdhc_is_usdhc(imx_data) &&
+            !IS_ERR(imx_data->pins_default)) {
                 imx_data->pins_100mhz = pinctrl_lookup_state(imx_data->pinctrl,
                                                 ESDHC_PINCTRL_STATE_100MHZ);
                 imx_data->pins_200mhz = pinctrl_lookup_state(imx_data->pinctrl,
@@ -1172,7 +1108,7 @@ static int sdhci_esdhc_imx_remove(struct platform_device *pdev)
         pm_runtime_dont_use_autosuspend(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
 
-        if (!IS_ENABLED(CONFIG_PM_RUNTIME)) {
+        if (!IS_ENABLED(CONFIG_PM)) {
                 clk_disable_unprepare(imx_data->clk_per);
                 clk_disable_unprepare(imx_data->clk_ipg);
                 clk_disable_unprepare(imx_data->clk_ahb);
@@ -1183,7 +1119,7 @@ static int sdhci_esdhc_imx_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int sdhci_esdhc_runtime_suspend(struct device *dev)
 {
         struct sdhci_host *host = dev_get_drvdata(dev);
diff --git a/drivers/mmc/host/sdhci-msm.c b/drivers/mmc/host/sdhci-msm.c
index 30804385af6d..3d32ce896b09 100644
--- a/drivers/mmc/host/sdhci-msm.c
+++ b/drivers/mmc/host/sdhci-msm.c
@@ -339,9 +339,7 @@ static int msm_init_cm_dll(struct sdhci_host *host)
 static int sdhci_msm_execute_tuning(struct sdhci_host *host, u32 opcode)
 {
         int tuning_seq_cnt = 3;
-        u8 phase, *data_buf, tuned_phases[16], tuned_phase_cnt = 0;
-        const u8 *tuning_block_pattern = tuning_blk_pattern_4bit;
-        int size = sizeof(tuning_blk_pattern_4bit);
+        u8 phase, tuned_phases[16], tuned_phase_cnt = 0;
         int rc;
         struct mmc_host *mmc = host->mmc;
         struct mmc_ios ios = host->mmc->ios;
@@ -355,53 +353,21 @@ static int sdhci_msm_execute_tuning(struct sdhci_host *host, u32 opcode)
               (ios.timing == MMC_TIMING_UHS_SDR104)))
                 return 0;
 
-        if ((opcode == MMC_SEND_TUNING_BLOCK_HS200) &&
-            (mmc->ios.bus_width == MMC_BUS_WIDTH_8)) {
-                tuning_block_pattern = tuning_blk_pattern_8bit;
-                size = sizeof(tuning_blk_pattern_8bit);
-        }
-
-        data_buf = kmalloc(size, GFP_KERNEL);
-        if (!data_buf)
-                return -ENOMEM;
-
 retry:
         /* First of all reset the tuning block */
         rc = msm_init_cm_dll(host);
         if (rc)
-                goto out;
+                return rc;
 
         phase = 0;
         do {
-                struct mmc_command cmd = { 0 };
-                struct mmc_data data = { 0 };
-                struct mmc_request mrq = {
-                        .cmd = &cmd,
-                        .data = &data
-                };
-                struct scatterlist sg;
-
                 /* Set the phase in delay line hw block */
                 rc = msm_config_cm_dll_phase(host, phase);
                 if (rc)
-                        goto out;
+                        return rc;
 
-                cmd.opcode = opcode;
-                cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
-
-                data.blksz = size;
-                data.blocks = 1;
-                data.flags = MMC_DATA_READ;
-                data.timeout_ns = NSEC_PER_SEC; /* 1 second */
-
-                data.sg = &sg;
-                data.sg_len = 1;
-                sg_init_one(&sg, data_buf, size);
-                memset(data_buf, 0, size);
-                mmc_wait_for_req(mmc, &mrq);
-
-                if (!cmd.error && !data.error &&
-                    !memcmp(data_buf, tuning_block_pattern, size)) {
+                rc = mmc_send_tuning(mmc);
+                if (!rc) {
                         /* Tuning is successful at this tuning point */
                         tuned_phases[tuned_phase_cnt++] = phase;
                         dev_dbg(mmc_dev(mmc), "%s: Found good phase = %d\n",
@@ -413,7 +379,7 @@ retry:
                 rc = msm_find_most_appropriate_phase(host, tuned_phases,
                                                      tuned_phase_cnt);
                 if (rc < 0)
-                        goto out;
+                        return rc;
                 else
                         phase = rc;
 
@@ -423,7 +389,7 @@ retry:
                  */
                 rc = msm_config_cm_dll_phase(host, phase);
                 if (rc)
-                        goto out;
+                        return rc;
                 dev_dbg(mmc_dev(mmc), "%s: Setting the tuning phase to %d\n",
                          mmc_hostname(mmc), phase);
         } else {
@@ -435,8 +401,6 @@ retry:
                 rc = -EIO;
         }
 
-out:
-        kfree(data_buf);
         return rc;
 }
 
diff --git a/drivers/mmc/host/sdhci-of-arasan.c b/drivers/mmc/host/sdhci-of-arasan.c
index 981d66e5c023..bcb51e9dfdcd 100644
--- a/drivers/mmc/host/sdhci-of-arasan.c
+++ b/drivers/mmc/host/sdhci-of-arasan.c
@@ -165,7 +165,6 @@ static int sdhci_arasan_probe(struct platform_device *pdev)
         host = sdhci_pltfm_init(pdev, &sdhci_arasan_pdata, 0);
         if (IS_ERR(host)) {
                 ret = PTR_ERR(host);
-                dev_err(&pdev->dev, "platform init failed (%u)\n", ret);
                 goto clk_disable_all;
         }
 
@@ -175,10 +174,8 @@ static int sdhci_arasan_probe(struct platform_device *pdev)
         pltfm_host->clk = clk_xin;
 
         ret = sdhci_add_host(host);
-        if (ret) {
-                dev_err(&pdev->dev, "platform register failed (%u)\n", ret);
+        if (ret)
                 goto err_pltfm_free;
-        }
 
         return 0;
 
diff --git a/drivers/mmc/host/sdhci-pci-o2micro.c b/drivers/mmc/host/sdhci-pci-o2micro.c
index 5670e381b0cf..e2ec108dba0e 100644
--- a/drivers/mmc/host/sdhci-pci-o2micro.c
+++ b/drivers/mmc/host/sdhci-pci-o2micro.c
@@ -127,8 +127,6 @@ void sdhci_pci_o2_fujin2_pci_init(struct sdhci_pci_chip *chip)
                 return;
         scratch_32 &= ~((1 << 21) | (1 << 30));
 
-        /* Set RTD3 function disabled */
-        scratch_32 |= ((1 << 29) | (1 << 28));
         pci_write_config_dword(chip->pdev, O2_SD_FUNC_REG3, scratch_32);
 
         /* Set L1 Entrance Timer */
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 61192973e7cb..03427755b902 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -134,7 +134,7 @@ static int pch_hc_probe_slot(struct sdhci_pci_slot *slot)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 
 static irqreturn_t sdhci_pci_sd_cd(int irq, void *dev_id)
 {
@@ -269,7 +269,9 @@ static void sdhci_pci_int_hw_reset(struct sdhci_host *host)
 static int byt_emmc_probe_slot(struct sdhci_pci_slot *slot)
 {
         slot->host->mmc->caps |= MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE |
-                                 MMC_CAP_HW_RESET | MMC_CAP_1_8V_DDR;
+                                 MMC_CAP_HW_RESET | MMC_CAP_1_8V_DDR |
+                                 MMC_CAP_BUS_WIDTH_TEST |
+                                 MMC_CAP_WAIT_WHILE_BUSY;
         slot->host->mmc->caps2 |= MMC_CAP2_HC_ERASE_SZ;
         slot->hw_reset = sdhci_pci_int_hw_reset;
         if (slot->chip->pdev->device == PCI_DEVICE_ID_INTEL_BSW_EMMC)
@@ -279,12 +281,16 @@ static int byt_emmc_probe_slot(struct sdhci_pci_slot *slot)
 
 static int byt_sdio_probe_slot(struct sdhci_pci_slot *slot)
 {
-        slot->host->mmc->caps |= MMC_CAP_POWER_OFF_CARD | MMC_CAP_NONREMOVABLE;
+        slot->host->mmc->caps |= MMC_CAP_POWER_OFF_CARD | MMC_CAP_NONREMOVABLE |
+                                 MMC_CAP_BUS_WIDTH_TEST |
+                                 MMC_CAP_WAIT_WHILE_BUSY;
         return 0;
 }
 
 static int byt_sd_probe_slot(struct sdhci_pci_slot *slot)
 {
+        slot->host->mmc->caps |= MMC_CAP_BUS_WIDTH_TEST |
+                                 MMC_CAP_WAIT_WHILE_BUSY;
         slot->cd_con_id = NULL;
         slot->cd_idx = 0;
         slot->cd_override_level = true;
@@ -294,11 +300,13 @@ static int byt_sd_probe_slot(struct sdhci_pci_slot *slot)
 static const struct sdhci_pci_fixes sdhci_intel_byt_emmc = {
         .allow_runtime_pm = true,
         .probe_slot     = byt_emmc_probe_slot,
+        .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .quirks2        = SDHCI_QUIRK2_PRESET_VALUE_BROKEN |
                           SDHCI_QUIRK2_STOP_WITH_TC,
 };
 
 static const struct sdhci_pci_fixes sdhci_intel_byt_sdio = {
+        .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .quirks2        = SDHCI_QUIRK2_HOST_OFF_CARD_ON |
                         SDHCI_QUIRK2_PRESET_VALUE_BROKEN,
         .allow_runtime_pm = true,
@@ -306,6 +314,7 @@ static const struct sdhci_pci_fixes sdhci_intel_byt_sdio = {
 };
 
 static const struct sdhci_pci_fixes sdhci_intel_byt_sd = {
+        .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .quirks2        = SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON |
                           SDHCI_QUIRK2_PRESET_VALUE_BROKEN |
                           SDHCI_QUIRK2_STOP_WITH_TC,
@@ -645,6 +654,25 @@ static const struct sdhci_pci_fixes sdhci_rtsx = {
         .probe_slot     = rtsx_probe_slot,
 };
 
+static int amd_probe(struct sdhci_pci_chip *chip)
+{
+        struct pci_dev  *smbus_dev;
+
+        smbus_dev = pci_get_device(PCI_VENDOR_ID_AMD,
+                        PCI_DEVICE_ID_AMD_HUDSON2_SMBUS, NULL);
+
+        if (smbus_dev && (smbus_dev->revision < 0x51)) {
+                chip->quirks2 |= SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD;
+                chip->quirks2 |= SDHCI_QUIRK2_BROKEN_HS200;
+        }
+
+        return 0;
+}
+
+static const struct sdhci_pci_fixes sdhci_amd = {
+        .probe          = amd_probe,
+};
+
 static const struct pci_device_id pci_ids[] = {
         {
                 .vendor         = PCI_VENDOR_ID_RICOH,
@@ -1044,7 +1072,15 @@ static const struct pci_device_id pci_ids[] = {
                 .subdevice      = PCI_ANY_ID,
                 .driver_data    = (kernel_ulong_t)&sdhci_o2,
         },
-
+        {
+                .vendor         = PCI_VENDOR_ID_AMD,
+                .device         = PCI_ANY_ID,
+                .class          = PCI_CLASS_SYSTEM_SDHCI << 8,
+                .class_mask     = 0xFFFF00,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_amd,
+        },
         {       /* Generic SD host controller */
                 PCI_DEVICE_CLASS((PCI_CLASS_SYSTEM_SDHCI << 8), 0xFFFF00)
         },
@@ -1064,7 +1100,7 @@ static int sdhci_pci_enable_dma(struct sdhci_host *host)
 {
         struct sdhci_pci_slot *slot;
         struct pci_dev *pdev;
-        int ret;
+        int ret = -1;
 
         slot = sdhci_priv(host);
         pdev = slot->chip->pdev;
@@ -1076,7 +1112,17 @@ static int sdhci_pci_enable_dma(struct sdhci_host *host)
                         "doesn't fully claim to support it.\n");
         }
 
-        ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+        if (host->flags & SDHCI_USE_64_BIT_DMA) {
+                if (host->quirks2 & SDHCI_QUIRK2_BROKEN_64_BIT_DMA) {
+                        host->flags &= ~SDHCI_USE_64_BIT_DMA;
+                } else {
+                        ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
+                        if (ret)
+                                dev_warn(&pdev->dev, "Failed to set 64-bit DMA mask\n");
+                }
+        }
+        if (ret)
+                ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
         if (ret)
                 return ret;
 
@@ -1230,15 +1276,6 @@ static int sdhci_pci_resume(struct device *dev)
         return 0;
 }
 
-#else /* CONFIG_PM */
-
-#define sdhci_pci_suspend NULL
-#define sdhci_pci_resume NULL
-
-#endif /* CONFIG_PM */
-
-#ifdef CONFIG_PM_RUNTIME
-
 static int sdhci_pci_runtime_suspend(struct device *dev)
 {
         struct pci_dev *pdev = container_of(dev, struct pci_dev, dev);
@@ -1310,7 +1347,12 @@ static int sdhci_pci_runtime_idle(struct device *dev)
         return 0;
 }
 
-#endif
+#else /* CONFIG_PM */
+
+#define sdhci_pci_suspend NULL
+#define sdhci_pci_resume NULL
+
+#endif /* CONFIG_PM */
 
 static const struct dev_pm_ops sdhci_pci_pm_ops = {
         .suspend = sdhci_pci_suspend,
diff --git a/drivers/mmc/host/sdhci-pxav2.c b/drivers/mmc/host/sdhci-pxav2.c
index b4c23e983baf..f98008b5ea77 100644
--- a/drivers/mmc/host/sdhci-pxav2.c
+++ b/drivers/mmc/host/sdhci-pxav2.c
@@ -167,23 +167,17 @@ static int sdhci_pxav2_probe(struct platform_device *pdev)
         struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
         struct device *dev = &pdev->dev;
         struct sdhci_host *host = NULL;
-        struct sdhci_pxa *pxa = NULL;
         const struct of_device_id *match;
 
         int ret;
         struct clk *clk;
 
-        pxa = kzalloc(sizeof(struct sdhci_pxa), GFP_KERNEL);
-        if (!pxa)
-                return -ENOMEM;
-
         host = sdhci_pltfm_init(pdev, NULL, 0);
-        if (IS_ERR(host)) {
-                kfree(pxa);
+        if (IS_ERR(host))
                 return PTR_ERR(host);
-        }
+
         pltfm_host = sdhci_priv(host);
-        pltfm_host->priv = pxa;
+        pltfm_host->priv = NULL;
 
         clk = clk_get(dev, "PXA-SDHCLK");
         if (IS_ERR(clk)) {
@@ -238,7 +232,6 @@ err_add_host:
         clk_put(clk);
 err_clk_get:
         sdhci_pltfm_free(pdev);
-        kfree(pxa);
         return ret;
 }
 
@@ -246,14 +239,12 @@ static int sdhci_pxav2_remove(struct platform_device *pdev)
 {
         struct sdhci_host *host = platform_get_drvdata(pdev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-        struct sdhci_pxa *pxa = pltfm_host->priv;
 
         sdhci_remove_host(host, 1);
 
         clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
         sdhci_pltfm_free(pdev);
-        kfree(pxa);
 
         return 0;
 }
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index 5036d7d39529..45238871192d 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -58,6 +58,12 @@
 #define SDCE_MISC_INT           (1<<2)
 #define SDCE_MISC_INT_EN        (1<<1)
 
+struct sdhci_pxa {
+        struct clk *clk_core;
+        struct clk *clk_io;
+        u8      power_mode;
+};
+
 /*
  * These registers are relative to the second register region, for the
  * MBus bridge.
@@ -211,6 +217,7 @@ static void pxav3_set_uhs_signaling(struct sdhci_host *host, unsigned int uhs)
         case MMC_TIMING_UHS_SDR104:
                 ctrl_2 |= SDHCI_CTRL_UHS_SDR104 | SDHCI_CTRL_VDD_180;
                 break;
+        case MMC_TIMING_MMC_DDR52:
         case MMC_TIMING_UHS_DDR50:
                 ctrl_2 |= SDHCI_CTRL_UHS_DDR50 | SDHCI_CTRL_VDD_180;
                 break;
@@ -283,9 +290,7 @@ static int sdhci_pxav3_probe(struct platform_device *pdev)
         struct sdhci_host *host = NULL;
         struct sdhci_pxa *pxa = NULL;
         const struct of_device_id *match;
-
         int ret;
-        struct clk *clk;
 
         pxa = devm_kzalloc(&pdev->dev, sizeof(struct sdhci_pxa), GFP_KERNEL);
         if (!pxa)
@@ -305,14 +310,20 @@ static int sdhci_pxav3_probe(struct platform_device *pdev)
         pltfm_host = sdhci_priv(host);
         pltfm_host->priv = pxa;
 
-        clk = devm_clk_get(dev, NULL);
-        if (IS_ERR(clk)) {
+        pxa->clk_io = devm_clk_get(dev, "io");
+        if (IS_ERR(pxa->clk_io))
+                pxa->clk_io = devm_clk_get(dev, NULL);
+        if (IS_ERR(pxa->clk_io)) {
                 dev_err(dev, "failed to get io clock\n");
-                ret = PTR_ERR(clk);
+                ret = PTR_ERR(pxa->clk_io);
                 goto err_clk_get;
         }
-        pltfm_host->clk = clk;
-        clk_prepare_enable(clk);
+        pltfm_host->clk = pxa->clk_io;
+        clk_prepare_enable(pxa->clk_io);
+
+        pxa->clk_core = devm_clk_get(dev, "core");
+        if (!IS_ERR(pxa->clk_core))
+                clk_prepare_enable(pxa->clk_core);
 
         /* enable 1/8V DDR capable */
         host->mmc->caps |= MMC_CAP_1_8V_DDR;
@@ -385,7 +396,9 @@ err_add_host:
         pm_runtime_disable(&pdev->dev);
 err_of_parse:
 err_cd_req:
-        clk_disable_unprepare(clk);
+        clk_disable_unprepare(pxa->clk_io);
+        if (!IS_ERR(pxa->clk_core))
+                clk_disable_unprepare(pxa->clk_core);
 err_clk_get:
 err_mbus_win:
         sdhci_pltfm_free(pdev);
@@ -396,12 +409,15 @@ static int sdhci_pxav3_remove(struct platform_device *pdev)
 {
         struct sdhci_host *host = platform_get_drvdata(pdev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_pxa *pxa = pltfm_host->priv;
 
         pm_runtime_get_sync(&pdev->dev);
         sdhci_remove_host(host, 1);
         pm_runtime_disable(&pdev->dev);
 
-        clk_disable_unprepare(pltfm_host->clk);
+        clk_disable_unprepare(pxa->clk_io);
+        if (!IS_ERR(pxa->clk_core))
+                clk_disable_unprepare(pxa->clk_core);
 
         sdhci_pltfm_free(pdev);
 
@@ -436,20 +452,21 @@ static int sdhci_pxav3_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int sdhci_pxav3_runtime_suspend(struct device *dev)
 {
         struct sdhci_host *host = dev_get_drvdata(dev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_pxa *pxa = pltfm_host->priv;
         unsigned long flags;
 
-        if (pltfm_host->clk) {
-                spin_lock_irqsave(&host->lock, flags);
-                host->runtime_suspended = true;
-                spin_unlock_irqrestore(&host->lock, flags);
+        spin_lock_irqsave(&host->lock, flags);
+        host->runtime_suspended = true;
+        spin_unlock_irqrestore(&host->lock, flags);
 
-                clk_disable_unprepare(pltfm_host->clk);
-        }
+        clk_disable_unprepare(pxa->clk_io);
+        if (!IS_ERR(pxa->clk_core))
+                clk_disable_unprepare(pxa->clk_core);
 
         return 0;
 }
@@ -458,15 +475,16 @@ static int sdhci_pxav3_runtime_resume(struct device *dev)
 {
         struct sdhci_host *host = dev_get_drvdata(dev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_pxa *pxa = pltfm_host->priv;
         unsigned long flags;
 
-        if (pltfm_host->clk) {
-                clk_prepare_enable(pltfm_host->clk);
+        clk_prepare_enable(pxa->clk_io);
+        if (!IS_ERR(pxa->clk_core))
+                clk_prepare_enable(pxa->clk_core);
 
-                spin_lock_irqsave(&host->lock, flags);
-                host->runtime_suspended = false;
-                spin_unlock_irqrestore(&host->lock, flags);
-        }
+        spin_lock_irqsave(&host->lock, flags);
+        host->runtime_suspended = false;
+        spin_unlock_irqrestore(&host->lock, flags);
 
         return 0;
 }
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 0ce6eb17deaf..c45b8932d843 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -300,6 +300,7 @@ static void sdhci_cmu_set_clock(struct sdhci_host *host, unsigned int clock)
         struct device *dev = &ourhost->pdev->dev;
         unsigned long timeout;
         u16 clk = 0;
+        int ret;
 
         host->mmc->actual_clock = 0;
 
@@ -311,7 +312,12 @@ static void sdhci_cmu_set_clock(struct sdhci_host *host, unsigned int clock)
 
         sdhci_s3c_set_clock(host, clock);
 
-        clk_set_rate(ourhost->clk_bus[ourhost->cur_clk], clock);
+        ret = clk_set_rate(ourhost->clk_bus[ourhost->cur_clk], clock);
+        if (ret != 0) {
+                dev_err(dev, "%s: failed to set clock rate %uHz\n",
+                        mmc_hostname(host->mmc), clock);
+                return;
+        }
 
         clk = SDHCI_CLOCK_INT_EN;
         sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
@@ -609,7 +615,7 @@ static int sdhci_s3c_probe(struct platform_device *pdev)
                 goto err_req_regs;
         }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         if (pdata->cd_type != S3C_SDHCI_CD_INTERNAL)
                 clk_disable_unprepare(sc->clk_io);
 #endif
@@ -635,7 +641,7 @@ static int sdhci_s3c_remove(struct platform_device *pdev)
         if (sc->ext_cd_irq)
                 free_irq(sc->ext_cd_irq, sc);
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         if (sc->pdata->cd_type != S3C_SDHCI_CD_INTERNAL)
                 clk_prepare_enable(sc->clk_io);
 #endif
@@ -667,7 +673,7 @@ static int sdhci_s3c_resume(struct device *dev)
 }
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int sdhci_s3c_runtime_suspend(struct device *dev)
 {
         struct sdhci_host *host = dev_get_drvdata(dev);
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index ada1a3ea3a87..cbb245b58538 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -44,8 +44,6 @@
 
 #define MAX_TUNING_LOOP 40
 
-#define ADMA_SIZE       ((128 * 2 + 1) * 4)
-
 static unsigned int debug_quirks = 0;
 static unsigned int debug_quirks2;
 
@@ -56,7 +54,7 @@ static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode);
 static void sdhci_tuning_timer(unsigned long data);
 static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable);
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int sdhci_runtime_pm_get(struct sdhci_host *host);
 static int sdhci_runtime_pm_put(struct sdhci_host *host);
 static void sdhci_runtime_pm_bus_on(struct sdhci_host *host);
@@ -119,10 +117,17 @@ static void sdhci_dumpregs(struct sdhci_host *host)
         pr_debug(DRIVER_NAME ": Host ctl2: 0x%08x\n",
                 sdhci_readw(host, SDHCI_HOST_CONTROL2));
 
-        if (host->flags & SDHCI_USE_ADMA)
-                pr_debug(DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n",
-                       readl(host->ioaddr + SDHCI_ADMA_ERROR),
-                       readl(host->ioaddr + SDHCI_ADMA_ADDRESS));
+        if (host->flags & SDHCI_USE_ADMA) {
+                if (host->flags & SDHCI_USE_64_BIT_DMA)
+                        pr_debug(DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x%08x\n",
+                                 readl(host->ioaddr + SDHCI_ADMA_ERROR),
+                                 readl(host->ioaddr + SDHCI_ADMA_ADDRESS_HI),
+                                 readl(host->ioaddr + SDHCI_ADMA_ADDRESS));
+                else
+                        pr_debug(DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n",
+                                 readl(host->ioaddr + SDHCI_ADMA_ERROR),
+                                 readl(host->ioaddr + SDHCI_ADMA_ADDRESS));
+        }
 
         pr_debug(DRIVER_NAME ": ===========================================\n");
 }
@@ -448,18 +453,26 @@ static void sdhci_kunmap_atomic(void *buffer, unsigned long *flags)
         local_irq_restore(*flags);
 }
 
-static void sdhci_set_adma_desc(u8 *desc, u32 addr, int len, unsigned cmd)
+static void sdhci_adma_write_desc(struct sdhci_host *host, void *desc,
+                                  dma_addr_t addr, int len, unsigned cmd)
 {
-        __le32 *dataddr = (__le32 __force *)(desc + 4);
-        __le16 *cmdlen = (__le16 __force *)desc;
+        struct sdhci_adma2_64_desc *dma_desc = desc;
+
+        /* 32-bit and 64-bit descriptors have these members in same position */
+        dma_desc->cmd = cpu_to_le16(cmd);
+        dma_desc->len = cpu_to_le16(len);
+        dma_desc->addr_lo = cpu_to_le32((u32)addr);
 
-        /* SDHCI specification says ADMA descriptors should be 4 byte
-         * aligned, so using 16 or 32bit operations should be safe. */
+        if (host->flags & SDHCI_USE_64_BIT_DMA)
+                dma_desc->addr_hi = cpu_to_le32((u64)addr >> 32);
+}
 
-        cmdlen[0] = cpu_to_le16(cmd);
-        cmdlen[1] = cpu_to_le16(len);
+static void sdhci_adma_mark_end(void *desc)
+{
+        struct sdhci_adma2_64_desc *dma_desc = desc;
 
-        dataddr[0] = cpu_to_le32(addr);
+        /* 32-bit and 64-bit descriptors have 'cmd' in same position */
+        dma_desc->cmd |= cpu_to_le16(ADMA2_END);
 }
 
 static int sdhci_adma_table_pre(struct sdhci_host *host,
@@ -467,8 +480,8 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
 {
         int direction;
 
-        u8 *desc;
-        u8 *align;
+        void *desc;
+        void *align;
         dma_addr_t addr;
         dma_addr_t align_addr;
         int len, offset;
@@ -489,17 +502,17 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
                 direction = DMA_TO_DEVICE;
 
         host->align_addr = dma_map_single(mmc_dev(host->mmc),
-                host->align_buffer, 128 * 4, direction);
+                host->align_buffer, host->align_buffer_sz, direction);
         if (dma_mapping_error(mmc_dev(host->mmc), host->align_addr))
                 goto fail;
-        BUG_ON(host->align_addr & 0x3);
+        BUG_ON(host->align_addr & host->align_mask);
 
         host->sg_count = dma_map_sg(mmc_dev(host->mmc),
                 data->sg, data->sg_len, direction);
         if (host->sg_count == 0)
                 goto unmap_align;
 
-        desc = host->adma_desc;
+        desc = host->adma_table;
         align = host->align_buffer;
 
         align_addr = host->align_addr;
@@ -515,24 +528,27 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
                  * the (up to three) bytes that screw up the
                  * alignment.
                  */
-                offset = (4 - (addr & 0x3)) & 0x3;
+                offset = (host->align_sz - (addr & host->align_mask)) &
+                         host->align_mask;
                 if (offset) {
                         if (data->flags & MMC_DATA_WRITE) {
                                 buffer = sdhci_kmap_atomic(sg, &flags);
-                                WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
+                                WARN_ON(((long)buffer & (PAGE_SIZE - 1)) >
+                                        (PAGE_SIZE - offset));
                                 memcpy(align, buffer, offset);
                                 sdhci_kunmap_atomic(buffer, &flags);
                         }
 
                         /* tran, valid */
-                        sdhci_set_adma_desc(desc, align_addr, offset, 0x21);
+                        sdhci_adma_write_desc(host, desc, align_addr, offset,
+                                              ADMA2_TRAN_VALID);
 
                         BUG_ON(offset > 65536);
 
-                        align += 4;
-                        align_addr += 4;
+                        align += host->align_sz;
+                        align_addr += host->align_sz;
 
-                        desc += 8;
+                        desc += host->desc_sz;
 
                         addr += offset;
                         len -= offset;
@@ -541,23 +557,23 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
                 BUG_ON(len > 65536);
 
                 /* tran, valid */
-                sdhci_set_adma_desc(desc, addr, len, 0x21);
-                desc += 8;
+                sdhci_adma_write_desc(host, desc, addr, len, ADMA2_TRAN_VALID);
+                desc += host->desc_sz;
 
                 /*
                  * If this triggers then we have a calculation bug
                  * somewhere. :/
                  */
-                WARN_ON((desc - host->adma_desc) > ADMA_SIZE);
+                WARN_ON((desc - host->adma_table) >= host->adma_table_sz);
         }
 
         if (host->quirks & SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC) {
                 /*
                 * Mark the last descriptor as the terminating descriptor
                 */
-                if (desc != host->adma_desc) {
-                        desc -= 8;
-                        desc[0] |= 0x2; /* end */
+                if (desc != host->adma_table) {
+                        desc -= host->desc_sz;
+                        sdhci_adma_mark_end(desc);
                 }
         } else {
                 /*
@@ -565,7 +581,7 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
                 */
 
                 /* nop, end, valid */
-                sdhci_set_adma_desc(desc, 0, 0, 0x3);
+                sdhci_adma_write_desc(host, desc, 0, 0, ADMA2_NOP_END_VALID);
         }
 
         /*
@@ -573,14 +589,14 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
          */
         if (data->flags & MMC_DATA_WRITE) {
                 dma_sync_single_for_device(mmc_dev(host->mmc),
-                        host->align_addr, 128 * 4, direction);
+                        host->align_addr, host->align_buffer_sz, direction);
         }
 
         return 0;
 
 unmap_align:
         dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
-                128 * 4, direction);
+                host->align_buffer_sz, direction);
 fail:
         return -EINVAL;
 }
@@ -592,7 +608,7 @@ static void sdhci_adma_table_post(struct sdhci_host *host,
 
         struct scatterlist *sg;
         int i, size;
-        u8 *align;
+        void *align;
         char *buffer;
         unsigned long flags;
         bool has_unaligned;
@@ -603,12 +619,12 @@ static void sdhci_adma_table_post(struct sdhci_host *host,
                 direction = DMA_TO_DEVICE;
 
         dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
-                128 * 4, direction);
+                host->align_buffer_sz, direction);
 
         /* Do a quick scan of the SG list for any unaligned mappings */
         has_unaligned = false;
         for_each_sg(data->sg, sg, host->sg_count, i)
-                if (sg_dma_address(sg) & 3) {
+                if (sg_dma_address(sg) & host->align_mask) {
                         has_unaligned = true;
                         break;
                 }
@@ -620,15 +636,17 @@ static void sdhci_adma_table_post(struct sdhci_host *host,
                 align = host->align_buffer;
 
                 for_each_sg(data->sg, sg, host->sg_count, i) {
-                        if (sg_dma_address(sg) & 0x3) {
-                                size = 4 - (sg_dma_address(sg) & 0x3);
+                        if (sg_dma_address(sg) & host->align_mask) {
+                                size = host->align_sz -
+                                       (sg_dma_address(sg) & host->align_mask);
 
                                 buffer = sdhci_kmap_atomic(sg, &flags);
-                                WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
+                                WARN_ON(((long)buffer & (PAGE_SIZE - 1)) >
+                                        (PAGE_SIZE - size));
                                 memcpy(buffer, align, size);
                                 sdhci_kunmap_atomic(buffer, &flags);
 
-                                align += 4;
+                                align += host->align_sz;
                         }
                 }
         }
@@ -822,6 +840,10 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
                         } else {
                                 sdhci_writel(host, host->adma_addr,
                                         SDHCI_ADMA_ADDRESS);
+                                if (host->flags & SDHCI_USE_64_BIT_DMA)
+                                        sdhci_writel(host,
+                                                     (u64)host->adma_addr >> 32,
+                                                     SDHCI_ADMA_ADDRESS_HI);
                         }
                 } else {
                         int sg_cnt;
@@ -855,10 +877,14 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
                 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
                 ctrl &= ~SDHCI_CTRL_DMA_MASK;
                 if ((host->flags & SDHCI_REQ_USE_DMA) &&
-                        (host->flags & SDHCI_USE_ADMA))
-                        ctrl |= SDHCI_CTRL_ADMA32;
-                else
+                        (host->flags & SDHCI_USE_ADMA)) {
+                        if (host->flags & SDHCI_USE_64_BIT_DMA)
+                                ctrl |= SDHCI_CTRL_ADMA64;
+                        else
+                                ctrl |= SDHCI_CTRL_ADMA32;
+                } else {
                         ctrl |= SDHCI_CTRL_SDMA;
+                }
                 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
         }
 
@@ -889,10 +915,15 @@ static void sdhci_set_transfer_mode(struct sdhci_host *host,
         struct mmc_data *data = cmd->data;
 
         if (data == NULL) {
+                if (host->quirks2 &
+                        SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD) {
+                        sdhci_writew(host, 0x0, SDHCI_TRANSFER_MODE);
+                } else {
                 /* clear Auto CMD settings for no data CMDs */
-                mode = sdhci_readw(host, SDHCI_TRANSFER_MODE);
-                sdhci_writew(host, mode & ~(SDHCI_TRNS_AUTO_CMD12 |
+                        mode = sdhci_readw(host, SDHCI_TRANSFER_MODE);
+                        sdhci_writew(host, mode & ~(SDHCI_TRNS_AUTO_CMD12 |
                                 SDHCI_TRNS_AUTO_CMD23), SDHCI_TRANSFER_MODE);
+                }
                 return;
         }
 
@@ -1117,6 +1148,9 @@ static u16 sdhci_get_preset_value(struct sdhci_host *host)
         case MMC_TIMING_UHS_DDR50:
                 preset = sdhci_readw(host, SDHCI_PRESET_FOR_DDR50);
                 break;
+        case MMC_TIMING_MMC_HS400:
+                preset = sdhci_readw(host, SDHCI_PRESET_FOR_HS400);
+                break;
         default:
                 pr_warn("%s: Invalid UHS-I mode selected\n",
                         mmc_hostname(host->mmc));
@@ -1444,6 +1478,8 @@ void sdhci_set_uhs_signaling(struct sdhci_host *host, unsigned timing)
         else if ((timing == MMC_TIMING_UHS_DDR50) ||
                  (timing == MMC_TIMING_MMC_DDR52))
                 ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
+        else if (timing == MMC_TIMING_MMC_HS400)
+                ctrl_2 |= SDHCI_CTRL_HS400; /* Non-standard */
         sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
 }
 EXPORT_SYMBOL_GPL(sdhci_set_uhs_signaling);
@@ -1515,7 +1551,8 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
                 u16 clk, ctrl_2;
 
                 /* In case of UHS-I modes, set High Speed Enable */
-                if ((ios->timing == MMC_TIMING_MMC_HS200) ||
+                if ((ios->timing == MMC_TIMING_MMC_HS400) ||
+                    (ios->timing == MMC_TIMING_MMC_HS200) ||
                     (ios->timing == MMC_TIMING_MMC_DDR52) ||
                     (ios->timing == MMC_TIMING_UHS_SDR50) ||
                     (ios->timing == MMC_TIMING_UHS_SDR104) ||
@@ -1862,6 +1899,7 @@ static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
          * tuning function has to be executed.
          */
         switch (host->timing) {
+        case MMC_TIMING_MMC_HS400:
         case MMC_TIMING_MMC_HS200:
         case MMC_TIMING_UHS_SDR104:
                 break;
@@ -2144,9 +2182,10 @@ static void sdhci_tasklet_finish(unsigned long param)
          */
         if (!(host->flags & SDHCI_DEVICE_DEAD) &&
             ((mrq->cmd && mrq->cmd->error) ||
-                 (mrq->data && (mrq->data->error ||
-                  (mrq->data->stop && mrq->data->stop->error))) ||
-                   (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST))) {
+             (mrq->sbc && mrq->sbc->error) ||
+             (mrq->data && ((mrq->data->error && !mrq->data->stop) ||
+                            (mrq->data->stop && mrq->data->stop->error))) ||
+             (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST))) {
 
                 /* Some controllers need this kick or reset won't work here */
                 if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET)
@@ -2282,32 +2321,36 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask, u32 *mask)
 }
 
 #ifdef CONFIG_MMC_DEBUG
-static void sdhci_show_adma_error(struct sdhci_host *host)
+static void sdhci_adma_show_error(struct sdhci_host *host)
 {
         const char *name = mmc_hostname(host->mmc);
-        u8 *desc = host->adma_desc;
-        __le32 *dma;
-        __le16 *len;
-        u8 attr;
+        void *desc = host->adma_table;
 
         sdhci_dumpregs(host);
 
         while (true) {
-                dma = (__le32 *)(desc + 4);
-                len = (__le16 *)(desc + 2);
-                attr = *desc;
-
-                DBG("%s: %p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n",
-                    name, desc, le32_to_cpu(*dma), le16_to_cpu(*len), attr);
+                struct sdhci_adma2_64_desc *dma_desc = desc;
+
+                if (host->flags & SDHCI_USE_64_BIT_DMA)
+                        DBG("%s: %p: DMA 0x%08x%08x, LEN 0x%04x, Attr=0x%02x\n",
+                            name, desc, le32_to_cpu(dma_desc->addr_hi),
+                            le32_to_cpu(dma_desc->addr_lo),
+                            le16_to_cpu(dma_desc->len),
+                            le16_to_cpu(dma_desc->cmd));
+                else
+                        DBG("%s: %p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n",
+                            name, desc, le32_to_cpu(dma_desc->addr_lo),
+                            le16_to_cpu(dma_desc->len),
+                            le16_to_cpu(dma_desc->cmd));
 
-                desc += 8;
+                desc += host->desc_sz;
 
-                if (attr & 2)
+                if (dma_desc->cmd & cpu_to_le16(ADMA2_END))
                         break;
         }
 }
 #else
-static void sdhci_show_adma_error(struct sdhci_host *host) { }
+static void sdhci_adma_show_error(struct sdhci_host *host) { }
 #endif
 
 static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
@@ -2370,7 +2413,7 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
                 host->data->error = -EILSEQ;
         else if (intmask & SDHCI_INT_ADMA_ERROR) {
                 pr_err("%s: ADMA error\n", mmc_hostname(host->mmc));
-                sdhci_show_adma_error(host);
+                sdhci_adma_show_error(host);
                 host->data->error = -EIO;
                 if (host->ops->adma_workaround)
                         host->ops->adma_workaround(host, intmask);
@@ -2654,9 +2697,6 @@ int sdhci_resume_host(struct sdhci_host *host)
 }
 
 EXPORT_SYMBOL_GPL(sdhci_resume_host);
-#endif /* CONFIG_PM */
-
-#ifdef CONFIG_PM_RUNTIME
 
 static int sdhci_runtime_pm_get(struct sdhci_host *host)
 {
@@ -2757,7 +2797,7 @@ int sdhci_runtime_resume_host(struct sdhci_host *host)
 }
 EXPORT_SYMBOL_GPL(sdhci_runtime_resume_host);
 
-#endif
+#endif /* CONFIG_PM */
 
 /*****************************************************************************\
  *                                                                           *
@@ -2849,6 +2889,16 @@ int sdhci_add_host(struct sdhci_host *host)
                 host->flags &= ~SDHCI_USE_ADMA;
         }
 
+        /*
+         * It is assumed that a 64-bit capable device has set a 64-bit DMA mask
+         * and *must* do 64-bit DMA.  A driver has the opportunity to change
+         * that during the first call to ->enable_dma().  Similarly
+         * SDHCI_QUIRK2_BROKEN_64_BIT_DMA must be left to the drivers to
+         * implement.
+         */
+        if (sdhci_readl(host, SDHCI_CAPABILITIES) & SDHCI_CAN_64BIT)
+                host->flags |= SDHCI_USE_64_BIT_DMA;
+
         if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
                 if (host->ops->enable_dma) {
                         if (host->ops->enable_dma(host)) {
@@ -2860,33 +2910,56 @@ int sdhci_add_host(struct sdhci_host *host)
                 }
         }
 
+        /* SDMA does not support 64-bit DMA */
+        if (host->flags & SDHCI_USE_64_BIT_DMA)
+                host->flags &= ~SDHCI_USE_SDMA;
+
         if (host->flags & SDHCI_USE_ADMA) {
                 /*
-                 * We need to allocate descriptors for all sg entries
-                 * (128) and potentially one alignment transfer for
-                 * each of those entries.
+                 * The DMA descriptor table size is calculated as the maximum
+                 * number of segments times 2, to allow for an alignment
+                 * descriptor for each segment, plus 1 for a nop end descriptor,
+                 * all multipled by the descriptor size.
                  */
-                host->adma_desc = dma_alloc_coherent(mmc_dev(mmc),
-                                                     ADMA_SIZE, &host->adma_addr,
-                                                     GFP_KERNEL);
-                host->align_buffer = kmalloc(128 * 4, GFP_KERNEL);
-                if (!host->adma_desc || !host->align_buffer) {
-                        dma_free_coherent(mmc_dev(mmc), ADMA_SIZE,
-                                          host->adma_desc, host->adma_addr);
+                if (host->flags & SDHCI_USE_64_BIT_DMA) {
+                        host->adma_table_sz = (SDHCI_MAX_SEGS * 2 + 1) *
+                                              SDHCI_ADMA2_64_DESC_SZ;
+                        host->align_buffer_sz = SDHCI_MAX_SEGS *
+                                                SDHCI_ADMA2_64_ALIGN;
+                        host->desc_sz = SDHCI_ADMA2_64_DESC_SZ;
+                        host->align_sz = SDHCI_ADMA2_64_ALIGN;
+                        host->align_mask = SDHCI_ADMA2_64_ALIGN - 1;
+                } else {
+                        host->adma_table_sz = (SDHCI_MAX_SEGS * 2 + 1) *
+                                              SDHCI_ADMA2_32_DESC_SZ;
+                        host->align_buffer_sz = SDHCI_MAX_SEGS *
+                                                SDHCI_ADMA2_32_ALIGN;
+                        host->desc_sz = SDHCI_ADMA2_32_DESC_SZ;
+                        host->align_sz = SDHCI_ADMA2_32_ALIGN;
+                        host->align_mask = SDHCI_ADMA2_32_ALIGN - 1;
+                }
+                host->adma_table = dma_alloc_coherent(mmc_dev(mmc),
+                                                      host->adma_table_sz,
+                                                      &host->adma_addr,
+                                                      GFP_KERNEL);
+                host->align_buffer = kmalloc(host->align_buffer_sz, GFP_KERNEL);
+                if (!host->adma_table || !host->align_buffer) {
+                        dma_free_coherent(mmc_dev(mmc), host->adma_table_sz,
+                                          host->adma_table, host->adma_addr);
                         kfree(host->align_buffer);
                         pr_warn("%s: Unable to allocate ADMA buffers - falling back to standard DMA\n",
                                 mmc_hostname(mmc));
                         host->flags &= ~SDHCI_USE_ADMA;
-                        host->adma_desc = NULL;
+                        host->adma_table = NULL;
                         host->align_buffer = NULL;
-                } else if (host->adma_addr & 3) {
+                } else if (host->adma_addr & host->align_mask) {
                         pr_warn("%s: unable to allocate aligned ADMA descriptor\n",
                                 mmc_hostname(mmc));
                         host->flags &= ~SDHCI_USE_ADMA;
-                        dma_free_coherent(mmc_dev(mmc), ADMA_SIZE,
-                                          host->adma_desc, host->adma_addr);
+                        dma_free_coherent(mmc_dev(mmc), host->adma_table_sz,
+                                          host->adma_table, host->adma_addr);
                         kfree(host->align_buffer);
-                        host->adma_desc = NULL;
+                        host->adma_table = NULL;
                         host->align_buffer = NULL;
                 }
         }
@@ -3027,7 +3100,7 @@ int sdhci_add_host(struct sdhci_host *host)
                 if (ret) {
                         pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
                                 mmc_hostname(mmc), ret);
-                        mmc->supply.vqmmc = NULL;
+                        mmc->supply.vqmmc = ERR_PTR(-EINVAL);
                 }
         }
 
@@ -3046,16 +3119,21 @@ int sdhci_add_host(struct sdhci_host *host)
                 /* SD3.0: SDR104 is supported so (for eMMC) the caps2
                  * field can be promoted to support HS200.
                  */
-                if (!(host->quirks2 & SDHCI_QUIRK2_BROKEN_HS200)) {
+                if (!(host->quirks2 & SDHCI_QUIRK2_BROKEN_HS200))
                         mmc->caps2 |= MMC_CAP2_HS200;
-                        if (IS_ERR(mmc->supply.vqmmc) ||
-                                        !regulator_is_supported_voltage
-                                        (mmc->supply.vqmmc, 1100000, 1300000))
-                                mmc->caps2 &= ~MMC_CAP2_HS200_1_2V_SDR;
-                }
         } else if (caps[1] & SDHCI_SUPPORT_SDR50)
                 mmc->caps |= MMC_CAP_UHS_SDR50;
 
+        if (host->quirks2 & SDHCI_QUIRK2_CAPS_BIT63_FOR_HS400 &&
+            (caps[1] & SDHCI_SUPPORT_HS400))
+                mmc->caps2 |= MMC_CAP2_HS400;
+
+        if ((mmc->caps2 & MMC_CAP2_HSX00_1_2V) &&
+            (IS_ERR(mmc->supply.vqmmc) ||
+             !regulator_is_supported_voltage(mmc->supply.vqmmc, 1100000,
+                                             1300000)))
+                mmc->caps2 &= ~MMC_CAP2_HSX00_1_2V;
+
         if ((caps[1] & SDHCI_SUPPORT_DDR50) &&
                 !(host->quirks2 & SDHCI_QUIRK2_BROKEN_DDR50))
                 mmc->caps |= MMC_CAP_UHS_DDR50;
@@ -3175,11 +3253,11 @@ int sdhci_add_host(struct sdhci_host *host)
          * can do scatter/gather or not.
          */
         if (host->flags & SDHCI_USE_ADMA)
-                mmc->max_segs = 128;
+                mmc->max_segs = SDHCI_MAX_SEGS;
         else if (host->flags & SDHCI_USE_SDMA)
                 mmc->max_segs = 1;
         else /* PIO */
-                mmc->max_segs = 128;
+                mmc->max_segs = SDHCI_MAX_SEGS;
 
         /*
          * Maximum number of sectors in one transfer. Limited by DMA boundary
@@ -3277,7 +3355,8 @@ int sdhci_add_host(struct sdhci_host *host)
 
         pr_info("%s: SDHCI controller on %s [%s] using %s\n",
                 mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
-                (host->flags & SDHCI_USE_ADMA) ? "ADMA" :
+                (host->flags & SDHCI_USE_ADMA) ?
+                (host->flags & SDHCI_USE_64_BIT_DMA) ? "ADMA 64-bit" : "ADMA" :
                 (host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
 
         sdhci_enable_card_detection(host);
@@ -3339,18 +3418,15 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
         tasklet_kill(&host->finish_tasklet);
 
-        if (!IS_ERR(mmc->supply.vmmc))
-                regulator_disable(mmc->supply.vmmc);
-
         if (!IS_ERR(mmc->supply.vqmmc))
                 regulator_disable(mmc->supply.vqmmc);
 
-        if (host->adma_desc)
-                dma_free_coherent(mmc_dev(mmc), ADMA_SIZE,
-                                  host->adma_desc, host->adma_addr);
+        if (host->adma_table)
+                dma_free_coherent(mmc_dev(mmc), host->adma_table_sz,
+                                  host->adma_table, host->adma_addr);
         kfree(host->align_buffer);
 
-        host->adma_desc = NULL;
+        host->adma_table = NULL;
         host->align_buffer = NULL;
 }
 
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 31896a779d4e..41a2c34299ed 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -161,7 +161,7 @@
 #define   SDHCI_CTRL_UHS_SDR50          0x0002
 #define   SDHCI_CTRL_UHS_SDR104         0x0003
 #define   SDHCI_CTRL_UHS_DDR50          0x0004
-#define   SDHCI_CTRL_HS_SDR200          0x0005 /* reserved value in SDIO spec */
+#define   SDHCI_CTRL_HS400              0x0005 /* Non-standard */
 #define  SDHCI_CTRL_VDD_180             0x0008
 #define  SDHCI_CTRL_DRV_TYPE_MASK       0x0030
 #define   SDHCI_CTRL_DRV_TYPE_B         0x0000
@@ -204,6 +204,7 @@
 #define  SDHCI_RETUNING_MODE_SHIFT              14
 #define  SDHCI_CLOCK_MUL_MASK   0x00FF0000
 #define  SDHCI_CLOCK_MUL_SHIFT  16
+#define  SDHCI_SUPPORT_HS400    0x80000000 /* Non-standard */
 
 #define SDHCI_CAPABILITIES_1    0x44
 
@@ -227,6 +228,7 @@
 /* 55-57 reserved */
 
 #define SDHCI_ADMA_ADDRESS      0x58
+#define SDHCI_ADMA_ADDRESS_HI   0x5C
 
 /* 60-FB reserved */
 
@@ -235,6 +237,7 @@
 #define SDHCI_PRESET_FOR_SDR50 0x6A
 #define SDHCI_PRESET_FOR_SDR104        0x6C
 #define SDHCI_PRESET_FOR_DDR50 0x6E
+#define SDHCI_PRESET_FOR_HS400 0x74 /* Non-standard */
 #define SDHCI_PRESET_DRV_MASK  0xC000
 #define SDHCI_PRESET_DRV_SHIFT  14
 #define SDHCI_PRESET_CLKGEN_SEL_MASK   0x400
@@ -266,6 +269,46 @@
 #define SDHCI_DEFAULT_BOUNDARY_SIZE  (512 * 1024)
 #define SDHCI_DEFAULT_BOUNDARY_ARG   (ilog2(SDHCI_DEFAULT_BOUNDARY_SIZE) - 12)
 
+/* ADMA2 32-bit DMA descriptor size */
+#define SDHCI_ADMA2_32_DESC_SZ  8
+
+/* ADMA2 32-bit DMA alignment */
+#define SDHCI_ADMA2_32_ALIGN    4
+
+/* ADMA2 32-bit descriptor */
+struct sdhci_adma2_32_desc {
+        __le16  cmd;
+        __le16  len;
+        __le32  addr;
+}  __packed __aligned(SDHCI_ADMA2_32_ALIGN);
+
+/* ADMA2 64-bit DMA descriptor size */
+#define SDHCI_ADMA2_64_DESC_SZ  12
+
+/* ADMA2 64-bit DMA alignment */
+#define SDHCI_ADMA2_64_ALIGN    8
+
+/*
+ * ADMA2 64-bit descriptor. Note 12-byte descriptor can't always be 8-byte
+ * aligned.
+ */
+struct sdhci_adma2_64_desc {
+        __le16  cmd;
+        __le16  len;
+        __le32  addr_lo;
+        __le32  addr_hi;
+}  __packed __aligned(4);
+
+#define ADMA2_TRAN_VALID        0x21
+#define ADMA2_NOP_END_VALID     0x3
+#define ADMA2_END               0x2
+
+/*
+ * Maximum segments assuming a 512KiB maximum requisition size and a minimum
+ * 4KiB page size.
+ */
+#define SDHCI_MAX_SEGS          128
+
 struct sdhci_ops {
 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
         u32             (*read_l)(struct sdhci_host *host, int reg);
@@ -411,9 +454,6 @@ void sdhci_set_uhs_signaling(struct sdhci_host *host, unsigned timing);
 extern int sdhci_suspend_host(struct sdhci_host *host);
 extern int sdhci_resume_host(struct sdhci_host *host);
 extern void sdhci_enable_irq_wakeups(struct sdhci_host *host);
-#endif
-
-#ifdef CONFIG_PM_RUNTIME
 extern int sdhci_runtime_suspend_host(struct sdhci_host *host);
 extern int sdhci_runtime_resume_host(struct sdhci_host *host);
 #endif
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index a2e81a1ea6af..00c8ebdf8ec7 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -375,7 +375,7 @@ static int sh_mobile_sdhi_remove(struct platform_device *pdev)
 static const struct dev_pm_ops tmio_mmc_dev_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
                         pm_runtime_force_resume)
-        SET_PM_RUNTIME_PM_OPS(tmio_mmc_host_runtime_suspend,
+        SET_RUNTIME_PM_OPS(tmio_mmc_host_runtime_suspend,
                         tmio_mmc_host_runtime_resume,
                         NULL)
 };
diff --git a/drivers/mmc/host/sunxi-mmc.c b/drivers/mmc/host/sunxi-mmc.c
index d1663b3c4143..15cb8b7ffc34 100644
--- a/drivers/mmc/host/sunxi-mmc.c
+++ b/drivers/mmc/host/sunxi-mmc.c
@@ -21,7 +21,6 @@
 #include <linux/err.h>
 
 #include <linux/clk.h>
-#include <linux/clk-private.h>
 #include <linux/clk/sunxi.h>
 
 #include <linux/gpio.h>
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 659028ddb8b1..2616fdfdbbeb 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -135,7 +135,7 @@ static int tmio_mmc_remove(struct platform_device *pdev)
 
 static const struct dev_pm_ops tmio_mmc_dev_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(tmio_mmc_suspend, tmio_mmc_resume)
-        SET_PM_RUNTIME_PM_OPS(tmio_mmc_host_runtime_suspend,
+        SET_RUNTIME_PM_OPS(tmio_mmc_host_runtime_suspend,
                         tmio_mmc_host_runtime_resume,
                         NULL)
 };
diff --git a/drivers/mmc/host/toshsd.c b/drivers/mmc/host/toshsd.c
new file mode 100644
index 000000000000..4666262edaca
--- /dev/null
+++ b/drivers/mmc/host/toshsd.c
@@ -0,0 +1,717 @@
+/*
+ *  Toshiba PCI Secure Digital Host Controller Interface driver
+ *
+ *  Copyright (C) 2014 Ondrej Zary
+ *  Copyright (C) 2007 Richard Betts, All Rights Reserved.
+ *
+ *      Based on asic3_mmc.c, copyright (c) 2005 SDG Systems, LLC and,
+ *      sdhci.c, copyright (C) 2005-2006 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/scatterlist.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/pm.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>
+
+#include "toshsd.h"
+
+#define DRIVER_NAME "toshsd"
+
+static const struct pci_device_id pci_ids[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA, 0x0805) },
+        { /* end: all zeroes */ },
+};
+
+MODULE_DEVICE_TABLE(pci, pci_ids);
+
+static void toshsd_init(struct toshsd_host *host)
+{
+        /* enable clock */
+        pci_write_config_byte(host->pdev, SD_PCICFG_CLKSTOP,
+                                        SD_PCICFG_CLKSTOP_ENABLE_ALL);
+        pci_write_config_byte(host->pdev, SD_PCICFG_CARDDETECT, 2);
+
+        /* reset */
+        iowrite16(0, host->ioaddr + SD_SOFTWARERESET); /* assert */
+        mdelay(2);
+        iowrite16(1, host->ioaddr + SD_SOFTWARERESET); /* deassert */
+        mdelay(2);
+
+        /* Clear card registers */
+        iowrite16(0, host->ioaddr + SD_CARDCLOCKCTRL);
+        iowrite32(0, host->ioaddr + SD_CARDSTATUS);
+        iowrite32(0, host->ioaddr + SD_ERRORSTATUS0);
+        iowrite16(0, host->ioaddr + SD_STOPINTERNAL);
+
+        /* SDIO clock? */
+        iowrite16(0x100, host->ioaddr + SDIO_BASE + SDIO_CLOCKNWAITCTRL);
+
+        /* enable LED */
+        pci_write_config_byte(host->pdev, SD_PCICFG_SDLED_ENABLE1,
+                                        SD_PCICFG_LED_ENABLE1_START);
+        pci_write_config_byte(host->pdev, SD_PCICFG_SDLED_ENABLE2,
+                                        SD_PCICFG_LED_ENABLE2_START);
+
+        /* set interrupt masks */
+        iowrite32(~(u32)(SD_CARD_RESP_END | SD_CARD_RW_END
+                        | SD_CARD_CARD_REMOVED_0 | SD_CARD_CARD_INSERTED_0
+                        | SD_BUF_READ_ENABLE | SD_BUF_WRITE_ENABLE
+                        | SD_BUF_CMD_TIMEOUT),
+                        host->ioaddr + SD_INTMASKCARD);
+
+        iowrite16(0x1000, host->ioaddr + SD_TRANSACTIONCTRL);
+}
+
+/* Set MMC clock / power.
+ * Note: This controller uses a simple divider scheme therefore it cannot run
+ * SD/MMC cards at full speed (24/20MHz). HCLK (=33MHz PCI clock?) is too high
+ * and the next slowest is 16MHz (div=2).
+ */
+static void __toshsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct toshsd_host *host = mmc_priv(mmc);
+
+        if (ios->clock) {
+                u16 clk;
+                int div = 1;
+
+                while (ios->clock < HCLK / div)
+                        div *= 2;
+
+                clk = div >> 2;
+
+                if (div == 1) { /* disable the divider */
+                        pci_write_config_byte(host->pdev, SD_PCICFG_CLKMODE,
+                                              SD_PCICFG_CLKMODE_DIV_DISABLE);
+                        clk |= SD_CARDCLK_DIV_DISABLE;
+                } else
+                        pci_write_config_byte(host->pdev, SD_PCICFG_CLKMODE, 0);
+
+                clk |= SD_CARDCLK_ENABLE_CLOCK;
+                iowrite16(clk, host->ioaddr + SD_CARDCLOCKCTRL);
+
+                mdelay(10);
+        } else
+                iowrite16(0, host->ioaddr + SD_CARDCLOCKCTRL);
+
+        switch (ios->power_mode) {
+        case MMC_POWER_OFF:
+                pci_write_config_byte(host->pdev, SD_PCICFG_POWER1,
+                                        SD_PCICFG_PWR1_OFF);
+                mdelay(1);
+                break;
+        case MMC_POWER_UP:
+                break;
+        case MMC_POWER_ON:
+                pci_write_config_byte(host->pdev, SD_PCICFG_POWER1,
+                                        SD_PCICFG_PWR1_33V);
+                pci_write_config_byte(host->pdev, SD_PCICFG_POWER2,
+                                        SD_PCICFG_PWR2_AUTO);
+                mdelay(20);
+                break;
+        }
+
+        switch (ios->bus_width) {
+        case MMC_BUS_WIDTH_1:
+                iowrite16(SD_CARDOPT_REQUIRED | SD_CARDOPT_DATA_RESP_TIMEOUT(14)
+                                | SD_CARDOPT_C2_MODULE_ABSENT
+                                | SD_CARDOPT_DATA_XFR_WIDTH_1,
+                                host->ioaddr + SD_CARDOPTIONSETUP);
+                break;
+        case MMC_BUS_WIDTH_4:
+                iowrite16(SD_CARDOPT_REQUIRED | SD_CARDOPT_DATA_RESP_TIMEOUT(14)
+                                | SD_CARDOPT_C2_MODULE_ABSENT
+                                | SD_CARDOPT_DATA_XFR_WIDTH_4,
+                                host->ioaddr + SD_CARDOPTIONSETUP);
+                break;
+        }
+}
+
+static void toshsd_set_led(struct toshsd_host *host, unsigned char state)
+{
+        iowrite16(state, host->ioaddr + SDIO_BASE + SDIO_LEDCTRL);
+}
+
+static void toshsd_finish_request(struct toshsd_host *host)
+{
+        struct mmc_request *mrq = host->mrq;
+
+        /* Write something to end the command */
+        host->mrq = NULL;
+        host->cmd = NULL;
+        host->data = NULL;
+
+        toshsd_set_led(host, 0);
+        mmc_request_done(host->mmc, mrq);
+}
+
+static irqreturn_t toshsd_thread_irq(int irq, void *dev_id)
+{
+        struct toshsd_host *host = dev_id;
+        struct mmc_data *data = host->data;
+        struct sg_mapping_iter *sg_miter = &host->sg_miter;
+        unsigned short *buf;
+        int count;
+        unsigned long flags;
+
+        if (!data) {
+                dev_warn(&host->pdev->dev, "Spurious Data IRQ\n");
+                if (host->cmd) {
+                        host->cmd->error = -EIO;
+                        toshsd_finish_request(host);
+                }
+                return IRQ_NONE;
+        }
+        spin_lock_irqsave(&host->lock, flags);
+
+        if (!sg_miter_next(sg_miter))
+                return IRQ_HANDLED;
+        buf = sg_miter->addr;
+
+        /* Ensure we dont read more than one block. The chip will interrupt us
+         * When the next block is available.
+         */
+        count = sg_miter->length;
+        if (count > data->blksz)
+                count = data->blksz;
+
+        dev_dbg(&host->pdev->dev, "count: %08x, flags %08x\n", count,
+                data->flags);
+
+        /* Transfer the data */
+        if (data->flags & MMC_DATA_READ)
+                ioread32_rep(host->ioaddr + SD_DATAPORT, buf, count >> 2);
+        else
+                iowrite32_rep(host->ioaddr + SD_DATAPORT, buf, count >> 2);
+
+        sg_miter->consumed = count;
+        sg_miter_stop(sg_miter);
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        return IRQ_HANDLED;
+}
+
+static void toshsd_cmd_irq(struct toshsd_host *host)
+{
+        struct mmc_command *cmd = host->cmd;
+        u8 *buf;
+        u16 data;
+
+        if (!host->cmd) {
+                dev_warn(&host->pdev->dev, "Spurious CMD irq\n");
+                return;
+        }
+        buf = (u8 *)cmd->resp;
+        host->cmd = NULL;
+
+        if (cmd->flags & MMC_RSP_PRESENT && cmd->flags & MMC_RSP_136) {
+                /* R2 */
+                buf[12] = 0xff;
+                data = ioread16(host->ioaddr + SD_RESPONSE0);
+                buf[13] = data & 0xff;
+                buf[14] = data >> 8;
+                data = ioread16(host->ioaddr + SD_RESPONSE1);
+                buf[15] = data & 0xff;
+                buf[8] = data >> 8;
+                data = ioread16(host->ioaddr + SD_RESPONSE2);
+                buf[9] = data & 0xff;
+                buf[10] = data >> 8;
+                data = ioread16(host->ioaddr + SD_RESPONSE3);
+                buf[11] = data & 0xff;
+                buf[4] = data >> 8;
+                data = ioread16(host->ioaddr + SD_RESPONSE4);
+                buf[5] = data & 0xff;
+                buf[6] = data >> 8;
+                data = ioread16(host->ioaddr + SD_RESPONSE5);
+                buf[7] = data & 0xff;
+                buf[0] = data >> 8;
+                data = ioread16(host->ioaddr + SD_RESPONSE6);
+                buf[1] = data & 0xff;
+                buf[2] = data >> 8;
+                data = ioread16(host->ioaddr + SD_RESPONSE7);
+                buf[3] = data & 0xff;
+        } else if (cmd->flags & MMC_RSP_PRESENT) {
+                /* R1, R1B, R3, R6, R7 */
+                data = ioread16(host->ioaddr + SD_RESPONSE0);
+                buf[0] = data & 0xff;
+                buf[1] = data >> 8;
+                data = ioread16(host->ioaddr + SD_RESPONSE1);
+                buf[2] = data & 0xff;
+                buf[3] = data >> 8;
+        }
+
+        dev_dbg(&host->pdev->dev, "Command IRQ complete %d %d %x\n",
+                cmd->opcode, cmd->error, cmd->flags);
+
+        /* If there is data to handle we will
+         * finish the request in the mmc_data_end_irq handler.*/
+        if (host->data)
+                return;
+
+        toshsd_finish_request(host);
+}
+
+static void toshsd_data_end_irq(struct toshsd_host *host)
+{
+        struct mmc_data *data = host->data;
+
+        host->data = NULL;
+
+        if (!data) {
+                dev_warn(&host->pdev->dev, "Spurious data end IRQ\n");
+                return;
+        }
+
+        if (data->error == 0)
+                data->bytes_xfered = data->blocks * data->blksz;
+        else
+                data->bytes_xfered = 0;
+
+        dev_dbg(&host->pdev->dev, "Completed data request xfr=%d\n",
+                data->bytes_xfered);
+
+        iowrite16(0, host->ioaddr + SD_STOPINTERNAL);
+
+        toshsd_finish_request(host);
+}
+
+static irqreturn_t toshsd_irq(int irq, void *dev_id)
+{
+        struct toshsd_host *host = dev_id;
+        u32 int_reg, int_mask, int_status, detail;
+        int error = 0, ret = IRQ_HANDLED;
+
+        spin_lock(&host->lock);
+        int_status = ioread32(host->ioaddr + SD_CARDSTATUS);
+        int_mask = ioread32(host->ioaddr + SD_INTMASKCARD);
+        int_reg = int_status & ~int_mask & ~IRQ_DONT_CARE_BITS;
+
+        dev_dbg(&host->pdev->dev, "IRQ status:%x mask:%x\n",
+                int_status, int_mask);
+
+        /* nothing to do: it's not our IRQ */
+        if (!int_reg) {
+                ret = IRQ_NONE;
+                goto irq_end;
+        }
+
+        if (int_reg & SD_BUF_CMD_TIMEOUT) {
+                error = -ETIMEDOUT;
+                dev_dbg(&host->pdev->dev, "Timeout\n");
+        } else if (int_reg & SD_BUF_CRC_ERR) {
+                error = -EILSEQ;
+                dev_err(&host->pdev->dev, "BadCRC\n");
+        } else if (int_reg & (SD_BUF_ILLEGAL_ACCESS
+                                | SD_BUF_CMD_INDEX_ERR
+                                | SD_BUF_STOP_BIT_END_ERR
+                                | SD_BUF_OVERFLOW
+                                | SD_BUF_UNDERFLOW
+                                | SD_BUF_DATA_TIMEOUT)) {
+                dev_err(&host->pdev->dev, "Buffer status error: { %s%s%s%s%s%s}\n",
+                        int_reg & SD_BUF_ILLEGAL_ACCESS ? "ILLEGAL_ACC " : "",
+                        int_reg & SD_BUF_CMD_INDEX_ERR ? "CMD_INDEX " : "",
+                        int_reg & SD_BUF_STOP_BIT_END_ERR ? "STOPBIT_END " : "",
+                        int_reg & SD_BUF_OVERFLOW ? "OVERFLOW " : "",
+                        int_reg & SD_BUF_UNDERFLOW ? "UNDERFLOW " : "",
+                        int_reg & SD_BUF_DATA_TIMEOUT ? "DATA_TIMEOUT " : "");
+
+                detail = ioread32(host->ioaddr + SD_ERRORSTATUS0);
+                dev_err(&host->pdev->dev, "detail error status { %s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
+                        detail & SD_ERR0_RESP_CMD_ERR ? "RESP_CMD " : "",
+                        detail & SD_ERR0_RESP_NON_CMD12_END_BIT_ERR ? "RESP_END_BIT " : "",
+                        detail & SD_ERR0_RESP_CMD12_END_BIT_ERR ? "RESP_END_BIT " : "",
+                        detail & SD_ERR0_READ_DATA_END_BIT_ERR ? "READ_DATA_END_BIT " : "",
+                        detail & SD_ERR0_WRITE_CRC_STATUS_END_BIT_ERR ? "WRITE_CMD_END_BIT " : "",
+                        detail & SD_ERR0_RESP_NON_CMD12_CRC_ERR ? "RESP_CRC " : "",
+                        detail & SD_ERR0_RESP_CMD12_CRC_ERR ? "RESP_CRC " : "",
+                        detail & SD_ERR0_READ_DATA_CRC_ERR ? "READ_DATA_CRC " : "",
+                        detail & SD_ERR0_WRITE_CMD_CRC_ERR ? "WRITE_CMD_CRC " : "",
+                        detail & SD_ERR1_NO_CMD_RESP ? "NO_CMD_RESP " : "",
+                        detail & SD_ERR1_TIMEOUT_READ_DATA ? "READ_DATA_TIMEOUT " : "",
+                        detail & SD_ERR1_TIMEOUT_CRS_STATUS ? "CRS_STATUS_TIMEOUT " : "",
+                        detail & SD_ERR1_TIMEOUT_CRC_BUSY ? "CRC_BUSY_TIMEOUT " : "");
+                error = -EIO;
+        }
+
+        if (error) {
+                if (host->cmd)
+                        host->cmd->error = error;
+
+                if (error == -ETIMEDOUT) {
+                        iowrite32(int_status &
+                                  ~(SD_BUF_CMD_TIMEOUT | SD_CARD_RESP_END),
+                                  host->ioaddr + SD_CARDSTATUS);
+                } else {
+                        toshsd_init(host);
+                        __toshsd_set_ios(host->mmc, &host->mmc->ios);
+                        goto irq_end;
+                }
+        }
+
+        /* Card insert/remove. The mmc controlling code is stateless. */
+        if (int_reg & (SD_CARD_CARD_INSERTED_0 | SD_CARD_CARD_REMOVED_0)) {
+                iowrite32(int_status &
+                          ~(SD_CARD_CARD_REMOVED_0 | SD_CARD_CARD_INSERTED_0),
+                          host->ioaddr + SD_CARDSTATUS);
+
+                if (int_reg & SD_CARD_CARD_INSERTED_0)
+                        toshsd_init(host);
+
+                mmc_detect_change(host->mmc, 1);
+        }
+
+        /* Data transfer */
+        if (int_reg & (SD_BUF_READ_ENABLE | SD_BUF_WRITE_ENABLE)) {
+                iowrite32(int_status &
+                          ~(SD_BUF_WRITE_ENABLE | SD_BUF_READ_ENABLE),
+                          host->ioaddr + SD_CARDSTATUS);
+
+                ret = IRQ_WAKE_THREAD;
+                goto irq_end;
+        }
+
+        /* Command completion */
+        if (int_reg & SD_CARD_RESP_END) {
+                iowrite32(int_status & ~(SD_CARD_RESP_END),
+                          host->ioaddr + SD_CARDSTATUS);
+                toshsd_cmd_irq(host);
+        }
+
+        /* Data transfer completion */
+        if (int_reg & SD_CARD_RW_END) {
+                iowrite32(int_status & ~(SD_CARD_RW_END),
+                          host->ioaddr + SD_CARDSTATUS);
+                toshsd_data_end_irq(host);
+        }
+irq_end:
+        spin_unlock(&host->lock);
+        return ret;
+}
+
+static void toshsd_start_cmd(struct toshsd_host *host, struct mmc_command *cmd)
+{
+        struct mmc_data *data = host->data;
+        int c = cmd->opcode;
+
+        dev_dbg(&host->pdev->dev, "Command opcode: %d\n", cmd->opcode);
+
+        if (cmd->opcode == MMC_STOP_TRANSMISSION) {
+                iowrite16(SD_STOPINT_ISSUE_CMD12,
+                          host->ioaddr + SD_STOPINTERNAL);
+
+                cmd->resp[0] = cmd->opcode;
+                cmd->resp[1] = 0;
+                cmd->resp[2] = 0;
+                cmd->resp[3] = 0;
+
+                toshsd_finish_request(host);
+                return;
+        }
+
+        switch (mmc_resp_type(cmd)) {
+        case MMC_RSP_NONE:
+                c |= SD_CMD_RESP_TYPE_NONE;
+                break;
+
+        case MMC_RSP_R1:
+                c |= SD_CMD_RESP_TYPE_EXT_R1;
+                break;
+        case MMC_RSP_R1B:
+                c |= SD_CMD_RESP_TYPE_EXT_R1B;
+                break;
+        case MMC_RSP_R2:
+                c |= SD_CMD_RESP_TYPE_EXT_R2;
+                break;
+        case MMC_RSP_R3:
+                c |= SD_CMD_RESP_TYPE_EXT_R3;
+                break;
+
+        default:
+                dev_err(&host->pdev->dev, "Unknown response type %d\n",
+                        mmc_resp_type(cmd));
+                break;
+        }
+
+        host->cmd = cmd;
+
+        if (cmd->opcode == MMC_APP_CMD)
+                c |= SD_CMD_TYPE_ACMD;
+
+        if (cmd->opcode == MMC_GO_IDLE_STATE)
+                c |= (3 << 8);  /* removed from ipaq-asic3.h for some reason */
+
+        if (data) {
+                c |= SD_CMD_DATA_PRESENT;
+
+                if (data->blocks > 1) {
+                        iowrite16(SD_STOPINT_AUTO_ISSUE_CMD12,
+                                  host->ioaddr + SD_STOPINTERNAL);
+                        c |= SD_CMD_MULTI_BLOCK;
+                }
+
+                if (data->flags & MMC_DATA_READ)
+                        c |= SD_CMD_TRANSFER_READ;
+
+                /* MMC_DATA_WRITE does not require a bit to be set */
+        }
+
+        /* Send the command */
+        iowrite32(cmd->arg, host->ioaddr + SD_ARG0);
+        iowrite16(c, host->ioaddr + SD_CMD);
+}
+
+static void toshsd_start_data(struct toshsd_host *host, struct mmc_data *data)
+{
+        unsigned int flags = SG_MITER_ATOMIC;
+
+        dev_dbg(&host->pdev->dev, "setup data transfer: blocksize %08x  nr_blocks %d, offset: %08x\n",
+                data->blksz, data->blocks, data->sg->offset);
+
+        host->data = data;
+
+        if (data->flags & MMC_DATA_READ)
+                flags |= SG_MITER_TO_SG;
+        else
+                flags |= SG_MITER_FROM_SG;
+
+        sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
+
+        /* Set transfer length and blocksize */
+        iowrite16(data->blocks, host->ioaddr + SD_BLOCKCOUNT);
+        iowrite16(data->blksz, host->ioaddr + SD_CARDXFERDATALEN);
+}
+
+/* Process requests from the MMC layer */
+static void toshsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+        struct toshsd_host *host = mmc_priv(mmc);
+        unsigned long flags;
+
+        /* abort if card not present */
+        if (!(ioread16(host->ioaddr + SD_CARDSTATUS) & SD_CARD_PRESENT_0)) {
+                mrq->cmd->error = -ENOMEDIUM;
+                mmc_request_done(mmc, mrq);
+                return;
+        }
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        WARN_ON(host->mrq != NULL);
+
+        host->mrq = mrq;
+
+        if (mrq->data)
+                toshsd_start_data(host, mrq->data);
+
+        toshsd_set_led(host, 1);
+
+        toshsd_start_cmd(host, mrq->cmd);
+
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
+static void toshsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct toshsd_host *host = mmc_priv(mmc);
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+        __toshsd_set_ios(mmc, ios);
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
+static int toshsd_get_ro(struct mmc_host *mmc)
+{
+        struct toshsd_host *host = mmc_priv(mmc);
+
+        /* active low */
+        return !(ioread16(host->ioaddr + SD_CARDSTATUS) & SD_CARD_WRITE_PROTECT);
+}
+
+static int toshsd_get_cd(struct mmc_host *mmc)
+{
+        struct toshsd_host *host = mmc_priv(mmc);
+
+        return !!(ioread16(host->ioaddr + SD_CARDSTATUS) & SD_CARD_PRESENT_0);
+}
+
+static struct mmc_host_ops toshsd_ops = {
+        .request = toshsd_request,
+        .set_ios = toshsd_set_ios,
+        .get_ro = toshsd_get_ro,
+        .get_cd = toshsd_get_cd,
+};
+
+
+static void toshsd_powerdown(struct toshsd_host *host)
+{
+        /* mask all interrupts */
+        iowrite32(0xffffffff, host->ioaddr + SD_INTMASKCARD);
+        /* disable card clock */
+        iowrite16(0x000, host->ioaddr + SDIO_BASE + SDIO_CLOCKNWAITCTRL);
+        iowrite16(0, host->ioaddr + SD_CARDCLOCKCTRL);
+        /* power down card */
+        pci_write_config_byte(host->pdev, SD_PCICFG_POWER1, SD_PCICFG_PWR1_OFF);
+        /* disable clock */
+        pci_write_config_byte(host->pdev, SD_PCICFG_CLKSTOP, 0);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int toshsd_pm_suspend(struct device *dev)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct toshsd_host *host = pci_get_drvdata(pdev);
+
+        toshsd_powerdown(host);
+
+        pci_save_state(pdev);
+        pci_enable_wake(pdev, PCI_D3hot, 0);
+        pci_disable_device(pdev);
+        pci_set_power_state(pdev, PCI_D3hot);
+
+        return 0;
+}
+
+static int toshsd_pm_resume(struct device *dev)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct toshsd_host *host = pci_get_drvdata(pdev);
+        int ret;
+
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+        ret = pci_enable_device(pdev);
+        if (ret)
+                return ret;
+
+        toshsd_init(host);
+
+        return 0;
+}
+#endif /* CONFIG_PM_SLEEP */
+
+static int toshsd_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        int ret;
+        struct toshsd_host *host;
+        struct mmc_host *mmc;
+        resource_size_t base;
+
+        ret = pci_enable_device(pdev);
+        if (ret)
+                return ret;
+
+        mmc = mmc_alloc_host(sizeof(struct toshsd_host), &pdev->dev);
+        if (!mmc) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        host = mmc_priv(mmc);
+        host->mmc = mmc;
+
+        host->pdev = pdev;
+        pci_set_drvdata(pdev, host);
+
+        ret = pci_request_regions(pdev, DRIVER_NAME);
+        if (ret)
+                goto free;
+
+        host->ioaddr = pci_iomap(pdev, 0, 0);
+        if (!host->ioaddr) {
+                ret = -ENOMEM;
+                goto release;
+        }
+
+        /* Set MMC host parameters */
+        mmc->ops = &toshsd_ops;
+        mmc->caps = MMC_CAP_4_BIT_DATA;
+        mmc->ocr_avail = MMC_VDD_32_33;
+
+        mmc->f_min = HCLK / 512;
+        mmc->f_max = HCLK;
+
+        spin_lock_init(&host->lock);
+
+        toshsd_init(host);
+
+        ret = request_threaded_irq(pdev->irq, toshsd_irq, toshsd_thread_irq,
+                                   IRQF_SHARED, DRIVER_NAME, host);
+        if (ret)
+                goto unmap;
+
+        mmc_add_host(mmc);
+
+        base = pci_resource_start(pdev, 0);
+        dev_dbg(&pdev->dev, "MMIO %pa, IRQ %d\n", &base, pdev->irq);
+
+        pm_suspend_ignore_children(&pdev->dev, 1);
+
+        return 0;
+
+unmap:
+        pci_iounmap(pdev, host->ioaddr);
+release:
+        pci_release_regions(pdev);
+free:
+        mmc_free_host(mmc);
+        pci_set_drvdata(pdev, NULL);
+err:
+        pci_disable_device(pdev);
+        return ret;
+}
+
+static void toshsd_remove(struct pci_dev *pdev)
+{
+        struct toshsd_host *host = pci_get_drvdata(pdev);
+
+        mmc_remove_host(host->mmc);
+        toshsd_powerdown(host);
+        free_irq(pdev->irq, host);
+        pci_iounmap(pdev, host->ioaddr);
+        pci_release_regions(pdev);
+        mmc_free_host(host->mmc);
+        pci_set_drvdata(pdev, NULL);
+        pci_disable_device(pdev);
+}
+
+static const struct dev_pm_ops toshsd_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(toshsd_pm_suspend, toshsd_pm_resume)
+};
+
+static struct pci_driver toshsd_driver = {
+        .name = DRIVER_NAME,
+        .id_table = pci_ids,
+        .probe = toshsd_probe,
+        .remove = toshsd_remove,
+        .driver.pm = &toshsd_pm_ops,
+};
+
+static int __init toshsd_drv_init(void)
+{
+        return pci_register_driver(&toshsd_driver);
+}
+
+static void __exit toshsd_drv_exit(void)
+{
+        pci_unregister_driver(&toshsd_driver);
+}
+
+module_init(toshsd_drv_init);
+module_exit(toshsd_drv_exit);
+
+MODULE_AUTHOR("Ondrej Zary, Richard Betts");
+MODULE_DESCRIPTION("Toshiba PCI Secure Digital Host Controller Interface driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/toshsd.h b/drivers/mmc/host/toshsd.h
new file mode 100644
index 000000000000..b6c0d89e53a6
--- /dev/null
+++ b/drivers/mmc/host/toshsd.h
@@ -0,0 +1,176 @@
+/*
+ *  Toshiba PCI Secure Digital Host Controller Interface driver
+ *
+ *  Copyright (C) 2014 Ondrej Zary
+ *  Copyright (C) 2007 Richard Betts, All Rights Reserved.
+ *
+ *      Based on asic3_mmc.c Copyright (c) 2005 SDG Systems, LLC
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#define HCLK    33000000        /* 33 MHz (PCI clock) */
+
+#define SD_PCICFG_CLKSTOP       0x40    /* 0x1f = clock controller, 0 = stop */
+#define SD_PCICFG_GATEDCLK      0x41    /* Gated clock */
+#define SD_PCICFG_CLKMODE       0x42    /* Control clock of SD controller */
+#define SD_PCICFG_PINSTATUS     0x44    /* R/O: read status of SD pins */
+#define SD_PCICFG_POWER1        0x48
+#define SD_PCICFG_POWER2        0x49
+#define SD_PCICFG_POWER3        0x4a
+#define SD_PCICFG_CARDDETECT    0x4c
+#define SD_PCICFG_SLOTS         0x50    /* R/O: define support slot number */
+#define SD_PCICFG_EXTGATECLK1   0xf0    /* Could be used for gated clock */
+#define SD_PCICFG_EXTGATECLK2   0xf1    /* Could be used for gated clock */
+#define SD_PCICFG_EXTGATECLK3   0xf9    /* Bit 1: double buffer/single buffer */
+#define SD_PCICFG_SDLED_ENABLE1 0xfa
+#define SD_PCICFG_SDLED_ENABLE2 0xfe
+
+#define SD_PCICFG_CLKMODE_DIV_DISABLE   BIT(0)
+#define SD_PCICFG_CLKSTOP_ENABLE_ALL    0x1f
+#define SD_PCICFG_LED_ENABLE1_START     0x12
+#define SD_PCICFG_LED_ENABLE2_START     0x80
+
+#define SD_PCICFG_PWR1_33V      0x08    /* Set for 3.3 volts */
+#define SD_PCICFG_PWR1_OFF      0x00    /* Turn off power */
+#define SD_PCICFG_PWR2_AUTO     0x02
+
+#define SD_CMD                  0x00    /* also for SDIO */
+#define SD_ARG0                 0x04    /* also for SDIO */
+#define SD_ARG1                 0x06    /* also for SDIO */
+#define SD_STOPINTERNAL         0x08
+#define SD_BLOCKCOUNT           0x0a    /* also for SDIO */
+#define SD_RESPONSE0            0x0c    /* also for SDIO */
+#define SD_RESPONSE1            0x0e    /* also for SDIO */
+#define SD_RESPONSE2            0x10    /* also for SDIO */
+#define SD_RESPONSE3            0x12    /* also for SDIO */
+#define SD_RESPONSE4            0x14    /* also for SDIO */
+#define SD_RESPONSE5            0x16    /* also for SDIO */
+#define SD_RESPONSE6            0x18    /* also for SDIO */
+#define SD_RESPONSE7            0x1a    /* also for SDIO */
+#define SD_CARDSTATUS           0x1c    /* also for SDIO */
+#define SD_BUFFERCTRL           0x1e    /* also for SDIO */
+#define SD_INTMASKCARD          0x20    /* also for SDIO */
+#define SD_INTMASKBUFFER        0x22    /* also for SDIO */
+#define SD_CARDCLOCKCTRL        0x24
+#define SD_CARDXFERDATALEN      0x26    /* also for SDIO */
+#define SD_CARDOPTIONSETUP      0x28    /* also for SDIO */
+#define SD_ERRORSTATUS0         0x2c    /* also for SDIO */
+#define SD_ERRORSTATUS1         0x2e    /* also for SDIO */
+#define SD_DATAPORT             0x30    /* also for SDIO */
+#define SD_TRANSACTIONCTRL      0x34    /* also for SDIO */
+#define SD_SOFTWARERESET        0xe0    /* also for SDIO */
+
+/* registers above marked "also for SDIO" and all SDIO registers below can be
+ * accessed at SDIO_BASE + reg address */
+#define SDIO_BASE        0x100
+
+#define SDIO_CARDPORTSEL        0x02
+#define SDIO_CARDINTCTRL        0x36
+#define SDIO_CLOCKNWAITCTRL     0x38
+#define SDIO_HOSTINFORMATION    0x3a
+#define SDIO_ERRORCTRL          0x3c
+#define SDIO_LEDCTRL            0x3e
+
+#define SD_TRANSCTL_SET         BIT(8)
+
+#define SD_CARDCLK_DIV_DISABLE  BIT(15)
+#define SD_CARDCLK_ENABLE_CLOCK BIT(8)
+#define SD_CARDCLK_CLK_DIV_512  BIT(7)
+#define SD_CARDCLK_CLK_DIV_256  BIT(6)
+#define SD_CARDCLK_CLK_DIV_128  BIT(5)
+#define SD_CARDCLK_CLK_DIV_64   BIT(4)
+#define SD_CARDCLK_CLK_DIV_32   BIT(3)
+#define SD_CARDCLK_CLK_DIV_16   BIT(2)
+#define SD_CARDCLK_CLK_DIV_8    BIT(1)
+#define SD_CARDCLK_CLK_DIV_4    BIT(0)
+#define SD_CARDCLK_CLK_DIV_2    0
+
+#define SD_CARDOPT_REQUIRED             0x000e
+#define SD_CARDOPT_DATA_RESP_TIMEOUT(x) (((x) & 0x0f) << 4) /* 4 bits */
+#define SD_CARDOPT_C2_MODULE_ABSENT     BIT(14)
+#define SD_CARDOPT_DATA_XFR_WIDTH_1     (1 << 15)
+#define SD_CARDOPT_DATA_XFR_WIDTH_4     (0 << 15)
+
+#define SD_CMD_TYPE_CMD                 (0 << 6)
+#define SD_CMD_TYPE_ACMD                (1 << 6)
+#define SD_CMD_TYPE_AUTHEN              (2 << 6)
+#define SD_CMD_RESP_TYPE_NONE           (3 << 8)
+#define SD_CMD_RESP_TYPE_EXT_R1         (4 << 8)
+#define SD_CMD_RESP_TYPE_EXT_R1B        (5 << 8)
+#define SD_CMD_RESP_TYPE_EXT_R2         (6 << 8)
+#define SD_CMD_RESP_TYPE_EXT_R3         (7 << 8)
+#define SD_CMD_RESP_TYPE_EXT_R6         (4 << 8)
+#define SD_CMD_RESP_TYPE_EXT_R7         (4 << 8)
+#define SD_CMD_DATA_PRESENT             BIT(11)
+#define SD_CMD_TRANSFER_READ            BIT(12)
+#define SD_CMD_MULTI_BLOCK              BIT(13)
+#define SD_CMD_SECURITY_CMD             BIT(14)
+
+#define SD_STOPINT_ISSUE_CMD12          BIT(0)
+#define SD_STOPINT_AUTO_ISSUE_CMD12     BIT(8)
+
+#define SD_CARD_RESP_END        BIT(0)
+#define SD_CARD_RW_END          BIT(2)
+#define SD_CARD_CARD_REMOVED_0  BIT(3)
+#define SD_CARD_CARD_INSERTED_0 BIT(4)
+#define SD_CARD_PRESENT_0       BIT(5)
+#define SD_CARD_UNK6            BIT(6)
+#define SD_CARD_WRITE_PROTECT   BIT(7)
+#define SD_CARD_CARD_REMOVED_3  BIT(8)
+#define SD_CARD_CARD_INSERTED_3 BIT(9)
+#define SD_CARD_PRESENT_3       BIT(10)
+
+#define SD_BUF_CMD_INDEX_ERR    BIT(16)
+#define SD_BUF_CRC_ERR          BIT(17)
+#define SD_BUF_STOP_BIT_END_ERR BIT(18)
+#define SD_BUF_DATA_TIMEOUT     BIT(19)
+#define SD_BUF_OVERFLOW         BIT(20)
+#define SD_BUF_UNDERFLOW        BIT(21)
+#define SD_BUF_CMD_TIMEOUT      BIT(22)
+#define SD_BUF_UNK7             BIT(23)
+#define SD_BUF_READ_ENABLE      BIT(24)
+#define SD_BUF_WRITE_ENABLE     BIT(25)
+#define SD_BUF_ILLEGAL_FUNCTION BIT(29)
+#define SD_BUF_CMD_BUSY         BIT(30)
+#define SD_BUF_ILLEGAL_ACCESS   BIT(31)
+
+#define SD_ERR0_RESP_CMD_ERR                    BIT(0)
+#define SD_ERR0_RESP_NON_CMD12_END_BIT_ERR      BIT(2)
+#define SD_ERR0_RESP_CMD12_END_BIT_ERR          BIT(3)
+#define SD_ERR0_READ_DATA_END_BIT_ERR           BIT(4)
+#define SD_ERR0_WRITE_CRC_STATUS_END_BIT_ERR    BIT(5)
+#define SD_ERR0_RESP_NON_CMD12_CRC_ERR          BIT(8)
+#define SD_ERR0_RESP_CMD12_CRC_ERR              BIT(9)
+#define SD_ERR0_READ_DATA_CRC_ERR               BIT(10)
+#define SD_ERR0_WRITE_CMD_CRC_ERR               BIT(11)
+
+#define SD_ERR1_NO_CMD_RESP             BIT(16)
+#define SD_ERR1_TIMEOUT_READ_DATA       BIT(20)
+#define SD_ERR1_TIMEOUT_CRS_STATUS      BIT(21)
+#define SD_ERR1_TIMEOUT_CRC_BUSY        BIT(22)
+
+#define IRQ_DONT_CARE_BITS (SD_CARD_PRESENT_3 \
+        | SD_CARD_WRITE_PROTECT \
+        | SD_CARD_UNK6 \
+        | SD_CARD_PRESENT_0 \
+        | SD_BUF_UNK7 \
+        | SD_BUF_CMD_BUSY)
+
+struct toshsd_host {
+        struct pci_dev *pdev;
+        struct mmc_host *mmc;
+
+        spinlock_t lock;
+
+        struct mmc_request *mrq;/* Current request */
+        struct mmc_command *cmd;/* Current command */
+        struct mmc_data *data;  /* Current data request */
+
+        struct sg_mapping_iter sg_miter; /* for PIO */
+
+        void __iomem *ioaddr; /* mapped address */
+};
diff --git a/drivers/net/bonding/bond_netlink.c b/drivers/net/bonding/bond_netlink.c
index c13d83e15ace..45f09a66e6c9 100644
--- a/drivers/net/bonding/bond_netlink.c
+++ b/drivers/net/bonding/bond_netlink.c
@@ -225,7 +225,12 @@ static int bond_changelink(struct net_device *bond_dev,
 
                 bond_option_arp_ip_targets_clear(bond);
                 nla_for_each_nested(attr, data[IFLA_BOND_ARP_IP_TARGET], rem) {
-                        __be32 target = nla_get_be32(attr);
+                        __be32 target;
+
+                        if (nla_len(attr) < sizeof(target))
+                                return -EINVAL;
+
+                        target = nla_get_be32(attr);
 
                         bond_opt_initval(&newval, (__force u64)target);
                         err = __bond_opt_set(bond, BOND_OPT_ARP_TARGETS,
diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c
index b9625968daac..4f4c2a7888e5 100644
--- a/drivers/net/dsa/bcm_sf2.c
+++ b/drivers/net/dsa/bcm_sf2.c
@@ -377,6 +377,29 @@ static irqreturn_t bcm_sf2_switch_1_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+static int bcm_sf2_sw_rst(struct bcm_sf2_priv *priv)
+{
+        unsigned int timeout = 1000;
+        u32 reg;
+
+        reg = core_readl(priv, CORE_WATCHDOG_CTRL);
+        reg |= SOFTWARE_RESET | EN_CHIP_RST | EN_SW_RESET;
+        core_writel(priv, reg, CORE_WATCHDOG_CTRL);
+
+        do {
+                reg = core_readl(priv, CORE_WATCHDOG_CTRL);
+                if (!(reg & SOFTWARE_RESET))
+                        break;
+
+                usleep_range(1000, 2000);
+        } while (timeout-- > 0);
+
+        if (timeout == 0)
+                return -ETIMEDOUT;
+
+        return 0;
+}
+
 static int bcm_sf2_sw_setup(struct dsa_switch *ds)
 {
         const char *reg_names[BCM_SF2_REGS_NUM] = BCM_SF2_REGS_NAME;
@@ -404,11 +427,18 @@ static int bcm_sf2_sw_setup(struct dsa_switch *ds)
                 *base = of_iomap(dn, i);
                 if (*base == NULL) {
                         pr_err("unable to find register: %s\n", reg_names[i]);
-                        return -ENODEV;
+                        ret = -ENOMEM;
+                        goto out_unmap;
                 }
                 base++;
         }
 
+        ret = bcm_sf2_sw_rst(priv);
+        if (ret) {
+                pr_err("unable to software reset switch: %d\n", ret);
+                goto out_unmap;
+        }
+
         /* Disable all interrupts and request them */
         intrl2_0_writel(priv, 0xffffffff, INTRL2_CPU_MASK_SET);
         intrl2_0_writel(priv, 0xffffffff, INTRL2_CPU_CLEAR);
@@ -484,7 +514,8 @@ out_free_irq0:
 out_unmap:
         base = &priv->core;
         for (i = 0; i < BCM_SF2_REGS_NUM; i++) {
-                iounmap(*base);
+                if (*base)
+                        iounmap(*base);
                 base++;
         }
         return ret;
@@ -733,29 +764,6 @@ static int bcm_sf2_sw_suspend(struct dsa_switch *ds)
         return 0;
 }
 
-static int bcm_sf2_sw_rst(struct bcm_sf2_priv *priv)
-{
-        unsigned int timeout = 1000;
-        u32 reg;
-
-        reg = core_readl(priv, CORE_WATCHDOG_CTRL);
-        reg |= SOFTWARE_RESET | EN_CHIP_RST | EN_SW_RESET;
-        core_writel(priv, reg, CORE_WATCHDOG_CTRL);
-
-        do {
-                reg = core_readl(priv, CORE_WATCHDOG_CTRL);
-                if (!(reg & SOFTWARE_RESET))
-                        break;
-
-                usleep_range(1000, 2000);
-        } while (timeout-- > 0);
-
-        if (timeout == 0)
-                return -ETIMEDOUT;
-
-        return 0;
-}
-
 static int bcm_sf2_sw_resume(struct dsa_switch *ds)
 {
         struct bcm_sf2_priv *priv = ds_to_priv(ds);
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index dbb41c1923e6..77f8f836cbbe 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -8563,7 +8563,8 @@ static int tg3_init_rings(struct tg3 *tp)
                 if (tnapi->rx_rcb)
                         memset(tnapi->rx_rcb, 0, TG3_RX_RCB_RING_BYTES(tp));
 
-                if (tg3_rx_prodring_alloc(tp, &tnapi->prodring)) {
+                if (tnapi->prodring.rx_std &&
+                    tg3_rx_prodring_alloc(tp, &tnapi->prodring)) {
                         tg3_free_rings(tp);
                         return -ENOMEM;
                 }
diff --git a/drivers/net/ethernet/cadence/Kconfig b/drivers/net/ethernet/cadence/Kconfig
index 9e089d24466e..3564fe9d3f69 100644
--- a/drivers/net/ethernet/cadence/Kconfig
+++ b/drivers/net/ethernet/cadence/Kconfig
@@ -22,7 +22,7 @@ if NET_CADENCE
 
 config ARM_AT91_ETHER
         tristate "AT91RM9200 Ethernet support"
-        depends on HAS_DMA && (ARCH_AT91RM9200 || COMPILE_TEST)
+        depends on HAS_DMA && (ARCH_AT91 || COMPILE_TEST)
         select MACB
         ---help---
           If you wish to compile a kernel for the AT91RM9200 and enable
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index 8520d5529df8..279873cb6e3a 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -2442,9 +2442,13 @@ static unsigned int from_fw_linkcaps(unsigned int type, unsigned int caps)
                      SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full |
                      SUPPORTED_10000baseKX4_Full;
         else if (type == FW_PORT_TYPE_FIBER_XFI ||
-                 type == FW_PORT_TYPE_FIBER_XAUI || type == FW_PORT_TYPE_SFP)
+                 type == FW_PORT_TYPE_FIBER_XAUI || type == FW_PORT_TYPE_SFP) {
                 v |= SUPPORTED_FIBRE;
-        else if (type == FW_PORT_TYPE_BP40_BA)
+                if (caps & FW_PORT_CAP_SPEED_1G)
+                        v |= SUPPORTED_1000baseT_Full;
+                if (caps & FW_PORT_CAP_SPEED_10G)
+                        v |= SUPPORTED_10000baseT_Full;
+        } else if (type == FW_PORT_TYPE_BP40_BA)
                 v |= SUPPORTED_40000baseSR4_Full;
 
         if (caps & FW_PORT_CAP_ANEG)
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index 3e8475cae4f9..597c463e384d 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -4309,11 +4309,16 @@ static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh)
                 return -EOPNOTSUPP;
 
         br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
+        if (!br_spec)
+                return -EINVAL;
 
         nla_for_each_nested(attr, br_spec, rem) {
                 if (nla_type(attr) != IFLA_BRIDGE_MODE)
                         continue;
 
+                if (nla_len(attr) < sizeof(mode))
+                        return -EINVAL;
+
                 mode = nla_get_u16(attr);
                 if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB)
                         return -EINVAL;
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 247335d2c7ec..952ef7c434e8 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -6372,7 +6372,6 @@ static int e1000e_pm_resume(struct device *dev)
 }
 #endif /* CONFIG_PM_SLEEP */
 
-#ifdef CONFIG_PM_RUNTIME
 static int e1000e_pm_runtime_idle(struct device *dev)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
@@ -6432,7 +6431,6 @@ static int e1000e_pm_runtime_suspend(struct device *dev)
 
         return 0;
 }
-#endif /* CONFIG_PM_RUNTIME */
 #endif /* CONFIG_PM */
 
 static void e1000_shutdown(struct pci_dev *pdev)
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index a2d72a87cbde..b85880a6e4c4 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -186,11 +186,9 @@ static int igb_pci_enable_sriov(struct pci_dev *dev, int num_vfs);
 static int igb_suspend(struct device *);
 #endif
 static int igb_resume(struct device *);
-#ifdef CONFIG_PM_RUNTIME
 static int igb_runtime_suspend(struct device *dev);
 static int igb_runtime_resume(struct device *dev);
 static int igb_runtime_idle(struct device *dev);
-#endif
 static const struct dev_pm_ops igb_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(igb_suspend, igb_resume)
         SET_RUNTIME_PM_OPS(igb_runtime_suspend, igb_runtime_resume,
@@ -1012,7 +1010,8 @@ static void igb_free_q_vector(struct igb_adapter *adapter, int v_idx)
         /* igb_get_stats64() might access the rings on this vector,
          * we must wait a grace period before freeing it.
          */
-        kfree_rcu(q_vector, rcu);
+        if (q_vector)
+                kfree_rcu(q_vector, rcu);
 }
 
 /**
@@ -1792,8 +1791,10 @@ void igb_down(struct igb_adapter *adapter)
         adapter->flags &= ~IGB_FLAG_NEED_LINK_UPDATE;
 
         for (i = 0; i < adapter->num_q_vectors; i++) {
-                napi_synchronize(&(adapter->q_vector[i]->napi));
-                napi_disable(&(adapter->q_vector[i]->napi));
+                if (adapter->q_vector[i]) {
+                        napi_synchronize(&adapter->q_vector[i]->napi);
+                        napi_disable(&adapter->q_vector[i]->napi);
+                }
         }
 
 
@@ -3717,7 +3718,8 @@ static void igb_free_all_tx_resources(struct igb_adapter *adapter)
         int i;
 
         for (i = 0; i < adapter->num_tx_queues; i++)
-                igb_free_tx_resources(adapter->tx_ring[i]);
+                if (adapter->tx_ring[i])
+                        igb_free_tx_resources(adapter->tx_ring[i]);
 }
 
 void igb_unmap_and_free_tx_resource(struct igb_ring *ring,
@@ -3782,7 +3784,8 @@ static void igb_clean_all_tx_rings(struct igb_adapter *adapter)
         int i;
 
         for (i = 0; i < adapter->num_tx_queues; i++)
-                igb_clean_tx_ring(adapter->tx_ring[i]);
+                if (adapter->tx_ring[i])
+                        igb_clean_tx_ring(adapter->tx_ring[i]);
 }
 
 /**
@@ -3819,7 +3822,8 @@ static void igb_free_all_rx_resources(struct igb_adapter *adapter)
         int i;
 
         for (i = 0; i < adapter->num_rx_queues; i++)
-                igb_free_rx_resources(adapter->rx_ring[i]);
+                if (adapter->rx_ring[i])
+                        igb_free_rx_resources(adapter->rx_ring[i]);
 }
 
 /**
@@ -3874,7 +3878,8 @@ static void igb_clean_all_rx_rings(struct igb_adapter *adapter)
         int i;
 
         for (i = 0; i < adapter->num_rx_queues; i++)
-                igb_clean_rx_ring(adapter->rx_ring[i]);
+                if (adapter->rx_ring[i])
+                        igb_clean_rx_ring(adapter->rx_ring[i]);
 }
 
 /**
@@ -7404,6 +7409,8 @@ static int igb_resume(struct device *dev)
         pci_restore_state(pdev);
         pci_save_state(pdev);
 
+        if (!pci_device_is_present(pdev))
+                return -ENODEV;
         err = pci_enable_device_mem(pdev);
         if (err) {
                 dev_err(&pdev->dev,
@@ -7441,7 +7448,6 @@ static int igb_resume(struct device *dev)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
 static int igb_runtime_idle(struct device *dev)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
@@ -7478,8 +7484,7 @@ static int igb_runtime_resume(struct device *dev)
 {
         return igb_resume(dev);
 }
-#endif /* CONFIG_PM_RUNTIME */
-#endif
+#endif /* CONFIG_PM */
 
 static void igb_shutdown(struct pci_dev *pdev)
 {
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index d2df4e3d1032..cc51554c9e99 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -3936,8 +3936,8 @@ void ixgbe_set_rx_mode(struct net_device *netdev)
                  * if SR-IOV and VMDQ are disabled - otherwise ensure
                  * that hardware VLAN filters remain enabled.
                  */
-                if (!(adapter->flags & (IXGBE_FLAG_VMDQ_ENABLED |
-                                        IXGBE_FLAG_SRIOV_ENABLED)))
+                if (adapter->flags & (IXGBE_FLAG_VMDQ_ENABLED |
+                                      IXGBE_FLAG_SRIOV_ENABLED))
                         vlnctrl |= (IXGBE_VLNCTRL_VFE | IXGBE_VLNCTRL_CFIEN);
         } else {
                 if (netdev->flags & IFF_ALLMULTI) {
@@ -7669,6 +7669,8 @@ static int ixgbe_ndo_bridge_setlink(struct net_device *dev,
                 return -EOPNOTSUPP;
 
         br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
+        if (!br_spec)
+                return -EINVAL;
 
         nla_for_each_nested(attr, br_spec, rem) {
                 __u16 mode;
@@ -7677,6 +7679,9 @@ static int ixgbe_ndo_bridge_setlink(struct net_device *dev,
                 if (nla_type(attr) != IFLA_BRIDGE_MODE)
                         continue;
 
+                if (nla_len(attr) < sizeof(mode))
+                        return -EINVAL;
+
                 mode = nla_get_u16(attr);
                 if (mode == BRIDGE_MODE_VEPA) {
                         reg = 0;
@@ -7979,6 +7984,7 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         int i, err, pci_using_dac, expected_gts;
         unsigned int indices = MAX_TX_QUEUES;
         u8 part_str[IXGBE_PBANUM_LENGTH];
+        bool disable_dev = false;
 #ifdef IXGBE_FCOE
         u16 device_caps;
 #endif
@@ -8369,13 +8375,14 @@ err_sw_init:
         iounmap(adapter->io_addr);
         kfree(adapter->mac_table);
 err_ioremap:
+        disable_dev = !test_and_set_bit(__IXGBE_DISABLED, &adapter->state);
         free_netdev(netdev);
 err_alloc_etherdev:
         pci_release_selected_regions(pdev,
                                      pci_select_bars(pdev, IORESOURCE_MEM));
 err_pci_reg:
 err_dma:
-        if (!adapter || !test_and_set_bit(__IXGBE_DISABLED, &adapter->state))
+        if (!adapter || disable_dev)
                 pci_disable_device(pdev);
         return err;
 }
@@ -8393,6 +8400,7 @@ static void ixgbe_remove(struct pci_dev *pdev)
 {
         struct ixgbe_adapter *adapter = pci_get_drvdata(pdev);
         struct net_device *netdev = adapter->netdev;
+        bool disable_dev;
 
         ixgbe_dbg_adapter_exit(adapter);
 
@@ -8442,11 +8450,12 @@ static void ixgbe_remove(struct pci_dev *pdev)
         e_dev_info("complete\n");
 
         kfree(adapter->mac_table);
+        disable_dev = !test_and_set_bit(__IXGBE_DISABLED, &adapter->state);
         free_netdev(netdev);
 
         pci_disable_pcie_error_reporting(pdev);
 
-        if (!test_and_set_bit(__IXGBE_DISABLED, &adapter->state))
+        if (disable_dev)
                 pci_disable_device(pdev);
 }
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
index 5d2498dcf536..cd5cf6d957c7 100644
--- a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
+++ b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
@@ -1546,7 +1546,7 @@ static int qp_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
 
         switch (op) {
         case RES_OP_RESERVE:
-                count = get_param_l(&in_param);
+                count = get_param_l(&in_param) & 0xffffff;
                 align = get_param_h(&in_param);
                 err = mlx4_grant_resource(dev, slave, RES_QP, count, 0);
                 if (err)
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index 60e9c2cd051e..b5db6b3f939f 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -917,21 +917,13 @@ static int sh_eth_reset(struct net_device *ndev)
         return ret;
 }
 
-#if defined(CONFIG_CPU_SH4) || defined(CONFIG_ARCH_SHMOBILE)
 static void sh_eth_set_receive_align(struct sk_buff *skb)
 {
-        int reserve;
+        uintptr_t reserve = (uintptr_t)skb->data & (SH_ETH_RX_ALIGN - 1);
 
-        reserve = SH4_SKB_RX_ALIGN - ((u32)skb->data & (SH4_SKB_RX_ALIGN - 1));
         if (reserve)
-                skb_reserve(skb, reserve);
+                skb_reserve(skb, SH_ETH_RX_ALIGN - reserve);
 }
-#else
-static void sh_eth_set_receive_align(struct sk_buff *skb)
-{
-        skb_reserve(skb, SH2_SH3_SKB_RX_ALIGN);
-}
-#endif
 
 
 /* CPU <-> EDMAC endian convert */
@@ -1119,6 +1111,7 @@ static void sh_eth_ring_format(struct net_device *ndev)
         struct sh_eth_txdesc *txdesc = NULL;
         int rx_ringsize = sizeof(*rxdesc) * mdp->num_rx_ring;
         int tx_ringsize = sizeof(*txdesc) * mdp->num_tx_ring;
+        int skbuff_size = mdp->rx_buf_sz + SH_ETH_RX_ALIGN - 1;
 
         mdp->cur_rx = 0;
         mdp->cur_tx = 0;
@@ -1131,21 +1124,21 @@ static void sh_eth_ring_format(struct net_device *ndev)
         for (i = 0; i < mdp->num_rx_ring; i++) {
                 /* skb */
                 mdp->rx_skbuff[i] = NULL;
-                skb = netdev_alloc_skb(ndev, mdp->rx_buf_sz);
+                skb = netdev_alloc_skb(ndev, skbuff_size);
                 mdp->rx_skbuff[i] = skb;
                 if (skb == NULL)
                         break;
-                dma_map_single(&ndev->dev, skb->data, mdp->rx_buf_sz,
-                               DMA_FROM_DEVICE);
                 sh_eth_set_receive_align(skb);
 
                 /* RX descriptor */
                 rxdesc = &mdp->rx_ring[i];
+                /* The size of the buffer is a multiple of 16 bytes. */
+                rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
+                dma_map_single(&ndev->dev, skb->data, rxdesc->buffer_length,
+                               DMA_FROM_DEVICE);
                 rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
                 rxdesc->status = cpu_to_edmac(mdp, RD_RACT | RD_RFP);
 
-                /* The size of the buffer is 16 byte boundary. */
-                rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
                 /* Rx descriptor address set */
                 if (i == 0) {
                         sh_eth_write(ndev, mdp->rx_desc_dma, RDLAR);
@@ -1397,6 +1390,7 @@ static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
         struct sk_buff *skb;
         u16 pkt_len = 0;
         u32 desc_status;
+        int skbuff_size = mdp->rx_buf_sz + SH_ETH_RX_ALIGN - 1;
 
         rxdesc = &mdp->rx_ring[entry];
         while (!(rxdesc->status & cpu_to_edmac(mdp, RD_RACT))) {
@@ -1448,7 +1442,7 @@ static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
                         if (mdp->cd->rpadir)
                                 skb_reserve(skb, NET_IP_ALIGN);
                         dma_sync_single_for_cpu(&ndev->dev, rxdesc->addr,
-                                                mdp->rx_buf_sz,
+                                                ALIGN(mdp->rx_buf_sz, 16),
                                                 DMA_FROM_DEVICE);
                         skb_put(skb, pkt_len);
                         skb->protocol = eth_type_trans(skb, ndev);
@@ -1468,13 +1462,13 @@ static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
                 rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
 
                 if (mdp->rx_skbuff[entry] == NULL) {
-                        skb = netdev_alloc_skb(ndev, mdp->rx_buf_sz);
+                        skb = netdev_alloc_skb(ndev, skbuff_size);
                         mdp->rx_skbuff[entry] = skb;
                         if (skb == NULL)
                                 break;  /* Better luck next round. */
-                        dma_map_single(&ndev->dev, skb->data, mdp->rx_buf_sz,
-                                       DMA_FROM_DEVICE);
                         sh_eth_set_receive_align(skb);
+                        dma_map_single(&ndev->dev, skb->data,
+                                       rxdesc->buffer_length, DMA_FROM_DEVICE);
 
                         skb_checksum_none_assert(skb);
                         rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
@@ -2042,6 +2036,8 @@ static int sh_eth_open(struct net_device *ndev)
         if (ret)
                 goto out_free_irq;
 
+        mdp->is_opened = 1;
+
         return ret;
 
 out_free_irq:
@@ -2131,6 +2127,36 @@ static int sh_eth_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         return NETDEV_TX_OK;
 }
 
+static struct net_device_stats *sh_eth_get_stats(struct net_device *ndev)
+{
+        struct sh_eth_private *mdp = netdev_priv(ndev);
+
+        if (sh_eth_is_rz_fast_ether(mdp))
+                return &ndev->stats;
+
+        if (!mdp->is_opened)
+                return &ndev->stats;
+
+        ndev->stats.tx_dropped += sh_eth_read(ndev, TROCR);
+        sh_eth_write(ndev, 0, TROCR);   /* (write clear) */
+        ndev->stats.collisions += sh_eth_read(ndev, CDCR);
+        sh_eth_write(ndev, 0, CDCR);    /* (write clear) */
+        ndev->stats.tx_carrier_errors += sh_eth_read(ndev, LCCR);
+        sh_eth_write(ndev, 0, LCCR);    /* (write clear) */
+
+        if (sh_eth_is_gether(mdp)) {
+                ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CERCR);
+                sh_eth_write(ndev, 0, CERCR);   /* (write clear) */
+                ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CEECR);
+                sh_eth_write(ndev, 0, CEECR);   /* (write clear) */
+        } else {
+                ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CNDCR);
+                sh_eth_write(ndev, 0, CNDCR);   /* (write clear) */
+        }
+
+        return &ndev->stats;
+}
+
 /* device close function */
 static int sh_eth_close(struct net_device *ndev)
 {
@@ -2145,6 +2171,7 @@ static int sh_eth_close(struct net_device *ndev)
         sh_eth_write(ndev, 0, EDTRR);
         sh_eth_write(ndev, 0, EDRRR);
 
+        sh_eth_get_stats(ndev);
         /* PHY Disconnect */
         if (mdp->phydev) {
                 phy_stop(mdp->phydev);
@@ -2163,36 +2190,9 @@ static int sh_eth_close(struct net_device *ndev)
 
         pm_runtime_put_sync(&mdp->pdev->dev);
 
-        return 0;
-}
-
-static struct net_device_stats *sh_eth_get_stats(struct net_device *ndev)
-{
-        struct sh_eth_private *mdp = netdev_priv(ndev);
-
-        if (sh_eth_is_rz_fast_ether(mdp))
-                return &ndev->stats;
+        mdp->is_opened = 0;
 
-        pm_runtime_get_sync(&mdp->pdev->dev);
-
-        ndev->stats.tx_dropped += sh_eth_read(ndev, TROCR);
-        sh_eth_write(ndev, 0, TROCR);   /* (write clear) */
-        ndev->stats.collisions += sh_eth_read(ndev, CDCR);
-        sh_eth_write(ndev, 0, CDCR);    /* (write clear) */
-        ndev->stats.tx_carrier_errors += sh_eth_read(ndev, LCCR);
-        sh_eth_write(ndev, 0, LCCR);    /* (write clear) */
-        if (sh_eth_is_gether(mdp)) {
-                ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CERCR);
-                sh_eth_write(ndev, 0, CERCR);   /* (write clear) */
-                ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CEECR);
-                sh_eth_write(ndev, 0, CEECR);   /* (write clear) */
-        } else {
-                ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CNDCR);
-                sh_eth_write(ndev, 0, CNDCR);   /* (write clear) */
-        }
-        pm_runtime_put_sync(&mdp->pdev->dev);
-
-        return &ndev->stats;
+        return 0;
 }
 
 /* ioctl to device function */
diff --git a/drivers/net/ethernet/renesas/sh_eth.h b/drivers/net/ethernet/renesas/sh_eth.h
index b37c427144ee..22301bf9c21d 100644
--- a/drivers/net/ethernet/renesas/sh_eth.h
+++ b/drivers/net/ethernet/renesas/sh_eth.h
@@ -162,9 +162,9 @@ enum {
 
 /* Driver's parameters */
 #if defined(CONFIG_CPU_SH4) || defined(CONFIG_ARCH_SHMOBILE)
-#define SH4_SKB_RX_ALIGN        32
+#define SH_ETH_RX_ALIGN         32
 #else
-#define SH2_SH3_SKB_RX_ALIGN    2
+#define SH_ETH_RX_ALIGN         2
 #endif
 
 /* Register's bits
@@ -522,6 +522,7 @@ struct sh_eth_private {
 
         unsigned no_ether_link:1;
         unsigned ether_link_active_low:1;
+        unsigned is_opened:1;
 };
 
 static inline void sh_eth_soft_swap(char *src, int len)
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
index db56fa7ce8f9..58a1a0a423d4 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
@@ -177,12 +177,6 @@ static int stmmac_probe_config_dt(struct platform_device *pdev,
          */
         plat->maxmtu = JUMBO_LEN;
 
-        /* Set default value for multicast hash bins */
-        plat->multicast_filter_bins = HASH_TABLE_SIZE;
-
-        /* Set default value for unicast filter entries */
-        plat->unicast_filter_entries = 1;
-
         /*
          * Currently only the properties needed on SPEAr600
          * are provided. All other properties should be added
@@ -270,16 +264,23 @@ static int stmmac_pltfr_probe(struct platform_device *pdev)
                 return PTR_ERR(addr);
 
         plat_dat = dev_get_platdata(&pdev->dev);
-        if (pdev->dev.of_node) {
-                if (!plat_dat)
-                        plat_dat = devm_kzalloc(&pdev->dev,
+
+        if (!plat_dat)
+                plat_dat = devm_kzalloc(&pdev->dev,
                                         sizeof(struct plat_stmmacenet_data),
                                         GFP_KERNEL);
-                if (!plat_dat) {
-                        pr_err("%s: ERROR: no memory", __func__);
-                        return  -ENOMEM;
-                }
+        if (!plat_dat) {
+                pr_err("%s: ERROR: no memory", __func__);
+                return  -ENOMEM;
+        }
+
+        /* Set default value for multicast hash bins */
+        plat_dat->multicast_filter_bins = HASH_TABLE_SIZE;
 
+        /* Set default value for unicast filter entries */
+        plat_dat->unicast_filter_entries = 1;
+
+        if (pdev->dev.of_node) {
                 ret = stmmac_probe_config_dt(pdev, plat_dat, &mac);
                 if (ret) {
                         pr_err("%s: main dt probe failed", __func__);
diff --git a/drivers/net/macvtap.c b/drivers/net/macvtap.c
index 880cc090dc44..af90ab5e5768 100644
--- a/drivers/net/macvtap.c
+++ b/drivers/net/macvtap.c
@@ -45,6 +45,18 @@ struct macvtap_queue {
         struct list_head next;
 };
 
+#define MACVTAP_FEATURES (IFF_VNET_HDR | IFF_VNET_LE | IFF_MULTI_QUEUE)
+
+static inline u16 macvtap16_to_cpu(struct macvtap_queue *q, __virtio16 val)
+{
+        return __virtio16_to_cpu(q->flags & IFF_VNET_LE, val);
+}
+
+static inline __virtio16 cpu_to_macvtap16(struct macvtap_queue *q, u16 val)
+{
+        return __cpu_to_virtio16(q->flags & IFF_VNET_LE, val);
+}
+
 static struct proto macvtap_proto = {
         .name = "macvtap",
         .owner = THIS_MODULE,
@@ -557,7 +569,8 @@ static inline struct sk_buff *macvtap_alloc_skb(struct sock *sk, size_t prepad,
  * macvtap_skb_from_vnet_hdr and macvtap_skb_to_vnet_hdr should
  * be shared with the tun/tap driver.
  */
-static int macvtap_skb_from_vnet_hdr(struct sk_buff *skb,
+static int macvtap_skb_from_vnet_hdr(struct macvtap_queue *q,
+                                     struct sk_buff *skb,
                                      struct virtio_net_hdr *vnet_hdr)
 {
         unsigned short gso_type = 0;
@@ -588,13 +601,13 @@ static int macvtap_skb_from_vnet_hdr(struct sk_buff *skb,
         }
 
         if (vnet_hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
-                if (!skb_partial_csum_set(skb, vnet_hdr->csum_start,
-                                          vnet_hdr->csum_offset))
+                if (!skb_partial_csum_set(skb, macvtap16_to_cpu(q, vnet_hdr->csum_start),
+                                          macvtap16_to_cpu(q, vnet_hdr->csum_offset)))
                         return -EINVAL;
         }
 
         if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
-                skb_shinfo(skb)->gso_size = vnet_hdr->gso_size;
+                skb_shinfo(skb)->gso_size = macvtap16_to_cpu(q, vnet_hdr->gso_size);
                 skb_shinfo(skb)->gso_type = gso_type;
 
                 /* Header must be checked, and gso_segs computed. */
@@ -604,8 +617,9 @@ static int macvtap_skb_from_vnet_hdr(struct sk_buff *skb,
         return 0;
 }
 
-static void macvtap_skb_to_vnet_hdr(const struct sk_buff *skb,
-                                   struct virtio_net_hdr *vnet_hdr)
+static void macvtap_skb_to_vnet_hdr(struct macvtap_queue *q,
+                                    const struct sk_buff *skb,
+                                    struct virtio_net_hdr *vnet_hdr)
 {
         memset(vnet_hdr, 0, sizeof(*vnet_hdr));
 
@@ -613,8 +627,8 @@ static void macvtap_skb_to_vnet_hdr(const struct sk_buff *skb,
                 struct skb_shared_info *sinfo = skb_shinfo(skb);
 
                 /* This is a hint as to how much should be linear. */
-                vnet_hdr->hdr_len = skb_headlen(skb);
-                vnet_hdr->gso_size = sinfo->gso_size;
+                vnet_hdr->hdr_len = cpu_to_macvtap16(q, skb_headlen(skb));
+                vnet_hdr->gso_size = cpu_to_macvtap16(q, sinfo->gso_size);
                 if (sinfo->gso_type & SKB_GSO_TCPV4)
                         vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
                 else if (sinfo->gso_type & SKB_GSO_TCPV6)
@@ -628,10 +642,13 @@ static void macvtap_skb_to_vnet_hdr(const struct sk_buff *skb,
 
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 vnet_hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
-                vnet_hdr->csum_start = skb_checksum_start_offset(skb);
                 if (vlan_tx_tag_present(skb))
-                        vnet_hdr->csum_start += VLAN_HLEN;
-                vnet_hdr->csum_offset = skb->csum_offset;
+                        vnet_hdr->csum_start = cpu_to_macvtap16(q,
+                                skb_checksum_start_offset(skb) + VLAN_HLEN);
+                else
+                        vnet_hdr->csum_start = cpu_to_macvtap16(q,
+                                skb_checksum_start_offset(skb));
+                vnet_hdr->csum_offset = cpu_to_macvtap16(q, skb->csum_offset);
         } else if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
                 vnet_hdr->flags = VIRTIO_NET_HDR_F_DATA_VALID;
         } /* else everything is zero */
@@ -666,12 +683,14 @@ static ssize_t macvtap_get_user(struct macvtap_queue *q, struct msghdr *m,
                 if (err < 0)
                         goto err;
                 if ((vnet_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
-                     vnet_hdr.csum_start + vnet_hdr.csum_offset + 2 >
-                                                        vnet_hdr.hdr_len)
-                        vnet_hdr.hdr_len = vnet_hdr.csum_start +
-                                                vnet_hdr.csum_offset + 2;
+                     macvtap16_to_cpu(q, vnet_hdr.csum_start) +
+                     macvtap16_to_cpu(q, vnet_hdr.csum_offset) + 2 >
+                             macvtap16_to_cpu(q, vnet_hdr.hdr_len))
+                        vnet_hdr.hdr_len = cpu_to_macvtap16(q,
+                                 macvtap16_to_cpu(q, vnet_hdr.csum_start) +
+                                 macvtap16_to_cpu(q, vnet_hdr.csum_offset) + 2);
                 err = -EINVAL;
-                if (vnet_hdr.hdr_len > len)
+                if (macvtap16_to_cpu(q, vnet_hdr.hdr_len) > len)
                         goto err;
         }
 
@@ -684,7 +703,8 @@ static ssize_t macvtap_get_user(struct macvtap_queue *q, struct msghdr *m,
                 goto err;
 
         if (m && m->msg_control && sock_flag(&q->sk, SOCK_ZEROCOPY)) {
-                copylen = vnet_hdr.hdr_len ? vnet_hdr.hdr_len : GOODCOPY_LEN;
+                copylen = vnet_hdr.hdr_len ?
+                        macvtap16_to_cpu(q, vnet_hdr.hdr_len) : GOODCOPY_LEN;
                 if (copylen > good_linear)
                         copylen = good_linear;
                 linear = copylen;
@@ -695,10 +715,10 @@ static ssize_t macvtap_get_user(struct macvtap_queue *q, struct msghdr *m,
 
         if (!zerocopy) {
                 copylen = len;
-                if (vnet_hdr.hdr_len > good_linear)
+                if (macvtap16_to_cpu(q, vnet_hdr.hdr_len) > good_linear)
                         linear = good_linear;
                 else
-                        linear = vnet_hdr.hdr_len;
+                        linear = macvtap16_to_cpu(q, vnet_hdr.hdr_len);
         }
 
         skb = macvtap_alloc_skb(&q->sk, NET_IP_ALIGN, copylen,
@@ -725,7 +745,7 @@ static ssize_t macvtap_get_user(struct macvtap_queue *q, struct msghdr *m,
         skb->protocol = eth_hdr(skb)->h_proto;
 
         if (vnet_hdr_len) {
-                err = macvtap_skb_from_vnet_hdr(skb, &vnet_hdr);
+                err = macvtap_skb_from_vnet_hdr(q, skb, &vnet_hdr);
                 if (err)
                         goto err_kfree;
         }
@@ -791,7 +811,7 @@ static ssize_t macvtap_put_user(struct macvtap_queue *q,
                 if ((len -= vnet_hdr_len) < 0)
                         return -EINVAL;
 
-                macvtap_skb_to_vnet_hdr(skb, &vnet_hdr);
+                macvtap_skb_to_vnet_hdr(q, skb, &vnet_hdr);
 
                 if (memcpy_toiovecend(iv, (void *)&vnet_hdr, 0, sizeof(vnet_hdr)))
                         return -EFAULT;
@@ -1003,8 +1023,7 @@ static long macvtap_ioctl(struct file *file, unsigned int cmd,
                         return -EFAULT;
 
                 ret = 0;
-                if ((u & ~(IFF_VNET_HDR | IFF_MULTI_QUEUE)) !=
-                    (IFF_NO_PI | IFF_TAP))
+                if ((u & ~MACVTAP_FEATURES) != (IFF_NO_PI | IFF_TAP))
                         ret = -EINVAL;
                 else
                         q->flags = u;
@@ -1036,8 +1055,7 @@ static long macvtap_ioctl(struct file *file, unsigned int cmd,
                 return ret;
 
         case TUNGETFEATURES:
-                if (put_user(IFF_TAP | IFF_NO_PI | IFF_VNET_HDR |
-                             IFF_MULTI_QUEUE, up))
+                if (put_user(IFF_TAP | IFF_NO_PI | MACVTAP_FEATURES, up))
                         return -EFAULT;
                 return 0;
 
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 9dd3746994a4..798ce70e3d61 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -103,6 +103,15 @@ do {								\
 } while (0)
 #endif
 
+/* TUN device flags */
+
+/* IFF_ATTACH_QUEUE is never stored in device flags,
+ * overload it to mean fasync when stored there.
+ */
+#define TUN_FASYNC      IFF_ATTACH_QUEUE
+
+#define TUN_FEATURES (IFF_NO_PI | IFF_ONE_QUEUE | IFF_VNET_HDR | \
+                      IFF_VNET_LE | IFF_MULTI_QUEUE)
 #define GOODCOPY_LEN 128
 
 #define FLT_EXACT_COUNT 8
@@ -196,6 +205,16 @@ struct tun_struct {
         u32 flow_count;
 };
 
+static inline u16 tun16_to_cpu(struct tun_struct *tun, __virtio16 val)
+{
+        return __virtio16_to_cpu(tun->flags & IFF_VNET_LE, val);
+}
+
+static inline __virtio16 cpu_to_tun16(struct tun_struct *tun, u16 val)
+{
+        return __cpu_to_virtio16(tun->flags & IFF_VNET_LE, val);
+}
+
 static inline u32 tun_hashfn(u32 rxhash)
 {
         return rxhash & 0x3ff;
@@ -472,7 +491,7 @@ static void __tun_detach(struct tun_file *tfile, bool clean)
                 if (tun && tun->numqueues == 0 && tun->numdisabled == 0) {
                         netif_carrier_off(tun->dev);
 
-                        if (!(tun->flags & TUN_PERSIST) &&
+                        if (!(tun->flags & IFF_PERSIST) &&
                             tun->dev->reg_state == NETREG_REGISTERED)
                                 unregister_netdevice(tun->dev);
                 }
@@ -523,7 +542,7 @@ static void tun_detach_all(struct net_device *dev)
         }
         BUG_ON(tun->numdisabled != 0);
 
-        if (tun->flags & TUN_PERSIST)
+        if (tun->flags & IFF_PERSIST)
                 module_put(THIS_MODULE);
 }
 
@@ -541,7 +560,7 @@ static int tun_attach(struct tun_struct *tun, struct file *file, bool skip_filte
                 goto out;
 
         err = -EBUSY;
-        if (!(tun->flags & TUN_TAP_MQ) && tun->numqueues == 1)
+        if (!(tun->flags & IFF_MULTI_QUEUE) && tun->numqueues == 1)
                 goto out;
 
         err = -E2BIG;
@@ -920,7 +939,7 @@ static void tun_net_init(struct net_device *dev)
         struct tun_struct *tun = netdev_priv(dev);
 
         switch (tun->flags & TUN_TYPE_MASK) {
-        case TUN_TUN_DEV:
+        case IFF_TUN:
                 dev->netdev_ops = &tun_netdev_ops;
 
                 /* Point-to-Point TUN Device */
@@ -934,7 +953,7 @@ static void tun_net_init(struct net_device *dev)
                 dev->tx_queue_len = TUN_READQ_SIZE;  /* We prefer our own queue length */
                 break;
 
-        case TUN_TAP_DEV:
+        case IFF_TAP:
                 dev->netdev_ops = &tap_netdev_ops;
                 /* Ethernet TAP Device */
                 ether_setup(dev);
@@ -1025,7 +1044,7 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
         int err;
         u32 rxhash;
 
-        if (!(tun->flags & TUN_NO_PI)) {
+        if (!(tun->flags & IFF_NO_PI)) {
                 if (len < sizeof(pi))
                         return -EINVAL;
                 len -= sizeof(pi);
@@ -1035,7 +1054,7 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
                 offset += sizeof(pi);
         }
 
-        if (tun->flags & TUN_VNET_HDR) {
+        if (tun->flags & IFF_VNET_HDR) {
                 if (len < tun->vnet_hdr_sz)
                         return -EINVAL;
                 len -= tun->vnet_hdr_sz;
@@ -1044,18 +1063,18 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
                         return -EFAULT;
 
                 if ((gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
-                    gso.csum_start + gso.csum_offset + 2 > gso.hdr_len)
-                        gso.hdr_len = gso.csum_start + gso.csum_offset + 2;
+                    tun16_to_cpu(tun, gso.csum_start) + tun16_to_cpu(tun, gso.csum_offset) + 2 > tun16_to_cpu(tun, gso.hdr_len))
+                        gso.hdr_len = cpu_to_tun16(tun, tun16_to_cpu(tun, gso.csum_start) + tun16_to_cpu(tun, gso.csum_offset) + 2);
 
-                if (gso.hdr_len > len)
+                if (tun16_to_cpu(tun, gso.hdr_len) > len)
                         return -EINVAL;
                 offset += tun->vnet_hdr_sz;
         }
 
-        if ((tun->flags & TUN_TYPE_MASK) == TUN_TAP_DEV) {
+        if ((tun->flags & TUN_TYPE_MASK) == IFF_TAP) {
                 align += NET_IP_ALIGN;
                 if (unlikely(len < ETH_HLEN ||
-                             (gso.hdr_len && gso.hdr_len < ETH_HLEN)))
+                             (gso.hdr_len && tun16_to_cpu(tun, gso.hdr_len) < ETH_HLEN)))
                         return -EINVAL;
         }
 
@@ -1066,7 +1085,7 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
                  * enough room for skb expand head in case it is used.
                  * The rest of the buffer is mapped from userspace.
                  */
-                copylen = gso.hdr_len ? gso.hdr_len : GOODCOPY_LEN;
+                copylen = gso.hdr_len ? tun16_to_cpu(tun, gso.hdr_len) : GOODCOPY_LEN;
                 if (copylen > good_linear)
                         copylen = good_linear;
                 linear = copylen;
@@ -1076,10 +1095,10 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
 
         if (!zerocopy) {
                 copylen = len;
-                if (gso.hdr_len > good_linear)
+                if (tun16_to_cpu(tun, gso.hdr_len) > good_linear)
                         linear = good_linear;
                 else
-                        linear = gso.hdr_len;
+                        linear = tun16_to_cpu(tun, gso.hdr_len);
         }
 
         skb = tun_alloc_skb(tfile, align, copylen, linear, noblock);
@@ -1106,8 +1125,8 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
         }
 
         if (gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
-                if (!skb_partial_csum_set(skb, gso.csum_start,
-                                          gso.csum_offset)) {
+                if (!skb_partial_csum_set(skb, tun16_to_cpu(tun, gso.csum_start),
+                                          tun16_to_cpu(tun, gso.csum_offset))) {
                         tun->dev->stats.rx_frame_errors++;
                         kfree_skb(skb);
                         return -EINVAL;
@@ -1115,8 +1134,8 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
         }
 
         switch (tun->flags & TUN_TYPE_MASK) {
-        case TUN_TUN_DEV:
-                if (tun->flags & TUN_NO_PI) {
+        case IFF_TUN:
+                if (tun->flags & IFF_NO_PI) {
                         switch (skb->data[0] & 0xf0) {
                         case 0x40:
                                 pi.proto = htons(ETH_P_IP);
@@ -1135,7 +1154,7 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
                 skb->protocol = pi.proto;
                 skb->dev = tun->dev;
                 break;
-        case TUN_TAP_DEV:
+        case IFF_TAP:
                 skb->protocol = eth_type_trans(skb, tun->dev);
                 break;
         }
@@ -1175,7 +1194,7 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
                 if (gso.gso_type & VIRTIO_NET_HDR_GSO_ECN)
                         skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
 
-                skb_shinfo(skb)->gso_size = gso.gso_size;
+                skb_shinfo(skb)->gso_size = tun16_to_cpu(tun, gso.gso_size);
                 if (skb_shinfo(skb)->gso_size == 0) {
                         tun->dev->stats.rx_frame_errors++;
                         kfree_skb(skb);
@@ -1241,10 +1260,10 @@ static ssize_t tun_put_user(struct tun_struct *tun,
         if (vlan_tx_tag_present(skb))
                 vlan_hlen = VLAN_HLEN;
 
-        if (tun->flags & TUN_VNET_HDR)
+        if (tun->flags & IFF_VNET_HDR)
                 vnet_hdr_sz = tun->vnet_hdr_sz;
 
-        if (!(tun->flags & TUN_NO_PI)) {
+        if (!(tun->flags & IFF_NO_PI)) {
                 if ((len -= sizeof(pi)) < 0)
                         return -EINVAL;
 
@@ -1267,8 +1286,8 @@ static ssize_t tun_put_user(struct tun_struct *tun,
                         struct skb_shared_info *sinfo = skb_shinfo(skb);
 
                         /* This is a hint as to how much should be linear. */
-                        gso.hdr_len = skb_headlen(skb);
-                        gso.gso_size = sinfo->gso_size;
+                        gso.hdr_len = cpu_to_tun16(tun, skb_headlen(skb));
+                        gso.gso_size = cpu_to_tun16(tun, sinfo->gso_size);
                         if (sinfo->gso_type & SKB_GSO_TCPV4)
                                 gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
                         else if (sinfo->gso_type & SKB_GSO_TCPV6)
@@ -1276,12 +1295,12 @@ static ssize_t tun_put_user(struct tun_struct *tun,
                         else {
                                 pr_err("unexpected GSO type: "
                                        "0x%x, gso_size %d, hdr_len %d\n",
-                                       sinfo->gso_type, gso.gso_size,
-                                       gso.hdr_len);
+                                       sinfo->gso_type, tun16_to_cpu(tun, gso.gso_size),
+                                       tun16_to_cpu(tun, gso.hdr_len));
                                 print_hex_dump(KERN_ERR, "tun: ",
                                                DUMP_PREFIX_NONE,
                                                16, 1, skb->head,
-                                               min((int)gso.hdr_len, 64), true);
+                                               min((int)tun16_to_cpu(tun, gso.hdr_len), 64), true);
                                 WARN_ON_ONCE(1);
                                 return -EINVAL;
                         }
@@ -1292,9 +1311,9 @@ static ssize_t tun_put_user(struct tun_struct *tun,
 
                 if (skb->ip_summed == CHECKSUM_PARTIAL) {
                         gso.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
-                        gso.csum_start = skb_checksum_start_offset(skb) +
-                                         vlan_hlen;
-                        gso.csum_offset = skb->csum_offset;
+                        gso.csum_start = cpu_to_tun16(tun, skb_checksum_start_offset(skb) +
+                                                      vlan_hlen);
+                        gso.csum_offset = cpu_to_tun16(tun, skb->csum_offset);
                 } else if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
                         gso.flags = VIRTIO_NET_HDR_F_DATA_VALID;
                 } /* else everything is zero */
@@ -1521,32 +1540,7 @@ static struct proto tun_proto = {
 
 static int tun_flags(struct tun_struct *tun)
 {
-        int flags = 0;
-
-        if (tun->flags & TUN_TUN_DEV)
-                flags |= IFF_TUN;
-        else
-                flags |= IFF_TAP;
-
-        if (tun->flags & TUN_NO_PI)
-                flags |= IFF_NO_PI;
-
-        /* This flag has no real effect.  We track the value for backwards
-         * compatibility.
-         */
-        if (tun->flags & TUN_ONE_QUEUE)
-                flags |= IFF_ONE_QUEUE;
-
-        if (tun->flags & TUN_VNET_HDR)
-                flags |= IFF_VNET_HDR;
-
-        if (tun->flags & TUN_TAP_MQ)
-                flags |= IFF_MULTI_QUEUE;
-
-        if (tun->flags & TUN_PERSIST)
-                flags |= IFF_PERSIST;
-
-        return flags;
+        return tun->flags & (TUN_FEATURES | IFF_PERSIST | IFF_TUN | IFF_TAP);
 }
 
 static ssize_t tun_show_flags(struct device *dev, struct device_attribute *attr,
@@ -1602,7 +1596,7 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
                         return -EINVAL;
 
                 if (!!(ifr->ifr_flags & IFF_MULTI_QUEUE) !=
-                    !!(tun->flags & TUN_TAP_MQ))
+                    !!(tun->flags & IFF_MULTI_QUEUE))
                         return -EINVAL;
 
                 if (tun_not_capable(tun))
@@ -1615,7 +1609,7 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
                 if (err < 0)
                         return err;
 
-                if (tun->flags & TUN_TAP_MQ &&
+                if (tun->flags & IFF_MULTI_QUEUE &&
                     (tun->numqueues + tun->numdisabled > 1)) {
                         /* One or more queue has already been attached, no need
                          * to initialize the device again.
@@ -1638,11 +1632,11 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
                 /* Set dev type */
                 if (ifr->ifr_flags & IFF_TUN) {
                         /* TUN device */
-                        flags |= TUN_TUN_DEV;
+                        flags |= IFF_TUN;
                         name = "tun%d";
                 } else if (ifr->ifr_flags & IFF_TAP) {
                         /* TAP device */
-                        flags |= TUN_TAP_DEV;
+                        flags |= IFF_TAP;
                         name = "tap%d";
                 } else
                         return -EINVAL;
@@ -1706,28 +1700,8 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
 
         tun_debug(KERN_INFO, tun, "tun_set_iff\n");
 
-        if (ifr->ifr_flags & IFF_NO_PI)
-                tun->flags |= TUN_NO_PI;
-        else
-                tun->flags &= ~TUN_NO_PI;
-
-        /* This flag has no real effect.  We track the value for backwards
-         * compatibility.
-         */
-        if (ifr->ifr_flags & IFF_ONE_QUEUE)
-                tun->flags |= TUN_ONE_QUEUE;
-        else
-                tun->flags &= ~TUN_ONE_QUEUE;
-
-        if (ifr->ifr_flags & IFF_VNET_HDR)
-                tun->flags |= TUN_VNET_HDR;
-        else
-                tun->flags &= ~TUN_VNET_HDR;
-
-        if (ifr->ifr_flags & IFF_MULTI_QUEUE)
-                tun->flags |= TUN_TAP_MQ;
-        else
-                tun->flags &= ~TUN_TAP_MQ;
+        tun->flags = (tun->flags & ~TUN_FEATURES) |
+                (ifr->ifr_flags & TUN_FEATURES);
 
         /* Make sure persistent devices do not get stuck in
          * xoff state.
@@ -1855,7 +1829,7 @@ static int tun_set_queue(struct file *file, struct ifreq *ifr)
                 ret = tun_attach(tun, file, false);
         } else if (ifr->ifr_flags & IFF_DETACH_QUEUE) {
                 tun = rtnl_dereference(tfile->tun);
-                if (!tun || !(tun->flags & TUN_TAP_MQ) || tfile->detached)
+                if (!tun || !(tun->flags & IFF_MULTI_QUEUE) || tfile->detached)
                         ret = -EINVAL;
                 else
                         __tun_detach(tfile, false);
@@ -1890,9 +1864,9 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
         if (cmd == TUNGETFEATURES) {
                 /* Currently this just means: "what IFF flags are valid?".
                  * This is needed because we never checked for invalid flags on
-                 * TUNSETIFF. */
-                return put_user(IFF_TUN | IFF_TAP | IFF_NO_PI | IFF_ONE_QUEUE |
-                                IFF_VNET_HDR | IFF_MULTI_QUEUE,
+                 * TUNSETIFF.
+                 */
+                return put_user(IFF_TUN | IFF_TAP | TUN_FEATURES,
                                 (unsigned int __user*)argp);
         } else if (cmd == TUNSETQUEUE)
                 return tun_set_queue(file, &ifr);
@@ -1959,12 +1933,12 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
                 /* Disable/Enable persist mode. Keep an extra reference to the
                  * module to prevent the module being unprobed.
                  */
-                if (arg && !(tun->flags & TUN_PERSIST)) {
-                        tun->flags |= TUN_PERSIST;
+                if (arg && !(tun->flags & IFF_PERSIST)) {
+                        tun->flags |= IFF_PERSIST;
                         __module_get(THIS_MODULE);
                 }
-                if (!arg && (tun->flags & TUN_PERSIST)) {
-                        tun->flags &= ~TUN_PERSIST;
+                if (!arg && (tun->flags & IFF_PERSIST)) {
+                        tun->flags &= ~IFF_PERSIST;
                         module_put(THIS_MODULE);
                 }
 
@@ -2022,7 +1996,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
         case TUNSETTXFILTER:
                 /* Can be set only for TAPs */
                 ret = -EINVAL;
-                if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV)
+                if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
                         break;
                 ret = update_filter(&tun->txflt, (void __user *)arg);
                 break;
@@ -2081,7 +2055,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
         case TUNATTACHFILTER:
                 /* Can be set only for TAPs */
                 ret = -EINVAL;
-                if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV)
+                if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
                         break;
                 ret = -EFAULT;
                 if (copy_from_user(&tun->fprog, argp, sizeof(tun->fprog)))
@@ -2093,7 +2067,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
         case TUNDETACHFILTER:
                 /* Can be set only for TAPs */
                 ret = -EINVAL;
-                if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV)
+                if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
                         break;
                 ret = 0;
                 tun_detach_filter(tun, tun->numqueues);
@@ -2101,7 +2075,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
 
         case TUNGETFILTER:
                 ret = -EINVAL;
-                if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV)
+                if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
                         break;
                 ret = -EFAULT;
                 if (copy_to_user(argp, &tun->fprog, sizeof(tun->fprog)))
@@ -2222,7 +2196,7 @@ static int tun_chr_close(struct inode *inode, struct file *file)
 }
 
 #ifdef CONFIG_PROC_FS
-static int tun_chr_show_fdinfo(struct seq_file *m, struct file *f)
+static void tun_chr_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct tun_struct *tun;
         struct ifreq ifr;
@@ -2238,7 +2212,7 @@ static int tun_chr_show_fdinfo(struct seq_file *m, struct file *f)
         if (tun)
                 tun_put(tun);
 
-        return seq_printf(m, "iff:\t%s\n", ifr.ifr_name);
+        seq_printf(m, "iff:\t%s\n", ifr.ifr_name);
 }
 #endif
 
@@ -2294,10 +2268,10 @@ static void tun_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info
         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 
         switch (tun->flags & TUN_TYPE_MASK) {
-        case TUN_TUN_DEV:
+        case IFF_TUN:
                 strlcpy(info->bus_info, "tun", sizeof(info->bus_info));
                 break;
-        case TUN_TAP_DEV:
+        case IFF_TAP:
                 strlcpy(info->bus_info, "tap", sizeof(info->bus_info));
                 break;
         }
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index b0bc8ead47de..b8bd7191572d 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -123,6 +123,9 @@ struct virtnet_info {
         /* Host can handle any s/g split between our header and packet data */
         bool any_header_sg;
 
+        /* Packet virtio header size */
+        u8 hdr_len;
+
         /* Active statistics */
         struct virtnet_stats __percpu *stats;
 
@@ -139,21 +142,14 @@ struct virtnet_info {
         struct notifier_block nb;
 };
 
-struct skb_vnet_hdr {
-        union {
-                struct virtio_net_hdr hdr;
-                struct virtio_net_hdr_mrg_rxbuf mhdr;
-        };
-};
-
 struct padded_vnet_hdr {
-        struct virtio_net_hdr hdr;
+        struct virtio_net_hdr_mrg_rxbuf hdr;
         /*
-         * virtio_net_hdr should be in a separated sg buffer because of a
-         * QEMU bug, and data sg buffer shares same page with this header sg.
-         * This padding makes next sg 16 byte aligned after virtio_net_hdr.
+         * hdr is in a separate sg buffer, and data sg buffer shares same page
+         * with this header sg. This padding makes next sg 16 byte aligned
+         * after the header.
          */
-        char padding[6];
+        char padding[4];
 };
 
 /* Converting between virtqueue no. and kernel tx/rx queue no.
@@ -179,9 +175,9 @@ static int rxq2vq(int rxq)
         return rxq * 2;
 }
 
-static inline struct skb_vnet_hdr *skb_vnet_hdr(struct sk_buff *skb)
+static inline struct virtio_net_hdr_mrg_rxbuf *skb_vnet_hdr(struct sk_buff *skb)
 {
-        return (struct skb_vnet_hdr *)skb->cb;
+        return (struct virtio_net_hdr_mrg_rxbuf *)skb->cb;
 }
 
 /*
@@ -241,13 +237,13 @@ static unsigned long mergeable_buf_to_ctx(void *buf, unsigned int truesize)
 }
 
 /* Called from bottom half context */
-static struct sk_buff *page_to_skb(struct receive_queue *rq,
+static struct sk_buff *page_to_skb(struct virtnet_info *vi,
+                                   struct receive_queue *rq,
                                    struct page *page, unsigned int offset,
                                    unsigned int len, unsigned int truesize)
 {
-        struct virtnet_info *vi = rq->vq->vdev->priv;
         struct sk_buff *skb;
-        struct skb_vnet_hdr *hdr;
+        struct virtio_net_hdr_mrg_rxbuf *hdr;
         unsigned int copy, hdr_len, hdr_padded_len;
         char *p;
 
@@ -260,13 +256,11 @@ static struct sk_buff *page_to_skb(struct receive_queue *rq,
 
         hdr = skb_vnet_hdr(skb);
 
-        if (vi->mergeable_rx_bufs) {
-                hdr_len = sizeof hdr->mhdr;
-                hdr_padded_len = sizeof hdr->mhdr;
-        } else {
-                hdr_len = sizeof hdr->hdr;
+        hdr_len = vi->hdr_len;
+        if (vi->mergeable_rx_bufs)
+                hdr_padded_len = sizeof *hdr;
+        else
                 hdr_padded_len = sizeof(struct padded_vnet_hdr);
-        }
 
         memcpy(hdr, p, hdr_len);
 
@@ -317,23 +311,24 @@ static struct sk_buff *page_to_skb(struct receive_queue *rq,
         return skb;
 }
 
-static struct sk_buff *receive_small(void *buf, unsigned int len)
+static struct sk_buff *receive_small(struct virtnet_info *vi, void *buf, unsigned int len)
 {
         struct sk_buff * skb = buf;
 
-        len -= sizeof(struct virtio_net_hdr);
+        len -= vi->hdr_len;
         skb_trim(skb, len);
 
         return skb;
 }
 
 static struct sk_buff *receive_big(struct net_device *dev,
+                                   struct virtnet_info *vi,
                                    struct receive_queue *rq,
                                    void *buf,
                                    unsigned int len)
 {
         struct page *page = buf;
-        struct sk_buff *skb = page_to_skb(rq, page, 0, len, PAGE_SIZE);
+        struct sk_buff *skb = page_to_skb(vi, rq, page, 0, len, PAGE_SIZE);
 
         if (unlikely(!skb))
                 goto err;
@@ -347,18 +342,20 @@ err:
 }
 
 static struct sk_buff *receive_mergeable(struct net_device *dev,
+                                         struct virtnet_info *vi,
                                          struct receive_queue *rq,
                                          unsigned long ctx,
                                          unsigned int len)
 {
         void *buf = mergeable_ctx_to_buf_address(ctx);
-        struct skb_vnet_hdr *hdr = buf;
-        int num_buf = hdr->mhdr.num_buffers;
+        struct virtio_net_hdr_mrg_rxbuf *hdr = buf;
+        u16 num_buf = virtio16_to_cpu(vi->vdev, hdr->num_buffers);
         struct page *page = virt_to_head_page(buf);
         int offset = buf - page_address(page);
         unsigned int truesize = max(len, mergeable_ctx_to_buf_truesize(ctx));
 
-        struct sk_buff *head_skb = page_to_skb(rq, page, offset, len, truesize);
+        struct sk_buff *head_skb = page_to_skb(vi, rq, page, offset, len,
+                                               truesize);
         struct sk_buff *curr_skb = head_skb;
 
         if (unlikely(!curr_skb))
@@ -369,7 +366,9 @@ static struct sk_buff *receive_mergeable(struct net_device *dev,
                 ctx = (unsigned long)virtqueue_get_buf(rq->vq, &len);
                 if (unlikely(!ctx)) {
                         pr_debug("%s: rx error: %d buffers out of %d missing\n",
-                                 dev->name, num_buf, hdr->mhdr.num_buffers);
+                                 dev->name, num_buf,
+                                 virtio16_to_cpu(vi->vdev,
+                                                 hdr->num_buffers));
                         dev->stats.rx_length_errors++;
                         goto err_buf;
                 }
@@ -430,15 +429,15 @@ err_buf:
         return NULL;
 }
 
-static void receive_buf(struct receive_queue *rq, void *buf, unsigned int len)
+static void receive_buf(struct virtnet_info *vi, struct receive_queue *rq,
+                        void *buf, unsigned int len)
 {
-        struct virtnet_info *vi = rq->vq->vdev->priv;
         struct net_device *dev = vi->dev;
         struct virtnet_stats *stats = this_cpu_ptr(vi->stats);
         struct sk_buff *skb;
-        struct skb_vnet_hdr *hdr;
+        struct virtio_net_hdr_mrg_rxbuf *hdr;
 
-        if (unlikely(len < sizeof(struct virtio_net_hdr) + ETH_HLEN)) {
+        if (unlikely(len < vi->hdr_len + ETH_HLEN)) {
                 pr_debug("%s: short packet %i\n", dev->name, len);
                 dev->stats.rx_length_errors++;
                 if (vi->mergeable_rx_bufs) {
@@ -454,11 +453,11 @@ static void receive_buf(struct receive_queue *rq, void *buf, unsigned int len)
         }
 
         if (vi->mergeable_rx_bufs)
-                skb = receive_mergeable(dev, rq, (unsigned long)buf, len);
+                skb = receive_mergeable(dev, vi, rq, (unsigned long)buf, len);
         else if (vi->big_packets)
-                skb = receive_big(dev, rq, buf, len);
+                skb = receive_big(dev, vi, rq, buf, len);
         else
-                skb = receive_small(buf, len);
+                skb = receive_small(vi, buf, len);
 
         if (unlikely(!skb))
                 return;
@@ -473,8 +472,8 @@ static void receive_buf(struct receive_queue *rq, void *buf, unsigned int len)
         if (hdr->hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
                 pr_debug("Needs csum!\n");
                 if (!skb_partial_csum_set(skb,
-                                          hdr->hdr.csum_start,
-                                          hdr->hdr.csum_offset))
+                          virtio16_to_cpu(vi->vdev, hdr->hdr.csum_start),
+                          virtio16_to_cpu(vi->vdev, hdr->hdr.csum_offset)))
                         goto frame_err;
         } else if (hdr->hdr.flags & VIRTIO_NET_HDR_F_DATA_VALID) {
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
@@ -514,7 +513,8 @@ static void receive_buf(struct receive_queue *rq, void *buf, unsigned int len)
                 if (hdr->hdr.gso_type & VIRTIO_NET_HDR_GSO_ECN)
                         skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
 
-                skb_shinfo(skb)->gso_size = hdr->hdr.gso_size;
+                skb_shinfo(skb)->gso_size = virtio16_to_cpu(vi->vdev,
+                                                            hdr->hdr.gso_size);
                 if (skb_shinfo(skb)->gso_size == 0) {
                         net_warn_ratelimited("%s: zero gso size.\n", dev->name);
                         goto frame_err;
@@ -535,11 +535,11 @@ frame_err:
         dev_kfree_skb(skb);
 }
 
-static int add_recvbuf_small(struct receive_queue *rq, gfp_t gfp)
+static int add_recvbuf_small(struct virtnet_info *vi, struct receive_queue *rq,
+                             gfp_t gfp)
 {
-        struct virtnet_info *vi = rq->vq->vdev->priv;
         struct sk_buff *skb;
-        struct skb_vnet_hdr *hdr;
+        struct virtio_net_hdr_mrg_rxbuf *hdr;
         int err;
 
         skb = __netdev_alloc_skb_ip_align(vi->dev, GOOD_PACKET_LEN, gfp);
@@ -550,7 +550,7 @@ static int add_recvbuf_small(struct receive_queue *rq, gfp_t gfp)
 
         hdr = skb_vnet_hdr(skb);
         sg_init_table(rq->sg, MAX_SKB_FRAGS + 2);
-        sg_set_buf(rq->sg, &hdr->hdr, sizeof hdr->hdr);
+        sg_set_buf(rq->sg, hdr, vi->hdr_len);
         skb_to_sgvec(skb, rq->sg + 1, 0, skb->len);
 
         err = virtqueue_add_inbuf(rq->vq, rq->sg, 2, skb, gfp);
@@ -560,7 +560,8 @@ static int add_recvbuf_small(struct receive_queue *rq, gfp_t gfp)
         return err;
 }
 
-static int add_recvbuf_big(struct receive_queue *rq, gfp_t gfp)
+static int add_recvbuf_big(struct virtnet_info *vi, struct receive_queue *rq,
+                           gfp_t gfp)
 {
         struct page *first, *list = NULL;
         char *p;
@@ -591,8 +592,8 @@ static int add_recvbuf_big(struct receive_queue *rq, gfp_t gfp)
         p = page_address(first);
 
         /* rq->sg[0], rq->sg[1] share the same page */
-        /* a separated rq->sg[0] for virtio_net_hdr only due to QEMU bug */
-        sg_set_buf(&rq->sg[0], p, sizeof(struct virtio_net_hdr));
+        /* a separated rq->sg[0] for header - required in case !any_header_sg */
+        sg_set_buf(&rq->sg[0], p, vi->hdr_len);
 
         /* rq->sg[1] for data packet, from offset */
         offset = sizeof(struct padded_vnet_hdr);
@@ -660,9 +661,9 @@ static int add_recvbuf_mergeable(struct receive_queue *rq, gfp_t gfp)
  * before we're receiving packets, or from refill_work which is
  * careful to disable receiving (using napi_disable).
  */
-static bool try_fill_recv(struct receive_queue *rq, gfp_t gfp)
+static bool try_fill_recv(struct virtnet_info *vi, struct receive_queue *rq,
+                          gfp_t gfp)
 {
-        struct virtnet_info *vi = rq->vq->vdev->priv;
         int err;
         bool oom;
 
@@ -671,9 +672,9 @@ static bool try_fill_recv(struct receive_queue *rq, gfp_t gfp)
                 if (vi->mergeable_rx_bufs)
                         err = add_recvbuf_mergeable(rq, gfp);
                 else if (vi->big_packets)
-                        err = add_recvbuf_big(rq, gfp);
+                        err = add_recvbuf_big(vi, rq, gfp);
                 else
-                        err = add_recvbuf_small(rq, gfp);
+                        err = add_recvbuf_small(vi, rq, gfp);
 
                 oom = err == -ENOMEM;
                 if (err)
@@ -722,7 +723,7 @@ static void refill_work(struct work_struct *work)
                 struct receive_queue *rq = &vi->rq[i];
 
                 napi_disable(&rq->napi);
-                still_empty = !try_fill_recv(rq, GFP_KERNEL);
+                still_empty = !try_fill_recv(vi, rq, GFP_KERNEL);
                 virtnet_napi_enable(rq);
 
                 /* In theory, this can happen: if we don't get any buffers in
@@ -741,12 +742,12 @@ static int virtnet_receive(struct receive_queue *rq, int budget)
 
         while (received < budget &&
                (buf = virtqueue_get_buf(rq->vq, &len)) != NULL) {
-                receive_buf(rq, buf, len);
+                receive_buf(vi, rq, buf, len);
                 received++;
         }
 
         if (rq->vq->num_free > virtqueue_get_vring_size(rq->vq) / 2) {
-                if (!try_fill_recv(rq, GFP_ATOMIC))
+                if (!try_fill_recv(vi, rq, GFP_ATOMIC))
                         schedule_delayed_work(&vi->refill, 0);
         }
 
@@ -822,7 +823,7 @@ static int virtnet_open(struct net_device *dev)
         for (i = 0; i < vi->max_queue_pairs; i++) {
                 if (i < vi->curr_queue_pairs)
                         /* Make sure we have some buffers: if oom use wq. */
-                        if (!try_fill_recv(&vi->rq[i], GFP_KERNEL))
+                        if (!try_fill_recv(vi, &vi->rq[i], GFP_KERNEL))
                                 schedule_delayed_work(&vi->refill, 0);
                 virtnet_napi_enable(&vi->rq[i]);
         }
@@ -851,18 +852,14 @@ static void free_old_xmit_skbs(struct send_queue *sq)
 
 static int xmit_skb(struct send_queue *sq, struct sk_buff *skb)
 {
-        struct skb_vnet_hdr *hdr;
+        struct virtio_net_hdr_mrg_rxbuf *hdr;
         const unsigned char *dest = ((struct ethhdr *)skb->data)->h_dest;
         struct virtnet_info *vi = sq->vq->vdev->priv;
         unsigned num_sg;
-        unsigned hdr_len;
+        unsigned hdr_len = vi->hdr_len;
         bool can_push;
 
         pr_debug("%s: xmit %p %pM\n", vi->dev->name, skb, dest);
-        if (vi->mergeable_rx_bufs)
-                hdr_len = sizeof hdr->mhdr;
-        else
-                hdr_len = sizeof hdr->hdr;
 
         can_push = vi->any_header_sg &&
                 !((unsigned long)skb->data & (__alignof__(*hdr) - 1)) &&
@@ -870,22 +867,25 @@ static int xmit_skb(struct send_queue *sq, struct sk_buff *skb)
         /* Even if we can, don't push here yet as this would skew
          * csum_start offset below. */
         if (can_push)
-                hdr = (struct skb_vnet_hdr *)(skb->data - hdr_len);
+                hdr = (struct virtio_net_hdr_mrg_rxbuf *)(skb->data - hdr_len);
         else
                 hdr = skb_vnet_hdr(skb);
 
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 hdr->hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
-                hdr->hdr.csum_start = skb_checksum_start_offset(skb);
-                hdr->hdr.csum_offset = skb->csum_offset;
+                hdr->hdr.csum_start = cpu_to_virtio16(vi->vdev,
+                                                skb_checksum_start_offset(skb));
+                hdr->hdr.csum_offset = cpu_to_virtio16(vi->vdev,
+                                                         skb->csum_offset);
         } else {
                 hdr->hdr.flags = 0;
                 hdr->hdr.csum_offset = hdr->hdr.csum_start = 0;
         }
 
         if (skb_is_gso(skb)) {
-                hdr->hdr.hdr_len = skb_headlen(skb);
-                hdr->hdr.gso_size = skb_shinfo(skb)->gso_size;
+                hdr->hdr.hdr_len = cpu_to_virtio16(vi->vdev, skb_headlen(skb));
+                hdr->hdr.gso_size = cpu_to_virtio16(vi->vdev,
+                                                    skb_shinfo(skb)->gso_size);
                 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
                         hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
                 else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
@@ -900,7 +900,7 @@ static int xmit_skb(struct send_queue *sq, struct sk_buff *skb)
         }
 
         if (vi->mergeable_rx_bufs)
-                hdr->mhdr.num_buffers = 0;
+                hdr->num_buffers = 0;
 
         sg_init_table(sq->sg, MAX_SKB_FRAGS + 2);
         if (can_push) {
@@ -1030,7 +1030,8 @@ static int virtnet_set_mac_address(struct net_device *dev, void *p)
                                  "Failed to set mac address by vq command.\n");
                         return -EINVAL;
                 }
-        } else if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC)) {
+        } else if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC) &&
+                   !virtio_has_feature(vdev, VIRTIO_F_VERSION_1)) {
                 unsigned int i;
 
                 /* Naturally, this has an atomicity problem. */
@@ -1112,7 +1113,7 @@ static int virtnet_set_queues(struct virtnet_info *vi, u16 queue_pairs)
         if (!vi->has_cvq || !virtio_has_feature(vi->vdev, VIRTIO_NET_F_MQ))
                 return 0;
 
-        s.virtqueue_pairs = queue_pairs;
+        s.virtqueue_pairs = cpu_to_virtio16(vi->vdev, queue_pairs);
         sg_init_one(&sg, &s, sizeof(s));
 
         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_MQ,
@@ -1189,7 +1190,7 @@ static void virtnet_set_rx_mode(struct net_device *dev)
         sg_init_table(sg, 2);
 
         /* Store the unicast list and count in the front of the buffer */
-        mac_data->entries = uc_count;
+        mac_data->entries = cpu_to_virtio32(vi->vdev, uc_count);
         i = 0;
         netdev_for_each_uc_addr(ha, dev)
                 memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
@@ -1200,7 +1201,7 @@ static void virtnet_set_rx_mode(struct net_device *dev)
         /* multicast list and count fill the end */
         mac_data = (void *)&mac_data->macs[uc_count][0];
 
-        mac_data->entries = mc_count;
+        mac_data->entries = cpu_to_virtio32(vi->vdev, mc_count);
         i = 0;
         netdev_for_each_mc_addr(ha, dev)
                 memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
@@ -1805,18 +1806,20 @@ static int virtnet_probe(struct virtio_device *vdev)
         if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF))
                 vi->mergeable_rx_bufs = true;
 
+        if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF) ||
+            virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
+                vi->hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
+        else
+                vi->hdr_len = sizeof(struct virtio_net_hdr);
+
         if (virtio_has_feature(vdev, VIRTIO_F_ANY_LAYOUT))
                 vi->any_header_sg = true;
 
         if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ))
                 vi->has_cvq = true;
 
-        if (vi->any_header_sg) {
-                if (vi->mergeable_rx_bufs)
-                        dev->needed_headroom = sizeof(struct virtio_net_hdr_mrg_rxbuf);
-                else
-                        dev->needed_headroom = sizeof(struct virtio_net_hdr);
-        }
+        if (vi->any_header_sg)
+                dev->needed_headroom = vi->hdr_len;
 
         /* Use single tx/rx queue pair as default */
         vi->curr_queue_pairs = 1;
@@ -1844,7 +1847,7 @@ static int virtnet_probe(struct virtio_device *vdev)
 
         /* Last of all, set up some receive buffers. */
         for (i = 0; i < vi->curr_queue_pairs; i++) {
-                try_fill_recv(&vi->rq[i], GFP_KERNEL);
+                try_fill_recv(vi, &vi->rq[i], GFP_KERNEL);
 
                 /* If we didn't even get one input buffer, we're useless. */
                 if (vi->rq[i].vq->num_free ==
@@ -1964,7 +1967,7 @@ static int virtnet_restore(struct virtio_device *vdev)
 
         if (netif_running(vi->dev)) {
                 for (i = 0; i < vi->curr_queue_pairs; i++)
-                        if (!try_fill_recv(&vi->rq[i], GFP_KERNEL))
+                        if (!try_fill_recv(vi, &vi->rq[i], GFP_KERNEL))
                                 schedule_delayed_work(&vi->refill, 0);
 
                 for (i = 0; i < vi->max_queue_pairs; i++)
diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c
index e1e335c339e3..be4649a49c5e 100644
--- a/drivers/net/vxlan.c
+++ b/drivers/net/vxlan.c
@@ -2306,9 +2306,9 @@ static struct socket *vxlan_create_sock(struct net *net, bool ipv6,
         if (ipv6) {
                 udp_conf.family = AF_INET6;
                 udp_conf.use_udp6_tx_checksums =
-                    !!(flags & VXLAN_F_UDP_ZERO_CSUM6_TX);
+                    !(flags & VXLAN_F_UDP_ZERO_CSUM6_TX);
                 udp_conf.use_udp6_rx_checksums =
-                    !!(flags & VXLAN_F_UDP_ZERO_CSUM6_RX);
+                    !(flags & VXLAN_F_UDP_ZERO_CSUM6_RX);
         } else {
                 udp_conf.family = AF_INET;
                 udp_conf.local_ip.s_addr = INADDR_ANY;
diff --git a/drivers/net/wireless/iwlwifi/iwl-fw.h b/drivers/net/wireless/iwlwifi/iwl-fw.h
index 4f6e66892acc..b894a84e8393 100644
--- a/drivers/net/wireless/iwlwifi/iwl-fw.h
+++ b/drivers/net/wireless/iwlwifi/iwl-fw.h
@@ -155,6 +155,7 @@ enum iwl_ucode_tlv_api {
  * @IWL_UCODE_TLV_CAPA_QUIET_PERIOD_SUPPORT: supports Quiet Period requests
  * @IWL_UCODE_TLV_CAPA_DQA_SUPPORT: supports dynamic queue allocation (DQA),
  *      which also implies support for the scheduler configuration command
+ * @IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT: supports Hot Spot Command
  */
 enum iwl_ucode_tlv_capa {
         IWL_UCODE_TLV_CAPA_D0I3_SUPPORT                 = BIT(0),
@@ -163,6 +164,7 @@ enum iwl_ucode_tlv_capa {
         IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT       = BIT(10),
         IWL_UCODE_TLV_CAPA_QUIET_PERIOD_SUPPORT         = BIT(11),
         IWL_UCODE_TLV_CAPA_DQA_SUPPORT                  = BIT(12),
+        IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT              = BIT(18),
 };
 
 /* The default calibrate table size if not specified by firmware file */
diff --git a/drivers/net/wireless/iwlwifi/mvm/mac80211.c b/drivers/net/wireless/iwlwifi/mvm/mac80211.c
index b62405865b25..b6d2683da3a9 100644
--- a/drivers/net/wireless/iwlwifi/mvm/mac80211.c
+++ b/drivers/net/wireless/iwlwifi/mvm/mac80211.c
@@ -2448,9 +2448,15 @@ static int iwl_mvm_roc(struct ieee80211_hw *hw,
 
         switch (vif->type) {
         case NL80211_IFTYPE_STATION:
-                /* Use aux roc framework (HS20) */
-                ret = iwl_mvm_send_aux_roc_cmd(mvm, channel,
-                                               vif, duration);
+                if (mvm->fw->ucode_capa.capa[0] &
+                    IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT) {
+                        /* Use aux roc framework (HS20) */
+                        ret = iwl_mvm_send_aux_roc_cmd(mvm, channel,
+                                                       vif, duration);
+                        goto out_unlock;
+                }
+                IWL_ERR(mvm, "hotspot not supported\n");
+                ret = -EINVAL;
                 goto out_unlock;
         case NL80211_IFTYPE_P2P_DEVICE:
                 /* handle below */
diff --git a/drivers/net/wireless/rtlwifi/pci.c b/drivers/net/wireless/rtlwifi/pci.c
index 61f5d36eca6a..846a2e6e34d8 100644
--- a/drivers/net/wireless/rtlwifi/pci.c
+++ b/drivers/net/wireless/rtlwifi/pci.c
@@ -2249,6 +2249,16 @@ int rtl_pci_probe(struct pci_dev *pdev,
         /*like read eeprom and so on */
         rtlpriv->cfg->ops->read_eeprom_info(hw);
 
+        if (rtlpriv->cfg->ops->init_sw_vars(hw)) {
+                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Can't init_sw_vars\n");
+                err = -ENODEV;
+                goto fail3;
+        }
+        rtlpriv->cfg->ops->init_sw_leds(hw);
+
+        /*aspm */
+        rtl_pci_init_aspm(hw);
+
         /* Init mac80211 sw */
         err = rtl_init_core(hw);
         if (err) {
@@ -2264,16 +2274,6 @@ int rtl_pci_probe(struct pci_dev *pdev,
                 goto fail3;
         }
 
-        if (rtlpriv->cfg->ops->init_sw_vars(hw)) {
-                RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Can't init_sw_vars\n");
-                err = -ENODEV;
-                goto fail3;
-        }
-        rtlpriv->cfg->ops->init_sw_leds(hw);
-
-        /*aspm */
-        rtl_pci_init_aspm(hw);
-
         err = ieee80211_register_hw(hw);
         if (err) {
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
diff --git a/drivers/net/wireless/rtlwifi/rtl8821ae/hw.c b/drivers/net/wireless/rtlwifi/rtl8821ae/hw.c
index 310d3163dc5b..8ec8200002c7 100644
--- a/drivers/net/wireless/rtlwifi/rtl8821ae/hw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8821ae/hw.c
@@ -3672,8 +3672,9 @@ static void rtl8821ae_update_hal_rate_mask(struct ieee80211_hw *hw,
                 mac->opmode == NL80211_IFTYPE_ADHOC)
                 macid = sta->aid + 1;
         if (wirelessmode == WIRELESS_MODE_N_5G ||
-            wirelessmode == WIRELESS_MODE_AC_5G)
-                ratr_bitmap = sta->supp_rates[NL80211_BAND_5GHZ];
+            wirelessmode == WIRELESS_MODE_AC_5G ||
+            wirelessmode == WIRELESS_MODE_A)
+                ratr_bitmap = sta->supp_rates[NL80211_BAND_5GHZ] << 4;
         else
                 ratr_bitmap = sta->supp_rates[NL80211_BAND_2GHZ];
 
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index 4e56a27f9689..fab0d4b42f58 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -39,7 +39,7 @@ struct backend_info {
 static int connect_rings(struct backend_info *be, struct xenvif_queue *queue);
 static void connect(struct backend_info *be);
 static int read_xenbus_vif_flags(struct backend_info *be);
-static void backend_create_xenvif(struct backend_info *be);
+static int backend_create_xenvif(struct backend_info *be);
 static void unregister_hotplug_status_watch(struct backend_info *be);
 static void set_backend_state(struct backend_info *be,
                               enum xenbus_state state);
@@ -352,7 +352,9 @@ static int netback_probe(struct xenbus_device *dev,
         be->state = XenbusStateInitWait;
 
         /* This kicks hotplug scripts, so do it immediately. */
-        backend_create_xenvif(be);
+        err = backend_create_xenvif(be);
+        if (err)
+                goto fail;
 
         return 0;
 
@@ -397,19 +399,19 @@ static int netback_uevent(struct xenbus_device *xdev,
 }
 
 
-static void backend_create_xenvif(struct backend_info *be)
+static int backend_create_xenvif(struct backend_info *be)
 {
         int err;
         long handle;
         struct xenbus_device *dev = be->dev;
 
         if (be->vif != NULL)
-                return;
+                return 0;
 
         err = xenbus_scanf(XBT_NIL, dev->nodename, "handle", "%li", &handle);
         if (err != 1) {
                 xenbus_dev_fatal(dev, err, "reading handle");
-                return;
+                return (err < 0) ? err : -EINVAL;
         }
 
         be->vif = xenvif_alloc(&dev->dev, dev->otherend_id, handle);
@@ -417,10 +419,11 @@ static void backend_create_xenvif(struct backend_info *be)
                 err = PTR_ERR(be->vif);
                 be->vif = NULL;
                 xenbus_dev_fatal(dev, err, "creating interface");
-                return;
+                return err;
         }
 
         kobject_uevent(&dev->dev.kobj, KOBJ_ONLINE);
+        return 0;
 }
 
 static void backend_disconnect(struct backend_info *be)
diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
index cca871346a0f..ece8d1804d13 100644
--- a/drivers/net/xen-netfront.c
+++ b/drivers/net/xen-netfront.c
@@ -496,9 +496,6 @@ static void xennet_make_frags(struct sk_buff *skb, struct netfront_queue *queue,
                 len = skb_frag_size(frag);
                 offset = frag->page_offset;
 
-                /* Data must not cross a page boundary. */
-                BUG_ON(len + offset > PAGE_SIZE<<compound_order(page));
-
                 /* Skip unused frames from start of page */
                 page += offset >> PAGE_SHIFT;
                 offset &= ~PAGE_MASK;
@@ -506,8 +503,6 @@ static void xennet_make_frags(struct sk_buff *skb, struct netfront_queue *queue,
                 while (len > 0) {
                         unsigned long bytes;
 
-                        BUG_ON(offset >= PAGE_SIZE);
-
                         bytes = PAGE_SIZE - offset;
                         if (bytes > len)
                                 bytes = len;
diff --git a/drivers/nubus/nubus.c b/drivers/nubus/nubus.c
index 5066a7ef7b6c..3319cf19deeb 100644
--- a/drivers/nubus/nubus.c
+++ b/drivers/nubus/nubus.c
@@ -920,14 +920,10 @@ void __init nubus_probe_slot(int slot)
         rp = nubus_rom_addr(slot);      
         for(i = 4; i; i--)
         {
-                unsigned long flags;
                 int card_present;
 
                 rp--;
-                local_irq_save(flags);
                 card_present = hwreg_present(rp);
-                local_irq_restore(flags);
-               
                 if (!card_present)
                         continue;
 
diff --git a/drivers/of/base.c b/drivers/of/base.c
index f2be7c860cf2..36536b6a8834 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -1272,6 +1272,39 @@ int of_property_read_u64(const struct device_node *np, const char *propname,
 EXPORT_SYMBOL_GPL(of_property_read_u64);
 
 /**
+ * of_property_read_u64_array - Find and read an array of 64 bit integers
+ * from a property.
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ * @out_values: pointer to return value, modified only if return value is 0.
+ * @sz:         number of array elements to read
+ *
+ * Search for a property in a device node and read 64-bit value(s) from
+ * it. Returns 0 on success, -EINVAL if the property does not exist,
+ * -ENODATA if property does not have a value, and -EOVERFLOW if the
+ * property data isn't large enough.
+ *
+ * The out_values is modified only if a valid u64 value can be decoded.
+ */
+int of_property_read_u64_array(const struct device_node *np,
+                               const char *propname, u64 *out_values,
+                               size_t sz)
+{
+        const __be32 *val = of_find_property_value_of_size(np, propname,
+                                                (sz * sizeof(*out_values)));
+
+        if (IS_ERR(val))
+                return PTR_ERR(val);
+
+        while (sz--) {
+                *out_values++ = of_read_number(val, 2);
+                val += 2;
+        }
+        return 0;
+}
+
+/**
  * of_property_read_string - Find and read a string from a property
  * @np:         device node from which the property value is to be read.
  * @propname:   name of the property to be searched.
diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
index a41f9fdb1aa0..510074226d57 100644
--- a/drivers/of/fdt.c
+++ b/drivers/of/fdt.c
@@ -983,8 +983,6 @@ void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
 int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base,
                                         phys_addr_t size, bool nomap)
 {
-        if (memblock_is_region_reserved(base, size))
-                return -EBUSY;
         if (nomap)
                 return memblock_remove(base, size);
         return memblock_reserve(base, size);
diff --git a/drivers/of/of_pci.c b/drivers/of/of_pci.c
index 8882b467be95..88471d3d98cd 100644
--- a/drivers/of/of_pci.c
+++ b/drivers/of/of_pci.c
@@ -236,7 +236,7 @@ EXPORT_SYMBOL_GPL(of_pci_get_host_bridge_resources);
 static LIST_HEAD(of_pci_msi_chip_list);
 static DEFINE_MUTEX(of_pci_msi_chip_mutex);
 
-int of_pci_msi_chip_add(struct msi_chip *chip)
+int of_pci_msi_chip_add(struct msi_controller *chip)
 {
         if (!of_property_read_bool(chip->of_node, "msi-controller"))
                 return -EINVAL;
@@ -249,7 +249,7 @@ int of_pci_msi_chip_add(struct msi_chip *chip)
 }
 EXPORT_SYMBOL_GPL(of_pci_msi_chip_add);
 
-void of_pci_msi_chip_remove(struct msi_chip *chip)
+void of_pci_msi_chip_remove(struct msi_controller *chip)
 {
         mutex_lock(&of_pci_msi_chip_mutex);
         list_del(&chip->list);
@@ -257,9 +257,9 @@ void of_pci_msi_chip_remove(struct msi_chip *chip)
 }
 EXPORT_SYMBOL_GPL(of_pci_msi_chip_remove);
 
-struct msi_chip *of_pci_find_msi_chip_by_node(struct device_node *of_node)
+struct msi_controller *of_pci_find_msi_chip_by_node(struct device_node *of_node)
 {
-        struct msi_chip *c;
+        struct msi_controller *c;
 
         mutex_lock(&of_pci_msi_chip_mutex);
         list_for_each_entry(c, &of_pci_msi_chip_list, list) {
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 893503fa1782..cced84233ac0 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -4,6 +4,7 @@
 config PCI_MSI
         bool "Message Signaled Interrupts (MSI and MSI-X)"
         depends on PCI
+        select GENERIC_MSI_IRQ
         help
            This allows device drivers to enable MSI (Message Signaled
            Interrupts).  Message Signaled Interrupts enable a device to
@@ -16,6 +17,11 @@ config PCI_MSI
 
            If you don't know what to do here, say Y.
 
+config PCI_MSI_IRQ_DOMAIN
+        bool
+        depends on PCI_MSI
+        select GENERIC_MSI_IRQ_DOMAIN
+
 config PCI_DEBUG
         bool "PCI Debugging"
         depends on PCI && DEBUG_KERNEL
diff --git a/drivers/pci/host/Kconfig b/drivers/pci/host/Kconfig
index 3dc25fad490c..c4b6568e486d 100644
--- a/drivers/pci/host/Kconfig
+++ b/drivers/pci/host/Kconfig
@@ -32,7 +32,10 @@ config PCI_IMX6
 
 config PCI_TEGRA
         bool "NVIDIA Tegra PCIe controller"
-        depends on ARCH_TEGRA
+        depends on ARCH_TEGRA && !ARM64
+        help
+          Say Y here if you want support for the PCIe host controller found
+          on NVIDIA Tegra SoCs.
 
 config PCI_RCAR_GEN2
         bool "Renesas R-Car Gen2 Internal PCI controller"
@@ -91,4 +94,12 @@ config PCI_XGENE
           There are 5 internal PCIe ports available. Each port is GEN3 capable
           and have varied lanes from x1 to x8.
 
+config PCI_LAYERSCAPE
+        bool "Freescale Layerscape PCIe controller"
+        depends on OF && ARM
+        select PCIE_DW
+        select MFD_SYSCON
+        help
+          Say Y here if you want PCIe controller support on Layerscape SoCs.
+
 endmenu
diff --git a/drivers/pci/host/Makefile b/drivers/pci/host/Makefile
index 26b3461d68d7..44c26998027f 100644
--- a/drivers/pci/host/Makefile
+++ b/drivers/pci/host/Makefile
@@ -11,3 +11,4 @@ obj-$(CONFIG_PCIE_SPEAR13XX) += pcie-spear13xx.o
 obj-$(CONFIG_PCI_KEYSTONE) += pci-keystone-dw.o pci-keystone.o
 obj-$(CONFIG_PCIE_XILINX) += pcie-xilinx.o
 obj-$(CONFIG_PCI_XGENE) += pci-xgene.o
+obj-$(CONFIG_PCI_LAYERSCAPE) += pci-layerscape.o
diff --git a/drivers/pci/host/pci-dra7xx.c b/drivers/pci/host/pci-dra7xx.c
index 52b34fee07fd..8c6969747acd 100644
--- a/drivers/pci/host/pci-dra7xx.c
+++ b/drivers/pci/host/pci-dra7xx.c
@@ -270,8 +270,8 @@ static irqreturn_t dra7xx_pcie_irq_handler(int irq, void *arg)
         return IRQ_HANDLED;
 }
 
-static int add_pcie_port(struct dra7xx_pcie *dra7xx,
-                          struct platform_device *pdev)
+static int __init dra7xx_add_pcie_port(struct dra7xx_pcie *dra7xx,
+                                       struct platform_device *pdev)
 {
         int ret;
         struct pcie_port *pp;
@@ -398,7 +398,7 @@ static int __init dra7xx_pcie_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, dra7xx);
 
-        ret = add_pcie_port(dra7xx, pdev);
+        ret = dra7xx_add_pcie_port(dra7xx, pdev);
         if (ret < 0)
                 goto err_add_port;
 
diff --git a/drivers/pci/host/pci-exynos.c b/drivers/pci/host/pci-exynos.c
index c5d0ca384502..850c9f951a3f 100644
--- a/drivers/pci/host/pci-exynos.c
+++ b/drivers/pci/host/pci-exynos.c
@@ -312,7 +312,6 @@ static void exynos_pcie_assert_reset(struct pcie_port *pp)
         if (exynos_pcie->reset_gpio >= 0)
                 devm_gpio_request_one(pp->dev, exynos_pcie->reset_gpio,
                                 GPIOF_OUT_INIT_HIGH, "RESET");
-        return;
 }
 
 static int exynos_pcie_establish_link(struct pcie_port *pp)
@@ -388,7 +387,6 @@ static void exynos_pcie_clear_irq_pulse(struct pcie_port *pp)
 
         val = exynos_elb_readl(exynos_pcie, PCIE_IRQ_PULSE);
         exynos_elb_writel(exynos_pcie, val, PCIE_IRQ_PULSE);
-        return;
 }
 
 static void exynos_pcie_enable_irq_pulse(struct pcie_port *pp)
@@ -400,7 +398,6 @@ static void exynos_pcie_enable_irq_pulse(struct pcie_port *pp)
         val = IRQ_INTA_ASSERT | IRQ_INTB_ASSERT |
                 IRQ_INTC_ASSERT | IRQ_INTD_ASSERT,
         exynos_elb_writel(exynos_pcie, val, PCIE_IRQ_EN_PULSE);
-        return;
 }
 
 static irqreturn_t exynos_pcie_irq_handler(int irq, void *arg)
@@ -429,7 +426,6 @@ static void exynos_pcie_msi_init(struct pcie_port *pp)
         val = exynos_elb_readl(exynos_pcie, PCIE_IRQ_EN_LEVEL);
         val |= IRQ_MSI_ENABLE;
         exynos_elb_writel(exynos_pcie, val, PCIE_IRQ_EN_LEVEL);
-        return;
 }
 
 static void exynos_pcie_enable_interrupts(struct pcie_port *pp)
@@ -438,8 +434,6 @@ static void exynos_pcie_enable_interrupts(struct pcie_port *pp)
 
         if (IS_ENABLED(CONFIG_PCI_MSI))
                 exynos_pcie_msi_init(pp);
-
-        return;
 }
 
 static inline void exynos_pcie_readl_rc(struct pcie_port *pp,
@@ -448,7 +442,6 @@ static inline void exynos_pcie_readl_rc(struct pcie_port *pp,
         exynos_pcie_sideband_dbi_r_mode(pp, true);
         *val = readl(dbi_base);
         exynos_pcie_sideband_dbi_r_mode(pp, false);
-        return;
 }
 
 static inline void exynos_pcie_writel_rc(struct pcie_port *pp,
@@ -457,7 +450,6 @@ static inline void exynos_pcie_writel_rc(struct pcie_port *pp,
         exynos_pcie_sideband_dbi_w_mode(pp, true);
         writel(val, dbi_base);
         exynos_pcie_sideband_dbi_w_mode(pp, false);
-        return;
 }
 
 static int exynos_pcie_rd_own_conf(struct pcie_port *pp, int where, int size,
@@ -509,8 +501,8 @@ static struct pcie_host_ops exynos_pcie_host_ops = {
         .host_init = exynos_pcie_host_init,
 };
 
-static int __init add_pcie_port(struct pcie_port *pp,
-                                struct platform_device *pdev)
+static int __init exynos_add_pcie_port(struct pcie_port *pp,
+                                       struct platform_device *pdev)
 {
         int ret;
 
@@ -615,7 +607,7 @@ static int __init exynos_pcie_probe(struct platform_device *pdev)
                 goto fail_bus_clk;
         }
 
-        ret = add_pcie_port(pp, pdev);
+        ret = exynos_add_pcie_port(pp, pdev);
         if (ret < 0)
                 goto fail_bus_clk;
 
@@ -656,11 +648,11 @@ static struct platform_driver exynos_pcie_driver = {
 
 /* Exynos PCIe driver does not allow module unload */
 
-static int __init pcie_init(void)
+static int __init exynos_pcie_init(void)
 {
         return platform_driver_probe(&exynos_pcie_driver, exynos_pcie_probe);
 }
-subsys_initcall(pcie_init);
+subsys_initcall(exynos_pcie_init);
 
 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
 MODULE_DESCRIPTION("Samsung PCIe host controller driver");
diff --git a/drivers/pci/host/pci-host-generic.c b/drivers/pci/host/pci-host-generic.c
index 3d2076f59911..18959075d164 100644
--- a/drivers/pci/host/pci-host-generic.c
+++ b/drivers/pci/host/pci-host-generic.c
@@ -32,7 +32,7 @@ struct gen_pci_cfg_bus_ops {
 
 struct gen_pci_cfg_windows {
         struct resource                         res;
-        struct resource                         bus_range;
+        struct resource                         *bus_range;
         void __iomem                            **win;
 
         const struct gen_pci_cfg_bus_ops        *ops;
@@ -50,7 +50,7 @@ static void __iomem *gen_pci_map_cfg_bus_cam(struct pci_bus *bus,
 {
         struct pci_sys_data *sys = bus->sysdata;
         struct gen_pci *pci = sys->private_data;
-        resource_size_t idx = bus->number - pci->cfg.bus_range.start;
+        resource_size_t idx = bus->number - pci->cfg.bus_range->start;
 
         return pci->cfg.win[idx] + ((devfn << 8) | where);
 }
@@ -66,7 +66,7 @@ static void __iomem *gen_pci_map_cfg_bus_ecam(struct pci_bus *bus,
 {
         struct pci_sys_data *sys = bus->sysdata;
         struct gen_pci *pci = sys->private_data;
-        resource_size_t idx = bus->number - pci->cfg.bus_range.start;
+        resource_size_t idx = bus->number - pci->cfg.bus_range->start;
 
         return pci->cfg.win[idx] + ((devfn << 12) | where);
 }
@@ -138,106 +138,50 @@ static const struct of_device_id gen_pci_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, gen_pci_of_match);
 
-static int gen_pci_calc_io_offset(struct device *dev,
-                                  struct of_pci_range *range,
-                                  struct resource *res,
-                                  resource_size_t *offset)
-{
-        static atomic_t wins = ATOMIC_INIT(0);
-        int err, idx, max_win;
-        unsigned int window;
-
-        if (!PAGE_ALIGNED(range->cpu_addr))
-                return -EINVAL;
-
-        max_win = (IO_SPACE_LIMIT + 1) / SZ_64K;
-        idx = atomic_inc_return(&wins);
-        if (idx > max_win)
-                return -ENOSPC;
-
-        window = (idx - 1) * SZ_64K;
-        err = pci_ioremap_io(window, range->cpu_addr);
-        if (err)
-                return err;
-
-        of_pci_range_to_resource(range, dev->of_node, res);
-        res->start = window;
-        res->end = res->start + range->size - 1;
-        *offset = window - range->pci_addr;
-        return 0;
-}
-
-static int gen_pci_calc_mem_offset(struct device *dev,
-                                   struct of_pci_range *range,
-                                   struct resource *res,
-                                   resource_size_t *offset)
-{
-        of_pci_range_to_resource(range, dev->of_node, res);
-        *offset = range->cpu_addr - range->pci_addr;
-        return 0;
-}
-
 static void gen_pci_release_of_pci_ranges(struct gen_pci *pci)
 {
-        struct pci_host_bridge_window *win;
-
-        list_for_each_entry(win, &pci->resources, list)
-                release_resource(win->res);
-
         pci_free_resource_list(&pci->resources);
 }
 
 static int gen_pci_parse_request_of_pci_ranges(struct gen_pci *pci)
 {
-        struct of_pci_range range;
-        struct of_pci_range_parser parser;
         int err, res_valid = 0;
         struct device *dev = pci->host.dev.parent;
         struct device_node *np = dev->of_node;
+        resource_size_t iobase;
+        struct pci_host_bridge_window *win;
 
-        if (of_pci_range_parser_init(&parser, np)) {
-                dev_err(dev, "missing \"ranges\" property\n");
-                return -EINVAL;
-        }
-
-        for_each_of_pci_range(&parser, &range) {
-                struct resource *parent, *res;
-                resource_size_t offset;
-                u32 restype = range.flags & IORESOURCE_TYPE_BITS;
+        err = of_pci_get_host_bridge_resources(np, 0, 0xff, &pci->resources,
+                                               &iobase);
+        if (err)
+                return err;
 
-                res = devm_kmalloc(dev, sizeof(*res), GFP_KERNEL);
-                if (!res) {
-                        err = -ENOMEM;
-                        goto out_release_res;
-                }
+        list_for_each_entry(win, &pci->resources, list) {
+                struct resource *parent, *res = win->res;
 
-                switch (restype) {
+                switch (resource_type(res)) {
                 case IORESOURCE_IO:
                         parent = &ioport_resource;
-                        err = gen_pci_calc_io_offset(dev, &range, res, &offset);
+                        err = pci_remap_iospace(res, iobase);
+                        if (err) {
+                                dev_warn(dev, "error %d: failed to map resource %pR\n",
+                                         err, res);
+                                continue;
+                        }
                         break;
                 case IORESOURCE_MEM:
                         parent = &iomem_resource;
-                        err = gen_pci_calc_mem_offset(dev, &range, res, &offset);
-                        res_valid |= !(res->flags & IORESOURCE_PREFETCH || err);
+                        res_valid |= !(res->flags & IORESOURCE_PREFETCH);
                         break;
+                case IORESOURCE_BUS:
+                        pci->cfg.bus_range = res;
                 default:
-                        err = -EINVAL;
-                        continue;
-                }
-
-                if (err) {
-                        dev_warn(dev,
-                                 "error %d: failed to add resource [type 0x%x, %lld bytes]\n",
-                                 err, restype, range.size);
                         continue;
                 }
 
-                err = request_resource(parent, res);
+                err = devm_request_resource(dev, parent, res);
                 if (err)
                         goto out_release_res;
-
-                pci_add_resource_offset(&pci->resources, res, offset);
         }
 
         if (!res_valid) {
@@ -262,38 +206,30 @@ static int gen_pci_parse_map_cfg_windows(struct gen_pci *pci)
         struct device *dev = pci->host.dev.parent;
         struct device_node *np = dev->of_node;
 
-        if (of_pci_parse_bus_range(np, &pci->cfg.bus_range))
-                pci->cfg.bus_range = (struct resource) {
-                        .name   = np->name,
-                        .start  = 0,
-                        .end    = 0xff,
-                        .flags  = IORESOURCE_BUS,
-                };
-
         err = of_address_to_resource(np, 0, &pci->cfg.res);
         if (err) {
                 dev_err(dev, "missing \"reg\" property\n");
                 return err;
         }
 
-        pci->cfg.win = devm_kcalloc(dev, resource_size(&pci->cfg.bus_range),
+        /* Limit the bus-range to fit within reg */
+        bus_max = pci->cfg.bus_range->start +
+                  (resource_size(&pci->cfg.res) >> pci->cfg.ops->bus_shift) - 1;
+        pci->cfg.bus_range->end = min_t(resource_size_t,
+                                        pci->cfg.bus_range->end, bus_max);
+
+        pci->cfg.win = devm_kcalloc(dev, resource_size(pci->cfg.bus_range),
                                     sizeof(*pci->cfg.win), GFP_KERNEL);
         if (!pci->cfg.win)
                 return -ENOMEM;
 
-        /* Limit the bus-range to fit within reg */
-        bus_max = pci->cfg.bus_range.start +
-                  (resource_size(&pci->cfg.res) >> pci->cfg.ops->bus_shift) - 1;
-        pci->cfg.bus_range.end = min_t(resource_size_t, pci->cfg.bus_range.end,
-                                       bus_max);
-
         /* Map our Configuration Space windows */
         if (!devm_request_mem_region(dev, pci->cfg.res.start,
                                      resource_size(&pci->cfg.res),
                                      "Configuration Space"))
                 return -ENOMEM;
 
-        bus_range = &pci->cfg.bus_range;
+        bus_range = pci->cfg.bus_range;
         for (busn = bus_range->start; busn <= bus_range->end; ++busn) {
                 u32 idx = busn - bus_range->start;
                 u32 sz = 1 << pci->cfg.ops->bus_shift;
@@ -305,8 +241,6 @@ static int gen_pci_parse_map_cfg_windows(struct gen_pci *pci)
                         return -ENOMEM;
         }
 
-        /* Register bus resource */
-        pci_add_resource(&pci->resources, bus_range);
         return 0;
 }
 
diff --git a/drivers/pci/host/pci-imx6.c b/drivers/pci/host/pci-imx6.c
index 69202d1eb8fb..d1a26d17b586 100644
--- a/drivers/pci/host/pci-imx6.c
+++ b/drivers/pci/host/pci-imx6.c
@@ -533,8 +533,8 @@ static int __init imx6_add_pcie_port(struct pcie_port *pp,
                 }
 
                 ret = devm_request_irq(&pdev->dev, pp->msi_irq,
-                                       imx6_pcie_msi_handler,
-                                       IRQF_SHARED, "mx6-pcie-msi", pp);
+                                       imx6_pcie_msi_handler,
+                                       IRQF_SHARED, "mx6-pcie-msi", pp);
                 if (ret) {
                         dev_err(&pdev->dev, "failed to request MSI irq\n");
                         return -ENODEV;
diff --git a/drivers/pci/host/pci-keystone-dw.c b/drivers/pci/host/pci-keystone-dw.c
index 34086ce88e8e..66d8ea41b972 100644
--- a/drivers/pci/host/pci-keystone-dw.c
+++ b/drivers/pci/host/pci-keystone-dw.c
@@ -155,7 +155,7 @@ static void ks_dw_pcie_msi_irq_mask(struct irq_data *d)
         /* Mask the end point if PVM implemented */
         if (IS_ENABLED(CONFIG_PCI_MSI)) {
                 if (msi->msi_attrib.maskbit)
-                        mask_msi_irq(d);
+                        pci_msi_mask_irq(d);
         }
 
         ks_dw_pcie_msi_clear_irq(pp, offset);
@@ -177,7 +177,7 @@ static void ks_dw_pcie_msi_irq_unmask(struct irq_data *d)
         /* Mask the end point if PVM implemented */
         if (IS_ENABLED(CONFIG_PCI_MSI)) {
                 if (msi->msi_attrib.maskbit)
-                        unmask_msi_irq(d);
+                        pci_msi_unmask_irq(d);
         }
 
         ks_dw_pcie_msi_set_irq(pp, offset);
@@ -201,11 +201,11 @@ static int ks_dw_pcie_msi_map(struct irq_domain *domain, unsigned int irq,
         return 0;
 }
 
-const struct irq_domain_ops ks_dw_pcie_msi_domain_ops = {
+static const struct irq_domain_ops ks_dw_pcie_msi_domain_ops = {
         .map = ks_dw_pcie_msi_map,
 };
 
-int ks_dw_pcie_msi_host_init(struct pcie_port *pp, struct msi_chip *chip)
+int ks_dw_pcie_msi_host_init(struct pcie_port *pp, struct msi_controller *chip)
 {
         struct keystone_pcie *ks_pcie = to_keystone_pcie(pp);
         int i;
diff --git a/drivers/pci/host/pci-keystone.c b/drivers/pci/host/pci-keystone.c
index 1b893bc8b842..62b9454c86fb 100644
--- a/drivers/pci/host/pci-keystone.c
+++ b/drivers/pci/host/pci-keystone.c
@@ -353,10 +353,9 @@ static int __init ks_pcie_probe(struct platform_device *pdev)
 
         ks_pcie = devm_kzalloc(&pdev->dev, sizeof(*ks_pcie),
                                 GFP_KERNEL);
-        if (!ks_pcie) {
-                dev_err(dev, "no memory for keystone pcie\n");
+        if (!ks_pcie)
                 return -ENOMEM;
-        }
+
         pp = &ks_pcie->pp;
 
         /* initialize SerDes Phy if present */
diff --git a/drivers/pci/host/pci-keystone.h b/drivers/pci/host/pci-keystone.h
index 1fc1fceede9e..478d932b602d 100644
--- a/drivers/pci/host/pci-keystone.h
+++ b/drivers/pci/host/pci-keystone.h
@@ -55,4 +55,4 @@ void ks_dw_pcie_msi_set_irq(struct pcie_port *pp, int irq);
 void ks_dw_pcie_msi_clear_irq(struct pcie_port *pp, int irq);
 void ks_dw_pcie_v3_65_scan_bus(struct pcie_port *pp);
 int ks_dw_pcie_msi_host_init(struct pcie_port *pp,
-                struct msi_chip *chip);
+                struct msi_controller *chip);
diff --git a/drivers/pci/host/pci-layerscape.c b/drivers/pci/host/pci-layerscape.c
new file mode 100644
index 000000000000..6697b1a4d4fa
--- /dev/null
+++ b/drivers/pci/host/pci-layerscape.c
@@ -0,0 +1,179 @@
+/*
+ * PCIe host controller driver for Freescale Layerscape SoCs
+ *
+ * Copyright (C) 2014 Freescale Semiconductor.
+ *
+  * Author: Minghuan Lian <Minghuan.Lian@freescale.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/of_pci.h>
+#include <linux/of_platform.h>
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/pci.h>
+#include <linux/platform_device.h>
+#include <linux/resource.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
+
+#include "pcie-designware.h"
+
+/* PEX1/2 Misc Ports Status Register */
+#define SCFG_PEXMSCPORTSR(pex_idx)      (0x94 + (pex_idx) * 4)
+#define LTSSM_STATE_SHIFT       20
+#define LTSSM_STATE_MASK        0x3f
+#define LTSSM_PCIE_L0           0x11 /* L0 state */
+
+/* Symbol Timer Register and Filter Mask Register 1 */
+#define PCIE_STRFMR1 0x71c
+
+struct ls_pcie {
+        struct list_head node;
+        struct device *dev;
+        struct pci_bus *bus;
+        void __iomem *dbi;
+        struct regmap *scfg;
+        struct pcie_port pp;
+        int index;
+        int msi_irq;
+};
+
+#define to_ls_pcie(x)   container_of(x, struct ls_pcie, pp)
+
+static int ls_pcie_link_up(struct pcie_port *pp)
+{
+        u32 state;
+        struct ls_pcie *pcie = to_ls_pcie(pp);
+
+        regmap_read(pcie->scfg, SCFG_PEXMSCPORTSR(pcie->index), &state);
+        state = (state >> LTSSM_STATE_SHIFT) & LTSSM_STATE_MASK;
+
+        if (state < LTSSM_PCIE_L0)
+                return 0;
+
+        return 1;
+}
+
+static void ls_pcie_host_init(struct pcie_port *pp)
+{
+        struct ls_pcie *pcie = to_ls_pcie(pp);
+        int count = 0;
+        u32 val;
+
+        dw_pcie_setup_rc(pp);
+
+        while (!ls_pcie_link_up(pp)) {
+                usleep_range(100, 1000);
+                count++;
+                if (count >= 200) {
+                        dev_err(pp->dev, "phy link never came up\n");
+                        return;
+                }
+        }
+
+        /*
+         * LS1021A Workaround for internal TKT228622
+         * to fix the INTx hang issue
+         */
+        val = ioread32(pcie->dbi + PCIE_STRFMR1);
+        val &= 0xffff;
+        iowrite32(val, pcie->dbi + PCIE_STRFMR1);
+}
+
+static struct pcie_host_ops ls_pcie_host_ops = {
+        .link_up = ls_pcie_link_up,
+        .host_init = ls_pcie_host_init,
+};
+
+static int ls_add_pcie_port(struct ls_pcie *pcie)
+{
+        struct pcie_port *pp;
+        int ret;
+
+        pp = &pcie->pp;
+        pp->dev = pcie->dev;
+        pp->dbi_base = pcie->dbi;
+        pp->root_bus_nr = -1;
+        pp->ops = &ls_pcie_host_ops;
+
+        ret = dw_pcie_host_init(pp);
+        if (ret) {
+                dev_err(pp->dev, "failed to initialize host\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static int __init ls_pcie_probe(struct platform_device *pdev)
+{
+        struct ls_pcie *pcie;
+        struct resource *dbi_base;
+        u32 index[2];
+        int ret;
+
+        pcie = devm_kzalloc(&pdev->dev, sizeof(*pcie), GFP_KERNEL);
+        if (!pcie)
+                return -ENOMEM;
+
+        pcie->dev = &pdev->dev;
+
+        dbi_base = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
+        if (!dbi_base) {
+                dev_err(&pdev->dev, "missing *regs* space\n");
+                return -ENODEV;
+        }
+
+        pcie->dbi = devm_ioremap_resource(&pdev->dev, dbi_base);
+        if (IS_ERR(pcie->dbi))
+                return PTR_ERR(pcie->dbi);
+
+        pcie->scfg = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
+                                                     "fsl,pcie-scfg");
+        if (IS_ERR(pcie->scfg)) {
+                dev_err(&pdev->dev, "No syscfg phandle specified\n");
+                return PTR_ERR(pcie->scfg);
+        }
+
+        ret = of_property_read_u32_array(pdev->dev.of_node,
+                                         "fsl,pcie-scfg", index, 2);
+        if (ret)
+                return ret;
+        pcie->index = index[1];
+
+        ret = ls_add_pcie_port(pcie);
+        if (ret < 0)
+                return ret;
+
+        platform_set_drvdata(pdev, pcie);
+
+        return 0;
+}
+
+static const struct of_device_id ls_pcie_of_match[] = {
+        { .compatible = "fsl,ls1021a-pcie" },
+        { },
+};
+MODULE_DEVICE_TABLE(of, ls_pcie_of_match);
+
+static struct platform_driver ls_pcie_driver = {
+        .driver = {
+                .name = "layerscape-pcie",
+                .owner = THIS_MODULE,
+                .of_match_table = ls_pcie_of_match,
+        },
+};
+
+module_platform_driver_probe(ls_pcie_driver, ls_pcie_probe);
+
+MODULE_AUTHOR("Minghuan Lian <Minghuan.Lian@freescale.com>");
+MODULE_DESCRIPTION("Freescale Layerscape PCIe host controller driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pci/host/pci-mvebu.c b/drivers/pci/host/pci-mvebu.c
index b1315e197ffb..fed3fab132f2 100644
--- a/drivers/pci/host/pci-mvebu.c
+++ b/drivers/pci/host/pci-mvebu.c
@@ -99,7 +99,7 @@ struct mvebu_pcie_port;
 struct mvebu_pcie {
         struct platform_device *pdev;
         struct mvebu_pcie_port *ports;
-        struct msi_chip *msi;
+        struct msi_controller *msi;
         struct resource io;
         char io_name[30];
         struct resource realio;
@@ -622,6 +622,7 @@ static struct mvebu_pcie_port *mvebu_pcie_find_port(struct mvebu_pcie *pcie,
 
         for (i = 0; i < pcie->nports; i++) {
                 struct mvebu_pcie_port *port = &pcie->ports[i];
+
                 if (bus->number == 0 && port->devfn == devfn)
                         return port;
                 if (bus->number != 0 &&
@@ -751,6 +752,7 @@ static int mvebu_pcie_setup(int nr, struct pci_sys_data *sys)
 
         for (i = 0; i < pcie->nports; i++) {
                 struct mvebu_pcie_port *port = &pcie->ports[i];
+
                 if (!port->base)
                         continue;
                 mvebu_pcie_setup_hw(port);
@@ -774,12 +776,6 @@ static struct pci_bus *mvebu_pcie_scan_bus(int nr, struct pci_sys_data *sys)
         return bus;
 }
 
-static void mvebu_pcie_add_bus(struct pci_bus *bus)
-{
-        struct mvebu_pcie *pcie = sys_to_pcie(bus->sysdata);
-        bus->msi = pcie->msi;
-}
-
 static resource_size_t mvebu_pcie_align_resource(struct pci_dev *dev,
                                                  const struct resource *res,
                                                  resource_size_t start,
@@ -816,6 +812,10 @@ static void mvebu_pcie_enable(struct mvebu_pcie *pcie)
 
         memset(&hw, 0, sizeof(hw));
 
+#ifdef CONFIG_PCI_MSI
+        hw.msi_ctrl = pcie->msi;
+#endif
+
         hw.nr_controllers = 1;
         hw.private_data   = (void **)&pcie;
         hw.setup          = mvebu_pcie_setup;
@@ -823,7 +823,6 @@ static void mvebu_pcie_enable(struct mvebu_pcie *pcie)
         hw.map_irq        = of_irq_parse_and_map_pci;
         hw.ops            = &mvebu_pcie_ops;
         hw.align_resource = mvebu_pcie_align_resource;
-        hw.add_bus        = mvebu_pcie_add_bus;
 
         pci_common_init(&hw);
 }
diff --git a/drivers/pci/host/pci-tegra.c b/drivers/pci/host/pci-tegra.c
index 3d43874319be..feccfa6b6c11 100644
--- a/drivers/pci/host/pci-tegra.c
+++ b/drivers/pci/host/pci-tegra.c
@@ -238,7 +238,7 @@
         )
 
 struct tegra_msi {
-        struct msi_chip chip;
+        struct msi_controller chip;
         DECLARE_BITMAP(used, INT_PCI_MSI_NR);
         struct irq_domain *domain;
         unsigned long pages;
@@ -259,7 +259,7 @@ struct tegra_pcie_soc_data {
         bool has_gen2;
 };
 
-static inline struct tegra_msi *to_tegra_msi(struct msi_chip *chip)
+static inline struct tegra_msi *to_tegra_msi(struct msi_controller *chip)
 {
         return container_of(chip, struct tegra_msi, chip);
 }
@@ -276,6 +276,7 @@ struct tegra_pcie {
 
         struct resource all;
         struct resource io;
+        struct resource pio;
         struct resource mem;
         struct resource prefetch;
         struct resource busn;
@@ -658,7 +659,6 @@ static int tegra_pcie_setup(int nr, struct pci_sys_data *sys)
 {
         struct tegra_pcie *pcie = sys_to_pcie(sys);
         int err;
-        phys_addr_t io_start;
 
         err = devm_request_resource(pcie->dev, &pcie->all, &pcie->mem);
         if (err < 0)
@@ -668,14 +668,12 @@ static int tegra_pcie_setup(int nr, struct pci_sys_data *sys)
         if (err)
                 return err;
 
-        io_start = pci_pio_to_address(pcie->io.start);
-
         pci_add_resource_offset(&sys->resources, &pcie->mem, sys->mem_offset);
         pci_add_resource_offset(&sys->resources, &pcie->prefetch,
                                 sys->mem_offset);
         pci_add_resource(&sys->resources, &pcie->busn);
 
-        pci_ioremap_io(nr * SZ_64K, io_start);
+        pci_ioremap_io(pcie->pio.start, pcie->io.start);
 
         return 1;
 }
@@ -694,15 +692,6 @@ static int tegra_pcie_map_irq(const struct pci_dev *pdev, u8 slot, u8 pin)
         return irq;
 }
 
-static void tegra_pcie_add_bus(struct pci_bus *bus)
-{
-        if (IS_ENABLED(CONFIG_PCI_MSI)) {
-                struct tegra_pcie *pcie = sys_to_pcie(bus->sysdata);
-
-                bus->msi = &pcie->msi.chip;
-        }
-}
-
 static struct pci_bus *tegra_pcie_scan_bus(int nr, struct pci_sys_data *sys)
 {
         struct tegra_pcie *pcie = sys_to_pcie(sys);
@@ -786,7 +775,6 @@ static irqreturn_t tegra_pcie_isr(int irq, void *arg)
 static void tegra_pcie_setup_translations(struct tegra_pcie *pcie)
 {
         u32 fpci_bar, size, axi_address;
-        phys_addr_t io_start = pci_pio_to_address(pcie->io.start);
 
         /* Bar 0: type 1 extended configuration space */
         fpci_bar = 0xfe100000;
@@ -799,7 +787,7 @@ static void tegra_pcie_setup_translations(struct tegra_pcie *pcie)
         /* Bar 1: downstream IO bar */
         fpci_bar = 0xfdfc0000;
         size = resource_size(&pcie->io);
-        axi_address = io_start;
+        axi_address = pcie->io.start;
         afi_writel(pcie, axi_address, AFI_AXI_BAR1_START);
         afi_writel(pcie, size >> 12, AFI_AXI_BAR1_SZ);
         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR1);
@@ -1283,8 +1271,8 @@ static irqreturn_t tegra_pcie_msi_irq(int irq, void *data)
         return processed > 0 ? IRQ_HANDLED : IRQ_NONE;
 }
 
-static int tegra_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
-                               struct msi_desc *desc)
+static int tegra_msi_setup_irq(struct msi_controller *chip,
+                               struct pci_dev *pdev, struct msi_desc *desc)
 {
         struct tegra_msi *msi = to_tegra_msi(chip);
         struct msi_msg msg;
@@ -1308,12 +1296,13 @@ static int tegra_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
         msg.address_hi = 0;
         msg.data = hwirq;
 
-        write_msi_msg(irq, &msg);
+        pci_write_msi_msg(irq, &msg);
 
         return 0;
 }
 
-static void tegra_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
+static void tegra_msi_teardown_irq(struct msi_controller *chip,
+                                   unsigned int irq)
 {
         struct tegra_msi *msi = to_tegra_msi(chip);
         struct irq_data *d = irq_get_irq_data(irq);
@@ -1325,10 +1314,10 @@ static void tegra_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
 
 static struct irq_chip tegra_msi_irq_chip = {
         .name = "Tegra PCIe MSI",
-        .irq_enable = unmask_msi_irq,
-        .irq_disable = mask_msi_irq,
-        .irq_mask = mask_msi_irq,
-        .irq_unmask = unmask_msi_irq,
+        .irq_enable = pci_msi_unmask_irq,
+        .irq_disable = pci_msi_mask_irq,
+        .irq_mask = pci_msi_mask_irq,
+        .irq_unmask = pci_msi_unmask_irq,
 };
 
 static int tegra_msi_map(struct irq_domain *domain, unsigned int irq,
@@ -1690,8 +1679,23 @@ static int tegra_pcie_parse_dt(struct tegra_pcie *pcie)
 
                 switch (res.flags & IORESOURCE_TYPE_BITS) {
                 case IORESOURCE_IO:
-                        memcpy(&pcie->io, &res, sizeof(res));
-                        pcie->io.name = np->full_name;
+                        memcpy(&pcie->pio, &res, sizeof(res));
+                        pcie->pio.name = np->full_name;
+
+                        /*
+                         * The Tegra PCIe host bridge uses this to program the
+                         * mapping of the I/O space to the physical address,
+                         * so we override the .start and .end fields here that
+                         * of_pci_range_to_resource() converted to I/O space.
+                         * We also set the IORESOURCE_MEM type to clarify that
+                         * the resource is in the physical memory space.
+                         */
+                        pcie->io.start = range.cpu_addr;
+                        pcie->io.end = range.cpu_addr + range.size - 1;
+                        pcie->io.flags = IORESOURCE_MEM;
+                        pcie->io.name = "I/O";
+
+                        memcpy(&res, &pcie->io, sizeof(res));
                         break;
 
                 case IORESOURCE_MEM:
@@ -1881,11 +1885,14 @@ static int tegra_pcie_enable(struct tegra_pcie *pcie)
 
         memset(&hw, 0, sizeof(hw));
 
+#ifdef CONFIG_PCI_MSI
+        hw.msi_ctrl = &pcie->msi.chip;
+#endif
+
         hw.nr_controllers = 1;
         hw.private_data = (void **)&pcie;
         hw.setup = tegra_pcie_setup;
         hw.map_irq = tegra_pcie_map_irq;
-        hw.add_bus = tegra_pcie_add_bus;
         hw.scan = tegra_pcie_scan_bus;
         hw.ops = &tegra_pcie_ops;
 
diff --git a/drivers/pci/host/pcie-designware.c b/drivers/pci/host/pcie-designware.c
index dfed00aa3ac0..df781cdf13c1 100644
--- a/drivers/pci/host/pcie-designware.c
+++ b/drivers/pci/host/pcie-designware.c
@@ -152,10 +152,10 @@ static int dw_pcie_wr_own_conf(struct pcie_port *pp, int where, int size,
 
 static struct irq_chip dw_msi_irq_chip = {
         .name = "PCI-MSI",
-        .irq_enable = unmask_msi_irq,
-        .irq_disable = mask_msi_irq,
-        .irq_mask = mask_msi_irq,
-        .irq_unmask = unmask_msi_irq,
+        .irq_enable = pci_msi_unmask_irq,
+        .irq_disable = pci_msi_mask_irq,
+        .irq_mask = pci_msi_mask_irq,
+        .irq_unmask = pci_msi_unmask_irq,
 };
 
 /* MSI int handler */
@@ -276,7 +276,7 @@ no_valid_irq:
         return -ENOSPC;
 }
 
-static int dw_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
+static int dw_msi_setup_irq(struct msi_controller *chip, struct pci_dev *pdev,
                         struct msi_desc *desc)
 {
         int irq, pos;
@@ -298,12 +298,12 @@ static int dw_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
         else
                 msg.data = pos;
 
-        write_msi_msg(irq, &msg);
+        pci_write_msi_msg(irq, &msg);
 
         return 0;
 }
 
-static void dw_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
+static void dw_msi_teardown_irq(struct msi_controller *chip, unsigned int irq)
 {
         struct irq_data *data = irq_get_irq_data(irq);
         struct msi_desc *msi = irq_data_get_msi(data);
@@ -312,7 +312,7 @@ static void dw_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
         clear_irq_range(pp, irq, 1, data->hwirq);
 }
 
-static struct msi_chip dw_pcie_msi_chip = {
+static struct msi_controller dw_pcie_msi_chip = {
         .setup_irq = dw_msi_setup_irq,
         .teardown_irq = dw_msi_teardown_irq,
 };
@@ -380,6 +380,7 @@ int __init dw_pcie_host_init(struct pcie_port *pp)
         /* Get the I/O and memory ranges from DT */
         for_each_of_pci_range(&parser, &range) {
                 unsigned long restype = range.flags & IORESOURCE_TYPE_BITS;
+
                 if (restype == IORESOURCE_IO) {
                         of_pci_range_to_resource(&range, np, &pp->io);
                         pp->io.name = "I/O";
@@ -498,6 +499,11 @@ int __init dw_pcie_host_init(struct pcie_port *pp)
         val |= PORT_LOGIC_SPEED_CHANGE;
         dw_pcie_wr_own_conf(pp, PCIE_LINK_WIDTH_SPEED_CONTROL, 4, val);
 
+#ifdef CONFIG_PCI_MSI
+        dw_pcie_msi_chip.dev = pp->dev;
+        dw_pci.msi_ctrl = &dw_pcie_msi_chip;
+#endif
+
         dw_pci.nr_controllers = 1;
         dw_pci.private_data = (void **)&pp;
 
@@ -747,21 +753,10 @@ static int dw_pcie_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
         return irq;
 }
 
-static void dw_pcie_add_bus(struct pci_bus *bus)
-{
-        if (IS_ENABLED(CONFIG_PCI_MSI)) {
-                struct pcie_port *pp = sys_to_pcie(bus->sysdata);
-
-                dw_pcie_msi_chip.dev = pp->dev;
-                bus->msi = &dw_pcie_msi_chip;
-        }
-}
-
 static struct hw_pci dw_pci = {
         .setup          = dw_pcie_setup,
         .scan           = dw_pcie_scan_bus,
         .map_irq        = dw_pcie_map_irq,
-        .add_bus        = dw_pcie_add_bus,
 };
 
 void dw_pcie_setup_rc(struct pcie_port *pp)
diff --git a/drivers/pci/host/pcie-designware.h b/drivers/pci/host/pcie-designware.h
index c6256751daff..d0bbd276840d 100644
--- a/drivers/pci/host/pcie-designware.h
+++ b/drivers/pci/host/pcie-designware.h
@@ -73,7 +73,7 @@ struct pcie_host_ops {
         u32 (*get_msi_addr)(struct pcie_port *pp);
         u32 (*get_msi_data)(struct pcie_port *pp, int pos);
         void (*scan_bus)(struct pcie_port *pp);
-        int (*msi_host_init)(struct pcie_port *pp, struct msi_chip *chip);
+        int (*msi_host_init)(struct pcie_port *pp, struct msi_controller *chip);
 };
 
 int dw_pcie_cfg_read(void __iomem *addr, int where, int size, u32 *val);
diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
index 61158e03ab5f..5519e939e412 100644
--- a/drivers/pci/host/pcie-rcar.c
+++ b/drivers/pci/host/pcie-rcar.c
@@ -111,14 +111,14 @@
 struct rcar_msi {
         DECLARE_BITMAP(used, INT_PCI_MSI_NR);
         struct irq_domain *domain;
-        struct msi_chip chip;
+        struct msi_controller chip;
         unsigned long pages;
         struct mutex lock;
         int irq1;
         int irq2;
 };
 
-static inline struct rcar_msi *to_rcar_msi(struct msi_chip *chip)
+static inline struct rcar_msi *to_rcar_msi(struct msi_controller *chip)
 {
         return container_of(chip, struct rcar_msi, chip);
 }
@@ -380,20 +380,10 @@ static int rcar_pcie_setup(int nr, struct pci_sys_data *sys)
         return 1;
 }
 
-static void rcar_pcie_add_bus(struct pci_bus *bus)
-{
-        if (IS_ENABLED(CONFIG_PCI_MSI)) {
-                struct rcar_pcie *pcie = sys_to_pcie(bus->sysdata);
-
-                bus->msi = &pcie->msi.chip;
-        }
-}
-
-struct hw_pci rcar_pci = {
+static struct hw_pci rcar_pci = {
         .setup          = rcar_pcie_setup,
         .map_irq        = of_irq_parse_and_map_pci,
         .ops            = &rcar_pcie_ops,
-        .add_bus        = rcar_pcie_add_bus,
 };
 
 static void rcar_pcie_enable(struct rcar_pcie *pcie)
@@ -402,6 +392,9 @@ static void rcar_pcie_enable(struct rcar_pcie *pcie)
 
         rcar_pci.nr_controllers = 1;
         rcar_pci.private_data = (void **)&pcie;
+#ifdef CONFIG_PCI_MSI
+        rcar_pci.msi_ctrl = &pcie->msi.chip;
+#endif
 
         pci_common_init_dev(&pdev->dev, &rcar_pci);
 #ifdef CONFIG_PCI_DOMAINS
@@ -622,7 +615,7 @@ static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
         return IRQ_HANDLED;
 }
 
-static int rcar_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
+static int rcar_msi_setup_irq(struct msi_controller *chip, struct pci_dev *pdev,
                               struct msi_desc *desc)
 {
         struct rcar_msi *msi = to_rcar_msi(chip);
@@ -647,12 +640,12 @@ static int rcar_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
         msg.address_hi = rcar_pci_read_reg(pcie, PCIEMSIAUR);
         msg.data = hwirq;
 
-        write_msi_msg(irq, &msg);
+        pci_write_msi_msg(irq, &msg);
 
         return 0;
 }
 
-static void rcar_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
+static void rcar_msi_teardown_irq(struct msi_controller *chip, unsigned int irq)
 {
         struct rcar_msi *msi = to_rcar_msi(chip);
         struct irq_data *d = irq_get_irq_data(irq);
@@ -662,10 +655,10 @@ static void rcar_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
 
 static struct irq_chip rcar_msi_irq_chip = {
         .name = "R-Car PCIe MSI",
-        .irq_enable = unmask_msi_irq,
-        .irq_disable = mask_msi_irq,
-        .irq_mask = mask_msi_irq,
-        .irq_unmask = unmask_msi_irq,
+        .irq_enable = pci_msi_unmask_irq,
+        .irq_disable = pci_msi_mask_irq,
+        .irq_mask = pci_msi_mask_irq,
+        .irq_unmask = pci_msi_unmask_irq,
 };
 
 static int rcar_msi_map(struct irq_domain *domain, unsigned int irq,
diff --git a/drivers/pci/host/pcie-spear13xx.c b/drivers/pci/host/pcie-spear13xx.c
index 85f594e1708f..2ca10cc887ee 100644
--- a/drivers/pci/host/pcie-spear13xx.c
+++ b/drivers/pci/host/pcie-spear13xx.c
@@ -269,7 +269,8 @@ static struct pcie_host_ops spear13xx_pcie_host_ops = {
         .host_init = spear13xx_pcie_host_init,
 };
 
-static int add_pcie_port(struct pcie_port *pp, struct platform_device *pdev)
+static int __init spear13xx_add_pcie_port(struct pcie_port *pp,
+                                         struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         int ret;
@@ -308,10 +309,8 @@ static int __init spear13xx_pcie_probe(struct platform_device *pdev)
         int ret;
 
         spear13xx_pcie = devm_kzalloc(dev, sizeof(*spear13xx_pcie), GFP_KERNEL);
-        if (!spear13xx_pcie) {
-                dev_err(dev, "no memory for SPEAr13xx pcie\n");
+        if (!spear13xx_pcie)
                 return -ENOMEM;
-        }
 
         spear13xx_pcie->phy = devm_phy_get(dev, "pcie-phy");
         if (IS_ERR(spear13xx_pcie->phy)) {
@@ -352,7 +351,7 @@ static int __init spear13xx_pcie_probe(struct platform_device *pdev)
         if (of_property_read_bool(np, "st,pcie-is-gen1"))
                 spear13xx_pcie->is_gen1 = true;
 
-        ret = add_pcie_port(pp, pdev);
+        ret = spear13xx_add_pcie_port(pp, pdev);
         if (ret < 0)
                 goto fail_clk;
 
@@ -382,11 +381,11 @@ static struct platform_driver spear13xx_pcie_driver __initdata = {
 
 /* SPEAr13xx PCIe driver does not allow module unload */
 
-static int __init pcie_init(void)
+static int __init spear13xx_pcie_init(void)
 {
         return platform_driver_register(&spear13xx_pcie_driver);
 }
-module_init(pcie_init);
+module_init(spear13xx_pcie_init);
 
 MODULE_DESCRIPTION("ST Microelectronics SPEAr13xx PCIe host controller driver");
 MODULE_AUTHOR("Pratyush Anand <pratyush.anand@st.com>");
diff --git a/drivers/pci/host/pcie-xilinx.c b/drivers/pci/host/pcie-xilinx.c
index ccc496b33a97..2f50fa5953fd 100644
--- a/drivers/pci/host/pcie-xilinx.c
+++ b/drivers/pci/host/pcie-xilinx.c
@@ -335,7 +335,8 @@ static int xilinx_pcie_assign_msi(struct xilinx_pcie_port *port)
  * @chip: MSI Chip descriptor
  * @irq: MSI IRQ to destroy
  */
-static void xilinx_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
+static void xilinx_msi_teardown_irq(struct msi_controller *chip,
+                                    unsigned int irq)
 {
         xilinx_pcie_destroy_msi(irq);
 }
@@ -348,7 +349,7 @@ static void xilinx_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
  *
  * Return: '0' on success and error value on failure
  */
-static int xilinx_pcie_msi_setup_irq(struct msi_chip *chip,
+static int xilinx_pcie_msi_setup_irq(struct msi_controller *chip,
                                      struct pci_dev *pdev,
                                      struct msi_desc *desc)
 {
@@ -374,13 +375,13 @@ static int xilinx_pcie_msi_setup_irq(struct msi_chip *chip,
         msg.address_lo = msg_addr;
         msg.data = irq;
 
-        write_msi_msg(irq, &msg);
+        pci_write_msi_msg(irq, &msg);
 
         return 0;
 }
 
 /* MSI Chip Descriptor */
-static struct msi_chip xilinx_pcie_msi_chip = {
+static struct msi_controller xilinx_pcie_msi_chip = {
         .setup_irq = xilinx_pcie_msi_setup_irq,
         .teardown_irq = xilinx_msi_teardown_irq,
 };
@@ -388,10 +389,10 @@ static struct msi_chip xilinx_pcie_msi_chip = {
 /* HW Interrupt Chip Descriptor */
 static struct irq_chip xilinx_msi_irq_chip = {
         .name = "Xilinx PCIe MSI",
-        .irq_enable = unmask_msi_irq,
-        .irq_disable = mask_msi_irq,
-        .irq_mask = mask_msi_irq,
-        .irq_unmask = unmask_msi_irq,
+        .irq_enable = pci_msi_unmask_irq,
+        .irq_disable = pci_msi_mask_irq,
+        .irq_mask = pci_msi_mask_irq,
+        .irq_unmask = pci_msi_unmask_irq,
 };
 
 /**
@@ -431,20 +432,6 @@ static void xilinx_pcie_enable_msi(struct xilinx_pcie_port *port)
         pcie_write(port, msg_addr, XILINX_PCIE_REG_MSIBASE2);
 }
 
-/**
- * xilinx_pcie_add_bus - Add MSI chip info to PCIe bus
- * @bus: PCIe bus
- */
-static void xilinx_pcie_add_bus(struct pci_bus *bus)
-{
-        if (IS_ENABLED(CONFIG_PCI_MSI)) {
-                struct xilinx_pcie_port *port = sys_to_pcie(bus->sysdata);
-
-                xilinx_pcie_msi_chip.dev = port->dev;
-                bus->msi = &xilinx_pcie_msi_chip;
-        }
-}
-
 /* INTx Functions */
 
 /**
@@ -924,10 +911,14 @@ static int xilinx_pcie_probe(struct platform_device *pdev)
                 .private_data   = (void **)&port,
                 .setup          = xilinx_pcie_setup,
                 .map_irq        = of_irq_parse_and_map_pci,
-                .add_bus        = xilinx_pcie_add_bus,
                 .scan           = xilinx_pcie_scan_bus,
                 .ops            = &xilinx_pcie_ops,
         };
+
+#ifdef CONFIG_PCI_MSI
+        xilinx_pcie_msi_chip.dev = port->dev;
+        hw.msi_ctrl = &xilinx_pcie_msi_chip;
+#endif
         pci_common_init_dev(dev, &hw);
 
         return 0;
diff --git a/drivers/pci/hotplug/ibmphp_res.c b/drivers/pci/hotplug/ibmphp_res.c
index 219ba8090a37..f279060cf6e2 100644
--- a/drivers/pci/hotplug/ibmphp_res.c
+++ b/drivers/pci/hotplug/ibmphp_res.c
@@ -376,10 +376,7 @@ int __init ibmphp_rsrc_init (void)
                 if (rc)
                         return rc;
         }
-        rc = once_over ();  /* This is to align ranges (so no -1) */
-        if (rc)
-                return rc;
-        return 0;
+        return once_over ();    /* This is to align ranges (so no -1) */
 }
 
 /********************************************************************************
diff --git a/drivers/pci/iov.c b/drivers/pci/iov.c
index 4d109c07294a..4b3a4eaad996 100644
--- a/drivers/pci/iov.c
+++ b/drivers/pci/iov.c
@@ -479,20 +479,16 @@ void pci_iov_release(struct pci_dev *dev)
  * pci_iov_resource_bar - get position of the SR-IOV BAR
  * @dev: the PCI device
  * @resno: the resource number
- * @type: the BAR type to be filled in
  *
  * Returns position of the BAR encapsulated in the SR-IOV capability.
  */
-int pci_iov_resource_bar(struct pci_dev *dev, int resno,
-                         enum pci_bar_type *type)
+int pci_iov_resource_bar(struct pci_dev *dev, int resno)
 {
         if (resno < PCI_IOV_RESOURCES || resno > PCI_IOV_RESOURCE_END)
                 return 0;
 
         BUG_ON(!dev->is_physfn);
 
-        *type = pci_bar_unknown;
-
         return dev->sriov->pos + PCI_SRIOV_BAR +
                 4 * (resno - PCI_IOV_RESOURCES);
 }
@@ -510,13 +506,12 @@ int pci_iov_resource_bar(struct pci_dev *dev, int resno,
 resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno)
 {
         struct resource tmp;
-        enum pci_bar_type type;
-        int reg = pci_iov_resource_bar(dev, resno, &type);
+        int reg = pci_iov_resource_bar(dev, resno);
 
         if (!reg)
                 return 0;
 
-         __pci_read_base(dev, type, &tmp, reg);
+         __pci_read_base(dev, pci_bar_unknown, &tmp, reg);
         return resource_alignment(&tmp);
 }
 
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 9fab30af0e75..fd60806d3fd0 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -19,19 +19,82 @@
 #include <linux/errno.h>
 #include <linux/io.h>
 #include <linux/slab.h>
+#include <linux/irqdomain.h>
 
 #include "pci.h"
 
 static int pci_msi_enable = 1;
+int pci_msi_ignore_mask;
 
 #define msix_table_size(flags)  ((flags & PCI_MSIX_FLAGS_QSIZE) + 1)
 
+#ifdef CONFIG_PCI_MSI_IRQ_DOMAIN
+static struct irq_domain *pci_msi_default_domain;
+static DEFINE_MUTEX(pci_msi_domain_lock);
+
+struct irq_domain * __weak arch_get_pci_msi_domain(struct pci_dev *dev)
+{
+        return pci_msi_default_domain;
+}
+
+static struct irq_domain *pci_msi_get_domain(struct pci_dev *dev)
+{
+        struct irq_domain *domain = NULL;
+
+        if (dev->bus->msi)
+                domain = dev->bus->msi->domain;
+        if (!domain)
+                domain = arch_get_pci_msi_domain(dev);
+
+        return domain;
+}
+
+static int pci_msi_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
+{
+        struct irq_domain *domain;
+
+        domain = pci_msi_get_domain(dev);
+        if (domain)
+                return pci_msi_domain_alloc_irqs(domain, dev, nvec, type);
+
+        return arch_setup_msi_irqs(dev, nvec, type);
+}
+
+static void pci_msi_teardown_msi_irqs(struct pci_dev *dev)
+{
+        struct irq_domain *domain;
+
+        domain = pci_msi_get_domain(dev);
+        if (domain)
+                pci_msi_domain_free_irqs(domain, dev);
+        else
+                arch_teardown_msi_irqs(dev);
+}
+#else
+#define pci_msi_setup_msi_irqs          arch_setup_msi_irqs
+#define pci_msi_teardown_msi_irqs       arch_teardown_msi_irqs
+#endif
 
 /* Arch hooks */
 
+struct msi_controller * __weak pcibios_msi_controller(struct pci_dev *dev)
+{
+        return NULL;
+}
+
+static struct msi_controller *pci_msi_controller(struct pci_dev *dev)
+{
+        struct msi_controller *msi_ctrl = dev->bus->msi;
+
+        if (msi_ctrl)
+                return msi_ctrl;
+
+        return pcibios_msi_controller(dev);
+}
+
 int __weak arch_setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc)
 {
-        struct msi_chip *chip = dev->bus->msi;
+        struct msi_controller *chip = pci_msi_controller(dev);
         int err;
 
         if (!chip || !chip->setup_irq)
@@ -48,7 +111,7 @@ int __weak arch_setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc)
 
 void __weak arch_teardown_msi_irq(unsigned int irq)
 {
-        struct msi_chip *chip = irq_get_chip_data(irq);
+        struct msi_controller *chip = irq_get_chip_data(irq);
 
         if (!chip || !chip->teardown_irq)
                 return;
@@ -85,19 +148,13 @@ int __weak arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
  */
 void default_teardown_msi_irqs(struct pci_dev *dev)
 {
+        int i;
         struct msi_desc *entry;
 
-        list_for_each_entry(entry, &dev->msi_list, list) {
-                int i, nvec;
-                if (entry->irq == 0)
-                        continue;
-                if (entry->nvec_used)
-                        nvec = entry->nvec_used;
-                else
-                        nvec = 1 << entry->msi_attrib.multiple;
-                for (i = 0; i < nvec; i++)
-                        arch_teardown_msi_irq(entry->irq + i);
-        }
+        list_for_each_entry(entry, &dev->msi_list, list)
+                if (entry->irq)
+                        for (i = 0; i < entry->nvec_used; i++)
+                                arch_teardown_msi_irq(entry->irq + i);
 }
 
 void __weak arch_teardown_msi_irqs(struct pci_dev *dev)
@@ -120,7 +177,7 @@ static void default_restore_msi_irq(struct pci_dev *dev, int irq)
         }
 
         if (entry)
-                __write_msi_msg(entry, &entry->msg);
+                __pci_write_msi_msg(entry, &entry->msg);
 }
 
 void __weak arch_restore_msi_irqs(struct pci_dev *dev)
@@ -163,11 +220,11 @@ static inline __attribute_const__ u32 msi_mask(unsigned x)
  * reliably as devices without an INTx disable bit will then generate a
  * level IRQ which will never be cleared.
  */
-u32 default_msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
+u32 __pci_msi_desc_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
 {
         u32 mask_bits = desc->masked;
 
-        if (!desc->msi_attrib.maskbit)
+        if (pci_msi_ignore_mask || !desc->msi_attrib.maskbit)
                 return 0;
 
         mask_bits &= ~mask;
@@ -177,14 +234,9 @@ u32 default_msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
         return mask_bits;
 }
 
-__weak u32 arch_msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
-{
-        return default_msi_mask_irq(desc, mask, flag);
-}
-
 static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
 {
-        desc->masked = arch_msi_mask_irq(desc, mask, flag);
+        desc->masked = __pci_msi_desc_mask_irq(desc, mask, flag);
 }
 
 /*
@@ -194,11 +246,15 @@ static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
  * file.  This saves a few milliseconds when initialising devices with lots
  * of MSI-X interrupts.
  */
-u32 default_msix_mask_irq(struct msi_desc *desc, u32 flag)
+u32 __pci_msix_desc_mask_irq(struct msi_desc *desc, u32 flag)
 {
         u32 mask_bits = desc->masked;
         unsigned offset = desc->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
                                                 PCI_MSIX_ENTRY_VECTOR_CTRL;
+
+        if (pci_msi_ignore_mask)
+                return 0;
+
         mask_bits &= ~PCI_MSIX_ENTRY_CTRL_MASKBIT;
         if (flag)
                 mask_bits |= PCI_MSIX_ENTRY_CTRL_MASKBIT;
@@ -207,14 +263,9 @@ u32 default_msix_mask_irq(struct msi_desc *desc, u32 flag)
         return mask_bits;
 }
 
-__weak u32 arch_msix_mask_irq(struct msi_desc *desc, u32 flag)
-{
-        return default_msix_mask_irq(desc, flag);
-}
-
 static void msix_mask_irq(struct msi_desc *desc, u32 flag)
 {
-        desc->masked = arch_msix_mask_irq(desc, flag);
+        desc->masked = __pci_msix_desc_mask_irq(desc, flag);
 }
 
 static void msi_set_mask_bit(struct irq_data *data, u32 flag)
@@ -230,12 +281,20 @@ static void msi_set_mask_bit(struct irq_data *data, u32 flag)
         }
 }
 
-void mask_msi_irq(struct irq_data *data)
+/**
+ * pci_msi_mask_irq - Generic irq chip callback to mask PCI/MSI interrupts
+ * @data:       pointer to irqdata associated to that interrupt
+ */
+void pci_msi_mask_irq(struct irq_data *data)
 {
         msi_set_mask_bit(data, 1);
 }
 
-void unmask_msi_irq(struct irq_data *data)
+/**
+ * pci_msi_unmask_irq - Generic irq chip callback to unmask PCI/MSI interrupts
+ * @data:       pointer to irqdata associated to that interrupt
+ */
+void pci_msi_unmask_irq(struct irq_data *data)
 {
         msi_set_mask_bit(data, 0);
 }
@@ -244,12 +303,11 @@ void default_restore_msi_irqs(struct pci_dev *dev)
 {
         struct msi_desc *entry;
 
-        list_for_each_entry(entry, &dev->msi_list, list) {
+        list_for_each_entry(entry, &dev->msi_list, list)
                 default_restore_msi_irq(dev, entry->irq);
-        }
 }
 
-void __read_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
+void __pci_read_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
         BUG_ON(entry->dev->current_state != PCI_D0);
 
@@ -279,32 +337,7 @@ void __read_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
         }
 }
 
-void read_msi_msg(unsigned int irq, struct msi_msg *msg)
-{
-        struct msi_desc *entry = irq_get_msi_desc(irq);
-
-        __read_msi_msg(entry, msg);
-}
-
-void __get_cached_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
-{
-        /* Assert that the cache is valid, assuming that
-         * valid messages are not all-zeroes. */
-        BUG_ON(!(entry->msg.address_hi | entry->msg.address_lo |
-                 entry->msg.data));
-
-        *msg = entry->msg;
-}
-
-void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg)
-{
-        struct msi_desc *entry = irq_get_msi_desc(irq);
-
-        __get_cached_msi_msg(entry, msg);
-}
-EXPORT_SYMBOL_GPL(get_cached_msi_msg);
-
-void __write_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
+void __pci_write_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
         if (entry->dev->current_state != PCI_D0) {
                 /* Don't touch the hardware now */
@@ -341,34 +374,27 @@ void __write_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
         entry->msg = *msg;
 }
 
-void write_msi_msg(unsigned int irq, struct msi_msg *msg)
+void pci_write_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
         struct msi_desc *entry = irq_get_msi_desc(irq);
 
-        __write_msi_msg(entry, msg);
+        __pci_write_msi_msg(entry, msg);
 }
-EXPORT_SYMBOL_GPL(write_msi_msg);
+EXPORT_SYMBOL_GPL(pci_write_msi_msg);
 
 static void free_msi_irqs(struct pci_dev *dev)
 {
         struct msi_desc *entry, *tmp;
         struct attribute **msi_attrs;
         struct device_attribute *dev_attr;
-        int count = 0;
+        int i, count = 0;
 
-        list_for_each_entry(entry, &dev->msi_list, list) {
-                int i, nvec;
-                if (!entry->irq)
-                        continue;
-                if (entry->nvec_used)
-                        nvec = entry->nvec_used;
-                else
-                        nvec = 1 << entry->msi_attrib.multiple;
-                for (i = 0; i < nvec; i++)
-                        BUG_ON(irq_has_action(entry->irq + i));
-        }
+        list_for_each_entry(entry, &dev->msi_list, list)
+                if (entry->irq)
+                        for (i = 0; i < entry->nvec_used; i++)
+                                BUG_ON(irq_has_action(entry->irq + i));
 
-        arch_teardown_msi_irqs(dev);
+        pci_msi_teardown_msi_irqs(dev);
 
         list_for_each_entry_safe(entry, tmp, &dev->msi_list, list) {
                 if (entry->msi_attrib.is_msix) {
@@ -451,9 +477,8 @@ static void __pci_restore_msix_state(struct pci_dev *dev)
                                 PCI_MSIX_FLAGS_ENABLE | PCI_MSIX_FLAGS_MASKALL);
 
         arch_restore_msi_irqs(dev);
-        list_for_each_entry(entry, &dev->msi_list, list) {
+        list_for_each_entry(entry, &dev->msi_list, list)
                 msix_mask_irq(entry, entry->masked);
-        }
 
         msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_MASKALL, 0);
 }
@@ -497,9 +522,8 @@ static int populate_msi_sysfs(struct pci_dev *pdev)
         int count = 0;
 
         /* Determine how many msi entries we have */
-        list_for_each_entry(entry, &pdev->msi_list, list) {
+        list_for_each_entry(entry, &pdev->msi_list, list)
                 ++num_msi;
-        }
         if (!num_msi)
                 return 0;
 
@@ -559,7 +583,7 @@ error_attrs:
         return ret;
 }
 
-static struct msi_desc *msi_setup_entry(struct pci_dev *dev)
+static struct msi_desc *msi_setup_entry(struct pci_dev *dev, int nvec)
 {
         u16 control;
         struct msi_desc *entry;
@@ -577,6 +601,8 @@ static struct msi_desc *msi_setup_entry(struct pci_dev *dev)
         entry->msi_attrib.maskbit       = !!(control & PCI_MSI_FLAGS_MASKBIT);
         entry->msi_attrib.default_irq   = dev->irq;     /* Save IOAPIC IRQ */
         entry->msi_attrib.multi_cap     = (control & PCI_MSI_FLAGS_QMASK) >> 1;
+        entry->msi_attrib.multiple      = ilog2(__roundup_pow_of_two(nvec));
+        entry->nvec_used                = nvec;
 
         if (control & PCI_MSI_FLAGS_64BIT)
                 entry->mask_pos = dev->msi_cap + PCI_MSI_MASK_64;
@@ -590,6 +616,20 @@ static struct msi_desc *msi_setup_entry(struct pci_dev *dev)
         return entry;
 }
 
+static int msi_verify_entries(struct pci_dev *dev)
+{
+        struct msi_desc *entry;
+
+        list_for_each_entry(entry, &dev->msi_list, list) {
+                if (!dev->no_64bit_msi || !entry->msg.address_hi)
+                        continue;
+                dev_err(&dev->dev, "Device has broken 64-bit MSI but arch"
+                        " tried to assign one above 4G\n");
+                return -EIO;
+        }
+        return 0;
+}
+
 /**
  * msi_capability_init - configure device's MSI capability structure
  * @dev: pointer to the pci_dev data structure of MSI device function
@@ -609,7 +649,7 @@ static int msi_capability_init(struct pci_dev *dev, int nvec)
 
         msi_set_enable(dev, 0); /* Disable MSI during set up */
 
-        entry = msi_setup_entry(dev);
+        entry = msi_setup_entry(dev, nvec);
         if (!entry)
                 return -ENOMEM;
 
@@ -620,7 +660,14 @@ static int msi_capability_init(struct pci_dev *dev, int nvec)
         list_add_tail(&entry->list, &dev->msi_list);
 
         /* Configure MSI capability structure */
-        ret = arch_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSI);
+        ret = pci_msi_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSI);
+        if (ret) {
+                msi_mask_irq(entry, mask, ~mask);
+                free_msi_irqs(dev);
+                return ret;
+        }
+
+        ret = msi_verify_entries(dev);
         if (ret) {
                 msi_mask_irq(entry, mask, ~mask);
                 free_msi_irqs(dev);
@@ -680,6 +727,7 @@ static int msix_setup_entries(struct pci_dev *dev, void __iomem *base,
                 entry->msi_attrib.entry_nr      = entries[i].entry;
                 entry->msi_attrib.default_irq   = dev->irq;
                 entry->mask_base                = base;
+                entry->nvec_used                = 1;
 
                 list_add_tail(&entry->list, &dev->msi_list);
         }
@@ -698,7 +746,6 @@ static void msix_program_entries(struct pci_dev *dev,
                                                 PCI_MSIX_ENTRY_VECTOR_CTRL;
 
                 entries[i].vector = entry->irq;
-                irq_set_msi_desc(entry->irq, entry);
                 entry->masked = readl(entry->mask_base + offset);
                 msix_mask_irq(entry, 1);
                 i++;
@@ -735,10 +782,15 @@ static int msix_capability_init(struct pci_dev *dev,
         if (ret)
                 return ret;
 
-        ret = arch_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSIX);
+        ret = pci_msi_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSIX);
         if (ret)
                 goto out_avail;
 
+        /* Check if all MSI entries honor device restrictions */
+        ret = msi_verify_entries(dev);
+        if (ret)
+                goto out_free;
+
         /*
          * Some devices require MSI-X to be enabled before we can touch the
          * MSI-X registers.  We need to mask all the vectors to prevent
@@ -869,7 +921,7 @@ void pci_msi_shutdown(struct pci_dev *dev)
         /* Return the device with MSI unmasked as initial states */
         mask = msi_mask(desc->msi_attrib.multi_cap);
         /* Keep cached state to be restored */
-        arch_msi_mask_irq(desc, mask, ~mask);
+        __pci_msi_desc_mask_irq(desc, mask, ~mask);
 
         /* Restore dev->irq to its default pin-assertion irq */
         dev->irq = desc->msi_attrib.default_irq;
@@ -967,7 +1019,7 @@ void pci_msix_shutdown(struct pci_dev *dev)
         /* Return the device with MSI-X masked as initial states */
         list_for_each_entry(entry, &dev->msi_list, list) {
                 /* Keep cached states to be restored */
-                arch_msix_mask_irq(entry, 1);
+                __pci_msix_desc_mask_irq(entry, 1);
         }
 
         msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_ENABLE, 0);
@@ -1112,3 +1164,197 @@ int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
         return nvec;
 }
 EXPORT_SYMBOL(pci_enable_msix_range);
+
+#ifdef CONFIG_PCI_MSI_IRQ_DOMAIN
+/**
+ * pci_msi_domain_write_msg - Helper to write MSI message to PCI config space
+ * @irq_data:   Pointer to interrupt data of the MSI interrupt
+ * @msg:        Pointer to the message
+ */
+void pci_msi_domain_write_msg(struct irq_data *irq_data, struct msi_msg *msg)
+{
+        struct msi_desc *desc = irq_data->msi_desc;
+
+        /*
+         * For MSI-X desc->irq is always equal to irq_data->irq. For
+         * MSI only the first interrupt of MULTI MSI passes the test.
+         */
+        if (desc->irq == irq_data->irq)
+                __pci_write_msi_msg(desc, msg);
+}
+
+/**
+ * pci_msi_domain_calc_hwirq - Generate a unique ID for an MSI source
+ * @dev:        Pointer to the PCI device
+ * @desc:       Pointer to the msi descriptor
+ *
+ * The ID number is only used within the irqdomain.
+ */
+irq_hw_number_t pci_msi_domain_calc_hwirq(struct pci_dev *dev,
+                                          struct msi_desc *desc)
+{
+        return (irq_hw_number_t)desc->msi_attrib.entry_nr |
+                PCI_DEVID(dev->bus->number, dev->devfn) << 11 |
+                (pci_domain_nr(dev->bus) & 0xFFFFFFFF) << 27;
+}
+
+static inline bool pci_msi_desc_is_multi_msi(struct msi_desc *desc)
+{
+        return !desc->msi_attrib.is_msix && desc->nvec_used > 1;
+}
+
+/**
+ * pci_msi_domain_check_cap - Verify that @domain supports the capabilities for @dev
+ * @domain:     The interrupt domain to check
+ * @info:       The domain info for verification
+ * @dev:        The device to check
+ *
+ * Returns:
+ *  0 if the functionality is supported
+ *  1 if Multi MSI is requested, but the domain does not support it
+ *  -ENOTSUPP otherwise
+ */
+int pci_msi_domain_check_cap(struct irq_domain *domain,
+                             struct msi_domain_info *info, struct device *dev)
+{
+        struct msi_desc *desc = first_pci_msi_entry(to_pci_dev(dev));
+
+        /* Special handling to support pci_enable_msi_range() */
+        if (pci_msi_desc_is_multi_msi(desc) &&
+            !(info->flags & MSI_FLAG_MULTI_PCI_MSI))
+                return 1;
+        else if (desc->msi_attrib.is_msix && !(info->flags & MSI_FLAG_PCI_MSIX))
+                return -ENOTSUPP;
+
+        return 0;
+}
+
+static int pci_msi_domain_handle_error(struct irq_domain *domain,
+                                       struct msi_desc *desc, int error)
+{
+        /* Special handling to support pci_enable_msi_range() */
+        if (pci_msi_desc_is_multi_msi(desc) && error == -ENOSPC)
+                return 1;
+
+        return error;
+}
+
+#ifdef GENERIC_MSI_DOMAIN_OPS
+static void pci_msi_domain_set_desc(msi_alloc_info_t *arg,
+                                    struct msi_desc *desc)
+{
+        arg->desc = desc;
+        arg->hwirq = pci_msi_domain_calc_hwirq(msi_desc_to_pci_dev(desc),
+                                               desc);
+}
+#else
+#define pci_msi_domain_set_desc         NULL
+#endif
+
+static struct msi_domain_ops pci_msi_domain_ops_default = {
+        .set_desc       = pci_msi_domain_set_desc,
+        .msi_check      = pci_msi_domain_check_cap,
+        .handle_error   = pci_msi_domain_handle_error,
+};
+
+static void pci_msi_domain_update_dom_ops(struct msi_domain_info *info)
+{
+        struct msi_domain_ops *ops = info->ops;
+
+        if (ops == NULL) {
+                info->ops = &pci_msi_domain_ops_default;
+        } else {
+                if (ops->set_desc == NULL)
+                        ops->set_desc = pci_msi_domain_set_desc;
+                if (ops->msi_check == NULL)
+                        ops->msi_check = pci_msi_domain_check_cap;
+                if (ops->handle_error == NULL)
+                        ops->handle_error = pci_msi_domain_handle_error;
+        }
+}
+
+static void pci_msi_domain_update_chip_ops(struct msi_domain_info *info)
+{
+        struct irq_chip *chip = info->chip;
+
+        BUG_ON(!chip);
+        if (!chip->irq_write_msi_msg)
+                chip->irq_write_msi_msg = pci_msi_domain_write_msg;
+}
+
+/**
+ * pci_msi_create_irq_domain - Creat a MSI interrupt domain
+ * @node:       Optional device-tree node of the interrupt controller
+ * @info:       MSI domain info
+ * @parent:     Parent irq domain
+ *
+ * Updates the domain and chip ops and creates a MSI interrupt domain.
+ *
+ * Returns:
+ * A domain pointer or NULL in case of failure.
+ */
+struct irq_domain *pci_msi_create_irq_domain(struct device_node *node,
+                                             struct msi_domain_info *info,
+                                             struct irq_domain *parent)
+{
+        if (info->flags & MSI_FLAG_USE_DEF_DOM_OPS)
+                pci_msi_domain_update_dom_ops(info);
+        if (info->flags & MSI_FLAG_USE_DEF_CHIP_OPS)
+                pci_msi_domain_update_chip_ops(info);
+
+        return msi_create_irq_domain(node, info, parent);
+}
+
+/**
+ * pci_msi_domain_alloc_irqs - Allocate interrupts for @dev in @domain
+ * @domain:     The interrupt domain to allocate from
+ * @dev:        The device for which to allocate
+ * @nvec:       The number of interrupts to allocate
+ * @type:       Unused to allow simpler migration from the arch_XXX interfaces
+ *
+ * Returns:
+ * A virtual interrupt number or an error code in case of failure
+ */
+int pci_msi_domain_alloc_irqs(struct irq_domain *domain, struct pci_dev *dev,
+                              int nvec, int type)
+{
+        return msi_domain_alloc_irqs(domain, &dev->dev, nvec);
+}
+
+/**
+ * pci_msi_domain_free_irqs - Free interrupts for @dev in @domain
+ * @domain:     The interrupt domain
+ * @dev:        The device for which to free interrupts
+ */
+void pci_msi_domain_free_irqs(struct irq_domain *domain, struct pci_dev *dev)
+{
+        msi_domain_free_irqs(domain, &dev->dev);
+}
+
+/**
+ * pci_msi_create_default_irq_domain - Create a default MSI interrupt domain
+ * @node:       Optional device-tree node of the interrupt controller
+ * @info:       MSI domain info
+ * @parent:     Parent irq domain
+ *
+ * Returns: A domain pointer or NULL in case of failure. If successful
+ * the default PCI/MSI irqdomain pointer is updated.
+ */
+struct irq_domain *pci_msi_create_default_irq_domain(struct device_node *node,
+                struct msi_domain_info *info, struct irq_domain *parent)
+{
+        struct irq_domain *domain;
+
+        mutex_lock(&pci_msi_domain_lock);
+        if (pci_msi_default_domain) {
+                pr_err("PCI: default irq domain for PCI MSI has already been created.\n");
+                domain = NULL;
+        } else {
+                domain = pci_msi_create_irq_domain(node, info, parent);
+                pci_msi_default_domain = domain;
+        }
+        mutex_unlock(&pci_msi_domain_lock);
+
+        return domain;
+}
+#endif /* CONFIG_PCI_MSI_IRQ_DOMAIN */
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 6ebf8edc5f3c..3542150fc8a3 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -322,8 +322,7 @@ static void pci_acpi_wake_dev(struct work_struct *work)
         pci_wakeup_event(pci_dev);
         pm_runtime_resume(&pci_dev->dev);
 
-        if (pci_dev->subordinate)
-                pci_pme_wakeup_bus(pci_dev->subordinate);
+        pci_pme_wakeup_bus(pci_dev->subordinate);
 }
 
 /**
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 2b3c89425bb5..887e6bd95af7 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -1104,7 +1104,7 @@ static int pci_pm_restore(struct device *dev)
 
 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 
 static int pci_pm_runtime_suspend(struct device *dev)
 {
@@ -1200,16 +1200,6 @@ static int pci_pm_runtime_idle(struct device *dev)
         return ret;
 }
 
-#else /* !CONFIG_PM_RUNTIME */
-
-#define pci_pm_runtime_suspend  NULL
-#define pci_pm_runtime_resume   NULL
-#define pci_pm_runtime_idle     NULL
-
-#endif /* !CONFIG_PM_RUNTIME */
-
-#ifdef CONFIG_PM
-
 static const struct dev_pm_ops pci_dev_pm_ops = {
         .prepare = pci_pm_prepare,
         .suspend = pci_pm_suspend,
@@ -1231,11 +1221,15 @@ static const struct dev_pm_ops pci_dev_pm_ops = {
 
 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
 
-#else /* !COMFIG_PM_OPS */
+#else /* !CONFIG_PM */
+
+#define pci_pm_runtime_suspend  NULL
+#define pci_pm_runtime_resume   NULL
+#define pci_pm_runtime_idle     NULL
 
 #define PCI_PM_OPS_PTR  NULL
 
-#endif /* !COMFIG_PM_OPS */
+#endif /* !CONFIG_PM */
 
 /**
  * __pci_register_driver - register a new pci driver
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 2c6643fdc0cf..a62acc443d5b 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -221,12 +221,37 @@ static ssize_t enable_show(struct device *dev, struct device_attribute *attr,
 static DEVICE_ATTR_RW(enable);
 
 #ifdef CONFIG_NUMA
+static ssize_t numa_node_store(struct device *dev,
+                               struct device_attribute *attr, const char *buf,
+                               size_t count)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+        int node, ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        ret = kstrtoint(buf, 0, &node);
+        if (ret)
+                return ret;
+
+        if (!node_online(node))
+                return -EINVAL;
+
+        add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
+        dev_alert(&pdev->dev, FW_BUG "Overriding NUMA node to %d.  Contact your vendor for updates.",
+                  node);
+
+        dev->numa_node = node;
+        return count;
+}
+
 static ssize_t numa_node_show(struct device *dev, struct device_attribute *attr,
                               char *buf)
 {
         return sprintf(buf, "%d\n", dev->numa_node);
 }
-static DEVICE_ATTR_RO(numa_node);
+static DEVICE_ATTR_RW(numa_node);
 #endif
 
 static ssize_t dma_mask_bits_show(struct device *dev,
@@ -385,7 +410,7 @@ static ssize_t dev_bus_rescan_store(struct device *dev,
 }
 static DEVICE_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_bus_rescan_store);
 
-#if defined(CONFIG_PM_RUNTIME) && defined(CONFIG_ACPI)
+#if defined(CONFIG_PM) && defined(CONFIG_ACPI)
 static ssize_t d3cold_allowed_store(struct device *dev,
                                     struct device_attribute *attr,
                                     const char *buf, size_t count)
@@ -566,7 +591,7 @@ static struct attribute *pci_dev_attrs[] = {
         &dev_attr_enable.attr,
         &dev_attr_broken_parity_status.attr,
         &dev_attr_msi_bus.attr,
-#if defined(CONFIG_PM_RUNTIME) && defined(CONFIG_ACPI)
+#if defined(CONFIG_PM) && defined(CONFIG_ACPI)
         &dev_attr_d3cold_allowed.attr,
 #endif
 #ifdef CONFIG_OF
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 625a4ace10b4..a7ac72639c52 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1012,11 +1012,7 @@ int pci_save_state(struct pci_dev *dev)
         if (i != 0)
                 return i;
 
-        i = pci_save_vc_state(dev);
-        if (i != 0)
-                return i;
-
-        return 0;
+        return pci_save_vc_state(dev);
 }
 EXPORT_SYMBOL(pci_save_state);
 
@@ -3144,12 +3140,10 @@ static int pcie_flr(struct pci_dev *dev, int probe)
                 return 0;
 
         if (!pci_wait_for_pending_transaction(dev))
-                dev_err(&dev->dev, "transaction is not cleared; proceeding with reset anyway\n");
+                dev_err(&dev->dev, "timed out waiting for pending transaction; performing function level reset anyway\n");
 
         pcie_capability_set_word(dev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_BCR_FLR);
-
         msleep(100);
-
         return 0;
 }
 
@@ -3174,16 +3168,12 @@ static int pci_af_flr(struct pci_dev *dev, int probe)
          * is used, so we use the conrol offset rather than status and shift
          * the test bit to match.
          */
-        if (pci_wait_for_pending(dev, pos + PCI_AF_CTRL,
+        if (!pci_wait_for_pending(dev, pos + PCI_AF_CTRL,
                                  PCI_AF_STATUS_TP << 8))
-                goto clear;
-
-        dev_err(&dev->dev, "transaction is not cleared; proceeding with reset anyway\n");
+                dev_err(&dev->dev, "timed out waiting for pending transaction; performing AF function level reset anyway\n");
 
-clear:
         pci_write_config_byte(dev, pos + PCI_AF_CTRL, PCI_AF_CTRL_FLR);
         msleep(100);
-
         return 0;
 }
 
@@ -4180,7 +4170,8 @@ int pci_resource_bar(struct pci_dev *dev, int resno, enum pci_bar_type *type)
                 return dev->rom_base_reg;
         } else if (resno < PCI_BRIDGE_RESOURCES) {
                 /* device specific resource */
-                reg = pci_iov_resource_bar(dev, resno, type);
+                *type = pci_bar_unknown;
+                reg = pci_iov_resource_bar(dev, resno);
                 if (reg)
                         return reg;
         }
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 4a3902d8e6fe..8aff29a804ff 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -253,8 +253,7 @@ static inline void pci_restore_ats_state(struct pci_dev *dev)
 #ifdef CONFIG_PCI_IOV
 int pci_iov_init(struct pci_dev *dev);
 void pci_iov_release(struct pci_dev *dev);
-int pci_iov_resource_bar(struct pci_dev *dev, int resno,
-                         enum pci_bar_type *type);
+int pci_iov_resource_bar(struct pci_dev *dev, int resno);
 resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno);
 void pci_restore_iov_state(struct pci_dev *dev);
 int pci_iov_bus_range(struct pci_bus *bus);
@@ -268,8 +267,7 @@ static inline void pci_iov_release(struct pci_dev *dev)
 
 {
 }
-static inline int pci_iov_resource_bar(struct pci_dev *dev, int resno,
-                                       enum pci_bar_type *type)
+static inline int pci_iov_resource_bar(struct pci_dev *dev, int resno)
 {
         return 0;
 }
diff --git a/drivers/pci/pcie/Kconfig b/drivers/pci/pcie/Kconfig
index 7958e59d6077..e294713c8143 100644
--- a/drivers/pci/pcie/Kconfig
+++ b/drivers/pci/pcie/Kconfig
@@ -79,4 +79,4 @@ endchoice
 
 config PCIE_PME
         def_bool y
-        depends on PCIEPORTBUS && PM_RUNTIME
+        depends on PCIEPORTBUS && PM
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index c8ca98c2b480..23212f8ae09b 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -87,8 +87,7 @@ static void release_pcibus_dev(struct device *dev)
 {
         struct pci_bus *pci_bus = to_pci_bus(dev);
 
-        if (pci_bus->bridge)
-                put_device(pci_bus->bridge);
+        put_device(pci_bus->bridge);
         pci_bus_remove_resources(pci_bus);
         pci_release_bus_of_node(pci_bus);
         kfree(pci_bus);
@@ -175,7 +174,6 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
         u64 l64, sz64, mask64;
         u16 orig_cmd;
         struct pci_bus_region region, inverted_region;
-        bool bar_too_big = false, bar_too_high = false, bar_invalid = false;
 
         mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
 
@@ -201,8 +199,8 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
          * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
          * 1 must be clear.
          */
-        if (!sz || sz == 0xffffffff)
-                goto fail;
+        if (sz == 0xffffffff)
+                sz = 0;
 
         /*
          * I don't know how l can have all bits set.  Copied from old code.
@@ -215,23 +213,22 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                 res->flags = decode_bar(dev, l);
                 res->flags |= IORESOURCE_SIZEALIGN;
                 if (res->flags & IORESOURCE_IO) {
-                        l &= PCI_BASE_ADDRESS_IO_MASK;
-                        mask = PCI_BASE_ADDRESS_IO_MASK & (u32) IO_SPACE_LIMIT;
+                        l64 = l & PCI_BASE_ADDRESS_IO_MASK;
+                        sz64 = sz & PCI_BASE_ADDRESS_IO_MASK;
+                        mask64 = PCI_BASE_ADDRESS_IO_MASK & (u32)IO_SPACE_LIMIT;
                 } else {
-                        l &= PCI_BASE_ADDRESS_MEM_MASK;
-                        mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
+                        l64 = l & PCI_BASE_ADDRESS_MEM_MASK;
+                        sz64 = sz & PCI_BASE_ADDRESS_MEM_MASK;
+                        mask64 = (u32)PCI_BASE_ADDRESS_MEM_MASK;
                 }
         } else {
                 res->flags |= (l & IORESOURCE_ROM_ENABLE);
-                l &= PCI_ROM_ADDRESS_MASK;
-                mask = (u32)PCI_ROM_ADDRESS_MASK;
+                l64 = l & PCI_ROM_ADDRESS_MASK;
+                sz64 = sz & PCI_ROM_ADDRESS_MASK;
+                mask64 = (u32)PCI_ROM_ADDRESS_MASK;
         }
 
         if (res->flags & IORESOURCE_MEM_64) {
-                l64 = l;
-                sz64 = sz;
-                mask64 = mask | (u64)~0 << 32;
-
                 pci_read_config_dword(dev, pos + 4, &l);
                 pci_write_config_dword(dev, pos + 4, ~0);
                 pci_read_config_dword(dev, pos + 4, &sz);
@@ -239,18 +236,30 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 
                 l64 |= ((u64)l << 32);
                 sz64 |= ((u64)sz << 32);
+                mask64 |= ((u64)~0 << 32);
+        }
 
-                sz64 = pci_size(l64, sz64, mask64);
+        if (!dev->mmio_always_on && (orig_cmd & PCI_COMMAND_DECODE_ENABLE))
+                pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
 
-                if (!sz64)
-                        goto fail;
+        if (!sz64)
+                goto fail;
 
+        sz64 = pci_size(l64, sz64, mask64);
+        if (!sz64) {
+                dev_info(&dev->dev, FW_BUG "reg 0x%x: invalid BAR (can't size)\n",
+                         pos);
+                goto fail;
+        }
+
+        if (res->flags & IORESOURCE_MEM_64) {
                 if ((sizeof(dma_addr_t) < 8 || sizeof(resource_size_t) < 8) &&
                     sz64 > 0x100000000ULL) {
                         res->flags |= IORESOURCE_UNSET | IORESOURCE_DISABLED;
                         res->start = 0;
                         res->end = 0;
-                        bar_too_big = true;
+                        dev_err(&dev->dev, "reg 0x%x: can't handle BAR larger than 4GB (size %#010llx)\n",
+                                pos, (unsigned long long)sz64);
                         goto out;
                 }
 
@@ -259,22 +268,15 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                         res->flags |= IORESOURCE_UNSET;
                         res->start = 0;
                         res->end = sz64;
-                        bar_too_high = true;
+                        dev_info(&dev->dev, "reg 0x%x: can't handle BAR above 4GB (bus address %#010llx)\n",
+                                 pos, (unsigned long long)l64);
                         goto out;
-                } else {
-                        region.start = l64;
-                        region.end = l64 + sz64;
                 }
-        } else {
-                sz = pci_size(l, sz, mask);
-
-                if (!sz)
-                        goto fail;
-
-                region.start = l;
-                region.end = l + sz;
         }
 
+        region.start = l64;
+        region.end = l64 + sz64;
+
         pcibios_bus_to_resource(dev->bus, res, &region);
         pcibios_resource_to_bus(dev->bus, &inverted_region, res);
 
@@ -293,7 +295,8 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                 res->flags |= IORESOURCE_UNSET;
                 res->start = 0;
                 res->end = region.end - region.start;
-                bar_invalid = true;
+                dev_info(&dev->dev, "reg 0x%x: initial BAR value %#010llx invalid\n",
+                         pos, (unsigned long long)region.start);
         }
 
         goto out;
@@ -302,19 +305,6 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 fail:
         res->flags = 0;
 out:
-        if (!dev->mmio_always_on &&
-            (orig_cmd & PCI_COMMAND_DECODE_ENABLE))
-                pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
-
-        if (bar_too_big)
-                dev_err(&dev->dev, "reg 0x%x: can't handle BAR larger than 4GB (size %#010llx)\n",
-                        pos, (unsigned long long) sz64);
-        if (bar_too_high)
-                dev_info(&dev->dev, "reg 0x%x: can't handle BAR above 4G (bus address %#010llx)\n",
-                         pos, (unsigned long long) l64);
-        if (bar_invalid)
-                dev_info(&dev->dev, "reg 0x%x: initial BAR value %#010llx invalid\n",
-                         pos, (unsigned long long) region.start);
         if (res->flags)
                 dev_printk(KERN_DEBUG, &dev->dev, "reg 0x%x: %pR\n", pos, res);
 
diff --git a/drivers/pci/search.c b/drivers/pci/search.c
index a81f413083e4..a20ce7d5e2a7 100644
--- a/drivers/pci/search.c
+++ b/drivers/pci/search.c
@@ -271,8 +271,7 @@ static struct pci_dev *pci_get_dev_by_id(const struct pci_device_id *id,
                               match_pci_dev_by_id);
         if (dev)
                 pdev = to_pci_dev(dev);
-        if (from)
-                pci_dev_put(from);
+        pci_dev_put(from);
         return pdev;
 }
 
diff --git a/drivers/pci/xen-pcifront.c b/drivers/pci/xen-pcifront.c
index 116ca3746adb..b1ffebec9b9e 100644
--- a/drivers/pci/xen-pcifront.c
+++ b/drivers/pci/xen-pcifront.c
@@ -596,8 +596,7 @@ static pci_ers_result_t pcifront_common_process(int cmd,
         pcidev = pci_get_bus_and_slot(bus, devfn);
         if (!pcidev || !pcidev->driver) {
                 dev_err(&pdev->xdev->dev, "device or AER driver is NULL\n");
-                if (pcidev)
-                        pci_dev_put(pcidev);
+                pci_dev_put(pcidev);
                 return result;
         }
         pdrv = pcidev->driver;
@@ -866,6 +865,11 @@ static int pcifront_try_connect(struct pcifront_device *pdev)
                 xenbus_dev_error(pdev->xdev, err,
                                  "No PCI Roots found, trying 0000:00");
                 err = pcifront_scan_root(pdev, 0, 0);
+                if (err) {
+                        xenbus_dev_fatal(pdev->xdev, err,
+                                         "Error scanning PCI root 0000:00");
+                        goto out;
+                }
                 num_roots = 0;
         } else if (err != 1) {
                 if (err == 0)
@@ -947,6 +951,11 @@ static int pcifront_attach_devices(struct pcifront_device *pdev)
                 xenbus_dev_error(pdev->xdev, err,
                                  "No PCI Roots found, trying 0000:00");
                 err = pcifront_rescan_root(pdev, 0, 0);
+                if (err) {
+                        xenbus_dev_fatal(pdev->xdev, err,
+                                         "Error scanning PCI root 0000:00");
+                        goto out;
+                }
                 num_roots = 0;
         } else if (err != 1) {
                 if (err == 0)
diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig
index c6a66de6ed72..d014f22f387a 100644
--- a/drivers/pinctrl/Kconfig
+++ b/drivers/pinctrl/Kconfig
@@ -67,18 +67,6 @@ config PINCTRL_AT91
         help
           Say Y here to enable the at91 pinctrl driver
 
-config PINCTRL_BAYTRAIL
-        bool "Intel Baytrail GPIO pin control"
-        depends on GPIOLIB && ACPI && X86
-        select GPIOLIB_IRQCHIP
-        help
-          driver for memory mapped GPIO functionality on Intel Baytrail
-          platforms. Supports 3 banks with 102, 28 and 44 gpios.
-          Most pins are usually muxed to some other functionality by firmware,
-          so only a small amount is available for gpio use.
-
-          Requires ACPI device enumeration code to set up a platform device.
-
 config PINCTRL_BCM2835
         bool
         select PINMUX
@@ -205,6 +193,7 @@ config PINCTRL_PALMAS
 
 source "drivers/pinctrl/berlin/Kconfig"
 source "drivers/pinctrl/freescale/Kconfig"
+source "drivers/pinctrl/intel/Kconfig"
 source "drivers/pinctrl/mvebu/Kconfig"
 source "drivers/pinctrl/nomadik/Kconfig"
 source "drivers/pinctrl/qcom/Kconfig"
diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile
index 51f52d32859e..c030b3db8034 100644
--- a/drivers/pinctrl/Makefile
+++ b/drivers/pinctrl/Makefile
@@ -15,7 +15,6 @@ obj-$(CONFIG_PINCTRL_BF54x)	+= pinctrl-adi2-bf54x.o
 obj-$(CONFIG_PINCTRL_BF60x)     += pinctrl-adi2-bf60x.o
 obj-$(CONFIG_PINCTRL_AT91)      += pinctrl-at91.o
 obj-$(CONFIG_PINCTRL_BCM2835)   += pinctrl-bcm2835.o
-obj-$(CONFIG_PINCTRL_BAYTRAIL)  += pinctrl-baytrail.o
 obj-$(CONFIG_PINCTRL_BCM281XX)  += pinctrl-bcm281xx.o
 obj-$(CONFIG_PINCTRL_FALCON)    += pinctrl-falcon.o
 obj-$(CONFIG_PINCTRL_PALMAS)    += pinctrl-palmas.o
@@ -39,6 +38,7 @@ obj-$(CONFIG_PINCTRL_ST) 	+= pinctrl-st.o
 
 obj-$(CONFIG_ARCH_BERLIN)       += berlin/
 obj-y                           += freescale/
+obj-$(CONFIG_X86)               += intel/
 obj-$(CONFIG_PLAT_ORION)        += mvebu/
 obj-y                           += nomadik/
 obj-$(CONFIG_ARCH_QCOM)         += qcom/
diff --git a/drivers/pinctrl/freescale/pinctrl-imx.c b/drivers/pinctrl/freescale/pinctrl-imx.c
index f2446769247f..52f2b9404fe0 100644
--- a/drivers/pinctrl/freescale/pinctrl-imx.c
+++ b/drivers/pinctrl/freescale/pinctrl-imx.c
@@ -294,11 +294,83 @@ static int imx_pmx_get_groups(struct pinctrl_dev *pctldev, unsigned selector,
         return 0;
 }
 
+static int imx_pmx_gpio_request_enable(struct pinctrl_dev *pctldev,
+                        struct pinctrl_gpio_range *range, unsigned offset)
+{
+        struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
+        const struct imx_pinctrl_soc_info *info = ipctl->info;
+        const struct imx_pin_reg *pin_reg;
+        struct imx_pin_group *grp;
+        struct imx_pin *imx_pin;
+        unsigned int pin, group;
+        u32 reg;
+
+        /* Currently implementation only for shared mux/conf register */
+        if (!(info->flags & SHARE_MUX_CONF_REG))
+                return -EINVAL;
+
+        pin_reg = &info->pin_regs[offset];
+        if (pin_reg->mux_reg == -1)
+                return -EINVAL;
+
+        /* Find the pinctrl config with GPIO mux mode for the requested pin */
+        for (group = 0; group < info->ngroups; group++) {
+                grp = &info->groups[group];
+                for (pin = 0; pin < grp->npins; pin++) {
+                        imx_pin = &grp->pins[pin];
+                        if (imx_pin->pin == offset && !imx_pin->mux_mode)
+                                goto mux_pin;
+                }
+        }
+
+        return -EINVAL;
+
+mux_pin:
+        reg = readl(ipctl->base + pin_reg->mux_reg);
+        reg &= ~(0x7 << 20);
+        reg |= imx_pin->config;
+        writel(reg, ipctl->base + pin_reg->mux_reg);
+
+        return 0;
+}
+
+static int imx_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
+           struct pinctrl_gpio_range *range, unsigned offset, bool input)
+{
+        struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
+        const struct imx_pinctrl_soc_info *info = ipctl->info;
+        const struct imx_pin_reg *pin_reg;
+        u32 reg;
+
+        /*
+         * Only Vybrid has the input/output buffer enable flags (IBE/OBE)
+         * They are part of the shared mux/conf register.
+         */
+        if (!(info->flags & SHARE_MUX_CONF_REG))
+                return -EINVAL;
+
+        pin_reg = &info->pin_regs[offset];
+        if (pin_reg->mux_reg == -1)
+                return -EINVAL;
+
+        /* IBE always enabled allows us to read the value "on the wire" */
+        reg = readl(ipctl->base + pin_reg->mux_reg);
+        if (input)
+                reg &= ~0x2;
+        else
+                reg |= 0x2;
+        writel(reg, ipctl->base + pin_reg->mux_reg);
+
+        return 0;
+}
+
 static const struct pinmux_ops imx_pmx_ops = {
         .get_functions_count = imx_pmx_get_funcs_count,
         .get_function_name = imx_pmx_get_func_name,
         .get_function_groups = imx_pmx_get_groups,
         .set_mux = imx_pmx_set,
+        .gpio_request_enable = imx_pmx_gpio_request_enable,
+        .gpio_set_direction = imx_pmx_gpio_set_direction,
 };
 
 static int imx_pinconf_get(struct pinctrl_dev *pctldev,
diff --git a/drivers/pinctrl/freescale/pinctrl-mxs.c b/drivers/pinctrl/freescale/pinctrl-mxs.c
index f98c6bb0f769..646d5c244af1 100644
--- a/drivers/pinctrl/freescale/pinctrl-mxs.c
+++ b/drivers/pinctrl/freescale/pinctrl-mxs.c
@@ -445,6 +445,31 @@ static int mxs_pinctrl_probe_dt(struct platform_device *pdev,
                 if (of_property_read_u32(child, "reg", &val))
                         continue;
                 if (strcmp(fn, child->name)) {
+                        struct device_node *child2;
+
+                        /*
+                         * This reference is dropped by
+                         * of_get_next_child(np, * child)
+                         */
+                        of_node_get(child);
+
+                        /*
+                         * The logic parsing the functions from dt currently
+                         * doesn't handle if functions with the same name are
+                         * not grouped together. Only the first contiguous
+                         * cluster is usable for each function name. This is a
+                         * bug that is not trivial to fix, but at least warn
+                         * about it.
+                         */
+                        for (child2 = of_get_next_child(np, child);
+                             child2 != NULL;
+                             child2 = of_get_next_child(np, child2)) {
+                                if (!strcmp(child2->name, fn))
+                                        dev_warn(&pdev->dev,
+                                                 "function nodes must be grouped by name (failed for: %s)",
+                                                 fn);
+                        }
+
                         f = &soc->functions[idxf++];
                         f->name = fn = child->name;
                 }
diff --git a/drivers/pinctrl/intel/Kconfig b/drivers/pinctrl/intel/Kconfig
new file mode 100644
index 000000000000..b801d869e91c
--- /dev/null
+++ b/drivers/pinctrl/intel/Kconfig
@@ -0,0 +1,27 @@
+#
+# Intel pin control drivers
+#
+
+config PINCTRL_BAYTRAIL
+        bool "Intel Baytrail GPIO pin control"
+        depends on GPIOLIB && ACPI
+        select GPIOLIB_IRQCHIP
+        help
+          driver for memory mapped GPIO functionality on Intel Baytrail
+          platforms. Supports 3 banks with 102, 28 and 44 gpios.
+          Most pins are usually muxed to some other functionality by firmware,
+          so only a small amount is available for gpio use.
+
+          Requires ACPI device enumeration code to set up a platform device.
+
+config PINCTRL_CHERRYVIEW
+        tristate "Intel Cherryview/Braswell pinctrl and GPIO driver"
+        depends on ACPI
+        select PINMUX
+        select PINCONF
+        select GENERIC_PINCONF
+        select GPIOLIB
+        select GPIOLIB_IRQCHIP
+        help
+          Cherryview/Braswell pinctrl driver provides an interface that
+          allows configuring of SoC pins and using them as GPIOs.
diff --git a/drivers/pinctrl/intel/Makefile b/drivers/pinctrl/intel/Makefile
new file mode 100644
index 000000000000..4c210e4139e2
--- /dev/null
+++ b/drivers/pinctrl/intel/Makefile
@@ -0,0 +1,4 @@
+# Intel pin control drivers
+
+obj-$(CONFIG_PINCTRL_BAYTRAIL)          += pinctrl-baytrail.o
+obj-$(CONFIG_PINCTRL_CHERRYVIEW)        += pinctrl-cherryview.o
diff --git a/drivers/pinctrl/pinctrl-baytrail.c b/drivers/pinctrl/intel/pinctrl-baytrail.c
index 9dc38140194b..7db000431da7 100644
--- a/drivers/pinctrl/pinctrl-baytrail.c
+++ b/drivers/pinctrl/intel/pinctrl-baytrail.c
@@ -616,5 +616,10 @@ static int __init byt_gpio_init(void)
 {
         return platform_driver_register(&byt_gpio_driver);
 }
-
 subsys_initcall(byt_gpio_init);
+
+static void __exit byt_gpio_exit(void)
+{
+        platform_driver_unregister(&byt_gpio_driver);
+}
+module_exit(byt_gpio_exit);
diff --git a/drivers/pinctrl/intel/pinctrl-cherryview.c b/drivers/pinctrl/intel/pinctrl-cherryview.c
new file mode 100644
index 000000000000..e9f8b39d1a9f
--- /dev/null
+++ b/drivers/pinctrl/intel/pinctrl-cherryview.c
@@ -0,0 +1,1519 @@
+/*
+ * Cherryview/Braswell pinctrl driver
+ *
+ * Copyright (C) 2014, Intel Corporation
+ * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
+ *
+ * This driver is based on the original Cherryview GPIO driver by
+ *   Ning Li <ning.li@intel.com>
+ *   Alan Cox <alan@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
+#include <linux/acpi.h>
+#include <linux/pinctrl/pinctrl.h>
+#include <linux/pinctrl/pinmux.h>
+#include <linux/pinctrl/pinconf.h>
+#include <linux/pinctrl/pinconf-generic.h>
+#include <linux/platform_device.h>
+
+#define CHV_INTSTAT                     0x300
+#define CHV_INTMASK                     0x380
+
+#define FAMILY_PAD_REGS_OFF             0x4400
+#define FAMILY_PAD_REGS_SIZE            0x400
+#define MAX_FAMILY_PAD_GPIO_NO          15
+#define GPIO_REGS_SIZE                  8
+
+#define CHV_PADCTRL0                    0x000
+#define CHV_PADCTRL0_INTSEL_SHIFT       28
+#define CHV_PADCTRL0_INTSEL_MASK        (0xf << CHV_PADCTRL0_INTSEL_SHIFT)
+#define CHV_PADCTRL0_TERM_UP            BIT(23)
+#define CHV_PADCTRL0_TERM_SHIFT         20
+#define CHV_PADCTRL0_TERM_MASK          (7 << CHV_PADCTRL0_TERM_SHIFT)
+#define CHV_PADCTRL0_TERM_20K           1
+#define CHV_PADCTRL0_TERM_5K            2
+#define CHV_PADCTRL0_TERM_1K            4
+#define CHV_PADCTRL0_PMODE_SHIFT        16
+#define CHV_PADCTRL0_PMODE_MASK         (0xf << CHV_PADCTRL0_PMODE_SHIFT)
+#define CHV_PADCTRL0_GPIOEN             BIT(15)
+#define CHV_PADCTRL0_GPIOCFG_SHIFT      8
+#define CHV_PADCTRL0_GPIOCFG_MASK       (7 << CHV_PADCTRL0_GPIOCFG_SHIFT)
+#define CHV_PADCTRL0_GPIOCFG_GPIO       0
+#define CHV_PADCTRL0_GPIOCFG_GPO        1
+#define CHV_PADCTRL0_GPIOCFG_GPI        2
+#define CHV_PADCTRL0_GPIOCFG_HIZ        3
+#define CHV_PADCTRL0_GPIOTXSTATE        BIT(1)
+#define CHV_PADCTRL0_GPIORXSTATE        BIT(0)
+
+#define CHV_PADCTRL1                    0x004
+#define CHV_PADCTRL1_CFGLOCK            BIT(31)
+#define CHV_PADCTRL1_INVRXTX_SHIFT      4
+#define CHV_PADCTRL1_INVRXTX_MASK       (0xf << CHV_PADCTRL1_INVRXTX_SHIFT)
+#define CHV_PADCTRL1_INVRXTX_TXENABLE   (2 << CHV_PADCTRL1_INVRXTX_SHIFT)
+#define CHV_PADCTRL1_ODEN               BIT(3)
+#define CHV_PADCTRL1_INVRXTX_RXDATA     (4 << CHV_PADCTRL1_INVRXTX_SHIFT)
+#define CHV_PADCTRL1_INTWAKECFG_MASK    7
+#define CHV_PADCTRL1_INTWAKECFG_FALLING 1
+#define CHV_PADCTRL1_INTWAKECFG_RISING  2
+#define CHV_PADCTRL1_INTWAKECFG_BOTH    3
+#define CHV_PADCTRL1_INTWAKECFG_LEVEL   4
+
+/**
+ * struct chv_alternate_function - A per group or per pin alternate function
+ * @pin: Pin number (only used in per pin configs)
+ * @mode: Mode the pin should be set in
+ * @invert_oe: Invert OE for this pin
+ */
+struct chv_alternate_function {
+        unsigned pin;
+        u8 mode;
+        bool invert_oe;
+};
+
+/**
+ * struct chv_pincgroup - describes a CHV pin group
+ * @name: Name of the group
+ * @pins: An array of pins in this group
+ * @npins: Number of pins in this group
+ * @altfunc: Alternate function applied to all pins in this group
+ * @overrides: Alternate function override per pin or %NULL if not used
+ * @noverrides: Number of per pin alternate function overrides if
+ *              @overrides != NULL.
+ */
+struct chv_pingroup {
+        const char *name;
+        const unsigned *pins;
+        size_t npins;
+        struct chv_alternate_function altfunc;
+        const struct chv_alternate_function *overrides;
+        size_t noverrides;
+};
+
+/**
+ * struct chv_function - A CHV pinmux function
+ * @name: Name of the function
+ * @groups: An array of groups for this function
+ * @ngroups: Number of groups in @groups
+ */
+struct chv_function {
+        const char *name;
+        const char * const *groups;
+        size_t ngroups;
+};
+
+/**
+ * struct chv_gpio_pinrange - A range of pins that can be used as GPIOs
+ * @base: Start pin number
+ * @npins: Number of pins in this range
+ */
+struct chv_gpio_pinrange {
+        unsigned base;
+        unsigned npins;
+};
+
+/**
+ * struct chv_community - A community specific configuration
+ * @uid: ACPI _UID used to match the community
+ * @pins: All pins in this community
+ * @npins: Number of pins
+ * @groups: All groups in this community
+ * @ngroups: Number of groups
+ * @functions: All functions in this community
+ * @nfunctions: Number of functions
+ * @ngpios: Number of GPIOs in this community
+ * @gpio_ranges: An array of GPIO ranges in this community
+ * @ngpio_ranges: Number of GPIO ranges
+ * @ngpios: Total number of GPIOs in this community
+ */
+struct chv_community {
+        const char *uid;
+        const struct pinctrl_pin_desc *pins;
+        size_t npins;
+        const struct chv_pingroup *groups;
+        size_t ngroups;
+        const struct chv_function *functions;
+        size_t nfunctions;
+        const struct chv_gpio_pinrange *gpio_ranges;
+        size_t ngpio_ranges;
+        size_t ngpios;
+};
+
+/**
+ * struct chv_pinctrl - CHV pinctrl private structure
+ * @dev: Pointer to the parent device
+ * @pctldesc: Pin controller description
+ * @pctldev: Pointer to the pin controller device
+ * @chip: GPIO chip in this pin controller
+ * @regs: MMIO registers
+ * @lock: Lock to serialize register accesses
+ * @intr_lines: Stores mapping between 16 HW interrupt wires and GPIO
+ *              offset (in GPIO number space)
+ * @community: Community this pinctrl instance represents
+ *
+ * The first group in @groups is expected to contain all pins that can be
+ * used as GPIOs.
+ */
+struct chv_pinctrl {
+        struct device *dev;
+        struct pinctrl_desc pctldesc;
+        struct pinctrl_dev *pctldev;
+        struct gpio_chip chip;
+        void __iomem *regs;
+        spinlock_t lock;
+        unsigned intr_lines[16];
+        const struct chv_community *community;
+};
+
+#define gpiochip_to_pinctrl(c) container_of(c, struct chv_pinctrl, chip)
+
+#define ALTERNATE_FUNCTION(p, m, i)             \
+        {                                       \
+                .pin = (p),                     \
+                .mode = (m),                    \
+                .invert_oe = (i),               \
+        }
+
+#define PIN_GROUP(n, p, m, i)                   \
+        {                                       \
+                .name = (n),                    \
+                .pins = (p),                    \
+                .npins = ARRAY_SIZE((p)),       \
+                .altfunc.mode = (m),            \
+                .altfunc.invert_oe = (i),       \
+        }
+
+#define PIN_GROUP_WITH_OVERRIDE(n, p, m, i, o)  \
+        {                                       \
+                .name = (n),                    \
+                .pins = (p),                    \
+                .npins = ARRAY_SIZE((p)),       \
+                .altfunc.mode = (m),            \
+                .altfunc.invert_oe = (i),       \
+                .overrides = (o),               \
+                .noverrides = ARRAY_SIZE((o)),  \
+        }
+
+#define FUNCTION(n, g)                          \
+        {                                       \
+                .name = (n),                    \
+                .groups = (g),                  \
+                .ngroups = ARRAY_SIZE((g)),     \
+        }
+
+#define GPIO_PINRANGE(start, end)               \
+        {                                       \
+                .base = (start),                \
+                .npins = (end) - (start) + 1,   \
+        }
+
+static const struct pinctrl_pin_desc southwest_pins[] = {
+        PINCTRL_PIN(0, "FST_SPI_D2"),
+        PINCTRL_PIN(1, "FST_SPI_D0"),
+        PINCTRL_PIN(2, "FST_SPI_CLK"),
+        PINCTRL_PIN(3, "FST_SPI_D3"),
+        PINCTRL_PIN(4, "FST_SPI_CS1_B"),
+        PINCTRL_PIN(5, "FST_SPI_D1"),
+        PINCTRL_PIN(6, "FST_SPI_CS0_B"),
+        PINCTRL_PIN(7, "FST_SPI_CS2_B"),
+
+        PINCTRL_PIN(15, "UART1_RTS_B"),
+        PINCTRL_PIN(16, "UART1_RXD"),
+        PINCTRL_PIN(17, "UART2_RXD"),
+        PINCTRL_PIN(18, "UART1_CTS_B"),
+        PINCTRL_PIN(19, "UART2_RTS_B"),
+        PINCTRL_PIN(20, "UART1_TXD"),
+        PINCTRL_PIN(21, "UART2_TXD"),
+        PINCTRL_PIN(22, "UART2_CTS_B"),
+
+        PINCTRL_PIN(30, "MF_HDA_CLK"),
+        PINCTRL_PIN(31, "MF_HDA_RSTB"),
+        PINCTRL_PIN(32, "MF_HDA_SDIO"),
+        PINCTRL_PIN(33, "MF_HDA_SDO"),
+        PINCTRL_PIN(34, "MF_HDA_DOCKRSTB"),
+        PINCTRL_PIN(35, "MF_HDA_SYNC"),
+        PINCTRL_PIN(36, "MF_HDA_SDI1"),
+        PINCTRL_PIN(37, "MF_HDA_DOCKENB"),
+
+        PINCTRL_PIN(45, "I2C5_SDA"),
+        PINCTRL_PIN(46, "I2C4_SDA"),
+        PINCTRL_PIN(47, "I2C6_SDA"),
+        PINCTRL_PIN(48, "I2C5_SCL"),
+        PINCTRL_PIN(49, "I2C_NFC_SDA"),
+        PINCTRL_PIN(50, "I2C4_SCL"),
+        PINCTRL_PIN(51, "I2C6_SCL"),
+        PINCTRL_PIN(52, "I2C_NFC_SCL"),
+
+        PINCTRL_PIN(60, "I2C1_SDA"),
+        PINCTRL_PIN(61, "I2C0_SDA"),
+        PINCTRL_PIN(62, "I2C2_SDA"),
+        PINCTRL_PIN(63, "I2C1_SCL"),
+        PINCTRL_PIN(64, "I2C3_SDA"),
+        PINCTRL_PIN(65, "I2C0_SCL"),
+        PINCTRL_PIN(66, "I2C2_SCL"),
+        PINCTRL_PIN(67, "I2C3_SCL"),
+
+        PINCTRL_PIN(75, "SATA_GP0"),
+        PINCTRL_PIN(76, "SATA_GP1"),
+        PINCTRL_PIN(77, "SATA_LEDN"),
+        PINCTRL_PIN(78, "SATA_GP2"),
+        PINCTRL_PIN(79, "MF_SMB_ALERTB"),
+        PINCTRL_PIN(80, "SATA_GP3"),
+        PINCTRL_PIN(81, "MF_SMB_CLK"),
+        PINCTRL_PIN(82, "MF_SMB_DATA"),
+
+        PINCTRL_PIN(90, "PCIE_CLKREQ0B"),
+        PINCTRL_PIN(91, "PCIE_CLKREQ1B"),
+        PINCTRL_PIN(92, "GP_SSP_2_CLK"),
+        PINCTRL_PIN(93, "PCIE_CLKREQ2B"),
+        PINCTRL_PIN(94, "GP_SSP_2_RXD"),
+        PINCTRL_PIN(95, "PCIE_CLKREQ3B"),
+        PINCTRL_PIN(96, "GP_SSP_2_FS"),
+        PINCTRL_PIN(97, "GP_SSP_2_TXD"),
+};
+
+static const unsigned southwest_fspi_pins[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+static const unsigned southwest_uart0_pins[] = { 16, 20 };
+static const unsigned southwest_uart1_pins[] = { 15, 16, 18, 20 };
+static const unsigned southwest_uart2_pins[] = { 17, 19, 21, 22 };
+static const unsigned southwest_i2c0_pins[] = { 61, 65 };
+static const unsigned southwest_hda_pins[] = { 30, 31, 32, 33, 34, 35, 36, 37 };
+static const unsigned southwest_lpe_pins[] = {
+        30, 31, 32, 33, 34, 35, 36, 37, 92, 94, 96, 97,
+};
+static const unsigned southwest_i2c1_pins[] = { 60, 63 };
+static const unsigned southwest_i2c2_pins[] = { 62, 66 };
+static const unsigned southwest_i2c3_pins[] = { 64, 67 };
+static const unsigned southwest_i2c4_pins[] = { 46, 50 };
+static const unsigned southwest_i2c5_pins[] = { 45, 48 };
+static const unsigned southwest_i2c6_pins[] = { 47, 51 };
+static const unsigned southwest_i2c_nfc_pins[] = { 49, 52 };
+static const unsigned southwest_smbus_pins[] = { 79, 81, 82 };
+static const unsigned southwest_spi3_pins[] = { 76, 79, 80, 81, 82 };
+
+/* LPE I2S TXD pins need to have invert_oe set */
+static const struct chv_alternate_function southwest_lpe_altfuncs[] = {
+        ALTERNATE_FUNCTION(30, 1, true),
+        ALTERNATE_FUNCTION(34, 1, true),
+        ALTERNATE_FUNCTION(97, 1, true),
+};
+
+/*
+ * Two spi3 chipselects are available in different mode than the main spi3
+ * functionality, which is using mode 1.
+ */
+static const struct chv_alternate_function southwest_spi3_altfuncs[] = {
+        ALTERNATE_FUNCTION(76, 3, false),
+        ALTERNATE_FUNCTION(80, 3, false),
+};
+
+static const struct chv_pingroup southwest_groups[] = {
+        PIN_GROUP("uart0_grp", southwest_uart0_pins, 2, false),
+        PIN_GROUP("uart1_grp", southwest_uart1_pins, 1, false),
+        PIN_GROUP("uart2_grp", southwest_uart2_pins, 1, false),
+        PIN_GROUP("hda_grp", southwest_hda_pins, 2, false),
+        PIN_GROUP("i2c0_grp", southwest_i2c0_pins, 1, true),
+        PIN_GROUP("i2c1_grp", southwest_i2c1_pins, 1, true),
+        PIN_GROUP("i2c2_grp", southwest_i2c2_pins, 1, true),
+        PIN_GROUP("i2c3_grp", southwest_i2c3_pins, 1, true),
+        PIN_GROUP("i2c4_grp", southwest_i2c4_pins, 1, true),
+        PIN_GROUP("i2c5_grp", southwest_i2c5_pins, 1, true),
+        PIN_GROUP("i2c6_grp", southwest_i2c6_pins, 1, true),
+        PIN_GROUP("i2c_nfc_grp", southwest_i2c_nfc_pins, 2, true),
+
+        PIN_GROUP_WITH_OVERRIDE("lpe_grp", southwest_lpe_pins, 1, false,
+                                southwest_lpe_altfuncs),
+        PIN_GROUP_WITH_OVERRIDE("spi3_grp", southwest_spi3_pins, 2, false,
+                                southwest_spi3_altfuncs),
+};
+
+static const char * const southwest_uart0_groups[] = { "uart0_grp" };
+static const char * const southwest_uart1_groups[] = { "uart1_grp" };
+static const char * const southwest_uart2_groups[] = { "uart2_grp" };
+static const char * const southwest_hda_groups[] = { "hda_grp" };
+static const char * const southwest_lpe_groups[] = { "lpe_grp" };
+static const char * const southwest_i2c0_groups[] = { "i2c0_grp" };
+static const char * const southwest_i2c1_groups[] = { "i2c1_grp" };
+static const char * const southwest_i2c2_groups[] = { "i2c2_grp" };
+static const char * const southwest_i2c3_groups[] = { "i2c3_grp" };
+static const char * const southwest_i2c4_groups[] = { "i2c4_grp" };
+static const char * const southwest_i2c5_groups[] = { "i2c5_grp" };
+static const char * const southwest_i2c6_groups[] = { "i2c6_grp" };
+static const char * const southwest_i2c_nfc_groups[] = { "i2c_nfc_grp" };
+static const char * const southwest_spi3_groups[] = { "spi3_grp" };
+
+/*
+ * Only do pinmuxing for certain LPSS devices for now. Rest of the pins are
+ * enabled only as GPIOs.
+ */
+static const struct chv_function southwest_functions[] = {
+        FUNCTION("uart0", southwest_uart0_groups),
+        FUNCTION("uart1", southwest_uart1_groups),
+        FUNCTION("uart2", southwest_uart2_groups),
+        FUNCTION("hda", southwest_hda_groups),
+        FUNCTION("lpe", southwest_lpe_groups),
+        FUNCTION("i2c0", southwest_i2c0_groups),
+        FUNCTION("i2c1", southwest_i2c1_groups),
+        FUNCTION("i2c2", southwest_i2c2_groups),
+        FUNCTION("i2c3", southwest_i2c3_groups),
+        FUNCTION("i2c4", southwest_i2c4_groups),
+        FUNCTION("i2c5", southwest_i2c5_groups),
+        FUNCTION("i2c6", southwest_i2c6_groups),
+        FUNCTION("i2c_nfc", southwest_i2c_nfc_groups),
+        FUNCTION("spi3", southwest_spi3_groups),
+};
+
+static const struct chv_gpio_pinrange southwest_gpio_ranges[] = {
+        GPIO_PINRANGE(0, 7),
+        GPIO_PINRANGE(15, 22),
+        GPIO_PINRANGE(30, 37),
+        GPIO_PINRANGE(45, 52),
+        GPIO_PINRANGE(60, 67),
+        GPIO_PINRANGE(75, 82),
+        GPIO_PINRANGE(90, 97),
+};
+
+static const struct chv_community southwest_community = {
+        .uid = "1",
+        .pins = southwest_pins,
+        .npins = ARRAY_SIZE(southwest_pins),
+        .groups = southwest_groups,
+        .ngroups = ARRAY_SIZE(southwest_groups),
+        .functions = southwest_functions,
+        .nfunctions = ARRAY_SIZE(southwest_functions),
+        .gpio_ranges = southwest_gpio_ranges,
+        .ngpio_ranges = ARRAY_SIZE(southwest_gpio_ranges),
+        .ngpios = ARRAY_SIZE(southwest_pins),
+};
+
+static const struct pinctrl_pin_desc north_pins[] = {
+        PINCTRL_PIN(0, "GPIO_DFX_0"),
+        PINCTRL_PIN(1, "GPIO_DFX_3"),
+        PINCTRL_PIN(2, "GPIO_DFX_7"),
+        PINCTRL_PIN(3, "GPIO_DFX_1"),
+        PINCTRL_PIN(4, "GPIO_DFX_5"),
+        PINCTRL_PIN(5, "GPIO_DFX_4"),
+        PINCTRL_PIN(6, "GPIO_DFX_8"),
+        PINCTRL_PIN(7, "GPIO_DFX_2"),
+        PINCTRL_PIN(8, "GPIO_DFX_6"),
+
+        PINCTRL_PIN(15, "GPIO_SUS0"),
+        PINCTRL_PIN(16, "SEC_GPIO_SUS10"),
+        PINCTRL_PIN(17, "GPIO_SUS3"),
+        PINCTRL_PIN(18, "GPIO_SUS7"),
+        PINCTRL_PIN(19, "GPIO_SUS1"),
+        PINCTRL_PIN(20, "GPIO_SUS5"),
+        PINCTRL_PIN(21, "SEC_GPIO_SUS11"),
+        PINCTRL_PIN(22, "GPIO_SUS4"),
+        PINCTRL_PIN(23, "SEC_GPIO_SUS8"),
+        PINCTRL_PIN(24, "GPIO_SUS2"),
+        PINCTRL_PIN(25, "GPIO_SUS6"),
+        PINCTRL_PIN(26, "CX_PREQ_B"),
+        PINCTRL_PIN(27, "SEC_GPIO_SUS9"),
+
+        PINCTRL_PIN(30, "TRST_B"),
+        PINCTRL_PIN(31, "TCK"),
+        PINCTRL_PIN(32, "PROCHOT_B"),
+        PINCTRL_PIN(33, "SVIDO_DATA"),
+        PINCTRL_PIN(34, "TMS"),
+        PINCTRL_PIN(35, "CX_PRDY_B_2"),
+        PINCTRL_PIN(36, "TDO_2"),
+        PINCTRL_PIN(37, "CX_PRDY_B"),
+        PINCTRL_PIN(38, "SVIDO_ALERT_B"),
+        PINCTRL_PIN(39, "TDO"),
+        PINCTRL_PIN(40, "SVIDO_CLK"),
+        PINCTRL_PIN(41, "TDI"),
+
+        PINCTRL_PIN(45, "GP_CAMERASB_05"),
+        PINCTRL_PIN(46, "GP_CAMERASB_02"),
+        PINCTRL_PIN(47, "GP_CAMERASB_08"),
+        PINCTRL_PIN(48, "GP_CAMERASB_00"),
+        PINCTRL_PIN(49, "GP_CAMERASB_06"),
+        PINCTRL_PIN(50, "GP_CAMERASB_10"),
+        PINCTRL_PIN(51, "GP_CAMERASB_03"),
+        PINCTRL_PIN(52, "GP_CAMERASB_09"),
+        PINCTRL_PIN(53, "GP_CAMERASB_01"),
+        PINCTRL_PIN(54, "GP_CAMERASB_07"),
+        PINCTRL_PIN(55, "GP_CAMERASB_11"),
+        PINCTRL_PIN(56, "GP_CAMERASB_04"),
+
+        PINCTRL_PIN(60, "PANEL0_BKLTEN"),
+        PINCTRL_PIN(61, "HV_DDI0_HPD"),
+        PINCTRL_PIN(62, "HV_DDI2_DDC_SDA"),
+        PINCTRL_PIN(63, "PANEL1_BKLTCTL"),
+        PINCTRL_PIN(64, "HV_DDI1_HPD"),
+        PINCTRL_PIN(65, "PANEL0_BKLTCTL"),
+        PINCTRL_PIN(66, "HV_DDI0_DDC_SDA"),
+        PINCTRL_PIN(67, "HV_DDI2_DDC_SCL"),
+        PINCTRL_PIN(68, "HV_DDI2_HPD"),
+        PINCTRL_PIN(69, "PANEL1_VDDEN"),
+        PINCTRL_PIN(70, "PANEL1_BKLTEN"),
+        PINCTRL_PIN(71, "HV_DDI0_DDC_SCL"),
+        PINCTRL_PIN(72, "PANEL0_VDDEN"),
+};
+
+static const struct chv_gpio_pinrange north_gpio_ranges[] = {
+        GPIO_PINRANGE(0, 8),
+        GPIO_PINRANGE(15, 27),
+        GPIO_PINRANGE(30, 41),
+        GPIO_PINRANGE(45, 56),
+        GPIO_PINRANGE(60, 72),
+};
+
+static const struct chv_community north_community = {
+        .uid = "2",
+        .pins = north_pins,
+        .npins = ARRAY_SIZE(north_pins),
+        .gpio_ranges = north_gpio_ranges,
+        .ngpio_ranges = ARRAY_SIZE(north_gpio_ranges),
+        .ngpios = ARRAY_SIZE(north_pins),
+};
+
+static const struct pinctrl_pin_desc east_pins[] = {
+        PINCTRL_PIN(0, "PMU_SLP_S3_B"),
+        PINCTRL_PIN(1, "PMU_BATLOW_B"),
+        PINCTRL_PIN(2, "SUS_STAT_B"),
+        PINCTRL_PIN(3, "PMU_SLP_S0IX_B"),
+        PINCTRL_PIN(4, "PMU_AC_PRESENT"),
+        PINCTRL_PIN(5, "PMU_PLTRST_B"),
+        PINCTRL_PIN(6, "PMU_SUSCLK"),
+        PINCTRL_PIN(7, "PMU_SLP_LAN_B"),
+        PINCTRL_PIN(8, "PMU_PWRBTN_B"),
+        PINCTRL_PIN(9, "PMU_SLP_S4_B"),
+        PINCTRL_PIN(10, "PMU_WAKE_B"),
+        PINCTRL_PIN(11, "PMU_WAKE_LAN_B"),
+
+        PINCTRL_PIN(15, "MF_ISH_GPIO_3"),
+        PINCTRL_PIN(16, "MF_ISH_GPIO_7"),
+        PINCTRL_PIN(17, "MF_ISH_I2C1_SCL"),
+        PINCTRL_PIN(18, "MF_ISH_GPIO_1"),
+        PINCTRL_PIN(19, "MF_ISH_GPIO_5"),
+        PINCTRL_PIN(20, "MF_ISH_GPIO_9"),
+        PINCTRL_PIN(21, "MF_ISH_GPIO_0"),
+        PINCTRL_PIN(22, "MF_ISH_GPIO_4"),
+        PINCTRL_PIN(23, "MF_ISH_GPIO_8"),
+        PINCTRL_PIN(24, "MF_ISH_GPIO_2"),
+        PINCTRL_PIN(25, "MF_ISH_GPIO_6"),
+        PINCTRL_PIN(26, "MF_ISH_I2C1_SDA"),
+};
+
+static const struct chv_gpio_pinrange east_gpio_ranges[] = {
+        GPIO_PINRANGE(0, 11),
+        GPIO_PINRANGE(15, 26),
+};
+
+static const struct chv_community east_community = {
+        .uid = "3",
+        .pins = east_pins,
+        .npins = ARRAY_SIZE(east_pins),
+        .gpio_ranges = east_gpio_ranges,
+        .ngpio_ranges = ARRAY_SIZE(east_gpio_ranges),
+        .ngpios = ARRAY_SIZE(east_pins),
+};
+
+static const struct pinctrl_pin_desc southeast_pins[] = {
+        PINCTRL_PIN(0, "MF_PLT_CLK0"),
+        PINCTRL_PIN(1, "PWM1"),
+        PINCTRL_PIN(2, "MF_PLT_CLK1"),
+        PINCTRL_PIN(3, "MF_PLT_CLK4"),
+        PINCTRL_PIN(4, "MF_PLT_CLK3"),
+        PINCTRL_PIN(5, "PWM0"),
+        PINCTRL_PIN(6, "MF_PLT_CLK5"),
+        PINCTRL_PIN(7, "MF_PLT_CLK2"),
+
+        PINCTRL_PIN(15, "SDMMC2_D3_CD_B"),
+        PINCTRL_PIN(16, "SDMMC1_CLK"),
+        PINCTRL_PIN(17, "SDMMC1_D0"),
+        PINCTRL_PIN(18, "SDMMC2_D1"),
+        PINCTRL_PIN(19, "SDMMC2_CLK"),
+        PINCTRL_PIN(20, "SDMMC1_D2"),
+        PINCTRL_PIN(21, "SDMMC2_D2"),
+        PINCTRL_PIN(22, "SDMMC2_CMD"),
+        PINCTRL_PIN(23, "SDMMC1_CMD"),
+        PINCTRL_PIN(24, "SDMMC1_D1"),
+        PINCTRL_PIN(25, "SDMMC2_D0"),
+        PINCTRL_PIN(26, "SDMMC1_D3_CD_B"),
+
+        PINCTRL_PIN(30, "SDMMC3_D1"),
+        PINCTRL_PIN(31, "SDMMC3_CLK"),
+        PINCTRL_PIN(32, "SDMMC3_D3"),
+        PINCTRL_PIN(33, "SDMMC3_D2"),
+        PINCTRL_PIN(34, "SDMMC3_CMD"),
+        PINCTRL_PIN(35, "SDMMC3_D0"),
+
+        PINCTRL_PIN(45, "MF_LPC_AD2"),
+        PINCTRL_PIN(46, "LPC_CLKRUNB"),
+        PINCTRL_PIN(47, "MF_LPC_AD0"),
+        PINCTRL_PIN(48, "LPC_FRAMEB"),
+        PINCTRL_PIN(49, "MF_LPC_CLKOUT1"),
+        PINCTRL_PIN(50, "MF_LPC_AD3"),
+        PINCTRL_PIN(51, "MF_LPC_CLKOUT0"),
+        PINCTRL_PIN(52, "MF_LPC_AD1"),
+
+        PINCTRL_PIN(60, "SPI1_MISO"),
+        PINCTRL_PIN(61, "SPI1_CSO_B"),
+        PINCTRL_PIN(62, "SPI1_CLK"),
+        PINCTRL_PIN(63, "MMC1_D6"),
+        PINCTRL_PIN(64, "SPI1_MOSI"),
+        PINCTRL_PIN(65, "MMC1_D5"),
+        PINCTRL_PIN(66, "SPI1_CS1_B"),
+        PINCTRL_PIN(67, "MMC1_D4_SD_WE"),
+        PINCTRL_PIN(68, "MMC1_D7"),
+        PINCTRL_PIN(69, "MMC1_RCLK"),
+
+        PINCTRL_PIN(75, "USB_OC1_B"),
+        PINCTRL_PIN(76, "PMU_RESETBUTTON_B"),
+        PINCTRL_PIN(77, "GPIO_ALERT"),
+        PINCTRL_PIN(78, "SDMMC3_PWR_EN_B"),
+        PINCTRL_PIN(79, "ILB_SERIRQ"),
+        PINCTRL_PIN(80, "USB_OC0_B"),
+        PINCTRL_PIN(81, "SDMMC3_CD_B"),
+        PINCTRL_PIN(82, "SPKR"),
+        PINCTRL_PIN(83, "SUSPWRDNACK"),
+        PINCTRL_PIN(84, "SPARE_PIN"),
+        PINCTRL_PIN(85, "SDMMC3_1P8_EN"),
+};
+
+static const unsigned southeast_pwm0_pins[] = { 5 };
+static const unsigned southeast_pwm1_pins[] = { 1 };
+static const unsigned southeast_sdmmc1_pins[] = {
+        16, 17, 20, 23, 24, 26, 63, 65, 67, 68, 69,
+};
+static const unsigned southeast_sdmmc2_pins[] = { 15, 18, 19, 21, 22, 25 };
+static const unsigned southeast_sdmmc3_pins[] = {
+        30, 31, 32, 33, 34, 35, 78, 81, 85,
+};
+static const unsigned southeast_spi1_pins[] = { 60, 61, 62, 64, 66 };
+static const unsigned southeast_spi2_pins[] = { 2, 3, 4, 6, 7 };
+
+static const struct chv_pingroup southeast_groups[] = {
+        PIN_GROUP("pwm0_grp", southeast_pwm0_pins, 1, false),
+        PIN_GROUP("pwm1_grp", southeast_pwm1_pins, 1, false),
+        PIN_GROUP("sdmmc1_grp", southeast_sdmmc1_pins, 1, false),
+        PIN_GROUP("sdmmc2_grp", southeast_sdmmc2_pins, 1, false),
+        PIN_GROUP("sdmmc3_grp", southeast_sdmmc3_pins, 1, false),
+        PIN_GROUP("spi1_grp", southeast_spi1_pins, 1, false),
+        PIN_GROUP("spi2_grp", southeast_spi2_pins, 4, false),
+};
+
+static const char * const southeast_pwm0_groups[] = { "pwm0_grp" };
+static const char * const southeast_pwm1_groups[] = { "pwm1_grp" };
+static const char * const southeast_sdmmc1_groups[] = { "sdmmc1_grp" };
+static const char * const southeast_sdmmc2_groups[] = { "sdmmc2_grp" };
+static const char * const southeast_sdmmc3_groups[] = { "sdmmc3_grp" };
+static const char * const southeast_spi1_groups[] = { "spi1_grp" };
+static const char * const southeast_spi2_groups[] = { "spi2_grp" };
+
+static const struct chv_function southeast_functions[] = {
+        FUNCTION("pwm0", southeast_pwm0_groups),
+        FUNCTION("pwm1", southeast_pwm1_groups),
+        FUNCTION("sdmmc1", southeast_sdmmc1_groups),
+        FUNCTION("sdmmc2", southeast_sdmmc2_groups),
+        FUNCTION("sdmmc3", southeast_sdmmc3_groups),
+        FUNCTION("spi1", southeast_spi1_groups),
+        FUNCTION("spi2", southeast_spi2_groups),
+};
+
+static const struct chv_gpio_pinrange southeast_gpio_ranges[] = {
+        GPIO_PINRANGE(0, 7),
+        GPIO_PINRANGE(15, 26),
+        GPIO_PINRANGE(30, 35),
+        GPIO_PINRANGE(45, 52),
+        GPIO_PINRANGE(60, 69),
+        GPIO_PINRANGE(75, 85),
+};
+
+static const struct chv_community southeast_community = {
+        .uid = "4",
+        .pins = southeast_pins,
+        .npins = ARRAY_SIZE(southeast_pins),
+        .groups = southeast_groups,
+        .ngroups = ARRAY_SIZE(southeast_groups),
+        .functions = southeast_functions,
+        .nfunctions = ARRAY_SIZE(southeast_functions),
+        .gpio_ranges = southeast_gpio_ranges,
+        .ngpio_ranges = ARRAY_SIZE(southeast_gpio_ranges),
+        .ngpios = ARRAY_SIZE(southeast_pins),
+};
+
+static const struct chv_community *chv_communities[] = {
+        &southwest_community,
+        &north_community,
+        &east_community,
+        &southeast_community,
+};
+
+static void __iomem *chv_padreg(struct chv_pinctrl *pctrl, unsigned offset,
+                                unsigned reg)
+{
+        unsigned family_no = offset / MAX_FAMILY_PAD_GPIO_NO;
+        unsigned pad_no = offset % MAX_FAMILY_PAD_GPIO_NO;
+
+        offset = FAMILY_PAD_REGS_OFF + FAMILY_PAD_REGS_SIZE * family_no +
+                 GPIO_REGS_SIZE * pad_no;
+
+        return pctrl->regs + offset + reg;
+}
+
+static void chv_writel(u32 value, void __iomem *reg)
+{
+        writel(value, reg);
+        /* simple readback to confirm the bus transferring done */
+        readl(reg);
+}
+
+/* When Pad Cfg is locked, driver can only change GPIOTXState or GPIORXState */
+static bool chv_pad_locked(struct chv_pinctrl *pctrl, unsigned offset)
+{
+        void __iomem *reg;
+
+        reg = chv_padreg(pctrl, offset, CHV_PADCTRL1);
+        return readl(reg) & CHV_PADCTRL1_CFGLOCK;
+}
+
+static int chv_get_groups_count(struct pinctrl_dev *pctldev)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        return pctrl->community->ngroups;
+}
+
+static const char *chv_get_group_name(struct pinctrl_dev *pctldev,
+                                      unsigned group)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        return pctrl->community->groups[group].name;
+}
+
+static int chv_get_group_pins(struct pinctrl_dev *pctldev, unsigned group,
+                              const unsigned **pins, unsigned *npins)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        *pins = pctrl->community->groups[group].pins;
+        *npins = pctrl->community->groups[group].npins;
+        return 0;
+}
+
+static void chv_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
+                             unsigned offset)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        unsigned long flags;
+        u32 ctrl0, ctrl1;
+        bool locked;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        ctrl0 = readl(chv_padreg(pctrl, offset, CHV_PADCTRL0));
+        ctrl1 = readl(chv_padreg(pctrl, offset, CHV_PADCTRL1));
+        locked = chv_pad_locked(pctrl, offset);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        if (ctrl0 & CHV_PADCTRL0_GPIOEN) {
+                seq_puts(s, "GPIO ");
+        } else {
+                u32 mode;
+
+                mode = ctrl0 & CHV_PADCTRL0_PMODE_MASK;
+                mode >>= CHV_PADCTRL0_PMODE_SHIFT;
+
+                seq_printf(s, "mode %d ", mode);
+        }
+
+        seq_printf(s, "ctrl0 0x%08x ctrl1 0x%08x", ctrl0, ctrl1);
+
+        if (locked)
+                seq_puts(s, " [LOCKED]");
+}
+
+static const struct pinctrl_ops chv_pinctrl_ops = {
+        .get_groups_count = chv_get_groups_count,
+        .get_group_name = chv_get_group_name,
+        .get_group_pins = chv_get_group_pins,
+        .pin_dbg_show = chv_pin_dbg_show,
+};
+
+static int chv_get_functions_count(struct pinctrl_dev *pctldev)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        return pctrl->community->nfunctions;
+}
+
+static const char *chv_get_function_name(struct pinctrl_dev *pctldev,
+                                         unsigned function)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        return pctrl->community->functions[function].name;
+}
+
+static int chv_get_function_groups(struct pinctrl_dev *pctldev,
+                                   unsigned function,
+                                   const char * const **groups,
+                                   unsigned * const ngroups)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        *groups = pctrl->community->functions[function].groups;
+        *ngroups = pctrl->community->functions[function].ngroups;
+        return 0;
+}
+
+static int chv_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned function,
+                              unsigned group)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        const struct chv_pingroup *grp;
+        unsigned long flags;
+        int i;
+
+        grp = &pctrl->community->groups[group];
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        /* Check first that the pad is not locked */
+        for (i = 0; i < grp->npins; i++) {
+                if (chv_pad_locked(pctrl, grp->pins[i])) {
+                        dev_warn(pctrl->dev, "unable to set mode for locked pin %u\n",
+                                 grp->pins[i]);
+                        spin_unlock_irqrestore(&pctrl->lock, flags);
+                        return -EBUSY;
+                }
+        }
+
+        for (i = 0; i < grp->npins; i++) {
+                const struct chv_alternate_function *altfunc = &grp->altfunc;
+                int pin = grp->pins[i];
+                void __iomem *reg;
+                u32 value;
+
+                /* Check if there is pin-specific config */
+                if (grp->overrides) {
+                        int j;
+
+                        for (j = 0; j < grp->noverrides; j++) {
+                                if (grp->overrides[j].pin == pin) {
+                                        altfunc = &grp->overrides[j];
+                                        break;
+                                }
+                        }
+                }
+
+                reg = chv_padreg(pctrl, pin, CHV_PADCTRL0);
+                value = readl(reg);
+                /* Disable GPIO mode */
+                value &= ~CHV_PADCTRL0_GPIOEN;
+                /* Set to desired mode */
+                value &= ~CHV_PADCTRL0_PMODE_MASK;
+                value |= altfunc->mode << CHV_PADCTRL0_PMODE_SHIFT;
+                chv_writel(value, reg);
+
+                /* Update for invert_oe */
+                reg = chv_padreg(pctrl, pin, CHV_PADCTRL1);
+                value = readl(reg) & ~CHV_PADCTRL1_INVRXTX_MASK;
+                if (altfunc->invert_oe)
+                        value |= CHV_PADCTRL1_INVRXTX_TXENABLE;
+                chv_writel(value, reg);
+
+                dev_dbg(pctrl->dev, "configured pin %u mode %u OE %sinverted\n",
+                        pin, altfunc->mode, altfunc->invert_oe ? "" : "not ");
+        }
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static int chv_gpio_request_enable(struct pinctrl_dev *pctldev,
+                                   struct pinctrl_gpio_range *range,
+                                   unsigned offset)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        unsigned long flags;
+        void __iomem *reg;
+        u32 value;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        if (chv_pad_locked(pctrl, offset)) {
+                value = readl(chv_padreg(pctrl, offset, CHV_PADCTRL0));
+                if (!(value & CHV_PADCTRL0_GPIOEN)) {
+                        /* Locked so cannot enable */
+                        spin_unlock_irqrestore(&pctrl->lock, flags);
+                        return -EBUSY;
+                }
+        } else {
+                int i;
+
+                /* Reset the interrupt mapping */
+                for (i = 0; i < ARRAY_SIZE(pctrl->intr_lines); i++) {
+                        if (pctrl->intr_lines[i] == offset) {
+                                pctrl->intr_lines[i] = 0;
+                                break;
+                        }
+                }
+
+                /* Disable interrupt generation */
+                reg = chv_padreg(pctrl, offset, CHV_PADCTRL1);
+                value = readl(reg);
+                value &= ~CHV_PADCTRL1_INTWAKECFG_MASK;
+                value &= ~CHV_PADCTRL1_INVRXTX_MASK;
+                chv_writel(value, reg);
+
+                /* Switch to a GPIO mode */
+                reg = chv_padreg(pctrl, offset, CHV_PADCTRL0);
+                value = readl(reg) | CHV_PADCTRL0_GPIOEN;
+                chv_writel(value, reg);
+        }
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static void chv_gpio_disable_free(struct pinctrl_dev *pctldev,
+                                  struct pinctrl_gpio_range *range,
+                                  unsigned offset)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        unsigned long flags;
+        void __iomem *reg;
+        u32 value;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        reg = chv_padreg(pctrl, offset, CHV_PADCTRL0);
+        value = readl(reg) & ~CHV_PADCTRL0_GPIOEN;
+        chv_writel(value, reg);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+}
+
+static int chv_gpio_set_direction(struct pinctrl_dev *pctldev,
+                                  struct pinctrl_gpio_range *range,
+                                  unsigned offset, bool input)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        void __iomem *reg = chv_padreg(pctrl, offset, CHV_PADCTRL0);
+        unsigned long flags;
+        u32 ctrl0;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        ctrl0 = readl(reg) & ~CHV_PADCTRL0_GPIOCFG_MASK;
+        if (input)
+                ctrl0 |= CHV_PADCTRL0_GPIOCFG_GPI << CHV_PADCTRL0_GPIOCFG_SHIFT;
+        else
+                ctrl0 |= CHV_PADCTRL0_GPIOCFG_GPO << CHV_PADCTRL0_GPIOCFG_SHIFT;
+        chv_writel(ctrl0, reg);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static const struct pinmux_ops chv_pinmux_ops = {
+        .get_functions_count = chv_get_functions_count,
+        .get_function_name = chv_get_function_name,
+        .get_function_groups = chv_get_function_groups,
+        .set_mux = chv_pinmux_set_mux,
+        .gpio_request_enable = chv_gpio_request_enable,
+        .gpio_disable_free = chv_gpio_disable_free,
+        .gpio_set_direction = chv_gpio_set_direction,
+};
+
+static int chv_config_get(struct pinctrl_dev *pctldev, unsigned pin,
+                          unsigned long *config)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        enum pin_config_param param = pinconf_to_config_param(*config);
+        unsigned long flags;
+        u32 ctrl0, ctrl1;
+        u16 arg = 0;
+        u32 term;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+        ctrl0 = readl(chv_padreg(pctrl, pin, CHV_PADCTRL0));
+        ctrl1 = readl(chv_padreg(pctrl, pin, CHV_PADCTRL1));
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        term = (ctrl0 & CHV_PADCTRL0_TERM_MASK) >> CHV_PADCTRL0_TERM_SHIFT;
+
+        switch (param) {
+        case PIN_CONFIG_BIAS_DISABLE:
+                if (term)
+                        return -EINVAL;
+                break;
+
+        case PIN_CONFIG_BIAS_PULL_UP:
+                if (!(ctrl0 & CHV_PADCTRL0_TERM_UP))
+                        return -EINVAL;
+
+                switch (term) {
+                case CHV_PADCTRL0_TERM_20K:
+                        arg = 20000;
+                        break;
+                case CHV_PADCTRL0_TERM_5K:
+                        arg = 5000;
+                        break;
+                case CHV_PADCTRL0_TERM_1K:
+                        arg = 1000;
+                        break;
+                }
+
+                break;
+
+        case PIN_CONFIG_BIAS_PULL_DOWN:
+                if (!term || (ctrl0 & CHV_PADCTRL0_TERM_UP))
+                        return -EINVAL;
+
+                switch (term) {
+                case CHV_PADCTRL0_TERM_20K:
+                        arg = 20000;
+                        break;
+                case CHV_PADCTRL0_TERM_5K:
+                        arg = 5000;
+                        break;
+                }
+
+                break;
+
+        case PIN_CONFIG_DRIVE_OPEN_DRAIN:
+                if (!(ctrl1 & CHV_PADCTRL1_ODEN))
+                        return -EINVAL;
+                break;
+
+        case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: {
+                u32 cfg;
+
+                cfg = ctrl0 & CHV_PADCTRL0_GPIOCFG_MASK;
+                cfg >>= CHV_PADCTRL0_GPIOCFG_SHIFT;
+                if (cfg != CHV_PADCTRL0_GPIOCFG_HIZ)
+                        return -EINVAL;
+
+                break;
+        }
+
+        default:
+                return -ENOTSUPP;
+        }
+
+        *config = pinconf_to_config_packed(param, arg);
+        return 0;
+}
+
+static int chv_config_set_pull(struct chv_pinctrl *pctrl, unsigned pin,
+                               enum pin_config_param param, u16 arg)
+{
+        void __iomem *reg = chv_padreg(pctrl, pin, CHV_PADCTRL0);
+        unsigned long flags;
+        u32 ctrl0, pull;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+        ctrl0 = readl(reg);
+
+        switch (param) {
+        case PIN_CONFIG_BIAS_DISABLE:
+                ctrl0 &= ~(CHV_PADCTRL0_TERM_MASK | CHV_PADCTRL0_TERM_UP);
+                break;
+
+        case PIN_CONFIG_BIAS_PULL_UP:
+                ctrl0 &= ~(CHV_PADCTRL0_TERM_MASK | CHV_PADCTRL0_TERM_UP);
+
+                switch (arg) {
+                case 1000:
+                        /* For 1k there is only pull up */
+                        pull = CHV_PADCTRL0_TERM_1K << CHV_PADCTRL0_TERM_SHIFT;
+                        break;
+                case 5000:
+                        pull = CHV_PADCTRL0_TERM_5K << CHV_PADCTRL0_TERM_SHIFT;
+                        break;
+                case 20000:
+                        pull = CHV_PADCTRL0_TERM_20K << CHV_PADCTRL0_TERM_SHIFT;
+                        break;
+                default:
+                        spin_unlock_irqrestore(&pctrl->lock, flags);
+                        return -EINVAL;
+                }
+
+                ctrl0 |= CHV_PADCTRL0_TERM_UP | pull;
+                break;
+
+        case PIN_CONFIG_BIAS_PULL_DOWN:
+                ctrl0 &= ~(CHV_PADCTRL0_TERM_MASK | CHV_PADCTRL0_TERM_UP);
+
+                switch (arg) {
+                case 5000:
+                        pull = CHV_PADCTRL0_TERM_5K << CHV_PADCTRL0_TERM_SHIFT;
+                        break;
+                case 20000:
+                        pull = CHV_PADCTRL0_TERM_20K << CHV_PADCTRL0_TERM_SHIFT;
+                        break;
+                default:
+                        spin_unlock_irqrestore(&pctrl->lock, flags);
+                        return -EINVAL;
+                }
+
+                ctrl0 |= pull;
+                break;
+
+        default:
+                spin_unlock_irqrestore(&pctrl->lock, flags);
+                return -EINVAL;
+        }
+
+        chv_writel(ctrl0, reg);
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static int chv_config_set(struct pinctrl_dev *pctldev, unsigned pin,
+                          unsigned long *configs, unsigned nconfigs)
+{
+        struct chv_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        enum pin_config_param param;
+        int i, ret;
+        u16 arg;
+
+        if (chv_pad_locked(pctrl, pin))
+                return -EBUSY;
+
+        for (i = 0; i < nconfigs; i++) {
+                param = pinconf_to_config_param(configs[i]);
+                arg = pinconf_to_config_argument(configs[i]);
+
+                switch (param) {
+                case PIN_CONFIG_BIAS_DISABLE:
+                case PIN_CONFIG_BIAS_PULL_UP:
+                case PIN_CONFIG_BIAS_PULL_DOWN:
+                        ret = chv_config_set_pull(pctrl, pin, param, arg);
+                        if (ret)
+                                return ret;
+                        break;
+
+                default:
+                        return -ENOTSUPP;
+                }
+
+                dev_dbg(pctrl->dev, "pin %d set config %d arg %u\n", pin,
+                        param, arg);
+        }
+
+        return 0;
+}
+
+static const struct pinconf_ops chv_pinconf_ops = {
+        .is_generic = true,
+        .pin_config_set = chv_config_set,
+        .pin_config_get = chv_config_get,
+};
+
+static struct pinctrl_desc chv_pinctrl_desc = {
+        .pctlops = &chv_pinctrl_ops,
+        .pmxops = &chv_pinmux_ops,
+        .confops = &chv_pinconf_ops,
+        .owner = THIS_MODULE,
+};
+
+static int chv_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        return pinctrl_request_gpio(chip->base + offset);
+}
+
+static void chv_gpio_free(struct gpio_chip *chip, unsigned offset)
+{
+        pinctrl_free_gpio(chip->base + offset);
+}
+
+static unsigned chv_gpio_offset_to_pin(struct chv_pinctrl *pctrl,
+                                       unsigned offset)
+{
+        return pctrl->community->pins[offset].number;
+}
+
+static int chv_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        int pin = chv_gpio_offset_to_pin(pctrl, offset);
+        u32 ctrl0, cfg;
+
+        ctrl0 = readl(chv_padreg(pctrl, pin, CHV_PADCTRL0));
+
+        cfg = ctrl0 & CHV_PADCTRL0_GPIOCFG_MASK;
+        cfg >>= CHV_PADCTRL0_GPIOCFG_SHIFT;
+
+        if (cfg == CHV_PADCTRL0_GPIOCFG_GPO)
+                return !!(ctrl0 & CHV_PADCTRL0_GPIOTXSTATE);
+        return !!(ctrl0 & CHV_PADCTRL0_GPIORXSTATE);
+}
+
+static void chv_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        unsigned pin = chv_gpio_offset_to_pin(pctrl, offset);
+        unsigned long flags;
+        void __iomem *reg;
+        u32 ctrl0;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        reg = chv_padreg(pctrl, pin, CHV_PADCTRL0);
+        ctrl0 = readl(reg);
+
+        if (value)
+                ctrl0 |= CHV_PADCTRL0_GPIOTXSTATE;
+        else
+                ctrl0 &= ~CHV_PADCTRL0_GPIOTXSTATE;
+
+        chv_writel(ctrl0, reg);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+}
+
+static int chv_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
+{
+        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        unsigned pin = chv_gpio_offset_to_pin(pctrl, offset);
+        u32 ctrl0, direction;
+
+        ctrl0 = readl(chv_padreg(pctrl, pin, CHV_PADCTRL0));
+
+        direction = ctrl0 & CHV_PADCTRL0_GPIOCFG_MASK;
+        direction >>= CHV_PADCTRL0_GPIOCFG_SHIFT;
+
+        return direction != CHV_PADCTRL0_GPIOCFG_GPO;
+}
+
+static int chv_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        return pinctrl_gpio_direction_input(chip->base + offset);
+}
+
+static int chv_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
+                                     int value)
+{
+        return pinctrl_gpio_direction_output(chip->base + offset);
+}
+
+static const struct gpio_chip chv_gpio_chip = {
+        .owner = THIS_MODULE,
+        .request = chv_gpio_request,
+        .free = chv_gpio_free,
+        .get_direction = chv_gpio_get_direction,
+        .direction_input = chv_gpio_direction_input,
+        .direction_output = chv_gpio_direction_output,
+        .get = chv_gpio_get,
+        .set = chv_gpio_set,
+};
+
+static void chv_gpio_irq_ack(struct irq_data *d)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        int pin = chv_gpio_offset_to_pin(pctrl, irqd_to_hwirq(d));
+        u32 intr_line;
+
+        spin_lock(&pctrl->lock);
+
+        intr_line = readl(chv_padreg(pctrl, pin, CHV_PADCTRL0));
+        intr_line &= CHV_PADCTRL0_INTSEL_MASK;
+        intr_line >>= CHV_PADCTRL0_INTSEL_SHIFT;
+        chv_writel(BIT(intr_line), pctrl->regs + CHV_INTSTAT);
+
+        spin_unlock(&pctrl->lock);
+}
+
+static void chv_gpio_irq_mask_unmask(struct irq_data *d, bool mask)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        int pin = chv_gpio_offset_to_pin(pctrl, irqd_to_hwirq(d));
+        u32 value, intr_line;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        intr_line = readl(chv_padreg(pctrl, pin, CHV_PADCTRL0));
+        intr_line &= CHV_PADCTRL0_INTSEL_MASK;
+        intr_line >>= CHV_PADCTRL0_INTSEL_SHIFT;
+
+        value = readl(pctrl->regs + CHV_INTMASK);
+        if (mask)
+                value &= ~BIT(intr_line);
+        else
+                value |= BIT(intr_line);
+        chv_writel(value, pctrl->regs + CHV_INTMASK);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+}
+
+static void chv_gpio_irq_mask(struct irq_data *d)
+{
+        chv_gpio_irq_mask_unmask(d, true);
+}
+
+static void chv_gpio_irq_unmask(struct irq_data *d)
+{
+        chv_gpio_irq_mask_unmask(d, false);
+}
+
+static int chv_gpio_irq_type(struct irq_data *d, unsigned type)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        unsigned offset = irqd_to_hwirq(d);
+        int pin = chv_gpio_offset_to_pin(pctrl, offset);
+        unsigned long flags;
+        u32 value;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        /*
+         * Pins which can be used as shared interrupt are configured in
+         * BIOS. Driver trusts BIOS configurations and assigns different
+         * handler according to the irq type.
+         *
+         * Driver needs to save the mapping between each pin and
+         * its interrupt line.
+         * 1. If the pin cfg is locked in BIOS:
+         *      Trust BIOS has programmed IntWakeCfg bits correctly,
+         *      driver just needs to save the mapping.
+         * 2. If the pin cfg is not locked in BIOS:
+         *      Driver programs the IntWakeCfg bits and save the mapping.
+         */
+        if (!chv_pad_locked(pctrl, pin)) {
+                void __iomem *reg = chv_padreg(pctrl, pin, CHV_PADCTRL1);
+
+                value = readl(reg);
+                value &= ~CHV_PADCTRL1_INTWAKECFG_MASK;
+                value &= ~CHV_PADCTRL1_INVRXTX_MASK;
+
+                if (type & IRQ_TYPE_EDGE_BOTH) {
+                        if ((type & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH)
+                                value |= CHV_PADCTRL1_INTWAKECFG_BOTH;
+                        else if (type & IRQ_TYPE_EDGE_RISING)
+                                value |= CHV_PADCTRL1_INTWAKECFG_RISING;
+                        else if (type & IRQ_TYPE_EDGE_FALLING)
+                                value |= CHV_PADCTRL1_INTWAKECFG_FALLING;
+                } else if (type & IRQ_TYPE_LEVEL_MASK) {
+                        value |= CHV_PADCTRL1_INTWAKECFG_LEVEL;
+                        if (type & IRQ_TYPE_LEVEL_LOW)
+                                value |= CHV_PADCTRL1_INVRXTX_RXDATA;
+                }
+
+                chv_writel(value, reg);
+        }
+
+        value = readl(chv_padreg(pctrl, pin, CHV_PADCTRL0));
+        value &= CHV_PADCTRL0_INTSEL_MASK;
+        value >>= CHV_PADCTRL0_INTSEL_SHIFT;
+
+        pctrl->intr_lines[value] = offset;
+
+        if (type & IRQ_TYPE_EDGE_BOTH)
+                __irq_set_handler_locked(d->irq, handle_edge_irq);
+        else if (type & IRQ_TYPE_LEVEL_MASK)
+                __irq_set_handler_locked(d->irq, handle_level_irq);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static struct irq_chip chv_gpio_irqchip = {
+        .name = "chv-gpio",
+        .irq_ack = chv_gpio_irq_ack,
+        .irq_mask = chv_gpio_irq_mask,
+        .irq_unmask = chv_gpio_irq_unmask,
+        .irq_set_type = chv_gpio_irq_type,
+        .flags = IRQCHIP_SKIP_SET_WAKE,
+};
+
+static void chv_gpio_irq_handler(unsigned irq, struct irq_desc *desc)
+{
+        struct gpio_chip *gc = irq_desc_get_handler_data(desc);
+        struct chv_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct irq_chip *chip = irq_get_chip(irq);
+        unsigned long pending;
+        u32 intr_line;
+
+        chained_irq_enter(chip, desc);
+
+        pending = readl(pctrl->regs + CHV_INTSTAT);
+        for_each_set_bit(intr_line, &pending, 16) {
+                unsigned irq, offset;
+
+                offset = pctrl->intr_lines[intr_line];
+                irq = irq_find_mapping(gc->irqdomain, offset);
+                generic_handle_irq(irq);
+        }
+
+        chained_irq_exit(chip, desc);
+}
+
+static int chv_gpio_probe(struct chv_pinctrl *pctrl, int irq)
+{
+        const struct chv_gpio_pinrange *range;
+        struct gpio_chip *chip = &pctrl->chip;
+        int ret, i, offset;
+
+        *chip = chv_gpio_chip;
+
+        chip->ngpio = pctrl->community->ngpios;
+        chip->label = dev_name(pctrl->dev);
+        chip->dev = pctrl->dev;
+        chip->base = -1;
+
+        ret = gpiochip_add(chip);
+        if (ret) {
+                dev_err(pctrl->dev, "Failed to register gpiochip\n");
+                return ret;
+        }
+
+        for (i = 0, offset = 0; i < pctrl->community->ngpio_ranges; i++) {
+                range = &pctrl->community->gpio_ranges[i];
+                ret = gpiochip_add_pin_range(chip, dev_name(pctrl->dev), offset,
+                                             range->base, range->npins);
+                if (ret) {
+                        dev_err(pctrl->dev, "failed to add GPIO pin range\n");
+                        goto fail;
+                }
+
+                offset += range->npins;
+        }
+
+        /* Mask and clear all interrupts */
+        chv_writel(0, pctrl->regs + CHV_INTMASK);
+        chv_writel(0xffff, pctrl->regs + CHV_INTSTAT);
+
+        ret = gpiochip_irqchip_add(chip, &chv_gpio_irqchip, 0,
+                                   handle_simple_irq, IRQ_TYPE_NONE);
+        if (ret) {
+                dev_err(pctrl->dev, "failed to add IRQ chip\n");
+                goto fail;
+        }
+
+        gpiochip_set_chained_irqchip(chip, &chv_gpio_irqchip, irq,
+                                     chv_gpio_irq_handler);
+        return 0;
+
+fail:
+        gpiochip_remove(chip);
+
+        return ret;
+}
+
+static int chv_pinctrl_probe(struct platform_device *pdev)
+{
+        struct chv_pinctrl *pctrl;
+        struct acpi_device *adev;
+        struct resource *res;
+        int ret, irq, i;
+
+        adev = ACPI_COMPANION(&pdev->dev);
+        if (!adev)
+                return -ENODEV;
+
+        pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL);
+        if (!pctrl)
+                return -ENOMEM;
+
+        for (i = 0; i < ARRAY_SIZE(chv_communities); i++)
+                if (!strcmp(adev->pnp.unique_id, chv_communities[i]->uid)) {
+                        pctrl->community = chv_communities[i];
+                        break;
+                }
+        if (i == ARRAY_SIZE(chv_communities))
+                return -ENODEV;
+
+        spin_lock_init(&pctrl->lock);
+        pctrl->dev = &pdev->dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        pctrl->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(pctrl->regs))
+                return PTR_ERR(pctrl->regs);
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "failed to get interrupt number\n");
+                return irq;
+        }
+
+        pctrl->pctldesc = chv_pinctrl_desc;
+        pctrl->pctldesc.name = dev_name(&pdev->dev);
+        pctrl->pctldesc.pins = pctrl->community->pins;
+        pctrl->pctldesc.npins = pctrl->community->npins;
+
+        pctrl->pctldev = pinctrl_register(&pctrl->pctldesc, &pdev->dev, pctrl);
+        if (!pctrl->pctldev) {
+                dev_err(&pdev->dev, "failed to register pinctrl driver\n");
+                return -ENODEV;
+        }
+
+        ret = chv_gpio_probe(pctrl, irq);
+        if (ret) {
+                pinctrl_unregister(pctrl->pctldev);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, pctrl);
+
+        return 0;
+}
+
+static int chv_pinctrl_remove(struct platform_device *pdev)
+{
+        struct chv_pinctrl *pctrl = platform_get_drvdata(pdev);
+
+        gpiochip_remove(&pctrl->chip);
+        pinctrl_unregister(pctrl->pctldev);
+
+        return 0;
+}
+
+static const struct acpi_device_id chv_pinctrl_acpi_match[] = {
+        { "INT33FF" },
+        { }
+};
+MODULE_DEVICE_TABLE(acpi, chv_pinctrl_acpi_match);
+
+static struct platform_driver chv_pinctrl_driver = {
+        .probe = chv_pinctrl_probe,
+        .remove = chv_pinctrl_remove,
+        .driver = {
+                .name = "cherryview-pinctrl",
+                .owner = THIS_MODULE,
+                .acpi_match_table = chv_pinctrl_acpi_match,
+        },
+};
+
+static int __init chv_pinctrl_init(void)
+{
+        return platform_driver_register(&chv_pinctrl_driver);
+}
+subsys_initcall(chv_pinctrl_init);
+
+static void __exit chv_pinctrl_exit(void)
+{
+        platform_driver_unregister(&chv_pinctrl_driver);
+}
+module_exit(chv_pinctrl_exit);
+
+MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
+MODULE_DESCRIPTION("Intel Cherryview/Braswell pinctrl driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pinctrl/nomadik/pinctrl-abx500.c b/drivers/pinctrl/nomadik/pinctrl-abx500.c
index 228972827132..e1087c75e4f4 100644
--- a/drivers/pinctrl/nomadik/pinctrl-abx500.c
+++ b/drivers/pinctrl/nomadik/pinctrl-abx500.c
@@ -891,14 +891,13 @@ static int abx500_dt_subnode_to_map(struct pinctrl_dev *pctldev,
         const char *function = NULL;
         unsigned long *configs;
         unsigned int nconfigs = 0;
-        bool has_config = 0;
         struct property *prop;
-        const char *group, *gpio_name;
-        struct device_node *np_config;
 
-        ret = of_property_read_string(np, "ste,function", &function);
+        ret = of_property_read_string(np, "function", &function);
         if (ret >= 0) {
-                ret = of_property_count_strings(np, "ste,pins");
+                const char *group;
+
+                ret = of_property_count_strings(np, "groups");
                 if (ret < 0)
                         goto exit;
 
@@ -907,7 +906,7 @@ static int abx500_dt_subnode_to_map(struct pinctrl_dev *pctldev,
                 if (ret < 0)
                         goto exit;
 
-                of_property_for_each_string(np, "ste,pins", prop, group) {
+                of_property_for_each_string(np, "groups", prop, group) {
                         ret = abx500_dt_add_map_mux(map, reserved_maps,
                                         num_maps, group, function);
                         if (ret < 0)
@@ -916,18 +915,11 @@ static int abx500_dt_subnode_to_map(struct pinctrl_dev *pctldev,
         }
 
         ret = pinconf_generic_parse_dt_config(np, &configs, &nconfigs);
-        if (nconfigs)
-                has_config = 1;
-        np_config = of_parse_phandle(np, "ste,config", 0);
-        if (np_config) {
-                ret = pinconf_generic_parse_dt_config(np_config, &configs,
-                                &nconfigs);
-                if (ret)
-                        goto exit;
-                has_config |= nconfigs;
-        }
-        if (has_config) {
-                ret = of_property_count_strings(np, "ste,pins");
+        if (nconfigs) {
+                const char *gpio_name;
+                const char *pin;
+
+                ret = of_property_count_strings(np, "pins");
                 if (ret < 0)
                         goto exit;
 
@@ -937,8 +929,8 @@ static int abx500_dt_subnode_to_map(struct pinctrl_dev *pctldev,
                 if (ret < 0)
                         goto exit;
 
-                of_property_for_each_string(np, "ste,pins", prop, group) {
-                        gpio_name = abx500_find_pin_name(pctldev, group);
+                of_property_for_each_string(np, "pins", prop, pin) {
+                        gpio_name = abx500_find_pin_name(pctldev, pin);
 
                         ret = abx500_dt_add_map_configs(map, reserved_maps,
                                         num_maps, gpio_name, configs, 1);
@@ -1112,6 +1104,7 @@ out:
 static const struct pinconf_ops abx500_pinconf_ops = {
         .pin_config_get = abx500_pin_config_get,
         .pin_config_set = abx500_pin_config_set,
+        .is_generic = true,
 };
 
 static struct pinctrl_desc abx500_pinctrl_desc = {
diff --git a/drivers/pinctrl/nomadik/pinctrl-nomadik-stn8815.c b/drivers/pinctrl/nomadik/pinctrl-nomadik-stn8815.c
index ed39dcafd4f8..2cd71470f270 100644
--- a/drivers/pinctrl/nomadik/pinctrl-nomadik-stn8815.c
+++ b/drivers/pinctrl/nomadik/pinctrl-nomadik-stn8815.c
@@ -291,6 +291,7 @@ static const unsigned u0_a_1_pins[] = { STN8815_PIN_B4, STN8815_PIN_D5,
 static const unsigned mmcsd_a_1_pins[] = { STN8815_PIN_B10, STN8815_PIN_A10,
         STN8815_PIN_C11, STN8815_PIN_B11, STN8815_PIN_A11, STN8815_PIN_C12,
         STN8815_PIN_B12, STN8815_PIN_A12, STN8815_PIN_C13, STN8815_PIN_C15 };
+static const unsigned mmcsd_b_1_pins[] = { STN8815_PIN_D15 };
 static const unsigned u1_a_1_pins[] = { STN8815_PIN_M2, STN8815_PIN_L1,
                                         STN8815_PIN_F3, STN8815_PIN_F2 };
 static const unsigned i2c1_a_1_pins[] = { STN8815_PIN_L4, STN8815_PIN_L3 };
@@ -305,6 +306,7 @@ static const unsigned i2cusb_b_1_pins[] = { STN8815_PIN_C21, STN8815_PIN_C20 };
 static const struct nmk_pingroup nmk_stn8815_groups[] = {
         STN8815_PIN_GROUP(u0_a_1, NMK_GPIO_ALT_A),
         STN8815_PIN_GROUP(mmcsd_a_1, NMK_GPIO_ALT_A),
+        STN8815_PIN_GROUP(mmcsd_b_1, NMK_GPIO_ALT_B),
         STN8815_PIN_GROUP(u1_a_1, NMK_GPIO_ALT_A),
         STN8815_PIN_GROUP(i2c1_a_1, NMK_GPIO_ALT_A),
         STN8815_PIN_GROUP(i2c0_a_1, NMK_GPIO_ALT_A),
@@ -317,7 +319,7 @@ static const struct nmk_pingroup nmk_stn8815_groups[] = {
 static const char * const a##_groups[] = { b };
 
 STN8815_FUNC_GROUPS(u0, "u0_a_1");
-STN8815_FUNC_GROUPS(mmcsd, "mmcsd_a_1");
+STN8815_FUNC_GROUPS(mmcsd, "mmcsd_a_1", "mmcsd_b_1");
 STN8815_FUNC_GROUPS(u1, "u1_a_1", "u1_b_1");
 STN8815_FUNC_GROUPS(i2c1, "i2c1_a_1");
 STN8815_FUNC_GROUPS(i2c0, "i2c0_a_1");
diff --git a/drivers/pinctrl/nomadik/pinctrl-nomadik.c b/drivers/pinctrl/nomadik/pinctrl-nomadik.c
index 746db6acf648..ad99ba886e50 100644
--- a/drivers/pinctrl/nomadik/pinctrl-nomadik.c
+++ b/drivers/pinctrl/nomadik/pinctrl-nomadik.c
@@ -1520,12 +1520,13 @@ static int nmk_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
         unsigned long configs = 0;
         bool has_config = 0;
         struct property *prop;
-        const char *group, *gpio_name;
         struct device_node *np_config;
 
-        ret = of_property_read_string(np, "ste,function", &function);
+        ret = of_property_read_string(np, "function", &function);
         if (ret >= 0) {
-                ret = of_property_count_strings(np, "ste,pins");
+                const char *group;
+
+                ret = of_property_count_strings(np, "groups");
                 if (ret < 0)
                         goto exit;
 
@@ -1535,7 +1536,7 @@ static int nmk_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
                 if (ret < 0)
                         goto exit;
 
-                of_property_for_each_string(np, "ste,pins", prop, group) {
+                of_property_for_each_string(np, "groups", prop, group) {
                         ret = nmk_dt_add_map_mux(map, reserved_maps, num_maps,
                                           group, function);
                         if (ret < 0)
@@ -1548,7 +1549,10 @@ static int nmk_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
         if (np_config)
                 has_config |= nmk_pinctrl_dt_get_config(np_config, &configs);
         if (has_config) {
-                ret = of_property_count_strings(np, "ste,pins");
+                const char *gpio_name;
+                const char *pin;
+
+                ret = of_property_count_strings(np, "pins");
                 if (ret < 0)
                         goto exit;
                 ret = pinctrl_utils_reserve_map(pctldev, map,
@@ -1557,8 +1561,8 @@ static int nmk_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
                 if (ret < 0)
                         goto exit;
 
-                of_property_for_each_string(np, "ste,pins", prop, group) {
-                        gpio_name = nmk_find_pin_name(pctldev, group);
+                of_property_for_each_string(np, "pins", prop, pin) {
+                        gpio_name = nmk_find_pin_name(pctldev, pin);
 
                         ret = nmk_dt_add_map_configs(map, reserved_maps,
                                                      num_maps,
diff --git a/drivers/pinctrl/pinconf-generic.c b/drivers/pinctrl/pinconf-generic.c
index 29ff77f90fcb..f78b416d7984 100644
--- a/drivers/pinctrl/pinconf-generic.c
+++ b/drivers/pinctrl/pinconf-generic.c
@@ -32,30 +32,32 @@ struct pin_config_item {
         const enum pin_config_param param;
         const char * const display;
         const char * const format;
+        bool has_arg;
 };
 
-#define PCONFDUMP(a, b, c) { .param = a, .display = b, .format = c }
+#define PCONFDUMP(a, b, c, d) { .param = a, .display = b, .format = c, \
+                                .has_arg = d }
 
-static struct pin_config_item conf_items[] = {
-        PCONFDUMP(PIN_CONFIG_BIAS_DISABLE, "input bias disabled", NULL),
-        PCONFDUMP(PIN_CONFIG_BIAS_HIGH_IMPEDANCE, "input bias high impedance", NULL),
-        PCONFDUMP(PIN_CONFIG_BIAS_BUS_HOLD, "input bias bus hold", NULL),
-        PCONFDUMP(PIN_CONFIG_BIAS_PULL_UP, "input bias pull up", NULL),
-        PCONFDUMP(PIN_CONFIG_BIAS_PULL_DOWN, "input bias pull down", NULL),
+static const struct pin_config_item conf_items[] = {
+        PCONFDUMP(PIN_CONFIG_BIAS_DISABLE, "input bias disabled", NULL, false),
+        PCONFDUMP(PIN_CONFIG_BIAS_HIGH_IMPEDANCE, "input bias high impedance", NULL, false),
+        PCONFDUMP(PIN_CONFIG_BIAS_BUS_HOLD, "input bias bus hold", NULL, false),
+        PCONFDUMP(PIN_CONFIG_BIAS_PULL_UP, "input bias pull up", NULL, false),
+        PCONFDUMP(PIN_CONFIG_BIAS_PULL_DOWN, "input bias pull down", NULL, false),
         PCONFDUMP(PIN_CONFIG_BIAS_PULL_PIN_DEFAULT,
-                                "input bias pull to pin specific state", NULL),
-        PCONFDUMP(PIN_CONFIG_DRIVE_PUSH_PULL, "output drive push pull", NULL),
-        PCONFDUMP(PIN_CONFIG_DRIVE_OPEN_DRAIN, "output drive open drain", NULL),
-        PCONFDUMP(PIN_CONFIG_DRIVE_OPEN_SOURCE, "output drive open source", NULL),
-        PCONFDUMP(PIN_CONFIG_DRIVE_STRENGTH, "output drive strength", "mA"),
-        PCONFDUMP(PIN_CONFIG_INPUT_ENABLE, "input enabled", NULL),
-        PCONFDUMP(PIN_CONFIG_INPUT_SCHMITT_ENABLE, "input schmitt enabled", NULL),
-        PCONFDUMP(PIN_CONFIG_INPUT_SCHMITT, "input schmitt trigger", NULL),
-        PCONFDUMP(PIN_CONFIG_INPUT_DEBOUNCE, "input debounce", "usec"),
-        PCONFDUMP(PIN_CONFIG_POWER_SOURCE, "pin power source", "selector"),
-        PCONFDUMP(PIN_CONFIG_SLEW_RATE, "slew rate", NULL),
-        PCONFDUMP(PIN_CONFIG_LOW_POWER_MODE, "pin low power", "mode"),
-        PCONFDUMP(PIN_CONFIG_OUTPUT, "pin output", "level"),
+                                "input bias pull to pin specific state", NULL, false),
+        PCONFDUMP(PIN_CONFIG_DRIVE_PUSH_PULL, "output drive push pull", NULL, false),
+        PCONFDUMP(PIN_CONFIG_DRIVE_OPEN_DRAIN, "output drive open drain", NULL, false),
+        PCONFDUMP(PIN_CONFIG_DRIVE_OPEN_SOURCE, "output drive open source", NULL, false),
+        PCONFDUMP(PIN_CONFIG_DRIVE_STRENGTH, "output drive strength", "mA", true),
+        PCONFDUMP(PIN_CONFIG_INPUT_ENABLE, "input enabled", NULL, false),
+        PCONFDUMP(PIN_CONFIG_INPUT_SCHMITT_ENABLE, "input schmitt enabled", NULL, false),
+        PCONFDUMP(PIN_CONFIG_INPUT_SCHMITT, "input schmitt trigger", NULL, false),
+        PCONFDUMP(PIN_CONFIG_INPUT_DEBOUNCE, "input debounce", "usec", true),
+        PCONFDUMP(PIN_CONFIG_POWER_SOURCE, "pin power source", "selector", true),
+        PCONFDUMP(PIN_CONFIG_SLEW_RATE, "slew rate", NULL, true),
+        PCONFDUMP(PIN_CONFIG_LOW_POWER_MODE, "pin low power", "mode", true),
+        PCONFDUMP(PIN_CONFIG_OUTPUT, "pin output", "level", true),
 };
 
 void pinconf_generic_dump_pin(struct pinctrl_dev *pctldev,
@@ -85,11 +87,14 @@ void pinconf_generic_dump_pin(struct pinctrl_dev *pctldev,
                 seq_puts(s, " ");
                 seq_puts(s, conf_items[i].display);
                 /* Print unit if available */
-                if (conf_items[i].format &&
-                    pinconf_to_config_argument(config) != 0)
-                        seq_printf(s, " (%u %s)",
-                                   pinconf_to_config_argument(config),
-                                   conf_items[i].format);
+                if (conf_items[i].has_arg) {
+                        seq_printf(s, " (%u",
+                                   pinconf_to_config_argument(config));
+                        if (conf_items[i].format)
+                                seq_printf(s, " %s)", conf_items[i].format);
+                        else
+                                seq_puts(s, ")");
+                }
         }
 }
 
@@ -121,10 +126,14 @@ void pinconf_generic_dump_group(struct pinctrl_dev *pctldev,
                 seq_puts(s, " ");
                 seq_puts(s, conf_items[i].display);
                 /* Print unit if available */
-                if (conf_items[i].format && config != 0)
-                        seq_printf(s, " (%u %s)",
-                                   pinconf_to_config_argument(config),
-                                   conf_items[i].format);
+                if (conf_items[i].has_arg) {
+                        seq_printf(s, " (%u",
+                                   pinconf_to_config_argument(config));
+                        if (conf_items[i].format)
+                                seq_printf(s, " %s)", conf_items[i].format);
+                        else
+                                seq_puts(s, ")");
+                }
         }
 }
 
@@ -150,7 +159,7 @@ struct pinconf_generic_dt_params {
         u32 default_value;
 };
 
-static struct pinconf_generic_dt_params dt_params[] = {
+static const struct pinconf_generic_dt_params dt_params[] = {
         { "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 },
         { "bias-high-impedance", PIN_CONFIG_BIAS_HIGH_IMPEDANCE, 0 },
         { "bias-bus-hold", PIN_CONFIG_BIAS_BUS_HOLD, 0 },
@@ -200,7 +209,7 @@ int pinconf_generic_parse_dt_config(struct device_node *np,
                 return -ENOMEM;
 
         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
-                struct pinconf_generic_dt_params *par = &dt_params[i];
+                const struct pinconf_generic_dt_params *par = &dt_params[i];
                 ret = of_property_read_u32(np, par->property, &val);
 
                 /* property not found */
diff --git a/drivers/pinctrl/pinctrl-at91.c b/drivers/pinctrl/pinctrl-at91.c
index 354a81d40925..66db9849aca8 100644
--- a/drivers/pinctrl/pinctrl-at91.c
+++ b/drivers/pinctrl/pinctrl-at91.c
@@ -25,9 +25,7 @@
 /* Since we request GPIOs from ourself */
 #include <linux/pinctrl/consumer.h>
 
-#include <mach/hardware.h>
-#include <mach/at91_pio.h>
-
+#include "pinctrl-at91.h"
 #include "core.h"
 
 #define MAX_GPIO_BANKS          5
@@ -1344,7 +1342,6 @@ static void at91_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
         for (i = 0; i < chip->ngpio; i++) {
                 unsigned mask = pin_to_mask(i);
                 const char *gpio_label;
-                u32 pdsr;
 
                 gpio_label = gpiochip_is_requested(chip, i);
                 if (!gpio_label)
@@ -1353,11 +1350,13 @@ static void at91_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
                 seq_printf(s, "[%s] GPIO%s%d: ",
                            gpio_label, chip->label, i);
                 if (mode == AT91_MUX_GPIO) {
-                        pdsr = readl_relaxed(pio + PIO_PDSR);
-
-                        seq_printf(s, "[gpio] %s\n",
-                                   pdsr & mask ?
-                                   "set" : "clear");
+                        seq_printf(s, "[gpio] ");
+                        seq_printf(s, "%s ",
+                                      readl_relaxed(pio + PIO_OSR) & mask ?
+                                      "output" : "input");
+                        seq_printf(s, "%s\n",
+                                      readl_relaxed(pio + PIO_PDSR) & mask ?
+                                      "set" : "clear");
                 } else {
                         seq_printf(s, "[periph %c]\n",
                                    mode + 'A' - 1);
diff --git a/drivers/pinctrl/pinctrl-at91.h b/drivers/pinctrl/pinctrl-at91.h
new file mode 100644
index 000000000000..79b957f1dfa2
--- /dev/null
+++ b/drivers/pinctrl/pinctrl-at91.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2005 Ivan Kokshaysky
+ * Copyright (C) SAN People
+ *
+ * Parallel I/O Controller (PIO) - System peripherals registers.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef __PINCTRL_AT91_H
+#define __PINCTRL_AT91_H
+
+#define PIO_PER         0x00    /* Enable Register */
+#define PIO_PDR         0x04    /* Disable Register */
+#define PIO_PSR         0x08    /* Status Register */
+#define PIO_OER         0x10    /* Output Enable Register */
+#define PIO_ODR         0x14    /* Output Disable Register */
+#define PIO_OSR         0x18    /* Output Status Register */
+#define PIO_IFER        0x20    /* Glitch Input Filter Enable */
+#define PIO_IFDR        0x24    /* Glitch Input Filter Disable */
+#define PIO_IFSR        0x28    /* Glitch Input Filter Status */
+#define PIO_SODR        0x30    /* Set Output Data Register */
+#define PIO_CODR        0x34    /* Clear Output Data Register */
+#define PIO_ODSR        0x38    /* Output Data Status Register */
+#define PIO_PDSR        0x3c    /* Pin Data Status Register */
+#define PIO_IER         0x40    /* Interrupt Enable Register */
+#define PIO_IDR         0x44    /* Interrupt Disable Register */
+#define PIO_IMR         0x48    /* Interrupt Mask Register */
+#define PIO_ISR         0x4c    /* Interrupt Status Register */
+#define PIO_MDER        0x50    /* Multi-driver Enable Register */
+#define PIO_MDDR        0x54    /* Multi-driver Disable Register */
+#define PIO_MDSR        0x58    /* Multi-driver Status Register */
+#define PIO_PUDR        0x60    /* Pull-up Disable Register */
+#define PIO_PUER        0x64    /* Pull-up Enable Register */
+#define PIO_PUSR        0x68    /* Pull-up Status Register */
+#define PIO_ASR         0x70    /* Peripheral A Select Register */
+#define PIO_ABCDSR1     0x70    /* Peripheral ABCD Select Register 1 [some sam9 only] */
+#define PIO_BSR         0x74    /* Peripheral B Select Register */
+#define PIO_ABCDSR2     0x74    /* Peripheral ABCD Select Register 2 [some sam9 only] */
+#define PIO_ABSR        0x78    /* AB Status Register */
+#define PIO_IFSCDR      0x80    /* Input Filter Slow Clock Disable Register */
+#define PIO_IFSCER      0x84    /* Input Filter Slow Clock Enable Register */
+#define PIO_IFSCSR      0x88    /* Input Filter Slow Clock Status Register */
+#define PIO_SCDR        0x8c    /* Slow Clock Divider Debouncing Register */
+#define         PIO_SCDR_DIV    (0x3fff <<  0)          /* Slow Clock Divider Mask */
+#define PIO_PPDDR       0x90    /* Pad Pull-down Disable Register */
+#define PIO_PPDER       0x94    /* Pad Pull-down Enable Register */
+#define PIO_PPDSR       0x98    /* Pad Pull-down Status Register */
+#define PIO_OWER        0xa0    /* Output Write Enable Register */
+#define PIO_OWDR        0xa4    /* Output Write Disable Register */
+#define PIO_OWSR        0xa8    /* Output Write Status Register */
+#define PIO_AIMER       0xb0    /* Additional Interrupt Modes Enable Register */
+#define PIO_AIMDR       0xb4    /* Additional Interrupt Modes Disable Register */
+#define PIO_AIMMR       0xb8    /* Additional Interrupt Modes Mask Register */
+#define PIO_ESR         0xc0    /* Edge Select Register */
+#define PIO_LSR         0xc4    /* Level Select Register */
+#define PIO_ELSR        0xc8    /* Edge/Level Status Register */
+#define PIO_FELLSR      0xd0    /* Falling Edge/Low Level Select Register */
+#define PIO_REHLSR      0xd4    /* Rising Edge/ High Level Select Register */
+#define PIO_FRLHSR      0xd8    /* Fall/Rise - Low/High Status Register */
+#define PIO_SCHMITT     0x100   /* Schmitt Trigger Register */
+
+#define SAMA5D3_PIO_DRIVER1             0x118  /*PIO Driver 1 register offset*/
+#define SAMA5D3_PIO_DRIVER2             0x11C  /*PIO Driver 2 register offset*/
+
+#define AT91SAM9X5_PIO_DRIVER1  0x114  /*PIO Driver 1 register offset*/
+#define AT91SAM9X5_PIO_DRIVER2  0x118  /*PIO Driver 2 register offset*/
+
+#endif
diff --git a/drivers/pinctrl/pinctrl-bcm281xx.c b/drivers/pinctrl/pinctrl-bcm281xx.c
index a26e0c2ba33e..2b25047fef8d 100644
--- a/drivers/pinctrl/pinctrl-bcm281xx.c
+++ b/drivers/pinctrl/pinctrl-bcm281xx.c
@@ -1404,11 +1404,6 @@ static int __init bcm281xx_pinctrl_probe(struct platform_device *pdev)
 
         /* So far We can assume there is only 1 bank of registers */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "Missing MEM resource\n");
-                return -ENODEV;
-        }
-
         pdata->reg_base = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(pdata->reg_base)) {
                 dev_err(&pdev->dev, "Failed to ioremap MEM resource\n");
diff --git a/drivers/pinctrl/pinctrl-rockchip.c b/drivers/pinctrl/pinctrl-rockchip.c
index 016f4578e494..40970c305dd0 100644
--- a/drivers/pinctrl/pinctrl-rockchip.c
+++ b/drivers/pinctrl/pinctrl-rockchip.c
@@ -856,27 +856,22 @@ static int rockchip_pmx_set(struct pinctrl_dev *pctldev, unsigned selector,
  * leads to this function call (via the pinctrl_gpio_direction_{input|output}()
  * function called from the gpiolib interface).
  */
-static int rockchip_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
-                                              struct pinctrl_gpio_range *range,
-                                              unsigned offset, bool input)
+static int _rockchip_pmx_gpio_set_direction(struct gpio_chip *chip,
+                                            int pin, bool input)
 {
-        struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
         struct rockchip_pin_bank *bank;
-        struct gpio_chip *chip;
-        int pin, ret;
+        int ret;
+        unsigned long flags;
         u32 data;
 
-        chip = range->gc;
         bank = gc_to_pin_bank(chip);
-        pin = offset - chip->base;
-
-        dev_dbg(info->dev, "gpio_direction for pin %u as %s-%d to %s\n",
-                 offset, range->name, pin, input ? "input" : "output");
 
         ret = rockchip_set_mux(bank, pin, RK_FUNC_GPIO);
         if (ret < 0)
                 return ret;
 
+        spin_lock_irqsave(&bank->slock, flags);
+
         data = readl_relaxed(bank->reg_base + GPIO_SWPORT_DDR);
         /* set bit to 1 for output, 0 for input */
         if (!input)
@@ -885,9 +880,28 @@ static int rockchip_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
                 data &= ~BIT(pin);
         writel_relaxed(data, bank->reg_base + GPIO_SWPORT_DDR);
 
+        spin_unlock_irqrestore(&bank->slock, flags);
+
         return 0;
 }
 
+static int rockchip_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
+                                              struct pinctrl_gpio_range *range,
+                                              unsigned offset, bool input)
+{
+        struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
+        struct gpio_chip *chip;
+        int pin;
+
+        chip = range->gc;
+        pin = offset - chip->base;
+        dev_dbg(info->dev, "gpio_direction for pin %u as %s-%d to %s\n",
+                 offset, range->name, pin, input ? "input" : "output");
+
+        return _rockchip_pmx_gpio_set_direction(chip, offset - chip->base,
+                                                input);
+}
+
 static const struct pinmux_ops rockchip_pmx_ops = {
         .get_functions_count    = rockchip_pmx_get_funcs_count,
         .get_function_name      = rockchip_pmx_get_func_name,
@@ -917,8 +931,7 @@ static bool rockchip_pinconf_pull_valid(struct rockchip_pin_ctrl *ctrl,
         return false;
 }
 
-static int rockchip_gpio_direction_output(struct gpio_chip *gc,
-                                          unsigned offset, int value);
+static void rockchip_gpio_set(struct gpio_chip *gc, unsigned offset, int value);
 static int rockchip_gpio_get(struct gpio_chip *gc, unsigned offset);
 
 /* set the pin config settings for a specified pin */
@@ -959,9 +972,10 @@ static int rockchip_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
                                 return rc;
                         break;
                 case PIN_CONFIG_OUTPUT:
-                        rc = rockchip_gpio_direction_output(&bank->gpio_chip,
-                                                            pin - bank->pin_base,
-                                                            arg);
+                        rockchip_gpio_set(&bank->gpio_chip,
+                                          pin - bank->pin_base, arg);
+                        rc = _rockchip_pmx_gpio_set_direction(&bank->gpio_chip,
+                                          pin - bank->pin_base, false);
                         if (rc)
                                 return rc;
                         break;
@@ -1253,6 +1267,10 @@ static int rockchip_pinctrl_register(struct platform_device *pdev,
                 }
         }
 
+        ret = rockchip_pinctrl_parse_dt(pdev, info);
+        if (ret)
+                return ret;
+
         info->pctl_dev = pinctrl_register(ctrldesc, &pdev->dev, info);
         if (!info->pctl_dev) {
                 dev_err(&pdev->dev, "could not register pinctrl driver\n");
@@ -1270,12 +1288,6 @@ static int rockchip_pinctrl_register(struct platform_device *pdev,
                 pinctrl_add_gpio_range(info->pctl_dev, &pin_bank->grange);
         }
 
-        ret = rockchip_pinctrl_parse_dt(pdev, info);
-        if (ret) {
-                pinctrl_unregister(info->pctl_dev);
-                return ret;
-        }
-
         return 0;
 }
 
@@ -1387,6 +1399,7 @@ static void rockchip_irq_demux(unsigned int irq, struct irq_desc *desc)
         u32 polarity = 0, data = 0;
         u32 pend;
         bool edge_changed = false;
+        unsigned long flags;
 
         dev_dbg(bank->drvdata->dev, "got irq for bank %s\n", bank->name);
 
@@ -1432,10 +1445,14 @@ static void rockchip_irq_demux(unsigned int irq, struct irq_desc *desc)
 
         if (bank->toggle_edge_mode && edge_changed) {
                 /* Interrupt params should only be set with ints disabled */
+                spin_lock_irqsave(&bank->slock, flags);
+
                 data = readl_relaxed(bank->reg_base + GPIO_INTEN);
                 writel_relaxed(0, bank->reg_base + GPIO_INTEN);
                 writel(polarity, bank->reg_base + GPIO_INT_POLARITY);
                 writel(data, bank->reg_base + GPIO_INTEN);
+
+                spin_unlock_irqrestore(&bank->slock, flags);
         }
 
         chained_irq_exit(chip, desc);
@@ -1449,6 +1466,7 @@ static int rockchip_irq_set_type(struct irq_data *d, unsigned int type)
         u32 polarity;
         u32 level;
         u32 data;
+        unsigned long flags;
         int ret;
 
         /* make sure the pin is configured as gpio input */
@@ -1456,15 +1474,20 @@ static int rockchip_irq_set_type(struct irq_data *d, unsigned int type)
         if (ret < 0)
                 return ret;
 
+        spin_lock_irqsave(&bank->slock, flags);
+
         data = readl_relaxed(bank->reg_base + GPIO_SWPORT_DDR);
         data &= ~mask;
         writel_relaxed(data, bank->reg_base + GPIO_SWPORT_DDR);
 
+        spin_unlock_irqrestore(&bank->slock, flags);
+
         if (type & IRQ_TYPE_EDGE_BOTH)
                 __irq_set_handler_locked(d->irq, handle_edge_irq);
         else
                 __irq_set_handler_locked(d->irq, handle_level_irq);
 
+        spin_lock_irqsave(&bank->slock, flags);
         irq_gc_lock(gc);
 
         level = readl_relaxed(gc->reg_base + GPIO_INTTYPE_LEVEL);
@@ -1507,6 +1530,7 @@ static int rockchip_irq_set_type(struct irq_data *d, unsigned int type)
                 break;
         default:
                 irq_gc_unlock(gc);
+                spin_unlock_irqrestore(&bank->slock, flags);
                 return -EINVAL;
         }
 
@@ -1514,6 +1538,7 @@ static int rockchip_irq_set_type(struct irq_data *d, unsigned int type)
         writel_relaxed(polarity, gc->reg_base + GPIO_INT_POLARITY);
 
         irq_gc_unlock(gc);
+        spin_unlock_irqrestore(&bank->slock, flags);
 
         return 0;
 }
@@ -1563,6 +1588,7 @@ static int rockchip_interrupts_register(struct platform_device *pdev,
                 gc->chip_types[0].chip.irq_unmask = irq_gc_mask_set_bit;
                 gc->chip_types[0].chip.irq_set_wake = irq_gc_set_wake;
                 gc->chip_types[0].chip.irq_set_type = rockchip_irq_set_type;
+                gc->wake_enabled = IRQ_MSK(bank->nr_pins);
 
                 irq_set_handler_data(bank->irq, bank);
                 irq_set_chained_handler(bank->irq, rockchip_irq_demux);
@@ -1770,6 +1796,51 @@ static struct rockchip_pin_ctrl *rockchip_pinctrl_get_soc_data(
         return ctrl;
 }
 
+#define RK3288_GRF_GPIO6C_IOMUX         0x64
+#define GPIO6C6_SEL_WRITE_ENABLE        BIT(28)
+
+static u32 rk3288_grf_gpio6c_iomux;
+
+static int __maybe_unused rockchip_pinctrl_suspend(struct device *dev)
+{
+        struct rockchip_pinctrl *info = dev_get_drvdata(dev);
+        int ret = pinctrl_force_sleep(info->pctl_dev);
+
+        if (ret)
+                return ret;
+
+        /*
+         * RK3288 GPIO6_C6 mux would be modified by Maskrom when resume, so save
+         * the setting here, and restore it at resume.
+         */
+        if (info->ctrl->type == RK3288) {
+                ret = regmap_read(info->regmap_base, RK3288_GRF_GPIO6C_IOMUX,
+                                  &rk3288_grf_gpio6c_iomux);
+                if (ret) {
+                        pinctrl_force_default(info->pctl_dev);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static int __maybe_unused rockchip_pinctrl_resume(struct device *dev)
+{
+        struct rockchip_pinctrl *info = dev_get_drvdata(dev);
+        int ret = regmap_write(info->regmap_base, RK3288_GRF_GPIO6C_IOMUX,
+                               rk3288_grf_gpio6c_iomux |
+                               GPIO6C6_SEL_WRITE_ENABLE);
+
+        if (ret)
+                return ret;
+
+        return pinctrl_force_default(info->pctl_dev);
+}
+
+static SIMPLE_DEV_PM_OPS(rockchip_pinctrl_dev_pm_ops, rockchip_pinctrl_suspend,
+                         rockchip_pinctrl_resume);
+
 static int rockchip_pinctrl_probe(struct platform_device *pdev)
 {
         struct rockchip_pinctrl *info;
@@ -1983,6 +2054,7 @@ static struct platform_driver rockchip_pinctrl_driver = {
         .driver = {
                 .name   = "rockchip-pinctrl",
                 .owner  = THIS_MODULE,
+                .pm = &rockchip_pinctrl_dev_pm_ops,
                 .of_match_table = rockchip_pinctrl_dt_match,
         },
 };
diff --git a/drivers/pinctrl/pinctrl-st.c b/drivers/pinctrl/pinctrl-st.c
index 4b1792aad3d8..caeeb1c65b0f 100644
--- a/drivers/pinctrl/pinctrl-st.c
+++ b/drivers/pinctrl/pinctrl-st.c
@@ -1512,7 +1512,7 @@ static int st_gpiolib_register_bank(struct st_pinctrl *info,
                                              gpio_irq, st_gpio_irq_handler);
         }
 
-        if (info->irqmux_base > 0 || gpio_irq > 0) {
+        if (info->irqmux_base || gpio_irq > 0) {
                 err = gpiochip_irqchip_add(&bank->gpio_chip, &st_gpio_irqchip,
                                            0, handle_simple_irq,
                                            IRQ_TYPE_LEVEL_LOW);
diff --git a/drivers/pinctrl/pinctrl-tb10x.c b/drivers/pinctrl/pinctrl-tb10x.c
index 3b9bfcf717ac..9363563f9777 100644
--- a/drivers/pinctrl/pinctrl-tb10x.c
+++ b/drivers/pinctrl/pinctrl-tb10x.c
@@ -759,7 +759,7 @@ static struct pinctrl_desc tb10x_pindesc = {
 static int tb10x_pinctrl_probe(struct platform_device *pdev)
 {
         int ret = -EINVAL;
-        struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        struct resource *mem;
         struct device *dev = &pdev->dev;
         struct device_node *of_node = dev->of_node;
         struct device_node *child;
@@ -771,11 +771,6 @@ static int tb10x_pinctrl_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        if (!mem) {
-                dev_err(dev, "No memory resource defined.\n");
-                return -EINVAL;
-        }
-
         state = devm_kzalloc(dev, sizeof(struct tb10x_pinctrl) +
                                         of_get_child_count(of_node)
                                         * sizeof(struct tb10x_of_pinfunc),
@@ -787,6 +782,7 @@ static int tb10x_pinctrl_probe(struct platform_device *pdev)
         state->pinfuncs = (struct tb10x_of_pinfunc *)(state + 1);
         mutex_init(&state->mutex);
 
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         state->base = devm_ioremap_resource(dev, mem);
         if (IS_ERR(state->base)) {
                 ret = PTR_ERR(state->base);
diff --git a/drivers/pinctrl/pinctrl-tegra-xusb.c b/drivers/pinctrl/pinctrl-tegra-xusb.c
index 1631ec94fb02..080ec7723ef2 100644
--- a/drivers/pinctrl/pinctrl-tegra-xusb.c
+++ b/drivers/pinctrl/pinctrl-tegra-xusb.c
@@ -20,6 +20,7 @@
 #include <linux/pinctrl/pinmux.h>
 #include <linux/platform_device.h>
 #include <linux/reset.h>
+#include <linux/slab.h>
 
 #include <dt-bindings/pinctrl/pinctrl-tegra-xusb.h>
 
@@ -171,7 +172,7 @@ static int tegra_xusb_padctl_parse_subnode(struct tegra_xusb_padctl *padctl,
                         if (err == -EINVAL)
                                 continue;
 
-                        return err;
+                        goto out;
                 }
 
                 config = TEGRA_XUSB_PADCTL_PACK(properties[i].param, value);
@@ -179,7 +180,7 @@ static int tegra_xusb_padctl_parse_subnode(struct tegra_xusb_padctl *padctl,
                 err = pinctrl_utils_add_config(padctl->pinctrl, &configs,
                                                &num_configs, config);
                 if (err < 0)
-                        return err;
+                        goto out;
         }
 
         if (function)
@@ -190,14 +191,14 @@ static int tegra_xusb_padctl_parse_subnode(struct tegra_xusb_padctl *padctl,
 
         err = of_property_count_strings(np, "nvidia,lanes");
         if (err < 0)
-                return err;
+                goto out;
 
         reserve *= err;
 
         err = pinctrl_utils_reserve_map(padctl->pinctrl, maps, reserved_maps,
                                         num_maps, reserve);
         if (err < 0)
-                return err;
+                goto out;
 
         of_property_for_each_string(np, "nvidia,lanes", prop, group) {
                 if (function) {
@@ -205,7 +206,7 @@ static int tegra_xusb_padctl_parse_subnode(struct tegra_xusb_padctl *padctl,
                                         reserved_maps, num_maps, group,
                                         function);
                         if (err < 0)
-                                return err;
+                                goto out;
                 }
 
                 if (num_configs) {
@@ -214,11 +215,15 @@ static int tegra_xusb_padctl_parse_subnode(struct tegra_xusb_padctl *padctl,
                                         configs, num_configs,
                                         PIN_MAP_TYPE_CONFIGS_GROUP);
                         if (err < 0)
-                                return err;
+                                goto out;
                 }
         }
 
-        return 0;
+        err = 0;
+
+out:
+        kfree(configs);
+        return err;
 }
 
 static int tegra_xusb_padctl_dt_node_to_map(struct pinctrl_dev *pinctrl,
diff --git a/drivers/pinctrl/qcom/Kconfig b/drivers/pinctrl/qcom/Kconfig
index 81275af9638b..3cd243c26b7d 100644
--- a/drivers/pinctrl/qcom/Kconfig
+++ b/drivers/pinctrl/qcom/Kconfig
@@ -47,4 +47,17 @@ config PINCTRL_MSM8X74
           This is the pinctrl, pinmux, pinconf and gpiolib driver for the
           Qualcomm TLMM block found in the Qualcomm 8974 platform.
 
+config PINCTRL_QCOM_SPMI_PMIC
+       tristate "Qualcomm SPMI PMIC pin controller driver"
+       depends on GPIOLIB && OF && SPMI
+       select REGMAP_SPMI
+       select PINMUX
+       select PINCONF
+       select GENERIC_PINCONF
+       help
+         This is the pinctrl, pinmux, pinconf and gpiolib driver for the
+         Qualcomm GPIO and MPP blocks found in the Qualcomm PMIC's chips,
+         which are using SPMI for communication with SoC. Example PMIC's
+         devices are pm8841, pm8941 and pma8084.
+
 endif
diff --git a/drivers/pinctrl/qcom/Makefile b/drivers/pinctrl/qcom/Makefile
index ba8519fcd8d3..bfd79af5f982 100644
--- a/drivers/pinctrl/qcom/Makefile
+++ b/drivers/pinctrl/qcom/Makefile
@@ -5,3 +5,5 @@ obj-$(CONFIG_PINCTRL_APQ8084)	+= pinctrl-apq8084.o
 obj-$(CONFIG_PINCTRL_IPQ8064)   += pinctrl-ipq8064.o
 obj-$(CONFIG_PINCTRL_MSM8960)   += pinctrl-msm8960.o
 obj-$(CONFIG_PINCTRL_MSM8X74)   += pinctrl-msm8x74.o
+obj-$(CONFIG_PINCTRL_QCOM_SPMI_PMIC) += pinctrl-spmi-gpio.o
+obj-$(CONFIG_PINCTRL_QCOM_SPMI_PMIC) += pinctrl-spmi-mpp.o
diff --git a/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c b/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c
new file mode 100644
index 000000000000..b863b5080890
--- /dev/null
+++ b/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c
@@ -0,0 +1,933 @@
+/*
+ * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/gpio.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/pinctrl/pinconf-generic.h>
+#include <linux/pinctrl/pinconf.h>
+#include <linux/pinctrl/pinmux.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+#include <dt-bindings/pinctrl/qcom,pmic-gpio.h>
+
+#include "../core.h"
+#include "../pinctrl-utils.h"
+
+#define PMIC_GPIO_ADDRESS_RANGE                 0x100
+
+/* type and subtype registers base address offsets */
+#define PMIC_GPIO_REG_TYPE                      0x4
+#define PMIC_GPIO_REG_SUBTYPE                   0x5
+
+/* GPIO peripheral type and subtype out_values */
+#define PMIC_GPIO_TYPE                          0x10
+#define PMIC_GPIO_SUBTYPE_GPIO_4CH              0x1
+#define PMIC_GPIO_SUBTYPE_GPIOC_4CH             0x5
+#define PMIC_GPIO_SUBTYPE_GPIO_8CH              0x9
+#define PMIC_GPIO_SUBTYPE_GPIOC_8CH             0xd
+
+#define PMIC_MPP_REG_RT_STS                     0x10
+#define PMIC_MPP_REG_RT_STS_VAL_MASK            0x1
+
+/* control register base address offsets */
+#define PMIC_GPIO_REG_MODE_CTL                  0x40
+#define PMIC_GPIO_REG_DIG_VIN_CTL               0x41
+#define PMIC_GPIO_REG_DIG_PULL_CTL              0x42
+#define PMIC_GPIO_REG_DIG_OUT_CTL               0x45
+#define PMIC_GPIO_REG_EN_CTL                    0x46
+
+/* PMIC_GPIO_REG_MODE_CTL */
+#define PMIC_GPIO_REG_MODE_VALUE_SHIFT          0x1
+#define PMIC_GPIO_REG_MODE_FUNCTION_SHIFT       1
+#define PMIC_GPIO_REG_MODE_FUNCTION_MASK        0x7
+#define PMIC_GPIO_REG_MODE_DIR_SHIFT            4
+#define PMIC_GPIO_REG_MODE_DIR_MASK             0x7
+
+/* PMIC_GPIO_REG_DIG_VIN_CTL */
+#define PMIC_GPIO_REG_VIN_SHIFT                 0
+#define PMIC_GPIO_REG_VIN_MASK                  0x7
+
+/* PMIC_GPIO_REG_DIG_PULL_CTL */
+#define PMIC_GPIO_REG_PULL_SHIFT                0
+#define PMIC_GPIO_REG_PULL_MASK                 0x7
+
+#define PMIC_GPIO_PULL_DOWN                     4
+#define PMIC_GPIO_PULL_DISABLE                  5
+
+/* PMIC_GPIO_REG_DIG_OUT_CTL */
+#define PMIC_GPIO_REG_OUT_STRENGTH_SHIFT        0
+#define PMIC_GPIO_REG_OUT_STRENGTH_MASK         0x3
+#define PMIC_GPIO_REG_OUT_TYPE_SHIFT            4
+#define PMIC_GPIO_REG_OUT_TYPE_MASK             0x3
+
+/*
+ * Output type - indicates pin should be configured as push-pull,
+ * open drain or open source.
+ */
+#define PMIC_GPIO_OUT_BUF_CMOS                  0
+#define PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS       1
+#define PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS       2
+
+/* PMIC_GPIO_REG_EN_CTL */
+#define PMIC_GPIO_REG_MASTER_EN_SHIFT           7
+
+#define PMIC_GPIO_PHYSICAL_OFFSET               1
+
+/* Qualcomm specific pin configurations */
+#define PMIC_GPIO_CONF_PULL_UP                  (PIN_CONFIG_END + 1)
+#define PMIC_GPIO_CONF_STRENGTH                 (PIN_CONFIG_END + 2)
+
+/**
+ * struct pmic_gpio_pad - keep current GPIO settings
+ * @base: Address base in SPMI device.
+ * @irq: IRQ number which this GPIO generate.
+ * @is_enabled: Set to false when GPIO should be put in high Z state.
+ * @out_value: Cached pin output value
+ * @have_buffer: Set to true if GPIO output could be configured in push-pull,
+ *      open-drain or open-source mode.
+ * @output_enabled: Set to true if GPIO output logic is enabled.
+ * @input_enabled: Set to true if GPIO input buffer logic is enabled.
+ * @num_sources: Number of power-sources supported by this GPIO.
+ * @power_source: Current power-source used.
+ * @buffer_type: Push-pull, open-drain or open-source.
+ * @pullup: Constant current which flow trough GPIO output buffer.
+ * @strength: No, Low, Medium, High
+ * @function: See pmic_gpio_functions[]
+ */
+struct pmic_gpio_pad {
+        u16             base;
+        int             irq;
+        bool            is_enabled;
+        bool            out_value;
+        bool            have_buffer;
+        bool            output_enabled;
+        bool            input_enabled;
+        unsigned int    num_sources;
+        unsigned int    power_source;
+        unsigned int    buffer_type;
+        unsigned int    pullup;
+        unsigned int    strength;
+        unsigned int    function;
+};
+
+struct pmic_gpio_state {
+        struct device   *dev;
+        struct regmap   *map;
+        struct pinctrl_dev *ctrl;
+        struct gpio_chip chip;
+};
+
+struct pmic_gpio_bindings {
+        const char      *property;
+        unsigned        param;
+};
+
+static struct pmic_gpio_bindings pmic_gpio_bindings[] = {
+        {"qcom,pull-up-strength",       PMIC_GPIO_CONF_PULL_UP},
+        {"qcom,drive-strength",         PMIC_GPIO_CONF_STRENGTH},
+};
+
+static const char *const pmic_gpio_groups[] = {
+        "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7", "gpio8",
+        "gpio9", "gpio10", "gpio11", "gpio12", "gpio13", "gpio14", "gpio15",
+        "gpio16", "gpio17", "gpio18", "gpio19", "gpio20", "gpio21", "gpio22",
+        "gpio23", "gpio24", "gpio25", "gpio26", "gpio27", "gpio28", "gpio29",
+        "gpio30", "gpio31", "gpio32", "gpio33", "gpio34", "gpio35", "gpio36",
+};
+
+static const char *const pmic_gpio_functions[] = {
+        PMIC_GPIO_FUNC_NORMAL, PMIC_GPIO_FUNC_PAIRED,
+        PMIC_GPIO_FUNC_FUNC1, PMIC_GPIO_FUNC_FUNC2,
+        PMIC_GPIO_FUNC_DTEST1, PMIC_GPIO_FUNC_DTEST2,
+        PMIC_GPIO_FUNC_DTEST3, PMIC_GPIO_FUNC_DTEST4,
+};
+
+static inline struct pmic_gpio_state *to_gpio_state(struct gpio_chip *chip)
+{
+        return container_of(chip, struct pmic_gpio_state, chip);
+};
+
+static int pmic_gpio_read(struct pmic_gpio_state *state,
+                          struct pmic_gpio_pad *pad, unsigned int addr)
+{
+        unsigned int val;
+        int ret;
+
+        ret = regmap_read(state->map, pad->base + addr, &val);
+        if (ret < 0)
+                dev_err(state->dev, "read 0x%x failed\n", addr);
+        else
+                ret = val;
+
+        return ret;
+}
+
+static int pmic_gpio_write(struct pmic_gpio_state *state,
+                           struct pmic_gpio_pad *pad, unsigned int addr,
+                           unsigned int val)
+{
+        int ret;
+
+        ret = regmap_write(state->map, pad->base + addr, val);
+        if (ret < 0)
+                dev_err(state->dev, "write 0x%x failed\n", addr);
+
+        return ret;
+}
+
+static int pmic_gpio_get_groups_count(struct pinctrl_dev *pctldev)
+{
+        /* Every PIN is a group */
+        return pctldev->desc->npins;
+}
+
+static const char *pmic_gpio_get_group_name(struct pinctrl_dev *pctldev,
+                                            unsigned pin)
+{
+        return pctldev->desc->pins[pin].name;
+}
+
+static int pmic_gpio_get_group_pins(struct pinctrl_dev *pctldev, unsigned pin,
+                                    const unsigned **pins, unsigned *num_pins)
+{
+        *pins = &pctldev->desc->pins[pin].number;
+        *num_pins = 1;
+        return 0;
+}
+
+static int pmic_gpio_parse_dt_config(struct device_node *np,
+                                     struct pinctrl_dev *pctldev,
+                                     unsigned long **configs,
+                                     unsigned int *nconfs)
+{
+        struct pmic_gpio_bindings *par;
+        unsigned long cfg;
+        int ret, i;
+        u32 val;
+
+        for (i = 0; i < ARRAY_SIZE(pmic_gpio_bindings); i++) {
+                par = &pmic_gpio_bindings[i];
+                ret = of_property_read_u32(np, par->property, &val);
+
+                /* property not found */
+                if (ret == -EINVAL)
+                        continue;
+
+                /* use zero as default value */
+                if (ret)
+                        val = 0;
+
+                dev_dbg(pctldev->dev, "found %s with value %u\n",
+                        par->property, val);
+
+                cfg = pinconf_to_config_packed(par->param, val);
+
+                ret = pinctrl_utils_add_config(pctldev, configs, nconfs, cfg);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static int pmic_gpio_dt_subnode_to_map(struct pinctrl_dev *pctldev,
+                                       struct device_node *np,
+                                       struct pinctrl_map **map,
+                                       unsigned *reserv, unsigned *nmaps,
+                                       enum pinctrl_map_type type)
+{
+        unsigned long *configs = NULL;
+        unsigned nconfs = 0;
+        struct property *prop;
+        const char *group;
+        int ret;
+
+        ret = pmic_gpio_parse_dt_config(np, pctldev, &configs, &nconfs);
+        if (ret < 0)
+                return ret;
+
+        if (!nconfs)
+                return 0;
+
+        ret = of_property_count_strings(np, "pins");
+        if (ret < 0)
+                goto exit;
+
+        ret = pinctrl_utils_reserve_map(pctldev, map, reserv, nmaps, ret);
+        if (ret < 0)
+                goto exit;
+
+        of_property_for_each_string(np, "pins", prop, group) {
+                ret = pinctrl_utils_add_map_configs(pctldev, map,
+                                                    reserv, nmaps, group,
+                                                    configs, nconfs, type);
+                if (ret < 0)
+                        break;
+        }
+exit:
+        kfree(configs);
+        return ret;
+}
+
+static int pmic_gpio_dt_node_to_map(struct pinctrl_dev *pctldev,
+                                    struct device_node *np_config,
+                                    struct pinctrl_map **map, unsigned *nmaps)
+{
+        enum pinctrl_map_type type;
+        struct device_node *np;
+        unsigned reserv;
+        int ret;
+
+        ret = 0;
+        *map = NULL;
+        *nmaps = 0;
+        reserv = 0;
+        type = PIN_MAP_TYPE_CONFIGS_GROUP;
+
+        for_each_child_of_node(np_config, np) {
+                ret = pinconf_generic_dt_subnode_to_map(pctldev, np, map,
+                                                        &reserv, nmaps, type);
+                if (ret)
+                        break;
+
+                ret = pmic_gpio_dt_subnode_to_map(pctldev, np, map, &reserv,
+                                                  nmaps, type);
+                if (ret)
+                        break;
+        }
+
+        if (ret < 0)
+                pinctrl_utils_dt_free_map(pctldev, *map, *nmaps);
+
+        return ret;
+}
+
+static const struct pinctrl_ops pmic_gpio_pinctrl_ops = {
+        .get_groups_count       = pmic_gpio_get_groups_count,
+        .get_group_name         = pmic_gpio_get_group_name,
+        .get_group_pins         = pmic_gpio_get_group_pins,
+        .dt_node_to_map         = pmic_gpio_dt_node_to_map,
+        .dt_free_map            = pinctrl_utils_dt_free_map,
+};
+
+static int pmic_gpio_get_functions_count(struct pinctrl_dev *pctldev)
+{
+        return ARRAY_SIZE(pmic_gpio_functions);
+}
+
+static const char *pmic_gpio_get_function_name(struct pinctrl_dev *pctldev,
+                                               unsigned function)
+{
+        return pmic_gpio_functions[function];
+}
+
+static int pmic_gpio_get_function_groups(struct pinctrl_dev *pctldev,
+                                         unsigned function,
+                                         const char *const **groups,
+                                         unsigned *const num_qgroups)
+{
+        *groups = pmic_gpio_groups;
+        *num_qgroups = pctldev->desc->npins;
+        return 0;
+}
+
+static int pmic_gpio_set_mux(struct pinctrl_dev *pctldev, unsigned function,
+                                unsigned pin)
+{
+        struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev);
+        struct pmic_gpio_pad *pad;
+        unsigned int val;
+        int ret;
+
+        pad = pctldev->desc->pins[pin].drv_data;
+
+        pad->function = function;
+
+        val = 0;
+        if (pad->output_enabled) {
+                if (pad->input_enabled)
+                        val = 2;
+                else
+                        val = 1;
+        }
+
+        val |= pad->function << PMIC_GPIO_REG_MODE_FUNCTION_SHIFT;
+        val |= pad->out_value & PMIC_GPIO_REG_MODE_VALUE_SHIFT;
+
+        ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_MODE_CTL, val);
+        if (ret < 0)
+                return ret;
+
+        val = pad->is_enabled << PMIC_GPIO_REG_MASTER_EN_SHIFT;
+
+        return pmic_gpio_write(state, pad, PMIC_GPIO_REG_EN_CTL, val);
+}
+
+static const struct pinmux_ops pmic_gpio_pinmux_ops = {
+        .get_functions_count    = pmic_gpio_get_functions_count,
+        .get_function_name      = pmic_gpio_get_function_name,
+        .get_function_groups    = pmic_gpio_get_function_groups,
+        .set_mux                = pmic_gpio_set_mux,
+};
+
+static int pmic_gpio_config_get(struct pinctrl_dev *pctldev,
+                                unsigned int pin, unsigned long *config)
+{
+        unsigned param = pinconf_to_config_param(*config);
+        struct pmic_gpio_pad *pad;
+        unsigned arg;
+
+        pad = pctldev->desc->pins[pin].drv_data;
+
+        switch (param) {
+        case PIN_CONFIG_DRIVE_PUSH_PULL:
+                arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_CMOS;
+                break;
+        case PIN_CONFIG_DRIVE_OPEN_DRAIN:
+                arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS;
+                break;
+        case PIN_CONFIG_DRIVE_OPEN_SOURCE:
+                arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS;
+                break;
+        case PIN_CONFIG_BIAS_PULL_DOWN:
+                arg = pad->pullup == PMIC_GPIO_PULL_DOWN;
+                break;
+        case PIN_CONFIG_BIAS_DISABLE:
+                arg = pad->pullup = PMIC_GPIO_PULL_DISABLE;
+                break;
+        case PIN_CONFIG_BIAS_PULL_UP:
+                arg = pad->pullup == PMIC_GPIO_PULL_UP_30;
+                break;
+        case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
+                arg = !pad->is_enabled;
+                break;
+        case PIN_CONFIG_POWER_SOURCE:
+                arg = pad->power_source;
+                break;
+        case PIN_CONFIG_INPUT_ENABLE:
+                arg = pad->input_enabled;
+                break;
+        case PIN_CONFIG_OUTPUT:
+                arg = pad->out_value;
+                break;
+        case PMIC_GPIO_CONF_PULL_UP:
+                arg = pad->pullup;
+                break;
+        case PMIC_GPIO_CONF_STRENGTH:
+                arg = pad->strength;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        *config = pinconf_to_config_packed(param, arg);
+        return 0;
+}
+
+static int pmic_gpio_config_set(struct pinctrl_dev *pctldev, unsigned int pin,
+                                unsigned long *configs, unsigned nconfs)
+{
+        struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev);
+        struct pmic_gpio_pad *pad;
+        unsigned param, arg;
+        unsigned int val;
+        int i, ret;
+
+        pad = pctldev->desc->pins[pin].drv_data;
+
+        for (i = 0; i < nconfs; i++) {
+                param = pinconf_to_config_param(configs[i]);
+                arg = pinconf_to_config_argument(configs[i]);
+
+                switch (param) {
+                case PIN_CONFIG_DRIVE_PUSH_PULL:
+                        pad->buffer_type = PMIC_GPIO_OUT_BUF_CMOS;
+                        break;
+                case PIN_CONFIG_DRIVE_OPEN_DRAIN:
+                        if (!pad->have_buffer)
+                                return -EINVAL;
+                        pad->buffer_type = PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS;
+                        break;
+                case PIN_CONFIG_DRIVE_OPEN_SOURCE:
+                        if (!pad->have_buffer)
+                                return -EINVAL;
+                        pad->buffer_type = PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS;
+                        break;
+                case PIN_CONFIG_BIAS_DISABLE:
+                        pad->pullup = PMIC_GPIO_PULL_DISABLE;
+                        break;
+                case PIN_CONFIG_BIAS_PULL_UP:
+                        pad->pullup = PMIC_GPIO_PULL_UP_30;
+                        break;
+                case PIN_CONFIG_BIAS_PULL_DOWN:
+                        if (arg)
+                                pad->pullup = PMIC_GPIO_PULL_DOWN;
+                        else
+                                pad->pullup = PMIC_GPIO_PULL_DISABLE;
+                        break;
+                case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
+                        pad->is_enabled = false;
+                        break;
+                case PIN_CONFIG_POWER_SOURCE:
+                        if (arg > pad->num_sources)
+                                return -EINVAL;
+                        pad->power_source = arg;
+                        break;
+                case PIN_CONFIG_INPUT_ENABLE:
+                        pad->input_enabled = arg ? true : false;
+                        break;
+                case PIN_CONFIG_OUTPUT:
+                        pad->output_enabled = true;
+                        pad->out_value = arg;
+                        break;
+                case PMIC_GPIO_CONF_PULL_UP:
+                        if (arg > PMIC_GPIO_PULL_UP_1P5_30)
+                                return -EINVAL;
+                        pad->pullup = arg;
+                        break;
+                case PMIC_GPIO_CONF_STRENGTH:
+                        if (arg > PMIC_GPIO_STRENGTH_LOW)
+                                return -EINVAL;
+                        pad->strength = arg;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        }
+
+        val = pad->power_source << PMIC_GPIO_REG_VIN_SHIFT;
+
+        ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_VIN_CTL, val);
+        if (ret < 0)
+                return ret;
+
+        val = pad->pullup << PMIC_GPIO_REG_PULL_SHIFT;
+
+        ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_PULL_CTL, val);
+        if (ret < 0)
+                return ret;
+
+        val = pad->buffer_type << PMIC_GPIO_REG_OUT_TYPE_SHIFT;
+        val = pad->strength << PMIC_GPIO_REG_OUT_STRENGTH_SHIFT;
+
+        ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_OUT_CTL, val);
+        if (ret < 0)
+                return ret;
+
+        val = 0;
+        if (pad->output_enabled) {
+                if (pad->input_enabled)
+                        val = 2;
+                else
+                        val = 1;
+        }
+
+        val = val << PMIC_GPIO_REG_MODE_DIR_SHIFT;
+        val |= pad->function << PMIC_GPIO_REG_MODE_FUNCTION_SHIFT;
+        val |= pad->out_value & PMIC_GPIO_REG_MODE_VALUE_SHIFT;
+
+        return pmic_gpio_write(state, pad, PMIC_GPIO_REG_MODE_CTL, val);
+}
+
+static void pmic_gpio_config_dbg_show(struct pinctrl_dev *pctldev,
+                                      struct seq_file *s, unsigned pin)
+{
+        struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev);
+        struct pmic_gpio_pad *pad;
+        int ret, val;
+
+        static const char *const biases[] = {
+                "pull-up 30uA", "pull-up 1.5uA", "pull-up 31.5uA",
+                "pull-up 1.5uA + 30uA boost", "pull-down 10uA", "no pull"
+        };
+        static const char *const buffer_types[] = {
+                "push-pull", "open-drain", "open-source"
+        };
+        static const char *const strengths[] = {
+                "no", "high", "medium", "low"
+        };
+
+        pad = pctldev->desc->pins[pin].drv_data;
+
+        seq_printf(s, " gpio%-2d:", pin + PMIC_GPIO_PHYSICAL_OFFSET);
+
+        val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_EN_CTL);
+
+        if (val < 0 || !(val >> PMIC_GPIO_REG_MASTER_EN_SHIFT)) {
+                seq_puts(s, " ---");
+        } else {
+
+                if (!pad->input_enabled) {
+                        ret = pmic_gpio_read(state, pad, PMIC_MPP_REG_RT_STS);
+                        if (!ret) {
+                                ret &= PMIC_MPP_REG_RT_STS_VAL_MASK;
+                                pad->out_value = ret;
+                        }
+                }
+
+                seq_printf(s, " %-4s", pad->output_enabled ? "out" : "in");
+                seq_printf(s, " %-7s", pmic_gpio_functions[pad->function]);
+                seq_printf(s, " vin-%d", pad->power_source);
+                seq_printf(s, " %-27s", biases[pad->pullup]);
+                seq_printf(s, " %-10s", buffer_types[pad->buffer_type]);
+                seq_printf(s, " %-4s", pad->out_value ? "high" : "low");
+                seq_printf(s, " %-7s", strengths[pad->strength]);
+        }
+}
+
+static const struct pinconf_ops pmic_gpio_pinconf_ops = {
+        .pin_config_group_get           = pmic_gpio_config_get,
+        .pin_config_group_set           = pmic_gpio_config_set,
+        .pin_config_group_dbg_show      = pmic_gpio_config_dbg_show,
+};
+
+static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
+{
+        struct pmic_gpio_state *state = to_gpio_state(chip);
+        unsigned long config;
+
+        config = pinconf_to_config_packed(PIN_CONFIG_INPUT_ENABLE, 1);
+
+        return pmic_gpio_config_set(state->ctrl, pin, &config, 1);
+}
+
+static int pmic_gpio_direction_output(struct gpio_chip *chip,
+                                      unsigned pin, int val)
+{
+        struct pmic_gpio_state *state = to_gpio_state(chip);
+        unsigned long config;
+
+        config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, val);
+
+        return pmic_gpio_config_set(state->ctrl, pin, &config, 1);
+}
+
+static int pmic_gpio_get(struct gpio_chip *chip, unsigned pin)
+{
+        struct pmic_gpio_state *state = to_gpio_state(chip);
+        struct pmic_gpio_pad *pad;
+        int ret;
+
+        pad = state->ctrl->desc->pins[pin].drv_data;
+
+        if (!pad->is_enabled)
+                return -EINVAL;
+
+        if (pad->input_enabled) {
+                ret = pmic_gpio_read(state, pad, PMIC_MPP_REG_RT_STS);
+                if (ret < 0)
+                        return ret;
+
+                pad->out_value = ret & PMIC_MPP_REG_RT_STS_VAL_MASK;
+        }
+
+        return pad->out_value;
+}
+
+static void pmic_gpio_set(struct gpio_chip *chip, unsigned pin, int value)
+{
+        struct pmic_gpio_state *state = to_gpio_state(chip);
+        unsigned long config;
+
+        config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, value);
+
+        pmic_gpio_config_set(state->ctrl, pin, &config, 1);
+}
+
+static int pmic_gpio_request(struct gpio_chip *chip, unsigned base)
+{
+        return pinctrl_request_gpio(chip->base + base);
+}
+
+static void pmic_gpio_free(struct gpio_chip *chip, unsigned base)
+{
+        pinctrl_free_gpio(chip->base + base);
+}
+
+static int pmic_gpio_of_xlate(struct gpio_chip *chip,
+                              const struct of_phandle_args *gpio_desc,
+                              u32 *flags)
+{
+        if (chip->of_gpio_n_cells < 2)
+                return -EINVAL;
+
+        if (flags)
+                *flags = gpio_desc->args[1];
+
+        return gpio_desc->args[0] - PMIC_GPIO_PHYSICAL_OFFSET;
+}
+
+static int pmic_gpio_to_irq(struct gpio_chip *chip, unsigned pin)
+{
+        struct pmic_gpio_state *state = to_gpio_state(chip);
+        struct pmic_gpio_pad *pad;
+
+        pad = state->ctrl->desc->pins[pin].drv_data;
+
+        return pad->irq;
+}
+
+static void pmic_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
+{
+        struct pmic_gpio_state *state = to_gpio_state(chip);
+        unsigned i;
+
+        for (i = 0; i < chip->ngpio; i++) {
+                pmic_gpio_config_dbg_show(state->ctrl, s, i);
+                seq_puts(s, "\n");
+        }
+}
+
+static const struct gpio_chip pmic_gpio_gpio_template = {
+        .direction_input        = pmic_gpio_direction_input,
+        .direction_output       = pmic_gpio_direction_output,
+        .get                    = pmic_gpio_get,
+        .set                    = pmic_gpio_set,
+        .request                = pmic_gpio_request,
+        .free                   = pmic_gpio_free,
+        .of_xlate               = pmic_gpio_of_xlate,
+        .to_irq                 = pmic_gpio_to_irq,
+        .dbg_show               = pmic_gpio_dbg_show,
+};
+
+static int pmic_gpio_populate(struct pmic_gpio_state *state,
+                              struct pmic_gpio_pad *pad)
+{
+        int type, subtype, val, dir;
+
+        type = pmic_gpio_read(state, pad, PMIC_GPIO_REG_TYPE);
+        if (type < 0)
+                return type;
+
+        if (type != PMIC_GPIO_TYPE) {
+                dev_err(state->dev, "incorrect block type 0x%x at 0x%x\n",
+                        type, pad->base);
+                return -ENODEV;
+        }
+
+        subtype = pmic_gpio_read(state, pad, PMIC_GPIO_REG_SUBTYPE);
+        if (subtype < 0)
+                return subtype;
+
+        switch (subtype) {
+        case PMIC_GPIO_SUBTYPE_GPIO_4CH:
+                pad->have_buffer = true;
+        case PMIC_GPIO_SUBTYPE_GPIOC_4CH:
+                pad->num_sources = 4;
+                break;
+        case PMIC_GPIO_SUBTYPE_GPIO_8CH:
+                pad->have_buffer = true;
+        case PMIC_GPIO_SUBTYPE_GPIOC_8CH:
+                pad->num_sources = 8;
+                break;
+        default:
+                dev_err(state->dev, "unknown GPIO type 0x%x\n", subtype);
+                return -ENODEV;
+        }
+
+        val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_MODE_CTL);
+        if (val < 0)
+                return val;
+
+        pad->out_value = val & PMIC_GPIO_REG_MODE_VALUE_SHIFT;
+
+        dir = val >> PMIC_GPIO_REG_MODE_DIR_SHIFT;
+        dir &= PMIC_GPIO_REG_MODE_DIR_MASK;
+        switch (dir) {
+        case 0:
+                pad->input_enabled = true;
+                pad->output_enabled = false;
+                break;
+        case 1:
+                pad->input_enabled = false;
+                pad->output_enabled = true;
+                break;
+        case 2:
+                pad->input_enabled = true;
+                pad->output_enabled = true;
+                break;
+        default:
+                dev_err(state->dev, "unknown GPIO direction\n");
+                return -ENODEV;
+        }
+
+        pad->function = val >> PMIC_GPIO_REG_MODE_FUNCTION_SHIFT;
+        pad->function &= PMIC_GPIO_REG_MODE_FUNCTION_MASK;
+
+        val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_VIN_CTL);
+        if (val < 0)
+                return val;
+
+        pad->power_source = val >> PMIC_GPIO_REG_VIN_SHIFT;
+        pad->power_source &= PMIC_GPIO_REG_VIN_MASK;
+
+        val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_PULL_CTL);
+        if (val < 0)
+                return val;
+
+        pad->pullup = val >> PMIC_GPIO_REG_PULL_SHIFT;
+        pad->pullup &= PMIC_GPIO_REG_PULL_MASK;
+
+        val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_OUT_CTL);
+        if (val < 0)
+                return val;
+
+        pad->strength = val >> PMIC_GPIO_REG_OUT_STRENGTH_SHIFT;
+        pad->strength &= PMIC_GPIO_REG_OUT_STRENGTH_MASK;
+
+        pad->buffer_type = val >> PMIC_GPIO_REG_OUT_TYPE_SHIFT;
+        pad->buffer_type &= PMIC_GPIO_REG_OUT_TYPE_MASK;
+
+        /* Pin could be disabled with PIN_CONFIG_BIAS_HIGH_IMPEDANCE */
+        pad->is_enabled = true;
+        return 0;
+}
+
+static int pmic_gpio_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct pinctrl_pin_desc *pindesc;
+        struct pinctrl_desc *pctrldesc;
+        struct pmic_gpio_pad *pad, *pads;
+        struct pmic_gpio_state *state;
+        int ret, npins, i;
+        u32 res[2];
+
+        ret = of_property_read_u32_array(dev->of_node, "reg", res, 2);
+        if (ret < 0) {
+                dev_err(dev, "missing base address and/or range");
+                return ret;
+        }
+
+        npins = res[1] / PMIC_GPIO_ADDRESS_RANGE;
+
+        if (!npins)
+                return -EINVAL;
+
+        BUG_ON(npins > ARRAY_SIZE(pmic_gpio_groups));
+
+        state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL);
+        if (!state)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, state);
+
+        state->dev = &pdev->dev;
+        state->map = dev_get_regmap(dev->parent, NULL);
+
+        pindesc = devm_kcalloc(dev, npins, sizeof(*pindesc), GFP_KERNEL);
+        if (!pindesc)
+                return -ENOMEM;
+
+        pads = devm_kcalloc(dev, npins, sizeof(*pads), GFP_KERNEL);
+        if (!pads)
+                return -ENOMEM;
+
+        pctrldesc = devm_kzalloc(dev, sizeof(*pctrldesc), GFP_KERNEL);
+        if (!pctrldesc)
+                return -ENOMEM;
+
+        pctrldesc->pctlops = &pmic_gpio_pinctrl_ops;
+        pctrldesc->pmxops = &pmic_gpio_pinmux_ops;
+        pctrldesc->confops = &pmic_gpio_pinconf_ops;
+        pctrldesc->owner = THIS_MODULE;
+        pctrldesc->name = dev_name(dev);
+        pctrldesc->pins = pindesc;
+        pctrldesc->npins = npins;
+
+        for (i = 0; i < npins; i++, pindesc++) {
+                pad = &pads[i];
+                pindesc->drv_data = pad;
+                pindesc->number = i;
+                pindesc->name = pmic_gpio_groups[i];
+
+                pad->irq = platform_get_irq(pdev, i);
+                if (pad->irq < 0)
+                        return pad->irq;
+
+                pad->base = res[0] + i * PMIC_GPIO_ADDRESS_RANGE;
+
+                ret = pmic_gpio_populate(state, pad);
+                if (ret < 0)
+                        return ret;
+        }
+
+        state->chip = pmic_gpio_gpio_template;
+        state->chip.dev = dev;
+        state->chip.base = -1;
+        state->chip.ngpio = npins;
+        state->chip.label = dev_name(dev);
+        state->chip.of_gpio_n_cells = 2;
+        state->chip.can_sleep = false;
+
+        state->ctrl = pinctrl_register(pctrldesc, dev, state);
+        if (!state->ctrl)
+                return -ENODEV;
+
+        ret = gpiochip_add(&state->chip);
+        if (ret) {
+                dev_err(state->dev, "can't add gpio chip\n");
+                goto err_chip;
+        }
+
+        ret = gpiochip_add_pin_range(&state->chip, dev_name(dev), 0, 0, npins);
+        if (ret) {
+                dev_err(dev, "failed to add pin range\n");
+                goto err_range;
+        }
+
+        return 0;
+
+err_range:
+        gpiochip_remove(&state->chip);
+err_chip:
+        pinctrl_unregister(state->ctrl);
+        return ret;
+}
+
+static int pmic_gpio_remove(struct platform_device *pdev)
+{
+        struct pmic_gpio_state *state = platform_get_drvdata(pdev);
+
+        gpiochip_remove(&state->chip);
+        pinctrl_unregister(state->ctrl);
+        return 0;
+}
+
+static const struct of_device_id pmic_gpio_of_match[] = {
+        { .compatible = "qcom,pm8941-gpio" },   /* 36 GPIO's */
+        { .compatible = "qcom,pma8084-gpio" },  /* 22 GPIO's */
+        { },
+};
+
+MODULE_DEVICE_TABLE(of, pmic_gpio_of_match);
+
+static struct platform_driver pmic_gpio_driver = {
+        .driver = {
+                   .name = "qcom-spmi-gpio",
+                   .of_match_table = pmic_gpio_of_match,
+        },
+        .probe  = pmic_gpio_probe,
+        .remove = pmic_gpio_remove,
+};
+
+module_platform_driver(pmic_gpio_driver);
+
+MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");
+MODULE_DESCRIPTION("Qualcomm SPMI PMIC GPIO pin control driver");
+MODULE_ALIAS("platform:qcom-spmi-gpio");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pinctrl/qcom/pinctrl-spmi-mpp.c b/drivers/pinctrl/qcom/pinctrl-spmi-mpp.c
new file mode 100644
index 000000000000..a8924dba335e
--- /dev/null
+++ b/drivers/pinctrl/qcom/pinctrl-spmi-mpp.c
@@ -0,0 +1,949 @@
+/*
+ * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/gpio.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/pinctrl/pinconf-generic.h>
+#include <linux/pinctrl/pinconf.h>
+#include <linux/pinctrl/pinmux.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+#include <dt-bindings/pinctrl/qcom,pmic-mpp.h>
+
+#include "../core.h"
+#include "../pinctrl-utils.h"
+
+#define PMIC_MPP_ADDRESS_RANGE                  0x100
+
+/*
+ * Pull Up Values - it indicates whether a pull-up should be
+ * applied for bidirectional mode only. The hardware ignores the
+ * configuration when operating in other modes.
+ */
+#define PMIC_MPP_PULL_UP_0P6KOHM                0
+#define PMIC_MPP_PULL_UP_10KOHM                 1
+#define PMIC_MPP_PULL_UP_30KOHM                 2
+#define PMIC_MPP_PULL_UP_OPEN                   3
+
+/* type registers base address bases */
+#define PMIC_MPP_REG_TYPE                       0x4
+#define PMIC_MPP_REG_SUBTYPE                    0x5
+
+/* mpp peripheral type and subtype values */
+#define PMIC_MPP_TYPE                           0x11
+#define PMIC_MPP_SUBTYPE_4CH_NO_ANA_OUT         0x3
+#define PMIC_MPP_SUBTYPE_ULT_4CH_NO_ANA_OUT     0x4
+#define PMIC_MPP_SUBTYPE_4CH_NO_SINK            0x5
+#define PMIC_MPP_SUBTYPE_ULT_4CH_NO_SINK        0x6
+#define PMIC_MPP_SUBTYPE_4CH_FULL_FUNC          0x7
+#define PMIC_MPP_SUBTYPE_8CH_FULL_FUNC          0xf
+
+#define PMIC_MPP_REG_RT_STS                     0x10
+#define PMIC_MPP_REG_RT_STS_VAL_MASK            0x1
+
+/* control register base address bases */
+#define PMIC_MPP_REG_MODE_CTL                   0x40
+#define PMIC_MPP_REG_DIG_VIN_CTL                0x41
+#define PMIC_MPP_REG_DIG_PULL_CTL               0x42
+#define PMIC_MPP_REG_DIG_IN_CTL                 0x43
+#define PMIC_MPP_REG_EN_CTL                     0x46
+#define PMIC_MPP_REG_AIN_CTL                    0x4a
+
+/* PMIC_MPP_REG_MODE_CTL */
+#define PMIC_MPP_REG_MODE_VALUE_MASK            0x1
+#define PMIC_MPP_REG_MODE_FUNCTION_SHIFT        1
+#define PMIC_MPP_REG_MODE_FUNCTION_MASK         0x7
+#define PMIC_MPP_REG_MODE_DIR_SHIFT             4
+#define PMIC_MPP_REG_MODE_DIR_MASK              0x7
+
+/* PMIC_MPP_REG_DIG_VIN_CTL */
+#define PMIC_MPP_REG_VIN_SHIFT                  0
+#define PMIC_MPP_REG_VIN_MASK                   0x7
+
+/* PMIC_MPP_REG_DIG_PULL_CTL */
+#define PMIC_MPP_REG_PULL_SHIFT                 0
+#define PMIC_MPP_REG_PULL_MASK                  0x7
+
+/* PMIC_MPP_REG_EN_CTL */
+#define PMIC_MPP_REG_MASTER_EN_SHIFT            7
+
+/* PMIC_MPP_REG_AIN_CTL */
+#define PMIC_MPP_REG_AIN_ROUTE_SHIFT            0
+#define PMIC_MPP_REG_AIN_ROUTE_MASK             0x7
+
+#define PMIC_MPP_PHYSICAL_OFFSET                1
+
+/* Qualcomm specific pin configurations */
+#define PMIC_MPP_CONF_AMUX_ROUTE                (PIN_CONFIG_END + 1)
+#define PMIC_MPP_CONF_ANALOG_MODE               (PIN_CONFIG_END + 2)
+
+/**
+ * struct pmic_mpp_pad - keep current MPP settings
+ * @base: Address base in SPMI device.
+ * @irq: IRQ number which this MPP generate.
+ * @is_enabled: Set to false when MPP should be put in high Z state.
+ * @out_value: Cached pin output value.
+ * @output_enabled: Set to true if MPP output logic is enabled.
+ * @input_enabled: Set to true if MPP input buffer logic is enabled.
+ * @analog_mode: Set to true when MPP should operate in Analog Input, Analog
+ *      Output or Bidirectional Analog mode.
+ * @num_sources: Number of power-sources supported by this MPP.
+ * @power_source: Current power-source used.
+ * @amux_input: Set the source for analog input.
+ * @pullup: Pullup resistor value. Valid in Bidirectional mode only.
+ * @function: See pmic_mpp_functions[].
+ */
+struct pmic_mpp_pad {
+        u16             base;
+        int             irq;
+        bool            is_enabled;
+        bool            out_value;
+        bool            output_enabled;
+        bool            input_enabled;
+        bool            analog_mode;
+        unsigned int    num_sources;
+        unsigned int    power_source;
+        unsigned int    amux_input;
+        unsigned int    pullup;
+        unsigned int    function;
+};
+
+struct pmic_mpp_state {
+        struct device   *dev;
+        struct regmap   *map;
+        struct pinctrl_dev *ctrl;
+        struct gpio_chip chip;
+};
+
+struct pmic_mpp_bindings {
+        const char      *property;
+        unsigned        param;
+};
+
+static struct pmic_mpp_bindings pmic_mpp_bindings[] = {
+        {"qcom,amux-route",     PMIC_MPP_CONF_AMUX_ROUTE},
+        {"qcom,analog-mode",    PMIC_MPP_CONF_ANALOG_MODE},
+};
+
+static const char *const pmic_mpp_groups[] = {
+        "mpp1", "mpp2", "mpp3", "mpp4", "mpp5", "mpp6", "mpp7", "mpp8",
+};
+
+static const char *const pmic_mpp_functions[] = {
+        PMIC_MPP_FUNC_NORMAL, PMIC_MPP_FUNC_PAIRED,
+        "reserved1", "reserved2",
+        PMIC_MPP_FUNC_DTEST1, PMIC_MPP_FUNC_DTEST2,
+        PMIC_MPP_FUNC_DTEST3, PMIC_MPP_FUNC_DTEST4,
+};
+
+static inline struct pmic_mpp_state *to_mpp_state(struct gpio_chip *chip)
+{
+        return container_of(chip, struct pmic_mpp_state, chip);
+};
+
+static int pmic_mpp_read(struct pmic_mpp_state *state,
+                         struct pmic_mpp_pad *pad, unsigned int addr)
+{
+        unsigned int val;
+        int ret;
+
+        ret = regmap_read(state->map, pad->base + addr, &val);
+        if (ret < 0)
+                dev_err(state->dev, "read 0x%x failed\n", addr);
+        else
+                ret = val;
+
+        return ret;
+}
+
+static int pmic_mpp_write(struct pmic_mpp_state *state,
+                          struct pmic_mpp_pad *pad, unsigned int addr,
+                          unsigned int val)
+{
+        int ret;
+
+        ret = regmap_write(state->map, pad->base + addr, val);
+        if (ret < 0)
+                dev_err(state->dev, "write 0x%x failed\n", addr);
+
+        return ret;
+}
+
+static int pmic_mpp_get_groups_count(struct pinctrl_dev *pctldev)
+{
+        /* Every PIN is a group */
+        return pctldev->desc->npins;
+}
+
+static const char *pmic_mpp_get_group_name(struct pinctrl_dev *pctldev,
+                                           unsigned pin)
+{
+        return pctldev->desc->pins[pin].name;
+}
+
+static int pmic_mpp_get_group_pins(struct pinctrl_dev *pctldev,
+                                   unsigned pin,
+                                   const unsigned **pins, unsigned *num_pins)
+{
+        *pins = &pctldev->desc->pins[pin].number;
+        *num_pins = 1;
+        return 0;
+}
+
+static int pmic_mpp_parse_dt_config(struct device_node *np,
+                                    struct pinctrl_dev *pctldev,
+                                    unsigned long **configs,
+                                    unsigned int *nconfs)
+{
+        struct pmic_mpp_bindings *par;
+        unsigned long cfg;
+        int ret, i;
+        u32 val;
+
+        for (i = 0; i < ARRAY_SIZE(pmic_mpp_bindings); i++) {
+                par = &pmic_mpp_bindings[i];
+                ret = of_property_read_u32(np, par->property, &val);
+
+                /* property not found */
+                if (ret == -EINVAL)
+                        continue;
+
+                /* use zero as default value, when no value is specified */
+                if (ret)
+                        val = 0;
+
+                dev_dbg(pctldev->dev, "found %s with value %u\n",
+                        par->property, val);
+
+                cfg = pinconf_to_config_packed(par->param, val);
+
+                ret = pinctrl_utils_add_config(pctldev, configs, nconfs, cfg);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static int pmic_mpp_dt_subnode_to_map(struct pinctrl_dev *pctldev,
+                                      struct device_node *np,
+                                      struct pinctrl_map **map,
+                                      unsigned *reserv, unsigned *nmaps,
+                                      enum pinctrl_map_type type)
+{
+        unsigned long *configs = NULL;
+        unsigned nconfs = 0;
+        struct property *prop;
+        const char *group;
+        int ret;
+
+        ret = pmic_mpp_parse_dt_config(np, pctldev, &configs, &nconfs);
+        if (ret < 0)
+                return ret;
+
+        if (!nconfs)
+                return 0;
+
+        ret = of_property_count_strings(np, "pins");
+        if (ret < 0)
+                goto exit;
+
+        ret = pinctrl_utils_reserve_map(pctldev, map, reserv, nmaps, ret);
+        if (ret < 0)
+                goto exit;
+
+        of_property_for_each_string(np, "pins", prop, group) {
+                ret = pinctrl_utils_add_map_configs(pctldev, map,
+                                                    reserv, nmaps, group,
+                                                    configs, nconfs, type);
+                if (ret < 0)
+                        break;
+        }
+exit:
+        kfree(configs);
+        return ret;
+}
+
+static int pmic_mpp_dt_node_to_map(struct pinctrl_dev *pctldev,
+                                   struct device_node *np_config,
+                                   struct pinctrl_map **map, unsigned *nmaps)
+{
+        struct device_node *np;
+        enum pinctrl_map_type type;
+        unsigned reserv;
+        int ret;
+
+        ret = 0;
+        *map = NULL;
+        *nmaps = 0;
+        reserv = 0;
+        type = PIN_MAP_TYPE_CONFIGS_GROUP;
+
+        for_each_child_of_node(np_config, np) {
+                ret = pinconf_generic_dt_subnode_to_map(pctldev, np, map,
+                                                        &reserv, nmaps, type);
+                if (ret)
+                        break;
+
+                ret = pmic_mpp_dt_subnode_to_map(pctldev, np, map, &reserv,
+                                                 nmaps, type);
+                if (ret)
+                        break;
+        }
+
+        if (ret < 0)
+                pinctrl_utils_dt_free_map(pctldev, *map, *nmaps);
+
+        return ret;
+}
+
+static const struct pinctrl_ops pmic_mpp_pinctrl_ops = {
+        .get_groups_count       = pmic_mpp_get_groups_count,
+        .get_group_name         = pmic_mpp_get_group_name,
+        .get_group_pins         = pmic_mpp_get_group_pins,
+        .dt_node_to_map         = pmic_mpp_dt_node_to_map,
+        .dt_free_map            = pinctrl_utils_dt_free_map,
+};
+
+static int pmic_mpp_get_functions_count(struct pinctrl_dev *pctldev)
+{
+        return ARRAY_SIZE(pmic_mpp_functions);
+}
+
+static const char *pmic_mpp_get_function_name(struct pinctrl_dev *pctldev,
+                                              unsigned function)
+{
+        return pmic_mpp_functions[function];
+}
+
+static int pmic_mpp_get_function_groups(struct pinctrl_dev *pctldev,
+                                        unsigned function,
+                                        const char *const **groups,
+                                        unsigned *const num_qgroups)
+{
+        *groups = pmic_mpp_groups;
+        *num_qgroups = pctldev->desc->npins;
+        return 0;
+}
+
+static int pmic_mpp_set_mux(struct pinctrl_dev *pctldev, unsigned function,
+                                unsigned pin)
+{
+        struct pmic_mpp_state *state = pinctrl_dev_get_drvdata(pctldev);
+        struct pmic_mpp_pad *pad;
+        unsigned int val;
+        int ret;
+
+        pad = pctldev->desc->pins[pin].drv_data;
+
+        pad->function = function;
+
+        if (!pad->analog_mode) {
+                val = 0;        /* just digital input */
+                if (pad->output_enabled) {
+                        if (pad->input_enabled)
+                                val = 2; /* digital input and output */
+                        else
+                                val = 1; /* just digital output */
+                }
+        } else {
+                val = 4;        /* just analog input */
+                if (pad->output_enabled) {
+                        if (pad->input_enabled)
+                                val = 3; /* analog input and output */
+                        else
+                                val = 5; /* just analog output */
+                }
+        }
+
+        val |= pad->function << PMIC_MPP_REG_MODE_FUNCTION_SHIFT;
+        val |= pad->out_value & PMIC_MPP_REG_MODE_VALUE_MASK;
+
+        ret = pmic_mpp_write(state, pad, PMIC_MPP_REG_MODE_CTL, val);
+        if (ret < 0)
+                return ret;
+
+        val = pad->is_enabled << PMIC_MPP_REG_MASTER_EN_SHIFT;
+
+        return pmic_mpp_write(state, pad, PMIC_MPP_REG_EN_CTL, val);
+}
+
+static const struct pinmux_ops pmic_mpp_pinmux_ops = {
+        .get_functions_count    = pmic_mpp_get_functions_count,
+        .get_function_name      = pmic_mpp_get_function_name,
+        .get_function_groups    = pmic_mpp_get_function_groups,
+        .set_mux                = pmic_mpp_set_mux,
+};
+
+static int pmic_mpp_config_get(struct pinctrl_dev *pctldev,
+                               unsigned int pin, unsigned long *config)
+{
+        unsigned param = pinconf_to_config_param(*config);
+        struct pmic_mpp_pad *pad;
+        unsigned arg = 0;
+
+        pad = pctldev->desc->pins[pin].drv_data;
+
+        switch (param) {
+        case PIN_CONFIG_BIAS_DISABLE:
+                arg = pad->pullup == PMIC_MPP_PULL_UP_OPEN;
+                break;
+        case PIN_CONFIG_BIAS_PULL_UP:
+                switch (pad->pullup) {
+                case PMIC_MPP_PULL_UP_OPEN:
+                        arg = 0;
+                        break;
+                case PMIC_MPP_PULL_UP_0P6KOHM:
+                        arg = 600;
+                        break;
+                case PMIC_MPP_PULL_UP_10KOHM:
+                        arg = 10000;
+                        break;
+                case PMIC_MPP_PULL_UP_30KOHM:
+                        arg = 30000;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
+                arg = !pad->is_enabled;
+                break;
+        case PIN_CONFIG_POWER_SOURCE:
+                arg = pad->power_source;
+                break;
+        case PIN_CONFIG_INPUT_ENABLE:
+                arg = pad->input_enabled;
+                break;
+        case PIN_CONFIG_OUTPUT:
+                arg = pad->out_value;
+                break;
+        case PMIC_MPP_CONF_AMUX_ROUTE:
+                arg = pad->amux_input;
+                break;
+        case PMIC_MPP_CONF_ANALOG_MODE:
+                arg = pad->analog_mode;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* Convert register value to pinconf value */
+        *config = pinconf_to_config_packed(param, arg);
+        return 0;
+}
+
+static int pmic_mpp_config_set(struct pinctrl_dev *pctldev, unsigned int pin,
+                               unsigned long *configs, unsigned nconfs)
+{
+        struct pmic_mpp_state *state = pinctrl_dev_get_drvdata(pctldev);
+        struct pmic_mpp_pad *pad;
+        unsigned param, arg;
+        unsigned int val;
+        int i, ret;
+
+        pad = pctldev->desc->pins[pin].drv_data;
+
+        for (i = 0; i < nconfs; i++) {
+                param = pinconf_to_config_param(configs[i]);
+                arg = pinconf_to_config_argument(configs[i]);
+
+                switch (param) {
+                case PIN_CONFIG_BIAS_DISABLE:
+                        pad->pullup = PMIC_MPP_PULL_UP_OPEN;
+                        break;
+                case PIN_CONFIG_BIAS_PULL_UP:
+                        switch (arg) {
+                        case 600:
+                                pad->pullup = PMIC_MPP_PULL_UP_0P6KOHM;
+                                break;
+                        case 10000:
+                                pad->pullup = PMIC_MPP_PULL_UP_10KOHM;
+                                break;
+                        case 30000:
+                                pad->pullup = PMIC_MPP_PULL_UP_30KOHM;
+                                break;
+                        default:
+                                return -EINVAL;
+                        }
+                        break;
+                case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
+                        pad->is_enabled = false;
+                        break;
+                case PIN_CONFIG_POWER_SOURCE:
+                        if (arg >= pad->num_sources)
+                                return -EINVAL;
+                        pad->power_source = arg;
+                        break;
+                case PIN_CONFIG_INPUT_ENABLE:
+                        pad->input_enabled = arg ? true : false;
+                        break;
+                case PIN_CONFIG_OUTPUT:
+                        pad->output_enabled = true;
+                        pad->out_value = arg;
+                        break;
+                case PMIC_MPP_CONF_AMUX_ROUTE:
+                        if (arg >= PMIC_MPP_AMUX_ROUTE_ABUS4)
+                                return -EINVAL;
+                        pad->amux_input = arg;
+                        break;
+                case PMIC_MPP_CONF_ANALOG_MODE:
+                        pad->analog_mode = true;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        }
+
+        val = pad->power_source << PMIC_MPP_REG_VIN_SHIFT;
+
+        ret = pmic_mpp_write(state, pad, PMIC_MPP_REG_DIG_VIN_CTL, val);
+        if (ret < 0)
+                return ret;
+
+        val = pad->pullup << PMIC_MPP_REG_PULL_SHIFT;
+
+        ret = pmic_mpp_write(state, pad, PMIC_MPP_REG_DIG_PULL_CTL, val);
+        if (ret < 0)
+                return ret;
+
+        val = pad->amux_input & PMIC_MPP_REG_AIN_ROUTE_MASK;
+
+        ret = pmic_mpp_write(state, pad, PMIC_MPP_REG_AIN_CTL, val);
+        if (ret < 0)
+                return ret;
+
+        if (!pad->analog_mode) {
+                val = 0;        /* just digital input */
+                if (pad->output_enabled) {
+                        if (pad->input_enabled)
+                                val = 2; /* digital input and output */
+                        else
+                                val = 1; /* just digital output */
+                }
+        } else {
+                val = 4;        /* just analog input */
+                if (pad->output_enabled) {
+                        if (pad->input_enabled)
+                                val = 3; /* analog input and output */
+                        else
+                                val = 5; /* just analog output */
+                }
+        }
+
+        val = val << PMIC_MPP_REG_MODE_DIR_SHIFT;
+        val |= pad->function << PMIC_MPP_REG_MODE_FUNCTION_SHIFT;
+        val |= pad->out_value & PMIC_MPP_REG_MODE_VALUE_MASK;
+
+        return pmic_mpp_write(state, pad, PMIC_MPP_REG_MODE_CTL, val);
+}
+
+static void pmic_mpp_config_dbg_show(struct pinctrl_dev *pctldev,
+                                     struct seq_file *s, unsigned pin)
+{
+        struct pmic_mpp_state *state = pinctrl_dev_get_drvdata(pctldev);
+        struct pmic_mpp_pad *pad;
+        int ret, val;
+
+        static const char *const biases[] = {
+                "0.6kOhm", "10kOhm", "30kOhm", "Disabled"
+        };
+
+
+        pad = pctldev->desc->pins[pin].drv_data;
+
+        seq_printf(s, " mpp%-2d:", pin + PMIC_MPP_PHYSICAL_OFFSET);
+
+        val = pmic_mpp_read(state, pad, PMIC_MPP_REG_EN_CTL);
+
+        if (val < 0 || !(val >> PMIC_MPP_REG_MASTER_EN_SHIFT)) {
+                seq_puts(s, " ---");
+        } else {
+
+                if (pad->input_enabled) {
+                        ret = pmic_mpp_read(state, pad, PMIC_MPP_REG_RT_STS);
+                        if (!ret) {
+                                ret &= PMIC_MPP_REG_RT_STS_VAL_MASK;
+                                pad->out_value = ret;
+                        }
+                }
+
+                seq_printf(s, " %-4s", pad->output_enabled ? "out" : "in");
+                seq_printf(s, " %-4s", pad->analog_mode ? "ana" : "dig");
+                seq_printf(s, " %-7s", pmic_mpp_functions[pad->function]);
+                seq_printf(s, " vin-%d", pad->power_source);
+                seq_printf(s, " %-8s", biases[pad->pullup]);
+                seq_printf(s, " %-4s", pad->out_value ? "high" : "low");
+        }
+}
+
+static const struct pinconf_ops pmic_mpp_pinconf_ops = {
+        .pin_config_group_get           = pmic_mpp_config_get,
+        .pin_config_group_set           = pmic_mpp_config_set,
+        .pin_config_group_dbg_show      = pmic_mpp_config_dbg_show,
+};
+
+static int pmic_mpp_direction_input(struct gpio_chip *chip, unsigned pin)
+{
+        struct pmic_mpp_state *state = to_mpp_state(chip);
+        unsigned long config;
+
+        config = pinconf_to_config_packed(PIN_CONFIG_INPUT_ENABLE, 1);
+
+        return pmic_mpp_config_set(state->ctrl, pin, &config, 1);
+}
+
+static int pmic_mpp_direction_output(struct gpio_chip *chip,
+                                     unsigned pin, int val)
+{
+        struct pmic_mpp_state *state = to_mpp_state(chip);
+        unsigned long config;
+
+        config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, val);
+
+        return pmic_mpp_config_set(state->ctrl, pin, &config, 1);
+}
+
+static int pmic_mpp_get(struct gpio_chip *chip, unsigned pin)
+{
+        struct pmic_mpp_state *state = to_mpp_state(chip);
+        struct pmic_mpp_pad *pad;
+        int ret;
+
+        pad = state->ctrl->desc->pins[pin].drv_data;
+
+        if (pad->input_enabled) {
+                ret = pmic_mpp_read(state, pad, PMIC_MPP_REG_RT_STS);
+                if (ret < 0)
+                        return ret;
+
+                pad->out_value = ret & PMIC_MPP_REG_RT_STS_VAL_MASK;
+        }
+
+        return pad->out_value;
+}
+
+static void pmic_mpp_set(struct gpio_chip *chip, unsigned pin, int value)
+{
+        struct pmic_mpp_state *state = to_mpp_state(chip);
+        unsigned long config;
+
+        config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, value);
+
+        pmic_mpp_config_set(state->ctrl, pin, &config, 1);
+}
+
+static int pmic_mpp_request(struct gpio_chip *chip, unsigned base)
+{
+        return pinctrl_request_gpio(chip->base + base);
+}
+
+static void pmic_mpp_free(struct gpio_chip *chip, unsigned base)
+{
+        pinctrl_free_gpio(chip->base + base);
+}
+
+static int pmic_mpp_of_xlate(struct gpio_chip *chip,
+                             const struct of_phandle_args *gpio_desc,
+                             u32 *flags)
+{
+        if (chip->of_gpio_n_cells < 2)
+                return -EINVAL;
+
+        if (flags)
+                *flags = gpio_desc->args[1];
+
+        return gpio_desc->args[0] - PMIC_MPP_PHYSICAL_OFFSET;
+}
+
+static int pmic_mpp_to_irq(struct gpio_chip *chip, unsigned pin)
+{
+        struct pmic_mpp_state *state = to_mpp_state(chip);
+        struct pmic_mpp_pad *pad;
+
+        pad = state->ctrl->desc->pins[pin].drv_data;
+
+        return pad->irq;
+}
+
+static void pmic_mpp_dbg_show(struct seq_file *s, struct gpio_chip *chip)
+{
+        struct pmic_mpp_state *state = to_mpp_state(chip);
+        unsigned i;
+
+        for (i = 0; i < chip->ngpio; i++) {
+                pmic_mpp_config_dbg_show(state->ctrl, s, i);
+                seq_puts(s, "\n");
+        }
+}
+
+static const struct gpio_chip pmic_mpp_gpio_template = {
+        .direction_input        = pmic_mpp_direction_input,
+        .direction_output       = pmic_mpp_direction_output,
+        .get                    = pmic_mpp_get,
+        .set                    = pmic_mpp_set,
+        .request                = pmic_mpp_request,
+        .free                   = pmic_mpp_free,
+        .of_xlate               = pmic_mpp_of_xlate,
+        .to_irq                 = pmic_mpp_to_irq,
+        .dbg_show               = pmic_mpp_dbg_show,
+};
+
+static int pmic_mpp_populate(struct pmic_mpp_state *state,
+                             struct pmic_mpp_pad *pad)
+{
+        int type, subtype, val, dir;
+
+        type = pmic_mpp_read(state, pad, PMIC_MPP_REG_TYPE);
+        if (type < 0)
+                return type;
+
+        if (type != PMIC_MPP_TYPE) {
+                dev_err(state->dev, "incorrect block type 0x%x at 0x%x\n",
+                        type, pad->base);
+                return -ENODEV;
+        }
+
+        subtype = pmic_mpp_read(state, pad, PMIC_MPP_REG_SUBTYPE);
+        if (subtype < 0)
+                return subtype;
+
+        switch (subtype) {
+        case PMIC_MPP_SUBTYPE_4CH_NO_ANA_OUT:
+        case PMIC_MPP_SUBTYPE_ULT_4CH_NO_ANA_OUT:
+        case PMIC_MPP_SUBTYPE_4CH_NO_SINK:
+        case PMIC_MPP_SUBTYPE_ULT_4CH_NO_SINK:
+        case PMIC_MPP_SUBTYPE_4CH_FULL_FUNC:
+                pad->num_sources = 4;
+                break;
+        case PMIC_MPP_SUBTYPE_8CH_FULL_FUNC:
+                pad->num_sources = 8;
+                break;
+        default:
+                dev_err(state->dev, "unknown MPP type 0x%x at 0x%x\n",
+                        subtype, pad->base);
+                return -ENODEV;
+        }
+
+        val = pmic_mpp_read(state, pad, PMIC_MPP_REG_MODE_CTL);
+        if (val < 0)
+                return val;
+
+        pad->out_value = val & PMIC_MPP_REG_MODE_VALUE_MASK;
+
+        dir = val >> PMIC_MPP_REG_MODE_DIR_SHIFT;
+        dir &= PMIC_MPP_REG_MODE_DIR_MASK;
+
+        switch (dir) {
+        case 0:
+                pad->input_enabled = true;
+                pad->output_enabled = false;
+                pad->analog_mode = false;
+                break;
+        case 1:
+                pad->input_enabled = false;
+                pad->output_enabled = true;
+                pad->analog_mode = false;
+                break;
+        case 2:
+                pad->input_enabled = true;
+                pad->output_enabled = true;
+                pad->analog_mode = false;
+                break;
+        case 3:
+                pad->input_enabled = true;
+                pad->output_enabled = true;
+                pad->analog_mode = true;
+                break;
+        case 4:
+                pad->input_enabled = true;
+                pad->output_enabled = false;
+                pad->analog_mode = true;
+                break;
+        case 5:
+                pad->input_enabled = false;
+                pad->output_enabled = true;
+                pad->analog_mode = true;
+                break;
+        default:
+                dev_err(state->dev, "unknown MPP direction\n");
+                return -ENODEV;
+        }
+
+        pad->function = val >> PMIC_MPP_REG_MODE_FUNCTION_SHIFT;
+        pad->function &= PMIC_MPP_REG_MODE_FUNCTION_MASK;
+
+        val = pmic_mpp_read(state, pad, PMIC_MPP_REG_DIG_VIN_CTL);
+        if (val < 0)
+                return val;
+
+        pad->power_source = val >> PMIC_MPP_REG_VIN_SHIFT;
+        pad->power_source &= PMIC_MPP_REG_VIN_MASK;
+
+        val = pmic_mpp_read(state, pad, PMIC_MPP_REG_DIG_PULL_CTL);
+        if (val < 0)
+                return val;
+
+        pad->pullup = val >> PMIC_MPP_REG_PULL_SHIFT;
+        pad->pullup &= PMIC_MPP_REG_PULL_MASK;
+
+        val = pmic_mpp_read(state, pad, PMIC_MPP_REG_AIN_CTL);
+        if (val < 0)
+                return val;
+
+        pad->amux_input = val >> PMIC_MPP_REG_AIN_ROUTE_SHIFT;
+        pad->amux_input &= PMIC_MPP_REG_AIN_ROUTE_MASK;
+
+        /* Pin could be disabled with PIN_CONFIG_BIAS_HIGH_IMPEDANCE */
+        pad->is_enabled = true;
+        return 0;
+}
+
+static int pmic_mpp_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct pinctrl_pin_desc *pindesc;
+        struct pinctrl_desc *pctrldesc;
+        struct pmic_mpp_pad *pad, *pads;
+        struct pmic_mpp_state *state;
+        int ret, npins, i;
+        u32 res[2];
+
+        ret = of_property_read_u32_array(dev->of_node, "reg", res, 2);
+        if (ret < 0) {
+                dev_err(dev, "missing base address and/or range");
+                return ret;
+        }
+
+        npins = res[1] / PMIC_MPP_ADDRESS_RANGE;
+        if (!npins)
+                return -EINVAL;
+
+        BUG_ON(npins > ARRAY_SIZE(pmic_mpp_groups));
+
+        state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL);
+        if (!state)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, state);
+
+        state->dev = &pdev->dev;
+        state->map = dev_get_regmap(dev->parent, NULL);
+
+        pindesc = devm_kcalloc(dev, npins, sizeof(*pindesc), GFP_KERNEL);
+        if (!pindesc)
+                return -ENOMEM;
+
+        pads = devm_kcalloc(dev, npins, sizeof(*pads), GFP_KERNEL);
+        if (!pads)
+                return -ENOMEM;
+
+        pctrldesc = devm_kzalloc(dev, sizeof(*pctrldesc), GFP_KERNEL);
+        if (!pctrldesc)
+                return -ENOMEM;
+
+        pctrldesc->pctlops = &pmic_mpp_pinctrl_ops;
+        pctrldesc->pmxops = &pmic_mpp_pinmux_ops;
+        pctrldesc->confops = &pmic_mpp_pinconf_ops;
+        pctrldesc->owner = THIS_MODULE;
+        pctrldesc->name = dev_name(dev);
+        pctrldesc->pins = pindesc;
+        pctrldesc->npins = npins;
+
+        for (i = 0; i < npins; i++, pindesc++) {
+                pad = &pads[i];
+                pindesc->drv_data = pad;
+                pindesc->number = i;
+                pindesc->name = pmic_mpp_groups[i];
+
+                pad->irq = platform_get_irq(pdev, i);
+                if (pad->irq < 0)
+                        return pad->irq;
+
+                pad->base = res[0] + i * PMIC_MPP_ADDRESS_RANGE;
+
+                ret = pmic_mpp_populate(state, pad);
+                if (ret < 0)
+                        return ret;
+        }
+
+        state->chip = pmic_mpp_gpio_template;
+        state->chip.dev = dev;
+        state->chip.base = -1;
+        state->chip.ngpio = npins;
+        state->chip.label = dev_name(dev);
+        state->chip.of_gpio_n_cells = 2;
+        state->chip.can_sleep = false;
+
+        state->ctrl = pinctrl_register(pctrldesc, dev, state);
+        if (!state->ctrl)
+                return -ENODEV;
+
+        ret = gpiochip_add(&state->chip);
+        if (ret) {
+                dev_err(state->dev, "can't add gpio chip\n");
+                goto err_chip;
+        }
+
+        ret = gpiochip_add_pin_range(&state->chip, dev_name(dev), 0, 0, npins);
+        if (ret) {
+                dev_err(dev, "failed to add pin range\n");
+                goto err_range;
+        }
+
+        return 0;
+
+err_range:
+        gpiochip_remove(&state->chip);
+err_chip:
+        pinctrl_unregister(state->ctrl);
+        return ret;
+}
+
+static int pmic_mpp_remove(struct platform_device *pdev)
+{
+        struct pmic_mpp_state *state = platform_get_drvdata(pdev);
+
+        gpiochip_remove(&state->chip);
+        pinctrl_unregister(state->ctrl);
+        return 0;
+}
+
+static const struct of_device_id pmic_mpp_of_match[] = {
+        { .compatible = "qcom,pm8841-mpp" },    /* 4 MPP's */
+        { .compatible = "qcom,pm8941-mpp" },    /* 8 MPP's */
+        { .compatible = "qcom,pma8084-mpp" },   /* 8 MPP's */
+        { },
+};
+
+MODULE_DEVICE_TABLE(of, pmic_mpp_of_match);
+
+static struct platform_driver pmic_mpp_driver = {
+        .driver = {
+                   .name = "qcom-spmi-mpp",
+                   .of_match_table = pmic_mpp_of_match,
+        },
+        .probe  = pmic_mpp_probe,
+        .remove = pmic_mpp_remove,
+};
+
+module_platform_driver(pmic_mpp_driver);
+
+MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");
+MODULE_DESCRIPTION("Qualcomm SPMI PMIC MPP pin control driver");
+MODULE_ALIAS("platform:qcom-spmi-mpp");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pinctrl/samsung/pinctrl-exynos.c b/drivers/pinctrl/samsung/pinctrl-exynos.c
index d7154ed0b0eb..d5d4cfc55873 100644
--- a/drivers/pinctrl/samsung/pinctrl-exynos.c
+++ b/drivers/pinctrl/samsung/pinctrl-exynos.c
@@ -46,22 +46,16 @@ static inline struct exynos_irq_chip *to_exynos_irq_chip(struct irq_chip *chip)
         return container_of(chip, struct exynos_irq_chip, chip);
 }
 
-static struct samsung_pin_bank_type bank_type_off = {
+static const struct samsung_pin_bank_type bank_type_off = {
         .fld_width = { 4, 1, 2, 2, 2, 2, },
         .reg_offset = { 0x00, 0x04, 0x08, 0x0c, 0x10, 0x14, },
 };
 
-static struct samsung_pin_bank_type bank_type_alive = {
+static const struct samsung_pin_bank_type bank_type_alive = {
         .fld_width = { 4, 1, 2, 2, },
         .reg_offset = { 0x00, 0x04, 0x08, 0x0c, },
 };
 
-/* list of external wakeup controllers supported */
-static const struct of_device_id exynos_wkup_irq_ids[] = {
-        { .compatible = "samsung,exynos4210-wakeup-eint", },
-        { }
-};
-
 static void exynos_irq_mask(struct irq_data *irqd)
 {
         struct irq_chip *chip = irq_data_get_irq_chip(irqd);
@@ -171,7 +165,7 @@ static int exynos_irq_request_resources(struct irq_data *irqd)
         struct irq_chip *chip = irq_data_get_irq_chip(irqd);
         struct exynos_irq_chip *our_chip = to_exynos_irq_chip(chip);
         struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
-        struct samsung_pin_bank_type *bank_type = bank->type;
+        const struct samsung_pin_bank_type *bank_type = bank->type;
         struct samsung_pinctrl_drv_data *d = bank->drvdata;
         unsigned int shift = EXYNOS_EINT_CON_LEN * irqd->hwirq;
         unsigned long reg_con = our_chip->eint_con + bank->eint_offset;
@@ -210,7 +204,7 @@ static void exynos_irq_release_resources(struct irq_data *irqd)
         struct irq_chip *chip = irq_data_get_irq_chip(irqd);
         struct exynos_irq_chip *our_chip = to_exynos_irq_chip(chip);
         struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
-        struct samsung_pin_bank_type *bank_type = bank->type;
+        const struct samsung_pin_bank_type *bank_type = bank->type;
         struct samsung_pinctrl_drv_data *d = bank->drvdata;
         unsigned int shift = EXYNOS_EINT_CON_LEN * irqd->hwirq;
         unsigned long reg_con = our_chip->eint_con + bank->eint_offset;
@@ -254,31 +248,30 @@ static struct exynos_irq_chip exynos_gpio_irq_chip = {
         .eint_pend = EXYNOS_GPIO_EPEND_OFFSET,
 };
 
-static int exynos_gpio_irq_map(struct irq_domain *h, unsigned int virq,
+static int exynos_eint_irq_map(struct irq_domain *h, unsigned int virq,
                                         irq_hw_number_t hw)
 {
         struct samsung_pin_bank *b = h->host_data;
 
         irq_set_chip_data(virq, b);
-        irq_set_chip_and_handler(virq, &exynos_gpio_irq_chip.chip,
+        irq_set_chip_and_handler(virq, &b->irq_chip->chip,
                                         handle_level_irq);
         set_irq_flags(virq, IRQF_VALID);
         return 0;
 }
 
 /*
- * irq domain callbacks for external gpio interrupt controller.
+ * irq domain callbacks for external gpio and wakeup interrupt controllers.
  */
-static const struct irq_domain_ops exynos_gpio_irqd_ops = {
-        .map    = exynos_gpio_irq_map,
+static const struct irq_domain_ops exynos_eint_irqd_ops = {
+        .map    = exynos_eint_irq_map,
         .xlate  = irq_domain_xlate_twocell,
 };
 
 static irqreturn_t exynos_eint_gpio_irq(int irq, void *data)
 {
         struct samsung_pinctrl_drv_data *d = data;
-        struct samsung_pin_ctrl *ctrl = d->ctrl;
-        struct samsung_pin_bank *bank = ctrl->pin_banks;
+        struct samsung_pin_bank *bank = d->pin_banks;
         unsigned int svc, group, pin, virq;
 
         svc = readl(d->virt_base + EXYNOS_SVC_OFFSET);
@@ -325,12 +318,12 @@ static int exynos_eint_gpio_init(struct samsung_pinctrl_drv_data *d)
                 return -ENXIO;
         }
 
-        bank = d->ctrl->pin_banks;
-        for (i = 0; i < d->ctrl->nr_banks; ++i, ++bank) {
+        bank = d->pin_banks;
+        for (i = 0; i < d->nr_banks; ++i, ++bank) {
                 if (bank->eint_type != EINT_TYPE_GPIO)
                         continue;
                 bank->irq_domain = irq_domain_add_linear(bank->of_node,
-                                bank->nr_pins, &exynos_gpio_irqd_ops, bank);
+                                bank->nr_pins, &exynos_eint_irqd_ops, bank);
                 if (!bank->irq_domain) {
                         dev_err(dev, "gpio irq domain add failed\n");
                         ret = -ENXIO;
@@ -344,6 +337,8 @@ static int exynos_eint_gpio_init(struct samsung_pinctrl_drv_data *d)
                         ret = -ENOMEM;
                         goto err_domains;
                 }
+
+                bank->irq_chip = &exynos_gpio_irq_chip;
         }
 
         return 0;
@@ -383,9 +378,9 @@ static int exynos_wkup_irq_set_wake(struct irq_data *irqd, unsigned int on)
 /*
  * irq_chip for wakeup interrupts
  */
-static struct exynos_irq_chip exynos_wkup_irq_chip = {
+static struct exynos_irq_chip exynos4210_wkup_irq_chip __initdata = {
         .chip = {
-                .name = "exynos_wkup_irq_chip",
+                .name = "exynos4210_wkup_irq_chip",
                 .irq_unmask = exynos_irq_unmask,
                 .irq_mask = exynos_irq_mask,
                 .irq_ack = exynos_irq_ack,
@@ -399,6 +394,31 @@ static struct exynos_irq_chip exynos_wkup_irq_chip = {
         .eint_pend = EXYNOS_WKUP_EPEND_OFFSET,
 };
 
+static struct exynos_irq_chip exynos7_wkup_irq_chip __initdata = {
+        .chip = {
+                .name = "exynos7_wkup_irq_chip",
+                .irq_unmask = exynos_irq_unmask,
+                .irq_mask = exynos_irq_mask,
+                .irq_ack = exynos_irq_ack,
+                .irq_set_type = exynos_irq_set_type,
+                .irq_set_wake = exynos_wkup_irq_set_wake,
+                .irq_request_resources = exynos_irq_request_resources,
+                .irq_release_resources = exynos_irq_release_resources,
+        },
+        .eint_con = EXYNOS7_WKUP_ECON_OFFSET,
+        .eint_mask = EXYNOS7_WKUP_EMASK_OFFSET,
+        .eint_pend = EXYNOS7_WKUP_EPEND_OFFSET,
+};
+
+/* list of external wakeup controllers supported */
+static const struct of_device_id exynos_wkup_irq_ids[] = {
+        { .compatible = "samsung,exynos4210-wakeup-eint",
+                        .data = &exynos4210_wkup_irq_chip },
+        { .compatible = "samsung,exynos7-wakeup-eint",
+                        .data = &exynos7_wkup_irq_chip },
+        { }
+};
+
 /* interrupt handler for wakeup interrupts 0..15 */
 static void exynos_irq_eint0_15(unsigned int irq, struct irq_desc *desc)
 {
@@ -445,9 +465,9 @@ static void exynos_irq_demux_eint16_31(unsigned int irq, struct irq_desc *desc)
 
         for (i = 0; i < eintd->nr_banks; ++i) {
                 struct samsung_pin_bank *b = eintd->banks[i];
-                pend = readl(d->virt_base + EXYNOS_WKUP_EPEND_OFFSET
+                pend = readl(d->virt_base + b->irq_chip->eint_pend
                                 + b->eint_offset);
-                mask = readl(d->virt_base + EXYNOS_WKUP_EMASK_OFFSET
+                mask = readl(d->virt_base + b->irq_chip->eint_mask
                                 + b->eint_offset);
                 exynos_irq_demux_eint(pend & ~mask, b->irq_domain);
         }
@@ -455,24 +475,6 @@ static void exynos_irq_demux_eint16_31(unsigned int irq, struct irq_desc *desc)
         chained_irq_exit(chip, desc);
 }
 
-static int exynos_wkup_irq_map(struct irq_domain *h, unsigned int virq,
-                                        irq_hw_number_t hw)
-{
-        irq_set_chip_and_handler(virq, &exynos_wkup_irq_chip.chip,
-                                        handle_level_irq);
-        irq_set_chip_data(virq, h->host_data);
-        set_irq_flags(virq, IRQF_VALID);
-        return 0;
-}
-
-/*
- * irq domain callbacks for external wakeup interrupt controller.
- */
-static const struct irq_domain_ops exynos_wkup_irqd_ops = {
-        .map    = exynos_wkup_irq_map,
-        .xlate  = irq_domain_xlate_twocell,
-};
-
 /*
  * exynos_eint_wkup_init() - setup handling of external wakeup interrupts.
  * @d: driver data of samsung pinctrl driver.
@@ -485,12 +487,18 @@ static int exynos_eint_wkup_init(struct samsung_pinctrl_drv_data *d)
         struct samsung_pin_bank *bank;
         struct exynos_weint_data *weint_data;
         struct exynos_muxed_weint_data *muxed_data;
+        struct exynos_irq_chip *irq_chip;
         unsigned int muxed_banks = 0;
         unsigned int i;
         int idx, irq;
 
         for_each_child_of_node(dev->of_node, np) {
-                if (of_match_node(exynos_wkup_irq_ids, np)) {
+                const struct of_device_id *match;
+
+                match = of_match_node(exynos_wkup_irq_ids, np);
+                if (match) {
+                        irq_chip = kmemdup(match->data,
+                                sizeof(*irq_chip), GFP_KERNEL);
                         wkup_np = np;
                         break;
                 }
@@ -498,18 +506,20 @@ static int exynos_eint_wkup_init(struct samsung_pinctrl_drv_data *d)
         if (!wkup_np)
                 return -ENODEV;
 
-        bank = d->ctrl->pin_banks;
-        for (i = 0; i < d->ctrl->nr_banks; ++i, ++bank) {
+        bank = d->pin_banks;
+        for (i = 0; i < d->nr_banks; ++i, ++bank) {
                 if (bank->eint_type != EINT_TYPE_WKUP)
                         continue;
 
                 bank->irq_domain = irq_domain_add_linear(bank->of_node,
-                                bank->nr_pins, &exynos_wkup_irqd_ops, bank);
+                                bank->nr_pins, &exynos_eint_irqd_ops, bank);
                 if (!bank->irq_domain) {
                         dev_err(dev, "wkup irq domain add failed\n");
                         return -ENXIO;
                 }
 
+                bank->irq_chip = irq_chip;
+
                 if (!of_find_property(bank->of_node, "interrupts", NULL)) {
                         bank->eint_type = EINT_TYPE_WKUP_MUX;
                         ++muxed_banks;
@@ -556,9 +566,9 @@ static int exynos_eint_wkup_init(struct samsung_pinctrl_drv_data *d)
         irq_set_chained_handler(irq, exynos_irq_demux_eint16_31);
         irq_set_handler_data(irq, muxed_data);
 
-        bank = d->ctrl->pin_banks;
+        bank = d->pin_banks;
         idx = 0;
-        for (i = 0; i < d->ctrl->nr_banks; ++i, ++bank) {
+        for (i = 0; i < d->nr_banks; ++i, ++bank) {
                 if (bank->eint_type != EINT_TYPE_WKUP_MUX)
                         continue;
 
@@ -590,11 +600,10 @@ static void exynos_pinctrl_suspend_bank(
 
 static void exynos_pinctrl_suspend(struct samsung_pinctrl_drv_data *drvdata)
 {
-        struct samsung_pin_ctrl *ctrl = drvdata->ctrl;
-        struct samsung_pin_bank *bank = ctrl->pin_banks;
+        struct samsung_pin_bank *bank = drvdata->pin_banks;
         int i;
 
-        for (i = 0; i < ctrl->nr_banks; ++i, ++bank)
+        for (i = 0; i < drvdata->nr_banks; ++i, ++bank)
                 if (bank->eint_type == EINT_TYPE_GPIO)
                         exynos_pinctrl_suspend_bank(drvdata, bank);
 }
@@ -626,17 +635,16 @@ static void exynos_pinctrl_resume_bank(
 
 static void exynos_pinctrl_resume(struct samsung_pinctrl_drv_data *drvdata)
 {
-        struct samsung_pin_ctrl *ctrl = drvdata->ctrl;
-        struct samsung_pin_bank *bank = ctrl->pin_banks;
+        struct samsung_pin_bank *bank = drvdata->pin_banks;
         int i;
 
-        for (i = 0; i < ctrl->nr_banks; ++i, ++bank)
+        for (i = 0; i < drvdata->nr_banks; ++i, ++bank)
                 if (bank->eint_type == EINT_TYPE_GPIO)
                         exynos_pinctrl_resume_bank(drvdata, bank);
 }
 
 /* pin banks of s5pv210 pin-controller */
-static struct samsung_pin_bank s5pv210_pin_bank[] = {
+static const struct samsung_pin_bank_data s5pv210_pin_bank[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
         EXYNOS_PIN_BANK_EINTG(4, 0x020, "gpa1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpb", 0x08),
@@ -673,7 +681,7 @@ static struct samsung_pin_bank s5pv210_pin_bank[] = {
         EXYNOS_PIN_BANK_EINTW(8, 0xc60, "gph3", 0x0c),
 };
 
-struct samsung_pin_ctrl s5pv210_pin_ctrl[] = {
+const struct samsung_pin_ctrl s5pv210_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = s5pv210_pin_bank,
@@ -682,12 +690,11 @@ struct samsung_pin_ctrl s5pv210_pin_ctrl[] = {
                 .eint_wkup_init = exynos_eint_wkup_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "s5pv210-gpio-ctrl0",
         },
 };
 
 /* pin banks of exynos3250 pin-controller 0 */
-static struct samsung_pin_bank exynos3250_pin_banks0[] = {
+static const struct samsung_pin_bank_data exynos3250_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
         EXYNOS_PIN_BANK_EINTG(6, 0x020, "gpa1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpb",  0x08),
@@ -698,7 +705,7 @@ static struct samsung_pin_bank exynos3250_pin_banks0[] = {
 };
 
 /* pin banks of exynos3250 pin-controller 1 */
-static struct samsung_pin_bank exynos3250_pin_banks1[] = {
+static const struct samsung_pin_bank_data exynos3250_pin_banks1[] __initconst = {
         EXYNOS_PIN_BANK_EINTN(8, 0x120, "gpe0"),
         EXYNOS_PIN_BANK_EINTN(8, 0x140, "gpe1"),
         EXYNOS_PIN_BANK_EINTN(3, 0x180, "gpe2"),
@@ -721,7 +728,7 @@ static struct samsung_pin_bank exynos3250_pin_banks1[] = {
  * Samsung pinctrl driver data for Exynos3250 SoC. Exynos3250 SoC includes
  * two gpio/pin-mux/pinconfig controllers.
  */
-struct samsung_pin_ctrl exynos3250_pin_ctrl[] = {
+const struct samsung_pin_ctrl exynos3250_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos3250_pin_banks0,
@@ -729,7 +736,6 @@ struct samsung_pin_ctrl exynos3250_pin_ctrl[] = {
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos3250-gpio-ctrl0",
         }, {
                 /* pin-controller instance 1 data */
                 .pin_banks      = exynos3250_pin_banks1,
@@ -738,12 +744,11 @@ struct samsung_pin_ctrl exynos3250_pin_ctrl[] = {
                 .eint_wkup_init = exynos_eint_wkup_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos3250-gpio-ctrl1",
         },
 };
 
 /* pin banks of exynos4210 pin-controller 0 */
-static struct samsung_pin_bank exynos4210_pin_banks0[] = {
+static const struct samsung_pin_bank_data exynos4210_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
         EXYNOS_PIN_BANK_EINTG(6, 0x020, "gpa1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpb", 0x08),
@@ -763,7 +768,7 @@ static struct samsung_pin_bank exynos4210_pin_banks0[] = {
 };
 
 /* pin banks of exynos4210 pin-controller 1 */
-static struct samsung_pin_bank exynos4210_pin_banks1[] = {
+static const struct samsung_pin_bank_data exynos4210_pin_banks1[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpj0", 0x00),
         EXYNOS_PIN_BANK_EINTG(5, 0x020, "gpj1", 0x04),
         EXYNOS_PIN_BANK_EINTG(7, 0x040, "gpk0", 0x08),
@@ -787,7 +792,7 @@ static struct samsung_pin_bank exynos4210_pin_banks1[] = {
 };
 
 /* pin banks of exynos4210 pin-controller 2 */
-static struct samsung_pin_bank exynos4210_pin_banks2[] = {
+static const struct samsung_pin_bank_data exynos4210_pin_banks2[] __initconst = {
         EXYNOS_PIN_BANK_EINTN(7, 0x000, "gpz"),
 };
 
@@ -795,7 +800,7 @@ static struct samsung_pin_bank exynos4210_pin_banks2[] = {
  * Samsung pinctrl driver data for Exynos4210 SoC. Exynos4210 SoC includes
  * three gpio/pin-mux/pinconfig controllers.
  */
-struct samsung_pin_ctrl exynos4210_pin_ctrl[] = {
+const struct samsung_pin_ctrl exynos4210_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos4210_pin_banks0,
@@ -803,7 +808,6 @@ struct samsung_pin_ctrl exynos4210_pin_ctrl[] = {
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos4210-gpio-ctrl0",
         }, {
                 /* pin-controller instance 1 data */
                 .pin_banks      = exynos4210_pin_banks1,
@@ -812,17 +816,15 @@ struct samsung_pin_ctrl exynos4210_pin_ctrl[] = {
                 .eint_wkup_init = exynos_eint_wkup_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos4210-gpio-ctrl1",
         }, {
                 /* pin-controller instance 2 data */
                 .pin_banks      = exynos4210_pin_banks2,
                 .nr_banks       = ARRAY_SIZE(exynos4210_pin_banks2),
-                .label          = "exynos4210-gpio-ctrl2",
         },
 };
 
 /* pin banks of exynos4x12 pin-controller 0 */
-static struct samsung_pin_bank exynos4x12_pin_banks0[] = {
+static const struct samsung_pin_bank_data exynos4x12_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
         EXYNOS_PIN_BANK_EINTG(6, 0x020, "gpa1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpb", 0x08),
@@ -839,7 +841,7 @@ static struct samsung_pin_bank exynos4x12_pin_banks0[] = {
 };
 
 /* pin banks of exynos4x12 pin-controller 1 */
-static struct samsung_pin_bank exynos4x12_pin_banks1[] = {
+static const struct samsung_pin_bank_data exynos4x12_pin_banks1[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(7, 0x040, "gpk0", 0x08),
         EXYNOS_PIN_BANK_EINTG(7, 0x060, "gpk1", 0x0c),
         EXYNOS_PIN_BANK_EINTG(7, 0x080, "gpk2", 0x10),
@@ -866,12 +868,12 @@ static struct samsung_pin_bank exynos4x12_pin_banks1[] = {
 };
 
 /* pin banks of exynos4x12 pin-controller 2 */
-static struct samsung_pin_bank exynos4x12_pin_banks2[] = {
+static const struct samsung_pin_bank_data exynos4x12_pin_banks2[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(7, 0x000, "gpz", 0x00),
 };
 
 /* pin banks of exynos4x12 pin-controller 3 */
-static struct samsung_pin_bank exynos4x12_pin_banks3[] = {
+static const struct samsung_pin_bank_data exynos4x12_pin_banks3[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpv0", 0x00),
         EXYNOS_PIN_BANK_EINTG(8, 0x020, "gpv1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpv2", 0x08),
@@ -883,7 +885,7 @@ static struct samsung_pin_bank exynos4x12_pin_banks3[] = {
  * Samsung pinctrl driver data for Exynos4x12 SoC. Exynos4x12 SoC includes
  * four gpio/pin-mux/pinconfig controllers.
  */
-struct samsung_pin_ctrl exynos4x12_pin_ctrl[] = {
+const struct samsung_pin_ctrl exynos4x12_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos4x12_pin_banks0,
@@ -891,7 +893,6 @@ struct samsung_pin_ctrl exynos4x12_pin_ctrl[] = {
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos4x12-gpio-ctrl0",
         }, {
                 /* pin-controller instance 1 data */
                 .pin_banks      = exynos4x12_pin_banks1,
@@ -900,7 +901,6 @@ struct samsung_pin_ctrl exynos4x12_pin_ctrl[] = {
                 .eint_wkup_init = exynos_eint_wkup_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos4x12-gpio-ctrl1",
         }, {
                 /* pin-controller instance 2 data */
                 .pin_banks      = exynos4x12_pin_banks2,
@@ -908,7 +908,6 @@ struct samsung_pin_ctrl exynos4x12_pin_ctrl[] = {
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos4x12-gpio-ctrl2",
         }, {
                 /* pin-controller instance 3 data */
                 .pin_banks      = exynos4x12_pin_banks3,
@@ -916,12 +915,86 @@ struct samsung_pin_ctrl exynos4x12_pin_ctrl[] = {
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos4x12-gpio-ctrl3",
+        },
+};
+
+/* pin banks of exynos4415 pin-controller 0 */
+static const struct samsung_pin_bank_data exynos4415_pin_banks0[] = {
+        EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
+        EXYNOS_PIN_BANK_EINTG(6, 0x020, "gpa1", 0x04),
+        EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpb", 0x08),
+        EXYNOS_PIN_BANK_EINTG(5, 0x060, "gpc0", 0x0c),
+        EXYNOS_PIN_BANK_EINTG(5, 0x080, "gpc1", 0x10),
+        EXYNOS_PIN_BANK_EINTG(4, 0x0A0, "gpd0", 0x14),
+        EXYNOS_PIN_BANK_EINTG(4, 0x0C0, "gpd1", 0x18),
+        EXYNOS_PIN_BANK_EINTG(8, 0x180, "gpf0", 0x30),
+        EXYNOS_PIN_BANK_EINTG(8, 0x1A0, "gpf1", 0x34),
+        EXYNOS_PIN_BANK_EINTG(1, 0x1C0, "gpf2", 0x38),
+};
+
+/* pin banks of exynos4415 pin-controller 1 */
+static const struct samsung_pin_bank_data exynos4415_pin_banks1[] = {
+        EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpk0", 0x08),
+        EXYNOS_PIN_BANK_EINTG(7, 0x060, "gpk1", 0x0c),
+        EXYNOS_PIN_BANK_EINTG(7, 0x080, "gpk2", 0x10),
+        EXYNOS_PIN_BANK_EINTG(7, 0x0A0, "gpk3", 0x14),
+        EXYNOS_PIN_BANK_EINTG(4, 0x0C0, "gpl0", 0x18),
+        EXYNOS_PIN_BANK_EINTN(6, 0x120, "mp00"),
+        EXYNOS_PIN_BANK_EINTN(4, 0x140, "mp01"),
+        EXYNOS_PIN_BANK_EINTN(6, 0x160, "mp02"),
+        EXYNOS_PIN_BANK_EINTN(8, 0x180, "mp03"),
+        EXYNOS_PIN_BANK_EINTN(8, 0x1A0, "mp04"),
+        EXYNOS_PIN_BANK_EINTN(8, 0x1C0, "mp05"),
+        EXYNOS_PIN_BANK_EINTN(8, 0x1E0, "mp06"),
+        EXYNOS_PIN_BANK_EINTG(8, 0x260, "gpm0", 0x24),
+        EXYNOS_PIN_BANK_EINTG(7, 0x280, "gpm1", 0x28),
+        EXYNOS_PIN_BANK_EINTG(5, 0x2A0, "gpm2", 0x2c),
+        EXYNOS_PIN_BANK_EINTG(8, 0x2C0, "gpm3", 0x30),
+        EXYNOS_PIN_BANK_EINTG(8, 0x2E0, "gpm4", 0x34),
+        EXYNOS_PIN_BANK_EINTW(8, 0xC00, "gpx0", 0x00),
+        EXYNOS_PIN_BANK_EINTW(8, 0xC20, "gpx1", 0x04),
+        EXYNOS_PIN_BANK_EINTW(8, 0xC40, "gpx2", 0x08),
+        EXYNOS_PIN_BANK_EINTW(8, 0xC60, "gpx3", 0x0c),
+};
+
+/* pin banks of exynos4415 pin-controller 2 */
+static const struct samsung_pin_bank_data exynos4415_pin_banks2[] = {
+        EXYNOS_PIN_BANK_EINTG(7, 0x000, "gpz", 0x00),
+        EXYNOS_PIN_BANK_EINTN(2, 0x000, "etc1"),
+};
+
+/*
+ * Samsung pinctrl driver data for Exynos4415 SoC. Exynos4415 SoC includes
+ * three gpio/pin-mux/pinconfig controllers.
+ */
+const struct samsung_pin_ctrl exynos4415_pin_ctrl[] = {
+        {
+                /* pin-controller instance 0 data */
+                .pin_banks      = exynos4415_pin_banks0,
+                .nr_banks       = ARRAY_SIZE(exynos4415_pin_banks0),
+                .eint_gpio_init = exynos_eint_gpio_init,
+                .suspend        = exynos_pinctrl_suspend,
+                .resume         = exynos_pinctrl_resume,
+        }, {
+                /* pin-controller instance 1 data */
+                .pin_banks      = exynos4415_pin_banks1,
+                .nr_banks       = ARRAY_SIZE(exynos4415_pin_banks1),
+                .eint_gpio_init = exynos_eint_gpio_init,
+                .eint_wkup_init = exynos_eint_wkup_init,
+                .suspend        = exynos_pinctrl_suspend,
+                .resume         = exynos_pinctrl_resume,
+        }, {
+                /* pin-controller instance 2 data */
+                .pin_banks      = exynos4415_pin_banks2,
+                .nr_banks       = ARRAY_SIZE(exynos4415_pin_banks2),
+                .eint_gpio_init = exynos_eint_gpio_init,
+                .suspend        = exynos_pinctrl_suspend,
+                .resume         = exynos_pinctrl_resume,
         },
 };
 
 /* pin banks of exynos5250 pin-controller 0 */
-static struct samsung_pin_bank exynos5250_pin_banks0[] = {
+static const struct samsung_pin_bank_data exynos5250_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
         EXYNOS_PIN_BANK_EINTG(6, 0x020, "gpa1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpa2", 0x08),
@@ -950,7 +1023,7 @@ static struct samsung_pin_bank exynos5250_pin_banks0[] = {
 };
 
 /* pin banks of exynos5250 pin-controller 1 */
-static struct samsung_pin_bank exynos5250_pin_banks1[] = {
+static const struct samsung_pin_bank_data exynos5250_pin_banks1[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpe0", 0x00),
         EXYNOS_PIN_BANK_EINTG(2, 0x020, "gpe1", 0x04),
         EXYNOS_PIN_BANK_EINTG(4, 0x040, "gpf0", 0x08),
@@ -963,7 +1036,7 @@ static struct samsung_pin_bank exynos5250_pin_banks1[] = {
 };
 
 /* pin banks of exynos5250 pin-controller 2 */
-static struct samsung_pin_bank exynos5250_pin_banks2[] = {
+static const struct samsung_pin_bank_data exynos5250_pin_banks2[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpv0", 0x00),
         EXYNOS_PIN_BANK_EINTG(8, 0x020, "gpv1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x060, "gpv2", 0x08),
@@ -972,7 +1045,7 @@ static struct samsung_pin_bank exynos5250_pin_banks2[] = {
 };
 
 /* pin banks of exynos5250 pin-controller 3 */
-static struct samsung_pin_bank exynos5250_pin_banks3[] = {
+static const struct samsung_pin_bank_data exynos5250_pin_banks3[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(7, 0x000, "gpz", 0x00),
 };
 
@@ -980,7 +1053,7 @@ static struct samsung_pin_bank exynos5250_pin_banks3[] = {
  * Samsung pinctrl driver data for Exynos5250 SoC. Exynos5250 SoC includes
  * four gpio/pin-mux/pinconfig controllers.
  */
-struct samsung_pin_ctrl exynos5250_pin_ctrl[] = {
+const struct samsung_pin_ctrl exynos5250_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos5250_pin_banks0,
@@ -989,7 +1062,6 @@ struct samsung_pin_ctrl exynos5250_pin_ctrl[] = {
                 .eint_wkup_init = exynos_eint_wkup_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos5250-gpio-ctrl0",
         }, {
                 /* pin-controller instance 1 data */
                 .pin_banks      = exynos5250_pin_banks1,
@@ -997,7 +1069,6 @@ struct samsung_pin_ctrl exynos5250_pin_ctrl[] = {
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos5250-gpio-ctrl1",
         }, {
                 /* pin-controller instance 2 data */
                 .pin_banks      = exynos5250_pin_banks2,
@@ -1005,7 +1076,6 @@ struct samsung_pin_ctrl exynos5250_pin_ctrl[] = {
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos5250-gpio-ctrl2",
         }, {
                 /* pin-controller instance 3 data */
                 .pin_banks      = exynos5250_pin_banks3,
@@ -1013,12 +1083,11 @@ struct samsung_pin_ctrl exynos5250_pin_ctrl[] = {
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .suspend        = exynos_pinctrl_suspend,
                 .resume         = exynos_pinctrl_resume,
-                .label          = "exynos5250-gpio-ctrl3",
         },
 };
 
 /* pin banks of exynos5260 pin-controller 0 */
-static struct samsung_pin_bank exynos5260_pin_banks0[] = {
+static const struct samsung_pin_bank_data exynos5260_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(4, 0x000, "gpa0", 0x00),
         EXYNOS_PIN_BANK_EINTG(7, 0x020, "gpa1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpa2", 0x08),
@@ -1043,7 +1112,7 @@ static struct samsung_pin_bank exynos5260_pin_banks0[] = {
 };
 
 /* pin banks of exynos5260 pin-controller 1 */
-static struct samsung_pin_bank exynos5260_pin_banks1[] = {
+static const struct samsung_pin_bank_data exynos5260_pin_banks1[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(7, 0x000, "gpc0", 0x00),
         EXYNOS_PIN_BANK_EINTG(6, 0x020, "gpc1", 0x04),
         EXYNOS_PIN_BANK_EINTG(7, 0x040, "gpc2", 0x08),
@@ -1052,7 +1121,7 @@ static struct samsung_pin_bank exynos5260_pin_banks1[] = {
 };
 
 /* pin banks of exynos5260 pin-controller 2 */
-static struct samsung_pin_bank exynos5260_pin_banks2[] = {
+static const struct samsung_pin_bank_data exynos5260_pin_banks2[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(7, 0x000, "gpz0", 0x00),
         EXYNOS_PIN_BANK_EINTG(4, 0x020, "gpz1", 0x04),
 };
@@ -1061,31 +1130,28 @@ static struct samsung_pin_bank exynos5260_pin_banks2[] = {
  * Samsung pinctrl driver data for Exynos5260 SoC. Exynos5260 SoC includes
  * three gpio/pin-mux/pinconfig controllers.
  */
-struct samsung_pin_ctrl exynos5260_pin_ctrl[] = {
+const struct samsung_pin_ctrl exynos5260_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos5260_pin_banks0,
                 .nr_banks       = ARRAY_SIZE(exynos5260_pin_banks0),
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .eint_wkup_init = exynos_eint_wkup_init,
-                .label          = "exynos5260-gpio-ctrl0",
         }, {
                 /* pin-controller instance 1 data */
                 .pin_banks      = exynos5260_pin_banks1,
                 .nr_banks       = ARRAY_SIZE(exynos5260_pin_banks1),
                 .eint_gpio_init = exynos_eint_gpio_init,
-                .label          = "exynos5260-gpio-ctrl1",
         }, {
                 /* pin-controller instance 2 data */
                 .pin_banks      = exynos5260_pin_banks2,
                 .nr_banks       = ARRAY_SIZE(exynos5260_pin_banks2),
                 .eint_gpio_init = exynos_eint_gpio_init,
-                .label          = "exynos5260-gpio-ctrl2",
         },
 };
 
 /* pin banks of exynos5420 pin-controller 0 */
-static struct samsung_pin_bank exynos5420_pin_banks0[] = {
+static const struct samsung_pin_bank_data exynos5420_pin_banks0[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpy7", 0x00),
         EXYNOS_PIN_BANK_EINTW(8, 0xC00, "gpx0", 0x00),
         EXYNOS_PIN_BANK_EINTW(8, 0xC20, "gpx1", 0x04),
@@ -1094,7 +1160,7 @@ static struct samsung_pin_bank exynos5420_pin_banks0[] = {
 };
 
 /* pin banks of exynos5420 pin-controller 1 */
-static struct samsung_pin_bank exynos5420_pin_banks1[] = {
+static const struct samsung_pin_bank_data exynos5420_pin_banks1[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpc0", 0x00),
         EXYNOS_PIN_BANK_EINTG(8, 0x020, "gpc1", 0x04),
         EXYNOS_PIN_BANK_EINTG(7, 0x040, "gpc2", 0x08),
@@ -1111,7 +1177,7 @@ static struct samsung_pin_bank exynos5420_pin_banks1[] = {
 };
 
 /* pin banks of exynos5420 pin-controller 2 */
-static struct samsung_pin_bank exynos5420_pin_banks2[] = {
+static const struct samsung_pin_bank_data exynos5420_pin_banks2[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpe0", 0x00),
         EXYNOS_PIN_BANK_EINTG(2, 0x020, "gpe1", 0x04),
         EXYNOS_PIN_BANK_EINTG(6, 0x040, "gpf0", 0x08),
@@ -1123,7 +1189,7 @@ static struct samsung_pin_bank exynos5420_pin_banks2[] = {
 };
 
 /* pin banks of exynos5420 pin-controller 3 */
-static struct samsung_pin_bank exynos5420_pin_banks3[] = {
+static const struct samsung_pin_bank_data exynos5420_pin_banks3[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(8, 0x000, "gpa0", 0x00),
         EXYNOS_PIN_BANK_EINTG(6, 0x020, "gpa1", 0x04),
         EXYNOS_PIN_BANK_EINTG(8, 0x040, "gpa2", 0x08),
@@ -1136,7 +1202,7 @@ static struct samsung_pin_bank exynos5420_pin_banks3[] = {
 };
 
 /* pin banks of exynos5420 pin-controller 4 */
-static struct samsung_pin_bank exynos5420_pin_banks4[] = {
+static const struct samsung_pin_bank_data exynos5420_pin_banks4[] __initconst = {
         EXYNOS_PIN_BANK_EINTG(7, 0x000, "gpz", 0x00),
 };
 
@@ -1144,37 +1210,137 @@ static struct samsung_pin_bank exynos5420_pin_banks4[] = {
  * Samsung pinctrl driver data for Exynos5420 SoC. Exynos5420 SoC includes
  * four gpio/pin-mux/pinconfig controllers.
  */
-struct samsung_pin_ctrl exynos5420_pin_ctrl[] = {
+const struct samsung_pin_ctrl exynos5420_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 0 data */
                 .pin_banks      = exynos5420_pin_banks0,
                 .nr_banks       = ARRAY_SIZE(exynos5420_pin_banks0),
                 .eint_gpio_init = exynos_eint_gpio_init,
                 .eint_wkup_init = exynos_eint_wkup_init,
-                .label          = "exynos5420-gpio-ctrl0",
         }, {
                 /* pin-controller instance 1 data */
                 .pin_banks      = exynos5420_pin_banks1,
                 .nr_banks       = ARRAY_SIZE(exynos5420_pin_banks1),
                 .eint_gpio_init = exynos_eint_gpio_init,
-                .label          = "exynos5420-gpio-ctrl1",
         }, {
                 /* pin-controller instance 2 data */
                 .pin_banks      = exynos5420_pin_banks2,
                 .nr_banks       = ARRAY_SIZE(exynos5420_pin_banks2),
                 .eint_gpio_init = exynos_eint_gpio_init,
-                .label          = "exynos5420-gpio-ctrl2",
         }, {
                 /* pin-controller instance 3 data */
                 .pin_banks      = exynos5420_pin_banks3,
                 .nr_banks       = ARRAY_SIZE(exynos5420_pin_banks3),
                 .eint_gpio_init = exynos_eint_gpio_init,
-                .label          = "exynos5420-gpio-ctrl3",
         }, {
                 /* pin-controller instance 4 data */
                 .pin_banks      = exynos5420_pin_banks4,
                 .nr_banks       = ARRAY_SIZE(exynos5420_pin_banks4),
                 .eint_gpio_init = exynos_eint_gpio_init,
-                .label          = "exynos5420-gpio-ctrl4",
+        },
+};
+
+/* pin banks of exynos7 pin-controller - ALIVE */
+static const struct samsung_pin_bank_data exynos7_pin_banks0[] __initconst = {
+        EXYNOS_PIN_BANK_EINTW(8, 0x000, "gpa0", 0x00),
+        EXYNOS_PIN_BANK_EINTW(8, 0x020, "gpa1", 0x04),
+        EXYNOS_PIN_BANK_EINTW(8, 0x040, "gpa2", 0x08),
+        EXYNOS_PIN_BANK_EINTW(8, 0x060, "gpa3", 0x0c),
+};
+
+/* pin banks of exynos7 pin-controller - BUS0 */
+static const struct samsung_pin_bank_data exynos7_pin_banks1[] __initconst = {
+        EXYNOS_PIN_BANK_EINTG(5, 0x000, "gpb0", 0x00),
+        EXYNOS_PIN_BANK_EINTG(8, 0x020, "gpc0", 0x04),
+        EXYNOS_PIN_BANK_EINTG(2, 0x040, "gpc1", 0x08),
+        EXYNOS_PIN_BANK_EINTG(6, 0x060, "gpc2", 0x0c),
+        EXYNOS_PIN_BANK_EINTG(8, 0x080, "gpc3", 0x10),
+        EXYNOS_PIN_BANK_EINTG(4, 0x0a0, "gpd0", 0x14),
+        EXYNOS_PIN_BANK_EINTG(6, 0x0c0, "gpd1", 0x18),
+        EXYNOS_PIN_BANK_EINTG(8, 0x0e0, "gpd2", 0x1c),
+        EXYNOS_PIN_BANK_EINTG(5, 0x100, "gpd4", 0x20),
+        EXYNOS_PIN_BANK_EINTG(4, 0x120, "gpd5", 0x24),
+        EXYNOS_PIN_BANK_EINTG(6, 0x140, "gpd6", 0x28),
+        EXYNOS_PIN_BANK_EINTG(3, 0x160, "gpd7", 0x2c),
+        EXYNOS_PIN_BANK_EINTG(2, 0x180, "gpd8", 0x30),
+        EXYNOS_PIN_BANK_EINTG(2, 0x1a0, "gpg0", 0x34),
+        EXYNOS_PIN_BANK_EINTG(4, 0x1c0, "gpg3", 0x38),
+};
+
+/* pin banks of exynos7 pin-controller - NFC */
+static const struct samsung_pin_bank_data exynos7_pin_banks2[] __initconst = {
+        EXYNOS_PIN_BANK_EINTG(3, 0x000, "gpj0", 0x00),
+};
+
+/* pin banks of exynos7 pin-controller - TOUCH */
+static const struct samsung_pin_bank_data exynos7_pin_banks3[] __initconst = {
+        EXYNOS_PIN_BANK_EINTG(3, 0x000, "gpj1", 0x00),
+};
+
+/* pin banks of exynos7 pin-controller - FF */
+static const struct samsung_pin_bank_data exynos7_pin_banks4[] __initconst = {
+        EXYNOS_PIN_BANK_EINTG(4, 0x000, "gpg4", 0x00),
+};
+
+/* pin banks of exynos7 pin-controller - ESE */
+static const struct samsung_pin_bank_data exynos7_pin_banks5[] __initconst = {
+        EXYNOS_PIN_BANK_EINTG(5, 0x000, "gpv7", 0x00),
+};
+
+/* pin banks of exynos7 pin-controller - FSYS0 */
+static const struct samsung_pin_bank_data exynos7_pin_banks6[] __initconst = {
+        EXYNOS_PIN_BANK_EINTG(7, 0x000, "gpr4", 0x00),
+};
+
+/* pin banks of exynos7 pin-controller - FSYS1 */
+static const struct samsung_pin_bank_data exynos7_pin_banks7[] __initconst = {
+        EXYNOS_PIN_BANK_EINTG(4, 0x000, "gpr0", 0x00),
+        EXYNOS_PIN_BANK_EINTG(8, 0x020, "gpr1", 0x04),
+        EXYNOS_PIN_BANK_EINTG(5, 0x040, "gpr2", 0x08),
+        EXYNOS_PIN_BANK_EINTG(8, 0x060, "gpr3", 0x0c),
+};
+
+const struct samsung_pin_ctrl exynos7_pin_ctrl[] __initconst = {
+        {
+                /* pin-controller instance 0 Alive data */
+                .pin_banks      = exynos7_pin_banks0,
+                .nr_banks       = ARRAY_SIZE(exynos7_pin_banks0),
+                .eint_gpio_init = exynos_eint_gpio_init,
+                .eint_wkup_init = exynos_eint_wkup_init,
+        }, {
+                /* pin-controller instance 1 BUS0 data */
+                .pin_banks      = exynos7_pin_banks1,
+                .nr_banks       = ARRAY_SIZE(exynos7_pin_banks1),
+                .eint_gpio_init = exynos_eint_gpio_init,
+        }, {
+                /* pin-controller instance 2 NFC data */
+                .pin_banks      = exynos7_pin_banks2,
+                .nr_banks       = ARRAY_SIZE(exynos7_pin_banks2),
+                .eint_gpio_init = exynos_eint_gpio_init,
+        }, {
+                /* pin-controller instance 3 TOUCH data */
+                .pin_banks      = exynos7_pin_banks3,
+                .nr_banks       = ARRAY_SIZE(exynos7_pin_banks3),
+                .eint_gpio_init = exynos_eint_gpio_init,
+        }, {
+                /* pin-controller instance 4 FF data */
+                .pin_banks      = exynos7_pin_banks4,
+                .nr_banks       = ARRAY_SIZE(exynos7_pin_banks4),
+                .eint_gpio_init = exynos_eint_gpio_init,
+        }, {
+                /* pin-controller instance 5 ESE data */
+                .pin_banks      = exynos7_pin_banks5,
+                .nr_banks       = ARRAY_SIZE(exynos7_pin_banks5),
+                .eint_gpio_init = exynos_eint_gpio_init,
+        }, {
+                /* pin-controller instance 6 FSYS0 data */
+                .pin_banks      = exynos7_pin_banks6,
+                .nr_banks       = ARRAY_SIZE(exynos7_pin_banks6),
+                .eint_gpio_init = exynos_eint_gpio_init,
+        }, {
+                /* pin-controller instance 7 FSYS1 data */
+                .pin_banks      = exynos7_pin_banks7,
+                .nr_banks       = ARRAY_SIZE(exynos7_pin_banks7),
+                .eint_gpio_init = exynos_eint_gpio_init,
         },
 };
diff --git a/drivers/pinctrl/samsung/pinctrl-exynos.h b/drivers/pinctrl/samsung/pinctrl-exynos.h
index 3c91c357792f..0f0f7cedb2dc 100644
--- a/drivers/pinctrl/samsung/pinctrl-exynos.h
+++ b/drivers/pinctrl/samsung/pinctrl-exynos.h
@@ -25,6 +25,9 @@
 #define EXYNOS_WKUP_ECON_OFFSET         0xE00
 #define EXYNOS_WKUP_EMASK_OFFSET        0xF00
 #define EXYNOS_WKUP_EPEND_OFFSET        0xF40
+#define EXYNOS7_WKUP_ECON_OFFSET        0x700
+#define EXYNOS7_WKUP_EMASK_OFFSET       0x900
+#define EXYNOS7_WKUP_EPEND_OFFSET       0xA00
 #define EXYNOS_SVC_OFFSET               0xB08
 #define EXYNOS_EINT_FUNC                0xF
 
diff --git a/drivers/pinctrl/samsung/pinctrl-s3c24xx.c b/drivers/pinctrl/samsung/pinctrl-s3c24xx.c
index ad3eaad17001..f1993f42114c 100644
--- a/drivers/pinctrl/samsung/pinctrl-s3c24xx.c
+++ b/drivers/pinctrl/samsung/pinctrl-s3c24xx.c
@@ -44,12 +44,12 @@
 #define EINT_EDGE_BOTH          6
 #define EINT_MASK               0xf
 
-static struct samsung_pin_bank_type bank_type_1bit = {
+static const struct samsung_pin_bank_type bank_type_1bit = {
         .fld_width = { 1, 1, },
         .reg_offset = { 0x00, 0x04, },
 };
 
-static struct samsung_pin_bank_type bank_type_2bit = {
+static const struct samsung_pin_bank_type bank_type_2bit = {
         .fld_width = { 2, 1, 2, },
         .reg_offset = { 0x00, 0x04, 0x08, },
 };
@@ -143,7 +143,7 @@ static void s3c24xx_eint_set_handler(unsigned int irq, unsigned int type)
 static void s3c24xx_eint_set_function(struct samsung_pinctrl_drv_data *d,
                                         struct samsung_pin_bank *bank, int pin)
 {
-        struct samsung_pin_bank_type *bank_type = bank->type;
+        const struct samsung_pin_bank_type *bank_type = bank->type;
         unsigned long flags;
         void __iomem *reg;
         u8 shift;
@@ -518,8 +518,8 @@ static int s3c24xx_eint_init(struct samsung_pinctrl_drv_data *d)
                 irq_set_handler_data(irq, eint_data);
         }
 
-        bank = d->ctrl->pin_banks;
-        for (i = 0; i < d->ctrl->nr_banks; ++i, ++bank) {
+        bank = d->pin_banks;
+        for (i = 0; i < d->nr_banks; ++i, ++bank) {
                 struct s3c24xx_eint_domain_data *ddata;
                 unsigned int mask;
                 unsigned int irq;
@@ -561,7 +561,7 @@ static int s3c24xx_eint_init(struct samsung_pinctrl_drv_data *d)
         return 0;
 }
 
-static struct samsung_pin_bank s3c2412_pin_banks[] = {
+static const struct samsung_pin_bank_data s3c2412_pin_banks[] __initconst = {
         PIN_BANK_A(23, 0x000, "gpa"),
         PIN_BANK_2BIT(11, 0x010, "gpb"),
         PIN_BANK_2BIT(16, 0x020, "gpc"),
@@ -573,16 +573,15 @@ static struct samsung_pin_bank s3c2412_pin_banks[] = {
         PIN_BANK_2BIT(13, 0x080, "gpj"),
 };
 
-struct samsung_pin_ctrl s3c2412_pin_ctrl[] = {
+const struct samsung_pin_ctrl s3c2412_pin_ctrl[] __initconst = {
         {
                 .pin_banks      = s3c2412_pin_banks,
                 .nr_banks       = ARRAY_SIZE(s3c2412_pin_banks),
                 .eint_wkup_init = s3c24xx_eint_init,
-                .label          = "S3C2412-GPIO",
         },
 };
 
-static struct samsung_pin_bank s3c2416_pin_banks[] = {
+static const struct samsung_pin_bank_data s3c2416_pin_banks[] __initconst = {
         PIN_BANK_A(27, 0x000, "gpa"),
         PIN_BANK_2BIT(11, 0x010, "gpb"),
         PIN_BANK_2BIT(16, 0x020, "gpc"),
@@ -596,16 +595,15 @@ static struct samsung_pin_bank s3c2416_pin_banks[] = {
         PIN_BANK_2BIT(2, 0x100, "gpm"),
 };
 
-struct samsung_pin_ctrl s3c2416_pin_ctrl[] = {
+const struct samsung_pin_ctrl s3c2416_pin_ctrl[] __initconst = {
         {
                 .pin_banks      = s3c2416_pin_banks,
                 .nr_banks       = ARRAY_SIZE(s3c2416_pin_banks),
                 .eint_wkup_init = s3c24xx_eint_init,
-                .label          = "S3C2416-GPIO",
         },
 };
 
-static struct samsung_pin_bank s3c2440_pin_banks[] = {
+static const struct samsung_pin_bank_data s3c2440_pin_banks[] __initconst = {
         PIN_BANK_A(25, 0x000, "gpa"),
         PIN_BANK_2BIT(11, 0x010, "gpb"),
         PIN_BANK_2BIT(16, 0x020, "gpc"),
@@ -617,16 +615,15 @@ static struct samsung_pin_bank s3c2440_pin_banks[] = {
         PIN_BANK_2BIT(13, 0x0d0, "gpj"),
 };
 
-struct samsung_pin_ctrl s3c2440_pin_ctrl[] = {
+const struct samsung_pin_ctrl s3c2440_pin_ctrl[] __initconst = {
         {
                 .pin_banks      = s3c2440_pin_banks,
                 .nr_banks       = ARRAY_SIZE(s3c2440_pin_banks),
                 .eint_wkup_init = s3c24xx_eint_init,
-                .label          = "S3C2440-GPIO",
         },
 };
 
-static struct samsung_pin_bank s3c2450_pin_banks[] = {
+static const struct samsung_pin_bank_data s3c2450_pin_banks[] __initconst = {
         PIN_BANK_A(28, 0x000, "gpa"),
         PIN_BANK_2BIT(11, 0x010, "gpb"),
         PIN_BANK_2BIT(16, 0x020, "gpc"),
@@ -641,11 +638,10 @@ static struct samsung_pin_bank s3c2450_pin_banks[] = {
         PIN_BANK_2BIT(2, 0x100, "gpm"),
 };
 
-struct samsung_pin_ctrl s3c2450_pin_ctrl[] = {
+const struct samsung_pin_ctrl s3c2450_pin_ctrl[] __initconst = {
         {
                 .pin_banks      = s3c2450_pin_banks,
                 .nr_banks       = ARRAY_SIZE(s3c2450_pin_banks),
                 .eint_wkup_init = s3c24xx_eint_init,
-                .label          = "S3C2450-GPIO",
         },
 };
diff --git a/drivers/pinctrl/samsung/pinctrl-s3c64xx.c b/drivers/pinctrl/samsung/pinctrl-s3c64xx.c
index 89143c903000..7756c1e9e763 100644
--- a/drivers/pinctrl/samsung/pinctrl-s3c64xx.c
+++ b/drivers/pinctrl/samsung/pinctrl-s3c64xx.c
@@ -68,32 +68,32 @@
 #define EINT_CON_MASK           0xF
 #define EINT_CON_LEN            4
 
-static struct samsung_pin_bank_type bank_type_4bit_off = {
+static const struct samsung_pin_bank_type bank_type_4bit_off = {
         .fld_width = { 4, 1, 2, 0, 2, 2, },
         .reg_offset = { 0x00, 0x04, 0x08, 0, 0x0c, 0x10, },
 };
 
-static struct samsung_pin_bank_type bank_type_4bit_alive = {
+static const struct samsung_pin_bank_type bank_type_4bit_alive = {
         .fld_width = { 4, 1, 2, },
         .reg_offset = { 0x00, 0x04, 0x08, },
 };
 
-static struct samsung_pin_bank_type bank_type_4bit2_off = {
+static const struct samsung_pin_bank_type bank_type_4bit2_off = {
         .fld_width = { 4, 1, 2, 0, 2, 2, },
         .reg_offset = { 0x00, 0x08, 0x0c, 0, 0x10, 0x14, },
 };
 
-static struct samsung_pin_bank_type bank_type_4bit2_alive = {
+static const struct samsung_pin_bank_type bank_type_4bit2_alive = {
         .fld_width = { 4, 1, 2, },
         .reg_offset = { 0x00, 0x08, 0x0c, },
 };
 
-static struct samsung_pin_bank_type bank_type_2bit_off = {
+static const struct samsung_pin_bank_type bank_type_2bit_off = {
         .fld_width = { 2, 1, 2, 0, 2, 2, },
         .reg_offset = { 0x00, 0x04, 0x08, 0, 0x0c, 0x10, },
 };
 
-static struct samsung_pin_bank_type bank_type_2bit_alive = {
+static const struct samsung_pin_bank_type bank_type_2bit_alive = {
         .fld_width = { 2, 1, 2, },
         .reg_offset = { 0x00, 0x04, 0x08, },
 };
@@ -272,7 +272,7 @@ static void s3c64xx_irq_set_handler(unsigned int irq, unsigned int type)
 static void s3c64xx_irq_set_function(struct samsung_pinctrl_drv_data *d,
                                         struct samsung_pin_bank *bank, int pin)
 {
-        struct samsung_pin_bank_type *bank_type = bank->type;
+        const struct samsung_pin_bank_type *bank_type = bank->type;
         unsigned long flags;
         void __iomem *reg;
         u8 shift;
@@ -468,8 +468,8 @@ static int s3c64xx_eint_gpio_init(struct samsung_pinctrl_drv_data *d)
         }
 
         nr_domains = 0;
-        bank = d->ctrl->pin_banks;
-        for (i = 0; i < d->ctrl->nr_banks; ++i, ++bank) {
+        bank = d->pin_banks;
+        for (i = 0; i < d->nr_banks; ++i, ++bank) {
                 unsigned int nr_eints;
                 unsigned int mask;
 
@@ -497,9 +497,9 @@ static int s3c64xx_eint_gpio_init(struct samsung_pinctrl_drv_data *d)
         }
         data->drvdata = d;
 
-        bank = d->ctrl->pin_banks;
+        bank = d->pin_banks;
         nr_domains = 0;
-        for (i = 0; i < d->ctrl->nr_banks; ++i, ++bank) {
+        for (i = 0; i < d->nr_banks; ++i, ++bank) {
                 if (bank->eint_type != EINT_TYPE_GPIO)
                         continue;
 
@@ -735,8 +735,8 @@ static int s3c64xx_eint_eint0_init(struct samsung_pinctrl_drv_data *d)
                 irq_set_handler_data(irq, data);
         }
 
-        bank = d->ctrl->pin_banks;
-        for (i = 0; i < d->ctrl->nr_banks; ++i, ++bank) {
+        bank = d->pin_banks;
+        for (i = 0; i < d->nr_banks; ++i, ++bank) {
                 struct s3c64xx_eint0_domain_data *ddata;
                 unsigned int nr_eints;
                 unsigned int mask;
@@ -780,7 +780,7 @@ static int s3c64xx_eint_eint0_init(struct samsung_pinctrl_drv_data *d)
 }
 
 /* pin banks of s3c64xx pin-controller 0 */
-static struct samsung_pin_bank s3c64xx_pin_banks0[] = {
+static const struct samsung_pin_bank_data s3c64xx_pin_banks0[] __initconst = {
         PIN_BANK_4BIT_EINTG(8, 0x000, "gpa", 0),
         PIN_BANK_4BIT_EINTG(7, 0x020, "gpb", 8),
         PIN_BANK_4BIT_EINTG(8, 0x040, "gpc", 16),
@@ -804,13 +804,12 @@ static struct samsung_pin_bank s3c64xx_pin_banks0[] = {
  * Samsung pinctrl driver data for S3C64xx SoC. S3C64xx SoC includes
  * one gpio/pin-mux/pinconfig controller.
  */
-struct samsung_pin_ctrl s3c64xx_pin_ctrl[] = {
+const struct samsung_pin_ctrl s3c64xx_pin_ctrl[] __initconst = {
         {
                 /* pin-controller instance 1 data */
                 .pin_banks      = s3c64xx_pin_banks0,
                 .nr_banks       = ARRAY_SIZE(s3c64xx_pin_banks0),
                 .eint_gpio_init = s3c64xx_eint_gpio_init,
                 .eint_wkup_init = s3c64xx_eint_eint0_init,
-                .label          = "S3C64xx-GPIO",
         },
 };
diff --git a/drivers/pinctrl/samsung/pinctrl-samsung.c b/drivers/pinctrl/samsung/pinctrl-samsung.c
index 2d37c8f49f3c..32940a01a84f 100644
--- a/drivers/pinctrl/samsung/pinctrl-samsung.c
+++ b/drivers/pinctrl/samsung/pinctrl-samsung.c
@@ -349,7 +349,7 @@ static void pin_to_reg_bank(struct samsung_pinctrl_drv_data *drvdata,
 {
         struct samsung_pin_bank *b;
 
-        b = drvdata->ctrl->pin_banks;
+        b = drvdata->pin_banks;
 
         while ((pin >= b->pin_base) &&
                         ((b->pin_base + b->nr_pins - 1) < pin))
@@ -366,7 +366,7 @@ static void samsung_pinmux_setup(struct pinctrl_dev *pctldev, unsigned selector,
                                         unsigned group, bool enable)
 {
         struct samsung_pinctrl_drv_data *drvdata;
-        struct samsung_pin_bank_type *type;
+        const struct samsung_pin_bank_type *type;
         struct samsung_pin_bank *bank;
         void __iomem *reg;
         u32 mask, shift, data, pin_offset;
@@ -378,7 +378,7 @@ static void samsung_pinmux_setup(struct pinctrl_dev *pctldev, unsigned selector,
         func = &drvdata->pmx_functions[selector];
         grp = &drvdata->pin_groups[group];
 
-        pin_to_reg_bank(drvdata, grp->pins[0] - drvdata->ctrl->base,
+        pin_to_reg_bank(drvdata, grp->pins[0] - drvdata->pin_base,
                         &reg, &pin_offset, &bank);
         type = bank->type;
         mask = (1 << type->fld_width[PINCFG_TYPE_FUNC]) - 1;
@@ -422,7 +422,7 @@ static int samsung_pinconf_rw(struct pinctrl_dev *pctldev, unsigned int pin,
                                 unsigned long *config, bool set)
 {
         struct samsung_pinctrl_drv_data *drvdata;
-        struct samsung_pin_bank_type *type;
+        const struct samsung_pin_bank_type *type;
         struct samsung_pin_bank *bank;
         void __iomem *reg_base;
         enum pincfg_type cfg_type = PINCFG_UNPACK_TYPE(*config);
@@ -431,7 +431,7 @@ static int samsung_pinconf_rw(struct pinctrl_dev *pctldev, unsigned int pin,
         unsigned long flags;
 
         drvdata = pinctrl_dev_get_drvdata(pctldev);
-        pin_to_reg_bank(drvdata, pin - drvdata->ctrl->base, &reg_base,
+        pin_to_reg_bank(drvdata, pin - drvdata->pin_base, &reg_base,
                                         &pin_offset, &bank);
         type = bank->type;
 
@@ -528,7 +528,7 @@ static const struct pinconf_ops samsung_pinconf_ops = {
 static void samsung_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 {
         struct samsung_pin_bank *bank = gc_to_pin_bank(gc);
-        struct samsung_pin_bank_type *type = bank->type;
+        const struct samsung_pin_bank_type *type = bank->type;
         unsigned long flags;
         void __iomem *reg;
         u32 data;
@@ -552,7 +552,7 @@ static int samsung_gpio_get(struct gpio_chip *gc, unsigned offset)
         void __iomem *reg;
         u32 data;
         struct samsung_pin_bank *bank = gc_to_pin_bank(gc);
-        struct samsung_pin_bank_type *type = bank->type;
+        const struct samsung_pin_bank_type *type = bank->type;
 
         reg = bank->drvdata->virt_base + bank->pctl_offset;
 
@@ -569,7 +569,7 @@ static int samsung_gpio_get(struct gpio_chip *gc, unsigned offset)
 static int samsung_gpio_set_direction(struct gpio_chip *gc,
                                              unsigned offset, bool input)
 {
-        struct samsung_pin_bank_type *type;
+        const struct samsung_pin_bank_type *type;
         struct samsung_pin_bank *bank;
         struct samsung_pinctrl_drv_data *drvdata;
         void __iomem *reg;
@@ -834,32 +834,32 @@ static int samsung_pinctrl_register(struct platform_device *pdev,
         ctrldesc->confops = &samsung_pinconf_ops;
 
         pindesc = devm_kzalloc(&pdev->dev, sizeof(*pindesc) *
-                        drvdata->ctrl->nr_pins, GFP_KERNEL);
+                        drvdata->nr_pins, GFP_KERNEL);
         if (!pindesc) {
                 dev_err(&pdev->dev, "mem alloc for pin descriptors failed\n");
                 return -ENOMEM;
         }
         ctrldesc->pins = pindesc;
-        ctrldesc->npins = drvdata->ctrl->nr_pins;
+        ctrldesc->npins = drvdata->nr_pins;
 
         /* dynamically populate the pin number and pin name for pindesc */
         for (pin = 0, pdesc = pindesc; pin < ctrldesc->npins; pin++, pdesc++)
-                pdesc->number = pin + drvdata->ctrl->base;
+                pdesc->number = pin + drvdata->pin_base;
 
         /*
          * allocate space for storing the dynamically generated names for all
          * the pins which belong to this pin-controller.
          */
         pin_names = devm_kzalloc(&pdev->dev, sizeof(char) * PIN_NAME_LENGTH *
-                                        drvdata->ctrl->nr_pins, GFP_KERNEL);
+                                        drvdata->nr_pins, GFP_KERNEL);
         if (!pin_names) {
                 dev_err(&pdev->dev, "mem alloc for pin names failed\n");
                 return -ENOMEM;
         }
 
         /* for each pin, the name of the pin is pin-bank name + pin number */
-        for (bank = 0; bank < drvdata->ctrl->nr_banks; bank++) {
-                pin_bank = &drvdata->ctrl->pin_banks[bank];
+        for (bank = 0; bank < drvdata->nr_banks; bank++) {
+                pin_bank = &drvdata->pin_banks[bank];
                 for (pin = 0; pin < pin_bank->nr_pins; pin++) {
                         sprintf(pin_names, "%s-%d", pin_bank->name, pin);
                         pdesc = pindesc + pin_bank->pin_base + pin;
@@ -878,11 +878,11 @@ static int samsung_pinctrl_register(struct platform_device *pdev,
                 return -EINVAL;
         }
 
-        for (bank = 0; bank < drvdata->ctrl->nr_banks; ++bank) {
-                pin_bank = &drvdata->ctrl->pin_banks[bank];
+        for (bank = 0; bank < drvdata->nr_banks; ++bank) {
+                pin_bank = &drvdata->pin_banks[bank];
                 pin_bank->grange.name = pin_bank->name;
                 pin_bank->grange.id = bank;
-                pin_bank->grange.pin_base = drvdata->ctrl->base
+                pin_bank->grange.pin_base = drvdata->pin_base
                                                 + pin_bank->pin_base;
                 pin_bank->grange.base = pin_bank->gpio_chip.base;
                 pin_bank->grange.npins = pin_bank->gpio_chip.ngpio;
@@ -918,17 +918,16 @@ static const struct gpio_chip samsung_gpiolib_chip = {
 static int samsung_gpiolib_register(struct platform_device *pdev,
                                     struct samsung_pinctrl_drv_data *drvdata)
 {
-        struct samsung_pin_ctrl *ctrl = drvdata->ctrl;
-        struct samsung_pin_bank *bank = ctrl->pin_banks;
+        struct samsung_pin_bank *bank = drvdata->pin_banks;
         struct gpio_chip *gc;
         int ret;
         int i;
 
-        for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
+        for (i = 0; i < drvdata->nr_banks; ++i, ++bank) {
                 bank->gpio_chip = samsung_gpiolib_chip;
 
                 gc = &bank->gpio_chip;
-                gc->base = ctrl->base + bank->pin_base;
+                gc->base = drvdata->pin_base + bank->pin_base;
                 gc->ngpio = bank->nr_pins;
                 gc->dev = &pdev->dev;
                 gc->of_node = bank->of_node;
@@ -954,51 +953,70 @@ fail:
 static int samsung_gpiolib_unregister(struct platform_device *pdev,
                                       struct samsung_pinctrl_drv_data *drvdata)
 {
-        struct samsung_pin_ctrl *ctrl = drvdata->ctrl;
-        struct samsung_pin_bank *bank = ctrl->pin_banks;
+        struct samsung_pin_bank *bank = drvdata->pin_banks;
         int i;
 
-        for (i = 0; i < ctrl->nr_banks; ++i, ++bank)
+        for (i = 0; i < drvdata->nr_banks; ++i, ++bank)
                 gpiochip_remove(&bank->gpio_chip);
+
         return 0;
 }
 
 static const struct of_device_id samsung_pinctrl_dt_match[];
 
 /* retrieve the soc specific data */
-static struct samsung_pin_ctrl *samsung_pinctrl_get_soc_data(
-                                struct samsung_pinctrl_drv_data *d,
-                                struct platform_device *pdev)
+static const struct samsung_pin_ctrl *
+samsung_pinctrl_get_soc_data(struct samsung_pinctrl_drv_data *d,
+                             struct platform_device *pdev)
 {
         int id;
         const struct of_device_id *match;
         struct device_node *node = pdev->dev.of_node;
         struct device_node *np;
-        struct samsung_pin_ctrl *ctrl;
+        const struct samsung_pin_bank_data *bdata;
+        const struct samsung_pin_ctrl *ctrl;
         struct samsung_pin_bank *bank;
         int i;
 
         id = of_alias_get_id(node, "pinctrl");
         if (id < 0) {
                 dev_err(&pdev->dev, "failed to get alias id\n");
-                return NULL;
+                return ERR_PTR(-ENOENT);
         }
         match = of_match_node(samsung_pinctrl_dt_match, node);
         ctrl = (struct samsung_pin_ctrl *)match->data + id;
 
-        bank = ctrl->pin_banks;
-        for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
+        d->suspend = ctrl->suspend;
+        d->resume = ctrl->resume;
+        d->nr_banks = ctrl->nr_banks;
+        d->pin_banks = devm_kcalloc(&pdev->dev, d->nr_banks,
+                                        sizeof(*d->pin_banks), GFP_KERNEL);
+        if (!d->pin_banks)
+                return ERR_PTR(-ENOMEM);
+
+        bank = d->pin_banks;
+        bdata = ctrl->pin_banks;
+        for (i = 0; i < ctrl->nr_banks; ++i, ++bdata, ++bank) {
+                bank->type = bdata->type;
+                bank->pctl_offset = bdata->pctl_offset;
+                bank->nr_pins = bdata->nr_pins;
+                bank->eint_func = bdata->eint_func;
+                bank->eint_type = bdata->eint_type;
+                bank->eint_mask = bdata->eint_mask;
+                bank->eint_offset = bdata->eint_offset;
+                bank->name = bdata->name;
+
                 spin_lock_init(&bank->slock);
                 bank->drvdata = d;
-                bank->pin_base = ctrl->nr_pins;
-                ctrl->nr_pins += bank->nr_pins;
+                bank->pin_base = d->nr_pins;
+                d->nr_pins += bank->nr_pins;
         }
 
         for_each_child_of_node(node, np) {
                 if (!of_find_property(np, "gpio-controller", NULL))
                         continue;
-                bank = ctrl->pin_banks;
-                for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
+                bank = d->pin_banks;
+                for (i = 0; i < d->nr_banks; ++i, ++bank) {
                         if (!strcmp(bank->name, np->name)) {
                                 bank->of_node = np;
                                 break;
@@ -1006,8 +1024,8 @@ static struct samsung_pin_ctrl *samsung_pinctrl_get_soc_data(
                 }
         }
 
-        ctrl->base = pin_base;
-        pin_base += ctrl->nr_pins;
+        d->pin_base = pin_base;
+        pin_base += d->nr_pins;
 
         return ctrl;
 }
@@ -1015,8 +1033,8 @@ static struct samsung_pin_ctrl *samsung_pinctrl_get_soc_data(
 static int samsung_pinctrl_probe(struct platform_device *pdev)
 {
         struct samsung_pinctrl_drv_data *drvdata;
+        const struct samsung_pin_ctrl *ctrl;
         struct device *dev = &pdev->dev;
-        struct samsung_pin_ctrl *ctrl;
         struct resource *res;
         int ret;
 
@@ -1033,11 +1051,10 @@ static int samsung_pinctrl_probe(struct platform_device *pdev)
         }
 
         ctrl = samsung_pinctrl_get_soc_data(drvdata, pdev);
-        if (!ctrl) {
+        if (IS_ERR(ctrl)) {
                 dev_err(&pdev->dev, "driver data not available\n");
-                return -EINVAL;
+                return PTR_ERR(ctrl);
         }
-        drvdata->ctrl = ctrl;
         drvdata->dev = dev;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -1082,16 +1099,14 @@ static int samsung_pinctrl_probe(struct platform_device *pdev)
 static void samsung_pinctrl_suspend_dev(
         struct samsung_pinctrl_drv_data *drvdata)
 {
-        struct samsung_pin_ctrl *ctrl = drvdata->ctrl;
         void __iomem *virt_base = drvdata->virt_base;
         int i;
 
-        for (i = 0; i < ctrl->nr_banks; i++) {
-                struct samsung_pin_bank *bank = &ctrl->pin_banks[i];
+        for (i = 0; i < drvdata->nr_banks; i++) {
+                struct samsung_pin_bank *bank = &drvdata->pin_banks[i];
                 void __iomem *reg = virt_base + bank->pctl_offset;
-
-                u8 *offs = bank->type->reg_offset;
-                u8 *widths = bank->type->fld_width;
+                const u8 *offs = bank->type->reg_offset;
+                const u8 *widths = bank->type->fld_width;
                 enum pincfg_type type;
 
                 /* Registers without a powerdown config aren't lost */
@@ -1116,8 +1131,8 @@ static void samsung_pinctrl_suspend_dev(
                 }
         }
 
-        if (ctrl->suspend)
-                ctrl->suspend(drvdata);
+        if (drvdata->suspend)
+                drvdata->suspend(drvdata);
 }
 
 /**
@@ -1130,19 +1145,17 @@ static void samsung_pinctrl_suspend_dev(
  */
 static void samsung_pinctrl_resume_dev(struct samsung_pinctrl_drv_data *drvdata)
 {
-        struct samsung_pin_ctrl *ctrl = drvdata->ctrl;
         void __iomem *virt_base = drvdata->virt_base;
         int i;
 
-        if (ctrl->resume)
-                ctrl->resume(drvdata);
+        if (drvdata->resume)
+                drvdata->resume(drvdata);
 
-        for (i = 0; i < ctrl->nr_banks; i++) {
-                struct samsung_pin_bank *bank = &ctrl->pin_banks[i];
+        for (i = 0; i < drvdata->nr_banks; i++) {
+                struct samsung_pin_bank *bank = &drvdata->pin_banks[i];
                 void __iomem *reg = virt_base + bank->pctl_offset;
-
-                u8 *offs = bank->type->reg_offset;
-                u8 *widths = bank->type->fld_width;
+                const u8 *offs = bank->type->reg_offset;
+                const u8 *widths = bank->type->fld_width;
                 enum pincfg_type type;
 
                 /* Registers without a powerdown config aren't lost */
@@ -1218,6 +1231,8 @@ static const struct of_device_id samsung_pinctrl_dt_match[] = {
                 .data = (void *)exynos4210_pin_ctrl },
         { .compatible = "samsung,exynos4x12-pinctrl",
                 .data = (void *)exynos4x12_pin_ctrl },
+        { .compatible = "samsung,exynos4415-pinctrl",
+                .data = (void *)exynos4415_pin_ctrl },
         { .compatible = "samsung,exynos5250-pinctrl",
                 .data = (void *)exynos5250_pin_ctrl },
         { .compatible = "samsung,exynos5260-pinctrl",
@@ -1226,6 +1241,8 @@ static const struct of_device_id samsung_pinctrl_dt_match[] = {
                 .data = (void *)exynos5420_pin_ctrl },
         { .compatible = "samsung,s5pv210-pinctrl",
                 .data = (void *)s5pv210_pin_ctrl },
+        { .compatible = "samsung,exynos7-pinctrl",
+                .data = (void *)exynos7_pin_ctrl },
 #endif
 #ifdef CONFIG_PINCTRL_S3C64XX
         { .compatible = "samsung,s3c64xx-pinctrl",
diff --git a/drivers/pinctrl/samsung/pinctrl-samsung.h b/drivers/pinctrl/samsung/pinctrl-samsung.h
index 5cedc9d26390..1b8c0139d604 100644
--- a/drivers/pinctrl/samsung/pinctrl-samsung.h
+++ b/drivers/pinctrl/samsung/pinctrl-samsung.h
@@ -113,39 +113,66 @@ struct samsung_pin_bank_type {
 };
 
 /**
+ * struct samsung_pin_bank_data: represent a controller pin-bank (init data).
+ * @type: type of the bank (register offsets and bitfield widths)
+ * @pctl_offset: starting offset of the pin-bank registers.
+ * @nr_pins: number of pins included in this bank.
+ * @eint_func: function to set in CON register to configure pin as EINT.
+ * @eint_type: type of the external interrupt supported by the bank.
+ * @eint_mask: bit mask of pins which support EINT function.
+ * @eint_offset: SoC-specific EINT register or interrupt offset of bank.
+ * @name: name to be prefixed for each pin in this pin bank.
+ */
+struct samsung_pin_bank_data {
+        const struct samsung_pin_bank_type *type;
+        u32             pctl_offset;
+        u8              nr_pins;
+        u8              eint_func;
+        enum eint_type  eint_type;
+        u32             eint_mask;
+        u32             eint_offset;
+        const char      *name;
+};
+
+/**
  * struct samsung_pin_bank: represent a controller pin-bank.
  * @type: type of the bank (register offsets and bitfield widths)
  * @pctl_offset: starting offset of the pin-bank registers.
- * @pin_base: starting pin number of the bank.
  * @nr_pins: number of pins included in this bank.
  * @eint_func: function to set in CON register to configure pin as EINT.
  * @eint_type: type of the external interrupt supported by the bank.
  * @eint_mask: bit mask of pins which support EINT function.
+ * @eint_offset: SoC-specific EINT register or interrupt offset of bank.
  * @name: name to be prefixed for each pin in this pin bank.
+ * @pin_base: starting pin number of the bank.
+ * @soc_priv: per-bank private data for SoC-specific code.
  * @of_node: OF node of the bank.
  * @drvdata: link to controller driver data
  * @irq_domain: IRQ domain of the bank.
  * @gpio_chip: GPIO chip of the bank.
  * @grange: linux gpio pin range supported by this bank.
+ * @irq_chip: link to irq chip for external gpio and wakeup interrupts.
  * @slock: spinlock protecting bank registers
  * @pm_save: saved register values during suspend
  */
 struct samsung_pin_bank {
-        struct samsung_pin_bank_type *type;
+        const struct samsung_pin_bank_type *type;
         u32             pctl_offset;
-        u32             pin_base;
         u8              nr_pins;
         u8              eint_func;
         enum eint_type  eint_type;
         u32             eint_mask;
         u32             eint_offset;
-        char            *name;
+        const char      *name;
+
+        u32             pin_base;
         void            *soc_priv;
         struct device_node *of_node;
         struct samsung_pinctrl_drv_data *drvdata;
         struct irq_domain *irq_domain;
         struct gpio_chip gpio_chip;
         struct pinctrl_gpio_range grange;
+        struct exynos_irq_chip *irq_chip;
         spinlock_t slock;
 
         u32 pm_save[PINCFG_TYPE_NUM + 1]; /* +1 to handle double CON registers*/
@@ -155,27 +182,19 @@ struct samsung_pin_bank {
  * struct samsung_pin_ctrl: represent a pin controller.
  * @pin_banks: list of pin banks included in this controller.
  * @nr_banks: number of pin banks.
- * @base: starting system wide pin number.
- * @nr_pins: number of pins supported by the controller.
  * @eint_gpio_init: platform specific callback to setup the external gpio
  *      interrupts for the controller.
  * @eint_wkup_init: platform specific callback to setup the external wakeup
  *      interrupts for the controller.
- * @label: for debug information.
  */
 struct samsung_pin_ctrl {
-        struct samsung_pin_bank *pin_banks;
+        const struct samsung_pin_bank_data *pin_banks;
         u32             nr_banks;
 
-        u32             base;
-        u32             nr_pins;
-
         int             (*eint_gpio_init)(struct samsung_pinctrl_drv_data *);
         int             (*eint_wkup_init)(struct samsung_pinctrl_drv_data *);
         void            (*suspend)(struct samsung_pinctrl_drv_data *);
         void            (*resume)(struct samsung_pinctrl_drv_data *);
-
-        char            *label;
 };
 
 /**
@@ -191,6 +210,8 @@ struct samsung_pin_ctrl {
  * @nr_groups: number of such pin groups.
  * @pmx_functions: list of pin functions available to the driver.
  * @nr_function: number of such pin functions.
+ * @pin_base: starting system wide pin number.
+ * @nr_pins: number of pins supported by the controller.
  */
 struct samsung_pinctrl_drv_data {
         struct list_head                node;
@@ -198,7 +219,6 @@ struct samsung_pinctrl_drv_data {
         struct device                   *dev;
         int                             irq;
 
-        struct samsung_pin_ctrl         *ctrl;
         struct pinctrl_desc             pctl;
         struct pinctrl_dev              *pctl_dev;
 
@@ -206,6 +226,14 @@ struct samsung_pinctrl_drv_data {
         unsigned int                    nr_groups;
         const struct samsung_pmx_func   *pmx_functions;
         unsigned int                    nr_functions;
+
+        struct samsung_pin_bank         *pin_banks;
+        u32                             nr_banks;
+        unsigned int                    pin_base;
+        unsigned int                    nr_pins;
+
+        void (*suspend)(struct samsung_pinctrl_drv_data *);
+        void (*resume)(struct samsung_pinctrl_drv_data *);
 };
 
 /**
@@ -236,17 +264,19 @@ struct samsung_pmx_func {
 };
 
 /* list of all exported SoC specific data */
-extern struct samsung_pin_ctrl exynos3250_pin_ctrl[];
-extern struct samsung_pin_ctrl exynos4210_pin_ctrl[];
-extern struct samsung_pin_ctrl exynos4x12_pin_ctrl[];
-extern struct samsung_pin_ctrl exynos5250_pin_ctrl[];
-extern struct samsung_pin_ctrl exynos5260_pin_ctrl[];
-extern struct samsung_pin_ctrl exynos5420_pin_ctrl[];
-extern struct samsung_pin_ctrl s3c64xx_pin_ctrl[];
-extern struct samsung_pin_ctrl s3c2412_pin_ctrl[];
-extern struct samsung_pin_ctrl s3c2416_pin_ctrl[];
-extern struct samsung_pin_ctrl s3c2440_pin_ctrl[];
-extern struct samsung_pin_ctrl s3c2450_pin_ctrl[];
-extern struct samsung_pin_ctrl s5pv210_pin_ctrl[];
+extern const struct samsung_pin_ctrl exynos3250_pin_ctrl[];
+extern const struct samsung_pin_ctrl exynos4210_pin_ctrl[];
+extern const struct samsung_pin_ctrl exynos4x12_pin_ctrl[];
+extern const struct samsung_pin_ctrl exynos4415_pin_ctrl[];
+extern const struct samsung_pin_ctrl exynos5250_pin_ctrl[];
+extern const struct samsung_pin_ctrl exynos5260_pin_ctrl[];
+extern const struct samsung_pin_ctrl exynos5420_pin_ctrl[];
+extern const struct samsung_pin_ctrl exynos7_pin_ctrl[];
+extern const struct samsung_pin_ctrl s3c64xx_pin_ctrl[];
+extern const struct samsung_pin_ctrl s3c2412_pin_ctrl[];
+extern const struct samsung_pin_ctrl s3c2416_pin_ctrl[];
+extern const struct samsung_pin_ctrl s3c2440_pin_ctrl[];
+extern const struct samsung_pin_ctrl s3c2450_pin_ctrl[];
+extern const struct samsung_pin_ctrl s5pv210_pin_ctrl[];
 
 #endif /* __PINCTRL_SAMSUNG_H */
diff --git a/drivers/pinctrl/sunxi/Kconfig b/drivers/pinctrl/sunxi/Kconfig
index a5e10f777ed2..230a952608cb 100644
--- a/drivers/pinctrl/sunxi/Kconfig
+++ b/drivers/pinctrl/sunxi/Kconfig
@@ -39,4 +39,8 @@ config PINCTRL_SUN8I_A23_R
         depends on RESET_CONTROLLER
         select PINCTRL_SUNXI_COMMON
 
+config PINCTRL_SUN9I_A80
+        def_bool MACH_SUN9I
+        select PINCTRL_SUNXI_COMMON
+
 endif
diff --git a/drivers/pinctrl/sunxi/Makefile b/drivers/pinctrl/sunxi/Makefile
index e797efb02901..c7d92e4673b5 100644
--- a/drivers/pinctrl/sunxi/Makefile
+++ b/drivers/pinctrl/sunxi/Makefile
@@ -10,3 +10,4 @@ obj-$(CONFIG_PINCTRL_SUN6I_A31_R)	+= pinctrl-sun6i-a31-r.o
 obj-$(CONFIG_PINCTRL_SUN7I_A20)         += pinctrl-sun7i-a20.o
 obj-$(CONFIG_PINCTRL_SUN8I_A23)         += pinctrl-sun8i-a23.o
 obj-$(CONFIG_PINCTRL_SUN8I_A23_R)       += pinctrl-sun8i-a23-r.o
+obj-$(CONFIG_PINCTRL_SUN9I_A80)         += pinctrl-sun9i-a80.o
diff --git a/drivers/pinctrl/sunxi/pinctrl-sun9i-a80.c b/drivers/pinctrl/sunxi/pinctrl-sun9i-a80.c
new file mode 100644
index 000000000000..adb29422efc9
--- /dev/null
+++ b/drivers/pinctrl/sunxi/pinctrl-sun9i-a80.c
@@ -0,0 +1,749 @@
+/*
+ * Allwinner A80 SoCs pinctrl driver.
+ *
+ * Copyright (C) 2014 Maxime Ripard
+ *
+ * Maxime Ripard <maxime.ripard@free-electrons.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/pinctrl/pinctrl.h>
+
+#include "pinctrl-sunxi.h"
+
+static const struct sunxi_desc_pin sun9i_a80_pins[] = {
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 0),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RXD3 */
+                  SUNXI_FUNCTION(0x4, "uart1"),         /* TX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 0)),  /* PA_EINT0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 1),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RXD2 */
+                  SUNXI_FUNCTION(0x4, "uart1"),         /* RX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 1)),  /* PA_EINT1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 2),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RXD1 */
+                  SUNXI_FUNCTION(0x4, "uart1"),         /* RTS */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 2)),  /* PA_EINT2 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 3),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RXD0 */
+                  SUNXI_FUNCTION(0x4, "uart1"),         /* CTS */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 3)),  /* PA_EINT3 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 4),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RXCK */
+                  SUNXI_FUNCTION(0x4, "uart1"),         /* DTR */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 4)),  /* PA_EINT4 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 5),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RXCTL */
+                  SUNXI_FUNCTION(0x4, "uart1"),         /* DSR */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 5)),  /* PA_EINT5 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 6),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RXERR */
+                  SUNXI_FUNCTION(0x4, "uart1"),         /* DCD */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 6)),  /* PA_EINT6 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 7),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* TXD3 */
+                  SUNXI_FUNCTION(0x4, "uart1"),         /* RING */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 7)),  /* PA_EINT7 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 8),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* TXD2 */
+                  SUNXI_FUNCTION(0x4, "eclk"),          /* IN0 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 8)),  /* PA_EINT8 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 9),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* TXEN */
+                  SUNXI_FUNCTION(0x4, "eclk"),          /* IN1 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 9)),  /* PA_EINT9 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 10),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* TXD0 */
+                  SUNXI_FUNCTION(0x4, "clk_out_a"),
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 10)), /* PA_EINT10 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 11),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* MII-CRS */
+                  SUNXI_FUNCTION(0x4, "clk_out_b"),
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 11)), /* PA_EINT11 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 12),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* TXCK */
+                  SUNXI_FUNCTION(0x4, "pwm3"),          /* PWM_P */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 12)), /* PA_EINT12 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 13),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RGMII-TXCK / GMII-TXEN */
+                  SUNXI_FUNCTION(0x4, "pwm3"),          /* PWM_N */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 13)), /* PA_EINT13 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 14),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* MII-TXERR */
+                  SUNXI_FUNCTION(0x4, "spi1"),          /* CS0 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 14)), /* PA_EINT14 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 15),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* RGMII-CLKIN / MII-COL */
+                  SUNXI_FUNCTION(0x4, "spi1"),          /* CLK */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 15)), /* PA_EINT15 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 16),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* EMDC */
+                  SUNXI_FUNCTION(0x4, "spi1"),          /* MOSI */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 16)), /* PA_EINT16 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 17),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "gmac"),          /* EMDIO */
+                  SUNXI_FUNCTION(0x4, "spi1"),          /* MISO */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 17)), /* PA_EINT17 */
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(B, 5),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "uart3"),         /* TX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 1, 5)),  /* PB_EINT5 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(B, 6),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "uart3"),         /* RX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 1, 6)),  /* PB_EINT6 */
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(B, 14),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "mcsi"),          /* MCLK */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 14)), /* PB_EINT14 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(B, 15),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "mcsi"),          /* SCK */
+                  SUNXI_FUNCTION(0x4, "i2c4"),          /* SCK */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 15)), /* PB_EINT15 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(B, 16),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "mcsi"),          /* SDA */
+                  SUNXI_FUNCTION(0x4, "i2c4"),          /* SDA */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 16)), /* PB_EINT16 */
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 0),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* WE */
+                  SUNXI_FUNCTION(0x3, "spi0")),         /* MOSI */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 1),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* ALE */
+                  SUNXI_FUNCTION(0x3, "spi0")),         /* MISO */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 2),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* CLE */
+                  SUNXI_FUNCTION(0x3, "spi0")),         /* CLK */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 3),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0")),        /* CE1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 4),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0")),        /* CE0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 5),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0")),        /* RE */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 6),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* RB0 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* CMD */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 7),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* RB1 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* CLK */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 8),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQ0 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* D0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 9),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQ1 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* D1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 10),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQ2 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* D2 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 11),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQ3 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* D3 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 12),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQ4 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* D4 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 13),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQ5 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* D5 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 14),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQ6 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* D6 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 15),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQ7 */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* D7 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 16),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* DQS */
+                  SUNXI_FUNCTION(0x3, "mmc2")),         /* RST */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 17),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* CE2 */
+                  SUNXI_FUNCTION(0x3, "nand0_b")),      /* RE */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 18),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "nand0"),         /* CE3 */
+                  SUNXI_FUNCTION(0x3, "nand0_b")),      /* DQS */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(C, 19),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "spi0")),         /* CS0 */
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 0),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D0 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VP0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 1),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D1 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VN0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 2),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D2 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VP1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 3),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D3 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VN1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 4),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D4 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VP2 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 5),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D5 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VN2 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 6),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D6 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VPC */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 7),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D7 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VNC */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 8),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D8 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VP3 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 9),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D9 */
+                  SUNXI_FUNCTION(0x3, "lvds0")),        /* VN3 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 10),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D10 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VP0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 11),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D11 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VN0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 12),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D12 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VP1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 13),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D13 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VN1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 14),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D14 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VP2 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 15),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D15 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VN2 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 16),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D16 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VPC */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 17),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D17 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VNC */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 18),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D18 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VP3 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 19),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0"),          /* D19 */
+                  SUNXI_FUNCTION(0x3, "lvds1")),        /* VN3 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 20),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0")),         /* D20 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 21),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0")),         /* D21 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 22),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0")),         /* D22 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 23),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0")),         /* D23 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 24),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0")),         /* CLK */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 25),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0")),         /* DE */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 26),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0")),         /* HSYNC */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(D, 27),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "lcd0")),         /* VSYNC */
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 0),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* PCLK */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* CLK */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 0)),  /* PE_EINT0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 1),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* MCLK */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* ERR */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 1)),  /* PE_EINT1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 2),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* HSYNC */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* SYNC */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 2)),  /* PE_EINT2 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 3),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* VSYNC */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* DVLD */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 3)),  /* PE_EINT3 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 4),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D0 */
+                  SUNXI_FUNCTION(0x3, "spi2"),          /* CS0 */
+                  SUNXI_FUNCTION(0x4, "uart5"),         /* TX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 4)),  /* PE_EINT4 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 5),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D1 */
+                  SUNXI_FUNCTION(0x3, "spi2"),          /* CLK */
+                  SUNXI_FUNCTION(0x4, "uart5"),         /* RX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 5)),  /* PE_EINT5 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 6),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D2 */
+                  SUNXI_FUNCTION(0x3, "spi2"),          /* MOSI */
+                  SUNXI_FUNCTION(0x4, "uart5"),         /* RTS */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 6)),  /* PE_EINT6 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 7),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D3 */
+                  SUNXI_FUNCTION(0x3, "spi2"),          /* MISO */
+                  SUNXI_FUNCTION(0x4, "uart5"),         /* CTS */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 7)),  /* PE_EINT7 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 8),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D4 */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* D0 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 8)),  /* PE_EINT8 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 9),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D5 */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* D1 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 9)),  /* PE_EINT9 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 10),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D6 */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* D2 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 10)), /* PE_EINT10 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 11),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D7 */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* D3 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 11)), /* PE_EINT11 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 12),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D8 */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* D4 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 12)), /* PE_EINT12 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 13),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D9 */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* D5 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 13)), /* PE_EINT13 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 14),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D10 */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* D6 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 14)), /* PE_EINT14 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 15),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* D11 */
+                  SUNXI_FUNCTION(0x3, "ts"),            /* D7 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 15)), /* PE_EINT15 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 16),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* SCK */
+                  SUNXI_FUNCTION(0x3, "i2c4"),          /* SCK */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 16)), /* PE_EINT16 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(E, 17),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "csi"),           /* SDA */
+                  SUNXI_FUNCTION(0x3, "i2c4"),          /* SDA */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 2, 17)), /* PE_EINT17 */
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(F, 0),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc0")),         /* D1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(F, 1),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc0")),         /* D0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(F, 2),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc0"),          /* CLK */
+                  SUNXI_FUNCTION(0x4, "uart0")),        /* TX */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(F, 3),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc0")),         /* CMD */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(F, 4),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc0"),          /* D3 */
+                  SUNXI_FUNCTION(0x4, "uart0")),        /* RX */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(F, 5),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc0")),         /* D2 */
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 0),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc1"),          /* CLK */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 0)),  /* PG_EINT0 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 1),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc1"),          /* CMD */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 1)),  /* PG_EINT1 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 2),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc1"),          /* D0 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 2)),  /* PG_EINT2 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 3),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc1"),          /* D1 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 3)),  /* PG_EINT3 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 4),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc1"),          /* D2 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 4)),  /* PG_EINT4 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 5),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "mmc1"),          /* D3 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 5)),  /* PG_EINT5 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 6),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart2"),         /* TX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 6)),  /* PG_EINT6 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 7),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart2"),         /* RX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 7)),  /* PG_EINT7 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 8),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart2"),         /* RTS */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 8)),  /* PG_EINT8 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 9),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart2"),         /* CTS */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 9)),  /* PG_EINT9 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 10),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "i2c3"),          /* SCK */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 10)), /* PG_EINT10 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 11),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "i2c3"),          /* SDA */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 11)), /* PG_EINT11 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 12),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart4"),         /* TX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 12)), /* PG_EINT12 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 13),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart4"),         /* RX */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 13)), /* PG_EINT13 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 14),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart4"),         /* RTS */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 14)), /* PG_EINT14 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(G, 15),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart4"),         /* CTS */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 3, 15)), /* PG_EINT15 */
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 0),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "i2c0")),         /* SCK */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 1),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "i2c0")),         /* SDA */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 2),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "i2c1")),         /* SCK */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 3),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "i2c1")),         /* SDA */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 4),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "i2c2")),         /* SCK */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 5),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "i2c2")),         /* SDA */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 6),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "pwm0")),
+
+        /* Hole */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 8),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "pwm1"),          /* Positive */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 8)),  /* PH_EINT8 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 9),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "pwm1"),          /* Negative */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 9)),  /* PH_EINT9 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 10),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "pwm2"),          /* Positive */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 10)), /* PH_EINT10 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 11),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x3, "pwm2"),          /* Negative */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 11)), /* PH_EINT12 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 12),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart0"),         /* TX */
+                  SUNXI_FUNCTION(0x3, "spi3"),          /* CS2 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 12)), /* PH_EINT12 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 13),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "uart0"),         /* RX */
+                  SUNXI_FUNCTION(0x3, "spi3"),          /* CS2 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 13)), /* PH_EINT13 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 14),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "spi3"),          /* CLK */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 14)), /* PH_EINT14 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 15),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "spi3"),          /* MOSI */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 15)), /* PH_EINT15 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 16),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "spi3"),          /* MISO */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 16)), /* PH_EINT16 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 17),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "spi3"),          /* CS0 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 17)), /* PH_EINT17 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 18),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "spi3"),          /* CS1 */
+                  SUNXI_FUNCTION_IRQ_BANK(0x6, 4, 18)), /* PH_EINT18 */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 19),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "hdmi")),         /* SCL */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 20),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "hdmi")),         /* SDA */
+        SUNXI_PIN(SUNXI_PINCTRL_PIN(H, 21),
+                  SUNXI_FUNCTION(0x0, "gpio_in"),
+                  SUNXI_FUNCTION(0x1, "gpio_out"),
+                  SUNXI_FUNCTION(0x2, "hdmi")),         /* CEC */
+};
+
+static const struct sunxi_pinctrl_desc sun9i_a80_pinctrl_data = {
+        .pins = sun9i_a80_pins,
+        .npins = ARRAY_SIZE(sun9i_a80_pins),
+        .irq_banks = 5,
+};
+
+static int sun9i_a80_pinctrl_probe(struct platform_device *pdev)
+{
+        return sunxi_pinctrl_init(pdev,
+                                  &sun9i_a80_pinctrl_data);
+}
+
+static struct of_device_id sun9i_a80_pinctrl_match[] = {
+        { .compatible = "allwinner,sun9i-a80-pinctrl", },
+        {}
+};
+MODULE_DEVICE_TABLE(of, sun9i_a80_pinctrl_match);
+
+static struct platform_driver sun9i_a80_pinctrl_driver = {
+        .probe  = sun9i_a80_pinctrl_probe,
+        .driver = {
+                .name           = "sun9i-a80-pinctrl",
+                .of_match_table = sun9i_a80_pinctrl_match,
+        },
+};
+module_platform_driver(sun9i_a80_pinctrl_driver);
+
+MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
+MODULE_DESCRIPTION("Allwinner A80 pinctrl driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/pinctrl/sunxi/pinctrl-sunxi.h b/drivers/pinctrl/sunxi/pinctrl-sunxi.h
index 4245b96c7996..5a51523a3459 100644
--- a/drivers/pinctrl/sunxi/pinctrl-sunxi.h
+++ b/drivers/pinctrl/sunxi/pinctrl-sunxi.h
@@ -27,6 +27,7 @@
 #define PI_BASE 256
 #define PL_BASE 352
 #define PM_BASE 384
+#define PN_BASE 416
 
 #define SUNXI_PINCTRL_PIN(bank, pin)            \
         PINCTRL_PIN(P ## bank ## _BASE + (pin), "P" #bank #pin)
diff --git a/drivers/power/reset/Kconfig b/drivers/power/reset/Kconfig
index f65ff49bb275..028e76504519 100644
--- a/drivers/power/reset/Kconfig
+++ b/drivers/power/reset/Kconfig
@@ -71,6 +71,15 @@ config POWER_RESET_HISI
         help
           Reboot support for Hisilicon boards.
 
+config POWER_RESET_IMX
+        bool "IMX6 power-off driver"
+        depends on POWER_RESET && SOC_IMX6
+        help
+          This driver support power off external PMIC by PMIC_ON_REQ on i.mx6
+          boards.If you want to use other pin to control external power,please
+          say N here or disable in dts to make sure pm_power_off never be
+          overwrote wrongly by this driver.
+
 config POWER_RESET_MSM
         bool "Qualcomm MSM power-off driver"
         depends on ARCH_QCOM
diff --git a/drivers/power/reset/Makefile b/drivers/power/reset/Makefile
index 76ce1c59469b..1d4804d6b323 100644
--- a/drivers/power/reset/Makefile
+++ b/drivers/power/reset/Makefile
@@ -6,6 +6,7 @@ obj-$(CONFIG_POWER_RESET_BRCMSTB) += brcmstb-reboot.o
 obj-$(CONFIG_POWER_RESET_GPIO) += gpio-poweroff.o
 obj-$(CONFIG_POWER_RESET_GPIO_RESTART) += gpio-restart.o
 obj-$(CONFIG_POWER_RESET_HISI) += hisi-reboot.o
+obj-$(CONFIG_POWER_RESET_IMX) += imx-snvs-poweroff.o
 obj-$(CONFIG_POWER_RESET_MSM) += msm-poweroff.o
 obj-$(CONFIG_POWER_RESET_LTC2952) += ltc2952-poweroff.o
 obj-$(CONFIG_POWER_RESET_QNAP) += qnap-poweroff.o
diff --git a/drivers/power/reset/at91-reset.c b/drivers/power/reset/at91-reset.c
index 3cb36693343a..69a75d99ae92 100644
--- a/drivers/power/reset/at91-reset.c
+++ b/drivers/power/reset/at91-reset.c
@@ -19,8 +19,8 @@
 
 #include <asm/system_misc.h>
 
-#include <mach/at91sam9_ddrsdr.h>
-#include <mach/at91sam9_sdramc.h>
+#include <soc/at91/at91sam9_ddrsdr.h>
+#include <soc/at91/at91sam9_sdramc.h>
 
 #define AT91_RSTC_CR    0x00            /* Reset Controller Control Register */
 #define AT91_RSTC_PROCRST       BIT(0)          /* Processor Reset */
diff --git a/drivers/power/reset/imx-snvs-poweroff.c b/drivers/power/reset/imx-snvs-poweroff.c
new file mode 100644
index 000000000000..ad6ce5020ea7
--- /dev/null
+++ b/drivers/power/reset/imx-snvs-poweroff.c
@@ -0,0 +1,66 @@
+/* Power off driver for i.mx6
+ * Copyright (c) 2014, FREESCALE CORPORATION.  All rights reserved.
+ *
+ * based on msm-poweroff.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/platform_device.h>
+
+static void __iomem *snvs_base;
+
+static void do_imx_poweroff(void)
+{
+        u32 value = readl(snvs_base);
+
+        /* set TOP and DP_EN bit */
+        writel(value | 0x60, snvs_base);
+}
+
+static int imx_poweroff_probe(struct platform_device *pdev)
+{
+        snvs_base = of_iomap(pdev->dev.of_node, 0);
+        if (!snvs_base) {
+                dev_err(&pdev->dev, "failed to get memory\n");
+                return -ENODEV;
+        }
+
+        pm_power_off = do_imx_poweroff;
+        return 0;
+}
+
+static const struct of_device_id of_imx_poweroff_match[] = {
+        { .compatible = "fsl,sec-v4.0-poweroff", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, of_imx_poweroff_match);
+
+static struct platform_driver imx_poweroff_driver = {
+        .probe = imx_poweroff_probe,
+        .driver = {
+                .name = "imx-snvs-poweroff",
+                .of_match_table = of_match_ptr(of_imx_poweroff_match),
+        },
+};
+
+static int __init imx_poweroff_init(void)
+{
+        return platform_driver_register(&imx_poweroff_driver);
+}
+device_initcall(imx_poweroff_init);
diff --git a/drivers/powercap/Kconfig b/drivers/powercap/Kconfig
index a7c81b53d88a..85727ef6ce8e 100644
--- a/drivers/powercap/Kconfig
+++ b/drivers/powercap/Kconfig
@@ -17,7 +17,7 @@ if POWERCAP
 # Client driver configurations go here.
 config INTEL_RAPL
         tristate "Intel RAPL Support"
-        depends on X86
+        depends on X86 && IOSF_MBI
         default n
         ---help---
           This enables support for the Intel Running Average Power Limit (RAPL)
diff --git a/drivers/powercap/intel_rapl.c b/drivers/powercap/intel_rapl.c
index 45e05b32f9b6..c71443c4f265 100644
--- a/drivers/powercap/intel_rapl.c
+++ b/drivers/powercap/intel_rapl.c
@@ -29,6 +29,7 @@
 #include <linux/sysfs.h>
 #include <linux/cpu.h>
 #include <linux/powercap.h>
+#include <asm/iosf_mbi.h>
 
 #include <asm/processor.h>
 #include <asm/cpu_device_id.h>
@@ -70,11 +71,6 @@
 #define RAPL_PRIMITIVE_DERIVED       BIT(1) /* not from raw data */
 #define RAPL_PRIMITIVE_DUMMY         BIT(2)
 
-/* scale RAPL units to avoid floating point math inside kernel */
-#define POWER_UNIT_SCALE     (1000000)
-#define ENERGY_UNIT_SCALE    (1000000)
-#define TIME_UNIT_SCALE      (1000000)
-
 #define TIME_WINDOW_MAX_MSEC 40000
 #define TIME_WINDOW_MIN_MSEC 250
 
@@ -175,9 +171,9 @@ struct rapl_package {
         unsigned int id; /* physical package/socket id */
         unsigned int nr_domains;
         unsigned long domain_map; /* bit map of active domains */
-        unsigned int power_unit_divisor;
-        unsigned int energy_unit_divisor;
-        unsigned int time_unit_divisor;
+        unsigned int power_unit;
+        unsigned int energy_unit;
+        unsigned int time_unit;
         struct rapl_domain *domains; /* array of domains, sized at runtime */
         struct powercap_zone *power_zone; /* keep track of parent zone */
         int nr_cpus; /* active cpus on the package, topology info is lost during
@@ -188,6 +184,18 @@ struct rapl_package {
                                         */
         struct list_head plist;
 };
+
+struct rapl_defaults {
+        int (*check_unit)(struct rapl_package *rp, int cpu);
+        void (*set_floor_freq)(struct rapl_domain *rd, bool mode);
+        u64 (*compute_time_window)(struct rapl_package *rp, u64 val,
+                                bool to_raw);
+};
+static struct rapl_defaults *rapl_defaults;
+
+/* Sideband MBI registers */
+#define IOSF_CPU_POWER_BUDGET_CTL (0x2)
+
 #define PACKAGE_PLN_INT_SAVED   BIT(0)
 #define MAX_PRIM_NAME (32)
 
@@ -339,23 +347,13 @@ static int find_nr_power_limit(struct rapl_domain *rd)
 static int set_domain_enable(struct powercap_zone *power_zone, bool mode)
 {
         struct rapl_domain *rd = power_zone_to_rapl_domain(power_zone);
-        int nr_powerlimit;
 
         if (rd->state & DOMAIN_STATE_BIOS_LOCKED)
                 return -EACCES;
+
         get_online_cpus();
-        nr_powerlimit = find_nr_power_limit(rd);
-        /* here we activate/deactivate the hardware for power limiting */
         rapl_write_data_raw(rd, PL1_ENABLE, mode);
-        /* always enable clamp such that p-state can go below OS requested
-         * range. power capping priority over guranteed frequency.
-         */
-        rapl_write_data_raw(rd, PL1_CLAMP, mode);
-        /* some domains have pl2 */
-        if (nr_powerlimit > 1) {
-                rapl_write_data_raw(rd, PL2_ENABLE, mode);
-                rapl_write_data_raw(rd, PL2_CLAMP, mode);
-        }
+        rapl_defaults->set_floor_freq(rd, mode);
         put_online_cpus();
 
         return 0;
@@ -653,9 +651,7 @@ static void rapl_init_domains(struct rapl_package *rp)
 static u64 rapl_unit_xlate(int package, enum unit_type type, u64 value,
                         int to_raw)
 {
-        u64 divisor = 1;
-        int scale = 1; /* scale to user friendly data without floating point */
-        u64 f, y; /* fraction and exp. used for time unit */
+        u64 units = 1;
         struct rapl_package *rp;
 
         rp = find_package_by_id(package);
@@ -664,42 +660,24 @@ static u64 rapl_unit_xlate(int package, enum unit_type type, u64 value,
 
         switch (type) {
         case POWER_UNIT:
-                divisor = rp->power_unit_divisor;
-                scale = POWER_UNIT_SCALE;
+                units = rp->power_unit;
                 break;
         case ENERGY_UNIT:
-                scale = ENERGY_UNIT_SCALE;
-                divisor = rp->energy_unit_divisor;
+                units = rp->energy_unit;
                 break;
         case TIME_UNIT:
-                divisor = rp->time_unit_divisor;
-                scale = TIME_UNIT_SCALE;
-                /* special processing based on 2^Y*(1+F)/4 = val/divisor, refer
-                 * to Intel Software Developer's manual Vol. 3a, CH 14.7.4.
-                 */
-                if (!to_raw) {
-                        f = (value & 0x60) >> 5;
-                        y = value & 0x1f;
-                        value = (1 << y) * (4 + f) * scale / 4;
-                        return div64_u64(value, divisor);
-                } else {
-                        do_div(value, scale);
-                        value *= divisor;
-                        y = ilog2(value);
-                        f = div64_u64(4 * (value - (1 << y)), 1 << y);
-                        value = (y & 0x1f) | ((f & 0x3) << 5);
-                        return value;
-                }
-                break;
+                return rapl_defaults->compute_time_window(rp, value, to_raw);
         case ARBITRARY_UNIT:
         default:
                 return value;
         };
 
         if (to_raw)
-                return div64_u64(value * divisor, scale);
-        else
-                return div64_u64(value * scale, divisor);
+                return div64_u64(value, units);
+
+        value *= units;
+
+        return value;
 }
 
 /* in the order of enum rapl_primitives */
@@ -833,12 +811,18 @@ static int rapl_write_data_raw(struct rapl_domain *rd,
         return 0;
 }
 
-static const struct x86_cpu_id energy_unit_quirk_ids[] = {
-        { X86_VENDOR_INTEL, 6, 0x37},/* Valleyview */
-        {}
-};
-
-static int rapl_check_unit(struct rapl_package *rp, int cpu)
+/*
+ * Raw RAPL data stored in MSRs are in certain scales. We need to
+ * convert them into standard units based on the units reported in
+ * the RAPL unit MSRs. This is specific to CPUs as the method to
+ * calculate units differ on different CPUs.
+ * We convert the units to below format based on CPUs.
+ * i.e.
+ * energy unit: microJoules : Represented in microJoules by default
+ * power unit : microWatts  : Represented in milliWatts by default
+ * time unit  : microseconds: Represented in seconds by default
+ */
+static int rapl_check_unit_core(struct rapl_package *rp, int cpu)
 {
         u64 msr_val;
         u32 value;
@@ -849,36 +833,47 @@ static int rapl_check_unit(struct rapl_package *rp, int cpu)
                 return -ENODEV;
         }
 
-        /* Raw RAPL data stored in MSRs are in certain scales. We need to
-         * convert them into standard units based on the divisors reported in
-         * the RAPL unit MSRs.
-         * i.e.
-         * energy unit: 1/enery_unit_divisor Joules
-         * power unit: 1/power_unit_divisor Watts
-         * time unit: 1/time_unit_divisor Seconds
-         */
         value = (msr_val & ENERGY_UNIT_MASK) >> ENERGY_UNIT_OFFSET;
-        /* some CPUs have different way to calculate energy unit */
-        if (x86_match_cpu(energy_unit_quirk_ids))
-                rp->energy_unit_divisor = 1000000 / (1 << value);
-        else
-                rp->energy_unit_divisor = 1 << value;
+        rp->energy_unit = 1000000 / (1 << value);
 
         value = (msr_val & POWER_UNIT_MASK) >> POWER_UNIT_OFFSET;
-        rp->power_unit_divisor = 1 << value;
+        rp->power_unit = 1000000 / (1 << value);
 
         value = (msr_val & TIME_UNIT_MASK) >> TIME_UNIT_OFFSET;
-        rp->time_unit_divisor = 1 << value;
+        rp->time_unit = 1000000 / (1 << value);
 
-        pr_debug("Physical package %d units: energy=%d, time=%d, power=%d\n",
-                rp->id,
-                rp->energy_unit_divisor,
-                rp->time_unit_divisor,
-                rp->power_unit_divisor);
+        pr_debug("Core CPU package %d energy=%duJ, time=%dus, power=%duW\n",
+                rp->id, rp->energy_unit, rp->time_unit, rp->power_unit);
 
         return 0;
 }
 
+static int rapl_check_unit_atom(struct rapl_package *rp, int cpu)
+{
+        u64 msr_val;
+        u32 value;
+
+        if (rdmsrl_safe_on_cpu(cpu, MSR_RAPL_POWER_UNIT, &msr_val)) {
+                pr_err("Failed to read power unit MSR 0x%x on CPU %d, exit.\n",
+                        MSR_RAPL_POWER_UNIT, cpu);
+                return -ENODEV;
+        }
+        value = (msr_val & ENERGY_UNIT_MASK) >> ENERGY_UNIT_OFFSET;
+        rp->energy_unit = 1 << value;
+
+        value = (msr_val & POWER_UNIT_MASK) >> POWER_UNIT_OFFSET;
+        rp->power_unit = (1 << value) * 1000;
+
+        value = (msr_val & TIME_UNIT_MASK) >> TIME_UNIT_OFFSET;
+        rp->time_unit = 1000000 / (1 << value);
+
+        pr_debug("Atom package %d energy=%duJ, time=%dus, power=%duW\n",
+                rp->id, rp->energy_unit, rp->time_unit, rp->power_unit);
+
+        return 0;
+}
+
+
 /* REVISIT:
  * When package power limit is set artificially low by RAPL, LVT
  * thermal interrupt for package power limit should be ignored
@@ -946,16 +941,107 @@ static void package_power_limit_irq_restore(int package_id)
         wrmsr_on_cpu(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, l, h);
 }
 
+static void set_floor_freq_default(struct rapl_domain *rd, bool mode)
+{
+        int nr_powerlimit = find_nr_power_limit(rd);
+
+        /* always enable clamp such that p-state can go below OS requested
+         * range. power capping priority over guranteed frequency.
+         */
+        rapl_write_data_raw(rd, PL1_CLAMP, mode);
+
+        /* some domains have pl2 */
+        if (nr_powerlimit > 1) {
+                rapl_write_data_raw(rd, PL2_ENABLE, mode);
+                rapl_write_data_raw(rd, PL2_CLAMP, mode);
+        }
+}
+
+static void set_floor_freq_atom(struct rapl_domain *rd, bool enable)
+{
+        static u32 power_ctrl_orig_val;
+        u32 mdata;
+
+        if (!power_ctrl_orig_val)
+                iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_PMC_READ,
+                        IOSF_CPU_POWER_BUDGET_CTL, &power_ctrl_orig_val);
+        mdata = power_ctrl_orig_val;
+        if (enable) {
+                mdata &= ~(0x7f << 8);
+                mdata |= 1 << 8;
+        }
+        iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_PMC_WRITE,
+                IOSF_CPU_POWER_BUDGET_CTL, mdata);
+}
+
+static u64 rapl_compute_time_window_core(struct rapl_package *rp, u64 value,
+                                        bool to_raw)
+{
+        u64 f, y; /* fraction and exp. used for time unit */
+
+        /*
+         * Special processing based on 2^Y*(1+F/4), refer
+         * to Intel Software Developer's manual Vol.3B: CH 14.9.3.
+         */
+        if (!to_raw) {
+                f = (value & 0x60) >> 5;
+                y = value & 0x1f;
+                value = (1 << y) * (4 + f) * rp->time_unit / 4;
+        } else {
+                do_div(value, rp->time_unit);
+                y = ilog2(value);
+                f = div64_u64(4 * (value - (1 << y)), 1 << y);
+                value = (y & 0x1f) | ((f & 0x3) << 5);
+        }
+        return value;
+}
+
+static u64 rapl_compute_time_window_atom(struct rapl_package *rp, u64 value,
+                                        bool to_raw)
+{
+        /*
+         * Atom time unit encoding is straight forward val * time_unit,
+         * where time_unit is default to 1 sec. Never 0.
+         */
+        if (!to_raw)
+                return (value) ? value *= rp->time_unit : rp->time_unit;
+        else
+                value = div64_u64(value, rp->time_unit);
+
+        return value;
+}
+
+static const struct rapl_defaults rapl_defaults_core = {
+        .check_unit = rapl_check_unit_core,
+        .set_floor_freq = set_floor_freq_default,
+        .compute_time_window = rapl_compute_time_window_core,
+};
+
+static const struct rapl_defaults rapl_defaults_atom = {
+        .check_unit = rapl_check_unit_atom,
+        .set_floor_freq = set_floor_freq_atom,
+        .compute_time_window = rapl_compute_time_window_atom,
+};
+
+#define RAPL_CPU(_model, _ops) {                        \
+                .vendor = X86_VENDOR_INTEL,             \
+                .family = 6,                            \
+                .model = _model,                        \
+                .driver_data = (kernel_ulong_t)&_ops,   \
+                }
+
 static const struct x86_cpu_id rapl_ids[] = {
-        { X86_VENDOR_INTEL, 6, 0x2a},/* Sandy Bridge */
-        { X86_VENDOR_INTEL, 6, 0x2d},/* Sandy Bridge EP */
-        { X86_VENDOR_INTEL, 6, 0x37},/* Valleyview */
-        { X86_VENDOR_INTEL, 6, 0x3a},/* Ivy Bridge */
-        { X86_VENDOR_INTEL, 6, 0x3c},/* Haswell */
-        { X86_VENDOR_INTEL, 6, 0x3d},/* Broadwell */
-        { X86_VENDOR_INTEL, 6, 0x3f},/* Haswell */
-        { X86_VENDOR_INTEL, 6, 0x45},/* Haswell ULT */
-        /* TODO: Add more CPU IDs after testing */
+        RAPL_CPU(0x2a, rapl_defaults_core),/* Sandy Bridge */
+        RAPL_CPU(0x2d, rapl_defaults_core),/* Sandy Bridge EP */
+        RAPL_CPU(0x37, rapl_defaults_atom),/* Valleyview */
+        RAPL_CPU(0x3a, rapl_defaults_core),/* Ivy Bridge */
+        RAPL_CPU(0x3c, rapl_defaults_core),/* Haswell */
+        RAPL_CPU(0x3d, rapl_defaults_core),/* Broadwell */
+        RAPL_CPU(0x3f, rapl_defaults_core),/* Haswell */
+        RAPL_CPU(0x45, rapl_defaults_core),/* Haswell ULT */
+        RAPL_CPU(0x4C, rapl_defaults_atom),/* Braswell */
+        RAPL_CPU(0x4A, rapl_defaults_atom),/* Tangier */
+        RAPL_CPU(0x5A, rapl_defaults_atom),/* Annidale */
         {}
 };
 MODULE_DEVICE_TABLE(x86cpu, rapl_ids);
@@ -1241,7 +1327,7 @@ static int rapl_detect_topology(void)
 
                         /* check if the package contains valid domains */
                         if (rapl_detect_domains(new_package, i) ||
-                                rapl_check_unit(new_package, i)) {
+                                rapl_defaults->check_unit(new_package, i)) {
                                 kfree(new_package->domains);
                                 kfree(new_package);
                                 /* free up the packages already initialized */
@@ -1296,7 +1382,7 @@ static int rapl_add_package(int cpu)
         rp->nr_cpus = 1;
         /* check if the package contains valid domains */
         if (rapl_detect_domains(rp, cpu) ||
-                rapl_check_unit(rp, cpu)) {
+                rapl_defaults->check_unit(rp, cpu)) {
                 ret = -ENODEV;
                 goto err_free_package;
         }
@@ -1358,14 +1444,18 @@ static struct notifier_block rapl_cpu_notifier = {
 static int __init rapl_init(void)
 {
         int ret = 0;
+        const struct x86_cpu_id *id;
 
-        if (!x86_match_cpu(rapl_ids)) {
+        id = x86_match_cpu(rapl_ids);
+        if (!id) {
                 pr_err("driver does not support CPU family %d model %d\n",
                         boot_cpu_data.x86, boot_cpu_data.x86_model);
 
                 return -ENODEV;
         }
 
+        rapl_defaults = (struct rapl_defaults *)id->driver_data;
+
         cpu_notifier_register_begin();
 
         /* prevent CPU hotplug during detection */
diff --git a/drivers/regulator/88pm8607.c b/drivers/regulator/88pm8607.c
index 6d77dcd7dcf6..3fe47bd66153 100644
--- a/drivers/regulator/88pm8607.c
+++ b/drivers/regulator/88pm8607.c
@@ -330,7 +330,8 @@ static int pm8607_regulator_dt_init(struct platform_device *pdev,
         for_each_child_of_node(nproot, np) {
                 if (!of_node_cmp(np->name, info->desc.name)) {
                         config->init_data =
-                                of_get_regulator_init_data(&pdev->dev, np);
+                                of_get_regulator_init_data(&pdev->dev, np,
+                                                           &info->desc);
                         config->of_node = np;
                         break;
                 }
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 55d7b7b0f2e0..c3a60b57a865 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -521,6 +521,14 @@ config REGULATOR_RN5T618
         help
           Say y here to support the regulators found on Ricoh RN5T618 PMIC.
 
+config REGULATOR_RT5033
+        tristate "Richtek RT5033 Regulators"
+        depends on MFD_RT5033
+        help
+          This adds support for voltage and current regulators in Richtek
+          RT5033 PMIC. The device supports multiple regulators like
+          current source, LDO and Buck.
+
 config REGULATOR_S2MPA01
         tristate "Samsung S2MPA01 voltage regulator"
         depends on MFD_SEC_CORE
@@ -529,13 +537,13 @@ config REGULATOR_S2MPA01
          via I2C bus. S2MPA01 has 10 Bucks and 26 LDO outputs.
 
 config REGULATOR_S2MPS11
-        tristate "Samsung S2MPS11/S2MPS14/S2MPU02 voltage regulator"
+        tristate "Samsung S2MPS11/S2MPS13/S2MPS14/S2MPU02 voltage regulator"
         depends on MFD_SEC_CORE
         help
-         This driver supports a Samsung S2MPS11/S2MPS14/S2MPU02 voltage output
-         regulator via I2C bus. The chip is comprised of high efficient Buck
-         converters including Dual-Phase Buck converter, Buck-Boost converter,
-         various LDOs.
+         This driver supports a Samsung S2MPS11/S2MPS13/S2MPS14/S2MPU02 voltage
+         output regulator via I2C bus. The chip is comprised of high efficient
+         Buck converters including Dual-Phase Buck converter, Buck-Boost
+         converter, various LDOs.
 
 config REGULATOR_S5M8767
         tristate "Samsung S5M8767A voltage regulator"
@@ -547,7 +555,7 @@ config REGULATOR_S5M8767
 
 config REGULATOR_SKY81452
         tristate "Skyworks Solutions SKY81452 voltage regulator"
-        depends on SKY81452
+        depends on MFD_SKY81452
         help
           This driver supports Skyworks SKY81452 voltage output regulator
           via I2C bus. SKY81452 has one voltage linear regulator can be
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 1029ed39c512..1f28ebfc6f3a 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -69,6 +69,7 @@ obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o
 obj-$(CONFIG_REGULATOR_RC5T583)  += rc5t583-regulator.o
 obj-$(CONFIG_REGULATOR_RK808)   += rk808-regulator.o
 obj-$(CONFIG_REGULATOR_RN5T618) += rn5t618-regulator.o
+obj-$(CONFIG_REGULATOR_RT5033)  += rt5033-regulator.o
 obj-$(CONFIG_REGULATOR_S2MPA01) += s2mpa01.o
 obj-$(CONFIG_REGULATOR_S2MPS11) += s2mps11.o
 obj-$(CONFIG_REGULATOR_S5M8767) += s5m8767.o
diff --git a/drivers/regulator/act8865-regulator.c b/drivers/regulator/act8865-regulator.c
index afd06f92dfdf..9eec453b745d 100644
--- a/drivers/regulator/act8865-regulator.c
+++ b/drivers/regulator/act8865-regulator.c
@@ -61,6 +61,8 @@
 #define ACT8846_REG12_VSET      0xa0
 #define ACT8846_REG12_CTRL      0xa1
 #define ACT8846_REG13_CTRL      0xb1
+#define ACT8846_GLB_OFF_CTRL    0xc3
+#define ACT8846_OFF_SYSMASK     0x18
 
 /*
  * ACT8865 Global Register Map.
@@ -84,6 +86,7 @@
 #define ACT8865_LDO3_CTRL       0x61
 #define ACT8865_LDO4_VSET       0x64
 #define ACT8865_LDO4_CTRL       0x65
+#define ACT8865_MSTROFF         0x20
 
 /*
  * Field Definitions.
@@ -98,6 +101,8 @@
 
 struct act8865 {
         struct regmap *regmap;
+        int off_reg;
+        int off_mask;
 };
 
 static const struct regmap_config act8865_regmap_config = {
@@ -275,6 +280,16 @@ static struct regulator_init_data
         return NULL;
 }
 
+static struct i2c_client *act8865_i2c_client;
+static void act8865_power_off(void)
+{
+        struct act8865 *act8865;
+
+        act8865 = i2c_get_clientdata(act8865_i2c_client);
+        regmap_write(act8865->regmap, act8865->off_reg, act8865->off_mask);
+        while (1);
+}
+
 static int act8865_pmic_probe(struct i2c_client *client,
                               const struct i2c_device_id *i2c_id)
 {
@@ -285,6 +300,7 @@ static int act8865_pmic_probe(struct i2c_client *client,
         int i, ret, num_regulators;
         struct act8865 *act8865;
         unsigned long type;
+        int off_reg, off_mask;
 
         pdata = dev_get_platdata(dev);
 
@@ -304,10 +320,14 @@ static int act8865_pmic_probe(struct i2c_client *client,
         case ACT8846:
                 regulators = act8846_regulators;
                 num_regulators = ARRAY_SIZE(act8846_regulators);
+                off_reg = ACT8846_GLB_OFF_CTRL;
+                off_mask = ACT8846_OFF_SYSMASK;
                 break;
         case ACT8865:
                 regulators = act8865_regulators;
                 num_regulators = ARRAY_SIZE(act8865_regulators);
+                off_reg = ACT8865_SYS_CTRL;
+                off_mask = ACT8865_MSTROFF;
                 break;
         default:
                 dev_err(dev, "invalid device id %lu\n", type);
@@ -345,6 +365,17 @@ static int act8865_pmic_probe(struct i2c_client *client,
                 return ret;
         }
 
+        if (of_device_is_system_power_controller(dev->of_node)) {
+                if (!pm_power_off) {
+                        act8865_i2c_client = client;
+                        act8865->off_reg = off_reg;
+                        act8865->off_mask = off_mask;
+                        pm_power_off = act8865_power_off;
+                } else {
+                        dev_err(dev, "Failed to set poweroff capability, already defined\n");
+                }
+        }
+
         /* Finally register devices */
         for (i = 0; i < num_regulators; i++) {
                 const struct regulator_desc *desc = &regulators[i];
diff --git a/drivers/regulator/anatop-regulator.c b/drivers/regulator/anatop-regulator.c
index 4f730af70e7c..3586571814b2 100644
--- a/drivers/regulator/anatop-regulator.c
+++ b/drivers/regulator/anatop-regulator.c
@@ -189,17 +189,18 @@ static int anatop_regulator_probe(struct platform_device *pdev)
         int ret = 0;
         u32 val;
 
-        initdata = of_get_regulator_init_data(dev, np);
         sreg = devm_kzalloc(dev, sizeof(*sreg), GFP_KERNEL);
         if (!sreg)
                 return -ENOMEM;
-        sreg->initdata = initdata;
         sreg->name = of_get_property(np, "regulator-name", NULL);
         rdesc = &sreg->rdesc;
         rdesc->name = sreg->name;
         rdesc->type = REGULATOR_VOLTAGE;
         rdesc->owner = THIS_MODULE;
 
+        initdata = of_get_regulator_init_data(dev, np, rdesc);
+        sreg->initdata = initdata;
+
         anatop_np = of_get_parent(np);
         if (!anatop_np)
                 return -ENODEV;
@@ -283,6 +284,19 @@ static int anatop_regulator_probe(struct platform_device *pdev)
                         sreg->sel = 0;
                         sreg->bypass = true;
                 }
+
+                /*
+                 * In case vddpu was disabled by the bootloader, we need to set
+                 * a sane default until imx6-cpufreq was probed and changes the
+                 * voltage to the correct value. In this case we set 1.25V.
+                 */
+                if (!sreg->sel && !strcmp(sreg->name, "vddpu"))
+                        sreg->sel = 22;
+
+                if (!sreg->sel) {
+                        dev_err(&pdev->dev, "Failed to read a valid default voltage selector.\n");
+                        return -EINVAL;
+                }
         } else {
                 rdesc->ops = &anatop_rops;
         }
diff --git a/drivers/regulator/arizona-ldo1.c b/drivers/regulator/arizona-ldo1.c
index 4c9db589f6c1..d071b2119a60 100644
--- a/drivers/regulator/arizona-ldo1.c
+++ b/drivers/regulator/arizona-ldo1.c
@@ -179,7 +179,8 @@ static const struct regulator_init_data arizona_ldo1_default = {
 };
 
 static int arizona_ldo1_of_get_pdata(struct arizona *arizona,
-                                     struct regulator_config *config)
+                                     struct regulator_config *config,
+                                     const struct regulator_desc *desc)
 {
         struct arizona_pdata *pdata = &arizona->pdata;
         struct arizona_ldo1 *ldo1 = config->driver_data;
@@ -194,7 +195,8 @@ static int arizona_ldo1_of_get_pdata(struct arizona *arizona,
         if (init_node) {
                 config->of_node = init_node;
 
-                init_data = of_get_regulator_init_data(arizona->dev, init_node);
+                init_data = of_get_regulator_init_data(arizona->dev, init_node,
+                                                       desc);
 
                 if (init_data) {
                         init_data->consumer_supplies = &ldo1->supply;
@@ -257,9 +259,11 @@ static int arizona_ldo1_probe(struct platform_device *pdev)
 
         if (IS_ENABLED(CONFIG_OF)) {
                 if (!dev_get_platdata(arizona->dev)) {
-                        ret = arizona_ldo1_of_get_pdata(arizona, &config);
+                        ret = arizona_ldo1_of_get_pdata(arizona, &config, desc);
                         if (ret < 0)
                                 return ret;
+
+                        config.ena_gpio_initialized = true;
                 }
         }
 
diff --git a/drivers/regulator/arizona-micsupp.c b/drivers/regulator/arizona-micsupp.c
index ce9aca5f8ee7..c313ef4c3a2f 100644
--- a/drivers/regulator/arizona-micsupp.c
+++ b/drivers/regulator/arizona-micsupp.c
@@ -198,7 +198,8 @@ static const struct regulator_init_data arizona_micsupp_ext_default = {
 };
 
 static int arizona_micsupp_of_get_pdata(struct arizona *arizona,
-                                        struct regulator_config *config)
+                                        struct regulator_config *config,
+                                        const struct regulator_desc *desc)
 {
         struct arizona_pdata *pdata = &arizona->pdata;
         struct arizona_micsupp *micsupp = config->driver_data;
@@ -210,7 +211,7 @@ static int arizona_micsupp_of_get_pdata(struct arizona *arizona,
         if (np) {
                 config->of_node = np;
 
-                init_data = of_get_regulator_init_data(arizona->dev, np);
+                init_data = of_get_regulator_init_data(arizona->dev, np, desc);
 
                 if (init_data) {
                         init_data->consumer_supplies = &micsupp->supply;
@@ -264,7 +265,8 @@ static int arizona_micsupp_probe(struct platform_device *pdev)
 
         if (IS_ENABLED(CONFIG_OF)) {
                 if (!dev_get_platdata(arizona->dev)) {
-                        ret = arizona_micsupp_of_get_pdata(arizona, &config);
+                        ret = arizona_micsupp_of_get_pdata(arizona, &config,
+                                                           desc);
                         if (ret < 0)
                                 return ret;
                 }
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index cd87c0c37034..e225711bb8bc 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -828,7 +828,7 @@ static void print_constraints(struct regulator_dev *rdev)
         if (!count)
                 sprintf(buf, "no parameters");
 
-        rdev_info(rdev, "%s\n", buf);
+        rdev_dbg(rdev, "%s\n", buf);
 
         if ((constraints->min_uV != constraints->max_uV) &&
             !(constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE))
@@ -1713,6 +1713,8 @@ static void regulator_ena_gpio_free(struct regulator_dev *rdev)
                                 gpiod_put(pin->gpiod);
                                 list_del(&pin->list);
                                 kfree(pin);
+                                rdev->ena_pin = NULL;
+                                return;
                         } else {
                                 pin->request_count--;
                         }
@@ -1976,9 +1978,18 @@ static int _regulator_disable(struct regulator_dev *rdev)
 
                 /* we are last user */
                 if (_regulator_can_change_status(rdev)) {
+                        ret = _notifier_call_chain(rdev,
+                                                   REGULATOR_EVENT_PRE_DISABLE,
+                                                   NULL);
+                        if (ret & NOTIFY_STOP_MASK)
+                                return -EINVAL;
+
                         ret = _regulator_do_disable(rdev);
                         if (ret < 0) {
                                 rdev_err(rdev, "failed to disable\n");
+                                _notifier_call_chain(rdev,
+                                                REGULATOR_EVENT_ABORT_DISABLE,
+                                                NULL);
                                 return ret;
                         }
                         _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
@@ -2035,9 +2046,16 @@ static int _regulator_force_disable(struct regulator_dev *rdev)
 {
         int ret = 0;
 
+        ret = _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
+                        REGULATOR_EVENT_PRE_DISABLE, NULL);
+        if (ret & NOTIFY_STOP_MASK)
+                return -EINVAL;
+
         ret = _regulator_do_disable(rdev);
         if (ret < 0) {
                 rdev_err(rdev, "failed to force disable\n");
+                _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
+                                REGULATOR_EVENT_ABORT_DISABLE, NULL);
                 return ret;
         }
 
@@ -3650,7 +3668,8 @@ regulator_register(const struct regulator_desc *regulator_desc,
 
         dev_set_drvdata(&rdev->dev, rdev);
 
-        if (config->ena_gpio && gpio_is_valid(config->ena_gpio)) {
+        if ((config->ena_gpio || config->ena_gpio_initialized) &&
+            gpio_is_valid(config->ena_gpio)) {
                 ret = regulator_ena_gpio_request(rdev, config);
                 if (ret != 0) {
                         rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
diff --git a/drivers/regulator/da9052-regulator.c b/drivers/regulator/da9052-regulator.c
index 00033625a09c..3945f1006d23 100644
--- a/drivers/regulator/da9052-regulator.c
+++ b/drivers/regulator/da9052-regulator.c
@@ -436,7 +436,8 @@ static int da9052_regulator_probe(struct platform_device *pdev)
                         if (!of_node_cmp(np->name,
                                          regulator->info->reg_desc.name)) {
                                 config.init_data = of_get_regulator_init_data(
-                                        &pdev->dev, np);
+                                        &pdev->dev, np,
+                                        &regulator->info->reg_desc);
                                 config.of_node = np;
                                 break;
                         }
diff --git a/drivers/regulator/da9063-regulator.c b/drivers/regulator/da9063-regulator.c
index 7c9461d13313..37dd42759ca9 100644
--- a/drivers/regulator/da9063-regulator.c
+++ b/drivers/regulator/da9063-regulator.c
@@ -867,17 +867,14 @@ static int da9063_regulator_probe(struct platform_device *pdev)
                 return irq;
         }
 
-        regulators->irq_ldo_lim = regmap_irq_get_virq(da9063->regmap_irq, irq);
-        if (regulators->irq_ldo_lim >= 0) {
-                ret = request_threaded_irq(regulators->irq_ldo_lim,
-                                           NULL, da9063_ldo_lim_event,
-                                           IRQF_TRIGGER_LOW | IRQF_ONESHOT,
-                                           "LDO_LIM", regulators);
-                if (ret) {
-                        dev_err(&pdev->dev,
-                                        "Failed to request LDO_LIM IRQ.\n");
-                        regulators->irq_ldo_lim = -ENXIO;
-                }
+        ret = request_threaded_irq(irq,
+                                NULL, da9063_ldo_lim_event,
+                                IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                "LDO_LIM", regulators);
+        if (ret) {
+                dev_err(&pdev->dev,
+                                "Failed to request LDO_LIM IRQ.\n");
+                regulators->irq_ldo_lim = -ENXIO;
         }
 
         return 0;
diff --git a/drivers/regulator/da9210-regulator.c b/drivers/regulator/da9210-regulator.c
index 7a320dd11c46..bc6100103f7f 100644
--- a/drivers/regulator/da9210-regulator.c
+++ b/drivers/regulator/da9210-regulator.c
@@ -147,7 +147,7 @@ static int da9210_i2c_probe(struct i2c_client *i2c,
 
         config.dev = &i2c->dev;
         config.init_data = pdata ? &pdata->da9210_constraints :
-                of_get_regulator_init_data(dev, dev->of_node);
+                of_get_regulator_init_data(dev, dev->of_node, &da9210_reg);
         config.driver_data = chip;
         config.regmap = chip->regmap;
         config.of_node = dev->of_node;
diff --git a/drivers/regulator/dummy.c b/drivers/regulator/dummy.c
index 2436db9e2ca3..7aef9e4c6fbf 100644
--- a/drivers/regulator/dummy.c
+++ b/drivers/regulator/dummy.c
@@ -33,7 +33,7 @@ static struct regulator_init_data dummy_initdata = {
 
 static struct regulator_ops dummy_ops;
 
-static struct regulator_desc dummy_desc = {
+static const struct regulator_desc dummy_desc = {
         .name = "regulator-dummy",
         .id = -1,
         .type = REGULATOR_VOLTAGE,
diff --git a/drivers/regulator/fan53555.c b/drivers/regulator/fan53555.c
index f8e4257aef92..6c43ab2d5121 100644
--- a/drivers/regulator/fan53555.c
+++ b/drivers/regulator/fan53555.c
@@ -302,7 +302,8 @@ static struct regmap_config fan53555_regmap_config = {
 };
 
 static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
-                                                        struct device_node *np)
+                                              struct device_node *np,
+                                              const struct regulator_desc *desc)
 {
         struct fan53555_platform_data *pdata;
         int ret;
@@ -312,7 +313,7 @@ static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
         if (!pdata)
                 return NULL;
 
-        pdata->regulator = of_get_regulator_init_data(dev, np);
+        pdata->regulator = of_get_regulator_init_data(dev, np, desc);
 
         ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",
                                    &tmp);
@@ -347,20 +348,20 @@ static int fan53555_regulator_probe(struct i2c_client *client,
         unsigned int val;
         int ret;
 
+        di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
+                                        GFP_KERNEL);
+        if (!di)
+                return -ENOMEM;
+
         pdata = dev_get_platdata(&client->dev);
         if (!pdata)
-                pdata = fan53555_parse_dt(&client->dev, np);
+                pdata = fan53555_parse_dt(&client->dev, np, &di->desc);
 
         if (!pdata || !pdata->regulator) {
                 dev_err(&client->dev, "Platform data not found!\n");
                 return -ENODEV;
         }
 
-        di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
-                                        GFP_KERNEL);
-        if (!di)
-                return -ENOMEM;
-
         di->regulator = pdata->regulator;
         if (client->dev.of_node) {
                 const struct of_device_id *match;
diff --git a/drivers/regulator/fixed.c b/drivers/regulator/fixed.c
index 354105eff1f8..d21da27c0eb6 100644
--- a/drivers/regulator/fixed.c
+++ b/drivers/regulator/fixed.c
@@ -40,13 +40,15 @@ struct fixed_voltage_data {
 /**
  * of_get_fixed_voltage_config - extract fixed_voltage_config structure info
  * @dev: device requesting for fixed_voltage_config
+ * @desc: regulator description
  *
  * Populates fixed_voltage_config structure by extracting data from device
  * tree node, returns a pointer to the populated structure of NULL if memory
  * alloc fails.
  */
 static struct fixed_voltage_config *
-of_get_fixed_voltage_config(struct device *dev)
+of_get_fixed_voltage_config(struct device *dev,
+                            const struct regulator_desc *desc)
 {
         struct fixed_voltage_config *config;
         struct device_node *np = dev->of_node;
@@ -57,7 +59,7 @@ of_get_fixed_voltage_config(struct device *dev)
         if (!config)
                 return ERR_PTR(-ENOMEM);
 
-        config->init_data = of_get_regulator_init_data(dev, dev->of_node);
+        config->init_data = of_get_regulator_init_data(dev, dev->of_node, desc);
         if (!config->init_data)
                 return ERR_PTR(-EINVAL);
 
@@ -112,8 +114,14 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
         struct regulator_config cfg = { };
         int ret;
 
+        drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data),
+                               GFP_KERNEL);
+        if (!drvdata)
+                return -ENOMEM;
+
         if (pdev->dev.of_node) {
-                config = of_get_fixed_voltage_config(&pdev->dev);
+                config = of_get_fixed_voltage_config(&pdev->dev,
+                                                     &drvdata->desc);
                 if (IS_ERR(config))
                         return PTR_ERR(config);
         } else {
@@ -123,11 +131,6 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
         if (!config)
                 return -ENOMEM;
 
-        drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data),
-                               GFP_KERNEL);
-        if (!drvdata)
-                return -ENOMEM;
-
         drvdata->desc.name = devm_kstrdup(&pdev->dev,
                                           config->supply_name,
                                           GFP_KERNEL);
@@ -157,8 +160,11 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
 
         drvdata->desc.fixed_uV = config->microvolts;
 
-        if (config->gpio >= 0)
+        if (gpio_is_valid(config->gpio)) {
                 cfg.ena_gpio = config->gpio;
+                if (pdev->dev.of_node)
+                        cfg.ena_gpio_initialized = true;
+        }
         cfg.ena_gpio_invert = !config->enable_high;
         if (config->enabled_at_boot) {
                 if (config->enable_high)
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index 989b23b377c0..c888a9a9482c 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -133,7 +133,8 @@ static struct regulator_ops gpio_regulator_voltage_ops = {
 };
 
 static struct gpio_regulator_config *
-of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
+of_get_gpio_regulator_config(struct device *dev, struct device_node *np,
+                             const struct regulator_desc *desc)
 {
         struct gpio_regulator_config *config;
         const char *regtype;
@@ -146,7 +147,7 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
         if (!config)
                 return ERR_PTR(-ENOMEM);
 
-        config->init_data = of_get_regulator_init_data(dev, np);
+        config->init_data = of_get_regulator_init_data(dev, np, desc);
         if (!config->init_data)
                 return ERR_PTR(-EINVAL);
 
@@ -162,34 +163,41 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
 
         config->enable_gpio = of_get_named_gpio(np, "enable-gpio", 0);
 
-        /* Fetch GPIOs. */
-        config->nr_gpios = of_gpio_count(np);
-
-        config->gpios = devm_kzalloc(dev,
-                                sizeof(struct gpio) * config->nr_gpios,
-                                GFP_KERNEL);
-        if (!config->gpios)
-                return ERR_PTR(-ENOMEM);
-
-        proplen = of_property_count_u32_elems(np, "gpios-states");
-        /* optional property */
-        if (proplen < 0)
-                proplen = 0;
-
-        if (proplen > 0 && proplen != config->nr_gpios) {
-                dev_warn(dev, "gpios <-> gpios-states mismatch\n");
-                proplen = 0;
-        }
+        /* Fetch GPIOs. - optional property*/
+        ret = of_gpio_count(np);
+        if ((ret < 0) && (ret != -ENOENT))
+                return ERR_PTR(ret);
+
+        if (ret > 0) {
+                config->nr_gpios = ret;
+                config->gpios = devm_kzalloc(dev,
+                                        sizeof(struct gpio) * config->nr_gpios,
+                                        GFP_KERNEL);
+                if (!config->gpios)
+                        return ERR_PTR(-ENOMEM);
+
+                proplen = of_property_count_u32_elems(np, "gpios-states");
+                /* optional property */
+                if (proplen < 0)
+                        proplen = 0;
+
+                if (proplen > 0 && proplen != config->nr_gpios) {
+                        dev_warn(dev, "gpios <-> gpios-states mismatch\n");
+                        proplen = 0;
+                }
 
-        for (i = 0; i < config->nr_gpios; i++) {
-                gpio = of_get_named_gpio(np, "gpios", i);
-                if (gpio < 0)
-                        break;
-                config->gpios[i].gpio = gpio;
-                if (proplen > 0) {
-                        of_property_read_u32_index(np, "gpios-states", i, &ret);
-                        if (ret)
-                                config->gpios[i].flags = GPIOF_OUT_INIT_HIGH;
+                for (i = 0; i < config->nr_gpios; i++) {
+                        gpio = of_get_named_gpio(np, "gpios", i);
+                        if (gpio < 0)
+                                break;
+                        config->gpios[i].gpio = gpio;
+                        if (proplen > 0) {
+                                of_property_read_u32_index(np, "gpios-states",
+                                                           i, &ret);
+                                if (ret)
+                                        config->gpios[i].flags =
+                                                           GPIOF_OUT_INIT_HIGH;
+                        }
                 }
         }
 
@@ -243,17 +251,18 @@ static int gpio_regulator_probe(struct platform_device *pdev)
         struct regulator_config cfg = { };
         int ptr, ret, state;
 
-        if (np) {
-                config = of_get_gpio_regulator_config(&pdev->dev, np);
-                if (IS_ERR(config))
-                        return PTR_ERR(config);
-        }
-
         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct gpio_regulator_data),
                                GFP_KERNEL);
         if (drvdata == NULL)
                 return -ENOMEM;
 
+        if (np) {
+                config = of_get_gpio_regulator_config(&pdev->dev, np,
+                                                      &drvdata->desc);
+                if (IS_ERR(config))
+                        return PTR_ERR(config);
+        }
+
         drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL);
         if (drvdata->desc.name == NULL) {
                 dev_err(&pdev->dev, "Failed to allocate supply name\n");
@@ -261,13 +270,23 @@ static int gpio_regulator_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        drvdata->gpios = kmemdup(config->gpios,
-                                 config->nr_gpios * sizeof(struct gpio),
-                                 GFP_KERNEL);
-        if (drvdata->gpios == NULL) {
-                dev_err(&pdev->dev, "Failed to allocate gpio data\n");
-                ret = -ENOMEM;
-                goto err_name;
+        if (config->nr_gpios != 0) {
+                drvdata->gpios = kmemdup(config->gpios,
+                                         config->nr_gpios * sizeof(struct gpio),
+                                         GFP_KERNEL);
+                if (drvdata->gpios == NULL) {
+                        dev_err(&pdev->dev, "Failed to allocate gpio data\n");
+                        ret = -ENOMEM;
+                        goto err_name;
+                }
+
+                drvdata->nr_gpios = config->nr_gpios;
+                ret = gpio_request_array(drvdata->gpios, drvdata->nr_gpios);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                        "Could not obtain regulator setting GPIOs: %d\n", ret);
+                        goto err_memstate;
+                }
         }
 
         drvdata->states = kmemdup(config->states,
@@ -301,14 +320,6 @@ static int gpio_regulator_probe(struct platform_device *pdev)
                 goto err_memgpio;
         }
 
-        drvdata->nr_gpios = config->nr_gpios;
-        ret = gpio_request_array(drvdata->gpios, drvdata->nr_gpios);
-        if (ret) {
-                dev_err(&pdev->dev,
-                   "Could not obtain regulator setting GPIOs: %d\n", ret);
-                goto err_memstate;
-        }
-
         /* build initial state from gpio init data. */
         state = 0;
         for (ptr = 0; ptr < drvdata->nr_gpios; ptr++) {
@@ -322,8 +333,10 @@ static int gpio_regulator_probe(struct platform_device *pdev)
         cfg.driver_data = drvdata;
         cfg.of_node = np;
 
-        if (config->enable_gpio >= 0)
+        if (gpio_is_valid(config->enable_gpio)) {
                 cfg.ena_gpio = config->enable_gpio;
+                cfg.ena_gpio_initialized = true;
+        }
         cfg.ena_gpio_invert = !config->enable_high;
         if (config->enabled_at_boot) {
                 if (config->enable_high)
diff --git a/drivers/regulator/max77686.c b/drivers/regulator/max77686.c
index f69320e1738f..871b96bcd2d0 100644
--- a/drivers/regulator/max77686.c
+++ b/drivers/regulator/max77686.c
@@ -45,6 +45,23 @@
 #define MAX77686_DVS_MINUV      600000
 #define MAX77686_DVS_UVSTEP     12500
 
+/*
+ * Values used for configuring LDOs and bucks.
+ * Forcing low power mode: LDO1, 3-5, 9, 13, 17-26
+ */
+#define MAX77686_LDO_LOWPOWER           0x1
+/*
+ * On/off controlled by PWRREQ:
+ *  - LDO2, 6-8, 10-12, 14-16
+ *  - buck[1234]
+ */
+#define MAX77686_OFF_PWRREQ             0x1
+/* Low power mode controlled by PWRREQ: All LDOs */
+#define MAX77686_LDO_LOWPOWER_PWRREQ    0x2
+/* Forcing low power mode: buck[234] */
+#define MAX77686_BUCK_LOWPOWER          0x2
+#define MAX77686_NORMAL                 0x3
+
 #define MAX77686_OPMODE_SHIFT   6
 #define MAX77686_OPMODE_BUCK234_SHIFT   4
 #define MAX77686_OPMODE_MASK    0x3
@@ -65,23 +82,36 @@ enum max77686_ramp_rate {
 };
 
 struct max77686_data {
+        /* Array indexed by regulator id */
         unsigned int opmode[MAX77686_REGULATORS];
 };
 
-/* Some BUCKS supports Normal[ON/OFF] mode during suspend */
-static int max77686_buck_set_suspend_disable(struct regulator_dev *rdev)
+static unsigned int max77686_get_opmode_shift(int id)
 {
-        unsigned int val;
+        switch (id) {
+        case MAX77686_BUCK1:
+        case MAX77686_BUCK5 ... MAX77686_BUCK9:
+                return 0;
+        case MAX77686_BUCK2 ... MAX77686_BUCK4:
+                return MAX77686_OPMODE_BUCK234_SHIFT;
+        default:
+                /* all LDOs */
+                return MAX77686_OPMODE_SHIFT;
+        }
+}
+
+/* Some BUCKs and LDOs supports Normal[ON/OFF] mode during suspend */
+static int max77686_set_suspend_disable(struct regulator_dev *rdev)
+{
+        unsigned int val, shift;
         struct max77686_data *max77686 = rdev_get_drvdata(rdev);
         int ret, id = rdev_get_id(rdev);
 
-        if (id == MAX77686_BUCK1)
-                val = 0x1;
-        else
-                val = 0x1 << MAX77686_OPMODE_BUCK234_SHIFT;
+        shift = max77686_get_opmode_shift(id);
+        val = MAX77686_OFF_PWRREQ;
 
         ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
-                                 rdev->desc->enable_mask, val);
+                                 rdev->desc->enable_mask, val << shift);
         if (ret)
                 return ret;
 
@@ -103,10 +133,10 @@ static int max77686_set_suspend_mode(struct regulator_dev *rdev,
 
         switch (mode) {
         case REGULATOR_MODE_IDLE:                       /* ON in LP Mode */
-                val = 0x2 << MAX77686_OPMODE_SHIFT;
+                val = MAX77686_LDO_LOWPOWER_PWRREQ;
                 break;
         case REGULATOR_MODE_NORMAL:                     /* ON in Normal Mode */
-                val = 0x3 << MAX77686_OPMODE_SHIFT;
+                val = MAX77686_NORMAL;
                 break;
         default:
                 pr_warn("%s: regulator_suspend_mode : 0x%x not supported\n",
@@ -115,7 +145,8 @@ static int max77686_set_suspend_mode(struct regulator_dev *rdev,
         }
 
         ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
-                                  rdev->desc->enable_mask, val);
+                                  rdev->desc->enable_mask,
+                                  val << MAX77686_OPMODE_SHIFT);
         if (ret)
                 return ret;
 
@@ -133,13 +164,13 @@ static int max77686_ldo_set_suspend_mode(struct regulator_dev *rdev,
 
         switch (mode) {
         case REGULATOR_MODE_STANDBY:                    /* switch off */
-                val = 0x1 << MAX77686_OPMODE_SHIFT;
+                val = MAX77686_OFF_PWRREQ;
                 break;
         case REGULATOR_MODE_IDLE:                       /* ON in LP Mode */
-                val = 0x2 << MAX77686_OPMODE_SHIFT;
+                val = MAX77686_LDO_LOWPOWER_PWRREQ;
                 break;
         case REGULATOR_MODE_NORMAL:                     /* ON in Normal Mode */
-                val = 0x3 << MAX77686_OPMODE_SHIFT;
+                val = MAX77686_NORMAL;
                 break;
         default:
                 pr_warn("%s: regulator_suspend_mode : 0x%x not supported\n",
@@ -148,7 +179,8 @@ static int max77686_ldo_set_suspend_mode(struct regulator_dev *rdev,
         }
 
         ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
-                                 rdev->desc->enable_mask, val);
+                                 rdev->desc->enable_mask,
+                                 val << MAX77686_OPMODE_SHIFT);
         if (ret)
                 return ret;
 
@@ -159,10 +191,17 @@ static int max77686_ldo_set_suspend_mode(struct regulator_dev *rdev,
 static int max77686_enable(struct regulator_dev *rdev)
 {
         struct max77686_data *max77686 = rdev_get_drvdata(rdev);
+        unsigned int shift;
+        int id = rdev_get_id(rdev);
+
+        shift = max77686_get_opmode_shift(id);
+
+        if (max77686->opmode[id] == MAX77686_OFF_PWRREQ)
+                max77686->opmode[id] = MAX77686_NORMAL;
 
         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
                                   rdev->desc->enable_mask,
-                                  max77686->opmode[rdev_get_id(rdev)]);
+                                  max77686->opmode[id] << shift);
 }
 
 static int max77686_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
@@ -212,6 +251,7 @@ static struct regulator_ops max77686_ldo_ops = {
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
         .set_suspend_mode       = max77686_ldo_set_suspend_mode,
+        .set_suspend_disable    = max77686_set_suspend_disable,
 };
 
 static struct regulator_ops max77686_buck1_ops = {
@@ -223,7 +263,7 @@ static struct regulator_ops max77686_buck1_ops = {
         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
-        .set_suspend_disable    = max77686_buck_set_suspend_disable,
+        .set_suspend_disable    = max77686_set_suspend_disable,
 };
 
 static struct regulator_ops max77686_buck_dvs_ops = {
@@ -236,11 +276,13 @@ static struct regulator_ops max77686_buck_dvs_ops = {
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
         .set_ramp_delay         = max77686_set_ramp_delay,
-        .set_suspend_disable    = max77686_buck_set_suspend_disable,
+        .set_suspend_disable    = max77686_set_suspend_disable,
 };
 
 #define regulator_desc_ldo(num)         {                               \
         .name           = "LDO"#num,                                    \
+        .of_match       = of_match_ptr("LDO"#num),                      \
+        .regulators_node        = of_match_ptr("voltage-regulators"),   \
         .id             = MAX77686_LDO##num,                            \
         .ops            = &max77686_ops,                                \
         .type           = REGULATOR_VOLTAGE,                            \
@@ -257,6 +299,8 @@ static struct regulator_ops max77686_buck_dvs_ops = {
 }
 #define regulator_desc_lpm_ldo(num)     {                               \
         .name           = "LDO"#num,                                    \
+        .of_match       = of_match_ptr("LDO"#num),                      \
+        .regulators_node        = of_match_ptr("voltage-regulators"),   \
         .id             = MAX77686_LDO##num,                            \
         .ops            = &max77686_ldo_ops,                            \
         .type           = REGULATOR_VOLTAGE,                            \
@@ -273,6 +317,8 @@ static struct regulator_ops max77686_buck_dvs_ops = {
 }
 #define regulator_desc_ldo_low(num)             {                       \
         .name           = "LDO"#num,                                    \
+        .of_match       = of_match_ptr("LDO"#num),                      \
+        .regulators_node        = of_match_ptr("voltage-regulators"),   \
         .id             = MAX77686_LDO##num,                            \
         .ops            = &max77686_ldo_ops,                            \
         .type           = REGULATOR_VOLTAGE,                            \
@@ -289,6 +335,8 @@ static struct regulator_ops max77686_buck_dvs_ops = {
 }
 #define regulator_desc_ldo1_low(num)            {                       \
         .name           = "LDO"#num,                                    \
+        .of_match       = of_match_ptr("LDO"#num),                      \
+        .regulators_node        = of_match_ptr("voltage-regulators"),   \
         .id             = MAX77686_LDO##num,                            \
         .ops            = &max77686_ops,                                \
         .type           = REGULATOR_VOLTAGE,                            \
@@ -305,6 +353,8 @@ static struct regulator_ops max77686_buck_dvs_ops = {
 }
 #define regulator_desc_buck(num)                {                       \
         .name           = "BUCK"#num,                                   \
+        .of_match       = of_match_ptr("BUCK"#num),                     \
+        .regulators_node        = of_match_ptr("voltage-regulators"),   \
         .id             = MAX77686_BUCK##num,                           \
         .ops            = &max77686_ops,                                \
         .type           = REGULATOR_VOLTAGE,                            \
@@ -320,6 +370,8 @@ static struct regulator_ops max77686_buck_dvs_ops = {
 }
 #define regulator_desc_buck1(num)               {                       \
         .name           = "BUCK"#num,                                   \
+        .of_match       = of_match_ptr("BUCK"#num),                     \
+        .regulators_node        = of_match_ptr("voltage-regulators"),   \
         .id             = MAX77686_BUCK##num,                           \
         .ops            = &max77686_buck1_ops,                          \
         .type           = REGULATOR_VOLTAGE,                            \
@@ -335,6 +387,8 @@ static struct regulator_ops max77686_buck_dvs_ops = {
 }
 #define regulator_desc_buck_dvs(num)            {                       \
         .name           = "BUCK"#num,                                   \
+        .of_match       = of_match_ptr("BUCK"#num),                     \
+        .regulators_node        = of_match_ptr("voltage-regulators"),   \
         .id             = MAX77686_BUCK##num,                           \
         .ops            = &max77686_buck_dvs_ops,                       \
         .type           = REGULATOR_VOLTAGE,                            \
@@ -350,7 +404,7 @@ static struct regulator_ops max77686_buck_dvs_ops = {
                         << MAX77686_OPMODE_BUCK234_SHIFT,               \
 }
 
-static struct regulator_desc regulators[] = {
+static const struct regulator_desc regulators[] = {
         regulator_desc_ldo1_low(1),
         regulator_desc_ldo_low(2),
         regulator_desc_ldo(3),
@@ -388,103 +442,37 @@ static struct regulator_desc regulators[] = {
         regulator_desc_buck(9),
 };
 
-#ifdef CONFIG_OF
-static int max77686_pmic_dt_parse_pdata(struct platform_device *pdev,
-                                        struct max77686_platform_data *pdata)
-{
-        struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
-        struct device_node *pmic_np, *regulators_np;
-        struct max77686_regulator_data *rdata;
-        struct of_regulator_match rmatch = { };
-        unsigned int i;
-
-        pmic_np = iodev->dev->of_node;
-        regulators_np = of_get_child_by_name(pmic_np, "voltage-regulators");
-        if (!regulators_np) {
-                dev_err(&pdev->dev, "could not find regulators sub-node\n");
-                return -EINVAL;
-        }
-
-        pdata->num_regulators = ARRAY_SIZE(regulators);
-        rdata = devm_kzalloc(&pdev->dev, sizeof(*rdata) *
-                             pdata->num_regulators, GFP_KERNEL);
-        if (!rdata) {
-                of_node_put(regulators_np);
-                return -ENOMEM;
-        }
-
-        for (i = 0; i < pdata->num_regulators; i++) {
-                rmatch.name = regulators[i].name;
-                rmatch.init_data = NULL;
-                rmatch.of_node = NULL;
-                of_regulator_match(&pdev->dev, regulators_np, &rmatch, 1);
-                rdata[i].initdata = rmatch.init_data;
-                rdata[i].of_node = rmatch.of_node;
-        }
-
-        pdata->regulators = rdata;
-        of_node_put(regulators_np);
-
-        return 0;
-}
-#else
-static int max77686_pmic_dt_parse_pdata(struct platform_device *pdev,
-                                        struct max77686_platform_data *pdata)
-{
-        return 0;
-}
-#endif /* CONFIG_OF */
-
 static int max77686_pmic_probe(struct platform_device *pdev)
 {
         struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
-        struct max77686_platform_data *pdata = dev_get_platdata(iodev->dev);
         struct max77686_data *max77686;
-        int i, ret = 0;
+        int i;
         struct regulator_config config = { };
 
         dev_dbg(&pdev->dev, "%s\n", __func__);
 
-        if (!pdata) {
-                dev_err(&pdev->dev, "no platform data found for regulator\n");
-                return -ENODEV;
-        }
-
-        if (iodev->dev->of_node) {
-                ret = max77686_pmic_dt_parse_pdata(pdev, pdata);
-                if (ret)
-                        return ret;
-        }
-
-        if (pdata->num_regulators != MAX77686_REGULATORS) {
-                dev_err(&pdev->dev,
-                        "Invalid initial data for regulator's initialiation\n");
-                return -EINVAL;
-        }
-
         max77686 = devm_kzalloc(&pdev->dev, sizeof(struct max77686_data),
                                 GFP_KERNEL);
         if (!max77686)
                 return -ENOMEM;
 
-        config.dev = &pdev->dev;
+        config.dev = iodev->dev;
         config.regmap = iodev->regmap;
         config.driver_data = max77686;
         platform_set_drvdata(pdev, max77686);
 
         for (i = 0; i < MAX77686_REGULATORS; i++) {
                 struct regulator_dev *rdev;
+                int id = regulators[i].id;
 
-                config.init_data = pdata->regulators[i].initdata;
-                config.of_node = pdata->regulators[i].of_node;
-
-                max77686->opmode[i] = regulators[i].enable_mask;
+                max77686->opmode[id] = MAX77686_NORMAL;
                 rdev = devm_regulator_register(&pdev->dev,
                                                 &regulators[i], &config);
                 if (IS_ERR(rdev)) {
+                        int ret = PTR_ERR(rdev);
                         dev_err(&pdev->dev,
-                                "regulator init failed for %d\n", i);
-                        return PTR_ERR(rdev);
+                                "regulator init failed for %d: %d\n", i, ret);
+                        return ret;
                 }
         }
 
diff --git a/drivers/regulator/max77693.c b/drivers/regulator/max77693.c
index d158f71fa128..7b9755a6c3b5 100644
--- a/drivers/regulator/max77693.c
+++ b/drivers/regulator/max77693.c
@@ -139,7 +139,7 @@ static struct regulator_ops max77693_charger_ops = {
         .enable_mask    = SAFEOUT_CTRL_ENSAFEOUT##_num##_MASK , \
 }
 
-static struct regulator_desc regulators[] = {
+static const struct regulator_desc regulators[] = {
         regulator_desc_esafeout(1),
         regulator_desc_esafeout(2),
         {
diff --git a/drivers/regulator/max77802.c b/drivers/regulator/max77802.c
index 45fa240fe243..0766615c60bc 100644
--- a/drivers/regulator/max77802.c
+++ b/drivers/regulator/max77802.c
@@ -33,6 +33,7 @@
 #include <linux/regulator/of_regulator.h>
 #include <linux/mfd/max77686.h>
 #include <linux/mfd/max77686-private.h>
+#include <dt-bindings/regulator/maxim,max77802.h>
 
 /* Default ramp delay in case it is not manually set */
 #define MAX77802_RAMP_DELAY             100000          /* uV/us */
@@ -49,6 +50,10 @@
 #define MAX77802_RAMP_RATE_MASK_4BIT    0xF0
 #define MAX77802_RAMP_RATE_SHIFT_4BIT   4
 
+#define MAX77802_STATUS_OFF             0x0
+#define MAX77802_OFF_PWRREQ             0x1
+#define MAX77802_LP_PWRREQ              0x2
+
 /* MAX77802 has two register formats: 2-bit and 4-bit */
 static const unsigned int ramp_table_77802_2bit[] = {
         12500,
@@ -65,9 +70,16 @@ static unsigned int ramp_table_77802_4bit[] = {
 };
 
 struct max77802_regulator_prv {
+        /* Array indexed by regulator id */
         unsigned int opmode[MAX77802_REG_MAX];
 };
 
+static inline unsigned int max77802_map_mode(unsigned int mode)
+{
+        return mode == MAX77802_OPMODE_NORMAL ?
+                REGULATOR_MODE_NORMAL : REGULATOR_MODE_STANDBY;
+}
+
 static int max77802_get_opmode_shift(int id)
 {
         if (id == MAX77802_BUCK1 || (id >= MAX77802_BUCK5 &&
@@ -83,17 +95,16 @@ static int max77802_get_opmode_shift(int id)
         return -EINVAL;
 }
 
-/*
- * Some BUCKS supports Normal[ON/OFF] mode during suspend
+/**
+ * max77802_set_suspend_disable - Disable the regulator during system suspend
+ * @rdev: regulator to mark as disabled
  *
- * BUCK 1, 6, 2-4, 5, 7-10 (all)
- *
- * The other mode (0x02) will make PWRREQ switch between normal
- * and low power.
+ * All regulators expect LDO 1, 3, 20 and 21 support OFF by PWRREQ.
+ * Configure the regulator so the PMIC will turn it OFF during system suspend.
  */
-static int max77802_buck_set_suspend_disable(struct regulator_dev *rdev)
+static int max77802_set_suspend_disable(struct regulator_dev *rdev)
 {
-        unsigned int val = MAX77802_OPMODE_STANDBY;
+        unsigned int val = MAX77802_OFF_PWRREQ;
         struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
         int id = rdev_get_id(rdev);
         int shift = max77802_get_opmode_shift(id);
@@ -104,14 +115,11 @@ static int max77802_buck_set_suspend_disable(struct regulator_dev *rdev)
 }
 
 /*
- * Some LDOs supports LPM-ON/OFF/Normal-ON mode during suspend state
- * (Enable Control Logic1 by PWRREQ)
- *
- * LDOs 2, 4-19, 22-35.
+ * Some LDOs support Low Power Mode while the system is running.
  *
+ * LDOs 1, 3, 20, 21.
  */
-static int max77802_ldo_set_suspend_mode_logic1(struct regulator_dev *rdev,
-                                                unsigned int mode)
+static int max77802_set_mode(struct regulator_dev *rdev, unsigned int mode)
 {
         struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
         int id = rdev_get_id(rdev);
@@ -119,14 +127,11 @@ static int max77802_ldo_set_suspend_mode_logic1(struct regulator_dev *rdev,
         int shift = max77802_get_opmode_shift(id);
 
         switch (mode) {
-        case REGULATOR_MODE_IDLE:                       /* ON in LP Mode */
-                val = MAX77802_OPMODE_LP;
+        case REGULATOR_MODE_STANDBY:
+                val = MAX77802_OPMODE_LP;       /* ON in Low Power Mode */
                 break;
-        case REGULATOR_MODE_NORMAL:                     /* ON in Normal Mode */
-                val = MAX77802_OPMODE_NORMAL;
-                break;
-        case REGULATOR_MODE_STANDBY:                    /* ON/OFF by PWRREQ */
-                val = MAX77802_OPMODE_STANDBY;
+        case REGULATOR_MODE_NORMAL:
+                val = MAX77802_OPMODE_NORMAL;   /* ON in Normal Mode */
                 break;
         default:
                 dev_warn(&rdev->dev, "%s: regulator mode: 0x%x not supported\n",
@@ -139,35 +144,76 @@ static int max77802_ldo_set_suspend_mode_logic1(struct regulator_dev *rdev,
                                   rdev->desc->enable_mask, val << shift);
 }
 
-/*
- * Mode 1 (Output[ON/OFF] by PWRREQ) is not supported on some LDOs
- * (Enable Control Logic2 by PWRREQ)
+static unsigned max77802_get_mode(struct regulator_dev *rdev)
+{
+        struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
+        int id = rdev_get_id(rdev);
+
+        return max77802_map_mode(max77802->opmode[id]);
+}
+
+/**
+ * max77802_set_suspend_mode - set regulator opmode when the system is suspended
+ * @rdev: regulator to change mode
+ * @mode: operating mode to be set
  *
- * LDOs 1, 20, 21, and 3,
+ * Will set the operating mode for the regulators during system suspend.
+ * This function is valid for the three different enable control logics:
  *
+ * Enable Control Logic1 by PWRREQ (BUCK 2-4 and LDOs 2, 4-19, 22-35)
+ * Enable Control Logic2 by PWRREQ (LDOs 1, 20, 21)
+ * Enable Control Logic3 by PWRREQ (LDO 3)
+ *
+ * If setting the regulator mode fails, the function only warns but does
+ * not return an error code to avoid the regulator core to stop setting
+ * the operating mode for the remaining regulators.
  */
-static int max77802_ldo_set_suspend_mode_logic2(struct regulator_dev *rdev,
-                                                unsigned int mode)
+static int max77802_set_suspend_mode(struct regulator_dev *rdev,
+                                     unsigned int mode)
 {
         struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
         int id = rdev_get_id(rdev);
         unsigned int val;
         int shift = max77802_get_opmode_shift(id);
 
+        /*
+         * If the regulator has been disabled for suspend
+         * then is invalid to try setting a suspend mode.
+         */
+        if (max77802->opmode[id] == MAX77802_OFF_PWRREQ) {
+                dev_warn(&rdev->dev, "%s: is disabled, mode: 0x%x not set\n",
+                         rdev->desc->name, mode);
+                return 0;
+        }
+
         switch (mode) {
-        case REGULATOR_MODE_IDLE:                       /* ON in LP Mode */
-                val = MAX77802_OPMODE_LP;
-                break;
-        case REGULATOR_MODE_NORMAL:                     /* ON in Normal Mode */
-                val = MAX77802_OPMODE_NORMAL;
+        case REGULATOR_MODE_STANDBY:
+                /*
+                 * If the regulator opmode is normal then enable
+                 * ON in Low Power Mode by PWRREQ. If the mode is
+                 * already Low Power then no action is required.
+                 */
+                if (max77802->opmode[id] == MAX77802_OPMODE_NORMAL)
+                        val = MAX77802_LP_PWRREQ;
+                else
+                        return 0;
                 break;
+        case REGULATOR_MODE_NORMAL:
+                /*
+                 * If the regulator operating mode is Low Power then
+                 * normal is not a valid opmode in suspend. If the
+                 * mode is already normal then no action is required.
+                 */
+                if (max77802->opmode[id] == MAX77802_OPMODE_LP)
+                        dev_warn(&rdev->dev, "%s: in Low Power: 0x%x invalid\n",
+                                 rdev->desc->name, mode);
+                return 0;
         default:
                 dev_warn(&rdev->dev, "%s: regulator mode: 0x%x not supported\n",
                          rdev->desc->name, mode);
                 return -EINVAL;
         }
 
-        max77802->opmode[id] = val;
         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
                                   rdev->desc->enable_mask, val << shift);
 }
@@ -178,6 +224,9 @@ static int max77802_enable(struct regulator_dev *rdev)
         int id = rdev_get_id(rdev);
         int shift = max77802_get_opmode_shift(id);
 
+        if (max77802->opmode[id] == MAX77802_OFF_PWRREQ)
+                max77802->opmode[id] = MAX77802_OPMODE_NORMAL;
+
         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
                                   rdev->desc->enable_mask,
                                   max77802->opmode[id] << shift);
@@ -247,7 +296,8 @@ static struct regulator_ops max77802_ldo_ops_logic1 = {
         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
-        .set_suspend_mode       = max77802_ldo_set_suspend_mode_logic1,
+        .set_suspend_disable    = max77802_set_suspend_disable,
+        .set_suspend_mode       = max77802_set_suspend_mode,
 };
 
 /*
@@ -262,7 +312,9 @@ static struct regulator_ops max77802_ldo_ops_logic2 = {
         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
-        .set_suspend_mode       = max77802_ldo_set_suspend_mode_logic2,
+        .set_mode               = max77802_set_mode,
+        .get_mode               = max77802_get_mode,
+        .set_suspend_mode       = max77802_set_suspend_mode,
 };
 
 /* BUCKS 1, 6 */
@@ -276,10 +328,25 @@ static struct regulator_ops max77802_buck_16_dvs_ops = {
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
         .set_ramp_delay         = max77802_set_ramp_delay_4bit,
-        .set_suspend_disable    = max77802_buck_set_suspend_disable,
+        .set_suspend_disable    = max77802_set_suspend_disable,
 };
 
-/* BUCKs 2-4, 5, 7-10 */
+/* BUCKs 2-4 */
+static struct regulator_ops max77802_buck_234_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = max77802_enable,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+        .set_ramp_delay         = max77802_set_ramp_delay_2bit,
+        .set_suspend_disable    = max77802_set_suspend_disable,
+        .set_suspend_mode       = max77802_set_suspend_mode,
+};
+
+/* BUCKs 5, 7-10 */
 static struct regulator_ops max77802_buck_dvs_ops = {
         .list_voltage           = regulator_list_voltage_linear,
         .map_voltage            = regulator_map_voltage_linear,
@@ -290,12 +357,14 @@ static struct regulator_ops max77802_buck_dvs_ops = {
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
         .set_ramp_delay         = max77802_set_ramp_delay_2bit,
-        .set_suspend_disable    = max77802_buck_set_suspend_disable,
+        .set_suspend_disable    = max77802_set_suspend_disable,
 };
 
 /* LDOs 3-7, 9-14, 18-26, 28, 29, 32-34 */
 #define regulator_77802_desc_p_ldo(num, supply, log)    {               \
         .name           = "LDO"#num,                                    \
+        .of_match       = of_match_ptr("LDO"#num),                      \
+        .regulators_node        = of_match_ptr("regulators"),           \
         .id             = MAX77802_LDO##num,                            \
         .supply_name    = "inl"#supply,                                 \
         .ops            = &max77802_ldo_ops_logic##log,                 \
@@ -309,11 +378,14 @@ static struct regulator_ops max77802_buck_dvs_ops = {
         .vsel_mask      = MAX77802_VSEL_MASK,                           \
         .enable_reg     = MAX77802_REG_LDO1CTRL1 + num - 1,             \
         .enable_mask    = MAX77802_OPMODE_MASK << MAX77802_OPMODE_SHIFT_LDO, \
+        .of_map_mode    = max77802_map_mode,                            \
 }
 
 /* LDOs 1, 2, 8, 15, 17, 27, 30, 35 */
 #define regulator_77802_desc_n_ldo(num, supply, log)   {                \
         .name           = "LDO"#num,                                    \
+        .of_match       = of_match_ptr("LDO"#num),                      \
+        .regulators_node        = of_match_ptr("regulators"),           \
         .id             = MAX77802_LDO##num,                            \
         .supply_name    = "inl"#supply,                                 \
         .ops            = &max77802_ldo_ops_logic##log,                 \
@@ -327,11 +399,14 @@ static struct regulator_ops max77802_buck_dvs_ops = {
         .vsel_mask      = MAX77802_VSEL_MASK,                           \
         .enable_reg     = MAX77802_REG_LDO1CTRL1 + num - 1,             \
         .enable_mask    = MAX77802_OPMODE_MASK << MAX77802_OPMODE_SHIFT_LDO, \
+        .of_map_mode    = max77802_map_mode,                            \
 }
 
 /* BUCKs 1, 6 */
 #define regulator_77802_desc_16_buck(num)       {               \
         .name           = "BUCK"#num,                                   \
+        .of_match       = of_match_ptr("BUCK"#num),                     \
+        .regulators_node        = of_match_ptr("regulators"),           \
         .id             = MAX77802_BUCK##num,                           \
         .supply_name    = "inb"#num,                                    \
         .ops            = &max77802_buck_16_dvs_ops,                    \
@@ -345,14 +420,17 @@ static struct regulator_ops max77802_buck_dvs_ops = {
         .vsel_mask      = MAX77802_DVS_VSEL_MASK,                       \
         .enable_reg     = MAX77802_REG_BUCK ## num ## CTRL,             \
         .enable_mask    = MAX77802_OPMODE_MASK,                         \
+        .of_map_mode    = max77802_map_mode,                            \
 }
 
 /* BUCKS 2-4 */
 #define regulator_77802_desc_234_buck(num)      {               \
         .name           = "BUCK"#num,                                   \
+        .of_match       = of_match_ptr("BUCK"#num),                     \
+        .regulators_node        = of_match_ptr("regulators"),           \
         .id             = MAX77802_BUCK##num,                           \
         .supply_name    = "inb"#num,                                    \
-        .ops            = &max77802_buck_dvs_ops,                       \
+        .ops            = &max77802_buck_234_ops,                       \
         .type           = REGULATOR_VOLTAGE,                            \
         .owner          = THIS_MODULE,                                  \
         .min_uV         = 600000,                                       \
@@ -364,11 +442,14 @@ static struct regulator_ops max77802_buck_dvs_ops = {
         .enable_reg     = MAX77802_REG_BUCK ## num ## CTRL1,            \
         .enable_mask    = MAX77802_OPMODE_MASK <<                       \
                                 MAX77802_OPMODE_BUCK234_SHIFT,          \
+        .of_map_mode    = max77802_map_mode,                            \
 }
 
 /* BUCK 5 */
 #define regulator_77802_desc_buck5(num)         {               \
         .name           = "BUCK"#num,                                   \
+        .of_match       = of_match_ptr("BUCK"#num),                     \
+        .regulators_node        = of_match_ptr("regulators"),           \
         .id             = MAX77802_BUCK##num,                           \
         .supply_name    = "inb"#num,                                    \
         .ops            = &max77802_buck_dvs_ops,                       \
@@ -382,11 +463,14 @@ static struct regulator_ops max77802_buck_dvs_ops = {
         .vsel_mask      = MAX77802_VSEL_MASK,                           \
         .enable_reg     = MAX77802_REG_BUCK5CTRL,                       \
         .enable_mask    = MAX77802_OPMODE_MASK,                         \
+        .of_map_mode    = max77802_map_mode,                            \
 }
 
 /* BUCKs 7-10 */
 #define regulator_77802_desc_buck7_10(num)      {               \
         .name           = "BUCK"#num,                                   \
+        .of_match       = of_match_ptr("BUCK"#num),                     \
+        .regulators_node        = of_match_ptr("regulators"),           \
         .id             = MAX77802_BUCK##num,                           \
         .supply_name    = "inb"#num,                                    \
         .ops            = &max77802_buck_dvs_ops,                       \
@@ -400,9 +484,10 @@ static struct regulator_ops max77802_buck_dvs_ops = {
         .vsel_mask      = MAX77802_VSEL_MASK,                           \
         .enable_reg     = MAX77802_REG_BUCK7CTRL + (num - 7) * 3,       \
         .enable_mask    = MAX77802_OPMODE_MASK,                         \
+        .of_map_mode    = max77802_map_mode,                            \
 }
 
-static struct regulator_desc regulators[] = {
+static const struct regulator_desc regulators[] = {
         regulator_77802_desc_16_buck(1),
         regulator_77802_desc_234_buck(2),
         regulator_77802_desc_234_buck(3),
@@ -447,85 +532,19 @@ static struct regulator_desc regulators[] = {
         regulator_77802_desc_n_ldo(35, 2, 1),
 };
 
-#ifdef CONFIG_OF
-static int max77802_pmic_dt_parse_pdata(struct platform_device *pdev,
-                                        struct max77686_platform_data *pdata)
-{
-        struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
-        struct device_node *pmic_np, *regulators_np;
-        struct max77686_regulator_data *rdata;
-        struct of_regulator_match rmatch = { };
-        unsigned int i;
-
-        pmic_np = iodev->dev->of_node;
-        regulators_np = of_get_child_by_name(pmic_np, "regulators");
-        if (!regulators_np) {
-                dev_err(&pdev->dev, "could not find regulators sub-node\n");
-                return -EINVAL;
-        }
-
-        pdata->num_regulators = ARRAY_SIZE(regulators);
-        rdata = devm_kzalloc(&pdev->dev, sizeof(*rdata) *
-                             pdata->num_regulators, GFP_KERNEL);
-        if (!rdata) {
-                of_node_put(regulators_np);
-                return -ENOMEM;
-        }
-
-        for (i = 0; i < pdata->num_regulators; i++) {
-                rmatch.name = regulators[i].name;
-                rmatch.init_data = NULL;
-                rmatch.of_node = NULL;
-                if (of_regulator_match(&pdev->dev, regulators_np, &rmatch,
-                                       1) != 1) {
-                        dev_warn(&pdev->dev, "No matching regulator for '%s'\n",
-                                 rmatch.name);
-                        continue;
-                }
-                rdata[i].initdata = rmatch.init_data;
-                rdata[i].of_node = rmatch.of_node;
-                rdata[i].id = regulators[i].id;
-        }
-
-        pdata->regulators = rdata;
-        of_node_put(regulators_np);
-
-        return 0;
-}
-#else
-static int max77802_pmic_dt_parse_pdata(struct platform_device *pdev,
-                                        struct max77686_platform_data *pdata)
-{
-        return 0;
-}
-#endif /* CONFIG_OF */
-
 static int max77802_pmic_probe(struct platform_device *pdev)
 {
         struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
-        struct max77686_platform_data *pdata = dev_get_platdata(iodev->dev);
         struct max77802_regulator_prv *max77802;
-        int i, ret = 0, val;
+        int i, val;
         struct regulator_config config = { };
 
-        /* This is allocated by the MFD driver */
-        if (!pdata) {
-                dev_err(&pdev->dev, "no platform data found for regulator\n");
-                return -ENODEV;
-        }
-
         max77802 = devm_kzalloc(&pdev->dev,
                                 sizeof(struct max77802_regulator_prv),
                                 GFP_KERNEL);
         if (!max77802)
                 return -ENOMEM;
 
-        if (iodev->dev->of_node) {
-                ret = max77802_pmic_dt_parse_pdata(pdev, pdata);
-                if (ret)
-                        return ret;
-        }
-
         config.dev = iodev->dev;
         config.regmap = iodev->regmap;
         config.driver_data = max77802;
@@ -533,21 +552,25 @@ static int max77802_pmic_probe(struct platform_device *pdev)
 
         for (i = 0; i < MAX77802_REG_MAX; i++) {
                 struct regulator_dev *rdev;
-                int id = pdata->regulators[i].id;
+                int id = regulators[i].id;
                 int shift = max77802_get_opmode_shift(id);
-
-                config.init_data = pdata->regulators[i].initdata;
-                config.of_node = pdata->regulators[i].of_node;
+                int ret;
 
                 ret = regmap_read(iodev->regmap, regulators[i].enable_reg, &val);
-                val = val >> shift & MAX77802_OPMODE_MASK;
+                if (ret < 0) {
+                        dev_warn(&pdev->dev,
+                                "cannot read current mode for %d\n", i);
+                        val = MAX77802_OPMODE_NORMAL;
+                } else {
+                        val = val >> shift & MAX77802_OPMODE_MASK;
+                }
 
                 /*
                  * If the regulator is disabled and the system warm rebooted,
                  * the hardware reports OFF as the regulator operating mode.
                  * Default to operating mode NORMAL in that case.
                  */
-                if (val == MAX77802_OPMODE_OFF)
+                if (val == MAX77802_STATUS_OFF)
                         max77802->opmode[id] = MAX77802_OPMODE_NORMAL;
                 else
                         max77802->opmode[id] = val;
@@ -555,9 +578,10 @@ static int max77802_pmic_probe(struct platform_device *pdev)
                 rdev = devm_regulator_register(&pdev->dev,
                                                &regulators[i], &config);
                 if (IS_ERR(rdev)) {
+                        ret = PTR_ERR(rdev);
                         dev_err(&pdev->dev,
-                                "regulator init failed for %d\n", i);
-                        return PTR_ERR(rdev);
+                                "regulator init failed for %d: %d\n", i, ret);
+                        return ret;
                 }
         }
 
diff --git a/drivers/regulator/max8952.c b/drivers/regulator/max8952.c
index f7f9efcfedb7..1af8f4a2ab86 100644
--- a/drivers/regulator/max8952.c
+++ b/drivers/regulator/max8952.c
@@ -174,7 +174,7 @@ static struct max8952_platform_data *max8952_parse_dt(struct device *dev)
         if (of_property_read_u32(np, "max8952,ramp-speed", &pd->ramp_speed))
                 dev_warn(dev, "max8952,ramp-speed property not specified, defaulting to 32mV/us\n");
 
-        pd->reg_data = of_get_regulator_init_data(dev, np);
+        pd->reg_data = of_get_regulator_init_data(dev, np, &regulator);
         if (!pd->reg_data) {
                 dev_err(dev, "Failed to parse regulator init data\n");
                 return NULL;
@@ -225,6 +225,8 @@ static int max8952_pmic_probe(struct i2c_client *client,
         config.of_node = client->dev.of_node;
 
         config.ena_gpio = pdata->gpio_en;
+        if (client->dev.of_node)
+                config.ena_gpio_initialized = true;
         if (pdata->reg_data->constraints.boot_on)
                 config.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
 
diff --git a/drivers/regulator/max8973-regulator.c b/drivers/regulator/max8973-regulator.c
index dbedf1768db0..c3d55c2db593 100644
--- a/drivers/regulator/max8973-regulator.c
+++ b/drivers/regulator/max8973-regulator.c
@@ -458,7 +458,8 @@ static int max8973_probe(struct i2c_client *client,
 
         config.dev = &client->dev;
         config.init_data = pdata ? pdata->reg_init_data :
-                of_get_regulator_init_data(&client->dev, client->dev.of_node);
+                of_get_regulator_init_data(&client->dev, client->dev.of_node,
+                                           &max->desc);
         config.driver_data = max;
         config.of_node = client->dev.of_node;
         config.regmap = max->regmap;
diff --git a/drivers/regulator/max8997.c b/drivers/regulator/max8997.c
index 9c31e215a521..726fde1d883e 100644
--- a/drivers/regulator/max8997.c
+++ b/drivers/regulator/max8997.c
@@ -953,7 +953,8 @@ static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev,
 
                 rdata->id = i;
                 rdata->initdata = of_get_regulator_init_data(&pdev->dev,
-                                                             reg_np);
+                                                             reg_np,
+                                                             &regulators[i]);
                 rdata->reg_node = reg_np;
                 rdata++;
         }
diff --git a/drivers/regulator/max8998.c b/drivers/regulator/max8998.c
index 961091b46557..59e34a05a4a2 100644
--- a/drivers/regulator/max8998.c
+++ b/drivers/regulator/max8998.c
@@ -686,8 +686,9 @@ static int max8998_pmic_dt_parse_pdata(struct max8998_dev *iodev,
                         continue;
 
                 rdata->id = regulators[i].id;
-                rdata->initdata = of_get_regulator_init_data(
-                                                        iodev->dev, reg_np);
+                rdata->initdata = of_get_regulator_init_data(iodev->dev,
+                                                             reg_np,
+                                                             &regulators[i]);
                 rdata->reg_node = reg_np;
                 ++rdata;
         }
diff --git a/drivers/regulator/mc13xxx-regulator-core.c b/drivers/regulator/mc13xxx-regulator-core.c
index afba024953e1..0281c31ae2ed 100644
--- a/drivers/regulator/mc13xxx-regulator-core.c
+++ b/drivers/regulator/mc13xxx-regulator-core.c
@@ -194,7 +194,8 @@ struct mc13xxx_regulator_init_data *mc13xxx_parse_regulators_dt(
                                          regulators[i].desc.name)) {
                                 p->id = i;
                                 p->init_data = of_get_regulator_init_data(
-                                                        &pdev->dev, child);
+                                                        &pdev->dev, child,
+                                                        &regulators[i].desc);
                                 p->node = child;
                                 p++;
 
diff --git a/drivers/regulator/of_regulator.c b/drivers/regulator/of_regulator.c
index 5a1d4afa4776..91eaaf010524 100644
--- a/drivers/regulator/of_regulator.c
+++ b/drivers/regulator/of_regulator.c
@@ -19,12 +19,20 @@
 
 #include "internal.h"
 
+static const char *const regulator_states[PM_SUSPEND_MAX + 1] = {
+        [PM_SUSPEND_MEM]        = "regulator-state-mem",
+        [PM_SUSPEND_MAX]        = "regulator-state-disk",
+};
+
 static void of_get_regulation_constraints(struct device_node *np,
-                                        struct regulator_init_data **init_data)
+                                        struct regulator_init_data **init_data,
+                                        const struct regulator_desc *desc)
 {
         const __be32 *min_uV, *max_uV;
         struct regulation_constraints *constraints = &(*init_data)->constraints;
-        int ret;
+        struct regulator_state *suspend_state;
+        struct device_node *suspend_np;
+        int ret, i;
         u32 pval;
 
         constraints->name = of_get_property(np, "regulator-name", NULL);
@@ -73,18 +81,84 @@ static void of_get_regulation_constraints(struct device_node *np,
         ret = of_property_read_u32(np, "regulator-enable-ramp-delay", &pval);
         if (!ret)
                 constraints->enable_time = pval;
+
+        if (!of_property_read_u32(np, "regulator-initial-mode", &pval)) {
+                if (desc && desc->of_map_mode) {
+                        ret = desc->of_map_mode(pval);
+                        if (ret == -EINVAL)
+                                pr_err("%s: invalid mode %u\n", np->name, pval);
+                        else
+                                constraints->initial_mode = ret;
+                } else {
+                        pr_warn("%s: mapping for mode %d not defined\n",
+                                np->name, pval);
+                }
+        }
+
+        for (i = 0; i < ARRAY_SIZE(regulator_states); i++) {
+                switch (i) {
+                case PM_SUSPEND_MEM:
+                        suspend_state = &constraints->state_mem;
+                        break;
+                case PM_SUSPEND_MAX:
+                        suspend_state = &constraints->state_disk;
+                        break;
+                case PM_SUSPEND_ON:
+                case PM_SUSPEND_FREEZE:
+                case PM_SUSPEND_STANDBY:
+                default:
+                        continue;
+                };
+
+                suspend_np = of_get_child_by_name(np, regulator_states[i]);
+                if (!suspend_np || !suspend_state)
+                        continue;
+
+                if (!of_property_read_u32(suspend_np, "regulator-mode",
+                                          &pval)) {
+                        if (desc && desc->of_map_mode) {
+                                ret = desc->of_map_mode(pval);
+                                if (ret == -EINVAL)
+                                        pr_err("%s: invalid mode %u\n",
+                                               np->name, pval);
+                                else
+                                        suspend_state->mode = ret;
+                        } else {
+                                pr_warn("%s: mapping for mode %d not defined\n",
+                                        np->name, pval);
+                        }
+                }
+
+                if (of_property_read_bool(suspend_np,
+                                        "regulator-on-in-suspend"))
+                        suspend_state->enabled = true;
+                else if (of_property_read_bool(suspend_np,
+                                        "regulator-off-in-suspend"))
+                        suspend_state->disabled = true;
+
+                if (!of_property_read_u32(suspend_np,
+                                        "regulator-suspend-microvolt", &pval))
+                        suspend_state->uV = pval;
+
+                of_node_put(suspend_np);
+                suspend_state = NULL;
+                suspend_np = NULL;
+        }
 }
 
 /**
  * of_get_regulator_init_data - extract regulator_init_data structure info
  * @dev: device requesting for regulator_init_data
+ * @node: regulator device node
+ * @desc: regulator description
  *
  * Populates regulator_init_data structure by extracting data from device
  * tree node, returns a pointer to the populated struture or NULL if memory
  * alloc fails.
  */
 struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
-                                                struct device_node *node)
+                                          struct device_node *node,
+                                          const struct regulator_desc *desc)
 {
         struct regulator_init_data *init_data;
 
@@ -95,7 +169,7 @@ struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
         if (!init_data)
                 return NULL; /* Out of memory? */
 
-        of_get_regulation_constraints(node, &init_data);
+        of_get_regulation_constraints(node, &init_data, desc);
         return init_data;
 }
 EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
@@ -176,7 +250,8 @@ int of_regulator_match(struct device *dev, struct device_node *node,
                                 continue;
 
                         match->init_data =
-                                of_get_regulator_init_data(dev, child);
+                                of_get_regulator_init_data(dev, child,
+                                                           match->desc);
                         if (!match->init_data) {
                                 dev_err(dev,
                                         "failed to parse DT for regulator %s\n",
@@ -224,7 +299,7 @@ struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
                 if (strcmp(desc->of_match, name))
                         continue;
 
-                init_data = of_get_regulator_init_data(dev, child);
+                init_data = of_get_regulator_init_data(dev, child, desc);
                 if (!init_data) {
                         dev_err(dev,
                                 "failed to parse DT for regulator %s\n",
diff --git a/drivers/regulator/pwm-regulator.c b/drivers/regulator/pwm-regulator.c
index d3f55eaea058..91f34ca3a9ac 100644
--- a/drivers/regulator/pwm-regulator.c
+++ b/drivers/regulator/pwm-regulator.c
@@ -149,7 +149,8 @@ static int pwm_regulator_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        config.init_data = of_get_regulator_init_data(&pdev->dev, np);
+        config.init_data = of_get_regulator_init_data(&pdev->dev, np,
+                                                      &drvdata->desc);
         if (!config.init_data)
                 return -ENOMEM;
 
diff --git a/drivers/regulator/qcom_rpm-regulator.c b/drivers/regulator/qcom_rpm-regulator.c
index b55cd5b50ebe..183598b111f9 100644
--- a/drivers/regulator/qcom_rpm-regulator.c
+++ b/drivers/regulator/qcom_rpm-regulator.c
@@ -183,6 +183,13 @@ static const struct regulator_linear_range ftsmps_ranges[] = {
         REGULATOR_LINEAR_RANGE(1500000,  64, 100, 50000),
 };
 
+static const struct regulator_linear_range smb208_ranges[] = {
+        REGULATOR_LINEAR_RANGE( 375000,   0,  29, 12500),
+        REGULATOR_LINEAR_RANGE( 750000,  30,  89, 12500),
+        REGULATOR_LINEAR_RANGE(1500000,  90, 153, 25000),
+        REGULATOR_LINEAR_RANGE(3100000, 154, 234, 25000),
+};
+
 static const struct regulator_linear_range ncp_ranges[] = {
         REGULATOR_LINEAR_RANGE(1500000,   0,  31, 50000),
 };
@@ -559,6 +566,16 @@ static const struct qcom_rpm_reg pm8921_switch = {
         .parts = &rpm8960_switch_parts,
 };
 
+static const struct qcom_rpm_reg smb208_smps = {
+        .desc.linear_ranges = smb208_ranges,
+        .desc.n_linear_ranges = ARRAY_SIZE(smb208_ranges),
+        .desc.n_voltages = 235,
+        .desc.ops = &uV_ops,
+        .parts = &rpm8960_smps_parts,
+        .supports_force_mode_auto = false,
+        .supports_force_mode_bypass = false,
+};
+
 static const struct of_device_id rpm_of_match[] = {
         { .compatible = "qcom,rpm-pm8058-pldo",     .data = &pm8058_pldo },
         { .compatible = "qcom,rpm-pm8058-nldo",     .data = &pm8058_nldo },
@@ -578,6 +595,8 @@ static const struct of_device_id rpm_of_match[] = {
         { .compatible = "qcom,rpm-pm8921-ftsmps",   .data = &pm8921_ftsmps },
         { .compatible = "qcom,rpm-pm8921-ncp",      .data = &pm8921_ncp },
         { .compatible = "qcom,rpm-pm8921-switch",   .data = &pm8921_switch },
+
+        { .compatible = "qcom,rpm-smb208", .data = &smb208_smps },
         { }
 };
 MODULE_DEVICE_TABLE(of, rpm_of_match);
@@ -643,10 +662,6 @@ static int rpm_reg_probe(struct platform_device *pdev)
         match = of_match_device(rpm_of_match, &pdev->dev);
         template = match->data;
 
-        initdata = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node);
-        if (!initdata)
-                return -EINVAL;
-
         vreg = devm_kmalloc(&pdev->dev, sizeof(*vreg), GFP_KERNEL);
         if (!vreg) {
                 dev_err(&pdev->dev, "failed to allocate vreg\n");
@@ -666,6 +681,11 @@ static int rpm_reg_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
+        initdata = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
+                                              &vreg->desc);
+        if (!initdata)
+                return -EINVAL;
+
         key = "reg";
         ret = of_property_read_u32(pdev->dev.of_node, key, &val);
         if (ret) {
diff --git a/drivers/regulator/rk808-regulator.c b/drivers/regulator/rk808-regulator.c
index 196a5c8838c4..ea9d05eabd0a 100644
--- a/drivers/regulator/rk808-regulator.c
+++ b/drivers/regulator/rk808-regulator.c
@@ -36,6 +36,12 @@
 #define RK808_RAMP_RATE_6MV_PER_US      (2 << RK808_RAMP_RATE_OFFSET)
 #define RK808_RAMP_RATE_10MV_PER_US     (3 << RK808_RAMP_RATE_OFFSET)
 
+/* Offset from XXX_ON_VSEL to XXX_SLP_VSEL */
+#define RK808_SLP_REG_OFFSET 1
+
+/* Offset from XXX_EN_REG to SLEEP_SET_OFF_XXX */
+#define RK808_SLP_SET_OFF_REG_OFFSET 2
+
 static const int rk808_buck_config_regs[] = {
         RK808_BUCK1_CONFIG_REG,
         RK808_BUCK2_CONFIG_REG,
@@ -91,6 +97,43 @@ static int rk808_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
                                   RK808_RAMP_RATE_MASK, ramp_value);
 }
 
+int rk808_set_suspend_voltage(struct regulator_dev *rdev, int uv)
+{
+        unsigned int reg;
+        int sel = regulator_map_voltage_linear_range(rdev, uv, uv);
+
+        if (sel < 0)
+                return -EINVAL;
+
+        reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
+
+        return regmap_update_bits(rdev->regmap, reg,
+                                  rdev->desc->vsel_mask,
+                                  sel);
+}
+
+int rk808_set_suspend_enable(struct regulator_dev *rdev)
+{
+        unsigned int reg;
+
+        reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
+
+        return regmap_update_bits(rdev->regmap, reg,
+                                  rdev->desc->enable_mask,
+                                  0);
+}
+
+int rk808_set_suspend_disable(struct regulator_dev *rdev)
+{
+        unsigned int reg;
+
+        reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
+
+        return regmap_update_bits(rdev->regmap, reg,
+                                  rdev->desc->enable_mask,
+                                  rdev->desc->enable_mask);
+}
+
 static struct regulator_ops rk808_buck1_2_ops = {
         .list_voltage           = regulator_list_voltage_linear_range,
         .map_voltage            = regulator_map_voltage_linear_range,
@@ -100,6 +143,9 @@ static struct regulator_ops rk808_buck1_2_ops = {
         .disable                = regulator_disable_regmap,
         .is_enabled             = regulator_is_enabled_regmap,
         .set_ramp_delay         = rk808_set_ramp_delay,
+        .set_suspend_voltage    = rk808_set_suspend_voltage,
+        .set_suspend_enable     = rk808_set_suspend_enable,
+        .set_suspend_disable    = rk808_set_suspend_disable,
 };
 
 static struct regulator_ops rk808_reg_ops = {
@@ -110,12 +156,17 @@ static struct regulator_ops rk808_reg_ops = {
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
         .is_enabled             = regulator_is_enabled_regmap,
+        .set_suspend_voltage    = rk808_set_suspend_voltage,
+        .set_suspend_enable     = rk808_set_suspend_enable,
+        .set_suspend_disable    = rk808_set_suspend_disable,
 };
 
 static struct regulator_ops rk808_switch_ops = {
-        .enable = regulator_enable_regmap,
-        .disable = regulator_disable_regmap,
-        .is_enabled = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .set_suspend_enable     = rk808_set_suspend_enable,
+        .set_suspend_disable    = rk808_set_suspend_disable,
 };
 
 static const struct regulator_desc rk808_reg[] = {
diff --git a/drivers/regulator/rn5t618-regulator.c b/drivers/regulator/rn5t618-regulator.c
index e58d79aeb393..b85ceb8ff911 100644
--- a/drivers/regulator/rn5t618-regulator.c
+++ b/drivers/regulator/rn5t618-regulator.c
@@ -31,6 +31,8 @@ static struct regulator_ops rn5t618_reg_ops = {
 #define REG(rid, ereg, emask, vreg, vmask, min, max, step)              \
         [RN5T618_##rid] = {                                             \
                 .name           = #rid,                                 \
+                .of_match       = of_match_ptr(#rid),                   \
+                .regulators_node = of_match_ptr("regulators"),          \
                 .id             = RN5T618_##rid,                        \
                 .type           = REGULATOR_VOLTAGE,                    \
                 .owner          = THIS_MODULE,                          \
@@ -60,60 +62,15 @@ static struct regulator_desc rn5t618_regulators[] = {
         REG(LDORTC2, LDOEN2, BIT(5), LDORTC2DAC, 0x7f, 900000, 3500000, 25000),
 };
 
-static struct of_regulator_match rn5t618_matches[] = {
-        [RN5T618_DCDC1]         = { .name = "DCDC1" },
-        [RN5T618_DCDC2]         = { .name = "DCDC2" },
-        [RN5T618_DCDC3]         = { .name = "DCDC3" },
-        [RN5T618_LDO1]          = { .name = "LDO1" },
-        [RN5T618_LDO2]          = { .name = "LDO2" },
-        [RN5T618_LDO3]          = { .name = "LDO3" },
-        [RN5T618_LDO4]          = { .name = "LDO4" },
-        [RN5T618_LDO5]          = { .name = "LDO5" },
-        [RN5T618_LDORTC1]       = { .name = "LDORTC1" },
-        [RN5T618_LDORTC2]       = { .name = "LDORTC2" },
-};
-
-static int rn5t618_regulator_parse_dt(struct platform_device *pdev)
-{
-        struct device_node *np, *regulators;
-        int ret;
-
-        np = of_node_get(pdev->dev.parent->of_node);
-        if (!np)
-                return 0;
-
-        regulators = of_get_child_by_name(np, "regulators");
-        if (!regulators) {
-                dev_err(&pdev->dev, "regulators node not found\n");
-                return -EINVAL;
-        }
-
-        ret = of_regulator_match(&pdev->dev, regulators, rn5t618_matches,
-                                 ARRAY_SIZE(rn5t618_matches));
-        of_node_put(regulators);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "error parsing regulator init data: %d\n",
-                        ret);
-        }
-
-        return 0;
-}
-
 static int rn5t618_regulator_probe(struct platform_device *pdev)
 {
         struct rn5t618 *rn5t618 = dev_get_drvdata(pdev->dev.parent);
         struct regulator_config config = { };
         struct regulator_dev *rdev;
-        int ret, i;
-
-        ret = rn5t618_regulator_parse_dt(pdev);
-        if (ret)
-                return ret;
+        int i;
 
         for (i = 0; i < RN5T618_REG_NUM; i++) {
-                config.dev = &pdev->dev;
-                config.init_data = rn5t618_matches[i].init_data;
-                config.of_node = rn5t618_matches[i].of_node;
+                config.dev = pdev->dev.parent;
                 config.regmap = rn5t618->regmap;
 
                 rdev = devm_regulator_register(&pdev->dev,
diff --git a/drivers/regulator/rt5033-regulator.c b/drivers/regulator/rt5033-regulator.c
new file mode 100644
index 000000000000..870cc49438db
--- /dev/null
+++ b/drivers/regulator/rt5033-regulator.c
@@ -0,0 +1,123 @@
+/*
+ * Regulator driver for the Richtek RT5033
+ *
+ * Copyright (C) 2014 Samsung Electronics, Co., Ltd.
+ * Author: Beomho Seo <beomho.seo@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published bythe Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/mfd/rt5033.h>
+#include <linux/mfd/rt5033-private.h>
+#include <linux/regulator/of_regulator.h>
+
+static struct regulator_ops rt5033_safe_ldo_ops = {
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .list_voltage           = regulator_list_voltage_linear,
+};
+
+static struct regulator_ops rt5033_buck_ops = {
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+};
+
+static const struct regulator_desc rt5033_supported_regulators[] = {
+        [RT5033_BUCK] = {
+                .name           = "BUCK",
+                .id             = RT5033_BUCK,
+                .ops            = &rt5033_buck_ops,
+                .type           = REGULATOR_VOLTAGE,
+                .owner          = THIS_MODULE,
+                .n_voltages     = RT5033_REGULATOR_BUCK_VOLTAGE_STEP_NUM,
+                .min_uV         = RT5033_REGULATOR_BUCK_VOLTAGE_MIN,
+                .uV_step        = RT5033_REGULATOR_BUCK_VOLTAGE_STEP,
+                .enable_reg     = RT5033_REG_CTRL,
+                .enable_mask    = RT5033_CTRL_EN_BUCK_MASK,
+                .vsel_reg       = RT5033_REG_BUCK_CTRL,
+                .vsel_mask      = RT5033_BUCK_CTRL_MASK,
+        },
+        [RT5033_LDO] = {
+                .name           = "LDO",
+                .id             = RT5033_LDO,
+                .ops            = &rt5033_buck_ops,
+                .type           = REGULATOR_VOLTAGE,
+                .owner          = THIS_MODULE,
+                .n_voltages     = RT5033_REGULATOR_LDO_VOLTAGE_STEP_NUM,
+                .min_uV         = RT5033_REGULATOR_LDO_VOLTAGE_MIN,
+                .uV_step        = RT5033_REGULATOR_LDO_VOLTAGE_STEP,
+                .enable_reg     = RT5033_REG_CTRL,
+                .enable_mask    = RT5033_CTRL_EN_LDO_MASK,
+                .vsel_reg       = RT5033_REG_LDO_CTRL,
+                .vsel_mask      = RT5033_LDO_CTRL_MASK,
+        },
+        [RT5033_SAFE_LDO] = {
+                .name           = "SAFE_LDO",
+                .id             = RT5033_SAFE_LDO,
+                .ops            = &rt5033_safe_ldo_ops,
+                .type           = REGULATOR_VOLTAGE,
+                .owner          = THIS_MODULE,
+                .n_voltages     = 1,
+                .min_uV         = RT5033_REGULATOR_SAFE_LDO_VOLTAGE,
+                .enable_reg     = RT5033_REG_CTRL,
+                .enable_mask    = RT5033_CTRL_EN_SAFE_LDO_MASK,
+        },
+};
+
+static int rt5033_regulator_probe(struct platform_device *pdev)
+{
+        struct rt5033_dev *rt5033 = dev_get_drvdata(pdev->dev.parent);
+        int ret, i;
+        struct regulator_config config = {};
+
+        config.dev = &pdev->dev;
+        config.driver_data = rt5033;
+
+        for (i = 0; i < ARRAY_SIZE(rt5033_supported_regulators); i++) {
+                struct regulator_dev *regulator;
+
+                config.regmap = rt5033->regmap;
+
+                regulator = devm_regulator_register(&pdev->dev,
+                                &rt5033_supported_regulators[i], &config);
+                if (IS_ERR(regulator)) {
+                        ret = PTR_ERR(regulator);
+                        dev_err(&pdev->dev,
+                                "Regulator init failed %d: with error: %d\n",
+                                i, ret);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static const struct platform_device_id rt5033_regulator_id[] = {
+        { "rt5033-regulator", },
+        { }
+};
+MODULE_DEVICE_TABLE(platform, rt5033_regulator_id);
+
+static struct platform_driver rt5033_regulator_driver = {
+        .driver = {
+                .name = "rt5033-regulator",
+        },
+        .probe          = rt5033_regulator_probe,
+        .id_table       = rt5033_regulator_id,
+};
+module_platform_driver(rt5033_regulator_driver);
+
+MODULE_DESCRIPTION("Richtek RT5033 Regulator driver");
+MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/s2mpa01.c b/drivers/regulator/s2mpa01.c
index 7633b9bfbe6e..5db4e12a7e04 100644
--- a/drivers/regulator/s2mpa01.c
+++ b/drivers/regulator/s2mpa01.c
@@ -298,7 +298,7 @@ static struct regulator_ops s2mpa01_buck_ops = {
         .enable_mask    = S2MPA01_ENABLE_MASK                   \
 }
 
-static struct regulator_desc regulators[] = {
+static const struct regulator_desc regulators[] = {
         regulator_desc_ldo(1, STEP_25_MV),
         regulator_desc_ldo(2, STEP_50_MV),
         regulator_desc_ldo(3, STEP_50_MV),
diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
index adab82d5279f..b345cf51225a 100644
--- a/drivers/regulator/s2mps11.c
+++ b/drivers/regulator/s2mps11.c
@@ -30,6 +30,7 @@
 #include <linux/of_gpio.h>
 #include <linux/mfd/samsung/core.h>
 #include <linux/mfd/samsung/s2mps11.h>
+#include <linux/mfd/samsung/s2mps13.h>
 #include <linux/mfd/samsung/s2mps14.h>
 #include <linux/mfd/samsung/s2mpu02.h>
 
@@ -45,10 +46,10 @@ struct s2mps11_info {
         enum sec_device_type dev_type;
 
         /*
-         * One bit for each S2MPS14/S2MPU02 regulator whether the suspend mode
-         * was enabled.
+         * One bit for each S2MPS13/S2MPS14/S2MPU02 regulator whether
+         * the suspend mode was enabled.
          */
-        unsigned long long s2mps14_suspend_state:35;
+        unsigned long long s2mps14_suspend_state:50;
 
         /* Array of size rdev_num with GPIO-s for external sleep control */
         int *ext_control_gpio;
@@ -369,12 +370,101 @@ static const struct regulator_desc s2mps11_regulators[] = {
         regulator_desc_s2mps11_buck6_10(10, MIN_750_MV, STEP_12_5_MV),
 };
 
+static struct regulator_ops s2mps14_reg_ops;
+
+#define regulator_desc_s2mps13_ldo(num, min, step, min_sel) {   \
+        .name           = "LDO"#num,                            \
+        .id             = S2MPS13_LDO##num,                     \
+        .ops            = &s2mps14_reg_ops,                     \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = min,                                  \
+        .uV_step        = step,                                 \
+        .linear_min_sel = min_sel,                              \
+        .n_voltages     = S2MPS14_LDO_N_VOLTAGES,               \
+        .vsel_reg       = S2MPS13_REG_L1CTRL + num - 1,         \
+        .vsel_mask      = S2MPS14_LDO_VSEL_MASK,                \
+        .enable_reg     = S2MPS13_REG_L1CTRL + num - 1,         \
+        .enable_mask    = S2MPS14_ENABLE_MASK                   \
+}
+
+#define regulator_desc_s2mps13_buck(num, min, step, min_sel) {  \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPS13_BUCK##num,                    \
+        .ops            = &s2mps14_reg_ops,                     \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = min,                                  \
+        .uV_step        = step,                                 \
+        .linear_min_sel = min_sel,                              \
+        .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
+        .ramp_delay     = S2MPS13_BUCK_RAMP_DELAY,              \
+        .vsel_reg       = S2MPS13_REG_B1OUT + (num - 1) * 2,    \
+        .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS13_REG_B1CTRL + (num - 1) * 2,   \
+        .enable_mask    = S2MPS14_ENABLE_MASK                   \
+}
+
+static const struct regulator_desc s2mps13_regulators[] = {
+        regulator_desc_s2mps13_ldo(1,  MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(2,  MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(3,  MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(4,  MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(5,  MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(6,  MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(7,  MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(8,  MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(9,  MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(10, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(11, MIN_800_MV,  STEP_25_MV,   0x10),
+        regulator_desc_s2mps13_ldo(12, MIN_800_MV,  STEP_25_MV,   0x10),
+        regulator_desc_s2mps13_ldo(13, MIN_800_MV,  STEP_25_MV,   0x10),
+        regulator_desc_s2mps13_ldo(14, MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(15, MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(16, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(17, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(18, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(19, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(20, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(21, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(22, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(23, MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(24, MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(25, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(26, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(27, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(28, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(29, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(30, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(31, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(32, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(33, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(34, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(35, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(36, MIN_800_MV,  STEP_12_5_MV, 0x00),
+        regulator_desc_s2mps13_ldo(37, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(38, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_ldo(39, MIN_1000_MV, STEP_25_MV,   0x08),
+        regulator_desc_s2mps13_ldo(40, MIN_1400_MV, STEP_50_MV,   0x0C),
+        regulator_desc_s2mps13_buck(1,  MIN_500_MV,  STEP_6_25_MV, 0x10),
+        regulator_desc_s2mps13_buck(2,  MIN_500_MV,  STEP_6_25_MV, 0x10),
+        regulator_desc_s2mps13_buck(3,  MIN_500_MV,  STEP_6_25_MV, 0x10),
+        regulator_desc_s2mps13_buck(4,  MIN_500_MV,  STEP_6_25_MV, 0x10),
+        regulator_desc_s2mps13_buck(5,  MIN_500_MV,  STEP_6_25_MV, 0x10),
+        regulator_desc_s2mps13_buck(6,  MIN_500_MV,  STEP_6_25_MV, 0x10),
+        regulator_desc_s2mps13_buck(7,  MIN_500_MV,  STEP_6_25_MV, 0x10),
+        regulator_desc_s2mps13_buck(8,  MIN_1000_MV, STEP_12_5_MV, 0x20),
+        regulator_desc_s2mps13_buck(9,  MIN_1000_MV, STEP_12_5_MV, 0x20),
+        regulator_desc_s2mps13_buck(10, MIN_500_MV,  STEP_6_25_MV, 0x10),
+};
+
 static int s2mps14_regulator_enable(struct regulator_dev *rdev)
 {
         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
         unsigned int val;
 
         switch (s2mps11->dev_type) {
+        case S2MPS13X:
         case S2MPS14X:
                 if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
                         val = S2MPS14_ENABLE_SUSPEND;
@@ -406,6 +496,7 @@ static int s2mps14_regulator_set_suspend_disable(struct regulator_dev *rdev)
 
         /* Below LDO should be always on or does not support suspend mode. */
         switch (s2mps11->dev_type) {
+        case S2MPS13X:
         case S2MPS14X:
                 switch (rdev_id) {
                 case S2MPS14_LDO3:
@@ -831,6 +922,10 @@ static int s2mps11_pmic_probe(struct platform_device *pdev)
                 s2mps11->rdev_num = ARRAY_SIZE(s2mps11_regulators);
                 regulators = s2mps11_regulators;
                 break;
+        case S2MPS13X:
+                s2mps11->rdev_num = ARRAY_SIZE(s2mps13_regulators);
+                regulators = s2mps13_regulators;
+                break;
         case S2MPS14X:
                 s2mps11->rdev_num = ARRAY_SIZE(s2mps14_regulators);
                 regulators = s2mps14_regulators;
@@ -845,7 +940,7 @@ static int s2mps11_pmic_probe(struct platform_device *pdev)
                 return -EINVAL;
         };
 
-        s2mps11->ext_control_gpio = devm_kzalloc(&pdev->dev,
+        s2mps11->ext_control_gpio = devm_kmalloc(&pdev->dev,
                         sizeof(*s2mps11->ext_control_gpio) * s2mps11->rdev_num,
                         GFP_KERNEL);
         if (!s2mps11->ext_control_gpio)
@@ -886,6 +981,7 @@ common_reg:
         config.regmap = iodev->regmap_pmic;
         config.driver_data = s2mps11;
         config.ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
+        config.ena_gpio_initialized = true;
         for (i = 0; i < s2mps11->rdev_num; i++) {
                 struct regulator_dev *regulator;
 
@@ -927,6 +1023,7 @@ out:
 
 static const struct platform_device_id s2mps11_pmic_id[] = {
         { "s2mps11-pmic", S2MPS11X},
+        { "s2mps13-pmic", S2MPS13X},
         { "s2mps14-pmic", S2MPS14X},
         { "s2mpu02-pmic", S2MPU02},
         { },
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c
index 0ab5cbeeb797..dc1328c0c71c 100644
--- a/drivers/regulator/s5m8767.c
+++ b/drivers/regulator/s5m8767.c
@@ -581,7 +581,8 @@ static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
 
                 rdata->id = i;
                 rdata->initdata = of_get_regulator_init_data(
-                                                &pdev->dev, reg_np);
+                                                &pdev->dev, reg_np,
+                                                &regulators[i]);
                 rdata->reg_node = reg_np;
                 rdata++;
                 rmode->id = i;
@@ -950,6 +951,7 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
                 config.of_node = pdata->regulators[i].reg_node;
                 config.ena_gpio = -EINVAL;
                 config.ena_gpio_flags = 0;
+                config.ena_gpio_initialized = true;
                 if (gpio_is_valid(pdata->regulators[i].ext_control_gpio))
                         s5m8767_regulator_config_ext_control(s5m8767,
                                         &pdata->regulators[i], &config);
diff --git a/drivers/regulator/sky81452-regulator.c b/drivers/regulator/sky81452-regulator.c
index 97aff0ccd65f..647860611916 100644
--- a/drivers/regulator/sky81452-regulator.c
+++ b/drivers/regulator/sky81452-regulator.c
@@ -5,9 +5,8 @@
  * Author : Gyungoh Yoo <jack.yoo@skyworksinc.com>
  *
  * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2, or (at your option) any
- * later version.
+ * under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -52,6 +51,8 @@ static const struct regulator_linear_range sky81452_reg_ranges[] = {
 
 static const struct regulator_desc sky81452_reg = {
         .name = "LOUT",
+        .of_match = of_match_ptr("lout"),
+        .regulators_node = of_match_ptr("regulator"),
         .ops = &sky81452_reg_ops,
         .type = REGULATOR_VOLTAGE,
         .owner = THIS_MODULE,
@@ -64,30 +65,6 @@ static const struct regulator_desc sky81452_reg = {
         .enable_mask = SKY81452_LEN,
 };
 
-#ifdef CONFIG_OF
-static struct regulator_init_data *sky81452_reg_parse_dt(struct device *dev)
-{
-        struct regulator_init_data *init_data;
-        struct device_node *np;
-
-        np = of_get_child_by_name(dev->parent->of_node, "regulator");
-        if (unlikely(!np)) {
-                dev_err(dev, "regulator node not found");
-                return NULL;
-        }
-
-        init_data = of_get_regulator_init_data(dev, np);
-
-        of_node_put(np);
-        return init_data;
-}
-#else
-static struct regulator_init_data *sky81452_reg_parse_dt(struct device *dev)
-{
-        return ERR_PTR(-EINVAL);
-}
-#endif
-
 static int sky81452_reg_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
@@ -95,20 +72,16 @@ static int sky81452_reg_probe(struct platform_device *pdev)
         struct regulator_config config = { };
         struct regulator_dev *rdev;
 
-        if (!init_data) {
-                init_data = sky81452_reg_parse_dt(dev);
-                if (IS_ERR(init_data))
-                        return PTR_ERR(init_data);
-        }
-
-        config.dev = dev;
+        config.dev = dev->parent;
         config.init_data = init_data;
         config.of_node = dev->of_node;
         config.regmap = dev_get_drvdata(dev->parent);
 
         rdev = devm_regulator_register(dev, &sky81452_reg, &config);
-        if (IS_ERR(rdev))
+        if (IS_ERR(rdev)) {
+                dev_err(dev, "failed to register. err=%ld\n", PTR_ERR(rdev));
                 return PTR_ERR(rdev);
+        }
 
         platform_set_drvdata(pdev, rdev);
 
@@ -126,5 +99,4 @@ module_platform_driver(sky81452_reg_driver);
 
 MODULE_DESCRIPTION("Skyworks SKY81452 Regulator driver");
 MODULE_AUTHOR("Gyungoh Yoo <jack.yoo@skyworksinc.com>");
-MODULE_LICENSE("GPL");
-MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/regulator/stw481x-vmmc.c b/drivers/regulator/stw481x-vmmc.c
index a7e152696a02..b4f1696456a7 100644
--- a/drivers/regulator/stw481x-vmmc.c
+++ b/drivers/regulator/stw481x-vmmc.c
@@ -72,7 +72,8 @@ static int stw481x_vmmc_regulator_probe(struct platform_device *pdev)
         config.regmap = stw481x->map;
         config.of_node = pdev->dev.of_node;
         config.init_data = of_get_regulator_init_data(&pdev->dev,
-                                                      pdev->dev.of_node);
+                                                      pdev->dev.of_node,
+                                                      &vmmc_regulator);
 
         stw481x->vmmc_regulator = devm_regulator_register(&pdev->dev,
                                                 &vmmc_regulator, &config);
diff --git a/drivers/regulator/ti-abb-regulator.c b/drivers/regulator/ti-abb-regulator.c
index a2dabb575b97..1ef5aba96f17 100644
--- a/drivers/regulator/ti-abb-regulator.c
+++ b/drivers/regulator/ti-abb-regulator.c
@@ -837,7 +837,8 @@ skip_opt:
                 return -EINVAL;
         }
 
-        initdata = of_get_regulator_init_data(dev, pdev->dev.of_node);
+        initdata = of_get_regulator_init_data(dev, pdev->dev.of_node,
+                                              &abb->rdesc);
         if (!initdata) {
                 dev_err(dev, "%s: Unable to alloc regulator init data\n",
                         __func__);
diff --git a/drivers/regulator/tps51632-regulator.c b/drivers/regulator/tps51632-regulator.c
index f31f22e3e1bd..c213e37eb69e 100644
--- a/drivers/regulator/tps51632-regulator.c
+++ b/drivers/regulator/tps51632-regulator.c
@@ -221,7 +221,8 @@ static const struct of_device_id tps51632_of_match[] = {
 MODULE_DEVICE_TABLE(of, tps51632_of_match);
 
 static struct tps51632_regulator_platform_data *
-        of_get_tps51632_platform_data(struct device *dev)
+        of_get_tps51632_platform_data(struct device *dev,
+                                      const struct regulator_desc *desc)
 {
         struct tps51632_regulator_platform_data *pdata;
         struct device_node *np = dev->of_node;
@@ -230,7 +231,8 @@ static struct tps51632_regulator_platform_data *
         if (!pdata)
                 return NULL;
 
-        pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node);
+        pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
+                                                          desc);
         if (!pdata->reg_init_data) {
                 dev_err(dev, "Not able to get OF regulator init data\n");
                 return NULL;
@@ -248,7 +250,8 @@ static struct tps51632_regulator_platform_data *
 }
 #else
 static struct tps51632_regulator_platform_data *
-        of_get_tps51632_platform_data(struct device *dev)
+        of_get_tps51632_platform_data(struct device *dev,
+                                      const struct regulator_desc *desc)
 {
         return NULL;
 }
@@ -273,9 +276,25 @@ static int tps51632_probe(struct i2c_client *client,
                 }
         }
 
+        tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
+        if (!tps)
+                return -ENOMEM;
+
+        tps->dev = &client->dev;
+        tps->desc.name = client->name;
+        tps->desc.id = 0;
+        tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
+        tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
+        tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
+        tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
+        tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
+        tps->desc.ops = &tps51632_dcdc_ops;
+        tps->desc.type = REGULATOR_VOLTAGE;
+        tps->desc.owner = THIS_MODULE;
+
         pdata = dev_get_platdata(&client->dev);
         if (!pdata && client->dev.of_node)
-                pdata = of_get_tps51632_platform_data(&client->dev);
+                pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
         if (!pdata) {
                 dev_err(&client->dev, "No Platform data\n");
                 return -EINVAL;
@@ -296,22 +315,6 @@ static int tps51632_probe(struct i2c_client *client,
                 }
         }
 
-        tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
-        if (!tps)
-                return -ENOMEM;
-
-        tps->dev = &client->dev;
-        tps->desc.name = client->name;
-        tps->desc.id = 0;
-        tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
-        tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
-        tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
-        tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
-        tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
-        tps->desc.ops = &tps51632_dcdc_ops;
-        tps->desc.type = REGULATOR_VOLTAGE;
-        tps->desc.owner = THIS_MODULE;
-
         if (pdata->enable_pwm_dvfs)
                 tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
         else
diff --git a/drivers/regulator/tps62360-regulator.c b/drivers/regulator/tps62360-regulator.c
index a1672044e519..a1fd626c6c96 100644
--- a/drivers/regulator/tps62360-regulator.c
+++ b/drivers/regulator/tps62360-regulator.c
@@ -293,7 +293,8 @@ static const struct regmap_config tps62360_regmap_config = {
 };
 
 static struct tps62360_regulator_platform_data *
-        of_get_tps62360_platform_data(struct device *dev)
+        of_get_tps62360_platform_data(struct device *dev,
+                                      const struct regulator_desc *desc)
 {
         struct tps62360_regulator_platform_data *pdata;
         struct device_node *np = dev->of_node;
@@ -302,7 +303,8 @@ static struct tps62360_regulator_platform_data *
         if (!pdata)
                 return NULL;
 
-        pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node);
+        pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
+                                                          desc);
         if (!pdata->reg_init_data) {
                 dev_err(dev, "Not able to get OF regulator init data\n");
                 return NULL;
@@ -350,6 +352,17 @@ static int tps62360_probe(struct i2c_client *client,
 
         pdata = dev_get_platdata(&client->dev);
 
+        tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
+        if (!tps)
+                return -ENOMEM;
+
+        tps->desc.name = client->name;
+        tps->desc.id = 0;
+        tps->desc.ops = &tps62360_dcdc_ops;
+        tps->desc.type = REGULATOR_VOLTAGE;
+        tps->desc.owner = THIS_MODULE;
+        tps->desc.uV_step = 10000;
+
         if (client->dev.of_node) {
                 const struct of_device_id *match;
                 match = of_match_device(of_match_ptr(tps62360_of_match),
@@ -360,7 +373,8 @@ static int tps62360_probe(struct i2c_client *client,
                 }
                 chip_id = (int)(long)match->data;
                 if (!pdata)
-                        pdata = of_get_tps62360_platform_data(&client->dev);
+                        pdata = of_get_tps62360_platform_data(&client->dev,
+                                                              &tps->desc);
         } else if (id) {
                 chip_id = id->driver_data;
         } else {
@@ -374,10 +388,6 @@ static int tps62360_probe(struct i2c_client *client,
                 return -EIO;
         }
 
-        tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
-        if (!tps)
-                return -ENOMEM;
-
         tps->en_discharge = pdata->en_discharge;
         tps->en_internal_pulldn = pdata->en_internal_pulldn;
         tps->vsel0_gpio = pdata->vsel0_gpio;
@@ -401,13 +411,6 @@ static int tps62360_probe(struct i2c_client *client,
                 return -ENODEV;
         }
 
-        tps->desc.name = client->name;
-        tps->desc.id = 0;
-        tps->desc.ops = &tps62360_dcdc_ops;
-        tps->desc.type = REGULATOR_VOLTAGE;
-        tps->desc.owner = THIS_MODULE;
-        tps->desc.uV_step = 10000;
-
         tps->regmap = devm_regmap_init_i2c(client, &tps62360_regmap_config);
         if (IS_ERR(tps->regmap)) {
                 ret = PTR_ERR(tps->regmap);
diff --git a/drivers/regulator/tps65090-regulator.c b/drivers/regulator/tps65090-regulator.c
index d5df1e9ad1da..f1df4423d361 100644
--- a/drivers/regulator/tps65090-regulator.c
+++ b/drivers/regulator/tps65090-regulator.c
@@ -312,7 +312,11 @@ static void tps65090_configure_regulator_config(
                         gpio_flag = GPIOF_OUT_INIT_HIGH;
 
                 config->ena_gpio = tps_pdata->gpio;
+                config->ena_gpio_initialized = true;
                 config->ena_gpio_flags = gpio_flag;
+        } else {
+                config->ena_gpio = -EINVAL;
+                config->ena_gpio_initialized = false;
         }
 }
 
diff --git a/drivers/regulator/tps65218-regulator.c b/drivers/regulator/tps65218-regulator.c
index f0a40281b9c1..263cc85d6202 100644
--- a/drivers/regulator/tps65218-regulator.c
+++ b/drivers/regulator/tps65218-regulator.c
@@ -231,7 +231,8 @@ static int tps65218_regulator_probe(struct platform_device *pdev)
 
         template = match->data;
         id = template->id;
-        init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node);
+        init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
+                                               &regulators[id]);
 
         platform_set_drvdata(pdev, tps);
 
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index 0b4f8660fdb4..dd727bca1983 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -1104,7 +1104,8 @@ static int twlreg_probe(struct platform_device *pdev)
                 template = match->data;
                 id = template->desc.id;
                 initdata = of_get_regulator_init_data(&pdev->dev,
-                                                      pdev->dev.of_node);
+                                                      pdev->dev.of_node,
+                                                      &template->desc);
                 drvdata = NULL;
         } else {
                 id = pdev->id;
diff --git a/drivers/regulator/vexpress.c b/drivers/regulator/vexpress.c
index 02e7267ccf92..5e7c789023a9 100644
--- a/drivers/regulator/vexpress.c
+++ b/drivers/regulator/vexpress.c
@@ -74,7 +74,8 @@ static int vexpress_regulator_probe(struct platform_device *pdev)
         reg->desc.owner = THIS_MODULE;
         reg->desc.continuous_voltage_range = true;
 
-        init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node);
+        init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
+                                               &reg->desc);
         if (!init_data)
                 return -EINVAL;
 
diff --git a/drivers/regulator/wm8994-regulator.c b/drivers/regulator/wm8994-regulator.c
index c24346db8a71..88f5064e412b 100644
--- a/drivers/regulator/wm8994-regulator.c
+++ b/drivers/regulator/wm8994-regulator.c
@@ -145,10 +145,12 @@ static int wm8994_ldo_probe(struct platform_device *pdev)
         config.driver_data = ldo;
         config.regmap = wm8994->regmap;
         config.init_data = &ldo->init_data;
-        if (pdata)
+        if (pdata) {
                 config.ena_gpio = pdata->ldo[id].enable;
-        else if (wm8994->dev->of_node)
+        } else if (wm8994->dev->of_node) {
                 config.ena_gpio = wm8994->pdata.ldo[id].enable;
+                config.ena_gpio_initialized = true;
+        }
 
         /* Use default constraints if none set up */
         if (!pdata || !pdata->ldo[id].init_data || wm8994->dev->of_node) {
diff --git a/drivers/remoteproc/omap_remoteproc.c b/drivers/remoteproc/omap_remoteproc.c
index 51689721ea7a..cf92f6e7c5dc 100644
--- a/drivers/remoteproc/omap_remoteproc.c
+++ b/drivers/remoteproc/omap_remoteproc.c
@@ -27,6 +27,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/remoteproc.h>
+#include <linux/mailbox_client.h>
 #include <linux/omap-mailbox.h>
 
 #include <linux/platform_data/remoteproc-omap.h>
@@ -36,20 +37,19 @@
 
 /**
  * struct omap_rproc - omap remote processor state
- * @mbox: omap mailbox handle
- * @nb: notifier block that will be invoked on inbound mailbox messages
+ * @mbox: mailbox channel handle
+ * @client: mailbox client to request the mailbox channel
  * @rproc: rproc handle
  */
 struct omap_rproc {
-        struct omap_mbox *mbox;
-        struct notifier_block nb;
+        struct mbox_chan *mbox;
+        struct mbox_client client;
         struct rproc *rproc;
 };
 
 /**
  * omap_rproc_mbox_callback() - inbound mailbox message handler
- * @this: notifier block
- * @index: unused
+ * @client: mailbox client pointer used for requesting the mailbox channel
  * @data: mailbox payload
  *
  * This handler is invoked by omap's mailbox driver whenever a mailbox
@@ -61,13 +61,13 @@ struct omap_rproc {
  * that indicates different events. Those values are deliberately very
  * big so they don't coincide with virtqueue indices.
  */
-static int omap_rproc_mbox_callback(struct notifier_block *this,
-                                        unsigned long index, void *data)
+static void omap_rproc_mbox_callback(struct mbox_client *client, void *data)
 {
-        mbox_msg_t msg = (mbox_msg_t) data;
-        struct omap_rproc *oproc = container_of(this, struct omap_rproc, nb);
+        struct omap_rproc *oproc = container_of(client, struct omap_rproc,
+                                                client);
         struct device *dev = oproc->rproc->dev.parent;
         const char *name = oproc->rproc->name;
+        u32 msg = (u32)data;
 
         dev_dbg(dev, "mbox msg: 0x%x\n", msg);
 
@@ -84,8 +84,6 @@ static int omap_rproc_mbox_callback(struct notifier_block *this,
                 if (rproc_vq_interrupt(oproc->rproc, msg) == IRQ_NONE)
                         dev_dbg(dev, "no message was found in vqid %d\n", msg);
         }
-
-        return NOTIFY_DONE;
 }
 
 /* kick a virtqueue */
@@ -96,8 +94,8 @@ static void omap_rproc_kick(struct rproc *rproc, int vqid)
         int ret;
 
         /* send the index of the triggered virtqueue in the mailbox payload */
-        ret = omap_mbox_msg_send(oproc->mbox, vqid);
-        if (ret)
+        ret = mbox_send_message(oproc->mbox, (void *)vqid);
+        if (ret < 0)
                 dev_err(dev, "omap_mbox_msg_send failed: %d\n", ret);
 }
 
@@ -115,17 +113,22 @@ static int omap_rproc_start(struct rproc *rproc)
         struct platform_device *pdev = to_platform_device(dev);
         struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
         int ret;
+        struct mbox_client *client = &oproc->client;
 
         if (pdata->set_bootaddr)
                 pdata->set_bootaddr(rproc->bootaddr);
 
-        oproc->nb.notifier_call = omap_rproc_mbox_callback;
+        client->dev = dev;
+        client->tx_done = NULL;
+        client->rx_callback = omap_rproc_mbox_callback;
+        client->tx_block = false;
+        client->knows_txdone = false;
 
-        /* every omap rproc is assigned a mailbox instance for messaging */
-        oproc->mbox = omap_mbox_get(pdata->mbox_name, &oproc->nb);
+        oproc->mbox = omap_mbox_request_channel(client, pdata->mbox_name);
         if (IS_ERR(oproc->mbox)) {
-                ret = PTR_ERR(oproc->mbox);
-                dev_err(dev, "omap_mbox_get failed: %d\n", ret);
+                ret = -EBUSY;
+                dev_err(dev, "mbox_request_channel failed: %ld\n",
+                        PTR_ERR(oproc->mbox));
                 return ret;
         }
 
@@ -136,9 +139,9 @@ static int omap_rproc_start(struct rproc *rproc)
          * Note that the reply will _not_ arrive immediately: this message
          * will wait in the mailbox fifo until the remote processor is booted.
          */
-        ret = omap_mbox_msg_send(oproc->mbox, RP_MBOX_ECHO_REQUEST);
-        if (ret) {
-                dev_err(dev, "omap_mbox_get failed: %d\n", ret);
+        ret = mbox_send_message(oproc->mbox, (void *)RP_MBOX_ECHO_REQUEST);
+        if (ret < 0) {
+                dev_err(dev, "mbox_send_message failed: %d\n", ret);
                 goto put_mbox;
         }
 
@@ -151,7 +154,7 @@ static int omap_rproc_start(struct rproc *rproc)
         return 0;
 
 put_mbox:
-        omap_mbox_put(oproc->mbox, &oproc->nb);
+        mbox_free_channel(oproc->mbox);
         return ret;
 }
 
@@ -168,7 +171,7 @@ static int omap_rproc_stop(struct rproc *rproc)
         if (ret)
                 return ret;
 
-        omap_mbox_put(oproc->mbox, &oproc->nb);
+        mbox_free_channel(oproc->mbox);
 
         return 0;
 }
diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
index a34b50690b4e..e1a10232a943 100644
--- a/drivers/remoteproc/remoteproc_virtio.c
+++ b/drivers/remoteproc/remoteproc_virtio.c
@@ -207,7 +207,7 @@ static void rproc_virtio_reset(struct virtio_device *vdev)
 }
 
 /* provide the vdev features as retrieved from the firmware */
-static u32 rproc_virtio_get_features(struct virtio_device *vdev)
+static u64 rproc_virtio_get_features(struct virtio_device *vdev)
 {
         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
         struct fw_rsc_vdev *rsc;
@@ -217,7 +217,7 @@ static u32 rproc_virtio_get_features(struct virtio_device *vdev)
         return rsc->dfeatures;
 }
 
-static void rproc_virtio_finalize_features(struct virtio_device *vdev)
+static int rproc_virtio_finalize_features(struct virtio_device *vdev)
 {
         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
         struct fw_rsc_vdev *rsc;
@@ -227,11 +227,16 @@ static void rproc_virtio_finalize_features(struct virtio_device *vdev)
         /* Give virtio_ring a chance to accept features */
         vring_transport_features(vdev);
 
+        /* Make sure we don't have any features > 32 bits! */
+        BUG_ON((u32)vdev->features != vdev->features);
+
         /*
          * Remember the finalized features of our vdev, and provide it
          * to the remote processor once it is powered on.
          */
-        rsc->gfeatures = vdev->features[0];
+        rsc->gfeatures = vdev->features;
+
+        return 0;
 }
 
 static void rproc_virtio_get(struct virtio_device *vdev, unsigned offset,
diff --git a/drivers/reset/Makefile b/drivers/reset/Makefile
index 60fed3d7820b..157d421f755b 100644
--- a/drivers/reset/Makefile
+++ b/drivers/reset/Makefile
@@ -1,4 +1,5 @@
 obj-$(CONFIG_RESET_CONTROLLER) += core.o
 obj-$(CONFIG_ARCH_SOCFPGA) += reset-socfpga.o
+obj-$(CONFIG_ARCH_BERLIN) += reset-berlin.o
 obj-$(CONFIG_ARCH_SUNXI) += reset-sunxi.o
 obj-$(CONFIG_ARCH_STI) += sti/
diff --git a/drivers/reset/core.c b/drivers/reset/core.c
index baeaf82d40d9..7955e00d04d4 100644
--- a/drivers/reset/core.c
+++ b/drivers/reset/core.c
@@ -126,6 +126,21 @@ int reset_control_deassert(struct reset_control *rstc)
 EXPORT_SYMBOL_GPL(reset_control_deassert);
 
 /**
+ * reset_control_status - returns a negative errno if not supported, a
+ * positive value if the reset line is asserted, or zero if the reset
+ * line is not asserted.
+ * @rstc: reset controller
+ */
+int reset_control_status(struct reset_control *rstc)
+{
+        if (rstc->rcdev->ops->status)
+                return rstc->rcdev->ops->status(rstc->rcdev, rstc->id);
+
+        return -ENOSYS;
+}
+EXPORT_SYMBOL_GPL(reset_control_status);
+
+/**
  * of_reset_control_get - Lookup and obtain a reference to a reset controller.
  * @node: device to be reset by the controller
  * @id: reset line name
diff --git a/drivers/reset/reset-berlin.c b/drivers/reset/reset-berlin.c
new file mode 100644
index 000000000000..f8b48a13cf0b
--- /dev/null
+++ b/drivers/reset/reset-berlin.c
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2014 Marvell Technology Group Ltd.
+ *
+ * Antoine Tenart <antoine.tenart@free-electrons.com>
+ * Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/platform_device.h>
+#include <linux/reset-controller.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+#define BERLIN_MAX_RESETS       32
+
+#define to_berlin_reset_priv(p)         \
+        container_of((p), struct berlin_reset_priv, rcdev)
+
+struct berlin_reset_priv {
+        void __iomem                    *base;
+        unsigned int                    size;
+        struct reset_controller_dev     rcdev;
+};
+
+static int berlin_reset_reset(struct reset_controller_dev *rcdev,
+                              unsigned long id)
+{
+        struct berlin_reset_priv *priv = to_berlin_reset_priv(rcdev);
+        int offset = id >> 8;
+        int mask = BIT(id & 0x1f);
+
+        writel(mask, priv->base + offset);
+
+        /* let the reset be effective */
+        udelay(10);
+
+        return 0;
+}
+
+static struct reset_control_ops berlin_reset_ops = {
+        .reset  = berlin_reset_reset,
+};
+
+static int berlin_reset_xlate(struct reset_controller_dev *rcdev,
+                              const struct of_phandle_args *reset_spec)
+{
+        struct berlin_reset_priv *priv = to_berlin_reset_priv(rcdev);
+        unsigned offset, bit;
+
+        if (WARN_ON(reset_spec->args_count != rcdev->of_reset_n_cells))
+                return -EINVAL;
+
+        offset = reset_spec->args[0];
+        bit = reset_spec->args[1];
+
+        if (offset >= priv->size)
+                return -EINVAL;
+
+        if (bit >= BERLIN_MAX_RESETS)
+                return -EINVAL;
+
+        return (offset << 8) | bit;
+}
+
+static int __berlin_reset_init(struct device_node *np)
+{
+        struct berlin_reset_priv *priv;
+        struct resource res;
+        resource_size_t size;
+        int ret;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        ret = of_address_to_resource(np, 0, &res);
+        if (ret)
+                goto err;
+
+        size = resource_size(&res);
+        priv->base = ioremap(res.start, size);
+        if (!priv->base) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        priv->size = size;
+
+        priv->rcdev.owner = THIS_MODULE;
+        priv->rcdev.ops = &berlin_reset_ops;
+        priv->rcdev.of_node = np;
+        priv->rcdev.of_reset_n_cells = 2;
+        priv->rcdev.of_xlate = berlin_reset_xlate;
+
+        reset_controller_register(&priv->rcdev);
+
+        return 0;
+
+err:
+        kfree(priv);
+        return ret;
+}
+
+static const struct of_device_id berlin_reset_of_match[] __initconst = {
+        { .compatible = "marvell,berlin2-chip-ctrl" },
+        { .compatible = "marvell,berlin2cd-chip-ctrl" },
+        { .compatible = "marvell,berlin2q-chip-ctrl" },
+        { },
+};
+
+static int __init berlin_reset_init(void)
+{
+        struct device_node *np;
+        int ret;
+
+        for_each_matching_node(np, berlin_reset_of_match) {
+                ret = __berlin_reset_init(np);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+arch_initcall(berlin_reset_init);
diff --git a/drivers/reset/reset-socfpga.c b/drivers/reset/reset-socfpga.c
index 79c32ca84ef1..40582089474a 100644
--- a/drivers/reset/reset-socfpga.c
+++ b/drivers/reset/reset-socfpga.c
@@ -76,9 +76,24 @@ static int socfpga_reset_deassert(struct reset_controller_dev *rcdev,
         return 0;
 }
 
+static int socfpga_reset_status(struct reset_controller_dev *rcdev,
+                                unsigned long id)
+{
+        struct socfpga_reset_data *data = container_of(rcdev,
+                                                struct socfpga_reset_data, rcdev);
+        int bank = id / BITS_PER_LONG;
+        int offset = id % BITS_PER_LONG;
+        u32 reg;
+
+        reg = readl(data->membase + OFFSET_MODRST + (bank * NR_BANKS));
+
+        return !(reg & BIT(offset));
+}
+
 static struct reset_control_ops socfpga_reset_ops = {
         .assert         = socfpga_reset_assert,
         .deassert       = socfpga_reset_deassert,
+        .status         = socfpga_reset_status,
 };
 
 static int socfpga_reset_probe(struct platform_device *pdev)
diff --git a/drivers/reset/sti/Kconfig b/drivers/reset/sti/Kconfig
index 88d2d0316613..f8c15a37fb35 100644
--- a/drivers/reset/sti/Kconfig
+++ b/drivers/reset/sti/Kconfig
@@ -12,4 +12,8 @@ config STIH416_RESET
         bool
         select STI_RESET_SYSCFG
 
+config STIH407_RESET
+        bool
+        select STI_RESET_SYSCFG
+
 endif
diff --git a/drivers/reset/sti/Makefile b/drivers/reset/sti/Makefile
index be1c97647871..dc85dfbe56a9 100644
--- a/drivers/reset/sti/Makefile
+++ b/drivers/reset/sti/Makefile
@@ -2,3 +2,4 @@ obj-$(CONFIG_STI_RESET_SYSCFG) += reset-syscfg.o
 
 obj-$(CONFIG_STIH415_RESET) += reset-stih415.o
 obj-$(CONFIG_STIH416_RESET) += reset-stih416.o
+obj-$(CONFIG_STIH407_RESET) += reset-stih407.o
diff --git a/drivers/reset/sti/reset-stih407.c b/drivers/reset/sti/reset-stih407.c
new file mode 100644
index 000000000000..d83db5d72d08
--- /dev/null
+++ b/drivers/reset/sti/reset-stih407.c
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2014 STMicroelectronics (R&D) Limited
+ * Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <dt-bindings/reset-controller/stih407-resets.h>
+#include "reset-syscfg.h"
+
+/* STiH407 Peripheral powerdown definitions. */
+static const char stih407_core[] = "st,stih407-core-syscfg";
+static const char stih407_sbc_reg[] = "st,stih407-sbc-reg-syscfg";
+static const char stih407_lpm[] = "st,stih407-lpm-syscfg";
+
+#define STIH407_PDN_0(_bit) \
+        _SYSCFG_RST_CH(stih407_core, SYSCFG_5000, _bit, SYSSTAT_5500, _bit)
+#define STIH407_PDN_1(_bit) \
+        _SYSCFG_RST_CH(stih407_core, SYSCFG_5001, _bit, SYSSTAT_5501, _bit)
+#define STIH407_PDN_ETH(_bit, _stat) \
+        _SYSCFG_RST_CH(stih407_sbc_reg, SYSCFG_4032, _bit, SYSSTAT_4520, _stat)
+
+/* Powerdown requests control 0 */
+#define SYSCFG_5000     0x0
+#define SYSSTAT_5500    0x7d0
+/* Powerdown requests control 1 (High Speed Links) */
+#define SYSCFG_5001     0x4
+#define SYSSTAT_5501    0x7d4
+
+/* Ethernet powerdown/status/reset */
+#define SYSCFG_4032     0x80
+#define SYSSTAT_4520    0x820
+#define SYSCFG_4002     0x8
+
+static const struct syscfg_reset_channel_data stih407_powerdowns[] = {
+        [STIH407_EMISS_POWERDOWN] = STIH407_PDN_0(1),
+        [STIH407_NAND_POWERDOWN] = STIH407_PDN_0(0),
+        [STIH407_USB3_POWERDOWN] = STIH407_PDN_1(6),
+        [STIH407_USB2_PORT1_POWERDOWN] = STIH407_PDN_1(5),
+        [STIH407_USB2_PORT0_POWERDOWN] = STIH407_PDN_1(4),
+        [STIH407_PCIE1_POWERDOWN] = STIH407_PDN_1(3),
+        [STIH407_PCIE0_POWERDOWN] = STIH407_PDN_1(2),
+        [STIH407_SATA1_POWERDOWN] = STIH407_PDN_1(1),
+        [STIH407_SATA0_POWERDOWN] = STIH407_PDN_1(0),
+        [STIH407_ETH1_POWERDOWN] = STIH407_PDN_ETH(0, 2),
+};
+
+/* Reset Generator control 0/1 */
+#define SYSCFG_5131     0x20c
+#define SYSCFG_5132     0x210
+
+#define LPM_SYSCFG_1    0x4     /* Softreset IRB & SBC UART */
+
+#define STIH407_SRST_CORE(_reg, _bit) \
+        _SYSCFG_RST_CH_NO_ACK(stih407_core, _reg, _bit)
+
+#define STIH407_SRST_SBC(_reg, _bit) \
+        _SYSCFG_RST_CH_NO_ACK(stih407_sbc_reg, _reg, _bit)
+
+#define STIH407_SRST_LPM(_reg, _bit) \
+        _SYSCFG_RST_CH_NO_ACK(stih407_lpm, _reg, _bit)
+
+static const struct syscfg_reset_channel_data stih407_softresets[] = {
+        [STIH407_ETH1_SOFTRESET] = STIH407_SRST_SBC(SYSCFG_4002, 4),
+        [STIH407_MMC1_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 3),
+        [STIH407_USB2_PORT0_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 28),
+        [STIH407_USB2_PORT1_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 29),
+        [STIH407_PICOPHY_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 30),
+        [STIH407_IRB_SOFTRESET] = STIH407_SRST_LPM(LPM_SYSCFG_1, 6),
+        [STIH407_PCIE0_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 6),
+        [STIH407_PCIE1_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 15),
+        [STIH407_SATA0_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 7),
+        [STIH407_SATA1_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 16),
+        [STIH407_MIPHY0_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 4),
+        [STIH407_MIPHY1_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 13),
+        [STIH407_MIPHY2_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 22),
+        [STIH407_SATA0_PWR_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 5),
+        [STIH407_SATA1_PWR_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 14),
+        [STIH407_DELTA_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 3),
+        [STIH407_BLITTER_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 10),
+        [STIH407_HDTVOUT_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 11),
+        [STIH407_HDQVDP_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 12),
+        [STIH407_VDP_AUX_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 14),
+        [STIH407_COMPO_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 15),
+        [STIH407_HDMI_TX_PHY_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 21),
+        [STIH407_JPEG_DEC_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 23),
+        [STIH407_VP8_DEC_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 24),
+        [STIH407_GPU_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5131, 30),
+        [STIH407_HVA_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 0),
+        [STIH407_ERAM_HVA_SOFTRESET] = STIH407_SRST_CORE(SYSCFG_5132, 1),
+        [STIH407_LPM_SOFTRESET] = STIH407_SRST_SBC(SYSCFG_4002, 2),
+        [STIH407_KEYSCAN_SOFTRESET] = STIH407_SRST_LPM(LPM_SYSCFG_1, 8),
+};
+
+/* PicoPHY reset/control */
+#define SYSCFG_5061     0x0f4
+
+static const struct syscfg_reset_channel_data stih407_picophyresets[] = {
+        [STIH407_PICOPHY0_RESET] = STIH407_SRST_CORE(SYSCFG_5061, 5),
+        [STIH407_PICOPHY1_RESET] = STIH407_SRST_CORE(SYSCFG_5061, 6),
+        [STIH407_PICOPHY2_RESET] = STIH407_SRST_CORE(SYSCFG_5061, 7),
+};
+
+static const struct syscfg_reset_controller_data stih407_powerdown_controller = {
+        .wait_for_ack = true,
+        .nr_channels = ARRAY_SIZE(stih407_powerdowns),
+        .channels = stih407_powerdowns,
+};
+
+static const struct syscfg_reset_controller_data stih407_softreset_controller = {
+        .wait_for_ack = false,
+        .active_low = true,
+        .nr_channels = ARRAY_SIZE(stih407_softresets),
+        .channels = stih407_softresets,
+};
+
+static const struct syscfg_reset_controller_data stih407_picophyreset_controller = {
+        .wait_for_ack = false,
+        .nr_channels = ARRAY_SIZE(stih407_picophyresets),
+        .channels = stih407_picophyresets,
+};
+
+static struct of_device_id stih407_reset_match[] = {
+        {
+                .compatible = "st,stih407-powerdown",
+                .data = &stih407_powerdown_controller,
+        },
+        {
+                .compatible = "st,stih407-softreset",
+                .data = &stih407_softreset_controller,
+        },
+        {
+                .compatible = "st,stih407-picophyreset",
+                .data = &stih407_picophyreset_controller,
+        },
+        { /* sentinel */ },
+};
+
+static struct platform_driver stih407_reset_driver = {
+        .probe = syscfg_reset_probe,
+        .driver = {
+                .name = "reset-stih407",
+                .of_match_table = stih407_reset_match,
+        },
+};
+
+static int __init stih407_reset_init(void)
+{
+        return platform_driver_register(&stih407_reset_driver);
+}
+
+arch_initcall(stih407_reset_init);
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 6dd12ddbabc6..4511ddc1ac31 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -192,6 +192,14 @@ config RTC_DRV_DS1374
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1374.
 
+config RTC_DRV_DS1374_WDT
+        bool "Dallas/Maxim DS1374 watchdog timer"
+        depends on RTC_DRV_DS1374
+        help
+          If you say Y here you will get support for the
+          watchdog timer in the Dallas Semiconductor DS1374
+          real-time clock chips.
+
 config RTC_DRV_DS1672
         tristate "Dallas/Maxim DS1672"
         help
@@ -1109,36 +1117,42 @@ config RTC_DRV_AT91RM9200
           this is powered by the backup power supply.
 
 config RTC_DRV_AT91SAM9
-        tristate "AT91SAM9x/AT91CAP9 RTT as RTC"
-        depends on ARCH_AT91 && !(ARCH_AT91RM9200 || ARCH_AT91X40)
+        tristate "AT91SAM9 RTT as RTC"
+        depends on ARCH_AT91
+        select MFD_SYSCON
         help
-          RTC driver for the Atmel AT91SAM9x and AT91CAP9 internal RTT
-          (Real Time Timer). These timers are powered by the backup power
-          supply (such as a small coin cell battery), but do not need to
-          be used as RTCs.
-
-          (On AT91SAM9rl and AT91SAM9G45 chips you probably want to use the
-          dedicated RTC module and leave the RTT available for other uses.)
+          Some AT91SAM9 SoCs provide an RTT (Real Time Timer) block which
+          can be used as an RTC thanks to the backup power supply (e.g. a
+          small coin cell battery) which keeps this block and the GPBR
+          (General Purpose Backup Registers) block powered when the device
+          is shutdown.
+          Some AT91SAM9 SoCs provide a real RTC block, on those ones you'd
+          probably want to use the real RTC block instead of the "RTT as an
+          RTC" driver.
 
 config RTC_DRV_AT91SAM9_RTT
         int
         range 0 1
         default 0
-        prompt "RTT module Number" if ARCH_AT91SAM9263
         depends on RTC_DRV_AT91SAM9
         help
+          This option is only relevant for legacy board support and
+          won't be used when booting a DT board.
+
           More than one RTT module is available. You can choose which
           one will be used as an RTC. The default of zero is normally
           OK to use, though some systems use that for non-RTC purposes.
 
 config RTC_DRV_AT91SAM9_GPBR
         int
-        range 0 3 if !ARCH_AT91SAM9263
-        range 0 15 if ARCH_AT91SAM9263
+        range 0 3
         default 0
         prompt "Backup Register Number"
         depends on RTC_DRV_AT91SAM9
         help
+          This option is only relevant for legacy board support and
+          won't be used when booting a DT board.
+
           The RTC driver needs to use one of the General Purpose Backup
           Registers (GPBRs) as well as the RTT. You can choose which one
           will be used. The default of zero is normally OK to use, but
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 38e26be705be..472a5adc4642 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -45,14 +45,14 @@ int rtc_hctosys_ret = -ENODEV;
  * system's wall clock; restore it on resume().
  */
 
-static struct timespec old_rtc, old_system, old_delta;
+static struct timespec64 old_rtc, old_system, old_delta;
 
 
 static int rtc_suspend(struct device *dev)
 {
         struct rtc_device       *rtc = to_rtc_device(dev);
         struct rtc_time         tm;
-        struct timespec         delta, delta_delta;
+        struct timespec64       delta, delta_delta;
         int err;
 
         if (has_persistent_clock())
@@ -68,8 +68,8 @@ static int rtc_suspend(struct device *dev)
                 return 0;
         }
 
-        getnstimeofday(&old_system);
-        rtc_tm_to_time(&tm, &old_rtc.tv_sec);
+        getnstimeofday64(&old_system);
+        old_rtc.tv_sec = rtc_tm_to_time64(&tm);
 
 
         /*
@@ -78,8 +78,8 @@ static int rtc_suspend(struct device *dev)
          * try to compensate so the difference in system time
          * and rtc time stays close to constant.
          */
-        delta = timespec_sub(old_system, old_rtc);
-        delta_delta = timespec_sub(delta, old_delta);
+        delta = timespec64_sub(old_system, old_rtc);
+        delta_delta = timespec64_sub(delta, old_delta);
         if (delta_delta.tv_sec < -2 || delta_delta.tv_sec >= 2) {
                 /*
                  * if delta_delta is too large, assume time correction
@@ -88,7 +88,7 @@ static int rtc_suspend(struct device *dev)
                 old_delta = delta;
         } else {
                 /* Otherwise try to adjust old_system to compensate */
-                old_system = timespec_sub(old_system, delta_delta);
+                old_system = timespec64_sub(old_system, delta_delta);
         }
 
         return 0;
@@ -98,8 +98,8 @@ static int rtc_resume(struct device *dev)
 {
         struct rtc_device       *rtc = to_rtc_device(dev);
         struct rtc_time         tm;
-        struct timespec         new_system, new_rtc;
-        struct timespec         sleep_time;
+        struct timespec64       new_system, new_rtc;
+        struct timespec64       sleep_time;
         int err;
 
         if (has_persistent_clock())
@@ -110,7 +110,7 @@ static int rtc_resume(struct device *dev)
                 return 0;
 
         /* snapshot the current rtc and system time at resume */
-        getnstimeofday(&new_system);
+        getnstimeofday64(&new_system);
         err = rtc_read_time(rtc, &tm);
         if (err < 0) {
                 pr_debug("%s:  fail to read rtc time\n", dev_name(&rtc->dev));
@@ -121,7 +121,7 @@ static int rtc_resume(struct device *dev)
                 pr_debug("%s:  bogus resume time\n", dev_name(&rtc->dev));
                 return 0;
         }
-        rtc_tm_to_time(&tm, &new_rtc.tv_sec);
+        new_rtc.tv_sec = rtc_tm_to_time64(&tm);
         new_rtc.tv_nsec = 0;
 
         if (new_rtc.tv_sec < old_rtc.tv_sec) {
@@ -130,7 +130,7 @@ static int rtc_resume(struct device *dev)
         }
 
         /* calculate the RTC time delta (sleep time)*/
-        sleep_time = timespec_sub(new_rtc, old_rtc);
+        sleep_time = timespec64_sub(new_rtc, old_rtc);
 
         /*
          * Since these RTC suspend/resume handlers are not called
@@ -139,11 +139,11 @@ static int rtc_resume(struct device *dev)
          * so subtract kernel run-time between rtc_suspend to rtc_resume
          * to keep things accurate.
          */
-        sleep_time = timespec_sub(sleep_time,
-                        timespec_sub(new_system, old_system));
+        sleep_time = timespec64_sub(sleep_time,
+                        timespec64_sub(new_system, old_system));
 
         if (sleep_time.tv_sec >= 0)
-                timekeeping_inject_sleeptime(&sleep_time);
+                timekeeping_inject_sleeptime64(&sleep_time);
         rtc_hctosys_ret = 0;
         return 0;
 }
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 5b2717f5dafa..45bfc28ee3aa 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -30,6 +30,14 @@ static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
         else {
                 memset(tm, 0, sizeof(struct rtc_time));
                 err = rtc->ops->read_time(rtc->dev.parent, tm);
+                if (err < 0) {
+                        dev_err(&rtc->dev, "read_time: fail to read\n");
+                        return err;
+                }
+
+                err = rtc_valid_tm(tm);
+                if (err < 0)
+                        dev_err(&rtc->dev, "read_time: rtc_time isn't valid\n");
         }
         return err;
 }
@@ -891,11 +899,24 @@ again:
         if (next) {
                 struct rtc_wkalrm alarm;
                 int err;
+                int retry = 3;
+
                 alarm.time = rtc_ktime_to_tm(next->expires);
                 alarm.enabled = 1;
+reprogram:
                 err = __rtc_set_alarm(rtc, &alarm);
                 if (err == -ETIME)
                         goto again;
+                else if (err) {
+                        if (retry-- > 0)
+                                goto reprogram;
+
+                        timer = container_of(next, struct rtc_timer, node);
+                        timerqueue_del(&rtc->timerqueue, &timer->node);
+                        timer->enabled = 0;
+                        dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);
+                        goto again;
+                }
         } else
                 rtc_alarm_disable(rtc);
 
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index 727e2f5d14d9..866e0ef5122d 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -504,6 +504,8 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
                 return err;
         }
 
+        rtc->uie_unsupported = 1;
+
         return 0;
 }
 
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index 596374304532..abac38abd38e 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -21,10 +21,9 @@
 #include <linux/slab.h>
 #include <linux/platform_data/atmel.h>
 #include <linux/io.h>
-
-#include <mach/at91_rtt.h>
-#include <mach/cpu.h>
-#include <mach/hardware.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
+#include <linux/clk.h>
 
 /*
  * This driver uses two configurable hardware resources that live in the
@@ -47,6 +46,22 @@
  * registers available, likewise usable for more than "RTC" support.
  */
 
+#define AT91_RTT_MR             0x00                    /* Real-time Mode Register */
+#define AT91_RTT_RTPRES         (0xffff << 0)           /* Real-time Timer Prescaler Value */
+#define AT91_RTT_ALMIEN         (1 << 16)               /* Alarm Interrupt Enable */
+#define AT91_RTT_RTTINCIEN      (1 << 17)               /* Real Time Timer Increment Interrupt Enable */
+#define AT91_RTT_RTTRST         (1 << 18)               /* Real Time Timer Restart */
+
+#define AT91_RTT_AR             0x04                    /* Real-time Alarm Register */
+#define AT91_RTT_ALMV           (0xffffffff)            /* Alarm Value */
+
+#define AT91_RTT_VR             0x08                    /* Real-time Value Register */
+#define AT91_RTT_CRTV           (0xffffffff)            /* Current Real-time Value */
+
+#define AT91_RTT_SR             0x0c                    /* Real-time Status Register */
+#define AT91_RTT_ALMS           (1 << 0)                /* Real-time Alarm Status */
+#define AT91_RTT_RTTINC         (1 << 1)                /* Real-time Timer Increment */
+
 /*
  * We store ALARM_DISABLED in ALMV to record that no alarm is set.
  * It's also the reset value for that field.
@@ -58,19 +73,30 @@ struct sam9_rtc {
         void __iomem            *rtt;
         struct rtc_device       *rtcdev;
         u32                     imr;
-        void __iomem            *gpbr;
+        struct regmap           *gpbr;
+        unsigned int            gpbr_offset;
         int                     irq;
+        struct clk              *sclk;
 };
 
 #define rtt_readl(rtc, field) \
-        __raw_readl((rtc)->rtt + AT91_RTT_ ## field)
+        readl((rtc)->rtt + AT91_RTT_ ## field)
 #define rtt_writel(rtc, field, val) \
-        __raw_writel((val), (rtc)->rtt + AT91_RTT_ ## field)
+        writel((val), (rtc)->rtt + AT91_RTT_ ## field)
+
+static inline unsigned int gpbr_readl(struct sam9_rtc *rtc)
+{
+        unsigned int val;
+
+        regmap_read(rtc->gpbr, rtc->gpbr_offset, &val);
 
-#define gpbr_readl(rtc) \
-        __raw_readl((rtc)->gpbr)
-#define gpbr_writel(rtc, val) \
-        __raw_writel((val), (rtc)->gpbr)
+        return val;
+}
+
+static inline void gpbr_writel(struct sam9_rtc *rtc, unsigned int val)
+{
+        regmap_write(rtc->gpbr, rtc->gpbr_offset, val);
+}
 
 /*
  * Read current time and date in RTC
@@ -287,22 +313,22 @@ static const struct rtc_class_ops at91_rtc_ops = {
         .alarm_irq_enable = at91_rtc_alarm_irq_enable,
 };
 
+static struct regmap_config gpbr_regmap_config = {
+        .reg_bits = 32,
+        .val_bits = 32,
+        .reg_stride = 4,
+};
+
 /*
  * Initialize and install RTC driver
  */
 static int at91_rtc_probe(struct platform_device *pdev)
 {
-        struct resource *r, *r_gpbr;
+        struct resource *r;
         struct sam9_rtc *rtc;
         int             ret, irq;
         u32             mr;
-
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        r_gpbr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        if (!r || !r_gpbr) {
-                dev_err(&pdev->dev, "need 2 ressources\n");
-                return -ENODEV;
-        }
+        unsigned int    sclk_rate;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
@@ -321,24 +347,66 @@ static int at91_rtc_probe(struct platform_device *pdev)
                 device_init_wakeup(&pdev->dev, 1);
 
         platform_set_drvdata(pdev, rtc);
-        rtc->rtt = devm_ioremap(&pdev->dev, r->start, resource_size(r));
-        if (!rtc->rtt) {
-                dev_err(&pdev->dev, "failed to map registers, aborting.\n");
-                return -ENOMEM;
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        rtc->rtt = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(rtc->rtt))
+                return PTR_ERR(rtc->rtt);
+
+        if (!pdev->dev.of_node) {
+                /*
+                 * TODO: Remove this code chunk when removing non DT board
+                 * support. Remember to remove the gpbr_regmap_config
+                 * variable too.
+                 */
+                void __iomem *gpbr;
+
+                r = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+                gpbr = devm_ioremap_resource(&pdev->dev, r);
+                if (IS_ERR(gpbr))
+                        return PTR_ERR(gpbr);
+
+                rtc->gpbr = regmap_init_mmio(NULL, gpbr,
+                                             &gpbr_regmap_config);
+        } else {
+                struct of_phandle_args args;
+
+                ret = of_parse_phandle_with_fixed_args(pdev->dev.of_node,
+                                                "atmel,rtt-rtc-time-reg", 1, 0,
+                                                &args);
+                if (ret)
+                        return ret;
+
+                rtc->gpbr = syscon_node_to_regmap(args.np);
+                rtc->gpbr_offset = args.args[0];
         }
 
-        rtc->gpbr = devm_ioremap(&pdev->dev, r_gpbr->start,
-                                resource_size(r_gpbr));
-        if (!rtc->gpbr) {
-                dev_err(&pdev->dev, "failed to map gpbr registers, aborting.\n");
+        if (IS_ERR(rtc->gpbr)) {
+                dev_err(&pdev->dev, "failed to retrieve gpbr regmap, aborting.\n");
                 return -ENOMEM;
         }
 
+        rtc->sclk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(rtc->sclk))
+                return PTR_ERR(rtc->sclk);
+
+        sclk_rate = clk_get_rate(rtc->sclk);
+        if (!sclk_rate || sclk_rate > AT91_RTT_RTPRES) {
+                dev_err(&pdev->dev, "Invalid slow clock rate\n");
+                return -EINVAL;
+        }
+
+        ret = clk_prepare_enable(rtc->sclk);
+        if (ret) {
+                dev_err(&pdev->dev, "Could not enable slow clock\n");
+                return ret;
+        }
+
         mr = rtt_readl(rtc, MR);
 
         /* unless RTT is counting at 1 Hz, re-initialize it */
-        if ((mr & AT91_RTT_RTPRES) != AT91_SLOW_CLOCK) {
-                mr = AT91_RTT_RTTRST | (AT91_SLOW_CLOCK & AT91_RTT_RTPRES);
+        if ((mr & AT91_RTT_RTPRES) != sclk_rate) {
+                mr = AT91_RTT_RTTRST | (sclk_rate & AT91_RTT_RTPRES);
                 gpbr_writel(rtc, 0);
         }
 
@@ -383,6 +451,9 @@ static int at91_rtc_remove(struct platform_device *pdev)
         /* disable all interrupts */
         rtt_writel(rtc, MR, mr & ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN));
 
+        if (!IS_ERR(rtc->sclk))
+                clk_disable_unprepare(rtc->sclk);
+
         return 0;
 }
 
@@ -440,6 +511,14 @@ static int at91_rtc_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(at91_rtc_pm_ops, at91_rtc_suspend, at91_rtc_resume);
 
+#ifdef CONFIG_OF
+static const struct of_device_id at91_rtc_dt_ids[] = {
+        { .compatible = "atmel,at91sam9260-rtt" },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, at91_rtc_dt_ids);
+#endif
+
 static struct platform_driver at91_rtc_driver = {
         .probe          = at91_rtc_probe,
         .remove         = at91_rtc_remove,
@@ -448,6 +527,7 @@ static struct platform_driver at91_rtc_driver = {
                 .name   = "rtc-at91sam9",
                 .owner  = THIS_MODULE,
                 .pm     = &at91_rtc_pm_ops,
+                .of_match_table = of_match_ptr(at91_rtc_dt_ids),
         },
 };
 
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index bb43cf703efc..4ffabb322a9a 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -35,7 +35,7 @@ enum ds_type {
         ds_1388,
         ds_3231,
         m41t00,
-        mcp7941x,
+        mcp794xx,
         rx_8025,
         last_ds_type /* always last */
         /* rs5c372 too?  different address... */
@@ -46,7 +46,7 @@ enum ds_type {
 #define DS1307_REG_SECS         0x00    /* 00-59 */
 #       define DS1307_BIT_CH            0x80
 #       define DS1340_BIT_nEOSC         0x80
-#       define MCP7941X_BIT_ST          0x80
+#       define MCP794XX_BIT_ST          0x80
 #define DS1307_REG_MIN          0x01    /* 00-59 */
 #define DS1307_REG_HOUR         0x02    /* 00-23, or 1-12{am,pm} */
 #       define DS1307_BIT_12HR          0x40    /* in REG_HOUR */
@@ -54,7 +54,7 @@ enum ds_type {
 #       define DS1340_BIT_CENTURY_EN    0x80    /* in REG_HOUR */
 #       define DS1340_BIT_CENTURY       0x40    /* in REG_HOUR */
 #define DS1307_REG_WDAY         0x03    /* 01-07 */
-#       define MCP7941X_BIT_VBATEN      0x08
+#       define MCP794XX_BIT_VBATEN      0x08
 #define DS1307_REG_MDAY         0x04    /* 01-31 */
 #define DS1307_REG_MONTH        0x05    /* 01-12 */
 #       define DS1337_BIT_CENTURY       0x80    /* in REG_MONTH */
@@ -159,7 +159,7 @@ static struct chip_desc chips[last_ds_type] = {
         [ds_3231] = {
                 .alarm          = 1,
         },
-        [mcp7941x] = {
+        [mcp794xx] = {
                 .alarm          = 1,
                 /* this is battery backed SRAM */
                 .nvram_offset   = 0x20,
@@ -176,7 +176,8 @@ static const struct i2c_device_id ds1307_id[] = {
         { "ds1340", ds_1340 },
         { "ds3231", ds_3231 },
         { "m41t00", m41t00 },
-        { "mcp7941x", mcp7941x },
+        { "mcp7940x", mcp794xx },
+        { "mcp7941x", mcp794xx },
         { "pt7c4338", ds_1307 },
         { "rx8025", rx_8025 },
         { }
@@ -439,14 +440,14 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t)
                 buf[DS1307_REG_HOUR] |= DS1340_BIT_CENTURY_EN
                                 | DS1340_BIT_CENTURY;
                 break;
-        case mcp7941x:
+        case mcp794xx:
                 /*
                  * these bits were cleared when preparing the date/time
                  * values and need to be set again before writing the
                  * buffer out to the device.
                  */
-                buf[DS1307_REG_SECS] |= MCP7941X_BIT_ST;
-                buf[DS1307_REG_WDAY] |= MCP7941X_BIT_VBATEN;
+                buf[DS1307_REG_SECS] |= MCP794XX_BIT_ST;
+                buf[DS1307_REG_WDAY] |= MCP794XX_BIT_VBATEN;
                 break;
         default:
                 break;
@@ -614,26 +615,26 @@ static const struct rtc_class_ops ds13xx_rtc_ops = {
 /*----------------------------------------------------------------------*/
 
 /*
- * Alarm support for mcp7941x devices.
+ * Alarm support for mcp794xx devices.
  */
 
-#define MCP7941X_REG_CONTROL            0x07
-#       define MCP7941X_BIT_ALM0_EN     0x10
-#       define MCP7941X_BIT_ALM1_EN     0x20
-#define MCP7941X_REG_ALARM0_BASE        0x0a
-#define MCP7941X_REG_ALARM0_CTRL        0x0d
-#define MCP7941X_REG_ALARM1_BASE        0x11
-#define MCP7941X_REG_ALARM1_CTRL        0x14
-#       define MCP7941X_BIT_ALMX_IF     (1 << 3)
-#       define MCP7941X_BIT_ALMX_C0     (1 << 4)
-#       define MCP7941X_BIT_ALMX_C1     (1 << 5)
-#       define MCP7941X_BIT_ALMX_C2     (1 << 6)
-#       define MCP7941X_BIT_ALMX_POL    (1 << 7)
-#       define MCP7941X_MSK_ALMX_MATCH  (MCP7941X_BIT_ALMX_C0 | \
-                                         MCP7941X_BIT_ALMX_C1 | \
-                                         MCP7941X_BIT_ALMX_C2)
-
-static void mcp7941x_work(struct work_struct *work)
+#define MCP794XX_REG_CONTROL            0x07
+#       define MCP794XX_BIT_ALM0_EN     0x10
+#       define MCP794XX_BIT_ALM1_EN     0x20
+#define MCP794XX_REG_ALARM0_BASE        0x0a
+#define MCP794XX_REG_ALARM0_CTRL        0x0d
+#define MCP794XX_REG_ALARM1_BASE        0x11
+#define MCP794XX_REG_ALARM1_CTRL        0x14
+#       define MCP794XX_BIT_ALMX_IF     (1 << 3)
+#       define MCP794XX_BIT_ALMX_C0     (1 << 4)
+#       define MCP794XX_BIT_ALMX_C1     (1 << 5)
+#       define MCP794XX_BIT_ALMX_C2     (1 << 6)
+#       define MCP794XX_BIT_ALMX_POL    (1 << 7)
+#       define MCP794XX_MSK_ALMX_MATCH  (MCP794XX_BIT_ALMX_C0 | \
+                                         MCP794XX_BIT_ALMX_C1 | \
+                                         MCP794XX_BIT_ALMX_C2)
+
+static void mcp794xx_work(struct work_struct *work)
 {
         struct ds1307 *ds1307 = container_of(work, struct ds1307, work);
         struct i2c_client *client = ds1307->client;
@@ -642,22 +643,22 @@ static void mcp7941x_work(struct work_struct *work)
         mutex_lock(&ds1307->rtc->ops_lock);
 
         /* Check and clear alarm 0 interrupt flag. */
-        reg = i2c_smbus_read_byte_data(client, MCP7941X_REG_ALARM0_CTRL);
+        reg = i2c_smbus_read_byte_data(client, MCP794XX_REG_ALARM0_CTRL);
         if (reg < 0)
                 goto out;
-        if (!(reg & MCP7941X_BIT_ALMX_IF))
+        if (!(reg & MCP794XX_BIT_ALMX_IF))
                 goto out;
-        reg &= ~MCP7941X_BIT_ALMX_IF;
-        ret = i2c_smbus_write_byte_data(client, MCP7941X_REG_ALARM0_CTRL, reg);
+        reg &= ~MCP794XX_BIT_ALMX_IF;
+        ret = i2c_smbus_write_byte_data(client, MCP794XX_REG_ALARM0_CTRL, reg);
         if (ret < 0)
                 goto out;
 
         /* Disable alarm 0. */
-        reg = i2c_smbus_read_byte_data(client, MCP7941X_REG_CONTROL);
+        reg = i2c_smbus_read_byte_data(client, MCP794XX_REG_CONTROL);
         if (reg < 0)
                 goto out;
-        reg &= ~MCP7941X_BIT_ALM0_EN;
-        ret = i2c_smbus_write_byte_data(client, MCP7941X_REG_CONTROL, reg);
+        reg &= ~MCP794XX_BIT_ALM0_EN;
+        ret = i2c_smbus_write_byte_data(client, MCP794XX_REG_CONTROL, reg);
         if (ret < 0)
                 goto out;
 
@@ -669,7 +670,7 @@ out:
         mutex_unlock(&ds1307->rtc->ops_lock);
 }
 
-static int mcp7941x_read_alarm(struct device *dev, struct rtc_wkalrm *t)
+static int mcp794xx_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 {
         struct i2c_client *client = to_i2c_client(dev);
         struct ds1307 *ds1307 = i2c_get_clientdata(client);
@@ -680,11 +681,11 @@ static int mcp7941x_read_alarm(struct device *dev, struct rtc_wkalrm *t)
                 return -EINVAL;
 
         /* Read control and alarm 0 registers. */
-        ret = ds1307->read_block_data(client, MCP7941X_REG_CONTROL, 10, regs);
+        ret = ds1307->read_block_data(client, MCP794XX_REG_CONTROL, 10, regs);
         if (ret < 0)
                 return ret;
 
-        t->enabled = !!(regs[0] & MCP7941X_BIT_ALM0_EN);
+        t->enabled = !!(regs[0] & MCP794XX_BIT_ALM0_EN);
 
         /* Report alarm 0 time assuming 24-hour and day-of-month modes. */
         t->time.tm_sec = bcd2bin(ds1307->regs[3] & 0x7f);
@@ -701,14 +702,14 @@ static int mcp7941x_read_alarm(struct device *dev, struct rtc_wkalrm *t)
                 "enabled=%d polarity=%d irq=%d match=%d\n", __func__,
                 t->time.tm_sec, t->time.tm_min, t->time.tm_hour,
                 t->time.tm_wday, t->time.tm_mday, t->time.tm_mon, t->enabled,
-                !!(ds1307->regs[6] & MCP7941X_BIT_ALMX_POL),
-                !!(ds1307->regs[6] & MCP7941X_BIT_ALMX_IF),
-                (ds1307->regs[6] & MCP7941X_MSK_ALMX_MATCH) >> 4);
+                !!(ds1307->regs[6] & MCP794XX_BIT_ALMX_POL),
+                !!(ds1307->regs[6] & MCP794XX_BIT_ALMX_IF),
+                (ds1307->regs[6] & MCP794XX_MSK_ALMX_MATCH) >> 4);
 
         return 0;
 }
 
-static int mcp7941x_set_alarm(struct device *dev, struct rtc_wkalrm *t)
+static int mcp794xx_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 {
         struct i2c_client *client = to_i2c_client(dev);
         struct ds1307 *ds1307 = i2c_get_clientdata(client);
@@ -725,7 +726,7 @@ static int mcp7941x_set_alarm(struct device *dev, struct rtc_wkalrm *t)
                 t->enabled, t->pending);
 
         /* Read control and alarm 0 registers. */
-        ret = ds1307->read_block_data(client, MCP7941X_REG_CONTROL, 10, regs);
+        ret = ds1307->read_block_data(client, MCP794XX_REG_CONTROL, 10, regs);
         if (ret < 0)
                 return ret;
 
@@ -738,23 +739,23 @@ static int mcp7941x_set_alarm(struct device *dev, struct rtc_wkalrm *t)
         regs[8] = bin2bcd(t->time.tm_mon) + 1;
 
         /* Clear the alarm 0 interrupt flag. */
-        regs[6] &= ~MCP7941X_BIT_ALMX_IF;
+        regs[6] &= ~MCP794XX_BIT_ALMX_IF;
         /* Set alarm match: second, minute, hour, day, date, month. */
-        regs[6] |= MCP7941X_MSK_ALMX_MATCH;
+        regs[6] |= MCP794XX_MSK_ALMX_MATCH;
 
         if (t->enabled)
-                regs[0] |= MCP7941X_BIT_ALM0_EN;
+                regs[0] |= MCP794XX_BIT_ALM0_EN;
         else
-                regs[0] &= ~MCP7941X_BIT_ALM0_EN;
+                regs[0] &= ~MCP794XX_BIT_ALM0_EN;
 
-        ret = ds1307->write_block_data(client, MCP7941X_REG_CONTROL, 10, regs);
+        ret = ds1307->write_block_data(client, MCP794XX_REG_CONTROL, 10, regs);
         if (ret < 0)
                 return ret;
 
         return 0;
 }
 
-static int mcp7941x_alarm_irq_enable(struct device *dev, unsigned int enabled)
+static int mcp794xx_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         struct i2c_client *client = to_i2c_client(dev);
         struct ds1307 *ds1307 = i2c_get_clientdata(client);
@@ -763,24 +764,24 @@ static int mcp7941x_alarm_irq_enable(struct device *dev, unsigned int enabled)
         if (!test_bit(HAS_ALARM, &ds1307->flags))
                 return -EINVAL;
 
-        reg = i2c_smbus_read_byte_data(client, MCP7941X_REG_CONTROL);
+        reg = i2c_smbus_read_byte_data(client, MCP794XX_REG_CONTROL);
         if (reg < 0)
                 return reg;
 
         if (enabled)
-                reg |= MCP7941X_BIT_ALM0_EN;
+                reg |= MCP794XX_BIT_ALM0_EN;
         else
-                reg &= ~MCP7941X_BIT_ALM0_EN;
+                reg &= ~MCP794XX_BIT_ALM0_EN;
 
-        return i2c_smbus_write_byte_data(client, MCP7941X_REG_CONTROL, reg);
+        return i2c_smbus_write_byte_data(client, MCP794XX_REG_CONTROL, reg);
 }
 
-static const struct rtc_class_ops mcp7941x_rtc_ops = {
+static const struct rtc_class_ops mcp794xx_rtc_ops = {
         .read_time      = ds1307_get_time,
         .set_time       = ds1307_set_time,
-        .read_alarm     = mcp7941x_read_alarm,
-        .set_alarm      = mcp7941x_set_alarm,
-        .alarm_irq_enable = mcp7941x_alarm_irq_enable,
+        .read_alarm     = mcp794xx_read_alarm,
+        .set_alarm      = mcp794xx_set_alarm,
+        .alarm_irq_enable = mcp794xx_alarm_irq_enable,
 };
 
 /*----------------------------------------------------------------------*/
@@ -1049,10 +1050,10 @@ static int ds1307_probe(struct i2c_client *client,
         case ds_1388:
                 ds1307->offset = 1; /* Seconds starts at 1 */
                 break;
-        case mcp7941x:
-                rtc_ops = &mcp7941x_rtc_ops;
+        case mcp794xx:
+                rtc_ops = &mcp794xx_rtc_ops;
                 if (ds1307->client->irq > 0 && chip->alarm) {
-                        INIT_WORK(&ds1307->work, mcp7941x_work);
+                        INIT_WORK(&ds1307->work, mcp794xx_work);
                         want_irq = true;
                 }
                 break;
@@ -1117,18 +1118,18 @@ read_rtc:
                         dev_warn(&client->dev, "SET TIME!\n");
                 }
                 break;
-        case mcp7941x:
+        case mcp794xx:
                 /* make sure that the backup battery is enabled */
-                if (!(ds1307->regs[DS1307_REG_WDAY] & MCP7941X_BIT_VBATEN)) {
+                if (!(ds1307->regs[DS1307_REG_WDAY] & MCP794XX_BIT_VBATEN)) {
                         i2c_smbus_write_byte_data(client, DS1307_REG_WDAY,
                                         ds1307->regs[DS1307_REG_WDAY]
-                                        | MCP7941X_BIT_VBATEN);
+                                        | MCP794XX_BIT_VBATEN);
                 }
 
                 /* clock halted?  turn it on, so clock can tick. */
-                if (!(tmp & MCP7941X_BIT_ST)) {
+                if (!(tmp & MCP794XX_BIT_ST)) {
                         i2c_smbus_write_byte_data(client, DS1307_REG_SECS,
-                                        MCP7941X_BIT_ST);
+                                        MCP794XX_BIT_ST);
                         dev_warn(&client->dev, "SET TIME!\n");
                         goto read_rtc;
                 }
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 9e6e14fb53d7..8605fde394b2 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -4,6 +4,7 @@
  * Based on code by Randy Vinson <rvinson@mvista.com>,
  * which was based on the m41t00.c by Mark Greer <mgreer@mvista.com>.
  *
+ * Copyright (C) 2014 Rose Technology
  * Copyright (C) 2006-2007 Freescale Semiconductor
  *
  * 2005 (c) MontaVista Software, Inc. This file is licensed under
@@ -26,6 +27,13 @@
 #include <linux/workqueue.h>
 #include <linux/slab.h>
 #include <linux/pm.h>
+#ifdef CONFIG_RTC_DRV_DS1374_WDT
+#include <linux/fs.h>
+#include <linux/ioctl.h>
+#include <linux/miscdevice.h>
+#include <linux/reboot.h>
+#include <linux/watchdog.h>
+#endif
 
 #define DS1374_REG_TOD0         0x00 /* Time of Day */
 #define DS1374_REG_TOD1         0x01
@@ -49,6 +57,14 @@ static const struct i2c_device_id ds1374_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, ds1374_id);
 
+#ifdef CONFIG_OF
+static const struct of_device_id ds1374_of_match[] = {
+        { .compatible = "dallas,ds1374" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, ds1374_of_match);
+#endif
+
 struct ds1374 {
         struct i2c_client *client;
         struct rtc_device *rtc;
@@ -162,6 +178,7 @@ static int ds1374_set_time(struct device *dev, struct rtc_time *time)
         return ds1374_write_rtc(client, itime, DS1374_REG_TOD0, 4);
 }
 
+#ifndef CONFIG_RTC_DRV_DS1374_WDT
 /* The ds1374 has a decrementer for an alarm, rather than a comparator.
  * If the time of day is changed, then the alarm will need to be
  * reset.
@@ -263,6 +280,7 @@ out:
         mutex_unlock(&ds1374->mutex);
         return ret;
 }
+#endif
 
 static irqreturn_t ds1374_irq(int irq, void *dev_id)
 {
@@ -307,6 +325,7 @@ unlock:
         mutex_unlock(&ds1374->mutex);
 }
 
+#ifndef CONFIG_RTC_DRV_DS1374_WDT
 static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         struct i2c_client *client = to_i2c_client(dev);
@@ -331,15 +350,260 @@ out:
         mutex_unlock(&ds1374->mutex);
         return ret;
 }
+#endif
 
 static const struct rtc_class_ops ds1374_rtc_ops = {
         .read_time = ds1374_read_time,
         .set_time = ds1374_set_time,
+#ifndef CONFIG_RTC_DRV_DS1374_WDT
         .read_alarm = ds1374_read_alarm,
         .set_alarm = ds1374_set_alarm,
         .alarm_irq_enable = ds1374_alarm_irq_enable,
+#endif
+};
+
+#ifdef CONFIG_RTC_DRV_DS1374_WDT
+/*
+ *****************************************************************************
+ *
+ * Watchdog Driver
+ *
+ *****************************************************************************
+ */
+static struct i2c_client *save_client;
+/* Default margin */
+#define WD_TIMO 131762
+
+#define DRV_NAME "DS1374 Watchdog"
+
+static int wdt_margin = WD_TIMO;
+static unsigned long wdt_is_open;
+module_param(wdt_margin, int, 0);
+MODULE_PARM_DESC(wdt_margin, "Watchdog timeout in seconds (default 32s)");
+
+static const struct watchdog_info ds1374_wdt_info = {
+        .identity       = "DS1374 WTD",
+        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                                                WDIOF_MAGICCLOSE,
 };
 
+static int ds1374_wdt_settimeout(unsigned int timeout)
+{
+        int ret = -ENOIOCTLCMD;
+        int cr;
+
+        ret = cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR);
+        if (ret < 0)
+                goto out;
+
+        /* Disable any existing watchdog/alarm before setting the new one */
+        cr &= ~DS1374_REG_CR_WACE;
+
+        ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr);
+        if (ret < 0)
+                goto out;
+
+        /* Set new watchdog time */
+        ret = ds1374_write_rtc(save_client, timeout, DS1374_REG_WDALM0, 3);
+        if (ret) {
+                pr_info("rtc-ds1374 - couldn't set new watchdog time\n");
+                goto out;
+        }
+
+        /* Enable watchdog timer */
+        cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_WDALM;
+        cr &= ~DS1374_REG_CR_AIE;
+
+        ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr);
+        if (ret < 0)
+                goto out;
+
+        return 0;
+out:
+        return ret;
+}
+
+
+/*
+ * Reload the watchdog timer.  (ie, pat the watchdog)
+ */
+static void ds1374_wdt_ping(void)
+{
+        u32 val;
+        int ret = 0;
+
+        ret = ds1374_read_rtc(save_client, &val, DS1374_REG_WDALM0, 3);
+        if (ret)
+                pr_info("WD TICK FAIL!!!!!!!!!! %i\n", ret);
+}
+
+static void ds1374_wdt_disable(void)
+{
+        int ret = -ENOIOCTLCMD;
+        int cr;
+
+        cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR);
+        /* Disable watchdog timer */
+        cr &= ~DS1374_REG_CR_WACE;
+
+        ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr);
+}
+
+/*
+ * Watchdog device is opened, and watchdog starts running.
+ */
+static int ds1374_wdt_open(struct inode *inode, struct file *file)
+{
+        struct ds1374 *ds1374 = i2c_get_clientdata(save_client);
+
+        if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) {
+                mutex_lock(&ds1374->mutex);
+                if (test_and_set_bit(0, &wdt_is_open)) {
+                        mutex_unlock(&ds1374->mutex);
+                        return -EBUSY;
+                }
+                /*
+                 *      Activate
+                 */
+                wdt_is_open = 1;
+                mutex_unlock(&ds1374->mutex);
+                return nonseekable_open(inode, file);
+        }
+        return -ENODEV;
+}
+
+/*
+ * Close the watchdog device.
+ */
+static int ds1374_wdt_release(struct inode *inode, struct file *file)
+{
+        if (MINOR(inode->i_rdev) == WATCHDOG_MINOR)
+                clear_bit(0, &wdt_is_open);
+
+        return 0;
+}
+
+/*
+ * Pat the watchdog whenever device is written to.
+ */
+static ssize_t ds1374_wdt_write(struct file *file, const char __user *data,
+                                size_t len, loff_t *ppos)
+{
+        if (len) {
+                ds1374_wdt_ping();
+                return 1;
+        }
+        return 0;
+}
+
+static ssize_t ds1374_wdt_read(struct file *file, char __user *data,
+                                size_t len, loff_t *ppos)
+{
+        return 0;
+}
+
+/*
+ * Handle commands from user-space.
+ */
+static long ds1374_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
+{
+        int new_margin, options;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user((struct watchdog_info __user *)arg,
+                &ds1374_wdt_info, sizeof(ds1374_wdt_info)) ? -EFAULT : 0;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, (int __user *)arg);
+        case WDIOC_KEEPALIVE:
+                ds1374_wdt_ping();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_margin, (int __user *)arg))
+                        return -EFAULT;
+
+                if (new_margin < 1 || new_margin > 16777216)
+                        return -EINVAL;
+
+                wdt_margin = new_margin;
+                ds1374_wdt_settimeout(new_margin);
+                ds1374_wdt_ping();
+                /* fallthrough */
+        case WDIOC_GETTIMEOUT:
+                return put_user(wdt_margin, (int __user *)arg);
+        case WDIOC_SETOPTIONS:
+                if (copy_from_user(&options, (int __user *)arg, sizeof(int)))
+                        return -EFAULT;
+
+                if (options & WDIOS_DISABLECARD) {
+                        pr_info("rtc-ds1374: disable watchdog\n");
+                        ds1374_wdt_disable();
+                }
+
+                if (options & WDIOS_ENABLECARD) {
+                        pr_info("rtc-ds1374: enable watchdog\n");
+                        ds1374_wdt_settimeout(wdt_margin);
+                        ds1374_wdt_ping();
+                }
+
+                return -EINVAL;
+        }
+        return -ENOTTY;
+}
+
+static long ds1374_wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
+                        unsigned long arg)
+{
+        int ret;
+        struct ds1374 *ds1374 = i2c_get_clientdata(save_client);
+
+        mutex_lock(&ds1374->mutex);
+        ret = ds1374_wdt_ioctl(file, cmd, arg);
+        mutex_unlock(&ds1374->mutex);
+
+        return ret;
+}
+
+static int ds1374_wdt_notify_sys(struct notifier_block *this,
+                        unsigned long code, void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT)
+                /* Disable Watchdog */
+                ds1374_wdt_disable();
+        return NOTIFY_DONE;
+}
+
+static const struct file_operations ds1374_wdt_fops = {
+        .owner                  = THIS_MODULE,
+        .read                   = ds1374_wdt_read,
+        .unlocked_ioctl         = ds1374_wdt_unlocked_ioctl,
+        .write                  = ds1374_wdt_write,
+        .open                   = ds1374_wdt_open,
+        .release                = ds1374_wdt_release,
+        .llseek                 = no_llseek,
+};
+
+static struct miscdevice ds1374_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &ds1374_wdt_fops,
+};
+
+static struct notifier_block ds1374_wdt_notifier = {
+        .notifier_call = ds1374_wdt_notify_sys,
+};
+
+#endif /*CONFIG_RTC_DRV_DS1374_WDT*/
+/*
+ *****************************************************************************
+ *
+ *      Driver Interface
+ *
+ *****************************************************************************
+ */
 static int ds1374_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
@@ -378,12 +642,33 @@ static int ds1374_probe(struct i2c_client *client,
                 return PTR_ERR(ds1374->rtc);
         }
 
+#ifdef CONFIG_RTC_DRV_DS1374_WDT
+        save_client = client;
+        ret = misc_register(&ds1374_miscdev);
+        if (ret)
+                return ret;
+        ret = register_reboot_notifier(&ds1374_wdt_notifier);
+        if (ret) {
+                misc_deregister(&ds1374_miscdev);
+                return ret;
+        }
+        ds1374_wdt_settimeout(131072);
+#endif
+
         return 0;
 }
 
 static int ds1374_remove(struct i2c_client *client)
 {
         struct ds1374 *ds1374 = i2c_get_clientdata(client);
+#ifdef CONFIG_RTC_DRV_DS1374_WDT
+        int res;
+
+        res = misc_deregister(&ds1374_miscdev);
+        if (!res)
+                ds1374_miscdev.parent = NULL;
+        unregister_reboot_notifier(&ds1374_wdt_notifier);
+#endif
 
         if (client->irq > 0) {
                 mutex_lock(&ds1374->mutex);
diff --git a/drivers/rtc/rtc-isl12057.c b/drivers/rtc/rtc-isl12057.c
index 455b601d731d..6e1fcfb5d7e6 100644
--- a/drivers/rtc/rtc-isl12057.c
+++ b/drivers/rtc/rtc-isl12057.c
@@ -41,6 +41,7 @@
 #define ISL12057_REG_RTC_DW     0x03    /* Day of the Week */
 #define ISL12057_REG_RTC_DT     0x04    /* Date */
 #define ISL12057_REG_RTC_MO     0x05    /* Month */
+#define ISL12057_REG_RTC_MO_CEN BIT(7)  /* Century bit */
 #define ISL12057_REG_RTC_YR     0x06    /* Year */
 #define ISL12057_RTC_SEC_LEN    7
 
@@ -88,7 +89,7 @@ static void isl12057_rtc_regs_to_tm(struct rtc_time *tm, u8 *regs)
         tm->tm_min = bcd2bin(regs[ISL12057_REG_RTC_MN]);
 
         if (regs[ISL12057_REG_RTC_HR] & ISL12057_REG_RTC_HR_MIL) { /* AM/PM */
-                tm->tm_hour = bcd2bin(regs[ISL12057_REG_RTC_HR] & 0x0f);
+                tm->tm_hour = bcd2bin(regs[ISL12057_REG_RTC_HR] & 0x1f);
                 if (regs[ISL12057_REG_RTC_HR] & ISL12057_REG_RTC_HR_PM)
                         tm->tm_hour += 12;
         } else {                                            /* 24 hour mode */
@@ -97,26 +98,37 @@ static void isl12057_rtc_regs_to_tm(struct rtc_time *tm, u8 *regs)
 
         tm->tm_mday = bcd2bin(regs[ISL12057_REG_RTC_DT]);
         tm->tm_wday = bcd2bin(regs[ISL12057_REG_RTC_DW]) - 1; /* starts at 1 */
-        tm->tm_mon  = bcd2bin(regs[ISL12057_REG_RTC_MO]) - 1; /* starts at 1 */
+        tm->tm_mon  = bcd2bin(regs[ISL12057_REG_RTC_MO] & 0x1f) - 1; /* ditto */
         tm->tm_year = bcd2bin(regs[ISL12057_REG_RTC_YR]) + 100;
+
+        /* Check if years register has overflown from 99 to 00 */
+        if (regs[ISL12057_REG_RTC_MO] & ISL12057_REG_RTC_MO_CEN)
+                tm->tm_year += 100;
 }
 
 static int isl12057_rtc_tm_to_regs(u8 *regs, struct rtc_time *tm)
 {
+        u8 century_bit;
+
         /*
          * The clock has an 8 bit wide bcd-coded register for the year.
+         * It also has a century bit encoded in MO flag which provides
+         * information about overflow of year register from 99 to 00.
          * tm_year is an offset from 1900 and we are interested in the
-         * 2000-2099 range, so any value less than 100 is invalid.
+         * 2000-2199 range, so any value less than 100 or larger than
+         * 299 is invalid.
          */
-        if (tm->tm_year < 100)
+        if (tm->tm_year < 100 || tm->tm_year > 299)
                 return -EINVAL;
 
+        century_bit = (tm->tm_year > 199) ? ISL12057_REG_RTC_MO_CEN : 0;
+
         regs[ISL12057_REG_RTC_SC] = bin2bcd(tm->tm_sec);
         regs[ISL12057_REG_RTC_MN] = bin2bcd(tm->tm_min);
         regs[ISL12057_REG_RTC_HR] = bin2bcd(tm->tm_hour); /* 24-hour format */
         regs[ISL12057_REG_RTC_DT] = bin2bcd(tm->tm_mday);
-        regs[ISL12057_REG_RTC_MO] = bin2bcd(tm->tm_mon + 1);
-        regs[ISL12057_REG_RTC_YR] = bin2bcd(tm->tm_year - 100);
+        regs[ISL12057_REG_RTC_MO] = bin2bcd(tm->tm_mon + 1) | century_bit;
+        regs[ISL12057_REG_RTC_YR] = bin2bcd(tm->tm_year % 100);
         regs[ISL12057_REG_RTC_DW] = bin2bcd(tm->tm_wday + 1);
 
         return 0;
@@ -152,17 +164,33 @@ static int isl12057_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         struct isl12057_rtc_data *data = dev_get_drvdata(dev);
         u8 regs[ISL12057_RTC_SEC_LEN];
+        unsigned int sr;
         int ret;
 
         mutex_lock(&data->lock);
+        ret = regmap_read(data->regmap, ISL12057_REG_SR, &sr);
+        if (ret) {
+                dev_err(dev, "%s: unable to read oscillator status flag (%d)\n",
+                        __func__, ret);
+                goto out;
+        } else {
+                if (sr & ISL12057_REG_SR_OSF) {
+                        ret = -ENODATA;
+                        goto out;
+                }
+        }
+
         ret = regmap_bulk_read(data->regmap, ISL12057_REG_RTC_SC, regs,
                                ISL12057_RTC_SEC_LEN);
+        if (ret)
+                dev_err(dev, "%s: unable to read RTC time section (%d)\n",
+                        __func__, ret);
+
+out:
         mutex_unlock(&data->lock);
 
-        if (ret) {
-                dev_err(dev, "%s: RTC read failed\n", __func__);
+        if (ret)
                 return ret;
-        }
 
         isl12057_rtc_regs_to_tm(tm, regs);
 
@@ -182,10 +210,24 @@ static int isl12057_rtc_set_time(struct device *dev, struct rtc_time *tm)
         mutex_lock(&data->lock);
         ret = regmap_bulk_write(data->regmap, ISL12057_REG_RTC_SC, regs,
                                 ISL12057_RTC_SEC_LEN);
-        mutex_unlock(&data->lock);
+        if (ret) {
+                dev_err(dev, "%s: unable to write RTC time section (%d)\n",
+                        __func__, ret);
+                goto out;
+        }
 
-        if (ret)
-                dev_err(dev, "%s: RTC write failed\n", __func__);
+        /*
+         * Now that RTC time has been updated, let's clear oscillator
+         * failure flag, if needed.
+         */
+        ret = regmap_update_bits(data->regmap, ISL12057_REG_SR,
+                                 ISL12057_REG_SR_OSF, 0);
+        if (ret < 0)
+                dev_err(dev, "%s: unable to clear osc. failure bit (%d)\n",
+                        __func__, ret);
+
+out:
+        mutex_unlock(&data->lock);
 
         return ret;
 }
@@ -203,15 +245,8 @@ static int isl12057_check_rtc_status(struct device *dev, struct regmap *regmap)
         ret = regmap_update_bits(regmap, ISL12057_REG_INT,
                                  ISL12057_REG_INT_EOSC, 0);
         if (ret < 0) {
-                dev_err(dev, "Unable to enable oscillator\n");
-                return ret;
-        }
-
-        /* Clear oscillator failure bit if needed */
-        ret = regmap_update_bits(regmap, ISL12057_REG_SR,
-                                 ISL12057_REG_SR_OSF, 0);
-        if (ret < 0) {
-                dev_err(dev, "Unable to clear oscillator failure bit\n");
+                dev_err(dev, "%s: unable to enable oscillator (%d)\n",
+                        __func__, ret);
                 return ret;
         }
 
@@ -219,7 +254,8 @@ static int isl12057_check_rtc_status(struct device *dev, struct regmap *regmap)
         ret = regmap_update_bits(regmap, ISL12057_REG_SR,
                                  ISL12057_REG_SR_A1F, 0);
         if (ret < 0) {
-                dev_err(dev, "Unable to clear alarm bit\n");
+                dev_err(dev, "%s: unable to clear alarm bit (%d)\n",
+                        __func__, ret);
                 return ret;
         }
 
@@ -253,7 +289,8 @@ static int isl12057_probe(struct i2c_client *client,
         regmap = devm_regmap_init_i2c(client, &isl12057_rtc_regmap_config);
         if (IS_ERR(regmap)) {
                 ret = PTR_ERR(regmap);
-                dev_err(dev, "regmap allocation failed: %d\n", ret);
+                dev_err(dev, "%s: regmap allocation failed (%d)\n",
+                        __func__, ret);
                 return ret;
         }
 
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
index c4cf05731118..e6bfb9c42a10 100644
--- a/drivers/rtc/rtc-lib.c
+++ b/drivers/rtc/rtc-lib.c
@@ -45,16 +45,20 @@ int rtc_year_days(unsigned int day, unsigned int month, unsigned int year)
 }
 EXPORT_SYMBOL(rtc_year_days);
 
+
 /*
+ * rtc_time_to_tm64 - Converts time64_t to rtc_time.
  * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
  */
-void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
+void rtc_time64_to_tm(time64_t time, struct rtc_time *tm)
 {
         unsigned int month, year;
+        unsigned long secs;
         int days;
 
-        days = time / 86400;
-        time -= (unsigned int) days * 86400;
+        /* time must be positive */
+        days = div_s64(time, 86400);
+        secs = time - (unsigned int) days * 86400;
 
         /* day of the week, 1970-01-01 was a Thursday */
         tm->tm_wday = (days + 4) % 7;
@@ -81,14 +85,14 @@ void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
         tm->tm_mon = month;
         tm->tm_mday = days + 1;
 
-        tm->tm_hour = time / 3600;
-        time -= tm->tm_hour * 3600;
-        tm->tm_min = time / 60;
-        tm->tm_sec = time - tm->tm_min * 60;
+        tm->tm_hour = secs / 3600;
+        secs -= tm->tm_hour * 3600;
+        tm->tm_min = secs / 60;
+        tm->tm_sec = secs - tm->tm_min * 60;
 
         tm->tm_isdst = 0;
 }
-EXPORT_SYMBOL(rtc_time_to_tm);
+EXPORT_SYMBOL(rtc_time64_to_tm);
 
 /*
  * Does the rtc_time represent a valid date/time?
@@ -109,24 +113,22 @@ int rtc_valid_tm(struct rtc_time *tm)
 EXPORT_SYMBOL(rtc_valid_tm);
 
 /*
+ * rtc_tm_to_time64 - Converts rtc_time to time64_t.
  * Convert Gregorian date to seconds since 01-01-1970 00:00:00.
  */
-int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
+time64_t rtc_tm_to_time64(struct rtc_time *tm)
 {
-        *time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+        return mktime64(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
                         tm->tm_hour, tm->tm_min, tm->tm_sec);
-        return 0;
 }
-EXPORT_SYMBOL(rtc_tm_to_time);
+EXPORT_SYMBOL(rtc_tm_to_time64);
 
 /*
  * Convert rtc_time to ktime
  */
 ktime_t rtc_tm_to_ktime(struct rtc_time tm)
 {
-        time_t time;
-        rtc_tm_to_time(&tm, &time);
-        return ktime_set(time, 0);
+        return ktime_set(rtc_tm_to_time64(&tm), 0);
 }
 EXPORT_SYMBOL_GPL(rtc_tm_to_ktime);
 
@@ -135,14 +137,14 @@ EXPORT_SYMBOL_GPL(rtc_tm_to_ktime);
  */
 struct rtc_time rtc_ktime_to_tm(ktime_t kt)
 {
-        struct timespec ts;
+        struct timespec64 ts;
         struct rtc_time ret;
 
-        ts = ktime_to_timespec(kt);
+        ts = ktime_to_timespec64(kt);
         /* Round up any ns */
         if (ts.tv_nsec)
                 ts.tv_sec++;
-        rtc_time_to_tm(ts.tv_sec, &ret);
+        rtc_time64_to_tm(ts.tv_sec, &ret);
         return ret;
 }
 EXPORT_SYMBOL_GPL(rtc_ktime_to_tm);
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 21142e6574a9..4f1c6ca97211 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -1,10 +1,11 @@
 /*
- * TI OMAP1 Real Time Clock interface for Linux
+ * TI OMAP Real Time Clock interface for Linux
  *
  * Copyright (C) 2003 MontaVista Software, Inc.
  * Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
  *
  * Copyright (C) 2006 David Brownell (new RTC framework)
+ * Copyright (C) 2014 Johan Hovold <johan@kernel.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -25,7 +26,8 @@
 #include <linux/pm_runtime.h>
 #include <linux/io.h>
 
-/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
+/*
+ * The OMAP RTC is a year/month/day/hours/minutes/seconds BCD clock
  * with century-range alarm matching, driven by the 32kHz clock.
  *
  * The main user-visible ways it differs from PC RTCs are by omitting
@@ -39,10 +41,6 @@
  * the SoC). See the BOARD-SPECIFIC CUSTOMIZATION comment.
  */
 
-#define DRIVER_NAME                     "omap_rtc"
-
-#define OMAP_RTC_BASE                   0xfffb4800
-
 /* RTC registers */
 #define OMAP_RTC_SECONDS_REG            0x00
 #define OMAP_RTC_MINUTES_REG            0x04
@@ -72,6 +70,15 @@
 
 #define OMAP_RTC_IRQWAKEEN              0x7c
 
+#define OMAP_RTC_ALARM2_SECONDS_REG     0x80
+#define OMAP_RTC_ALARM2_MINUTES_REG     0x84
+#define OMAP_RTC_ALARM2_HOURS_REG       0x88
+#define OMAP_RTC_ALARM2_DAYS_REG        0x8c
+#define OMAP_RTC_ALARM2_MONTHS_REG      0x90
+#define OMAP_RTC_ALARM2_YEARS_REG       0x94
+
+#define OMAP_RTC_PMIC_REG               0x98
+
 /* OMAP_RTC_CTRL_REG bit fields: */
 #define OMAP_RTC_CTRL_SPLIT             BIT(7)
 #define OMAP_RTC_CTRL_DISABLE           BIT(6)
@@ -84,6 +91,7 @@
 
 /* OMAP_RTC_STATUS_REG bit fields: */
 #define OMAP_RTC_STATUS_POWER_UP        BIT(7)
+#define OMAP_RTC_STATUS_ALARM2          BIT(7)
 #define OMAP_RTC_STATUS_ALARM           BIT(6)
 #define OMAP_RTC_STATUS_1D_EVENT        BIT(5)
 #define OMAP_RTC_STATUS_1H_EVENT        BIT(4)
@@ -93,6 +101,7 @@
 #define OMAP_RTC_STATUS_BUSY            BIT(0)
 
 /* OMAP_RTC_INTERRUPTS_REG bit fields: */
+#define OMAP_RTC_INTERRUPTS_IT_ALARM2   BIT(4)
 #define OMAP_RTC_INTERRUPTS_IT_ALARM    BIT(3)
 #define OMAP_RTC_INTERRUPTS_IT_TIMER    BIT(2)
 
@@ -102,61 +111,82 @@
 /* OMAP_RTC_IRQWAKEEN bit fields: */
 #define OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN BIT(1)
 
+/* OMAP_RTC_PMIC bit fields: */
+#define OMAP_RTC_PMIC_POWER_EN_EN       BIT(16)
+
 /* OMAP_RTC_KICKER values */
 #define KICK0_VALUE                     0x83e70b13
 #define KICK1_VALUE                     0x95a4f1e0
 
-#define OMAP_RTC_HAS_KICKER             BIT(0)
-
-/*
- * Few RTC IP revisions has special WAKE-EN Register to enable Wakeup
- * generation for event Alarm.
- */
-#define OMAP_RTC_HAS_IRQWAKEEN          BIT(1)
+struct omap_rtc_device_type {
+        bool has_32kclk_en;
+        bool has_kicker;
+        bool has_irqwakeen;
+        bool has_pmic_mode;
+        bool has_power_up_reset;
+};
 
-/*
- * Some RTC IP revisions (like those in AM335x and DRA7x) need
- * the 32KHz clock to be explicitly enabled.
- */
-#define OMAP_RTC_HAS_32KCLK_EN          BIT(2)
+struct omap_rtc {
+        struct rtc_device *rtc;
+        void __iomem *base;
+        int irq_alarm;
+        int irq_timer;
+        u8 interrupts_reg;
+        bool is_pmic_controller;
+        const struct omap_rtc_device_type *type;
+};
 
-static void __iomem     *rtc_base;
+static inline u8 rtc_read(struct omap_rtc *rtc, unsigned int reg)
+{
+        return readb(rtc->base + reg);
+}
 
-#define rtc_read(addr)          readb(rtc_base + (addr))
-#define rtc_write(val, addr)    writeb(val, rtc_base + (addr))
+static inline u32 rtc_readl(struct omap_rtc *rtc, unsigned int reg)
+{
+        return readl(rtc->base + reg);
+}
 
-#define rtc_writel(val, addr)   writel(val, rtc_base + (addr))
+static inline void rtc_write(struct omap_rtc *rtc, unsigned int reg, u8 val)
+{
+        writeb(val, rtc->base + reg);
+}
 
+static inline void rtc_writel(struct omap_rtc *rtc, unsigned int reg, u32 val)
+{
+        writel(val, rtc->base + reg);
+}
 
-/* we rely on the rtc framework to handle locking (rtc->ops_lock),
+/*
+ * We rely on the rtc framework to handle locking (rtc->ops_lock),
  * so the only other requirement is that register accesses which
  * require BUSY to be clear are made with IRQs locally disabled
  */
-static void rtc_wait_not_busy(void)
+static void rtc_wait_not_busy(struct omap_rtc *rtc)
 {
-        int     count = 0;
-        u8      status;
+        int count;
+        u8 status;
 
         /* BUSY may stay active for 1/32768 second (~30 usec) */
         for (count = 0; count < 50; count++) {
-                status = rtc_read(OMAP_RTC_STATUS_REG);
-                if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
+                status = rtc_read(rtc, OMAP_RTC_STATUS_REG);
+                if (!(status & OMAP_RTC_STATUS_BUSY))
                         break;
                 udelay(1);
         }
         /* now we have ~15 usec to read/write various registers */
 }
 
-static irqreturn_t rtc_irq(int irq, void *rtc)
+static irqreturn_t rtc_irq(int irq, void *dev_id)
 {
-        unsigned long           events = 0;
-        u8                      irq_data;
+        struct omap_rtc *rtc = dev_id;
+        unsigned long events = 0;
+        u8 irq_data;
 
-        irq_data = rtc_read(OMAP_RTC_STATUS_REG);
+        irq_data = rtc_read(rtc, OMAP_RTC_STATUS_REG);
 
         /* alarm irq? */
         if (irq_data & OMAP_RTC_STATUS_ALARM) {
-                rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
+                rtc_write(rtc, OMAP_RTC_STATUS_REG, OMAP_RTC_STATUS_ALARM);
                 events |= RTC_IRQF | RTC_AF;
         }
 
@@ -164,23 +194,21 @@ static irqreturn_t rtc_irq(int irq, void *rtc)
         if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
                 events |= RTC_IRQF | RTC_UF;
 
-        rtc_update_irq(rtc, 1, events);
+        rtc_update_irq(rtc->rtc, 1, events);
 
         return IRQ_HANDLED;
 }
 
 static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
+        struct omap_rtc *rtc = dev_get_drvdata(dev);
         u8 reg, irqwake_reg = 0;
-        struct platform_device *pdev = to_platform_device(dev);
-        const struct platform_device_id *id_entry =
-                                        platform_get_device_id(pdev);
 
         local_irq_disable();
-        rtc_wait_not_busy();
-        reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
-        if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)
-                irqwake_reg = rtc_read(OMAP_RTC_IRQWAKEEN);
+        rtc_wait_not_busy(rtc);
+        reg = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
+        if (rtc->type->has_irqwakeen)
+                irqwake_reg = rtc_read(rtc, OMAP_RTC_IRQWAKEEN);
 
         if (enabled) {
                 reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
@@ -189,10 +217,10 @@ static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
                 reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
                 irqwake_reg &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
         }
-        rtc_wait_not_busy();
-        rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
-        if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)
-                rtc_write(irqwake_reg, OMAP_RTC_IRQWAKEEN);
+        rtc_wait_not_busy(rtc);
+        rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, reg);
+        if (rtc->type->has_irqwakeen)
+                rtc_write(rtc, OMAP_RTC_IRQWAKEEN, irqwake_reg);
         local_irq_enable();
 
         return 0;
@@ -230,39 +258,47 @@ static void bcd2tm(struct rtc_time *tm)
         tm->tm_year = bcd2bin(tm->tm_year) + 100;
 }
 
+static void omap_rtc_read_time_raw(struct omap_rtc *rtc, struct rtc_time *tm)
+{
+        tm->tm_sec = rtc_read(rtc, OMAP_RTC_SECONDS_REG);
+        tm->tm_min = rtc_read(rtc, OMAP_RTC_MINUTES_REG);
+        tm->tm_hour = rtc_read(rtc, OMAP_RTC_HOURS_REG);
+        tm->tm_mday = rtc_read(rtc, OMAP_RTC_DAYS_REG);
+        tm->tm_mon = rtc_read(rtc, OMAP_RTC_MONTHS_REG);
+        tm->tm_year = rtc_read(rtc, OMAP_RTC_YEARS_REG);
+}
 
 static int omap_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
+        struct omap_rtc *rtc = dev_get_drvdata(dev);
+
         /* we don't report wday/yday/isdst ... */
         local_irq_disable();
-        rtc_wait_not_busy();
-
-        tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
-        tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
-        tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
-        tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
-        tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
-        tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);
-
+        rtc_wait_not_busy(rtc);
+        omap_rtc_read_time_raw(rtc, tm);
         local_irq_enable();
 
         bcd2tm(tm);
+
         return 0;
 }
 
 static int omap_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
+        struct omap_rtc *rtc = dev_get_drvdata(dev);
+
         if (tm2bcd(tm) < 0)
                 return -EINVAL;
+
         local_irq_disable();
-        rtc_wait_not_busy();
+        rtc_wait_not_busy(rtc);
 
-        rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
-        rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
-        rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
-        rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
-        rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
-        rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);
+        rtc_write(rtc, OMAP_RTC_YEARS_REG, tm->tm_year);
+        rtc_write(rtc, OMAP_RTC_MONTHS_REG, tm->tm_mon);
+        rtc_write(rtc, OMAP_RTC_DAYS_REG, tm->tm_mday);
+        rtc_write(rtc, OMAP_RTC_HOURS_REG, tm->tm_hour);
+        rtc_write(rtc, OMAP_RTC_MINUTES_REG, tm->tm_min);
+        rtc_write(rtc, OMAP_RTC_SECONDS_REG, tm->tm_sec);
 
         local_irq_enable();
 
@@ -271,48 +307,50 @@ static int omap_rtc_set_time(struct device *dev, struct rtc_time *tm)
 
 static int omap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
+        struct omap_rtc *rtc = dev_get_drvdata(dev);
+        u8 interrupts;
+
         local_irq_disable();
-        rtc_wait_not_busy();
+        rtc_wait_not_busy(rtc);
 
-        alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
-        alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
-        alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
-        alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
-        alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
-        alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);
+        alm->time.tm_sec = rtc_read(rtc, OMAP_RTC_ALARM_SECONDS_REG);
+        alm->time.tm_min = rtc_read(rtc, OMAP_RTC_ALARM_MINUTES_REG);
+        alm->time.tm_hour = rtc_read(rtc, OMAP_RTC_ALARM_HOURS_REG);
+        alm->time.tm_mday = rtc_read(rtc, OMAP_RTC_ALARM_DAYS_REG);
+        alm->time.tm_mon = rtc_read(rtc, OMAP_RTC_ALARM_MONTHS_REG);
+        alm->time.tm_year = rtc_read(rtc, OMAP_RTC_ALARM_YEARS_REG);
 
         local_irq_enable();
 
         bcd2tm(&alm->time);
-        alm->enabled = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
-                        & OMAP_RTC_INTERRUPTS_IT_ALARM);
+
+        interrupts = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
+        alm->enabled = !!(interrupts & OMAP_RTC_INTERRUPTS_IT_ALARM);
 
         return 0;
 }
 
 static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
+        struct omap_rtc *rtc = dev_get_drvdata(dev);
         u8 reg, irqwake_reg = 0;
-        struct platform_device *pdev = to_platform_device(dev);
-        const struct platform_device_id *id_entry =
-                                        platform_get_device_id(pdev);
 
         if (tm2bcd(&alm->time) < 0)
                 return -EINVAL;
 
         local_irq_disable();
-        rtc_wait_not_busy();
+        rtc_wait_not_busy(rtc);
 
-        rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
-        rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
-        rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
-        rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
-        rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
-        rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
+        rtc_write(rtc, OMAP_RTC_ALARM_YEARS_REG, alm->time.tm_year);
+        rtc_write(rtc, OMAP_RTC_ALARM_MONTHS_REG, alm->time.tm_mon);
+        rtc_write(rtc, OMAP_RTC_ALARM_DAYS_REG, alm->time.tm_mday);
+        rtc_write(rtc, OMAP_RTC_ALARM_HOURS_REG, alm->time.tm_hour);
+        rtc_write(rtc, OMAP_RTC_ALARM_MINUTES_REG, alm->time.tm_min);
+        rtc_write(rtc, OMAP_RTC_ALARM_SECONDS_REG, alm->time.tm_sec);
 
-        reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
-        if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)
-                irqwake_reg = rtc_read(OMAP_RTC_IRQWAKEEN);
+        reg = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
+        if (rtc->type->has_irqwakeen)
+                irqwake_reg = rtc_read(rtc, OMAP_RTC_IRQWAKEEN);
 
         if (alm->enabled) {
                 reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
@@ -321,15 +359,79 @@ static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
                 reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
                 irqwake_reg &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
         }
-        rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
-        if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)
-                rtc_write(irqwake_reg, OMAP_RTC_IRQWAKEEN);
+        rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, reg);
+        if (rtc->type->has_irqwakeen)
+                rtc_write(rtc, OMAP_RTC_IRQWAKEEN, irqwake_reg);
 
         local_irq_enable();
 
         return 0;
 }
 
+static struct omap_rtc *omap_rtc_power_off_rtc;
+
+/*
+ * omap_rtc_poweroff: RTC-controlled power off
+ *
+ * The RTC can be used to control an external PMIC via the pmic_power_en pin,
+ * which can be configured to transition to OFF on ALARM2 events.
+ *
+ * Notes:
+ * The two-second alarm offset is the shortest offset possible as the alarm
+ * registers must be set before the next timer update and the offset
+ * calculation is too heavy for everything to be done within a single access
+ * period (~15 us).
+ *
+ * Called with local interrupts disabled.
+ */
+static void omap_rtc_power_off(void)
+{
+        struct omap_rtc *rtc = omap_rtc_power_off_rtc;
+        struct rtc_time tm;
+        unsigned long now;
+        u32 val;
+
+        /* enable pmic_power_en control */
+        val = rtc_readl(rtc, OMAP_RTC_PMIC_REG);
+        rtc_writel(rtc, OMAP_RTC_PMIC_REG, val | OMAP_RTC_PMIC_POWER_EN_EN);
+
+        /* set alarm two seconds from now */
+        omap_rtc_read_time_raw(rtc, &tm);
+        bcd2tm(&tm);
+        rtc_tm_to_time(&tm, &now);
+        rtc_time_to_tm(now + 2, &tm);
+
+        if (tm2bcd(&tm) < 0) {
+                dev_err(&rtc->rtc->dev, "power off failed\n");
+                return;
+        }
+
+        rtc_wait_not_busy(rtc);
+
+        rtc_write(rtc, OMAP_RTC_ALARM2_SECONDS_REG, tm.tm_sec);
+        rtc_write(rtc, OMAP_RTC_ALARM2_MINUTES_REG, tm.tm_min);
+        rtc_write(rtc, OMAP_RTC_ALARM2_HOURS_REG, tm.tm_hour);
+        rtc_write(rtc, OMAP_RTC_ALARM2_DAYS_REG, tm.tm_mday);
+        rtc_write(rtc, OMAP_RTC_ALARM2_MONTHS_REG, tm.tm_mon);
+        rtc_write(rtc, OMAP_RTC_ALARM2_YEARS_REG, tm.tm_year);
+
+        /*
+         * enable ALARM2 interrupt
+         *
+         * NOTE: this fails on AM3352 if rtc_write (writeb) is used
+         */
+        val = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
+        rtc_writel(rtc, OMAP_RTC_INTERRUPTS_REG,
+                        val | OMAP_RTC_INTERRUPTS_IT_ALARM2);
+
+        /*
+         * Wait for alarm to trigger (within two seconds) and external PMIC to
+         * power off the system. Add a 500 ms margin for external latencies
+         * (e.g. debounce circuits).
+         */
+        mdelay(2500);
+}
+
 static struct rtc_class_ops omap_rtc_ops = {
         .read_time      = omap_rtc_read_time,
         .set_time       = omap_rtc_set_time,
@@ -338,137 +440,140 @@ static struct rtc_class_ops omap_rtc_ops = {
         .alarm_irq_enable = omap_rtc_alarm_irq_enable,
 };
 
-static int omap_rtc_alarm;
-static int omap_rtc_timer;
+static const struct omap_rtc_device_type omap_rtc_default_type = {
+        .has_power_up_reset = true,
+};
 
-#define OMAP_RTC_DATA_AM3352_IDX        1
-#define OMAP_RTC_DATA_DA830_IDX         2
+static const struct omap_rtc_device_type omap_rtc_am3352_type = {
+        .has_32kclk_en  = true,
+        .has_kicker     = true,
+        .has_irqwakeen  = true,
+        .has_pmic_mode  = true,
+};
 
-static struct platform_device_id omap_rtc_devtype[] = {
+static const struct omap_rtc_device_type omap_rtc_da830_type = {
+        .has_kicker     = true,
+};
+
+static const struct platform_device_id omap_rtc_id_table[] = {
         {
-                .name   = DRIVER_NAME,
-        },
-        [OMAP_RTC_DATA_AM3352_IDX] = {
+                .name   = "omap_rtc",
+                .driver_data = (kernel_ulong_t)&omap_rtc_default_type,
+        }, {
                 .name   = "am3352-rtc",
-                .driver_data = OMAP_RTC_HAS_KICKER | OMAP_RTC_HAS_IRQWAKEEN |
-                               OMAP_RTC_HAS_32KCLK_EN,
-        },
-        [OMAP_RTC_DATA_DA830_IDX] = {
+                .driver_data = (kernel_ulong_t)&omap_rtc_am3352_type,
+        }, {
                 .name   = "da830-rtc",
-                .driver_data = OMAP_RTC_HAS_KICKER,
-        },
-        {},
+                .driver_data = (kernel_ulong_t)&omap_rtc_da830_type,
+        }, {
+                /* sentinel */
+        }
 };
-MODULE_DEVICE_TABLE(platform, omap_rtc_devtype);
+MODULE_DEVICE_TABLE(platform, omap_rtc_id_table);
 
 static const struct of_device_id omap_rtc_of_match[] = {
-        {       .compatible     = "ti,da830-rtc",
-                .data           = &omap_rtc_devtype[OMAP_RTC_DATA_DA830_IDX],
-        },
-        {       .compatible     = "ti,am3352-rtc",
-                .data           = &omap_rtc_devtype[OMAP_RTC_DATA_AM3352_IDX],
-        },
-        {},
+        {
+                .compatible     = "ti,am3352-rtc",
+                .data           = &omap_rtc_am3352_type,
+        }, {
+                .compatible     = "ti,da830-rtc",
+                .data           = &omap_rtc_da830_type,
+        }, {
+                /* sentinel */
+        }
 };
 MODULE_DEVICE_TABLE(of, omap_rtc_of_match);
 
 static int __init omap_rtc_probe(struct platform_device *pdev)
 {
-        struct resource         *res;
-        struct rtc_device       *rtc;
-        u8                      reg, new_ctrl;
+        struct omap_rtc *rtc;
+        struct resource *res;
+        u8 reg, mask, new_ctrl;
         const struct platform_device_id *id_entry;
         const struct of_device_id *of_id;
+        int ret;
 
-        of_id = of_match_device(omap_rtc_of_match, &pdev->dev);
-        if (of_id)
-                pdev->id_entry = of_id->data;
+        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
+        if (!rtc)
+                return -ENOMEM;
 
-        id_entry = platform_get_device_id(pdev);
-        if (!id_entry) {
-                dev_err(&pdev->dev, "no matching device entry\n");
-                return -ENODEV;
+        of_id = of_match_device(omap_rtc_of_match, &pdev->dev);
+        if (of_id) {
+                rtc->type = of_id->data;
+                rtc->is_pmic_controller = rtc->type->has_pmic_mode &&
+                                of_property_read_bool(pdev->dev.of_node,
+                                                "system-power-controller");
+        } else {
+                id_entry = platform_get_device_id(pdev);
+                rtc->type = (void *)id_entry->driver_data;
         }
 
-        omap_rtc_timer = platform_get_irq(pdev, 0);
-        if (omap_rtc_timer <= 0) {
-                pr_debug("%s: no update irq?\n", pdev->name);
+        rtc->irq_timer = platform_get_irq(pdev, 0);
+        if (rtc->irq_timer <= 0)
                 return -ENOENT;
-        }
 
-        omap_rtc_alarm = platform_get_irq(pdev, 1);
-        if (omap_rtc_alarm <= 0) {
-                pr_debug("%s: no alarm irq?\n", pdev->name);
+        rtc->irq_alarm = platform_get_irq(pdev, 1);
+        if (rtc->irq_alarm <= 0)
                 return -ENOENT;
-        }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        rtc_base = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(rtc_base))
-                return PTR_ERR(rtc_base);
+        rtc->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(rtc->base))
+                return PTR_ERR(rtc->base);
+
+        platform_set_drvdata(pdev, rtc);
 
         /* Enable the clock/module so that we can access the registers */
         pm_runtime_enable(&pdev->dev);
         pm_runtime_get_sync(&pdev->dev);
 
-        if (id_entry->driver_data & OMAP_RTC_HAS_KICKER) {
-                rtc_writel(KICK0_VALUE, OMAP_RTC_KICK0_REG);
-                rtc_writel(KICK1_VALUE, OMAP_RTC_KICK1_REG);
-        }
-
-        rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
-                        &omap_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                pr_debug("%s: can't register RTC device, err %ld\n",
-                        pdev->name, PTR_ERR(rtc));
-                goto fail0;
+        if (rtc->type->has_kicker) {
+                rtc_writel(rtc, OMAP_RTC_KICK0_REG, KICK0_VALUE);
+                rtc_writel(rtc, OMAP_RTC_KICK1_REG, KICK1_VALUE);
         }
-        platform_set_drvdata(pdev, rtc);
 
-        /* clear pending irqs, and set 1/second periodic,
-         * which we'll use instead of update irqs
+        /*
+         * disable interrupts
+         *
+         * NOTE: ALARM2 is not cleared on AM3352 if rtc_write (writeb) is used
          */
-        rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+        rtc_writel(rtc, OMAP_RTC_INTERRUPTS_REG, 0);
 
         /* enable RTC functional clock */
-        if (id_entry->driver_data & OMAP_RTC_HAS_32KCLK_EN)
-                rtc_writel(OMAP_RTC_OSC_32KCLK_EN, OMAP_RTC_OSC_REG);
+        if (rtc->type->has_32kclk_en) {
+                reg = rtc_read(rtc, OMAP_RTC_OSC_REG);
+                rtc_writel(rtc, OMAP_RTC_OSC_REG,
+                                reg | OMAP_RTC_OSC_32KCLK_EN);
+        }
 
         /* clear old status */
-        reg = rtc_read(OMAP_RTC_STATUS_REG);
-        if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
-                pr_info("%s: RTC power up reset detected\n",
-                        pdev->name);
-                rtc_write(OMAP_RTC_STATUS_POWER_UP, OMAP_RTC_STATUS_REG);
-        }
-        if (reg & (u8) OMAP_RTC_STATUS_ALARM)
-                rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
+        reg = rtc_read(rtc, OMAP_RTC_STATUS_REG);
 
-        /* handle periodic and alarm irqs */
-        if (devm_request_irq(&pdev->dev, omap_rtc_timer, rtc_irq, 0,
-                        dev_name(&rtc->dev), rtc)) {
-                pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
-                        pdev->name, omap_rtc_timer);
-                goto fail0;
-        }
-        if ((omap_rtc_timer != omap_rtc_alarm) &&
-                (devm_request_irq(&pdev->dev, omap_rtc_alarm, rtc_irq, 0,
-                        dev_name(&rtc->dev), rtc))) {
-                pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
-                        pdev->name, omap_rtc_alarm);
-                goto fail0;
+        mask = OMAP_RTC_STATUS_ALARM;
+
+        if (rtc->type->has_pmic_mode)
+                mask |= OMAP_RTC_STATUS_ALARM2;
+
+        if (rtc->type->has_power_up_reset) {
+                mask |= OMAP_RTC_STATUS_POWER_UP;
+                if (reg & OMAP_RTC_STATUS_POWER_UP)
+                        dev_info(&pdev->dev, "RTC power up reset detected\n");
         }
 
+        if (reg & mask)
+                rtc_write(rtc, OMAP_RTC_STATUS_REG, reg & mask);
+
         /* On boards with split power, RTC_ON_NOFF won't reset the RTC */
-        reg = rtc_read(OMAP_RTC_CTRL_REG);
-        if (reg & (u8) OMAP_RTC_CTRL_STOP)
-                pr_info("%s: already running\n", pdev->name);
+        reg = rtc_read(rtc, OMAP_RTC_CTRL_REG);
+        if (reg & OMAP_RTC_CTRL_STOP)
+                dev_info(&pdev->dev, "already running\n");
 
         /* force to 24 hour mode */
-        new_ctrl = reg & (OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
+        new_ctrl = reg & (OMAP_RTC_CTRL_SPLIT | OMAP_RTC_CTRL_AUTO_COMP);
         new_ctrl |= OMAP_RTC_CTRL_STOP;
 
-        /* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
+        /*
+         * BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
          *
          *  - Device wake-up capability setting should come through chip
          *    init logic. OMAP1 boards should initialize the "wakeup capable"
@@ -482,36 +587,70 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
          *    is write-only, and always reads as zero...)
          */
 
+        if (new_ctrl & OMAP_RTC_CTRL_SPLIT)
+                dev_info(&pdev->dev, "split power mode\n");
+
+        if (reg != new_ctrl)
+                rtc_write(rtc, OMAP_RTC_CTRL_REG, new_ctrl);
+
         device_init_wakeup(&pdev->dev, true);
 
-        if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
-                pr_info("%s: split power mode\n", pdev->name);
+        rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
+                        &omap_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc->rtc)) {
+                ret = PTR_ERR(rtc->rtc);
+                goto err;
+        }
 
-        if (reg != new_ctrl)
-                rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);
+        /* handle periodic and alarm irqs */
+        ret = devm_request_irq(&pdev->dev, rtc->irq_timer, rtc_irq, 0,
+                        dev_name(&rtc->rtc->dev), rtc);
+        if (ret)
+                goto err;
+
+        if (rtc->irq_timer != rtc->irq_alarm) {
+                ret = devm_request_irq(&pdev->dev, rtc->irq_alarm, rtc_irq, 0,
+                                dev_name(&rtc->rtc->dev), rtc);
+                if (ret)
+                        goto err;
+        }
+
+        if (rtc->is_pmic_controller) {
+                if (!pm_power_off) {
+                        omap_rtc_power_off_rtc = rtc;
+                        pm_power_off = omap_rtc_power_off;
+                }
+        }
 
         return 0;
 
-fail0:
-        if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)
-                rtc_writel(0, OMAP_RTC_KICK0_REG);
+err:
+        device_init_wakeup(&pdev->dev, false);
+        if (rtc->type->has_kicker)
+                rtc_writel(rtc, OMAP_RTC_KICK0_REG, 0);
         pm_runtime_put_sync(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
-        return -EIO;
+
+        return ret;
 }
 
 static int __exit omap_rtc_remove(struct platform_device *pdev)
 {
-        const struct platform_device_id *id_entry =
-                                platform_get_device_id(pdev);
+        struct omap_rtc *rtc = platform_get_drvdata(pdev);
+
+        if (pm_power_off == omap_rtc_power_off &&
+                        omap_rtc_power_off_rtc == rtc) {
+                pm_power_off = NULL;
+                omap_rtc_power_off_rtc = NULL;
+        }
 
         device_init_wakeup(&pdev->dev, 0);
 
         /* leave rtc running, but disable irqs */
-        rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+        rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, 0);
 
-        if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)
-                rtc_writel(0, OMAP_RTC_KICK0_REG);
+        if (rtc->type->has_kicker)
+                rtc_writel(rtc, OMAP_RTC_KICK0_REG, 0);
 
         /* Disable the clock/module */
         pm_runtime_put_sync(&pdev->dev);
@@ -521,20 +660,21 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM_SLEEP
-static u8 irqstat;
-
 static int omap_rtc_suspend(struct device *dev)
 {
-        irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
+        struct omap_rtc *rtc = dev_get_drvdata(dev);
 
-        /* FIXME the RTC alarm is not currently acting as a wakeup event
+        rtc->interrupts_reg = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
+
+        /*
+         * FIXME: the RTC alarm is not currently acting as a wakeup event
          * source on some platforms, and in fact this enable() call is just
          * saving a flag that's never used...
          */
         if (device_may_wakeup(dev))
-                enable_irq_wake(omap_rtc_alarm);
+                enable_irq_wake(rtc->irq_alarm);
         else
-                rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+                rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, 0);
 
         /* Disable the clock/module */
         pm_runtime_put_sync(dev);
@@ -544,13 +684,15 @@ static int omap_rtc_suspend(struct device *dev)
 
 static int omap_rtc_resume(struct device *dev)
 {
+        struct omap_rtc *rtc = dev_get_drvdata(dev);
+
         /* Enable the clock/module so that we can access the registers */
         pm_runtime_get_sync(dev);
 
         if (device_may_wakeup(dev))
-                disable_irq_wake(omap_rtc_alarm);
+                disable_irq_wake(rtc->irq_alarm);
         else
-                rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
+                rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, rtc->interrupts_reg);
 
         return 0;
 }
@@ -560,23 +702,32 @@ static SIMPLE_DEV_PM_OPS(omap_rtc_pm_ops, omap_rtc_suspend, omap_rtc_resume);
 
 static void omap_rtc_shutdown(struct platform_device *pdev)
 {
-        rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
+        struct omap_rtc *rtc = platform_get_drvdata(pdev);
+        u8 mask;
+
+        /*
+         * Keep the ALARM interrupt enabled to allow the system to power up on
+         * alarm events.
+         */
+        mask = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
+        mask &= OMAP_RTC_INTERRUPTS_IT_ALARM;
+        rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, mask);
 }
 
-MODULE_ALIAS("platform:omap_rtc");
 static struct platform_driver omap_rtc_driver = {
         .remove         = __exit_p(omap_rtc_remove),
         .shutdown       = omap_rtc_shutdown,
         .driver         = {
-                .name   = DRIVER_NAME,
+                .name   = "omap_rtc",
                 .owner  = THIS_MODULE,
                 .pm     = &omap_rtc_pm_ops,
                 .of_match_table = omap_rtc_of_match,
         },
-        .id_table       = omap_rtc_devtype,
+        .id_table       = omap_rtc_id_table,
 };
 
 module_platform_driver_probe(omap_rtc_driver, omap_rtc_probe);
 
+MODULE_ALIAS("platform:omap_rtc");
 MODULE_AUTHOR("George G. Davis (and others)");
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index c2ef0a22ee94..96fb32e7d6f8 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -28,6 +28,7 @@
 #define PCF8563_REG_ST2         0x01
 #define PCF8563_BIT_AIE         (1 << 1)
 #define PCF8563_BIT_AF          (1 << 3)
+#define PCF8563_BITS_ST2_N      (7 << 5)
 
 #define PCF8563_REG_SC          0x02 /* datetime */
 #define PCF8563_REG_MN          0x03
@@ -41,6 +42,13 @@
 
 #define PCF8563_REG_CLKO        0x0D /* clock out */
 #define PCF8563_REG_TMRC        0x0E /* timer control */
+#define PCF8563_TMRC_ENABLE     BIT(7)
+#define PCF8563_TMRC_4096       0
+#define PCF8563_TMRC_64         1
+#define PCF8563_TMRC_1          2
+#define PCF8563_TMRC_1_60       3
+#define PCF8563_TMRC_MASK       3
+
 #define PCF8563_REG_TMR         0x0F /* timer */
 
 #define PCF8563_SC_LV           0x80 /* low voltage */
@@ -118,22 +126,21 @@ static int pcf8563_write_block_data(struct i2c_client *client,
 
 static int pcf8563_set_alarm_mode(struct i2c_client *client, bool on)
 {
-        unsigned char buf[2];
+        unsigned char buf;
         int err;
 
-        err = pcf8563_read_block_data(client, PCF8563_REG_ST2, 1, buf + 1);
+        err = pcf8563_read_block_data(client, PCF8563_REG_ST2, 1, &buf);
         if (err < 0)
                 return err;
 
         if (on)
-                buf[1] |= PCF8563_BIT_AIE;
+                buf |= PCF8563_BIT_AIE;
         else
-                buf[1] &= ~PCF8563_BIT_AIE;
+                buf &= ~PCF8563_BIT_AIE;
 
-        buf[1] &= ~PCF8563_BIT_AF;
-        buf[0] = PCF8563_REG_ST2;
+        buf &= ~(PCF8563_BIT_AF | PCF8563_BITS_ST2_N);
 
-        err = pcf8563_write_block_data(client, PCF8563_REG_ST2, 1, buf + 1);
+        err = pcf8563_write_block_data(client, PCF8563_REG_ST2, 1, &buf);
         if (err < 0) {
                 dev_err(&client->dev, "%s: write error\n", __func__);
                 return -EIO;
@@ -336,8 +343,8 @@ static int pcf8563_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *tm)
                 __func__, buf[0], buf[1], buf[2], buf[3]);
 
         tm->time.tm_min = bcd2bin(buf[0] & 0x7F);
-        tm->time.tm_hour = bcd2bin(buf[1] & 0x7F);
-        tm->time.tm_mday = bcd2bin(buf[2] & 0x1F);
+        tm->time.tm_hour = bcd2bin(buf[1] & 0x3F);
+        tm->time.tm_mday = bcd2bin(buf[2] & 0x3F);
         tm->time.tm_wday = bcd2bin(buf[3] & 0x7);
         tm->time.tm_mon = -1;
         tm->time.tm_year = -1;
@@ -361,6 +368,14 @@ static int pcf8563_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *tm)
         struct i2c_client *client = to_i2c_client(dev);
         unsigned char buf[4];
         int err;
+        unsigned long alarm_time;
+
+        /* The alarm has no seconds, round up to nearest minute */
+        if (tm->time.tm_sec) {
+                rtc_tm_to_time(&tm->time, &alarm_time);
+                alarm_time += 60-tm->time.tm_sec;
+                rtc_time_to_tm(alarm_time, &tm->time);
+        }
 
         dev_dbg(dev, "%s, min=%d hour=%d wday=%d mday=%d "
                 "enabled=%d pending=%d\n", __func__,
@@ -381,6 +396,7 @@ static int pcf8563_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *tm)
 
 static int pcf8563_irq_enable(struct device *dev, unsigned int enabled)
 {
+        dev_dbg(dev, "%s: en=%d\n", __func__, enabled);
         return pcf8563_set_alarm_mode(to_i2c_client(dev), !!enabled);
 }
 
@@ -398,6 +414,8 @@ static int pcf8563_probe(struct i2c_client *client,
 {
         struct pcf8563 *pcf8563;
         int err;
+        unsigned char buf;
+        unsigned char alm_pending;
 
         dev_dbg(&client->dev, "%s\n", __func__);
 
@@ -415,6 +433,22 @@ static int pcf8563_probe(struct i2c_client *client,
         pcf8563->client = client;
         device_set_wakeup_capable(&client->dev, 1);
 
+        /* Set timer to lowest frequency to save power (ref Haoyu datasheet) */
+        buf = PCF8563_TMRC_1_60;
+        err = pcf8563_write_block_data(client, PCF8563_REG_TMRC, 1, &buf);
+        if (err < 0) {
+                dev_err(&client->dev, "%s: write error\n", __func__);
+                return err;
+        }
+
+        err = pcf8563_get_alarm_mode(client, NULL, &alm_pending);
+        if (err < 0) {
+                dev_err(&client->dev, "%s: read error\n", __func__);
+                return err;
+        }
+        if (alm_pending)
+                pcf8563_set_alarm_mode(client, 0);
+
         pcf8563->rtc = devm_rtc_device_register(&client->dev,
                                 pcf8563_driver.driver.name,
                                 &pcf8563_rtc_ops, THIS_MODULE);
@@ -435,6 +469,9 @@ static int pcf8563_probe(struct i2c_client *client,
 
         }
 
+        /* the pcf8563 alarm only supports a minute accuracy */
+        pcf8563->rtc->uie_unsupported = 1;
+
         return 0;
 }
 
diff --git a/drivers/rtc/rtc-sirfsoc.c b/drivers/rtc/rtc-sirfsoc.c
index 76e38007ba90..d2ac6688e5c7 100644
--- a/drivers/rtc/rtc-sirfsoc.c
+++ b/drivers/rtc/rtc-sirfsoc.c
@@ -47,6 +47,7 @@ struct sirfsoc_rtc_drv {
         unsigned                irq_wake;
         /* Overflow for every 8 years extra time */
         u32                     overflow_rtc;
+        spinlock_t              lock;
 #ifdef CONFIG_PM
         u32             saved_counter;
         u32             saved_overflow_rtc;
@@ -61,7 +62,7 @@ static int sirfsoc_rtc_read_alarm(struct device *dev,
 
         rtcdrv = dev_get_drvdata(dev);
 
-        local_irq_disable();
+        spin_lock_irq(&rtcdrv->lock);
 
         rtc_count = sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_CN);
 
@@ -84,7 +85,8 @@ static int sirfsoc_rtc_read_alarm(struct device *dev,
         if (sirfsoc_rtc_iobrg_readl(
                         rtcdrv->rtc_base + RTC_STATUS) & SIRFSOC_RTC_AL0E)
                 alrm->enabled = 1;
-        local_irq_enable();
+
+        spin_unlock_irq(&rtcdrv->lock);
 
         return 0;
 }
@@ -99,7 +101,7 @@ static int sirfsoc_rtc_set_alarm(struct device *dev,
         if (alrm->enabled) {
                 rtc_tm_to_time(&(alrm->time), &rtc_alarm);
 
-                local_irq_disable();
+                spin_lock_irq(&rtcdrv->lock);
 
                 rtc_status_reg = sirfsoc_rtc_iobrg_readl(
                                 rtcdrv->rtc_base + RTC_STATUS);
@@ -123,14 +125,15 @@ static int sirfsoc_rtc_set_alarm(struct device *dev,
                 rtc_status_reg |= SIRFSOC_RTC_AL0E;
                 sirfsoc_rtc_iobrg_writel(
                         rtc_status_reg, rtcdrv->rtc_base + RTC_STATUS);
-                local_irq_enable();
+
+                spin_unlock_irq(&rtcdrv->lock);
         } else {
                 /*
                  * if this function was called with enabled=0
                  * then it could mean that the application is
                  * trying to cancel an ongoing alarm
                  */
-                local_irq_disable();
+                spin_lock_irq(&rtcdrv->lock);
 
                 rtc_status_reg = sirfsoc_rtc_iobrg_readl(
                                 rtcdrv->rtc_base + RTC_STATUS);
@@ -146,7 +149,7 @@ static int sirfsoc_rtc_set_alarm(struct device *dev,
                                         rtcdrv->rtc_base + RTC_STATUS);
                 }
 
-                local_irq_enable();
+                spin_unlock_irq(&rtcdrv->lock);
         }
 
         return 0;
@@ -209,12 +212,38 @@ static int sirfsoc_rtc_ioctl(struct device *dev, unsigned int cmd,
         }
 }
 
+static int sirfsoc_rtc_alarm_irq_enable(struct device *dev,
+                unsigned int enabled)
+{
+        unsigned long rtc_status_reg = 0x0;
+        struct sirfsoc_rtc_drv *rtcdrv;
+
+        rtcdrv = dev_get_drvdata(dev);
+
+        spin_lock_irq(&rtcdrv->lock);
+
+        rtc_status_reg = sirfsoc_rtc_iobrg_readl(
+                                rtcdrv->rtc_base + RTC_STATUS);
+        if (enabled)
+                rtc_status_reg |= SIRFSOC_RTC_AL0E;
+        else
+                rtc_status_reg &= ~SIRFSOC_RTC_AL0E;
+
+        sirfsoc_rtc_iobrg_writel(rtc_status_reg, rtcdrv->rtc_base + RTC_STATUS);
+
+        spin_unlock_irq(&rtcdrv->lock);
+
+        return 0;
+
+}
+
 static const struct rtc_class_ops sirfsoc_rtc_ops = {
         .read_time = sirfsoc_rtc_read_time,
         .set_time = sirfsoc_rtc_set_time,
         .read_alarm = sirfsoc_rtc_read_alarm,
         .set_alarm = sirfsoc_rtc_set_alarm,
-        .ioctl = sirfsoc_rtc_ioctl
+        .ioctl = sirfsoc_rtc_ioctl,
+        .alarm_irq_enable = sirfsoc_rtc_alarm_irq_enable
 };
 
 static irqreturn_t sirfsoc_rtc_irq_handler(int irq, void *pdata)
@@ -223,6 +252,8 @@ static irqreturn_t sirfsoc_rtc_irq_handler(int irq, void *pdata)
         unsigned long rtc_status_reg = 0x0;
         unsigned long events = 0x0;
 
+        spin_lock(&rtcdrv->lock);
+
         rtc_status_reg = sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_STATUS);
         /* this bit will be set ONLY if an alarm was active
          * and it expired NOW
@@ -240,6 +271,9 @@ static irqreturn_t sirfsoc_rtc_irq_handler(int irq, void *pdata)
                 rtc_status_reg &= ~(SIRFSOC_RTC_AL0E);
         }
         sirfsoc_rtc_iobrg_writel(rtc_status_reg, rtcdrv->rtc_base + RTC_STATUS);
+
+        spin_unlock(&rtcdrv->lock);
+
         /* this should wake up any apps polling/waiting on the read
          * after setting the alarm
          */
@@ -267,6 +301,8 @@ static int sirfsoc_rtc_probe(struct platform_device *pdev)
         if (rtcdrv == NULL)
                 return -ENOMEM;
 
+        spin_lock_init(&rtcdrv->lock);
+
         err = of_property_read_u32(np, "reg", &rtcdrv->rtc_base);
         if (err) {
                 dev_err(&pdev->dev, "unable to find base address of rtc node in dtb\n");
@@ -286,14 +322,6 @@ static int sirfsoc_rtc_probe(struct platform_device *pdev)
         rtc_div = ((32768 / RTC_HZ) / 2) - 1;
         sirfsoc_rtc_iobrg_writel(rtc_div, rtcdrv->rtc_base + RTC_DIV);
 
-        rtcdrv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
-                        &sirfsoc_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtcdrv->rtc)) {
-                err = PTR_ERR(rtcdrv->rtc);
-                dev_err(&pdev->dev, "can't register RTC device\n");
-                return err;
-        }
-
         /* 0x3 -> RTC_CLK */
         sirfsoc_rtc_iobrg_writel(SIRFSOC_RTC_CLK,
                         rtcdrv->rtc_base + RTC_CLOCK_SWITCH);
@@ -308,6 +336,14 @@ static int sirfsoc_rtc_probe(struct platform_device *pdev)
         rtcdrv->overflow_rtc =
                 sirfsoc_rtc_iobrg_readl(rtcdrv->rtc_base + RTC_SW_VALUE);
 
+        rtcdrv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
+                        &sirfsoc_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtcdrv->rtc)) {
+                err = PTR_ERR(rtcdrv->rtc);
+                dev_err(&pdev->dev, "can't register RTC device\n");
+                return err;
+        }
+
         rtcdrv->irq = platform_get_irq(pdev, 0);
         err = devm_request_irq(
                         &pdev->dev,
diff --git a/drivers/rtc/rtc-snvs.c b/drivers/rtc/rtc-snvs.c
index fa384fe28988..2cd8ffe5c698 100644
--- a/drivers/rtc/rtc-snvs.c
+++ b/drivers/rtc/rtc-snvs.c
@@ -17,6 +17,7 @@
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
+#include <linux/clk.h>
 
 /* These register offsets are relative to LP (Low Power) range */
 #define SNVS_LPCR               0x04
@@ -39,6 +40,7 @@ struct snvs_rtc_data {
         void __iomem *ioaddr;
         int irq;
         spinlock_t lock;
+        struct clk *clk;
 };
 
 static u32 rtc_read_lp_counter(void __iomem *ioaddr)
@@ -260,6 +262,18 @@ static int snvs_rtc_probe(struct platform_device *pdev)
         if (data->irq < 0)
                 return data->irq;
 
+        data->clk = devm_clk_get(&pdev->dev, "snvs-rtc");
+        if (IS_ERR(data->clk)) {
+                data->clk = NULL;
+        } else {
+                ret = clk_prepare_enable(data->clk);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "Could not prepare or enable the snvs clock\n");
+                        return ret;
+                }
+        }
+
         platform_set_drvdata(pdev, data);
 
         spin_lock_init(&data->lock);
@@ -280,7 +294,7 @@ static int snvs_rtc_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(&pdev->dev, "failed to request irq %d: %d\n",
                         data->irq, ret);
-                return ret;
+                goto error_rtc_device_register;
         }
 
         data->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
@@ -288,10 +302,16 @@ static int snvs_rtc_probe(struct platform_device *pdev)
         if (IS_ERR(data->rtc)) {
                 ret = PTR_ERR(data->rtc);
                 dev_err(&pdev->dev, "failed to register rtc: %d\n", ret);
-                return ret;
+                goto error_rtc_device_register;
         }
 
         return 0;
+
+error_rtc_device_register:
+        if (data->clk)
+                clk_disable_unprepare(data->clk);
+
+        return ret;
 }
 
 #ifdef CONFIG_PM_SLEEP
@@ -302,21 +322,34 @@ static int snvs_rtc_suspend(struct device *dev)
         if (device_may_wakeup(dev))
                 enable_irq_wake(data->irq);
 
+        if (data->clk)
+                clk_disable_unprepare(data->clk);
+
         return 0;
 }
 
 static int snvs_rtc_resume(struct device *dev)
 {
         struct snvs_rtc_data *data = dev_get_drvdata(dev);
+        int ret;
 
         if (device_may_wakeup(dev))
                 disable_irq_wake(data->irq);
 
+        if (data->clk) {
+                ret = clk_prepare_enable(data->clk);
+                if (ret)
+                        return ret;
+        }
+
         return 0;
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(snvs_rtc_pm_ops, snvs_rtc_suspend, snvs_rtc_resume);
+static const struct dev_pm_ops snvs_rtc_pm_ops = {
+        .suspend_noirq = snvs_rtc_suspend,
+        .resume_noirq = snvs_rtc_resume,
+};
 
 static const struct of_device_id snvs_dt_ids[] = {
         { .compatible = "fsl,sec-v4.0-mon-rtc-lp", },
diff --git a/drivers/s390/char/hmcdrv_dev.c b/drivers/s390/char/hmcdrv_dev.c
index 0c5176179c17..43cee7fcd01c 100644
--- a/drivers/s390/char/hmcdrv_dev.c
+++ b/drivers/s390/char/hmcdrv_dev.c
@@ -136,8 +136,7 @@ static int hmcdrv_dev_open(struct inode *inode, struct file *fp)
         if (rc)
                 module_put(THIS_MODULE);
 
-        pr_debug("open file '/dev/%s' with return code %d\n",
-                 fp->f_dentry->d_name.name, rc);
+        pr_debug("open file '/dev/%pD' with return code %d\n", fp, rc);
         return rc;
 }
 
@@ -146,7 +145,7 @@ static int hmcdrv_dev_open(struct inode *inode, struct file *fp)
  */
 static int hmcdrv_dev_release(struct inode *inode, struct file *fp)
 {
-        pr_debug("closing file '/dev/%s'\n", fp->f_dentry->d_name.name);
+        pr_debug("closing file '/dev/%pD'\n", fp);
         kfree(fp->private_data);
         fp->private_data = NULL;
         hmcdrv_ftp_shutdown();
@@ -231,8 +230,8 @@ static ssize_t hmcdrv_dev_read(struct file *fp, char __user *ubuf,
         retlen = hmcdrv_dev_transfer((char *) fp->private_data,
                                      *pos, ubuf, len);
 
-        pr_debug("read from file '/dev/%s' at %lld returns %zd/%zu\n",
-                 fp->f_dentry->d_name.name, (long long) *pos, retlen, len);
+        pr_debug("read from file '/dev/%pD' at %lld returns %zd/%zu\n",
+                 fp, (long long) *pos, retlen, len);
 
         if (retlen > 0)
                 *pos += retlen;
@@ -248,8 +247,8 @@ static ssize_t hmcdrv_dev_write(struct file *fp, const char __user *ubuf,
 {
         ssize_t retlen;
 
-        pr_debug("writing file '/dev/%s' at pos. %lld with length %zd\n",
-                 fp->f_dentry->d_name.name, (long long) *pos, len);
+        pr_debug("writing file '/dev/%pD' at pos. %lld with length %zd\n",
+                 fp, (long long) *pos, len);
 
         if (!fp->private_data) { /* first expect a cmd write */
                 fp->private_data = kmalloc(len + 1, GFP_KERNEL);
@@ -272,8 +271,7 @@ static ssize_t hmcdrv_dev_write(struct file *fp, const char __user *ubuf,
         if (retlen > 0)
                 *pos += retlen;
 
-        pr_debug("write to file '/dev/%s' returned %zd\n",
-                 fp->f_dentry->d_name.name, retlen);
+        pr_debug("write to file '/dev/%pD' returned %zd\n", fp, retlen);
 
         return retlen;
 }
diff --git a/drivers/s390/kvm/kvm_virtio.c b/drivers/s390/kvm/kvm_virtio.c
index 643129070c51..dd65c8b4c7fe 100644
--- a/drivers/s390/kvm/kvm_virtio.c
+++ b/drivers/s390/kvm/kvm_virtio.c
@@ -80,7 +80,7 @@ static unsigned desc_size(const struct kvm_device_desc *desc)
 }
 
 /* This gets the device's feature bits. */
-static u32 kvm_get_features(struct virtio_device *vdev)
+static u64 kvm_get_features(struct virtio_device *vdev)
 {
         unsigned int i;
         u32 features = 0;
@@ -93,7 +93,7 @@ static u32 kvm_get_features(struct virtio_device *vdev)
         return features;
 }
 
-static void kvm_finalize_features(struct virtio_device *vdev)
+static int kvm_finalize_features(struct virtio_device *vdev)
 {
         unsigned int i, bits;
         struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
@@ -103,12 +103,17 @@ static void kvm_finalize_features(struct virtio_device *vdev)
         /* Give virtio_ring a chance to accept features. */
         vring_transport_features(vdev);
 
+        /* Make sure we don't have any features > 32 bits! */
+        BUG_ON((u32)vdev->features != vdev->features);
+
         memset(out_features, 0, desc->feature_len);
         bits = min_t(unsigned, desc->feature_len, sizeof(vdev->features)) * 8;
         for (i = 0; i < bits; i++) {
-                if (test_bit(i, vdev->features))
+                if (__virtio_test_bit(vdev, i))
                         out_features[i / 8] |= (1 << (i % 8));
         }
+
+        return 0;
 }
 
 /*
diff --git a/drivers/s390/kvm/virtio_ccw.c b/drivers/s390/kvm/virtio_ccw.c
index bda52f18e967..71d7802aa8b4 100644
--- a/drivers/s390/kvm/virtio_ccw.c
+++ b/drivers/s390/kvm/virtio_ccw.c
@@ -55,6 +55,7 @@ struct virtio_ccw_device {
         struct ccw_device *cdev;
         __u32 curr_io;
         int err;
+        unsigned int revision; /* Transport revision */
         wait_queue_head_t wait_q;
         spinlock_t lock;
         struct list_head virtqueues;
@@ -67,13 +68,22 @@ struct virtio_ccw_device {
         void *airq_info;
 };
 
-struct vq_info_block {
+struct vq_info_block_legacy {
         __u64 queue;
         __u32 align;
         __u16 index;
         __u16 num;
 } __packed;
 
+struct vq_info_block {
+        __u64 desc;
+        __u32 res0;
+        __u16 index;
+        __u16 num;
+        __u64 avail;
+        __u64 used;
+} __packed;
+
 struct virtio_feature_desc {
         __u32 features;
         __u8 index;
@@ -86,11 +96,23 @@ struct virtio_thinint_area {
         u8 isc;
 } __packed;
 
+struct virtio_rev_info {
+        __u16 revision;
+        __u16 length;
+        __u8 data[];
+};
+
+/* the highest virtio-ccw revision we support */
+#define VIRTIO_CCW_REV_MAX 1
+
 struct virtio_ccw_vq_info {
         struct virtqueue *vq;
         int num;
         void *queue;
-        struct vq_info_block *info_block;
+        union {
+                struct vq_info_block s;
+                struct vq_info_block_legacy l;
+        } *info_block;
         int bit_nr;
         struct list_head node;
         long cookie;
@@ -122,6 +144,7 @@ static struct airq_info *airq_areas[MAX_AIRQ_AREAS];
 #define CCW_CMD_WRITE_STATUS 0x31
 #define CCW_CMD_READ_VQ_CONF 0x32
 #define CCW_CMD_SET_IND_ADAPTER 0x73
+#define CCW_CMD_SET_VIRTIO_REV 0x83
 
 #define VIRTIO_CCW_DOING_SET_VQ 0x00010000
 #define VIRTIO_CCW_DOING_RESET 0x00040000
@@ -134,6 +157,7 @@ static struct airq_info *airq_areas[MAX_AIRQ_AREAS];
 #define VIRTIO_CCW_DOING_READ_VQ_CONF 0x02000000
 #define VIRTIO_CCW_DOING_SET_CONF_IND 0x04000000
 #define VIRTIO_CCW_DOING_SET_IND_ADAPTER 0x08000000
+#define VIRTIO_CCW_DOING_SET_VIRTIO_REV 0x10000000
 #define VIRTIO_CCW_INTPARM_MASK 0xffff0000
 
 static struct virtio_ccw_device *to_vc_device(struct virtio_device *vdev)
@@ -399,13 +423,22 @@ static void virtio_ccw_del_vq(struct virtqueue *vq, struct ccw1 *ccw)
         spin_unlock_irqrestore(&vcdev->lock, flags);
 
         /* Release from host. */
-        info->info_block->queue = 0;
-        info->info_block->align = 0;
-        info->info_block->index = index;
-        info->info_block->num = 0;
+        if (vcdev->revision == 0) {
+                info->info_block->l.queue = 0;
+                info->info_block->l.align = 0;
+                info->info_block->l.index = index;
+                info->info_block->l.num = 0;
+                ccw->count = sizeof(info->info_block->l);
+        } else {
+                info->info_block->s.desc = 0;
+                info->info_block->s.index = index;
+                info->info_block->s.num = 0;
+                info->info_block->s.avail = 0;
+                info->info_block->s.used = 0;
+                ccw->count = sizeof(info->info_block->s);
+        }
         ccw->cmd_code = CCW_CMD_SET_VQ;
         ccw->flags = 0;
-        ccw->count = sizeof(*info->info_block);
         ccw->cda = (__u32)(unsigned long)(info->info_block);
         ret = ccw_io_helper(vcdev, ccw,
                             VIRTIO_CCW_DOING_SET_VQ | index);
@@ -488,13 +521,22 @@ static struct virtqueue *virtio_ccw_setup_vq(struct virtio_device *vdev,
         }
 
         /* Register it with the host. */
-        info->info_block->queue = (__u64)info->queue;
-        info->info_block->align = KVM_VIRTIO_CCW_RING_ALIGN;
-        info->info_block->index = i;
-        info->info_block->num = info->num;
+        if (vcdev->revision == 0) {
+                info->info_block->l.queue = (__u64)info->queue;
+                info->info_block->l.align = KVM_VIRTIO_CCW_RING_ALIGN;
+                info->info_block->l.index = i;
+                info->info_block->l.num = info->num;
+                ccw->count = sizeof(info->info_block->l);
+        } else {
+                info->info_block->s.desc = (__u64)info->queue;
+                info->info_block->s.index = i;
+                info->info_block->s.num = info->num;
+                info->info_block->s.avail = (__u64)virtqueue_get_avail(vq);
+                info->info_block->s.used = (__u64)virtqueue_get_used(vq);
+                ccw->count = sizeof(info->info_block->s);
+        }
         ccw->cmd_code = CCW_CMD_SET_VQ;
         ccw->flags = 0;
-        ccw->count = sizeof(*info->info_block);
         ccw->cda = (__u32)(unsigned long)(info->info_block);
         err = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_VQ | i);
         if (err) {
@@ -660,11 +702,12 @@ static void virtio_ccw_reset(struct virtio_device *vdev)
         kfree(ccw);
 }
 
-static u32 virtio_ccw_get_features(struct virtio_device *vdev)
+static u64 virtio_ccw_get_features(struct virtio_device *vdev)
 {
         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
         struct virtio_feature_desc *features;
-        int ret, rc;
+        int ret;
+        u64 rc;
         struct ccw1 *ccw;
 
         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
@@ -677,7 +720,6 @@ static u32 virtio_ccw_get_features(struct virtio_device *vdev)
                 goto out_free;
         }
         /* Read the feature bits from the host. */
-        /* TODO: Features > 32 bits */
         features->index = 0;
         ccw->cmd_code = CCW_CMD_READ_FEAT;
         ccw->flags = 0;
@@ -691,46 +733,79 @@ static u32 virtio_ccw_get_features(struct virtio_device *vdev)
 
         rc = le32_to_cpu(features->features);
 
+        if (vcdev->revision == 0)
+                goto out_free;
+
+        /* Read second half of the feature bits from the host. */
+        features->index = 1;
+        ccw->cmd_code = CCW_CMD_READ_FEAT;
+        ccw->flags = 0;
+        ccw->count = sizeof(*features);
+        ccw->cda = (__u32)(unsigned long)features;
+        ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_FEAT);
+        if (ret == 0)
+                rc |= (u64)le32_to_cpu(features->features) << 32;
+
 out_free:
         kfree(features);
         kfree(ccw);
         return rc;
 }
 
-static void virtio_ccw_finalize_features(struct virtio_device *vdev)
+static int virtio_ccw_finalize_features(struct virtio_device *vdev)
 {
         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
         struct virtio_feature_desc *features;
-        int i;
         struct ccw1 *ccw;
+        int ret;
+
+        if (vcdev->revision >= 1 &&
+            !__virtio_test_bit(vdev, VIRTIO_F_VERSION_1)) {
+                dev_err(&vdev->dev, "virtio: device uses revision 1 "
+                        "but does not have VIRTIO_F_VERSION_1\n");
+                return -EINVAL;
+        }
 
         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
         if (!ccw)
-                return;
+                return -ENOMEM;
 
         features = kzalloc(sizeof(*features), GFP_DMA | GFP_KERNEL);
-        if (!features)
+        if (!features) {
+                ret = -ENOMEM;
                 goto out_free;
-
+        }
         /* Give virtio_ring a chance to accept features. */
         vring_transport_features(vdev);
 
-        for (i = 0; i < sizeof(*vdev->features) / sizeof(features->features);
-             i++) {
-                int highbits = i % 2 ? 32 : 0;
-                features->index = i;
-                features->features = cpu_to_le32(vdev->features[i / 2]
-                                                 >> highbits);
-                /* Write the feature bits to the host. */
-                ccw->cmd_code = CCW_CMD_WRITE_FEAT;
-                ccw->flags = 0;
-                ccw->count = sizeof(*features);
-                ccw->cda = (__u32)(unsigned long)features;
-                ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_FEAT);
-        }
+        features->index = 0;
+        features->features = cpu_to_le32((u32)vdev->features);
+        /* Write the first half of the feature bits to the host. */
+        ccw->cmd_code = CCW_CMD_WRITE_FEAT;
+        ccw->flags = 0;
+        ccw->count = sizeof(*features);
+        ccw->cda = (__u32)(unsigned long)features;
+        ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_FEAT);
+        if (ret)
+                goto out_free;
+
+        if (vcdev->revision == 0)
+                goto out_free;
+
+        features->index = 1;
+        features->features = cpu_to_le32(vdev->features >> 32);
+        /* Write the second half of the feature bits to the host. */
+        ccw->cmd_code = CCW_CMD_WRITE_FEAT;
+        ccw->flags = 0;
+        ccw->count = sizeof(*features);
+        ccw->cda = (__u32)(unsigned long)features;
+        ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_FEAT);
+
 out_free:
         kfree(features);
         kfree(ccw);
+
+        return ret;
 }
 
 static void virtio_ccw_get_config(struct virtio_device *vdev,
@@ -806,7 +881,9 @@ static u8 virtio_ccw_get_status(struct virtio_device *vdev)
 static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)
 {
         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+        u8 old_status = *vcdev->status;
         struct ccw1 *ccw;
+        int ret;
 
         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
         if (!ccw)
@@ -818,7 +895,10 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)
         ccw->flags = 0;
         ccw->count = sizeof(status);
         ccw->cda = (__u32)(unsigned long)vcdev->status;
-        ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_STATUS);
+        ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_STATUS);
+        /* Write failed? We assume status is unchanged. */
+        if (ret)
+                *vcdev->status = old_status;
         kfree(ccw);
 }
 
@@ -919,6 +999,7 @@ static void virtio_ccw_int_handler(struct ccw_device *cdev,
                 case VIRTIO_CCW_DOING_RESET:
                 case VIRTIO_CCW_DOING_READ_VQ_CONF:
                 case VIRTIO_CCW_DOING_SET_IND_ADAPTER:
+                case VIRTIO_CCW_DOING_SET_VIRTIO_REV:
                         vcdev->curr_io &= ~activity;
                         wake_up(&vcdev->wait_q);
                         break;
@@ -1034,6 +1115,51 @@ static int virtio_ccw_offline(struct ccw_device *cdev)
         return 0;
 }
 
+static int virtio_ccw_set_transport_rev(struct virtio_ccw_device *vcdev)
+{
+        struct virtio_rev_info *rev;
+        struct ccw1 *ccw;
+        int ret;
+
+        ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+        if (!ccw)
+                return -ENOMEM;
+        rev = kzalloc(sizeof(*rev), GFP_DMA | GFP_KERNEL);
+        if (!rev) {
+                kfree(ccw);
+                return -ENOMEM;
+        }
+
+        /* Set transport revision */
+        ccw->cmd_code = CCW_CMD_SET_VIRTIO_REV;
+        ccw->flags = 0;
+        ccw->count = sizeof(*rev);
+        ccw->cda = (__u32)(unsigned long)rev;
+
+        vcdev->revision = VIRTIO_CCW_REV_MAX;
+        do {
+                rev->revision = vcdev->revision;
+                /* none of our supported revisions carry payload */
+                rev->length = 0;
+                ret = ccw_io_helper(vcdev, ccw,
+                                    VIRTIO_CCW_DOING_SET_VIRTIO_REV);
+                if (ret == -EOPNOTSUPP) {
+                        if (vcdev->revision == 0)
+                                /*
+                                 * The host device does not support setting
+                                 * the revision: let's operate it in legacy
+                                 * mode.
+                                 */
+                                ret = 0;
+                        else
+                                vcdev->revision--;
+                }
+        } while (ret == -EOPNOTSUPP);
+
+        kfree(ccw);
+        kfree(rev);
+        return ret;
+}
 
 static int virtio_ccw_online(struct ccw_device *cdev)
 {
@@ -1074,6 +1200,15 @@ static int virtio_ccw_online(struct ccw_device *cdev)
         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
         vcdev->vdev.id.vendor = cdev->id.cu_type;
         vcdev->vdev.id.device = cdev->id.cu_model;
+
+        if (virtio_device_is_legacy_only(vcdev->vdev.id)) {
+                vcdev->revision = 0;
+        } else {
+                ret = virtio_ccw_set_transport_rev(vcdev);
+                if (ret)
+                        goto out_free;
+        }
+
         ret = register_virtio_device(&vcdev->vdev);
         if (ret) {
                 dev_warn(&cdev->dev, "Failed to register virtio device: %d\n",
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 8004b071a9f2..01a73395a017 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -353,9 +353,11 @@ struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device)
         adapter->ccw_device = ccw_device;
 
         INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
-        INIT_WORK(&adapter->scan_work, zfcp_fc_scan_ports);
+        INIT_DELAYED_WORK(&adapter->scan_work, zfcp_fc_scan_ports);
         INIT_WORK(&adapter->ns_up_work, zfcp_fc_sym_name_update);
 
+        adapter->next_port_scan = jiffies;
+
         if (zfcp_qdio_setup(adapter))
                 goto failed;
 
@@ -420,7 +422,7 @@ void zfcp_adapter_unregister(struct zfcp_adapter *adapter)
 {
         struct ccw_device *cdev = adapter->ccw_device;
 
-        cancel_work_sync(&adapter->scan_work);
+        cancel_delayed_work_sync(&adapter->scan_work);
         cancel_work_sync(&adapter->stat_work);
         cancel_work_sync(&adapter->ns_up_work);
         zfcp_destroy_adapter_work_queue(adapter);
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index f9879d400d0e..54c7b48fdb46 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -56,8 +56,22 @@ static int zfcp_ccw_activate(struct ccw_device *cdev, int clear, char *tag)
         zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
                                 tag);
+
+        /*
+         * We want to scan ports here, with some random backoff and without
+         * rate limit. Recovery has already scheduled a port scan for us,
+         * but with both random delay and rate limit. Nevertheless we get
+         * what we want here by flushing the scheduled work after sleeping
+         * an equivalent random time.
+         * Let the port scan random delay elapse first. If recovery finishes
+         * up to that point in time, that would be perfect for both recovery
+         * and port scan. If not, i.e. recovery takes ages, there was no
+         * point in waiting a random delay on top of the time consumed by
+         * recovery.
+         */
+        msleep(zfcp_fc_port_scan_backoff());
         zfcp_erp_wait(adapter);
-        flush_work(&adapter->scan_work); /* ok to call even if nothing queued */
+        flush_delayed_work(&adapter->scan_work);
 
         zfcp_ccw_adapter_put(adapter);
 
@@ -162,11 +176,19 @@ static int zfcp_ccw_set_online(struct ccw_device *cdev)
         adapter->req_no = 0;
 
         zfcp_ccw_activate(cdev, 0, "ccsonl1");
-        /* scan for remote ports
-           either at the end of any successful adapter recovery
-           or only after the adapter recovery for setting a device online */
+
+        /*
+         * We want to scan ports here, always, with some random delay and
+         * without rate limit - basically what zfcp_ccw_activate() has
+         * achieved for us. Not quite! That port scan depended on
+         * !no_auto_port_rescan. So let's cover the no_auto_port_rescan
+         * case here to make sure a port scan is done unconditionally.
+         * Since zfcp_ccw_activate() has waited the desired random time,
+         * we can immediately schedule and flush a port scan for the
+         * remaining cases.
+         */
         zfcp_fc_inverse_conditional_port_scan(adapter);
-        flush_work(&adapter->scan_work); /* ok to call even if nothing queued */
+        flush_delayed_work(&adapter->scan_work);
         zfcp_ccw_adapter_put(adapter);
         return 0;
 }
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index d91173f326c5..b8e853e53546 100644
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -186,12 +186,13 @@ struct zfcp_adapter {
         struct fc_host_statistics *fc_stats;
         struct fsf_qtcb_bottom_port *stats_reset_data;
         unsigned long           stats_reset;
-        struct work_struct      scan_work;
+        struct delayed_work     scan_work;
         struct work_struct      ns_up_work;
         struct service_level    service_level;
         struct workqueue_struct *work_queue;
         struct device_dma_parameters dma_parms;
         struct zfcp_fc_events events;
+        unsigned long           next_port_scan;
 };
 
 struct zfcp_port {
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index c82fe65c4128..2c5d4567d1da 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -821,11 +821,6 @@ static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
         return ZFCP_ERP_CONTINUES;
 }
 
-static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
-{
-        atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, &port->status);
-}
-
 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_port *port = erp_action->port;
@@ -833,7 +828,6 @@ static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
 
         switch (erp_action->step) {
         case ZFCP_ERP_STEP_UNINITIALIZED:
-                zfcp_erp_port_strategy_clearstati(port);
                 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
                     (status & ZFCP_STATUS_COMMON_OPEN))
                         return zfcp_erp_port_forced_strategy_close(erp_action);
@@ -933,7 +927,6 @@ static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
 
         switch (erp_action->step) {
         case ZFCP_ERP_STEP_UNINITIALIZED:
-                zfcp_erp_port_strategy_clearstati(port);
                 if (p_status & ZFCP_STATUS_COMMON_OPEN)
                         return zfcp_erp_port_strategy_close(erp_action);
                 break;
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index a9c570a09b85..5b500652572b 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -85,6 +85,7 @@ extern void zfcp_fc_gs_destroy(struct zfcp_adapter *);
 extern int zfcp_fc_exec_bsg_job(struct fc_bsg_job *);
 extern int zfcp_fc_timeout_bsg_job(struct fc_bsg_job *);
 extern void zfcp_fc_sym_name_update(struct work_struct *);
+extern unsigned int zfcp_fc_port_scan_backoff(void);
 extern void zfcp_fc_conditional_port_scan(struct zfcp_adapter *);
 extern void zfcp_fc_inverse_conditional_port_scan(struct zfcp_adapter *);
 
diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index ca28e1c66115..25d49f32ca63 100644
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -12,6 +12,7 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/utsname.h>
+#include <linux/random.h>
 #include <scsi/fc/fc_els.h>
 #include <scsi/libfc.h>
 #include "zfcp_ext.h"
@@ -31,12 +32,54 @@ module_param_named(no_auto_port_rescan, no_auto_port_rescan, bool, 0600);
 MODULE_PARM_DESC(no_auto_port_rescan,
                  "no automatic port_rescan (default off)");
 
+static unsigned int port_scan_backoff = 500;
+module_param(port_scan_backoff, uint, 0600);
+MODULE_PARM_DESC(port_scan_backoff,
+        "upper limit of port scan random backoff in msecs (default 500)");
+
+static unsigned int port_scan_ratelimit = 60000;
+module_param(port_scan_ratelimit, uint, 0600);
+MODULE_PARM_DESC(port_scan_ratelimit,
+        "minimum interval between port scans in msecs (default 60000)");
+
+unsigned int zfcp_fc_port_scan_backoff(void)
+{
+        if (!port_scan_backoff)
+                return 0;
+        return get_random_int() % port_scan_backoff;
+}
+
+static void zfcp_fc_port_scan_time(struct zfcp_adapter *adapter)
+{
+        unsigned long interval = msecs_to_jiffies(port_scan_ratelimit);
+        unsigned long backoff = msecs_to_jiffies(zfcp_fc_port_scan_backoff());
+
+        adapter->next_port_scan = jiffies + interval + backoff;
+}
+
+static void zfcp_fc_port_scan(struct zfcp_adapter *adapter)
+{
+        unsigned long now = jiffies;
+        unsigned long next = adapter->next_port_scan;
+        unsigned long delay = 0, max;
+
+        /* delay only needed within waiting period */
+        if (time_before(now, next)) {
+                delay = next - now;
+                /* paranoia: never ever delay scans longer than specified */
+                max = msecs_to_jiffies(port_scan_ratelimit + port_scan_backoff);
+                delay = min(delay, max);
+        }
+
+        queue_delayed_work(adapter->work_queue, &adapter->scan_work, delay);
+}
+
 void zfcp_fc_conditional_port_scan(struct zfcp_adapter *adapter)
 {
         if (no_auto_port_rescan)
                 return;
 
-        queue_work(adapter->work_queue, &adapter->scan_work);
+        zfcp_fc_port_scan(adapter);
 }
 
 void zfcp_fc_inverse_conditional_port_scan(struct zfcp_adapter *adapter)
@@ -44,7 +87,7 @@ void zfcp_fc_inverse_conditional_port_scan(struct zfcp_adapter *adapter)
         if (!no_auto_port_rescan)
                 return;
 
-        queue_work(adapter->work_queue, &adapter->scan_work);
+        zfcp_fc_port_scan(adapter);
 }
 
 /**
@@ -680,12 +723,15 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_req *fc_req,
  */
 void zfcp_fc_scan_ports(struct work_struct *work)
 {
-        struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
+        struct delayed_work *dw = to_delayed_work(work);
+        struct zfcp_adapter *adapter = container_of(dw, struct zfcp_adapter,
                                                     scan_work);
         int ret, i;
         struct zfcp_fc_req *fc_req;
         int chain, max_entries, buf_num, max_bytes;
 
+        zfcp_fc_port_scan_time(adapter);
+
         chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS;
         buf_num = chain ? ZFCP_FC_GPN_FT_NUM_BUFS : 1;
         max_entries = chain ? ZFCP_FC_GPN_FT_MAX_ENT : ZFCP_FC_GPN_FT_ENT_PAGE;
diff --git a/drivers/s390/scsi/zfcp_fc.h b/drivers/s390/scsi/zfcp_fc.h
index b1d2024ed513..df2b541c8287 100644
--- a/drivers/s390/scsi/zfcp_fc.h
+++ b/drivers/s390/scsi/zfcp_fc.h
@@ -212,8 +212,6 @@ static inline
 void zfcp_fc_scsi_to_fcp(struct fcp_cmnd *fcp, struct scsi_cmnd *scsi,
                          u8 tm_flags)
 {
-        char tag[2];
-
         int_to_scsilun(scsi->device->lun, (struct scsi_lun *) &fcp->fc_lun);
 
         if (unlikely(tm_flags)) {
@@ -221,17 +219,7 @@ void zfcp_fc_scsi_to_fcp(struct fcp_cmnd *fcp, struct scsi_cmnd *scsi,
                 return;
         }
 
-        if (scsi_populate_tag_msg(scsi, tag)) {
-                switch (tag[0]) {
-                case MSG_ORDERED_TAG:
-                        fcp->fc_pri_ta |= FCP_PTA_ORDERED;
-                        break;
-                case MSG_SIMPLE_TAG:
-                        fcp->fc_pri_ta |= FCP_PTA_SIMPLE;
-                        break;
-                };
-        } else
-                fcp->fc_pri_ta = FCP_PTA_SIMPLE;
+        fcp->fc_pri_ta = FCP_PTA_SIMPLE;
 
         if (scsi->sc_data_direction == DMA_FROM_DEVICE)
                 fcp->fc_flags |= FCP_CFL_RDDATA;
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 0fe8d5d95119..21ec5e2f584c 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -1396,8 +1396,7 @@ static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
                 port->handle = header->port_handle;
                 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN |
                                 ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
-                atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
-                                  ZFCP_STATUS_COMMON_ACCESS_BOXED,
+                atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
                                   &port->status);
                 /* check whether D_ID has changed during open */
                 /*
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 7b353647cb90..75f4bfc2b98a 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -32,25 +32,6 @@ static bool allow_lun_scan = 1;
 module_param(allow_lun_scan, bool, 0600);
 MODULE_PARM_DESC(allow_lun_scan, "For NPIV, scan and attach all storage LUNs");
 
-static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth,
-                                        int reason)
-{
-        switch (reason) {
-        case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
-                break;
-        case SCSI_QDEPTH_QFULL:
-                scsi_track_queue_full(sdev, depth);
-                break;
-        case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-        return sdev->queue_depth;
-}
-
 static void zfcp_scsi_slave_destroy(struct scsi_device *sdev)
 {
         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
@@ -66,9 +47,7 @@ static void zfcp_scsi_slave_destroy(struct scsi_device *sdev)
 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
 {
         if (sdp->tagged_supported)
-                scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, default_depth);
-        else
-                scsi_adjust_queue_depth(sdp, 0, 1);
+                scsi_change_queue_depth(sdp, default_depth);
         return 0;
 }
 
@@ -307,7 +286,7 @@ static struct scsi_host_template zfcp_scsi_host_template = {
         .slave_alloc             = zfcp_scsi_slave_alloc,
         .slave_configure         = zfcp_scsi_slave_configure,
         .slave_destroy           = zfcp_scsi_slave_destroy,
-        .change_queue_depth      = zfcp_scsi_change_queue_depth,
+        .change_queue_depth      = scsi_change_queue_depth,
         .proc_name               = "zfcp",
         .can_queue               = 4096,
         .this_id                 = -1,
@@ -322,6 +301,7 @@ static struct scsi_host_template zfcp_scsi_host_template = {
         .use_clustering          = 1,
         .shost_attrs             = zfcp_sysfs_shost_attrs,
         .sdev_attrs              = zfcp_sysfs_sdev_attrs,
+        .track_queue_depth       = 1,
 };
 
 /**
diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c
index 672b57219e11..96a0be13e841 100644
--- a/drivers/s390/scsi/zfcp_sysfs.c
+++ b/drivers/s390/scsi/zfcp_sysfs.c
@@ -73,9 +73,7 @@ ZFCP_DEFINE_ATTR(zfcp_port, port, status, "0x%08x\n",
 ZFCP_DEFINE_ATTR(zfcp_port, port, in_recovery, "%d\n",
                  (atomic_read(&port->status) &
                   ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
-ZFCP_DEFINE_ATTR(zfcp_port, port, access_denied, "%d\n",
-                 (atomic_read(&port->status) &
-                  ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
+ZFCP_DEFINE_ATTR_CONST(port, access_denied, "%d\n", 0);
 
 ZFCP_DEFINE_ATTR(zfcp_unit, unit, status, "0x%08x\n",
                  zfcp_unit_sdev_status(unit));
@@ -223,9 +221,13 @@ static ssize_t zfcp_sysfs_port_rescan_store(struct device *dev,
         if (!adapter)
                 return -ENODEV;
 
-        /* sync the user-space- with the kernel-invocation of scan_work */
-        queue_work(adapter->work_queue, &adapter->scan_work);
-        flush_work(&adapter->scan_work);
+        /*
+         * Users wish is our command: immediately schedule and flush a
+         * worker to conduct a synchronous port scan, that is, neither
+         * a random delay nor a rate limit is applied here.
+         */
+        queue_delayed_work(adapter->work_queue, &adapter->scan_work, 0);
+        flush_delayed_work(&adapter->scan_work);
         zfcp_ccw_adapter_put(adapter);
 
         return (ssize_t) count;
@@ -439,16 +441,15 @@ static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev,	\
 {                                                                        \
         struct scsi_device *sdev = to_scsi_device(dev);                  \
         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);            \
-        struct zfcp_port *port = zfcp_sdev->port;                        \
                                                                          \
         return sprintf(buf, _format, _value);                            \
 }                                                                        \
 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);
 
 ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n",
-                      dev_name(&port->adapter->ccw_device->dev));
+                      dev_name(&zfcp_sdev->port->adapter->ccw_device->dev));
 ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n",
-                      (unsigned long long) port->wwpn);
+                      (unsigned long long) zfcp_sdev->port->wwpn);
 
 static ssize_t zfcp_sysfs_scsi_fcp_lun_show(struct device *dev,
                                             struct device_attribute *attr,
@@ -460,6 +461,49 @@ static ssize_t zfcp_sysfs_scsi_fcp_lun_show(struct device *dev,
 }
 static DEVICE_ATTR(fcp_lun, S_IRUGO, zfcp_sysfs_scsi_fcp_lun_show, NULL);
 
+ZFCP_DEFINE_SCSI_ATTR(zfcp_access_denied, "%d\n",
+                      (atomic_read(&zfcp_sdev->status) &
+                       ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
+
+static ssize_t zfcp_sysfs_scsi_zfcp_failed_show(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+        unsigned int status = atomic_read(&sdev_to_zfcp(sdev)->status);
+        unsigned int failed = status & ZFCP_STATUS_COMMON_ERP_FAILED ? 1 : 0;
+
+        return sprintf(buf, "%d\n", failed);
+}
+
+static ssize_t zfcp_sysfs_scsi_zfcp_failed_store(struct device *dev,
+                                            struct device_attribute *attr,
+                                            const char *buf, size_t count)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+        unsigned long val;
+
+        if (kstrtoul(buf, 0, &val) || val != 0)
+                return -EINVAL;
+
+        zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
+        zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
+                            "syufai3");
+        zfcp_erp_wait(sdev_to_zfcp(sdev)->port->adapter);
+
+        return count;
+}
+static DEVICE_ATTR(zfcp_failed, S_IWUSR | S_IRUGO,
+                   zfcp_sysfs_scsi_zfcp_failed_show,
+                   zfcp_sysfs_scsi_zfcp_failed_store);
+
+ZFCP_DEFINE_SCSI_ATTR(zfcp_in_recovery, "%d\n",
+                      (atomic_read(&zfcp_sdev->status) &
+                       ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
+
+ZFCP_DEFINE_SCSI_ATTR(zfcp_status, "0x%08x\n",
+                      atomic_read(&zfcp_sdev->status));
+
 struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
         &dev_attr_fcp_lun,
         &dev_attr_wwpn,
@@ -467,6 +511,10 @@ struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
         &dev_attr_read_latency,
         &dev_attr_write_latency,
         &dev_attr_cmd_latency,
+        &dev_attr_zfcp_access_denied,
+        &dev_attr_zfcp_failed,
+        &dev_attr_zfcp_in_recovery,
+        &dev_attr_zfcp_status,
         NULL
 };
 
diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index 0a7325361d29..cd4129ff7ae4 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -189,19 +189,6 @@ static ssize_t twa_show_stats(struct device *dev,
         return len;
 } /* End twa_show_stats() */
 
-/* This function will set a devices queue depth */
-static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth,
-                                  int reason)
-{
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
-        if (queue_depth > TW_Q_LENGTH-2)
-                queue_depth = TW_Q_LENGTH-2;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
-        return queue_depth;
-} /* End twa_change_queue_depth() */
-
 /* Create sysfs 'stats' entry */
 static struct device_attribute twa_host_stats_attr = {
         .attr = {
@@ -2016,7 +2003,7 @@ static struct scsi_host_template driver_template = {
         .queuecommand           = twa_scsi_queue,
         .eh_host_reset_handler  = twa_scsi_eh_reset,
         .bios_param             = twa_scsi_biosparam,
-        .change_queue_depth     = twa_change_queue_depth,
+        .change_queue_depth     = scsi_change_queue_depth,
         .can_queue              = TW_Q_LENGTH-2,
         .slave_configure        = twa_slave_configure,
         .this_id                = -1,
diff --git a/drivers/scsi/3w-sas.c b/drivers/scsi/3w-sas.c
index 6da6cec9a651..2361772d5909 100644
--- a/drivers/scsi/3w-sas.c
+++ b/drivers/scsi/3w-sas.c
@@ -191,19 +191,6 @@ static ssize_t twl_show_stats(struct device *dev,
         return len;
 } /* End twl_show_stats() */
 
-/* This function will set a devices queue depth */
-static int twl_change_queue_depth(struct scsi_device *sdev, int queue_depth,
-                                  int reason)
-{
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
-        if (queue_depth > TW_Q_LENGTH-2)
-                queue_depth = TW_Q_LENGTH-2;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
-        return queue_depth;
-} /* End twl_change_queue_depth() */
-
 /* stats sysfs attribute initializer */
 static struct device_attribute twl_host_stats_attr = {
         .attr = {
@@ -1590,7 +1577,7 @@ static struct scsi_host_template driver_template = {
         .queuecommand           = twl_scsi_queue,
         .eh_host_reset_handler  = twl_scsi_eh_reset,
         .bios_param             = twl_scsi_biosparam,
-        .change_queue_depth     = twl_change_queue_depth,
+        .change_queue_depth     = scsi_change_queue_depth,
         .can_queue              = TW_Q_LENGTH-2,
         .slave_configure        = twl_slave_configure,
         .this_id                = -1,
diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c
index 752624e6bc00..c75f2048319f 100644
--- a/drivers/scsi/3w-xxxx.c
+++ b/drivers/scsi/3w-xxxx.c
@@ -523,19 +523,6 @@ static ssize_t tw_show_stats(struct device *dev, struct device_attribute *attr,
         return len;
 } /* End tw_show_stats() */
 
-/* This function will set a devices queue depth */
-static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth,
-                                 int reason)
-{
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
-        if (queue_depth > TW_Q_LENGTH-2)
-                queue_depth = TW_Q_LENGTH-2;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
-        return queue_depth;
-} /* End tw_change_queue_depth() */
-
 /* Create sysfs 'stats' entry */
 static struct device_attribute tw_host_stats_attr = {
         .attr = {
@@ -2270,7 +2257,7 @@ static struct scsi_host_template driver_template = {
         .queuecommand           = tw_scsi_queue,
         .eh_host_reset_handler  = tw_scsi_eh_reset,
         .bios_param             = tw_scsi_biosparam,
-        .change_queue_depth     = tw_change_queue_depth,
+        .change_queue_depth     = scsi_change_queue_depth,
         .can_queue              = TW_Q_LENGTH-2,
         .slave_configure        = tw_slave_configure,
         .this_id                = -1,
diff --git a/drivers/scsi/53c700.c b/drivers/scsi/53c700.c
index fabd4be2c985..aa915da2a5e5 100644
--- a/drivers/scsi/53c700.c
+++ b/drivers/scsi/53c700.c
@@ -175,7 +175,7 @@ STATIC void NCR_700_chip_reset(struct Scsi_Host *host);
 STATIC int NCR_700_slave_alloc(struct scsi_device *SDpnt);
 STATIC int NCR_700_slave_configure(struct scsi_device *SDpnt);
 STATIC void NCR_700_slave_destroy(struct scsi_device *SDpnt);
-static int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth, int reason);
+static int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth);
 static int NCR_700_change_queue_type(struct scsi_device *SDpnt, int depth);
 
 STATIC struct device_attribute *NCR_700_dev_attrs[];
@@ -327,6 +327,7 @@ NCR_700_detect(struct scsi_host_template *tpnt,
         tpnt->slave_alloc = NCR_700_slave_alloc;
         tpnt->change_queue_depth = NCR_700_change_queue_depth;
         tpnt->change_queue_type = NCR_700_change_queue_type;
+        tpnt->use_blk_tags = 1;
 
         if(tpnt->name == NULL)
                 tpnt->name = "53c700";
@@ -592,19 +593,14 @@ NCR_700_scsi_done(struct NCR_700_Host_Parameters *hostdata,
         hostdata->cmd = NULL;
 
         if(SCp != NULL) {
-                struct NCR_700_command_slot *slot = 
+                struct NCR_700_command_slot *slot =
                         (struct NCR_700_command_slot *)SCp->host_scribble;
-                
+
                 dma_unmap_single(hostdata->dev, slot->pCmd,
                                  MAX_COMMAND_SIZE, DMA_TO_DEVICE);
                 if (slot->flags == NCR_700_FLAG_AUTOSENSE) {
                         char *cmnd = NCR_700_get_sense_cmnd(SCp->device);
-#ifdef NCR_700_DEBUG
-                        printk(" ORIGINAL CMD %p RETURNED %d, new return is %d sense is\n",
-                               SCp, SCp->cmnd[7], result);
-                        scsi_print_sense("53c700", SCp);
 
-#endif
                         dma_unmap_single(hostdata->dev, slot->dma_handle,
                                          SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
                         /* restore the old result if the request sense was
@@ -906,8 +902,10 @@ process_message(struct Scsi_Host *host,	struct NCR_700_Host_Parameters *hostdata
                         /* we're done negotiating */
                         NCR_700_set_tag_neg_state(SCp->device, NCR_700_FINISHED_TAG_NEGOTIATION);
                         hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
+
                         SCp->device->tagged_supported = 0;
-                        scsi_deactivate_tcq(SCp->device, host->cmd_per_lun);
+                        scsi_change_queue_depth(SCp->device, host->cmd_per_lun);
+                        scsi_set_tag_type(SCp->device, 0);
                 } else {
                         shost_printk(KERN_WARNING, host,
                                 "(%d:%d) Unexpected REJECT Message %s\n",
@@ -1432,7 +1430,7 @@ NCR_700_start_command(struct scsi_cmnd *SCp)
         if((hostdata->tag_negotiated & (1<<scmd_id(SCp)))
            && (slot->tag != SCSI_NO_TAG && SCp->cmnd[0] != REQUEST_SENSE &&
                slot->flags != NCR_700_FLAG_AUTOSENSE)) {
-                count += scsi_populate_tag_msg(SCp, &hostdata->msgout[count]);
+                count += spi_populate_tag_msg(&hostdata->msgout[count], SCp);
         }
 
         if(hostdata->fast &&
@@ -1772,7 +1770,7 @@ NCR_700_queuecommand_lck(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *)
          */
         if(NCR_700_get_depth(SCp->device) != 0
            && (!(hostdata->tag_negotiated & (1<<scmd_id(SCp)))
-               || !blk_rq_tagged(SCp->request))) {
+               || !(SCp->flags & SCMD_TAGGED))) {
                 CDEBUG(KERN_ERR, SCp, "has non zero depth %d\n",
                        NCR_700_get_depth(SCp->device));
                 return SCSI_MLQUEUE_DEVICE_BUSY;
@@ -1800,7 +1798,7 @@ NCR_700_queuecommand_lck(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *)
         printk("53c700: scsi%d, command ", SCp->device->host->host_no);
         scsi_print_command(SCp);
 #endif
-        if(blk_rq_tagged(SCp->request)
+        if ((SCp->flags & SCMD_TAGGED)
            && (hostdata->tag_negotiated &(1<<scmd_id(SCp))) == 0
            && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_START_TAG_NEGOTIATION) {
                 scmd_printk(KERN_ERR, SCp, "Enabling Tag Command Queuing\n");
@@ -1814,7 +1812,7 @@ NCR_700_queuecommand_lck(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *)
          *
          * FIXME: This will royally screw up on multiple LUN devices
          * */
-        if(!blk_rq_tagged(SCp->request)
+        if (!(SCp->flags & SCMD_TAGGED)
            && (hostdata->tag_negotiated &(1<<scmd_id(SCp)))) {
                 scmd_printk(KERN_INFO, SCp, "Disabling Tag Command Queuing\n");
                 hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
@@ -1911,9 +1909,7 @@ NCR_700_abort(struct scsi_cmnd * SCp)
 {
         struct NCR_700_command_slot *slot;
 
-        scmd_printk(KERN_INFO, SCp,
-                "New error handler wants to abort command\n\t");
-        scsi_print_command(SCp);
+        scmd_printk(KERN_INFO, SCp, "abort command\n");
 
         slot = (struct NCR_700_command_slot *)SCp->host_scribble;
 
@@ -2056,13 +2052,10 @@ NCR_700_slave_configure(struct scsi_device *SDp)
 
         /* to do here: allocate memory; build a queue_full list */
         if(SDp->tagged_supported) {
-                scsi_set_tag_type(SDp, MSG_ORDERED_TAG);
-                scsi_activate_tcq(SDp, NCR_700_DEFAULT_TAGS);
+                scsi_change_queue_depth(SDp, NCR_700_DEFAULT_TAGS);
                 NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
-        } else {
-                /* initialise to default depth */
-                scsi_adjust_queue_depth(SDp, 0, SDp->host->cmd_per_lun);
         }
+
         if(hostdata->fast) {
                 /* Find the correct offset and period via domain validation */
                 if (!spi_initial_dv(SDp->sdev_target))
@@ -2082,16 +2075,11 @@ NCR_700_slave_destroy(struct scsi_device *SDp)
 }
 
 static int
-NCR_700_change_queue_depth(struct scsi_device *SDp, int depth, int reason)
+NCR_700_change_queue_depth(struct scsi_device *SDp, int depth)
 {
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (depth > NCR_700_MAX_TAGS)
                 depth = NCR_700_MAX_TAGS;
-
-        scsi_adjust_queue_depth(SDp, scsi_get_tag_type(SDp), depth);
-        return depth;
+        return scsi_change_queue_depth(SDp, depth);
 }
 
 static int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type)
@@ -2101,8 +2089,6 @@ static int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type)
         struct NCR_700_Host_Parameters *hostdata = 
                 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
 
-        scsi_set_tag_type(SDp, tag_type);
-
         /* We have a global (per target) flag to track whether TCQ is
          * enabled, so we'll be turning it off for the entire target here.
          * our tag algorithm will fail if we mix tagged and untagged commands,
@@ -2110,15 +2096,16 @@ static int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type)
         if (change_tag)
                 scsi_target_quiesce(SDp->sdev_target);
 
+        scsi_set_tag_type(SDp, tag_type);
         if (!tag_type) {
                 /* shift back to the default unqueued number of commands
                  * (the user can still raise this) */
-                scsi_deactivate_tcq(SDp, SDp->host->cmd_per_lun);
+                scsi_change_queue_depth(SDp, SDp->host->cmd_per_lun);
                 hostdata->tag_negotiated &= ~(1 << sdev_id(SDp));
         } else {
                 /* Here, we cleared the negotiation flag above, so this
                  * will force the driver to renegotiate */
-                scsi_activate_tcq(SDp, SDp->queue_depth);
+                scsi_change_queue_depth(SDp, SDp->queue_depth);
                 if (change_tag)
                         NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
         }
diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 64c75143c89a..8d66a6469e29 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -2327,12 +2327,12 @@ static int blogic_slaveconfig(struct scsi_device *dev)
                 if (qdepth == 0)
                         qdepth = BLOGIC_MAX_AUTO_TAG_DEPTH;
                 adapter->qdepth[tgt_id] = qdepth;
-                scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, qdepth);
+                scsi_change_queue_depth(dev, qdepth);
         } else {
                 adapter->tagq_ok &= ~(1 << tgt_id);
                 qdepth = adapter->untag_qdepth;
                 adapter->qdepth[tgt_id] = qdepth;
-                scsi_adjust_queue_depth(dev, 0, qdepth);
+                scsi_change_queue_depth(dev, qdepth);
         }
         qdepth = 0;
         for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 3a820f61ce65..86cf3d671eb9 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -1341,13 +1341,15 @@ config SCSI_DC395x
           To compile this driver as a module, choose M here: the
           module will be called dc395x.
 
-config SCSI_DC390T
-        tristate "Tekram DC390(T) and Am53/79C974 SCSI support"
+config SCSI_AM53C974
+        tristate "Tekram DC390(T) and Am53/79C974 SCSI support (new driver)"
         depends on PCI && SCSI
+        select SCSI_SPI_ATTRS
         ---help---
           This driver supports PCI SCSI host adapters based on the Am53C974A
           chip, e.g. Tekram DC390(T), DawiControl 2974 and some onboard
           PCscsi/PCnet (Am53/79C974) solutions.
+          This is a new implementation base on the generic esp_scsi driver.
 
           Documentation can be found in <file:Documentation/scsi/tmscsim.txt>.
 
@@ -1355,7 +1357,7 @@ config SCSI_DC390T
           based on NCR/Symbios chips. Use "NCR53C8XX SCSI support" for those.
 
           To compile this driver as a module, choose M here: the
-          module will be called tmscsim.
+          module will be called am53c974.
 
 config SCSI_T128
         tristate "Trantor T128/T128F/T228 SCSI support"
@@ -1451,6 +1453,14 @@ config SCSI_NSP32
           To compile this driver as a module, choose M here: the
           module will be called nsp32.
 
+config SCSI_WD719X
+        tristate "Western Digital WD7193/7197/7296 support"
+        depends on PCI && SCSI
+        select EEPROM_93CX6
+        ---help---
+          This is a driver for Western Digital WD7193, WD7197 and WD7296 PCI
+          SCSI controllers (based on WD33C296A chip).
+
 config SCSI_DEBUG
         tristate "SCSI debugging host simulator"
         depends on SCSI
@@ -1615,7 +1625,7 @@ config ATARI_SCSI_RESET_BOOT
           that leave the devices with SCSI operations partway completed.
 
 config MAC_SCSI
-        bool "Macintosh NCR5380 SCSI"
+        tristate "Macintosh NCR5380 SCSI"
         depends on MAC && SCSI=y
         select SCSI_SPI_ATTRS
         help
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 59f1ce6df2d6..58158f11ed7b 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -100,7 +100,7 @@ obj-$(CONFIG_SCSI_EATA_PIO)	+= eata_pio.o
 obj-$(CONFIG_SCSI_7000FASST)    += wd7000.o
 obj-$(CONFIG_SCSI_EATA)         += eata.o
 obj-$(CONFIG_SCSI_DC395x)       += dc395x.o
-obj-$(CONFIG_SCSI_DC390T)       += tmscsim.o
+obj-$(CONFIG_SCSI_AM53C974)     += esp_scsi.o   am53c974.o
 obj-$(CONFIG_MEGARAID_LEGACY)   += megaraid.o
 obj-$(CONFIG_MEGARAID_NEWGEN)   += megaraid/
 obj-$(CONFIG_MEGARAID_SAS)      += megaraid/
@@ -143,6 +143,7 @@ obj-$(CONFIG_SCSI_VIRTIO)	+= virtio_scsi.o
 obj-$(CONFIG_VMWARE_PVSCSI)     += vmw_pvscsi.o
 obj-$(CONFIG_XEN_SCSI_FRONTEND) += xen-scsifront.o
 obj-$(CONFIG_HYPERV_STORAGE)    += hv_storvsc.o
+obj-$(CONFIG_SCSI_WD719X)       += wd719x.o
 
 obj-$(CONFIG_ARM)               += arm/
 
diff --git a/drivers/scsi/NCR5380.c b/drivers/scsi/NCR5380.c
index 45da3c823322..36244d63def2 100644
--- a/drivers/scsi/NCR5380.c
+++ b/drivers/scsi/NCR5380.c
@@ -11,8 +11,6 @@
  *      drew@colorado.edu
  *      +1 (303) 666-5836
  *
- * DISTRIBUTION RELEASE 6. 
- *
  * For more information, please consult 
  *
  * NCR 5380 Family
@@ -279,7 +277,7 @@ static void do_reset(struct Scsi_Host *host);
  *      Set up the internal fields in the SCSI command.
  */
 
-static __inline__ void initialize_SCp(Scsi_Cmnd * cmd)
+static inline void initialize_SCp(struct scsi_cmnd *cmd)
 {
         /* 
          * Initialize the Scsi Pointer field so that all of the commands in the 
@@ -574,12 +572,12 @@ static int __init __maybe_unused NCR5380_probe_irq(struct Scsi_Host *instance,
         int trying_irqs, i, mask;
         NCR5380_setup(instance);
 
-        for (trying_irqs = i = 0, mask = 1; i < 16; ++i, mask <<= 1)
+        for (trying_irqs = 0, i = 1, mask = 2; i < 16; ++i, mask <<= 1)
                 if ((mask & possible) && (request_irq(i, &probe_intr, 0, "NCR-probe", NULL) == 0))
                         trying_irqs |= mask;
 
         timeout = jiffies + (250 * HZ / 1000);
-        probe_irq = SCSI_IRQ_NONE;
+        probe_irq = NO_IRQ;
 
         /*
          * A interrupt is triggered whenever BSY = false, SEL = true
@@ -596,13 +594,13 @@ static int __init __maybe_unused NCR5380_probe_irq(struct Scsi_Host *instance,
         NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_SEL);
 
-        while (probe_irq == SCSI_IRQ_NONE && time_before(jiffies, timeout))
+        while (probe_irq == NO_IRQ && time_before(jiffies, timeout))
                 schedule_timeout_uninterruptible(1);
         
         NCR5380_write(SELECT_ENABLE_REG, 0);
         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
 
-        for (i = 0, mask = 1; i < 16; ++i, mask <<= 1)
+        for (i = 1, mask = 2; i < 16; ++i, mask <<= 1)
                 if (trying_irqs & mask)
                         free_irq(i, NULL);
 
@@ -610,50 +608,70 @@ static int __init __maybe_unused NCR5380_probe_irq(struct Scsi_Host *instance,
 }
 
 /**
- *      NCR58380_print_options  -       show options
- *      @instance: unused for now
+ *      NCR58380_info - report driver and host information
+ *      @instance: relevant scsi host instance
  *
- *      Called by probe code indicating the NCR5380 driver options that 
- *      were selected. At some point this will switch to runtime options
- *      read from the adapter in question
+ *      For use as the host template info() handler.
  *
  *      Locks: none
  */
 
-static void __init __maybe_unused
-NCR5380_print_options(struct Scsi_Host *instance)
+static const char *NCR5380_info(struct Scsi_Host *instance)
 {
-        printk(" generic options"
-#ifdef AUTOPROBE_IRQ
-               " AUTOPROBE_IRQ"
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+
+        return hostdata->info;
+}
+
+static void prepare_info(struct Scsi_Host *instance)
+{
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+
+        snprintf(hostdata->info, sizeof(hostdata->info),
+                 "%s, io_port 0x%lx, n_io_port %d, "
+                 "base 0x%lx, irq %d, "
+                 "can_queue %d, cmd_per_lun %d, "
+                 "sg_tablesize %d, this_id %d, "
+                 "flags { %s%s%s}, "
+#if defined(USLEEP_POLL) && defined(USLEEP_WAITLONG)
+                 "USLEEP_POLL %d, USLEEP_WAITLONG %d, "
 #endif
-#ifdef AUTOSENSE
-               " AUTOSENSE"
+                 "options { %s} ",
+                 instance->hostt->name, instance->io_port, instance->n_io_port,
+                 instance->base, instance->irq,
+                 instance->can_queue, instance->cmd_per_lun,
+                 instance->sg_tablesize, instance->this_id,
+                 hostdata->flags & FLAG_NCR53C400     ? "NCR53C400 "     : "",
+                 hostdata->flags & FLAG_DTC3181E      ? "DTC3181E "      : "",
+                 hostdata->flags & FLAG_NO_PSEUDO_DMA ? "NO_PSEUDO_DMA " : "",
+#if defined(USLEEP_POLL) && defined(USLEEP_WAITLONG)
+                 USLEEP_POLL, USLEEP_WAITLONG,
+#endif
+#ifdef AUTOPROBE_IRQ
+                 "AUTOPROBE_IRQ "
 #endif
 #ifdef DIFFERENTIAL
-               " DIFFERENTIAL"
+                 "DIFFERENTIAL "
 #endif
 #ifdef REAL_DMA
-               " REAL DMA"
+                 "REAL_DMA "
 #endif
 #ifdef REAL_DMA_POLL
-               " REAL DMA POLL"
+                 "REAL_DMA_POLL "
 #endif
 #ifdef PARITY
-               " PARITY"
+                 "PARITY "
 #endif
 #ifdef PSEUDO_DMA
-               " PSEUDO DMA"
+                 "PSEUDO_DMA "
 #endif
 #ifdef UNSAFE
-               " UNSAFE "
+                 "UNSAFE "
 #endif
-            );
-        printk(" USLEEP, USLEEP_POLL=%d USLEEP_SLEEP=%d", USLEEP_POLL, USLEEP_SLEEP);
-        printk(" generic release=%d", NCR5380_PUBLIC_RELEASE);
-        if (((struct NCR5380_hostdata *) instance->hostdata)->flags & FLAG_NCR53C400) {
-                printk(" ncr53c400 release=%d", NCR53C400_PUBLIC_RELEASE);
-        }
+#ifdef NCR53C400
+                 "NCR53C400 "
+#endif
+                 "");
 }
 
 /**
@@ -672,6 +690,7 @@ static void NCR5380_print_status(struct Scsi_Host *instance)
         NCR5380_dprint_phase(NDEBUG_ANY, instance);
 }
 
+#ifdef PSEUDO_DMA
 /******************************************/
 /*
  * /proc/scsi/[dtc pas16 t128 generic]/[0-ASC_NUM_BOARD_SUPPORTED]
@@ -689,19 +708,18 @@ static void NCR5380_print_status(struct Scsi_Host *instance)
 static int __maybe_unused NCR5380_write_info(struct Scsi_Host *instance,
         char *buffer, int length)
 {
-#ifdef DTC_PUBLIC_RELEASE
-        dtc_wmaxi = dtc_maxi = 0;
-#endif
-#ifdef PAS16_PUBLIC_RELEASE
-        pas_wmaxi = pas_maxi = 0;
-#endif
-        return (-ENOSYS);       /* Currently this is a no-op */
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+
+        hostdata->spin_max_r = 0;
+        hostdata->spin_max_w = 0;
+        return 0;
 }
+#endif
 
 #undef SPRINTF
 #define SPRINTF(args...) seq_printf(m, ## args)
 static
-void lprint_Scsi_Cmnd(Scsi_Cmnd * cmd, struct seq_file *m);
+void lprint_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m);
 static
 void lprint_command(unsigned char *cmd, struct seq_file *m);
 static
@@ -711,56 +729,31 @@ static int __maybe_unused NCR5380_show_info(struct seq_file *m,
         struct Scsi_Host *instance)
 {
         struct NCR5380_hostdata *hostdata;
-        Scsi_Cmnd *ptr;
+        struct scsi_cmnd *ptr;
 
         hostdata = (struct NCR5380_hostdata *) instance->hostdata;
 
-        SPRINTF("NCR5380 core release=%d.   ", NCR5380_PUBLIC_RELEASE);
-        if (((struct NCR5380_hostdata *) instance->hostdata)->flags & FLAG_NCR53C400)
-                SPRINTF("ncr53c400 release=%d.  ", NCR53C400_PUBLIC_RELEASE);
-#ifdef DTC_PUBLIC_RELEASE
-        SPRINTF("DTC 3180/3280 release %d", DTC_PUBLIC_RELEASE);
-#endif
-#ifdef T128_PUBLIC_RELEASE
-        SPRINTF("T128 release %d", T128_PUBLIC_RELEASE);
-#endif
-#ifdef GENERIC_NCR5380_PUBLIC_RELEASE
-        SPRINTF("Generic5380 release %d", GENERIC_NCR5380_PUBLIC_RELEASE);
-#endif
-#ifdef PAS16_PUBLIC_RELEASE
-        SPRINTF("PAS16 release=%d", PAS16_PUBLIC_RELEASE);
-#endif
-
-        SPRINTF("\nBase Addr: 0x%05lX    ", (long) instance->base);
-        SPRINTF("io_port: %04x      ", (int) instance->io_port);
-        if (instance->irq == SCSI_IRQ_NONE)
-                SPRINTF("IRQ: None.\n");
-        else
-                SPRINTF("IRQ: %d.\n", instance->irq);
-
-#ifdef DTC_PUBLIC_RELEASE
-        SPRINTF("Highwater I/O busy_spin_counts -- write: %d  read: %d\n", dtc_wmaxi, dtc_maxi);
-#endif
-#ifdef PAS16_PUBLIC_RELEASE
-        SPRINTF("Highwater I/O busy_spin_counts -- write: %d  read: %d\n", pas_wmaxi, pas_maxi);
+#ifdef PSEUDO_DMA
+        SPRINTF("Highwater I/O busy spin counts: write %d, read %d\n",
+                hostdata->spin_max_w, hostdata->spin_max_r);
 #endif
         spin_lock_irq(instance->host_lock);
         if (!hostdata->connected)
                 SPRINTF("scsi%d: no currently connected command\n", instance->host_no);
         else
-                lprint_Scsi_Cmnd((Scsi_Cmnd *) hostdata->connected, m);
+                lprint_Scsi_Cmnd((struct scsi_cmnd *) hostdata->connected, m);
         SPRINTF("scsi%d: issue_queue\n", instance->host_no);
-        for (ptr = (Scsi_Cmnd *) hostdata->issue_queue; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
+        for (ptr = (struct scsi_cmnd *) hostdata->issue_queue; ptr; ptr = (struct scsi_cmnd *) ptr->host_scribble)
                 lprint_Scsi_Cmnd(ptr, m);
 
         SPRINTF("scsi%d: disconnected_queue\n", instance->host_no);
-        for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
+        for (ptr = (struct scsi_cmnd *) hostdata->disconnected_queue; ptr; ptr = (struct scsi_cmnd *) ptr->host_scribble)
                 lprint_Scsi_Cmnd(ptr, m);
         spin_unlock_irq(instance->host_lock);
         return 0;
 }
 
-static void lprint_Scsi_Cmnd(Scsi_Cmnd * cmd, struct seq_file *m)
+static void lprint_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m)
 {
         SPRINTF("scsi%d : destination target %d, lun %llu\n", cmd->device->host->host_no, cmd->device->id, cmd->device->lun);
         SPRINTF("        command = ");
@@ -836,18 +829,6 @@ static int NCR5380_init(struct Scsi_Host *instance, int flags)
         
         INIT_DELAYED_WORK(&hostdata->coroutine, NCR5380_main);
         
-#ifdef NCR5380_STATS
-        for (i = 0; i < 8; ++i) {
-                hostdata->time_read[i] = 0;
-                hostdata->time_write[i] = 0;
-                hostdata->bytes_read[i] = 0;
-                hostdata->bytes_write[i] = 0;
-        }
-        hostdata->timebase = 0;
-        hostdata->pendingw = 0;
-        hostdata->pendingr = 0;
-#endif
-
         /* The CHECK code seems to break the 53C400. Will check it later maybe */
         if (flags & FLAG_NCR53C400)
                 hostdata->flags = FLAG_HAS_LAST_BYTE_SENT | flags;
@@ -857,11 +838,7 @@ static int NCR5380_init(struct Scsi_Host *instance, int flags)
         hostdata->host = instance;
         hostdata->time_expires = 0;
 
-#ifndef AUTOSENSE
-        if ((instance->cmd_per_lun > 1) || instance->can_queue > 1)
-                    printk(KERN_WARNING "scsi%d : WARNING : support for multiple outstanding commands enabled\n" "         without AUTOSENSE option, contingent allegiance conditions may\n"
-                           "         be incorrectly cleared.\n", instance->host_no);
-#endif                          /* def AUTOSENSE */
+        prepare_info(instance);
 
         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
         NCR5380_write(MODE_REG, MR_BASE);
@@ -935,11 +912,11 @@ static void NCR5380_exit(struct Scsi_Host *instance)
  *      Locks: host lock taken by caller
  */
 
-static int NCR5380_queue_command_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
+static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd, void (*done) (struct scsi_cmnd *))
 {
         struct Scsi_Host *instance = cmd->device->host;
         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
-        Scsi_Cmnd *tmp;
+        struct scsi_cmnd *tmp;
 
 #if (NDEBUG & NDEBUG_NO_WRITE)
         switch (cmd->cmnd[0]) {
@@ -952,25 +929,6 @@ static int NCR5380_queue_command_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)
         }
 #endif                          /* (NDEBUG & NDEBUG_NO_WRITE) */
 
-#ifdef NCR5380_STATS
-        switch (cmd->cmnd[0]) {
-                case WRITE:
-                case WRITE_6:
-                case WRITE_10:
-                        hostdata->time_write[cmd->device->id] -= (jiffies - hostdata->timebase);
-                        hostdata->bytes_write[cmd->device->id] += scsi_bufflen(cmd);
-                        hostdata->pendingw++;
-                        break;
-                case READ:
-                case READ_6:
-                case READ_10:
-                        hostdata->time_read[cmd->device->id] -= (jiffies - hostdata->timebase);
-                        hostdata->bytes_read[cmd->device->id] += scsi_bufflen(cmd);
-                        hostdata->pendingr++;
-                        break;
-        }
-#endif
-
         /* 
          * We use the host_scribble field as a pointer to the next command  
          * in a queue 
@@ -992,7 +950,7 @@ static int NCR5380_queue_command_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)
                 cmd->host_scribble = (unsigned char *) hostdata->issue_queue;
                 hostdata->issue_queue = cmd;
         } else {
-                for (tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp->host_scribble; tmp = (Scsi_Cmnd *) tmp->host_scribble);
+                for (tmp = (struct scsi_cmnd *) hostdata->issue_queue; tmp->host_scribble; tmp = (struct scsi_cmnd *) tmp->host_scribble);
                 LIST(cmd, tmp);
                 tmp->host_scribble = (unsigned char *) cmd;
         }
@@ -1023,7 +981,7 @@ static void NCR5380_main(struct work_struct *work)
         struct NCR5380_hostdata *hostdata =
                 container_of(work, struct NCR5380_hostdata, coroutine.work);
         struct Scsi_Host *instance = hostdata->host;
-        Scsi_Cmnd *tmp, *prev;
+        struct scsi_cmnd *tmp, *prev;
         int done;
         
         spin_lock_irq(instance->host_lock);
@@ -1036,7 +994,7 @@ static void NCR5380_main(struct work_struct *work)
                          * Search through the issue_queue for a command destined
                          * for a target that's not busy.
                          */
-                        for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble) 
+                        for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL; tmp; prev = tmp, tmp = (struct scsi_cmnd *) tmp->host_scribble)
                         {
                                 if (prev != tmp)
                                     dprintk(NDEBUG_LISTS, "MAIN tmp=%p   target=%d   busy=%d lun=%llu\n", tmp, tmp->device->id, hostdata->busy[tmp->device->id], tmp->device->lun);
@@ -1048,7 +1006,7 @@ static void NCR5380_main(struct work_struct *work)
                                                 prev->host_scribble = tmp->host_scribble;
                                         } else {
                                                 REMOVE(-1, hostdata->issue_queue, tmp, tmp->host_scribble);
-                                                hostdata->issue_queue = (Scsi_Cmnd *) tmp->host_scribble;
+                                                hostdata->issue_queue = (struct scsi_cmnd *) tmp->host_scribble;
                                         }
                                         tmp->host_scribble = NULL;
 
@@ -1073,14 +1031,14 @@ static void NCR5380_main(struct work_struct *work)
                                         hostdata->selecting = NULL;
                                         /* RvC: have to preset this to indicate a new command is being performed */
 
-                                        if (!NCR5380_select(instance, tmp,
-                                                            /* 
-                                                             * REQUEST SENSE commands are issued without tagged
-                                                             * queueing, even on SCSI-II devices because the 
-                                                             * contingent allegiance condition exists for the 
-                                                             * entire unit.
-                                                             */
-                                                            (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT)) {
+                                        /*
+                                         * REQUEST SENSE commands are issued without tagged
+                                         * queueing, even on SCSI-II devices because the
+                                         * contingent allegiance condition exists for the
+                                         * entire unit.
+                                         */
+
+                                        if (!NCR5380_select(instance, tmp)) {
                                                 break;
                                         } else {
                                                 LIST(tmp, hostdata->issue_queue);
@@ -1095,9 +1053,9 @@ static void NCR5380_main(struct work_struct *work)
                         /* exited locked */
                 }       /* if (!hostdata->connected) */
                 if (hostdata->selecting) {
-                        tmp = (Scsi_Cmnd *) hostdata->selecting;
+                        tmp = (struct scsi_cmnd *) hostdata->selecting;
                         /* Selection will drop and retake the lock */
-                        if (!NCR5380_select(instance, tmp, (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT)) {
+                        if (!NCR5380_select(instance, tmp)) {
                                 /* Ok ?? */
                         } else {
                                 /* RvC: device failed, so we wait a long time
@@ -1216,47 +1174,16 @@ static irqreturn_t NCR5380_intr(int dummy, void *dev_id)
 
 #endif 
 
-/**
- *      collect_stats           -       collect stats on a scsi command
- *      @hostdata: adapter 
- *      @cmd: command being issued
- *
- *      Update the statistical data by parsing the command in question
- */
- 
-static void collect_stats(struct NCR5380_hostdata *hostdata, Scsi_Cmnd * cmd) 
-{
-#ifdef NCR5380_STATS
-        switch (cmd->cmnd[0]) {
-        case WRITE:
-        case WRITE_6:
-        case WRITE_10:
-                hostdata->time_write[scmd_id(cmd)] += (jiffies - hostdata->timebase);
-                hostdata->pendingw--;
-                break;
-        case READ:
-        case READ_6:
-        case READ_10:
-                hostdata->time_read[scmd_id(cmd)] += (jiffies - hostdata->timebase);
-                hostdata->pendingr--;
-                break;
-        }
-#endif
-}
-
-
 /* 
- * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, 
- *      int tag);
+ * Function : int NCR5380_select(struct Scsi_Host *instance,
+ *                               struct scsi_cmnd *cmd)
  *
  * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
  *      including ARBITRATION, SELECTION, and initial message out for 
  *      IDENTIFY and queue messages. 
  *
  * Inputs : instance - instantiation of the 5380 driver on which this 
- *      target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for 
- *      new tag, TAG_NONE for untagged queueing, otherwise set to the tag for 
- *      the command that is presently connected.
+ *      target lives, cmd - SCSI command to execute.
  * 
  * Returns : -1 if selection could not execute for some reason,
  *      0 if selection succeeded or failed because the target 
@@ -1278,7 +1205,7 @@ static void collect_stats(struct NCR5380_hostdata *hostdata, Scsi_Cmnd * cmd)
  *      Locks: caller holds hostdata lock in IRQ mode
  */
  
-static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd * cmd, int tag) 
+static int NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd)
 {
         NCR5380_local_declare();
         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
@@ -1476,7 +1403,6 @@ part2:
                         return -1;
                 }
                 cmd->result = DID_BAD_TARGET << 16;
-                collect_stats(hostdata, cmd);
                 cmd->scsi_done(cmd);
                 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
                 dprintk(NDEBUG_SELECTION, "scsi%d : target did not respond within 250ms\n", instance->host_no);
@@ -1513,7 +1439,7 @@ part2:
         }
 
         dprintk(NDEBUG_SELECTION, "scsi%d : target %d selected, going into MESSAGE OUT phase.\n", instance->host_no, cmd->device->id);
-        tmp[0] = IDENTIFY(((instance->irq == SCSI_IRQ_NONE) ? 0 : 1), cmd->device->lun);
+        tmp[0] = IDENTIFY(((instance->irq == NO_IRQ) ? 0 : 1), cmd->device->lun);
 
         len = 1;
         cmd->tag = 0;
@@ -2086,7 +2012,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
 #endif
         unsigned char *data;
         unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
-        Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
+        struct scsi_cmnd *cmd = (struct scsi_cmnd *) hostdata->connected;
         /* RvC: we need to set the end of the polling time */
         unsigned long poll_time = jiffies + USLEEP_POLL;
 
@@ -2228,7 +2154,6 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
                                         cmd->next_link->tag = cmd->tag;
                                         cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
                                         dprintk(NDEBUG_LINKED, "scsi%d : target %d lun %llu linked request done, calling scsi_done().\n", instance->host_no, cmd->device->id, cmd->device->lun);
-                                        collect_stats(hostdata, cmd);
                                         cmd->scsi_done(cmd);
                                         cmd = hostdata->connected;
                                         break;
@@ -2263,7 +2188,6 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
                                         else if (status_byte(cmd->SCp.Status) != GOOD)
                                                 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
 
-#ifdef AUTOSENSE
                                         if ((cmd->cmnd[0] == REQUEST_SENSE) &&
                                                 hostdata->ses.cmd_len) {
                                                 scsi_eh_restore_cmnd(cmd, &hostdata->ses);
@@ -2278,12 +2202,9 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
                                                 LIST(cmd, hostdata->issue_queue);
                                                 cmd->host_scribble = (unsigned char *)
                                                     hostdata->issue_queue;
-                                                hostdata->issue_queue = (Scsi_Cmnd *) cmd;
+                                                hostdata->issue_queue = (struct scsi_cmnd *) cmd;
                                                 dprintk(NDEBUG_QUEUES, "scsi%d : REQUEST SENSE added to head of issue queue\n", instance->host_no);
-                                        } else
-#endif                          /* def AUTOSENSE */
-                                        {
-                                                collect_stats(hostdata, cmd);
+                                        } else {
                                                 cmd->scsi_done(cmd);
                                         }
 
@@ -2430,7 +2351,6 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
                                         hostdata->busy[cmd->device->id] &= ~(1 << (cmd->device->lun & 0xFF));
                                         hostdata->connected = NULL;
                                         cmd->result = DID_ERROR << 16;
-                                        collect_stats(hostdata, cmd);
                                         cmd->scsi_done(cmd);
                                         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
                                         return;
@@ -2479,7 +2399,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
  * Function : void NCR5380_reselect (struct Scsi_Host *instance)
  *
  * Purpose : does reselection, initializing the instance->connected 
- *      field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q 
+ *      field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q
  *      nexus has been reestablished,
  *      
  * Inputs : instance - this instance of the NCR5380.
@@ -2496,7 +2416,7 @@ static void NCR5380_reselect(struct Scsi_Host *instance) {
         int len;
         unsigned char msg[3];
         unsigned char *data;
-        Scsi_Cmnd *tmp = NULL, *prev;
+        struct scsi_cmnd *tmp = NULL, *prev;
         int abort = 0;
         NCR5380_setup(instance);
 
@@ -2562,7 +2482,7 @@ static void NCR5380_reselect(struct Scsi_Host *instance) {
                  */
 
 
-                for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble)
+                for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL; tmp; prev = tmp, tmp = (struct scsi_cmnd *) tmp->host_scribble)
                         if ((target_mask == (1 << tmp->device->id)) && (lun == (u8)tmp->device->lun)
                             ) {
                                 if (prev) {
@@ -2570,7 +2490,7 @@ static void NCR5380_reselect(struct Scsi_Host *instance) {
                                         prev->host_scribble = tmp->host_scribble;
                                 } else {
                                         REMOVE(-1, hostdata->disconnected_queue, tmp, tmp->host_scribble);
-                                        hostdata->disconnected_queue = (Scsi_Cmnd *) tmp->host_scribble;
+                                        hostdata->disconnected_queue = (struct scsi_cmnd *) tmp->host_scribble;
                                 }
                                 tmp->host_scribble = NULL;
                                 break;
@@ -2601,7 +2521,7 @@ static void NCR5380_reselect(struct Scsi_Host *instance) {
  *
  * Inputs : instance - this instance of the NCR5380.
  *
- * Returns : pointer to the Scsi_Cmnd structure for which the I_T_L
+ * Returns : pointer to the scsi_cmnd structure for which the I_T_L
  *      nexus has been reestablished, on failure NULL is returned.
  */
 
@@ -2643,32 +2563,32 @@ static void NCR5380_dma_complete(NCR5380_instance * instance) {
 #endif                          /* def REAL_DMA */
 
 /*
- * Function : int NCR5380_abort (Scsi_Cmnd *cmd)
+ * Function : int NCR5380_abort (struct scsi_cmnd *cmd)
  *
  * Purpose : abort a command
  *
- * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the 
- *      host byte of the result field to, if zero DID_ABORTED is 
+ * Inputs : cmd - the scsi_cmnd to abort, code - code to set the
+ *      host byte of the result field to, if zero DID_ABORTED is
  *      used.
  *
- * Returns : 0 - success, -1 on failure.
+ * Returns : SUCCESS - success, FAILED on failure.
  *
- *      XXX - there is no way to abort the command that is currently 
- *      connected, you have to wait for it to complete.  If this is 
+ *      XXX - there is no way to abort the command that is currently
+ *      connected, you have to wait for it to complete.  If this is
  *      a problem, we could implement longjmp() / setjmp(), setjmp()
  *      called where the loop started in NCR5380_main().
  *
  * Locks: host lock taken by caller
  */
 
-static int NCR5380_abort(Scsi_Cmnd * cmd) {
+static int NCR5380_abort(struct scsi_cmnd *cmd)
+{
         NCR5380_local_declare();
         struct Scsi_Host *instance = cmd->device->host;
         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
-        Scsi_Cmnd *tmp, **prev;
-        
-        printk(KERN_WARNING "scsi%d : aborting command\n", instance->host_no);
-        scsi_print_command(cmd);
+        struct scsi_cmnd *tmp, **prev;
+
+        scmd_printk(KERN_WARNING, cmd, "aborting command\n");
 
         NCR5380_print_status(instance);
 
@@ -2704,7 +2624,7 @@ static int NCR5380_abort(Scsi_Cmnd * cmd) {
  * aborted flag and get back into our main loop.
  */
 
-                return 0;
+                return SUCCESS;
         }
 #endif
 
@@ -2714,10 +2634,10 @@ static int NCR5380_abort(Scsi_Cmnd * cmd) {
  */
  
         dprintk(NDEBUG_ABORT, "scsi%d : abort going into loop.\n", instance->host_no);
-        for (prev = (Scsi_Cmnd **) & (hostdata->issue_queue), tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp; prev = (Scsi_Cmnd **) & (tmp->host_scribble), tmp = (Scsi_Cmnd *) tmp->host_scribble)
+        for (prev = (struct scsi_cmnd **) &(hostdata->issue_queue), tmp = (struct scsi_cmnd *) hostdata->issue_queue; tmp; prev = (struct scsi_cmnd **) &(tmp->host_scribble), tmp = (struct scsi_cmnd *) tmp->host_scribble)
                 if (cmd == tmp) {
                         REMOVE(5, *prev, tmp, tmp->host_scribble);
-                        (*prev) = (Scsi_Cmnd *) tmp->host_scribble;
+                        (*prev) = (struct scsi_cmnd *) tmp->host_scribble;
                         tmp->host_scribble = NULL;
                         tmp->result = DID_ABORT << 16;
                         dprintk(NDEBUG_ABORT, "scsi%d : abort removed command from issue queue.\n", instance->host_no);
@@ -2770,20 +2690,20 @@ static int NCR5380_abort(Scsi_Cmnd * cmd) {
  * it from the disconnected queue.
  */
 
-        for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp; tmp = (Scsi_Cmnd *) tmp->host_scribble)
+        for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp; tmp = (struct scsi_cmnd *) tmp->host_scribble)
                 if (cmd == tmp) {
                         dprintk(NDEBUG_ABORT, "scsi%d : aborting disconnected command.\n", instance->host_no);
 
-                        if (NCR5380_select(instance, cmd, (int) cmd->tag))
+                        if (NCR5380_select(instance, cmd))
                                 return FAILED;
                         dprintk(NDEBUG_ABORT, "scsi%d : nexus reestablished.\n", instance->host_no);
 
                         do_abort(instance);
 
-                        for (prev = (Scsi_Cmnd **) & (hostdata->disconnected_queue), tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp; prev = (Scsi_Cmnd **) & (tmp->host_scribble), tmp = (Scsi_Cmnd *) tmp->host_scribble)
+                        for (prev = (struct scsi_cmnd **) &(hostdata->disconnected_queue), tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp; prev = (struct scsi_cmnd **) &(tmp->host_scribble), tmp = (struct scsi_cmnd *) tmp->host_scribble)
                                 if (cmd == tmp) {
                                         REMOVE(5, *prev, tmp, tmp->host_scribble);
-                                        *prev = (Scsi_Cmnd *) tmp->host_scribble;
+                                        *prev = (struct scsi_cmnd *) tmp->host_scribble;
                                         tmp->host_scribble = NULL;
                                         tmp->result = DID_ABORT << 16;
                                         tmp->scsi_done(tmp);
@@ -2806,7 +2726,7 @@ static int NCR5380_abort(Scsi_Cmnd * cmd) {
 
 
 /* 
- * Function : int NCR5380_bus_reset (Scsi_Cmnd *cmd)
+ * Function : int NCR5380_bus_reset (struct scsi_cmnd *cmd)
  * 
  * Purpose : reset the SCSI bus.
  *
@@ -2815,7 +2735,7 @@ static int NCR5380_abort(Scsi_Cmnd * cmd) {
  * Locks: host lock taken by caller
  */
 
-static int NCR5380_bus_reset(Scsi_Cmnd * cmd)
+static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
 {
         struct Scsi_Host *instance = cmd->device->host;
 
diff --git a/drivers/scsi/NCR5380.h b/drivers/scsi/NCR5380.h
index c79ddfa6f53c..162112dd1bf8 100644
--- a/drivers/scsi/NCR5380.h
+++ b/drivers/scsi/NCR5380.h
@@ -7,8 +7,6 @@
  *      drew@colorado.edu
  *      +1 (303) 666-5836
  *
- * DISTRIBUTION RELEASE 7
- *
  * For more information, please consult 
  *
  * NCR 5380 Family
@@ -25,13 +23,7 @@
 #define NCR5380_H
 
 #include <linux/interrupt.h>
-
-#ifdef AUTOSENSE
 #include <scsi/scsi_eh.h>
-#endif
-
-#define NCR5380_PUBLIC_RELEASE 7
-#define NCR53C400_PUBLIC_RELEASE 2
 
 #define NDEBUG_ARBITRATION      0x1
 #define NDEBUG_AUTOSENSE        0x2
@@ -224,33 +216,44 @@
 #define DISCONNECT_LONG         2
 
 /* 
- * These are "special" values for the tag parameter passed to NCR5380_select.
+ * "Special" value for the (unsigned char) command tag, to indicate
+ * I_T_L nexus instead of I_T_L_Q.
  */
 
-#define TAG_NEXT        -1      /* Use next free tag */
-#define TAG_NONE        -2      /* 
-                                 * Establish I_T_L nexus instead of I_T_L_Q
-                                 * even on SCSI-II devices.
-                                 */
+#define TAG_NONE        0xff
 
 /*
  * These are "special" values for the irq and dma_channel fields of the 
  * Scsi_Host structure
  */
 
-#define SCSI_IRQ_NONE   255
 #define DMA_NONE        255
 #define IRQ_AUTO        254
 #define DMA_AUTO        254
 #define PORT_AUTO       0xffff  /* autoprobe io port for 53c400a */
 
+#ifndef NO_IRQ
+#define NO_IRQ          0
+#endif
+
 #define FLAG_HAS_LAST_BYTE_SENT         1       /* NCR53c81 or better */
 #define FLAG_CHECK_LAST_BYTE_SENT       2       /* Only test once */
 #define FLAG_NCR53C400                  4       /* NCR53c400 */
 #define FLAG_NO_PSEUDO_DMA              8       /* Inhibit DMA */
 #define FLAG_DTC3181E                   16      /* DTC3181E */
+#define FLAG_LATE_DMA_SETUP             32      /* Setup NCR before DMA H/W */
+#define FLAG_TAGGED_QUEUING             64      /* as X3T9.2 spelled it */
 
 #ifndef ASM
+
+#ifdef SUPPORT_TAGS
+struct tag_alloc {
+        DECLARE_BITMAP(allocated, MAX_TAGS);
+        int nr_allocated;
+        int queue_size;
+};
+#endif
+
 struct NCR5380_hostdata {
         NCR5380_implementation_fields;          /* implementation specific */
         struct Scsi_Host *host;                 /* Host backpointer */
@@ -263,9 +266,9 @@ struct NCR5380_hostdata {
         volatile int dma_len;                   /* requested length of DMA */
 #endif
         volatile unsigned char last_message;    /* last message OUT */
-        volatile Scsi_Cmnd *connected;          /* currently connected command */
-        volatile Scsi_Cmnd *issue_queue;        /* waiting to be issued */
-        volatile Scsi_Cmnd *disconnected_queue; /* waiting for reconnect */
+        volatile struct scsi_cmnd *connected;   /* currently connected command */
+        volatile struct scsi_cmnd *issue_queue; /* waiting to be issued */
+        volatile struct scsi_cmnd *disconnected_queue;  /* waiting for reconnect */
         volatile int restart_select;            /* we have disconnected,
                                                    used to restart 
                                                    NCR5380_select() */
@@ -273,19 +276,21 @@ struct NCR5380_hostdata {
         int flags;
         unsigned long time_expires;             /* in jiffies, set prior to sleeping */
         int select_time;                        /* timer in select for target response */
-        volatile Scsi_Cmnd *selecting;
+        volatile struct scsi_cmnd *selecting;
         struct delayed_work coroutine;          /* our co-routine */
-#ifdef NCR5380_STATS
-        unsigned timebase;                      /* Base for time calcs */
-        long time_read[8];                      /* time to do reads */
-        long time_write[8];                     /* time to do writes */
-        unsigned long bytes_read[8];            /* bytes read */
-        unsigned long bytes_write[8];           /* bytes written */
-        unsigned pendingr;
-        unsigned pendingw;
-#endif
-#ifdef AUTOSENSE
         struct scsi_eh_save ses;
+        char info[256];
+        int read_overruns;                /* number of bytes to cut from a
+                                           * transfer to handle chip overruns */
+        int retain_dma_intr;
+        struct work_struct main_task;
+        volatile int main_running;
+#ifdef SUPPORT_TAGS
+        struct tag_alloc TagAlloc[8][8];        /* 8 targets and 8 LUNs */
+#endif
+#ifdef PSEUDO_DMA
+        unsigned spin_max_r;
+        unsigned spin_max_w;
 #endif
 };
 
@@ -296,7 +301,8 @@ struct NCR5380_hostdata {
 #endif
 
 #define dprintk(flg, fmt, ...) \
-        do { if ((NDEBUG) & (flg)) pr_debug(fmt, ## __VA_ARGS__); } while (0)
+        do { if ((NDEBUG) & (flg)) \
+                printk(KERN_DEBUG fmt, ## __VA_ARGS__); } while (0)
 
 #if NDEBUG
 #define NCR5380_dprint(flg, arg) \
@@ -320,17 +326,9 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance);
 static irqreturn_t NCR5380_intr(int irq, void *dev_id);
 #endif
 static void NCR5380_main(struct work_struct *work);
-static void __maybe_unused NCR5380_print_options(struct Scsi_Host *instance);
-static int NCR5380_abort(Scsi_Cmnd * cmd);
-static int NCR5380_bus_reset(Scsi_Cmnd * cmd);
-static int NCR5380_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
-static int __maybe_unused NCR5380_show_info(struct seq_file *,
-        struct Scsi_Host *);
-static int __maybe_unused NCR5380_write_info(struct Scsi_Host *instance,
-        char *buffer, int length);
-
+static const char *NCR5380_info(struct Scsi_Host *instance);
 static void NCR5380_reselect(struct Scsi_Host *instance);
-static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd * cmd, int tag);
+static int NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd);
 #if defined(PSEUDO_DMA) || defined(REAL_DMA) || defined(REAL_DMA_POLL)
 static int NCR5380_transfer_dma(struct Scsi_Host *instance, unsigned char *phase, int *count, unsigned char **data);
 #endif
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 681434e2dfe9..b32e77db0c48 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -2181,7 +2181,7 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
                           (fsa_dev_ptr[cid].sense_data.sense_key ==
                            NOT_READY)) {
                                 switch (scsicmd->cmnd[0]) {
-                                case SERVICE_ACTION_IN:
+                                case SERVICE_ACTION_IN_16:
                                         if (!(dev->raw_io_interface) ||
                                             !(dev->raw_io_64) ||
                                             ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16))
@@ -2309,7 +2309,7 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
                 scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data));
                 return aac_get_container_name(scsicmd);
         }
-        case SERVICE_ACTION_IN:
+        case SERVICE_ACTION_IN_16:
                 if (!(dev->raw_io_interface) ||
                     !(dev->raw_io_64) ||
                     ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16))
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index a759cb2d4b15..fdcdf9f781bc 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -462,9 +462,9 @@ static int aac_slave_configure(struct scsi_device *sdev)
                         depth = 256;
                 else if (depth < 2)
                         depth = 2;
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
+                scsi_change_queue_depth(sdev, depth);
         } else
-                scsi_adjust_queue_depth(sdev, 0, 1);
+                scsi_change_queue_depth(sdev, 1);
 
         return 0;
 }
@@ -478,12 +478,8 @@ static int aac_slave_configure(struct scsi_device *sdev)
  *      total capacity and the queue depth supported by the target device.
  */
 
-static int aac_change_queue_depth(struct scsi_device *sdev, int depth,
-                                  int reason)
+static int aac_change_queue_depth(struct scsi_device *sdev, int depth)
 {
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (sdev->tagged_supported && (sdev->type == TYPE_DISK) &&
             (sdev_channel(sdev) == CONTAINER_CHANNEL)) {
                 struct scsi_device * dev;
@@ -504,10 +500,10 @@ static int aac_change_queue_depth(struct scsi_device *sdev, int depth,
                         depth = 256;
                 else if (depth < 2)
                         depth = 2;
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
-        } else
-                scsi_adjust_queue_depth(sdev, 0, 1);
-        return sdev->queue_depth;
+                return scsi_change_queue_depth(sdev, depth);
+        }
+
+        return scsi_change_queue_depth(sdev, 1);
 }
 
 static ssize_t aac_show_raid_level(struct device *dev, struct device_attribute *attr, char *buf)
@@ -555,7 +551,7 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
                 AAC_DRIVERNAME,
                 host->host_no, sdev_channel(dev), sdev_id(dev), dev->lun);
         switch (cmd->cmnd[0]) {
-        case SERVICE_ACTION_IN:
+        case SERVICE_ACTION_IN_16:
                 if (!(aac->raw_io_interface) ||
                     !(aac->raw_io_64) ||
                     ((cmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16))
diff --git a/drivers/scsi/advansys.c b/drivers/scsi/advansys.c
index 43761c1c46f0..6719a3390ebd 100644
--- a/drivers/scsi/advansys.c
+++ b/drivers/scsi/advansys.c
@@ -7706,7 +7706,7 @@ advansys_narrow_slave_configure(struct scsi_device *sdev, ASC_DVC_VAR *asc_dvc)
                                 asc_dvc->cfg->can_tagged_qng |= tid_bit;
                                 asc_dvc->use_tagged_qng |= tid_bit;
                         }
-                        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
+                        scsi_change_queue_depth(sdev, 
                                                 asc_dvc->max_dvc_qng[sdev->id]);
                 }
         } else {
@@ -7714,7 +7714,6 @@ advansys_narrow_slave_configure(struct scsi_device *sdev, ASC_DVC_VAR *asc_dvc)
                         asc_dvc->cfg->can_tagged_qng &= ~tid_bit;
                         asc_dvc->use_tagged_qng &= ~tid_bit;
                 }
-                scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
         }
 
         if ((sdev->lun == 0) &&
@@ -7848,12 +7847,8 @@ advansys_wide_slave_configure(struct scsi_device *sdev, ADV_DVC_VAR *adv_dvc)
                 }
         }
 
-        if ((adv_dvc->tagqng_able & tidmask) && sdev->tagged_supported) {
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
-                                        adv_dvc->max_dvc_qng);
-        } else {
-                scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
-        }
+        if ((adv_dvc->tagqng_able & tidmask) && sdev->tagged_supported)
+                scsi_change_queue_depth(sdev, adv_dvc->max_dvc_qng);
 }
 
 /*
diff --git a/drivers/scsi/aha152x.c b/drivers/scsi/aha152x.c
index e77b72f78006..2b960b326daf 100644
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
@@ -230,7 +230,7 @@
  *
  *
  **************************************************************************
- 
+
  see Documentation/scsi/aha152x.txt for configuration details
 
  **************************************************************************/
@@ -279,45 +279,11 @@ static LIST_HEAD(aha152x_host_list);
 #error define AUTOCONF or SETUP0
 #endif
 
-#if defined(AHA152X_DEBUG)
-#define DEBUG_DEFAULT debug_eh
-
-#define DPRINTK(when,msgs...) \
-        do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
-
-#define DO_LOCK(flags)  \
-        do { \
-                if(spin_is_locked(&QLOCK)) { \
-                        DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
-                } \
-                DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
-                spin_lock_irqsave(&QLOCK,flags); \
-                DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
-                QLOCKER=__func__; \
-                QLOCKERL=__LINE__; \
-        } while(0)
-
-#define DO_UNLOCK(flags)        \
-        do { \
-                DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
-                spin_unlock_irqrestore(&QLOCK,flags); \
-                DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
-                QLOCKER="(not locked)"; \
-                QLOCKERL=0; \
-        } while(0)
-
-#else
-#define DPRINTK(when,msgs...)
 #define DO_LOCK(flags)          spin_lock_irqsave(&QLOCK,flags)
 #define DO_UNLOCK(flags)        spin_unlock_irqrestore(&QLOCK,flags)
-#endif
 
 #define LEAD            "(scsi%d:%d:%d) "
-#define WARN_LEAD       KERN_WARNING    LEAD
 #define INFO_LEAD       KERN_INFO       LEAD
-#define NOTE_LEAD       KERN_NOTICE     LEAD
-#define ERR_LEAD        KERN_ERR        LEAD
-#define DEBUG_LEAD      KERN_DEBUG      LEAD
 #define CMDINFO(cmd) \
                         (cmd) ? ((cmd)->device->host->host_no) : -1, \
                         (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
@@ -345,10 +311,10 @@ CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
 
 enum {
         not_issued      = 0x0001,       /* command not yet issued */
-        selecting       = 0x0002,       /* target is beeing selected */
+        selecting       = 0x0002,       /* target is being selected */
         identified      = 0x0004,       /* IDENTIFY was sent */
         disconnected    = 0x0008,       /* target disconnected */
-        completed       = 0x0010,       /* target sent COMMAND COMPLETE */ 
+        completed       = 0x0010,       /* target sent COMMAND COMPLETE */
         aborted         = 0x0020,       /* ABORT was sent */
         resetted        = 0x0040,       /* BUS DEVICE RESET was sent */
         spiordy         = 0x0080,       /* waiting for SPIORDY to raise */
@@ -396,7 +362,6 @@ static int exttrans[] = {0, 0};
 module_param_array(exttrans, int, NULL, 0);
 MODULE_PARM_DESC(exttrans,"use extended translation");
 
-#if !defined(AHA152X_DEBUG)
 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
 module_param_array(aha152x, int, NULL, 0);
 MODULE_PARM_DESC(aha152x, "parameters for first controller");
@@ -404,19 +369,6 @@ MODULE_PARM_DESC(aha152x, "parameters for first controller");
 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
 module_param_array(aha152x1, int, NULL, 0);
 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
-#else
-static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
-module_param_array(debug, int, NULL, 0);
-MODULE_PARM_DESC(debug, "flags for driver debugging");
-
-static int aha152x[]   = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
-module_param_array(aha152x, int, NULL, 0);
-MODULE_PARM_DESC(aha152x, "parameters for first controller");
-
-static int aha152x1[]  = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
-module_param_array(aha152x1, int, NULL, 0);
-MODULE_PARM_DESC(aha152x1, "parameters for second controller");
-#endif /* !defined(AHA152X_DEBUG) */
 #endif /* MODULE */
 
 #ifdef __ISAPNP__
@@ -446,7 +398,7 @@ static struct scsi_host_template aha152x_driver_template;
 /*
  * internal states of the host
  *
- */ 
+ */
 enum aha152x_state {
         idle=0,
         unknown,
@@ -485,24 +437,16 @@ struct aha152x_hostdata {
         spinlock_t lock;
                 /* host lock */
 
-#if defined(AHA152X_DEBUG)
-        const char *locker;
-                /* which function has the lock */
-        int lockerl;    /* where did it get it */
-
-        int debug;      /* current debugging setting */
-#endif
-
 #if defined(AHA152X_STAT)
-        int           total_commands;
+        int           total_commands;
         int           disconnections;
         int           busfree_without_any_action;
         int           busfree_without_old_command;
         int           busfree_without_new_command;
         int           busfree_without_done_command;
         int           busfree_with_check_condition;
-        int           count[maxstate];
-        int           count_trans[maxstate];
+        int           count[maxstate];
+        int           count_trans[maxstate];
         unsigned long time[maxstate];
 #endif
 
@@ -514,7 +458,7 @@ struct aha152x_hostdata {
         int delay;              /* reset out delay */
         int ext_trans;          /* extended translation enabled */
 
-        int swint;              /* software-interrupt was fired during detect() */
+        int swint;              /* software-interrupt was fired during detect() */
         int service;            /* bh needs to be run */
         int in_intr;            /* bh is running */
 
@@ -543,7 +487,7 @@ struct aha152x_hostdata {
         unsigned char msgi[256];
                 /* received message bytes */
 
-        int msgo_i, msgo_len;   
+        int msgo_i, msgo_len;
                 /* number of sent bytes and length of current messages */
         unsigned char msgo[256];
                 /* pending messages */
@@ -689,7 +633,6 @@ static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
 static void done(struct Scsi_Host *shpnt, int error);
 
 /* diagnostics */
-static void disp_ports(struct Scsi_Host *shpnt);
 static void show_command(Scsi_Cmnd * ptr);
 static void show_queues(struct Scsi_Host *shpnt);
 static void disp_enintr(struct Scsi_Host *shpnt);
@@ -812,10 +755,6 @@ struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
         DELAY       = setup->delay;
         EXT_TRANS   = setup->ext_trans;
 
-#if defined(AHA152X_DEBUG)
-        HOSTDATA(shpnt)->debug = setup->debug;
-#endif
-
         SETPORT(SCSIID, setup->scsiid << 4);
         shpnt->this_id = setup->scsiid;
 
@@ -941,31 +880,24 @@ void aha152x_release(struct Scsi_Host *shpnt)
  * setup controller to generate interrupts depending
  * on current state (lock has to be acquired)
  *
- */ 
+ */
 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
 {
         if(CURRENT_SC) {
                 CURRENT_SC->SCp.phase |= 1 << 16;
-        
+
                 if(CURRENT_SC->SCp.phase & selecting) {
-                        DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
                         SETPORT(SSTAT1, SELTO);
                         SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
                         SETPORT(SIMODE1, ENSELTIMO);
                 } else {
-                        DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
                         SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
-                        SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 
+                        SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
                 }
         } else if(STATE==seldi) {
-                DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
                 SETPORT(SIMODE0, 0);
-                SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 
+                SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
         } else {
-                DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
-                        CMDINFO(CURRENT_SC),
-                        DISCONNECTED_SC ? "(reselection)" : "",
-                        ISSUE_SC ? "(busfree)" : "");
                 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
                 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
         }
@@ -977,7 +909,7 @@ static int setup_expected_interrupts(struct Scsi_Host *shpnt)
 }
 
 
-/* 
+/*
  *  Queue a command and setup interrupts for a free bus.
  */
 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
@@ -986,15 +918,6 @@ static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
         struct Scsi_Host *shpnt = SCpnt->device->host;
         unsigned long flags;
 
-#if defined(AHA152X_DEBUG)
-        if (HOSTDATA(shpnt)->debug & debug_queue) {
-                printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
-                       CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len,
-                       scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
-                __scsi_print_command(SCpnt->cmnd);
-        }
-#endif
-
         SCpnt->scsi_done        = done;
         SCpnt->SCp.phase        = not_issued | phase;
         SCpnt->SCp.Status       = 0x1; /* Ilegal status by SCSI standard */
@@ -1004,13 +927,13 @@ static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
 
         if(SCpnt->SCp.phase & (resetting|check_condition)) {
                 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
-                        printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
+                        scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
                         return FAILED;
                 }
         } else {
                 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
                 if(!SCpnt->host_scribble) {
-                        printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
+                        scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
                         return FAILED;
                 }
         }
@@ -1066,15 +989,6 @@ static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
  */
 static int aha152x_queue_lck(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
 {
-#if 0
-        if(*SCpnt->cmnd == REQUEST_SENSE) {
-                SCpnt->result = 0;
-                done(SCpnt);
-
-                return 0;
-        }
-#endif
-
         return aha152x_internal_queue(SCpnt, NULL, 0, done);
 }
 
@@ -1082,15 +996,10 @@ static DEF_SCSI_QCMD(aha152x_queue)
 
 
 /*
- *  
  *
  */
 static void reset_done(Scsi_Cmnd *SCpnt)
 {
-#if 0
-        struct Scsi_Host *shpnt = SCpnt->host;
-        DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
-#endif
         if(SCSEM(SCpnt)) {
                 complete(SCSEM(SCpnt));
         } else {
@@ -1108,20 +1017,11 @@ static int aha152x_abort(Scsi_Cmnd *SCpnt)
         Scsi_Cmnd *ptr;
         unsigned long flags;
 
-#if defined(AHA152X_DEBUG)
-        if(HOSTDATA(shpnt)->debug & debug_eh) {
-                printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
-                show_queues(shpnt);
-        }
-#endif
-
         DO_LOCK(flags);
 
         ptr=remove_SC(&ISSUE_SC, SCpnt);
 
         if(ptr) {
-                DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
-
                 HOSTDATA(shpnt)->commands--;
                 if (!HOSTDATA(shpnt)->commands)
                         SETPORT(PORTA, 0);
@@ -1131,7 +1031,7 @@ static int aha152x_abort(Scsi_Cmnd *SCpnt)
                 SCpnt->host_scribble=NULL;
 
                 return SUCCESS;
-        } 
+        }
 
         DO_UNLOCK(flags);
 
@@ -1142,7 +1042,8 @@ static int aha152x_abort(Scsi_Cmnd *SCpnt)
          *
          */
 
-        printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
+        scmd_printk(KERN_ERR, SCpnt,
+                    "cannot abort running or disconnected command\n");
 
         return FAILED;
 }
@@ -1160,15 +1061,8 @@ static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
         unsigned long flags;
         unsigned long timeleft;
 
-#if defined(AHA152X_DEBUG)
-        if(HOSTDATA(shpnt)->debug & debug_eh) {
-                printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
-                show_queues(shpnt);
-        }
-#endif
-
         if(CURRENT_SC==SCpnt) {
-                printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
+                scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n");
                 return FAILED;
         }
 
@@ -1208,7 +1102,7 @@ static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
                 } else if(disconnected) {
                         append_SC(&DISCONNECTED_SC, SCpnt);
                 }
-        
+
                 ret = FAILED;
         }
 
@@ -1227,12 +1121,12 @@ static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
                 if(SCDATA(ptr)) {
                         next = SCNEXT(ptr);
                 } else {
-                        printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
+                        scmd_printk(KERN_DEBUG, ptr,
+                                    "queue corrupted at %p\n", ptr);
                         next = NULL;
                 }
 
                 if (!ptr->device->soft_reset) {
-                        DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
                         remove_SC(SCs, ptr);
                         HOSTDATA(shpnt)->commands--;
                         kfree(ptr->host_scribble);
@@ -1253,25 +1147,14 @@ static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
 
         DO_LOCK(flags);
 
-#if defined(AHA152X_DEBUG)
-        if(HOSTDATA(shpnt)->debug & debug_eh) {
-                printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
-                show_queues(shpnt);
-        }
-#endif
-
         free_hard_reset_SCs(shpnt, &ISSUE_SC);
         free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
 
-        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
-
         SETPORT(SCSISEQ, SCSIRSTO);
         mdelay(256);
         SETPORT(SCSISEQ, 0);
         mdelay(DELAY);
 
-        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
-
         setup_expected_interrupts(shpnt);
         if(HOSTDATA(shpnt)->commands==0)
                 SETPORT(PORTA, 0);
@@ -1333,11 +1216,7 @@ static void reset_ports(struct Scsi_Host *shpnt)
  */
 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
 {
-        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
-
         aha152x_bus_reset_host(shpnt);
-
-        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
         reset_ports(shpnt);
 
         return SUCCESS;
@@ -1345,7 +1224,7 @@ int aha152x_host_reset_host(struct Scsi_Host *shpnt)
 
 /*
  * Reset the host (bus and controller)
- * 
+ *
  */
 static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
 {
@@ -1411,7 +1290,9 @@ static void done(struct Scsi_Host *shpnt, int error)
 {
         if (CURRENT_SC) {
                 if(DONE_SC)
-                        printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
+                        scmd_printk(KERN_ERR, CURRENT_SC,
+                                    "there's already a completed command %p "
+                                    "- will cause abort\n", DONE_SC);
 
                 DONE_SC = CURRENT_SC;
                 CURRENT_SC = NULL;
@@ -1466,7 +1347,7 @@ static irqreturn_t intr(int irqno, void *dev_id)
                 return IRQ_NONE;
 
         if( TESTLO(DMASTAT, INTSTAT) )
-                return IRQ_NONE;        
+                return IRQ_NONE;
 
         /* no more interrupts from the controller, while we're busy.
            INTEN is restored by the BH handler */
@@ -1501,7 +1382,7 @@ static void busfree_run(struct Scsi_Host *shpnt)
         SETPORT(SXFRCTL0, CH1);
 
         SETPORT(SSTAT1, CLRBUSFREE);
-        
+
         if(CURRENT_SC) {
 #if defined(AHA152X_STAT)
                 action++;
@@ -1513,19 +1394,13 @@ static void busfree_run(struct Scsi_Host *shpnt)
                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
 
                 } else if(CURRENT_SC->SCp.phase & aborted) {
-                        DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
 
                 } else if(CURRENT_SC->SCp.phase & resetted) {
-                        DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
 
                 } else if(CURRENT_SC->SCp.phase & disconnected) {
                         /* target sent DISCONNECT */
-                        DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
-                                CMDINFO(CURRENT_SC),
-                                scsi_get_resid(CURRENT_SC),
-                                scsi_bufflen(CURRENT_SC));
 #if defined(AHA152X_STAT)
                         HOSTDATA(shpnt)->disconnections++;
 #endif
@@ -1553,13 +1428,6 @@ static void busfree_run(struct Scsi_Host *shpnt)
                         struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
                         struct aha152x_scdata *sc = SCDATA(cmd);
 
-#if 0
-                        if(HOSTDATA(shpnt)->debug & debug_eh) {
-                                printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
-                                scsi_print_sense("bh", DONE_SC);
-                        }
-#endif
-
                         scsi_eh_restore_cmnd(cmd, &sc->ses);
 
                         cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
@@ -1571,17 +1439,11 @@ static void busfree_run(struct Scsi_Host *shpnt)
 #if defined(AHA152X_STAT)
                         HOSTDATA(shpnt)->busfree_with_check_condition++;
 #endif
-#if 0
-                        DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
-#endif
 
                         if(!(DONE_SC->SCp.phase & not_issued)) {
                                 struct aha152x_scdata *sc;
                                 Scsi_Cmnd *ptr = DONE_SC;
                                 DONE_SC=NULL;
-#if 0
-                                DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
-#endif
 
                                 sc = SCDATA(ptr);
                                 /* It was allocated in aha152x_internal_queue? */
@@ -1591,19 +1453,10 @@ static void busfree_run(struct Scsi_Host *shpnt)
                                 DO_UNLOCK(flags);
                                 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
                                 DO_LOCK(flags);
-#if 0
-                        } else {
-                                DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
-#endif
                         }
                 }
 
                 if(DONE_SC && DONE_SC->scsi_done) {
-#if defined(AHA152X_DEBUG)
-                        int hostno=DONE_SC->device->host->host_no;
-                        int id=DONE_SC->device->id & 0xf;
-                        int lun=((u8)DONE_SC->device->lun) & 0x7;
-#endif
                         Scsi_Cmnd *ptr = DONE_SC;
                         DONE_SC=NULL;
 
@@ -1618,9 +1471,7 @@ static void busfree_run(struct Scsi_Host *shpnt)
                         }
 
                         DO_UNLOCK(flags);
-                        DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
-                        ptr->scsi_done(ptr);
-                        DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
+                        ptr->scsi_done(ptr);
                         DO_LOCK(flags);
                 }
 
@@ -1640,9 +1491,7 @@ static void busfree_run(struct Scsi_Host *shpnt)
 #if defined(AHA152X_STAT)
                 action++;
 #endif
-                CURRENT_SC->SCp.phase |= selecting;
-
-                DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
+                CURRENT_SC->SCp.phase |= selecting;
 
                 /* clear selection timeout */
                 SETPORT(SSTAT1, SELTO);
@@ -1674,18 +1523,19 @@ static void seldo_run(struct Scsi_Host *shpnt)
         SETPORT(SSTAT1, CLRBUSFREE);
         SETPORT(SSTAT1, CLRPHASECHG);
 
-        CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
+        CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
 
         SETPORT(SCSISEQ, 0);
 
         if (TESTLO(SSTAT0, SELDO)) {
-                printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
+                scmd_printk(KERN_ERR, CURRENT_SC,
+                            "aha152x: passing bus free condition\n");
                 done(shpnt, DID_NO_CONNECT << 16);
                 return;
         }
 
         SETPORT(SSTAT0, CLRSELDO);
-        
+
         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
 
         if (CURRENT_SC->SCp.phase & aborting) {
@@ -1693,7 +1543,7 @@ static void seldo_run(struct Scsi_Host *shpnt)
         } else if (CURRENT_SC->SCp.phase & resetting) {
                 ADDMSGO(BUS_DEVICE_RESET);
         } else if (SYNCNEG==0 && SYNCHRONOUS) {
-                CURRENT_SC->SCp.phase |= syncneg;
+                CURRENT_SC->SCp.phase |= syncneg;
                 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
                 SYNCNEG=1;              /* negotiation in progress */
         }
@@ -1708,29 +1558,21 @@ static void seldo_run(struct Scsi_Host *shpnt)
  */
 static void selto_run(struct Scsi_Host *shpnt)
 {
-        SETPORT(SCSISEQ, 0);            
+        SETPORT(SCSISEQ, 0);
         SETPORT(SSTAT1, CLRSELTIMO);
 
-        DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
-
-        if(!CURRENT_SC) {
-                DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
+        if (!CURRENT_SC)
                 return;
-        }
 
-        CURRENT_SC->SCp.phase &= ~selecting;
+        CURRENT_SC->SCp.phase &= ~selecting;
 
-        if (CURRENT_SC->SCp.phase & aborted) {
-                DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
+        if (CURRENT_SC->SCp.phase & aborted)
                 done(shpnt, DID_ABORT << 16);
-        } else if (TESTLO(SSTAT0, SELINGO)) {
-                DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
+        else if (TESTLO(SSTAT0, SELINGO))
                 done(shpnt, DID_BUS_BUSY << 16);
-        } else {
+        else
                 /* ARBITRATION won, but SELECTION failed */
-                DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
                 done(shpnt, DID_NO_CONNECT << 16);
-        }
 }
 
 /*
@@ -1753,9 +1595,8 @@ static void seldi_run(struct Scsi_Host *shpnt)
 
         if(CURRENT_SC) {
                 if(!(CURRENT_SC->SCp.phase & not_issued))
-                        printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
-
-                DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
+                        scmd_printk(KERN_ERR, CURRENT_SC,
+                                    "command should not have been issued yet\n");
 
                 DO_LOCK(flags);
                 append_SC(&ISSUE_SC, CURRENT_SC);
@@ -1764,17 +1605,16 @@ static void seldi_run(struct Scsi_Host *shpnt)
                 CURRENT_SC = NULL;
         }
 
-        if(!DISCONNECTED_SC) {
-                DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
+        if (!DISCONNECTED_SC)
                 return;
-        }
 
         RECONN_TARGET=-1;
 
         selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
 
         if (selid==0) {
-                printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
+                shost_printk(KERN_INFO, shpnt,
+                             "target id unknown (%02x)\n", selid);
                 return;
         }
 
@@ -1782,8 +1622,8 @@ static void seldi_run(struct Scsi_Host *shpnt)
                 ;
 
         if(selid & ~(1 << target)) {
-                printk("aha152x%d: multiple targets reconnected (%02x)\n",
-                       HOSTNO, selid);
+                shost_printk(KERN_INFO, shpnt,
+                             "multiple targets reconnected (%02x)\n", selid);
         }
 
 
@@ -1793,7 +1633,6 @@ static void seldi_run(struct Scsi_Host *shpnt)
         SETRATE(HOSTDATA(shpnt)->syncrate[target]);
 
         RECONN_TARGET=target;
-        DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
 }
 
 /*
@@ -1817,31 +1656,24 @@ static void msgi_run(struct Scsi_Host *shpnt)
                 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
                         return;
 
-                if(TESTLO(SSTAT0,SPIORDY)) {
-                        DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
+                if (TESTLO(SSTAT0, SPIORDY))
                         return;
-                }       
 
                 ADDMSGI(GETPORT(SCSIDAT));
 
-#if defined(AHA152X_DEBUG)
-                if (HOSTDATA(shpnt)->debug & debug_msgi) {
-                        printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
-                        spi_print_msg(&MSGI(0));
-                        printk("\n");
-                }
-#endif
-
                 if(!CURRENT_SC) {
                         if(LASTSTATE!=seldi) {
-                                printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
+                                shost_printk(KERN_ERR, shpnt,
+                                             "message in w/o current command"
+                                             " not after reselection\n");
                         }
 
                         /*
-                         * Handle reselection
-                         */
+                         * Handle reselection
+                         */
                         if(!(MSGI(0) & IDENTIFY_BASE)) {
-                                printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
+                                shost_printk(KERN_ERR, shpnt,
+                                             "target didn't identify after reselection\n");
                                 continue;
                         }
 
@@ -1849,12 +1681,13 @@ static void msgi_run(struct Scsi_Host *shpnt)
 
                         if (!CURRENT_SC) {
                                 show_queues(shpnt);
-                                printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
+                                shost_printk(KERN_ERR, shpnt,
+                                             "no disconnected command"
+                                             " for target %d/%d\n",
+                                             RECONN_TARGET, MSGI(0) & 0x3f);
                                 continue;
                         }
 
-                        DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
-
                         CURRENT_SC->SCp.Message = MSGI(0);
                         CURRENT_SC->SCp.phase &= ~disconnected;
 
@@ -1862,31 +1695,32 @@ static void msgi_run(struct Scsi_Host *shpnt)
 
                         /* next message if any */
                         continue;
-                } 
+                }
 
                 CURRENT_SC->SCp.Message = MSGI(0);
 
                 switch (MSGI(0)) {
                 case DISCONNECT:
                         if (!RECONNECT)
-                                printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
+                                scmd_printk(KERN_WARNING, CURRENT_SC,
+                                            "target was not allowed to disconnect\n");
 
                         CURRENT_SC->SCp.phase |= disconnected;
                         break;
 
                 case COMMAND_COMPLETE:
-                        if(CURRENT_SC->SCp.phase & completed)
-                                DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
-
                         CURRENT_SC->SCp.phase |= completed;
                         break;
 
                 case MESSAGE_REJECT:
                         if (SYNCNEG==1) {
-                                printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
+                                scmd_printk(KERN_INFO, CURRENT_SC,
+                                            "Synchronous Data Transfer Request"
+                                            " was rejected\n");
                                 SYNCNEG=2;      /* negotiation completed */
                         } else
-                                printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
+                                scmd_printk(KERN_INFO, CURRENT_SC,
+                                            "inbound message (MESSAGE REJECT)\n");
                         break;
 
                 case SAVE_POINTERS:
@@ -1907,7 +1741,8 @@ static void msgi_run(struct Scsi_Host *shpnt)
                                         long ticks;
 
                                         if (MSGI(1) != 3) {
-                                                printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
+                                                scmd_printk(KERN_ERR, CURRENT_SC,
+                                                            "SDTR message length!=3\n");
                                                 break;
                                         }
 
@@ -1924,10 +1759,12 @@ static void msgi_run(struct Scsi_Host *shpnt)
                                                 /* negotiation in progress */
                                                 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
                                                         ADDMSGO(MESSAGE_REJECT);
-                                                        printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
+                                                        scmd_printk(KERN_INFO,
+                                                                    CURRENT_SC,
+                                                                    "received Synchronous Data Transfer Request invalid - rejected\n");
                                                         break;
                                                 }
-                                                
+
                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
                                         } else if (ticks <= 9 && MSGI(4) >= 1) {
                                                 ADDMSGO(EXTENDED_MESSAGE);
@@ -1947,11 +1784,14 @@ static void msgi_run(struct Scsi_Host *shpnt)
                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
                                         } else {
                                                 /* requested SDTR is too slow, do it asynchronously */
-                                                printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
+                                                scmd_printk(KERN_INFO,
+                                                            CURRENT_SC,
+                                                            "Synchronous Data Transfer Request too slow - Rejecting\n");
                                                 ADDMSGO(MESSAGE_REJECT);
                                         }
 
-                                        SYNCNEG=2;              /* negotiation completed */
+                                        /* negotiation completed */
+                                        SYNCNEG=2;
                                         SETRATE(SYNCRATE);
                                 }
                                 break;
@@ -1985,12 +1825,12 @@ static void msgi_run(struct Scsi_Host *shpnt)
 static void msgi_end(struct Scsi_Host *shpnt)
 {
         if(MSGILEN>0)
-                printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
+                scmd_printk(KERN_WARNING, CURRENT_SC,
+                            "target left before message completed (%d)\n",
+                            MSGILEN);
 
-        if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
-                DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
+        if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE))
                 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
-        } 
 }
 
 /*
@@ -2003,21 +1843,12 @@ static void msgo_init(struct Scsi_Host *shpnt)
                 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
                         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
                 } else {
-                        printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
+                        scmd_printk(KERN_INFO, CURRENT_SC,
+                                    "unexpected MESSAGE OUT phase; rejecting\n");
                         ADDMSGO(MESSAGE_REJECT);
                 }
         }
 
-#if defined(AHA152X_DEBUG)
-        if(HOSTDATA(shpnt)->debug & debug_msgo) {
-                int i;
-
-                printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
-                for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
-                        ;
-                printk(")\n");
-        }
-#endif
 }
 
 /*
@@ -2026,16 +1857,9 @@ static void msgo_init(struct Scsi_Host *shpnt)
  */
 static void msgo_run(struct Scsi_Host *shpnt)
 {
-        if(MSGO_I==MSGOLEN)
-                DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
-
         while(MSGO_I<MSGOLEN) {
-                DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
-
-                if(TESTLO(SSTAT0, SPIORDY)) {
-                        DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
+                if (TESTLO(SSTAT0, SPIORDY))
                         return;
-                }
 
                 if (MSGO_I==MSGOLEN-1) {
                         /* Leave MESSAGE OUT after transfer */
@@ -2059,36 +1883,33 @@ static void msgo_run(struct Scsi_Host *shpnt)
 static void msgo_end(struct Scsi_Host *shpnt)
 {
         if(MSGO_I<MSGOLEN) {
-                printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
+                scmd_printk(KERN_ERR, CURRENT_SC,
+                            "message sent incompletely (%d/%d)\n",
+                            MSGO_I, MSGOLEN);
                 if(SYNCNEG==1) {
-                        printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
+                        scmd_printk(KERN_INFO, CURRENT_SC,
+                                    "Synchronous Data Transfer Request was rejected\n");
                         SYNCNEG=2;
                 }
         }
-                
+
         MSGO_I  = 0;
         MSGOLEN = 0;
 }
 
-/* 
+/*
  * command phase
  *
  */
 static void cmd_init(struct Scsi_Host *shpnt)
 {
         if (CURRENT_SC->SCp.sent_command) {
-                printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
+                scmd_printk(KERN_ERR, CURRENT_SC,
+                            "command already sent\n");
                 done(shpnt, DID_ERROR << 16);
                 return;
         }
 
-#if defined(AHA152X_DEBUG)
-        if (HOSTDATA(shpnt)->debug & debug_cmd) {
-                printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
-                __scsi_print_command(CURRENT_SC->cmnd);
-        }
-#endif
-
         CMD_I=0;
 }
 
@@ -2098,18 +1919,9 @@ static void cmd_init(struct Scsi_Host *shpnt)
  */
 static void cmd_run(struct Scsi_Host *shpnt)
 {
-        if(CMD_I==CURRENT_SC->cmd_len) {
-                DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
-                disp_ports(shpnt);
-        }
-
         while(CMD_I<CURRENT_SC->cmd_len) {
-                DPRINTK(debug_cmd, DEBUG_LEAD "command byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), CURRENT_SC->cmnd[CMD_I], CMD_I, CURRENT_SC->cmd_len);
-
-                if(TESTLO(SSTAT0, SPIORDY)) {
-                        DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
+                if (TESTLO(SSTAT0, SPIORDY))
                         return;
-                }
 
                 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
         }
@@ -2118,7 +1930,9 @@ static void cmd_run(struct Scsi_Host *shpnt)
 static void cmd_end(struct Scsi_Host *shpnt)
 {
         if(CMD_I<CURRENT_SC->cmd_len)
-                printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
+                scmd_printk(KERN_ERR, CURRENT_SC,
+                            "command sent incompletely (%d/%d)\n",
+                            CMD_I, CURRENT_SC->cmd_len);
         else
                 CURRENT_SC->SCp.sent_command++;
 }
@@ -2129,20 +1943,11 @@ static void cmd_end(struct Scsi_Host *shpnt)
  */
 static void status_run(struct Scsi_Host *shpnt)
 {
-        if(TESTLO(SSTAT0,SPIORDY)) {
-                DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
+        if (TESTLO(SSTAT0, SPIORDY))
                 return;
-        }
 
         CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
 
-#if defined(AHA152X_DEBUG)
-        if (HOSTDATA(shpnt)->debug & debug_status) {
-                printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
-                scsi_print_status(CURRENT_SC->SCp.Status);
-                printk("\n");
-        }
-#endif
 }
 
 /*
@@ -2161,10 +1966,6 @@ static void datai_init(struct Scsi_Host *shpnt)
         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
 
         DATA_LEN=0;
-        DPRINTK(debug_datai,
-                DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
-                CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
-                scsi_get_resid(CURRENT_SC));
 }
 
 static void datai_run(struct Scsi_Host *shpnt)
@@ -2186,8 +1987,7 @@ static void datai_run(struct Scsi_Host *shpnt)
                         barrier();
 
                 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
-                        printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
-                        disp_ports(shpnt);
+                        scmd_printk(KERN_ERR, CURRENT_SC, "datai timeout\n");
                         break;
                 }
 
@@ -2199,8 +1999,8 @@ static void datai_run(struct Scsi_Host *shpnt)
                                 barrier();
 
                         if(TESTLO(SSTAT2, SEMPTY)) {
-                                printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
-                                disp_ports(shpnt);
+                                scmd_printk(KERN_ERR, CURRENT_SC,
+                                            "datai sempty timeout");
                                 break;
                         }
 
@@ -2209,48 +2009,49 @@ static void datai_run(struct Scsi_Host *shpnt)
 
                 if(CURRENT_SC->SCp.this_residual>0) {
                         while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
-                                data_count = fifodata>CURRENT_SC->SCp.this_residual ?
+                                data_count = fifodata > CURRENT_SC->SCp.this_residual ?
                                                 CURRENT_SC->SCp.this_residual :
                                                 fifodata;
                                 fifodata -= data_count;
 
-                                if(data_count & 1) {
-                                        DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
-                                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
-                                        *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
-                                        CURRENT_SC->SCp.this_residual--;
-                                        DATA_LEN++;
-                                        SETPORT(DMACNTRL0, ENDMA);
-                                }
-        
-                                if(data_count > 1) {
-                                        DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
-                                        data_count >>= 1;
-                                        insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
-                                        CURRENT_SC->SCp.ptr           += 2 * data_count;
-                                        CURRENT_SC->SCp.this_residual -= 2 * data_count;
-                                        DATA_LEN                      += 2 * data_count;
-                                }
-        
-                                if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
-                                        /* advance to next buffer */
-                                        CURRENT_SC->SCp.buffers_residual--;
-                                        CURRENT_SC->SCp.buffer++;
-                                        CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
-                                        CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
-                                } 
-                        }
-                } else if(fifodata>0) { 
-                        printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
-                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
+                                if (data_count & 1) {
+                                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
+                                        *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
+                                        CURRENT_SC->SCp.this_residual--;
+                                        DATA_LEN++;
+                                        SETPORT(DMACNTRL0, ENDMA);
+                                }
+
+                                if (data_count > 1) {
+                                        data_count >>= 1;
+                                        insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
+                                        CURRENT_SC->SCp.ptr += 2 * data_count;
+                                        CURRENT_SC->SCp.this_residual -= 2 * data_count;
+                                        DATA_LEN += 2 * data_count;
+                                }
+
+                                if (CURRENT_SC->SCp.this_residual == 0 &&
+                                    CURRENT_SC->SCp.buffers_residual > 0) {
+                                        /* advance to next buffer */
+                                        CURRENT_SC->SCp.buffers_residual--;
+                                        CURRENT_SC->SCp.buffer++;
+                                        CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
+                                        CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
+                                }
+                        }
+                } else if (fifodata > 0) {
+                        scmd_printk(KERN_ERR, CURRENT_SC,
+                                    "no buffers left for %d(%d) bytes"
+                                    " (data overrun!?)\n",
+                                    fifodata, GETPORT(FIFOSTAT));
+                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
                         while(fifodata>0) {
                                 int data;
                                 data=GETPORT(DATAPORT);
-                                DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
                                 fifodata--;
                                 DATA_LEN++;
                         }
-                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
+                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
                 }
         }
 
@@ -2258,19 +2059,20 @@ static void datai_run(struct Scsi_Host *shpnt)
            TESTLO(DMASTAT, DFIFOEMP) ||
            TESTLO(SSTAT2, SEMPTY) ||
            GETPORT(FIFOSTAT)>0) {
-                /*
+                /*
                  * something went wrong, if there's something left in the fifos
                  * or the phase didn't change
                  */
-                printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
-                disp_ports(shpnt);
+                scmd_printk(KERN_ERR, CURRENT_SC,
+                            "fifos should be empty and phase should have changed\n");
         }
 
         if(DATA_LEN!=GETSTCNT()) {
-                printk(ERR_LEAD
-                       "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
-                       CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
-                disp_ports(shpnt);
+                scmd_printk(KERN_ERR, CURRENT_SC,
+                            "manual transfer count differs from automatic "
+                            "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
+                            DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
+                            GETPORT(FIFOSTAT));
                 mdelay(10000);
         }
 }
@@ -2279,11 +2081,6 @@ static void datai_end(struct Scsi_Host *shpnt)
 {
         CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
 
-        DPRINTK(debug_datai,
-                DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
-                CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
-                scsi_get_resid(CURRENT_SC), GETSTCNT());
-
         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
         SETPORT(DMACNTRL0, 0);
 }
@@ -2304,11 +2101,6 @@ static void datao_init(struct Scsi_Host *shpnt)
         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
 
         DATA_LEN = scsi_get_resid(CURRENT_SC);
-
-        DPRINTK(debug_datao,
-                DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
-                CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
-                scsi_get_resid(CURRENT_SC));
 }
 
 static void datao_run(struct Scsi_Host *shpnt)
@@ -2323,8 +2115,9 @@ static void datao_run(struct Scsi_Host *shpnt)
                         data_count=CURRENT_SC->SCp.this_residual;
 
                 if(TESTLO(DMASTAT, DFIFOEMP)) {
-                        printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
-                        disp_ports(shpnt);
+                        scmd_printk(KERN_ERR, CURRENT_SC,
+                                    "datao fifo not empty (%d)",
+                                    GETPORT(FIFOSTAT));
                         break;
                 }
 
@@ -2342,7 +2135,7 @@ static void datao_run(struct Scsi_Host *shpnt)
                         CURRENT_SC->SCp.ptr           += 2 * data_count;
                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
                         CMD_INC_RESID(CURRENT_SC, -2 * data_count);
-                }
+                }
 
                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
                         /* advance to next buffer */
@@ -2357,8 +2150,7 @@ static void datao_run(struct Scsi_Host *shpnt)
                         barrier();
 
                 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
-                        printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
-                        disp_ports(shpnt);
+                        scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
                         break;
                 }
         }
@@ -2368,35 +2160,23 @@ static void datao_end(struct Scsi_Host *shpnt)
 {
         if(TESTLO(DMASTAT, DFIFOEMP)) {
                 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
-                                                                    GETSTCNT();
-
-                DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
-                        CMDINFO(CURRENT_SC),
-                        data_count,
-                        DATA_LEN - scsi_get_resid(CURRENT_SC),
-                        GETSTCNT());
+                        GETSTCNT();
 
                 CMD_INC_RESID(CURRENT_SC, data_count);
 
                 data_count -= CURRENT_SC->SCp.ptr -
-                                             SG_ADDRESS(CURRENT_SC->SCp.buffer);
+                        SG_ADDRESS(CURRENT_SC->SCp.buffer);
                 while(data_count>0) {
                         CURRENT_SC->SCp.buffer--;
                         CURRENT_SC->SCp.buffers_residual++;
                         data_count -= CURRENT_SC->SCp.buffer->length;
                 }
                 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
-                                                                     data_count;
+                        data_count;
                 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
-                                                                     data_count;
+                        data_count;
         }
 
-        DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
-                CMDINFO(CURRENT_SC),
-                scsi_bufflen(CURRENT_SC),
-                scsi_get_resid(CURRENT_SC),
-                GETSTCNT());
-
         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
         SETPORT(SXFRCTL0, CH1);
 
@@ -2420,7 +2200,7 @@ static int update_state(struct Scsi_Host *shpnt)
                 STATE=rsti;
                 SETPORT(SCSISEQ,0);
                 SETPORT(SSTAT1,SCSIRSTI);
-        } else if(stat0 & SELDI && PREVSTATE==busfree) {
+        } else if (stat0 & SELDI && PREVSTATE == busfree) {
                 STATE=seldi;
         } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
                 STATE=seldo;
@@ -2445,8 +2225,7 @@ static int update_state(struct Scsi_Host *shpnt)
         }
 
         if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
-                printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
-                disp_ports(shpnt);
+                scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
         }
 
         if(STATE!=PREVSTATE) {
@@ -2464,7 +2243,7 @@ static int update_state(struct Scsi_Host *shpnt)
  */
 static void parerr_run(struct Scsi_Host *shpnt)
 {
-        printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
+        scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
         done(shpnt, DID_PARITY << 16);
 }
 
@@ -2476,8 +2255,8 @@ static void rsti_run(struct Scsi_Host *shpnt)
 {
         Scsi_Cmnd *ptr;
 
-        printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
-        
+        shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
+
         ptr=DISCONNECTED_SC;
         while(ptr) {
                 Scsi_Cmnd *next = SCNEXT(ptr);
@@ -2539,8 +2318,6 @@ static void is_complete(struct Scsi_Host *shpnt)
 
                 dataphase=update_state(shpnt);
 
-                DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
-
                 /*
                  * end previous state
                  *
@@ -2567,9 +2344,9 @@ static void is_complete(struct Scsi_Host *shpnt)
                 if(dataphase) {
                         SETPORT(SSTAT0, REQINIT);
                         SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
-                        SETPORT(SSTAT1, PHASECHG);  
+                        SETPORT(SSTAT1, PHASECHG);
                 }
-                
+
                 /*
                  * enable SPIO mode if previous didn't use it
                  * and this one does
@@ -2581,14 +2358,14 @@ static void is_complete(struct Scsi_Host *shpnt)
                         if(CURRENT_SC)
                                 CURRENT_SC->SCp.phase |= spiordy;
                 }
-                
+
                 /*
                  * initialize for new state
                  *
                  */
                 if(PREVSTATE!=STATE && states[STATE].init)
                         states[STATE].init(shpnt);
-                
+
                 /*
                  * handle current state
                  *
@@ -2596,8 +2373,9 @@ static void is_complete(struct Scsi_Host *shpnt)
                 if(states[STATE].run)
                         states[STATE].run(shpnt);
                 else
-                        printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
-                
+                        scmd_printk(KERN_ERR, CURRENT_SC,
+                                    "unexpected state (%x)\n", STATE);
+
                 /*
                  * setup controller to interrupt on
                  * the next expected condition and
@@ -2613,7 +2391,6 @@ static void is_complete(struct Scsi_Host *shpnt)
                 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
 #endif
 
-                DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
         } while(pending);
 
         /*
@@ -2626,289 +2403,42 @@ static void is_complete(struct Scsi_Host *shpnt)
 }
 
 
-/* 
+/*
  * Dump the current driver status and panic
  */
 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
 {
-        printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
+        shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
         show_queues(shpnt);
         panic("aha152x panic\n");
 }
 
 /*
- * Display registers of AIC-6260
- */
-static void disp_ports(struct Scsi_Host *shpnt)
-{
-#if defined(AHA152X_DEBUG)
-        int s;
-
-        printk("\n%s: %s(%s) ",
-                CURRENT_SC ? "busy" : "waiting",
-                states[STATE].name,
-                states[PREVSTATE].name);
-
-        s = GETPORT(SCSISEQ);
-        printk("SCSISEQ( ");
-        if (s & TEMODEO)
-                printk("TARGET MODE ");
-        if (s & ENSELO)
-                printk("SELO ");
-        if (s & ENSELI)
-                printk("SELI ");
-        if (s & ENRESELI)
-                printk("RESELI ");
-        if (s & ENAUTOATNO)
-                printk("AUTOATNO ");
-        if (s & ENAUTOATNI)
-                printk("AUTOATNI ");
-        if (s & ENAUTOATNP)
-                printk("AUTOATNP ");
-        if (s & SCSIRSTO)
-                printk("SCSIRSTO ");
-        printk(");");
-
-        printk(" SCSISIG(");
-        s = GETPORT(SCSISIG);
-        switch (s & P_MASK) {
-        case P_DATAO:
-                printk("DATA OUT");
-                break;
-        case P_DATAI:
-                printk("DATA IN");
-                break;
-        case P_CMD:
-                printk("COMMAND");
-                break;
-        case P_STATUS:
-                printk("STATUS");
-                break;
-        case P_MSGO:
-                printk("MESSAGE OUT");
-                break;
-        case P_MSGI:
-                printk("MESSAGE IN");
-                break;
-        default:
-                printk("*invalid*");
-                break;
-        }
-
-        printk("); ");
-
-        printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
-
-        printk("SSTAT( ");
-        s = GETPORT(SSTAT0);
-        if (s & TARGET)
-                printk("TARGET ");
-        if (s & SELDO)
-                printk("SELDO ");
-        if (s & SELDI)
-                printk("SELDI ");
-        if (s & SELINGO)
-                printk("SELINGO ");
-        if (s & SWRAP)
-                printk("SWRAP ");
-        if (s & SDONE)
-                printk("SDONE ");
-        if (s & SPIORDY)
-                printk("SPIORDY ");
-        if (s & DMADONE)
-                printk("DMADONE ");
-
-        s = GETPORT(SSTAT1);
-        if (s & SELTO)
-                printk("SELTO ");
-        if (s & ATNTARG)
-                printk("ATNTARG ");
-        if (s & SCSIRSTI)
-                printk("SCSIRSTI ");
-        if (s & PHASEMIS)
-                printk("PHASEMIS ");
-        if (s & BUSFREE)
-                printk("BUSFREE ");
-        if (s & SCSIPERR)
-                printk("SCSIPERR ");
-        if (s & PHASECHG)
-                printk("PHASECHG ");
-        if (s & REQINIT)
-                printk("REQINIT ");
-        printk("); ");
-
-
-        printk("SSTAT( ");
-
-        s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
-
-        if (s & TARGET)
-                printk("TARGET ");
-        if (s & SELDO)
-                printk("SELDO ");
-        if (s & SELDI)
-                printk("SELDI ");
-        if (s & SELINGO)
-                printk("SELINGO ");
-        if (s & SWRAP)
-                printk("SWRAP ");
-        if (s & SDONE)
-                printk("SDONE ");
-        if (s & SPIORDY)
-                printk("SPIORDY ");
-        if (s & DMADONE)
-                printk("DMADONE ");
-
-        s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
-
-        if (s & SELTO)
-                printk("SELTO ");
-        if (s & ATNTARG)
-                printk("ATNTARG ");
-        if (s & SCSIRSTI)
-                printk("SCSIRSTI ");
-        if (s & PHASEMIS)
-                printk("PHASEMIS ");
-        if (s & BUSFREE)
-                printk("BUSFREE ");
-        if (s & SCSIPERR)
-                printk("SCSIPERR ");
-        if (s & PHASECHG)
-                printk("PHASECHG ");
-        if (s & REQINIT)
-                printk("REQINIT ");
-        printk("); ");
-
-        printk("SXFRCTL0( ");
-
-        s = GETPORT(SXFRCTL0);
-        if (s & SCSIEN)
-                printk("SCSIEN ");
-        if (s & DMAEN)
-                printk("DMAEN ");
-        if (s & CH1)
-                printk("CH1 ");
-        if (s & CLRSTCNT)
-                printk("CLRSTCNT ");
-        if (s & SPIOEN)
-                printk("SPIOEN ");
-        if (s & CLRCH1)
-                printk("CLRCH1 ");
-        printk("); ");
-
-        printk("SIGNAL( ");
-
-        s = GETPORT(SCSISIG);
-        if (s & SIG_ATNI)
-                printk("ATNI ");
-        if (s & SIG_SELI)
-                printk("SELI ");
-        if (s & SIG_BSYI)
-                printk("BSYI ");
-        if (s & SIG_REQI)
-                printk("REQI ");
-        if (s & SIG_ACKI)
-                printk("ACKI ");
-        printk("); ");
-
-        printk("SELID (%02x), ", GETPORT(SELID));
-
-        printk("STCNT (%d), ", GETSTCNT());
-        
-        printk("SSTAT2( ");
-
-        s = GETPORT(SSTAT2);
-        if (s & SOFFSET)
-                printk("SOFFSET ");
-        if (s & SEMPTY)
-                printk("SEMPTY ");
-        if (s & SFULL)
-                printk("SFULL ");
-        printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
-
-        s = GETPORT(SSTAT3);
-        printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
-
-        printk("SSTAT4( ");
-        s = GETPORT(SSTAT4);
-        if (s & SYNCERR)
-                printk("SYNCERR ");
-        if (s & FWERR)
-                printk("FWERR ");
-        if (s & FRERR)
-                printk("FRERR ");
-        printk("); ");
-
-        printk("DMACNTRL0( ");
-        s = GETPORT(DMACNTRL0);
-        printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
-        printk("%s ", s & DMA ? "DMA" : "PIO");
-        printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
-        if (s & ENDMA)
-                printk("ENDMA ");
-        if (s & INTEN)
-                printk("INTEN ");
-        if (s & RSTFIFO)
-                printk("RSTFIFO ");
-        if (s & SWINT)
-                printk("SWINT ");
-        printk("); ");
-
-        printk("DMASTAT( ");
-        s = GETPORT(DMASTAT);
-        if (s & ATDONE)
-                printk("ATDONE ");
-        if (s & WORDRDY)
-                printk("WORDRDY ");
-        if (s & DFIFOFULL)
-                printk("DFIFOFULL ");
-        if (s & DFIFOEMP)
-                printk("DFIFOEMP ");
-        printk(")\n");
-#endif
-}
-
-/*
  * display enabled interrupts
  */
 static void disp_enintr(struct Scsi_Host *shpnt)
 {
-        int s;
-
-        printk(KERN_DEBUG "enabled interrupts ( ");
-
-        s = GETPORT(SIMODE0);
-        if (s & ENSELDO)
-                printk("ENSELDO ");
-        if (s & ENSELDI)
-                printk("ENSELDI ");
-        if (s & ENSELINGO)
-                printk("ENSELINGO ");
-        if (s & ENSWRAP)
-                printk("ENSWRAP ");
-        if (s & ENSDONE)
-                printk("ENSDONE ");
-        if (s & ENSPIORDY)
-                printk("ENSPIORDY ");
-        if (s & ENDMADONE)
-                printk("ENDMADONE ");
-
-        s = GETPORT(SIMODE1);
-        if (s & ENSELTIMO)
-                printk("ENSELTIMO ");
-        if (s & ENATNTARG)
-                printk("ENATNTARG ");
-        if (s & ENPHASEMIS)
-                printk("ENPHASEMIS ");
-        if (s & ENBUSFREE)
-                printk("ENBUSFREE ");
-        if (s & ENSCSIPERR)
-                printk("ENSCSIPERR ");
-        if (s & ENPHASECHG)
-                printk("ENPHASECHG ");
-        if (s & ENREQINIT)
-                printk("ENREQINIT ");
-        printk(")\n");
+        int s0, s1;
+
+        s0 = GETPORT(SIMODE0);
+        s1 = GETPORT(SIMODE1);
+
+        shost_printk(KERN_DEBUG, shpnt,
+                     "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
+                     (s0 & ENSELDO) ? "ENSELDO " : "",
+                     (s0 & ENSELDI) ? "ENSELDI " : "",
+                     (s0 & ENSELINGO) ? "ENSELINGO " : "",
+                     (s0 & ENSWRAP) ? "ENSWRAP " : "",
+                     (s0 & ENSDONE) ? "ENSDONE " : "",
+                     (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
+                     (s0 & ENDMADONE) ? "ENDMADONE " : "",
+                     (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
+                     (s1 & ENATNTARG) ? "ENATNTARG " : "",
+                     (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
+                     (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
+                     (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
+                     (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
+                     (s1 & ENREQINIT) ? "ENREQINIT " : "");
 }
 
 /*
@@ -2916,36 +2446,21 @@ static void disp_enintr(struct Scsi_Host *shpnt)
  */
 static void show_command(Scsi_Cmnd *ptr)
 {
-        scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
-
-        __scsi_print_command(ptr->cmnd);
-
-        printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
-               scsi_bufflen(ptr), scsi_get_resid(ptr));
-
-        if (ptr->SCp.phase & not_issued)
-                printk("not issued|");
-        if (ptr->SCp.phase & selecting)
-                printk("selecting|");
-        if (ptr->SCp.phase & identified)
-                printk("identified|");
-        if (ptr->SCp.phase & disconnected)
-                printk("disconnected|");
-        if (ptr->SCp.phase & completed)
-                printk("completed|");
-        if (ptr->SCp.phase & spiordy)
-                printk("spiordy|");
-        if (ptr->SCp.phase & syncneg)
-                printk("syncneg|");
-        if (ptr->SCp.phase & aborted)
-                printk("aborted|");
-        if (ptr->SCp.phase & resetted)
-                printk("resetted|");
-        if( SCDATA(ptr) ) {
-                printk("; next=0x%p\n", SCNEXT(ptr));
-        } else {
-                printk("; next=(host scribble NULL)\n");
-        }
+        scsi_print_command(ptr);
+        scmd_printk(KERN_DEBUG, ptr,
+                    "request_bufflen=%d; resid=%d; "
+                    "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
+                    scsi_bufflen(ptr), scsi_get_resid(ptr),
+                    (ptr->SCp.phase & not_issued) ? "not issued|" : "",
+                    (ptr->SCp.phase & selecting) ? "selecting|" : "",
+                    (ptr->SCp.phase & identified) ? "identified|" : "",
+                    (ptr->SCp.phase & disconnected) ? "disconnected|" : "",
+                    (ptr->SCp.phase & completed) ? "completed|" : "",
+                    (ptr->SCp.phase & spiordy) ? "spiordy|" : "",
+                    (ptr->SCp.phase & syncneg) ? "syncneg|" : "",
+                    (ptr->SCp.phase & aborted) ? "aborted|" : "",
+                    (ptr->SCp.phase & resetted) ? "resetted|" : "",
+                    (SCDATA(ptr)) ? SCNEXT(ptr) : NULL);
 }
 
 /*
@@ -2972,7 +2487,6 @@ static void show_queues(struct Scsi_Host *shpnt)
         for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
                 show_command(ptr);
 
-        disp_ports(shpnt);
         disp_enintr(shpnt);
 }
 
@@ -3276,15 +2790,6 @@ static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
         if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
                 return -EINVAL;
 
-#if defined(AHA152X_DEBUG)
-        if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
-                int debug = HOSTDATA(shpnt)->debug;
-
-                HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
-
-                printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
-        } else
-#endif
 #if defined(AHA152X_STAT)
         if(length>13 && strncmp("reset", buffer+8, 5)==0) {
                 int i;
@@ -3302,7 +2807,7 @@ static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
                         HOSTDATA(shpnt)->time[i]=0;
                 }
 
-                printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
+                shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
 
         } else
 #endif
@@ -3343,29 +2848,6 @@ static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
                                     HOSTDATA(shpnt)->syncrate[i] & 0x0f);
         }
-#if defined(AHA152X_DEBUG)
-#define PDEBUG(flags,txt) \
-        if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
-
-        SPRINTF("enabled debugging options: ");
-
-        PDEBUG(debug_procinfo, "procinfo");
-        PDEBUG(debug_queue, "queue");
-        PDEBUG(debug_intr, "interrupt");
-        PDEBUG(debug_selection, "selection");
-        PDEBUG(debug_msgo, "message out");
-        PDEBUG(debug_msgi, "message in");
-        PDEBUG(debug_status, "status");
-        PDEBUG(debug_cmd, "command");
-        PDEBUG(debug_datai, "data in");
-        PDEBUG(debug_datao, "data out");
-        PDEBUG(debug_eh, "eh");
-        PDEBUG(debug_locking, "locks");
-        PDEBUG(debug_phases, "phases");
-
-        SPRINTF("\n");
-#endif
-
         SPRINTF("\nqueue status:\n");
         DO_LOCK(flags);
         if (ISSUE_SC) {
@@ -3393,8 +2875,8 @@ static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
 
 #if defined(AHA152X_STAT)
         SPRINTF("statistics:\n"
-                "total commands:               %d\n"
-                "disconnections:               %d\n"
+                "total commands:               %d\n"
+                "disconnections:               %d\n"
                 "busfree with check condition: %d\n"
                 "busfree without old command:  %d\n"
                 "busfree without new command:  %d\n"
@@ -3413,7 +2895,7 @@ static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
                 HOSTDATA(shpnt)->busfree_without_any_action);
         for(i=0; i<maxstate; i++) {
                 SPRINTF("%-10s %-12d %-12d %-12ld\n",
-                        states[i].name,
+                        states[i].name,
                         HOSTDATA(shpnt)->count_trans[i],
                         HOSTDATA(shpnt)->count[i],
                         HOSTDATA(shpnt)->time[i]);
@@ -3671,25 +3153,19 @@ static int __init aha152x_init(void)
                         setup[setup_count].synchronous = aha152x[5];
                         setup[setup_count].delay       = aha152x[6];
                         setup[setup_count].ext_trans   = aha152x[7];
-#if defined(AHA152X_DEBUG)
-                        setup[setup_count].debug       = aha152x[8];
-#endif
-                } else if(io[0]!=0 || irq[0]!=0) {
+                } else if (io[0] != 0 || irq[0] != 0) {
                         if(io[0]!=0)  setup[setup_count].io_port = io[0];
                         if(irq[0]!=0) setup[setup_count].irq     = irq[0];
 
-                        setup[setup_count].scsiid      = scsiid[0];
-                        setup[setup_count].reconnect   = reconnect[0];
-                        setup[setup_count].parity      = parity[0];
-                        setup[setup_count].synchronous = sync[0];
-                        setup[setup_count].delay       = delay[0];
-                        setup[setup_count].ext_trans   = exttrans[0];
-#if defined(AHA152X_DEBUG)
-                        setup[setup_count].debug       = debug[0];
-#endif
+                        setup[setup_count].scsiid      = scsiid[0];
+                        setup[setup_count].reconnect   = reconnect[0];
+                        setup[setup_count].parity      = parity[0];
+                        setup[setup_count].synchronous = sync[0];
+                        setup[setup_count].delay       = delay[0];
+                        setup[setup_count].ext_trans   = exttrans[0];
                 }
 
-                if (checksetup(&setup[setup_count]))
+                if (checksetup(&setup[setup_count]))
                         setup_count++;
                 else
                         printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
@@ -3714,22 +3190,16 @@ static int __init aha152x_init(void)
                         setup[setup_count].synchronous = aha152x1[5];
                         setup[setup_count].delay       = aha152x1[6];
                         setup[setup_count].ext_trans   = aha152x1[7];
-#if defined(AHA152X_DEBUG)
-                        setup[setup_count].debug       = aha152x1[8];
-#endif
-                } else if(io[1]!=0 || irq[1]!=0) {
+                } else if (io[1] != 0 || irq[1] != 0) {
                         if(io[1]!=0)  setup[setup_count].io_port = io[1];
                         if(irq[1]!=0) setup[setup_count].irq     = irq[1];
 
-                        setup[setup_count].scsiid      = scsiid[1];
-                        setup[setup_count].reconnect   = reconnect[1];
-                        setup[setup_count].parity      = parity[1];
-                        setup[setup_count].synchronous = sync[1];
-                        setup[setup_count].delay       = delay[1];
-                        setup[setup_count].ext_trans   = exttrans[1];
-#if defined(AHA152X_DEBUG)
-                        setup[setup_count].debug       = debug[1];
-#endif
+                        setup[setup_count].scsiid      = scsiid[1];
+                        setup[setup_count].reconnect   = reconnect[1];
+                        setup[setup_count].parity      = parity[1];
+                        setup[setup_count].synchronous = sync[1];
+                        setup[setup_count].delay       = delay[1];
+                        setup[setup_count].ext_trans   = exttrans[1];
                 }
                 if (checksetup(&setup[setup_count]))
                         setup_count++;
@@ -3776,9 +3246,6 @@ static int __init aha152x_init(void)
                         setup[setup_count].synchronous = 1;
                         setup[setup_count].delay       = DELAY_DEFAULT;
                         setup[setup_count].ext_trans   = 0;
-#if defined(AHA152X_DEBUG)
-                        setup[setup_count].debug       = DEBUG_DEFAULT;
-#endif
 #if defined(__ISAPNP__)
                         pnpdev[setup_count]            = dev;
 #endif
@@ -3847,9 +3314,6 @@ static int __init aha152x_init(void)
                         setup[setup_count].synchronous = conf.cf_syncneg;
                         setup[setup_count].delay = DELAY_DEFAULT;
                         setup[setup_count].ext_trans = 0;
-#if defined(AHA152X_DEBUG)
-                        setup[setup_count].debug = DEBUG_DEFAULT;
-#endif
                         setup_count++;
 
                 }
@@ -3903,11 +3367,8 @@ module_exit(aha152x_exit);
 #if !defined(MODULE)
 static int __init aha152x_setup(char *str)
 {
-#if defined(AHA152X_DEBUG)
-        int ints[11];
-#else
         int ints[10];
-#endif
+
         get_options(str, ARRAY_SIZE(ints), ints);
 
         if(setup_count>=ARRAY_SIZE(setup)) {
@@ -3924,16 +3385,9 @@ static int __init aha152x_setup(char *str)
         setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
         setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
         setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
-#if defined(AHA152X_DEBUG)
-        setup[setup_count].debug       = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
-        if (ints[0] > 9) {
-                printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
-                       "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
-#else
         if (ints[0] > 8) {                                                /*}*/
                 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
                        "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
-#endif
         } else {
                 setup_count++;
                 return 0;
diff --git a/drivers/scsi/aha1740.c b/drivers/scsi/aha1740.c
index 5f3101797c93..31ace4bef8fe 100644
--- a/drivers/scsi/aha1740.c
+++ b/drivers/scsi/aha1740.c
@@ -531,7 +531,7 @@ static int aha1740_eh_abort_handler (Scsi_Cmnd *dummy)
  * quiet as possible...
  */
 
-        return 0;
+        return SUCCESS;
 }
 
 static struct scsi_host_template aha1740_template = {
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index ed333669a7dc..d5c7b193d8d3 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -925,6 +925,7 @@ struct scsi_host_template aic79xx_driver_template = {
         .slave_configure        = ahd_linux_slave_configure,
         .target_alloc           = ahd_linux_target_alloc,
         .target_destroy         = ahd_linux_target_destroy,
+        .use_blk_tags           = 1,
 };
 
 /******************************** Bus DMA *************************************/
@@ -1468,12 +1469,9 @@ ahd_platform_set_tags(struct ahd_softc *ahd, struct scsi_device *sdev,
 
         switch ((dev->flags & (AHD_DEV_Q_BASIC|AHD_DEV_Q_TAGGED))) {
         case AHD_DEV_Q_BASIC:
-                scsi_set_tag_type(sdev, MSG_SIMPLE_TASK);
-                scsi_activate_tcq(sdev, dev->openings + dev->active);
-                break;
         case AHD_DEV_Q_TAGGED:
-                scsi_set_tag_type(sdev, MSG_ORDERED_TASK);
-                scsi_activate_tcq(sdev, dev->openings + dev->active);
+                scsi_change_queue_depth(sdev,
+                                dev->openings + dev->active);
                 break;
         default:
                 /*
@@ -1482,7 +1480,7 @@ ahd_platform_set_tags(struct ahd_softc *ahd, struct scsi_device *sdev,
                  * serially on the controller/device.  This should
                  * remove some latency.
                  */
-                scsi_deactivate_tcq(sdev, 1);
+                scsi_change_queue_depth(sdev, 1);
                 break;
         }
 }
@@ -1619,15 +1617,6 @@ ahd_linux_run_command(struct ahd_softc *ahd, struct ahd_linux_device *dev,
         }
 
         if ((dev->flags & (AHD_DEV_Q_TAGGED|AHD_DEV_Q_BASIC)) != 0) {
-                int     msg_bytes;
-                uint8_t tag_msgs[2];
-
-                msg_bytes = scsi_populate_tag_msg(cmd, tag_msgs);
-                if (msg_bytes && tag_msgs[0] != MSG_SIMPLE_TASK) {
-                        hscb->control |= tag_msgs[0];
-                        if (tag_msgs[0] == MSG_ORDERED_TASK)
-                                dev->commands_since_idle_or_otag = 0;
-                } else
                 if (dev->commands_since_idle_or_otag == AHD_OTAG_THRESH
                  && (dev->flags & AHD_DEV_Q_TAGGED) != 0) {
                         hscb->control |= MSG_ORDERED_TASK;
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index d2c9bf39033d..88360116dbcb 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -812,6 +812,7 @@ struct scsi_host_template aic7xxx_driver_template = {
         .slave_configure        = ahc_linux_slave_configure,
         .target_alloc           = ahc_linux_target_alloc,
         .target_destroy         = ahc_linux_target_destroy,
+        .use_blk_tags           = 1,
 };
 
 /**************************** Tasklet Handler *********************************/
@@ -1334,13 +1335,9 @@ ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev,
         }
         switch ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED))) {
         case AHC_DEV_Q_BASIC:
-                scsi_set_tag_type(sdev, MSG_SIMPLE_TAG);
-                scsi_activate_tcq(sdev, dev->openings + dev->active);
-                break;
         case AHC_DEV_Q_TAGGED:
-                scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
-                scsi_activate_tcq(sdev, dev->openings + dev->active);
-                break;
+                scsi_change_queue_depth(sdev,
+                                dev->openings + dev->active);
         default:
                 /*
                  * We allow the OS to queue 2 untagged transactions to
@@ -1348,7 +1345,7 @@ ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev,
                  * serially on the controller/device.  This should
                  * remove some latency.
                  */
-                scsi_deactivate_tcq(sdev, 2);
+                scsi_change_queue_depth(sdev, 2);
                 break;
         }
 }
@@ -1447,7 +1444,7 @@ ahc_linux_run_command(struct ahc_softc *ahc, struct ahc_linux_device *dev,
          * we are storing a full busy target *lun*
          * table in SCB space.
          */
-        if (!blk_rq_tagged(cmd->request)
+        if (!(cmd->flags & SCMD_TAGGED)
             && (ahc->features & AHC_SCB_BTT) == 0) {
                 int target_offset;
 
@@ -1501,15 +1498,7 @@ ahc_linux_run_command(struct ahc_softc *ahc, struct ahc_linux_device *dev,
         }
 
         if ((dev->flags & (AHC_DEV_Q_TAGGED|AHC_DEV_Q_BASIC)) != 0) {
-                int     msg_bytes;
-                uint8_t tag_msgs[2];
-                
-                msg_bytes = scsi_populate_tag_msg(cmd, tag_msgs);
-                if (msg_bytes && tag_msgs[0] != MSG_SIMPLE_TASK) {
-                        hscb->control |= tag_msgs[0];
-                        if (tag_msgs[0] == MSG_ORDERED_TASK)
-                                dev->commands_since_idle_or_otag = 0;
-                } else if (dev->commands_since_idle_or_otag == AHC_OTAG_THRESH
+                if (dev->commands_since_idle_or_otag == AHC_OTAG_THRESH
                                 && (dev->flags & AHC_DEV_Q_TAGGED) != 0) {
                         hscb->control |= MSG_ORDERED_TASK;
                         dev->commands_since_idle_or_otag = 0;
diff --git a/drivers/scsi/aic94xx/aic94xx.h b/drivers/scsi/aic94xx/aic94xx.h
index 66cda669b417..26d4ad9ede2e 100644
--- a/drivers/scsi/aic94xx/aic94xx.h
+++ b/drivers/scsi/aic94xx/aic94xx.h
@@ -78,7 +78,7 @@ void asd_dev_gone(struct domain_device *dev);
 
 void asd_invalidate_edb(struct asd_ascb *ascb, int edb_id);
 
-int  asd_execute_task(struct sas_task *, int num, gfp_t gfp_flags);
+int  asd_execute_task(struct sas_task *task, gfp_t gfp_flags);
 
 void asd_set_dmamode(struct domain_device *dev);
 
diff --git a/drivers/scsi/aic94xx/aic94xx_hwi.c b/drivers/scsi/aic94xx/aic94xx_hwi.c
index 4df867e07b20..9f636a34d595 100644
--- a/drivers/scsi/aic94xx/aic94xx_hwi.c
+++ b/drivers/scsi/aic94xx/aic94xx_hwi.c
@@ -1200,8 +1200,7 @@ static void asd_start_scb_timers(struct list_head *list)
  * Case A: we can send the whole batch at once.  Increment "pending"
  * in the beginning of this function, when it is checked, in order to
  * eliminate races when this function is called by multiple processes.
- * Case B: should never happen if the managing layer considers
- * lldd_queue_size.
+ * Case B: should never happen.
  */
 int asd_post_ascb_list(struct asd_ha_struct *asd_ha, struct asd_ascb *ascb,
                        int num)
diff --git a/drivers/scsi/aic94xx/aic94xx_init.c b/drivers/scsi/aic94xx/aic94xx_init.c
index c56741fc4b99..14fc018436c2 100644
--- a/drivers/scsi/aic94xx/aic94xx_init.c
+++ b/drivers/scsi/aic94xx/aic94xx_init.c
@@ -49,14 +49,6 @@ MODULE_PARM_DESC(use_msi, "\n"
         "\tEnable(1) or disable(0) using PCI MSI.\n"
         "\tDefault: 0");
 
-static int lldd_max_execute_num = 0;
-module_param_named(collector, lldd_max_execute_num, int, S_IRUGO);
-MODULE_PARM_DESC(collector, "\n"
-        "\tIf greater than one, tells the SAS Layer to run in Task Collector\n"
-        "\tMode.  If 1 or 0, tells the SAS Layer to run in Direct Mode.\n"
-        "\tThe aic94xx SAS LLDD supports both modes.\n"
-        "\tDefault: 0 (Direct Mode).\n");
-
 static struct scsi_transport_template *aic94xx_transport_template;
 static int asd_scan_finished(struct Scsi_Host *, unsigned long);
 static void asd_scan_start(struct Scsi_Host *);
@@ -83,6 +75,8 @@ static struct scsi_host_template aic94xx_sht = {
         .eh_bus_reset_handler   = sas_eh_bus_reset_handler,
         .target_destroy         = sas_target_destroy,
         .ioctl                  = sas_ioctl,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
 
 static int asd_map_memio(struct asd_ha_struct *asd_ha)
@@ -709,9 +703,6 @@ static int asd_register_sas_ha(struct asd_ha_struct *asd_ha)
         asd_ha->sas_ha.sas_port= sas_ports;
         asd_ha->sas_ha.num_phys= ASD_MAX_PHYS;
 
-        asd_ha->sas_ha.lldd_queue_size = asd_ha->seq.can_queue;
-        asd_ha->sas_ha.lldd_max_execute_num = lldd_max_execute_num;
-
         return sas_register_ha(&asd_ha->sas_ha);
 }
 
diff --git a/drivers/scsi/aic94xx/aic94xx_task.c b/drivers/scsi/aic94xx/aic94xx_task.c
index 59b86e260ce9..5ff1ce7ba1f4 100644
--- a/drivers/scsi/aic94xx/aic94xx_task.c
+++ b/drivers/scsi/aic94xx/aic94xx_task.c
@@ -543,8 +543,7 @@ static int asd_can_queue(struct asd_ha_struct *asd_ha, int num)
         return res;
 }
 
-int asd_execute_task(struct sas_task *task, const int num,
-                     gfp_t gfp_flags)
+int asd_execute_task(struct sas_task *task, gfp_t gfp_flags)
 {
         int res = 0;
         LIST_HEAD(alist);
@@ -553,11 +552,11 @@ int asd_execute_task(struct sas_task *task, const int num,
         struct asd_ha_struct *asd_ha = task->dev->port->ha->lldd_ha;
         unsigned long flags;
 
-        res = asd_can_queue(asd_ha, num);
+        res = asd_can_queue(asd_ha, 1);
         if (res)
                 return res;
 
-        res = num;
+        res = 1;
         ascb = asd_ascb_alloc_list(asd_ha, &res, gfp_flags);
         if (res) {
                 res = -ENOMEM;
@@ -568,7 +567,7 @@ int asd_execute_task(struct sas_task *task, const int num,
         list_for_each_entry(a, &alist, list) {
                 a->uldd_task = t;
                 t->lldd_task = a;
-                t = list_entry(t->list.next, struct sas_task, list);
+                break;
         }
         list_for_each_entry(a, &alist, list) {
                 t = a->uldd_task;
@@ -601,7 +600,7 @@ int asd_execute_task(struct sas_task *task, const int num,
         }
         list_del_init(&alist);
 
-        res = asd_post_ascb_list(asd_ha, ascb, num);
+        res = asd_post_ascb_list(asd_ha, ascb, 1);
         if (unlikely(res)) {
                 a = NULL;
                 __list_add(&alist, ascb->list.prev, &ascb->list);
@@ -639,6 +638,6 @@ out_err_unmap:
 out_err:
         if (ascb)
                 asd_ascb_free_list(ascb);
-        asd_can_dequeue(asd_ha, num);
+        asd_can_dequeue(asd_ha, 1);
         return res;
 }
diff --git a/drivers/scsi/am53c974.c b/drivers/scsi/am53c974.c
new file mode 100644
index 000000000000..aa3e2c7cd83c
--- /dev/null
+++ b/drivers/scsi/am53c974.c
@@ -0,0 +1,586 @@
+/*
+ * AMD am53c974 driver.
+ * Copyright (c) 2014 Hannes Reinecke, SUSE Linux GmbH
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+
+#include <scsi/scsi_host.h>
+
+#include "esp_scsi.h"
+
+#define DRV_MODULE_NAME "am53c974"
+#define DRV_MODULE_VERSION "1.00"
+
+static bool am53c974_debug;
+static bool am53c974_fenab = true;
+
+#define esp_dma_log(f, a...)                                            \
+        do {                                                            \
+                if (am53c974_debug)                                     \
+                        shost_printk(KERN_DEBUG, esp->host, f, ##a);    \
+        } while (0)
+
+#define ESP_DMA_CMD 0x10
+#define ESP_DMA_STC 0x11
+#define ESP_DMA_SPA 0x12
+#define ESP_DMA_WBC 0x13
+#define ESP_DMA_WAC 0x14
+#define ESP_DMA_STATUS 0x15
+#define ESP_DMA_SMDLA 0x16
+#define ESP_DMA_WMAC 0x17
+
+#define ESP_DMA_CMD_IDLE 0x00
+#define ESP_DMA_CMD_BLAST 0x01
+#define ESP_DMA_CMD_ABORT 0x02
+#define ESP_DMA_CMD_START 0x03
+#define ESP_DMA_CMD_MASK  0x03
+#define ESP_DMA_CMD_DIAG 0x04
+#define ESP_DMA_CMD_MDL 0x10
+#define ESP_DMA_CMD_INTE_P 0x20
+#define ESP_DMA_CMD_INTE_D 0x40
+#define ESP_DMA_CMD_DIR 0x80
+
+#define ESP_DMA_STAT_PWDN 0x01
+#define ESP_DMA_STAT_ERROR 0x02
+#define ESP_DMA_STAT_ABORT 0x04
+#define ESP_DMA_STAT_DONE 0x08
+#define ESP_DMA_STAT_SCSIINT 0x10
+#define ESP_DMA_STAT_BCMPLT 0x20
+
+/* EEPROM is accessed with 16-bit values */
+#define DC390_EEPROM_READ 0x80
+#define DC390_EEPROM_LEN 0x40
+
+/*
+ * DC390 EEPROM
+ *
+ * 8 * 4 bytes of per-device options
+ * followed by HBA specific options
+ */
+
+/* Per-device options */
+#define DC390_EE_MODE1 0x00
+#define DC390_EE_SPEED 0x01
+
+/* HBA-specific options */
+#define DC390_EE_ADAPT_SCSI_ID 0x40
+#define DC390_EE_MODE2 0x41
+#define DC390_EE_DELAY 0x42
+#define DC390_EE_TAG_CMD_NUM 0x43
+
+#define DC390_EE_MODE1_PARITY_CHK   0x01
+#define DC390_EE_MODE1_SYNC_NEGO    0x02
+#define DC390_EE_MODE1_EN_DISC      0x04
+#define DC390_EE_MODE1_SEND_START   0x08
+#define DC390_EE_MODE1_TCQ          0x10
+
+#define DC390_EE_MODE2_MORE_2DRV    0x01
+#define DC390_EE_MODE2_GREATER_1G   0x02
+#define DC390_EE_MODE2_RST_SCSI_BUS 0x04
+#define DC390_EE_MODE2_ACTIVE_NEGATION 0x08
+#define DC390_EE_MODE2_NO_SEEK      0x10
+#define DC390_EE_MODE2_LUN_CHECK    0x20
+
+struct pci_esp_priv {
+        struct esp *esp;
+        u8 dma_status;
+};
+
+static void pci_esp_dma_drain(struct esp *esp);
+
+static inline struct pci_esp_priv *pci_esp_get_priv(struct esp *esp)
+{
+        struct pci_dev *pdev = esp->dev;
+
+        return pci_get_drvdata(pdev);
+}
+
+static void pci_esp_write8(struct esp *esp, u8 val, unsigned long reg)
+{
+        iowrite8(val, esp->regs + (reg * 4UL));
+}
+
+static u8 pci_esp_read8(struct esp *esp, unsigned long reg)
+{
+        return ioread8(esp->regs + (reg * 4UL));
+}
+
+static void pci_esp_write32(struct esp *esp, u32 val, unsigned long reg)
+{
+        return iowrite32(val, esp->regs + (reg * 4UL));
+}
+
+static dma_addr_t pci_esp_map_single(struct esp *esp, void *buf,
+                                     size_t sz, int dir)
+{
+        return pci_map_single(esp->dev, buf, sz, dir);
+}
+
+static int pci_esp_map_sg(struct esp *esp, struct scatterlist *sg,
+                          int num_sg, int dir)
+{
+        return pci_map_sg(esp->dev, sg, num_sg, dir);
+}
+
+static void pci_esp_unmap_single(struct esp *esp, dma_addr_t addr,
+                                 size_t sz, int dir)
+{
+        pci_unmap_single(esp->dev, addr, sz, dir);
+}
+
+static void pci_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
+                             int num_sg, int dir)
+{
+        pci_unmap_sg(esp->dev, sg, num_sg, dir);
+}
+
+static int pci_esp_irq_pending(struct esp *esp)
+{
+        struct pci_esp_priv *pep = pci_esp_get_priv(esp);
+
+        pep->dma_status = pci_esp_read8(esp, ESP_DMA_STATUS);
+        esp_dma_log("dma intr dreg[%02x]\n", pep->dma_status);
+
+        if (pep->dma_status & (ESP_DMA_STAT_ERROR |
+                               ESP_DMA_STAT_ABORT |
+                               ESP_DMA_STAT_DONE |
+                               ESP_DMA_STAT_SCSIINT))
+                return 1;
+
+        return 0;
+}
+
+static void pci_esp_reset_dma(struct esp *esp)
+{
+        /* Nothing to do ? */
+}
+
+static void pci_esp_dma_drain(struct esp *esp)
+{
+        u8 resid;
+        int lim = 1000;
+
+
+        if ((esp->sreg & ESP_STAT_PMASK) == ESP_DOP ||
+            (esp->sreg & ESP_STAT_PMASK) == ESP_DIP)
+                /* Data-In or Data-Out, nothing to be done */
+                return;
+
+        while (--lim > 0) {
+                resid = pci_esp_read8(esp, ESP_FFLAGS) & ESP_FF_FBYTES;
+                if (resid <= 1)
+                        break;
+                cpu_relax();
+        }
+        if (resid > 1) {
+                /* FIFO not cleared */
+                shost_printk(KERN_INFO, esp->host,
+                             "FIFO not cleared, %d bytes left\n",
+                             resid);
+        }
+
+        /*
+         * When there is a residual BCMPLT will never be set
+         * (obviously). But we still have to issue the BLAST
+         * command, otherwise the data will not being transferred.
+         * But we'll never know when the BLAST operation is
+         * finished. So check for some time and give up eventually.
+         */
+        lim = 1000;
+        pci_esp_write8(esp, ESP_DMA_CMD_DIR | ESP_DMA_CMD_BLAST, ESP_DMA_CMD);
+        while (pci_esp_read8(esp, ESP_DMA_STATUS) & ESP_DMA_STAT_BCMPLT) {
+                if (--lim == 0)
+                        break;
+                cpu_relax();
+        }
+        pci_esp_write8(esp, ESP_DMA_CMD_DIR | ESP_DMA_CMD_IDLE, ESP_DMA_CMD);
+        esp_dma_log("DMA blast done (%d tries, %d bytes left)\n", lim, resid);
+        /* BLAST residual handling is currently untested */
+        if (WARN_ON_ONCE(resid == 1)) {
+                struct esp_cmd_entry *ent = esp->active_cmd;
+
+                ent->flags |= ESP_CMD_FLAG_RESIDUAL;
+        }
+}
+
+static void pci_esp_dma_invalidate(struct esp *esp)
+{
+        struct pci_esp_priv *pep = pci_esp_get_priv(esp);
+
+        esp_dma_log("invalidate DMA\n");
+
+        pci_esp_write8(esp, ESP_DMA_CMD_IDLE, ESP_DMA_CMD);
+        pep->dma_status = 0;
+}
+
+static int pci_esp_dma_error(struct esp *esp)
+{
+        struct pci_esp_priv *pep = pci_esp_get_priv(esp);
+
+        if (pep->dma_status & ESP_DMA_STAT_ERROR) {
+                u8 dma_cmd = pci_esp_read8(esp, ESP_DMA_CMD);
+
+                if ((dma_cmd & ESP_DMA_CMD_MASK) == ESP_DMA_CMD_START)
+                        pci_esp_write8(esp, ESP_DMA_CMD_ABORT, ESP_DMA_CMD);
+
+                return 1;
+        }
+        if (pep->dma_status & ESP_DMA_STAT_ABORT) {
+                pci_esp_write8(esp, ESP_DMA_CMD_IDLE, ESP_DMA_CMD);
+                pep->dma_status = pci_esp_read8(esp, ESP_DMA_CMD);
+                return 1;
+        }
+        return 0;
+}
+
+static void pci_esp_send_dma_cmd(struct esp *esp, u32 addr, u32 esp_count,
+                                 u32 dma_count, int write, u8 cmd)
+{
+        struct pci_esp_priv *pep = pci_esp_get_priv(esp);
+        u32 val = 0;
+
+        BUG_ON(!(cmd & ESP_CMD_DMA));
+
+        pep->dma_status = 0;
+
+        /* Set DMA engine to IDLE */
+        if (write)
+                /* DMA write direction logic is inverted */
+                val |= ESP_DMA_CMD_DIR;
+        pci_esp_write8(esp, ESP_DMA_CMD_IDLE | val, ESP_DMA_CMD);
+
+        pci_esp_write8(esp, (esp_count >> 0) & 0xff, ESP_TCLOW);
+        pci_esp_write8(esp, (esp_count >> 8) & 0xff, ESP_TCMED);
+        if (esp->config2 & ESP_CONFIG2_FENAB)
+                pci_esp_write8(esp, (esp_count >> 16) & 0xff, ESP_TCHI);
+
+        pci_esp_write32(esp, esp_count, ESP_DMA_STC);
+        pci_esp_write32(esp, addr, ESP_DMA_SPA);
+
+        esp_dma_log("start dma addr[%x] count[%d:%d]\n",
+                    addr, esp_count, dma_count);
+
+        scsi_esp_cmd(esp, cmd);
+        /* Send DMA Start command */
+        pci_esp_write8(esp, ESP_DMA_CMD_START | val, ESP_DMA_CMD);
+}
+
+static u32 pci_esp_dma_length_limit(struct esp *esp, u32 dma_addr, u32 dma_len)
+{
+        int dma_limit = 16;
+        u32 base, end;
+
+        /*
+         * If CONFIG2_FENAB is set we can
+         * handle up to 24 bit addresses
+         */
+        if (esp->config2 & ESP_CONFIG2_FENAB)
+                dma_limit = 24;
+
+        if (dma_len > (1U << dma_limit))
+                dma_len = (1U << dma_limit);
+
+        /*
+         * Prevent crossing a 24-bit address boundary.
+         */
+        base = dma_addr & ((1U << 24) - 1U);
+        end = base + dma_len;
+        if (end > (1U << 24))
+                end = (1U <<24);
+        dma_len = end - base;
+
+        return dma_len;
+}
+
+static const struct esp_driver_ops pci_esp_ops = {
+        .esp_write8     =       pci_esp_write8,
+        .esp_read8      =       pci_esp_read8,
+        .map_single     =       pci_esp_map_single,
+        .map_sg         =       pci_esp_map_sg,
+        .unmap_single   =       pci_esp_unmap_single,
+        .unmap_sg       =       pci_esp_unmap_sg,
+        .irq_pending    =       pci_esp_irq_pending,
+        .reset_dma      =       pci_esp_reset_dma,
+        .dma_drain      =       pci_esp_dma_drain,
+        .dma_invalidate =       pci_esp_dma_invalidate,
+        .send_dma_cmd   =       pci_esp_send_dma_cmd,
+        .dma_error      =       pci_esp_dma_error,
+        .dma_length_limit =     pci_esp_dma_length_limit,
+};
+
+/*
+ * Read DC-390 eeprom
+ */
+static void dc390_eeprom_prepare_read(struct pci_dev *pdev, u8 cmd)
+{
+        u8 carry_flag = 1, j = 0x80, bval;
+        int i;
+
+        for (i = 0; i < 9; i++) {
+                if (carry_flag) {
+                        pci_write_config_byte(pdev, 0x80, 0x40);
+                        bval = 0xc0;
+                } else
+                        bval = 0x80;
+
+                udelay(160);
+                pci_write_config_byte(pdev, 0x80, bval);
+                udelay(160);
+                pci_write_config_byte(pdev, 0x80, 0);
+                udelay(160);
+
+                carry_flag = (cmd & j) ? 1 : 0;
+                j >>= 1;
+        }
+}
+
+static u16 dc390_eeprom_get_data(struct pci_dev *pdev)
+{
+        int i;
+        u16 wval = 0;
+        u8 bval;
+
+        for (i = 0; i < 16; i++) {
+                wval <<= 1;
+
+                pci_write_config_byte(pdev, 0x80, 0x80);
+                udelay(160);
+                pci_write_config_byte(pdev, 0x80, 0x40);
+                udelay(160);
+                pci_read_config_byte(pdev, 0x00, &bval);
+
+                if (bval == 0x22)
+                        wval |= 1;
+        }
+
+        return wval;
+}
+
+static void dc390_read_eeprom(struct pci_dev *pdev, u16 *ptr)
+{
+        u8 cmd = DC390_EEPROM_READ, i;
+
+        for (i = 0; i < DC390_EEPROM_LEN; i++) {
+                pci_write_config_byte(pdev, 0xc0, 0);
+                udelay(160);
+
+                dc390_eeprom_prepare_read(pdev, cmd++);
+                *ptr++ = dc390_eeprom_get_data(pdev);
+
+                pci_write_config_byte(pdev, 0x80, 0);
+                pci_write_config_byte(pdev, 0x80, 0);
+                udelay(160);
+        }
+}
+
+static void dc390_check_eeprom(struct esp *esp)
+{
+        u8 EEbuf[128];
+        u16 *ptr = (u16 *)EEbuf, wval = 0;
+        int i;
+
+        dc390_read_eeprom((struct pci_dev *)esp->dev, ptr);
+
+        for (i = 0; i < DC390_EEPROM_LEN; i++, ptr++)
+                wval += *ptr;
+
+        /* no Tekram EEprom found */
+        if (wval != 0x1234) {
+                struct pci_dev *pdev = esp->dev;
+                dev_printk(KERN_INFO, &pdev->dev,
+                           "No valid Tekram EEprom found\n");
+                return;
+        }
+        esp->scsi_id = EEbuf[DC390_EE_ADAPT_SCSI_ID];
+        esp->num_tags = 2 << EEbuf[DC390_EE_TAG_CMD_NUM];
+        if (EEbuf[DC390_EE_MODE2] & DC390_EE_MODE2_ACTIVE_NEGATION)
+                esp->config4 |= ESP_CONFIG4_RADE | ESP_CONFIG4_RAE;
+}
+
+static int pci_esp_probe_one(struct pci_dev *pdev,
+                              const struct pci_device_id *id)
+{
+        struct scsi_host_template *hostt = &scsi_esp_template;
+        int err = -ENODEV;
+        struct Scsi_Host *shost;
+        struct esp *esp;
+        struct pci_esp_priv *pep;
+
+        if (pci_enable_device(pdev)) {
+                dev_printk(KERN_INFO, &pdev->dev, "cannot enable device\n");
+                return -ENODEV;
+        }
+
+        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
+                dev_printk(KERN_INFO, &pdev->dev,
+                           "failed to set 32bit DMA mask\n");
+                goto fail_disable_device;
+        }
+
+        shost = scsi_host_alloc(hostt, sizeof(struct esp));
+        if (!shost) {
+                dev_printk(KERN_INFO, &pdev->dev,
+                           "failed to allocate scsi host\n");
+                err = -ENOMEM;
+                goto fail_disable_device;
+        }
+
+        pep = kzalloc(sizeof(struct pci_esp_priv), GFP_KERNEL);
+        if (!pep) {
+                dev_printk(KERN_INFO, &pdev->dev,
+                           "failed to allocate esp_priv\n");
+                err = -ENOMEM;
+                goto fail_host_alloc;
+        }
+
+        esp = shost_priv(shost);
+        esp->host = shost;
+        esp->dev = pdev;
+        esp->ops = &pci_esp_ops;
+        /*
+         * The am53c974 HBA has a design flaw of generating
+         * spurious DMA completion interrupts when using
+         * DMA for command submission.
+         */
+        esp->flags |= ESP_FLAG_USE_FIFO;
+        /*
+         * Enable CONFIG2_FENAB to allow for large DMA transfers
+         */
+        if (am53c974_fenab)
+                esp->config2 |= ESP_CONFIG2_FENAB;
+
+        pep->esp = esp;
+
+        if (pci_request_regions(pdev, DRV_MODULE_NAME)) {
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "pci memory selection failed\n");
+                goto fail_priv_alloc;
+        }
+
+        esp->regs = pci_iomap(pdev, 0, pci_resource_len(pdev, 0));
+        if (!esp->regs) {
+                dev_printk(KERN_ERR, &pdev->dev, "pci I/O map failed\n");
+                err = -EINVAL;
+                goto fail_release_regions;
+        }
+        esp->dma_regs = esp->regs;
+
+        pci_set_master(pdev);
+
+        esp->command_block = pci_alloc_consistent(pdev, 16,
+                                                  &esp->command_block_dma);
+        if (!esp->command_block) {
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "failed to allocate command block\n");
+                err = -ENOMEM;
+                goto fail_unmap_regs;
+        }
+
+        err = request_irq(pdev->irq, scsi_esp_intr, IRQF_SHARED,
+                          DRV_MODULE_NAME, esp);
+        if (err < 0) {
+                dev_printk(KERN_ERR, &pdev->dev, "failed to register IRQ\n");
+                goto fail_unmap_command_block;
+        }
+
+        esp->scsi_id = 7;
+        dc390_check_eeprom(esp);
+
+        shost->this_id = esp->scsi_id;
+        shost->max_id = 8;
+        shost->irq = pdev->irq;
+        shost->io_port = pci_resource_start(pdev, 0);
+        shost->n_io_port = pci_resource_len(pdev, 0);
+        shost->unique_id = shost->io_port;
+        esp->scsi_id_mask = (1 << esp->scsi_id);
+        /* Assume 40MHz clock */
+        esp->cfreq = 40000000;
+
+        pci_set_drvdata(pdev, pep);
+
+        err = scsi_esp_register(esp, &pdev->dev);
+        if (err)
+                goto fail_free_irq;
+
+        return 0;
+
+fail_free_irq:
+        free_irq(pdev->irq, esp);
+fail_unmap_command_block:
+        pci_free_consistent(pdev, 16, esp->command_block,
+                            esp->command_block_dma);
+fail_unmap_regs:
+        pci_iounmap(pdev, esp->regs);
+fail_release_regions:
+        pci_release_regions(pdev);
+fail_priv_alloc:
+        kfree(pep);
+fail_host_alloc:
+        scsi_host_put(shost);
+fail_disable_device:
+        pci_disable_device(pdev);
+
+        return err;
+}
+
+static void pci_esp_remove_one(struct pci_dev *pdev)
+{
+        struct pci_esp_priv *pep = pci_get_drvdata(pdev);
+        struct esp *esp = pep->esp;
+
+        scsi_esp_unregister(esp);
+        free_irq(pdev->irq, esp);
+        pci_free_consistent(pdev, 16, esp->command_block,
+                            esp->command_block_dma);
+        pci_iounmap(pdev, esp->regs);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+        kfree(pep);
+
+        scsi_host_put(esp->host);
+}
+
+static struct pci_device_id am53c974_pci_tbl[] = {
+        { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_SCSI,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, am53c974_pci_tbl);
+
+static struct pci_driver am53c974_driver = {
+        .name           = DRV_MODULE_NAME,
+        .id_table       = am53c974_pci_tbl,
+        .probe          = pci_esp_probe_one,
+        .remove         = pci_esp_remove_one,
+};
+
+static int __init am53c974_module_init(void)
+{
+        return pci_register_driver(&am53c974_driver);
+}
+
+static void __exit am53c974_module_exit(void)
+{
+        pci_unregister_driver(&am53c974_driver);
+}
+
+MODULE_DESCRIPTION("AM53C974 SCSI driver");
+MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_MODULE_VERSION);
+MODULE_ALIAS("tmscsim");
+
+module_param(am53c974_debug, bool, 0644);
+MODULE_PARM_DESC(am53c974_debug, "Enable debugging");
+
+module_param(am53c974_fenab, bool, 0444);
+MODULE_PARM_DESC(am53c974_fenab, "Enable 24-bit DMA transfer sizes");
+
+module_init(am53c974_module_init);
+module_exit(am53c974_module_exit);
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 0b44fb5ee485..914c39f9f388 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -114,16 +114,11 @@ static void arcmsr_hardware_reset(struct AdapterControlBlock *acb);
 static const char *arcmsr_info(struct Scsi_Host *);
 static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb);
 static void arcmsr_free_irq(struct pci_dev *, struct AdapterControlBlock *);
-static int arcmsr_adjust_disk_queue_depth(struct scsi_device *sdev,
-                                          int queue_depth, int reason)
+static int arcmsr_adjust_disk_queue_depth(struct scsi_device *sdev, int queue_depth)
 {
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (queue_depth > ARCMSR_MAX_CMD_PERLUN)
                 queue_depth = ARCMSR_MAX_CMD_PERLUN;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
-        return queue_depth;
+        return scsi_change_queue_depth(sdev, queue_depth);
 }
 
 static struct scsi_host_template arcmsr_scsi_host_template = {
diff --git a/drivers/scsi/arm/acornscsi.c b/drivers/scsi/arm/acornscsi.c
index d89b9b4deb3c..deaaf84989cd 100644
--- a/drivers/scsi/arm/acornscsi.c
+++ b/drivers/scsi/arm/acornscsi.c
@@ -850,13 +850,13 @@ static void acornscsi_done(AS_Host *host, struct scsi_cmnd **SCpntp,
                         break;
 
                     default:
-                        printk(KERN_ERR "scsi%d.H: incomplete data transfer detected: result=%08X command=",
-                                host->host->host_no, SCpnt->result);
-                        __scsi_print_command(SCpnt->cmnd);
+                        scmd_printk(KERN_ERR, SCpnt,
+                                    "incomplete data transfer detected: "
+                                    "result=%08X", SCpnt->result);
+                        scsi_print_command(SCpnt);
                         acornscsi_dumpdma(host, "done");
-                        acornscsi_dumplog(host, SCpnt->device->id);
-                        SCpnt->result &= 0xffff;
-                        SCpnt->result |= DID_ERROR << 16;
+                        acornscsi_dumplog(host, SCpnt->device->id);
+                        set_host_byte(SCpnt, DID_ERROR);
                     }
                 }
         }
diff --git a/drivers/scsi/arm/cumana_1.c b/drivers/scsi/arm/cumana_1.c
index 8ef810a4476e..d28d6c0f18c0 100644
--- a/drivers/scsi/arm/cumana_1.c
+++ b/drivers/scsi/arm/cumana_1.c
@@ -13,16 +13,12 @@
 #include <asm/ecard.h>
 #include <asm/io.h>
 
-#include "../scsi.h"
 #include <scsi/scsi_host.h>
 
 #include <scsi/scsicam.h>
 
-#define AUTOSENSE
 #define PSEUDO_DMA
 
-#define CUMANASCSI_PUBLIC_RELEASE 1
-
 #define priv(host)                      ((struct NCR5380_hostdata *)(host)->hostdata)
 #define NCR5380_local_declare()         struct Scsi_Host *_instance
 #define NCR5380_setup(instance)         _instance = instance
@@ -30,6 +26,7 @@
 #define NCR5380_write(reg, value)       cumanascsi_write(_instance, reg, value)
 #define NCR5380_intr                    cumanascsi_intr
 #define NCR5380_queue_command           cumanascsi_queue_command
+#define NCR5380_info                    cumanascsi_info
 
 #define NCR5380_implementation_fields   \
         unsigned ctrl;                  \
@@ -42,11 +39,6 @@ void cumanascsi_setup(char *str, int *ints)
 {
 }
 
-const char *cumanascsi_info(struct Scsi_Host *spnt)
-{
-        return "";
-}
-
 #define CTRL    0x16fc
 #define STAT    0x2004
 #define L(v)    (((v)<<16)|((v) & 0x0000ffff))
@@ -267,14 +259,6 @@ static int cumanascsi1_probe(struct expansion_card *ec,
                 goto out_unmap;
         }
 
-        printk("scsi%d: at port 0x%08lx irq %d",
-                host->host_no, host->io_port, host->irq);
-        printk(" options CAN_QUEUE=%d CMD_PER_LUN=%d release=%d",
-                host->can_queue, host->cmd_per_lun, CUMANASCSI_PUBLIC_RELEASE);
-        printk("\nscsi%d:", host->host_no);
-        NCR5380_print_options(host);
-        printk("\n");
-
         ret = scsi_add_host(host, &ec->dev);
         if (ret)
                 goto out_free_irq;
diff --git a/drivers/scsi/arm/fas216.c b/drivers/scsi/arm/fas216.c
index 71cfb1e504c4..e64c3af7c1a0 100644
--- a/drivers/scsi/arm/fas216.c
+++ b/drivers/scsi/arm/fas216.c
@@ -308,8 +308,7 @@ static void fas216_log_command(FAS216_Info *info, int level,
         fas216_do_log(info, '0' + SCpnt->device->id, fmt, args);
         va_end(args);
 
-        printk(" CDB: ");
-        __scsi_print_command(SCpnt->cmnd);
+        scsi_print_command(SCpnt);
 }
 
 static void
@@ -2079,14 +2078,12 @@ fas216_std_done(FAS216_Info *info, struct scsi_cmnd *SCpnt, unsigned int result)
                         break;
 
                 default:
-                        printk(KERN_ERR "scsi%d.%c: incomplete data transfer "
-                                "detected: res=%08X ptr=%p len=%X CDB: ",
-                                info->host->host_no, '0' + SCpnt->device->id,
-                                SCpnt->result, info->scsi.SCp.ptr,
-                                info->scsi.SCp.this_residual);
-                        __scsi_print_command(SCpnt->cmnd);
-                        SCpnt->result &= ~(255 << 16);
-                        SCpnt->result |= DID_BAD_TARGET << 16;
+                        scmd_printk(KERN_ERR, SCpnt,
+                                    "incomplete data transfer detected: res=%08X ptr=%p len=%X\n",
+                                    SCpnt->result, info->scsi.SCp.ptr,
+                                    info->scsi.SCp.this_residual);
+                        scsi_print_command(SCpnt);
+                        set_host_byte(SCpnt, DID_ERROR);
                         goto request_sense;
                 }
         }
@@ -2158,12 +2155,11 @@ static void fas216_done(FAS216_Info *info, unsigned int result)
          * to transfer, we should not have a valid pointer.
          */
         if (info->scsi.SCp.ptr && info->scsi.SCp.this_residual == 0) {
-                printk("scsi%d.%c: zero bytes left to transfer, but "
-                       "buffer pointer still valid: ptr=%p len=%08x CDB: ",
-                       info->host->host_no, '0' + SCpnt->device->id,
-                       info->scsi.SCp.ptr, info->scsi.SCp.this_residual);
+                scmd_printk(KERN_INFO, SCpnt,
+                            "zero bytes left to transfer, but buffer pointer still valid: ptr=%p len=%08x\n",
+                            info->scsi.SCp.ptr, info->scsi.SCp.this_residual);
                 info->scsi.SCp.ptr = NULL;
-                __scsi_print_command(SCpnt->cmnd);
+                scsi_print_command(SCpnt);
         }
 
         /*
@@ -2427,14 +2423,11 @@ int fas216_eh_abort(struct scsi_cmnd *SCpnt)
 
         info->stats.aborts += 1;
 
-        printk(KERN_WARNING "scsi%d: abort command ", info->host->host_no);
-        __scsi_print_command(SCpnt->cmnd);
+        scmd_printk(KERN_WARNING, SCpnt, "abort command\n");
 
         print_debug_list();
         fas216_dumpstate(info);
 
-        printk(KERN_WARNING "scsi%d: abort %p ", info->host->host_no, SCpnt);
-
         switch (fas216_find_command(info, SCpnt)) {
         /*
          * We found the command, and cleared it out.  Either
@@ -2442,7 +2435,7 @@ int fas216_eh_abort(struct scsi_cmnd *SCpnt)
          * target, or the busylun bit is not set.
          */
         case res_success:
-                printk("success\n");
+                scmd_printk(KERN_WARNING, SCpnt, "abort %p success\n", SCpnt);
                 result = SUCCESS;
                 break;
 
@@ -2452,14 +2445,13 @@ int fas216_eh_abort(struct scsi_cmnd *SCpnt)
          * if the bus is free.
          */
         case res_hw_abort:
-                
 
         /*
          * We are unable to abort the command for some reason.
          */
         default:
         case res_failed:
-                printk("failed\n");
+                scmd_printk(KERN_WARNING, SCpnt, "abort %p failed\n", SCpnt);
                 break;
         }
 
@@ -2664,8 +2656,7 @@ int fas216_eh_host_reset(struct scsi_cmnd *SCpnt)
 
         fas216_checkmagic(info);
 
-        printk("scsi%d.%c: %s: resetting host\n",
-                info->host->host_no, '0' + SCpnt->device->id, __func__);
+        fas216_log(info, LOG_ERROR, "resetting host");
 
         /*
          * Reset the SCSI chip.
diff --git a/drivers/scsi/arm/oak.c b/drivers/scsi/arm/oak.c
index 188e734c7ff0..7c6fa1479c9c 100644
--- a/drivers/scsi/arm/oak.c
+++ b/drivers/scsi/arm/oak.c
@@ -14,13 +14,9 @@
 #include <asm/ecard.h>
 #include <asm/io.h>
 
-#include "../scsi.h"
 #include <scsi/scsi_host.h>
 
-#define AUTOSENSE
 /*#define PSEUDO_DMA*/
-
-#define OAKSCSI_PUBLIC_RELEASE 1
 #define DONT_USE_INTR
 
 #define priv(host)                      ((struct NCR5380_hostdata *)(host)->hostdata)
@@ -29,10 +25,9 @@
 
 #define NCR5380_read(reg)               readb(_base + ((reg) << 2))
 #define NCR5380_write(reg, value)       writeb(value, _base + ((reg) << 2))
-#define NCR5380_intr                    oakscsi_intr
 #define NCR5380_queue_command           oakscsi_queue_command
+#define NCR5380_info                    oakscsi_info
 #define NCR5380_show_info               oakscsi_show_info
-#define NCR5380_write_info              oakscsi_write_info
 
 #define NCR5380_implementation_fields   \
         void __iomem *base
@@ -42,11 +37,6 @@
 #undef START_DMA_INITIATOR_RECEIVE_REG
 #define START_DMA_INITIATOR_RECEIVE_REG (128 + 7)
 
-const char * oakscsi_info (struct Scsi_Host *spnt)
-{
-        return "";
-}
-
 #define STAT    ((128 + 16) << 2)
 #define DATA    ((128 + 8) << 2)
 
@@ -114,7 +104,6 @@ printk("reading %p len %d\n", addr, len);
 static struct scsi_host_template oakscsi_template = {
         .module                 = THIS_MODULE,
         .show_info              = oakscsi_show_info,
-        .write_info             = oakscsi_write_info,
         .name                   = "Oak 16-bit SCSI",
         .info                   = oakscsi_info,
         .queuecommand           = oakscsi_queue_command,
@@ -150,19 +139,11 @@ static int oakscsi_probe(struct expansion_card *ec, const struct ecard_id *id)
                 goto unreg;
         }
 
-        host->irq = IRQ_NONE;
+        host->irq = NO_IRQ;
         host->n_io_port = 255;
 
         NCR5380_init(host, 0);
 
-        printk("scsi%d: at port 0x%08lx irqs disabled",
-                host->host_no, host->io_port);
-        printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d",
-                host->can_queue, host->cmd_per_lun, OAKSCSI_PUBLIC_RELEASE);
-        printk("\nscsi%d:", host->host_no);
-        NCR5380_print_options(host);
-        printk("\n");
-
         ret = scsi_add_host(host, &ec->dev);
         if (ret)
                 goto out_unmap;
diff --git a/drivers/scsi/atari_NCR5380.c b/drivers/scsi/atari_NCR5380.c
index 79e6f045c2a9..6daed6b386d4 100644
--- a/drivers/scsi/atari_NCR5380.c
+++ b/drivers/scsi/atari_NCR5380.c
@@ -11,8 +11,6 @@
  *      drew@colorado.edu
  *      +1 (303) 666-5836
  *
- * DISTRIBUTION RELEASE 6.
- *
  * For more information, please consult
  *
  * NCR 5380 Family
@@ -73,6 +71,9 @@
  * 1.  Test linked command handling code after Eric is ready with
  *     the high level code.
  */
+
+/* Adapted for the sun3 by Sam Creasey. */
+
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_transport_spi.h>
 
@@ -103,27 +104,7 @@
 
 /*
  * Design
- * Issues :
- *
- * The other Linux SCSI drivers were written when Linux was Intel PC-only,
- * and specifically for each board rather than each chip.  This makes their
- * adaptation to platforms like the Mac (Some of which use NCR5380's)
- * more difficult than it has to be.
  *
- * Also, many of the SCSI drivers were written before the command queuing
- * routines were implemented, meaning their implementations of queued
- * commands were hacked on rather than designed in from the start.
- *
- * When I designed the Linux SCSI drivers I figured that
- * while having two different SCSI boards in a system might be useful
- * for debugging things, two of the same type wouldn't be used.
- * Well, I was wrong and a number of users have mailed me about running
- * multiple high-performance SCSI boards in a server.
- *
- * Finally, when I get questions from users, I have no idea what
- * revision of my driver they are running.
- *
- * This driver attempts to address these problems :
  * This is a generic 5380 driver.  To use it on a different platform,
  * one simply writes appropriate system specific macros (ie, data
  * transfer - some PC's will use the I/O bus, 68K's must use
@@ -138,17 +119,6 @@
  * allowing multiple commands to propagate all the way to a SCSI-II device
  * while a command is already executing.
  *
- * To solve the multiple-boards-in-the-same-system problem,
- * there is a separate instance structure for each instance
- * of a 5380 in the system.  So, multiple NCR5380 drivers will
- * be able to coexist with appropriate changes to the high level
- * SCSI code.
- *
- * A NCR5380_PUBLIC_REVISION macro is provided, with the release
- * number (updated for each public release) printed by the
- * NCR5380_print_options command, which should be called from the
- * wrapper detect function, so that I know what release of the driver
- * users are using.
  *
  * Issues specific to the NCR5380 :
  *
@@ -173,19 +143,17 @@
  * Architecture :
  *
  * At the heart of the design is a coroutine, NCR5380_main,
- * which is started when not running by the interrupt handler,
- * timer, and queue command function.  It attempts to establish
- * I_T_L or I_T_L_Q nexuses by removing the commands from the
- * issue queue and calling NCR5380_select() if a nexus
- * is not established.
+ * which is started from a workqueue for each NCR5380 host in the
+ * system.  It attempts to establish I_T_L or I_T_L_Q nexuses by
+ * removing the commands from the issue queue and calling
+ * NCR5380_select() if a nexus is not established.
  *
  * Once a nexus is established, the NCR5380_information_transfer()
  * phase goes through the various phases as instructed by the target.
  * if the target goes into MSG IN and sends a DISCONNECT message,
  * the command structure is placed into the per instance disconnected
- * queue, and NCR5380_main tries to find more work.  If USLEEP
- * was defined, and the target is idle for too long, the system
- * will try to sleep.
+ * queue, and NCR5380_main tries to find more work.  If the target is
+ * idle for too long, the system will try to sleep.
  *
  * If a command has disconnected, eventually an interrupt will trigger,
  * calling NCR5380_intr()  which will in turn call NCR5380_reselect
@@ -211,6 +179,9 @@
  * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
  *      for commands that return with a CHECK CONDITION status.
  *
+ * DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
+ *      transceivers.
+ *
  * LINKED - if defined, linked commands are supported.
  *
  * REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
@@ -223,6 +194,9 @@
  *
  * NCR5380_write(register, value) - write to the specific register
  *
+ * NCR5380_implementation_fields  - additional fields needed for this
+ *      specific implementation of the NCR5380
+ *
  * Either real DMA *or* pseudo DMA may be implemented
  * REAL functions :
  * NCR5380_REAL_DMA should be defined if real DMA is to be used.
@@ -241,40 +215,21 @@
  * NCR5380_pwrite(instance, src, count)
  * NCR5380_pread(instance, dst, count);
  *
- * If nothing specific to this implementation needs doing (ie, with external
- * hardware), you must also define
- *
- * NCR5380_queue_command
- * NCR5380_reset
- * NCR5380_abort
- * NCR5380_proc_info
- *
- * to be the global entry points into the specific driver, ie
- * #define NCR5380_queue_command t128_queue_command.
- *
- * If this is not done, the routines will be defined as static functions
- * with the NCR5380* names and the user must provide a globally
- * accessible wrapper function.
- *
  * The generic driver is initialized by calling NCR5380_init(instance),
  * after setting the appropriate host specific fields and ID.  If the
  * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
- * possible) function may be used.  Before the specific driver initialization
- * code finishes, NCR5380_print_options should be called.
+ * possible) function may be used.
  */
 
-static struct Scsi_Host *first_instance = NULL;
-static struct scsi_host_template *the_template = NULL;
-
 /* Macros ease life... :-) */
 #define SETUP_HOSTDATA(in)                              \
     struct NCR5380_hostdata *hostdata =                 \
         (struct NCR5380_hostdata *)(in)->hostdata
 #define HOSTDATA(in) ((struct NCR5380_hostdata *)(in)->hostdata)
 
-#define NEXT(cmd)               ((Scsi_Cmnd *)(cmd)->host_scribble)
+#define NEXT(cmd)               ((struct scsi_cmnd *)(cmd)->host_scribble)
 #define SET_NEXT(cmd,next)      ((cmd)->host_scribble = (void *)(next))
-#define NEXTADDR(cmd)           ((Scsi_Cmnd **)&(cmd)->host_scribble)
+#define NEXTADDR(cmd)           ((struct scsi_cmnd **)&(cmd)->host_scribble)
 
 #define HOSTNO          instance->host_no
 #define H_NO(cmd)       (cmd)->device->host->host_no
@@ -316,30 +271,17 @@ static struct scsi_host_template *the_template = NULL;
  * important: the tag bit must be cleared before 'nr_allocated' is decreased.
  */
 
-/* -1 for TAG_NONE is not possible with unsigned char cmd->tag */
-#undef TAG_NONE
-#define TAG_NONE 0xff
-
-typedef struct {
-        DECLARE_BITMAP(allocated, MAX_TAGS);
-        int nr_allocated;
-        int queue_size;
-} TAG_ALLOC;
-
-static TAG_ALLOC TagAlloc[8][8];        /* 8 targets and 8 LUNs */
-
-
-static void __init init_tags(void)
+static void __init init_tags(struct NCR5380_hostdata *hostdata)
 {
         int target, lun;
-        TAG_ALLOC *ta;
+        struct tag_alloc *ta;
 
-        if (!setup_use_tagged_queuing)
+        if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
                 return;
 
         for (target = 0; target < 8; ++target) {
                 for (lun = 0; lun < 8; ++lun) {
-                        ta = &TagAlloc[target][lun];
+                        ta = &hostdata->TagAlloc[target][lun];
                         bitmap_zero(ta->allocated, MAX_TAGS);
                         ta->nr_allocated = 0;
                         /* At the beginning, assume the maximum queue size we could
@@ -359,7 +301,7 @@ static void __init init_tags(void)
  * conditions.
  */
 
-static int is_lun_busy(Scsi_Cmnd *cmd, int should_be_tagged)
+static int is_lun_busy(struct scsi_cmnd *cmd, int should_be_tagged)
 {
         u8 lun = cmd->device->lun;
         SETUP_HOSTDATA(cmd->device->host);
@@ -367,10 +309,11 @@ static int is_lun_busy(Scsi_Cmnd *cmd, int should_be_tagged)
         if (hostdata->busy[cmd->device->id] & (1 << lun))
                 return 1;
         if (!should_be_tagged ||
-            !setup_use_tagged_queuing || !cmd->device->tagged_supported)
+            !(hostdata->flags & FLAG_TAGGED_QUEUING) ||
+            !cmd->device->tagged_supported)
                 return 0;
-        if (TagAlloc[cmd->device->id][lun].nr_allocated >=
-            TagAlloc[cmd->device->id][lun].queue_size) {
+        if (hostdata->TagAlloc[scmd_id(cmd)][lun].nr_allocated >=
+            hostdata->TagAlloc[scmd_id(cmd)][lun].queue_size) {
                 dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %d: no free tags\n",
                            H_NO(cmd), cmd->device->id, lun);
                 return 1;
@@ -384,7 +327,7 @@ static int is_lun_busy(Scsi_Cmnd *cmd, int should_be_tagged)
  * untagged.
  */
 
-static void cmd_get_tag(Scsi_Cmnd *cmd, int should_be_tagged)
+static void cmd_get_tag(struct scsi_cmnd *cmd, int should_be_tagged)
 {
         u8 lun = cmd->device->lun;
         SETUP_HOSTDATA(cmd->device->host);
@@ -393,13 +336,14 @@ static void cmd_get_tag(Scsi_Cmnd *cmd, int should_be_tagged)
          * an untagged command.
          */
         if (!should_be_tagged ||
-            !setup_use_tagged_queuing || !cmd->device->tagged_supported) {
+            !(hostdata->flags & FLAG_TAGGED_QUEUING) ||
+            !cmd->device->tagged_supported) {
                 cmd->tag = TAG_NONE;
                 hostdata->busy[cmd->device->id] |= (1 << lun);
                 dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %d now allocated by untagged "
                            "command\n", H_NO(cmd), cmd->device->id, lun);
         } else {
-                TAG_ALLOC *ta = &TagAlloc[cmd->device->id][lun];
+                struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
 
                 cmd->tag = find_first_zero_bit(ta->allocated, MAX_TAGS);
                 set_bit(cmd->tag, ta->allocated);
@@ -416,7 +360,7 @@ static void cmd_get_tag(Scsi_Cmnd *cmd, int should_be_tagged)
  * unlock the LUN.
  */
 
-static void cmd_free_tag(Scsi_Cmnd *cmd)
+static void cmd_free_tag(struct scsi_cmnd *cmd)
 {
         u8 lun = cmd->device->lun;
         SETUP_HOSTDATA(cmd->device->host);
@@ -429,7 +373,7 @@ static void cmd_free_tag(Scsi_Cmnd *cmd)
                 printk(KERN_NOTICE "scsi%d: trying to free bad tag %d!\n",
                        H_NO(cmd), cmd->tag);
         } else {
-                TAG_ALLOC *ta = &TagAlloc[cmd->device->id][lun];
+                struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
                 clear_bit(cmd->tag, ta->allocated);
                 ta->nr_allocated--;
                 dprintk(NDEBUG_TAGS, "scsi%d: freed tag %d for target %d lun %d\n",
@@ -438,17 +382,17 @@ static void cmd_free_tag(Scsi_Cmnd *cmd)
 }
 
 
-static void free_all_tags(void)
+static void free_all_tags(struct NCR5380_hostdata *hostdata)
 {
         int target, lun;
-        TAG_ALLOC *ta;
+        struct tag_alloc *ta;
 
-        if (!setup_use_tagged_queuing)
+        if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
                 return;
 
         for (target = 0; target < 8; ++target) {
                 for (lun = 0; lun < 8; ++lun) {
-                        ta = &TagAlloc[target][lun];
+                        ta = &hostdata->TagAlloc[target][lun];
                         bitmap_zero(ta->allocated, MAX_TAGS);
                         ta->nr_allocated = 0;
                 }
@@ -459,19 +403,20 @@ static void free_all_tags(void)
 
 
 /*
- * Function: void merge_contiguous_buffers( Scsi_Cmnd *cmd )
+ * Function: void merge_contiguous_buffers( struct scsi_cmnd *cmd )
  *
  * Purpose: Try to merge several scatter-gather requests into one DMA
  *    transfer. This is possible if the scatter buffers lie on
  *    physical contiguous addresses.
  *
- * Parameters: Scsi_Cmnd *cmd
+ * Parameters: struct scsi_cmnd *cmd
  *    The command to work on. The first scatter buffer's data are
  *    assumed to be already transferred into ptr/this_residual.
  */
 
-static void merge_contiguous_buffers(Scsi_Cmnd *cmd)
+static void merge_contiguous_buffers(struct scsi_cmnd *cmd)
 {
+#if !defined(CONFIG_SUN3)
         unsigned long endaddr;
 #if (NDEBUG & NDEBUG_MERGING)
         unsigned long oldlen = cmd->SCp.this_residual;
@@ -496,18 +441,17 @@ static void merge_contiguous_buffers(Scsi_Cmnd *cmd)
                 dprintk(NDEBUG_MERGING, "merged %d buffers from %p, new length %08x\n",
                            cnt, cmd->SCp.ptr, cmd->SCp.this_residual);
 #endif
+#endif /* !defined(CONFIG_SUN3) */
 }
 
-/*
- * Function : void initialize_SCp(Scsi_Cmnd *cmd)
+/**
+ * initialize_SCp - init the scsi pointer field
+ * @cmd: command block to set up
  *
- * Purpose : initialize the saved data pointers for cmd to point to the
- *      start of the buffer.
- *
- * Inputs : cmd - Scsi_Cmnd structure to have pointers reset.
+ * Set up the internal fields in the SCSI command.
  */
 
-static inline void initialize_SCp(Scsi_Cmnd *cmd)
+static inline void initialize_SCp(struct scsi_cmnd *cmd)
 {
         /*
          * Initialize the Scsi Pointer field so that all of the commands in the
@@ -557,12 +501,11 @@ static struct {
         {0, NULL}
 };
 
-/*
- * Function : void NCR5380_print(struct Scsi_Host *instance)
+/**
+ * NCR5380_print - print scsi bus signals
+ * @instance: adapter state to dump
  *
- * Purpose : print the SCSI bus signals for debugging purposes
- *
- * Input : instance - which NCR5380
+ * Print the SCSI bus signals for debugging purposes
  */
 
 static void NCR5380_print(struct Scsi_Host *instance)
@@ -605,12 +548,13 @@ static struct {
         {PHASE_UNKNOWN, "UNKNOWN"}
 };
 
-/*
- * Function : void NCR5380_print_phase(struct Scsi_Host *instance)
+/**
+ * NCR5380_print_phase - show SCSI phase
+ * @instance: adapter to dump
  *
- * Purpose : print the current SCSI phase for debugging purposes
+ * Print the current SCSI phase for debugging purposes
  *
- * Input : instance - which NCR5380
+ * Locks: none
  */
 
 static void NCR5380_print_phase(struct Scsi_Host *instance)
@@ -648,71 +592,75 @@ static void NCR5380_print_phase(struct Scsi_Host *instance)
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 
-static volatile int main_running;
-static DECLARE_WORK(NCR5380_tqueue, NCR5380_main);
-
-static inline void queue_main(void)
+static inline void queue_main(struct NCR5380_hostdata *hostdata)
 {
-        if (!main_running) {
+        if (!hostdata->main_running) {
                 /* If in interrupt and NCR5380_main() not already running,
                    queue it on the 'immediate' task queue, to be processed
                    immediately after the current interrupt processing has
                    finished. */
-                schedule_work(&NCR5380_tqueue);
+                schedule_work(&hostdata->main_task);
         }
         /* else: nothing to do: the running NCR5380_main() will pick up
            any newly queued command. */
 }
 
-
-static inline void NCR5380_all_init(void)
-{
-        static int done = 0;
-        if (!done) {
-                dprintk(NDEBUG_INIT, "scsi : NCR5380_all_init()\n");
-                done = 1;
-        }
-}
-
-
-/*
- * Function : void NCR58380_print_options (struct Scsi_Host *instance)
+/**
+ * NCR58380_info - report driver and host information
+ * @instance: relevant scsi host instance
  *
- * Purpose : called by probe code indicating the NCR5380 driver
- *           options that were selected.
+ * For use as the host template info() handler.
  *
- * Inputs : instance, pointer to this instance.  Unused.
+ * Locks: none
  */
 
-static void __init NCR5380_print_options(struct Scsi_Host *instance)
+static const char *NCR5380_info(struct Scsi_Host *instance)
+{
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+
+        return hostdata->info;
+}
+
+static void prepare_info(struct Scsi_Host *instance)
 {
-        printk(" generic options"
-#ifdef AUTOSENSE
-               " AUTOSENSE"
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+
+        snprintf(hostdata->info, sizeof(hostdata->info),
+                 "%s, io_port 0x%lx, n_io_port %d, "
+                 "base 0x%lx, irq %d, "
+                 "can_queue %d, cmd_per_lun %d, "
+                 "sg_tablesize %d, this_id %d, "
+                 "flags { %s}, "
+                 "options { %s} ",
+                 instance->hostt->name, instance->io_port, instance->n_io_port,
+                 instance->base, instance->irq,
+                 instance->can_queue, instance->cmd_per_lun,
+                 instance->sg_tablesize, instance->this_id,
+                 hostdata->flags & FLAG_TAGGED_QUEUING ? "TAGGED_QUEUING " : "",
+#ifdef DIFFERENTIAL
+                 "DIFFERENTIAL "
 #endif
 #ifdef REAL_DMA
-               " REAL DMA"
+                 "REAL_DMA "
 #endif
 #ifdef PARITY
-               " PARITY"
+                 "PARITY "
 #endif
 #ifdef SUPPORT_TAGS
-               " SCSI-2 TAGGED QUEUING"
+                 "SUPPORT_TAGS "
 #endif
-               );
-        printk(" generic release=%d", NCR5380_PUBLIC_RELEASE);
+                 "");
 }
 
-/*
- * Function : void NCR5380_print_status (struct Scsi_Host *instance)
+/**
+ * NCR5380_print_status - dump controller info
+ * @instance: controller to dump
  *
- * Purpose : print commands in the various queues, called from
- *      NCR5380_abort and NCR5380_debug to aid debugging.
- *
- * Inputs : instance, pointer to this instance.
+ * Print commands in the various queues, called from NCR5380_abort
+ * to aid debugging.
  */
 
-static void lprint_Scsi_Cmnd(Scsi_Cmnd *cmd)
+static void lprint_Scsi_Cmnd(struct scsi_cmnd *cmd)
 {
         int i, s;
         unsigned char *command;
@@ -729,7 +677,7 @@ static void lprint_Scsi_Cmnd(Scsi_Cmnd *cmd)
 static void NCR5380_print_status(struct Scsi_Host *instance)
 {
         struct NCR5380_hostdata *hostdata;
-        Scsi_Cmnd *ptr;
+        struct scsi_cmnd *ptr;
         unsigned long flags;
 
         NCR5380_dprint(NDEBUG_ANY, instance);
@@ -737,20 +685,19 @@ static void NCR5380_print_status(struct Scsi_Host *instance)
 
         hostdata = (struct NCR5380_hostdata *)instance->hostdata;
 
-        printk("\nNCR5380 core release=%d.\n", NCR5380_PUBLIC_RELEASE);
         local_irq_save(flags);
         printk("NCR5380: coroutine is%s running.\n",
-                main_running ? "" : "n't");
+                hostdata->main_running ? "" : "n't");
         if (!hostdata->connected)
                 printk("scsi%d: no currently connected command\n", HOSTNO);
         else
-                lprint_Scsi_Cmnd((Scsi_Cmnd *) hostdata->connected);
+                lprint_Scsi_Cmnd((struct scsi_cmnd *) hostdata->connected);
         printk("scsi%d: issue_queue\n", HOSTNO);
-        for (ptr = (Scsi_Cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr))
+        for (ptr = (struct scsi_cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr))
                 lprint_Scsi_Cmnd(ptr);
 
         printk("scsi%d: disconnected_queue\n", HOSTNO);
-        for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr;
+        for (ptr = (struct scsi_cmnd *) hostdata->disconnected_queue; ptr;
              ptr = NEXT(ptr))
                 lprint_Scsi_Cmnd(ptr);
 
@@ -758,7 +705,7 @@ static void NCR5380_print_status(struct Scsi_Host *instance)
         printk("\n");
 }
 
-static void show_Scsi_Cmnd(Scsi_Cmnd *cmd, struct seq_file *m)
+static void show_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m)
 {
         int i, s;
         unsigned char *command;
@@ -772,28 +719,28 @@ static void show_Scsi_Cmnd(Scsi_Cmnd *cmd, struct seq_file *m)
         seq_printf(m, "\n");
 }
 
-static int NCR5380_show_info(struct seq_file *m, struct Scsi_Host *instance)
+static int __maybe_unused NCR5380_show_info(struct seq_file *m,
+                                            struct Scsi_Host *instance)
 {
         struct NCR5380_hostdata *hostdata;
-        Scsi_Cmnd *ptr;
+        struct scsi_cmnd *ptr;
         unsigned long flags;
 
         hostdata = (struct NCR5380_hostdata *)instance->hostdata;
 
-        seq_printf(m, "NCR5380 core release=%d.\n", NCR5380_PUBLIC_RELEASE);
         local_irq_save(flags);
         seq_printf(m, "NCR5380: coroutine is%s running.\n",
-                main_running ? "" : "n't");
+                hostdata->main_running ? "" : "n't");
         if (!hostdata->connected)
                 seq_printf(m, "scsi%d: no currently connected command\n", HOSTNO);
         else
-                show_Scsi_Cmnd((Scsi_Cmnd *) hostdata->connected, m);
+                show_Scsi_Cmnd((struct scsi_cmnd *) hostdata->connected, m);
         seq_printf(m, "scsi%d: issue_queue\n", HOSTNO);
-        for (ptr = (Scsi_Cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr))
+        for (ptr = (struct scsi_cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr))
                 show_Scsi_Cmnd(ptr, m);
 
         seq_printf(m, "scsi%d: disconnected_queue\n", HOSTNO);
-        for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr;
+        for (ptr = (struct scsi_cmnd *) hostdata->disconnected_queue; ptr;
              ptr = NEXT(ptr))
                 show_Scsi_Cmnd(ptr, m);
 
@@ -801,16 +748,18 @@ static int NCR5380_show_info(struct seq_file *m, struct Scsi_Host *instance)
         return 0;
 }
 
-/*
- * Function : void NCR5380_init (struct Scsi_Host *instance)
+/**
+ * NCR5380_init - initialise an NCR5380
+ * @instance: adapter to configure
+ * @flags: control flags
  *
- * Purpose : initializes *instance and corresponding 5380 chip.
- *
- * Inputs : instance - instantiation of the 5380 driver.
+ * Initializes *instance and corresponding 5380 chip,
+ * with flags OR'd into the initial flags value.
  *
  * Notes : I assume that the host, hostno, and id bits have been
- *      set correctly.  I don't care about the irq and other fields.
+ * set correctly. I don't care about the irq and other fields.
  *
+ * Returns 0 for success
  */
 
 static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
@@ -818,8 +767,7 @@ static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
         int i;
         SETUP_HOSTDATA(instance);
 
-        NCR5380_all_init();
-
+        hostdata->host = instance;
         hostdata->aborted = 0;
         hostdata->id_mask = 1 << instance->this_id;
         hostdata->id_higher_mask = 0;
@@ -829,7 +777,7 @@ static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
         for (i = 0; i < 8; ++i)
                 hostdata->busy[i] = 0;
 #ifdef SUPPORT_TAGS
-        init_tags();
+        init_tags(hostdata);
 #endif
 #if defined (REAL_DMA)
         hostdata->dma_len = 0;
@@ -838,19 +786,11 @@ static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
         hostdata->connected = NULL;
         hostdata->issue_queue = NULL;
         hostdata->disconnected_queue = NULL;
-        hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT;
+        hostdata->flags = flags;
 
-        if (!the_template) {
-                the_template = instance->hostt;
-                first_instance = instance;
-        }
+        INIT_WORK(&hostdata->main_task, NCR5380_main);
 
-#ifndef AUTOSENSE
-        if ((instance->cmd_per_lun > 1) || (instance->can_queue > 1))
-                printk("scsi%d: WARNING : support for multiple outstanding commands enabled\n"
-                       "        without AUTOSENSE option, contingent allegiance conditions may\n"
-                       "        be incorrectly cleared.\n", HOSTNO);
-#endif /* def AUTOSENSE */
+        prepare_info(instance);
 
         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
         NCR5380_write(MODE_REG, MR_BASE);
@@ -860,33 +800,35 @@ static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
         return 0;
 }
 
+/**
+ * NCR5380_exit - remove an NCR5380
+ * @instance: adapter to remove
+ *
+ * Assumes that no more work can be queued (e.g. by NCR5380_intr).
+ */
+
 static void NCR5380_exit(struct Scsi_Host *instance)
 {
-        /* Empty, as we didn't schedule any delayed work */
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+
+        cancel_work_sync(&hostdata->main_task);
 }
 
-/*
- * Function : int NCR5380_queue_command (Scsi_Cmnd *cmd,
- *      void (*done)(Scsi_Cmnd *))
- *
- * Purpose :  enqueues a SCSI command
- *
- * Inputs : cmd - SCSI command, done - function called on completion, with
- *      a pointer to the command descriptor.
- *
- * Returns : 0
- *
- * Side effects :
- *      cmd is added to the per instance issue_queue, with minor
- *      twiddling done to the host specific fields of cmd.  If the
- *      main coroutine is not running, it is restarted.
+/**
+ * NCR5380_queue_command - queue a command
+ * @instance: the relevant SCSI adapter
+ * @cmd: SCSI command
  *
+ * cmd is added to the per instance issue_queue, with minor
+ * twiddling done to the host specific fields of cmd.  If the
+ * main coroutine is not running, it is restarted.
  */
 
-static int NCR5380_queue_command_lck(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
+static int NCR5380_queue_command(struct Scsi_Host *instance,
+                                 struct scsi_cmnd *cmd)
 {
-        SETUP_HOSTDATA(cmd->device->host);
-        Scsi_Cmnd *tmp;
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+        struct scsi_cmnd *tmp;
         unsigned long flags;
 
 #if (NDEBUG & NDEBUG_NO_WRITE)
@@ -896,47 +838,17 @@ static int NCR5380_queue_command_lck(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
                 printk(KERN_NOTICE "scsi%d: WRITE attempted with NO_WRITE debugging flag set\n",
                        H_NO(cmd));
                 cmd->result = (DID_ERROR << 16);
-                done(cmd);
+                cmd->scsi_done(cmd);
                 return 0;
         }
 #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
 
-#ifdef NCR5380_STATS
-# if 0
-        if (!hostdata->connected && !hostdata->issue_queue &&
-            !hostdata->disconnected_queue) {
-                hostdata->timebase = jiffies;
-        }
-# endif
-# ifdef NCR5380_STAT_LIMIT
-        if (scsi_bufflen(cmd) > NCR5380_STAT_LIMIT)
-# endif
-                switch (cmd->cmnd[0]) {
-                case WRITE:
-                case WRITE_6:
-                case WRITE_10:
-                        hostdata->time_write[cmd->device->id] -= (jiffies - hostdata->timebase);
-                        hostdata->bytes_write[cmd->device->id] += scsi_bufflen(cmd);
-                        hostdata->pendingw++;
-                        break;
-                case READ:
-                case READ_6:
-                case READ_10:
-                        hostdata->time_read[cmd->device->id] -= (jiffies - hostdata->timebase);
-                        hostdata->bytes_read[cmd->device->id] += scsi_bufflen(cmd);
-                        hostdata->pendingr++;
-                        break;
-                }
-#endif
-
         /*
          * We use the host_scribble field as a pointer to the next command
          * in a queue
          */
 
         SET_NEXT(cmd, NULL);
-        cmd->scsi_done = done;
-
         cmd->result = 0;
 
         /*
@@ -946,7 +858,6 @@ static int NCR5380_queue_command_lck(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
          * sense data is only guaranteed to be valid while the condition exists.
          */
 
-        local_irq_save(flags);
         /* ++guenther: now that the issue queue is being set up, we can lock ST-DMA.
          * Otherwise a running NCR5380_main may steal the lock.
          * Lock before actually inserting due to fairness reasons explained in
@@ -959,17 +870,24 @@ static int NCR5380_queue_command_lck(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
          * because also a timer int can trigger an abort or reset, which would
          * alter queues and touch the lock.
          */
-        if (!IS_A_TT()) {
-                /* perhaps stop command timer here */
-                falcon_get_lock();
-                /* perhaps restart command timer here */
-        }
+        if (!NCR5380_acquire_dma_irq(instance))
+                return SCSI_MLQUEUE_HOST_BUSY;
+
+        local_irq_save(flags);
+
+        /*
+         * Insert the cmd into the issue queue. Note that REQUEST SENSE
+         * commands are added to the head of the queue since any command will
+         * clear the contingent allegiance condition that exists and the
+         * sense data is only guaranteed to be valid while the condition exists.
+         */
+
         if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
                 LIST(cmd, hostdata->issue_queue);
                 SET_NEXT(cmd, hostdata->issue_queue);
                 hostdata->issue_queue = cmd;
         } else {
-                for (tmp = (Scsi_Cmnd *)hostdata->issue_queue;
+                for (tmp = (struct scsi_cmnd *)hostdata->issue_queue;
                      NEXT(tmp); tmp = NEXT(tmp))
                         ;
                 LIST(cmd, tmp);
@@ -987,32 +905,42 @@ static int NCR5380_queue_command_lck(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
          * If we're not in an interrupt, we can call NCR5380_main()
          * unconditionally, because it cannot be already running.
          */
-        if (in_interrupt() || ((flags >> 8) & 7) >= 6)
-                queue_main();
+        if (in_interrupt() || irqs_disabled())
+                queue_main(hostdata);
         else
-                NCR5380_main(NULL);
+                NCR5380_main(&hostdata->main_task);
         return 0;
 }
 
-static DEF_SCSI_QCMD(NCR5380_queue_command)
+static inline void maybe_release_dma_irq(struct Scsi_Host *instance)
+{
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+
+        /* Caller does the locking needed to set & test these data atomically */
+        if (!hostdata->disconnected_queue &&
+            !hostdata->issue_queue &&
+            !hostdata->connected &&
+            !hostdata->retain_dma_intr)
+                NCR5380_release_dma_irq(instance);
+}
 
-/*
- * Function : NCR5380_main (void)
+/**
+ * NCR5380_main - NCR state machines
  *
- * Purpose : NCR5380_main is a coroutine that runs as long as more work can
- *      be done on the NCR5380 host adapters in a system.  Both
- *      NCR5380_queue_command() and NCR5380_intr() will try to start it
- *      in case it is not running.
+ * NCR5380_main is a coroutine that runs as long as more work can
+ * be done on the NCR5380 host adapters in a system.  Both
+ * NCR5380_queue_command() and NCR5380_intr() will try to start it
+ * in case it is not running.
  *
- * NOTE : NCR5380_main exits with interrupts *disabled*, the caller should
- *  reenable them.  This prevents reentrancy and kernel stack overflow.
+ * Locks: called as its own thread with no locks held.
  */
 
 static void NCR5380_main(struct work_struct *work)
 {
-        Scsi_Cmnd *tmp, *prev;
-        struct Scsi_Host *instance = first_instance;
-        struct NCR5380_hostdata *hostdata = HOSTDATA(instance);
+        struct NCR5380_hostdata *hostdata =
+                container_of(work, struct NCR5380_hostdata, main_task);
+        struct Scsi_Host *instance = hostdata->host;
+        struct scsi_cmnd *tmp, *prev;
         int done;
         unsigned long flags;
 
@@ -1037,9 +965,9 @@ static void NCR5380_main(struct work_struct *work)
            'main_running' is set here, and queues/executes main via the
            task queue, it doesn't do any harm, just this instance of main
            won't find any work left to do. */
-        if (main_running)
+        if (hostdata->main_running)
                 return;
-        main_running = 1;
+        hostdata->main_running = 1;
 
         local_save_flags(flags);
         do {
@@ -1053,7 +981,7 @@ static void NCR5380_main(struct work_struct *work)
                          * for a target that's not busy.
                          */
 #if (NDEBUG & NDEBUG_LISTS)
-                        for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL;
+                        for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL;
                              tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp))
                                 ;
                         /*printk("%p  ", tmp);*/
@@ -1061,16 +989,14 @@ static void NCR5380_main(struct work_struct *work)
                                 printk(" LOOP\n");
                         /* else printk("\n"); */
 #endif
-                        for (tmp = (Scsi_Cmnd *) hostdata->issue_queue,
+                        for (tmp = (struct scsi_cmnd *) hostdata->issue_queue,
                              prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp)) {
                                 u8 lun = tmp->device->lun;
 
-#if (NDEBUG & NDEBUG_LISTS)
-                                if (prev != tmp)
-                                        printk("MAIN tmp=%p   target=%d   busy=%d lun=%llu\n",
-                                               tmp, tmp->device->id, hostdata->busy[tmp->device->id],
-                                               lun);
-#endif
+                                dprintk(NDEBUG_LISTS,
+                                        "MAIN tmp=%p target=%d busy=%d lun=%d\n",
+                                        tmp, scmd_id(tmp), hostdata->busy[scmd_id(tmp)],
+                                        lun);
                                 /*  When we find one, remove it from the issue queue. */
                                 /* ++guenther: possible race with Falcon locking */
                                 if (
@@ -1090,7 +1016,7 @@ static void NCR5380_main(struct work_struct *work)
                                                 hostdata->issue_queue = NEXT(tmp);
                                         }
                                         SET_NEXT(tmp, NULL);
-                                        falcon_dont_release++;
+                                        hostdata->retain_dma_intr++;
 
                                         /* reenable interrupts after finding one */
                                         local_irq_restore(flags);
@@ -1117,12 +1043,12 @@ static void NCR5380_main(struct work_struct *work)
 #ifdef SUPPORT_TAGS
                                         cmd_get_tag(tmp, tmp->cmnd[0] != REQUEST_SENSE);
 #endif
-                                        if (!NCR5380_select(instance, tmp,
-                                            (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE :
-                                            TAG_NEXT)) {
-                                                falcon_dont_release--;
+                                        if (!NCR5380_select(instance, tmp)) {
+                                                local_irq_disable();
+                                                hostdata->retain_dma_intr--;
                                                 /* release if target did not response! */
-                                                falcon_release_lock_if_possible(hostdata);
+                                                maybe_release_dma_irq(instance);
+                                                local_irq_restore(flags);
                                                 break;
                                         } else {
                                                 local_irq_disable();
@@ -1132,7 +1058,7 @@ static void NCR5380_main(struct work_struct *work)
 #ifdef SUPPORT_TAGS
                                                 cmd_free_tag(tmp);
 #endif
-                                                falcon_dont_release--;
+                                                hostdata->retain_dma_intr--;
                                                 local_irq_restore(flags);
                                                 dprintk(NDEBUG_MAIN, "scsi%d: main(): select() failed, "
                                                             "returned to issue_queue\n", HOSTNO);
@@ -1160,7 +1086,7 @@ static void NCR5380_main(struct work_struct *work)
         /* Better allow ints _after_ 'main_running' has been cleared, else
            an interrupt could believe we'll pick up the work it left for
            us, but we won't see it anymore here... */
-        main_running = 0;
+        hostdata->main_running = 0;
         local_irq_restore(flags);
 }
 
@@ -1179,9 +1105,11 @@ static void NCR5380_main(struct work_struct *work)
 static void NCR5380_dma_complete(struct Scsi_Host *instance)
 {
         SETUP_HOSTDATA(instance);
-        int transfered, saved_data = 0, overrun = 0, cnt, toPIO;
-        unsigned char **data, p;
+        int transferred;
+        unsigned char **data;
         volatile int *count;
+        int saved_data = 0, overrun = 0;
+        unsigned char p;
 
         if (!hostdata->connected) {
                 printk(KERN_WARNING "scsi%d: received end of DMA interrupt with "
@@ -1189,7 +1117,7 @@ static void NCR5380_dma_complete(struct Scsi_Host *instance)
                 return;
         }
 
-        if (atari_read_overruns) {
+        if (hostdata->read_overruns) {
                 p = hostdata->connected->SCp.phase;
                 if (p & SR_IO) {
                         udelay(10);
@@ -1207,21 +1135,41 @@ static void NCR5380_dma_complete(struct Scsi_Host *instance)
                    HOSTNO, NCR5380_read(BUS_AND_STATUS_REG),
                    NCR5380_read(STATUS_REG));
 
+#if defined(CONFIG_SUN3)
+        if ((sun3scsi_dma_finish(rq_data_dir(hostdata->connected->request)))) {
+                pr_err("scsi%d: overrun in UDC counter -- not prepared to deal with this!\n",
+                       instance->host_no);
+                BUG();
+        }
+
+        /* make sure we're not stuck in a data phase */
+        if ((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) ==
+            (BASR_PHASE_MATCH | BASR_ACK)) {
+                pr_err("scsi%d: BASR %02x\n", instance->host_no,
+                       NCR5380_read(BUS_AND_STATUS_REG));
+                pr_err("scsi%d: bus stuck in data phase -- probably a single byte overrun!\n",
+                       instance->host_no);
+                BUG();
+        }
+#endif
+
         (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
         NCR5380_write(MODE_REG, MR_BASE);
         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
 
-        transfered = hostdata->dma_len - NCR5380_dma_residual(instance);
+        transferred = hostdata->dma_len - NCR5380_dma_residual(instance);
         hostdata->dma_len = 0;
 
         data = (unsigned char **)&hostdata->connected->SCp.ptr;
         count = &hostdata->connected->SCp.this_residual;
-        *data += transfered;
-        *count -= transfered;
+        *data += transferred;
+        *count -= transferred;
+
+        if (hostdata->read_overruns) {
+                int cnt, toPIO;
 
-        if (atari_read_overruns) {
                 if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) {
-                        cnt = toPIO = atari_read_overruns;
+                        cnt = toPIO = hostdata->read_overruns;
                         if (overrun) {
                                 dprintk(NDEBUG_DMA, "Got an input overrun, using saved byte\n");
                                 *(*data)++ = saved_data;
@@ -1238,20 +1186,19 @@ static void NCR5380_dma_complete(struct Scsi_Host *instance)
 #endif /* REAL_DMA */
 
 
-/*
- * Function : void NCR5380_intr (int irq)
- *
- * Purpose : handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
- *      from the disconnected queue, and restarting NCR5380_main()
- *      as required.
- *
- * Inputs : int irq, irq that caused this interrupt.
+/**
+ * NCR5380_intr - generic NCR5380 irq handler
+ * @irq: interrupt number
+ * @dev_id: device info
  *
+ * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
+ * from the disconnected queue, and restarting NCR5380_main()
+ * as required.
  */
 
 static irqreturn_t NCR5380_intr(int irq, void *dev_id)
 {
-        struct Scsi_Host *instance = first_instance;
+        struct Scsi_Host *instance = dev_id;
         int done = 1, handled = 0;
         unsigned char basr;
 
@@ -1265,7 +1212,6 @@ static irqreturn_t NCR5380_intr(int irq, void *dev_id)
                 NCR5380_dprint(NDEBUG_INTR, instance);
                 if ((NCR5380_read(STATUS_REG) & (SR_SEL|SR_IO)) == (SR_SEL|SR_IO)) {
                         done = 0;
-                        ENABLE_IRQ();
                         dprintk(NDEBUG_INTR, "scsi%d: SEL interrupt\n", HOSTNO);
                         NCR5380_reselect(instance);
                         (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
@@ -1295,17 +1241,19 @@ static irqreturn_t NCR5380_intr(int irq, void *dev_id)
                                 dprintk(NDEBUG_INTR, "scsi%d: PHASE MISM or EOP interrupt\n", HOSTNO);
                                 NCR5380_dma_complete( instance );
                                 done = 0;
-                                ENABLE_IRQ();
                         } else
 #endif /* REAL_DMA */
                         {
 /* MS: Ignore unknown phase mismatch interrupts (caused by EOP interrupt) */
                                 if (basr & BASR_PHASE_MATCH)
-                                        printk(KERN_NOTICE "scsi%d: unknown interrupt, "
+                                        dprintk(NDEBUG_INTR, "scsi%d: unknown interrupt, "
                                                "BASR 0x%x, MR 0x%x, SR 0x%x\n",
                                                HOSTNO, basr, NCR5380_read(MODE_REG),
                                                NCR5380_read(STATUS_REG));
                                 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
+#ifdef SUN3_SCSI_VME
+                                dregs->csr |= CSR_DMA_ENABLE;
+#endif
                         }
                 } /* if !(SELECTION || PARITY) */
                 handled = 1;
@@ -1314,53 +1262,29 @@ static irqreturn_t NCR5380_intr(int irq, void *dev_id)
                        "BASR 0x%X, MR 0x%X, SR 0x%x\n", HOSTNO, basr,
                        NCR5380_read(MODE_REG), NCR5380_read(STATUS_REG));
                 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
+#ifdef SUN3_SCSI_VME
+                dregs->csr |= CSR_DMA_ENABLE;
+#endif
         }
 
         if (!done) {
                 dprintk(NDEBUG_INTR, "scsi%d: in int routine, calling main\n", HOSTNO);
                 /* Put a call to NCR5380_main() on the queue... */
-                queue_main();
+                queue_main(shost_priv(instance));
         }
         return IRQ_RETVAL(handled);
 }
 
-#ifdef NCR5380_STATS
-static void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd *cmd)
-{
-# ifdef NCR5380_STAT_LIMIT
-        if (scsi_bufflen(cmd) > NCR5380_STAT_LIMIT)
-# endif
-                switch (cmd->cmnd[0]) {
-                case WRITE:
-                case WRITE_6:
-                case WRITE_10:
-                        hostdata->time_write[cmd->device->id] += (jiffies - hostdata->timebase);
-                        /*hostdata->bytes_write[cmd->device->id] += scsi_bufflen(cmd);*/
-                        hostdata->pendingw--;
-                        break;
-                case READ:
-                case READ_6:
-                case READ_10:
-                        hostdata->time_read[cmd->device->id] += (jiffies - hostdata->timebase);
-                        /*hostdata->bytes_read[cmd->device->id] += scsi_bufflen(cmd);*/
-                        hostdata->pendingr--;
-                        break;
-                }
-}
-#endif
-
 /*
- * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
- *      int tag);
+ * Function : int NCR5380_select(struct Scsi_Host *instance,
+ *                               struct scsi_cmnd *cmd)
  *
  * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
  *      including ARBITRATION, SELECTION, and initial message out for
  *      IDENTIFY and queue messages.
  *
  * Inputs : instance - instantiation of the 5380 driver on which this
- *      target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for
- *      new tag, TAG_NONE for untagged queueing, otherwise set to the tag for
- *      the command that is presently connected.
+ *      target lives, cmd - SCSI command to execute.
  *
  * Returns : -1 if selection could not execute for some reason,
  *      0 if selection succeeded or failed because the target
@@ -1380,7 +1304,7 @@ static void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd *cmd)
  *              cmd->result host byte set to DID_BAD_TARGET.
  */
 
-static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
+static int NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd)
 {
         SETUP_HOSTDATA(instance);
         unsigned char tmp[3], phase;
@@ -1562,7 +1486,7 @@ static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
          * selection.
          */
 
-        timeout = jiffies + 25;
+        timeout = jiffies + (250 * HZ / 1000);
 
         /*
          * XXX very interesting - we're seeing a bounce where the BSY we
@@ -1616,9 +1540,6 @@ static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
                         return -1;
                 }
                 cmd->result = DID_BAD_TARGET << 16;
-#ifdef NCR5380_STATS
-                collect_stats(hostdata, cmd);
-#endif
 #ifdef SUPPORT_TAGS
                 cmd_free_tag(cmd);
 #endif
@@ -1676,6 +1597,9 @@ static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
 #ifndef SUPPORT_TAGS
         hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
 #endif
+#ifdef SUN3_SCSI_VME
+        dregs->csr |= CSR_INTR;
+#endif
 
         initialize_SCp(cmd);
 
@@ -1826,7 +1750,7 @@ static int NCR5380_transfer_pio(struct Scsi_Host *instance,
  * Returns : 0 on success, -1 on failure.
  */
 
-static int do_abort(struct Scsi_Host *host)
+static int do_abort(struct Scsi_Host *instance)
 {
         unsigned char tmp, *msgptr, phase;
         int len;
@@ -1861,7 +1785,7 @@ static int do_abort(struct Scsi_Host *host)
         msgptr = &tmp;
         len = 1;
         phase = PHASE_MSGOUT;
-        NCR5380_transfer_pio(host, &phase, &len, &msgptr);
+        NCR5380_transfer_pio(instance, &phase, &len, &msgptr);
 
         /*
          * If we got here, and the command completed successfully,
@@ -1899,17 +1823,62 @@ static int NCR5380_transfer_dma(struct Scsi_Host *instance,
         SETUP_HOSTDATA(instance);
         register int c = *count;
         register unsigned char p = *phase;
+        unsigned long flags;
+
+#if defined(CONFIG_SUN3)
+        /* sanity check */
+        if (!sun3_dma_setup_done) {
+                pr_err("scsi%d: transfer_dma without setup!\n",
+                       instance->host_no);
+                BUG();
+        }
+        hostdata->dma_len = c;
+
+        dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
+                instance->host_no, (p & SR_IO) ? "reading" : "writing",
+                c, (p & SR_IO) ? "to" : "from", *data);
+
+        /* netbsd turns off ints here, why not be safe and do it too */
+        local_irq_save(flags);
+
+        /* send start chain */
+        sun3scsi_dma_start(c, *data);
+
+        if (p & SR_IO) {
+                NCR5380_write(TARGET_COMMAND_REG, 1);
+                NCR5380_read(RESET_PARITY_INTERRUPT_REG);
+                NCR5380_write(INITIATOR_COMMAND_REG, 0);
+                NCR5380_write(MODE_REG,
+                              (NCR5380_read(MODE_REG) | MR_DMA_MODE | MR_ENABLE_EOP_INTR));
+                NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
+        } else {
+                NCR5380_write(TARGET_COMMAND_REG, 0);
+                NCR5380_read(RESET_PARITY_INTERRUPT_REG);
+                NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_DATA);
+                NCR5380_write(MODE_REG,
+                              (NCR5380_read(MODE_REG) | MR_DMA_MODE | MR_ENABLE_EOP_INTR));
+                NCR5380_write(START_DMA_SEND_REG, 0);
+        }
+
+#ifdef SUN3_SCSI_VME
+        dregs->csr |= CSR_DMA_ENABLE;
+#endif
+
+        local_irq_restore(flags);
+
+        sun3_dma_active = 1;
+
+#else /* !defined(CONFIG_SUN3) */
         register unsigned char *d = *data;
         unsigned char tmp;
-        unsigned long flags;
 
         if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
                 *phase = tmp;
                 return -1;
         }
 
-        if (atari_read_overruns && (p & SR_IO))
-                c -= atari_read_overruns;
+        if (hostdata->read_overruns && (p & SR_IO))
+                c -= hostdata->read_overruns;
 
         dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
                    HOSTNO, (p & SR_IO) ? "reading" : "writing",
@@ -1921,7 +1890,7 @@ static int NCR5380_transfer_dma(struct Scsi_Host *instance,
         NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_EOP_INTR | MR_MONITOR_BSY);
 #endif /* def REAL_DMA  */
 
-        if (IS_A_TT()) {
+        if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) {
                 /* On the Medusa, it is a must to initialize the DMA before
                  * starting the NCR. This is also the cleaner way for the TT.
                  */
@@ -1939,7 +1908,7 @@ static int NCR5380_transfer_dma(struct Scsi_Host *instance,
                 NCR5380_write(START_DMA_SEND_REG, 0);
         }
 
-        if (!IS_A_TT()) {
+        if (hostdata->flags & FLAG_LATE_DMA_SETUP) {
                 /* On the Falcon, the DMA setup must be done after the last */
                 /* NCR access, else the DMA setup gets trashed!
                  */
@@ -1949,6 +1918,8 @@ static int NCR5380_transfer_dma(struct Scsi_Host *instance,
                         NCR5380_dma_write_setup(instance, d, c);
                 local_irq_restore(flags);
         }
+#endif /* !defined(CONFIG_SUN3) */
+
         return 0;
 }
 #endif /* defined(REAL_DMA) */
@@ -1982,7 +1953,11 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
 #endif
         unsigned char *data;
         unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
-        Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
+        struct scsi_cmnd *cmd = (struct scsi_cmnd *) hostdata->connected;
+
+#ifdef SUN3_SCSI_VME
+        dregs->csr |= CSR_INTR;
+#endif
 
         while (1) {
                 tmp = NCR5380_read(STATUS_REG);
@@ -1993,6 +1968,33 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                 old_phase = phase;
                                 NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
                         }
+#if defined(CONFIG_SUN3)
+                        if (phase == PHASE_CMDOUT) {
+#if defined(REAL_DMA)
+                                void *d;
+                                unsigned long count;
+
+                                if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
+                                        count = cmd->SCp.buffer->length;
+                                        d = sg_virt(cmd->SCp.buffer);
+                                } else {
+                                        count = cmd->SCp.this_residual;
+                                        d = cmd->SCp.ptr;
+                                }
+                                /* this command setup for dma yet? */
+                                if ((count >= DMA_MIN_SIZE) && (sun3_dma_setup_done != cmd)) {
+                                        if (cmd->request->cmd_type == REQ_TYPE_FS) {
+                                                sun3scsi_dma_setup(d, count,
+                                                                   rq_data_dir(cmd->request));
+                                                sun3_dma_setup_done = cmd;
+                                        }
+                                }
+#endif
+#ifdef SUN3_SCSI_VME
+                                dregs->csr |= CSR_INTR;
+#endif
+                        }
+#endif /* CONFIG_SUN3 */
 
                         if (sink && (phase != PHASE_MSGOUT)) {
                                 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
@@ -2054,8 +2056,11 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                  */
 
 #if defined(REAL_DMA)
-                                if (!cmd->device->borken &&
-                                    (transfersize = NCR5380_dma_xfer_len(instance,cmd,phase)) > 31) {
+                                if (
+#if !defined(CONFIG_SUN3)
+                                    !cmd->device->borken &&
+#endif
+                                    (transfersize = NCR5380_dma_xfer_len(instance, cmd, phase)) >= DMA_MIN_SIZE) {
                                         len = transfersize;
                                         cmd->SCp.phase = phase;
                                         if (NCR5380_transfer_dma(instance, &phase,
@@ -2064,9 +2069,8 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                                  * If the watchdog timer fires, all future
                                                  * accesses to this device will use the
                                                  * polled-IO. */
-                                                printk(KERN_NOTICE "scsi%d: switching target %d "
-                                                           "lun %llu to slow handshake\n", HOSTNO,
-                                                           cmd->device->id, cmd->device->lun);
+                                                scmd_printk(KERN_INFO, cmd,
+                                                        "switching to slow handshake\n");
                                                 cmd->device->borken = 1;
                                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
                                                         ICR_ASSERT_ATN);
@@ -2092,6 +2096,11 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                         NCR5380_transfer_pio(instance, &phase,
                                                              (int *)&cmd->SCp.this_residual,
                                                              (unsigned char **)&cmd->SCp.ptr);
+#if defined(CONFIG_SUN3) && defined(REAL_DMA)
+                                /* if we had intended to dma that command clear it */
+                                if (sun3_dma_setup_done == cmd)
+                                        sun3_dma_setup_done = NULL;
+#endif
                                 break;
                         case PHASE_MSGIN:
                                 len = 1;
@@ -2145,9 +2154,6 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                         dprintk(NDEBUG_LINKED, "scsi%d: target %d lun %llu linked request "
                                                    "done, calling scsi_done().\n",
                                                    HOSTNO, cmd->device->id, cmd->device->lun);
-#ifdef NCR5380_STATS
-                                        collect_stats(hostdata, cmd);
-#endif
                                         cmd->scsi_done(cmd);
                                         cmd = hostdata->connected;
                                         break;
@@ -2156,11 +2162,12 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                 case COMMAND_COMPLETE:
                                         /* Accept message by clearing ACK */
                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-                                        /* ++guenther: possible race with Falcon locking */
-                                        falcon_dont_release++;
-                                        hostdata->connected = NULL;
                                         dprintk(NDEBUG_QUEUES, "scsi%d: command for target %d, lun %llu "
                                                   "completed\n", HOSTNO, cmd->device->id, cmd->device->lun);
+
+                                        local_irq_save(flags);
+                                        hostdata->retain_dma_intr++;
+                                        hostdata->connected = NULL;
 #ifdef SUPPORT_TAGS
                                         cmd_free_tag(cmd);
                                         if (status_byte(cmd->SCp.Status) == QUEUE_FULL) {
@@ -2172,7 +2179,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                                  */
                                                 /* ++Andreas: the mid level code knows about
                                                    QUEUE_FULL now. */
-                                                TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun];
+                                                struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][cmd->device->lun];
                                                 dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu returned "
                                                            "QUEUE_FULL after %d commands\n",
                                                            HOSTNO, cmd->device->id, cmd->device->lun,
@@ -2207,7 +2214,6 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                         else if (status_byte(cmd->SCp.Status) != GOOD)
                                                 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
 
-#ifdef AUTOSENSE
                                         if ((cmd->cmnd[0] == REQUEST_SENSE) &&
                                                 hostdata->ses.cmd_len) {
                                                 scsi_eh_restore_cmnd(cmd, &hostdata->ses);
@@ -2220,22 +2226,17 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
 
                                                 dprintk(NDEBUG_AUTOSENSE, "scsi%d: performing request sense\n", HOSTNO);
 
-                                                local_irq_save(flags);
                                                 LIST(cmd,hostdata->issue_queue);
                                                 SET_NEXT(cmd, hostdata->issue_queue);
-                                                hostdata->issue_queue = (Scsi_Cmnd *) cmd;
-                                                local_irq_restore(flags);
+                                                hostdata->issue_queue = (struct scsi_cmnd *) cmd;
                                                 dprintk(NDEBUG_QUEUES, "scsi%d: REQUEST SENSE added to head of "
                                                           "issue queue\n", H_NO(cmd));
-                                        } else
-#endif /* def AUTOSENSE */
-                                        {
-#ifdef NCR5380_STATS
-                                                collect_stats(hostdata, cmd);
-#endif
+                                        } else {
                                                 cmd->scsi_done(cmd);
                                         }
 
+                                        local_irq_restore(flags);
+
                                         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
                                         /*
                                          * Restore phase bits to 0 so an interrupted selection,
@@ -2246,12 +2247,14 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                         while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
                                                 barrier();
 
-                                        falcon_dont_release--;
+                                        local_irq_save(flags);
+                                        hostdata->retain_dma_intr--;
                                         /* ++roman: For Falcon SCSI, release the lock on the
                                          * ST-DMA here if no other commands are waiting on the
                                          * disconnected queue.
                                          */
-                                        falcon_release_lock_if_possible(hostdata);
+                                        maybe_release_dma_irq(instance);
+                                        local_irq_restore(flags);
                                         return;
                                 case MESSAGE_REJECT:
                                         /* Accept message by clearing ACK */
@@ -2303,6 +2306,9 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                         /* Wait for bus free to avoid nasty timeouts */
                                         while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
                                                 barrier();
+#ifdef SUN3_SCSI_VME
+                                        dregs->csr |= CSR_DMA_ENABLE;
+#endif
                                         return;
                                         /*
                                          * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
@@ -2384,20 +2390,18 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                          */
                                 default:
                                         if (!tmp) {
-                                                printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO);
+                                                printk(KERN_INFO "scsi%d: rejecting message ",
+                                                       instance->host_no);
                                                 spi_print_msg(extended_msg);
                                                 printk("\n");
                                         } else if (tmp != EXTENDED_MESSAGE)
-                                                printk(KERN_DEBUG "scsi%d: rejecting unknown "
-                                                       "message %02x from target %d, lun %llu\n",
-                                                       HOSTNO, tmp, cmd->device->id, cmd->device->lun);
+                                                scmd_printk(KERN_INFO, cmd,
+                                                            "rejecting unknown message %02x\n",
+                                                            tmp);
                                         else
-                                                printk(KERN_DEBUG "scsi%d: rejecting unknown "
-                                                       "extended message "
-                                                       "code %02x, length %d from target %d, lun %llu\n",
-                                                       HOSTNO, extended_msg[1], extended_msg[0],
-                                                       cmd->device->id, cmd->device->lun);
-
+                                                scmd_printk(KERN_INFO, cmd,
+                                                            "rejecting unknown extended message code %02x, length %d\n",
+                                                            extended_msg[1], extended_msg[0]);
 
                                         msgout = MESSAGE_REJECT;
                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
@@ -2410,6 +2414,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
                                 hostdata->last_message = msgout;
                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
                                 if (msgout == ABORT) {
+                                        local_irq_save(flags);
 #ifdef SUPPORT_TAGS
                                         cmd_free_tag(cmd);
 #else
@@ -2417,12 +2422,10 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
 #endif
                                         hostdata->connected = NULL;
                                         cmd->result = DID_ERROR << 16;
-#ifdef NCR5380_STATS
-                                        collect_stats(hostdata, cmd);
-#endif
-                                        cmd->scsi_done(cmd);
                                         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-                                        falcon_release_lock_if_possible(hostdata);
+                                        maybe_release_dma_irq(instance);
+                                        local_irq_restore(flags);
+                                        cmd->scsi_done(cmd);
                                         return;
                                 }
                                 msgout = NOP;
@@ -2455,7 +2458,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
  * Function : void NCR5380_reselect (struct Scsi_Host *instance)
  *
  * Purpose : does reselection, initializing the instance->connected
- *      field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q
+ *      field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q
  *      nexus has been reestablished,
  *
  * Inputs : instance - this instance of the NCR5380.
@@ -2463,19 +2466,21 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
  */
 
 
+/* it might eventually prove necessary to do a dma setup on
+   reselection, but it doesn't seem to be needed now -- sam */
+
 static void NCR5380_reselect(struct Scsi_Host *instance)
 {
         SETUP_HOSTDATA(instance);
         unsigned char target_mask;
-        unsigned char lun, phase;
-        int len;
+        unsigned char lun;
 #ifdef SUPPORT_TAGS
         unsigned char tag;
 #endif
         unsigned char msg[3];
-        unsigned char *data;
-        Scsi_Cmnd *tmp = NULL, *prev;
-/*      unsigned long flags; */
+        int __maybe_unused len;
+        unsigned char __maybe_unused *data, __maybe_unused phase;
+        struct scsi_cmnd *tmp = NULL, *prev;
 
         /*
          * Disable arbitration, etc. since the host adapter obviously
@@ -2511,10 +2516,18 @@ static void NCR5380_reselect(struct Scsi_Host *instance)
         while (!(NCR5380_read(STATUS_REG) & SR_REQ))
                 ;
 
+#if defined(CONFIG_SUN3) && defined(REAL_DMA)
+        /* acknowledge toggle to MSGIN */
+        NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(PHASE_MSGIN));
+
+        /* peek at the byte without really hitting the bus */
+        msg[0] = NCR5380_read(CURRENT_SCSI_DATA_REG);
+#else
         len = 1;
         data = msg;
         phase = PHASE_MSGIN;
         NCR5380_transfer_pio(instance, &phase, &len, &data);
+#endif
 
         if (!(msg[0] & 0x80)) {
                 printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO);
@@ -2524,13 +2537,13 @@ static void NCR5380_reselect(struct Scsi_Host *instance)
         }
         lun = (msg[0] & 0x07);
 
-#ifdef SUPPORT_TAGS
+#if defined(SUPPORT_TAGS) && !defined(CONFIG_SUN3)
         /* If the phase is still MSGIN, the target wants to send some more
          * messages. In case it supports tagged queuing, this is probably a
          * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
          */
         tag = TAG_NONE;
-        if (phase == PHASE_MSGIN && setup_use_tagged_queuing) {
+        if (phase == PHASE_MSGIN && (hostdata->flags & FLAG_TAGGED_QUEUING)) {
                 /* Accept previous IDENTIFY message by clearing ACK */
                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
                 len = 2;
@@ -2548,15 +2561,13 @@ static void NCR5380_reselect(struct Scsi_Host *instance)
          * just reestablished, and remove it from the disconnected queue.
          */
 
-        for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL;
+        for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL;
              tmp; prev = tmp, tmp = NEXT(tmp)) {
                 if ((target_mask == (1 << tmp->device->id)) && (lun == tmp->device->lun)
 #ifdef SUPPORT_TAGS
                     && (tag == tmp->tag)
 #endif
                     ) {
-                        /* ++guenther: prevent race with falcon_release_lock */
-                        falcon_dont_release++;
                         if (prev) {
                                 REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
                                 SET_NEXT(prev, NEXT(tmp));
@@ -2588,26 +2599,67 @@ static void NCR5380_reselect(struct Scsi_Host *instance)
                 return;
         }
 
+#if defined(CONFIG_SUN3) && defined(REAL_DMA)
+        /* engage dma setup for the command we just saw */
+        {
+                void *d;
+                unsigned long count;
+
+                if (!tmp->SCp.this_residual && tmp->SCp.buffers_residual) {
+                        count = tmp->SCp.buffer->length;
+                        d = sg_virt(tmp->SCp.buffer);
+                } else {
+                        count = tmp->SCp.this_residual;
+                        d = tmp->SCp.ptr;
+                }
+                /* setup this command for dma if not already */
+                if ((count >= DMA_MIN_SIZE) && (sun3_dma_setup_done != tmp)) {
+                        sun3scsi_dma_setup(d, count, rq_data_dir(tmp->request));
+                        sun3_dma_setup_done = tmp;
+                }
+        }
+
+        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
+#endif
+
         /* Accept message by clearing ACK */
         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
 
+#if defined(SUPPORT_TAGS) && defined(CONFIG_SUN3)
+        /* If the phase is still MSGIN, the target wants to send some more
+         * messages. In case it supports tagged queuing, this is probably a
+         * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
+         */
+        tag = TAG_NONE;
+        if (phase == PHASE_MSGIN && setup_use_tagged_queuing) {
+                /* Accept previous IDENTIFY message by clearing ACK */
+                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
+                len = 2;
+                data = msg + 1;
+                if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
+                    msg[1] == SIMPLE_QUEUE_TAG)
+                        tag = msg[2];
+                dprintk(NDEBUG_TAGS, "scsi%d: target mask %02x, lun %d sent tag %d at reselection\n"
+                        HOSTNO, target_mask, lun, tag);
+        }
+#endif
+
         hostdata->connected = tmp;
         dprintk(NDEBUG_RESELECTION, "scsi%d: nexus established, target = %d, lun = %llu, tag = %d\n",
                    HOSTNO, tmp->device->id, tmp->device->lun, tmp->tag);
-        falcon_dont_release--;
 }
 
 
 /*
- * Function : int NCR5380_abort (Scsi_Cmnd *cmd)
+ * Function : int NCR5380_abort (struct scsi_cmnd *cmd)
  *
  * Purpose : abort a command
  *
- * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the
+ * Inputs : cmd - the scsi_cmnd to abort, code - code to set the
  *      host byte of the result field to, if zero DID_ABORTED is
  *      used.
  *
- * Returns : 0 - success, -1 on failure.
+ * Returns : SUCCESS - success, FAILED on failure.
  *
  * XXX - there is no way to abort the command that is currently
  *       connected, you have to wait for it to complete.  If this is
@@ -2616,24 +2668,19 @@ static void NCR5380_reselect(struct Scsi_Host *instance)
  */
 
 static
-int NCR5380_abort(Scsi_Cmnd *cmd)
+int NCR5380_abort(struct scsi_cmnd *cmd)
 {
         struct Scsi_Host *instance = cmd->device->host;
         SETUP_HOSTDATA(instance);
-        Scsi_Cmnd *tmp, **prev;
+        struct scsi_cmnd *tmp, **prev;
         unsigned long flags;
 
-        printk(KERN_NOTICE "scsi%d: aborting command\n", HOSTNO);
-        scsi_print_command(cmd);
+        scmd_printk(KERN_NOTICE, cmd, "aborting command\n");
 
         NCR5380_print_status(instance);
 
         local_irq_save(flags);
 
-        if (!IS_A_TT() && !falcon_got_lock)
-                printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_abort\n",
-                       HOSTNO);
-
         dprintk(NDEBUG_ABORT, "scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO,
                     NCR5380_read(BUS_AND_STATUS_REG),
                     NCR5380_read(STATUS_REG));
@@ -2674,12 +2721,12 @@ int NCR5380_abort(Scsi_Cmnd *cmd)
 #else
                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
 #endif
+                        maybe_release_dma_irq(instance);
                         local_irq_restore(flags);
                         cmd->scsi_done(cmd);
-                        falcon_release_lock_if_possible(hostdata);
                         return SUCCESS;
                 } else {
-/*                      local_irq_restore(flags); */
+                        local_irq_restore(flags);
                         printk("scsi%d: abort of connected command failed!\n", HOSTNO);
                         return FAILED;
                 }
@@ -2690,21 +2737,21 @@ int NCR5380_abort(Scsi_Cmnd *cmd)
          * Case 2 : If the command hasn't been issued yet, we simply remove it
          *          from the issue queue.
          */
-        for (prev = (Scsi_Cmnd **)&(hostdata->issue_queue),
-             tmp = (Scsi_Cmnd *)hostdata->issue_queue;
+        for (prev = (struct scsi_cmnd **)&(hostdata->issue_queue),
+             tmp = (struct scsi_cmnd *)hostdata->issue_queue;
              tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
                 if (cmd == tmp) {
                         REMOVE(5, *prev, tmp, NEXT(tmp));
                         (*prev) = NEXT(tmp);
                         SET_NEXT(tmp, NULL);
                         tmp->result = DID_ABORT << 16;
+                        maybe_release_dma_irq(instance);
                         local_irq_restore(flags);
                         dprintk(NDEBUG_ABORT, "scsi%d: abort removed command from issue queue.\n",
                                     HOSTNO);
                         /* Tagged queuing note: no tag to free here, hasn't been assigned
                          * yet... */
                         tmp->scsi_done(tmp);
-                        falcon_release_lock_if_possible(hostdata);
                         return SUCCESS;
                 }
         }
@@ -2751,13 +2798,13 @@ int NCR5380_abort(Scsi_Cmnd *cmd)
          * it from the disconnected queue.
          */
 
-        for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp;
+        for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp;
              tmp = NEXT(tmp)) {
                 if (cmd == tmp) {
                         local_irq_restore(flags);
                         dprintk(NDEBUG_ABORT, "scsi%d: aborting disconnected command.\n", HOSTNO);
 
-                        if (NCR5380_select(instance, cmd, (int)cmd->tag))
+                        if (NCR5380_select(instance, cmd))
                                 return FAILED;
 
                         dprintk(NDEBUG_ABORT, "scsi%d: nexus reestablished.\n", HOSTNO);
@@ -2765,8 +2812,8 @@ int NCR5380_abort(Scsi_Cmnd *cmd)
                         do_abort(instance);
 
                         local_irq_save(flags);
-                        for (prev = (Scsi_Cmnd **)&(hostdata->disconnected_queue),
-                             tmp = (Scsi_Cmnd *)hostdata->disconnected_queue;
+                        for (prev = (struct scsi_cmnd **)&(hostdata->disconnected_queue),
+                             tmp = (struct scsi_cmnd *)hostdata->disconnected_queue;
                              tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
                                 if (cmd == tmp) {
                                         REMOVE(5, *prev, tmp, NEXT(tmp));
@@ -2782,15 +2829,22 @@ int NCR5380_abort(Scsi_Cmnd *cmd)
 #else
                                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
 #endif
+                                        maybe_release_dma_irq(instance);
                                         local_irq_restore(flags);
                                         tmp->scsi_done(tmp);
-                                        falcon_release_lock_if_possible(hostdata);
                                         return SUCCESS;
                                 }
                         }
                 }
         }
 
+        /* Maybe it is sufficient just to release the ST-DMA lock... (if
+         * possible at all) At least, we should check if the lock could be
+         * released after the abort, in case it is kept due to some bug.
+         */
+        maybe_release_dma_irq(instance);
+        local_irq_restore(flags);
+
         /*
          * Case 5 : If we reached this point, the command was not found in any of
          *          the queues.
@@ -2801,21 +2855,14 @@ int NCR5380_abort(Scsi_Cmnd *cmd)
          * broke.
          */
 
-        local_irq_restore(flags);
         printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully before abortion\n", HOSTNO);
 
-        /* Maybe it is sufficient just to release the ST-DMA lock... (if
-         * possible at all) At least, we should check if the lock could be
-         * released after the abort, in case it is kept due to some bug.
-         */
-        falcon_release_lock_if_possible(hostdata);
-
         return FAILED;
 }
 
 
 /*
- * Function : int NCR5380_reset (Scsi_Cmnd *cmd)
+ * Function : int NCR5380_reset (struct scsi_cmnd *cmd)
  *
  * Purpose : reset the SCSI bus.
  *
@@ -2823,20 +2870,14 @@ int NCR5380_abort(Scsi_Cmnd *cmd)
  *
  */
 
-static int NCR5380_bus_reset(Scsi_Cmnd *cmd)
+static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
 {
-        SETUP_HOSTDATA(cmd->device->host);
+        struct Scsi_Host *instance = cmd->device->host;
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
         int i;
         unsigned long flags;
-#if defined(RESET_RUN_DONE)
-        Scsi_Cmnd *connected, *disconnected_queue;
-#endif
-
-        if (!IS_A_TT() && !falcon_got_lock)
-                printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_reset\n",
-                       H_NO(cmd));
 
-        NCR5380_print_status(cmd->device->host);
+        NCR5380_print_status(instance);
 
         /* get in phase */
         NCR5380_write(TARGET_COMMAND_REG,
@@ -2853,89 +2894,6 @@ static int NCR5380_bus_reset(Scsi_Cmnd *cmd)
          * through anymore ... */
         (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
 
-        /* MSch 20140115 - looking at the generic NCR5380 driver, all of this
-         * should go.
-         * Catch-22: if we don't clear all queues, the SCSI driver lock will
-         * not be reset by atari_scsi_reset()!
-         */
-
-#if defined(RESET_RUN_DONE)
-        /* XXX Should now be done by midlevel code, but it's broken XXX */
-        /* XXX see below                                            XXX */
-
-        /* MSch: old-style reset: actually abort all command processing here */
-
-        /* After the reset, there are no more connected or disconnected commands
-         * and no busy units; to avoid problems with re-inserting the commands
-         * into the issue_queue (via scsi_done()), the aborted commands are
-         * remembered in local variables first.
-         */
-        local_irq_save(flags);
-        connected = (Scsi_Cmnd *)hostdata->connected;
-        hostdata->connected = NULL;
-        disconnected_queue = (Scsi_Cmnd *)hostdata->disconnected_queue;
-        hostdata->disconnected_queue = NULL;
-#ifdef SUPPORT_TAGS
-        free_all_tags();
-#endif
-        for (i = 0; i < 8; ++i)
-                hostdata->busy[i] = 0;
-#ifdef REAL_DMA
-        hostdata->dma_len = 0;
-#endif
-        local_irq_restore(flags);
-
-        /* In order to tell the mid-level code which commands were aborted,
-         * set the command status to DID_RESET and call scsi_done() !!!
-         * This ultimately aborts processing of these commands in the mid-level.
-         */
-
-        if ((cmd = connected)) {
-                dprintk(NDEBUG_ABORT, "scsi%d: reset aborted a connected command\n", H_NO(cmd));
-                cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
-                cmd->scsi_done(cmd);
-        }
-
-        for (i = 0; (cmd = disconnected_queue); ++i) {
-                disconnected_queue = NEXT(cmd);
-                SET_NEXT(cmd, NULL);
-                cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
-                cmd->scsi_done(cmd);
-        }
-        if (i > 0)
-                dprintk(NDEBUG_ABORT, "scsi: reset aborted %d disconnected command(s)\n", i);
-
-        /* The Falcon lock should be released after a reset...
-         */
-        /* ++guenther: moved to atari_scsi_reset(), to prevent a race between
-         * unlocking and enabling dma interrupt.
-         */
-/*      falcon_release_lock_if_possible( hostdata );*/
-
-        /* since all commands have been explicitly terminated, we need to tell
-         * the midlevel code that the reset was SUCCESSFUL, and there is no
-         * need to 'wake up' the commands by a request_sense
-         */
-        return SUCCESS;
-#else /* 1 */
-
-        /* MSch: new-style reset handling: let the mid-level do what it can */
-
-        /* ++guenther: MID-LEVEL IS STILL BROKEN.
-         * Mid-level is supposed to requeue all commands that were active on the
-         * various low-level queues. In fact it does this, but that's not enough
-         * because all these commands are subject to timeout. And if a timeout
-         * happens for any removed command, *_abort() is called but all queues
-         * are now empty. Abort then gives up the falcon lock, which is fatal,
-         * since the mid-level will queue more commands and must have the lock
-         * (it's all happening inside timer interrupt handler!!).
-         * Even worse, abort will return NOT_RUNNING for all those commands not
-         * on any queue, so they won't be retried ...
-         *
-         * Conclusion: either scsi.c disables timeout for all resetted commands
-         * immediately, or we lose!  As of linux-2.0.20 it doesn't.
-         */
-
         /* After the reset, there are no more connected or disconnected commands
          * and no busy units; so clear the low-level status here to avoid
          * conflicts when the mid-level code tries to wake up the affected
@@ -2954,16 +2912,16 @@ static int NCR5380_bus_reset(Scsi_Cmnd *cmd)
         hostdata->connected = NULL;
         hostdata->disconnected_queue = NULL;
 #ifdef SUPPORT_TAGS
-        free_all_tags();
+        free_all_tags(hostdata);
 #endif
         for (i = 0; i < 8; ++i)
                 hostdata->busy[i] = 0;
 #ifdef REAL_DMA
         hostdata->dma_len = 0;
 #endif
+
+        maybe_release_dma_irq(instance);
         local_irq_restore(flags);
 
-        /* we did no complete reset of all commands, so a wakeup is required */
         return SUCCESS;
-#endif /* 1 */
 }
diff --git a/drivers/scsi/atari_scsi.c b/drivers/scsi/atari_scsi.c
index b522134528d6..d1c37a386947 100644
--- a/drivers/scsi/atari_scsi.c
+++ b/drivers/scsi/atari_scsi.c
@@ -64,45 +64,57 @@
 /**************************************************************************/
 
 
-
 #include <linux/module.h>
-
-#define AUTOSENSE
-/* For the Atari version, use only polled IO or REAL_DMA */
-#define REAL_DMA
-/* Support tagged queuing? (on devices that are able to... :-) */
-#define SUPPORT_TAGS
-#define MAX_TAGS 32
-
 #include <linux/types.h>
-#include <linux/stddef.h>
-#include <linux/ctype.h>
 #include <linux/delay.h>
-#include <linux/mm.h>
 #include <linux/blkdev.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/nvram.h>
 #include <linux/bitops.h>
 #include <linux/wait.h>
+#include <linux/platform_device.h>
 
 #include <asm/setup.h>
 #include <asm/atarihw.h>
 #include <asm/atariints.h>
-#include <asm/page.h>
-#include <asm/pgtable.h>
-#include <asm/irq.h>
-#include <asm/traps.h>
-
-#include "scsi.h"
-#include <scsi/scsi_host.h>
-#include "atari_scsi.h"
-#include "NCR5380.h"
 #include <asm/atari_stdma.h>
 #include <asm/atari_stram.h>
 #include <asm/io.h>
 
-#include <linux/stat.h>
+#include <scsi/scsi_host.h>
+
+/* Definitions for the core NCR5380 driver. */
+
+#define REAL_DMA
+#define SUPPORT_TAGS
+#define MAX_TAGS                        32
+#define DMA_MIN_SIZE                    32
+
+#define NCR5380_implementation_fields   /* none */
+
+#define NCR5380_read(reg)               atari_scsi_reg_read(reg)
+#define NCR5380_write(reg, value)       atari_scsi_reg_write(reg, value)
+
+#define NCR5380_queue_command           atari_scsi_queue_command
+#define NCR5380_abort                   atari_scsi_abort
+#define NCR5380_show_info               atari_scsi_show_info
+#define NCR5380_info                    atari_scsi_info
+
+#define NCR5380_dma_read_setup(instance, data, count) \
+        atari_scsi_dma_setup(instance, data, count, 0)
+#define NCR5380_dma_write_setup(instance, data, count) \
+        atari_scsi_dma_setup(instance, data, count, 1)
+#define NCR5380_dma_residual(instance) \
+        atari_scsi_dma_residual(instance)
+#define NCR5380_dma_xfer_len(instance, cmd, phase) \
+        atari_dma_xfer_len(cmd->SCp.this_residual, cmd, !((phase) & SR_IO))
+
+#define NCR5380_acquire_dma_irq(instance)      falcon_get_lock(instance)
+#define NCR5380_release_dma_irq(instance)      falcon_release_lock()
+
+#include "NCR5380.h"
+
 
 #define IS_A_TT()       ATARIHW_PRESENT(TT_SCSI)
 
@@ -149,23 +161,6 @@ static inline unsigned long SCSI_DMA_GETADR(void)
         return adr;
 }
 
-static inline void ENABLE_IRQ(void)
-{
-        if (IS_A_TT())
-                atari_enable_irq(IRQ_TT_MFP_SCSI);
-        else
-                atari_enable_irq(IRQ_MFP_FSCSI);
-}
-
-static inline void DISABLE_IRQ(void)
-{
-        if (IS_A_TT())
-                atari_disable_irq(IRQ_TT_MFP_SCSI);
-        else
-                atari_disable_irq(IRQ_MFP_FSCSI);
-}
-
-
 #define HOSTDATA_DMALEN         (((struct NCR5380_hostdata *) \
                                 (atari_scsi_host->hostdata))->dma_len)
 
@@ -178,30 +173,9 @@ static inline void DISABLE_IRQ(void)
 #define AFTER_RESET_DELAY       (5*HZ/2)
 #endif
 
-/***************************** Prototypes *****************************/
-
 #ifdef REAL_DMA
-static int scsi_dma_is_ignored_buserr(unsigned char dma_stat);
 static void atari_scsi_fetch_restbytes(void);
-static long atari_scsi_dma_residual(struct Scsi_Host *instance);
-static int falcon_classify_cmd(Scsi_Cmnd *cmd);
-static unsigned long atari_dma_xfer_len(unsigned long wanted_len,
-                                        Scsi_Cmnd *cmd, int write_flag);
-#endif
-static irqreturn_t scsi_tt_intr(int irq, void *dummy);
-static irqreturn_t scsi_falcon_intr(int irq, void *dummy);
-static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata);
-static void falcon_get_lock(void);
-#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
-static void atari_scsi_reset_boot(void);
 #endif
-static unsigned char atari_scsi_tt_reg_read(unsigned char reg);
-static void atari_scsi_tt_reg_write(unsigned char reg, unsigned char value);
-static unsigned char atari_scsi_falcon_reg_read(unsigned char reg);
-static void atari_scsi_falcon_reg_write(unsigned char reg, unsigned char value);
-
-/************************* End of Prototypes **************************/
-
 
 static struct Scsi_Host *atari_scsi_host;
 static unsigned char (*atari_scsi_reg_read)(unsigned char reg);
@@ -226,8 +200,6 @@ static char		*atari_dma_orig_addr;
 /* mask for address bits that can't be used with the ST-DMA */
 static unsigned long    atari_dma_stram_mask;
 #define STRAM_ADDR(a)   (((a) & atari_dma_stram_mask) == 0)
-/* number of bytes to cut from a transfer to handle NCR overruns */
-static int atari_read_overruns;
 #endif
 
 static int setup_can_queue = -1;
@@ -386,10 +358,6 @@ static irqreturn_t scsi_tt_intr(int irq, void *dummy)
 
         NCR5380_intr(irq, dummy);
 
-#if 0
-        /* To be sure the int is not masked */
-        atari_enable_irq(IRQ_TT_MFP_SCSI);
-#endif
         return IRQ_HANDLED;
 }
 
@@ -480,257 +448,35 @@ static void atari_scsi_fetch_restbytes(void)
 #endif /* REAL_DMA */
 
 
-static int falcon_got_lock = 0;
-static DECLARE_WAIT_QUEUE_HEAD(falcon_fairness_wait);
-static int falcon_trying_lock = 0;
-static DECLARE_WAIT_QUEUE_HEAD(falcon_try_wait);
-static int falcon_dont_release = 0;
-
 /* This function releases the lock on the DMA chip if there is no
- * connected command and the disconnected queue is empty. On
- * releasing, instances of falcon_get_lock are awoken, that put
- * themselves to sleep for fairness. They can now try to get the lock
- * again (but others waiting longer more probably will win).
+ * connected command and the disconnected queue is empty.
  */
 
-static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata)
+static void falcon_release_lock(void)
 {
-        unsigned long flags;
-
         if (IS_A_TT())
                 return;
 
-        local_irq_save(flags);
-
-        if (falcon_got_lock && !hostdata->disconnected_queue &&
-            !hostdata->issue_queue && !hostdata->connected) {
-
-                if (falcon_dont_release) {
-#if 0
-                        printk("WARNING: Lock release not allowed. Ignored\n");
-#endif
-                        local_irq_restore(flags);
-                        return;
-                }
-                falcon_got_lock = 0;
+        if (stdma_is_locked_by(scsi_falcon_intr))
                 stdma_release();
-                wake_up(&falcon_fairness_wait);
-        }
-
-        local_irq_restore(flags);
 }
 
 /* This function manages the locking of the ST-DMA.
  * If the DMA isn't locked already for SCSI, it tries to lock it by
  * calling stdma_lock(). But if the DMA is locked by the SCSI code and
  * there are other drivers waiting for the chip, we do not issue the
- * command immediately but wait on 'falcon_fairness_queue'. We will be
- * waked up when the DMA is unlocked by some SCSI interrupt. After that
- * we try to get the lock again.
- * But we must be prepared that more than one instance of
- * falcon_get_lock() is waiting on the fairness queue. They should not
- * try all at once to call stdma_lock(), one is enough! For that, the
- * first one sets 'falcon_trying_lock', others that see that variable
- * set wait on the queue 'falcon_try_wait'.
- * Complicated, complicated.... Sigh...
+ * command immediately but tell the SCSI mid-layer to defer.
  */
 
-static void falcon_get_lock(void)
+static int falcon_get_lock(struct Scsi_Host *instance)
 {
-        unsigned long flags;
-
         if (IS_A_TT())
-                return;
-
-        local_irq_save(flags);
-
-        wait_event_cmd(falcon_fairness_wait,
-                in_interrupt() || !falcon_got_lock || !stdma_others_waiting(),
-                local_irq_restore(flags),
-                local_irq_save(flags));
-
-        while (!falcon_got_lock) {
-                if (in_irq())
-                        panic("Falcon SCSI hasn't ST-DMA lock in interrupt");
-                if (!falcon_trying_lock) {
-                        falcon_trying_lock = 1;
-                        stdma_lock(scsi_falcon_intr, NULL);
-                        falcon_got_lock = 1;
-                        falcon_trying_lock = 0;
-                        wake_up(&falcon_try_wait);
-                } else {
-                        wait_event_cmd(falcon_try_wait,
-                                falcon_got_lock && !falcon_trying_lock,
-                                local_irq_restore(flags),
-                                local_irq_save(flags));
-                }
-        }
-
-        local_irq_restore(flags);
-        if (!falcon_got_lock)
-                panic("Falcon SCSI: someone stole the lock :-(\n");
-}
-
-
-static int __init atari_scsi_detect(struct scsi_host_template *host)
-{
-        static int called = 0;
-        struct Scsi_Host *instance;
-
-        if (!MACH_IS_ATARI ||
-            (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) ||
-            called)
-                return 0;
-
-        host->proc_name = "Atari";
-
-        atari_scsi_reg_read  = IS_A_TT() ? atari_scsi_tt_reg_read :
-                                           atari_scsi_falcon_reg_read;
-        atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write :
-                                           atari_scsi_falcon_reg_write;
-
-        /* setup variables */
-        host->can_queue =
-                (setup_can_queue > 0) ? setup_can_queue :
-                IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE;
-        host->cmd_per_lun =
-                (setup_cmd_per_lun > 0) ? setup_cmd_per_lun :
-                IS_A_TT() ? ATARI_TT_CMD_PER_LUN : ATARI_FALCON_CMD_PER_LUN;
-        /* Force sg_tablesize to 0 on a Falcon! */
-        host->sg_tablesize =
-                !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE :
-                (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE;
-
-        if (setup_hostid >= 0)
-                host->this_id = setup_hostid;
-        else {
-                /* use 7 as default */
-                host->this_id = 7;
-                /* Test if a host id is set in the NVRam */
-                if (ATARIHW_PRESENT(TT_CLK) && nvram_check_checksum()) {
-                        unsigned char b = nvram_read_byte( 14 );
-                        /* Arbitration enabled? (for TOS) If yes, use configured host ID */
-                        if (b & 0x80)
-                                host->this_id = b & 7;
-                }
-        }
+                return 1;
 
-#ifdef SUPPORT_TAGS
-        if (setup_use_tagged_queuing < 0)
-                setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
-#endif
-#ifdef REAL_DMA
-        /* If running on a Falcon and if there's TT-Ram (i.e., more than one
-         * memory block, since there's always ST-Ram in a Falcon), then allocate a
-         * STRAM_BUFFER_SIZE byte dribble buffer for transfers from/to alternative
-         * Ram.
-         */
-        if (MACH_IS_ATARI && ATARIHW_PRESENT(ST_SCSI) &&
-            !ATARIHW_PRESENT(EXTD_DMA) && m68k_num_memory > 1) {
-                atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI");
-                if (!atari_dma_buffer) {
-                        printk(KERN_ERR "atari_scsi_detect: can't allocate ST-RAM "
-                                        "double buffer\n");
-                        return 0;
-                }
-                atari_dma_phys_buffer = atari_stram_to_phys(atari_dma_buffer);
-                atari_dma_orig_addr = 0;
-        }
-#endif
-        instance = scsi_register(host, sizeof(struct NCR5380_hostdata));
-        if (instance == NULL) {
-                atari_stram_free(atari_dma_buffer);
-                atari_dma_buffer = 0;
-                return 0;
-        }
-        atari_scsi_host = instance;
-        /*
-         * Set irq to 0, to avoid that the mid-level code disables our interrupt
-         * during queue_command calls. This is completely unnecessary, and even
-         * worse causes bad problems on the Falcon, where the int is shared with
-         * IDE and floppy!
-         */
-       instance->irq = 0;
-
-#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
-        atari_scsi_reset_boot();
-#endif
-        NCR5380_init(instance, 0);
-
-        if (IS_A_TT()) {
-
-                /* This int is actually "pseudo-slow", i.e. it acts like a slow
-                 * interrupt after having cleared the pending flag for the DMA
-                 * interrupt. */
-                if (request_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr, IRQ_TYPE_SLOW,
-                                 "SCSI NCR5380", instance)) {
-                        printk(KERN_ERR "atari_scsi_detect: cannot allocate irq %d, aborting",IRQ_TT_MFP_SCSI);
-                        scsi_unregister(atari_scsi_host);
-                        atari_stram_free(atari_dma_buffer);
-                        atari_dma_buffer = 0;
-                        return 0;
-                }
-                tt_mfp.active_edge |= 0x80;             /* SCSI int on L->H */
-#ifdef REAL_DMA
-                tt_scsi_dma.dma_ctrl = 0;
-                atari_dma_residual = 0;
-
-                if (MACH_IS_MEDUSA) {
-                        /* While the read overruns (described by Drew Eckhardt in
-                         * NCR5380.c) never happened on TTs, they do in fact on the Medusa
-                         * (This was the cause why SCSI didn't work right for so long
-                         * there.) Since handling the overruns slows down a bit, I turned
-                         * the #ifdef's into a runtime condition.
-                         *
-                         * In principle it should be sufficient to do max. 1 byte with
-                         * PIO, but there is another problem on the Medusa with the DMA
-                         * rest data register. So 'atari_read_overruns' is currently set
-                         * to 4 to avoid having transfers that aren't a multiple of 4. If
-                         * the rest data bug is fixed, this can be lowered to 1.
-                         */
-                        atari_read_overruns = 4;
-                }
-#endif /*REAL_DMA*/
-        } else { /* ! IS_A_TT */
-
-                /* Nothing to do for the interrupt: the ST-DMA is initialized
-                 * already by atari_init_INTS()
-                 */
-
-#ifdef REAL_DMA
-                atari_dma_residual = 0;
-                atari_dma_active = 0;
-                atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
-                                        : 0xff000000);
-#endif
-        }
+        if (in_interrupt())
+                return stdma_try_lock(scsi_falcon_intr, instance);
 
-        printk(KERN_INFO "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
-#ifdef SUPPORT_TAGS
-                        "TAGGED-QUEUING=%s "
-#endif
-                        "HOSTID=%d",
-                        instance->host_no, instance->hostt->can_queue,
-                        instance->hostt->cmd_per_lun,
-                        instance->hostt->sg_tablesize,
-#ifdef SUPPORT_TAGS
-                        setup_use_tagged_queuing ? "yes" : "no",
-#endif
-                        instance->hostt->this_id );
-        NCR5380_print_options(instance);
-        printk("\n");
-
-        called = 1;
-        return 1;
-}
-
-static int atari_scsi_release(struct Scsi_Host *sh)
-{
-        if (IS_A_TT())
-                free_irq(IRQ_TT_MFP_SCSI, sh);
-        if (atari_dma_buffer)
-                atari_stram_free(atari_dma_buffer);
-        NCR5380_exit(sh);
+        stdma_lock(scsi_falcon_intr, instance);
         return 1;
 }
 
@@ -739,7 +485,7 @@ static int __init atari_scsi_setup(char *str)
 {
         /* Format of atascsi parameter is:
          *   atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
-         * Defaults depend on TT or Falcon, hostid determined at run time.
+         * Defaults depend on TT or Falcon, determined at run time.
          * Negative values mean don't change.
          */
         int ints[6];
@@ -750,36 +496,17 @@ static int __init atari_scsi_setup(char *str)
                 printk("atari_scsi_setup: no arguments!\n");
                 return 0;
         }
-
-        if (ints[0] >= 1) {
-                if (ints[1] > 0)
-                        /* no limits on this, just > 0 */
-                        setup_can_queue = ints[1];
-        }
-        if (ints[0] >= 2) {
-                if (ints[2] > 0)
-                        setup_cmd_per_lun = ints[2];
-        }
-        if (ints[0] >= 3) {
-                if (ints[3] >= 0) {
-                        setup_sg_tablesize = ints[3];
-                        /* Must be <= SG_ALL (255) */
-                        if (setup_sg_tablesize > SG_ALL)
-                                setup_sg_tablesize = SG_ALL;
-                }
-        }
-        if (ints[0] >= 4) {
-                /* Must be between 0 and 7 */
-                if (ints[4] >= 0 && ints[4] <= 7)
-                        setup_hostid = ints[4];
-                else if (ints[4] > 7)
-                        printk("atari_scsi_setup: invalid host ID %d !\n", ints[4]);
-        }
+        if (ints[0] >= 1)
+                setup_can_queue = ints[1];
+        if (ints[0] >= 2)
+                setup_cmd_per_lun = ints[2];
+        if (ints[0] >= 3)
+                setup_sg_tablesize = ints[3];
+        if (ints[0] >= 4)
+                setup_hostid = ints[4];
 #ifdef SUPPORT_TAGS
-        if (ints[0] >= 5) {
-                if (ints[5] >= 0)
-                        setup_use_tagged_queuing = !!ints[5];
-        }
+        if (ints[0] >= 5)
+                setup_use_tagged_queuing = ints[5];
 #endif
 
         return 1;
@@ -788,45 +515,6 @@ static int __init atari_scsi_setup(char *str)
 __setup("atascsi=", atari_scsi_setup);
 #endif /* !MODULE */
 
-static int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
-{
-        int rv;
-        struct NCR5380_hostdata *hostdata =
-                (struct NCR5380_hostdata *)cmd->device->host->hostdata;
-
-        /* For doing the reset, SCSI interrupts must be disabled first,
-         * since the 5380 raises its IRQ line while _RST is active and we
-         * can't disable interrupts completely, since we need the timer.
-         */
-        /* And abort a maybe active DMA transfer */
-        if (IS_A_TT()) {
-                atari_turnoff_irq(IRQ_TT_MFP_SCSI);
-#ifdef REAL_DMA
-                tt_scsi_dma.dma_ctrl = 0;
-#endif /* REAL_DMA */
-        } else {
-                atari_turnoff_irq(IRQ_MFP_FSCSI);
-#ifdef REAL_DMA
-                st_dma.dma_mode_status = 0x90;
-                atari_dma_active = 0;
-                atari_dma_orig_addr = NULL;
-#endif /* REAL_DMA */
-        }
-
-        rv = NCR5380_bus_reset(cmd);
-
-        /* Re-enable ints */
-        if (IS_A_TT()) {
-                atari_turnon_irq(IRQ_TT_MFP_SCSI);
-        } else {
-                atari_turnon_irq(IRQ_MFP_FSCSI);
-        }
-        if (rv == SUCCESS)
-                falcon_release_lock_if_possible(hostdata);
-
-        return rv;
-}
-
 
 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
 static void __init atari_scsi_reset_boot(void)
@@ -860,15 +548,6 @@ static void __init atari_scsi_reset_boot(void)
 }
 #endif
 
-
-static const char *atari_scsi_info(struct Scsi_Host *host)
-{
-        /* atari_scsi_detect() is verbose enough... */
-        static const char string[] = "Atari native SCSI";
-        return string;
-}
-
-
 #if defined(REAL_DMA)
 
 static unsigned long atari_scsi_dma_setup(struct Scsi_Host *instance,
@@ -949,7 +628,7 @@ static long atari_scsi_dma_residual(struct Scsi_Host *instance)
 #define CMD_SURELY_BYTE_MODE    1
 #define CMD_MODE_UNKNOWN                2
 
-static int falcon_classify_cmd(Scsi_Cmnd *cmd)
+static int falcon_classify_cmd(struct scsi_cmnd *cmd)
 {
         unsigned char opcode = cmd->cmnd[0];
 
@@ -981,7 +660,7 @@ static int falcon_classify_cmd(Scsi_Cmnd *cmd)
  */
 
 static unsigned long atari_dma_xfer_len(unsigned long wanted_len,
-                                        Scsi_Cmnd *cmd, int write_flag)
+                                        struct scsi_cmnd *cmd, int write_flag)
 {
         unsigned long   possible_len, limit;
 
@@ -1099,23 +778,247 @@ static void atari_scsi_falcon_reg_write(unsigned char reg, unsigned char value)
 
 #include "atari_NCR5380.c"
 
-static struct scsi_host_template driver_template = {
+static int atari_scsi_bus_reset(struct scsi_cmnd *cmd)
+{
+        int rv;
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+#ifdef REAL_DMA
+        /* Abort a maybe active DMA transfer */
+        if (IS_A_TT()) {
+                tt_scsi_dma.dma_ctrl = 0;
+        } else {
+                st_dma.dma_mode_status = 0x90;
+                atari_dma_active = 0;
+                atari_dma_orig_addr = NULL;
+        }
+#endif
+
+        rv = NCR5380_bus_reset(cmd);
+
+        /* The 5380 raises its IRQ line while _RST is active but the ST DMA
+         * "lock" has been released so this interrupt may end up handled by
+         * floppy or IDE driver (if one of them holds the lock). The NCR5380
+         * interrupt flag has been cleared already.
+         */
+
+        local_irq_restore(flags);
+
+        return rv;
+}
+
+#define DRV_MODULE_NAME         "atari_scsi"
+#define PFX                     DRV_MODULE_NAME ": "
+
+static struct scsi_host_template atari_scsi_template = {
+        .module                 = THIS_MODULE,
+        .proc_name              = DRV_MODULE_NAME,
         .show_info              = atari_scsi_show_info,
         .name                   = "Atari native SCSI",
-        .detect                 = atari_scsi_detect,
-        .release                = atari_scsi_release,
         .info                   = atari_scsi_info,
         .queuecommand           = atari_scsi_queue_command,
         .eh_abort_handler       = atari_scsi_abort,
         .eh_bus_reset_handler   = atari_scsi_bus_reset,
-        .can_queue              = 0, /* initialized at run-time */
-        .this_id                = 0, /* initialized at run-time */
-        .sg_tablesize           = 0, /* initialized at run-time */
-        .cmd_per_lun            = 0, /* initialized at run-time */
+        .this_id                = 7,
         .use_clustering         = DISABLE_CLUSTERING
 };
 
+static int __init atari_scsi_probe(struct platform_device *pdev)
+{
+        struct Scsi_Host *instance;
+        int error;
+        struct resource *irq;
+        int host_flags = 0;
+
+        irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!irq)
+                return -ENODEV;
+
+        if (ATARIHW_PRESENT(TT_SCSI)) {
+                atari_scsi_reg_read  = atari_scsi_tt_reg_read;
+                atari_scsi_reg_write = atari_scsi_tt_reg_write;
+        } else {
+                atari_scsi_reg_read  = atari_scsi_falcon_reg_read;
+                atari_scsi_reg_write = atari_scsi_falcon_reg_write;
+        }
+
+        /* The values for CMD_PER_LUN and CAN_QUEUE are somehow arbitrary.
+         * Higher values should work, too; try it!
+         * (But cmd_per_lun costs memory!)
+         *
+         * But there seems to be a bug somewhere that requires CAN_QUEUE to be
+         * 2*CMD_PER_LUN. At least on a TT, no spurious timeouts seen since
+         * changed CMD_PER_LUN...
+         *
+         * Note: The Falcon currently uses 8/1 setting due to unsolved problems
+         * with cmd_per_lun != 1
+         */
+        if (ATARIHW_PRESENT(TT_SCSI)) {
+                atari_scsi_template.can_queue    = 16;
+                atari_scsi_template.cmd_per_lun  = 8;
+                atari_scsi_template.sg_tablesize = SG_ALL;
+        } else {
+                atari_scsi_template.can_queue    = 8;
+                atari_scsi_template.cmd_per_lun  = 1;
+                atari_scsi_template.sg_tablesize = SG_NONE;
+        }
+
+        if (setup_can_queue > 0)
+                atari_scsi_template.can_queue = setup_can_queue;
+
+        if (setup_cmd_per_lun > 0)
+                atari_scsi_template.cmd_per_lun = setup_cmd_per_lun;
+
+        /* Leave sg_tablesize at 0 on a Falcon! */
+        if (ATARIHW_PRESENT(TT_SCSI) && setup_sg_tablesize >= 0)
+                atari_scsi_template.sg_tablesize = setup_sg_tablesize;
+
+        if (setup_hostid >= 0) {
+                atari_scsi_template.this_id = setup_hostid & 7;
+        } else {
+                /* Test if a host id is set in the NVRam */
+                if (ATARIHW_PRESENT(TT_CLK) && nvram_check_checksum()) {
+                        unsigned char b = nvram_read_byte(14);
+
+                        /* Arbitration enabled? (for TOS)
+                         * If yes, use configured host ID
+                         */
+                        if (b & 0x80)
+                                atari_scsi_template.this_id = b & 7;
+                }
+        }
+
+
+#ifdef REAL_DMA
+        /* If running on a Falcon and if there's TT-Ram (i.e., more than one
+         * memory block, since there's always ST-Ram in a Falcon), then
+         * allocate a STRAM_BUFFER_SIZE byte dribble buffer for transfers
+         * from/to alternative Ram.
+         */
+        if (ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(EXTD_DMA) &&
+            m68k_num_memory > 1) {
+                atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI");
+                if (!atari_dma_buffer) {
+                        pr_err(PFX "can't allocate ST-RAM double buffer\n");
+                        return -ENOMEM;
+                }
+                atari_dma_phys_buffer = atari_stram_to_phys(atari_dma_buffer);
+                atari_dma_orig_addr = 0;
+        }
+#endif
+
+        instance = scsi_host_alloc(&atari_scsi_template,
+                                   sizeof(struct NCR5380_hostdata));
+        if (!instance) {
+                error = -ENOMEM;
+                goto fail_alloc;
+        }
+        atari_scsi_host = instance;
+
+#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
+        atari_scsi_reset_boot();
+#endif
+
+        instance->irq = irq->start;
+
+        host_flags |= IS_A_TT() ? 0 : FLAG_LATE_DMA_SETUP;
+
+#ifdef SUPPORT_TAGS
+        host_flags |= setup_use_tagged_queuing > 0 ? FLAG_TAGGED_QUEUING : 0;
+#endif
+
+        NCR5380_init(instance, host_flags);
+
+        if (IS_A_TT()) {
+                error = request_irq(instance->irq, scsi_tt_intr, 0,
+                                    "NCR5380", instance);
+                if (error) {
+                        pr_err(PFX "request irq %d failed, aborting\n",
+                               instance->irq);
+                        goto fail_irq;
+                }
+                tt_mfp.active_edge |= 0x80;     /* SCSI int on L->H */
+#ifdef REAL_DMA
+                tt_scsi_dma.dma_ctrl = 0;
+                atari_dma_residual = 0;
+
+                /* While the read overruns (described by Drew Eckhardt in
+                 * NCR5380.c) never happened on TTs, they do in fact on the
+                 * Medusa (This was the cause why SCSI didn't work right for
+                 * so long there.) Since handling the overruns slows down
+                 * a bit, I turned the #ifdef's into a runtime condition.
+                 *
+                 * In principle it should be sufficient to do max. 1 byte with
+                 * PIO, but there is another problem on the Medusa with the DMA
+                 * rest data register. So read_overruns is currently set
+                 * to 4 to avoid having transfers that aren't a multiple of 4.
+                 * If the rest data bug is fixed, this can be lowered to 1.
+                 */
+                if (MACH_IS_MEDUSA) {
+                        struct NCR5380_hostdata *hostdata =
+                                shost_priv(instance);
+
+                        hostdata->read_overruns = 4;
+                }
+#endif
+        } else {
+                /* Nothing to do for the interrupt: the ST-DMA is initialized
+                 * already.
+                 */
+#ifdef REAL_DMA
+                atari_dma_residual = 0;
+                atari_dma_active = 0;
+                atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
+                                        : 0xff000000);
+#endif
+        }
+
+        error = scsi_add_host(instance, NULL);
+        if (error)
+                goto fail_host;
+
+        platform_set_drvdata(pdev, instance);
+
+        scsi_scan_host(instance);
+        return 0;
+
+fail_host:
+        if (IS_A_TT())
+                free_irq(instance->irq, instance);
+fail_irq:
+        NCR5380_exit(instance);
+        scsi_host_put(instance);
+fail_alloc:
+        if (atari_dma_buffer)
+                atari_stram_free(atari_dma_buffer);
+        return error;
+}
+
+static int __exit atari_scsi_remove(struct platform_device *pdev)
+{
+        struct Scsi_Host *instance = platform_get_drvdata(pdev);
+
+        scsi_remove_host(instance);
+        if (IS_A_TT())
+                free_irq(instance->irq, instance);
+        NCR5380_exit(instance);
+        scsi_host_put(instance);
+        if (atari_dma_buffer)
+                atari_stram_free(atari_dma_buffer);
+        return 0;
+}
+
+static struct platform_driver atari_scsi_driver = {
+        .remove = __exit_p(atari_scsi_remove),
+        .driver = {
+                .name   = DRV_MODULE_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
 
-#include "scsi_module.c"
+module_platform_driver_probe(atari_scsi_driver, atari_scsi_probe);
 
+MODULE_ALIAS("platform:" DRV_MODULE_NAME);
 MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/atari_scsi.h b/drivers/scsi/atari_scsi.h
deleted file mode 100644
index 3299d91d7336..000000000000
--- a/drivers/scsi/atari_scsi.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * atari_scsi.h -- Header file for the Atari native SCSI driver
- *
- * Copyright 1994 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
- *
- * (Loosely based on the work of Robert De Vries' team)
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file COPYING in the main directory of this archive
- * for more details.
- *
- */
-
-
-#ifndef ATARI_SCSI_H
-#define ATARI_SCSI_H
-
-/* (I_HAVE_OVERRUNS stuff removed) */
-
-#ifndef ASM
-/* The values for CMD_PER_LUN and CAN_QUEUE are somehow arbitrary. Higher
- * values should work, too; try it! (but cmd_per_lun costs memory!) */
-
-/* But there seems to be a bug somewhere that requires CAN_QUEUE to be
- * 2*CMD_PER_LUN. At least on a TT, no spurious timeouts seen since
- * changed CMD_PER_LUN... */
-
-/* Note: The Falcon currently uses 8/1 setting due to unsolved problems with
- * cmd_per_lun != 1 */
-
-#define ATARI_TT_CAN_QUEUE              16
-#define ATARI_TT_CMD_PER_LUN            8
-#define ATARI_TT_SG_TABLESIZE           SG_ALL
-
-#define ATARI_FALCON_CAN_QUEUE          8
-#define ATARI_FALCON_CMD_PER_LUN        1
-#define ATARI_FALCON_SG_TABLESIZE       SG_NONE
-
-#define DEFAULT_USE_TAGGED_QUEUING      0
-
-
-#define NCR5380_implementation_fields   /* none */
-
-#define NCR5380_read(reg)                 atari_scsi_reg_read( reg )
-#define NCR5380_write(reg, value) atari_scsi_reg_write( reg, value )
-
-#define NCR5380_intr atari_scsi_intr
-#define NCR5380_queue_command atari_scsi_queue_command
-#define NCR5380_abort atari_scsi_abort
-#define NCR5380_show_info atari_scsi_show_info
-#define NCR5380_dma_read_setup(inst,d,c) atari_scsi_dma_setup (inst, d, c, 0)
-#define NCR5380_dma_write_setup(inst,d,c) atari_scsi_dma_setup (inst, d, c, 1)
-#define NCR5380_dma_residual(inst) atari_scsi_dma_residual( inst )
-#define NCR5380_dma_xfer_len(i,cmd,phase) \
-        atari_dma_xfer_len(cmd->SCp.this_residual,cmd,((phase) & SR_IO) ? 0 : 1)
-
-#endif /* ndef ASM */
-#endif /* ATARI_SCSI_H */
-
-
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 30d74a06b993..f3193406776c 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -556,7 +556,7 @@ static struct scsi_host_template beiscsi_sht = {
         .name = "Emulex 10Gbe open-iscsi Initiator Driver",
         .proc_name = DRV_NAME,
         .queuecommand = iscsi_queuecommand,
-        .change_queue_depth = iscsi_change_queue_depth,
+        .change_queue_depth = scsi_change_queue_depth,
         .slave_configure = beiscsi_slave_configure,
         .target_alloc = iscsi_target_alloc,
         .eh_abort_handler = beiscsi_eh_abort,
@@ -570,7 +570,7 @@ static struct scsi_host_template beiscsi_sht = {
         .cmd_per_lun = BEISCSI_CMD_PER_LUN,
         .use_clustering = ENABLE_CLUSTERING,
         .vendor_id = SCSI_NL_VID_TYPE_PCI | BE_VENDOR_ID,
-
+        .track_queue_depth = 1,
 };
 
 static struct scsi_transport_template *beiscsi_scsi_transport;
diff --git a/drivers/scsi/bfa/bfad_debugfs.c b/drivers/scsi/bfa/bfad_debugfs.c
index 8e83d0474fe7..74a307c0a240 100644
--- a/drivers/scsi/bfa/bfad_debugfs.c
+++ b/drivers/scsi/bfa/bfad_debugfs.c
@@ -260,18 +260,9 @@ bfad_debugfs_write_regrd(struct file *file, const char __user *buf,
         unsigned long flags;
         void *kern_buf;
 
-        kern_buf = kzalloc(nbytes, GFP_KERNEL);
-
-        if (!kern_buf) {
-                printk(KERN_INFO "bfad[%d]: Failed to allocate buffer\n",
-                                bfad->inst_no);
-                return -ENOMEM;
-        }
-
-        if (copy_from_user(kern_buf, (void  __user *)buf, nbytes)) {
-                kfree(kern_buf);
-                return -ENOMEM;
-        }
+        kern_buf = memdup_user(buf, nbytes);
+        if (IS_ERR(kern_buf))
+                return PTR_ERR(kern_buf);
 
         rc = sscanf(kern_buf, "%x:%x", &addr, &len);
         if (rc < 2) {
@@ -336,18 +327,9 @@ bfad_debugfs_write_regwr(struct file *file, const char __user *buf,
         unsigned long flags;
         void *kern_buf;
 
-        kern_buf = kzalloc(nbytes, GFP_KERNEL);
-
-        if (!kern_buf) {
-                printk(KERN_INFO "bfad[%d]: Failed to allocate buffer\n",
-                                bfad->inst_no);
-                return -ENOMEM;
-        }
-
-        if (copy_from_user(kern_buf, (void  __user *)buf, nbytes)) {
-                kfree(kern_buf);
-                return -ENOMEM;
-        }
+        kern_buf = memdup_user(buf, nbytes);
+        if (IS_ERR(kern_buf))
+                return PTR_ERR(kern_buf);
 
         rc = sscanf(kern_buf, "%x:%x", &addr, &val);
         if (rc < 2) {
diff --git a/drivers/scsi/bfa/bfad_im.c b/drivers/scsi/bfa/bfad_im.c
index f067332bf763..7223b0006740 100644
--- a/drivers/scsi/bfa/bfad_im.c
+++ b/drivers/scsi/bfa/bfad_im.c
@@ -776,11 +776,7 @@ bfad_thread_workq(struct bfad_s *bfad)
 static int
 bfad_im_slave_configure(struct scsi_device *sdev)
 {
-        if (sdev->tagged_supported)
-                scsi_activate_tcq(sdev, bfa_lun_queue_depth);
-        else
-                scsi_deactivate_tcq(sdev, bfa_lun_queue_depth);
-
+        scsi_change_queue_depth(sdev, bfa_lun_queue_depth);
         return 0;
 }
 
@@ -804,6 +800,7 @@ struct scsi_host_template bfad_im_scsi_host_template = {
         .shost_attrs = bfad_im_host_attrs,
         .max_sectors = BFAD_MAX_SECTORS,
         .vendor_id = BFA_PCI_VENDOR_ID_BROCADE,
+        .use_blk_tags = 1,
 };
 
 struct scsi_host_template bfad_im_vport_template = {
@@ -825,6 +822,7 @@ struct scsi_host_template bfad_im_vport_template = {
         .use_clustering = ENABLE_CLUSTERING,
         .shost_attrs = bfad_im_vport_attrs,
         .max_sectors = BFAD_MAX_SECTORS,
+        .use_blk_tags = 1,
 };
 
 bfa_status_t
@@ -868,14 +866,8 @@ bfad_ramp_up_qdepth(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
                         if (bfa_lun_queue_depth > tmp_sdev->queue_depth) {
                                 if (tmp_sdev->id != sdev->id)
                                         continue;
-                                if (tmp_sdev->ordered_tags)
-                                        scsi_adjust_queue_depth(tmp_sdev,
-                                                MSG_ORDERED_TAG,
-                                                tmp_sdev->queue_depth + 1);
-                                else
-                                        scsi_adjust_queue_depth(tmp_sdev,
-                                                MSG_SIMPLE_TAG,
-                                                tmp_sdev->queue_depth + 1);
+                                scsi_change_queue_depth(tmp_sdev,
+                                        tmp_sdev->queue_depth + 1);
 
                                 itnim->last_ramp_up_time = jiffies;
                         }
diff --git a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
index 79e5c94107a9..e861f286b42e 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
@@ -412,6 +412,7 @@ static int bnx2fc_rcv(struct sk_buff *skb, struct net_device *dev,
         struct fc_frame_header *fh;
         struct fcoe_rcv_info *fr;
         struct fcoe_percpu_s *bg;
+        struct sk_buff *tmp_skb;
         unsigned short oxid;
 
         interface = container_of(ptype, struct bnx2fc_interface,
@@ -424,6 +425,12 @@ static int bnx2fc_rcv(struct sk_buff *skb, struct net_device *dev,
                 goto err;
         }
 
+        tmp_skb = skb_share_check(skb, GFP_ATOMIC);
+        if (!tmp_skb)
+                goto err;
+
+        skb = tmp_skb;
+
         if (unlikely(eth_hdr(skb)->h_proto != htons(ETH_P_FCOE))) {
                 printk(KERN_ERR PFX "bnx2fc_rcv: Wrong FC type frame\n");
                 goto err;
@@ -1081,7 +1088,7 @@ static int bnx2fc_vport_create(struct fc_vport *vport, bool disabled)
         mutex_unlock(&bnx2fc_dev_lock);
         rtnl_unlock();
 
-        if (IS_ERR(vn_port)) {
+        if (!vn_port) {
                 printk(KERN_ERR PFX "bnx2fc_vport_create (%s) failed\n",
                         netdev->name);
                 return -EIO;
@@ -2195,6 +2202,7 @@ static int _bnx2fc_create(struct net_device *netdev,
         interface = bnx2fc_interface_create(hba, netdev, fip_mode);
         if (!interface) {
                 printk(KERN_ERR PFX "bnx2fc_interface_create failed\n");
+                rc = -ENOMEM;
                 goto ifput_err;
         }
 
@@ -2783,13 +2791,15 @@ static struct scsi_host_template bnx2fc_shost_template = {
         .eh_target_reset_handler = bnx2fc_eh_target_reset, /* tgt reset */
         .eh_host_reset_handler  = fc_eh_host_reset,
         .slave_alloc            = fc_slave_alloc,
-        .change_queue_depth     = fc_change_queue_depth,
-        .change_queue_type      = fc_change_queue_type,
+        .change_queue_depth     = scsi_change_queue_depth,
+        .change_queue_type      = scsi_change_queue_type,
         .this_id                = -1,
         .cmd_per_lun            = 3,
         .use_clustering         = ENABLE_CLUSTERING,
         .sg_tablesize           = BNX2FC_MAX_BDS_PER_CMD,
         .max_sectors            = 1024,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
 
 static struct libfc_function_template bnx2fc_libfc_fcn_templ = {
diff --git a/drivers/scsi/bnx2fc/bnx2fc_io.c b/drivers/scsi/bnx2fc/bnx2fc_io.c
index 5b99844ef6bf..4b56858c1df2 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_io.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_io.c
@@ -1725,7 +1725,6 @@ void bnx2fc_build_fcp_cmnd(struct bnx2fc_cmd *io_req,
                                   struct fcp_cmnd *fcp_cmnd)
 {
         struct scsi_cmnd *sc_cmd = io_req->sc_cmd;
-        char tag[2];
 
         memset(fcp_cmnd, 0, sizeof(struct fcp_cmnd));
 
@@ -1739,21 +1738,10 @@ void bnx2fc_build_fcp_cmnd(struct bnx2fc_cmd *io_req,
         fcp_cmnd->fc_tm_flags = io_req->mp_req.tm_flags;
         fcp_cmnd->fc_flags = io_req->io_req_flags;
 
-        if (scsi_populate_tag_msg(sc_cmd, tag)) {
-                switch (tag[0]) {
-                case HEAD_OF_QUEUE_TAG:
-                        fcp_cmnd->fc_pri_ta = FCP_PTA_HEADQ;
-                        break;
-                case ORDERED_QUEUE_TAG:
-                        fcp_cmnd->fc_pri_ta = FCP_PTA_ORDERED;
-                        break;
-                default:
-                        fcp_cmnd->fc_pri_ta = FCP_PTA_SIMPLE;
-                        break;
-                }
-        } else {
+        if (sc_cmd->flags & SCMD_TAGGED)
+                fcp_cmnd->fc_pri_ta = FCP_PTA_SIMPLE;
+        else
                 fcp_cmnd->fc_pri_ta = 0;
-        }
 }
 
 static void bnx2fc_parse_fcp_rsp(struct bnx2fc_cmd *io_req,
diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
index 7a36388822aa..e53078d03309 100644
--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
+++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
@@ -2259,7 +2259,7 @@ static struct scsi_host_template bnx2i_host_template = {
         .eh_abort_handler       = iscsi_eh_abort,
         .eh_device_reset_handler = iscsi_eh_device_reset,
         .eh_target_reset_handler = iscsi_eh_recover_target,
-        .change_queue_depth     = iscsi_change_queue_depth,
+        .change_queue_depth     = scsi_change_queue_depth,
         .target_alloc           = iscsi_target_alloc,
         .can_queue              = 2048,
         .max_sectors            = 127,
@@ -2268,6 +2268,7 @@ static struct scsi_host_template bnx2i_host_template = {
         .use_clustering         = ENABLE_CLUSTERING,
         .sg_tablesize           = ISCSI_MAX_BDS_PER_CMD,
         .shost_attrs            = bnx2i_dev_attributes,
+        .track_queue_depth      = 1,
 };
 
 struct iscsi_transport bnx2i_iscsi_transport = {
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index ef5ae0d03616..6bac8a746ee2 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -85,8 +85,7 @@ static const char * vendor_labels[CH_TYPES-4] = {
 // module_param_string_array(vendor_labels, NULL, 0444);
 
 #define ch_printk(prefix, ch, fmt, a...) \
-        sdev_printk(prefix, (ch)->device, "[%s] " fmt, \
-                    (ch)->name, ##a)
+        sdev_prefix_printk(prefix, (ch)->device, (ch)->name, fmt, ##a)
 
 #define DPRINTK(fmt, arg...)                                            \
 do {                                                                    \
@@ -183,7 +182,7 @@ static int ch_find_errno(struct scsi_sense_hdr *sshdr)
 }
 
 static int
-ch_do_scsi(scsi_changer *ch, unsigned char *cmd,
+ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
            void *buffer, unsigned buflength,
            enum dma_data_direction direction)
 {
@@ -197,7 +196,7 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd,
         errno = 0;
         if (debug) {
                 DPRINTK("command: ");
-                __scsi_print_command(cmd);
+                __scsi_print_command(cmd, cmd_len);
         }
 
         result = scsi_execute_req(ch->device, cmd, direction, buffer,
@@ -207,7 +206,7 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd,
         DPRINTK("result: 0x%x\n",result);
         if (driver_byte(result) & DRIVER_SENSE) {
                 if (debug)
-                        scsi_print_sense_hdr(ch->name, &sshdr);
+                        scsi_print_sense_hdr(ch->device, ch->name, &sshdr);
                 errno = ch_find_errno(&sshdr);
 
                 switch(sshdr.sense_key) {
@@ -258,7 +257,8 @@ ch_read_element_status(scsi_changer *ch, u_int elem, char *data)
         cmd[3] = elem        & 0xff;
         cmd[5] = 1;
         cmd[9] = 255;
-        if (0 == (result = ch_do_scsi(ch, cmd, buffer, 256, DMA_FROM_DEVICE))) {
+        if (0 == (result = ch_do_scsi(ch, cmd, 12,
+                                      buffer, 256, DMA_FROM_DEVICE))) {
                 if (((buffer[16] << 8) | buffer[17]) != elem) {
                         DPRINTK("asked for element 0x%02x, got 0x%02x\n",
                                 elem,(buffer[16] << 8) | buffer[17]);
@@ -288,7 +288,7 @@ ch_init_elem(scsi_changer *ch)
         memset(cmd,0,sizeof(cmd));
         cmd[0] = INITIALIZE_ELEMENT_STATUS;
         cmd[1] = (ch->device->lun & 0x7) << 5;
-        err = ch_do_scsi(ch, cmd, NULL, 0, DMA_NONE);
+        err = ch_do_scsi(ch, cmd, 6, NULL, 0, DMA_NONE);
         VPRINTK(KERN_INFO, "... finished\n");
         return err;
 }
@@ -310,10 +310,10 @@ ch_readconfig(scsi_changer *ch)
         cmd[1] = (ch->device->lun & 0x7) << 5;
         cmd[2] = 0x1d;
         cmd[4] = 255;
-        result = ch_do_scsi(ch, cmd, buffer, 255, DMA_FROM_DEVICE);
+        result = ch_do_scsi(ch, cmd, 10, buffer, 255, DMA_FROM_DEVICE);
         if (0 != result) {
                 cmd[1] |= (1<<3);
-                result  = ch_do_scsi(ch, cmd, buffer, 255, DMA_FROM_DEVICE);
+                result  = ch_do_scsi(ch, cmd, 10, buffer, 255, DMA_FROM_DEVICE);
         }
         if (0 == result) {
                 ch->firsts[CHET_MT] =
@@ -438,7 +438,7 @@ ch_position(scsi_changer *ch, u_int trans, u_int elem, int rotate)
         cmd[4]  = (elem  >> 8) & 0xff;
         cmd[5]  =  elem        & 0xff;
         cmd[8]  = rotate ? 1 : 0;
-        return ch_do_scsi(ch, cmd, NULL, 0, DMA_NONE);
+        return ch_do_scsi(ch, cmd, 10, NULL, 0, DMA_NONE);
 }
 
 static int
@@ -459,7 +459,7 @@ ch_move(scsi_changer *ch, u_int trans, u_int src, u_int dest, int rotate)
         cmd[6]  = (dest  >> 8) & 0xff;
         cmd[7]  =  dest        & 0xff;
         cmd[10] = rotate ? 1 : 0;
-        return ch_do_scsi(ch, cmd, NULL,0, DMA_NONE);
+        return ch_do_scsi(ch, cmd, 12, NULL,0, DMA_NONE);
 }
 
 static int
@@ -485,7 +485,7 @@ ch_exchange(scsi_changer *ch, u_int trans, u_int src,
         cmd[9]  =  dest2       & 0xff;
         cmd[10] = (rotate1 ? 1 : 0) | (rotate2 ? 2 : 0);
 
-        return ch_do_scsi(ch, cmd, NULL,0, DMA_NONE);
+        return ch_do_scsi(ch, cmd, 12, NULL, 0, DMA_NONE);
 }
 
 static void
@@ -535,7 +535,7 @@ ch_set_voltag(scsi_changer *ch, u_int elem,
         memcpy(buffer,tag,32);
         ch_check_voltag(buffer);
 
-        result = ch_do_scsi(ch, cmd, buffer, 256, DMA_TO_DEVICE);
+        result = ch_do_scsi(ch, cmd, 12, buffer, 256, DMA_TO_DEVICE);
         kfree(buffer);
         return result;
 }
@@ -616,6 +616,11 @@ static long ch_ioctl(struct file *file,
         int retval;
         void __user *argp = (void __user *)arg;
 
+        retval = scsi_ioctl_block_when_processing_errors(ch->device, cmd,
+                        file->f_flags & O_NDELAY);
+        if (retval)
+                return retval;
+
         switch (cmd) {
         case CHIOGPARAMS:
         {
@@ -766,7 +771,8 @@ static long ch_ioctl(struct file *file,
                 ch_cmd[5] = 1;
                 ch_cmd[9] = 255;
 
-                result = ch_do_scsi(ch, ch_cmd, buffer, 256, DMA_FROM_DEVICE);
+                result = ch_do_scsi(ch, ch_cmd, 12,
+                                    buffer, 256, DMA_FROM_DEVICE);
                 if (!result) {
                         cge.cge_status = buffer[18];
                         cge.cge_flags = 0;
@@ -966,9 +972,9 @@ static int ch_remove(struct device *dev)
 }
 
 static struct scsi_driver ch_template = {
-        .owner          = THIS_MODULE,
         .gendrv         = {
                 .name   = "ch",
+                .owner  = THIS_MODULE,
                 .probe  = ch_probe,
                 .remove = ch_remove,
         },
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index d35a5d6c8d7c..e2068a2621c4 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -21,15 +21,21 @@
 
 
 /* Commands with service actions that change the command name */
-#define SERVICE_ACTION_IN_12 0xab
-#define SERVICE_ACTION_OUT_12 0xa9
-#define SERVICE_ACTION_BIDIRECTIONAL 0x9d
-#define SERVICE_ACTION_IN_16 0x9e
-#define SERVICE_ACTION_OUT_16 0x9f
 #define THIRD_PARTY_COPY_OUT 0x83
 #define THIRD_PARTY_COPY_IN 0x84
 
+#define VENDOR_SPECIFIC_CDB 0xc0
 
+struct sa_name_list {
+        int opcode;
+        const struct value_name_pair *arr;
+        int arr_sz;
+};
+
+struct value_name_pair {
+        int value;
+        const char * name;
+};
 
 #ifdef CONFIG_SCSI_CONSTANTS
 static const char * cdb_byte0_names[] = {
@@ -102,11 +108,6 @@ static const char * cdb_byte0_names[] = {
             "Volume set (out), Send DVD structure",
 };
 
-struct value_name_pair {
-        int value;
-        const char * name;
-};
-
 static const struct value_name_pair maint_in_arr[] = {
         {0x5, "Report identifying information"},
         {0xa, "Report target port groups"},
@@ -244,170 +245,119 @@ static const struct value_name_pair variable_length_arr[] = {
 };
 #define VARIABLE_LENGTH_SZ ARRAY_SIZE(variable_length_arr)
 
-static const char * get_sa_name(const struct value_name_pair * arr,
-                                int arr_sz, int service_action)
-{
-        int k;
+static struct sa_name_list sa_names_arr[] = {
+        {VARIABLE_LENGTH_CMD, variable_length_arr, VARIABLE_LENGTH_SZ},
+        {MAINTENANCE_IN, maint_in_arr, MAINT_IN_SZ},
+        {MAINTENANCE_OUT, maint_out_arr, MAINT_OUT_SZ},
+        {PERSISTENT_RESERVE_IN, pr_in_arr, PR_IN_SZ},
+        {PERSISTENT_RESERVE_OUT, pr_out_arr, PR_OUT_SZ},
+        {SERVICE_ACTION_IN_12, serv_in12_arr, SERV_IN12_SZ},
+        {SERVICE_ACTION_OUT_12, serv_out12_arr, SERV_OUT12_SZ},
+        {SERVICE_ACTION_BIDIRECTIONAL, serv_bidi_arr, SERV_BIDI_SZ},
+        {SERVICE_ACTION_IN_16, serv_in16_arr, SERV_IN16_SZ},
+        {SERVICE_ACTION_OUT_16, serv_out16_arr, SERV_OUT16_SZ},
+        {THIRD_PARTY_COPY_IN, tpc_in_arr, TPC_IN_SZ},
+        {THIRD_PARTY_COPY_OUT, tpc_out_arr, TPC_OUT_SZ},
+        {0, NULL, 0},
+};
 
-        for (k = 0; k < arr_sz; ++k, ++arr) {
-                if (service_action == arr->value)
-                        break;
-        }
-        return (k < arr_sz) ? arr->name : NULL;
-}
+#else /* ifndef CONFIG_SCSI_CONSTANTS */
+static const char *cdb_byte0_names[0];
+
+static struct sa_name_list sa_names_arr[] = {
+        {VARIABLE_LENGTH_CMD, NULL, 0},
+        {MAINTENANCE_IN, NULL, 0},
+        {MAINTENANCE_OUT, NULL, 0},
+        {PERSISTENT_RESERVE_IN, NULL, 0},
+        {PERSISTENT_RESERVE_OUT, NULL, 0},
+        {SERVICE_ACTION_IN_12, NULL, 0},
+        {SERVICE_ACTION_OUT_12, NULL, 0},
+        {SERVICE_ACTION_BIDIRECTIONAL, NULL, 0},
+        {SERVICE_ACTION_IN_16, NULL, 0},
+        {SERVICE_ACTION_OUT_16, NULL, 0},
+        {THIRD_PARTY_COPY_IN, NULL, 0},
+        {THIRD_PARTY_COPY_OUT, NULL, 0},
+        {0, NULL, 0},
+};
+#endif /* CONFIG_SCSI_CONSTANTS */
 
-/* attempt to guess cdb length if cdb_len==0 . No trailing linefeed. */
-static void print_opcode_name(unsigned char * cdbp, int cdb_len)
+static bool scsi_opcode_sa_name(int opcode, int service_action,
+                                const char **cdb_name, const char **sa_name)
 {
-        int sa, len, cdb0;
-        int fin_name = 0;
-        const char * name;
+        struct sa_name_list *sa_name_ptr;
+        const struct value_name_pair *arr = NULL;
+        int arr_sz, k;
 
-        cdb0 = cdbp[0];
-        switch(cdb0) {
-        case VARIABLE_LENGTH_CMD:
-                len = scsi_varlen_cdb_length(cdbp);
-                if (len < 10) {
-                        printk("short variable length command, "
-                               "len=%d ext_len=%d", len, cdb_len);
-                        break;
-                }
-                sa = (cdbp[8] << 8) + cdbp[9];
-                name = get_sa_name(variable_length_arr, VARIABLE_LENGTH_SZ,
-                                   sa);
-                if (name)
-                        printk("%s", name);
-                else
-                        printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
+        *cdb_name = NULL;
+        if (opcode >= VENDOR_SPECIFIC_CDB)
+                return false;
 
-                if ((cdb_len > 0) && (len != cdb_len))
-                        printk(", in_cdb_len=%d, ext_len=%d", len, cdb_len);
+        if (opcode < ARRAY_SIZE(cdb_byte0_names))
+                *cdb_name = cdb_byte0_names[opcode];
 
-                break;
-        case MAINTENANCE_IN:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(maint_in_arr, MAINT_IN_SZ, sa);
-                fin_name = 1;
-                break;
-        case MAINTENANCE_OUT:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(maint_out_arr, MAINT_OUT_SZ, sa);
-                fin_name = 1;
-                break;
-        case PERSISTENT_RESERVE_IN:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(pr_in_arr, PR_IN_SZ, sa);
-                fin_name = 1;
-                break;
-        case PERSISTENT_RESERVE_OUT:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(pr_out_arr, PR_OUT_SZ, sa);
-                fin_name = 1;
-                break;
-        case SERVICE_ACTION_IN_12:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(serv_in12_arr, SERV_IN12_SZ, sa);
-                fin_name = 1;
-                break;
-        case SERVICE_ACTION_OUT_12:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(serv_out12_arr, SERV_OUT12_SZ, sa);
-                fin_name = 1;
-                break;
-        case SERVICE_ACTION_BIDIRECTIONAL:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(serv_bidi_arr, SERV_BIDI_SZ, sa);
-                fin_name = 1;
-                break;
-        case SERVICE_ACTION_IN_16:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(serv_in16_arr, SERV_IN16_SZ, sa);
-                fin_name = 1;
-                break;
-        case SERVICE_ACTION_OUT_16:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(serv_out16_arr, SERV_OUT16_SZ, sa);
-                fin_name = 1;
-                break;
-        case THIRD_PARTY_COPY_IN:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(tpc_in_arr, TPC_IN_SZ, sa);
-                fin_name = 1;
-                break;
-        case THIRD_PARTY_COPY_OUT:
-                sa = cdbp[1] & 0x1f;
-                name = get_sa_name(tpc_out_arr, TPC_OUT_SZ, sa);
-                fin_name = 1;
-                break;
-        default:
-                if (cdb0 < 0xc0) {
-                        name = cdb_byte0_names[cdb0];
-                        if (name)
-                                printk("%s", name);
-                        else
-                                printk("cdb[0]=0x%x (reserved)", cdb0);
-                } else
-                        printk("cdb[0]=0x%x (vendor)", cdb0);
-                break;
+        for (sa_name_ptr = sa_names_arr; sa_name_ptr->arr; ++sa_name_ptr) {
+                if (sa_name_ptr->opcode == opcode) {
+                        arr = sa_name_ptr->arr;
+                        arr_sz = sa_name_ptr->arr_sz;
+                        break;
+                }
         }
-        if (fin_name) {
-                if (name)
-                        printk("%s", name);
-                else
-                        printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
+        if (!arr)
+                return false;
+
+        for (k = 0; k < arr_sz; ++k, ++arr) {
+                if (service_action == arr->value)
+                        break;
         }
-}
+        if (k < arr_sz)
+                *sa_name = arr->name;
 
-#else /* ifndef CONFIG_SCSI_CONSTANTS */
+        return true;
+}
 
-static void print_opcode_name(unsigned char * cdbp, int cdb_len)
+static void print_opcode_name(const unsigned char *cdbp, size_t cdb_len)
 {
-        int sa, len, cdb0;
+        int sa, cdb0;
+        const char *cdb_name = NULL, *sa_name = NULL;
 
         cdb0 = cdbp[0];
-        switch(cdb0) {
-        case VARIABLE_LENGTH_CMD:
-                len = scsi_varlen_cdb_length(cdbp);
-                if (len < 10) {
-                        printk("short opcode=0x%x command, len=%d "
-                               "ext_len=%d", cdb0, len, cdb_len);
-                        break;
+        if (cdb0 == VARIABLE_LENGTH_CMD) {
+                if (cdb_len < 10) {
+                        printk("short variable length command, len=%zu",
+                               cdb_len);
+                        return;
                 }
                 sa = (cdbp[8] << 8) + cdbp[9];
-                printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
-                if (len != cdb_len)
-                        printk(", in_cdb_len=%d, ext_len=%d", len, cdb_len);
-                break;
-        case MAINTENANCE_IN:
-        case MAINTENANCE_OUT:
-        case PERSISTENT_RESERVE_IN:
-        case PERSISTENT_RESERVE_OUT:
-        case SERVICE_ACTION_IN_12:
-        case SERVICE_ACTION_OUT_12:
-        case SERVICE_ACTION_BIDIRECTIONAL:
-        case SERVICE_ACTION_IN_16:
-        case SERVICE_ACTION_OUT_16:
-        case THIRD_PARTY_COPY_IN:
-        case THIRD_PARTY_COPY_OUT:
+        } else
                 sa = cdbp[1] & 0x1f;
-                printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
-                break;
-        default:
-                if (cdb0 < 0xc0)
+
+        if (!scsi_opcode_sa_name(cdb0, sa, &cdb_name, &sa_name)) {
+                if (cdb_name)
+                        printk("%s", cdb_name);
+                else if (cdb0 >= VENDOR_SPECIFIC_CDB)
+                        printk("cdb[0]=0x%x (vendor)", cdb0);
+                else if (cdb0 >= 0x60 && cdb0 < 0x7e)
+                        printk("cdb[0]=0x%x (reserved)", cdb0);
+                else
                         printk("cdb[0]=0x%x", cdb0);
+        } else {
+                if (sa_name)
+                        printk("%s", sa_name);
+                else if (cdb_name)
+                        printk("%s, sa=0x%x", cdb_name, sa);
                 else
-                        printk("cdb[0]=0x%x (vendor)", cdb0);
-                break;
+                        printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
         }
 }
-#endif
 
-void __scsi_print_command(unsigned char *cdb)
+void __scsi_print_command(const unsigned char *cdb, size_t cdb_len)
 {
         int k, len;
 
-        print_opcode_name(cdb, 0);
+        print_opcode_name(cdb, cdb_len);
         len = scsi_command_size(cdb);
+        if (cdb_len < len)
+                len = cdb_len;
         /* print out all bytes in cdb */
         for (k = 0; k < len; ++k)
                 printk(" %02x", cdb[k]);
@@ -433,41 +383,6 @@ void scsi_print_command(struct scsi_cmnd *cmd)
 }
 EXPORT_SYMBOL(scsi_print_command);
 
-/**
- *      scsi_print_status - print scsi status description
- *      @scsi_status: scsi status value
- *
- *      If the status is recognized, the description is printed.
- *      Otherwise "Unknown status" is output. No trailing space.
- *      If CONFIG_SCSI_CONSTANTS is not set, then print status in hex
- *      (e.g. "0x2" for Check Condition).
- **/
-void
-scsi_print_status(unsigned char scsi_status) {
-#ifdef CONFIG_SCSI_CONSTANTS
-        const char * ccp;
-
-        switch (scsi_status) {
-        case 0:    ccp = "Good"; break;
-        case 0x2:  ccp = "Check Condition"; break;
-        case 0x4:  ccp = "Condition Met"; break;
-        case 0x8:  ccp = "Busy"; break;
-        case 0x10: ccp = "Intermediate"; break;
-        case 0x14: ccp = "Intermediate-Condition Met"; break;
-        case 0x18: ccp = "Reservation Conflict"; break;
-        case 0x22: ccp = "Command Terminated"; break;   /* obsolete */
-        case 0x28: ccp = "Task set Full"; break;        /* was: Queue Full */
-        case 0x30: ccp = "ACA Active"; break;
-        case 0x40: ccp = "Task Aborted"; break;
-        default:   ccp = "Unknown status";
-        }
-        printk(KERN_INFO "%s", ccp);
-#else
-        printk(KERN_INFO "0x%0x", scsi_status);
-#endif
-}
-EXPORT_SYMBOL(scsi_print_status);
-
 #ifdef CONFIG_SCSI_CONSTANTS
 
 struct error_info {
@@ -1292,18 +1207,19 @@ static const struct error_info additional[] =
 
 struct error_info2 {
         unsigned char code1, code2_min, code2_max;
+        const char * str;
         const char * fmt;
 };
 
 static const struct error_info2 additional2[] =
 {
-        {0x40, 0x00, 0x7f, "Ram failure (%x)"},
-        {0x40, 0x80, 0xff, "Diagnostic failure on component (%x)"},
-        {0x41, 0x00, 0xff, "Data path failure (%x)"},
-        {0x42, 0x00, 0xff, "Power-on or self-test failure (%x)"},
-        {0x4D, 0x00, 0xff, "Tagged overlapped commands (task tag %x)"},
-        {0x70, 0x00, 0xff, "Decompression exception short algorithm id of %x"},
-        {0, 0, 0, NULL}
+        {0x40, 0x00, 0x7f, "Ram failure", ""},
+        {0x40, 0x80, 0xff, "Diagnostic failure on component", ""},
+        {0x41, 0x00, 0xff, "Data path failure", ""},
+        {0x42, 0x00, 0xff, "Power-on or self-test failure", ""},
+        {0x4D, 0x00, 0xff, "Tagged overlapped commands", "task tag "},
+        {0x70, 0x00, 0xff, "Decompression exception", "short algorithm id of "},
+        {0, 0, 0, NULL, NULL}
 };
 
 /* description of the sense key values */
@@ -1349,69 +1265,79 @@ EXPORT_SYMBOL(scsi_sense_key_string);
  * This string may contain a "%x" and should be printed with ascq as arg.
  */
 const char *
-scsi_extd_sense_format(unsigned char asc, unsigned char ascq) {
+scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
+{
 #ifdef CONFIG_SCSI_CONSTANTS
         int i;
         unsigned short code = ((asc << 8) | ascq);
 
+        *fmt = NULL;
         for (i = 0; additional[i].text; i++)
                 if (additional[i].code12 == code)
                         return additional[i].text;
         for (i = 0; additional2[i].fmt; i++) {
                 if (additional2[i].code1 == asc &&
                     ascq >= additional2[i].code2_min &&
-                    ascq <= additional2[i].code2_max)
-                        return additional2[i].fmt;
+                    ascq <= additional2[i].code2_max) {
+                        *fmt = additional2[i].fmt;
+                        return additional2[i].str;
+                }
         }
+#else
+        *fmt = NULL;
 #endif
         return NULL;
 }
 EXPORT_SYMBOL(scsi_extd_sense_format);
 
 void
-scsi_show_extd_sense(unsigned char asc, unsigned char ascq)
+scsi_show_extd_sense(const struct scsi_device *sdev, const char *name,
+                     unsigned char asc, unsigned char ascq)
 {
-        const char *extd_sense_fmt = scsi_extd_sense_format(asc, ascq);
-
-        if (extd_sense_fmt) {
-                if (strstr(extd_sense_fmt, "%x")) {
-                        printk("Add. Sense: ");
-                        printk(extd_sense_fmt, ascq);
-                } else
-                        printk("Add. Sense: %s", extd_sense_fmt);
-        } else {
-                if (asc >= 0x80)
-                        printk("<<vendor>> ASC=0x%x ASCQ=0x%x", asc,
-                               ascq);
-                if (ascq >= 0x80)
-                        printk("ASC=0x%x <<vendor>> ASCQ=0x%x", asc,
-                               ascq);
+        const char *extd_sense_fmt = NULL;
+        const char *extd_sense_str = scsi_extd_sense_format(asc, ascq,
+                                                            &extd_sense_fmt);
+
+        if (extd_sense_str) {
+                if (extd_sense_fmt)
+                        sdev_prefix_printk(KERN_INFO, sdev, name,
+                                           "Add. Sense: %s (%s%x)",
+                                           extd_sense_str, extd_sense_fmt,
+                                           ascq);
                 else
-                        printk("ASC=0x%x ASCQ=0x%x", asc, ascq);
-        }
+                        sdev_prefix_printk(KERN_INFO, sdev, name,
+                                           "Add. Sense: %s", extd_sense_str);
 
-        printk("\n");
+        } else {
+                sdev_prefix_printk(KERN_INFO, sdev, name,
+                                   "%sASC=0x%x %sASCQ=0x%x\n",
+                                   asc >= 0x80 ? "<<vendor>> " : "", asc,
+                                   ascq >= 0x80 ? "<<vendor>> " : "", ascq);
+        }
 }
 EXPORT_SYMBOL(scsi_show_extd_sense);
 
 void
-scsi_show_sense_hdr(struct scsi_sense_hdr *sshdr)
+scsi_show_sense_hdr(const struct scsi_device *sdev, const char *name,
+                    const struct scsi_sense_hdr *sshdr)
 {
         const char *sense_txt;
 
         sense_txt = scsi_sense_key_string(sshdr->sense_key);
         if (sense_txt)
-                printk("Sense Key : %s ", sense_txt);
+                sdev_prefix_printk(KERN_INFO, sdev, name,
+                                   "Sense Key : %s [%s]%s\n", sense_txt,
+                                   scsi_sense_is_deferred(sshdr) ?
+                                   "deferred" : "current",
+                                   sshdr->response_code >= 0x72 ?
+                                   " [descriptor]" : "");
         else
-                printk("Sense Key : 0x%x ", sshdr->sense_key);
-
-        printk("%s", scsi_sense_is_deferred(sshdr) ? "[deferred] " :
-               "[current] ");
-
-        if (sshdr->response_code >= 0x72)
-                printk("[descriptor]");
-
-        printk("\n");
+                sdev_prefix_printk(KERN_INFO, sdev, name,
+                                   "Sense Key : 0x%x [%s]%s", sshdr->sense_key,
+                                   scsi_sense_is_deferred(sshdr) ?
+                                   "deferred" : "current",
+                                   sshdr->response_code >= 0x72 ?
+                                   " [descriptor]" : "");
 }
 EXPORT_SYMBOL(scsi_show_sense_hdr);
 
@@ -1419,141 +1345,55 @@ EXPORT_SYMBOL(scsi_show_sense_hdr);
  * Print normalized SCSI sense header with a prefix.
  */
 void
-scsi_print_sense_hdr(const char *name, struct scsi_sense_hdr *sshdr)
+scsi_print_sense_hdr(const struct scsi_device *sdev, const char *name,
+                     const struct scsi_sense_hdr *sshdr)
 {
-        printk(KERN_INFO "%s: ", name);
-        scsi_show_sense_hdr(sshdr);
-        printk(KERN_INFO "%s: ", name);
-        scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
+        scsi_show_sense_hdr(sdev, name, sshdr);
+        scsi_show_extd_sense(sdev, name, sshdr->asc, sshdr->ascq);
 }
 EXPORT_SYMBOL(scsi_print_sense_hdr);
 
-/*
- * Print normalized SCSI sense header with device information and a prefix.
- */
-void
-scsi_cmd_print_sense_hdr(struct scsi_cmnd *scmd, const char *desc,
-                          struct scsi_sense_hdr *sshdr)
-{
-        scmd_printk(KERN_INFO, scmd, "%s: ", desc);
-        scsi_show_sense_hdr(sshdr);
-        scmd_printk(KERN_INFO, scmd, "%s: ", desc);
-        scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
-}
-EXPORT_SYMBOL(scsi_cmd_print_sense_hdr);
-
 static void
-scsi_decode_sense_buffer(const unsigned char *sense_buffer, int sense_len,
-                       struct scsi_sense_hdr *sshdr)
+scsi_dump_sense_buffer(const unsigned char *sense_buffer, int sense_len)
 {
-        int k, num, res;
-
-        res = scsi_normalize_sense(sense_buffer, sense_len, sshdr);
-        if (0 == res) {
-                /* this may be SCSI-1 sense data */
-                num = (sense_len < 32) ? sense_len : 32;
-                printk("Unrecognized sense data (in hex):");
-                for (k = 0; k < num; ++k) {
-                        if (0 == (k % 16)) {
-                                printk("\n");
-                                printk(KERN_INFO "        ");
-                        }
-                        printk("%02x ", sense_buffer[k]);
+        int k, num;
+
+        num = (sense_len < 32) ? sense_len : 32;
+        printk("Unrecognized sense data (in hex):");
+        for (k = 0; k < num; ++k) {
+                if (0 == (k % 16)) {
+                        printk("\n");
+                        printk(KERN_INFO "        ");
                 }
-                printk("\n");
-                return;
+                printk("%02x ", sense_buffer[k]);
         }
-}
-
-static void
-scsi_decode_sense_extras(const unsigned char *sense_buffer, int sense_len,
-                         struct scsi_sense_hdr *sshdr)
-{
-        int k, num, res;
-
-        if (sshdr->response_code < 0x72)
-        {
-                /* only decode extras for "fixed" format now */
-                char buff[80];
-                int blen, fixed_valid;
-                unsigned int info;
-
-                fixed_valid = sense_buffer[0] & 0x80;
-                info = ((sense_buffer[3] << 24) | (sense_buffer[4] << 16) |
-                        (sense_buffer[5] << 8) | sense_buffer[6]);
-                res = 0;
-                memset(buff, 0, sizeof(buff));
-                blen = sizeof(buff) - 1;
-                if (fixed_valid)
-                        res += snprintf(buff + res, blen - res,
-                                        "Info fld=0x%x", info);
-                if (sense_buffer[2] & 0x80) {
-                        /* current command has read a filemark */
-                        if (res > 0)
-                                res += snprintf(buff + res, blen - res, ", ");
-                        res += snprintf(buff + res, blen - res, "FMK");
-                }
-                if (sense_buffer[2] & 0x40) {
-                        /* end-of-medium condition exists */
-                        if (res > 0)
-                                res += snprintf(buff + res, blen - res, ", ");
-                        res += snprintf(buff + res, blen - res, "EOM");
-                }
-                if (sense_buffer[2] & 0x20) {
-                        /* incorrect block length requested */
-                        if (res > 0)
-                                res += snprintf(buff + res, blen - res, ", ");
-                        res += snprintf(buff + res, blen - res, "ILI");
-                }
-                if (res > 0)
-                        printk("%s\n", buff);
-        } else if (sshdr->additional_length > 0) {
-                /* descriptor format with sense descriptors */
-                num = 8 + sshdr->additional_length;
-                num = (sense_len < num) ? sense_len : num;
-                printk("Descriptor sense data with sense descriptors "
-                       "(in hex):");
-                for (k = 0; k < num; ++k) {
-                        if (0 == (k % 16)) {
-                                printk("\n");
-                                printk(KERN_INFO "        ");
-                        }
-                        printk("%02x ", sense_buffer[k]);
-                }
-
-                printk("\n");
-        }
-
+        printk("\n");
+        return;
 }
 
 /* Normalize and print sense buffer with name prefix */
-void __scsi_print_sense(const char *name, const unsigned char *sense_buffer,
-                        int sense_len)
+void __scsi_print_sense(const struct scsi_device *sdev, const char *name,
+                        const unsigned char *sense_buffer, int sense_len)
 {
         struct scsi_sense_hdr sshdr;
 
-        printk(KERN_INFO "%s: ", name);
-        scsi_decode_sense_buffer(sense_buffer, sense_len, &sshdr);
-        scsi_show_sense_hdr(&sshdr);
-        scsi_decode_sense_extras(sense_buffer, sense_len, &sshdr);
-        printk(KERN_INFO "%s: ", name);
-        scsi_show_extd_sense(sshdr.asc, sshdr.ascq);
+        if (!scsi_normalize_sense(sense_buffer, sense_len, &sshdr)) {
+                scsi_dump_sense_buffer(sense_buffer, sense_len);
+                return;
+        }
+        scsi_show_sense_hdr(sdev, name, &sshdr);
+        scsi_show_extd_sense(sdev, name, sshdr.asc, sshdr.ascq);
 }
 EXPORT_SYMBOL(__scsi_print_sense);
 
 /* Normalize and print sense buffer in SCSI command */
-void scsi_print_sense(char *name, struct scsi_cmnd *cmd)
+void scsi_print_sense(const struct scsi_cmnd *cmd)
 {
-        struct scsi_sense_hdr sshdr;
+        struct gendisk *disk = cmd->request->rq_disk;
+        const char *disk_name = disk ? disk->disk_name : NULL;
 
-        scmd_printk(KERN_INFO, cmd, " ");
-        scsi_decode_sense_buffer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
-                                 &sshdr);
-        scsi_show_sense_hdr(&sshdr);
-        scsi_decode_sense_extras(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
-                                 &sshdr);
-        scmd_printk(KERN_INFO, cmd, " ");
-        scsi_show_extd_sense(sshdr.asc, sshdr.ascq);
+        __scsi_print_sense(cmd->device, disk_name, cmd->sense_buffer,
+                           SCSI_SENSE_BUFFERSIZE);
 }
 EXPORT_SYMBOL(scsi_print_sense);
 
@@ -1565,38 +1405,87 @@ static const char * const hostbyte_table[]={
 "DID_PASSTHROUGH", "DID_SOFT_ERROR", "DID_IMM_RETRY", "DID_REQUEUE",
 "DID_TRANSPORT_DISRUPTED", "DID_TRANSPORT_FAILFAST", "DID_TARGET_FAILURE",
 "DID_NEXUS_FAILURE" };
-#define NUM_HOSTBYTE_STRS ARRAY_SIZE(hostbyte_table)
 
 static const char * const driverbyte_table[]={
 "DRIVER_OK", "DRIVER_BUSY", "DRIVER_SOFT",  "DRIVER_MEDIA", "DRIVER_ERROR",
 "DRIVER_INVALID", "DRIVER_TIMEOUT", "DRIVER_HARD", "DRIVER_SENSE"};
-#define NUM_DRIVERBYTE_STRS ARRAY_SIZE(driverbyte_table)
 
-void scsi_show_result(int result)
+#endif
+
+const char *scsi_hostbyte_string(int result)
 {
+        const char *hb_string = NULL;
+#ifdef CONFIG_SCSI_CONSTANTS
         int hb = host_byte(result);
-        int db = driver_byte(result);
 
-        printk("Result: hostbyte=%s driverbyte=%s\n",
-               (hb < NUM_HOSTBYTE_STRS ? hostbyte_table[hb]     : "invalid"),
-               (db < NUM_DRIVERBYTE_STRS ? driverbyte_table[db] : "invalid"));
+        if (hb < ARRAY_SIZE(hostbyte_table))
+                hb_string = hostbyte_table[hb];
+#endif
+        return hb_string;
 }
+EXPORT_SYMBOL(scsi_hostbyte_string);
 
-#else
-
-void scsi_show_result(int result)
+const char *scsi_driverbyte_string(int result)
 {
-        printk("Result: hostbyte=0x%02x driverbyte=0x%02x\n",
-               host_byte(result), driver_byte(result));
+        const char *db_string = NULL;
+#ifdef CONFIG_SCSI_CONSTANTS
+        int db = driver_byte(result);
+
+        if (db < ARRAY_SIZE(driverbyte_table))
+                db_string = driverbyte_table[db];
+#endif
+        return db_string;
 }
+EXPORT_SYMBOL(scsi_driverbyte_string);
 
+#ifdef CONFIG_SCSI_CONSTANTS
+#define scsi_mlreturn_name(result)      { result, #result }
+static const struct value_name_pair scsi_mlreturn_arr[] = {
+        scsi_mlreturn_name(NEEDS_RETRY),
+        scsi_mlreturn_name(SUCCESS),
+        scsi_mlreturn_name(FAILED),
+        scsi_mlreturn_name(QUEUED),
+        scsi_mlreturn_name(SOFT_ERROR),
+        scsi_mlreturn_name(ADD_TO_MLQUEUE),
+        scsi_mlreturn_name(TIMEOUT_ERROR),
+        scsi_mlreturn_name(SCSI_RETURN_NOT_HANDLED),
+        scsi_mlreturn_name(FAST_IO_FAIL)
+};
 #endif
-EXPORT_SYMBOL(scsi_show_result);
 
+const char *scsi_mlreturn_string(int result)
+{
+#ifdef CONFIG_SCSI_CONSTANTS
+        const struct value_name_pair *arr = scsi_mlreturn_arr;
+        int k;
 
-void scsi_print_result(struct scsi_cmnd *cmd)
+        for (k = 0; k < ARRAY_SIZE(scsi_mlreturn_arr); ++k, ++arr) {
+                if (result == arr->value)
+                        return arr->name;
+        }
+#endif
+        return NULL;
+}
+EXPORT_SYMBOL(scsi_mlreturn_string);
+
+void scsi_print_result(struct scsi_cmnd *cmd, const char *msg, int disposition)
 {
-        scmd_printk(KERN_INFO, cmd, " ");
-        scsi_show_result(cmd->result);
+        const char *mlret_string = scsi_mlreturn_string(disposition);
+        const char *hb_string = scsi_hostbyte_string(cmd->result);
+        const char *db_string = scsi_driverbyte_string(cmd->result);
+
+        if (hb_string || db_string)
+                scmd_printk(KERN_INFO, cmd,
+                            "%s%s Result: hostbyte=%s driverbyte=%s",
+                            msg ? msg : "",
+                            mlret_string ? mlret_string : "UNKNOWN",
+                            hb_string ? hb_string : "invalid",
+                            db_string ? db_string : "invalid");
+        else
+                scmd_printk(KERN_INFO, cmd,
+                            "%s%s Result: hostbyte=0x%02x driverbyte=0x%02x",
+                            msg ? msg : "",
+                            mlret_string ? mlret_string : "UNKNOWN",
+                            host_byte(cmd->result), driver_byte(cmd->result));
 }
 EXPORT_SYMBOL(scsi_print_result);
diff --git a/drivers/scsi/csiostor/csio_scsi.c b/drivers/scsi/csiostor/csio_scsi.c
index 86103c8475d8..4d0b6ce55f20 100644
--- a/drivers/scsi/csiostor/csio_scsi.c
+++ b/drivers/scsi/csiostor/csio_scsi.c
@@ -152,28 +152,6 @@ csio_scsi_itnexus_loss_error(uint16_t error)
         return 0;
 }
 
-static inline void
-csio_scsi_tag(struct scsi_cmnd *scmnd, uint8_t *tag, uint8_t hq,
-              uint8_t oq, uint8_t sq)
-{
-        char stag[2];
-
-        if (scsi_populate_tag_msg(scmnd, stag)) {
-                switch (stag[0]) {
-                case HEAD_OF_QUEUE_TAG:
-                        *tag = hq;
-                        break;
-                case ORDERED_QUEUE_TAG:
-                        *tag = oq;
-                        break;
-                default:
-                        *tag = sq;
-                        break;
-                }
-        } else
-                *tag = 0;
-}
-
 /*
  * csio_scsi_fcp_cmnd - Frame the SCSI FCP command paylod.
  * @req: IO req structure.
@@ -192,11 +170,12 @@ csio_scsi_fcp_cmnd(struct csio_ioreq *req, void *addr)
                 int_to_scsilun(scmnd->device->lun, &fcp_cmnd->fc_lun);
                 fcp_cmnd->fc_tm_flags = 0;
                 fcp_cmnd->fc_cmdref = 0;
-                fcp_cmnd->fc_pri_ta = 0;
 
                 memcpy(fcp_cmnd->fc_cdb, scmnd->cmnd, 16);
-                csio_scsi_tag(scmnd, &fcp_cmnd->fc_pri_ta,
-                              FCP_PTA_HEADQ, FCP_PTA_ORDERED, FCP_PTA_SIMPLE);
+                if (scmnd->flags & SCMD_TAGGED)
+                        fcp_cmnd->fc_pri_ta = FCP_PTA_SIMPLE;
+                else
+                        fcp_cmnd->fc_pri_ta = 0;
                 fcp_cmnd->fc_dl = cpu_to_be32(scsi_bufflen(scmnd));
 
                 if (req->nsge)
@@ -2262,11 +2241,7 @@ csio_slave_alloc(struct scsi_device *sdev)
 static int
 csio_slave_configure(struct scsi_device *sdev)
 {
-        if (sdev->tagged_supported)
-                scsi_activate_tcq(sdev, csio_lun_qdepth);
-        else
-                scsi_deactivate_tcq(sdev, csio_lun_qdepth);
-
+        scsi_change_queue_depth(sdev, csio_lun_qdepth);
         return 0;
 }
 
@@ -2311,6 +2286,7 @@ struct scsi_host_template csio_fcoe_shost_template = {
         .use_clustering         = ENABLE_CLUSTERING,
         .shost_attrs            = csio_fcoe_lport_attrs,
         .max_sectors            = CSIO_MAX_SECTOR_SIZE,
+        .use_blk_tags           = 1,
 };
 
 struct scsi_host_template csio_fcoe_shost_vport_template = {
@@ -2330,6 +2306,7 @@ struct scsi_host_template csio_fcoe_shost_vport_template = {
         .use_clustering         = ENABLE_CLUSTERING,
         .shost_attrs            = csio_fcoe_vport_attrs,
         .max_sectors            = CSIO_MAX_SECTOR_SIZE,
+        .use_blk_tags           = 1,
 };
 
 /*
diff --git a/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c b/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
index 49692a1ac44a..3db4c63978c5 100644
--- a/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
+++ b/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
@@ -86,7 +86,7 @@ static struct scsi_host_template cxgb3i_host_template = {
         .proc_name      = DRV_MODULE_NAME,
         .can_queue      = CXGB3I_SCSI_HOST_QDEPTH,
         .queuecommand   = iscsi_queuecommand,
-        .change_queue_depth = iscsi_change_queue_depth,
+        .change_queue_depth = scsi_change_queue_depth,
         .sg_tablesize   = SG_ALL,
         .max_sectors    = 0xFFFF,
         .cmd_per_lun    = ISCSI_DEF_CMD_PER_LUN,
@@ -96,6 +96,7 @@ static struct scsi_host_template cxgb3i_host_template = {
         .target_alloc   = iscsi_target_alloc,
         .use_clustering = DISABLE_CLUSTERING,
         .this_id        = -1,
+        .track_queue_depth = 1,
 };
 
 static struct iscsi_transport cxgb3i_iscsi_transport = {
diff --git a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
index 15081257cfc8..e6c3f55d9d36 100644
--- a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
+++ b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
@@ -89,7 +89,7 @@ static struct scsi_host_template cxgb4i_host_template = {
         .proc_name      = DRV_MODULE_NAME,
         .can_queue      = CXGB4I_SCSI_HOST_QDEPTH,
         .queuecommand   = iscsi_queuecommand,
-        .change_queue_depth = iscsi_change_queue_depth,
+        .change_queue_depth = scsi_change_queue_depth,
         .sg_tablesize   = SG_ALL,
         .max_sectors    = 0xFFFF,
         .cmd_per_lun    = ISCSI_DEF_CMD_PER_LUN,
@@ -99,6 +99,7 @@ static struct scsi_host_template cxgb4i_host_template = {
         .target_alloc   = iscsi_target_alloc,
         .use_clustering = DISABLE_CLUSTERING,
         .this_id        = -1,
+        .track_queue_depth = 1,
 };
 
 static struct iscsi_transport cxgb4i_iscsi_transport = {
diff --git a/drivers/scsi/device_handler/scsi_dh.c b/drivers/scsi/device_handler/scsi_dh.c
index 33e422e75835..1dba62c5cf6a 100644
--- a/drivers/scsi/device_handler/scsi_dh.c
+++ b/drivers/scsi/device_handler/scsi_dh.c
@@ -98,27 +98,51 @@ device_handler_match(struct scsi_device_handler *scsi_dh,
 static int scsi_dh_handler_attach(struct scsi_device *sdev,
                                   struct scsi_device_handler *scsi_dh)
 {
-        int err = 0;
+        struct scsi_dh_data *d;
 
         if (sdev->scsi_dh_data) {
                 if (sdev->scsi_dh_data->scsi_dh != scsi_dh)
-                        err = -EBUSY;
-                else
-                        kref_get(&sdev->scsi_dh_data->kref);
-        } else if (scsi_dh->attach) {
-                err = scsi_dh->attach(sdev);
-                if (!err) {
-                        kref_init(&sdev->scsi_dh_data->kref);
-                        sdev->scsi_dh_data->sdev = sdev;
-                }
+                        return -EBUSY;
+
+                kref_get(&sdev->scsi_dh_data->kref);
+                return 0;
         }
-        return err;
+
+        if (!try_module_get(scsi_dh->module))
+                return -EINVAL;
+
+        d = scsi_dh->attach(sdev);
+        if (IS_ERR(d)) {
+                sdev_printk(KERN_ERR, sdev, "%s: Attach failed (%ld)\n",
+                            scsi_dh->name, PTR_ERR(d));
+                module_put(scsi_dh->module);
+                return PTR_ERR(d);
+        }
+
+        d->scsi_dh = scsi_dh;
+        kref_init(&d->kref);
+        d->sdev = sdev;
+
+        spin_lock_irq(sdev->request_queue->queue_lock);
+        sdev->scsi_dh_data = d;
+        spin_unlock_irq(sdev->request_queue->queue_lock);
+        return 0;
 }
 
 static void __detach_handler (struct kref *kref)
 {
-        struct scsi_dh_data *scsi_dh_data = container_of(kref, struct scsi_dh_data, kref);
-        scsi_dh_data->scsi_dh->detach(scsi_dh_data->sdev);
+        struct scsi_dh_data *scsi_dh_data =
+                container_of(kref, struct scsi_dh_data, kref);
+        struct scsi_device_handler *scsi_dh = scsi_dh_data->scsi_dh;
+        struct scsi_device *sdev = scsi_dh_data->sdev;
+
+        spin_lock_irq(sdev->request_queue->queue_lock);
+        sdev->scsi_dh_data = NULL;
+        spin_unlock_irq(sdev->request_queue->queue_lock);
+
+        scsi_dh->detach(sdev);
+        sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", scsi_dh->name);
+        module_put(scsi_dh->module);
 }
 
 /*
@@ -141,7 +165,7 @@ static void scsi_dh_handler_detach(struct scsi_device *sdev,
         if (!scsi_dh)
                 scsi_dh = sdev->scsi_dh_data->scsi_dh;
 
-        if (scsi_dh && scsi_dh->detach)
+        if (scsi_dh)
                 kref_put(&sdev->scsi_dh_data->kref, __detach_handler);
 }
 
@@ -330,6 +354,9 @@ int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
         if (get_device_handler(scsi_dh->name))
                 return -EBUSY;
 
+        if (!scsi_dh->attach || !scsi_dh->detach)
+                return -EINVAL;
+
         spin_lock(&list_lock);
         list_add(&scsi_dh->list, &scsi_dh_list);
         spin_unlock(&list_lock);
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index fd78bdc53528..854b568b9931 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -62,6 +62,7 @@
 #define ALUA_OPTIMIZE_STPG              1
 
 struct alua_dh_data {
+        struct scsi_dh_data     dh_data;
         int                     group_id;
         int                     rel_port;
         int                     tpgs;
@@ -87,9 +88,7 @@ static int alua_check_sense(struct scsi_device *, struct scsi_sense_hdr *);
 
 static inline struct alua_dh_data *get_alua_data(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
-        BUG_ON(scsi_dh_data == NULL);
-        return ((struct alua_dh_data *) scsi_dh_data->buf);
+        return container_of(sdev->scsi_dh_data, struct alua_dh_data, dh_data);
 }
 
 static int realloc_buffer(struct alua_dh_data *h, unsigned len)
@@ -825,42 +824,18 @@ static bool alua_match(struct scsi_device *sdev)
         return (scsi_device_tpgs(sdev) != 0);
 }
 
-static int alua_bus_attach(struct scsi_device *sdev);
-static void alua_bus_detach(struct scsi_device *sdev);
-
-static struct scsi_device_handler alua_dh = {
-        .name = ALUA_DH_NAME,
-        .module = THIS_MODULE,
-        .attach = alua_bus_attach,
-        .detach = alua_bus_detach,
-        .prep_fn = alua_prep_fn,
-        .check_sense = alua_check_sense,
-        .activate = alua_activate,
-        .set_params = alua_set_params,
-        .match = alua_match,
-};
-
 /*
  * alua_bus_attach - Attach device handler
  * @sdev: device to be attached to
  */
-static int alua_bus_attach(struct scsi_device *sdev)
+static struct scsi_dh_data *alua_bus_attach(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data;
         struct alua_dh_data *h;
-        unsigned long flags;
-        int err = SCSI_DH_OK;
-
-        scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
-                               + sizeof(*h) , GFP_KERNEL);
-        if (!scsi_dh_data) {
-                sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
-                            ALUA_DH_NAME);
-                return -ENOMEM;
-        }
+        int err;
 
-        scsi_dh_data->scsi_dh = &alua_dh;
-        h = (struct alua_dh_data *) scsi_dh_data->buf;
+        h = kzalloc(sizeof(*h) , GFP_KERNEL);
+        if (!h)
+                return ERR_PTR(-ENOMEM);
         h->tpgs = TPGS_MODE_UNINITIALIZED;
         h->state = TPGS_STATE_OPTIMIZED;
         h->group_id = -1;
@@ -870,23 +845,14 @@ static int alua_bus_attach(struct scsi_device *sdev)
         h->sdev = sdev;
 
         err = alua_initialize(sdev, h);
-        if ((err != SCSI_DH_OK) && (err != SCSI_DH_DEV_OFFLINED))
-                goto failed;
-
-        if (!try_module_get(THIS_MODULE))
+        if (err != SCSI_DH_OK && err != SCSI_DH_DEV_OFFLINED)
                 goto failed;
 
-        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
-        sdev->scsi_dh_data = scsi_dh_data;
-        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
         sdev_printk(KERN_NOTICE, sdev, "%s: Attached\n", ALUA_DH_NAME);
-
-        return 0;
-
+        return &h->dh_data;
 failed:
-        kfree(scsi_dh_data);
-        sdev_printk(KERN_ERR, sdev, "%s: not attached\n", ALUA_DH_NAME);
-        return -EINVAL;
+        kfree(h);
+        return ERR_PTR(-EINVAL);
 }
 
 /*
@@ -895,23 +861,25 @@ failed:
  */
 static void alua_bus_detach(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data;
-        struct alua_dh_data *h;
-        unsigned long flags;
-
-        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
-        scsi_dh_data = sdev->scsi_dh_data;
-        sdev->scsi_dh_data = NULL;
-        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
+        struct alua_dh_data *h = get_alua_data(sdev);
 
-        h = (struct alua_dh_data *) scsi_dh_data->buf;
         if (h->buff && h->inq != h->buff)
                 kfree(h->buff);
-        kfree(scsi_dh_data);
-        module_put(THIS_MODULE);
-        sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", ALUA_DH_NAME);
+        kfree(h);
 }
 
+static struct scsi_device_handler alua_dh = {
+        .name = ALUA_DH_NAME,
+        .module = THIS_MODULE,
+        .attach = alua_bus_attach,
+        .detach = alua_bus_detach,
+        .prep_fn = alua_prep_fn,
+        .check_sense = alua_check_sense,
+        .activate = alua_activate,
+        .set_params = alua_set_params,
+        .match = alua_match,
+};
+
 static int __init alua_init(void)
 {
         int r;
diff --git a/drivers/scsi/device_handler/scsi_dh_emc.c b/drivers/scsi/device_handler/scsi_dh_emc.c
index 84765384c47c..6ed1caadbc6a 100644
--- a/drivers/scsi/device_handler/scsi_dh_emc.c
+++ b/drivers/scsi/device_handler/scsi_dh_emc.c
@@ -72,6 +72,7 @@ static const char * lun_state[] =
 };
 
 struct clariion_dh_data {
+        struct scsi_dh_data dh_data;
         /*
          * Flags:
          *  CLARIION_SHORT_TRESPASS
@@ -116,9 +117,8 @@ struct clariion_dh_data {
 static inline struct clariion_dh_data
                         *get_clariion_data(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
-        BUG_ON(scsi_dh_data == NULL);
-        return ((struct clariion_dh_data *) scsi_dh_data->buf);
+        return container_of(sdev->scsi_dh_data, struct clariion_dh_data,
+                        dh_data);
 }
 
 /*
@@ -622,7 +622,10 @@ done:
         return result;
 }
 
-static const struct scsi_dh_devlist clariion_dev_list[] = {
+static const struct {
+        char *vendor;
+        char *model;
+} clariion_dev_list[] = {
         {"DGC", "RAID"},
         {"DGC", "DISK"},
         {"DGC", "VRAID"},
@@ -647,39 +650,14 @@ static bool clariion_match(struct scsi_device *sdev)
         return false;
 }
 
-static int clariion_bus_attach(struct scsi_device *sdev);
-static void clariion_bus_detach(struct scsi_device *sdev);
-
-static struct scsi_device_handler clariion_dh = {
-        .name           = CLARIION_NAME,
-        .module         = THIS_MODULE,
-        .devlist        = clariion_dev_list,
-        .attach         = clariion_bus_attach,
-        .detach         = clariion_bus_detach,
-        .check_sense    = clariion_check_sense,
-        .activate       = clariion_activate,
-        .prep_fn        = clariion_prep_fn,
-        .set_params     = clariion_set_params,
-        .match          = clariion_match,
-};
-
-static int clariion_bus_attach(struct scsi_device *sdev)
+static struct scsi_dh_data *clariion_bus_attach(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data;
         struct clariion_dh_data *h;
-        unsigned long flags;
         int err;
 
-        scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
-                               + sizeof(*h) , GFP_KERNEL);
-        if (!scsi_dh_data) {
-                sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
-                            CLARIION_NAME);
-                return -ENOMEM;
-        }
-
-        scsi_dh_data->scsi_dh = &clariion_dh;
-        h = (struct clariion_dh_data *) scsi_dh_data->buf;
+        h = kzalloc(sizeof(*h) , GFP_KERNEL);
+        if (!h)
+                return ERR_PTR(-ENOMEM);
         h->lun_state = CLARIION_LUN_UNINITIALIZED;
         h->default_sp = CLARIION_UNBOUND_LU;
         h->current_sp = CLARIION_UNBOUND_LU;
@@ -692,45 +670,37 @@ static int clariion_bus_attach(struct scsi_device *sdev)
         if (err != SCSI_DH_OK)
                 goto failed;
 
-        if (!try_module_get(THIS_MODULE))
-                goto failed;
-
-        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
-        sdev->scsi_dh_data = scsi_dh_data;
-        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
-
         sdev_printk(KERN_INFO, sdev,
                     "%s: connected to SP %c Port %d (%s, default SP %c)\n",
                     CLARIION_NAME, h->current_sp + 'A',
                     h->port, lun_state[h->lun_state],
                     h->default_sp + 'A');
-
-        return 0;
+        return &h->dh_data;
 
 failed:
-        kfree(scsi_dh_data);
-        sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
-                    CLARIION_NAME);
-        return -EINVAL;
+        kfree(h);
+        return ERR_PTR(-EINVAL);
 }
 
 static void clariion_bus_detach(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data;
-        unsigned long flags;
-
-        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
-        scsi_dh_data = sdev->scsi_dh_data;
-        sdev->scsi_dh_data = NULL;
-        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
-
-        sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n",
-                    CLARIION_NAME);
+        struct clariion_dh_data *h = get_clariion_data(sdev);
 
-        kfree(scsi_dh_data);
-        module_put(THIS_MODULE);
+        kfree(h);
 }
 
+static struct scsi_device_handler clariion_dh = {
+        .name           = CLARIION_NAME,
+        .module         = THIS_MODULE,
+        .attach         = clariion_bus_attach,
+        .detach         = clariion_bus_detach,
+        .check_sense    = clariion_check_sense,
+        .activate       = clariion_activate,
+        .prep_fn        = clariion_prep_fn,
+        .set_params     = clariion_set_params,
+        .match          = clariion_match,
+};
+
 static int __init clariion_init(void)
 {
         int r;
diff --git a/drivers/scsi/device_handler/scsi_dh_hp_sw.c b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
index 4ee2759f5299..485d99544a15 100644
--- a/drivers/scsi/device_handler/scsi_dh_hp_sw.c
+++ b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
@@ -38,6 +38,7 @@
 #define HP_SW_PATH_PASSIVE              1
 
 struct hp_sw_dh_data {
+        struct scsi_dh_data dh_data;
         unsigned char sense[SCSI_SENSE_BUFFERSIZE];
         int path_state;
         int retries;
@@ -51,9 +52,7 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *);
 
 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
-        BUG_ON(scsi_dh_data == NULL);
-        return ((struct hp_sw_dh_data *) scsi_dh_data->buf);
+        return container_of(sdev->scsi_dh_data, struct hp_sw_dh_data, dh_data);
 }
 
 /*
@@ -312,7 +311,10 @@ static int hp_sw_activate(struct scsi_device *sdev,
         return 0;
 }
 
-static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
+static const struct {
+        char *vendor;
+        char *model;
+} hp_sw_dh_data_list[] = {
         {"COMPAQ", "MSA1000 VOLUME"},
         {"COMPAQ", "HSV110"},
         {"HP", "HSV100"},
@@ -338,37 +340,14 @@ static bool hp_sw_match(struct scsi_device *sdev)
         return false;
 }
 
-static int hp_sw_bus_attach(struct scsi_device *sdev);
-static void hp_sw_bus_detach(struct scsi_device *sdev);
-
-static struct scsi_device_handler hp_sw_dh = {
-        .name           = HP_SW_NAME,
-        .module         = THIS_MODULE,
-        .devlist        = hp_sw_dh_data_list,
-        .attach         = hp_sw_bus_attach,
-        .detach         = hp_sw_bus_detach,
-        .activate       = hp_sw_activate,
-        .prep_fn        = hp_sw_prep_fn,
-        .match          = hp_sw_match,
-};
-
-static int hp_sw_bus_attach(struct scsi_device *sdev)
+static struct scsi_dh_data *hp_sw_bus_attach(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data;
         struct hp_sw_dh_data *h;
-        unsigned long flags;
         int ret;
 
-        scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
-                               + sizeof(*h) , GFP_KERNEL);
-        if (!scsi_dh_data) {
-                sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
-                            HP_SW_NAME);
-                return 0;
-        }
-
-        scsi_dh_data->scsi_dh = &hp_sw_dh;
-        h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
+        h = kzalloc(sizeof(*h), GFP_KERNEL);
+        if (!h)
+                return ERR_PTR(-ENOMEM);
         h->path_state = HP_SW_PATH_UNINITIALIZED;
         h->retries = HP_SW_RETRIES;
         h->sdev = sdev;
@@ -377,42 +356,32 @@ static int hp_sw_bus_attach(struct scsi_device *sdev)
         if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
                 goto failed;
 
-        if (!try_module_get(THIS_MODULE))
-                goto failed;
-
-        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
-        sdev->scsi_dh_data = scsi_dh_data;
-        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
-
         sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n",
                     HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE?
                     "active":"passive");
-
-        return 0;
-
+        return &h->dh_data;
 failed:
-        kfree(scsi_dh_data);
-        sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
-                    HP_SW_NAME);
-        return -EINVAL;
+        kfree(h);
+        return ERR_PTR(-EINVAL);
 }
 
 static void hp_sw_bus_detach( struct scsi_device *sdev )
 {
-        struct scsi_dh_data *scsi_dh_data;
-        unsigned long flags;
-
-        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
-        scsi_dh_data = sdev->scsi_dh_data;
-        sdev->scsi_dh_data = NULL;
-        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
-        module_put(THIS_MODULE);
-
-        sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", HP_SW_NAME);
+        struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
 
-        kfree(scsi_dh_data);
+        kfree(h);
 }
 
+static struct scsi_device_handler hp_sw_dh = {
+        .name           = HP_SW_NAME,
+        .module         = THIS_MODULE,
+        .attach         = hp_sw_bus_attach,
+        .detach         = hp_sw_bus_detach,
+        .activate       = hp_sw_activate,
+        .prep_fn        = hp_sw_prep_fn,
+        .match          = hp_sw_match,
+};
+
 static int __init hp_sw_init(void)
 {
         return scsi_register_device_handler(&hp_sw_dh);
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 1b5bc9293e37..b46ace3d4bf0 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -181,6 +181,7 @@ struct c2_inquiry {
 };
 
 struct rdac_dh_data {
+        struct scsi_dh_data     dh_data;
         struct rdac_controller  *ctlr;
 #define UNINITIALIZED_LUN       (1 << 8)
         unsigned                lun;
@@ -261,9 +262,7 @@ do { \
 
 static inline struct rdac_dh_data *get_rdac_data(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
-        BUG_ON(scsi_dh_data == NULL);
-        return ((struct rdac_dh_data *) scsi_dh_data->buf);
+        return container_of(sdev->scsi_dh_data, struct rdac_dh_data, dh_data);
 }
 
 static struct request *get_rdac_req(struct scsi_device *sdev,
@@ -779,7 +778,10 @@ static int rdac_check_sense(struct scsi_device *sdev,
         return SCSI_RETURN_NOT_HANDLED;
 }
 
-static const struct scsi_dh_devlist rdac_dev_list[] = {
+static const struct {
+        char *vendor;
+        char *model;
+} rdac_dev_list[] = {
         {"IBM", "1722"},
         {"IBM", "1724"},
         {"IBM", "1726"},
@@ -825,40 +827,16 @@ static bool rdac_match(struct scsi_device *sdev)
         return false;
 }
 
-static int rdac_bus_attach(struct scsi_device *sdev);
-static void rdac_bus_detach(struct scsi_device *sdev);
-
-static struct scsi_device_handler rdac_dh = {
-        .name = RDAC_NAME,
-        .module = THIS_MODULE,
-        .devlist = rdac_dev_list,
-        .prep_fn = rdac_prep_fn,
-        .check_sense = rdac_check_sense,
-        .attach = rdac_bus_attach,
-        .detach = rdac_bus_detach,
-        .activate = rdac_activate,
-        .match = rdac_match,
-};
-
-static int rdac_bus_attach(struct scsi_device *sdev)
+static struct scsi_dh_data *rdac_bus_attach(struct scsi_device *sdev)
 {
-        struct scsi_dh_data *scsi_dh_data;
         struct rdac_dh_data *h;
-        unsigned long flags;
         int err;
         char array_name[ARRAY_LABEL_LEN];
         char array_id[UNIQUE_ID_LEN];
 
-        scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
-                               + sizeof(*h) , GFP_KERNEL);
-        if (!scsi_dh_data) {
-                sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
-                            RDAC_NAME);
-                return -ENOMEM;
-        }
-
-        scsi_dh_data->scsi_dh = &rdac_dh;
-        h = (struct rdac_dh_data *) scsi_dh_data->buf;
+        h = kzalloc(sizeof(*h) , GFP_KERNEL);
+        if (!h)
+                return ERR_PTR(-ENOMEM);
         h->lun = UNINITIALIZED_LUN;
         h->state = RDAC_STATE_ACTIVE;
 
@@ -878,19 +856,12 @@ static int rdac_bus_attach(struct scsi_device *sdev)
         if (err != SCSI_DH_OK)
                 goto clean_ctlr;
 
-        if (!try_module_get(THIS_MODULE))
-                goto clean_ctlr;
-
-        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
-        sdev->scsi_dh_data = scsi_dh_data;
-        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
-
         sdev_printk(KERN_NOTICE, sdev,
                     "%s: LUN %d (%s) (%s)\n",
                     RDAC_NAME, h->lun, mode[(int)h->mode],
                     lun_state[(int)h->lun_state]);
 
-        return 0;
+        return &h->dh_data;
 
 clean_ctlr:
         spin_lock(&list_lock);
@@ -898,37 +869,34 @@ clean_ctlr:
         spin_unlock(&list_lock);
 
 failed:
-        kfree(scsi_dh_data);
-        sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
-                    RDAC_NAME);
-        return -EINVAL;
+        kfree(h);
+        return ERR_PTR(-EINVAL);
 }
 
 static void rdac_bus_detach( struct scsi_device *sdev )
 {
-        struct scsi_dh_data *scsi_dh_data;
-        struct rdac_dh_data *h;
-        unsigned long flags;
+        struct rdac_dh_data *h = get_rdac_data(sdev);
 
-        scsi_dh_data = sdev->scsi_dh_data;
-        h = (struct rdac_dh_data *) scsi_dh_data->buf;
         if (h->ctlr && h->ctlr->ms_queued)
                 flush_workqueue(kmpath_rdacd);
 
-        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
-        sdev->scsi_dh_data = NULL;
-        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
-
         spin_lock(&list_lock);
         if (h->ctlr)
                 kref_put(&h->ctlr->kref, release_controller);
         spin_unlock(&list_lock);
-        kfree(scsi_dh_data);
-        module_put(THIS_MODULE);
-        sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", RDAC_NAME);
+        kfree(h);
 }
 
-
+static struct scsi_device_handler rdac_dh = {
+        .name = RDAC_NAME,
+        .module = THIS_MODULE,
+        .prep_fn = rdac_prep_fn,
+        .check_sense = rdac_check_sense,
+        .attach = rdac_bus_attach,
+        .detach = rdac_bus_detach,
+        .activate = rdac_activate,
+        .match = rdac_match,
+};
 
 static int __init rdac_init(void)
 {
diff --git a/drivers/scsi/dmx3191d.c b/drivers/scsi/dmx3191d.c
index 4b0dd8c56707..3e088125a8be 100644
--- a/drivers/scsi/dmx3191d.c
+++ b/drivers/scsi/dmx3191d.c
@@ -33,20 +33,20 @@
 /*
  * Definitions for the generic 5380 driver.
  */
-#define AUTOSENSE
+
+#define DONT_USE_INTR
 
 #define NCR5380_read(reg)               inb(port + reg)
 #define NCR5380_write(reg, value)       outb(value, port + reg)
 
-#define NCR5380_implementation_fields   unsigned int port
-#define NCR5380_local_declare()         NCR5380_implementation_fields
+#define NCR5380_implementation_fields   /* none */
+#define NCR5380_local_declare()         unsigned int port
 #define NCR5380_setup(instance)         port = instance->io_port
 
 /*
  * Includes needed for NCR5380.[ch] (XXX: Move them to NCR5380.h)
  */
 #include <linux/delay.h>
-#include "scsi.h"
 
 #include "NCR5380.h"
 #include "NCR5380.c"
@@ -58,6 +58,7 @@
 static struct scsi_host_template dmx3191d_driver_template = {
         .proc_name              = DMX3191D_DRIVER_NAME,
         .name                   = "Domex DMX3191D",
+        .info                   = NCR5380_info,
         .queuecommand           = NCR5380_queue_command,
         .eh_abort_handler       = NCR5380_abort,
         .eh_bus_reset_handler   = NCR5380_bus_reset,
@@ -90,31 +91,23 @@ static int dmx3191d_probe_one(struct pci_dev *pdev,
         if (!shost)
                 goto out_release_region;       
         shost->io_port = io;
-        shost->irq = pdev->irq;
 
-        NCR5380_init(shost, FLAG_NO_PSEUDO_DMA | FLAG_DTC3181E);
+        /* This card does not seem to raise an interrupt on pdev->irq.
+         * Steam-powered SCSI controllers run without an IRQ anyway.
+         */
+        shost->irq = NO_IRQ;
 
-        if (request_irq(pdev->irq, NCR5380_intr, IRQF_SHARED,
-                                DMX3191D_DRIVER_NAME, shost)) {
-                /*
-                 * Steam powered scsi controllers run without an IRQ anyway
-                 */
-                printk(KERN_WARNING "dmx3191: IRQ %d not available - "
-                                    "switching to polled mode.\n", pdev->irq);
-                shost->irq = SCSI_IRQ_NONE;
-        }
+        NCR5380_init(shost, FLAG_NO_PSEUDO_DMA | FLAG_DTC3181E);
 
         pci_set_drvdata(pdev, shost);
 
         error = scsi_add_host(shost, &pdev->dev);
         if (error)
-                goto out_free_irq;
+                goto out_release_region;
 
         scsi_scan_host(shost);
         return 0;
 
- out_free_irq:
-        free_irq(shost->irq, shost);
  out_release_region:
         release_region(io, DMX3191D_REGION_LEN);
  out_disable_device:
@@ -131,8 +124,6 @@ static void dmx3191d_remove_one(struct pci_dev *pdev)
 
         NCR5380_exit(shost);
 
-        if (shost->irq != SCSI_IRQ_NONE)
-                free_irq(shost->irq, shost);
         release_region(shost->io_port, DMX3191D_REGION_LEN);
         pci_disable_device(pdev);
 
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 072f0ec2851e..0bf976936a10 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -415,10 +415,8 @@ static int adpt_slave_configure(struct scsi_device * device)
         pHba = (adpt_hba *) host->hostdata[0];
 
         if (host->can_queue && device->tagged_supported) {
-                scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG,
+                scsi_change_queue_depth(device,
                                 host->can_queue - 1);
-        } else {
-                scsi_adjust_queue_depth(device, 0, 1);
         }
         return 0;
 }
diff --git a/drivers/scsi/dtc.c b/drivers/scsi/dtc.c
index 0a667fe05006..4c74c7ba2dff 100644
--- a/drivers/scsi/dtc.c
+++ b/drivers/scsi/dtc.c
@@ -1,5 +1,4 @@
 
-#define AUTOSENSE
 #define PSEUDO_DMA
 #define DONT_USE_INTR
 #define UNSAFE                  /* Leave interrupts enabled during pseudo-dma I/O */
@@ -18,29 +17,9 @@
  *      (Unix and Linux consulting and custom programming)
  *      drew@colorado.edu
  *      +1 (303) 440-4894
- *
- * DISTRIBUTION RELEASE 1.
- *
- * For more information, please consult 
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
-*/
+ */
 
 /*
- * Options : 
- * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
- *      for commands that return with a CHECK CONDITION status. 
- *
- * PSEUDO_DMA - enables PSEUDO-DMA hardware, should give a 3-4X performance
- * increase compared to polled I/O.
- *
- * PARITY - enable parity checking.  Not supported.
- *
- * UNSAFE - leave interrupts enabled during pseudo-DMA transfers. 
- *              You probably want this.
- *
  * The card is detected and initialized in one of several ways : 
  * 1.  Autoprobe (default) - since the board is memory mapped, 
  *     a BIOS signature is scanned for to locate the registers.
@@ -79,15 +58,11 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
-#include "scsi.h"
 #include <scsi/scsi_host.h>
 #include "dtc.h"
 #define AUTOPROBE_IRQ
 #include "NCR5380.h"
 
-
-#define DTC_PUBLIC_RELEASE 2
-
 /*
  * The DTC3180 & 3280 boards are memory mapped.
  * 
@@ -173,10 +148,13 @@ static const struct signature {
  *
  */
 
-static void __init dtc_setup(char *str, int *ints)
+static int __init dtc_setup(char *str)
 {
         static int commandline_current = 0;
         int i;
+        int ints[10];
+
+        get_options(str, ARRAY_SIZE(ints), ints);
         if (ints[0] != 2)
                 printk("dtc_setup: usage dtc=address,irq\n");
         else if (commandline_current < NO_OVERRIDES) {
@@ -189,7 +167,10 @@ static void __init dtc_setup(char *str, int *ints)
                         }
                 ++commandline_current;
         }
+        return 1;
 }
+
+__setup("dtc=", dtc_setup);
 #endif
 
 /* 
@@ -213,10 +194,6 @@ static int __init dtc_detect(struct scsi_host_template * tpnt)
         void __iomem *base;
         int sig, count;
 
-        tpnt->proc_name = "dtc3x80";
-        tpnt->show_info = dtc_show_info;
-        tpnt->write_info = dtc_write_info;
-
         for (count = 0; current_override < NO_OVERRIDES; ++current_override) {
                 addr = 0;
                 base = NULL;
@@ -271,38 +248,33 @@ found:
                 else
                         instance->irq = NCR5380_probe_irq(instance, DTC_IRQS);
 
+                /* Compatibility with documented NCR5380 kernel parameters */
+                if (instance->irq == 255)
+                        instance->irq = NO_IRQ;
+
 #ifndef DONT_USE_INTR
                 /* With interrupts enabled, it will sometimes hang when doing heavy
                  * reads. So better not enable them until I finger it out. */
-                if (instance->irq != SCSI_IRQ_NONE)
+                if (instance->irq != NO_IRQ)
                         if (request_irq(instance->irq, dtc_intr, 0,
                                         "dtc", instance)) {
                                 printk(KERN_ERR "scsi%d : IRQ%d not free, interrupts disabled\n", instance->host_no, instance->irq);
-                                instance->irq = SCSI_IRQ_NONE;
+                                instance->irq = NO_IRQ;
                         }
 
-                if (instance->irq == SCSI_IRQ_NONE) {
+                if (instance->irq == NO_IRQ) {
                         printk(KERN_WARNING "scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
                         printk(KERN_WARNING "scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
                 }
 #else
-                if (instance->irq != SCSI_IRQ_NONE)
+                if (instance->irq != NO_IRQ)
                         printk(KERN_WARNING "scsi%d : interrupts not used. Might as well not jumper it.\n", instance->host_no);
-                instance->irq = SCSI_IRQ_NONE;
+                instance->irq = NO_IRQ;
 #endif
 #if defined(DTCDEBUG) && (DTCDEBUG & DTCDEBUG_INIT)
                 printk("scsi%d : irq = %d\n", instance->host_no, instance->irq);
 #endif
 
-                printk(KERN_INFO "scsi%d : at 0x%05X", instance->host_no, (int) instance->base);
-                if (instance->irq == SCSI_IRQ_NONE)
-                        printk(" interrupts disabled");
-                else
-                        printk(" irq %d", instance->irq);
-                printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d", CAN_QUEUE, CMD_PER_LUN, DTC_PUBLIC_RELEASE);
-                NCR5380_print_options(instance);
-                printk("\n");
-
                 ++current_override;
                 ++count;
         }
@@ -354,20 +326,18 @@ static int dtc_biosparam(struct scsi_device *sdev, struct block_device *dev,
  *      timeout.
 */
 
-static int dtc_maxi = 0;
-static int dtc_wmaxi = 0;
-
 static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst, int len)
 {
         unsigned char *d = dst;
         int i;                  /* For counting time spent in the poll-loop */
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
         NCR5380_local_declare();
         NCR5380_setup(instance);
 
         i = 0;
         NCR5380_read(RESET_PARITY_INTERRUPT_REG);
         NCR5380_write(MODE_REG, MR_ENABLE_EOP_INTR | MR_DMA_MODE);
-        if (instance->irq == SCSI_IRQ_NONE)
+        if (instance->irq == NO_IRQ)
                 NCR5380_write(DTC_CONTROL_REG, CSR_DIR_READ);
         else
                 NCR5380_write(DTC_CONTROL_REG, CSR_DIR_READ | CSR_INT_BASE);
@@ -391,8 +361,8 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
         NCR5380_write(MODE_REG, 0);     /* Clear the operating mode */
         rtrc(0);
         NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-        if (i > dtc_maxi)
-                dtc_maxi = i;
+        if (i > hostdata->spin_max_r)
+                hostdata->spin_max_r = i;
         return (0);
 }
 
@@ -412,13 +382,14 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
 static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src, int len)
 {
         int i;
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
         NCR5380_local_declare();
         NCR5380_setup(instance);
 
         NCR5380_read(RESET_PARITY_INTERRUPT_REG);
         NCR5380_write(MODE_REG, MR_ENABLE_EOP_INTR | MR_DMA_MODE);
         /* set direction (write) */
-        if (instance->irq == SCSI_IRQ_NONE)
+        if (instance->irq == NO_IRQ)
                 NCR5380_write(DTC_CONTROL_REG, 0);
         else
                 NCR5380_write(DTC_CONTROL_REG, CSR_5380_INTR);
@@ -444,8 +415,8 @@ static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src,
         /* Check for parity error here. fixme. */
         NCR5380_write(MODE_REG, 0);     /* Clear the operating mode */
         rtrc(0);
-        if (i > dtc_wmaxi)
-                dtc_wmaxi = i;
+        if (i > hostdata->spin_max_w)
+                hostdata->spin_max_w = i;
         return (0);
 }
 
@@ -457,7 +428,7 @@ static int dtc_release(struct Scsi_Host *shost)
 {
         NCR5380_local_declare();
         NCR5380_setup(shost);
-        if (shost->irq)
+        if (shost->irq != NO_IRQ)
                 free_irq(shost->irq, shost);
         NCR5380_exit(shost);
         if (shost->io_port && shost->n_io_port)
@@ -471,6 +442,10 @@ static struct scsi_host_template driver_template = {
         .name                           = "DTC 3180/3280 ",
         .detect                         = dtc_detect,
         .release                        = dtc_release,
+        .proc_name                      = "dtc3x80",
+        .show_info                      = dtc_show_info,
+        .write_info                     = dtc_write_info,
+        .info                           = dtc_info,
         .queuecommand                   = dtc_queue_command,
         .eh_abort_handler               = dtc_abort,
         .eh_bus_reset_handler           = dtc_bus_reset,
diff --git a/drivers/scsi/dtc.h b/drivers/scsi/dtc.h
index 92d7cfc3f4fc..78a2332e9064 100644
--- a/drivers/scsi/dtc.h
+++ b/drivers/scsi/dtc.h
@@ -5,24 +5,6 @@
  *      (Unix and Linux consulting and custom programming)
  *      drew@colorado.edu
  *      +1 (303) 440-4894
- *
- * DISTRIBUTION RELEASE 2. 
- *
- * For more information, please consult 
- *
- * 
- * 
- * and 
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 #ifndef DTC3280_H
@@ -32,13 +14,6 @@
 #define DTCDEBUG_INIT   0x1
 #define DTCDEBUG_TRANSFER 0x2
 
-static int dtc_abort(Scsi_Cmnd *);
-static int dtc_biosparam(struct scsi_device *, struct block_device *,
-                         sector_t, int*);
-static int dtc_detect(struct scsi_host_template *);
-static int dtc_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
-static int dtc_bus_reset(Scsi_Cmnd *);
-
 #ifndef CMD_PER_LUN
 #define CMD_PER_LUN 2
 #endif
@@ -88,6 +63,7 @@ static int dtc_bus_reset(Scsi_Cmnd *);
 #define NCR5380_queue_command           dtc_queue_command
 #define NCR5380_abort                   dtc_abort
 #define NCR5380_bus_reset               dtc_bus_reset
+#define NCR5380_info                    dtc_info
 #define NCR5380_show_info               dtc_show_info 
 #define NCR5380_write_info              dtc_write_info 
 
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index 943ad3a19661..227dd2c2ec2f 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -946,20 +946,18 @@ static int eata2x_slave_configure(struct scsi_device *dev)
 
         if (TLDEV(dev->type) && dev->tagged_supported) {
                 if (tag_mode == TAG_SIMPLE) {
-                        scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
                         tag_suffix = ", simple tags";
                 } else if (tag_mode == TAG_ORDERED) {
-                        scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
                         tag_suffix = ", ordered tags";
                 } else {
-                        scsi_adjust_queue_depth(dev, 0, tqd);
                         tag_suffix = ", no tags";
                 }
+                scsi_change_queue_depth(dev, tqd);
         } else if (TLDEV(dev->type) && linked_comm) {
-                scsi_adjust_queue_depth(dev, 0, tqd);
+                scsi_change_queue_depth(dev, tqd);
                 tag_suffix = ", untagged";
         } else {
-                scsi_adjust_queue_depth(dev, 0, utqd);
+                scsi_change_queue_depth(dev, utqd);
                 tag_suffix = "";
         }
 
diff --git a/drivers/scsi/esas2r/esas2r.h b/drivers/scsi/esas2r/esas2r.h
index 3fd305d6b67d..b6030e3edd01 100644
--- a/drivers/scsi/esas2r/esas2r.h
+++ b/drivers/scsi/esas2r/esas2r.h
@@ -972,11 +972,6 @@ u8 handle_hba_ioctl(struct esas2r_adapter *a,
                     struct atto_ioctl *ioctl_hba);
 int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd);
 int esas2r_show_info(struct seq_file *m, struct Scsi_Host *sh);
-int esas2r_slave_alloc(struct scsi_device *dev);
-int esas2r_slave_configure(struct scsi_device *dev);
-void esas2r_slave_destroy(struct scsi_device *dev);
-int esas2r_change_queue_depth(struct scsi_device *dev, int depth, int reason);
-int esas2r_change_queue_type(struct scsi_device *dev, int type);
 long esas2r_proc_ioctl(struct file *fp, unsigned int cmd, unsigned long arg);
 
 /* SCSI error handler (eh) functions */
diff --git a/drivers/scsi/esas2r/esas2r_ioctl.c b/drivers/scsi/esas2r/esas2r_ioctl.c
index d89a0277a8e1..baf913047b48 100644
--- a/drivers/scsi/esas2r/esas2r_ioctl.c
+++ b/drivers/scsi/esas2r/esas2r_ioctl.c
@@ -117,9 +117,8 @@ static void do_fm_api(struct esas2r_adapter *a, struct esas2r_flash_img *fi)
 
         rq = esas2r_alloc_request(a);
         if (rq == NULL) {
-                up(&a->fm_api_semaphore);
                 fi->status = FI_STAT_BUSY;
-                return;
+                goto free_sem;
         }
 
         if (fi == &a->firmware.header) {
@@ -135,7 +134,7 @@ static void do_fm_api(struct esas2r_adapter *a, struct esas2r_flash_img *fi)
                 if (a->firmware.header_buff == NULL) {
                         esas2r_debug("failed to allocate header buffer!");
                         fi->status = FI_STAT_BUSY;
-                        return;
+                        goto free_req;
                 }
 
                 memcpy(a->firmware.header_buff, fi,
@@ -171,9 +170,10 @@ all_done:
                                   a->firmware.header_buff,
                                   (dma_addr_t)a->firmware.header_buff_phys);
         }
-
-        up(&a->fm_api_semaphore);
+free_req:
         esas2r_free_request(a, (struct esas2r_request *)rq);
+free_sem:
+        up(&a->fm_api_semaphore);
         return;
 
 }
@@ -1420,9 +1420,10 @@ int esas2r_ioctl_handler(void *hostdata, int cmd, void __user *arg)
 
                 rq = esas2r_alloc_request(a);
                 if (rq == NULL) {
-                        up(&a->nvram_semaphore);
-                        ioctl->data.prw.code = 0;
-                        break;
+                        kfree(ioctl);
+                        esas2r_log(ESAS2R_LOG_WARN,
+                           "could not allocate an internal request");
+                        return -ENOMEM;
                 }
 
                 code = esas2r_write_params(a, rq,
@@ -1523,9 +1524,12 @@ ioctl_done:
                 case -EINVAL:
                         ioctl->header.return_code = IOCTL_INVALID_PARAM;
                         break;
+
+                default:
+                        ioctl->header.return_code = IOCTL_GENERAL_ERROR;
+                        break;
                 }
 
-                ioctl->header.return_code = IOCTL_GENERAL_ERROR;
         }
 
         /* Always copy the buffer back, if only to pick up the status */
diff --git a/drivers/scsi/esas2r/esas2r_main.c b/drivers/scsi/esas2r/esas2r_main.c
index 6504a195c874..593ff8a63c70 100644
--- a/drivers/scsi/esas2r/esas2r_main.c
+++ b/drivers/scsi/esas2r/esas2r_main.c
@@ -254,12 +254,10 @@ static struct scsi_host_template driver_template = {
         .use_clustering                 = ENABLE_CLUSTERING,
         .emulated                       = 0,
         .proc_name                      = ESAS2R_DRVR_NAME,
-        .slave_configure                = esas2r_slave_configure,
-        .slave_alloc                    = esas2r_slave_alloc,
-        .slave_destroy                  = esas2r_slave_destroy,
-        .change_queue_depth             = esas2r_change_queue_depth,
-        .change_queue_type              = esas2r_change_queue_type,
+        .change_queue_depth             = scsi_change_queue_depth,
+        .change_queue_type              = scsi_change_queue_type,
         .max_sectors                    = 0xFFFF,
+        .use_blk_tags                   = 1,
 };
 
 int sgl_page_size = 512;
@@ -1057,7 +1055,7 @@ int esas2r_eh_abort(struct scsi_cmnd *cmd)
 
                 cmd->scsi_done(cmd);
 
-                return 0;
+                return SUCCESS;
         }
 
         spin_lock_irqsave(&a->queue_lock, flags);
@@ -1259,60 +1257,6 @@ int esas2r_target_reset(struct scsi_cmnd *cmd)
         return esas2r_dev_targ_reset(cmd, true);
 }
 
-int esas2r_change_queue_depth(struct scsi_device *dev, int depth, int reason)
-{
-        esas2r_log(ESAS2R_LOG_INFO, "change_queue_depth %p, %d", dev, depth);
-
-        scsi_adjust_queue_depth(dev, scsi_get_tag_type(dev), depth);
-
-        return dev->queue_depth;
-}
-
-int esas2r_change_queue_type(struct scsi_device *dev, int type)
-{
-        esas2r_log(ESAS2R_LOG_INFO, "change_queue_type %p, %d", dev, type);
-
-        if (dev->tagged_supported) {
-                scsi_set_tag_type(dev, type);
-
-                if (type)
-                        scsi_activate_tcq(dev, dev->queue_depth);
-                else
-                        scsi_deactivate_tcq(dev, dev->queue_depth);
-        } else {
-                type = 0;
-        }
-
-        return type;
-}
-
-int esas2r_slave_alloc(struct scsi_device *dev)
-{
-        return 0;
-}
-
-int esas2r_slave_configure(struct scsi_device *dev)
-{
-        esas2r_log_dev(ESAS2R_LOG_INFO, &(dev->sdev_gendev),
-                       "esas2r_slave_configure()");
-
-        if (dev->tagged_supported) {
-                scsi_set_tag_type(dev, MSG_SIMPLE_TAG);
-                scsi_activate_tcq(dev, cmd_per_lun);
-        } else {
-                scsi_set_tag_type(dev, 0);
-                scsi_deactivate_tcq(dev, cmd_per_lun);
-        }
-
-        return 0;
-}
-
-void esas2r_slave_destroy(struct scsi_device *dev)
-{
-        esas2r_log_dev(ESAS2R_LOG_INFO, &(dev->sdev_gendev),
-                       "esas2r_slave_destroy()");
-}
-
 void esas2r_log_request_failure(struct esas2r_adapter *a,
                                 struct esas2r_request *rq)
 {
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index 55548dc5cec3..ce5bd52fe692 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -49,55 +49,67 @@ static u32 esp_debug;
 #define ESP_DEBUG_DATADONE      0x00000100
 #define ESP_DEBUG_RECONNECT     0x00000200
 #define ESP_DEBUG_AUTOSENSE     0x00000400
+#define ESP_DEBUG_EVENT         0x00000800
+#define ESP_DEBUG_COMMAND       0x00001000
 
 #define esp_log_intr(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_INTR) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_reset(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_RESET) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_msgin(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_MSGIN) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_msgout(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_MSGOUT) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_cmddone(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_CMDDONE) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_disconnect(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_DISCONNECT) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_datastart(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_DATASTART) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_datadone(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_DATADONE) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_reconnect(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_RECONNECT) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_log_autosense(f, a...) \
 do {    if (esp_debug & ESP_DEBUG_AUTOSENSE) \
-                printk(f, ## a); \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
+} while (0)
+
+#define esp_log_event(f, a...) \
+do {   if (esp_debug & ESP_DEBUG_EVENT) \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
+} while (0)
+
+#define esp_log_command(f, a...) \
+do {   if (esp_debug & ESP_DEBUG_COMMAND)       \
+                shost_printk(KERN_DEBUG, esp->host, f, ## a);   \
 } while (0)
 
 #define esp_read8(REG)          esp->ops->esp_read8(esp, REG)
@@ -126,10 +138,29 @@ void scsi_esp_cmd(struct esp *esp, u8 val)
 
         esp->esp_event_cur = (idx + 1) & (ESP_EVENT_LOG_SZ - 1);
 
+        esp_log_command("cmd[%02x]\n", val);
         esp_write8(val, ESP_CMD);
 }
 EXPORT_SYMBOL(scsi_esp_cmd);
 
+static void esp_send_dma_cmd(struct esp *esp, int len, int max_len, int cmd)
+{
+        if (esp->flags & ESP_FLAG_USE_FIFO) {
+                int i;
+
+                scsi_esp_cmd(esp, ESP_CMD_FLUSH);
+                for (i = 0; i < len; i++)
+                        esp_write8(esp->command_block[i], ESP_FDATA);
+                scsi_esp_cmd(esp, cmd);
+        } else {
+                if (esp->rev == FASHME)
+                        scsi_esp_cmd(esp, ESP_CMD_FLUSH);
+                cmd |= ESP_CMD_DMA;
+                esp->ops->send_dma_cmd(esp, esp->command_block_dma,
+                                       len, max_len, 0, cmd);
+        }
+}
+
 static void esp_event(struct esp *esp, u8 val)
 {
         struct esp_event_ent *p;
@@ -150,19 +181,17 @@ static void esp_dump_cmd_log(struct esp *esp)
         int idx = esp->esp_event_cur;
         int stop = idx;
 
-        printk(KERN_INFO PFX "esp%d: Dumping command log\n",
-               esp->host->unique_id);
+        shost_printk(KERN_INFO, esp->host, "Dumping command log\n");
         do {
                 struct esp_event_ent *p = &esp->esp_event_log[idx];
 
-                printk(KERN_INFO PFX "esp%d: ent[%d] %s ",
-                       esp->host->unique_id, idx,
-                       p->type == ESP_EVENT_TYPE_CMD ? "CMD" : "EVENT");
-
-                printk("val[%02x] sreg[%02x] seqreg[%02x] "
-                       "sreg2[%02x] ireg[%02x] ss[%02x] event[%02x]\n",
-                       p->val, p->sreg, p->seqreg,
-                       p->sreg2, p->ireg, p->select_state, p->event);
+                shost_printk(KERN_INFO, esp->host,
+                             "ent[%d] %s val[%02x] sreg[%02x] seqreg[%02x] "
+                             "sreg2[%02x] ireg[%02x] ss[%02x] event[%02x]\n",
+                             idx,
+                             p->type == ESP_EVENT_TYPE_CMD ? "CMD" : "EVENT",
+                             p->val, p->sreg, p->seqreg,
+                             p->sreg2, p->ireg, p->select_state, p->event);
 
                 idx = (idx + 1) & (ESP_EVENT_LOG_SZ - 1);
         } while (idx != stop);
@@ -176,9 +205,8 @@ static void esp_flush_fifo(struct esp *esp)
 
                 while (esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES) {
                         if (--lim == 0) {
-                                printk(KERN_ALERT PFX "esp%d: ESP_FF_BYTES "
-                                       "will not clear!\n",
-                                       esp->host->unique_id);
+                                shost_printk(KERN_ALERT, esp->host,
+                                             "ESP_FF_BYTES will not clear!\n");
                                 break;
                         }
                         udelay(1);
@@ -240,6 +268,19 @@ static void esp_reset_esp(struct esp *esp)
         } else {
                 esp->min_period = ((5 * esp->ccycle) / 1000);
         }
+        if (esp->rev == FAS236) {
+                /*
+                 * The AM53c974 chip returns the same ID as FAS236;
+                 * try to configure glitch eater.
+                 */
+                u8 config4 = ESP_CONFIG4_GE1;
+                esp_write8(config4, ESP_CFG4);
+                config4 = esp_read8(ESP_CFG4);
+                if (config4 & ESP_CONFIG4_GE1) {
+                        esp->rev = PCSCSI;
+                        esp_write8(esp->config4, ESP_CFG4);
+                }
+        }
         esp->max_period = (esp->max_period + 3)>>2;
         esp->min_period = (esp->min_period + 3)>>2;
 
@@ -265,7 +306,8 @@ static void esp_reset_esp(struct esp *esp)
                 /* fallthrough... */
 
         case FAS236:
-                /* Fast 236 or HME */
+        case PCSCSI:
+                /* Fast 236, AM53c974 or HME */
                 esp_write8(esp->config2, ESP_CFG2);
                 if (esp->rev == FASHME) {
                         u8 cfg3 = esp->target[0].esp_config3;
@@ -383,12 +425,11 @@ static void esp_advance_dma(struct esp *esp, struct esp_cmd_entry *ent,
         p->cur_residue -= len;
         p->tot_residue -= len;
         if (p->cur_residue < 0 || p->tot_residue < 0) {
-                printk(KERN_ERR PFX "esp%d: Data transfer overflow.\n",
-                       esp->host->unique_id);
-                printk(KERN_ERR PFX "esp%d: cur_residue[%d] tot_residue[%d] "
-                       "len[%u]\n",
-                       esp->host->unique_id,
-                       p->cur_residue, p->tot_residue, len);
+                shost_printk(KERN_ERR, esp->host,
+                             "Data transfer overflow.\n");
+                shost_printk(KERN_ERR, esp->host,
+                             "cur_residue[%d] tot_residue[%d] len[%u]\n",
+                             p->cur_residue, p->tot_residue, len);
                 p->cur_residue = 0;
                 p->tot_residue = 0;
         }
@@ -604,9 +645,8 @@ static void esp_autosense(struct esp *esp, struct esp_cmd_entry *ent)
 
 
         if (!ent->sense_ptr) {
-                esp_log_autosense("esp%d: Doing auto-sense for "
-                                  "tgt[%d] lun[%d]\n",
-                                  esp->host->unique_id, tgt, lun);
+                esp_log_autosense("Doing auto-sense for tgt[%d] lun[%d]\n",
+                                  tgt, lun);
 
                 ent->sense_ptr = cmd->sense_buffer;
                 ent->sense_dma = esp->ops->map_single(esp,
@@ -642,10 +682,7 @@ static void esp_autosense(struct esp *esp, struct esp_cmd_entry *ent)
 
         val = (p - esp->command_block);
 
-        if (esp->rev == FASHME)
-                scsi_esp_cmd(esp, ESP_CMD_FLUSH);
-        esp->ops->send_dma_cmd(esp, esp->command_block_dma,
-                               val, 16, 0, ESP_CMD_DMA | ESP_CMD_SELA);
+        esp_send_dma_cmd(esp, val, 16, ESP_CMD_SELA);
 }
 
 static struct esp_cmd_entry *find_and_prep_issuable_command(struct esp *esp)
@@ -663,7 +700,7 @@ static struct esp_cmd_entry *find_and_prep_issuable_command(struct esp *esp)
                         return ent;
                 }
 
-                if (!scsi_populate_tag_msg(cmd, &ent->tag[0])) {
+                if (!spi_populate_tag_msg(&ent->tag[0], cmd)) {
                         ent->tag[0] = 0;
                         ent->tag[1] = 0;
                 }
@@ -781,12 +818,12 @@ build_identify:
         }
 
         if (!(esp->flags & ESP_FLAG_DOING_SLOWCMD)) {
-                start_cmd = ESP_CMD_DMA | ESP_CMD_SELA;
+                start_cmd = ESP_CMD_SELA;
                 if (ent->tag[0]) {
                         *p++ = ent->tag[0];
                         *p++ = ent->tag[1];
 
-                        start_cmd = ESP_CMD_DMA | ESP_CMD_SA3;
+                        start_cmd = ESP_CMD_SA3;
                 }
 
                 for (i = 0; i < cmd->cmd_len; i++)
@@ -806,7 +843,7 @@ build_identify:
                         esp->msg_out_len += 2;
                 }
 
-                start_cmd = ESP_CMD_DMA | ESP_CMD_SELAS;
+                start_cmd = ESP_CMD_SELAS;
                 esp->select_state = ESP_SELECT_MSGOUT;
         }
         val = tgt;
@@ -826,10 +863,7 @@ build_identify:
                 printk("]\n");
         }
 
-        if (esp->rev == FASHME)
-                scsi_esp_cmd(esp, ESP_CMD_FLUSH);
-        esp->ops->send_dma_cmd(esp, esp->command_block_dma,
-                               val, 16, 0, start_cmd);
+        esp_send_dma_cmd(esp, val, 16, start_cmd);
 }
 
 static struct esp_cmd_entry *esp_get_ent(struct esp *esp)
@@ -953,8 +987,8 @@ static int esp_check_gross_error(struct esp *esp)
                  * - DMA programmed with wrong direction
                  * - improper phase change
                  */
-                printk(KERN_ERR PFX "esp%d: Gross error sreg[%02x]\n",
-                       esp->host->unique_id, esp->sreg);
+                shost_printk(KERN_ERR, esp->host,
+                             "Gross error sreg[%02x]\n", esp->sreg);
                 /* XXX Reset the chip. XXX */
                 return 1;
         }
@@ -974,7 +1008,6 @@ static int esp_check_spur_intr(struct esp *esp)
 
         default:
                 if (!(esp->sreg & ESP_STAT_INTR)) {
-                        esp->ireg = esp_read8(ESP_INTRPT);
                         if (esp->ireg & ESP_INTR_SR)
                                 return 1;
 
@@ -982,14 +1015,13 @@ static int esp_check_spur_intr(struct esp *esp)
                          * ESP is not, the only possibility is a DMA error.
                          */
                         if (!esp->ops->dma_error(esp)) {
-                                printk(KERN_ERR PFX "esp%d: Spurious irq, "
-                                       "sreg=%02x.\n",
-                                       esp->host->unique_id, esp->sreg);
+                                shost_printk(KERN_ERR, esp->host,
+                                             "Spurious irq, sreg=%02x.\n",
+                                             esp->sreg);
                                 return -1;
                         }
 
-                        printk(KERN_ERR PFX "esp%d: DMA error\n",
-                               esp->host->unique_id);
+                        shost_printk(KERN_ERR, esp->host, "DMA error\n");
 
                         /* XXX Reset the chip. XXX */
                         return -1;
@@ -1002,7 +1034,7 @@ static int esp_check_spur_intr(struct esp *esp)
 
 static void esp_schedule_reset(struct esp *esp)
 {
-        esp_log_reset("ESP: esp_schedule_reset() from %pf\n",
+        esp_log_reset("esp_schedule_reset() from %pf\n",
                       __builtin_return_address(0));
         esp->flags |= ESP_FLAG_RESETTING;
         esp_event(esp, ESP_EVENT_RESET);
@@ -1019,20 +1051,20 @@ static struct esp_cmd_entry *esp_reconnect_with_tag(struct esp *esp,
         int i;
 
         if (!lp->num_tagged) {
-                printk(KERN_ERR PFX "esp%d: Reconnect w/num_tagged==0\n",
-                       esp->host->unique_id);
+                shost_printk(KERN_ERR, esp->host,
+                             "Reconnect w/num_tagged==0\n");
                 return NULL;
         }
 
-        esp_log_reconnect("ESP: reconnect tag, ");
+        esp_log_reconnect("reconnect tag, ");
 
         for (i = 0; i < ESP_QUICKIRQ_LIMIT; i++) {
                 if (esp->ops->irq_pending(esp))
                         break;
         }
         if (i == ESP_QUICKIRQ_LIMIT) {
-                printk(KERN_ERR PFX "esp%d: Reconnect IRQ1 timeout\n",
-                       esp->host->unique_id);
+                shost_printk(KERN_ERR, esp->host,
+                             "Reconnect IRQ1 timeout\n");
                 return NULL;
         }
 
@@ -1043,14 +1075,14 @@ static struct esp_cmd_entry *esp_reconnect_with_tag(struct esp *esp,
                           i, esp->ireg, esp->sreg);
 
         if (esp->ireg & ESP_INTR_DC) {
-                printk(KERN_ERR PFX "esp%d: Reconnect, got disconnect.\n",
-                       esp->host->unique_id);
+                shost_printk(KERN_ERR, esp->host,
+                             "Reconnect, got disconnect.\n");
                 return NULL;
         }
 
         if ((esp->sreg & ESP_STAT_PMASK) != ESP_MIP) {
-                printk(KERN_ERR PFX "esp%d: Reconnect, not MIP sreg[%02x].\n",
-                       esp->host->unique_id, esp->sreg);
+                shost_printk(KERN_ERR, esp->host,
+                             "Reconnect, not MIP sreg[%02x].\n", esp->sreg);
                 return NULL;
         }
 
@@ -1073,8 +1105,7 @@ static struct esp_cmd_entry *esp_reconnect_with_tag(struct esp *esp,
                 udelay(1);
         }
         if (i == ESP_RESELECT_TAG_LIMIT) {
-                printk(KERN_ERR PFX "esp%d: Reconnect IRQ2 timeout\n",
-                       esp->host->unique_id);
+                shost_printk(KERN_ERR, esp->host, "Reconnect IRQ2 timeout\n");
                 return NULL;
         }
         esp->ops->dma_drain(esp);
@@ -1087,17 +1118,17 @@ static struct esp_cmd_entry *esp_reconnect_with_tag(struct esp *esp,
 
         if (esp->command_block[0] < SIMPLE_QUEUE_TAG ||
             esp->command_block[0] > ORDERED_QUEUE_TAG) {
-                printk(KERN_ERR PFX "esp%d: Reconnect, bad tag "
-                       "type %02x.\n",
-                       esp->host->unique_id, esp->command_block[0]);
+                shost_printk(KERN_ERR, esp->host,
+                             "Reconnect, bad tag type %02x.\n",
+                             esp->command_block[0]);
                 return NULL;
         }
 
         ent = lp->tagged_cmds[esp->command_block[1]];
         if (!ent) {
-                printk(KERN_ERR PFX "esp%d: Reconnect, no entry for "
-                       "tag %02x.\n",
-                       esp->host->unique_id, esp->command_block[1]);
+                shost_printk(KERN_ERR, esp->host,
+                             "Reconnect, no entry for tag %02x.\n",
+                             esp->command_block[1]);
                 return NULL;
         }
 
@@ -1163,9 +1194,9 @@ static int esp_reconnect(struct esp *esp)
         tp = &esp->target[target];
         dev = __scsi_device_lookup_by_target(tp->starget, lun);
         if (!dev) {
-                printk(KERN_ERR PFX "esp%d: Reconnect, no lp "
-                       "tgt[%u] lun[%u]\n",
-                       esp->host->unique_id, target, lun);
+                shost_printk(KERN_ERR, esp->host,
+                             "Reconnect, no lp tgt[%u] lun[%u]\n",
+                             target, lun);
                 goto do_reset;
         }
         lp = dev->hostdata;
@@ -1291,8 +1322,8 @@ static int esp_finish_select(struct esp *esp)
                 return 0;
         }
 
-        printk("ESP: Unexpected selection completion ireg[%x].\n",
-               esp->ireg);
+        shost_printk(KERN_INFO, esp->host,
+                     "Unexpected selection completion ireg[%x]\n", esp->ireg);
         esp_schedule_reset(esp);
         return 0;
 }
@@ -1312,11 +1343,42 @@ static int esp_data_bytes_sent(struct esp *esp, struct esp_cmd_entry *ent,
                           (((unsigned int)esp_read8(ESP_TCMED)) << 8));
                 if (esp->rev == FASHME)
                         ecount |= ((unsigned int)esp_read8(FAS_RLO)) << 16;
+                if (esp->rev == PCSCSI && (esp->config2 & ESP_CONFIG2_FENAB))
+                        ecount |= ((unsigned int)esp_read8(ESP_TCHI)) << 16;
         }
 
         bytes_sent = esp->data_dma_len;
         bytes_sent -= ecount;
 
+        /*
+         * The am53c974 has a DMA 'pecularity'. The doc states:
+         * In some odd byte conditions, one residual byte will
+         * be left in the SCSI FIFO, and the FIFO Flags will
+         * never count to '0 '. When this happens, the residual
+         * byte should be retrieved via PIO following completion
+         * of the BLAST operation.
+         */
+        if (fifo_cnt == 1 && ent->flags & ESP_CMD_FLAG_RESIDUAL) {
+                size_t count = 1;
+                size_t offset = bytes_sent;
+                u8 bval = esp_read8(ESP_FDATA);
+
+                if (ent->flags & ESP_CMD_FLAG_AUTOSENSE)
+                        ent->sense_ptr[bytes_sent] = bval;
+                else {
+                        struct esp_cmd_priv *p = ESP_CMD_PRIV(cmd);
+                        u8 *ptr;
+
+                        ptr = scsi_kmap_atomic_sg(p->cur_sg, p->u.num_sg,
+                                                  &offset, &count);
+                        if (likely(ptr)) {
+                                *(ptr + offset) = bval;
+                                scsi_kunmap_atomic_sg(ptr);
+                        }
+                }
+                bytes_sent += fifo_cnt;
+                ent->flags &= ~ESP_CMD_FLAG_RESIDUAL;
+        }
         if (!(ent->flags & ESP_CMD_FLAG_WRITE))
                 bytes_sent -= fifo_cnt;
 
@@ -1556,8 +1618,8 @@ static void esp_msgin_extended(struct esp *esp)
                 return;
         }
 
-        printk("ESP: Unexpected extended msg type %x\n",
-               esp->msg_in[2]);
+        shost_printk(KERN_INFO, esp->host,
+                     "Unexpected extended msg type %x\n", esp->msg_in[2]);
 
         esp->msg_out[0] = ABORT_TASK_SET;
         esp->msg_out_len = 1;
@@ -1574,7 +1636,8 @@ static int esp_msgin_process(struct esp *esp)
 
         if (msg0 & 0x80) {
                 /* Identify */
-                printk("ESP: Unexpected msgin identify\n");
+                shost_printk(KERN_INFO, esp->host,
+                             "Unexpected msgin identify\n");
                 return 0;
         }
 
@@ -1640,10 +1703,12 @@ static int esp_msgin_process(struct esp *esp)
 
 static int esp_process_event(struct esp *esp)
 {
-        int write;
+        int write, i;
 
 again:
         write = 0;
+        esp_log_event("process event %d phase %x\n",
+                      esp->event, esp->sreg & ESP_STAT_PMASK);
         switch (esp->event) {
         case ESP_EVENT_CHECK_PHASE:
                 switch (esp->sreg & ESP_STAT_PMASK) {
@@ -1673,8 +1738,9 @@ again:
                         break;
 
                 default:
-                        printk("ESP: Unexpected phase, sreg=%02x\n",
-                               esp->sreg);
+                        shost_printk(KERN_INFO, esp->host,
+                                     "Unexpected phase, sreg=%02x\n",
+                                     esp->sreg);
                         esp_schedule_reset(esp);
                         return 0;
                 }
@@ -1708,18 +1774,17 @@ again:
                 esp->data_dma_len = dma_len;
 
                 if (!dma_len) {
-                        printk(KERN_ERR PFX "esp%d: DMA length is zero!\n",
-                               esp->host->unique_id);
-                        printk(KERN_ERR PFX "esp%d: cur adr[%08llx] len[%08x]\n",
-                               esp->host->unique_id,
-                               (unsigned long long)esp_cur_dma_addr(ent, cmd),
-                               esp_cur_dma_len(ent, cmd));
+                        shost_printk(KERN_ERR, esp->host,
+                                     "DMA length is zero!\n");
+                        shost_printk(KERN_ERR, esp->host,
+                                     "cur adr[%08llx] len[%08x]\n",
+                                     (unsigned long long)esp_cur_dma_addr(ent, cmd),
+                                     esp_cur_dma_len(ent, cmd));
                         esp_schedule_reset(esp);
                         return 0;
                 }
 
-                esp_log_datastart("ESP: start data addr[%08llx] len[%u] "
-                                  "write(%d)\n",
+                esp_log_datastart("start data addr[%08llx] len[%u] write(%d)\n",
                                   (unsigned long long)dma_addr, dma_len, write);
 
                 esp->ops->send_dma_cmd(esp, dma_addr, dma_len, dma_len,
@@ -1733,7 +1798,8 @@ again:
                 int bytes_sent;
 
                 if (esp->ops->dma_error(esp)) {
-                        printk("ESP: data done, DMA error, resetting\n");
+                        shost_printk(KERN_INFO, esp->host,
+                                     "data done, DMA error, resetting\n");
                         esp_schedule_reset(esp);
                         return 0;
                 }
@@ -1749,14 +1815,15 @@ again:
                         /* We should always see exactly a bus-service
                          * interrupt at the end of a successful transfer.
                          */
-                        printk("ESP: data done, not BSERV, resetting\n");
+                        shost_printk(KERN_INFO, esp->host,
+                                     "data done, not BSERV, resetting\n");
                         esp_schedule_reset(esp);
                         return 0;
                 }
 
                 bytes_sent = esp_data_bytes_sent(esp, ent, cmd);
 
-                esp_log_datadone("ESP: data done flgs[%x] sent[%d]\n",
+                esp_log_datadone("data done flgs[%x] sent[%d]\n",
                                  ent->flags, bytes_sent);
 
                 if (bytes_sent < 0) {
@@ -1785,8 +1852,9 @@ again:
                 }
 
                 if (ent->message != COMMAND_COMPLETE) {
-                        printk("ESP: Unexpected message %x in status\n",
-                               ent->message);
+                        shost_printk(KERN_INFO, esp->host,
+                                     "Unexpected message %x in status\n",
+                                     ent->message);
                         esp_schedule_reset(esp);
                         return 0;
                 }
@@ -1804,8 +1872,7 @@ again:
                         scsi_esp_cmd(esp, ESP_CMD_ESEL);
 
                 if (ent->message == COMMAND_COMPLETE) {
-                        esp_log_cmddone("ESP: Command done status[%x] "
-                                        "message[%x]\n",
+                        esp_log_cmddone("Command done status[%x] message[%x]\n",
                                         ent->status, ent->message);
                         if (ent->status == SAM_STAT_TASK_SET_FULL)
                                 esp_event_queue_full(esp, ent);
@@ -1821,16 +1888,16 @@ again:
                                                                DID_OK));
                         }
                 } else if (ent->message == DISCONNECT) {
-                        esp_log_disconnect("ESP: Disconnecting tgt[%d] "
-                                           "tag[%x:%x]\n",
+                        esp_log_disconnect("Disconnecting tgt[%d] tag[%x:%x]\n",
                                            cmd->device->id,
                                            ent->tag[0], ent->tag[1]);
 
                         esp->active_cmd = NULL;
                         esp_maybe_execute_command(esp);
                 } else {
-                        printk("ESP: Unexpected message %x in freebus\n",
-                               ent->message);
+                        shost_printk(KERN_INFO, esp->host,
+                                     "Unexpected message %x in freebus\n",
+                                     ent->message);
                         esp_schedule_reset(esp);
                         return 0;
                 }
@@ -1862,6 +1929,10 @@ again:
                         if (esp->msg_out_len == 1) {
                                 esp_write8(esp->msg_out[0], ESP_FDATA);
                                 scsi_esp_cmd(esp, ESP_CMD_TI);
+                        } else if (esp->flags & ESP_FLAG_USE_FIFO) {
+                                for (i = 0; i < esp->msg_out_len; i++)
+                                        esp_write8(esp->msg_out[i], ESP_FDATA);
+                                scsi_esp_cmd(esp, ESP_CMD_TI);
                         } else {
                                 /* Use DMA. */
                                 memcpy(esp->command_block,
@@ -1917,7 +1988,7 @@ again:
                                 val = esp_read8(ESP_FDATA);
                         esp->msg_in[esp->msg_in_len++] = val;
 
-                        esp_log_msgin("ESP: Got msgin byte %x\n", val);
+                        esp_log_msgin("Got msgin byte %x\n", val);
 
                         if (!esp_msgin_process(esp))
                                 esp->msg_in_len = 0;
@@ -1930,7 +2001,8 @@ again:
                         if (esp->event != ESP_EVENT_FREE_BUS)
                                 esp_event(esp, ESP_EVENT_CHECK_PHASE);
                 } else {
-                        printk("ESP: MSGIN neither BSERV not FDON, resetting");
+                        shost_printk(KERN_INFO, esp->host,
+                                     "MSGIN neither BSERV not FDON, resetting");
                         esp_schedule_reset(esp);
                         return 0;
                 }
@@ -1938,11 +2010,7 @@ again:
         case ESP_EVENT_CMD_START:
                 memcpy(esp->command_block, esp->cmd_bytes_ptr,
                        esp->cmd_bytes_left);
-                if (esp->rev == FASHME)
-                        scsi_esp_cmd(esp, ESP_CMD_FLUSH);
-                esp->ops->send_dma_cmd(esp, esp->command_block_dma,
-                                       esp->cmd_bytes_left, 16, 0,
-                                       ESP_CMD_DMA | ESP_CMD_TI);
+                esp_send_dma_cmd(esp, esp->cmd_bytes_left, 16, ESP_CMD_TI);
                 esp_event(esp, ESP_EVENT_CMD_DONE);
                 esp->flags |= ESP_FLAG_QUICKIRQ_CHECK;
                 break;
@@ -1961,8 +2029,8 @@ again:
                 break;
 
         default:
-                printk("ESP: Unexpected event %x, resetting\n",
-                       esp->event);
+                shost_printk(KERN_INFO, esp->host,
+                             "Unexpected event %x, resetting\n", esp->event);
                 esp_schedule_reset(esp);
                 return 0;
                 break;
@@ -2044,7 +2112,12 @@ static void __esp_interrupt(struct esp *esp)
         int finish_reset, intr_done;
         u8 phase;
 
+       /*
+        * Once INTRPT is read STATUS and SSTEP are cleared.
+        */
         esp->sreg = esp_read8(ESP_STATUS);
+        esp->seqreg = esp_read8(ESP_SSTEP);
+        esp->ireg = esp_read8(ESP_INTRPT);
 
         if (esp->flags & ESP_FLAG_RESETTING) {
                 finish_reset = 1;
@@ -2057,8 +2130,6 @@ static void __esp_interrupt(struct esp *esp)
                         return;
         }
 
-        esp->ireg = esp_read8(ESP_INTRPT);
-
         if (esp->ireg & ESP_INTR_SR)
                 finish_reset = 1;
 
@@ -2085,14 +2156,15 @@ static void __esp_interrupt(struct esp *esp)
                 }
         }
 
-        esp_log_intr("ESP: intr sreg[%02x] seqreg[%02x] "
+        esp_log_intr("intr sreg[%02x] seqreg[%02x] "
                      "sreg2[%02x] ireg[%02x]\n",
                      esp->sreg, esp->seqreg, esp->sreg2, esp->ireg);
 
         intr_done = 0;
 
         if (esp->ireg & (ESP_INTR_S | ESP_INTR_SATN | ESP_INTR_IC)) {
-                printk("ESP: unexpected IREG %02x\n", esp->ireg);
+                shost_printk(KERN_INFO, esp->host,
+                             "unexpected IREG %02x\n", esp->ireg);
                 if (esp->ireg & ESP_INTR_IC)
                         esp_dump_cmd_log(esp);
 
@@ -2149,46 +2221,50 @@ static void esp_get_revision(struct esp *esp)
         u8 val;
 
         esp->config1 = (ESP_CONFIG1_PENABLE | (esp->scsi_id & 7));
-        esp->config2 = (ESP_CONFIG2_SCSI2ENAB | ESP_CONFIG2_REGPARITY);
+        if (esp->config2 == 0) {
+                esp->config2 = (ESP_CONFIG2_SCSI2ENAB | ESP_CONFIG2_REGPARITY);
+                esp_write8(esp->config2, ESP_CFG2);
+
+                val = esp_read8(ESP_CFG2);
+                val &= ~ESP_CONFIG2_MAGIC;
+
+                esp->config2 = 0;
+                if (val != (ESP_CONFIG2_SCSI2ENAB | ESP_CONFIG2_REGPARITY)) {
+                        /*
+                         * If what we write to cfg2 does not come back,
+                         * cfg2 is not implemented.
+                         * Therefore this must be a plain esp100.
+                         */
+                        esp->rev = ESP100;
+                        return;
+                }
+        }
+
+        esp_set_all_config3(esp, 5);
+        esp->prev_cfg3 = 5;
         esp_write8(esp->config2, ESP_CFG2);
+        esp_write8(0, ESP_CFG3);
+        esp_write8(esp->prev_cfg3, ESP_CFG3);
 
-        val = esp_read8(ESP_CFG2);
-        val &= ~ESP_CONFIG2_MAGIC;
-        if (val != (ESP_CONFIG2_SCSI2ENAB | ESP_CONFIG2_REGPARITY)) {
-                /* If what we write to cfg2 does not come back, cfg2 is not
-                 * implemented, therefore this must be a plain esp100.
+        val = esp_read8(ESP_CFG3);
+        if (val != 5) {
+                /* The cfg2 register is implemented, however
+                 * cfg3 is not, must be esp100a.
                  */
-                esp->rev = ESP100;
+                esp->rev = ESP100A;
         } else {
-                esp->config2 = 0;
-                esp_set_all_config3(esp, 5);
-                esp->prev_cfg3 = 5;
-                esp_write8(esp->config2, ESP_CFG2);
-                esp_write8(0, ESP_CFG3);
+                esp_set_all_config3(esp, 0);
+                esp->prev_cfg3 = 0;
                 esp_write8(esp->prev_cfg3, ESP_CFG3);
 
-                val = esp_read8(ESP_CFG3);
-                if (val != 5) {
-                        /* The cfg2 register is implemented, however
-                         * cfg3 is not, must be esp100a.
-                         */
-                        esp->rev = ESP100A;
+                /* All of cfg{1,2,3} implemented, must be one of
+                 * the fas variants, figure out which one.
+                 */
+                if (esp->cfact == 0 || esp->cfact > ESP_CCF_F5) {
+                        esp->rev = FAST;
+                        esp->sync_defp = SYNC_DEFP_FAST;
                 } else {
-                        esp_set_all_config3(esp, 0);
-                        esp->prev_cfg3 = 0;
-                        esp_write8(esp->prev_cfg3, ESP_CFG3);
-
-                        /* All of cfg{1,2,3} implemented, must be one of
-                         * the fas variants, figure out which one.
-                         */
-                        if (esp->cfact == 0 || esp->cfact > ESP_CCF_F5) {
-                                esp->rev = FAST;
-                                esp->sync_defp = SYNC_DEFP_FAST;
-                        } else {
-                                esp->rev = ESP236;
-                        }
-                        esp->config2 = 0;
-                        esp_write8(esp->config2, ESP_CFG2);
+                        esp->rev = ESP236;
                 }
         }
 }
@@ -2308,6 +2384,7 @@ static const char *esp_chip_names[] = {
         "FAS100A",
         "FAST",
         "FASHME",
+        "AM53C974",
 };
 
 static struct scsi_transport_template *esp_transport_template;
@@ -2317,6 +2394,10 @@ int scsi_esp_register(struct esp *esp, struct device *dev)
         static int instance;
         int err;
 
+        if (!esp->num_tags)
+                esp->num_tags = ESP_DEFAULT_TAGS;
+        else if (esp->num_tags >= ESP_MAX_TAG)
+                esp->num_tags = ESP_MAX_TAG - 1;
         esp->host->transportt = esp_transport_template;
         esp->host->max_lun = ESP_MAX_LUN;
         esp->host->cmd_per_lun = 2;
@@ -2330,12 +2411,13 @@ int scsi_esp_register(struct esp *esp, struct device *dev)
 
         esp_bootup_reset(esp);
 
-        printk(KERN_INFO PFX "esp%u, regs[%1p:%1p] irq[%u]\n",
-               esp->host->unique_id, esp->regs, esp->dma_regs,
-               esp->host->irq);
-        printk(KERN_INFO PFX "esp%u is a %s, %u MHz (ccf=%u), SCSI ID %u\n",
-               esp->host->unique_id, esp_chip_names[esp->rev],
-               esp->cfreq / 1000000, esp->cfact, esp->scsi_id);
+        dev_printk(KERN_INFO, dev, "esp%u: regs[%1p:%1p] irq[%u]\n",
+                   esp->host->unique_id, esp->regs, esp->dma_regs,
+                   esp->host->irq);
+        dev_printk(KERN_INFO, dev,
+                   "esp%u: is a %s, %u MHz (ccf=%u), SCSI ID %u\n",
+                   esp->host->unique_id, esp_chip_names[esp->rev],
+                   esp->cfreq / 1000000, esp->cfact, esp->scsi_id);
 
         /* Let the SCSI bus reset settle. */
         ssleep(esp_bus_reset_settle);
@@ -2402,28 +2484,10 @@ static int esp_slave_configure(struct scsi_device *dev)
 {
         struct esp *esp = shost_priv(dev->host);
         struct esp_target_data *tp = &esp->target[dev->id];
-        int goal_tags, queue_depth;
-
-        goal_tags = 0;
 
-        if (dev->tagged_supported) {
-                /* XXX make this configurable somehow XXX */
-                goal_tags = ESP_DEFAULT_TAGS;
-
-                if (goal_tags > ESP_MAX_TAG)
-                        goal_tags = ESP_MAX_TAG;
-        }
+        if (dev->tagged_supported)
+                scsi_change_queue_depth(dev, esp->num_tags);
 
-        queue_depth = goal_tags;
-        if (queue_depth < dev->host->cmd_per_lun)
-                queue_depth = dev->host->cmd_per_lun;
-
-        if (goal_tags) {
-                scsi_set_tag_type(dev, MSG_ORDERED_TAG);
-                scsi_activate_tcq(dev, queue_depth);
-        } else {
-                scsi_deactivate_tcq(dev, queue_depth);
-        }
         tp->flags |= ESP_TGT_DISCONNECT;
 
         if (!spi_initial_dv(dev->sdev_target))
@@ -2451,19 +2515,20 @@ static int esp_eh_abort_handler(struct scsi_cmnd *cmd)
          * XXX much for the final driver.
          */
         spin_lock_irqsave(esp->host->host_lock, flags);
-        printk(KERN_ERR PFX "esp%d: Aborting command [%p:%02x]\n",
-               esp->host->unique_id, cmd, cmd->cmnd[0]);
+        shost_printk(KERN_ERR, esp->host, "Aborting command [%p:%02x]\n",
+                     cmd, cmd->cmnd[0]);
         ent = esp->active_cmd;
         if (ent)
-                printk(KERN_ERR PFX "esp%d: Current command [%p:%02x]\n",
-                       esp->host->unique_id, ent->cmd, ent->cmd->cmnd[0]);
+                shost_printk(KERN_ERR, esp->host,
+                             "Current command [%p:%02x]\n",
+                             ent->cmd, ent->cmd->cmnd[0]);
         list_for_each_entry(ent, &esp->queued_cmds, list) {
-                printk(KERN_ERR PFX "esp%d: Queued command [%p:%02x]\n",
-                       esp->host->unique_id, ent->cmd, ent->cmd->cmnd[0]);
+                shost_printk(KERN_ERR, esp->host, "Queued command [%p:%02x]\n",
+                             ent->cmd, ent->cmd->cmnd[0]);
         }
         list_for_each_entry(ent, &esp->active_cmds, list) {
-                printk(KERN_ERR PFX "esp%d: Active command [%p:%02x]\n",
-                       esp->host->unique_id, ent->cmd, ent->cmd->cmnd[0]);
+                shost_printk(KERN_ERR, esp->host, " Active command [%p:%02x]\n",
+                             ent->cmd, ent->cmd->cmnd[0]);
         }
         esp_dump_cmd_log(esp);
         spin_unlock_irqrestore(esp->host->host_lock, flags);
@@ -2631,6 +2696,7 @@ struct scsi_host_template scsi_esp_template = {
         .use_clustering         = ENABLE_CLUSTERING,
         .max_sectors            = 0xffff,
         .skip_settle_delay      = 1,
+        .use_blk_tags           = 1,
 };
 EXPORT_SYMBOL(scsi_esp_template);
 
diff --git a/drivers/scsi/esp_scsi.h b/drivers/scsi/esp_scsi.h
index cd68805e8d78..84dcbe4a6268 100644
--- a/drivers/scsi/esp_scsi.h
+++ b/drivers/scsi/esp_scsi.h
@@ -1,4 +1,4 @@
-/* esp_scsi.h: Defines and structures for the ESP drier.
+/* esp_scsi.h: Defines and structures for the ESP driver.
  *
  * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
  */
@@ -25,6 +25,7 @@
 #define ESP_CTEST       0x0aUL          /* wo  Chip test register      0x28  */
 #define ESP_CFG2        0x0bUL          /* rw  Second cfg register     0x2c  */
 #define ESP_CFG3        0x0cUL          /* rw  Third cfg register      0x30  */
+#define ESP_CFG4        0x0dUL          /* rw  Fourth cfg register     0x34  */
 #define ESP_TCHI        0x0eUL          /* rw  High bits transf count  0x38  */
 #define ESP_UID         ESP_TCHI        /* ro  Unique ID code          0x38  */
 #define FAS_RLO         ESP_TCHI        /* rw  HME extended counter    0x38  */
@@ -76,6 +77,18 @@
 #define ESP_CONFIG3_IMS       0x80     /* ID msg chk'ng        (esp/fas236)  */
 #define ESP_CONFIG3_OBPUSH    0x80     /* Push odd-byte to dma (hme)         */
 
+/* ESP config register 4 read-write, found only on am53c974 chips */
+#define ESP_CONFIG4_RADE      0x04     /* Active negation */
+#define ESP_CONFIG4_RAE       0x08     /* Active negation on REQ and ACK */
+#define ESP_CONFIG4_PWD       0x20     /* Reduced power feature */
+#define ESP_CONFIG4_GE0       0x40     /* Glitch eater bit 0 */
+#define ESP_CONFIG4_GE1       0x80     /* Glitch eater bit 1 */
+
+#define ESP_CONFIG_GE_12NS    (0)
+#define ESP_CONFIG_GE_25NS    (ESP_CONFIG_GE1)
+#define ESP_CONFIG_GE_35NS    (ESP_CONFIG_GE0)
+#define ESP_CONFIG_GE_0NS     (ESP_CONFIG_GE0 | ESP_CONFIG_GE1)
+
 /* ESP command register read-write */
 /* Group 1 commands:  These may be sent at any point in time to the ESP
  *                    chip.  None of them can generate interrupts 'cept
@@ -254,6 +267,7 @@ enum esp_rev {
         FAS100A    = 0x04,
         FAST       = 0x05,
         FASHME     = 0x06,
+        PCSCSI     = 0x07,  /* AM53c974 */
 };
 
 struct esp_cmd_entry {
@@ -269,6 +283,7 @@ struct esp_cmd_entry {
 #define ESP_CMD_FLAG_WRITE      0x01 /* DMA is a write */
 #define ESP_CMD_FLAG_ABORT      0x02 /* being aborted */
 #define ESP_CMD_FLAG_AUTOSENSE  0x04 /* Doing automatic REQUEST_SENSE */
+#define ESP_CMD_FLAG_RESIDUAL   0x08 /* AM53c974 BLAST residual */
 
         u8                      tag[2];
         u8                      orig_tag[2];
@@ -283,7 +298,6 @@ struct esp_cmd_entry {
         struct completion       *eh_done;
 };
 
-/* XXX make this configurable somehow XXX */
 #define ESP_DEFAULT_TAGS        16
 
 #define ESP_MAX_TARGET          16
@@ -445,7 +459,7 @@ struct esp {
         u8                      prev_soff;
         u8                      prev_stp;
         u8                      prev_cfg3;
-        u8                      __pad;
+        u8                      num_tags;
 
         struct list_head        esp_cmd_pool;
 
@@ -466,6 +480,7 @@ struct esp {
         u8                      bursts;
         u8                      config1;
         u8                      config2;
+        u8                      config4;
 
         u8                      scsi_id;
         u32                     scsi_id_mask;
@@ -479,6 +494,7 @@ struct esp {
 #define ESP_FLAG_WIDE_CAPABLE   0x00000008
 #define ESP_FLAG_QUICKIRQ_CHECK 0x00000010
 #define ESP_FLAG_DISABLE_SYNC   0x00000020
+#define ESP_FLAG_USE_FIFO       0x00000040
 
         u8                      select_state;
 #define ESP_SELECT_NONE         0x00 /* Not selecting */
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index 4a8ac7d8c76b..308a016fdaea 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -280,14 +280,16 @@ static struct scsi_host_template fcoe_shost_template = {
         .eh_device_reset_handler = fc_eh_device_reset,
         .eh_host_reset_handler = fc_eh_host_reset,
         .slave_alloc = fc_slave_alloc,
-        .change_queue_depth = fc_change_queue_depth,
-        .change_queue_type = fc_change_queue_type,
+        .change_queue_depth = scsi_change_queue_depth,
+        .change_queue_type = scsi_change_queue_type,
         .this_id = -1,
         .cmd_per_lun = 3,
         .can_queue = FCOE_MAX_OUTSTANDING_COMMANDS,
         .use_clustering = ENABLE_CLUSTERING,
         .sg_tablesize = SG_ALL,
         .max_sectors = 0xffff,
+        .use_blk_tags = 1,
+        .track_queue_depth = 1,
 };
 
 /**
diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
index bf8d34c26f13..3b73b96619e2 100644
--- a/drivers/scsi/fnic/fnic.h
+++ b/drivers/scsi/fnic/fnic.h
@@ -39,7 +39,7 @@
 
 #define DRV_NAME                "fnic"
 #define DRV_DESCRIPTION         "Cisco FCoE HBA Driver"
-#define DRV_VERSION             "1.6.0.11"
+#define DRV_VERSION             "1.6.0.16"
 #define PFX                     DRV_NAME ": "
 #define DFX                     DRV_NAME "%d: "
 
diff --git a/drivers/scsi/fnic/fnic_fcs.c b/drivers/scsi/fnic/fnic_fcs.c
index f3984b48f8e9..bf0bbd42efb5 100644
--- a/drivers/scsi/fnic/fnic_fcs.c
+++ b/drivers/scsi/fnic/fnic_fcs.c
@@ -135,6 +135,11 @@ void fnic_handle_link(struct work_struct *work)
                         fnic->lport->host->host_no, FNIC_FC_LE,
                         "Link Status: UP_DOWN",
                         strlen("Link Status: UP_DOWN"));
+                if (fnic->config.flags & VFCF_FIP_CAPABLE) {
+                        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
+                                "deleting fip-timer during link-down\n");
+                        del_timer_sync(&fnic->fip_timer);
+                }
                 fcoe_ctlr_link_down(&fnic->ctlr);
         }
 
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index 8c56fdc3a456..0c1f8177b5b7 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -95,12 +95,10 @@ static int fnic_slave_alloc(struct scsi_device *sdev)
 {
         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
 
-        sdev->tagged_supported = 1;
-
         if (!rport || fc_remote_port_chkready(rport))
                 return -ENXIO;
 
-        scsi_activate_tcq(sdev, fnic_max_qdepth);
+        scsi_change_queue_depth(sdev, fnic_max_qdepth);
         return 0;
 }
 
@@ -112,8 +110,8 @@ static struct scsi_host_template fnic_host_template = {
         .eh_device_reset_handler = fnic_device_reset,
         .eh_host_reset_handler = fnic_host_reset,
         .slave_alloc = fnic_slave_alloc,
-        .change_queue_depth = fc_change_queue_depth,
-        .change_queue_type = fc_change_queue_type,
+        .change_queue_depth = scsi_change_queue_depth,
+        .change_queue_type = scsi_change_queue_type,
         .this_id = -1,
         .cmd_per_lun = 3,
         .can_queue = FNIC_DFLT_IO_REQ,
@@ -121,6 +119,8 @@ static struct scsi_host_template fnic_host_template = {
         .sg_tablesize = FNIC_MAX_SG_DESC_CNT,
         .max_sectors = 0xffff,
         .shost_attrs = fnic_attrs,
+        .use_blk_tags = 1,
+        .track_queue_depth = 1,
 };
 
 static void
@@ -438,21 +438,30 @@ static int fnic_dev_wait(struct vnic_dev *vdev,
         unsigned long time;
         int done;
         int err;
+        int count;
+
+        count = 0;
 
         err = start(vdev, arg);
         if (err)
                 return err;
 
-        /* Wait for func to complete...2 seconds max */
+        /* Wait for func to complete.
+        * Sometime schedule_timeout_uninterruptible take long time
+        * to wake up so we do not retry as we are only waiting for
+        * 2 seconds in while loop. By adding count, we make sure
+        * we try atleast three times before returning -ETIMEDOUT
+        */
         time = jiffies + (HZ * 2);
         do {
                 err = finished(vdev, &done);
+                count++;
                 if (err)
                         return err;
                 if (done)
                         return 0;
                 schedule_timeout_uninterruptible(HZ / 10);
-        } while (time_after(time, jiffies));
+        } while (time_after(time, jiffies) || (count < 3));
 
         return -ETIMEDOUT;
 }
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index 961bdf5d31cd..2097de42a147 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -325,13 +325,11 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
         struct fc_rport_libfc_priv *rp = rport->dd_data;
         struct host_sg_desc *desc;
         struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
-        u8 pri_tag = 0;
         unsigned int i;
         unsigned long intr_flags;
         int flags;
         u8 exch_flags;
         struct scsi_lun fc_lun;
-        char msg[2];
 
         if (sg_count) {
                 /* For each SGE, create a device desc entry */
@@ -357,12 +355,6 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
 
         int_to_scsilun(sc->device->lun, &fc_lun);
 
-        pri_tag = FCPIO_ICMND_PTA_SIMPLE;
-        msg[0] = MSG_SIMPLE_TAG;
-        scsi_populate_tag_msg(sc, msg);
-        if (msg[0] == MSG_ORDERED_TAG)
-                pri_tag = FCPIO_ICMND_PTA_ORDERED;
-
         /* Enqueue the descriptor in the Copy WQ */
         spin_lock_irqsave(&fnic->wq_copy_lock[0], intr_flags);
 
@@ -394,7 +386,8 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
                                          io_req->sgl_list_pa,
                                          io_req->sense_buf_pa,
                                          0, /* scsi cmd ref, always 0 */
-                                         pri_tag, /* scsi pri and tag */
+                                         FCPIO_ICMND_PTA_SIMPLE,
+                                                /* scsi pri and tag */
                                          flags, /* command flags */
                                          sc->cmnd, sc->cmd_len,
                                          scsi_bufflen(sc),
@@ -428,8 +421,10 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
         int ret;
         u64 cmd_trace;
         int sg_count = 0;
-        unsigned long flags;
+        unsigned long flags = 0;
         unsigned long ptr;
+        struct fc_rport_priv *rdata;
+        spinlock_t *io_lock = NULL;
 
         if (unlikely(fnic_chk_state_flags_locked(fnic, FNIC_FLAGS_IO_BLOCKED)))
                 return SCSI_MLQUEUE_HOST_BUSY;
@@ -443,6 +438,16 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
                 return 0;
         }
 
+        rdata = lp->tt.rport_lookup(lp, rport->port_id);
+        if (!rdata || (rdata->rp_state == RPORT_ST_DELETE)) {
+                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+                        "returning IO as rport is removed\n");
+                atomic64_inc(&fnic_stats->misc_stats.rport_not_ready);
+                sc->result = DID_NO_CONNECT;
+                done(sc);
+                return 0;
+        }
+
         if (lp->state != LPORT_ST_READY || !(lp->link_up))
                 return SCSI_MLQUEUE_HOST_BUSY;
 
@@ -505,6 +510,13 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
                 }
         }
 
+        /*
+        * Will acquire lock defore setting to IO initialized.
+        */
+
+        io_lock = fnic_io_lock_hash(fnic, sc);
+        spin_lock_irqsave(io_lock, flags);
+
         /* initialize rest of io_req */
         io_req->port_id = rport->port_id;
         io_req->start_time = jiffies;
@@ -521,11 +533,9 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
                  * In case another thread cancelled the request,
                  * refetch the pointer under the lock.
                  */
-                spinlock_t *io_lock = fnic_io_lock_hash(fnic, sc);
                 FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
                           sc->request->tag, sc, 0, 0, 0,
                           (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
-                spin_lock_irqsave(io_lock, flags);
                 io_req = (struct fnic_io_req *)CMD_SP(sc);
                 CMD_SP(sc) = NULL;
                 CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
@@ -534,6 +544,10 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
                         fnic_release_ioreq_buf(fnic, io_req, sc);
                         mempool_free(io_req, fnic->io_req_pool);
                 }
+                atomic_dec(&fnic->in_flight);
+                /* acquire host lock before returning to SCSI */
+                spin_lock(lp->host->host_lock);
+                return ret;
         } else {
                 atomic64_inc(&fnic_stats->io_stats.active_ios);
                 atomic64_inc(&fnic_stats->io_stats.num_ios);
@@ -555,6 +569,11 @@ out:
                   sc->request->tag, sc, io_req,
                   sg_count, cmd_trace,
                   (((u64)CMD_FLAGS(sc) >> 32) | CMD_STATE(sc)));
+
+        /* if only we issued IO, will we have the io lock */
+        if (CMD_FLAGS(sc) & FNIC_IO_INITIALIZED)
+                spin_unlock_irqrestore(io_lock, flags);
+
         atomic_dec(&fnic->in_flight);
         /* acquire host lock before returning to SCSI */
         spin_lock(lp->host->host_lock);
diff --git a/drivers/scsi/fnic/fnic_trace.c b/drivers/scsi/fnic/fnic_trace.c
index acf1f95cb5c5..65a9bde26974 100644
--- a/drivers/scsi/fnic/fnic_trace.c
+++ b/drivers/scsi/fnic/fnic_trace.c
@@ -624,12 +624,12 @@ int fnic_fc_trace_set_data(u32 host_no, u8 frame_type,
         if (frame_type == FNIC_FC_RECV) {
                 eth_fcoe_hdr_len = sizeof(struct ethhdr) +
                                         sizeof(struct fcoe_hdr);
-                fc_trc_frame_len = fc_trc_frame_len + eth_fcoe_hdr_len;
                 memset((char *)fc_trace, 0xff, eth_fcoe_hdr_len);
                 /* Copy the rest of data frame */
                 memcpy((char *)(fc_trace + eth_fcoe_hdr_len), (void *)frame,
                 min_t(u8, fc_trc_frame_len,
-                        (u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE)));
+                        (u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE
+                                                - eth_fcoe_hdr_len)));
         } else {
                 memcpy((char *)fc_trace, (void *)frame,
                 min_t(u8, fc_trc_frame_len,
diff --git a/drivers/scsi/g_NCR5380.c b/drivers/scsi/g_NCR5380.c
index b331272e93bc..f35792f7051c 100644
--- a/drivers/scsi/g_NCR5380.c
+++ b/drivers/scsi/g_NCR5380.c
@@ -18,20 +18,6 @@
  *
  * Added ISAPNP support for DTC436 adapters,
  * Thomas Sailer, sailer@ife.ee.ethz.ch
- *
- * ALPHA RELEASE 1. 
- *
- * For more information, please consult 
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 /* 
@@ -40,14 +26,6 @@
  */
 
 /*
- * Options :
- *
- * PARITY - enable parity checking.  Not supported.
- *
- * SCSI2 - enable support for SCSI-II tagged queueing.  Untested.
- *
- * USLEEP - enable support for devices that don't disconnect.  Untested.
- *
  * The card is detected and initialized in one of several ways : 
  * 1.  With command line overrides - NCR5380=port,irq may be 
  *     used on the LILO command line to override the defaults.
@@ -79,27 +57,21 @@
  */
 
 /* settings for DTC3181E card with only Mustek scanner attached */
-#define USLEEP
 #define USLEEP_POLL     1
 #define USLEEP_SLEEP    20
 #define USLEEP_WAITLONG 500
 
 #define AUTOPROBE_IRQ
-#define AUTOSENSE
-
 
 #ifdef CONFIG_SCSI_GENERIC_NCR53C400
 #define NCR53C400_PSEUDO_DMA 1
 #define PSEUDO_DMA
 #define NCR53C400
-#define NCR5380_STATS
-#undef NCR5380_STAT_LIMIT
 #endif
 
 #include <asm/io.h>
 #include <linux/signal.h>
 #include <linux/blkdev.h>
-#include "scsi.h"
 #include <scsi/scsi_host.h>
 #include "g_NCR5380.h"
 #include "NCR5380.h"
@@ -277,7 +249,7 @@ static int __init do_DTC3181E_setup(char *str)
  *      Locks: none
  */
 
-int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
+static int __init generic_NCR5380_detect(struct scsi_host_template *tpnt)
 {
         static int current_override = 0;
         int count;
@@ -335,7 +307,7 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
                         if (pnp_irq_valid(dev, 0))
                                 overrides[count].irq = pnp_irq(dev, 0);
                         else
-                                overrides[count].irq = SCSI_IRQ_NONE;
+                                overrides[count].irq = NO_IRQ;
                         if (pnp_dma_valid(dev, 0))
                                 overrides[count].dma = pnp_dma(dev, 0);
                         else
@@ -455,27 +427,22 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
                 else
                         instance->irq = NCR5380_probe_irq(instance, 0xffff);
 
-                if (instance->irq != SCSI_IRQ_NONE)
+                /* Compatibility with documented NCR5380 kernel parameters */
+                if (instance->irq == 255)
+                        instance->irq = NO_IRQ;
+
+                if (instance->irq != NO_IRQ)
                         if (request_irq(instance->irq, generic_NCR5380_intr,
                                         0, "NCR5380", instance)) {
                                 printk(KERN_WARNING "scsi%d : IRQ%d not free, interrupts disabled\n", instance->host_no, instance->irq);
-                                instance->irq = SCSI_IRQ_NONE;
+                                instance->irq = NO_IRQ;
                         }
 
-                if (instance->irq == SCSI_IRQ_NONE) {
+                if (instance->irq == NO_IRQ) {
                         printk(KERN_INFO "scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
                         printk(KERN_INFO "scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
                 }
 
-                printk(KERN_INFO "scsi%d : at " STRVAL(NCR5380_map_name) " 0x%x", instance->host_no, (unsigned int) instance->NCR5380_instance_name);
-                if (instance->irq == SCSI_IRQ_NONE)
-                        printk(" interrupts disabled");
-                else
-                        printk(" irq %d", instance->irq);
-                printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d", CAN_QUEUE, CMD_PER_LUN, GENERIC_NCR5380_PUBLIC_RELEASE);
-                NCR5380_print_options(instance);
-                printk("\n");
-
                 ++current_override;
                 ++count;
         }
@@ -483,19 +450,6 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
 }
 
 /**
- *      generic_NCR5380_info    -       reporting string
- *      @host: NCR5380 to report on
- *
- *      Report driver information for the NCR5380
- */
-        
-const char *generic_NCR5380_info(struct Scsi_Host *host)
-{
-        static const char string[] = "Generic NCR5380/53C400 Driver";
-        return string;
-}
-
-/**
  *      generic_NCR5380_release_resources       -       free resources
  *      @instance: host adapter to clean up 
  *
@@ -504,12 +458,12 @@ const char *generic_NCR5380_info(struct Scsi_Host *host)
  *      Locks: none
  */
  
-int generic_NCR5380_release_resources(struct Scsi_Host *instance)
+static int generic_NCR5380_release_resources(struct Scsi_Host *instance)
 {
         NCR5380_local_declare();
         NCR5380_setup(instance);
         
-        if (instance->irq != SCSI_IRQ_NONE)
+        if (instance->irq != NO_IRQ)
                 free_irq(instance->irq, instance);
         NCR5380_exit(instance);
 
@@ -741,163 +695,9 @@ static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src,
  
 #include "NCR5380.c"
 
-#define PRINTP(x) seq_printf(m, x)
-#define ANDP ,
-
-static void sprint_opcode(struct seq_file *m, int opcode)
-{
-        PRINTP("0x%02x " ANDP opcode);
-}
-
-static void sprint_command(struct seq_file *m, unsigned char *command)
-{
-        int i, s;
-        sprint_opcode(m, command[0]);
-        for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
-                PRINTP("%02x " ANDP command[i]);
-        PRINTP("\n");
-}
-
-/**
- *      sprintf_Scsi_Cmnd       -       print a scsi command
- *      @m: seq_fil to print into
- *      @cmd: SCSI command block
- *      
- *      Print out the target and command data in hex
- */
-
-static void sprint_Scsi_Cmnd(struct seq_file *m, Scsi_Cmnd * cmd)
-{
-        PRINTP("host number %d destination target %d, lun %llu\n" ANDP cmd->device->host->host_no ANDP cmd->device->id ANDP cmd->device->lun);
-        PRINTP("        command = ");
-        sprint_command(m, cmd->cmnd);
-}
-
-/**
- *      generic_NCR5380_proc_info       -       /proc for NCR5380 driver
- *      @buffer: buffer to print into
- *      @start: start position
- *      @offset: offset into buffer
- *      @len: length
- *      @hostno: instance to affect
- *      @inout: read/write
- *
- *      Provide the procfs information for the 5380 controller. We fill
- *      this with useful debugging information including the commands
- *      being executed, disconnected command queue and the statistical
- *      data
- *
- *      Locks: global cli/lock for queue walk
- */
- 
-static int generic_NCR5380_show_info(struct seq_file *m, struct Scsi_Host *scsi_ptr)
-{
-        NCR5380_local_declare();
-        unsigned long flags;
-        unsigned char status;
-        int i;
-        Scsi_Cmnd *ptr;
-        struct NCR5380_hostdata *hostdata;
-#ifdef NCR5380_STATS
-        struct scsi_device *dev;
-#endif
-
-        NCR5380_setup(scsi_ptr);
-        hostdata = (struct NCR5380_hostdata *) scsi_ptr->hostdata;
-
-        spin_lock_irqsave(scsi_ptr->host_lock, flags);
-        PRINTP("SCSI host number %d : %s\n" ANDP scsi_ptr->host_no ANDP scsi_ptr->hostt->name);
-        PRINTP("Generic NCR5380 driver version %d\n" ANDP GENERIC_NCR5380_PUBLIC_RELEASE);
-        PRINTP("NCR5380 core version %d\n" ANDP NCR5380_PUBLIC_RELEASE);
-#ifdef NCR53C400
-        PRINTP("NCR53C400 extension version %d\n" ANDP NCR53C400_PUBLIC_RELEASE);
-        PRINTP("NCR53C400 card%s detected\n" ANDP(((struct NCR5380_hostdata *) scsi_ptr->hostdata)->flags & FLAG_NCR53C400) ? "" : " not");
-# if NCR53C400_PSEUDO_DMA
-        PRINTP("NCR53C400 pseudo DMA used\n");
-# endif
-#else
-        PRINTP("NO NCR53C400 driver extensions\n");
-#endif
-        PRINTP("Using %s mapping at %s 0x%lx, " ANDP STRVAL(NCR5380_map_config) ANDP STRVAL(NCR5380_map_name) ANDP scsi_ptr->NCR5380_instance_name);
-        if (scsi_ptr->irq == SCSI_IRQ_NONE)
-                PRINTP("no interrupt\n");
-        else
-                PRINTP("on interrupt %d\n" ANDP scsi_ptr->irq);
-
-#ifdef NCR5380_STATS
-        if (hostdata->connected || hostdata->issue_queue || hostdata->disconnected_queue)
-                PRINTP("There are commands pending, transfer rates may be crud\n");
-        if (hostdata->pendingr)
-                PRINTP("  %d pending reads" ANDP hostdata->pendingr);
-        if (hostdata->pendingw)
-                PRINTP("  %d pending writes" ANDP hostdata->pendingw);
-        if (hostdata->pendingr || hostdata->pendingw)
-                PRINTP("\n");
-        shost_for_each_device(dev, scsi_ptr) {
-                unsigned long br = hostdata->bytes_read[dev->id];
-                unsigned long bw = hostdata->bytes_write[dev->id];
-                long tr = hostdata->time_read[dev->id] / HZ;
-                long tw = hostdata->time_write[dev->id] / HZ;
-
-                PRINTP("  T:%d %s " ANDP dev->id ANDP scsi_device_type(dev->type));
-                for (i = 0; i < 8; i++)
-                        if (dev->vendor[i] >= 0x20)
-                                seq_putc(m, dev->vendor[i]);
-                seq_putc(m, ' ');
-                for (i = 0; i < 16; i++)
-                        if (dev->model[i] >= 0x20)
-                                seq_putc(m, dev->model[i]);
-                seq_putc(m, ' ');
-                for (i = 0; i < 4; i++)
-                        if (dev->rev[i] >= 0x20)
-                                seq_putc(m, dev->rev[i]);
-                seq_putc(m, ' ');
-
-                PRINTP("\n%10ld kb read    in %5ld secs" ANDP br / 1024 ANDP tr);
-                if (tr)
-                        PRINTP(" @ %5ld bps" ANDP br / tr);
-
-                PRINTP("\n%10ld kb written in %5ld secs" ANDP bw / 1024 ANDP tw);
-                if (tw)
-                        PRINTP(" @ %5ld bps" ANDP bw / tw);
-                PRINTP("\n");
-        }
-#endif
-
-        status = NCR5380_read(STATUS_REG);
-        if (!(status & SR_REQ))
-                PRINTP("REQ not asserted, phase unknown.\n");
-        else {
-                for (i = 0; (phases[i].value != PHASE_UNKNOWN) && (phases[i].value != (status & PHASE_MASK)); ++i);
-                PRINTP("Phase %s\n" ANDP phases[i].name);
-        }
-
-        if (!hostdata->connected) {
-                PRINTP("No currently connected command\n");
-        } else {
-                sprint_Scsi_Cmnd(m, (Scsi_Cmnd *) hostdata->connected);
-        }
-
-        PRINTP("issue_queue\n");
-
-        for (ptr = (Scsi_Cmnd *) hostdata->issue_queue; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
-                sprint_Scsi_Cmnd(m, ptr);
-
-        PRINTP("disconnected_queue\n");
-
-        for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
-                sprint_Scsi_Cmnd(m, ptr);
-
-        spin_unlock_irqrestore(scsi_ptr->host_lock, flags);
-        return 0;
-}
-
-#undef PRINTP
-#undef ANDP
-
 static struct scsi_host_template driver_template = {
         .show_info              = generic_NCR5380_show_info,
-        .name                   = "Generic NCR5380/NCR53C400 Scsi Driver",
+        .name                   = "Generic NCR5380/NCR53C400 SCSI",
         .detect                 = generic_NCR5380_detect,
         .release                = generic_NCR5380_release_resources,
         .info                   = generic_NCR5380_info,
diff --git a/drivers/scsi/g_NCR5380.h b/drivers/scsi/g_NCR5380.h
index 703adf78e0b2..bea1a3b9b862 100644
--- a/drivers/scsi/g_NCR5380.h
+++ b/drivers/scsi/g_NCR5380.h
@@ -9,28 +9,11 @@
  *
  * NCR53C400 extensions (c) 1994,1995,1996, Kevin Lentin
  *    K.Lentin@cs.monash.edu.au
- *
- * ALPHA RELEASE 1. 
- *
- * For more information, please consult 
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 #ifndef GENERIC_NCR5380_H
 #define GENERIC_NCR5380_H
 
-
-#define GENERIC_NCR5380_PUBLIC_RELEASE 1
-
 #ifdef NCR53C400
 #define BIOSPARAM
 #define NCR5380_BIOSPARAM generic_NCR5380_biosparam
@@ -39,12 +22,6 @@
 #endif
 
 #ifndef ASM
-static int generic_NCR5380_abort(Scsi_Cmnd *);
-static int generic_NCR5380_detect(struct scsi_host_template *);
-static int generic_NCR5380_release_resources(struct Scsi_Host *);
-static int generic_NCR5380_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
-static int generic_NCR5380_bus_reset(Scsi_Cmnd *);
-static const char* generic_NCR5380_info(struct Scsi_Host *);
 
 #ifndef CMD_PER_LUN
 #define CMD_PER_LUN 2
@@ -118,7 +95,8 @@ static const char* generic_NCR5380_info(struct Scsi_Host *);
 #define NCR5380_bus_reset generic_NCR5380_bus_reset
 #define NCR5380_pread generic_NCR5380_pread
 #define NCR5380_pwrite generic_NCR5380_pwrite
-#define NCR5380_proc_info notyet_generic_proc_info
+#define NCR5380_info generic_NCR5380_info
+#define NCR5380_show_info generic_NCR5380_show_info
 
 #define BOARD_NCR5380   0
 #define BOARD_NCR53C400 1
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 0f1ae13ce7c7..71e138044379 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -2159,7 +2159,7 @@ static void gdth_next(gdth_ha_str *ha)
               case VERIFY:
               case START_STOP:
               case MODE_SENSE:
-              case SERVICE_ACTION_IN:
+              case SERVICE_ACTION_IN_16:
                 TRACE(("cache cmd %x/%x/%x/%x/%x/%x\n",nscp->cmnd[0],
                        nscp->cmnd[1],nscp->cmnd[2],nscp->cmnd[3],
                        nscp->cmnd[4],nscp->cmnd[5]));
@@ -2391,7 +2391,7 @@ static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
         gdth_copy_internal_data(ha, scp, (char*)&rdc, sizeof(gdth_rdcap_data));
         break;
 
-      case SERVICE_ACTION_IN:
+      case SERVICE_ACTION_IN_16:
         if ((scp->cmnd[1] & 0x1f) == SAI_READ_CAPACITY_16 &&
             (ha->cache_feat & GDT_64BIT)) {
             gdth_rdcap16_data rdc16;
@@ -4661,7 +4661,6 @@ static void gdth_flush(gdth_ha_str *ha)
 /* configure lun */
 static int gdth_slave_configure(struct scsi_device *sdev)
 {
-    scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
     sdev->skip_ms_page_3f = 1;
     sdev->skip_ms_page_8 = 1;
     return 0;
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 6de80e352871..8bb173e01084 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -418,7 +418,6 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
         shost->cmd_per_lun = sht->cmd_per_lun;
         shost->unchecked_isa_dma = sht->unchecked_isa_dma;
         shost->use_clustering = sht->use_clustering;
-        shost->ordered_tag = sht->ordered_tag;
         shost->no_write_same = sht->no_write_same;
 
         if (shost_eh_deadline == -1 || !sht->eh_host_reset_handler)
@@ -485,8 +484,8 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
                                             WQ_UNBOUND | WQ_MEM_RECLAIM,
                                            1, shost->host_no);
         if (!shost->tmf_work_q) {
-                printk(KERN_WARNING "scsi%d: failed to create tmf workq\n",
-                       shost->host_no);
+                shost_printk(KERN_WARNING, shost,
+                             "failed to create tmf workq\n");
                 goto fail_kthread;
         }
         scsi_proc_hostdir_add(shost->hostt);
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index cef5d49b59cd..6bb4611b238a 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -48,6 +48,7 @@
 #include <linux/bitmap.h>
 #include <linux/atomic.h>
 #include <linux/jiffies.h>
+#include <linux/percpu-defs.h>
 #include <linux/percpu.h>
 #include <asm/div64.h>
 #include "hpsa_cmd.h"
@@ -103,7 +104,6 @@ static const struct pci_device_id hpsa_pci_device_id[] = {
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSH,     0x103C, 0x1922},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSH,     0x103C, 0x1923},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSH,     0x103C, 0x1924},
-        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSH,     0x103C, 0x1925},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSH,     0x103C, 0x1926},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSH,     0x103C, 0x1928},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSH,     0x103C, 0x1929},
@@ -149,6 +149,7 @@ static struct board_type products[] = {
         {0x3249103C, "Smart Array P812", &SA5_access},
         {0x324A103C, "Smart Array P712m", &SA5_access},
         {0x324B103C, "Smart Array P711m", &SA5_access},
+        {0x3233103C, "HP StorageWorks 1210m", &SA5_access}, /* alias of 333f */
         {0x3350103C, "Smart Array P222", &SA5_access},
         {0x3351103C, "Smart Array P420", &SA5_access},
         {0x3352103C, "Smart Array P421", &SA5_access},
@@ -193,12 +194,13 @@ static int number_of_controllers;
 
 static irqreturn_t do_hpsa_intr_intx(int irq, void *dev_id);
 static irqreturn_t do_hpsa_intr_msi(int irq, void *dev_id);
-static int hpsa_ioctl(struct scsi_device *dev, int cmd, void *arg);
+static int hpsa_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
 static void lock_and_start_io(struct ctlr_info *h);
 static void start_io(struct ctlr_info *h, unsigned long *flags);
 
 #ifdef CONFIG_COMPAT
-static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd, void *arg);
+static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd,
+        void __user *arg);
 #endif
 
 static void cmd_free(struct ctlr_info *h, struct CommandList *c);
@@ -214,8 +216,6 @@ static int hpsa_scsi_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
 static void hpsa_scan_start(struct Scsi_Host *);
 static int hpsa_scan_finished(struct Scsi_Host *sh,
         unsigned long elapsed_time);
-static int hpsa_change_queue_depth(struct scsi_device *sdev,
-        int qdepth, int reason);
 
 static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd);
 static int hpsa_eh_abort_handler(struct scsi_cmnd *scsicmd);
@@ -274,12 +274,12 @@ static int check_for_unit_attention(struct ctlr_info *h,
                         "detected, command retried\n", h->ctlr);
                 break;
         case LUN_FAILED:
-                dev_warn(&h->pdev->dev, HPSA "%d: LUN failure "
-                        "detected, action required\n", h->ctlr);
+                dev_warn(&h->pdev->dev,
+                        HPSA "%d: LUN failure detected\n", h->ctlr);
                 break;
         case REPORT_LUNS_CHANGED:
-                dev_warn(&h->pdev->dev, HPSA "%d: report LUN data "
-                        "changed, action required\n", h->ctlr);
+                dev_warn(&h->pdev->dev,
+                        HPSA "%d: report LUN data changed\n", h->ctlr);
         /*
          * Note: this REPORT_LUNS_CHANGED condition only occurs on the external
          * target (array) devices.
@@ -392,7 +392,8 @@ static ssize_t host_show_commands_outstanding(struct device *dev,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct ctlr_info *h = shost_to_hba(shost);
 
-        return snprintf(buf, 20, "%d\n", h->commands_outstanding);
+        return snprintf(buf, 20, "%d\n",
+                        atomic_read(&h->commands_outstanding));
 }
 
 static ssize_t host_show_transport_mode(struct device *dev,
@@ -670,7 +671,7 @@ static struct scsi_host_template hpsa_driver_template = {
         .queuecommand           = hpsa_scsi_queue_command,
         .scan_start             = hpsa_scan_start,
         .scan_finished          = hpsa_scan_finished,
-        .change_queue_depth     = hpsa_change_queue_depth,
+        .change_queue_depth     = scsi_change_queue_depth,
         .this_id                = -1,
         .use_clustering         = ENABLE_CLUSTERING,
         .eh_abort_handler       = hpsa_eh_abort_handler,
@@ -698,7 +699,6 @@ static inline u32 next_command(struct ctlr_info *h, u8 q)
 {
         u32 a;
         struct reply_queue_buffer *rq = &h->reply_queue[q];
-        unsigned long flags;
 
         if (h->transMethod & CFGTBL_Trans_io_accel1)
                 return h->access.command_completed(h, q);
@@ -709,9 +709,7 @@ static inline u32 next_command(struct ctlr_info *h, u8 q)
         if ((rq->head[rq->current_entry] & 1) == rq->wraparound) {
                 a = rq->head[rq->current_entry];
                 rq->current_entry++;
-                spin_lock_irqsave(&h->lock, flags);
-                h->commands_outstanding--;
-                spin_unlock_irqrestore(&h->lock, flags);
+                atomic_dec(&h->commands_outstanding);
         } else {
                 a = FIFO_EMPTY;
         }
@@ -1500,22 +1498,22 @@ static int hpsa_map_sg_chain_block(struct ctlr_info *h,
 {
         struct SGDescriptor *chain_sg, *chain_block;
         u64 temp64;
+        u32 chain_len;
 
         chain_sg = &c->SG[h->max_cmd_sg_entries - 1];
         chain_block = h->cmd_sg_list[c->cmdindex];
-        chain_sg->Ext = HPSA_SG_CHAIN;
-        chain_sg->Len = sizeof(*chain_sg) *
+        chain_sg->Ext = cpu_to_le32(HPSA_SG_CHAIN);
+        chain_len = sizeof(*chain_sg) *
                 (c->Header.SGTotal - h->max_cmd_sg_entries);
-        temp64 = pci_map_single(h->pdev, chain_block, chain_sg->Len,
+        chain_sg->Len = cpu_to_le32(chain_len);
+        temp64 = pci_map_single(h->pdev, chain_block, chain_len,
                                 PCI_DMA_TODEVICE);
         if (dma_mapping_error(&h->pdev->dev, temp64)) {
                 /* prevent subsequent unmapping */
-                chain_sg->Addr.lower = 0;
-                chain_sg->Addr.upper = 0;
+                chain_sg->Addr = cpu_to_le64(0);
                 return -1;
         }
-        chain_sg->Addr.lower = (u32) (temp64 & 0x0FFFFFFFFULL);
-        chain_sg->Addr.upper = (u32) ((temp64 >> 32) & 0x0FFFFFFFFULL);
+        chain_sg->Addr = cpu_to_le64(temp64);
         return 0;
 }
 
@@ -1523,15 +1521,13 @@ static void hpsa_unmap_sg_chain_block(struct ctlr_info *h,
         struct CommandList *c)
 {
         struct SGDescriptor *chain_sg;
-        union u64bit temp64;
 
-        if (c->Header.SGTotal <= h->max_cmd_sg_entries)
+        if (le16_to_cpu(c->Header.SGTotal) <= h->max_cmd_sg_entries)
                 return;
 
         chain_sg = &c->SG[h->max_cmd_sg_entries - 1];
-        temp64.val32.lower = chain_sg->Addr.lower;
-        temp64.val32.upper = chain_sg->Addr.upper;
-        pci_unmap_single(h->pdev, temp64.val, chain_sg->Len, PCI_DMA_TODEVICE);
+        pci_unmap_single(h->pdev, le64_to_cpu(chain_sg->Addr),
+                        le32_to_cpu(chain_sg->Len), PCI_DMA_TODEVICE);
 }
 
 
@@ -1732,8 +1728,7 @@ static void complete_scsi_command(struct CommandList *cp)
                 struct io_accel1_cmd *c = &h->ioaccel_cmd_pool[cp->cmdindex];
                 cp->Header.SGList = cp->Header.SGTotal = scsi_sg_count(cmd);
                 cp->Request.CDBLen = c->io_flags & IOACCEL1_IOFLAGS_CDBLEN_MASK;
-                cp->Header.Tag.lower = c->Tag.lower;
-                cp->Header.Tag.upper = c->Tag.upper;
+                cp->Header.tag = c->tag;
                 memcpy(cp->Header.LUN.LunAddrBytes, c->CISS_LUN, 8);
                 memcpy(cp->Request.CDB, c->CDB, cp->Request.CDBLen);
 
@@ -1763,72 +1758,13 @@ static void complete_scsi_command(struct CommandList *cp)
                         /* Get addition sense code qualifier */
                         ascq = ei->SenseInfo[13];
                 }
-
                 if (ei->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
-                        if (check_for_unit_attention(h, cp))
-                                break;
-                        if (sense_key == ILLEGAL_REQUEST) {
-                                /*
-                                 * SCSI REPORT_LUNS is commonly unsupported on
-                                 * Smart Array.  Suppress noisy complaint.
-                                 */
-                                if (cp->Request.CDB[0] == REPORT_LUNS)
-                                        break;
-
-                                /* If ASC/ASCQ indicate Logical Unit
-                                 * Not Supported condition,
-                                 */
-                                if ((asc == 0x25) && (ascq == 0x0)) {
-                                        dev_warn(&h->pdev->dev, "cp %p "
-                                                "has check condition\n", cp);
-                                        break;
-                                }
-                        }
-
-                        if (sense_key == NOT_READY) {
-                                /* If Sense is Not Ready, Logical Unit
-                                 * Not ready, Manual Intervention
-                                 * required
-                                 */
-                                if ((asc == 0x04) && (ascq == 0x03)) {
-                                        dev_warn(&h->pdev->dev, "cp %p "
-                                                "has check condition: unit "
-                                                "not ready, manual "
-                                                "intervention required\n", cp);
-                                        break;
-                                }
-                        }
                         if (sense_key == ABORTED_COMMAND) {
-                                /* Aborted command is retryable */
-                                dev_warn(&h->pdev->dev, "cp %p "
-                                        "has check condition: aborted command: "
-                                        "ASC: 0x%x, ASCQ: 0x%x\n",
-                                        cp, asc, ascq);
                                 cmd->result |= DID_SOFT_ERROR << 16;
                                 break;
                         }
-                        /* Must be some other type of check condition */
-                        dev_dbg(&h->pdev->dev, "cp %p has check condition: "
-                                        "unknown type: "
-                                        "Sense: 0x%x, ASC: 0x%x, ASCQ: 0x%x, "
-                                        "Returning result: 0x%x, "
-                                        "cmd=[%02x %02x %02x %02x %02x "
-                                        "%02x %02x %02x %02x %02x %02x "
-                                        "%02x %02x %02x %02x %02x]\n",
-                                        cp, sense_key, asc, ascq,
-                                        cmd->result,
-                                        cmd->cmnd[0], cmd->cmnd[1],
-                                        cmd->cmnd[2], cmd->cmnd[3],
-                                        cmd->cmnd[4], cmd->cmnd[5],
-                                        cmd->cmnd[6], cmd->cmnd[7],
-                                        cmd->cmnd[8], cmd->cmnd[9],
-                                        cmd->cmnd[10], cmd->cmnd[11],
-                                        cmd->cmnd[12], cmd->cmnd[13],
-                                        cmd->cmnd[14], cmd->cmnd[15]);
                         break;
                 }
-
-
                 /* Problem was not a check condition
                  * Pass it up to the upper layers...
                  */
@@ -1934,14 +1870,11 @@ static void hpsa_pci_unmap(struct pci_dev *pdev,
         struct CommandList *c, int sg_used, int data_direction)
 {
         int i;
-        union u64bit addr64;
 
-        for (i = 0; i < sg_used; i++) {
-                addr64.val32.lower = c->SG[i].Addr.lower;
-                addr64.val32.upper = c->SG[i].Addr.upper;
-                pci_unmap_single(pdev, (dma_addr_t) addr64.val, c->SG[i].Len,
-                        data_direction);
-        }
+        for (i = 0; i < sg_used; i++)
+                pci_unmap_single(pdev, (dma_addr_t) le64_to_cpu(c->SG[i].Addr),
+                                le32_to_cpu(c->SG[i].Len),
+                                data_direction);
 }
 
 static int hpsa_map_one(struct pci_dev *pdev,
@@ -1954,25 +1887,22 @@ static int hpsa_map_one(struct pci_dev *pdev,
 
         if (buflen == 0 || data_direction == PCI_DMA_NONE) {
                 cp->Header.SGList = 0;
-                cp->Header.SGTotal = 0;
+                cp->Header.SGTotal = cpu_to_le16(0);
                 return 0;
         }
 
-        addr64 = (u64) pci_map_single(pdev, buf, buflen, data_direction);
+        addr64 = pci_map_single(pdev, buf, buflen, data_direction);
         if (dma_mapping_error(&pdev->dev, addr64)) {
                 /* Prevent subsequent unmap of something never mapped */
                 cp->Header.SGList = 0;
-                cp->Header.SGTotal = 0;
+                cp->Header.SGTotal = cpu_to_le16(0);
                 return -1;
         }
-        cp->SG[0].Addr.lower =
-          (u32) (addr64 & (u64) 0x00000000FFFFFFFF);
-        cp->SG[0].Addr.upper =
-          (u32) ((addr64 >> 32) & (u64) 0x00000000FFFFFFFF);
-        cp->SG[0].Len = buflen;
-        cp->SG[0].Ext = HPSA_SG_LAST; /* we are not chaining */
-        cp->Header.SGList = (u8) 1;   /* no. SGs contig in this cmd */
-        cp->Header.SGTotal = (u16) 1; /* total sgs in this cmd list */
+        cp->SG[0].Addr = cpu_to_le64(addr64);
+        cp->SG[0].Len = cpu_to_le32(buflen);
+        cp->SG[0].Ext = cpu_to_le32(HPSA_SG_LAST); /* we are not chaining */
+        cp->Header.SGList = 1;   /* no. SGs contig in this cmd */
+        cp->Header.SGTotal = cpu_to_le16(1); /* total sgs in cmd list */
         return 0;
 }
 
@@ -2830,8 +2760,8 @@ static int hpsa_get_pdisk_of_ioaccel2(struct ctlr_info *h,
         if (d == NULL)
                 return 0; /* no match */
 
-        it_nexus = cpu_to_le32((u32) d->ioaccel_handle);
-        scsi_nexus = cpu_to_le32((u32) c2a->scsi_nexus);
+        it_nexus = cpu_to_le32(d->ioaccel_handle);
+        scsi_nexus = cpu_to_le32(c2a->scsi_nexus);
         find = c2a->scsi_nexus;
 
         if (h->raid_offload_debug > 0)
@@ -2891,7 +2821,7 @@ static int hpsa_get_pdisk_of_ioaccel2(struct ctlr_info *h,
  * Returns 0 on success, -1 otherwise.
  */
 static int hpsa_gather_lun_info(struct ctlr_info *h,
-        int reportlunsize,
+        int reportphyslunsize, int reportloglunsize,
         struct ReportLUNdata *physdev, u32 *nphysicals, int *physical_mode,
         struct ReportLUNdata *logdev, u32 *nlogicals)
 {
@@ -2905,7 +2835,7 @@ static int hpsa_gather_lun_info(struct ctlr_info *h,
                 *physical_mode = HPSA_REPORT_PHYS_EXTENDED;
                 physical_entry_size = 24;
         }
-        if (hpsa_scsi_do_report_phys_luns(h, physdev, reportlunsize,
+        if (hpsa_scsi_do_report_phys_luns(h, physdev, reportphyslunsize,
                                                         *physical_mode)) {
                 dev_err(&h->pdev->dev, "report physical LUNs failed.\n");
                 return -1;
@@ -2918,7 +2848,7 @@ static int hpsa_gather_lun_info(struct ctlr_info *h,
                         *nphysicals - HPSA_MAX_PHYS_LUN);
                 *nphysicals = HPSA_MAX_PHYS_LUN;
         }
-        if (hpsa_scsi_do_report_log_luns(h, logdev, reportlunsize)) {
+        if (hpsa_scsi_do_report_log_luns(h, logdev, reportloglunsize)) {
                 dev_err(&h->pdev->dev, "report logical LUNs failed.\n");
                 return -1;
         }
@@ -2941,8 +2871,8 @@ static int hpsa_gather_lun_info(struct ctlr_info *h,
         return 0;
 }
 
-u8 *figure_lunaddrbytes(struct ctlr_info *h, int raid_ctlr_position, int i,
-        int nphysicals, int nlogicals,
+static u8 *figure_lunaddrbytes(struct ctlr_info *h, int raid_ctlr_position,
+        int i, int nphysicals, int nlogicals,
         struct ReportExtendedLUNdata *physdev_list,
         struct ReportLUNdata *logdev_list)
 {
@@ -3011,15 +2941,14 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
         u32 ndev_allocated = 0;
         struct hpsa_scsi_dev_t **currentsd, *this_device, *tmpdevice;
         int ncurrent = 0;
-        int reportlunsize = sizeof(*physdev_list) + HPSA_MAX_PHYS_LUN * 24;
         int i, n_ext_target_devs, ndevs_to_allocate;
         int raid_ctlr_position;
         int rescan_hba_mode;
         DECLARE_BITMAP(lunzerobits, MAX_EXT_TARGETS);
 
         currentsd = kzalloc(sizeof(*currentsd) * HPSA_MAX_DEVICES, GFP_KERNEL);
-        physdev_list = kzalloc(reportlunsize, GFP_KERNEL);
-        logdev_list = kzalloc(reportlunsize, GFP_KERNEL);
+        physdev_list = kzalloc(sizeof(*physdev_list), GFP_KERNEL);
+        logdev_list = kzalloc(sizeof(*logdev_list), GFP_KERNEL);
         tmpdevice = kzalloc(sizeof(*tmpdevice), GFP_KERNEL);
 
         if (!currentsd || !physdev_list || !logdev_list || !tmpdevice) {
@@ -3039,7 +2968,8 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
 
         h->hba_mode_enabled = rescan_hba_mode;
 
-        if (hpsa_gather_lun_info(h, reportlunsize,
+        if (hpsa_gather_lun_info(h,
+                        sizeof(*physdev_list), sizeof(*logdev_list),
                         (struct ReportLUNdata *) physdev_list, &nphysicals,
                         &physical_mode, logdev_list, &nlogicals))
                 goto out;
@@ -3210,19 +3140,19 @@ static int hpsa_scatter_gather(struct ctlr_info *h,
                 }
                 addr64 = (u64) sg_dma_address(sg);
                 len  = sg_dma_len(sg);
-                curr_sg->Addr.lower = (u32) (addr64 & 0x0FFFFFFFFULL);
-                curr_sg->Addr.upper = (u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
-                curr_sg->Len = len;
-                curr_sg->Ext = (i < scsi_sg_count(cmd) - 1) ? 0 : HPSA_SG_LAST;
+                curr_sg->Addr = cpu_to_le64(addr64);
+                curr_sg->Len = cpu_to_le32(len);
+                curr_sg->Ext = cpu_to_le32(0);
                 curr_sg++;
         }
+        (--curr_sg)->Ext = cpu_to_le32(HPSA_SG_LAST);
 
         if (use_sg + chained > h->maxSG)
                 h->maxSG = use_sg + chained;
 
         if (chained) {
                 cp->Header.SGList = h->max_cmd_sg_entries;
-                cp->Header.SGTotal = (u16) (use_sg + 1);
+                cp->Header.SGTotal = cpu_to_le16(use_sg + 1);
                 if (hpsa_map_sg_chain_block(h, cp)) {
                         scsi_dma_unmap(cmd);
                         return -1;
@@ -3233,7 +3163,7 @@ static int hpsa_scatter_gather(struct ctlr_info *h,
 sglist_finished:
 
         cp->Header.SGList = (u8) use_sg;   /* no. SGs contig in this cmd */
-        cp->Header.SGTotal = (u16) use_sg; /* total sgs in this cmd list */
+        cp->Header.SGTotal = cpu_to_le16(use_sg); /* total sgs in this cmd list */
         return 0;
 }
 
@@ -3325,17 +3255,12 @@ static int hpsa_scsi_ioaccel1_queue_command(struct ctlr_info *h,
                         addr64 = (u64) sg_dma_address(sg);
                         len  = sg_dma_len(sg);
                         total_len += len;
-                        curr_sg->Addr.lower = (u32) (addr64 & 0x0FFFFFFFFULL);
-                        curr_sg->Addr.upper =
-                                (u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
-                        curr_sg->Len = len;
-
-                        if (i == (scsi_sg_count(cmd) - 1))
-                                curr_sg->Ext = HPSA_SG_LAST;
-                        else
-                                curr_sg->Ext = 0;  /* we are not chaining */
+                        curr_sg->Addr = cpu_to_le64(addr64);
+                        curr_sg->Len = cpu_to_le32(len);
+                        curr_sg->Ext = cpu_to_le32(0);
                         curr_sg++;
                 }
+                (--curr_sg)->Ext = cpu_to_le32(HPSA_SG_LAST);
 
                 switch (cmd->sc_data_direction) {
                 case DMA_TO_DEVICE:
@@ -3592,7 +3517,7 @@ static int hpsa_scsi_ioaccel2_queue_command(struct ctlr_info *h,
         cp->data_len = cpu_to_le32(total_len);
         cp->err_ptr = cpu_to_le64(c->busaddr +
                         offsetof(struct io_accel2_cmd, error_data));
-        cp->err_len = cpu_to_le32((u32) sizeof(cp->error_data));
+        cp->err_len = cpu_to_le32(sizeof(cp->error_data));
 
         enqueue_cmd_and_start_io(h, c);
         return 0;
@@ -3809,11 +3734,6 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
                 offload_to_mirror =
                         (offload_to_mirror >= map->layout_map_count - 1)
                         ? 0 : offload_to_mirror + 1;
-                /* FIXME: remove after debug/dev */
-                BUG_ON(offload_to_mirror >= map->layout_map_count);
-                dev_warn(&h->pdev->dev,
-                        "DEBUG: Using physical disk map index %d from mirror group %d\n",
-                        map_index, offload_to_mirror);
                 dev->offload_to_mirror = offload_to_mirror;
                 /* Avoid direct use of dev->offload_to_mirror within this
                  * function since multiple threads might simultaneously
@@ -3959,8 +3879,11 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
                                                 dev->scsi3addr);
 }
 
-static int hpsa_scsi_queue_command_lck(struct scsi_cmnd *cmd,
-        void (*done)(struct scsi_cmnd *))
+/*
+ * Running in struct Scsi_Host->host_lock less mode using LLD internal
+ * struct ctlr_info *h->lock w/ spin_lock_irqsave() protection.
+ */
+static int hpsa_scsi_queue_command(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
 {
         struct ctlr_info *h;
         struct hpsa_scsi_dev_t *dev;
@@ -3973,14 +3896,14 @@ static int hpsa_scsi_queue_command_lck(struct scsi_cmnd *cmd,
         dev = cmd->device->hostdata;
         if (!dev) {
                 cmd->result = DID_NO_CONNECT << 16;
-                done(cmd);
+                cmd->scsi_done(cmd);
                 return 0;
         }
         memcpy(scsi3addr, dev->scsi3addr, sizeof(scsi3addr));
 
         if (unlikely(lockup_detected(h))) {
                 cmd->result = DID_ERROR << 16;
-                done(cmd);
+                cmd->scsi_done(cmd);
                 return 0;
         }
         c = cmd_alloc(h);
@@ -3990,9 +3913,6 @@ static int hpsa_scsi_queue_command_lck(struct scsi_cmnd *cmd,
         }
 
         /* Fill in the command list header */
-
-        cmd->scsi_done = done;    /* save this for use by completion code */
-
         /* save c in case we have to abort it  */
         cmd->host_scribble = (unsigned char *) c;
 
@@ -4026,8 +3946,8 @@ static int hpsa_scsi_queue_command_lck(struct scsi_cmnd *cmd,
 
         c->Header.ReplyQueue = 0;  /* unused in simple mode */
         memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
-        c->Header.Tag.lower = (c->cmdindex << DIRECT_LOOKUP_SHIFT);
-        c->Header.Tag.lower |= DIRECT_LOOKUP_BIT;
+        c->Header.tag = cpu_to_le64((c->cmdindex << DIRECT_LOOKUP_SHIFT) |
+                                        DIRECT_LOOKUP_BIT);
 
         /* Fill in the request block... */
 
@@ -4036,17 +3956,18 @@ static int hpsa_scsi_queue_command_lck(struct scsi_cmnd *cmd,
         BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
         c->Request.CDBLen = cmd->cmd_len;
         memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
-        c->Request.Type.Type = TYPE_CMD;
-        c->Request.Type.Attribute = ATTR_SIMPLE;
         switch (cmd->sc_data_direction) {
         case DMA_TO_DEVICE:
-                c->Request.Type.Direction = XFER_WRITE;
+                c->Request.type_attr_dir =
+                        TYPE_ATTR_DIR(TYPE_CMD, ATTR_SIMPLE, XFER_WRITE);
                 break;
         case DMA_FROM_DEVICE:
-                c->Request.Type.Direction = XFER_READ;
+                c->Request.type_attr_dir =
+                        TYPE_ATTR_DIR(TYPE_CMD, ATTR_SIMPLE, XFER_READ);
                 break;
         case DMA_NONE:
-                c->Request.Type.Direction = XFER_NONE;
+                c->Request.type_attr_dir =
+                        TYPE_ATTR_DIR(TYPE_CMD, ATTR_SIMPLE, XFER_NONE);
                 break;
         case DMA_BIDIRECTIONAL:
                 /* This can happen if a buggy application does a scsi passthru
@@ -4054,7 +3975,8 @@ static int hpsa_scsi_queue_command_lck(struct scsi_cmnd *cmd,
                  * ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
                  */
 
-                c->Request.Type.Direction = XFER_RSVD;
+                c->Request.type_attr_dir =
+                        TYPE_ATTR_DIR(TYPE_CMD, ATTR_SIMPLE, XFER_RSVD);
                 /* This is technically wrong, and hpsa controllers should
                  * reject it with CMD_INVALID, which is the most correct
                  * response, but non-fibre backends appear to let it
@@ -4081,8 +4003,6 @@ static int hpsa_scsi_queue_command_lck(struct scsi_cmnd *cmd,
         return 0;
 }
 
-static DEF_SCSI_QCMD(hpsa_scsi_queue_command)
-
 static int do_not_scan_if_controller_locked_up(struct ctlr_info *h)
 {
         unsigned long flags;
@@ -4152,23 +4072,6 @@ static int hpsa_scan_finished(struct Scsi_Host *sh,
         return finished;
 }
 
-static int hpsa_change_queue_depth(struct scsi_device *sdev,
-        int qdepth, int reason)
-{
-        struct ctlr_info *h = sdev_to_hba(sdev);
-
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -ENOTSUPP;
-
-        if (qdepth < 1)
-                qdepth = 1;
-        else
-                if (qdepth > h->nr_cmds)
-                        qdepth = h->nr_cmds;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-        return sdev->queue_depth;
-}
-
 static void hpsa_unregister_scsi(struct ctlr_info *h)
 {
         /* we are being forcibly unloaded, and may not refuse. */
@@ -4329,8 +4232,8 @@ static void hpsa_get_tag(struct ctlr_info *h,
         if (c->cmd_type == CMD_IOACCEL1) {
                 struct io_accel1_cmd *cm1 = (struct io_accel1_cmd *)
                         &h->ioaccel_cmd_pool[c->cmdindex];
-                *tagupper = cm1->Tag.upper;
-                *taglower = cm1->Tag.lower;
+                *tagupper = (u32) (cm1->tag >> 32);
+                *taglower = (u32) (cm1->tag & 0x0ffffffffULL);
                 return;
         }
         if (c->cmd_type == CMD_IOACCEL2) {
@@ -4341,11 +4244,10 @@ static void hpsa_get_tag(struct ctlr_info *h,
                 *taglower = cm2->Tag;
                 return;
         }
-        *tagupper = c->Header.Tag.upper;
-        *taglower = c->Header.Tag.lower;
+        *tagupper = (u32) (c->Header.tag >> 32);
+        *taglower = (u32) (c->Header.tag & 0x0ffffffffULL);
 }
 
-
 static int hpsa_send_abort(struct ctlr_info *h, unsigned char *scsi3addr,
         struct CommandList *abort, int swizzle)
 {
@@ -4410,7 +4312,7 @@ static struct CommandList *hpsa_find_cmd_in_queue(struct ctlr_info *h,
         struct CommandList *c = NULL;   /* ptr into cmpQ */
 
         if (!find)
-                return 0;
+                return NULL;
         spin_lock_irqsave(&h->lock, flags);
         list_for_each_entry(c, queue_head, list) {
                 if (c->scsi_cmd == NULL) /* e.g.: passthru ioctl */
@@ -4432,7 +4334,7 @@ static struct CommandList *hpsa_find_cmd_in_queue_by_tag(struct ctlr_info *h,
 
         spin_lock_irqsave(&h->lock, flags);
         list_for_each_entry(c, queue_head, list) {
-                if (memcmp(&c->Header.Tag, tag, 8) != 0)
+                if (memcmp(&c->Header.tag, tag, 8) != 0)
                         continue;
                 spin_unlock_irqrestore(&h->lock, flags);
                 return c;
@@ -4686,19 +4588,32 @@ static struct CommandList *cmd_alloc(struct ctlr_info *h)
         int i;
         union u64bit temp64;
         dma_addr_t cmd_dma_handle, err_dma_handle;
-        unsigned long flags;
+        int loopcount;
+
+        /* There is some *extremely* small but non-zero chance that that
+         * multiple threads could get in here, and one thread could
+         * be scanning through the list of bits looking for a free
+         * one, but the free ones are always behind him, and other
+         * threads sneak in behind him and eat them before he can
+         * get to them, so that while there is always a free one, a
+         * very unlucky thread might be starved anyway, never able to
+         * beat the other threads.  In reality, this happens so
+         * infrequently as to be indistinguishable from never.
+         */
 
-        spin_lock_irqsave(&h->lock, flags);
+        loopcount = 0;
         do {
                 i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
-                if (i == h->nr_cmds) {
-                        spin_unlock_irqrestore(&h->lock, flags);
-                        return NULL;
-                }
-        } while (test_and_set_bit
-                 (i & (BITS_PER_LONG - 1),
-                  h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
-        spin_unlock_irqrestore(&h->lock, flags);
+                if (i == h->nr_cmds)
+                        i = 0;
+                loopcount++;
+        } while (test_and_set_bit(i & (BITS_PER_LONG - 1),
+                  h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0 &&
+                loopcount < 10);
+
+        /* Thread got starved?  We do not expect this to ever happen. */
+        if (loopcount >= 10)
+                return NULL;
 
         c = h->cmd_pool + i;
         memset(c, 0, sizeof(*c));
@@ -4714,9 +4629,8 @@ static struct CommandList *cmd_alloc(struct ctlr_info *h)
         INIT_LIST_HEAD(&c->list);
         c->busaddr = (u32) cmd_dma_handle;
         temp64.val = (u64) err_dma_handle;
-        c->ErrDesc.Addr.lower = temp64.val32.lower;
-        c->ErrDesc.Addr.upper = temp64.val32.upper;
-        c->ErrDesc.Len = sizeof(*c->err_info);
+        c->ErrDesc.Addr = cpu_to_le64(err_dma_handle);
+        c->ErrDesc.Len = cpu_to_le32(sizeof(*c->err_info));
 
         c->h = h;
         return c;
@@ -4729,7 +4643,6 @@ static struct CommandList *cmd_alloc(struct ctlr_info *h)
 static struct CommandList *cmd_special_alloc(struct ctlr_info *h)
 {
         struct CommandList *c;
-        union u64bit temp64;
         dma_addr_t cmd_dma_handle, err_dma_handle;
 
         c = pci_zalloc_consistent(h->pdev, sizeof(*c), &cmd_dma_handle);
@@ -4750,10 +4663,8 @@ static struct CommandList *cmd_special_alloc(struct ctlr_info *h)
 
         INIT_LIST_HEAD(&c->list);
         c->busaddr = (u32) cmd_dma_handle;
-        temp64.val = (u64) err_dma_handle;
-        c->ErrDesc.Addr.lower = temp64.val32.lower;
-        c->ErrDesc.Addr.upper = temp64.val32.upper;
-        c->ErrDesc.Len = sizeof(*c->err_info);
+        c->ErrDesc.Addr = cpu_to_le64(err_dma_handle);
+        c->ErrDesc.Len = cpu_to_le32(sizeof(*c->err_info));
 
         c->h = h;
         return c;
@@ -4762,30 +4673,25 @@ static struct CommandList *cmd_special_alloc(struct ctlr_info *h)
 static void cmd_free(struct ctlr_info *h, struct CommandList *c)
 {
         int i;
-        unsigned long flags;
 
         i = c - h->cmd_pool;
-        spin_lock_irqsave(&h->lock, flags);
         clear_bit(i & (BITS_PER_LONG - 1),
                   h->cmd_pool_bits + (i / BITS_PER_LONG));
-        spin_unlock_irqrestore(&h->lock, flags);
 }
 
 static void cmd_special_free(struct ctlr_info *h, struct CommandList *c)
 {
-        union u64bit temp64;
-
-        temp64.val32.lower = c->ErrDesc.Addr.lower;
-        temp64.val32.upper = c->ErrDesc.Addr.upper;
         pci_free_consistent(h->pdev, sizeof(*c->err_info),
-                            c->err_info, (dma_addr_t) temp64.val);
+                            c->err_info,
+                            (dma_addr_t) le64_to_cpu(c->ErrDesc.Addr));
         pci_free_consistent(h->pdev, sizeof(*c),
                             c, (dma_addr_t) (c->busaddr & DIRECT_LOOKUP_MASK));
 }
 
 #ifdef CONFIG_COMPAT
 
-static int hpsa_ioctl32_passthru(struct scsi_device *dev, int cmd, void *arg)
+static int hpsa_ioctl32_passthru(struct scsi_device *dev, int cmd,
+        void __user *arg)
 {
         IOCTL32_Command_struct __user *arg32 =
             (IOCTL32_Command_struct __user *) arg;
@@ -4810,7 +4716,7 @@ static int hpsa_ioctl32_passthru(struct scsi_device *dev, int cmd, void *arg)
         if (err)
                 return -EFAULT;
 
-        err = hpsa_ioctl(dev, CCISS_PASSTHRU, (void *)p);
+        err = hpsa_ioctl(dev, CCISS_PASSTHRU, p);
         if (err)
                 return err;
         err |= copy_in_user(&arg32->error_info, &p->error_info,
@@ -4821,7 +4727,7 @@ static int hpsa_ioctl32_passthru(struct scsi_device *dev, int cmd, void *arg)
 }
 
 static int hpsa_ioctl32_big_passthru(struct scsi_device *dev,
-        int cmd, void *arg)
+        int cmd, void __user *arg)
 {
         BIG_IOCTL32_Command_struct __user *arg32 =
             (BIG_IOCTL32_Command_struct __user *) arg;
@@ -4848,7 +4754,7 @@ static int hpsa_ioctl32_big_passthru(struct scsi_device *dev,
         if (err)
                 return -EFAULT;
 
-        err = hpsa_ioctl(dev, CCISS_BIG_PASSTHRU, (void *)p);
+        err = hpsa_ioctl(dev, CCISS_BIG_PASSTHRU, p);
         if (err)
                 return err;
         err |= copy_in_user(&arg32->error_info, &p->error_info,
@@ -4858,7 +4764,7 @@ static int hpsa_ioctl32_big_passthru(struct scsi_device *dev,
         return err;
 }
 
-static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd, void *arg)
+static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
 {
         switch (cmd) {
         case CCISS_GETPCIINFO:
@@ -4932,7 +4838,7 @@ static int hpsa_passthru_ioctl(struct ctlr_info *h, void __user *argp)
         IOCTL_Command_struct iocommand;
         struct CommandList *c;
         char *buff = NULL;
-        union u64bit temp64;
+        u64 temp64;
         int rc = 0;
 
         if (!argp)
@@ -4971,14 +4877,14 @@ static int hpsa_passthru_ioctl(struct ctlr_info *h, void __user *argp)
         c->Header.ReplyQueue = 0; /* unused in simple mode */
         if (iocommand.buf_size > 0) {   /* buffer to fill */
                 c->Header.SGList = 1;
-                c->Header.SGTotal = 1;
+                c->Header.SGTotal = cpu_to_le16(1);
         } else  { /* no buffers to fill */
                 c->Header.SGList = 0;
-                c->Header.SGTotal = 0;
+                c->Header.SGTotal = cpu_to_le16(0);
         }
         memcpy(&c->Header.LUN, &iocommand.LUN_info, sizeof(c->Header.LUN));
         /* use the kernel address the cmd block for tag */
-        c->Header.Tag.lower = c->busaddr;
+        c->Header.tag = c->busaddr;
 
         /* Fill in Request block */
         memcpy(&c->Request, &iocommand.Request,
@@ -4986,19 +4892,17 @@ static int hpsa_passthru_ioctl(struct ctlr_info *h, void __user *argp)
 
         /* Fill in the scatter gather information */
         if (iocommand.buf_size > 0) {
-                temp64.val = pci_map_single(h->pdev, buff,
+                temp64 = pci_map_single(h->pdev, buff,
                         iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
-                if (dma_mapping_error(&h->pdev->dev, temp64.val)) {
-                        c->SG[0].Addr.lower = 0;
-                        c->SG[0].Addr.upper = 0;
-                        c->SG[0].Len = 0;
+                if (dma_mapping_error(&h->pdev->dev, (dma_addr_t) temp64)) {
+                        c->SG[0].Addr = cpu_to_le64(0);
+                        c->SG[0].Len = cpu_to_le32(0);
                         rc = -ENOMEM;
                         goto out;
                 }
-                c->SG[0].Addr.lower = temp64.val32.lower;
-                c->SG[0].Addr.upper = temp64.val32.upper;
-                c->SG[0].Len = iocommand.buf_size;
-                c->SG[0].Ext = HPSA_SG_LAST; /* we are not chaining*/
+                c->SG[0].Addr = cpu_to_le64(temp64);
+                c->SG[0].Len = cpu_to_le32(iocommand.buf_size);
+                c->SG[0].Ext = cpu_to_le32(HPSA_SG_LAST); /* not chaining */
         }
         hpsa_scsi_do_simple_cmd_core_if_no_lockup(h, c);
         if (iocommand.buf_size > 0)
@@ -5033,7 +4937,7 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
         struct CommandList *c;
         unsigned char **buff = NULL;
         int *buff_size = NULL;
-        union u64bit temp64;
+        u64 temp64;
         BYTE sg_used = 0;
         int status = 0;
         int i;
@@ -5107,29 +5011,30 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
         }
         c->cmd_type = CMD_IOCTL_PEND;
         c->Header.ReplyQueue = 0;
-        c->Header.SGList = c->Header.SGTotal = sg_used;
+        c->Header.SGList = (u8) sg_used;
+        c->Header.SGTotal = cpu_to_le16(sg_used);
         memcpy(&c->Header.LUN, &ioc->LUN_info, sizeof(c->Header.LUN));
-        c->Header.Tag.lower = c->busaddr;
+        c->Header.tag = c->busaddr;
         memcpy(&c->Request, &ioc->Request, sizeof(c->Request));
         if (ioc->buf_size > 0) {
                 int i;
                 for (i = 0; i < sg_used; i++) {
-                        temp64.val = pci_map_single(h->pdev, buff[i],
+                        temp64 = pci_map_single(h->pdev, buff[i],
                                     buff_size[i], PCI_DMA_BIDIRECTIONAL);
-                        if (dma_mapping_error(&h->pdev->dev, temp64.val)) {
-                                c->SG[i].Addr.lower = 0;
-                                c->SG[i].Addr.upper = 0;
-                                c->SG[i].Len = 0;
+                        if (dma_mapping_error(&h->pdev->dev,
+                                                        (dma_addr_t) temp64)) {
+                                c->SG[i].Addr = cpu_to_le64(0);
+                                c->SG[i].Len = cpu_to_le32(0);
                                 hpsa_pci_unmap(h->pdev, c, i,
                                         PCI_DMA_BIDIRECTIONAL);
                                 status = -ENOMEM;
                                 goto cleanup0;
                         }
-                        c->SG[i].Addr.lower = temp64.val32.lower;
-                        c->SG[i].Addr.upper = temp64.val32.upper;
-                        c->SG[i].Len = buff_size[i];
-                        c->SG[i].Ext = i < sg_used - 1 ? 0 : HPSA_SG_LAST;
+                        c->SG[i].Addr = cpu_to_le64(temp64);
+                        c->SG[i].Len = cpu_to_le32(buff_size[i]);
+                        c->SG[i].Ext = cpu_to_le32(0);
                 }
+                c->SG[--i].Ext = cpu_to_le32(HPSA_SG_LAST);
         }
         hpsa_scsi_do_simple_cmd_core_if_no_lockup(h, c);
         if (sg_used)
@@ -5206,7 +5111,7 @@ static void decrement_passthru_count(struct ctlr_info *h)
 /*
  * ioctl
  */
-static int hpsa_ioctl(struct scsi_device *dev, int cmd, void *arg)
+static int hpsa_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
 {
         struct ctlr_info *h;
         void __user *argp = (void __user *)arg;
@@ -5268,20 +5173,20 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
 {
         int pci_dir = XFER_NONE;
         struct CommandList *a; /* for commands to be aborted */
+        u32 tupper, tlower;
 
         c->cmd_type = CMD_IOCTL_PEND;
         c->Header.ReplyQueue = 0;
         if (buff != NULL && size > 0) {
                 c->Header.SGList = 1;
-                c->Header.SGTotal = 1;
+                c->Header.SGTotal = cpu_to_le16(1);
         } else {
                 c->Header.SGList = 0;
-                c->Header.SGTotal = 0;
+                c->Header.SGTotal = cpu_to_le16(0);
         }
-        c->Header.Tag.lower = c->busaddr;
+        c->Header.tag = c->busaddr;
         memcpy(c->Header.LUN.LunAddrBytes, scsi3addr, 8);
 
-        c->Request.Type.Type = cmd_type;
         if (cmd_type == TYPE_CMD) {
                 switch (cmd) {
                 case HPSA_INQUIRY:
@@ -5291,8 +5196,8 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                                 c->Request.CDB[2] = (page_code & 0xff);
                         }
                         c->Request.CDBLen = 6;
-                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_READ;
+                        c->Request.type_attr_dir =
+                                TYPE_ATTR_DIR(cmd_type, ATTR_SIMPLE, XFER_READ);
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = HPSA_INQUIRY;
                         c->Request.CDB[4] = size & 0xFF;
@@ -5303,8 +5208,8 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                            mode = 00 target = 0.  Nothing to write.
                          */
                         c->Request.CDBLen = 12;
-                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_READ;
+                        c->Request.type_attr_dir =
+                                TYPE_ATTR_DIR(cmd_type, ATTR_SIMPLE, XFER_READ);
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = cmd;
                         c->Request.CDB[6] = (size >> 24) & 0xFF; /* MSB */
@@ -5314,8 +5219,9 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         break;
                 case HPSA_CACHE_FLUSH:
                         c->Request.CDBLen = 12;
-                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_WRITE;
+                        c->Request.type_attr_dir =
+                                        TYPE_ATTR_DIR(cmd_type,
+                                                ATTR_SIMPLE, XFER_WRITE);
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = BMIC_WRITE;
                         c->Request.CDB[6] = BMIC_CACHE_FLUSH;
@@ -5324,14 +5230,14 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         break;
                 case TEST_UNIT_READY:
                         c->Request.CDBLen = 6;
-                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_NONE;
+                        c->Request.type_attr_dir =
+                                TYPE_ATTR_DIR(cmd_type, ATTR_SIMPLE, XFER_NONE);
                         c->Request.Timeout = 0;
                         break;
                 case HPSA_GET_RAID_MAP:
                         c->Request.CDBLen = 12;
-                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_READ;
+                        c->Request.type_attr_dir =
+                                TYPE_ATTR_DIR(cmd_type, ATTR_SIMPLE, XFER_READ);
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = HPSA_CISS_READ;
                         c->Request.CDB[1] = cmd;
@@ -5342,8 +5248,8 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         break;
                 case BMIC_SENSE_CONTROLLER_PARAMETERS:
                         c->Request.CDBLen = 10;
-                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_READ;
+                        c->Request.type_attr_dir =
+                                TYPE_ATTR_DIR(cmd_type, ATTR_SIMPLE, XFER_READ);
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = BMIC_READ;
                         c->Request.CDB[6] = BMIC_SENSE_CONTROLLER_PARAMETERS;
@@ -5360,9 +5266,8 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
 
                 case  HPSA_DEVICE_RESET_MSG:
                         c->Request.CDBLen = 16;
-                        c->Request.Type.Type =  1; /* It is a MSG not a CMD */
-                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_NONE;
+                        c->Request.type_attr_dir =
+                                TYPE_ATTR_DIR(cmd_type, ATTR_SIMPLE, XFER_NONE);
                         c->Request.Timeout = 0; /* Don't time out */
                         memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
                         c->Request.CDB[0] =  cmd;
@@ -5376,27 +5281,28 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         break;
                 case  HPSA_ABORT_MSG:
                         a = buff;       /* point to command to be aborted */
-                        dev_dbg(&h->pdev->dev, "Abort Tag:0x%08x:%08x using request Tag:0x%08x:%08x\n",
-                                a->Header.Tag.upper, a->Header.Tag.lower,
-                                c->Header.Tag.upper, c->Header.Tag.lower);
+                        dev_dbg(&h->pdev->dev, "Abort Tag:0x%016llx using request Tag:0x%016llx",
+                                a->Header.tag, c->Header.tag);
+                        tlower = (u32) (a->Header.tag >> 32);
+                        tupper = (u32) (a->Header.tag & 0x0ffffffffULL);
                         c->Request.CDBLen = 16;
-                        c->Request.Type.Type = TYPE_MSG;
-                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_WRITE;
+                        c->Request.type_attr_dir =
+                                        TYPE_ATTR_DIR(cmd_type,
+                                                ATTR_SIMPLE, XFER_WRITE);
                         c->Request.Timeout = 0; /* Don't time out */
                         c->Request.CDB[0] = HPSA_TASK_MANAGEMENT;
                         c->Request.CDB[1] = HPSA_TMF_ABORT_TASK;
                         c->Request.CDB[2] = 0x00; /* reserved */
                         c->Request.CDB[3] = 0x00; /* reserved */
                         /* Tag to abort goes in CDB[4]-CDB[11] */
-                        c->Request.CDB[4] = a->Header.Tag.lower & 0xFF;
-                        c->Request.CDB[5] = (a->Header.Tag.lower >> 8) & 0xFF;
-                        c->Request.CDB[6] = (a->Header.Tag.lower >> 16) & 0xFF;
-                        c->Request.CDB[7] = (a->Header.Tag.lower >> 24) & 0xFF;
-                        c->Request.CDB[8] = a->Header.Tag.upper & 0xFF;
-                        c->Request.CDB[9] = (a->Header.Tag.upper >> 8) & 0xFF;
-                        c->Request.CDB[10] = (a->Header.Tag.upper >> 16) & 0xFF;
-                        c->Request.CDB[11] = (a->Header.Tag.upper >> 24) & 0xFF;
+                        c->Request.CDB[4] = tlower & 0xFF;
+                        c->Request.CDB[5] = (tlower >> 8) & 0xFF;
+                        c->Request.CDB[6] = (tlower >> 16) & 0xFF;
+                        c->Request.CDB[7] = (tlower >> 24) & 0xFF;
+                        c->Request.CDB[8] = tupper & 0xFF;
+                        c->Request.CDB[9] = (tupper >> 8) & 0xFF;
+                        c->Request.CDB[10] = (tupper >> 16) & 0xFF;
+                        c->Request.CDB[11] = (tupper >> 24) & 0xFF;
                         c->Request.CDB[12] = 0x00; /* reserved */
                         c->Request.CDB[13] = 0x00; /* reserved */
                         c->Request.CDB[14] = 0x00; /* reserved */
@@ -5412,7 +5318,7 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                 BUG();
         }
 
-        switch (c->Request.Type.Direction) {
+        switch (GET_DIR(c->Request.type_attr_dir)) {
         case XFER_READ:
                 pci_dir = PCI_DMA_FROMDEVICE;
                 break;
@@ -5467,15 +5373,9 @@ static void start_io(struct ctlr_info *h, unsigned long *flags)
 
                 /* Put job onto the completed Q */
                 addQ(&h->cmpQ, c);
-
-                /* Must increment commands_outstanding before unlocking
-                 * and submitting to avoid race checking for fifo full
-                 * condition.
-                 */
-                h->commands_outstanding++;
-
-                /* Tell the controller execute command */
+                atomic_inc(&h->commands_outstanding);
                 spin_unlock_irqrestore(&h->lock, *flags);
+                /* Tell the controller execute command */
                 h->access.submit_command(h, c);
                 spin_lock_irqsave(&h->lock, *flags);
         }
@@ -5521,6 +5421,7 @@ static inline void finish_cmd(struct CommandList *c)
         unsigned long flags;
         int io_may_be_stalled = 0;
         struct ctlr_info *h = c->h;
+        int count;
 
         spin_lock_irqsave(&h->lock, flags);
         removeQ(c);
@@ -5541,11 +5442,10 @@ static inline void finish_cmd(struct CommandList *c)
          * want to get in a cycle where we call start_io every time
          * through here.
          */
-        if (unlikely(h->fifo_recently_full) &&
-                h->commands_outstanding < 5)
-                io_may_be_stalled = 1;
-
+        count = atomic_read(&h->commands_outstanding);
         spin_unlock_irqrestore(&h->lock, flags);
+        if (unlikely(h->fifo_recently_full) && count < 5)
+                io_may_be_stalled = 1;
 
         dial_up_lockup_detection_on_fw_flash_complete(c->h, c);
         if (likely(c->cmd_type == CMD_IOACCEL1 || c->cmd_type == CMD_SCSI
@@ -5765,22 +5665,20 @@ static int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
 
         cmd->CommandHeader.ReplyQueue = 0;
         cmd->CommandHeader.SGList = 0;
-        cmd->CommandHeader.SGTotal = 0;
-        cmd->CommandHeader.Tag.lower = paddr32;
-        cmd->CommandHeader.Tag.upper = 0;
+        cmd->CommandHeader.SGTotal = cpu_to_le16(0);
+        cmd->CommandHeader.tag = paddr32;
         memset(&cmd->CommandHeader.LUN.LunAddrBytes, 0, 8);
 
         cmd->Request.CDBLen = 16;
-        cmd->Request.Type.Type = TYPE_MSG;
-        cmd->Request.Type.Attribute = ATTR_HEADOFQUEUE;
-        cmd->Request.Type.Direction = XFER_NONE;
+        cmd->Request.type_attr_dir =
+                        TYPE_ATTR_DIR(TYPE_MSG, ATTR_HEADOFQUEUE, XFER_NONE);
         cmd->Request.Timeout = 0; /* Don't time out */
         cmd->Request.CDB[0] = opcode;
         cmd->Request.CDB[1] = type;
         memset(&cmd->Request.CDB[2], 0, 14); /* rest of the CDB is reserved */
-        cmd->ErrorDescriptor.Addr.lower = paddr32 + sizeof(*cmd);
-        cmd->ErrorDescriptor.Addr.upper = 0;
-        cmd->ErrorDescriptor.Len = sizeof(struct ErrorInfo);
+        cmd->ErrorDescriptor.Addr =
+                        cpu_to_le64((paddr32 + sizeof(*cmd)));
+        cmd->ErrorDescriptor.Len = cpu_to_le32(sizeof(struct ErrorInfo));
 
         writel(paddr32, vaddr + SA5_REQUEST_PORT_OFFSET);
 
@@ -5818,7 +5716,7 @@ static int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
 #define hpsa_noop(p) hpsa_message(p, 3, 0)
 
 static int hpsa_controller_hard_reset(struct pci_dev *pdev,
-        void * __iomem vaddr, u32 use_doorbell)
+        void __iomem *vaddr, u32 use_doorbell)
 {
         u16 pmcsr;
         int pos;
@@ -6056,7 +5954,7 @@ unmap_vaddr:
  *   the io functions.
  *   This is for debug only.
  */
-static void print_cfg_table(struct device *dev, struct CfgTable *tb)
+static void print_cfg_table(struct device *dev, struct CfgTable __iomem *tb)
 {
 #ifdef HPSA_DEBUG
         int i;
@@ -6323,11 +6221,11 @@ static void hpsa_find_board_params(struct ctlr_info *h)
         h->max_cmd_sg_entries = 31;
         if (h->maxsgentries > 512) {
                 h->max_cmd_sg_entries = 32;
-                h->chainsize = h->maxsgentries - h->max_cmd_sg_entries + 1;
+                h->chainsize = h->maxsgentries - h->max_cmd_sg_entries;
                 h->maxsgentries--; /* save one for chain pointer */
         } else {
-                h->maxsgentries = 31; /* default to traditional values */
                 h->chainsize = 0;
+                h->maxsgentries = 31; /* default to traditional values */
         }
 
         /* Find out what task management functions are supported and cache */
@@ -6456,15 +6354,15 @@ static int hpsa_pci_init(struct ctlr_info *h)
                 return err;
         }
 
-        /* Enable bus mastering (pci_disable_device may disable this) */
-        pci_set_master(h->pdev);
-
         err = pci_request_regions(h->pdev, HPSA);
         if (err) {
                 dev_err(&h->pdev->dev,
                         "cannot obtain PCI resources, aborting\n");
                 return err;
         }
+
+        pci_set_master(h->pdev);
+
         hpsa_interrupt_mode(h);
         err = hpsa_pci_find_memory_BAR(h->pdev, &h->paddr);
         if (err)
@@ -6544,7 +6442,9 @@ static int hpsa_init_reset_devices(struct pci_dev *pdev)
                 dev_warn(&pdev->dev, "failed to enable device.\n");
                 return -ENODEV;
         }
+
         pci_set_master(pdev);
+
         /* Reset the controller with a PCI power-cycle or via doorbell */
         rc = hpsa_kdump_hard_reset_controller(pdev);
 
@@ -7431,13 +7331,12 @@ static void hpsa_enter_performant_mode(struct ctlr_info *h, u32 trans_support)
                         cp->host_context_flags = IOACCEL1_HCFLAGS_CISS_FORMAT;
                         cp->timeout_sec = 0;
                         cp->ReplyQueue = 0;
-                        cp->Tag.lower = (i << DIRECT_LOOKUP_SHIFT) |
-                                                DIRECT_LOOKUP_BIT;
-                        cp->Tag.upper = 0;
-                        cp->host_addr.lower =
-                                (u32) (h->ioaccel_cmd_pool_dhandle +
+                        cp->tag =
+                                cpu_to_le64((i << DIRECT_LOOKUP_SHIFT) |
+                                                DIRECT_LOOKUP_BIT);
+                        cp->host_addr =
+                                cpu_to_le64(h->ioaccel_cmd_pool_dhandle +
                                         (i * sizeof(struct io_accel1_cmd)));
-                        cp->host_addr.upper = 0;
                 }
         } else if (trans_support & CFGTBL_Trans_io_accel2) {
                 u64 cfg_offset, cfg_base_addr_index;
@@ -7711,7 +7610,7 @@ static void __attribute__((unused)) verify_offsets(void)
         VERIFY_OFFSET(timeout_sec, 0x62);
         VERIFY_OFFSET(ReplyQueue, 0x64);
         VERIFY_OFFSET(reserved9, 0x65);
-        VERIFY_OFFSET(Tag, 0x68);
+        VERIFY_OFFSET(tag, 0x68);
         VERIFY_OFFSET(host_addr, 0x70);
         VERIFY_OFFSET(CISS_LUN, 0x78);
         VERIFY_OFFSET(SG, 0x78 + 8);
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index 24472cec7de3..8e06d9e280ec 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -118,7 +118,7 @@ struct ctlr_info {
         struct CfgTable __iomem *cfgtable;
         int     interrupts_enabled;
         int     max_commands;
-        int     commands_outstanding;
+        atomic_t commands_outstanding;
 #       define PERF_MODE_INT    0
 #       define DOORBELL_INT     1
 #       define SIMPLE_MODE_INT  2
@@ -164,7 +164,7 @@ struct ctlr_info {
          */
         u32 trans_support;
         u32 trans_offset;
-        struct TransTable_struct *transtable;
+        struct TransTable_struct __iomem *transtable;
         unsigned long transMethod;
 
         /* cap concurrent passthrus at some reasonable maximum */
@@ -181,7 +181,7 @@ struct ctlr_info {
         u32 *blockFetchTable;
         u32 *ioaccel1_blockFetchTable;
         u32 *ioaccel2_blockFetchTable;
-        u32 *ioaccel2_bft2_regs;
+        u32 __iomem *ioaccel2_bft2_regs;
         unsigned char *hba_inquiry_data;
         u32 driver_support;
         u32 fw_support;
@@ -192,7 +192,7 @@ struct ctlr_info {
         u64 last_heartbeat_timestamp;
         u32 heartbeat_sample_interval;
         atomic_t firmware_flash_in_progress;
-        u32 *lockup_detected;
+        u32 __percpu *lockup_detected;
         struct delayed_work monitor_ctlr_work;
         int remove_in_progress;
         u32 fifo_recently_full;
@@ -395,7 +395,7 @@ static void SA5_performant_intr_mask(struct ctlr_info *h, unsigned long val)
 static unsigned long SA5_performant_completed(struct ctlr_info *h, u8 q)
 {
         struct reply_queue_buffer *rq = &h->reply_queue[q];
-        unsigned long flags, register_value = FIFO_EMPTY;
+        unsigned long register_value = FIFO_EMPTY;
 
         /* msi auto clears the interrupt pending bit. */
         if (!(h->msi_vector || h->msix_vector)) {
@@ -413,9 +413,7 @@ static unsigned long SA5_performant_completed(struct ctlr_info *h, u8 q)
         if ((rq->head[rq->current_entry] & 1) == rq->wraparound) {
                 register_value = rq->head[rq->current_entry];
                 rq->current_entry++;
-                spin_lock_irqsave(&h->lock, flags);
-                h->commands_outstanding--;
-                spin_unlock_irqrestore(&h->lock, flags);
+                atomic_dec(&h->commands_outstanding);
         } else {
                 register_value = FIFO_EMPTY;
         }
@@ -433,11 +431,7 @@ static unsigned long SA5_performant_completed(struct ctlr_info *h, u8 q)
  */
 static unsigned long SA5_fifo_full(struct ctlr_info *h)
 {
-        if (h->commands_outstanding >= h->max_commands)
-                return 1;
-        else
-                return 0;
-
+        return atomic_read(&h->commands_outstanding) >= h->max_commands;
 }
 /*
  *   returns value read from hardware.
@@ -448,13 +442,9 @@ static unsigned long SA5_completed(struct ctlr_info *h,
 {
         unsigned long register_value
                 = readl(h->vaddr + SA5_REPLY_PORT_OFFSET);
-        unsigned long flags;
 
-        if (register_value != FIFO_EMPTY) {
-                spin_lock_irqsave(&h->lock, flags);
-                h->commands_outstanding--;
-                spin_unlock_irqrestore(&h->lock, flags);
-        }
+        if (register_value != FIFO_EMPTY)
+                atomic_dec(&h->commands_outstanding);
 
 #ifdef HPSA_DEBUG
         if (register_value != FIFO_EMPTY)
@@ -510,7 +500,6 @@ static unsigned long SA5_ioaccel_mode1_completed(struct ctlr_info *h, u8 q)
 {
         u64 register_value;
         struct reply_queue_buffer *rq = &h->reply_queue[q];
-        unsigned long flags;
 
         BUG_ON(q >= h->nreply_queues);
 
@@ -528,9 +517,7 @@ static unsigned long SA5_ioaccel_mode1_completed(struct ctlr_info *h, u8 q)
                 wmb();
                 writel((q << 24) | rq->current_entry, h->vaddr +
                                 IOACCEL_MODE1_CONSUMER_INDEX);
-                spin_lock_irqsave(&h->lock, flags);
-                h->commands_outstanding--;
-                spin_unlock_irqrestore(&h->lock, flags);
+                atomic_dec(&h->commands_outstanding);
         }
         return (unsigned long) register_value;
 }
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
index b5125dc31439..cb988c41cad9 100644
--- a/drivers/scsi/hpsa_cmd.h
+++ b/drivers/scsi/hpsa_cmd.h
@@ -252,7 +252,7 @@ struct ReportExtendedLUNdata {
         u8 LUNListLength[4];
         u8 extended_response_flag;
         u8 reserved[3];
-        struct ext_report_lun_entry LUN[HPSA_MAX_LUN];
+        struct ext_report_lun_entry LUN[HPSA_MAX_PHYS_LUN];
 };
 
 struct SenseSubsystem_info {
@@ -314,28 +314,36 @@ struct CommandListHeader {
         u8              ReplyQueue;
         u8              SGList;
         u16             SGTotal;
-        struct vals32     Tag;
+        u64             tag;
         union LUNAddr     LUN;
 };
 
 struct RequestBlock {
         u8   CDBLen;
-        struct {
-                u8 Type:3;
-                u8 Attribute:3;
-                u8 Direction:2;
-        } Type;
+        /*
+         * type_attr_dir:
+         * type: low 3 bits
+         * attr: middle 3 bits
+         * dir: high 2 bits
+         */
+        u8      type_attr_dir;
+#define TYPE_ATTR_DIR(t, a, d) ((((d) & 0x03) << 6) |\
+                                (((a) & 0x07) << 3) |\
+                                ((t) & 0x07))
+#define GET_TYPE(tad) ((tad) & 0x07)
+#define GET_ATTR(tad) (((tad) >> 3) & 0x07)
+#define GET_DIR(tad) (((tad) >> 6) & 0x03)
         u16  Timeout;
         u8   CDB[16];
 };
 
 struct ErrDescriptor {
-        struct vals32 Addr;
+        u64 Addr;
         u32  Len;
 };
 
 struct SGDescriptor {
-        struct vals32 Addr;
+        u64 Addr;
         u32  Len;
         u32  Ext;
 };
@@ -434,8 +442,8 @@ struct io_accel1_cmd {
         u16 timeout_sec;                /* 0x62 - 0x63 */
         u8  ReplyQueue;                 /* 0x64 */
         u8  reserved9[3];               /* 0x65 - 0x67 */
-        struct vals32 Tag;              /* 0x68 - 0x6F */
-        struct vals32 host_addr;        /* 0x70 - 0x77 */
+        u64 tag;                        /* 0x68 - 0x6F */
+        u64 host_addr;                  /* 0x70 - 0x77 */
         u8  CISS_LUN[8];                /* 0x78 - 0x7F */
         struct SGDescriptor SG[IOACCEL1_MAXSGENTRIES];
 } __aligned(IOACCEL1_COMMANDLIST_ALIGNMENT);
@@ -555,8 +563,8 @@ struct hpsa_tmf_struct {
         u8 reserved1;           /* byte 3 Reserved */
         u32 it_nexus;           /* SCSI I-T Nexus */
         u8 lun_id[8];           /* LUN ID for TMF request */
-        struct vals32 Tag;      /* cciss tag associated w/ request */
-        struct vals32 abort_tag;/* cciss tag of SCSI cmd or task to abort */
+        u64 tag;                /* cciss tag associated w/ request */
+        u64 abort_tag;          /* cciss tag of SCSI cmd or task to abort */
         u64 error_ptr;          /* Error Pointer */
         u32 error_len;          /* Error Length */
 };
diff --git a/drivers/scsi/hptiop.c b/drivers/scsi/hptiop.c
index dedb62c21b29..e995218476ed 100644
--- a/drivers/scsi/hptiop.c
+++ b/drivers/scsi/hptiop.c
@@ -1118,17 +1118,13 @@ static int hptiop_reset(struct scsi_cmnd *scp)
 }
 
 static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev,
-                                          int queue_depth, int reason)
+                                          int queue_depth)
 {
         struct hptiop_hba *hba = (struct hptiop_hba *)sdev->host->hostdata;
 
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (queue_depth > hba->max_requests)
                 queue_depth = hba->max_requests;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
-        return queue_depth;
+        return scsi_change_queue_depth(sdev, queue_depth);
 }
 
 static ssize_t hptiop_show_version(struct device *dev,
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index 598c42cba5a8..f58c6d8e0264 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -1643,19 +1643,9 @@ static int ibmvfc_queuecommand_lck(struct scsi_cmnd *cmnd,
         int_to_scsilun(cmnd->device->lun, &vfc_cmd->iu.lun);
         memcpy(vfc_cmd->iu.cdb, cmnd->cmnd, cmnd->cmd_len);
 
-        if (scsi_populate_tag_msg(cmnd, tag)) {
-                vfc_cmd->task_tag = cpu_to_be64(tag[1]);
-                switch (tag[0]) {
-                case MSG_SIMPLE_TAG:
-                        vfc_cmd->iu.pri_task_attr = IBMVFC_SIMPLE_TASK;
-                        break;
-                case MSG_HEAD_TAG:
-                        vfc_cmd->iu.pri_task_attr = IBMVFC_HEAD_OF_QUEUE;
-                        break;
-                case MSG_ORDERED_TAG:
-                        vfc_cmd->iu.pri_task_attr = IBMVFC_ORDERED_TASK;
-                        break;
-                };
+        if (cmnd->flags & SCMD_TAGGED) {
+                vfc_cmd->task_tag = cpu_to_be64(cmnd->tag);
+                vfc_cmd->iu.pri_task_attr = IBMVFC_SIMPLE_TASK;
         }
 
         if (likely(!(rc = ibmvfc_map_sg_data(cmnd, evt, vfc_cmd, vhost->dev))))
@@ -2897,12 +2887,6 @@ static int ibmvfc_slave_configure(struct scsi_device *sdev)
         spin_lock_irqsave(shost->host_lock, flags);
         if (sdev->type == TYPE_DISK)
                 sdev->allow_restart = 1;
-
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, MSG_SIMPLE_TAG);
-                scsi_activate_tcq(sdev, sdev->queue_depth);
-        } else
-                scsi_deactivate_tcq(sdev, sdev->queue_depth);
         spin_unlock_irqrestore(shost->host_lock, flags);
         return 0;
 }
@@ -2916,40 +2900,12 @@ static int ibmvfc_slave_configure(struct scsi_device *sdev)
  * Return value:
  *      actual depth set
  **/
-static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth,
-                                     int reason)
+static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (qdepth > IBMVFC_MAX_CMDS_PER_LUN)
                 qdepth = IBMVFC_MAX_CMDS_PER_LUN;
 
-        scsi_adjust_queue_depth(sdev, 0, qdepth);
-        return sdev->queue_depth;
-}
-
-/**
- * ibmvfc_change_queue_type - Change the device's queue type
- * @sdev:               scsi device struct
- * @tag_type:   type of tags to use
- *
- * Return value:
- *      actual queue type set
- **/
-static int ibmvfc_change_queue_type(struct scsi_device *sdev, int tag_type)
-{
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, tag_type);
-
-                if (tag_type)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                tag_type = 0;
-
-        return tag_type;
+        return scsi_change_queue_depth(sdev, qdepth);
 }
 
 static ssize_t ibmvfc_show_host_partition_name(struct device *dev,
@@ -3133,7 +3089,7 @@ static struct scsi_host_template driver_template = {
         .target_alloc = ibmvfc_target_alloc,
         .scan_finished = ibmvfc_scan_finished,
         .change_queue_depth = ibmvfc_change_queue_depth,
-        .change_queue_type = ibmvfc_change_queue_type,
+        .change_queue_type = scsi_change_queue_type,
         .cmd_per_lun = 16,
         .can_queue = IBMVFC_MAX_REQUESTS_DEFAULT,
         .this_id = -1,
@@ -3141,6 +3097,8 @@ static struct scsi_host_template driver_template = {
         .max_sectors = IBMVFC_MAX_SECTORS,
         .use_clustering = ENABLE_CLUSTERING,
         .shost_attrs = ibmvfc_attrs,
+        .use_blk_tags = 1,
+        .track_queue_depth = 1,
 };
 
 /**
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 7b23f21f22f1..acea5d6eebd0 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1929,7 +1929,6 @@ static int ibmvscsi_slave_configure(struct scsi_device *sdev)
                 blk_queue_rq_timeout(sdev->request_queue, 120 * HZ);
         }
         spin_unlock_irqrestore(shost->host_lock, lock_flags);
-        scsi_adjust_queue_depth(sdev, 0, shost->cmd_per_lun);
         return 0;
 }
 
@@ -1942,17 +1941,11 @@ static int ibmvscsi_slave_configure(struct scsi_device *sdev)
  * Return value:
  *      actual depth set
  **/
-static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth,
-                                       int reason)
+static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (qdepth > IBMVSCSI_MAX_CMDS_PER_LUN)
                 qdepth = IBMVSCSI_MAX_CMDS_PER_LUN;
-
-        scsi_adjust_queue_depth(sdev, 0, qdepth);
-        return sdev->queue_depth;
+        return scsi_change_queue_depth(sdev, qdepth);
 }
 
 /* ------------------------------------------------------------
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 2a9578c116b7..540294389355 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -3942,8 +3942,9 @@ static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
                 return -EIO;
         }
 
-        sglist->num_dma_sg = pci_map_sg(ioa_cfg->pdev, sglist->scatterlist,
-                                        sglist->num_sg, DMA_TO_DEVICE);
+        sglist->num_dma_sg = dma_map_sg(&ioa_cfg->pdev->dev,
+                                        sglist->scatterlist, sglist->num_sg,
+                                        DMA_TO_DEVICE);
 
         if (!sglist->num_dma_sg) {
                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
@@ -4327,16 +4328,12 @@ static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
  * Return value:
  *      actual depth set
  **/
-static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth,
-                                  int reason)
+static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
         struct ipr_resource_entry *res;
         unsigned long lock_flags = 0;
 
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
         res = (struct ipr_resource_entry *)sdev->hostdata;
 
@@ -4344,7 +4341,7 @@ static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth,
                 qdepth = IPR_MAX_CMD_PER_ATA_LUN;
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        scsi_change_queue_depth(sdev, qdepth);
         return sdev->queue_depth;
 }
 
@@ -4364,24 +4361,10 @@ static int ipr_change_queue_type(struct scsi_device *sdev, int tag_type)
 
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
         res = (struct ipr_resource_entry *)sdev->hostdata;
-
-        if (res) {
-                if (ipr_is_gscsi(res) && sdev->tagged_supported) {
-                        /*
-                         * We don't bother quiescing the device here since the
-                         * adapter firmware does it for us.
-                         */
-                        scsi_set_tag_type(sdev, tag_type);
-
-                        if (tag_type)
-                                scsi_activate_tcq(sdev, sdev->queue_depth);
-                        else
-                                scsi_deactivate_tcq(sdev, sdev->queue_depth);
-                } else
-                        tag_type = 0;
-        } else
+        if (res && ipr_is_gscsi(res))
+                tag_type = scsi_change_queue_type(sdev, tag_type);
+        else
                 tag_type = 0;
-
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
         return tag_type;
 }
@@ -4765,10 +4748,10 @@ static int ipr_slave_configure(struct scsi_device *sdev)
                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 
                 if (ap) {
-                        scsi_adjust_queue_depth(sdev, 0, IPR_MAX_CMD_PER_ATA_LUN);
+                        scsi_change_queue_depth(sdev, IPR_MAX_CMD_PER_ATA_LUN);
                         ata_sas_slave_configure(sdev, ap);
-                } else
-                        scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
+                }
+
                 if (ioa_cfg->sis64)
                         sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
                                     ipr_format_res_path(ioa_cfg,
@@ -5585,7 +5568,7 @@ static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
         nseg = scsi_dma_map(scsi_cmd);
         if (nseg < 0) {
                 if (printk_ratelimit())
-                        dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
+                        dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
                 return -1;
         }
 
@@ -5636,7 +5619,7 @@ static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
 
         nseg = scsi_dma_map(scsi_cmd);
         if (nseg < 0) {
-                dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
+                dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
                 return -1;
         }
 
@@ -5673,35 +5656,6 @@ static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
 }
 
 /**
- * ipr_get_task_attributes - Translate SPI Q-Tag to task attributes
- * @scsi_cmd:   scsi command struct
- *
- * Return value:
- *      task attributes
- **/
-static u8 ipr_get_task_attributes(struct scsi_cmnd *scsi_cmd)
-{
-        u8 tag[2];
-        u8 rc = IPR_FLAGS_LO_UNTAGGED_TASK;
-
-        if (scsi_populate_tag_msg(scsi_cmd, tag)) {
-                switch (tag[0]) {
-                case MSG_SIMPLE_TAG:
-                        rc = IPR_FLAGS_LO_SIMPLE_TASK;
-                        break;
-                case MSG_HEAD_TAG:
-                        rc = IPR_FLAGS_LO_HEAD_OF_Q_TASK;
-                        break;
-                case MSG_ORDERED_TAG:
-                        rc = IPR_FLAGS_LO_ORDERED_TASK;
-                        break;
-                };
-        }
-
-        return rc;
-}
-
-/**
  * ipr_erp_done - Process completion of ERP for a device
  * @ipr_cmd:            ipr command struct
  *
@@ -6236,7 +6190,10 @@ static int ipr_queuecommand(struct Scsi_Host *shost,
                         ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
                 }
                 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
-                ioarcb->cmd_pkt.flags_lo |= ipr_get_task_attributes(scsi_cmd);
+                if (scsi_cmd->flags & SCMD_TAGGED)
+                        ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_SIMPLE_TASK;
+                else
+                        ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_UNTAGGED_TASK;
         }
 
         if (scsi_cmd->cmnd[0] >= 0xC0 &&
@@ -6357,6 +6314,7 @@ static struct scsi_host_template driver_template = {
         .sdev_attrs = ipr_dev_attrs,
         .proc_name = IPR_NAME,
         .no_write_same = 1,
+        .use_blk_tags = 1,
 };
 
 /**
@@ -8431,7 +8389,7 @@ static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
 
-        pci_unmap_sg(ioa_cfg->pdev, sglist->scatterlist,
+        dma_unmap_sg(&ioa_cfg->pdev->dev, sglist->scatterlist,
                      sglist->num_sg, DMA_TO_DEVICE);
 
         ipr_cmd->job_step = ipr_reset_alert;
@@ -8871,7 +8829,7 @@ static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
 
         for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
                 if (ioa_cfg->ipr_cmnd_list[i])
-                        pci_pool_free(ioa_cfg->ipr_cmd_pool,
+                        dma_pool_free(ioa_cfg->ipr_cmd_pool,
                                       ioa_cfg->ipr_cmnd_list[i],
                                       ioa_cfg->ipr_cmnd_list_dma[i]);
 
@@ -8879,7 +8837,7 @@ static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
         }
 
         if (ioa_cfg->ipr_cmd_pool)
-                pci_pool_destroy(ioa_cfg->ipr_cmd_pool);
+                dma_pool_destroy(ioa_cfg->ipr_cmd_pool);
 
         kfree(ioa_cfg->ipr_cmnd_list);
         kfree(ioa_cfg->ipr_cmnd_list_dma);
@@ -8900,25 +8858,24 @@ static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
         int i;
 
         kfree(ioa_cfg->res_entries);
-        pci_free_consistent(ioa_cfg->pdev, sizeof(struct ipr_misc_cbs),
-                            ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
+        dma_free_coherent(&ioa_cfg->pdev->dev, sizeof(struct ipr_misc_cbs),
+                          ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
         ipr_free_cmd_blks(ioa_cfg);
 
         for (i = 0; i < ioa_cfg->hrrq_num; i++)
-                pci_free_consistent(ioa_cfg->pdev,
-                                        sizeof(u32) * ioa_cfg->hrrq[i].size,
-                                        ioa_cfg->hrrq[i].host_rrq,
-                                        ioa_cfg->hrrq[i].host_rrq_dma);
+                dma_free_coherent(&ioa_cfg->pdev->dev,
+                                  sizeof(u32) * ioa_cfg->hrrq[i].size,
+                                  ioa_cfg->hrrq[i].host_rrq,
+                                  ioa_cfg->hrrq[i].host_rrq_dma);
 
-        pci_free_consistent(ioa_cfg->pdev, ioa_cfg->cfg_table_size,
-                            ioa_cfg->u.cfg_table,
-                            ioa_cfg->cfg_table_dma);
+        dma_free_coherent(&ioa_cfg->pdev->dev, ioa_cfg->cfg_table_size,
+                          ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
 
         for (i = 0; i < IPR_NUM_HCAMS; i++) {
-                pci_free_consistent(ioa_cfg->pdev,
-                                    sizeof(struct ipr_hostrcb),
-                                    ioa_cfg->hostrcb[i],
-                                    ioa_cfg->hostrcb_dma[i]);
+                dma_free_coherent(&ioa_cfg->pdev->dev,
+                                  sizeof(struct ipr_hostrcb),
+                                  ioa_cfg->hostrcb[i],
+                                  ioa_cfg->hostrcb_dma[i]);
         }
 
         ipr_free_dump(ioa_cfg);
@@ -8979,7 +8936,7 @@ static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
         dma_addr_t dma_addr;
         int i, entries_each_hrrq, hrrq_id = 0;
 
-        ioa_cfg->ipr_cmd_pool = pci_pool_create(IPR_NAME, ioa_cfg->pdev,
+        ioa_cfg->ipr_cmd_pool = dma_pool_create(IPR_NAME, &ioa_cfg->pdev->dev,
                                                 sizeof(struct ipr_cmnd), 512, 0);
 
         if (!ioa_cfg->ipr_cmd_pool)
@@ -9029,7 +8986,7 @@ static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
         }
 
         for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
-                ipr_cmd = pci_pool_alloc(ioa_cfg->ipr_cmd_pool, GFP_KERNEL, &dma_addr);
+                ipr_cmd = dma_pool_alloc(ioa_cfg->ipr_cmd_pool, GFP_KERNEL, &dma_addr);
 
                 if (!ipr_cmd) {
                         ipr_free_cmd_blks(ioa_cfg);
@@ -9100,9 +9057,10 @@ static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
                 ioa_cfg->res_entries[i].ioa_cfg = ioa_cfg;
         }
 
-        ioa_cfg->vpd_cbs = pci_alloc_consistent(ioa_cfg->pdev,
-                                                sizeof(struct ipr_misc_cbs),
-                                                &ioa_cfg->vpd_cbs_dma);
+        ioa_cfg->vpd_cbs = dma_alloc_coherent(&pdev->dev,
+                                              sizeof(struct ipr_misc_cbs),
+                                              &ioa_cfg->vpd_cbs_dma,
+                                              GFP_KERNEL);
 
         if (!ioa_cfg->vpd_cbs)
                 goto out_free_res_entries;
@@ -9111,13 +9069,14 @@ static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
                 goto out_free_vpd_cbs;
 
         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
-                ioa_cfg->hrrq[i].host_rrq = pci_alloc_consistent(ioa_cfg->pdev,
+                ioa_cfg->hrrq[i].host_rrq = dma_alloc_coherent(&pdev->dev,
                                         sizeof(u32) * ioa_cfg->hrrq[i].size,
-                                        &ioa_cfg->hrrq[i].host_rrq_dma);
+                                        &ioa_cfg->hrrq[i].host_rrq_dma,
+                                        GFP_KERNEL);
 
                 if (!ioa_cfg->hrrq[i].host_rrq)  {
                         while (--i > 0)
-                                pci_free_consistent(pdev,
+                                dma_free_coherent(&pdev->dev,
                                         sizeof(u32) * ioa_cfg->hrrq[i].size,
                                         ioa_cfg->hrrq[i].host_rrq,
                                         ioa_cfg->hrrq[i].host_rrq_dma);
@@ -9126,17 +9085,19 @@ static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
                 ioa_cfg->hrrq[i].ioa_cfg = ioa_cfg;
         }
 
-        ioa_cfg->u.cfg_table = pci_alloc_consistent(ioa_cfg->pdev,
-                                                    ioa_cfg->cfg_table_size,
-                                                    &ioa_cfg->cfg_table_dma);
+        ioa_cfg->u.cfg_table = dma_alloc_coherent(&pdev->dev,
+                                                  ioa_cfg->cfg_table_size,
+                                                  &ioa_cfg->cfg_table_dma,
+                                                  GFP_KERNEL);
 
         if (!ioa_cfg->u.cfg_table)
                 goto out_free_host_rrq;
 
         for (i = 0; i < IPR_NUM_HCAMS; i++) {
-                ioa_cfg->hostrcb[i] = pci_alloc_consistent(ioa_cfg->pdev,
-                                                           sizeof(struct ipr_hostrcb),
-                                                           &ioa_cfg->hostrcb_dma[i]);
+                ioa_cfg->hostrcb[i] = dma_alloc_coherent(&pdev->dev,
+                                                         sizeof(struct ipr_hostrcb),
+                                                         &ioa_cfg->hostrcb_dma[i],
+                                                         GFP_KERNEL);
 
                 if (!ioa_cfg->hostrcb[i])
                         goto out_free_hostrcb_dma;
@@ -9160,25 +9121,24 @@ out:
 
 out_free_hostrcb_dma:
         while (i-- > 0) {
-                pci_free_consistent(pdev, sizeof(struct ipr_hostrcb),
-                                    ioa_cfg->hostrcb[i],
-                                    ioa_cfg->hostrcb_dma[i]);
+                dma_free_coherent(&pdev->dev, sizeof(struct ipr_hostrcb),
+                                  ioa_cfg->hostrcb[i],
+                                  ioa_cfg->hostrcb_dma[i]);
         }
-        pci_free_consistent(pdev, ioa_cfg->cfg_table_size,
-                            ioa_cfg->u.cfg_table,
-                            ioa_cfg->cfg_table_dma);
+        dma_free_coherent(&pdev->dev, ioa_cfg->cfg_table_size,
+                          ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
 out_free_host_rrq:
         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
-                pci_free_consistent(pdev,
-                                sizeof(u32) * ioa_cfg->hrrq[i].size,
-                                ioa_cfg->hrrq[i].host_rrq,
-                                ioa_cfg->hrrq[i].host_rrq_dma);
+                dma_free_coherent(&pdev->dev,
+                                  sizeof(u32) * ioa_cfg->hrrq[i].size,
+                                  ioa_cfg->hrrq[i].host_rrq,
+                                  ioa_cfg->hrrq[i].host_rrq_dma);
         }
 out_ipr_free_cmd_blocks:
         ipr_free_cmd_blks(ioa_cfg);
 out_free_vpd_cbs:
-        pci_free_consistent(pdev, sizeof(struct ipr_misc_cbs),
-                            ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
+        dma_free_coherent(&pdev->dev, sizeof(struct ipr_misc_cbs),
+                          ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
 out_free_res_entries:
         kfree(ioa_cfg->res_entries);
         goto out;
@@ -9618,16 +9578,17 @@ static int ipr_probe_ioa(struct pci_dev *pdev,
         ipr_init_regs(ioa_cfg);
 
         if (ioa_cfg->sis64) {
-                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
+                rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
                 if (rc < 0) {
-                        dev_dbg(&pdev->dev, "Failed to set 64 bit PCI DMA mask\n");
-                        rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+                        dev_dbg(&pdev->dev, "Failed to set 64 bit DMA mask\n");
+                        rc = dma_set_mask_and_coherent(&pdev->dev,
+                                                       DMA_BIT_MASK(32));
                 }
         } else
-                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+                rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
 
         if (rc < 0) {
-                dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
+                dev_err(&pdev->dev, "Failed to set DMA mask\n");
                 goto cleanup_nomem;
         }
 
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index d0201ceb4aac..9ebdebd944e7 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -1549,7 +1549,7 @@ struct ipr_ioa_cfg {
         struct ipr_misc_cbs *vpd_cbs;
         dma_addr_t vpd_cbs_dma;
 
-        struct pci_pool *ipr_cmd_pool;
+        struct dma_pool *ipr_cmd_pool;
 
         struct ipr_cmnd *reset_cmd;
         int (*reset) (struct ipr_cmnd *);
diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index e5afc3884d74..e5c28435d768 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -1210,7 +1210,7 @@ ips_slave_configure(struct scsi_device * SDptr)
                 min = ha->max_cmds / 2;
                 if (ha->enq->ucLogDriveCount <= 2)
                         min = ha->max_cmds - 1;
-                scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
+                scsi_change_queue_depth(SDptr, min);
         }
 
         SDptr->skip_ms_page_8 = 1;
diff --git a/drivers/scsi/isci/init.c b/drivers/scsi/isci/init.c
index 2e890b1e2526..724c6265b667 100644
--- a/drivers/scsi/isci/init.c
+++ b/drivers/scsi/isci/init.c
@@ -172,6 +172,8 @@ static struct scsi_host_template isci_sht = {
         .target_destroy                 = sas_target_destroy,
         .ioctl                          = sas_ioctl,
         .shost_attrs                    = isci_host_attrs,
+        .use_blk_tags                   = 1,
+        .track_queue_depth              = 1,
 };
 
 static struct sas_domain_function_template isci_transport_ops  = {
@@ -258,8 +260,6 @@ static int isci_register_sas_ha(struct isci_host *isci_host)
         sas_ha->sas_port = sas_ports;
         sas_ha->num_phys = SCI_MAX_PHYS;
 
-        sas_ha->lldd_queue_size = ISCI_CAN_QUEUE_VAL;
-        sas_ha->lldd_max_execute_num = 1;
         sas_ha->strict_wide_ports = 1;
 
         sas_register_ha(sas_ha);
diff --git a/drivers/scsi/isci/task.c b/drivers/scsi/isci/task.c
index 5d6fda72d659..3f63c6318b0d 100644
--- a/drivers/scsi/isci/task.c
+++ b/drivers/scsi/isci/task.c
@@ -117,104 +117,97 @@ static inline int isci_device_io_ready(struct isci_remote_device *idev,
  *    functions. This function is called by libsas to send a task down to
  *    hardware.
  * @task: This parameter specifies the SAS task to send.
- * @num: This parameter specifies the number of tasks to queue.
  * @gfp_flags: This parameter specifies the context of this call.
  *
  * status, zero indicates success.
  */
-int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
+int isci_task_execute_task(struct sas_task *task, gfp_t gfp_flags)
 {
         struct isci_host *ihost = dev_to_ihost(task->dev);
         struct isci_remote_device *idev;
         unsigned long flags;
+        enum sci_status status = SCI_FAILURE;
         bool io_ready;
         u16 tag;
 
-        dev_dbg(&ihost->pdev->dev, "%s: num=%d\n", __func__, num);
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        idev = isci_lookup_device(task->dev);
+        io_ready = isci_device_io_ready(idev, task);
+        tag = isci_alloc_tag(ihost);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
-        for_each_sas_task(num, task) {
-                enum sci_status status = SCI_FAILURE;
+        dev_dbg(&ihost->pdev->dev,
+                "task: %p, dev: %p idev: %p:%#lx cmd = %p\n",
+                task, task->dev, idev, idev ? idev->flags : 0,
+                task->uldd_task);
 
-                spin_lock_irqsave(&ihost->scic_lock, flags);
-                idev = isci_lookup_device(task->dev);
-                io_ready = isci_device_io_ready(idev, task);
-                tag = isci_alloc_tag(ihost);
-                spin_unlock_irqrestore(&ihost->scic_lock, flags);
+        if (!idev) {
+                isci_task_refuse(ihost, task, SAS_TASK_UNDELIVERED,
+                                 SAS_DEVICE_UNKNOWN);
+        } else if (!io_ready || tag == SCI_CONTROLLER_INVALID_IO_TAG) {
+                /* Indicate QUEUE_FULL so that the scsi midlayer
+                 * retries.
+                  */
+                isci_task_refuse(ihost, task, SAS_TASK_COMPLETE,
+                                 SAS_QUEUE_FULL);
+        } else {
+                /* There is a device and it's ready for I/O. */
+                spin_lock_irqsave(&task->task_state_lock, flags);
 
-                dev_dbg(&ihost->pdev->dev,
-                        "task: %p, num: %d dev: %p idev: %p:%#lx cmd = %p\n",
-                        task, num, task->dev, idev, idev ? idev->flags : 0,
-                        task->uldd_task);
-
-                if (!idev) {
-                        isci_task_refuse(ihost, task, SAS_TASK_UNDELIVERED,
-                                         SAS_DEVICE_UNKNOWN);
-                } else if (!io_ready || tag == SCI_CONTROLLER_INVALID_IO_TAG) {
-                        /* Indicate QUEUE_FULL so that the scsi midlayer
-                         * retries.
-                          */
-                        isci_task_refuse(ihost, task, SAS_TASK_COMPLETE,
-                                         SAS_QUEUE_FULL);
+                if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
+                        /* The I/O was aborted. */
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+                        isci_task_refuse(ihost, task,
+                                         SAS_TASK_UNDELIVERED,
+                                         SAM_STAT_TASK_ABORTED);
                 } else {
-                        /* There is a device and it's ready for I/O. */
-                        spin_lock_irqsave(&task->task_state_lock, flags);
-
-                        if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
-                                /* The I/O was aborted. */
-                                spin_unlock_irqrestore(&task->task_state_lock,
-                                                       flags);
-
-                                isci_task_refuse(ihost, task,
-                                                 SAS_TASK_UNDELIVERED,
-                                                 SAM_STAT_TASK_ABORTED);
-                        } else {
-                                task->task_state_flags |= SAS_TASK_AT_INITIATOR;
+                        task->task_state_flags |= SAS_TASK_AT_INITIATOR;
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+                        /* build and send the request. */
+                        status = isci_request_execute(ihost, idev, task, tag);
+
+                        if (status != SCI_SUCCESS) {
+                                spin_lock_irqsave(&task->task_state_lock, flags);
+                                /* Did not really start this command. */
+                                task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
                                 spin_unlock_irqrestore(&task->task_state_lock, flags);
 
-                                /* build and send the request. */
-                                status = isci_request_execute(ihost, idev, task, tag);
-
-                                if (status != SCI_SUCCESS) {
-
-                                        spin_lock_irqsave(&task->task_state_lock, flags);
-                                        /* Did not really start this command. */
-                                        task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
-                                        spin_unlock_irqrestore(&task->task_state_lock, flags);
-
-                                        if (test_bit(IDEV_GONE, &idev->flags)) {
-
-                                                /* Indicate that the device
-                                                 * is gone.
-                                                 */
-                                                isci_task_refuse(ihost, task,
-                                                        SAS_TASK_UNDELIVERED,
-                                                        SAS_DEVICE_UNKNOWN);
-                                        } else {
-                                                /* Indicate QUEUE_FULL so that
-                                                 * the scsi midlayer retries.
-                                                 * If the request failed for
-                                                 * remote device reasons, it
-                                                 * gets returned as
-                                                 * SAS_TASK_UNDELIVERED next
-                                                 * time through.
-                                                 */
-                                                isci_task_refuse(ihost, task,
-                                                        SAS_TASK_COMPLETE,
-                                                        SAS_QUEUE_FULL);
-                                        }
+                                if (test_bit(IDEV_GONE, &idev->flags)) {
+                                        /* Indicate that the device
+                                         * is gone.
+                                         */
+                                        isci_task_refuse(ihost, task,
+                                                SAS_TASK_UNDELIVERED,
+                                                SAS_DEVICE_UNKNOWN);
+                                } else {
+                                        /* Indicate QUEUE_FULL so that
+                                         * the scsi midlayer retries.
+                                         * If the request failed for
+                                         * remote device reasons, it
+                                         * gets returned as
+                                         * SAS_TASK_UNDELIVERED next
+                                         * time through.
+                                         */
+                                        isci_task_refuse(ihost, task,
+                                                SAS_TASK_COMPLETE,
+                                                SAS_QUEUE_FULL);
                                 }
                         }
                 }
-                if (status != SCI_SUCCESS && tag != SCI_CONTROLLER_INVALID_IO_TAG) {
-                        spin_lock_irqsave(&ihost->scic_lock, flags);
-                        /* command never hit the device, so just free
-                         * the tci and skip the sequence increment
-                         */
-                        isci_tci_free(ihost, ISCI_TAG_TCI(tag));
-                        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-                }
-                isci_put_device(idev);
         }
+
+        if (status != SCI_SUCCESS && tag != SCI_CONTROLLER_INVALID_IO_TAG) {
+                spin_lock_irqsave(&ihost->scic_lock, flags);
+                /* command never hit the device, so just free
+                 * the tci and skip the sequence increment
+                 */
+                isci_tci_free(ihost, ISCI_TAG_TCI(tag));
+                spin_unlock_irqrestore(&ihost->scic_lock, flags);
+        }
+
+        isci_put_device(idev);
         return 0;
 }
 
diff --git a/drivers/scsi/isci/task.h b/drivers/scsi/isci/task.h
index 9c06cbad1d26..8f4531f22ac2 100644
--- a/drivers/scsi/isci/task.h
+++ b/drivers/scsi/isci/task.h
@@ -131,7 +131,6 @@ static inline void isci_print_tmf(struct isci_host *ihost, struct isci_tmf *tmf)
 
 int isci_task_execute_task(
         struct sas_task *task,
-        int num,
         gfp_t gfp_flags);
 
 int isci_task_abort_task(
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index 427af0f24b0f..0b8af186e707 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -952,7 +952,7 @@ static struct scsi_host_template iscsi_sw_tcp_sht = {
         .module                 = THIS_MODULE,
         .name                   = "iSCSI Initiator over TCP/IP",
         .queuecommand           = iscsi_queuecommand,
-        .change_queue_depth     = iscsi_change_queue_depth,
+        .change_queue_depth     = scsi_change_queue_depth,
         .can_queue              = ISCSI_DEF_XMIT_CMDS_MAX - 1,
         .sg_tablesize           = 4096,
         .max_sectors            = 0xFFFF,
@@ -966,6 +966,7 @@ static struct scsi_host_template iscsi_sw_tcp_sht = {
         .target_alloc           = iscsi_target_alloc,
         .proc_name              = "iscsi_tcp",
         .this_id                = -1,
+        .track_queue_depth      = 1,
 };
 
 static struct iscsi_transport iscsi_sw_tcp_transport = {
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 1d7e76e8b447..c6795941b45d 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -2160,62 +2160,12 @@ int fc_slave_alloc(struct scsi_device *sdev)
         if (!rport || fc_remote_port_chkready(rport))
                 return -ENXIO;
 
-        if (sdev->tagged_supported)
-                scsi_activate_tcq(sdev, FC_FCP_DFLT_QUEUE_DEPTH);
-        else
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
-                                        FC_FCP_DFLT_QUEUE_DEPTH);
-
+        scsi_change_queue_depth(sdev, FC_FCP_DFLT_QUEUE_DEPTH);
         return 0;
 }
 EXPORT_SYMBOL(fc_slave_alloc);
 
 /**
- * fc_change_queue_depth() - Change a device's queue depth
- * @sdev:   The SCSI device whose queue depth is to change
- * @qdepth: The new queue depth
- * @reason: The resason for the change
- */
-int fc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
-{
-        switch (reason) {
-        case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-                break;
-        case SCSI_QDEPTH_QFULL:
-                scsi_track_queue_full(sdev, qdepth);
-                break;
-        case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-        return sdev->queue_depth;
-}
-EXPORT_SYMBOL(fc_change_queue_depth);
-
-/**
- * fc_change_queue_type() - Change a device's queue type
- * @sdev:     The SCSI device whose queue depth is to change
- * @tag_type: Identifier for queue type
- */
-int fc_change_queue_type(struct scsi_device *sdev, int tag_type)
-{
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, tag_type);
-                if (tag_type)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                tag_type = 0;
-
-        return tag_type;
-}
-EXPORT_SYMBOL(fc_change_queue_type);
-
-/**
  * fc_fcp_destory() - Tear down the FCP layer for a given local port
  * @lport: The local port that no longer needs the FCP layer
  */
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index 0d8bc6c66650..8053f24f0349 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -1771,25 +1771,6 @@ fault:
 }
 EXPORT_SYMBOL_GPL(iscsi_queuecommand);
 
-int iscsi_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
-{
-        switch (reason) {
-        case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
-                break;
-        case SCSI_QDEPTH_QFULL:
-                scsi_track_queue_full(sdev, depth);
-                break;
-        case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-        return sdev->queue_depth;
-}
-EXPORT_SYMBOL_GPL(iscsi_change_queue_depth);
-
 int iscsi_target_alloc(struct scsi_target *starget)
 {
         struct iscsi_cls_session *cls_session = starget_to_session(starget);
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index 766098af4eb7..577770fdee86 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -171,7 +171,6 @@ static void sas_ata_task_done(struct sas_task *task)
         spin_unlock_irqrestore(ap->lock, flags);
 
 qc_already_gone:
-        list_del_init(&task->list);
         sas_free_task(task);
 }
 
@@ -244,12 +243,7 @@ static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
         if (qc->scsicmd)
                 ASSIGN_SAS_TASK(qc->scsicmd, task);
 
-        if (sas_ha->lldd_max_execute_num < 2)
-                ret = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
-        else
-                ret = sas_queue_up(task);
-
-        /* Examine */
+        ret = i->dft->lldd_execute_task(task, GFP_ATOMIC);
         if (ret) {
                 SAS_DPRINTK("lldd_execute_task returned: %d\n", ret);
 
@@ -485,7 +479,6 @@ static void sas_ata_internal_abort(struct sas_task *task)
 
         return;
  out:
-        list_del_init(&task->list);
         sas_free_task(task);
 }
 
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index 0cac7d8fd0f7..022bb6e10d98 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -96,7 +96,7 @@ static int smp_execute_task(struct domain_device *dev, void *req, int req_size,
                 task->slow_task->timer.expires = jiffies + SMP_TIMEOUT*HZ;
                 add_timer(&task->slow_task->timer);
 
-                res = i->dft->lldd_execute_task(task, 1, GFP_KERNEL);
+                res = i->dft->lldd_execute_task(task, GFP_KERNEL);
 
                 if (res) {
                         del_timer(&task->slow_task->timer);
diff --git a/drivers/scsi/libsas/sas_init.c b/drivers/scsi/libsas/sas_init.c
index dbc8a793fd86..362da44f2948 100644
--- a/drivers/scsi/libsas/sas_init.c
+++ b/drivers/scsi/libsas/sas_init.c
@@ -45,7 +45,6 @@ struct sas_task *sas_alloc_task(gfp_t flags)
         struct sas_task *task = kmem_cache_zalloc(sas_task_cache, flags);
 
         if (task) {
-                INIT_LIST_HEAD(&task->list);
                 spin_lock_init(&task->task_state_lock);
                 task->task_state_flags = SAS_TASK_STATE_PENDING;
         }
@@ -77,7 +76,6 @@ EXPORT_SYMBOL_GPL(sas_alloc_slow_task);
 void sas_free_task(struct sas_task *task)
 {
         if (task) {
-                BUG_ON(!list_empty(&task->list));
                 kfree(task->slow_task);
                 kmem_cache_free(sas_task_cache, task);
         }
@@ -127,11 +125,6 @@ int sas_register_ha(struct sas_ha_struct *sas_ha)
         spin_lock_init(&sas_ha->phy_port_lock);
         sas_hash_addr(sas_ha->hashed_sas_addr, sas_ha->sas_addr);
 
-        if (sas_ha->lldd_queue_size == 0)
-                sas_ha->lldd_queue_size = 1;
-        else if (sas_ha->lldd_queue_size == -1)
-                sas_ha->lldd_queue_size = 128; /* Sanity */
-
         set_bit(SAS_HA_REGISTERED, &sas_ha->state);
         spin_lock_init(&sas_ha->lock);
         mutex_init(&sas_ha->drain_mutex);
@@ -157,15 +150,6 @@ int sas_register_ha(struct sas_ha_struct *sas_ha)
                 goto Undo_ports;
         }
 
-        if (sas_ha->lldd_max_execute_num > 1) {
-                error = sas_init_queue(sas_ha);
-                if (error) {
-                        printk(KERN_NOTICE "couldn't start queue thread:%d, "
-                               "running in direct mode\n", error);
-                        sas_ha->lldd_max_execute_num = 1;
-                }
-        }
-
         INIT_LIST_HEAD(&sas_ha->eh_done_q);
         INIT_LIST_HEAD(&sas_ha->eh_ata_q);
 
@@ -201,11 +185,6 @@ int sas_unregister_ha(struct sas_ha_struct *sas_ha)
         __sas_drain_work(sas_ha);
         mutex_unlock(&sas_ha->drain_mutex);
 
-        if (sas_ha->lldd_max_execute_num > 1) {
-                sas_shutdown_queue(sas_ha);
-                sas_ha->lldd_max_execute_num = 1;
-        }
-
         return 0;
 }
 
diff --git a/drivers/scsi/libsas/sas_internal.h b/drivers/scsi/libsas/sas_internal.h
index 7e7ba83f0a21..9cf0bc260b0e 100644
--- a/drivers/scsi/libsas/sas_internal.h
+++ b/drivers/scsi/libsas/sas_internal.h
@@ -66,9 +66,7 @@ void sas_unregister_ports(struct sas_ha_struct *sas_ha);
 
 enum blk_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *);
 
-int  sas_init_queue(struct sas_ha_struct *sas_ha);
 int  sas_init_events(struct sas_ha_struct *sas_ha);
-void sas_shutdown_queue(struct sas_ha_struct *sas_ha);
 void sas_disable_revalidation(struct sas_ha_struct *ha);
 void sas_enable_revalidation(struct sas_ha_struct *ha);
 void __sas_drain_work(struct sas_ha_struct *ha);
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index 24e477d2ea70..72918d227ead 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -112,7 +112,6 @@ static void sas_end_task(struct scsi_cmnd *sc, struct sas_task *task)
 
         sc->result = (hs << 16) | stat;
         ASSIGN_SAS_TASK(sc, NULL);
-        list_del_init(&task->list);
         sas_free_task(task);
 }
 
@@ -138,7 +137,6 @@ static void sas_scsi_task_done(struct sas_task *task)
 
         if (unlikely(!sc)) {
                 SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n");
-                list_del_init(&task->list);
                 sas_free_task(task);
                 return;
         }
@@ -179,31 +177,10 @@ static struct sas_task *sas_create_task(struct scsi_cmnd *cmd,
         return task;
 }
 
-int sas_queue_up(struct sas_task *task)
-{
-        struct sas_ha_struct *sas_ha = task->dev->port->ha;
-        struct scsi_core *core = &sas_ha->core;
-        unsigned long flags;
-        LIST_HEAD(list);
-
-        spin_lock_irqsave(&core->task_queue_lock, flags);
-        if (sas_ha->lldd_queue_size < core->task_queue_size + 1) {
-                spin_unlock_irqrestore(&core->task_queue_lock, flags);
-                return -SAS_QUEUE_FULL;
-        }
-        list_add_tail(&task->list, &core->task_queue);
-        core->task_queue_size += 1;
-        spin_unlock_irqrestore(&core->task_queue_lock, flags);
-        wake_up_process(core->queue_thread);
-
-        return 0;
-}
-
 int sas_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 {
         struct sas_internal *i = to_sas_internal(host->transportt);
         struct domain_device *dev = cmd_to_domain_dev(cmd);
-        struct sas_ha_struct *sas_ha = dev->port->ha;
         struct sas_task *task;
         int res = 0;
 
@@ -224,12 +201,7 @@ int sas_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
         if (!task)
                 return SCSI_MLQUEUE_HOST_BUSY;
 
-        /* Queue up, Direct Mode or Task Collector Mode. */
-        if (sas_ha->lldd_max_execute_num < 2)
-                res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
-        else
-                res = sas_queue_up(task);
-
+        res = i->dft->lldd_execute_task(task, GFP_ATOMIC);
         if (res)
                 goto out_free_task;
         return 0;
@@ -323,37 +295,17 @@ enum task_disposition {
         TASK_IS_DONE,
         TASK_IS_ABORTED,
         TASK_IS_AT_LU,
-        TASK_IS_NOT_AT_HA,
         TASK_IS_NOT_AT_LU,
         TASK_ABORT_FAILED,
 };
 
 static enum task_disposition sas_scsi_find_task(struct sas_task *task)
 {
-        struct sas_ha_struct *ha = task->dev->port->ha;
         unsigned long flags;
         int i, res;
         struct sas_internal *si =
                 to_sas_internal(task->dev->port->ha->core.shost->transportt);
 
-        if (ha->lldd_max_execute_num > 1) {
-                struct scsi_core *core = &ha->core;
-                struct sas_task *t, *n;
-
-                mutex_lock(&core->task_queue_flush);
-                spin_lock_irqsave(&core->task_queue_lock, flags);
-                list_for_each_entry_safe(t, n, &core->task_queue, list)
-                        if (task == t) {
-                                list_del_init(&t->list);
-                                break;
-                        }
-                spin_unlock_irqrestore(&core->task_queue_lock, flags);
-                mutex_unlock(&core->task_queue_flush);
-
-                if (task == t)
-                        return TASK_IS_NOT_AT_HA;
-        }
-
         for (i = 0; i < 5; i++) {
                 SAS_DPRINTK("%s: aborting task 0x%p\n", __func__, task);
                 res = si->dft->lldd_abort_task(task);
@@ -667,14 +619,6 @@ static void sas_eh_handle_sas_errors(struct Scsi_Host *shost, struct list_head *
                 cmd->eh_eflags = 0;
 
                 switch (res) {
-                case TASK_IS_NOT_AT_HA:
-                        SAS_DPRINTK("%s: task 0x%p is not at ha: %s\n",
-                                    __func__, task,
-                                    cmd->retries ? "retry" : "aborted");
-                        if (cmd->retries)
-                                cmd->retries--;
-                        sas_eh_finish_cmd(cmd);
-                        continue;
                 case TASK_IS_DONE:
                         SAS_DPRINTK("%s: task 0x%p is done\n", __func__,
                                     task);
@@ -836,9 +780,6 @@ retry:
                 scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q);
 
 out:
-        if (ha->lldd_max_execute_num > 1)
-                wake_up_process(ha->core.queue_thread);
-
         sas_eh_handle_resets(shost);
 
         /* now link into libata eh --- if we have any ata devices */
@@ -940,15 +881,12 @@ int sas_slave_configure(struct scsi_device *scsi_dev)
         sas_read_port_mode_page(scsi_dev);
 
         if (scsi_dev->tagged_supported) {
-                scsi_set_tag_type(scsi_dev, MSG_SIMPLE_TAG);
-                scsi_activate_tcq(scsi_dev, SAS_DEF_QD);
+                scsi_change_queue_depth(scsi_dev, SAS_DEF_QD);
         } else {
                 SAS_DPRINTK("device %llx, LUN %llx doesn't support "
                             "TCQ\n", SAS_ADDR(dev->sas_addr),
                             scsi_dev->lun);
-                scsi_dev->tagged_supported = 0;
-                scsi_set_tag_type(scsi_dev, 0);
-                scsi_deactivate_tcq(scsi_dev, 1);
+                scsi_change_queue_depth(scsi_dev, 1);
         }
 
         scsi_dev->allow_restart = 1;
@@ -956,47 +894,23 @@ int sas_slave_configure(struct scsi_device *scsi_dev)
         return 0;
 }
 
-int sas_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
+int sas_change_queue_depth(struct scsi_device *sdev, int depth)
 {
         struct domain_device *dev = sdev_to_domain_dev(sdev);
 
         if (dev_is_sata(dev))
-                return __ata_change_queue_depth(dev->sata_dev.ap, sdev, depth,
-                                                reason);
-
-        switch (reason) {
-        case SCSI_QDEPTH_DEFAULT:
-        case SCSI_QDEPTH_RAMP_UP:
-                if (!sdev->tagged_supported)
-                        depth = 1;
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
-                break;
-        case SCSI_QDEPTH_QFULL:
-                scsi_track_queue_full(sdev, depth);
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
+                return __ata_change_queue_depth(dev->sata_dev.ap, sdev, depth);
 
-        return depth;
+        if (!sdev->tagged_supported)
+                depth = 1;
+        return scsi_change_queue_depth(sdev, depth);
 }
 
-int sas_change_queue_type(struct scsi_device *scsi_dev, int qt)
+int sas_change_queue_type(struct scsi_device *scsi_dev, int type)
 {
-        struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
-
-        if (dev_is_sata(dev))
+        if (dev_is_sata(sdev_to_domain_dev(scsi_dev)))
                 return -EINVAL;
-
-        if (!scsi_dev->tagged_supported)
-                return 0;
-
-        scsi_deactivate_tcq(scsi_dev, 1);
-
-        scsi_set_tag_type(scsi_dev, qt);
-        scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
-
-        return qt;
+        return scsi_change_queue_type(scsi_dev, type);
 }
 
 int sas_bios_param(struct scsi_device *scsi_dev,
@@ -1011,121 +925,6 @@ int sas_bios_param(struct scsi_device *scsi_dev,
         return 0;
 }
 
-/* ---------- Task Collector Thread implementation ---------- */
-
-static void sas_queue(struct sas_ha_struct *sas_ha)
-{
-        struct scsi_core *core = &sas_ha->core;
-        unsigned long flags;
-        LIST_HEAD(q);
-        int can_queue;
-        int res;
-        struct sas_internal *i = to_sas_internal(core->shost->transportt);
-
-        mutex_lock(&core->task_queue_flush);
-        spin_lock_irqsave(&core->task_queue_lock, flags);
-        while (!kthread_should_stop() &&
-               !list_empty(&core->task_queue) &&
-               !test_bit(SAS_HA_FROZEN, &sas_ha->state)) {
-
-                can_queue = sas_ha->lldd_queue_size - core->task_queue_size;
-                if (can_queue >= 0) {
-                        can_queue = core->task_queue_size;
-                        list_splice_init(&core->task_queue, &q);
-                } else {
-                        struct list_head *a, *n;
-
-                        can_queue = sas_ha->lldd_queue_size;
-                        list_for_each_safe(a, n, &core->task_queue) {
-                                list_move_tail(a, &q);
-                                if (--can_queue == 0)
-                                        break;
-                        }
-                        can_queue = sas_ha->lldd_queue_size;
-                }
-                core->task_queue_size -= can_queue;
-                spin_unlock_irqrestore(&core->task_queue_lock, flags);
-                {
-                        struct sas_task *task = list_entry(q.next,
-                                                           struct sas_task,
-                                                           list);
-                        list_del_init(&q);
-                        res = i->dft->lldd_execute_task(task, can_queue,
-                                                        GFP_KERNEL);
-                        if (unlikely(res))
-                                __list_add(&q, task->list.prev, &task->list);
-                }
-                spin_lock_irqsave(&core->task_queue_lock, flags);
-                if (res) {
-                        list_splice_init(&q, &core->task_queue); /*at head*/
-                        core->task_queue_size += can_queue;
-                }
-        }
-        spin_unlock_irqrestore(&core->task_queue_lock, flags);
-        mutex_unlock(&core->task_queue_flush);
-}
-
-/**
- * sas_queue_thread -- The Task Collector thread
- * @_sas_ha: pointer to struct sas_ha
- */
-static int sas_queue_thread(void *_sas_ha)
-{
-        struct sas_ha_struct *sas_ha = _sas_ha;
-
-        while (1) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                schedule();
-                sas_queue(sas_ha);
-                if (kthread_should_stop())
-                        break;
-        }
-
-        return 0;
-}
-
-int sas_init_queue(struct sas_ha_struct *sas_ha)
-{
-        struct scsi_core *core = &sas_ha->core;
-
-        spin_lock_init(&core->task_queue_lock);
-        mutex_init(&core->task_queue_flush);
-        core->task_queue_size = 0;
-        INIT_LIST_HEAD(&core->task_queue);
-
-        core->queue_thread = kthread_run(sas_queue_thread, sas_ha,
-                                         "sas_queue_%d", core->shost->host_no);
-        if (IS_ERR(core->queue_thread))
-                return PTR_ERR(core->queue_thread);
-        return 0;
-}
-
-void sas_shutdown_queue(struct sas_ha_struct *sas_ha)
-{
-        unsigned long flags;
-        struct scsi_core *core = &sas_ha->core;
-        struct sas_task *task, *n;
-
-        kthread_stop(core->queue_thread);
-
-        if (!list_empty(&core->task_queue))
-                SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n",
-                            SAS_ADDR(sas_ha->sas_addr));
-
-        spin_lock_irqsave(&core->task_queue_lock, flags);
-        list_for_each_entry_safe(task, n, &core->task_queue, list) {
-                struct scsi_cmnd *cmd = task->uldd_task;
-
-                list_del_init(&task->list);
-
-                ASSIGN_SAS_TASK(cmd, NULL);
-                sas_free_task(task);
-                cmd->result = DID_ABORT << 16;
-                cmd->scsi_done(cmd);
-        }
-        spin_unlock_irqrestore(&core->task_queue_lock, flags);
-}
-
 /*
  * Tell an upper layer that it needs to initiate an abort for a given task.
  * This should only ever be called by an LLDD.
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index 786a2aff7b59..5633e7dadc08 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -968,8 +968,8 @@ lpfc_debugfs_dumpDif_open(struct inode *inode, struct file *file)
                 goto out;
 
         /* Round to page boundary */
-        printk(KERN_ERR "9060 BLKGRD: %s: _dump_buf_dif=0x%p file=%s\n",
-                __func__, _dump_buf_dif, file->f_dentry->d_name.name);
+        printk(KERN_ERR "9060 BLKGRD: %s: _dump_buf_dif=0x%p file=%pD\n",
+                __func__, _dump_buf_dif, file);
         debug->buffer = _dump_buf_dif;
         if (!debug->buffer) {
                 kfree(debug);
@@ -1011,7 +1011,7 @@ static ssize_t
 lpfc_debugfs_dif_err_read(struct file *file, char __user *buf,
         size_t nbytes, loff_t *ppos)
 {
-        struct dentry *dent = file->f_dentry;
+        struct dentry *dent = file->f_path.dentry;
         struct lpfc_hba *phba = file->private_data;
         char cbuf[32];
         uint64_t tmp = 0;
@@ -1052,7 +1052,7 @@ static ssize_t
 lpfc_debugfs_dif_err_write(struct file *file, const char __user *buf,
         size_t nbytes, loff_t *ppos)
 {
-        struct dentry *dent = file->f_dentry;
+        struct dentry *dent = file->f_path.dentry;
         struct lpfc_hba *phba = file->private_data;
         char dstbuf[32];
         uint64_t tmp = 0;
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index b99399fe2548..fd85952b621d 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -243,128 +243,6 @@ lpfc_update_stats(struct lpfc_hba *phba, struct  lpfc_scsi_buf *lpfc_cmd)
 }
 
 /**
- * lpfc_send_sdev_queuedepth_change_event - Posts a queuedepth change event
- * @phba: Pointer to HBA context object.
- * @vport: Pointer to vport object.
- * @ndlp: Pointer to FC node associated with the target.
- * @lun: Lun number of the scsi device.
- * @old_val: Old value of the queue depth.
- * @new_val: New value of the queue depth.
- *
- * This function sends an event to the mgmt application indicating
- * there is a change in the scsi device queue depth.
- **/
-static void
-lpfc_send_sdev_queuedepth_change_event(struct lpfc_hba *phba,
-                struct lpfc_vport  *vport,
-                struct lpfc_nodelist *ndlp,
-                uint64_t lun,
-                uint32_t old_val,
-                uint32_t new_val)
-{
-        struct lpfc_fast_path_event *fast_path_evt;
-        unsigned long flags;
-
-        fast_path_evt = lpfc_alloc_fast_evt(phba);
-        if (!fast_path_evt)
-                return;
-
-        fast_path_evt->un.queue_depth_evt.scsi_event.event_type =
-                FC_REG_SCSI_EVENT;
-        fast_path_evt->un.queue_depth_evt.scsi_event.subcategory =
-                LPFC_EVENT_VARQUEDEPTH;
-
-        /* Report all luns with change in queue depth */
-        fast_path_evt->un.queue_depth_evt.scsi_event.lun = lun;
-        if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
-                memcpy(&fast_path_evt->un.queue_depth_evt.scsi_event.wwpn,
-                        &ndlp->nlp_portname, sizeof(struct lpfc_name));
-                memcpy(&fast_path_evt->un.queue_depth_evt.scsi_event.wwnn,
-                        &ndlp->nlp_nodename, sizeof(struct lpfc_name));
-        }
-
-        fast_path_evt->un.queue_depth_evt.oldval = old_val;
-        fast_path_evt->un.queue_depth_evt.newval = new_val;
-        fast_path_evt->vport = vport;
-
-        fast_path_evt->work_evt.evt = LPFC_EVT_FASTPATH_MGMT_EVT;
-        spin_lock_irqsave(&phba->hbalock, flags);
-        list_add_tail(&fast_path_evt->work_evt.evt_listp, &phba->work_list);
-        spin_unlock_irqrestore(&phba->hbalock, flags);
-        lpfc_worker_wake_up(phba);
-
-        return;
-}
-
-/**
- * lpfc_change_queue_depth - Alter scsi device queue depth
- * @sdev: Pointer the scsi device on which to change the queue depth.
- * @qdepth: New queue depth to set the sdev to.
- * @reason: The reason for the queue depth change.
- *
- * This function is called by the midlayer and the LLD to alter the queue
- * depth for a scsi device. This function sets the queue depth to the new
- * value and sends an event out to log the queue depth change.
- **/
-static int
-lpfc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
-{
-        struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
-        struct lpfc_hba   *phba = vport->phba;
-        struct lpfc_rport_data *rdata;
-        unsigned long new_queue_depth, old_queue_depth;
-
-        old_queue_depth = sdev->queue_depth;
-
-        switch (reason) {
-        case SCSI_QDEPTH_DEFAULT:
-                /* change request from sysfs, fall through */
-        case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-                break;
-        case SCSI_QDEPTH_QFULL:
-                if (scsi_track_queue_full(sdev, qdepth) == 0)
-                        return sdev->queue_depth;
-
-                lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
-                                 "0711 detected queue full - lun queue "
-                                 "depth adjusted to %d.\n", sdev->queue_depth);
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-
-        new_queue_depth = sdev->queue_depth;
-        rdata = lpfc_rport_data_from_scsi_device(sdev);
-        if (rdata)
-                lpfc_send_sdev_queuedepth_change_event(phba, vport,
-                                                       rdata->pnode, sdev->lun,
-                                                       old_queue_depth,
-                                                       new_queue_depth);
-        return sdev->queue_depth;
-}
-
-/**
- * lpfc_change_queue_type() - Change a device's scsi tag queuing type
- * @sdev: Pointer the scsi device whose queue depth is to change
- * @tag_type: Identifier for queue tag type
- */
-static int
-lpfc_change_queue_type(struct scsi_device *sdev, int tag_type)
-{
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, tag_type);
-                if (tag_type)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                tag_type = 0;
-
-        return tag_type;
-}
-
-/**
  * lpfc_rampdown_queue_depth - Post RAMP_DOWN_QUEUE event to worker thread
  * @phba: The Hba for which this call is being executed.
  *
@@ -449,8 +327,7 @@ lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
                                 else
                                         new_queue_depth = sdev->queue_depth -
                                                                 new_queue_depth;
-                                lpfc_change_queue_depth(sdev, new_queue_depth,
-                                                        SCSI_QDEPTH_DEFAULT);
+                                scsi_change_queue_depth(sdev, new_queue_depth);
                         }
                 }
         lpfc_destroy_vport_work_array(phba, vports);
@@ -4286,7 +4163,6 @@ lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
         struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
         int datadir = scsi_cmnd->sc_data_direction;
-        char tag[2];
         uint8_t *ptr;
         bool sli4;
         uint32_t fcpdl;
@@ -4308,20 +4184,7 @@ lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
                 memset(ptr, 0, (LPFC_FCP_CDB_LEN - scsi_cmnd->cmd_len));
         }
 
-        if (scsi_populate_tag_msg(scsi_cmnd, tag)) {
-                switch (tag[0]) {
-                case HEAD_OF_QUEUE_TAG:
-                        fcp_cmnd->fcpCntl1 = HEAD_OF_Q;
-                        break;
-                case ORDERED_QUEUE_TAG:
-                        fcp_cmnd->fcpCntl1 = ORDERED_Q;
-                        break;
-                default:
-                        fcp_cmnd->fcpCntl1 = SIMPLE_Q;
-                        break;
-                }
-        } else
-                fcp_cmnd->fcpCntl1 = SIMPLE_Q;
+        fcp_cmnd->fcpCntl1 = SIMPLE_Q;
 
         sli4 = (phba->sli_rev == LPFC_SLI_REV4);
         piocbq->iocb.un.fcpi.fcpi_XRdy = 0;
@@ -5632,10 +5495,7 @@ lpfc_slave_configure(struct scsi_device *sdev)
         struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
-        if (sdev->tagged_supported)
-                scsi_activate_tcq(sdev, vport->cfg_lun_queue_depth);
-        else
-                scsi_deactivate_tcq(sdev, vport->cfg_lun_queue_depth);
+        scsi_change_queue_depth(sdev, vport->cfg_lun_queue_depth);
 
         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
                 lpfc_sli_handle_fast_ring_event(phba,
@@ -6018,8 +5878,10 @@ struct scsi_host_template lpfc_template = {
         .shost_attrs            = lpfc_hba_attrs,
         .max_sectors            = 0xFFFF,
         .vendor_id              = LPFC_NL_VENDOR_ID,
-        .change_queue_depth     = lpfc_change_queue_depth,
-        .change_queue_type      = lpfc_change_queue_type,
+        .change_queue_depth     = scsi_change_queue_depth,
+        .change_queue_type      = scsi_change_queue_type,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
 
 struct scsi_host_template lpfc_vport_template = {
@@ -6041,6 +5903,8 @@ struct scsi_host_template lpfc_vport_template = {
         .use_clustering         = ENABLE_CLUSTERING,
         .shost_attrs            = lpfc_vport_attrs,
         .max_sectors            = 0xFFFF,
-        .change_queue_depth     = lpfc_change_queue_depth,
-        .change_queue_type      = lpfc_change_queue_type,
+        .change_queue_depth     = scsi_change_queue_depth,
+        .change_queue_type      = scsi_change_queue_type,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
diff --git a/drivers/scsi/mac_scsi.c b/drivers/scsi/mac_scsi.c
index 6a039eb1cbce..953fd9b953c7 100644
--- a/drivers/scsi/mac_scsi.c
+++ b/drivers/scsi/mac_scsi.c
@@ -9,69 +9,62 @@
  * Generic Generic NCR5380 driver
  *
  * Copyright 1995, Russell King
- *
- * ALPHA RELEASE 1.
- *
- * For more information, please consult
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 #include <linux/types.h>
-#include <linux/stddef.h>
-#include <linux/ctype.h>
 #include <linux/delay.h>
-
 #include <linux/module.h>
-#include <linux/signal.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/interrupt.h>
+#include <linux/platform_device.h>
 
+#include <asm/hwtest.h>
 #include <asm/io.h>
-#include <asm/irq.h>
-
-#include <asm/macintosh.h>
 #include <asm/macints.h>
-#include <asm/mac_via.h>
+#include <asm/setup.h>
 
-#include "scsi.h"
 #include <scsi/scsi_host.h>
-#include "mac_scsi.h"
 
-/* These control the behaviour of the generic 5380 core */
-#define AUTOSENSE
+/* Definitions for the core NCR5380 driver. */
+
 #define PSEUDO_DMA
 
-#include "NCR5380.h"
+#define NCR5380_implementation_fields   unsigned char *pdma_base
+#define NCR5380_local_declare()         struct Scsi_Host *_instance
+#define NCR5380_setup(instance)         _instance = instance
 
-#define RESET_BOOT
-#define DRIVER_SETUP
+#define NCR5380_read(reg)               macscsi_read(_instance, reg)
+#define NCR5380_write(reg, value)       macscsi_write(_instance, reg, value)
 
-extern void via_scsi_clear(void);
+#define NCR5380_pread                   macscsi_pread
+#define NCR5380_pwrite                  macscsi_pwrite
 
-#ifdef RESET_BOOT
-static void mac_scsi_reset_boot(struct Scsi_Host *instance);
-#endif
+#define NCR5380_intr                    macscsi_intr
+#define NCR5380_queue_command           macscsi_queue_command
+#define NCR5380_abort                   macscsi_abort
+#define NCR5380_bus_reset               macscsi_bus_reset
+#define NCR5380_info                    macscsi_info
+#define NCR5380_show_info               macscsi_show_info
+#define NCR5380_write_info              macscsi_write_info
+
+#include "NCR5380.h"
+
+#define RESET_BOOT
 
-static int setup_called = 0;
 static int setup_can_queue = -1;
+module_param(setup_can_queue, int, 0);
 static int setup_cmd_per_lun = -1;
+module_param(setup_cmd_per_lun, int, 0);
 static int setup_sg_tablesize = -1;
+module_param(setup_sg_tablesize, int, 0);
 static int setup_use_pdma = -1;
-#ifdef SUPPORT_TAGS
+module_param(setup_use_pdma, int, 0);
 static int setup_use_tagged_queuing = -1;
-#endif
+module_param(setup_use_tagged_queuing, int, 0);
 static int setup_hostid = -1;
+module_param(setup_hostid, int, 0);
 
 /* Time (in jiffies) to wait after a reset; the SCSI standard calls for 250ms,
  * we usually do 0.5s to be on the safe side. But Toshiba CD-ROMs once more
@@ -84,232 +77,48 @@ static int setup_hostid = -1;
 #define AFTER_RESET_DELAY       (HZ/2)
 #endif
 
-static volatile unsigned char *mac_scsi_regp = NULL;
-static volatile unsigned char *mac_scsi_drq  = NULL;
-static volatile unsigned char *mac_scsi_nodrq = NULL;
-
-
 /*
  * NCR 5380 register access functions
  */
 
-#if 0
-/* Debug versions */
-#define CTRL(p,v) (*ctrl = (v))
-
-static char macscsi_read(struct Scsi_Host *instance, int reg)
+static inline char macscsi_read(struct Scsi_Host *instance, int reg)
 {
-  int iobase = instance->io_port;
-  int i;
-  int *ctrl = &((struct NCR5380_hostdata *)instance->hostdata)->ctrl;
-
-  CTRL(iobase, 0);
-  i = in_8(iobase + (reg<<4));
-  CTRL(iobase, 0x40);
-
-  return i;
+        return in_8(instance->base + (reg << 4));
 }
 
-static void macscsi_write(struct Scsi_Host *instance, int reg, int value)
-{
-  int iobase = instance->io_port;
-  int *ctrl = &((struct NCR5380_hostdata *)instance->hostdata)->ctrl;
-
-  CTRL(iobase, 0);
-  out_8(iobase + (reg<<4), value);
-  CTRL(iobase, 0x40);
-}
-#else
-
-/* Fast versions */
-static __inline__ char macscsi_read(struct Scsi_Host *instance, int reg)
+static inline void macscsi_write(struct Scsi_Host *instance, int reg, int value)
 {
-  return in_8(instance->io_port + (reg<<4));
+        out_8(instance->base + (reg << 4), value);
 }
 
-static __inline__ void macscsi_write(struct Scsi_Host *instance, int reg, int value)
+#ifndef MODULE
+static int __init mac_scsi_setup(char *str)
 {
-  out_8(instance->io_port + (reg<<4), value);
-}
-#endif
-
+        int ints[7];
 
-/*
- * Function : mac_scsi_setup(char *str)
- *
- * Purpose : booter command line initialization of the overrides array,
- *
- * Inputs : str - comma delimited list of options
- *
- */
+        (void)get_options(str, ARRAY_SIZE(ints), ints);
 
-static int __init mac_scsi_setup(char *str) {
-#ifdef DRIVER_SETUP     
-        int ints[7];
-        
-        (void)get_options( str, ARRAY_SIZE(ints), ints);
-        
-        if (setup_called++ || ints[0] < 1 || ints[0] > 6) {
-            printk(KERN_WARNING "scsi: <mac5380>"
-                " Usage: mac5380=<can_queue>[,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>,<use_pdma>]\n");
-            printk(KERN_ALERT "scsi: <mac5380> Bad Penguin parameters?\n");
-            return 0;
-        }
-            
-        if (ints[0] >= 1) {
-                if (ints[1] > 0)
-                        /* no limits on this, just > 0 */
-                        setup_can_queue = ints[1];
-        }
-        if (ints[0] >= 2) {
-                if (ints[2] > 0)
-                        setup_cmd_per_lun = ints[2];
-        }
-        if (ints[0] >= 3) {
-                if (ints[3] >= 0) {
-                        setup_sg_tablesize = ints[3];
-                        /* Must be <= SG_ALL (255) */
-                        if (setup_sg_tablesize > SG_ALL)
-                                setup_sg_tablesize = SG_ALL;
-                }
-        }
-        if (ints[0] >= 4) {
-                /* Must be between 0 and 7 */
-                if (ints[4] >= 0 && ints[4] <= 7)
-                        setup_hostid = ints[4];
-                else if (ints[4] > 7)
-                        printk(KERN_WARNING "mac_scsi_setup: invalid host ID %d !\n", ints[4] );
-        }
-#ifdef SUPPORT_TAGS     
-        if (ints[0] >= 5) {
-                if (ints[5] >= 0)
-                        setup_use_tagged_queuing = !!ints[5];
+        if (ints[0] < 1 || ints[0] > 6) {
+                pr_err("Usage: mac5380=<can_queue>[,<cmd_per_lun>[,<sg_tablesize>[,<hostid>[,<use_tags>[,<use_pdma>]]]]]\n");
+                return 0;
         }
-        
-        if (ints[0] == 6) {
-            if (ints[6] >= 0)
+        if (ints[0] >= 1)
+                setup_can_queue = ints[1];
+        if (ints[0] >= 2)
+                setup_cmd_per_lun = ints[2];
+        if (ints[0] >= 3)
+                setup_sg_tablesize = ints[3];
+        if (ints[0] >= 4)
+                setup_hostid = ints[4];
+        if (ints[0] >= 5)
+                setup_use_tagged_queuing = ints[5];
+        if (ints[0] >= 6)
                 setup_use_pdma = ints[6];
-        }
-#else
-        if (ints[0] == 5) {
-            if (ints[5] >= 0)
-                setup_use_pdma = ints[5];
-        }
-#endif /* SUPPORT_TAGS */
-        
-#endif /* DRIVER_SETUP */
         return 1;
 }
 
 __setup("mac5380=", mac_scsi_setup);
-
-/*
- * Function : int macscsi_detect(struct scsi_host_template * tpnt)
- *
- * Purpose : initializes mac NCR5380 driver based on the
- *      command line / compile time port and irq definitions.
- *
- * Inputs : tpnt - template for this SCSI adapter.
- *
- * Returns : 1 if a host adapter was found, 0 if not.
- *
- */
- 
-int __init macscsi_detect(struct scsi_host_template * tpnt)
-{
-    static int called = 0;
-    int flags = 0;
-    struct Scsi_Host *instance;
-
-    if (!MACH_IS_MAC || called)
-        return( 0 );
-
-    if (macintosh_config->scsi_type != MAC_SCSI_OLD)
-        return( 0 );
-
-    /* setup variables */
-    tpnt->can_queue =
-        (setup_can_queue > 0) ? setup_can_queue : CAN_QUEUE;
-    tpnt->cmd_per_lun =
-        (setup_cmd_per_lun > 0) ? setup_cmd_per_lun : CMD_PER_LUN;
-    tpnt->sg_tablesize = 
-        (setup_sg_tablesize >= 0) ? setup_sg_tablesize : SG_TABLESIZE;
-
-    if (setup_hostid >= 0)
-        tpnt->this_id = setup_hostid;
-    else {
-        /* use 7 as default */
-        tpnt->this_id = 7;
-    }
-
-#ifdef SUPPORT_TAGS
-    if (setup_use_tagged_queuing < 0)
-        setup_use_tagged_queuing = USE_TAGGED_QUEUING;
-#endif
-
-    /* Once we support multiple 5380s (e.g. DuoDock) we'll do
-       something different here */
-    instance = scsi_register (tpnt, sizeof(struct NCR5380_hostdata));
-    if (instance == NULL)
-        return 0;
-
-    if (macintosh_config->ident == MAC_MODEL_IIFX) {
-        mac_scsi_regp  = via1+0x8000;
-        mac_scsi_drq   = via1+0xE000;
-        mac_scsi_nodrq = via1+0xC000;
-        /* The IIFX should be able to do true DMA, but pseudo-dma doesn't work */
-        flags = FLAG_NO_PSEUDO_DMA;
-    } else {
-        mac_scsi_regp  = via1+0x10000;
-        mac_scsi_drq   = via1+0x6000;
-        mac_scsi_nodrq = via1+0x12000;
-    }
-
-    if (! setup_use_pdma)
-        flags = FLAG_NO_PSEUDO_DMA;
-        
-    instance->io_port = (unsigned long) mac_scsi_regp;
-    instance->irq = IRQ_MAC_SCSI;
-
-#ifdef RESET_BOOT   
-    mac_scsi_reset_boot(instance);
-#endif
-    
-    NCR5380_init(instance, flags);
-
-    instance->n_io_port = 255;
-
-    ((struct NCR5380_hostdata *)instance->hostdata)->ctrl = 0;
-
-    if (instance->irq != SCSI_IRQ_NONE)
-        if (request_irq(instance->irq, NCR5380_intr, 0, "ncr5380", instance)) {
-            printk(KERN_WARNING "scsi%d: IRQ%d not free, interrupts disabled\n",
-                   instance->host_no, instance->irq);
-            instance->irq = SCSI_IRQ_NONE;
-        }
-
-    printk(KERN_INFO "scsi%d: generic 5380 at port %lX irq", instance->host_no, instance->io_port);
-    if (instance->irq == SCSI_IRQ_NONE)
-        printk (KERN_INFO "s disabled");
-    else
-        printk (KERN_INFO " %d", instance->irq);
-    printk(KERN_INFO " options CAN_QUEUE=%d CMD_PER_LUN=%d release=%d",
-           instance->can_queue, instance->cmd_per_lun, MACSCSI_PUBLIC_RELEASE);
-    printk(KERN_INFO "\nscsi%d:", instance->host_no);
-    NCR5380_print_options(instance);
-    printk("\n");
-    called = 1;
-    return 1;
-}
-
-int macscsi_release (struct Scsi_Host *shpnt)
-{
-        if (shpnt->irq != SCSI_IRQ_NONE)
-                free_irq(shpnt->irq, shpnt);
-        NCR5380_exit(shpnt);
-
-        return 0;
-}
+#endif /* !MODULE */
 
 #ifdef RESET_BOOT
 /*
@@ -349,10 +158,7 @@ static void mac_scsi_reset_boot(struct Scsi_Host *instance)
 }
 #endif
 
-const char * macscsi_info (struct Scsi_Host *spnt) {
-        return "";
-}
-
+#ifdef PSEUDO_DMA
 /* 
    Pseudo-DMA: (Ove Edlund)
    The code attempts to catch bus errors that occur if one for example
@@ -422,38 +228,39 @@ __asm__ __volatile__					\
      : "0"(s), "1"(d), "2"(len)                         \
      : "d0")
 
-
-static int macscsi_pread (struct Scsi_Host *instance,
-                          unsigned char *dst, int len)
+static int macscsi_pread(struct Scsi_Host *instance,
+                         unsigned char *dst, int len)
 {
-   unsigned char *d;
-   volatile unsigned char *s;
-
-   NCR5380_local_declare();
-   NCR5380_setup(instance);
-
-   s = mac_scsi_drq+0x60;
-   d = dst;
-
-/* These conditions are derived from MacOS */
-
-   while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ) 
-         && !(NCR5380_read(STATUS_REG) & SR_REQ))
-      ;
-   if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ) 
-         && (NCR5380_read(BUS_AND_STATUS_REG) & BASR_PHASE_MATCH)) {
-      printk(KERN_ERR "Error in macscsi_pread\n");
-      return -1;
-   }
-
-   CP_IO_TO_MEM(s, d, len);
-   
-   if (len != 0) {
-      printk(KERN_NOTICE "Bus error in macscsi_pread\n");
-      return -1;
-   }
-   
-   return 0;
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+        unsigned char *d;
+        unsigned char *s;
+
+        NCR5380_local_declare();
+        NCR5380_setup(instance);
+
+        s = hostdata->pdma_base + (INPUT_DATA_REG << 4);
+        d = dst;
+
+        /* These conditions are derived from MacOS */
+
+        while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ) &&
+               !(NCR5380_read(STATUS_REG) & SR_REQ))
+                ;
+
+        if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ) &&
+            (NCR5380_read(BUS_AND_STATUS_REG) & BASR_PHASE_MATCH)) {
+                pr_err("Error in macscsi_pread\n");
+                return -1;
+        }
+
+        CP_IO_TO_MEM(s, d, len);
+
+        if (len != 0) {
+                pr_notice("Bus error in macscsi_pread\n");
+                return -1;
+        }
+
+        return 0;
 }
 
 
@@ -515,59 +322,172 @@ __asm__ __volatile__					\
      : "0"(s), "1"(d), "2"(len)                         \
      : "d0")
 
-static int macscsi_pwrite (struct Scsi_Host *instance,
-                                  unsigned char *src, int len)
+static int macscsi_pwrite(struct Scsi_Host *instance,
+                          unsigned char *src, int len)
 {
-   unsigned char *s;
-   volatile unsigned char *d;
-
-   NCR5380_local_declare();
-   NCR5380_setup(instance);
-
-   s = src;
-   d = mac_scsi_drq;
-   
-/* These conditions are derived from MacOS */
-
-   while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ) 
-         && (!(NCR5380_read(STATUS_REG) & SR_REQ) 
-            || (NCR5380_read(BUS_AND_STATUS_REG) & BASR_PHASE_MATCH))) 
-      ;
-   if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ)) {
-      printk(KERN_ERR "Error in macscsi_pwrite\n");
-      return -1;
-   }
-
-   CP_MEM_TO_IO(s, d, len);   
-
-   if (len != 0) {
-      printk(KERN_NOTICE "Bus error in macscsi_pwrite\n");
-      return -1;
-   }
-   
-   return 0;
-}
+        struct NCR5380_hostdata *hostdata = shost_priv(instance);
+        unsigned char *s;
+        unsigned char *d;
+
+        NCR5380_local_declare();
+        NCR5380_setup(instance);
+
+        s = src;
+        d = hostdata->pdma_base + (OUTPUT_DATA_REG << 4);
+
+        /* These conditions are derived from MacOS */
+
+        while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ) &&
+               (!(NCR5380_read(STATUS_REG) & SR_REQ) ||
+                (NCR5380_read(BUS_AND_STATUS_REG) & BASR_PHASE_MATCH)))
+                ;
+
+        if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ)) {
+                pr_err("Error in macscsi_pwrite\n");
+                return -1;
+        }
+
+        CP_MEM_TO_IO(s, d, len);
+
+        if (len != 0) {
+                pr_notice("Bus error in macscsi_pwrite\n");
+                return -1;
+        }
 
+        return 0;
+}
+#endif
 
 #include "NCR5380.c"
 
-static struct scsi_host_template driver_template = {
-        .proc_name                      = "Mac5380",
+#define DRV_MODULE_NAME         "mac_scsi"
+#define PFX                     DRV_MODULE_NAME ": "
+
+static struct scsi_host_template mac_scsi_template = {
+        .module                         = THIS_MODULE,
+        .proc_name                      = DRV_MODULE_NAME,
         .show_info                      = macscsi_show_info,
         .write_info                     = macscsi_write_info,
         .name                           = "Macintosh NCR5380 SCSI",
-        .detect                         = macscsi_detect,
-        .release                        = macscsi_release,
         .info                           = macscsi_info,
         .queuecommand                   = macscsi_queue_command,
         .eh_abort_handler               = macscsi_abort,
         .eh_bus_reset_handler           = macscsi_bus_reset,
-        .can_queue                      = CAN_QUEUE,
+        .can_queue                      = 16,
         .this_id                        = 7,
         .sg_tablesize                   = SG_ALL,
-        .cmd_per_lun                    = CMD_PER_LUN,
+        .cmd_per_lun                    = 2,
         .use_clustering                 = DISABLE_CLUSTERING
 };
 
+static int __init mac_scsi_probe(struct platform_device *pdev)
+{
+        struct Scsi_Host *instance;
+        int error;
+        int host_flags = 0;
+        struct resource *irq, *pio_mem, *pdma_mem = NULL;
+
+        pio_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!pio_mem)
+                return -ENODEV;
+
+#ifdef PSEUDO_DMA
+        pdma_mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+#endif
+
+        irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+
+        if (!hwreg_present((unsigned char *)pio_mem->start +
+                           (STATUS_REG << 4))) {
+                pr_info(PFX "no device detected at %pap\n", &pio_mem->start);
+                return -ENODEV;
+        }
+
+        if (setup_can_queue > 0)
+                mac_scsi_template.can_queue = setup_can_queue;
+        if (setup_cmd_per_lun > 0)
+                mac_scsi_template.cmd_per_lun = setup_cmd_per_lun;
+        if (setup_sg_tablesize >= 0)
+                mac_scsi_template.sg_tablesize = setup_sg_tablesize;
+        if (setup_hostid >= 0)
+                mac_scsi_template.this_id = setup_hostid & 7;
+        if (setup_use_pdma < 0)
+                setup_use_pdma = 0;
+
+        instance = scsi_host_alloc(&mac_scsi_template,
+                                   sizeof(struct NCR5380_hostdata));
+        if (!instance)
+                return -ENOMEM;
+
+        instance->base = pio_mem->start;
+        if (irq)
+                instance->irq = irq->start;
+        else
+                instance->irq = NO_IRQ;
+
+        if (pdma_mem && setup_use_pdma) {
+                struct NCR5380_hostdata *hostdata = shost_priv(instance);
+
+                hostdata->pdma_base = (unsigned char *)pdma_mem->start;
+        } else
+                host_flags |= FLAG_NO_PSEUDO_DMA;
+
+#ifdef RESET_BOOT
+        mac_scsi_reset_boot(instance);
+#endif
+
+#ifdef SUPPORT_TAGS
+        host_flags |= setup_use_tagged_queuing > 0 ? FLAG_TAGGED_QUEUING : 0;
+#endif
+
+        NCR5380_init(instance, host_flags);
+
+        if (instance->irq != NO_IRQ) {
+                error = request_irq(instance->irq, macscsi_intr, IRQF_SHARED,
+                                    "NCR5380", instance);
+                if (error)
+                        goto fail_irq;
+        }
+
+        error = scsi_add_host(instance, NULL);
+        if (error)
+                goto fail_host;
+
+        platform_set_drvdata(pdev, instance);
+
+        scsi_scan_host(instance);
+        return 0;
+
+fail_host:
+        if (instance->irq != NO_IRQ)
+                free_irq(instance->irq, instance);
+fail_irq:
+        NCR5380_exit(instance);
+        scsi_host_put(instance);
+        return error;
+}
+
+static int __exit mac_scsi_remove(struct platform_device *pdev)
+{
+        struct Scsi_Host *instance = platform_get_drvdata(pdev);
+
+        scsi_remove_host(instance);
+        if (instance->irq != NO_IRQ)
+                free_irq(instance->irq, instance);
+        NCR5380_exit(instance);
+        scsi_host_put(instance);
+        return 0;
+}
+
+static struct platform_driver mac_scsi_driver = {
+        .remove = __exit_p(mac_scsi_remove),
+        .driver = {
+                .name   = DRV_MODULE_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_platform_driver_probe(mac_scsi_driver, mac_scsi_probe);
 
-#include "scsi_module.c"
+MODULE_ALIAS("platform:" DRV_MODULE_NAME);
+MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/mac_scsi.h b/drivers/scsi/mac_scsi.h
deleted file mode 100644
index 06969b06e54b..000000000000
--- a/drivers/scsi/mac_scsi.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Cumana Generic NCR5380 driver defines
- *
- * Copyright 1993, Drew Eckhardt
- *      Visionary Computing
- *      (Unix and Linux consulting and custom programming)
- *      drew@colorado.edu
- *      +1 (303) 440-4894
- *
- * ALPHA RELEASE 1.
- *
- * For more information, please consult
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
- */
-
-#ifndef MAC_NCR5380_H
-#define MAC_NCR5380_H
-
-#define MACSCSI_PUBLIC_RELEASE 2
-
-#ifndef ASM
-
-#ifndef CMD_PER_LUN
-#define CMD_PER_LUN 2
-#endif
-
-#ifndef CAN_QUEUE
-#define CAN_QUEUE 16
-#endif
-
-#ifndef SG_TABLESIZE
-#define SG_TABLESIZE SG_NONE
-#endif
-
-#ifndef USE_TAGGED_QUEUING
-#define USE_TAGGED_QUEUING 0
-#endif
-
-#include <scsi/scsicam.h>
-
-#define NCR5380_implementation_fields \
-    int port, ctrl
-
-#define NCR5380_local_declare() \
-        struct Scsi_Host *_instance
-
-#define NCR5380_setup(instance) \
-        _instance = instance
-
-#define NCR5380_read(reg) macscsi_read(_instance, reg)
-#define NCR5380_write(reg, value) macscsi_write(_instance, reg, value)
-
-#define NCR5380_pread   macscsi_pread
-#define NCR5380_pwrite  macscsi_pwrite
-        
-#define NCR5380_intr macscsi_intr
-#define NCR5380_queue_command macscsi_queue_command
-#define NCR5380_abort macscsi_abort
-#define NCR5380_bus_reset macscsi_bus_reset
-#define NCR5380_show_info macscsi_show_info
-#define NCR5380_write_info macscsi_write_info
-
-#endif /* ndef ASM */
-#endif /* MAC_NCR5380_H */
-
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index ac5d94cfd52f..2485255f3414 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -1945,7 +1945,7 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
              cmd->device->id, (u32)cmd->device->lun);
 
         if(list_empty(&adapter->pending_list))
-                return FALSE;
+                return FAILED;
 
         list_for_each_safe(pos, next, &adapter->pending_list) {
 
@@ -1968,7 +1968,7 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
                                         (aor==SCB_ABORT) ? "ABORTING":"RESET",
                                         scb->idx);
 
-                                return FALSE;
+                                return FAILED;
                         }
                         else {
 
@@ -1993,12 +1993,12 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
                                 list_add_tail(SCSI_LIST(cmd),
                                                 &adapter->completed_list);
 
-                                return TRUE;
+                                return SUCCESS;
                         }
                 }
         }
 
-        return FALSE;
+        return FAILED;
 }
 
 static inline int
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 531dce419c18..f0987f22ea70 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -332,27 +332,6 @@ static struct device_attribute *megaraid_sdev_attrs[] = {
         NULL,
 };
 
-/**
- * megaraid_change_queue_depth - Change the device's queue depth
- * @sdev:       scsi device struct
- * @qdepth:     depth to set
- * @reason:     calling context
- *
- * Return value:
- *      actual depth set
- */
-static int megaraid_change_queue_depth(struct scsi_device *sdev, int qdepth,
-                                       int reason)
-{
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
-        if (qdepth > MBOX_MAX_SCSI_CMDS)
-                qdepth = MBOX_MAX_SCSI_CMDS;
-        scsi_adjust_queue_depth(sdev, 0, qdepth);
-        return sdev->queue_depth;
-}
-
 /*
  * Scsi host template for megaraid unified driver
  */
@@ -365,7 +344,7 @@ static struct scsi_host_template megaraid_template_g = {
         .eh_device_reset_handler        = megaraid_reset_handler,
         .eh_bus_reset_handler           = megaraid_reset_handler,
         .eh_host_reset_handler          = megaraid_reset_handler,
-        .change_queue_depth             = megaraid_change_queue_depth,
+        .change_queue_depth             = scsi_change_queue_depth,
         .use_clustering                 = ENABLE_CLUSTERING,
         .no_write_same                  = 1,
         .sdev_attrs                     = megaraid_sdev_attrs,
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index a49914de4b95..0d44d91c2fce 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -1,7 +1,8 @@
 /*
  *  Linux MegaRAID driver for SAS based RAID controllers
  *
- *  Copyright (c) 2003-2012  LSI Corporation.
+ *  Copyright (c) 2003-2013  LSI Corporation
+ *  Copyright (c) 2013-2014  Avago Technologies
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License
@@ -14,17 +15,18 @@
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  *  FILE: megaraid_sas.h
  *
- *  Authors: LSI Corporation
+ *  Authors: Avago Technologies
+ *           Kashyap Desai <kashyap.desai@avagotech.com>
+ *           Sumit Saxena <sumit.saxena@avagotech.com>
  *
- *  Send feedback to: <megaraidlinux@lsi.com>
+ *  Send feedback to: megaraidlinux.pdl@avagotech.com
  *
- *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
- *     ATTN: Linuxraid
+ *  Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
+ *  San Jose, California 95131
  */
 
 #ifndef LSI_MEGARAID_SAS_H
@@ -33,9 +35,7 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                         "06.805.06.00-rc1"
-#define MEGASAS_RELDATE                         "Sep. 4, 2014"
-#define MEGASAS_EXT_VERSION                     "Thu. Sep. 4 17:00:00 PDT 2014"
+#define MEGASAS_VERSION                         "06.805.06.01-rc1"
 
 /*
  * Device IDs
@@ -1931,8 +1931,7 @@ u16 get_updated_dev_handle(struct megasas_instance *instance,
         struct LD_LOAD_BALANCE_INFO *lbInfo, struct IO_REQUEST_INFO *in_info);
 void mr_update_load_balance_params(struct MR_DRV_RAID_MAP_ALL *map,
         struct LD_LOAD_BALANCE_INFO *lbInfo);
-int megasas_get_ctrl_info(struct megasas_instance *instance,
-        struct megasas_ctrl_info *ctrl_info);
+int megasas_get_ctrl_info(struct megasas_instance *instance);
 int megasas_set_crash_dump_params(struct megasas_instance *instance,
         u8 crash_buf_state);
 void megasas_free_host_crash_buffer(struct megasas_instance *instance);
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 5640ad1c8214..f05580e693d0 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -1,7 +1,8 @@
 /*
  *  Linux MegaRAID driver for SAS based RAID controllers
  *
- *  Copyright (c) 2003-2012  LSI Corporation.
+ *  Copyright (c) 2003-2013  LSI Corporation
+ *  Copyright (c) 2013-2014  Avago Technologies
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License
@@ -14,22 +15,20 @@
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
- *  FILE: megaraid_sas_base.c
- *  Version : 06.805.06.00-rc1
- *
- *  Authors: LSI Corporation
+ *  Authors: Avago Technologies
  *           Sreenivas Bagalkote
  *           Sumant Patro
  *           Bo Yang
- *           Adam Radford <linuxraid@lsi.com>
+ *           Adam Radford
+ *           Kashyap Desai <kashyap.desai@avagotech.com>
+ *           Sumit Saxena <sumit.saxena@avagotech.com>
  *
- *  Send feedback to: <megaraidlinux@lsi.com>
+ *  Send feedback to: megaraidlinux.pdl@avagotech.com
  *
- *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
- *     ATTN: Linuxraid
+ *  Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
+ *  San Jose, California 95131
  */
 
 #include <linux/kernel.h>
@@ -1008,7 +1007,7 @@ megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
                 cpu_to_le32(upper_32_bits(cmd_to_abort->frame_phys_addr));
 
         cmd->sync_cmd = 1;
-        cmd->cmd_status = 0xFF;
+        cmd->cmd_status = ENODATA;
 
         instance->instancet->issue_dcmd(instance, cmd);
 
@@ -1572,6 +1571,12 @@ megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
         instance = (struct megasas_instance *)
             scmd->device->host->hostdata;
 
+        if (instance->unload == 1) {
+                scmd->result = DID_NO_CONNECT << 16;
+                scmd->scsi_done(scmd);
+                return 0;
+        }
+
         if (instance->issuepend_done == 0)
                 return SCSI_MLQUEUE_HOST_BUSY;
 
@@ -2586,20 +2591,6 @@ megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
         }
 }
 
-static int megasas_change_queue_depth(struct scsi_device *sdev,
-                                      int queue_depth, int reason)
-{
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
-        if (queue_depth > sdev->host->can_queue)
-                queue_depth = sdev->host->can_queue;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
-                                queue_depth);
-
-        return queue_depth;
-}
-
 static ssize_t
 megasas_fw_crash_buffer_store(struct device *cdev,
         struct device_attribute *attr, const char *buf, size_t count)
@@ -2764,7 +2755,7 @@ static struct scsi_host_template megasas_template = {
         .shost_attrs = megaraid_host_attrs,
         .bios_param = megasas_bios_param,
         .use_clustering = ENABLE_CLUSTERING,
-        .change_queue_depth = megasas_change_queue_depth,
+        .change_queue_depth = scsi_change_queue_depth,
         .no_write_same = 1,
 };
 
@@ -4028,25 +4019,83 @@ megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
         return ret;
 }
 
+/*
+ * megasas_update_ext_vd_details : Update details w.r.t Extended VD
+ * instance                      : Controller's instance
+*/
+static void megasas_update_ext_vd_details(struct megasas_instance *instance)
+{
+        struct fusion_context *fusion;
+        u32 old_map_sz;
+        u32 new_map_sz;
+
+        fusion = instance->ctrl_context;
+        /* For MFI based controllers return dummy success */
+        if (!fusion)
+                return;
+
+        instance->supportmax256vd =
+                instance->ctrl_info->adapterOperations3.supportMaxExtLDs;
+        /* Below is additional check to address future FW enhancement */
+        if (instance->ctrl_info->max_lds > 64)
+                instance->supportmax256vd = 1;
+
+        instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS
+                                        * MEGASAS_MAX_DEV_PER_CHANNEL;
+        instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS
+                                        * MEGASAS_MAX_DEV_PER_CHANNEL;
+        if (instance->supportmax256vd) {
+                instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT;
+                instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
+        } else {
+                instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
+                instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
+        }
+        dev_info(&instance->pdev->dev, "Firmware supports %d VD %d PD\n",
+                instance->fw_supported_vd_count,
+                instance->fw_supported_pd_count);
+        dev_info(&instance->pdev->dev, "Driver supports %d VD  %d PD\n",
+                instance->drv_supported_vd_count,
+                instance->drv_supported_pd_count);
+
+        old_map_sz =  sizeof(struct MR_FW_RAID_MAP) +
+                                (sizeof(struct MR_LD_SPAN_MAP) *
+                                (instance->fw_supported_vd_count - 1));
+        new_map_sz =  sizeof(struct MR_FW_RAID_MAP_EXT);
+        fusion->drv_map_sz =  sizeof(struct MR_DRV_RAID_MAP) +
+                                (sizeof(struct MR_LD_SPAN_MAP) *
+                                (instance->drv_supported_vd_count - 1));
+
+        fusion->max_map_sz = max(old_map_sz, new_map_sz);
+
+
+        if (instance->supportmax256vd)
+                fusion->current_map_sz = new_map_sz;
+        else
+                fusion->current_map_sz = old_map_sz;
+
+}
+
 /**
  * megasas_get_controller_info -        Returns FW's controller structure
  * @instance:                           Adapter soft state
- * @ctrl_info:                          Controller information structure
  *
  * Issues an internal command (DCMD) to get the FW's controller structure.
  * This information is mainly used to find out the maximum IO transfer per
  * command supported by the FW.
  */
 int
-megasas_get_ctrl_info(struct megasas_instance *instance,
-                      struct megasas_ctrl_info *ctrl_info)
+megasas_get_ctrl_info(struct megasas_instance *instance)
 {
         int ret = 0;
         struct megasas_cmd *cmd;
         struct megasas_dcmd_frame *dcmd;
         struct megasas_ctrl_info *ci;
+        struct megasas_ctrl_info *ctrl_info;
         dma_addr_t ci_h = 0;
 
+        ctrl_info = instance->ctrl_info;
+
         cmd = megasas_get_cmd(instance);
 
         if (!cmd) {
@@ -4086,8 +4135,13 @@ megasas_get_ctrl_info(struct megasas_instance *instance,
         else
                 ret = megasas_issue_polled(instance, cmd);
 
-        if (!ret)
+        if (!ret) {
                 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info));
+                le32_to_cpus((u32 *)&ctrl_info->properties.OnOffProperties);
+                le32_to_cpus((u32 *)&ctrl_info->adapterOperations2);
+                le32_to_cpus((u32 *)&ctrl_info->adapterOperations3);
+                megasas_update_ext_vd_details(instance);
+        }
 
         pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
                             ci, ci_h);
@@ -4289,7 +4343,7 @@ megasas_init_adapter_mfi(struct megasas_instance *instance)
         if (megasas_issue_init_mfi(instance))
                 goto fail_fw_init;
 
-        if (megasas_get_ctrl_info(instance, instance->ctrl_info)) {
+        if (megasas_get_ctrl_info(instance)) {
                 dev_err(&instance->pdev->dev, "(%d): Could get controller info "
                         "Fail from %s %d\n", instance->unique_id,
                         __func__, __LINE__);
@@ -4527,12 +4581,8 @@ static int megasas_init_fw(struct megasas_instance *instance)
                 dev_info(&instance->pdev->dev,
                         "Controller type: iMR\n");
         }
-        /* OnOffProperties are converted into CPU arch*/
-        le32_to_cpus((u32 *)&ctrl_info->properties.OnOffProperties);
         instance->disableOnlineCtrlReset =
         ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset;
-        /* adapterOperations2 are converted into CPU arch*/
-        le32_to_cpus((u32 *)&ctrl_info->adapterOperations2);
         instance->mpio = ctrl_info->adapterOperations2.mpio;
         instance->UnevenSpanSupport =
                 ctrl_info->adapterOperations2.supportUnevenSpans;
@@ -4562,7 +4612,6 @@ static int megasas_init_fw(struct megasas_instance *instance)
                        "requestorId %d\n", instance->requestorId);
         }
 
-        le32_to_cpus((u32 *)&ctrl_info->adapterOperations3);
         instance->crash_dump_fw_support =
                 ctrl_info->adapterOperations3.supportCrashDump;
         instance->crash_dump_drv_support =
@@ -4587,8 +4636,6 @@ static int megasas_init_fw(struct megasas_instance *instance)
         if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
                 instance->max_sectors_per_req = tmp_sectors;
 
-        kfree(ctrl_info);
-
         /* Check for valid throttlequeuedepth module parameter */
         if (instance->is_imr) {
                 if (throttlequeuedepth > (instance->max_fw_cmds -
@@ -4957,10 +5004,6 @@ static int megasas_io_attach(struct megasas_instance *instance)
                 return -ENODEV;
         }
 
-        /*
-         * Trigger SCSI to scan our drives
-         */
-        scsi_scan_host(host);
         return 0;
 }
 
@@ -5083,6 +5126,8 @@ static int megasas_probe_one(struct pci_dev *pdev,
                         goto fail_alloc_dma_buf;
                 }
                 fusion = instance->ctrl_context;
+                memset(fusion, 0,
+                        ((1 << PAGE_SHIFT) << instance->ctrl_context_pages));
                 INIT_LIST_HEAD(&fusion->cmd_pool);
                 spin_lock_init(&fusion->mpt_pool_lock);
                 memset(fusion->load_balance_info, 0,
@@ -5288,6 +5333,10 @@ retry_irq_register:
                 goto fail_io_attach;
 
         instance->unload = 0;
+        /*
+         * Trigger SCSI to scan our drives
+         */
+        scsi_scan_host(host);
 
         /*
          * Initiate AEN (Asynchronous Event Notification)
@@ -6051,6 +6100,11 @@ megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
         megasas_issue_blocked_cmd(instance, cmd, 0);
         cmd->sync_cmd = 0;
 
+        if (instance->unload == 1) {
+                dev_info(&instance->pdev->dev, "Driver unload is in progress "
+                        "don't submit data to application\n");
+                goto out;
+        }
         /*
          * copy out the kernel buffers to user buffers
          */
@@ -6400,16 +6454,6 @@ static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf)
 static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL);
 
 static ssize_t
-megasas_sysfs_show_release_date(struct device_driver *dd, char *buf)
-{
-        return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
-                        MEGASAS_RELDATE);
-}
-
-static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date,
-                   NULL);
-
-static ssize_t
 megasas_sysfs_show_support_poll_for_event(struct device_driver *dd, char *buf)
 {
         return sprintf(buf, "%u\n", support_poll_for_event);
@@ -6712,8 +6756,7 @@ static int __init megasas_init(void)
         /*
          * Announce driver version and other information
          */
-        printk(KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION,
-               MEGASAS_EXT_VERSION);
+        pr_info("megasas: %s\n", MEGASAS_VERSION);
 
         spin_lock_init(&poll_aen_lock);
 
@@ -6748,10 +6791,6 @@ static int __init megasas_init(void)
                                   &driver_attr_version);
         if (rval)
                 goto err_dcf_attr_ver;
-        rval = driver_create_file(&megasas_pci_driver.driver,
-                                  &driver_attr_release_date);
-        if (rval)
-                goto err_dcf_rel_date;
 
         rval = driver_create_file(&megasas_pci_driver.driver,
                                 &driver_attr_support_poll_for_event);
@@ -6775,12 +6814,7 @@ err_dcf_support_device_change:
 err_dcf_dbg_lvl:
         driver_remove_file(&megasas_pci_driver.driver,
                         &driver_attr_support_poll_for_event);
-
 err_dcf_support_poll_for_event:
-        driver_remove_file(&megasas_pci_driver.driver,
-                           &driver_attr_release_date);
-
-err_dcf_rel_date:
         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
 err_dcf_attr_ver:
         pci_unregister_driver(&megasas_pci_driver);
@@ -6800,8 +6834,6 @@ static void __exit megasas_exit(void)
                         &driver_attr_support_poll_for_event);
         driver_remove_file(&megasas_pci_driver.driver,
                         &driver_attr_support_device_change);
-        driver_remove_file(&megasas_pci_driver.driver,
-                           &driver_attr_release_date);
         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
 
         pci_unregister_driver(&megasas_pci_driver);
diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c
index 685e6f391fe4..460c6a3d4ade 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fp.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
@@ -1,7 +1,8 @@
 /*
  *  Linux MegaRAID driver for SAS based RAID controllers
  *
- *  Copyright (c) 2009-2012  LSI Corporation.
+ *  Copyright (c) 2009-2013  LSI Corporation
+ *  Copyright (c) 2013-2014  Avago Technologies
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License
@@ -14,20 +15,21 @@
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  *  FILE: megaraid_sas_fp.c
  *
- *  Authors: LSI Corporation
+ *  Authors: Avago Technologies
  *           Sumant Patro
  *           Varad Talamacki
  *           Manoj Jose
+ *           Kashyap Desai <kashyap.desai@avagotech.com>
+ *           Sumit Saxena <sumit.saxena@avagotech.com>
  *
- *  Send feedback to: <megaraidlinux@lsi.com>
+ *  Send feedback to: megaraidlinux.pdl@avagotech.com
  *
- *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
- *     ATTN: Linuxraid
+ *  Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
+ *  San Jose, California 95131
  */
 
 #include <linux/kernel.h>
@@ -183,14 +185,15 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
                 /* New Raid map will not set totalSize, so keep expected value
                  * for legacy code in ValidateMapInfo
                  */
-                pDrvRaidMap->totalSize = sizeof(struct MR_FW_RAID_MAP_EXT);
+                pDrvRaidMap->totalSize =
+                        cpu_to_le32(sizeof(struct MR_FW_RAID_MAP_EXT));
         } else {
                 fw_map_old = (struct MR_FW_RAID_MAP_ALL *)
                         fusion->ld_map[(instance->map_id & 1)];
                 pFwRaidMap = &fw_map_old->raidMap;
 
 #if VD_EXT_DEBUG
-                for (i = 0; i < pFwRaidMap->ldCount; i++) {
+                for (i = 0; i < le16_to_cpu(pFwRaidMap->ldCount); i++) {
                         dev_dbg(&instance->pdev->dev, "(%d) :Index 0x%x "
                                 "Target Id 0x%x Seq Num 0x%x Size 0/%llx\n",
                                 instance->unique_id, i,
@@ -202,12 +205,12 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
 
                 memset(drv_map, 0, fusion->drv_map_sz);
                 pDrvRaidMap->totalSize = pFwRaidMap->totalSize;
-                pDrvRaidMap->ldCount = pFwRaidMap->ldCount;
+                pDrvRaidMap->ldCount = (__le16)pFwRaidMap->ldCount;
                 pDrvRaidMap->fpPdIoTimeoutSec = pFwRaidMap->fpPdIoTimeoutSec;
                 for (i = 0; i < MAX_RAIDMAP_LOGICAL_DRIVES + MAX_RAIDMAP_VIEWS; i++)
                         pDrvRaidMap->ldTgtIdToLd[i] =
                                 (u8)pFwRaidMap->ldTgtIdToLd[i];
-                for (i = 0; i < pDrvRaidMap->ldCount; i++) {
+                for (i = 0; i < le16_to_cpu(pDrvRaidMap->ldCount); i++) {
                         pDrvRaidMap->ldSpanMap[i] = pFwRaidMap->ldSpanMap[i];
 #if VD_EXT_DEBUG
                         dev_dbg(&instance->pdev->dev,
@@ -268,7 +271,7 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance)
         else
                 expected_size =
                         (sizeof(struct MR_FW_RAID_MAP) - sizeof(struct MR_LD_SPAN_MAP) +
-                        (sizeof(struct MR_LD_SPAN_MAP) * le32_to_cpu(pDrvRaidMap->ldCount)));
+                        (sizeof(struct MR_LD_SPAN_MAP) * le16_to_cpu(pDrvRaidMap->ldCount)));
 
         if (le32_to_cpu(pDrvRaidMap->totalSize) != expected_size) {
                 dev_err(&instance->pdev->dev, "map info structure size 0x%x is not matching with ld count\n",
@@ -284,7 +287,7 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance)
 
         mr_update_load_balance_params(drv_map, lbInfo);
 
-        num_lds = le32_to_cpu(drv_map->raidMap.ldCount);
+        num_lds = le16_to_cpu(drv_map->raidMap.ldCount);
 
         /*Convert Raid capability values to CPU arch */
         for (ldCount = 0; ldCount < num_lds; ldCount++) {
@@ -457,7 +460,7 @@ u32 mr_spanset_get_span_block(struct megasas_instance *instance,
                                 quad = &map->raidMap.ldSpanMap[ld].
                                         spanBlock[span].
                                         block_span_info.quad[info];
-                                if (le32_to_cpu(quad->diff == 0))
+                                if (le32_to_cpu(quad->diff) == 0)
                                         return SPAN_INVALID;
                                 if (le64_to_cpu(quad->logStart) <= row  &&
                                         row <= le64_to_cpu(quad->logEnd)  &&
@@ -520,7 +523,7 @@ static u64  get_row_from_strip(struct megasas_instance *instance,
                                 span_set->span_row_data_width) * span_set->diff;
                 for (span = 0, span_offset = 0; span < raid->spanDepth; span++)
                         if (le32_to_cpu(map->raidMap.ldSpanMap[ld].spanBlock[span].
-                                block_span_info.noElements >= info+1)) {
+                                block_span_info.noElements) >= info+1) {
                                 if (strip_offset >=
                                         span_set->strip_offset[span])
                                         span_offset++;
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index f37eed682c75..71557f64bb5e 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -1,7 +1,8 @@
 /*
  *  Linux MegaRAID driver for SAS based RAID controllers
  *
- *  Copyright (c) 2009-2012  LSI Corporation.
+ *  Copyright (c) 2009-2013  LSI Corporation
+ *  Copyright (c) 2013-2014  Avago Technologies
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License
@@ -14,19 +15,20 @@
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  *  FILE: megaraid_sas_fusion.c
  *
- *  Authors: LSI Corporation
+ *  Authors: Avago Technologies
  *           Sumant Patro
- *           Adam Radford <linuxraid@lsi.com>
+ *           Adam Radford
+ *           Kashyap Desai <kashyap.desai@avagotech.com>
+ *           Sumit Saxena <sumit.saxena@avagotech.com>
  *
- *  Send feedback to: <megaraidlinux@lsi.com>
+ *  Send feedback to: megaraidlinux.pdl@avagotech.com
  *
- *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
- *     ATTN: Linuxraid
+ *  Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
+ *  San Jose, California 95131
  */
 
 #include <linux/kernel.h>
@@ -880,7 +882,7 @@ megasas_sync_map_info(struct megasas_instance *instance)
 
         map = fusion->ld_drv_map[instance->map_id & 1];
 
-        num_lds = le32_to_cpu(map->raidMap.ldCount);
+        num_lds = le16_to_cpu(map->raidMap.ldCount);
 
         dcmd = &cmd->frame->dcmd;
 
@@ -1065,48 +1067,16 @@ megasas_init_adapter_fusion(struct megasas_instance *instance)
                 goto fail_ioc_init;
 
         megasas_display_intel_branding(instance);
-        if (megasas_get_ctrl_info(instance, instance->ctrl_info)) {
+        if (megasas_get_ctrl_info(instance)) {
                 dev_err(&instance->pdev->dev,
                         "Could not get controller info. Fail from %s %d\n",
                         __func__, __LINE__);
                 goto fail_ioc_init;
         }
 
-        instance->supportmax256vd =
-                instance->ctrl_info->adapterOperations3.supportMaxExtLDs;
-        /* Below is additional check to address future FW enhancement */
-        if (instance->ctrl_info->max_lds > 64)
-                instance->supportmax256vd = 1;
-        instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS
-                                        * MEGASAS_MAX_DEV_PER_CHANNEL;
-        instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS
-                                        * MEGASAS_MAX_DEV_PER_CHANNEL;
-        if (instance->supportmax256vd) {
-                instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT;
-                instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
-        } else {
-                instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
-                instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
-        }
-        dev_info(&instance->pdev->dev, "Firmware supports %d VDs %d PDs\n"
-                "Driver supports %d VDs  %d PDs\n",
-                instance->fw_supported_vd_count,
-                instance->fw_supported_pd_count,
-                instance->drv_supported_vd_count,
-                instance->drv_supported_pd_count);
-
         instance->flag_ieee = 1;
         fusion->fast_path_io = 0;
 
-        fusion->old_map_sz =
-                sizeof(struct MR_FW_RAID_MAP) + (sizeof(struct MR_LD_SPAN_MAP) *
-                (instance->fw_supported_vd_count - 1));
-        fusion->new_map_sz =
-                sizeof(struct MR_FW_RAID_MAP_EXT);
-        fusion->drv_map_sz =
-                sizeof(struct MR_DRV_RAID_MAP) + (sizeof(struct MR_LD_SPAN_MAP) *
-                (instance->drv_supported_vd_count - 1));
-
         fusion->drv_map_pages = get_order(fusion->drv_map_sz);
         for (i = 0; i < 2; i++) {
                 fusion->ld_map[i] = NULL;
@@ -1121,16 +1091,10 @@ megasas_init_adapter_fusion(struct megasas_instance *instance)
                                         fusion->drv_map_pages);
                         goto fail_ioc_init;
                 }
+                memset(fusion->ld_drv_map[i], 0,
+                        ((1 << PAGE_SHIFT) << fusion->drv_map_pages));
         }
 
-        fusion->max_map_sz = max(fusion->old_map_sz, fusion->new_map_sz);
-
-        if (instance->supportmax256vd)
-                fusion->current_map_sz = fusion->new_map_sz;
-        else
-                fusion->current_map_sz = fusion->old_map_sz;
-
-
         for (i = 0; i < 2; i++) {
                 fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev,
                                                        fusion->max_map_sz,
@@ -1173,9 +1137,10 @@ megasas_fire_cmd_fusion(struct megasas_instance *instance,
                         struct megasas_register_set __iomem *regs)
 {
 #if defined(writeq) && defined(CONFIG_64BIT)
-        u64 req_data = (((u64)req_desc_hi << 32) | (u32)req_desc_lo);
+        u64 req_data = (((u64)le32_to_cpu(req_desc_hi) << 32) |
+                        le32_to_cpu(req_desc_lo));
 
-        writeq(le64_to_cpu(req_data), &(regs)->inbound_low_queue_port);
+        writeq(req_data, &(regs)->inbound_low_queue_port);
 #else
         unsigned long flags;
 
@@ -1373,7 +1338,7 @@ megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
                 /* Logical block reference tag */
                 io_request->CDB.EEDP32.PrimaryReferenceTag =
                         cpu_to_be32(ref_tag);
-                io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0xffff;
+                io_request->CDB.EEDP32.PrimaryApplicationTagMask = cpu_to_be16(0xffff);
                 io_request->IoFlags = cpu_to_le16(32); /* Specify 32-byte cdb */
 
                 /* Transfer length */
@@ -1769,7 +1734,7 @@ megasas_build_dcdb_fusion(struct megasas_instance *instance,
 
                 /* set RAID context values */
                 pRAID_Context->regLockFlags     = REGION_TYPE_SHARED_READ;
-                pRAID_Context->timeoutValue     = raid->fpIoTimeoutForLd;
+                pRAID_Context->timeoutValue     = cpu_to_le16(raid->fpIoTimeoutForLd);
                 pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
                 pRAID_Context->regLockRowLBA    = 0;
                 pRAID_Context->regLockLength    = 0;
@@ -2254,7 +2219,7 @@ build_mpt_mfi_pass_thru(struct megasas_instance *instance,
          * megasas_complete_cmd
          */
 
-        if (frame_hdr->flags & MFI_FRAME_DONT_POST_IN_REPLY_QUEUE)
+        if (frame_hdr->flags & cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE))
                 cmd->flags = MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
 
         fusion = instance->ctrl_context;
@@ -2385,6 +2350,8 @@ megasas_alloc_host_crash_buffer(struct megasas_instance *instance)
                                 "memory allocation failed at index %d\n", i);
                         break;
                 }
+                memset(instance->crash_buf[i], 0,
+                        ((1 << PAGE_SHIFT) << instance->crash_buf_pages));
         }
         instance->drv_buf_alloc = i;
 }
@@ -2837,11 +2804,15 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout)
                                 }
                         }
 
-                        clear_bit(MEGASAS_FUSION_IN_RESET,
-                                  &instance->reset_flags);
-                        instance->instancet->enable_intr(instance);
-                        instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
-
+                        if (megasas_get_ctrl_info(instance)) {
+                                dev_info(&instance->pdev->dev,
+                                        "Failed from %s %d\n",
+                                        __func__, __LINE__);
+                                instance->adprecovery =
+                                        MEGASAS_HW_CRITICAL_ERROR;
+                                megaraid_sas_kill_hba(instance);
+                                retval = FAILED;
+                        }
                         /* Reset load balance info */
                         memset(fusion->load_balance_info, 0,
                                sizeof(struct LD_LOAD_BALANCE_INFO)
@@ -2850,6 +2821,11 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout)
                         if (!megasas_get_map_info(instance))
                                 megasas_sync_map_info(instance);
 
+                        clear_bit(MEGASAS_FUSION_IN_RESET,
+                                  &instance->reset_flags);
+                        instance->instancet->enable_intr(instance);
+                        instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
+
                         /* Restart SR-IOV heartbeat */
                         if (instance->requestorId) {
                                 if (!megasas_sriov_start_heartbeat(instance, 0))
@@ -2866,14 +2842,14 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout)
                                "successful for scsi%d.\n",
                                 instance->host->host_no);
 
-                        if (instance->crash_dump_drv_support) {
-                                if (instance->crash_dump_app_support)
-                                        megasas_set_crash_dump_params(instance,
-                                                MR_CRASH_BUF_TURN_ON);
-                                else
-                                        megasas_set_crash_dump_params(instance,
-                                                MR_CRASH_BUF_TURN_OFF);
-                        }
+                        if (instance->crash_dump_drv_support &&
+                                instance->crash_dump_app_support)
+                                megasas_set_crash_dump_params(instance,
+                                        MR_CRASH_BUF_TURN_ON);
+                        else
+                                megasas_set_crash_dump_params(instance,
+                                        MR_CRASH_BUF_TURN_OFF);
+
                         retval = SUCCESS;
                         goto out;
                 }
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.h b/drivers/scsi/megaraid/megaraid_sas_fusion.h
index 0d183d521bdd..5ab7daee11be 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.h
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.h
@@ -1,7 +1,8 @@
 /*
  *  Linux MegaRAID driver for SAS based RAID controllers
  *
- *  Copyright (c) 2009-2012  LSI Corporation.
+ *  Copyright (c) 2009-2013  LSI Corporation
+ *  Copyright (c) 2013-2014  Avago Technologies
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License
@@ -14,19 +15,20 @@
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  *  FILE: megaraid_sas_fusion.h
  *
- *  Authors: LSI Corporation
+ *  Authors: Avago Technologies
  *           Manoj Jose
  *           Sumant Patro
+ *           Kashyap Desai <kashyap.desai@avagotech.com>
+ *           Sumit Saxena <sumit.saxena@avagotech.com>
  *
- *  Send feedback to: <megaraidlinux@lsi.com>
+ *  Send feedback to: megaraidlinux.pdl@avagotech.com
  *
- *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
- *     ATTN: Linuxraid
+ *  Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
+ *  San Jose, California 95131
  */
 
 #ifndef _MEGARAID_SAS_FUSION_H_
@@ -834,8 +836,6 @@ struct fusion_context {
 
         u32 max_map_sz;
         u32 current_map_sz;
-        u32 old_map_sz;
-        u32 new_map_sz;
         u32 drv_map_sz;
         u32 drv_map_pages;
         u8 fast_path_io;
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index c80ed0482649..8431eb10bbb1 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -1179,15 +1179,14 @@ _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
- * _scsih_adjust_queue_depth - setting device queue depth
+ * _scsih_change_queue_depth - setting device queue depth
  * @sdev: scsi device struct
  * @qdepth: requested queue depth
  *
- *
- * Returns nothing
+ * Returns queue depth.
  */
-static void
-_scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
+static int
+_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
         struct Scsi_Host *shost = sdev->host;
         int max_depth;
@@ -1217,63 +1216,11 @@ _scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
  not_sata:
-
         if (!sdev->tagged_supported)
                 max_depth = 1;
         if (qdepth > max_depth)
                 qdepth = max_depth;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-}
-
-/**
- * _scsih_change_queue_depth - setting device queue depth
- * @sdev: scsi device struct
- * @qdepth: requested queue depth
- * @reason: SCSI_QDEPTH_DEFAULT/SCSI_QDEPTH_QFULL/SCSI_QDEPTH_RAMP_UP
- * (see include/scsi/scsi_host.h for definition)
- *
- * Returns queue depth.
- */
-static int
-_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
-{
-        if (reason == SCSI_QDEPTH_DEFAULT || reason == SCSI_QDEPTH_RAMP_UP)
-                _scsih_adjust_queue_depth(sdev, qdepth);
-        else if (reason == SCSI_QDEPTH_QFULL)
-                scsi_track_queue_full(sdev, qdepth);
-        else
-                return -EOPNOTSUPP;
-
-        if (sdev->inquiry_len > 7)
-                sdev_printk(KERN_INFO, sdev, "qdepth(%d), tagged(%d), "
-                "simple(%d), ordered(%d), scsi_level(%d), cmd_que(%d)\n",
-                sdev->queue_depth, sdev->tagged_supported, sdev->simple_tags,
-                sdev->ordered_tags, sdev->scsi_level,
-                (sdev->inquiry[7] & 2) >> 1);
-
-        return sdev->queue_depth;
-}
-
-/**
- * _scsih_change_queue_type - changing device queue tag type
- * @sdev: scsi device struct
- * @tag_type: requested tag type
- *
- * Returns queue tag type.
- */
-static int
-_scsih_change_queue_type(struct scsi_device *sdev, int tag_type)
-{
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, tag_type);
-                if (tag_type)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                tag_type = 0;
-
-        return tag_type;
+        return scsi_change_queue_depth(sdev, qdepth);
 }
 
 /**
@@ -2104,7 +2051,7 @@ _scsih_slave_configure(struct scsi_device *sdev)
                             r_level, raid_device->handle,
                             (unsigned long long)raid_device->wwid,
                             raid_device->num_pds, ds);
-                _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
+                _scsih_change_queue_depth(sdev, qdepth);
                 /* raid transport support */
                 if (!ioc->is_warpdrive)
                         _scsih_set_level(sdev, raid_device->volume_type);
@@ -2169,7 +2116,7 @@ _scsih_slave_configure(struct scsi_device *sdev)
                 _scsih_display_sata_capabilities(ioc, handle, sdev);
 
 
-        _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
+        _scsih_change_queue_depth(sdev, qdepth);
 
         if (ssp_target) {
                 sas_read_port_mode_page(sdev);
@@ -3966,16 +3913,8 @@ _scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
                 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
 
         /* set tags */
-        if (!(sas_device_priv_data->flags & MPT_DEVICE_FLAGS_INIT)) {
-                if (scmd->device->tagged_supported) {
-                        if (scmd->device->ordered_tags)
-                                mpi_control |= MPI2_SCSIIO_CONTROL_ORDEREDQ;
-                        else
-                                mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
-                } else
-                        mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
-        } else
-                mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
+        mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
+
         /* Make sure Device is not raid volume.
          * We do not expose raid functionality to upper layer for warpdrive.
          */
@@ -7653,7 +7592,7 @@ static struct scsi_host_template scsih_driver_template = {
         .scan_finished                  = _scsih_scan_finished,
         .scan_start                     = _scsih_scan_start,
         .change_queue_depth             = _scsih_change_queue_depth,
-        .change_queue_type              = _scsih_change_queue_type,
+        .change_queue_type              = scsi_change_queue_type,
         .eh_abort_handler               = _scsih_abort,
         .eh_device_reset_handler        = _scsih_dev_reset,
         .eh_target_reset_handler        = _scsih_target_reset,
@@ -7667,6 +7606,7 @@ static struct scsi_host_template scsih_driver_template = {
         .use_clustering                 = ENABLE_CLUSTERING,
         .shost_attrs                    = mpt2sas_host_attrs,
         .sdev_attrs                     = mpt2sas_dev_attrs,
+        .track_queue_depth              = 1,
 };
 
 /**
diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
index 857276b8880f..a2b60991efd4 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
@@ -1053,9 +1053,15 @@ _scsih_scsi_lookup_find_by_lun(struct MPT3SAS_ADAPTER *ioc, int id,
         return found;
 }
 
-
-static void
-_scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
+/**
+ * _scsih_change_queue_depth - setting device queue depth
+ * @sdev: scsi device struct
+ * @qdepth: requested queue depth
+ *
+ * Returns queue depth.
+ */
+static int
+_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
         struct Scsi_Host *shost = sdev->host;
         int max_depth;
@@ -1090,62 +1096,10 @@ _scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
                 max_depth = 1;
         if (qdepth > max_depth)
                 qdepth = max_depth;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        return scsi_change_queue_depth(sdev, qdepth);
 }
 
 /**
- * _scsih_change_queue_depth - setting device queue depth
- * @sdev: scsi device struct
- * @qdepth: requested queue depth
- * @reason: SCSI_QDEPTH_DEFAULT/SCSI_QDEPTH_QFULL/SCSI_QDEPTH_RAMP_UP
- * (see include/scsi/scsi_host.h for definition)
- *
- * Returns queue depth.
- */
-static int
-_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
-{
-        if (reason == SCSI_QDEPTH_DEFAULT || reason == SCSI_QDEPTH_RAMP_UP)
-                _scsih_adjust_queue_depth(sdev, qdepth);
-        else if (reason == SCSI_QDEPTH_QFULL)
-                scsi_track_queue_full(sdev, qdepth);
-        else
-                return -EOPNOTSUPP;
-
-        if (sdev->inquiry_len > 7)
-                sdev_printk(KERN_INFO, sdev, "qdepth(%d), tagged(%d), " \
-                "simple(%d), ordered(%d), scsi_level(%d), cmd_que(%d)\n",
-                sdev->queue_depth, sdev->tagged_supported, sdev->simple_tags,
-                sdev->ordered_tags, sdev->scsi_level,
-                (sdev->inquiry[7] & 2) >> 1);
-
-        return sdev->queue_depth;
-}
-
-/**
- * _scsih_change_queue_type - changing device queue tag type
- * @sdev: scsi device struct
- * @tag_type: requested tag type
- *
- * Returns queue tag type.
- */
-static int
-_scsih_change_queue_type(struct scsi_device *sdev, int tag_type)
-{
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, tag_type);
-                if (tag_type)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                tag_type = 0;
-
-        return tag_type;
-}
-
-
-/**
  * _scsih_target_alloc - target add routine
  * @starget: scsi target struct
  *
@@ -1762,7 +1716,7 @@ _scsih_slave_configure(struct scsi_device *sdev)
                          raid_device->num_pds, ds);
 
 
-                _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
+                _scsih_change_queue_depth(sdev, qdepth);
 
 /* raid transport support */
                 _scsih_set_level(sdev, raid_device->volume_type);
@@ -1828,7 +1782,7 @@ _scsih_slave_configure(struct scsi_device *sdev)
                 _scsih_display_sata_capabilities(ioc, handle, sdev);
 
 
-        _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
+        _scsih_change_queue_depth(sdev, qdepth);
 
         if (ssp_target) {
                 sas_read_port_mode_page(sdev);
@@ -3586,16 +3540,7 @@ _scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
                 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
 
         /* set tags */
-        if (!(sas_device_priv_data->flags & MPT_DEVICE_FLAGS_INIT)) {
-                if (scmd->device->tagged_supported) {
-                        if (scmd->device->ordered_tags)
-                                mpi_control |= MPI2_SCSIIO_CONTROL_ORDEREDQ;
-                        else
-                                mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
-                } else
-                        mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
-        } else
-                mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
+        mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
 
         if ((sas_device_priv_data->flags & MPT_DEVICE_TLR_ON) &&
             scmd->cmd_len != 32)
@@ -7284,7 +7229,7 @@ static struct scsi_host_template scsih_driver_template = {
         .scan_finished                  = _scsih_scan_finished,
         .scan_start                     = _scsih_scan_start,
         .change_queue_depth             = _scsih_change_queue_depth,
-        .change_queue_type              = _scsih_change_queue_type,
+        .change_queue_type              = scsi_change_queue_type,
         .eh_abort_handler               = _scsih_abort,
         .eh_device_reset_handler        = _scsih_dev_reset,
         .eh_target_reset_handler        = _scsih_target_reset,
@@ -7298,6 +7243,7 @@ static struct scsi_host_template scsih_driver_template = {
         .use_clustering                 = ENABLE_CLUSTERING,
         .shost_attrs                    = mpt3sas_host_attrs,
         .sdev_attrs                     = mpt3sas_dev_attrs,
+        .track_queue_depth              = 1,
 };
 
 /**
diff --git a/drivers/scsi/mvsas/mv_init.c b/drivers/scsi/mvsas/mv_init.c
index eacee48a955c..f15df3de6790 100644
--- a/drivers/scsi/mvsas/mv_init.c
+++ b/drivers/scsi/mvsas/mv_init.c
@@ -26,18 +26,9 @@
 
 #include "mv_sas.h"
 
-static int lldd_max_execute_num = 1;
-module_param_named(collector, lldd_max_execute_num, int, S_IRUGO);
-MODULE_PARM_DESC(collector, "\n"
-        "\tIf greater than one, tells the SAS Layer to run in Task Collector\n"
-        "\tMode.  If 1 or 0, tells the SAS Layer to run in Direct Mode.\n"
-        "\tThe mvsas SAS LLDD supports both modes.\n"
-        "\tDefault: 1 (Direct Mode).\n");
-
 int interrupt_coalescing = 0x80;
 
 static struct scsi_transport_template *mvs_stt;
-struct kmem_cache *mvs_task_list_cache;
 static const struct mvs_chip_info mvs_chips[] = {
         [chip_6320] =   { 1, 2, 0x400, 17, 16, 6,  9, &mvs_64xx_dispatch, },
         [chip_6440] =   { 1, 4, 0x400, 17, 16, 6,  9, &mvs_64xx_dispatch, },
@@ -76,6 +67,8 @@ static struct scsi_host_template mvs_sht = {
         .target_destroy         = sas_target_destroy,
         .ioctl                  = sas_ioctl,
         .shost_attrs            = mvst_host_attrs,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
 
 static struct sas_domain_function_template mvs_transport_ops = {
@@ -511,14 +504,11 @@ static void  mvs_post_sas_ha_init(struct Scsi_Host *shost,
 
         sha->num_phys = nr_core * chip_info->n_phy;
 
-        sha->lldd_max_execute_num = lldd_max_execute_num;
-
         if (mvi->flags & MVF_FLAG_SOC)
                 can_queue = MVS_SOC_CAN_QUEUE;
         else
                 can_queue = MVS_CHIP_SLOT_SZ;
 
-        sha->lldd_queue_size = can_queue;
         shost->sg_tablesize = min_t(u16, SG_ALL, MVS_MAX_SG);
         shost->can_queue = can_queue;
         mvi->shost->cmd_per_lun = MVS_QUEUE_SIZE;
@@ -831,16 +821,7 @@ static int __init mvs_init(void)
         if (!mvs_stt)
                 return -ENOMEM;
 
-        mvs_task_list_cache = kmem_cache_create("mvs_task_list", sizeof(struct mvs_task_list),
-                                                         0, SLAB_HWCACHE_ALIGN, NULL);
-        if (!mvs_task_list_cache) {
-                rc = -ENOMEM;
-                mv_printk("%s: mvs_task_list_cache alloc failed! \n", __func__);
-                goto err_out;
-        }
-
         rc = pci_register_driver(&mvs_pci_driver);
-
         if (rc)
                 goto err_out;
 
@@ -855,7 +836,6 @@ static void __exit mvs_exit(void)
 {
         pci_unregister_driver(&mvs_pci_driver);
         sas_release_transport(mvs_stt);
-        kmem_cache_destroy(mvs_task_list_cache);
 }
 
 struct device_attribute *mvst_host_attrs[] = {
diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
index ac52f7c99513..85d86a5cdb60 100644
--- a/drivers/scsi/mvsas/mv_sas.c
+++ b/drivers/scsi/mvsas/mv_sas.c
@@ -852,43 +852,7 @@ prep_out:
         return rc;
 }
 
-static struct mvs_task_list *mvs_task_alloc_list(int *num, gfp_t gfp_flags)
-{
-        struct mvs_task_list *first = NULL;
-
-        for (; *num > 0; --*num) {
-                struct mvs_task_list *mvs_list = kmem_cache_zalloc(mvs_task_list_cache, gfp_flags);
-
-                if (!mvs_list)
-                        break;
-
-                INIT_LIST_HEAD(&mvs_list->list);
-                if (!first)
-                        first = mvs_list;
-                else
-                        list_add_tail(&mvs_list->list, &first->list);
-
-        }
-
-        return first;
-}
-
-static inline void mvs_task_free_list(struct mvs_task_list *mvs_list)
-{
-        LIST_HEAD(list);
-        struct list_head *pos, *a;
-        struct mvs_task_list *mlist = NULL;
-
-        __list_add(&list, mvs_list->list.prev, &mvs_list->list);
-
-        list_for_each_safe(pos, a, &list) {
-                list_del_init(pos);
-                mlist = list_entry(pos, struct mvs_task_list, list);
-                kmem_cache_free(mvs_task_list_cache, mlist);
-        }
-}
-
-static int mvs_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
+static int mvs_task_exec(struct sas_task *task, gfp_t gfp_flags,
                                 struct completion *completion, int is_tmf,
                                 struct mvs_tmf_task *tmf)
 {
@@ -912,74 +876,9 @@ static int mvs_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
         return rc;
 }
 
-static int mvs_collector_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
-                                struct completion *completion, int is_tmf,
-                                struct mvs_tmf_task *tmf)
+int mvs_queue_command(struct sas_task *task, gfp_t gfp_flags)
 {
-        struct domain_device *dev = task->dev;
-        struct mvs_prv_info *mpi = dev->port->ha->lldd_ha;
-        struct mvs_info *mvi = NULL;
-        struct sas_task *t = task;
-        struct mvs_task_list *mvs_list = NULL, *a;
-        LIST_HEAD(q);
-        int pass[2] = {0};
-        u32 rc = 0;
-        u32 n = num;
-        unsigned long flags = 0;
-
-        mvs_list = mvs_task_alloc_list(&n, gfp_flags);
-        if (n) {
-                printk(KERN_ERR "%s: mvs alloc list failed.\n", __func__);
-                rc = -ENOMEM;
-                goto free_list;
-        }
-
-        __list_add(&q, mvs_list->list.prev, &mvs_list->list);
-
-        list_for_each_entry(a, &q, list) {
-                a->task = t;
-                t = list_entry(t->list.next, struct sas_task, list);
-        }
-
-        list_for_each_entry(a, &q , list) {
-
-                t = a->task;
-                mvi = ((struct mvs_device *)t->dev->lldd_dev)->mvi_info;
-
-                spin_lock_irqsave(&mvi->lock, flags);
-                rc = mvs_task_prep(t, mvi, is_tmf, tmf, &pass[mvi->id]);
-                if (rc)
-                        dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
-                spin_unlock_irqrestore(&mvi->lock, flags);
-        }
-
-        if (likely(pass[0]))
-                        MVS_CHIP_DISP->start_delivery(mpi->mvi[0],
-                                (mpi->mvi[0]->tx_prod - 1) & (MVS_CHIP_SLOT_SZ - 1));
-
-        if (likely(pass[1]))
-                        MVS_CHIP_DISP->start_delivery(mpi->mvi[1],
-                                (mpi->mvi[1]->tx_prod - 1) & (MVS_CHIP_SLOT_SZ - 1));
-
-        list_del_init(&q);
-
-free_list:
-        if (mvs_list)
-                mvs_task_free_list(mvs_list);
-
-        return rc;
-}
-
-int mvs_queue_command(struct sas_task *task, const int num,
-                        gfp_t gfp_flags)
-{
-        struct mvs_device *mvi_dev = task->dev->lldd_dev;
-        struct sas_ha_struct *sas = mvi_dev->mvi_info->sas;
-
-        if (sas->lldd_max_execute_num < 2)
-                return mvs_task_exec(task, num, gfp_flags, NULL, 0, NULL);
-        else
-                return mvs_collector_task_exec(task, num, gfp_flags, NULL, 0, NULL);
+        return mvs_task_exec(task, gfp_flags, NULL, 0, NULL);
 }
 
 static void mvs_slot_free(struct mvs_info *mvi, u32 rx_desc)
@@ -1411,7 +1310,7 @@ static int mvs_exec_internal_tmf_task(struct domain_device *dev,
                 task->slow_task->timer.expires = jiffies + MVS_TASK_TIMEOUT*HZ;
                 add_timer(&task->slow_task->timer);
 
-                res = mvs_task_exec(task, 1, GFP_KERNEL, NULL, 1, tmf);
+                res = mvs_task_exec(task, GFP_KERNEL, NULL, 1, tmf);
 
                 if (res) {
                         del_timer(&task->slow_task->timer);
diff --git a/drivers/scsi/mvsas/mv_sas.h b/drivers/scsi/mvsas/mv_sas.h
index d6b19dc80bee..dc409c04747a 100644
--- a/drivers/scsi/mvsas/mv_sas.h
+++ b/drivers/scsi/mvsas/mv_sas.h
@@ -65,7 +65,6 @@ extern struct mvs_tgt_initiator mvs_tgt;
 extern struct mvs_info *tgt_mvi;
 extern const struct mvs_dispatch mvs_64xx_dispatch;
 extern const struct mvs_dispatch mvs_94xx_dispatch;
-extern struct kmem_cache *mvs_task_list_cache;
 
 #define DEV_IS_EXPANDER(type)   \
         ((type == SAS_EDGE_EXPANDER_DEVICE) || (type == SAS_FANOUT_EXPANDER_DEVICE))
@@ -440,12 +439,6 @@ struct mvs_task_exec_info {
         int n_elem;
 };
 
-struct mvs_task_list {
-        struct sas_task *task;
-        struct list_head list;
-};
-
-
 /******************** function prototype *********************/
 void mvs_get_sas_addr(void *buf, u32 buflen);
 void mvs_tag_clear(struct mvs_info *mvi, u32 tag);
@@ -462,8 +455,7 @@ void mvs_set_sas_addr(struct mvs_info *mvi, int port_id, u32 off_lo,
                       u32 off_hi, u64 sas_addr);
 void mvs_scan_start(struct Scsi_Host *shost);
 int mvs_scan_finished(struct Scsi_Host *shost, unsigned long time);
-int mvs_queue_command(struct sas_task *task, const int num,
-                        gfp_t gfp_flags);
+int mvs_queue_command(struct sas_task *task, gfp_t gfp_flags);
 int mvs_abort_task(struct sas_task *task);
 int mvs_abort_task_set(struct domain_device *dev, u8 *lun);
 int mvs_clear_aca(struct domain_device *dev, u8 *lun);
diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
index a7305ffc359d..5b93ed810f6e 100644
--- a/drivers/scsi/ncr53c8xx.c
+++ b/drivers/scsi/ncr53c8xx.c
@@ -7997,10 +7997,7 @@ static int ncr53c8xx_slave_configure(struct scsi_device *device)
         if (depth_to_use > MAX_TAGS)
                 depth_to_use = MAX_TAGS;
 
-        scsi_adjust_queue_depth(device,
-                                (device->tagged_supported ?
-                                 MSG_SIMPLE_TAG : 0),
-                                depth_to_use);
+        scsi_change_queue_depth(device, depth_to_use);
 
         /*
         **      Since the queue depth is not tunable under Linux,
diff --git a/drivers/scsi/osd/osd_uld.c b/drivers/scsi/osd/osd_uld.c
index 92cdd4b06526..243eab3d10d0 100644
--- a/drivers/scsi/osd/osd_uld.c
+++ b/drivers/scsi/osd/osd_uld.c
@@ -540,9 +540,9 @@ static int osd_remove(struct device *dev)
  */
 
 static struct scsi_driver osd_driver = {
-        .owner                  = THIS_MODULE,
         .gendrv = {
                 .name           = osd_name,
+                .owner          = THIS_MODULE,
                 .probe          = osd_probe,
                 .remove         = osd_remove,
         }
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index dff37a250d79..5033223f6287 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -172,9 +172,9 @@ static int osst_probe(struct device *);
 static int osst_remove(struct device *);
 
 static struct scsi_driver osst_template = {
-        .owner                  = THIS_MODULE,
         .gendrv = {
                 .name           =  "osst",
+                .owner          = THIS_MODULE,
                 .probe          = osst_probe,
                 .remove         = osst_remove,
         }
@@ -259,9 +259,10 @@ static int osst_chk_result(struct osst_tape * STp, struct osst_request * SRpnt)
                    SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
                    SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
                 if (scode) printk(OSST_DEB_MSG "%s:D: Sense: %02x, ASC: %02x, ASCQ: %02x\n",
-                                name, scode, sense[12], sense[13]);
+                                  name, scode, sense[12], sense[13]);
                 if (cmdstatp->have_sense)
-                        __scsi_print_sense("osst ", SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
+                        __scsi_print_sense(STp->device, name,
+                                           SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
         }
         else
 #endif
@@ -275,7 +276,8 @@ static int osst_chk_result(struct osst_tape * STp, struct osst_request * SRpnt)
                  SRpnt->cmd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */
                 if (cmdstatp->have_sense) {
                         printk(KERN_WARNING "%s:W: Command with sense data:\n", name);
-                        __scsi_print_sense("osst ", SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
+                        __scsi_print_sense(STp->device, name,
+                                           SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
                 }
                 else {
                         static  int     notyetprinted = 1;
@@ -3325,19 +3327,18 @@ static int osst_write_frame(struct osst_tape * STp, struct osst_request ** aSRpn
 /* Lock or unlock the drive door. Don't use when struct osst_request allocated. */
 static int do_door_lock(struct osst_tape * STp, int do_lock)
 {
-        int retval, cmd;
+        int retval;
 
-        cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
 #if DEBUG
         printk(OSST_DEB_MSG "%s:D: %socking drive door.\n", tape_name(STp), do_lock ? "L" : "Unl");
 #endif
-        retval = scsi_ioctl(STp->device, cmd, NULL);
-        if (!retval) {
+
+        retval = scsi_set_medium_removal(STp->device,
+                        do_lock ? SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW);
+        if (!retval)
                 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
-        }
-        else {
+        else
                 STp->door_locked = ST_LOCK_FAILS;
-        }
         return retval;
 }
 
@@ -4967,10 +4968,10 @@ static long osst_ioctl(struct file * file,
          * may try and take the device offline, in which case all further
          * access to the device is prohibited.
          */
-        if( !scsi_block_when_processing_errors(STp->device) ) {
-                retval = (-ENXIO);
+        retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in,
+                        file->f_flags & O_NDELAY);
+        if (retval)
                 goto out;
-        }
 
         cmd_type = _IOC_TYPE(cmd_in);
         cmd_nr   = _IOC_NR(cmd_in);
diff --git a/drivers/scsi/pas16.c b/drivers/scsi/pas16.c
index 80bacb5dc1d4..e81eadd08afc 100644
--- a/drivers/scsi/pas16.c
+++ b/drivers/scsi/pas16.c
@@ -1,6 +1,4 @@
-#define AUTOSENSE
 #define PSEUDO_DMA
-#define FOO
 #define UNSAFE  /* Not unsafe for PAS16 -- use it */
 #define PDEBUG 0
 
@@ -24,47 +22,9 @@
  * Media Vision
  * (510) 770-8600
  * (800) 348-7116
- * 
- * and 
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 /*
- * Options : 
- * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
- *      for commands that return with a CHECK CONDITION status. 
- *
- * LIMIT_TRANSFERSIZE - if defined, limit the pseudo-dma transfers to 512
- *      bytes at a time.  Since interrupts are disabled by default during
- *      these transfers, we might need this to give reasonable interrupt
- *      service time if the transfer size gets too large.
- *
- * PSEUDO_DMA - enables PSEUDO-DMA hardware, should give a 3-4X performance
- * increase compared to polled I/O.
- *
- * PARITY - enable parity checking.  Not supported.
- * 
- * SCSI2 - enable support for SCSI-II tagged queueing.  Untested.
- *
- * UNSAFE - leave interrupts enabled during pseudo-DMA transfers.  This
- *          parameter comes from the NCR5380 code.  It is NOT unsafe with
- *          the PAS16 and you should use it.  If you don't you will have
- *          a problem with dropped characters during high speed
- *          communications during SCSI transfers.  If you really don't
- *          want to use UNSAFE you can try defining LIMIT_TRANSFERSIZE or
- *          twiddle with the transfer size in the high level code.
- *
- * USLEEP - enable support for devices that don't disconnect.  Untested.
- *
  * The card is detected and initialized in one of several ways : 
  * 1.  Autoprobe (default) - There are many different models of
  *     the Pro Audio Spectrum/Studio 16, and I only have one of
@@ -102,13 +62,11 @@
  *   If you have problems with your card not being recognized, use
  *   the LILO command line override.  Try to get it recognized without
  *   interrupts.  Ie, for a board at the default 0x388 base port,
- *   boot: linux pas16=0x388,255
+ *   boot: linux pas16=0x388,0
  *
- *   SCSI_IRQ_NONE (255) should be specified for no interrupt,
+ *   NO_IRQ (0) should be specified for no interrupt,
  *   IRQ_AUTO (254) to autoprobe for an IRQ line if overridden
  *   on the command line.
- *
- *   (IRQ_AUTO == 254, SCSI_IRQ_NONE == 255 in NCR5380.h)
  */
  
 #include <linux/module.h>
@@ -123,15 +81,12 @@
 #include <linux/stat.h>
 #include <linux/init.h>
 
-#include "scsi.h"
 #include <scsi/scsi_host.h>
 #include "pas16.h"
 #define AUTOPROBE_IRQ
 #include "NCR5380.h"
 
 
-static int pas_maxi = 0;
-static int pas_wmaxi = 0;
 static unsigned short pas16_addr = 0;
 static int pas16_irq = 0;
  
@@ -337,6 +292,7 @@ static int __init
 }
 
 
+#ifndef MODULE
 /*
  * Function : pas16_setup(char *str, int *ints)
  *
@@ -347,10 +303,13 @@ static int __init
  *
  */
 
-void __init pas16_setup(char *str, int *ints)
+static int __init pas16_setup(char *str)
 {
     static int commandline_current = 0;
     int i;
+    int ints[10];
+
+    get_options(str, ARRAY_SIZE(ints), ints);
     if (ints[0] != 2) 
         printk("pas16_setup : usage pas16=io_port,irq\n");
     else 
@@ -364,8 +323,12 @@ void __init pas16_setup(char *str, int *ints)
                 }
             ++commandline_current;
         }
+    return 1;
 }
 
+__setup("pas16=", pas16_setup);
+#endif
+
 /* 
  * Function : int pas16_detect(struct scsi_host_template * tpnt)
  *
@@ -379,7 +342,7 @@ void __init pas16_setup(char *str, int *ints)
  *
  */
 
-int __init pas16_detect(struct scsi_host_template * tpnt)
+static int __init pas16_detect(struct scsi_host_template *tpnt)
 {
     static int current_override = 0;
     static unsigned short current_base = 0;
@@ -387,10 +350,6 @@ int __init pas16_detect(struct scsi_host_template * tpnt)
     unsigned short io_port;
     int  count;
 
-    tpnt->proc_name = "pas16";
-    tpnt->show_info = pas16_show_info;
-    tpnt->write_info = pas16_write_info;
-
     if (pas16_addr != 0) {
         overrides[0].io_port = pas16_addr;
         /*
@@ -452,15 +411,19 @@ int __init pas16_detect(struct scsi_host_template * tpnt)
         else 
             instance->irq = NCR5380_probe_irq(instance, PAS16_IRQS);
 
-        if (instance->irq != SCSI_IRQ_NONE) 
+        /* Compatibility with documented NCR5380 kernel parameters */
+        if (instance->irq == 255)
+                instance->irq = NO_IRQ;
+
+        if (instance->irq != NO_IRQ)
             if (request_irq(instance->irq, pas16_intr, 0,
                             "pas16", instance)) {
                 printk("scsi%d : IRQ%d not free, interrupts disabled\n", 
                     instance->host_no, instance->irq);
-                instance->irq = SCSI_IRQ_NONE;
+                instance->irq = NO_IRQ;
             } 
 
-        if (instance->irq == SCSI_IRQ_NONE) {
+        if (instance->irq == NO_IRQ) {
             printk("scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
             printk("scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
             /* Disable 5380 interrupts, leave drive params the same */
@@ -472,17 +435,6 @@ int __init pas16_detect(struct scsi_host_template * tpnt)
         printk("scsi%d : irq = %d\n", instance->host_no, instance->irq);
 #endif
 
-        printk("scsi%d : at 0x%04x", instance->host_no, (int) 
-            instance->io_port);
-        if (instance->irq == SCSI_IRQ_NONE)
-            printk (" interrupts disabled");
-        else 
-            printk (" irq %d", instance->irq);
-        printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d",
-            CAN_QUEUE, CMD_PER_LUN, PAS16_PUBLIC_RELEASE);
-        NCR5380_print_options(instance);
-        printk("\n");
-
         ++current_override;
         ++count;
     }
@@ -509,8 +461,8 @@ int __init pas16_detect(struct scsi_host_template * tpnt)
  * and matching the H_C_S coordinates to what DOS uses.
  */
 
-int pas16_biosparam(struct scsi_device *sdev, struct block_device *dev,
-                sector_t capacity, int * ip)
+static int pas16_biosparam(struct scsi_device *sdev, struct block_device *dev,
+                           sector_t capacity, int *ip)
 {
   int size = capacity;
   ip[0] = 64;
@@ -547,6 +499,7 @@ static inline int NCR5380_pread (struct Scsi_Host *instance, unsigned char *dst,
         P_DATA_REG_OFFSET);
     register int i = len;
     int ii = 0;
+    struct NCR5380_hostdata *hostdata = shost_priv(instance);
 
     while ( !(inb(instance->io_port + P_STATUS_REG_OFFSET) & P_ST_RDY) )
          ++ii;
@@ -559,8 +512,8 @@ static inline int NCR5380_pread (struct Scsi_Host *instance, unsigned char *dst,
             instance->host_no);
         return -1;
     }
-   if (ii > pas_maxi)
-      pas_maxi = ii;
+    if (ii > hostdata->spin_max_r)
+        hostdata->spin_max_r = ii;
     return 0;
 }
 
@@ -583,6 +536,7 @@ static inline int NCR5380_pwrite (struct Scsi_Host *instance, unsigned char *src
     register unsigned short reg = (instance->io_port + P_DATA_REG_OFFSET);
     register int i = len;
     int ii = 0;
+    struct NCR5380_hostdata *hostdata = shost_priv(instance);
 
     while ( !((inb(instance->io_port + P_STATUS_REG_OFFSET)) & P_ST_RDY) )
          ++ii;
@@ -595,8 +549,8 @@ static inline int NCR5380_pwrite (struct Scsi_Host *instance, unsigned char *src
             instance->host_no);
         return -1;
     }
-    if (ii > pas_maxi)
-         pas_wmaxi = ii;
+    if (ii > hostdata->spin_max_w)
+        hostdata->spin_max_w = ii;
     return 0;
 }
 
@@ -604,7 +558,7 @@ static inline int NCR5380_pwrite (struct Scsi_Host *instance, unsigned char *src
 
 static int pas16_release(struct Scsi_Host *shost)
 {
-        if (shost->irq)
+        if (shost->irq != NO_IRQ)
                 free_irq(shost->irq, shost);
         NCR5380_exit(shost);
         if (shost->io_port && shost->n_io_port)
@@ -617,6 +571,10 @@ static struct scsi_host_template driver_template = {
         .name           = "Pro Audio Spectrum-16 SCSI",
         .detect         = pas16_detect,
         .release        = pas16_release,
+        .proc_name      = "pas16",
+        .show_info      = pas16_show_info,
+        .write_info     = pas16_write_info,
+        .info           = pas16_info,
         .queuecommand   = pas16_queue_command,
         .eh_abort_handler = pas16_abort,
         .eh_bus_reset_handler = pas16_bus_reset,
diff --git a/drivers/scsi/pas16.h b/drivers/scsi/pas16.h
index aa528f53c533..c6109c80050b 100644
--- a/drivers/scsi/pas16.h
+++ b/drivers/scsi/pas16.h
@@ -18,26 +18,12 @@
  * Media Vision
  * (510) 770-8600
  * (800) 348-7116
- * 
- * and 
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 
 #ifndef PAS16_H
 #define PAS16_H
 
-#define PAS16_PUBLIC_RELEASE 3
-
 #define PDEBUG_INIT     0x1
 #define PDEBUG_TRANSFER 0x2
 
@@ -114,12 +100,6 @@
 
 
 #ifndef ASM
-static int pas16_abort(Scsi_Cmnd *);
-static int pas16_biosparam(struct scsi_device *, struct block_device *,
-                           sector_t, int*);
-static int pas16_detect(struct scsi_host_template *);
-static int pas16_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
-static int pas16_bus_reset(Scsi_Cmnd *);
 
 #ifndef CMD_PER_LUN
 #define CMD_PER_LUN 2
@@ -161,6 +141,7 @@ static int pas16_bus_reset(Scsi_Cmnd *);
 #define NCR5380_queue_command pas16_queue_command
 #define NCR5380_abort pas16_abort
 #define NCR5380_bus_reset pas16_bus_reset
+#define NCR5380_info pas16_info
 #define NCR5380_show_info pas16_show_info
 #define NCR5380_write_info pas16_write_info
 
diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
index 666bf5af06e2..329aba0083ab 100644
--- a/drivers/scsi/pm8001/pm8001_init.c
+++ b/drivers/scsi/pm8001/pm8001_init.c
@@ -89,6 +89,8 @@ static struct scsi_host_template pm8001_sht = {
         .target_destroy         = sas_target_destroy,
         .ioctl                  = sas_ioctl,
         .shost_attrs            = pm8001_host_attrs,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
 
 /**
@@ -599,8 +601,6 @@ static void  pm8001_post_sas_ha_init(struct Scsi_Host *shost,
         sha->lldd_module = THIS_MODULE;
         sha->sas_addr = &pm8001_ha->sas_addr[0];
         sha->num_phys = chip_info->n_phy;
-        sha->lldd_max_execute_num = 1;
-        sha->lldd_queue_size = PM8001_CAN_QUEUE;
         sha->core.shost = shost;
 }
 
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index 76570e6a547d..b93f289b42b3 100644
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -350,7 +350,7 @@ static int sas_find_local_port_id(struct domain_device *dev)
   */
 #define DEV_IS_GONE(pm8001_dev) \
         ((!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED)))
-static int pm8001_task_exec(struct sas_task *task, const int num,
+static int pm8001_task_exec(struct sas_task *task,
         gfp_t gfp_flags, int is_tmf, struct pm8001_tmf_task *tmf)
 {
         struct domain_device *dev = task->dev;
@@ -360,7 +360,6 @@ static int pm8001_task_exec(struct sas_task *task, const int num,
         struct sas_task *t = task;
         struct pm8001_ccb_info *ccb;
         u32 tag = 0xdeadbeef, rc, n_elem = 0;
-        u32 n = num;
         unsigned long flags = 0;
 
         if (!dev->port) {
@@ -387,18 +386,12 @@ static int pm8001_task_exec(struct sas_task *task, const int num,
                                 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
                                 t->task_done(t);
                                 spin_lock_irqsave(&pm8001_ha->lock, flags);
-                                if (n > 1)
-                                        t = list_entry(t->list.next,
-                                                        struct sas_task, list);
                                 continue;
                         } else {
                                 struct task_status_struct *ts = &t->task_status;
                                 ts->resp = SAS_TASK_UNDELIVERED;
                                 ts->stat = SAS_PHY_DOWN;
                                 t->task_done(t);
-                                if (n > 1)
-                                        t = list_entry(t->list.next,
-                                                        struct sas_task, list);
                                 continue;
                         }
                 }
@@ -460,9 +453,7 @@ static int pm8001_task_exec(struct sas_task *task, const int num,
                 t->task_state_flags |= SAS_TASK_AT_INITIATOR;
                 spin_unlock(&t->task_state_lock);
                 pm8001_dev->running_req++;
-                if (n > 1)
-                        t = list_entry(t->list.next, struct sas_task, list);
-        } while (--n);
+        } while (0);
         rc = 0;
         goto out_done;
 
@@ -483,14 +474,11 @@ out_done:
   * pm8001_queue_command - register for upper layer used, all IO commands sent
   * to HBA are from this interface.
   * @task: the task to be execute.
-  * @num: if can_queue great than 1, the task can be queued up. for SMP task,
-  * we always execute one one time
   * @gfp_flags: gfp_flags
   */
-int pm8001_queue_command(struct sas_task *task, const int num,
-                gfp_t gfp_flags)
+int pm8001_queue_command(struct sas_task *task, gfp_t gfp_flags)
 {
-        return pm8001_task_exec(task, num, gfp_flags, 0, NULL);
+        return pm8001_task_exec(task, gfp_flags, 0, NULL);
 }
 
 /**
@@ -708,7 +696,7 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
                 task->slow_task->timer.expires = jiffies + PM8001_TASK_TIMEOUT*HZ;
                 add_timer(&task->slow_task->timer);
 
-                res = pm8001_task_exec(task, 1, GFP_KERNEL, 1, tmf);
+                res = pm8001_task_exec(task, GFP_KERNEL, 1, tmf);
 
                 if (res) {
                         del_timer(&task->slow_task->timer);
diff --git a/drivers/scsi/pm8001/pm8001_sas.h b/drivers/scsi/pm8001/pm8001_sas.h
index f6b2ac59dae4..8dd8b7840f04 100644
--- a/drivers/scsi/pm8001/pm8001_sas.h
+++ b/drivers/scsi/pm8001/pm8001_sas.h
@@ -623,8 +623,7 @@ int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
         void *funcdata);
 void pm8001_scan_start(struct Scsi_Host *shost);
 int pm8001_scan_finished(struct Scsi_Host *shost, unsigned long time);
-int pm8001_queue_command(struct sas_task *task, const int num,
-        gfp_t gfp_flags);
+int pm8001_queue_command(struct sas_task *task, gfp_t gfp_flags);
 int pm8001_abort_task(struct sas_task *task);
 int pm8001_abort_task_set(struct domain_device *dev, u8 *lun);
 int pm8001_clear_aca(struct domain_device *dev, u8 *lun);
diff --git a/drivers/scsi/pmcraid.c b/drivers/scsi/pmcraid.c
index bcb64eb1387f..b1b1f66b1ab7 100644
--- a/drivers/scsi/pmcraid.c
+++ b/drivers/scsi/pmcraid.c
@@ -249,15 +249,11 @@ static int pmcraid_slave_configure(struct scsi_device *scsi_dev)
                                       PMCRAID_VSET_MAX_SECTORS);
         }
 
-        if (scsi_dev->tagged_supported &&
-            (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry))) {
-                scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
-                scsi_adjust_queue_depth(scsi_dev, MSG_SIMPLE_TAG,
-                                        scsi_dev->host->cmd_per_lun);
-        } else {
-                scsi_adjust_queue_depth(scsi_dev, 0,
-                                        scsi_dev->host->cmd_per_lun);
-        }
+        /*
+         * We never want to report TCQ support for these types of devices.
+         */
+        if (!RES_IS_GSCSI(res->cfg_entry) && !RES_IS_VSET(res->cfg_entry))
+                scsi_dev->tagged_supported = 0;
 
         return 0;
 }
@@ -289,55 +285,18 @@ static void pmcraid_slave_destroy(struct scsi_device *scsi_dev)
  * pmcraid_change_queue_depth - Change the device's queue depth
  * @scsi_dev: scsi device struct
  * @depth: depth to set
- * @reason: calling context
  *
  * Return value
  *      actual depth set
  */
-static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth,
-                                      int reason)
+static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth)
 {
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         if (depth > PMCRAID_MAX_CMD_PER_LUN)
                 depth = PMCRAID_MAX_CMD_PER_LUN;
-
-        scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev), depth);
-
-        return scsi_dev->queue_depth;
+        return scsi_change_queue_depth(scsi_dev, depth);
 }
 
 /**
- * pmcraid_change_queue_type - Change the device's queue type
- * @scsi_dev: scsi device struct
- * @tag: type of tags to use
- *
- * Return value:
- *      actual queue type set
- */
-static int pmcraid_change_queue_type(struct scsi_device *scsi_dev, int tag)
-{
-        struct pmcraid_resource_entry *res;
-
-        res = (struct pmcraid_resource_entry *)scsi_dev->hostdata;
-
-        if ((res) && scsi_dev->tagged_supported &&
-            (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry))) {
-                scsi_set_tag_type(scsi_dev, tag);
-
-                if (tag)
-                        scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
-                else
-                        scsi_deactivate_tcq(scsi_dev, scsi_dev->queue_depth);
-        } else
-                tag = 0;
-
-        return tag;
-}
-
-
-/**
  * pmcraid_init_cmdblk - initializes a command block
  *
  * @cmd: pointer to struct pmcraid_cmd to be initialized
@@ -3175,36 +3134,6 @@ static int pmcraid_eh_host_reset_handler(struct scsi_cmnd *scmd)
 }
 
 /**
- * pmcraid_task_attributes - Translate SPI Q-Tags to task attributes
- * @scsi_cmd:   scsi command struct
- *
- * Return value
- *        number of tags or 0 if the task is not tagged
- */
-static u8 pmcraid_task_attributes(struct scsi_cmnd *scsi_cmd)
-{
-        char tag[2];
-        u8 rc = 0;
-
-        if (scsi_populate_tag_msg(scsi_cmd, tag)) {
-                switch (tag[0]) {
-                case MSG_SIMPLE_TAG:
-                        rc = TASK_TAG_SIMPLE;
-                        break;
-                case MSG_HEAD_TAG:
-                        rc = TASK_TAG_QUEUE_HEAD;
-                        break;
-                case MSG_ORDERED_TAG:
-                        rc = TASK_TAG_ORDERED;
-                        break;
-                };
-        }
-
-        return rc;
-}
-
-
-/**
  * pmcraid_init_ioadls - initializes IOADL related fields in IOARCB
  * @cmd: pmcraid command struct
  * @sgcount: count of scatter-gather elements
@@ -3559,7 +3488,9 @@ static int pmcraid_queuecommand_lck(
                 }
 
                 ioarcb->request_flags0 |= NO_LINK_DESCS;
-                ioarcb->request_flags1 |= pmcraid_task_attributes(scsi_cmd);
+
+                if (scsi_cmd->flags & SCMD_TAGGED)
+                        ioarcb->request_flags1 |= TASK_TAG_SIMPLE;
 
                 if (RES_IS_GSCSI(res->cfg_entry))
                         ioarcb->request_flags1 |= DELAY_AFTER_RESET;
@@ -4320,7 +4251,7 @@ static struct scsi_host_template pmcraid_host_template = {
         .slave_configure = pmcraid_slave_configure,
         .slave_destroy = pmcraid_slave_destroy,
         .change_queue_depth = pmcraid_change_queue_depth,
-        .change_queue_type  = pmcraid_change_queue_type,
+        .change_queue_type  = scsi_change_queue_type,
         .can_queue = PMCRAID_MAX_IO_CMD,
         .this_id = -1,
         .sg_tablesize = PMCRAID_MAX_IOADLS,
@@ -4329,7 +4260,8 @@ static struct scsi_host_template pmcraid_host_template = {
         .cmd_per_lun = PMCRAID_MAX_CMD_PER_LUN,
         .use_clustering = ENABLE_CLUSTERING,
         .shost_attrs = pmcraid_host_attrs,
-        .proc_name = PMCRAID_DRIVER_NAME
+        .proc_name = PMCRAID_DRIVER_NAME,
+        .use_blk_tags = 1,
 };
 
 /*
diff --git a/drivers/scsi/ps3rom.c b/drivers/scsi/ps3rom.c
index ef23fabe3924..b3b48b5a984c 100644
--- a/drivers/scsi/ps3rom.c
+++ b/drivers/scsi/ps3rom.c
@@ -220,10 +220,6 @@ static int ps3rom_queuecommand_lck(struct scsi_cmnd *cmd,
         unsigned char opcode;
         int res;
 
-#ifdef DEBUG
-        scsi_print_command(cmd);
-#endif
-
         priv->curr_cmd = cmd;
         cmd->scsi_done = done;
 
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 158020522dfb..c68a66e8cfc1 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -1224,10 +1224,9 @@ qla1280_slave_configure(struct scsi_device *device)
 
         if (device->tagged_supported &&
             (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
-                scsi_adjust_queue_depth(device, MSG_ORDERED_TAG,
-                                        ha->bus_settings[bus].hiwat);
+                scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);
         } else {
-                scsi_adjust_queue_depth(device, 0, default_depth);
+                scsi_change_queue_depth(device, default_depth);
         }
 
         nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index b1865a72ce59..7686bfe9a4a9 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -752,8 +752,6 @@ extern void qla8044_set_idc_dontreset(struct scsi_qla_host *ha);
 extern int qla8044_rd_direct(struct scsi_qla_host *vha, const uint32_t crb_reg);
 extern void qla8044_wr_direct(struct scsi_qla_host *vha,
                               const uint32_t crb_reg, const uint32_t value);
-extern inline void qla8044_set_qsnt_ready(struct scsi_qla_host *vha);
-extern inline void qla8044_need_reset_handler(struct scsi_qla_host *vha);
 extern int qla8044_device_state_handler(struct scsi_qla_host *vha);
 extern void qla8044_clear_qsnt_ready(struct scsi_qla_host *vha);
 extern void qla8044_clear_drv_active(struct qla_hw_data *);
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index f0edb07f3198..a1ab25fca874 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -325,7 +325,6 @@ qla2x00_start_scsi(srb_t *sp)
         struct qla_hw_data *ha;
         struct req_que *req;
         struct rsp_que *rsp;
-        char            tag[2];
 
         /* Setup device pointers. */
         ret = 0;
@@ -404,26 +403,7 @@ qla2x00_start_scsi(srb_t *sp)
         /* Set target ID and LUN number*/
         SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id);
         cmd_pkt->lun = cpu_to_le16(cmd->device->lun);
-
-        /* Update tagged queuing modifier */
-        if (scsi_populate_tag_msg(cmd, tag)) {
-                switch (tag[0]) {
-                case HEAD_OF_QUEUE_TAG:
-                        cmd_pkt->control_flags =
-                            __constant_cpu_to_le16(CF_HEAD_TAG);
-                        break;
-                case ORDERED_QUEUE_TAG:
-                        cmd_pkt->control_flags =
-                            __constant_cpu_to_le16(CF_ORDERED_TAG);
-                        break;
-                default:
-                        cmd_pkt->control_flags =
-                            __constant_cpu_to_le16(CF_SIMPLE_TAG);
-                        break;
-                }
-        } else {
-                cmd_pkt->control_flags = __constant_cpu_to_le16(CF_SIMPLE_TAG);
-        }
+        cmd_pkt->control_flags = __constant_cpu_to_le16(CF_SIMPLE_TAG);
 
         /* Load SCSI command packet. */
         memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len);
@@ -1264,7 +1244,6 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
         uint16_t                fcp_cmnd_len;
         struct fcp_cmnd         *fcp_cmnd;
         dma_addr_t              crc_ctx_dma;
-        char                    tag[2];
 
         cmd = GET_CMD_SP(sp);
 
@@ -1356,25 +1335,7 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
         cmd_pkt->fcp_cmnd_dseg_address[1] = cpu_to_le32(
             MSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF));
         fcp_cmnd->task_management = 0;
-
-        /*
-         * Update tagged queuing modifier if using command tag queuing
-         */
-        if (scsi_populate_tag_msg(cmd, tag)) {
-                switch (tag[0]) {
-                case HEAD_OF_QUEUE_TAG:
-                    fcp_cmnd->task_attribute = TSK_HEAD_OF_QUEUE;
-                    break;
-                case ORDERED_QUEUE_TAG:
-                    fcp_cmnd->task_attribute = TSK_ORDERED;
-                    break;
-                default:
-                    fcp_cmnd->task_attribute = TSK_SIMPLE;
-                    break;
-                }
-        } else {
-                fcp_cmnd->task_attribute = TSK_SIMPLE;
-        }
+        fcp_cmnd->task_attribute = TSK_SIMPLE;
 
         cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */
 
@@ -1495,7 +1456,6 @@ qla24xx_start_scsi(srb_t *sp)
         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
         struct scsi_qla_host *vha = sp->fcport->vha;
         struct qla_hw_data *ha = vha->hw;
-        char            tag[2];
 
         /* Setup device pointers. */
         ret = 0;
@@ -1578,22 +1538,7 @@ qla24xx_start_scsi(srb_t *sp)
         int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
         host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
 
-        /* Update tagged queuing modifier -- default is TSK_SIMPLE (0). */
-        if (scsi_populate_tag_msg(cmd, tag)) {
-                switch (tag[0]) {
-                case HEAD_OF_QUEUE_TAG:
-                        cmd_pkt->task = TSK_HEAD_OF_QUEUE;
-                        break;
-                case ORDERED_QUEUE_TAG:
-                        cmd_pkt->task = TSK_ORDERED;
-                        break;
-                default:
-                    cmd_pkt->task = TSK_SIMPLE;
-                    break;
-                }
-        } else {
-                cmd_pkt->task = TSK_SIMPLE;
-        }
+        cmd_pkt->task = TSK_SIMPLE;
 
         /* Load SCSI command packet. */
         memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
@@ -2310,7 +2255,6 @@ qla82xx_start_scsi(srb_t *sp)
         struct qla_hw_data *ha = vha->hw;
         struct req_que *req = NULL;
         struct rsp_que *rsp = NULL;
-        char tag[2];
 
         /* Setup device pointers. */
         ret = 0;
@@ -2489,22 +2433,6 @@ sufficient_dsds:
                 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
                         ctx->fcp_cmnd->additional_cdb_len |= 2;
 
-                /*
-                 * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
-                 */
-                if (scsi_populate_tag_msg(cmd, tag)) {
-                        switch (tag[0]) {
-                        case HEAD_OF_QUEUE_TAG:
-                                ctx->fcp_cmnd->task_attribute =
-                                    TSK_HEAD_OF_QUEUE;
-                                break;
-                        case ORDERED_QUEUE_TAG:
-                                ctx->fcp_cmnd->task_attribute =
-                                    TSK_ORDERED;
-                                break;
-                        }
-                }
-
                 /* Populate the FCP_PRIO. */
                 if (ha->flags.fcp_prio_enabled)
                         ctx->fcp_cmnd->task_attribute |=
@@ -2565,20 +2493,6 @@ sufficient_dsds:
                 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun,
                     sizeof(cmd_pkt->lun));
 
-                /*
-                 * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
-                 */
-                if (scsi_populate_tag_msg(cmd, tag)) {
-                        switch (tag[0]) {
-                        case HEAD_OF_QUEUE_TAG:
-                                cmd_pkt->task = TSK_HEAD_OF_QUEUE;
-                                break;
-                        case ORDERED_QUEUE_TAG:
-                                cmd_pkt->task = TSK_ORDERED;
-                                break;
-                        }
-                }
-
                 /* Populate the FCP_PRIO. */
                 if (ha->flags.fcp_prio_enabled)
                         cmd_pkt->task |= sp->fcport->fcp_prio << 3;
diff --git a/drivers/scsi/qla2xxx/qla_mr.c b/drivers/scsi/qla2xxx/qla_mr.c
index 80867599527d..6d190b4b82a0 100644
--- a/drivers/scsi/qla2xxx/qla_mr.c
+++ b/drivers/scsi/qla2xxx/qla_mr.c
@@ -3086,7 +3086,6 @@ qlafx00_start_scsi(srb_t *sp)
         struct cmd_type_7_fx00 *cmd_pkt;
         struct cmd_type_7_fx00 lcmd_pkt;
         struct scsi_lun llun;
-        char            tag[2];
 
         /* Setup device pointers. */
         ret = 0;
@@ -3157,18 +3156,6 @@ qlafx00_start_scsi(srb_t *sp)
         host_to_adap((uint8_t *)&llun, (uint8_t *)&lcmd_pkt.lun,
             sizeof(lcmd_pkt.lun));
 
-        /* Update tagged queuing modifier -- default is TSK_SIMPLE (0). */
-        if (scsi_populate_tag_msg(cmd, tag)) {
-                switch (tag[0]) {
-                case HEAD_OF_QUEUE_TAG:
-                        lcmd_pkt.task = TSK_HEAD_OF_QUEUE;
-                        break;
-                case ORDERED_QUEUE_TAG:
-                        lcmd_pkt.task = TSK_ORDERED;
-                        break;
-                }
-        }
-
         /* Load SCSI command packet. */
         host_to_adap(cmd->cmnd, lcmd_pkt.fcp_cdb, sizeof(lcmd_pkt.fcp_cdb));
         lcmd_pkt.byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
diff --git a/drivers/scsi/qla2xxx/qla_nx2.c b/drivers/scsi/qla2xxx/qla_nx2.c
index 24a852828b5d..ed4d6b6b53e3 100644
--- a/drivers/scsi/qla2xxx/qla_nx2.c
+++ b/drivers/scsi/qla2xxx/qla_nx2.c
@@ -238,7 +238,7 @@ qla8044_rmw_crb_reg(struct scsi_qla_host *vha,
         return;
 }
 
-inline void
+static inline void
 qla8044_set_qsnt_ready(struct scsi_qla_host *vha)
 {
         uint32_t qsnt_state;
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index db3dbd999cb6..6b4d9235368a 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -236,8 +236,6 @@ static int qla2xxx_eh_target_reset(struct scsi_cmnd *);
 static int qla2xxx_eh_bus_reset(struct scsi_cmnd *);
 static int qla2xxx_eh_host_reset(struct scsi_cmnd *);
 
-static int qla2x00_change_queue_depth(struct scsi_device *, int, int);
-static int qla2x00_change_queue_type(struct scsi_device *, int);
 static void qla2x00_clear_drv_active(struct qla_hw_data *);
 static void qla2x00_free_device(scsi_qla_host_t *);
 static void qla83xx_disable_laser(scsi_qla_host_t *vha);
@@ -259,8 +257,8 @@ struct scsi_host_template qla2xxx_driver_template = {
         .slave_destroy          = qla2xxx_slave_destroy,
         .scan_finished          = qla2xxx_scan_finished,
         .scan_start             = qla2xxx_scan_start,
-        .change_queue_depth     = qla2x00_change_queue_depth,
-        .change_queue_type      = qla2x00_change_queue_type,
+        .change_queue_depth     = scsi_change_queue_depth,
+        .change_queue_type      = scsi_change_queue_type,
         .this_id                = -1,
         .cmd_per_lun            = 3,
         .use_clustering         = ENABLE_CLUSTERING,
@@ -270,6 +268,8 @@ struct scsi_host_template qla2xxx_driver_template = {
         .shost_attrs            = qla2x00_host_attrs,
 
         .supported_mode         = MODE_INITIATOR,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
 
 static struct scsi_transport_template *qla2xxx_transport_template = NULL;
@@ -1405,10 +1405,7 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
         if (IS_T10_PI_CAPABLE(vha->hw))
                 blk_queue_update_dma_alignment(sdev->request_queue, 0x7);
 
-        if (sdev->tagged_supported)
-                scsi_activate_tcq(sdev, req->max_q_depth);
-        else
-                scsi_deactivate_tcq(sdev, req->max_q_depth);
+        scsi_change_queue_depth(sdev, req->max_q_depth);
         return 0;
 }
 
@@ -1418,76 +1415,6 @@ qla2xxx_slave_destroy(struct scsi_device *sdev)
         sdev->hostdata = NULL;
 }
 
-static void qla2x00_handle_queue_full(struct scsi_device *sdev, int qdepth)
-{
-        fc_port_t *fcport = (struct fc_port *) sdev->hostdata;
-
-        if (!scsi_track_queue_full(sdev, qdepth))
-                return;
-
-        ql_dbg(ql_dbg_io, fcport->vha, 0x3029,
-            "Queue depth adjusted-down to %d for nexus=%ld:%d:%llu.\n",
-            sdev->queue_depth, fcport->vha->host_no, sdev->id, sdev->lun);
-}
-
-static void qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, int qdepth)
-{
-        fc_port_t *fcport = sdev->hostdata;
-        struct scsi_qla_host *vha = fcport->vha;
-        struct req_que *req = NULL;
-
-        req = vha->req;
-        if (!req)
-                return;
-
-        if (req->max_q_depth <= sdev->queue_depth || req->max_q_depth < qdepth)
-                return;
-
-        if (sdev->ordered_tags)
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, qdepth);
-        else
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, qdepth);
-
-        ql_dbg(ql_dbg_io, vha, 0x302a,
-            "Queue depth adjusted-up to %d for nexus=%ld:%d:%llu.\n",
-            sdev->queue_depth, fcport->vha->host_no, sdev->id, sdev->lun);
-}
-
-static int
-qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
-{
-        switch (reason) {
-        case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-                break;
-        case SCSI_QDEPTH_QFULL:
-                qla2x00_handle_queue_full(sdev, qdepth);
-                break;
-        case SCSI_QDEPTH_RAMP_UP:
-                qla2x00_adjust_sdev_qdepth_up(sdev, qdepth);
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-
-        return sdev->queue_depth;
-}
-
-static int
-qla2x00_change_queue_type(struct scsi_device *sdev, int tag_type)
-{
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, tag_type);
-                if (tag_type)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                tag_type = 0;
-
-        return tag_type;
-}
-
 /**
  * qla2x00_config_dma_addressing() - Configure OS DMA addressing method.
  * @ha: HA context
diff --git a/drivers/scsi/qla4xxx/ql4_iocb.c b/drivers/scsi/qla4xxx/ql4_iocb.c
index 08ab6dac226d..17222eb49762 100644
--- a/drivers/scsi/qla4xxx/ql4_iocb.c
+++ b/drivers/scsi/qla4xxx/ql4_iocb.c
@@ -280,7 +280,6 @@ int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
         uint16_t req_cnt;
         unsigned long flags;
         uint32_t index;
-        char tag[2];
 
         /* Get real lun and adapter */
         ddb_entry = srb->ddb;
@@ -352,15 +351,6 @@ int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
 
         /* Set tagged queueing control flags */
         cmd_entry->control_flags |= CF_SIMPLE_TAG;
-        if (scsi_populate_tag_msg(cmd, tag))
-                switch (tag[0]) {
-                case MSG_HEAD_TAG:
-                        cmd_entry->control_flags |= CF_HEAD_TAG;
-                        break;
-                case MSG_ORDERED_TAG:
-                        cmd_entry->control_flags |= CF_ORDERED_TAG;
-                        break;
-                }
 
         qla4xxx_advance_req_ring_ptr(ha);
         qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 199fcf79a051..6d25879d87c8 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -162,12 +162,8 @@ static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd);
 static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd);
 static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd);
 static int qla4xxx_slave_alloc(struct scsi_device *device);
-static int qla4xxx_slave_configure(struct scsi_device *device);
-static void qla4xxx_slave_destroy(struct scsi_device *sdev);
 static umode_t qla4_attr_is_visible(int param_type, int param);
 static int qla4xxx_host_reset(struct Scsi_Host *shost, int reset_type);
-static int qla4xxx_change_queue_depth(struct scsi_device *sdev, int qdepth,
-                                      int reason);
 
 /*
  * iSCSI Flash DDB sysfs entry points
@@ -204,10 +200,8 @@ static struct scsi_host_template qla4xxx_driver_template = {
         .eh_host_reset_handler  = qla4xxx_eh_host_reset,
         .eh_timed_out           = qla4xxx_eh_cmd_timed_out,
 
-        .slave_configure        = qla4xxx_slave_configure,
         .slave_alloc            = qla4xxx_slave_alloc,
-        .slave_destroy          = qla4xxx_slave_destroy,
-        .change_queue_depth     = qla4xxx_change_queue_depth,
+        .change_queue_depth     = scsi_change_queue_depth,
 
         .this_id                = -1,
         .cmd_per_lun            = 3,
@@ -218,6 +212,7 @@ static struct scsi_host_template qla4xxx_driver_template = {
         .shost_attrs            = qla4xxx_host_attrs,
         .host_reset             = qla4xxx_host_reset,
         .vendor_id              = SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC,
+        .use_blk_tags           = 1,
 };
 
 static struct iscsi_transport qla4xxx_iscsi_transport = {
@@ -9060,35 +9055,14 @@ static int qla4xxx_slave_alloc(struct scsi_device *sdev)
         ddb = sess->dd_data;
 
         sdev->hostdata = ddb;
-        sdev->tagged_supported = 1;
 
         if (ql4xmaxqdepth != 0 && ql4xmaxqdepth <= 0xffffU)
                 queue_depth = ql4xmaxqdepth;
 
-        scsi_activate_tcq(sdev, queue_depth);
+        scsi_change_queue_depth(sdev, queue_depth);
         return 0;
 }
 
-static int qla4xxx_slave_configure(struct scsi_device *sdev)
-{
-        sdev->tagged_supported = 1;
-        return 0;
-}
-
-static void qla4xxx_slave_destroy(struct scsi_device *sdev)
-{
-        scsi_deactivate_tcq(sdev, 1);
-}
-
-static int qla4xxx_change_queue_depth(struct scsi_device *sdev, int qdepth,
-                                      int reason)
-{
-        if (!ql4xqfulltracking)
-                return -EOPNOTSUPP;
-
-        return iscsi_change_queue_depth(sdev, qdepth, reason);
-}
-
 /**
  * qla4xxx_del_from_active_array - returns an active srb
  * @ha: Pointer to host adapter structure.
@@ -9888,6 +9862,9 @@ static int __init qla4xxx_module_init(void)
 {
         int ret;
 
+        if (ql4xqfulltracking)
+                qla4xxx_driver_template.track_queue_depth = 1;
+
         /* Allocate cache for SRBs. */
         srb_cachep = kmem_cache_create("qla4xxx_srbs", sizeof(struct srb), 0,
                                        SLAB_HWCACHE_ALIGN, NULL);
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 79c77b485a67..1ad0c36375b8 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -527,9 +527,9 @@ void scsi_log_send(struct scsi_cmnd *cmd)
          *
          * 1: nothing (match completion)
          *
-         * 2: log opcode + command of all commands
+         * 2: log opcode + command of all commands + cmd address
          *
-         * 3: same as 2 plus dump cmd address
+         * 3: same as 2
          *
          * 4: same as 3 plus dump extra junk
          */
@@ -537,10 +537,8 @@ void scsi_log_send(struct scsi_cmnd *cmd)
                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
                                        SCSI_LOG_MLQUEUE_BITS);
                 if (level > 1) {
-                        scmd_printk(KERN_INFO, cmd, "Send: ");
-                        if (level > 2)
-                                printk("0x%p ", cmd);
-                        printk("\n");
+                        scmd_printk(KERN_INFO, cmd,
+                                    "Send: scmd 0x%p\n", cmd);
                         scsi_print_command(cmd);
                         if (level > 3) {
                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
@@ -565,7 +563,7 @@ void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
          *
          * 2: same as 1 but for all command completions.
          *
-         * 3: same as 2 plus dump cmd address
+         * 3: same as 2
          *
          * 4: same as 3 plus dump extra junk
          */
@@ -574,39 +572,10 @@ void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
                                        SCSI_LOG_MLCOMPLETE_BITS);
                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
                     (level > 1)) {
-                        scmd_printk(KERN_INFO, cmd, "Done: ");
-                        if (level > 2)
-                                printk("0x%p ", cmd);
-                        /*
-                         * Dump truncated values, so we usually fit within
-                         * 80 chars.
-                         */
-                        switch (disposition) {
-                        case SUCCESS:
-                                printk("SUCCESS\n");
-                                break;
-                        case NEEDS_RETRY:
-                                printk("RETRY\n");
-                                break;
-                        case ADD_TO_MLQUEUE:
-                                printk("MLQUEUE\n");
-                                break;
-                        case FAILED:
-                                printk("FAILED\n");
-                                break;
-                        case TIMEOUT_ERROR:
-                                /* 
-                                 * If called via scsi_times_out.
-                                 */
-                                printk("TIMEOUT\n");
-                                break;
-                        default:
-                                printk("UNKNOWN\n");
-                        }
-                        scsi_print_result(cmd);
+                        scsi_print_result(cmd, "Done: ", disposition);
                         scsi_print_command(cmd);
                         if (status_byte(cmd->result) & CHECK_CONDITION)
-                                scsi_print_sense("", cmd);
+                                scsi_print_sense(cmd);
                         if (level > 3)
                                 scmd_printk(KERN_INFO, cmd,
                                             "scsi host busy %d failed %d\n",
@@ -634,87 +603,6 @@ void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 EXPORT_SYMBOL(scsi_cmd_get_serial);
 
 /**
- * scsi_dispatch_command - Dispatch a command to the low-level driver.
- * @cmd: command block we are dispatching.
- *
- * Return: nonzero return request was rejected and device's queue needs to be
- * plugged.
- */
-int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
-{
-        struct Scsi_Host *host = cmd->device->host;
-        int rtn = 0;
-
-        atomic_inc(&cmd->device->iorequest_cnt);
-
-        /* check if the device is still usable */
-        if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
-                /* in SDEV_DEL we error all commands. DID_NO_CONNECT
-                 * returns an immediate error upwards, and signals
-                 * that the device is no longer present */
-                cmd->result = DID_NO_CONNECT << 16;
-                goto done;
-        }
-
-        /* Check to see if the scsi lld made this device blocked. */
-        if (unlikely(scsi_device_blocked(cmd->device))) {
-                /*
-                 * in blocked state, the command is just put back on
-                 * the device queue.  The suspend state has already
-                 * blocked the queue so future requests should not
-                 * occur until the device transitions out of the
-                 * suspend state.
-                 */
-                SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
-                        "queuecommand : device blocked\n"));
-                return SCSI_MLQUEUE_DEVICE_BUSY;
-        }
-
-        /* Store the LUN value in cmnd, if needed. */
-        if (cmd->device->lun_in_cdb)
-                cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
-                               (cmd->device->lun << 5 & 0xe0);
-
-        scsi_log_send(cmd);
-
-        /*
-         * Before we queue this command, check if the command
-         * length exceeds what the host adapter can handle.
-         */
-        if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
-                SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
-                               "queuecommand : command too long. "
-                               "cdb_size=%d host->max_cmd_len=%d\n",
-                               cmd->cmd_len, cmd->device->host->max_cmd_len));
-                cmd->result = (DID_ABORT << 16);
-                goto done;
-        }
-
-        if (unlikely(host->shost_state == SHOST_DEL)) {
-                cmd->result = (DID_NO_CONNECT << 16);
-                goto done;
-
-        }
-
-        trace_scsi_dispatch_cmd_start(cmd);
-        rtn = host->hostt->queuecommand(host, cmd);
-        if (rtn) {
-                trace_scsi_dispatch_cmd_error(cmd, rtn);
-                if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
-                    rtn != SCSI_MLQUEUE_TARGET_BUSY)
-                        rtn = SCSI_MLQUEUE_HOST_BUSY;
-
-                SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
-                        "queuecommand : request rejected\n"));
-        }
-
-        return rtn;
- done:
-        cmd->scsi_done(cmd);
-        return 0;
-}
-
-/**
  * scsi_finish_command - cleanup and pass command back to upper layer
  * @cmd: the command
  *
@@ -773,32 +661,18 @@ void scsi_finish_command(struct scsi_cmnd *cmd)
 }
 
 /**
- * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
+ * scsi_change_queue_depth - change a device's queue depth
  * @sdev: SCSI Device in question
- * @tagged: Do we use tagged queueing (non-0) or do we treat
- *          this device as an untagged device (0)
- * @tags: Number of tags allowed if tagged queueing enabled,
- *        or number of commands the low level driver can
- *        queue up in non-tagged mode (as per cmd_per_lun).
- *
- * Returns:     Nothing
+ * @depth: number of commands allowed to be queued to the driver
  *
- * Lock Status: None held on entry
- *
- * Notes:       Low level drivers may call this at any time and we will do
- *              the right thing depending on whether or not the device is
- *              currently active and whether or not it even has the
- *              command blocks built yet.
+ * Sets the device queue depth and returns the new value.
  */
-void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
+int scsi_change_queue_depth(struct scsi_device *sdev, int depth)
 {
         unsigned long flags;
 
-        /*
-         * refuse to set tagged depth to an unworkable size
-         */
-        if (tags <= 0)
-                return;
+        if (depth <= 0)
+                goto out;
 
         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 
@@ -813,35 +687,17 @@ void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
          */
         if (!shost_use_blk_mq(sdev->host) && !sdev->host->bqt) {
                 if (blk_queue_tagged(sdev->request_queue) &&
-                    blk_queue_resize_tags(sdev->request_queue, tags) != 0)
-                        goto out;
+                    blk_queue_resize_tags(sdev->request_queue, depth) != 0)
+                        goto out_unlock;
         }
 
-        sdev->queue_depth = tags;
-        switch (tagged) {
-                case 0:
-                        sdev->ordered_tags = 0;
-                        sdev->simple_tags = 0;
-                        break;
-                case MSG_ORDERED_TAG:
-                        sdev->ordered_tags = 1;
-                        sdev->simple_tags = 1;
-                        break;
-                case MSG_SIMPLE_TAG:
-                        sdev->ordered_tags = 0;
-                        sdev->simple_tags = 1;
-                        break;
-                default:
-                        sdev->ordered_tags = 0;
-                        sdev->simple_tags = 0;
-                        sdev_printk(KERN_WARNING, sdev,
-                                    "scsi_adjust_queue_depth, bad queue type, "
-                                    "disabled\n");
-        }
- out:
+        sdev->queue_depth = depth;
+out_unlock:
         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
+out:
+        return sdev->queue_depth;
 }
-EXPORT_SYMBOL(scsi_adjust_queue_depth);
+EXPORT_SYMBOL(scsi_change_queue_depth);
 
 /**
  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
@@ -885,19 +741,32 @@ int scsi_track_queue_full(struct scsi_device *sdev, int depth)
                 return 0;
         if (sdev->last_queue_full_depth < 8) {
                 /* Drop back to untagged */
-                scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
+                scsi_set_tag_type(sdev, 0);
+                scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun);
                 return -1;
         }
-        
-        if (sdev->ordered_tags)
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
-        else
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
-        return depth;
+
+        return scsi_change_queue_depth(sdev, depth);
 }
 EXPORT_SYMBOL(scsi_track_queue_full);
 
 /**
+ * scsi_change_queue_type() - Change a device's queue type
+ * @sdev:     The SCSI device whose queue depth is to change
+ * @tag_type: Identifier for queue type
+ */
+int scsi_change_queue_type(struct scsi_device *sdev, int tag_type)
+{
+        if (!sdev->tagged_supported)
+                return 0;
+
+        scsi_set_tag_type(sdev, tag_type);
+        return tag_type;
+
+}
+EXPORT_SYMBOL(scsi_change_queue_type);
+
+/**
  * scsi_vpd_inquiry - Request a device provide us with a VPD page
  * @sdev: The device to ask
  * @buffer: Where to put the result
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 238e06f13b8a..aa4b6b80aade 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -63,8 +63,8 @@
 #include "sd.h"
 #include "scsi_logging.h"
 
-#define SCSI_DEBUG_VERSION "1.84"
-static const char *scsi_debug_version_date = "20140706";
+#define SCSI_DEBUG_VERSION "1.85"
+static const char *scsi_debug_version_date = "20141022";
 
 #define MY_NAME "scsi_debug"
 
@@ -75,19 +75,22 @@ static const char *scsi_debug_version_date = "20140706";
 #define UNRECOVERED_READ_ERR 0x11
 #define PARAMETER_LIST_LENGTH_ERR 0x1a
 #define INVALID_OPCODE 0x20
-#define ADDR_OUT_OF_RANGE 0x21
-#define INVALID_COMMAND_OPCODE 0x20
+#define LBA_OUT_OF_RANGE 0x21
 #define INVALID_FIELD_IN_CDB 0x24
 #define INVALID_FIELD_IN_PARAM_LIST 0x26
 #define UA_RESET_ASC 0x29
 #define UA_CHANGED_ASC 0x2a
+#define INSUFF_RES_ASC 0x55
+#define INSUFF_RES_ASCQ 0x3
 #define POWER_ON_RESET_ASCQ 0x0
 #define BUS_RESET_ASCQ 0x2      /* scsi bus reset occurred */
 #define MODE_CHANGED_ASCQ 0x1   /* mode parameters changed */
+#define CAPACITY_CHANGED_ASCQ 0x9
 #define SAVING_PARAMS_UNSUP 0x39
 #define TRANSPORT_PROBLEM 0x4b
 #define THRESHOLD_EXCEEDED 0x5d
 #define LOW_POWER_COND_ON 0x5e
+#define MISCOMPARE_VERIFY_ASC 0x1d
 
 /* Additional Sense Code Qualifier (ASCQ) */
 #define ACK_NAK_TO 0x3
@@ -133,6 +136,7 @@ static const char *scsi_debug_version_date = "20140706";
 #define DEF_VIRTUAL_GB   0
 #define DEF_VPD_USE_HOSTNO 1
 #define DEF_WRITESAME_LENGTH 0xFFFF
+#define DEF_STRICT 0
 #define DELAY_OVERRIDDEN -9999
 
 /* bit mask values for scsi_debug_opts */
@@ -176,11 +180,12 @@ static const char *scsi_debug_version_date = "20140706";
 #define SDEBUG_UA_POR 0         /* Power on, reset, or bus device reset */
 #define SDEBUG_UA_BUS_RESET 1
 #define SDEBUG_UA_MODE_CHANGED 2
-#define SDEBUG_NUM_UAS 3
+#define SDEBUG_UA_CAPACITY_CHANGED 3
+#define SDEBUG_NUM_UAS 4
 
 /* for check_readiness() */
-#define UAS_ONLY 1
-#define UAS_TUR 0
+#define UAS_ONLY 1      /* check for UAs only */
+#define UAS_TUR 0       /* if no UAs then check if media access possible */
 
 /* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
  * sector on read commands: */
@@ -206,6 +211,301 @@ static const char *scsi_debug_version_date = "20140706";
 #warning "Expect DEF_CMD_PER_LUN <= SCSI_DEBUG_CANQUEUE"
 #endif
 
+/* SCSI opcodes (first byte of cdb) mapped onto these indexes */
+enum sdeb_opcode_index {
+        SDEB_I_INVALID_OPCODE = 0,
+        SDEB_I_INQUIRY = 1,
+        SDEB_I_REPORT_LUNS = 2,
+        SDEB_I_REQUEST_SENSE = 3,
+        SDEB_I_TEST_UNIT_READY = 4,
+        SDEB_I_MODE_SENSE = 5,          /* 6, 10 */
+        SDEB_I_MODE_SELECT = 6,         /* 6, 10 */
+        SDEB_I_LOG_SENSE = 7,
+        SDEB_I_READ_CAPACITY = 8,       /* 10; 16 is in SA_IN(16) */
+        SDEB_I_READ = 9,                /* 6, 10, 12, 16 */
+        SDEB_I_WRITE = 10,              /* 6, 10, 12, 16 */
+        SDEB_I_START_STOP = 11,
+        SDEB_I_SERV_ACT_IN = 12,        /* 12, 16 */
+        SDEB_I_SERV_ACT_OUT = 13,       /* 12, 16 */
+        SDEB_I_MAINT_IN = 14,
+        SDEB_I_MAINT_OUT = 15,
+        SDEB_I_VERIFY = 16,             /* 10 only */
+        SDEB_I_VARIABLE_LEN = 17,
+        SDEB_I_RESERVE = 18,            /* 6, 10 */
+        SDEB_I_RELEASE = 19,            /* 6, 10 */
+        SDEB_I_ALLOW_REMOVAL = 20,      /* PREVENT ALLOW MEDIUM REMOVAL */
+        SDEB_I_REZERO_UNIT = 21,        /* REWIND in SSC */
+        SDEB_I_ATA_PT = 22,             /* 12, 16 */
+        SDEB_I_SEND_DIAG = 23,
+        SDEB_I_UNMAP = 24,
+        SDEB_I_XDWRITEREAD = 25,        /* 10 only */
+        SDEB_I_WRITE_BUFFER = 26,
+        SDEB_I_WRITE_SAME = 27,         /* 10, 16 */
+        SDEB_I_SYNC_CACHE = 28,         /* 10 only */
+        SDEB_I_COMP_WRITE = 29,
+        SDEB_I_LAST_ELEMENT = 30,       /* keep this last */
+};
+
+static const unsigned char opcode_ind_arr[256] = {
+/* 0x0; 0x0->0x1f: 6 byte cdbs */
+        SDEB_I_TEST_UNIT_READY, SDEB_I_REZERO_UNIT, 0, SDEB_I_REQUEST_SENSE,
+            0, 0, 0, 0,
+        SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, 0,
+        0, 0, SDEB_I_INQUIRY, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
+            SDEB_I_RELEASE,
+        0, 0, SDEB_I_MODE_SENSE, SDEB_I_START_STOP, 0, SDEB_I_SEND_DIAG,
+            SDEB_I_ALLOW_REMOVAL, 0,
+/* 0x20; 0x20->0x3f: 10 byte cdbs */
+        0, 0, 0, 0, 0, SDEB_I_READ_CAPACITY, 0, 0,
+        SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, SDEB_I_VERIFY,
+        0, 0, 0, 0, 0, SDEB_I_SYNC_CACHE, 0, 0,
+        0, 0, 0, SDEB_I_WRITE_BUFFER, 0, 0, 0, 0,
+/* 0x40; 0x40->0x5f: 10 byte cdbs */
+        0, SDEB_I_WRITE_SAME, SDEB_I_UNMAP, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, SDEB_I_LOG_SENSE, 0, 0,
+        0, 0, 0, SDEB_I_XDWRITEREAD, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
+            SDEB_I_RELEASE,
+        0, 0, SDEB_I_MODE_SENSE, 0, 0, 0, 0, 0,
+/* 0x60; 0x60->0x7d are reserved */
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, SDEB_I_VARIABLE_LEN,
+/* 0x80; 0x80->0x9f: 16 byte cdbs */
+        0, 0, 0, 0, 0, SDEB_I_ATA_PT, 0, 0,
+        SDEB_I_READ, SDEB_I_COMP_WRITE, SDEB_I_WRITE, 0, 0, 0, 0, 0,
+        0, 0, 0, SDEB_I_WRITE_SAME, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, SDEB_I_SERV_ACT_IN, SDEB_I_SERV_ACT_OUT,
+/* 0xa0; 0xa0->0xbf: 12 byte cdbs */
+        SDEB_I_REPORT_LUNS, SDEB_I_ATA_PT, 0, SDEB_I_MAINT_IN,
+             SDEB_I_MAINT_OUT, 0, 0, 0,
+        SDEB_I_READ, SDEB_I_SERV_ACT_OUT, SDEB_I_WRITE, SDEB_I_SERV_ACT_IN,
+             0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+/* 0xc0; 0xc0->0xff: vendor specific */
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+#define F_D_IN                  1
+#define F_D_OUT                 2
+#define F_D_OUT_MAYBE           4       /* WRITE SAME, NDOB bit */
+#define F_D_UNKN                8
+#define F_RL_WLUN_OK            0x10
+#define F_SKIP_UA               0x20
+#define F_DELAY_OVERR           0x40
+#define F_SA_LOW                0x80    /* cdb byte 1, bits 4 to 0 */
+#define F_SA_HIGH               0x100   /* as used by variable length cdbs */
+#define F_INV_OP                0x200
+#define F_FAKE_RW               0x400
+#define F_M_ACCESS              0x800   /* media access */
+
+#define FF_RESPOND (F_RL_WLUN_OK | F_SKIP_UA | F_DELAY_OVERR)
+#define FF_DIRECT_IO (F_M_ACCESS | F_FAKE_RW)
+#define FF_SA (F_SA_HIGH | F_SA_LOW)
+
+struct sdebug_dev_info;
+static int resp_inquiry(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_report_luns(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_requests(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_mode_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_mode_select(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_log_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_readcap(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_read_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_write_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_start_stop(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_readcap16(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_get_lba_status(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_report_tgtpgs(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_unmap(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_rsup_opcodes(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_rsup_tmfs(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_write_same_10(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_write_same_16(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_xdwriteread_10(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_comp_write(struct scsi_cmnd *, struct sdebug_dev_info *);
+
+struct opcode_info_t {
+        u8 num_attached;        /* 0 if this is it (i.e. a leaf); use 0xff
+                                 * for terminating element */
+        u8 opcode;              /* if num_attached > 0, preferred */
+        u16 sa;                 /* service action */
+        u32 flags;              /* OR-ed set of SDEB_F_* */
+        int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
+        const struct opcode_info_t *arrp;  /* num_attached elements or NULL */
+        u8 len_mask[16];        /* len=len_mask[0], then mask for cdb[1]... */
+                                /* ignore cdb bytes after position 15 */
+};
+
+static const struct opcode_info_t msense_iarr[1] = {
+        {0, 0x1a, 0, F_D_IN, NULL, NULL,
+            {6,  0xe8, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+};
+
+static const struct opcode_info_t mselect_iarr[1] = {
+        {0, 0x15, 0, F_D_OUT, NULL, NULL,
+            {6,  0xf1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+};
+
+static const struct opcode_info_t read_iarr[3] = {
+        {0, 0x28, 0, F_D_IN | FF_DIRECT_IO, resp_read_dt0, NULL,/* READ(10) */
+            {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xc7, 0, 0,
+             0, 0, 0, 0} },
+        {0, 0x8, 0, F_D_IN | FF_DIRECT_IO, resp_read_dt0, NULL, /* READ(6) */
+            {6,  0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0xa8, 0, F_D_IN | FF_DIRECT_IO, resp_read_dt0, NULL,/* READ(12) */
+            {12,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f,
+             0xc7, 0, 0, 0, 0} },
+};
+
+static const struct opcode_info_t write_iarr[3] = {
+        {0, 0x2a, 0, F_D_OUT | FF_DIRECT_IO, resp_write_dt0, NULL,   /* 10 */
+            {10,  0xfb, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xc7, 0, 0,
+             0, 0, 0, 0} },
+        {0, 0xa, 0, F_D_OUT | FF_DIRECT_IO, resp_write_dt0, NULL,    /* 6 */
+            {6,  0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0xaa, 0, F_D_OUT | FF_DIRECT_IO, resp_write_dt0, NULL,   /* 12 */
+            {12,  0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f,
+             0xc7, 0, 0, 0, 0} },
+};
+
+static const struct opcode_info_t sa_in_iarr[1] = {
+        {0, 0x9e, 0x12, F_SA_LOW | F_D_IN, resp_get_lba_status, NULL,
+            {16,  0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+             0xff, 0xff, 0xff, 0, 0xc7} },
+};
+
+static const struct opcode_info_t vl_iarr[1] = {        /* VARIABLE LENGTH */
+        {0, 0x7f, 0xb, F_SA_HIGH | F_D_OUT | FF_DIRECT_IO, resp_write_dt0,
+            NULL, {32,  0xc7, 0, 0, 0, 0, 0x1f, 0x18, 0x0, 0xb, 0xfa,
+                   0, 0xff, 0xff, 0xff, 0xff} },        /* WRITE(32) */
+};
+
+static const struct opcode_info_t maint_in_iarr[2] = {
+        {0, 0xa3, 0xc, F_SA_LOW | F_D_IN, resp_rsup_opcodes, NULL,
+            {12,  0xc, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0,
+             0xc7, 0, 0, 0, 0} },
+        {0, 0xa3, 0xd, F_SA_LOW | F_D_IN, resp_rsup_tmfs, NULL,
+            {12,  0xd, 0x80, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
+             0, 0} },
+};
+
+static const struct opcode_info_t write_same_iarr[1] = {
+        {0, 0x93, 0, F_D_OUT_MAYBE | FF_DIRECT_IO, resp_write_same_16, NULL,
+            {16,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+             0xff, 0xff, 0xff, 0x1f, 0xc7} },
+};
+
+static const struct opcode_info_t reserve_iarr[1] = {
+        {0, 0x16, 0, F_D_OUT, NULL, NULL,       /* RESERVE(6) */
+            {6,  0x1f, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+};
+
+static const struct opcode_info_t release_iarr[1] = {
+        {0, 0x17, 0, F_D_OUT, NULL, NULL,       /* RELEASE(6) */
+            {6,  0x1f, 0xff, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+};
+
+
+/* This array is accessed via SDEB_I_* values. Make sure all are mapped,
+ * plus the terminating elements for logic that scans this table such as
+ * REPORT SUPPORTED OPERATION CODES. */
+static const struct opcode_info_t opcode_info_arr[SDEB_I_LAST_ELEMENT + 1] = {
+/* 0 */
+        {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL,
+            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0x12, 0, FF_RESPOND | F_D_IN, resp_inquiry, NULL,
+            {6,  0xe3, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0xa0, 0, FF_RESPOND | F_D_IN, resp_report_luns, NULL,
+            {12,  0xe3, 0xff, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
+             0, 0} },
+        {0, 0x3, 0, FF_RESPOND | F_D_IN, resp_requests, NULL,
+            {6,  0xe1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0x0, 0, F_M_ACCESS | F_RL_WLUN_OK, NULL, NULL,/* TEST UNIT READY */
+            {6,  0, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {1, 0x5a, 0, F_D_IN, resp_mode_sense, msense_iarr,
+            {10,  0xf8, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
+             0} },
+        {1, 0x55, 0, F_D_OUT, resp_mode_select, mselect_iarr,
+            {10,  0xf1, 0, 0, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
+        {0, 0x4d, 0, F_D_IN, resp_log_sense, NULL,
+            {10,  0xe3, 0xff, 0xff, 0, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0,
+             0, 0, 0} },
+        {0, 0x25, 0, F_D_IN, resp_readcap, NULL,
+            {10,  0xe1, 0xff, 0xff, 0xff, 0xff, 0, 0, 0x1, 0xc7, 0, 0, 0, 0,
+             0, 0} },
+        {3, 0x88, 0, F_D_IN | FF_DIRECT_IO, resp_read_dt0, read_iarr,
+            {16,  0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+             0xff, 0xff, 0xff, 0x9f, 0xc7} },           /* READ(16) */
+/* 10 */
+        {3, 0x8a, 0, F_D_OUT | FF_DIRECT_IO, resp_write_dt0, write_iarr,
+            {16,  0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+             0xff, 0xff, 0xff, 0x9f, 0xc7} },           /* WRITE(16) */
+        {0, 0x1b, 0, 0, resp_start_stop, NULL,          /* START STOP UNIT */
+            {6,  0x1, 0, 0xf, 0xf7, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {1, 0x9e, 0x10, F_SA_LOW | F_D_IN, resp_readcap16, sa_in_iarr,
+            {16,  0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+             0xff, 0xff, 0xff, 0x1, 0xc7} },    /* READ CAPACITY(16) */
+        {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* SA OUT */
+            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {2, 0xa3, 0xa, F_SA_LOW | F_D_IN, resp_report_tgtpgs, maint_in_iarr,
+            {12,  0xea, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0, 0,
+             0} },
+        {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* MAINT OUT */
+            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* VERIFY */
+            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {1, 0x7f, 0x9, F_SA_HIGH | F_D_IN | FF_DIRECT_IO, resp_read_dt0,
+            vl_iarr, {32,  0xc7, 0, 0, 0, 0, 0x1f, 0x18, 0x0, 0x9, 0xfe, 0,
+                      0xff, 0xff, 0xff, 0xff} },/* VARIABLE LENGTH, READ(32) */
+        {1, 0x56, 0, F_D_OUT, NULL, reserve_iarr, /* RESERVE(10) */
+            {10,  0xff, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
+             0} },
+        {1, 0x57, 0, F_D_OUT, NULL, release_iarr, /* RELEASE(10) */
+            {10,  0x13, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
+             0} },
+/* 20 */
+        {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ALLOW REMOVAL */
+            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0x1, 0, 0, resp_start_stop, NULL, /* REWIND ?? */
+            {6,  0x1, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ATA_PT */
+            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0x1d, F_D_OUT, 0, NULL, NULL,       /* SEND DIAGNOSTIC */
+            {6,  0xf7, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0x42, 0, F_D_OUT | FF_DIRECT_IO, resp_unmap, NULL, /* UNMAP */
+            {10,  0x1, 0, 0, 0, 0, 0x1f, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
+        {0, 0x53, 0, F_D_IN | F_D_OUT | FF_DIRECT_IO, resp_xdwriteread_10,
+            NULL, {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xc7,
+                   0, 0, 0, 0, 0, 0} },
+        {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* WRITE_BUFFER */
+            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {1, 0x41, 0, F_D_OUT_MAYBE | FF_DIRECT_IO, resp_write_same_10,
+            write_same_iarr, {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff,
+                              0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
+        {0, 0x35, 0, F_DELAY_OVERR | FF_DIRECT_IO, NULL, NULL, /* SYNC_CACHE */
+            {10,  0x7, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xc7, 0, 0,
+             0, 0, 0, 0} },
+        {0, 0x89, 0, F_D_OUT | FF_DIRECT_IO, resp_comp_write, NULL,
+            {16,  0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0,
+             0, 0xff, 0x1f, 0xc7} },            /* COMPARE AND WRITE */
+
+/* 30 */
+        {0xff, 0, 0, 0, NULL, NULL,             /* terminating element */
+            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+};
+
+struct sdebug_scmd_extra_t {
+        bool inj_recovered;
+        bool inj_transport;
+        bool inj_dif;
+        bool inj_dix;
+        bool inj_short;
+};
+
 static int scsi_debug_add_host = DEF_NUM_HOST;
 static int scsi_debug_ato = DEF_ATO;
 static int scsi_debug_delay = DEF_DELAY;
@@ -245,6 +545,8 @@ static unsigned int scsi_debug_write_same_length = DEF_WRITESAME_LENGTH;
 static bool scsi_debug_removable = DEF_REMOVABLE;
 static bool scsi_debug_clustering;
 static bool scsi_debug_host_lock = DEF_HOST_LOCK;
+static bool scsi_debug_strict = DEF_STRICT;
+static bool sdebug_any_injecting_opt;
 
 static atomic_t sdebug_cmnd_count;
 static atomic_t sdebug_completions;
@@ -277,11 +579,10 @@ struct sdebug_dev_info {
         unsigned int target;
         u64 lun;
         struct sdebug_host_info *sdbg_host;
-        u64 wlun;
         unsigned long uas_bm[1];
         atomic_t num_in_q;
-        char stopped;
-        char used;
+        char stopped;           /* TODO: should be atomic */
+        bool used;
 };
 
 struct sdebug_host_info {
@@ -394,6 +695,50 @@ static void sdebug_max_tgts_luns(void)
         spin_unlock(&sdebug_host_list_lock);
 }
 
+enum sdeb_cmd_data {SDEB_IN_DATA = 0, SDEB_IN_CDB = 1};
+
+/* Set in_bit to -1 to indicate no bit position of invalid field */
+static void
+mk_sense_invalid_fld(struct scsi_cmnd *scp, enum sdeb_cmd_data c_d,
+                     int in_byte, int in_bit)
+{
+        unsigned char *sbuff;
+        u8 sks[4];
+        int sl, asc;
+
+        sbuff = scp->sense_buffer;
+        if (!sbuff) {
+                sdev_printk(KERN_ERR, scp->device,
+                            "%s: sense_buffer is NULL\n", __func__);
+                return;
+        }
+        asc = c_d ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST;
+        memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
+        scsi_build_sense_buffer(scsi_debug_dsense, sbuff, ILLEGAL_REQUEST,
+                                asc, 0);
+        memset(sks, 0, sizeof(sks));
+        sks[0] = 0x80;
+        if (c_d)
+                sks[0] |= 0x40;
+        if (in_bit >= 0) {
+                sks[0] |= 0x8;
+                sks[0] |= 0x7 & in_bit;
+        }
+        put_unaligned_be16(in_byte, sks + 1);
+        if (scsi_debug_dsense) {
+                sl = sbuff[7] + 8;
+                sbuff[7] = sl;
+                sbuff[sl] = 0x2;
+                sbuff[sl + 1] = 0x6;
+                memcpy(sbuff + sl + 4, sks, 3);
+        } else
+                memcpy(sbuff + 15, sks, 3);
+        if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
+                sdev_printk(KERN_INFO, scp->device, "%s:  [sense_key,asc,ascq"
+                            "]: [0x5,0x%x,0x0] %c byte=%d, bit=%d\n",
+                            my_name, asc, c_d ? 'C' : 'D', in_byte, in_bit);
+}
+
 static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
 {
         unsigned char *sbuff;
@@ -414,63 +759,10 @@ static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
                             my_name, key, asc, asq);
 }
 
-static void get_data_transfer_info(unsigned char *cmd,
-                                   unsigned long long *lba, unsigned int *num,
-                                   u32 *ei_lba)
+static void
+mk_sense_invalid_opcode(struct scsi_cmnd *scp)
 {
-        *ei_lba = 0;
-
-        switch (*cmd) {
-        case VARIABLE_LENGTH_CMD:
-                *lba = (u64)cmd[19] | (u64)cmd[18] << 8 |
-                        (u64)cmd[17] << 16 | (u64)cmd[16] << 24 |
-                        (u64)cmd[15] << 32 | (u64)cmd[14] << 40 |
-                        (u64)cmd[13] << 48 | (u64)cmd[12] << 56;
-
-                *ei_lba = (u32)cmd[23] | (u32)cmd[22] << 8 |
-                        (u32)cmd[21] << 16 | (u32)cmd[20] << 24;
-
-                *num = (u32)cmd[31] | (u32)cmd[30] << 8 | (u32)cmd[29] << 16 |
-                        (u32)cmd[28] << 24;
-                break;
-
-        case WRITE_SAME_16:
-        case WRITE_16:
-        case READ_16:
-                *lba = (u64)cmd[9] | (u64)cmd[8] << 8 |
-                        (u64)cmd[7] << 16 | (u64)cmd[6] << 24 |
-                        (u64)cmd[5] << 32 | (u64)cmd[4] << 40 |
-                        (u64)cmd[3] << 48 | (u64)cmd[2] << 56;
-
-                *num = (u32)cmd[13] | (u32)cmd[12] << 8 | (u32)cmd[11] << 16 |
-                        (u32)cmd[10] << 24;
-                break;
-        case WRITE_12:
-        case READ_12:
-                *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
-                        (u32)cmd[2] << 24;
-
-                *num = (u32)cmd[9] | (u32)cmd[8] << 8 | (u32)cmd[7] << 16 |
-                        (u32)cmd[6] << 24;
-                break;
-        case WRITE_SAME:
-        case WRITE_10:
-        case READ_10:
-        case XDWRITEREAD_10:
-                *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
-                        (u32)cmd[2] << 24;
-
-                *num = (u32)cmd[8] | (u32)cmd[7] << 8;
-                break;
-        case WRITE_6:
-        case READ_6:
-                *lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
-                        (u32)(cmd[1] & 0x1f) << 16;
-                *num = (0 == cmd[4]) ? 256 : cmd[4];
-                break;
-        default:
-                break;
-        }
+        mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
 }
 
 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
@@ -520,6 +812,11 @@ static int check_readiness(struct scsi_cmnd *SCpnt, int uas_only,
                         if (debug)
                                 cp = "mode parameters changed";
                         break;
+                case SDEBUG_UA_CAPACITY_CHANGED:
+                        mk_sense_buffer(SCpnt, UNIT_ATTENTION,
+                                        UA_CHANGED_ASC, CAPACITY_CHANGED_ASCQ);
+                        if (debug)
+                                cp = "capacity data changed";
                 default:
                         pr_warn("%s: unexpected unit attention code=%d\n",
                                 __func__, k);
@@ -924,19 +1221,20 @@ static int inquiry_evpd_b2(unsigned char *arr)
 #define SDEBUG_LONG_INQ_SZ 96
 #define SDEBUG_MAX_INQ_ARR_SZ 584
 
-static int resp_inquiry(struct scsi_cmnd *scp, int target,
-                        struct sdebug_dev_info * devip)
+static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
 {
         unsigned char pq_pdt;
         unsigned char * arr;
         unsigned char *cmd = scp->cmnd;
         int alloc_len, n, ret;
+        bool have_wlun;
 
         alloc_len = (cmd[3] << 8) + cmd[4];
         arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
         if (! arr)
                 return DID_REQUEUE << 16;
-        if (devip->wlun)
+        have_wlun = (scp->device->lun == SAM2_WLUN_REPORT_LUNS);
+        if (have_wlun)
                 pq_pdt = 0x1e;  /* present, wlun */
         else if (scsi_debug_no_lun_0 && (0 == devip->lun))
                 pq_pdt = 0x7f;  /* not present, no device type */
@@ -944,8 +1242,7 @@ static int resp_inquiry(struct scsi_cmnd *scp, int target,
                 pq_pdt = (scsi_debug_ptype & 0x1f);
         arr[0] = pq_pdt;
         if (0x2 & cmd[1]) {  /* CMDDT bit set */
-                mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
-                                0);
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 1);
                 kfree(arr);
                 return check_condition_result;
         } else if (0x1 & cmd[1]) {  /* EVPD bit set */
@@ -957,7 +1254,7 @@ static int resp_inquiry(struct scsi_cmnd *scp, int target,
                     (devip->channel & 0x7f);
                 if (0 == scsi_debug_vpd_use_hostno)
                         host_no = 0;
-                lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
+                lu_id_num = have_wlun ? -1 : (((host_no + 1) * 2000) +
                             (devip->target * 1000) + devip->lun);
                 target_dev_id = ((host_no + 1) * 2000) +
                                  (devip->target * 1000) - 3;
@@ -1029,9 +1326,7 @@ static int resp_inquiry(struct scsi_cmnd *scp, int target,
                         arr[1] = cmd[2];        /*sanity */
                         arr[3] = inquiry_evpd_b2(&arr[4]);
                 } else {
-                        /* Illegal request, invalid field in cdb */
-                        mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                        INVALID_FIELD_IN_CDB, 0);
+                        mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
                         kfree(arr);
                         return check_condition_result;
                 }
@@ -1077,18 +1372,20 @@ static int resp_requests(struct scsi_cmnd * scp,
         unsigned char * sbuff;
         unsigned char *cmd = scp->cmnd;
         unsigned char arr[SCSI_SENSE_BUFFERSIZE];
-        int want_dsense;
+        bool dsense, want_dsense;
         int len = 18;
 
         memset(arr, 0, sizeof(arr));
-        want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
+        dsense = !!(cmd[1] & 1);
+        want_dsense = dsense || scsi_debug_dsense;
         sbuff = scp->sense_buffer;
         if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
-                if (want_dsense) {
+                if (dsense) {
                         arr[0] = 0x72;
                         arr[1] = 0x0;           /* NO_SENSE in sense_key */
                         arr[2] = THRESHOLD_EXCEEDED;
                         arr[3] = 0xff;          /* TEST set and MRIE==6 */
+                        len = 8;
                 } else {
                         arr[0] = 0x70;
                         arr[2] = 0x0;           /* NO_SENSE in sense_key */
@@ -1098,15 +1395,34 @@ static int resp_requests(struct scsi_cmnd * scp,
                 }
         } else {
                 memcpy(arr, sbuff, SCSI_SENSE_BUFFERSIZE);
-                if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
-                        /* DESC bit set and sense_buff in fixed format */
-                        memset(arr, 0, sizeof(arr));
+                if (arr[0] >= 0x70 && dsense == scsi_debug_dsense)
+                        ;       /* have sense and formats match */
+                else if (arr[0] <= 0x70) {
+                        if (dsense) {
+                                memset(arr, 0, 8);
+                                arr[0] = 0x72;
+                                len = 8;
+                        } else {
+                                memset(arr, 0, 18);
+                                arr[0] = 0x70;
+                                arr[7] = 0xa;
+                        }
+                } else if (dsense) {
+                        memset(arr, 0, 8);
                         arr[0] = 0x72;
                         arr[1] = sbuff[2];     /* sense key */
                         arr[2] = sbuff[12];    /* asc */
                         arr[3] = sbuff[13];    /* ascq */
                         len = 8;
+                } else {
+                        memset(arr, 0, 18);
+                        arr[0] = 0x70;
+                        arr[2] = sbuff[1];
+                        arr[7] = 0xa;
+                        arr[12] = sbuff[1];
+                        arr[13] = sbuff[3];
                 }
+
         }
         mk_sense_buffer(scp, 0, NO_ADDITIONAL_SENSE, 0);
         return fill_from_dev_buffer(scp, arr, len);
@@ -1116,15 +1432,11 @@ static int resp_start_stop(struct scsi_cmnd * scp,
                            struct sdebug_dev_info * devip)
 {
         unsigned char *cmd = scp->cmnd;
-        int power_cond, errsts, start;
+        int power_cond, start;
 
-        errsts = check_readiness(scp, UAS_ONLY, devip);
-        if (errsts)
-                return errsts;
         power_cond = (cmd[4] & 0xf0) >> 4;
         if (power_cond) {
-                mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
-                                0);
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 7);
                 return check_condition_result;
         }
         start = cmd[4] & 1;
@@ -1148,11 +1460,7 @@ static int resp_readcap(struct scsi_cmnd * scp,
 {
         unsigned char arr[SDEBUG_READCAP_ARR_SZ];
         unsigned int capac;
-        int errsts;
 
-        errsts = check_readiness(scp, UAS_ONLY, devip);
-        if (errsts)
-                return errsts;
         /* following just in case virtual_gb changed */
         sdebug_capacity = get_sdebug_capacity();
         memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
@@ -1180,11 +1488,8 @@ static int resp_readcap16(struct scsi_cmnd * scp,
         unsigned char *cmd = scp->cmnd;
         unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
         unsigned long long capac;
-        int errsts, k, alloc_len;
+        int k, alloc_len;
 
-        errsts = check_readiness(scp, UAS_ONLY, devip);
-        if (errsts)
-                return errsts;
         alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
                      + cmd[13]);
         /* following just in case virtual_gb changed */
@@ -1300,6 +1605,184 @@ static int resp_report_tgtpgs(struct scsi_cmnd * scp,
         return ret;
 }
 
+static int
+resp_rsup_opcodes(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
+{
+        bool rctd;
+        u8 reporting_opts, req_opcode, sdeb_i, supp;
+        u16 req_sa, u;
+        u32 alloc_len, a_len;
+        int k, offset, len, errsts, count, bump, na;
+        const struct opcode_info_t *oip;
+        const struct opcode_info_t *r_oip;
+        u8 *arr;
+        u8 *cmd = scp->cmnd;
+
+        rctd = !!(cmd[2] & 0x80);
+        reporting_opts = cmd[2] & 0x7;
+        req_opcode = cmd[3];
+        req_sa = get_unaligned_be16(cmd + 4);
+        alloc_len = get_unaligned_be32(cmd + 6);
+        if (alloc_len < 4 && alloc_len > 0xffff) {
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
+                return check_condition_result;
+        }
+        if (alloc_len > 8192)
+                a_len = 8192;
+        else
+                a_len = alloc_len;
+        arr = kzalloc((a_len < 256) ? 320 : a_len + 64, GFP_KERNEL);
+        if (NULL == arr) {
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
+                                INSUFF_RES_ASCQ);
+                return check_condition_result;
+        }
+        switch (reporting_opts) {
+        case 0: /* all commands */
+                /* count number of commands */
+                for (count = 0, oip = opcode_info_arr;
+                     oip->num_attached != 0xff; ++oip) {
+                        if (F_INV_OP & oip->flags)
+                                continue;
+                        count += (oip->num_attached + 1);
+                }
+                bump = rctd ? 20 : 8;
+                put_unaligned_be32(count * bump, arr);
+                for (offset = 4, oip = opcode_info_arr;
+                     oip->num_attached != 0xff && offset < a_len; ++oip) {
+                        if (F_INV_OP & oip->flags)
+                                continue;
+                        na = oip->num_attached;
+                        arr[offset] = oip->opcode;
+                        put_unaligned_be16(oip->sa, arr + offset + 2);
+                        if (rctd)
+                                arr[offset + 5] |= 0x2;
+                        if (FF_SA & oip->flags)
+                                arr[offset + 5] |= 0x1;
+                        put_unaligned_be16(oip->len_mask[0], arr + offset + 6);
+                        if (rctd)
+                                put_unaligned_be16(0xa, arr + offset + 8);
+                        r_oip = oip;
+                        for (k = 0, oip = oip->arrp; k < na; ++k, ++oip) {
+                                if (F_INV_OP & oip->flags)
+                                        continue;
+                                offset += bump;
+                                arr[offset] = oip->opcode;
+                                put_unaligned_be16(oip->sa, arr + offset + 2);
+                                if (rctd)
+                                        arr[offset + 5] |= 0x2;
+                                if (FF_SA & oip->flags)
+                                        arr[offset + 5] |= 0x1;
+                                put_unaligned_be16(oip->len_mask[0],
+                                                   arr + offset + 6);
+                                if (rctd)
+                                        put_unaligned_be16(0xa,
+                                                           arr + offset + 8);
+                        }
+                        oip = r_oip;
+                        offset += bump;
+                }
+                break;
+        case 1: /* one command: opcode only */
+        case 2: /* one command: opcode plus service action */
+        case 3: /* one command: if sa==0 then opcode only else opcode+sa */
+                sdeb_i = opcode_ind_arr[req_opcode];
+                oip = &opcode_info_arr[sdeb_i];
+                if (F_INV_OP & oip->flags) {
+                        supp = 1;
+                        offset = 4;
+                } else {
+                        if (1 == reporting_opts) {
+                                if (FF_SA & oip->flags) {
+                                        mk_sense_invalid_fld(scp, SDEB_IN_CDB,
+                                                             2, 2);
+                                        kfree(arr);
+                                        return check_condition_result;
+                                }
+                                req_sa = 0;
+                        } else if (2 == reporting_opts &&
+                                   0 == (FF_SA & oip->flags)) {
+                                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, -1);
+                                kfree(arr);     /* point at requested sa */
+                                return check_condition_result;
+                        }
+                        if (0 == (FF_SA & oip->flags) &&
+                            req_opcode == oip->opcode)
+                                supp = 3;
+                        else if (0 == (FF_SA & oip->flags)) {
+                                na = oip->num_attached;
+                                for (k = 0, oip = oip->arrp; k < na;
+                                     ++k, ++oip) {
+                                        if (req_opcode == oip->opcode)
+                                                break;
+                                }
+                                supp = (k >= na) ? 1 : 3;
+                        } else if (req_sa != oip->sa) {
+                                na = oip->num_attached;
+                                for (k = 0, oip = oip->arrp; k < na;
+                                     ++k, ++oip) {
+                                        if (req_sa == oip->sa)
+                                                break;
+                                }
+                                supp = (k >= na) ? 1 : 3;
+                        } else
+                                supp = 3;
+                        if (3 == supp) {
+                                u = oip->len_mask[0];
+                                put_unaligned_be16(u, arr + 2);
+                                arr[4] = oip->opcode;
+                                for (k = 1; k < u; ++k)
+                                        arr[4 + k] = (k < 16) ?
+                                                 oip->len_mask[k] : 0xff;
+                                offset = 4 + u;
+                        } else
+                                offset = 4;
+                }
+                arr[1] = (rctd ? 0x80 : 0) | supp;
+                if (rctd) {
+                        put_unaligned_be16(0xa, arr + offset);
+                        offset += 12;
+                }
+                break;
+        default:
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
+                kfree(arr);
+                return check_condition_result;
+        }
+        offset = (offset < a_len) ? offset : a_len;
+        len = (offset < alloc_len) ? offset : alloc_len;
+        errsts = fill_from_dev_buffer(scp, arr, len);
+        kfree(arr);
+        return errsts;
+}
+
+static int
+resp_rsup_tmfs(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
+{
+        bool repd;
+        u32 alloc_len, len;
+        u8 arr[16];
+        u8 *cmd = scp->cmnd;
+
+        memset(arr, 0, sizeof(arr));
+        repd = !!(cmd[2] & 0x80);
+        alloc_len = get_unaligned_be32(cmd + 6);
+        if (alloc_len < 4) {
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
+                return check_condition_result;
+        }
+        arr[0] = 0xc8;          /* ATS | ATSS | LURS */
+        arr[1] = 0x1;           /* ITNRS */
+        if (repd) {
+                arr[3] = 0xc;
+                len = 16;
+        } else
+                len = 4;
+
+        len = (len < alloc_len) ? len : alloc_len;
+        return fill_from_dev_buffer(scp, arr, len);
+}
+
 /* <<Following mode page info copied from ST318451LW>> */
 
 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
@@ -1459,20 +1942,18 @@ static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
 
 #define SDEBUG_MAX_MSENSE_SZ 256
 
-static int resp_mode_sense(struct scsi_cmnd * scp, int target,
-                           struct sdebug_dev_info * devip)
+static int
+resp_mode_sense(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
 {
         unsigned char dbd, llbaa;
         int pcontrol, pcode, subpcode, bd_len;
         unsigned char dev_spec;
-        int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
+        int k, alloc_len, msense_6, offset, len, target_dev_id;
+        int target = scp->device->id;
         unsigned char * ap;
         unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
         unsigned char *cmd = scp->cmnd;
 
-        errsts = check_readiness(scp, UAS_ONLY, devip);
-        if (errsts)
-                return errsts;
         dbd = !!(cmd[1] & 0x8);
         pcontrol = (cmd[2] & 0xc0) >> 6;
         pcode = cmd[2] & 0x3f;
@@ -1542,8 +2023,7 @@ static int resp_mode_sense(struct scsi_cmnd * scp, int target,
 
         if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
                 /* TODO: Control Extension page */
-                mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
-                                0);
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
                 return check_condition_result;
         }
         switch (pcode) {
@@ -1569,8 +2049,7 @@ static int resp_mode_sense(struct scsi_cmnd * scp, int target,
                 break;
         case 0x19:      /* if spc==1 then sas phy, control+discover */
                 if ((subpcode > 0x2) && (subpcode < 0xff)) {
-                        mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                        INVALID_FIELD_IN_CDB, 0);
+                        mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
                         return check_condition_result;
                 }
                 len = 0;
@@ -1602,15 +2081,13 @@ static int resp_mode_sense(struct scsi_cmnd * scp, int target,
                         }
                         len += resp_iec_m_pg(ap + len, pcontrol, target);
                 } else {
-                        mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                        INVALID_FIELD_IN_CDB, 0);
+                        mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
                         return check_condition_result;
                 }
                 offset += len;
                 break;
         default:
-                mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
-                                0);
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
                 return check_condition_result;
         }
         if (msense_6)
@@ -1624,24 +2101,21 @@ static int resp_mode_sense(struct scsi_cmnd * scp, int target,
 
 #define SDEBUG_MAX_MSELECT_SZ 512
 
-static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
-                            struct sdebug_dev_info * devip)
+static int
+resp_mode_select(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
 {
         int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
-        int param_len, res, errsts, mpage;
+        int param_len, res, mpage;
         unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
         unsigned char *cmd = scp->cmnd;
+        int mselect6 = (MODE_SELECT == cmd[0]);
 
-        errsts = check_readiness(scp, UAS_ONLY, devip);
-        if (errsts)
-                return errsts;
         memset(arr, 0, sizeof(arr));
         pf = cmd[1] & 0x10;
         sp = cmd[1] & 0x1;
         param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
         if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
-                mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                INVALID_FIELD_IN_CDB, 0);
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, mselect6 ? 4 : 7, -1);
                 return check_condition_result;
         }
         res = fetch_to_dev_buffer(scp, arr, param_len);
@@ -1655,16 +2129,14 @@ static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
         md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
         bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
         if (md_len > 2) {
-                mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                INVALID_FIELD_IN_PARAM_LIST, 0);
+                mk_sense_invalid_fld(scp, SDEB_IN_DATA, 0, -1);
                 return check_condition_result;
         }
         off = bd_len + (mselect6 ? 4 : 8);
         mpage = arr[off] & 0x3f;
         ps = !!(arr[off] & 0x80);
         if (ps) {
-                mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                INVALID_FIELD_IN_PARAM_LIST, 0);
+                mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 7);
                 return check_condition_result;
         }
         spf = !!(arr[off] & 0x40);
@@ -1701,8 +2173,7 @@ static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
         default:
                 break;
         }
-        mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                        INVALID_FIELD_IN_PARAM_LIST, 0);
+        mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 5);
         return check_condition_result;
 set_mode_changed_ua:
         set_bit(SDEBUG_UA_MODE_CHANGED, devip->uas_bm);
@@ -1737,19 +2208,15 @@ static int resp_ie_l_pg(unsigned char * arr)
 static int resp_log_sense(struct scsi_cmnd * scp,
                           struct sdebug_dev_info * devip)
 {
-        int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
+        int ppc, sp, pcontrol, pcode, subpcode, alloc_len, len, n;
         unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
         unsigned char *cmd = scp->cmnd;
 
-        errsts = check_readiness(scp, UAS_ONLY, devip);
-        if (errsts)
-                return errsts;
         memset(arr, 0, sizeof(arr));
         ppc = cmd[1] & 0x2;
         sp = cmd[1] & 0x1;
         if (ppc || sp) {
-                mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                INVALID_FIELD_IN_CDB, 0);
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, ppc ? 1 : 0);
                 return check_condition_result;
         }
         pcontrol = (cmd[2] & 0xc0) >> 6;
@@ -1773,8 +2240,7 @@ static int resp_log_sense(struct scsi_cmnd * scp,
                         arr[3] = resp_ie_l_pg(arr + 4);
                         break;
                 default:
-                        mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                        INVALID_FIELD_IN_CDB, 0);
+                        mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
                         return check_condition_result;
                 }
         } else if (0xff == subpcode) {
@@ -1806,13 +2272,11 @@ static int resp_log_sense(struct scsi_cmnd * scp,
                         arr[3] = n - 4;
                         break;
                 default:
-                        mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                        INVALID_FIELD_IN_CDB, 0);
+                        mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
                         return check_condition_result;
                 }
         } else {
-                mk_sense_buffer(scp, ILLEGAL_REQUEST,
-                                INVALID_FIELD_IN_CDB, 0);
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
                 return check_condition_result;
         }
         len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
@@ -1824,11 +2288,12 @@ static int check_device_access_params(struct scsi_cmnd *scp,
                                       unsigned long long lba, unsigned int num)
 {
         if (lba + num > sdebug_capacity) {
-                mk_sense_buffer(scp, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE, 0);
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
                 return check_condition_result;
         }
         /* transfer length excessive (tie in to block limits VPD page) */
         if (num > sdebug_store_sectors) {
+                /* needs work to find which cdb byte 'num' comes from */
                 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
                 return check_condition_result;
         }
@@ -1836,17 +2301,17 @@ static int check_device_access_params(struct scsi_cmnd *scp,
 }
 
 /* Returns number of bytes copied or -1 if error. */
-static int do_device_access(struct scsi_cmnd *scmd,
-                            unsigned long long lba, unsigned int num, int write)
+static int
+do_device_access(struct scsi_cmnd *scmd, u64 lba, u32 num, bool do_write)
 {
         int ret;
-        unsigned long long block, rest = 0;
+        u64 block, rest = 0;
         struct scsi_data_buffer *sdb;
         enum dma_data_direction dir;
         size_t (*func)(struct scatterlist *, unsigned int, void *, size_t,
                        off_t);
 
-        if (write) {
+        if (do_write) {
                 sdb = scsi_out(scmd);
                 dir = DMA_TO_DEVICE;
                 func = sg_pcopy_to_buffer;
@@ -1880,6 +2345,38 @@ static int do_device_access(struct scsi_cmnd *scmd,
         return ret;
 }
 
+/* If fake_store(lba,num) compares equal to arr(num), then copy top half of
+ * arr into fake_store(lba,num) and return true. If comparison fails then
+ * return false. */
+static bool
+comp_write_worker(u64 lba, u32 num, const u8 *arr)
+{
+        bool res;
+        u64 block, rest = 0;
+        u32 store_blks = sdebug_store_sectors;
+        u32 lb_size = scsi_debug_sector_size;
+
+        block = do_div(lba, store_blks);
+        if (block + num > store_blks)
+                rest = block + num - store_blks;
+
+        res = !memcmp(fake_storep + (block * lb_size), arr,
+                      (num - rest) * lb_size);
+        if (!res)
+                return res;
+        if (rest)
+                res = memcmp(fake_storep, arr + ((num - rest) * lb_size),
+                             rest * lb_size);
+        if (!res)
+                return res;
+        arr += num * lb_size;
+        memcpy(fake_storep + (block * lb_size), arr, (num - rest) * lb_size);
+        if (rest)
+                memcpy(fake_storep, arr + ((num - rest) * lb_size),
+                       rest * lb_size);
+        return res;
+}
+
 static __be16 dif_compute_csum(const void *buf, int len)
 {
         __be16 csum;
@@ -1992,55 +2489,143 @@ static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
         return 0;
 }
 
-static int resp_read(struct scsi_cmnd *SCpnt, unsigned long long lba,
-                     unsigned int num, u32 ei_lba)
+static int
+resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
 {
+        u8 *cmd = scp->cmnd;
+        u64 lba;
+        u32 num;
+        u32 ei_lba;
         unsigned long iflags;
         int ret;
+        bool check_prot;
 
-        ret = check_device_access_params(SCpnt, lba, num);
-        if (ret)
-                return ret;
+        switch (cmd[0]) {
+        case READ_16:
+                ei_lba = 0;
+                lba = get_unaligned_be64(cmd + 2);
+                num = get_unaligned_be32(cmd + 10);
+                check_prot = true;
+                break;
+        case READ_10:
+                ei_lba = 0;
+                lba = get_unaligned_be32(cmd + 2);
+                num = get_unaligned_be16(cmd + 7);
+                check_prot = true;
+                break;
+        case READ_6:
+                ei_lba = 0;
+                lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
+                      (u32)(cmd[1] & 0x1f) << 16;
+                num = (0 == cmd[4]) ? 256 : cmd[4];
+                check_prot = true;
+                break;
+        case READ_12:
+                ei_lba = 0;
+                lba = get_unaligned_be32(cmd + 2);
+                num = get_unaligned_be32(cmd + 6);
+                check_prot = true;
+                break;
+        case XDWRITEREAD_10:
+                ei_lba = 0;
+                lba = get_unaligned_be32(cmd + 2);
+                num = get_unaligned_be16(cmd + 7);
+                check_prot = false;
+                break;
+        default:        /* assume READ(32) */
+                lba = get_unaligned_be64(cmd + 12);
+                ei_lba = get_unaligned_be32(cmd + 20);
+                num = get_unaligned_be32(cmd + 28);
+                check_prot = false;
+                break;
+        }
+        if (check_prot) {
+                if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
+                    (cmd[1] & 0xe0)) {
+                        mk_sense_invalid_opcode(scp);
+                        return check_condition_result;
+                }
+                if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
+                     scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
+                    (cmd[1] & 0xe0) == 0)
+                        sdev_printk(KERN_ERR, scp->device, "Unprotected RD "
+                                    "to DIF device\n");
+        }
+        if (sdebug_any_injecting_opt) {
+                struct sdebug_scmd_extra_t *ep = scsi_cmd_priv(scp);
+
+                if (ep->inj_short)
+                        num /= 2;
+        }
+
+        /* inline check_device_access_params() */
+        if (lba + num > sdebug_capacity) {
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+                return check_condition_result;
+        }
+        /* transfer length excessive (tie in to block limits VPD page) */
+        if (num > sdebug_store_sectors) {
+                /* needs work to find which cdb byte 'num' comes from */
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+                return check_condition_result;
+        }
 
         if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
             (lba <= (OPT_MEDIUM_ERR_ADDR + OPT_MEDIUM_ERR_NUM - 1)) &&
             ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
                 /* claim unrecoverable read error */
-                mk_sense_buffer(SCpnt, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
+                mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
                 /* set info field and valid bit for fixed descriptor */
-                if (0x70 == (SCpnt->sense_buffer[0] & 0x7f)) {
-                        SCpnt->sense_buffer[0] |= 0x80; /* Valid bit */
+                if (0x70 == (scp->sense_buffer[0] & 0x7f)) {
+                        scp->sense_buffer[0] |= 0x80;   /* Valid bit */
                         ret = (lba < OPT_MEDIUM_ERR_ADDR)
                               ? OPT_MEDIUM_ERR_ADDR : (int)lba;
-                        SCpnt->sense_buffer[3] = (ret >> 24) & 0xff;
-                        SCpnt->sense_buffer[4] = (ret >> 16) & 0xff;
-                        SCpnt->sense_buffer[5] = (ret >> 8) & 0xff;
-                        SCpnt->sense_buffer[6] = ret & 0xff;
+                        put_unaligned_be32(ret, scp->sense_buffer + 3);
                 }
-                scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
+                scsi_set_resid(scp, scsi_bufflen(scp));
                 return check_condition_result;
         }
 
         read_lock_irqsave(&atomic_rw, iflags);
 
         /* DIX + T10 DIF */
-        if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
-                int prot_ret = prot_verify_read(SCpnt, lba, num, ei_lba);
+        if (scsi_debug_dix && scsi_prot_sg_count(scp)) {
+                int prot_ret = prot_verify_read(scp, lba, num, ei_lba);
 
                 if (prot_ret) {
                         read_unlock_irqrestore(&atomic_rw, iflags);
-                        mk_sense_buffer(SCpnt, ABORTED_COMMAND, 0x10, prot_ret);
+                        mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, prot_ret);
                         return illegal_condition_result;
                 }
         }
 
-        ret = do_device_access(SCpnt, lba, num, 0);
+        ret = do_device_access(scp, lba, num, false);
         read_unlock_irqrestore(&atomic_rw, iflags);
         if (ret == -1)
                 return DID_ERROR << 16;
 
-        scsi_in(SCpnt)->resid = scsi_bufflen(SCpnt) - ret;
+        scsi_in(scp)->resid = scsi_bufflen(scp) - ret;
+
+        if (sdebug_any_injecting_opt) {
+                struct sdebug_scmd_extra_t *ep = scsi_cmd_priv(scp);
 
+                if (ep->inj_recovered) {
+                        mk_sense_buffer(scp, RECOVERED_ERROR,
+                                        THRESHOLD_EXCEEDED, 0);
+                        return check_condition_result;
+                } else if (ep->inj_transport) {
+                        mk_sense_buffer(scp, ABORTED_COMMAND,
+                                        TRANSPORT_PROBLEM, ACK_NAK_TO);
+                        return check_condition_result;
+                } else if (ep->inj_dif) {
+                        /* Logical block guard check failed */
+                        mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
+                        return illegal_condition_result;
+                } else if (ep->inj_dix) {
+                        mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
+                        return illegal_condition_result;
+                }
+        }
         return 0;
 }
 
@@ -2223,31 +2808,95 @@ static void unmap_region(sector_t lba, unsigned int len)
         }
 }
 
-static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
-                      unsigned int num, u32 ei_lba)
+static int
+resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
 {
+        u8 *cmd = scp->cmnd;
+        u64 lba;
+        u32 num;
+        u32 ei_lba;
         unsigned long iflags;
         int ret;
+        bool check_prot;
 
-        ret = check_device_access_params(SCpnt, lba, num);
-        if (ret)
-                return ret;
+        switch (cmd[0]) {
+        case WRITE_16:
+                ei_lba = 0;
+                lba = get_unaligned_be64(cmd + 2);
+                num = get_unaligned_be32(cmd + 10);
+                check_prot = true;
+                break;
+        case WRITE_10:
+                ei_lba = 0;
+                lba = get_unaligned_be32(cmd + 2);
+                num = get_unaligned_be16(cmd + 7);
+                check_prot = true;
+                break;
+        case WRITE_6:
+                ei_lba = 0;
+                lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
+                      (u32)(cmd[1] & 0x1f) << 16;
+                num = (0 == cmd[4]) ? 256 : cmd[4];
+                check_prot = true;
+                break;
+        case WRITE_12:
+                ei_lba = 0;
+                lba = get_unaligned_be32(cmd + 2);
+                num = get_unaligned_be32(cmd + 6);
+                check_prot = true;
+                break;
+        case 0x53:      /* XDWRITEREAD(10) */
+                ei_lba = 0;
+                lba = get_unaligned_be32(cmd + 2);
+                num = get_unaligned_be16(cmd + 7);
+                check_prot = false;
+                break;
+        default:        /* assume WRITE(32) */
+                lba = get_unaligned_be64(cmd + 12);
+                ei_lba = get_unaligned_be32(cmd + 20);
+                num = get_unaligned_be32(cmd + 28);
+                check_prot = false;
+                break;
+        }
+        if (check_prot) {
+                if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
+                    (cmd[1] & 0xe0)) {
+                        mk_sense_invalid_opcode(scp);
+                        return check_condition_result;
+                }
+                if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
+                     scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
+                    (cmd[1] & 0xe0) == 0)
+                        sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
+                                    "to DIF device\n");
+        }
+
+        /* inline check_device_access_params() */
+        if (lba + num > sdebug_capacity) {
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+                return check_condition_result;
+        }
+        /* transfer length excessive (tie in to block limits VPD page) */
+        if (num > sdebug_store_sectors) {
+                /* needs work to find which cdb byte 'num' comes from */
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+                return check_condition_result;
+        }
 
         write_lock_irqsave(&atomic_rw, iflags);
 
         /* DIX + T10 DIF */
-        if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
-                int prot_ret = prot_verify_write(SCpnt, lba, num, ei_lba);
+        if (scsi_debug_dix && scsi_prot_sg_count(scp)) {
+                int prot_ret = prot_verify_write(scp, lba, num, ei_lba);
 
                 if (prot_ret) {
                         write_unlock_irqrestore(&atomic_rw, iflags);
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST, 0x10,
-                                        prot_ret);
+                        mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, prot_ret);
                         return illegal_condition_result;
                 }
         }
 
-        ret = do_device_access(SCpnt, lba, num, 1);
+        ret = do_device_access(scp, lba, num, true);
         if (scsi_debug_lbp())
                 map_region(lba, num);
         write_unlock_irqrestore(&atomic_rw, iflags);
@@ -2255,30 +2904,41 @@ static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
                 return (DID_ERROR << 16);
         else if ((ret < (num * scsi_debug_sector_size)) &&
                  (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
-                sdev_printk(KERN_INFO, SCpnt->device,
+                sdev_printk(KERN_INFO, scp->device,
                             "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
                             my_name, num * scsi_debug_sector_size, ret);
 
+        if (sdebug_any_injecting_opt) {
+                struct sdebug_scmd_extra_t *ep = scsi_cmd_priv(scp);
+
+                if (ep->inj_recovered) {
+                        mk_sense_buffer(scp, RECOVERED_ERROR,
+                                        THRESHOLD_EXCEEDED, 0);
+                        return check_condition_result;
+                } else if (ep->inj_dif) {
+                        /* Logical block guard check failed */
+                        mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
+                        return illegal_condition_result;
+                } else if (ep->inj_dix) {
+                        mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
+                        return illegal_condition_result;
+                }
+        }
         return 0;
 }
 
-static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba,
-                      unsigned int num, u32 ei_lba, unsigned int unmap)
+static int
+resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num, u32 ei_lba,
+                bool unmap, bool ndob)
 {
         unsigned long iflags;
         unsigned long long i;
         int ret;
 
-        ret = check_device_access_params(scmd, lba, num);
+        ret = check_device_access_params(scp, lba, num);
         if (ret)
                 return ret;
 
-        if (num > scsi_debug_write_same_length) {
-                mk_sense_buffer(scmd, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
-                                0);
-                return check_condition_result;
-        }
-
         write_lock_irqsave(&atomic_rw, iflags);
 
         if (unmap && scsi_debug_lbp()) {
@@ -2286,17 +2946,22 @@ static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba,
                 goto out;
         }
 
-        /* Else fetch one logical block */
-        ret = fetch_to_dev_buffer(scmd,
-                                  fake_storep + (lba * scsi_debug_sector_size),
-                                  scsi_debug_sector_size);
+        /* if ndob then zero 1 logical block, else fetch 1 logical block */
+        if (ndob) {
+                memset(fake_storep + (lba * scsi_debug_sector_size), 0,
+                       scsi_debug_sector_size);
+                ret = 0;
+        } else
+                ret = fetch_to_dev_buffer(scp, fake_storep +
+                                               (lba * scsi_debug_sector_size),
+                                          scsi_debug_sector_size);
 
         if (-1 == ret) {
                 write_unlock_irqrestore(&atomic_rw, iflags);
                 return (DID_ERROR << 16);
         } else if ((ret < (num * scsi_debug_sector_size)) &&
                  (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
-                sdev_printk(KERN_INFO, scmd->device,
+                sdev_printk(KERN_INFO, scp->device,
                             "%s: %s: cdb indicated=%u, IO sent=%d bytes\n",
                             my_name, "write same",
                             num * scsi_debug_sector_size, ret);
@@ -2315,13 +2980,143 @@ out:
         return 0;
 }
 
+static int
+resp_write_same_10(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
+{
+        u8 *cmd = scp->cmnd;
+        u32 lba;
+        u16 num;
+        u32 ei_lba = 0;
+        bool unmap = false;
+
+        if (cmd[1] & 0x8) {
+                if (scsi_debug_lbpws10 == 0) {
+                        mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
+                        return check_condition_result;
+                } else
+                        unmap = true;
+        }
+        lba = get_unaligned_be32(cmd + 2);
+        num = get_unaligned_be16(cmd + 7);
+        if (num > scsi_debug_write_same_length) {
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
+                return check_condition_result;
+        }
+        return resp_write_same(scp, lba, num, ei_lba, unmap, false);
+}
+
+static int
+resp_write_same_16(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
+{
+        u8 *cmd = scp->cmnd;
+        u64 lba;
+        u32 num;
+        u32 ei_lba = 0;
+        bool unmap = false;
+        bool ndob = false;
+
+        if (cmd[1] & 0x8) {     /* UNMAP */
+                if (scsi_debug_lbpws == 0) {
+                        mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
+                        return check_condition_result;
+                } else
+                        unmap = true;
+        }
+        if (cmd[1] & 0x1)  /* NDOB (no data-out buffer, assumes zeroes) */
+                ndob = true;
+        lba = get_unaligned_be64(cmd + 2);
+        num = get_unaligned_be32(cmd + 10);
+        if (num > scsi_debug_write_same_length) {
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 10, -1);
+                return check_condition_result;
+        }
+        return resp_write_same(scp, lba, num, ei_lba, unmap, ndob);
+}
+
+static int
+resp_comp_write(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
+{
+        u8 *cmd = scp->cmnd;
+        u8 *arr;
+        u8 *fake_storep_hold;
+        u64 lba;
+        u32 dnum;
+        u32 lb_size = scsi_debug_sector_size;
+        u8 num;
+        unsigned long iflags;
+        int ret;
+
+        lba = get_unaligned_be32(cmd + 2);
+        num = cmd[13];          /* 1 to a maximum of 255 logical blocks */
+        if (0 == num)
+                return 0;       /* degenerate case, not an error */
+        dnum = 2 * num;
+        arr = kzalloc(dnum * lb_size, GFP_ATOMIC);
+        if (NULL == arr) {
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
+                                INSUFF_RES_ASCQ);
+                return check_condition_result;
+        }
+        if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
+            (cmd[1] & 0xe0)) {
+                mk_sense_invalid_opcode(scp);
+                return check_condition_result;
+        }
+        if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
+             scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
+            (cmd[1] & 0xe0) == 0)
+                sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
+                            "to DIF device\n");
+
+        /* inline check_device_access_params() */
+        if (lba + num > sdebug_capacity) {
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+                return check_condition_result;
+        }
+        /* transfer length excessive (tie in to block limits VPD page) */
+        if (num > sdebug_store_sectors) {
+                /* needs work to find which cdb byte 'num' comes from */
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+                return check_condition_result;
+        }
+
+        write_lock_irqsave(&atomic_rw, iflags);
+
+        /* trick do_device_access() to fetch both compare and write buffers
+         * from data-in into arr. Safe (atomic) since write_lock held. */
+        fake_storep_hold = fake_storep;
+        fake_storep = arr;
+        ret = do_device_access(scp, 0, dnum, true);
+        fake_storep = fake_storep_hold;
+        if (ret == -1) {
+                write_unlock_irqrestore(&atomic_rw, iflags);
+                kfree(arr);
+                return DID_ERROR << 16;
+        } else if ((ret < (dnum * lb_size)) &&
+                 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
+                sdev_printk(KERN_INFO, scp->device, "%s: compare_write: cdb "
+                            "indicated=%u, IO sent=%d bytes\n", my_name,
+                            dnum * lb_size, ret);
+        if (!comp_write_worker(lba, num, arr)) {
+                write_unlock_irqrestore(&atomic_rw, iflags);
+                kfree(arr);
+                mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
+                return check_condition_result;
+        }
+        if (scsi_debug_lbp())
+                map_region(lba, num);
+        write_unlock_irqrestore(&atomic_rw, iflags);
+        return 0;
+}
+
 struct unmap_block_desc {
         __be64  lba;
         __be32  blocks;
         __be32  __reserved;
 };
 
-static int resp_unmap(struct scsi_cmnd * scmd, struct sdebug_dev_info * devip)
+static int
+resp_unmap(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
 {
         unsigned char *buf;
         struct unmap_block_desc *desc;
@@ -2329,20 +3124,26 @@ static int resp_unmap(struct scsi_cmnd * scmd, struct sdebug_dev_info * devip)
         int ret;
         unsigned long iflags;
 
-        ret = check_readiness(scmd, UAS_ONLY, devip);
-        if (ret)
-                return ret;
 
-        payload_len = get_unaligned_be16(&scmd->cmnd[7]);
-        BUG_ON(scsi_bufflen(scmd) != payload_len);
+        if (!scsi_debug_lbp())
+                return 0;       /* fib and say its done */
+        payload_len = get_unaligned_be16(scp->cmnd + 7);
+        BUG_ON(scsi_bufflen(scp) != payload_len);
 
         descriptors = (payload_len - 8) / 16;
+        if (descriptors > scsi_debug_unmap_max_desc) {
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
+                return check_condition_result;
+        }
 
-        buf = kmalloc(scsi_bufflen(scmd), GFP_ATOMIC);
-        if (!buf)
+        buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
+        if (!buf) {
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
+                                INSUFF_RES_ASCQ);
                 return check_condition_result;
+        }
 
-        scsi_sg_copy_to_buffer(scmd, buf, scsi_bufflen(scmd));
+        scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
 
         BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
         BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
@@ -2355,7 +3156,7 @@ static int resp_unmap(struct scsi_cmnd * scmd, struct sdebug_dev_info * devip)
                 unsigned long long lba = get_unaligned_be64(&desc[i].lba);
                 unsigned int num = get_unaligned_be32(&desc[i].blocks);
 
-                ret = check_device_access_params(scmd, lba, num);
+                ret = check_device_access_params(scp, lba, num);
                 if (ret)
                         goto out;
 
@@ -2373,37 +3174,44 @@ out:
 
 #define SDEBUG_GET_LBA_STATUS_LEN 32
 
-static int resp_get_lba_status(struct scsi_cmnd * scmd,
-                               struct sdebug_dev_info * devip)
+static int
+resp_get_lba_status(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
 {
-        unsigned long long lba;
-        unsigned int alloc_len, mapped, num;
-        unsigned char arr[SDEBUG_GET_LBA_STATUS_LEN];
+        u8 *cmd = scp->cmnd;
+        u64 lba;
+        u32 alloc_len, mapped, num;
+        u8 arr[SDEBUG_GET_LBA_STATUS_LEN];
         int ret;
 
-        ret = check_readiness(scmd, UAS_ONLY, devip);
-        if (ret)
-                return ret;
-
-        lba = get_unaligned_be64(&scmd->cmnd[2]);
-        alloc_len = get_unaligned_be32(&scmd->cmnd[10]);
+        lba = get_unaligned_be64(cmd + 2);
+        alloc_len = get_unaligned_be32(cmd + 10);
 
         if (alloc_len < 24)
                 return 0;
 
-        ret = check_device_access_params(scmd, lba, 1);
+        ret = check_device_access_params(scp, lba, 1);
         if (ret)
                 return ret;
 
-        mapped = map_state(lba, &num);
+        if (scsi_debug_lbp())
+                mapped = map_state(lba, &num);
+        else {
+                mapped = 1;
+                /* following just in case virtual_gb changed */
+                sdebug_capacity = get_sdebug_capacity();
+                if (sdebug_capacity - lba <= 0xffffffff)
+                        num = sdebug_capacity - lba;
+                else
+                        num = 0xffffffff;
+        }
 
         memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
-        put_unaligned_be32(20, &arr[0]);        /* Parameter Data Length */
-        put_unaligned_be64(lba, &arr[8]);       /* LBA */
-        put_unaligned_be32(num, &arr[16]);      /* Number of blocks */
-        arr[20] = !mapped;                      /* mapped = 0, unmapped = 1 */
+        put_unaligned_be32(20, arr);            /* Parameter Data Length */
+        put_unaligned_be64(lba, arr + 8);       /* LBA */
+        put_unaligned_be32(num, arr + 16);      /* Number of blocks */
+        arr[20] = !mapped;              /* prov_stat=0: mapped; 1: dealloc */
 
-        return fill_from_dev_buffer(scmd, arr, SDEBUG_GET_LBA_STATUS_LEN);
+        return fill_from_dev_buffer(scp, arr, SDEBUG_GET_LBA_STATUS_LEN);
 }
 
 #define SDEBUG_RLUN_ARR_SZ 256
@@ -2412,8 +3220,8 @@ static int resp_report_luns(struct scsi_cmnd * scp,
                             struct sdebug_dev_info * devip)
 {
         unsigned int alloc_len;
-        int lun_cnt, i, upper, num, n;
-        u64 wlun, lun;
+        int lun_cnt, i, upper, num, n, want_wlun, shortish;
+        u64 lun;
         unsigned char *cmd = scp->cmnd;
         int select_report = (int)cmd[2];
         struct scsi_lun *one_lun;
@@ -2421,9 +3229,9 @@ static int resp_report_luns(struct scsi_cmnd * scp,
         unsigned char * max_addr;
 
         alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
-        if ((alloc_len < 4) || (select_report > 2)) {
-                mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
-                                0);
+        shortish = (alloc_len < 4);
+        if (shortish || (select_report > 2)) {
+                mk_sense_invalid_fld(scp, SDEB_IN_CDB, shortish ? 6 : 2, -1);
                 return check_condition_result;
         }
         /* can produce response with up to 16k luns (lun 0 to lun 16383) */
@@ -2433,14 +3241,14 @@ static int resp_report_luns(struct scsi_cmnd * scp,
                 lun_cnt = 0;
         else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
                 --lun_cnt;
-        wlun = (select_report > 0) ? 1 : 0;
-        num = lun_cnt + wlun;
+        want_wlun = (select_report > 0) ? 1 : 0;
+        num = lun_cnt + want_wlun;
         arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
         arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
         n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
                             sizeof(struct scsi_lun)), num);
         if (n < num) {
-                wlun = 0;
+                want_wlun = 0;
                 lun_cnt = n;
         }
         one_lun = (struct scsi_lun *) &arr[8];
@@ -2454,7 +3262,7 @@ static int resp_report_luns(struct scsi_cmnd * scp,
                             (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
                 one_lun[i].scsi_lun[1] = lun & 0xff;
         }
-        if (wlun) {
+        if (want_wlun) {
                 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
                 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
                 i++;
@@ -2476,8 +3284,8 @@ static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
         /* better not to use temporary buffer. */
         buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
         if (!buf) {
-                mk_sense_buffer(scp, NOT_READY,
-                                LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
+                                INSUFF_RES_ASCQ);
                 return check_condition_result;
         }
 
@@ -2500,6 +3308,32 @@ static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
         return 0;
 }
 
+static int
+resp_xdwriteread_10(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
+{
+        u8 *cmd = scp->cmnd;
+        u64 lba;
+        u32 num;
+        int errsts;
+
+        if (!scsi_bidi_cmnd(scp)) {
+                mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
+                                INSUFF_RES_ASCQ);
+                return check_condition_result;
+        }
+        errsts = resp_read_dt0(scp, devip);
+        if (errsts)
+                return errsts;
+        if (!(cmd[1] & 0x4)) {          /* DISABLE_WRITE is not set */
+                errsts = resp_write_dt0(scp, devip);
+                if (errsts)
+                        return errsts;
+        }
+        lba = get_unaligned_be32(cmd + 2);
+        num = get_unaligned_be16(cmd + 7);
+        return resp_xdwriteread(scp, lba, num, devip);
+}
+
 /* When timer or tasklet goes off this function is called. */
 static void sdebug_q_cmd_complete(unsigned long indx)
 {
@@ -2672,10 +3506,7 @@ static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
         open_devip->sdbg_host = sdbg_host;
         atomic_set(&open_devip->num_in_q, 0);
         set_bit(SDEBUG_UA_POR, open_devip->uas_bm);
-        open_devip->used = 1;
-        if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
-                open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
-
+        open_devip->used = true;
         return open_devip;
 }
 
@@ -2701,10 +3532,6 @@ static int scsi_debug_slave_configure(struct scsi_device *sdp)
         if (NULL == devip)
                 return 1;       /* no resources, will be marked offline */
         sdp->hostdata = devip;
-        sdp->tagged_supported = 1;
-        if (sdp->host->cmd_per_lun)
-                scsi_adjust_queue_depth(sdp, DEF_TAGGED_QUEUING,
-                                        DEF_CMD_PER_LUN);
         blk_queue_max_segment_size(sdp->request_queue, -1U);
         if (scsi_debug_no_uld)
                 sdp->no_uld_attach = 1;
@@ -2721,7 +3548,7 @@ static void scsi_debug_slave_destroy(struct scsi_device *sdp)
                        sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
         if (devip) {
                 /* make this slot available for re-use */
-                devip->used = 0;
+                devip->used = false;
                 sdp->hostdata = NULL;
         }
 }
@@ -3166,6 +3993,7 @@ module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
 module_param_named(removable, scsi_debug_removable, bool, S_IRUGO | S_IWUSR);
 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
 module_param_named(sector_size, scsi_debug_sector_size, int, S_IRUGO);
+module_param_named(strict, scsi_debug_strict, bool, S_IRUGO | S_IWUSR);
 module_param_named(unmap_alignment, scsi_debug_unmap_alignment, int, S_IRUGO);
 module_param_named(unmap_granularity, scsi_debug_unmap_granularity, int, S_IRUGO);
 module_param_named(unmap_max_blocks, scsi_debug_unmap_max_blocks, int, S_IRUGO);
@@ -3185,7 +4013,7 @@ MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
 MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
 MODULE_PARM_DESC(clustering, "when set enables larger transfers (def=0)");
 MODULE_PARM_DESC(delay, "response delay (def=1 jiffy); 0:imm, -1,-2:tiny");
-MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
+MODULE_PARM_DESC(dev_size_mb, "size in MiB of ram shared by devs(def=8)");
 MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
 MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
@@ -3212,11 +4040,12 @@ MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
 MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=6[SPC-4])");
 MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
+MODULE_PARM_DESC(strict, "stricter checks: reserved field in cdb (def=0)");
 MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
 MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
 MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
 MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
-MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
+MODULE_PARM_DESC(virtual_gb, "virtual gigabyte (GiB) size (def=0 -> use dev_size_mb)");
 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
 MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
 
@@ -3382,6 +4211,16 @@ static ssize_t opts_store(struct device_driver *ddp, const char *buf,
         return -EINVAL;
 opts_done:
         scsi_debug_opts = opts;
+        if (SCSI_DEBUG_OPT_RECOVERED_ERR & opts)
+                sdebug_any_injecting_opt = true;
+        else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & opts)
+                sdebug_any_injecting_opt = true;
+        else if (SCSI_DEBUG_OPT_DIF_ERR & opts)
+                sdebug_any_injecting_opt = true;
+        else if (SCSI_DEBUG_OPT_DIX_ERR & opts)
+                sdebug_any_injecting_opt = true;
+        else if (SCSI_DEBUG_OPT_SHORT_TRANSFER & opts)
+                sdebug_any_injecting_opt = true;
         atomic_set(&sdebug_cmnd_count, 0);
         atomic_set(&sdebug_a_tsf, 0);
         return count;
@@ -3589,12 +4428,25 @@ static ssize_t virtual_gb_store(struct device_driver *ddp, const char *buf,
                                 size_t count)
 {
         int n;
+        bool changed;
 
         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
+                changed = (scsi_debug_virtual_gb != n);
                 scsi_debug_virtual_gb = n;
-
                 sdebug_capacity = get_sdebug_capacity();
-
+                if (changed) {
+                        struct sdebug_host_info *sdhp;
+                        struct sdebug_dev_info *dp;
+
+                        list_for_each_entry(sdhp, &sdebug_host_list,
+                                            host_list) {
+                                list_for_each_entry(dp, &sdhp->dev_info_list,
+                                                    dev_list) {
+                                        set_bit(SDEBUG_UA_CAPACITY_CHANGED,
+                                                dp->uas_bm);
+                                }
+                        }
+                }
                 return count;
         }
         return -EINVAL;
@@ -3740,6 +4592,23 @@ static ssize_t host_lock_store(struct device_driver *ddp, const char *buf,
 }
 static DRIVER_ATTR_RW(host_lock);
 
+static ssize_t strict_show(struct device_driver *ddp, char *buf)
+{
+        return scnprintf(buf, PAGE_SIZE, "%d\n", !!scsi_debug_strict);
+}
+static ssize_t strict_store(struct device_driver *ddp, const char *buf,
+                            size_t count)
+{
+        int n;
+
+        if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
+                scsi_debug_strict = (n > 0);
+                return count;
+        }
+        return -EINVAL;
+}
+static DRIVER_ATTR_RW(strict);
+
 
 /* Note: The following array creates attribute files in the
    /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
@@ -3775,6 +4644,7 @@ static struct attribute *sdebug_drv_attrs[] = {
         &driver_attr_removable.attr,
         &driver_attr_host_lock.attr,
         &driver_attr_ndelay.attr,
+        &driver_attr_strict.attr,
         NULL,
 };
 ATTRIBUTE_GROUPS(sdebug_drv);
@@ -4087,396 +4957,9 @@ static void sdebug_remove_adapter(void)
 }
 
 static int
-scsi_debug_queuecommand(struct scsi_cmnd *SCpnt)
-{
-        unsigned char *cmd = SCpnt->cmnd;
-        int len, k;
-        unsigned int num;
-        unsigned long long lba;
-        u32 ei_lba;
-        int errsts = 0;
-        int target = SCpnt->device->id;
-        struct sdebug_dev_info *devip = NULL;
-        int inj_recovered = 0;
-        int inj_transport = 0;
-        int inj_dif = 0;
-        int inj_dix = 0;
-        int inj_short = 0;
-        int delay_override = 0;
-        int unmap = 0;
-
-        scsi_set_resid(SCpnt, 0);
-        if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) &&
-            !(SCSI_DEBUG_OPT_NO_CDB_NOISE & scsi_debug_opts)) {
-                char b[120];
-                int n;
-
-                len = SCpnt->cmd_len;
-                if (len > 32)
-                        strcpy(b, "too long, over 32 bytes");
-                else {
-                        for (k = 0, n = 0; k < len; ++k)
-                                n += scnprintf(b + n, sizeof(b) - n, "%02x ",
-                                               (unsigned int)cmd[k]);
-                }
-                sdev_printk(KERN_INFO, SCpnt->device, "%s: cmd %s\n", my_name,
-                            b);
-        }
-
-        if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
-            (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
-                return schedule_resp(SCpnt, NULL, DID_NO_CONNECT << 16, 0);
-        devip = devInfoReg(SCpnt->device);
-        if (NULL == devip)
-                return schedule_resp(SCpnt, NULL, DID_NO_CONNECT << 16, 0);
-
-        if ((scsi_debug_every_nth != 0) &&
-            (atomic_inc_return(&sdebug_cmnd_count) >=
-             abs(scsi_debug_every_nth))) {
-                atomic_set(&sdebug_cmnd_count, 0);
-                if (scsi_debug_every_nth < -1)
-                        scsi_debug_every_nth = -1;
-                if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
-                        return 0; /* ignore command causing timeout */
-                else if (SCSI_DEBUG_OPT_MAC_TIMEOUT & scsi_debug_opts &&
-                         scsi_medium_access_command(SCpnt))
-                        return 0; /* time out reads and writes */
-                else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
-                        inj_recovered = 1; /* to reads and writes below */
-                else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
-                        inj_transport = 1; /* to reads and writes below */
-                else if (SCSI_DEBUG_OPT_DIF_ERR & scsi_debug_opts)
-                        inj_dif = 1; /* to reads and writes below */
-                else if (SCSI_DEBUG_OPT_DIX_ERR & scsi_debug_opts)
-                        inj_dix = 1; /* to reads and writes below */
-                else if (SCSI_DEBUG_OPT_SHORT_TRANSFER & scsi_debug_opts)
-                        inj_short = 1;
-        }
-
-        if (devip->wlun) {
-                switch (*cmd) {
-                case INQUIRY:
-                case REQUEST_SENSE:
-                case TEST_UNIT_READY:
-                case REPORT_LUNS:
-                        break;  /* only allowable wlun commands */
-                default:
-                        if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
-                                printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
-                                       "not supported for wlun\n", *cmd);
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                        INVALID_OPCODE, 0);
-                        errsts = check_condition_result;
-                        return schedule_resp(SCpnt, devip, errsts, 0);
-                }
-        }
-
-        switch (*cmd) {
-        case INQUIRY:     /* mandatory, ignore unit attention */
-                delay_override = 1;
-                errsts = resp_inquiry(SCpnt, target, devip);
-                break;
-        case REQUEST_SENSE:     /* mandatory, ignore unit attention */
-                delay_override = 1;
-                errsts = resp_requests(SCpnt, devip);
-                break;
-        case REZERO_UNIT:       /* actually this is REWIND for SSC */
-        case START_STOP:
-                errsts = resp_start_stop(SCpnt, devip);
-                break;
-        case ALLOW_MEDIUM_REMOVAL:
-                errsts = check_readiness(SCpnt, UAS_ONLY, devip);
-                if (errsts)
-                        break;
-                if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
-                        printk(KERN_INFO "scsi_debug: Medium removal %s\n",
-                               cmd[4] ? "inhibited" : "enabled");
-                break;
-        case SEND_DIAGNOSTIC:     /* mandatory */
-                errsts = check_readiness(SCpnt, UAS_ONLY, devip);
-                break;
-        case TEST_UNIT_READY:     /* mandatory */
-                /* delay_override = 1; */
-                errsts = check_readiness(SCpnt, UAS_TUR, devip);
-                break;
-        case RESERVE:
-                errsts = check_readiness(SCpnt, UAS_ONLY, devip);
-                break;
-        case RESERVE_10:
-                errsts = check_readiness(SCpnt, UAS_ONLY, devip);
-                break;
-        case RELEASE:
-                errsts = check_readiness(SCpnt, UAS_ONLY, devip);
-                break;
-        case RELEASE_10:
-                errsts = check_readiness(SCpnt, UAS_ONLY, devip);
-                break;
-        case READ_CAPACITY:
-                errsts = resp_readcap(SCpnt, devip);
-                break;
-        case SERVICE_ACTION_IN:
-                if (cmd[1] == SAI_READ_CAPACITY_16)
-                        errsts = resp_readcap16(SCpnt, devip);
-                else if (cmd[1] == SAI_GET_LBA_STATUS) {
-
-                        if (scsi_debug_lbp() == 0) {
-                                mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                                INVALID_COMMAND_OPCODE, 0);
-                                errsts = check_condition_result;
-                        } else
-                                errsts = resp_get_lba_status(SCpnt, devip);
-                } else {
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                        INVALID_OPCODE, 0);
-                        errsts = check_condition_result;
-                }
-                break;
-        case MAINTENANCE_IN:
-                if (MI_REPORT_TARGET_PGS != cmd[1]) {
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                        INVALID_OPCODE, 0);
-                        errsts = check_condition_result;
-                        break;
-                }
-                errsts = resp_report_tgtpgs(SCpnt, devip);
-                break;
-        case READ_16:
-        case READ_12:
-        case READ_10:
-                /* READ{10,12,16} and DIF Type 2 are natural enemies */
-                if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
-                    cmd[1] & 0xe0) {
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                        INVALID_COMMAND_OPCODE, 0);
-                        errsts = check_condition_result;
-                        break;
-                }
-
-                if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
-                     scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
-                    (cmd[1] & 0xe0) == 0)
-                        printk(KERN_ERR "Unprotected RD/WR to DIF device\n");
-
-                /* fall through */
-        case READ_6:
-read:
-                errsts = check_readiness(SCpnt, UAS_TUR, devip);
-                if (errsts)
-                        break;
-                if (scsi_debug_fake_rw)
-                        break;
-                get_data_transfer_info(cmd, &lba, &num, &ei_lba);
-
-                if (inj_short)
-                        num /= 2;
-
-                errsts = resp_read(SCpnt, lba, num, ei_lba);
-                if (inj_recovered && (0 == errsts)) {
-                        mk_sense_buffer(SCpnt, RECOVERED_ERROR,
-                                        THRESHOLD_EXCEEDED, 0);
-                        errsts = check_condition_result;
-                } else if (inj_transport && (0 == errsts)) {
-                        mk_sense_buffer(SCpnt, ABORTED_COMMAND,
-                                        TRANSPORT_PROBLEM, ACK_NAK_TO);
-                        errsts = check_condition_result;
-                } else if (inj_dif && (0 == errsts)) {
-                        /* Logical block guard check failed */
-                        mk_sense_buffer(SCpnt, ABORTED_COMMAND, 0x10, 1);
-                        errsts = illegal_condition_result;
-                } else if (inj_dix && (0 == errsts)) {
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST, 0x10, 1);
-                        errsts = illegal_condition_result;
-                }
-                break;
-        case REPORT_LUNS:       /* mandatory, ignore unit attention */
-                delay_override = 1;
-                errsts = resp_report_luns(SCpnt, devip);
-                break;
-        case VERIFY:            /* 10 byte SBC-2 command */
-                errsts = check_readiness(SCpnt, UAS_TUR, devip);
-                break;
-        case WRITE_16:
-        case WRITE_12:
-        case WRITE_10:
-                /* WRITE{10,12,16} and DIF Type 2 are natural enemies */
-                if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
-                    cmd[1] & 0xe0) {
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                        INVALID_COMMAND_OPCODE, 0);
-                        errsts = check_condition_result;
-                        break;
-                }
-
-                if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
-                     scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
-                    (cmd[1] & 0xe0) == 0)
-                        printk(KERN_ERR "Unprotected RD/WR to DIF device\n");
-
-                /* fall through */
-        case WRITE_6:
-write:
-                errsts = check_readiness(SCpnt, UAS_TUR, devip);
-                if (errsts)
-                        break;
-                if (scsi_debug_fake_rw)
-                        break;
-                get_data_transfer_info(cmd, &lba, &num, &ei_lba);
-                errsts = resp_write(SCpnt, lba, num, ei_lba);
-                if (inj_recovered && (0 == errsts)) {
-                        mk_sense_buffer(SCpnt, RECOVERED_ERROR,
-                                        THRESHOLD_EXCEEDED, 0);
-                        errsts = check_condition_result;
-                } else if (inj_dif && (0 == errsts)) {
-                        mk_sense_buffer(SCpnt, ABORTED_COMMAND, 0x10, 1);
-                        errsts = illegal_condition_result;
-                } else if (inj_dix && (0 == errsts)) {
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST, 0x10, 1);
-                        errsts = illegal_condition_result;
-                }
-                break;
-        case WRITE_SAME_16:
-        case WRITE_SAME:
-                if (cmd[1] & 0x8) {
-                        if ((*cmd == WRITE_SAME_16 && scsi_debug_lbpws == 0) ||
-                            (*cmd == WRITE_SAME && scsi_debug_lbpws10 == 0)) {
-                                mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                                INVALID_FIELD_IN_CDB, 0);
-                                errsts = check_condition_result;
-                        } else
-                                unmap = 1;
-                }
-                if (errsts)
-                        break;
-                errsts = check_readiness(SCpnt, UAS_TUR, devip);
-                if (errsts)
-                        break;
-                if (scsi_debug_fake_rw)
-                        break;
-                get_data_transfer_info(cmd, &lba, &num, &ei_lba);
-                errsts = resp_write_same(SCpnt, lba, num, ei_lba, unmap);
-                break;
-        case UNMAP:
-                errsts = check_readiness(SCpnt, UAS_TUR, devip);
-                if (errsts)
-                        break;
-                if (scsi_debug_fake_rw)
-                        break;
-
-                if (scsi_debug_unmap_max_desc == 0 || scsi_debug_lbpu == 0) {
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                        INVALID_COMMAND_OPCODE, 0);
-                        errsts = check_condition_result;
-                } else
-                        errsts = resp_unmap(SCpnt, devip);
-                break;
-        case MODE_SENSE:
-        case MODE_SENSE_10:
-                errsts = resp_mode_sense(SCpnt, target, devip);
-                break;
-        case MODE_SELECT:
-                errsts = resp_mode_select(SCpnt, 1, devip);
-                break;
-        case MODE_SELECT_10:
-                errsts = resp_mode_select(SCpnt, 0, devip);
-                break;
-        case LOG_SENSE:
-                errsts = resp_log_sense(SCpnt, devip);
-                break;
-        case SYNCHRONIZE_CACHE:
-                delay_override = 1;
-                errsts = check_readiness(SCpnt, UAS_TUR, devip);
-                break;
-        case WRITE_BUFFER:
-                errsts = check_readiness(SCpnt, UAS_ONLY, devip);
-                break;
-        case XDWRITEREAD_10:
-                if (!scsi_bidi_cmnd(SCpnt)) {
-                        mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                        INVALID_FIELD_IN_CDB, 0);
-                        errsts = check_condition_result;
-                        break;
-                }
-
-                errsts = check_readiness(SCpnt, UAS_TUR, devip);
-                if (errsts)
-                        break;
-                if (scsi_debug_fake_rw)
-                        break;
-                get_data_transfer_info(cmd, &lba, &num, &ei_lba);
-                errsts = resp_read(SCpnt, lba, num, ei_lba);
-                if (errsts)
-                        break;
-                errsts = resp_write(SCpnt, lba, num, ei_lba);
-                if (errsts)
-                        break;
-                errsts = resp_xdwriteread(SCpnt, lba, num, devip);
-                break;
-        case VARIABLE_LENGTH_CMD:
-                if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION) {
-
-                        if ((cmd[10] & 0xe0) == 0)
-                                printk(KERN_ERR
-                                       "Unprotected RD/WR to DIF device\n");
-
-                        if (cmd[9] == READ_32) {
-                                BUG_ON(SCpnt->cmd_len < 32);
-                                goto read;
-                        }
-
-                        if (cmd[9] == WRITE_32) {
-                                BUG_ON(SCpnt->cmd_len < 32);
-                                goto write;
-                        }
-                }
-
-                mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                INVALID_FIELD_IN_CDB, 0);
-                errsts = check_condition_result;
-                break;
-        case 0x85:
-                if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
-                        sdev_printk(KERN_INFO, SCpnt->device,
-                        "%s: ATA PASS-THROUGH(16) not supported\n", my_name);
-                mk_sense_buffer(SCpnt, ILLEGAL_REQUEST,
-                                INVALID_OPCODE, 0);
-                errsts = check_condition_result;
-                break;
-        default:
-                if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
-                        sdev_printk(KERN_INFO, SCpnt->device,
-                                    "%s: Opcode: 0x%x not supported\n",
-                                    my_name, *cmd);
-                errsts = check_readiness(SCpnt, UAS_ONLY, devip);
-                if (errsts)
-                        break;  /* Unit attention takes precedence */
-                mk_sense_buffer(SCpnt, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
-                errsts = check_condition_result;
-                break;
-        }
-        return schedule_resp(SCpnt, devip, errsts,
-                             (delay_override ? 0 : scsi_debug_delay));
-}
-
-static int
-sdebug_queuecommand_lock_or_not(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
-{
-        if (scsi_debug_host_lock) {
-                unsigned long iflags;
-                int rc;
-
-                spin_lock_irqsave(shost->host_lock, iflags);
-                rc = scsi_debug_queuecommand(cmd);
-                spin_unlock_irqrestore(shost->host_lock, iflags);
-                return rc;
-        } else
-                return scsi_debug_queuecommand(cmd);
-}
-
-static int
-sdebug_change_qdepth(struct scsi_device *sdev, int qdepth, int reason)
+sdebug_change_qdepth(struct scsi_device *sdev, int qdepth)
 {
         int num_in_q = 0;
-        int bad = 0;
         unsigned long iflags;
         struct sdebug_dev_info *devip;
 
@@ -4488,43 +4971,18 @@ sdebug_change_qdepth(struct scsi_device *sdev, int qdepth, int reason)
         }
         num_in_q = atomic_read(&devip->num_in_q);
         spin_unlock_irqrestore(&queued_arr_lock, iflags);
-        if (reason == SCSI_QDEPTH_DEFAULT || reason == SCSI_QDEPTH_RAMP_UP) {
-                if (qdepth < 1)
-                        qdepth = 1;
-                /* allow to exceed max host queued_arr elements for testing */
-                if (qdepth > SCSI_DEBUG_CANQUEUE + 10)
-                        qdepth = SCSI_DEBUG_CANQUEUE + 10;
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-        } else if (reason == SCSI_QDEPTH_QFULL)
-                scsi_track_queue_full(sdev, qdepth);
-        else
-                bad = 1;
-        if (bad)
-                sdev_printk(KERN_WARNING, sdev,
-                            "%s: unknown reason=0x%x\n", __func__, reason);
+
+        if (qdepth < 1)
+                qdepth = 1;
+        /* allow to exceed max host queued_arr elements for testing */
+        if (qdepth > SCSI_DEBUG_CANQUEUE + 10)
+                qdepth = SCSI_DEBUG_CANQUEUE + 10;
+        scsi_change_queue_depth(sdev, qdepth);
+
         if (SCSI_DEBUG_OPT_Q_NOISE & scsi_debug_opts) {
-                if (SCSI_QDEPTH_QFULL == reason)
-                        sdev_printk(KERN_INFO, sdev,
-                            "%s: -> %d, num_in_q=%d, reason: queue full\n",
-                                    __func__, qdepth, num_in_q);
-                else {
-                        const char *cp;
-
-                        switch (reason) {
-                        case SCSI_QDEPTH_DEFAULT:
-                                cp = "default (sysfs ?)";
-                                break;
-                        case SCSI_QDEPTH_RAMP_UP:
-                                cp = "ramp up";
-                                break;
-                        default:
-                                cp = "unknown";
-                                break;
-                        }
-                        sdev_printk(KERN_INFO, sdev,
-                                    "%s: qdepth=%d, num_in_q=%d, reason: %s\n",
-                                    __func__, qdepth, num_in_q, cp);
-                }
+                sdev_printk(KERN_INFO, sdev,
+                            "%s: qdepth=%d, num_in_q=%d\n",
+                            __func__, qdepth, num_in_q);
         }
         return sdev->queue_depth;
 }
@@ -4532,14 +4990,7 @@ sdebug_change_qdepth(struct scsi_device *sdev, int qdepth, int reason)
 static int
 sdebug_change_qtype(struct scsi_device *sdev, int qtype)
 {
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, qtype);
-                if (qtype)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                qtype = 0;
+        qtype = scsi_change_queue_type(sdev, qtype);
         if (SCSI_DEBUG_OPT_Q_NOISE & scsi_debug_opts) {
                 const char *cp;
 
@@ -4562,6 +5013,193 @@ sdebug_change_qtype(struct scsi_device *sdev, int qtype)
         return qtype;
 }
 
+static int
+check_inject(struct scsi_cmnd *scp)
+{
+        struct sdebug_scmd_extra_t *ep = scsi_cmd_priv(scp);
+
+        memset(ep, 0, sizeof(struct sdebug_scmd_extra_t));
+
+        if (atomic_inc_return(&sdebug_cmnd_count) >=
+            abs(scsi_debug_every_nth)) {
+                atomic_set(&sdebug_cmnd_count, 0);
+                if (scsi_debug_every_nth < -1)
+                        scsi_debug_every_nth = -1;
+                if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
+                        return 1; /* ignore command causing timeout */
+                else if (SCSI_DEBUG_OPT_MAC_TIMEOUT & scsi_debug_opts &&
+                         scsi_medium_access_command(scp))
+                        return 1; /* time out reads and writes */
+                if (sdebug_any_injecting_opt) {
+                        int opts = scsi_debug_opts;
+
+                        if (SCSI_DEBUG_OPT_RECOVERED_ERR & opts)
+                                ep->inj_recovered = true;
+                        else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & opts)
+                                ep->inj_transport = true;
+                        else if (SCSI_DEBUG_OPT_DIF_ERR & opts)
+                                ep->inj_dif = true;
+                        else if (SCSI_DEBUG_OPT_DIX_ERR & opts)
+                                ep->inj_dix = true;
+                        else if (SCSI_DEBUG_OPT_SHORT_TRANSFER & opts)
+                                ep->inj_short = true;
+                }
+        }
+        return 0;
+}
+
+static int
+scsi_debug_queuecommand(struct scsi_cmnd *scp)
+{
+        u8 sdeb_i;
+        struct scsi_device *sdp = scp->device;
+        const struct opcode_info_t *oip;
+        const struct opcode_info_t *r_oip;
+        struct sdebug_dev_info *devip;
+        u8 *cmd = scp->cmnd;
+        int (*r_pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
+        int k, na;
+        int errsts = 0;
+        int errsts_no_connect = DID_NO_CONNECT << 16;
+        u32 flags;
+        u16 sa;
+        u8 opcode = cmd[0];
+        bool has_wlun_rl;
+        bool debug = !!(SCSI_DEBUG_OPT_NOISE & scsi_debug_opts);
+
+        scsi_set_resid(scp, 0);
+        if (debug && !(SCSI_DEBUG_OPT_NO_CDB_NOISE & scsi_debug_opts)) {
+                char b[120];
+                int n, len, sb;
+
+                len = scp->cmd_len;
+                sb = (int)sizeof(b);
+                if (len > 32)
+                        strcpy(b, "too long, over 32 bytes");
+                else {
+                        for (k = 0, n = 0; k < len && n < sb; ++k)
+                                n += scnprintf(b + n, sb - n, "%02x ",
+                                               (u32)cmd[k]);
+                }
+                sdev_printk(KERN_INFO, sdp, "%s: cmd %s\n", my_name, b);
+        }
+        has_wlun_rl = (sdp->lun == SAM2_WLUN_REPORT_LUNS);
+        if ((sdp->lun >= scsi_debug_max_luns) && !has_wlun_rl)
+                return schedule_resp(scp, NULL, errsts_no_connect, 0);
+
+        sdeb_i = opcode_ind_arr[opcode];        /* fully mapped */
+        oip = &opcode_info_arr[sdeb_i];         /* safe if table consistent */
+        devip = (struct sdebug_dev_info *)sdp->hostdata;
+        if (!devip) {
+                devip = devInfoReg(sdp);
+                if (NULL == devip)
+                        return schedule_resp(scp, NULL, errsts_no_connect, 0);
+        }
+        na = oip->num_attached;
+        r_pfp = oip->pfp;
+        if (na) {       /* multiple commands with this opcode */
+                r_oip = oip;
+                if (FF_SA & r_oip->flags) {
+                        if (F_SA_LOW & oip->flags)
+                                sa = 0x1f & cmd[1];
+                        else
+                                sa = get_unaligned_be16(cmd + 8);
+                        for (k = 0; k <= na; oip = r_oip->arrp + k++) {
+                                if (opcode == oip->opcode && sa == oip->sa)
+                                        break;
+                        }
+                } else {   /* since no service action only check opcode */
+                        for (k = 0; k <= na; oip = r_oip->arrp + k++) {
+                                if (opcode == oip->opcode)
+                                        break;
+                        }
+                }
+                if (k > na) {
+                        if (F_SA_LOW & r_oip->flags)
+                                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 4);
+                        else if (F_SA_HIGH & r_oip->flags)
+                                mk_sense_invalid_fld(scp, SDEB_IN_CDB, 8, 7);
+                        else
+                                mk_sense_invalid_opcode(scp);
+                        goto check_cond;
+                }
+        }       /* else (when na==0) we assume the oip is a match */
+        flags = oip->flags;
+        if (F_INV_OP & flags) {
+                mk_sense_invalid_opcode(scp);
+                goto check_cond;
+        }
+        if (has_wlun_rl && !(F_RL_WLUN_OK & flags)) {
+                if (debug)
+                        sdev_printk(KERN_INFO, sdp, "scsi_debug: Opcode: "
+                                    "0x%x not supported for wlun\n", opcode);
+                mk_sense_invalid_opcode(scp);
+                goto check_cond;
+        }
+        if (scsi_debug_strict) {        /* check cdb against mask */
+                u8 rem;
+                int j;
+
+                for (k = 1; k < oip->len_mask[0] && k < 16; ++k) {
+                        rem = ~oip->len_mask[k] & cmd[k];
+                        if (rem) {
+                                for (j = 7; j >= 0; --j, rem <<= 1) {
+                                        if (0x80 & rem)
+                                                break;
+                                }
+                                mk_sense_invalid_fld(scp, SDEB_IN_CDB, k, j);
+                                goto check_cond;
+                        }
+                }
+        }
+        if (!(F_SKIP_UA & flags) &&
+            SDEBUG_NUM_UAS != find_first_bit(devip->uas_bm, SDEBUG_NUM_UAS)) {
+                errsts = check_readiness(scp, UAS_ONLY, devip);
+                if (errsts)
+                        goto check_cond;
+        }
+        if ((F_M_ACCESS & flags) && devip->stopped) {
+                mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
+                if (debug)
+                        sdev_printk(KERN_INFO, sdp, "%s reports: Not ready: "
+                                    "%s\n", my_name, "initializing command "
+                                    "required");
+                errsts = check_condition_result;
+                goto fini;
+        }
+        if (scsi_debug_fake_rw && (F_FAKE_RW & flags))
+                goto fini;
+        if (scsi_debug_every_nth) {
+                if (check_inject(scp))
+                        return 0;       /* ignore command: make trouble */
+        }
+        if (oip->pfp)   /* if this command has a resp_* function, call it */
+                errsts = oip->pfp(scp, devip);
+        else if (r_pfp) /* if leaf function ptr NULL, try the root's */
+                errsts = r_pfp(scp, devip);
+
+fini:
+        return schedule_resp(scp, devip, errsts,
+                             ((F_DELAY_OVERR & flags) ? 0 : scsi_debug_delay));
+check_cond:
+        return schedule_resp(scp, devip, check_condition_result, 0);
+}
+
+static int
+sdebug_queuecommand_lock_or_not(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
+{
+        if (scsi_debug_host_lock) {
+                unsigned long iflags;
+                int rc;
+
+                spin_lock_irqsave(shost->host_lock, iflags);
+                rc = scsi_debug_queuecommand(cmd);
+                spin_unlock_irqrestore(shost->host_lock, iflags);
+                return rc;
+        } else
+                return scsi_debug_queuecommand(cmd);
+}
+
 static struct scsi_host_template sdebug_driver_template = {
         .show_info =            scsi_debug_show_info,
         .write_info =           scsi_debug_write_info,
@@ -4587,13 +5225,16 @@ static struct scsi_host_template sdebug_driver_template = {
         .max_sectors =          -1U,
         .use_clustering =       DISABLE_CLUSTERING,
         .module =               THIS_MODULE,
+        .track_queue_depth =    1,
+        .cmd_size =             sizeof(struct sdebug_scmd_extra_t),
 };
 
 static int sdebug_driver_probe(struct device * dev)
 {
-        int error = 0;
-        struct sdebug_host_info *sdbg_host;
-        struct Scsi_Host *hpnt;
+        int error = 0;
+        int opts;
+        struct sdebug_host_info *sdbg_host;
+        struct Scsi_Host *hpnt;
         int host_prot;
 
         sdbg_host = to_sdebug_host(dev);
@@ -4603,7 +5244,7 @@ static int sdebug_driver_probe(struct device * dev)
                 sdebug_driver_template.use_clustering = ENABLE_CLUSTERING;
         hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
         if (NULL == hpnt) {
-                printk(KERN_ERR "%s: scsi_register failed\n", __func__);
+                pr_err("%s: scsi_host_alloc failed\n", __func__);
                 error = -ENODEV;
                 return error;
         }
@@ -4660,6 +5301,18 @@ static int sdebug_driver_probe(struct device * dev)
         else
                 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
 
+        opts = scsi_debug_opts;
+        if (SCSI_DEBUG_OPT_RECOVERED_ERR & opts)
+                sdebug_any_injecting_opt = true;
+        else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & opts)
+                sdebug_any_injecting_opt = true;
+        else if (SCSI_DEBUG_OPT_DIF_ERR & opts)
+                sdebug_any_injecting_opt = true;
+        else if (SCSI_DEBUG_OPT_DIX_ERR & opts)
+                sdebug_any_injecting_opt = true;
+        else if (SCSI_DEBUG_OPT_SHORT_TRANSFER & opts)
+                sdebug_any_injecting_opt = true;
+
         error = scsi_add_host(hpnt, &sdbg_host->dev);
         if (error) {
                 printk(KERN_ERR "%s: scsi_add_host failed\n", __func__);
diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
index 49014a143c6a..c1d04d4d3c6c 100644
--- a/drivers/scsi/scsi_devinfo.c
+++ b/drivers/scsi/scsi_devinfo.c
@@ -202,6 +202,7 @@ static struct {
         {"IOMEGA", "Io20S         *F", NULL, BLIST_KEY},
         {"INSITE", "Floptical   F*8I", NULL, BLIST_KEY},
         {"INSITE", "I325VM", NULL, BLIST_KEY},
+        {"Intel", "Multi-Flex", NULL, BLIST_NO_RSOC},
         {"iRiver", "iFP Mass Driver", NULL, BLIST_NOT_LOCKABLE | BLIST_INQUIRY_36},
         {"LASOUND", "CDX7405", "3.10", BLIST_MAX5LUN | BLIST_SINGLELUN},
         {"MATSHITA", "PD-1", NULL, BLIST_FORCELUN | BLIST_SINGLELUN},
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index bc5ff6ff9c79..e42fff6e8c10 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -36,6 +36,7 @@
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_ioctl.h>
+#include <scsi/sg.h>
 
 #include "scsi_priv.h"
 #include "scsi_logging.h"
@@ -157,8 +158,9 @@ scmd_eh_abort_handler(struct work_struct *work)
                 } else {
                         SCSI_LOG_ERROR_RECOVERY(3,
                                 scmd_printk(KERN_INFO, scmd,
-                                            "scmd %p abort failed, rtn %d\n",
-                                            scmd, rtn));
+                                            "scmd %p abort %s\n", scmd,
+                                            (rtn == FAST_IO_FAIL) ?
+                                            "not send" : "failed"));
                 }
         }
 
@@ -355,7 +357,7 @@ static inline void scsi_eh_prt_fail_stats(struct Scsi_Host *shost,
 
                 if (cmd_cancel || cmd_failed) {
                         SCSI_LOG_ERROR_RECOVERY(3,
-                                sdev_printk(KERN_INFO, sdev,
+                                shost_printk(KERN_INFO, shost,
                                             "%s: cmds failed: %d, cancel: %d\n",
                                             __func__, cmd_failed,
                                             cmd_cancel));
@@ -608,7 +610,7 @@ static void scsi_handle_queue_ramp_up(struct scsi_device *sdev)
         struct scsi_host_template *sht = sdev->host->hostt;
         struct scsi_device *tmp_sdev;
 
-        if (!sht->change_queue_depth ||
+        if (!sht->track_queue_depth ||
             sdev->queue_depth >= sdev->max_queue_depth)
                 return;
 
@@ -629,12 +631,8 @@ static void scsi_handle_queue_ramp_up(struct scsi_device *sdev)
                     tmp_sdev->id != sdev->id ||
                     tmp_sdev->queue_depth == sdev->max_queue_depth)
                         continue;
-                /*
-                 * call back into LLD to increase queue_depth by one
-                 * with ramp up reason code.
-                 */
-                sht->change_queue_depth(tmp_sdev, tmp_sdev->queue_depth + 1,
-                                        SCSI_QDEPTH_RAMP_UP);
+
+                scsi_change_queue_depth(tmp_sdev, tmp_sdev->queue_depth + 1);
                 sdev->last_queue_ramp_up = jiffies;
         }
 }
@@ -644,7 +642,7 @@ static void scsi_handle_queue_full(struct scsi_device *sdev)
         struct scsi_host_template *sht = sdev->host->hostt;
         struct scsi_device *tmp_sdev;
 
-        if (!sht->change_queue_depth)
+        if (!sht->track_queue_depth)
                 return;
 
         shost_for_each_device(tmp_sdev, sdev->host) {
@@ -656,8 +654,7 @@ static void scsi_handle_queue_full(struct scsi_device *sdev)
                  * the device when we got the queue full so we start
                  * from the highest possible value and work our way down.
                  */
-                sht->change_queue_depth(tmp_sdev, tmp_sdev->queue_depth - 1,
-                                        SCSI_QDEPTH_QFULL);
+                scsi_track_queue_full(tmp_sdev, tmp_sdev->queue_depth - 1);
         }
 }
 
@@ -869,7 +866,24 @@ static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
         return rtn;
 }
 
-static int scsi_try_to_abort_cmd(struct scsi_host_template *hostt, struct scsi_cmnd *scmd)
+/**
+ * scsi_try_to_abort_cmd - Ask host to abort a SCSI command
+ * @scmd:       SCSI cmd used to send a target reset
+ *
+ * Return value:
+ *      SUCCESS, FAILED, or FAST_IO_FAIL
+ *
+ * Notes:
+ *    SUCCESS does not necessarily indicate that the command
+ *    has been aborted; it only indicates that the LLDDs
+ *    has cleared all references to that command.
+ *    LLDDs should return FAILED only if an abort was required
+ *    but could not be executed. LLDDs should return FAST_IO_FAIL
+ *    if the device is temporarily unavailable (eg due to a
+ *    link down on FibreChannel)
+ */
+static int scsi_try_to_abort_cmd(struct scsi_host_template *hostt,
+                                 struct scsi_cmnd *scmd)
 {
         if (!hostt->eh_abort_handler)
                 return FAILED;
@@ -1156,9 +1170,9 @@ int scsi_eh_get_sense(struct list_head *work_q,
                 shost = scmd->device->host;
                 if (scsi_host_eh_past_deadline(shost)) {
                         SCSI_LOG_ERROR_RECOVERY(3,
-                                shost_printk(KERN_INFO, shost,
-                                            "skip %s, past eh deadline\n",
-                                             __func__));
+                                scmd_printk(KERN_INFO, scmd,
+                                            "%s: skip request sense, past eh deadline\n",
+                                             current->comm));
                         break;
                 }
                 if (status_byte(scmd->result) != CHECK_CONDITION)
@@ -1180,7 +1194,7 @@ int scsi_eh_get_sense(struct list_head *work_q,
                 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
                         "sense requested for %p result %x\n",
                         scmd, scmd->result));
-                SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense("bh", scmd));
+                SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense(scmd));
 
                 rtn = scsi_decide_disposition(scmd);
 
@@ -1265,9 +1279,9 @@ static int scsi_eh_test_devices(struct list_head *cmd_list,
                                 /* Push items back onto work_q */
                                 list_splice_init(cmd_list, work_q);
                                 SCSI_LOG_ERROR_RECOVERY(3,
-                                        shost_printk(KERN_INFO, sdev->host,
-                                                     "skip %s, past eh deadline",
-                                                     __func__));
+                                        sdev_printk(KERN_INFO, sdev,
+                                                    "%s: skip test device, past eh deadline",
+                                                    current->comm));
                                 break;
                         }
                 }
@@ -1318,21 +1332,20 @@ static int scsi_eh_abort_cmds(struct list_head *work_q,
                 if (scsi_host_eh_past_deadline(shost)) {
                         list_splice_init(&check_list, work_q);
                         SCSI_LOG_ERROR_RECOVERY(3,
-                                shost_printk(KERN_INFO, shost,
-                                            "skip %s, past eh deadline\n",
-                                             __func__));
+                                scmd_printk(KERN_INFO, scmd,
+                                            "%s: skip aborting cmd, past eh deadline\n",
+                                            current->comm));
                         return list_empty(work_q);
                 }
                 SCSI_LOG_ERROR_RECOVERY(3,
-                        shost_printk(KERN_INFO, shost,
-                                     "%s: aborting cmd: 0x%p\n",
-                                     current->comm, scmd));
+                        scmd_printk(KERN_INFO, scmd,
+                                     "%s: aborting cmd\n", current->comm));
                 rtn = scsi_try_to_abort_cmd(shost->hostt, scmd);
                 if (rtn == FAILED) {
                         SCSI_LOG_ERROR_RECOVERY(3,
-                                shost_printk(KERN_INFO, shost,
-                                             "%s: aborting cmd failed: 0x%p\n",
-                                             current->comm, scmd));
+                                scmd_printk(KERN_INFO, scmd,
+                                            "%s: aborting cmd failed\n",
+                                             current->comm));
                         list_splice_init(&check_list, work_q);
                         return list_empty(work_q);
                 }
@@ -1390,9 +1403,9 @@ static int scsi_eh_stu(struct Scsi_Host *shost,
         shost_for_each_device(sdev, shost) {
                 if (scsi_host_eh_past_deadline(shost)) {
                         SCSI_LOG_ERROR_RECOVERY(3,
-                                shost_printk(KERN_INFO, shost,
-                                            "skip %s, past eh deadline\n",
-                                             __func__));
+                                sdev_printk(KERN_INFO, sdev,
+                                            "%s: skip START_UNIT, past eh deadline\n",
+                                            current->comm));
                         break;
                 }
                 stu_scmd = NULL;
@@ -1407,9 +1420,9 @@ static int scsi_eh_stu(struct Scsi_Host *shost,
                         continue;
 
                 SCSI_LOG_ERROR_RECOVERY(3,
-                        shost_printk(KERN_INFO, shost,
-                                     "%s: Sending START_UNIT to sdev: 0x%p\n",
-                                     current->comm, sdev));
+                        sdev_printk(KERN_INFO, sdev,
+                                     "%s: Sending START_UNIT\n",
+                                    current->comm));
 
                 if (!scsi_eh_try_stu(stu_scmd)) {
                         if (!scsi_device_online(sdev) ||
@@ -1423,9 +1436,9 @@ static int scsi_eh_stu(struct Scsi_Host *shost,
                         }
                 } else {
                         SCSI_LOG_ERROR_RECOVERY(3,
-                                shost_printk(KERN_INFO, shost,
-                                             "%s: START_UNIT failed to sdev:"
-                                             " 0x%p\n", current->comm, sdev));
+                                sdev_printk(KERN_INFO, sdev,
+                                            "%s: START_UNIT failed\n",
+                                            current->comm));
                 }
         }
 
@@ -1456,9 +1469,9 @@ static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
         shost_for_each_device(sdev, shost) {
                 if (scsi_host_eh_past_deadline(shost)) {
                         SCSI_LOG_ERROR_RECOVERY(3,
-                                shost_printk(KERN_INFO, shost,
-                                            "skip %s, past eh deadline\n",
-                                             __func__));
+                                sdev_printk(KERN_INFO, sdev,
+                                            "%s: skip BDR, past eh deadline\n",
+                                             current->comm));
                         break;
                 }
                 bdr_scmd = NULL;
@@ -1472,9 +1485,8 @@ static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
                         continue;
 
                 SCSI_LOG_ERROR_RECOVERY(3,
-                        shost_printk(KERN_INFO, shost,
-                                     "%s: Sending BDR sdev: 0x%p\n",
-                                     current->comm, sdev));
+                        sdev_printk(KERN_INFO, sdev,
+                                     "%s: Sending BDR\n", current->comm));
                 rtn = scsi_try_bus_device_reset(bdr_scmd);
                 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
                         if (!scsi_device_online(sdev) ||
@@ -1490,9 +1502,8 @@ static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
                         }
                 } else {
                         SCSI_LOG_ERROR_RECOVERY(3,
-                                shost_printk(KERN_INFO, shost,
-                                             "%s: BDR failed sdev: 0x%p\n",
-                                             current->comm, sdev));
+                                sdev_printk(KERN_INFO, sdev,
+                                            "%s: BDR failed\n", current->comm));
                 }
         }
 
@@ -1528,8 +1539,8 @@ static int scsi_eh_target_reset(struct Scsi_Host *shost,
                         list_splice_init(&tmp_list, work_q);
                         SCSI_LOG_ERROR_RECOVERY(3,
                                 shost_printk(KERN_INFO, shost,
-                                            "skip %s, past eh deadline\n",
-                                             __func__));
+                                            "%s: Skip target reset, past eh deadline\n",
+                                             current->comm));
                         return list_empty(work_q);
                 }
 
@@ -1591,8 +1602,8 @@ static int scsi_eh_bus_reset(struct Scsi_Host *shost,
                         list_splice_init(&check_list, work_q);
                         SCSI_LOG_ERROR_RECOVERY(3,
                                 shost_printk(KERN_INFO, shost,
-                                            "skip %s, past eh deadline\n",
-                                             __func__));
+                                            "%s: skip BRST, past eh deadline\n",
+                                             current->comm));
                         return list_empty(work_q);
                 }
 
@@ -2193,9 +2204,9 @@ int scsi_error_handler(void *data)
                  */
                 if (!shost->eh_noresume && scsi_autopm_get_host(shost) != 0) {
                         SCSI_LOG_ERROR_RECOVERY(1,
-                                printk(KERN_ERR "Error handler scsi_eh_%d "
-                                                "unable to autoresume\n",
-                                                shost->host_no));
+                                shost_printk(KERN_ERR, shost,
+                                             "scsi_eh_%d: unable to autoresume\n",
+                                             shost->host_no));
                         continue;
                 }
 
@@ -2296,42 +2307,34 @@ scsi_reset_provider_done_command(struct scsi_cmnd *scmd)
 {
 }
 
-/*
- * Function:    scsi_reset_provider
- *
- * Purpose:     Send requested reset to a bus or device at any phase.
- *
- * Arguments:   device  - device to send reset to
- *              flag - reset type (see scsi.h)
- *
- * Returns:     SUCCESS/FAILURE.
- *
- * Notes:       This is used by the SCSI Generic driver to provide
- *              Bus/Device reset capability.
+/**
+ * scsi_ioctl_reset: explicitly reset a host/bus/target/device
+ * @dev:        scsi_device to operate on
+ * @arg:        reset type (see sg.h)
  */
 int
-scsi_reset_provider(struct scsi_device *dev, int flag)
+scsi_ioctl_reset(struct scsi_device *dev, int __user *arg)
 {
         struct scsi_cmnd *scmd;
         struct Scsi_Host *shost = dev->host;
         struct request req;
         unsigned long flags;
-        int rtn;
+        int error = 0, rtn, val;
 
-        if (scsi_autopm_get_host(shost) < 0)
-                return FAILED;
+        if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
+                return -EACCES;
 
-        if (!get_device(&dev->sdev_gendev)) {
-                rtn = FAILED;
-                goto out_put_autopm_host;
-        }
+        error = get_user(val, arg);
+        if (error)
+                return error;
 
+        if (scsi_autopm_get_host(shost) < 0)
+                return -EIO;
+
+        error = -EIO;
         scmd = scsi_get_command(dev, GFP_KERNEL);
-        if (!scmd) {
-                rtn = FAILED;
-                put_device(&dev->sdev_gendev);
+        if (!scmd)
                 goto out_put_autopm_host;
-        }
 
         blk_rq_init(NULL, &req);
         scmd->request = &req;
@@ -2349,29 +2352,37 @@ scsi_reset_provider(struct scsi_device *dev, int flag)
         shost->tmf_in_progress = 1;
         spin_unlock_irqrestore(shost->host_lock, flags);
 
-        switch (flag) {
-        case SCSI_TRY_RESET_DEVICE:
+        switch (val & ~SG_SCSI_RESET_NO_ESCALATE) {
+        case SG_SCSI_RESET_NOTHING:
+                rtn = SUCCESS;
+                break;
+        case SG_SCSI_RESET_DEVICE:
                 rtn = scsi_try_bus_device_reset(scmd);
-                if (rtn == SUCCESS)
+                if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
                         break;
                 /* FALLTHROUGH */
-        case SCSI_TRY_RESET_TARGET:
+        case SG_SCSI_RESET_TARGET:
                 rtn = scsi_try_target_reset(scmd);
-                if (rtn == SUCCESS)
+                if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
                         break;
                 /* FALLTHROUGH */
-        case SCSI_TRY_RESET_BUS:
+        case SG_SCSI_RESET_BUS:
                 rtn = scsi_try_bus_reset(scmd);
-                if (rtn == SUCCESS)
+                if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
                         break;
                 /* FALLTHROUGH */
-        case SCSI_TRY_RESET_HOST:
+        case SG_SCSI_RESET_HOST:
                 rtn = scsi_try_host_reset(scmd);
-                break;
+                if (rtn == SUCCESS)
+                        break;
         default:
+                /* FALLTHROUGH */
                 rtn = FAILED;
+                break;
         }
 
+        error = (rtn == SUCCESS) ? 0 : -EIO;
+
         spin_lock_irqsave(shost->host_lock, flags);
         shost->tmf_in_progress = 0;
         spin_unlock_irqrestore(shost->host_lock, flags);
@@ -2385,15 +2396,15 @@ scsi_reset_provider(struct scsi_device *dev, int flag)
                              "waking up host to restart after TMF\n"));
 
         wake_up(&shost->host_wait);
-
         scsi_run_host_queues(shost);
 
-        scsi_next_command(scmd);
+        scsi_put_command(scmd);
+
 out_put_autopm_host:
         scsi_autopm_put_host(shost);
-        return rtn;
+        return error;
 }
-EXPORT_SYMBOL(scsi_reset_provider);
+EXPORT_SYMBOL(scsi_ioctl_reset);
 
 /**
  * scsi_normalize_sense - normalize main elements from either fixed or
@@ -2412,20 +2423,20 @@ EXPORT_SYMBOL(scsi_reset_provider);
  *      responded to a SCSI command with the CHECK_CONDITION status.
  *
  * Return value:
- *      1 if valid sense data information found, else 0;
+ *      true if valid sense data information found, else false;
  */
-int scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
-                         struct scsi_sense_hdr *sshdr)
+bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
+                          struct scsi_sense_hdr *sshdr)
 {
         if (!sense_buffer || !sb_len)
-                return 0;
+                return false;
 
         memset(sshdr, 0, sizeof(struct scsi_sense_hdr));
 
         sshdr->response_code = (sense_buffer[0] & 0x7f);
 
         if (!scsi_sense_valid(sshdr))
-                return 0;
+                return false;
 
         if (sshdr->response_code >= 0x72) {
                 /*
@@ -2455,12 +2466,12 @@ int scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
                 }
         }
 
-        return 1;
+        return true;
 }
 EXPORT_SYMBOL(scsi_normalize_sense);
 
-int scsi_command_normalize_sense(struct scsi_cmnd *cmd,
-                                 struct scsi_sense_hdr *sshdr)
+bool scsi_command_normalize_sense(const struct scsi_cmnd *cmd,
+                                  struct scsi_sense_hdr *sshdr)
 {
         return scsi_normalize_sense(cmd->sense_buffer,
                         SCSI_SENSE_BUFFERSIZE, sshdr);
diff --git a/drivers/scsi/scsi_ioctl.c b/drivers/scsi/scsi_ioctl.c
index 1aaaf43c6803..c4f7b56fa6f6 100644
--- a/drivers/scsi/scsi_ioctl.c
+++ b/drivers/scsi/scsi_ioctl.c
@@ -126,7 +126,7 @@ static int ioctl_internal_command(struct scsi_device *sdev, char *cmd,
                         sdev_printk(KERN_INFO, sdev,
                                     "ioctl_internal_command return code = %x\n",
                                     result);
-                        scsi_print_sense_hdr("   ", &sshdr);
+                        scsi_print_sense_hdr(sdev, NULL, &sshdr);
                         break;
                 }
         }
@@ -200,19 +200,6 @@ int scsi_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
 {
         char scsi_cmd[MAX_COMMAND_SIZE];
 
-        /* No idea how this happens.... */
-        if (!sdev)
-                return -ENXIO;
-
-        /*
-         * If we are in the middle of error recovery, don't let anyone
-         * else try and use this device.  Also, if error recovery fails, it
-         * may try and take the device offline, in which case all further
-         * access to the device is prohibited.
-         */
-        if (!scsi_block_when_processing_errors(sdev))
-                return -ENODEV;
-
         /* Check for deprecated ioctls ... all the ioctls which don't
          * follow the new unique numbering scheme are deprecated */
         switch (cmd) {
@@ -273,6 +260,8 @@ int scsi_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
                                      START_STOP_TIMEOUT, NORMAL_RETRIES);
         case SCSI_IOCTL_GET_PCI:
                 return scsi_ioctl_get_pci(sdev, arg);
+        case SG_SCSI_RESET:
+                return scsi_ioctl_reset(sdev, arg);
         default:
                 if (sdev->host->hostt->ioctl)
                         return sdev->host->hostt->ioctl(sdev, cmd, arg);
@@ -281,55 +270,20 @@ int scsi_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
 }
 EXPORT_SYMBOL(scsi_ioctl);
 
-/**
- * scsi_nonblockable_ioctl() - Handle SG_SCSI_RESET
- * @sdev: scsi device receiving ioctl
- * @cmd: Must be SC_SCSI_RESET
- * @arg: pointer to int containing SG_SCSI_RESET_{DEVICE,BUS,HOST}
- * @ndelay: file mode O_NDELAY flag
+/*
+ * We can process a reset even when a device isn't fully operable.
  */
-int scsi_nonblockable_ioctl(struct scsi_device *sdev, int cmd,
-                            void __user *arg, int ndelay)
+int scsi_ioctl_block_when_processing_errors(struct scsi_device *sdev, int cmd,
+                bool ndelay)
 {
-        int val, result;
-
-        /* The first set of iocts may be executed even if we're doing
-         * error processing, as long as the device was opened
-         * non-blocking */
-        if (ndelay) {
+        if (cmd == SG_SCSI_RESET && ndelay) {
                 if (scsi_host_in_recovery(sdev->host))
+                        return -EAGAIN;
+        } else {
+                if (!scsi_block_when_processing_errors(sdev))
                         return -ENODEV;
-        } else if (!scsi_block_when_processing_errors(sdev))
-                return -ENODEV;
-
-        switch (cmd) {
-        case SG_SCSI_RESET:
-                result = get_user(val, (int __user *)arg);
-                if (result)
-                        return result;
-                if (val == SG_SCSI_RESET_NOTHING)
-                        return 0;
-                switch (val) {
-                case SG_SCSI_RESET_DEVICE:
-                        val = SCSI_TRY_RESET_DEVICE;
-                        break;
-                case SG_SCSI_RESET_TARGET:
-                        val = SCSI_TRY_RESET_TARGET;
-                        break;
-                case SG_SCSI_RESET_BUS:
-                        val = SCSI_TRY_RESET_BUS;
-                        break;
-                case SG_SCSI_RESET_HOST:
-                        val = SCSI_TRY_RESET_HOST;
-                        break;
-                default:
-                        return -EINVAL;
-                }
-                if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
-                        return -EACCES;
-                return (scsi_reset_provider(sdev, val) ==
-                        SUCCESS) ? 0 : -EIO;
         }
-        return -ENODEV;
+
+        return 0;
 }
-EXPORT_SYMBOL(scsi_nonblockable_ioctl);
+EXPORT_SYMBOL_GPL(scsi_ioctl_block_when_processing_errors);
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 50a6e1ac8d9c..7e3d954c9cac 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -22,6 +22,7 @@
 #include <linux/hardirq.h>
 #include <linux/scatterlist.h>
 #include <linux/blk-mq.h>
+#include <linux/ratelimit.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -47,7 +48,7 @@ struct scsi_host_sg_pool {
         mempool_t       *pool;
 };
 
-#define SP(x) { x, "sgpool-" __stringify(x) }
+#define SP(x) { .size = x, "sgpool-" __stringify(x) }
 #if (SCSI_MAX_SG_SEGMENTS < 32)
 #error SCSI_MAX_SG_SEGMENTS is too small (must be 32 or greater)
 #endif
@@ -542,17 +543,6 @@ static void scsi_requeue_command(struct request_queue *q, struct scsi_cmnd *cmd)
         put_device(&sdev->sdev_gendev);
 }
 
-void scsi_next_command(struct scsi_cmnd *cmd)
-{
-        struct scsi_device *sdev = cmd->device;
-        struct request_queue *q = sdev->request_queue;
-
-        scsi_put_command(cmd);
-        scsi_run_queue(q);
-
-        put_device(&sdev->sdev_gendev);
-}
-
 void scsi_run_host_queues(struct Scsi_Host *shost)
 {
         struct scsi_device *sdev;
@@ -598,10 +588,10 @@ static void scsi_free_sgtable(struct scsi_data_buffer *sdb, bool mq)
         __sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS, mq, scsi_sg_free);
 }
 
-static int scsi_alloc_sgtable(struct scsi_data_buffer *sdb, int nents,
-                              gfp_t gfp_mask, bool mq)
+static int scsi_alloc_sgtable(struct scsi_data_buffer *sdb, int nents, bool mq)
 {
         struct scatterlist *first_chunk = NULL;
+        gfp_t gfp_mask = mq ? GFP_NOIO : GFP_ATOMIC;
         int ret;
 
         BUG_ON(!nents);
@@ -730,8 +720,6 @@ static bool scsi_end_request(struct request *req, int error,
                         kblockd_schedule_work(&sdev->requeue_work);
                 else
                         blk_mq_start_stopped_hw_queues(q, true);
-
-                put_device(&sdev->sdev_gendev);
         } else {
                 unsigned long flags;
 
@@ -743,9 +731,12 @@ static bool scsi_end_request(struct request *req, int error,
                 spin_unlock_irqrestore(q->queue_lock, flags);
 
                 scsi_release_buffers(cmd);
-                scsi_next_command(cmd);
+
+                scsi_put_command(cmd);
+                scsi_run_queue(q);
         }
 
+        put_device(&sdev->sdev_gendev);
         return false;
 }
 
@@ -831,8 +822,8 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
         struct request *req = cmd->request;
         int error = 0;
         struct scsi_sense_hdr sshdr;
-        int sense_valid = 0;
-        int sense_deferred = 0;
+        bool sense_valid = false;
+        int sense_deferred = 0, level = 0;
         enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY,
               ACTION_DELAYED_RETRY} action;
         unsigned long wait_for = (cmd->allowed + 1) * req->timeout;
@@ -912,7 +903,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                 if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
                         ;
                 else if (!(req->cmd_flags & REQ_QUIET))
-                        scsi_print_sense("", cmd);
+                        scsi_print_sense(cmd);
                 result = 0;
                 /* BLOCK_PC may have set error */
                 error = 0;
@@ -1039,10 +1030,24 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
         case ACTION_FAIL:
                 /* Give up and fail the remainder of the request */
                 if (!(req->cmd_flags & REQ_QUIET)) {
-                        scsi_print_result(cmd);
-                        if (driver_byte(result) & DRIVER_SENSE)
-                                scsi_print_sense("", cmd);
-                        scsi_print_command(cmd);
+                        static DEFINE_RATELIMIT_STATE(_rs,
+                                        DEFAULT_RATELIMIT_INTERVAL,
+                                        DEFAULT_RATELIMIT_BURST);
+
+                        if (unlikely(scsi_logging_level))
+                                level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
+                                                       SCSI_LOG_MLCOMPLETE_BITS);
+
+                        /*
+                         * if logging is enabled the failure will be printed
+                         * in scsi_log_completion(), so avoid duplicate messages
+                         */
+                        if (!level && __ratelimit(&_rs)) {
+                                scsi_print_result(cmd, NULL, FAILED);
+                                if (driver_byte(result) & DRIVER_SENSE)
+                                        scsi_print_sense(cmd);
+                                scsi_print_command(cmd);
+                        }
                 }
                 if (!scsi_end_request(req, error, blk_rq_err_bytes(req), 0))
                         return;
@@ -1072,8 +1077,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
         }
 }
 
-static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
-                             gfp_t gfp_mask)
+static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb)
 {
         int count;
 
@@ -1081,7 +1085,7 @@ static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
          * If sg table allocation fails, requeue request later.
          */
         if (unlikely(scsi_alloc_sgtable(sdb, req->nr_phys_segments,
-                                        gfp_mask, req->mq_ctx != NULL)))
+                                        req->mq_ctx != NULL)))
                 return BLKPREP_DEFER;
 
         /* 
@@ -1106,7 +1110,7 @@ static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
  *              BLKPREP_DEFER if the failure is retryable
  *              BLKPREP_KILL if the failure is fatal
  */
-int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
+int scsi_init_io(struct scsi_cmnd *cmd)
 {
         struct scsi_device *sdev = cmd->device;
         struct request *rq = cmd->request;
@@ -1115,7 +1119,7 @@ int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
 
         BUG_ON(!rq->nr_phys_segments);
 
-        error = scsi_init_sgtable(rq, &cmd->sdb, gfp_mask);
+        error = scsi_init_sgtable(rq, &cmd->sdb);
         if (error)
                 goto err_exit;
 
@@ -1131,8 +1135,7 @@ int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
                         rq->next_rq->special = bidi_sdb;
                 }
 
-                error = scsi_init_sgtable(rq->next_rq, rq->next_rq->special,
-                                          GFP_ATOMIC);
+                error = scsi_init_sgtable(rq->next_rq, rq->next_rq->special);
                 if (error)
                         goto err_exit;
         }
@@ -1144,7 +1147,7 @@ int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
                 BUG_ON(prot_sdb == NULL);
                 ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);
 
-                if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask, is_mq)) {
+                if (scsi_alloc_sgtable(prot_sdb, ivecs, is_mq)) {
                         error = BLKPREP_DEFER;
                         goto err_exit;
                 }
@@ -1213,7 +1216,7 @@ static int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
          * submit a request without an attached bio.
          */
         if (req->bio) {
-                int ret = scsi_init_io(cmd, GFP_ATOMIC);
+                int ret = scsi_init_io(cmd);
                 if (unlikely(ret))
                         return ret;
         } else {
@@ -1638,6 +1641,87 @@ static void scsi_softirq_done(struct request *rq)
 }
 
 /**
+ * scsi_dispatch_command - Dispatch a command to the low-level driver.
+ * @cmd: command block we are dispatching.
+ *
+ * Return: nonzero return request was rejected and device's queue needs to be
+ * plugged.
+ */
+static int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
+{
+        struct Scsi_Host *host = cmd->device->host;
+        int rtn = 0;
+
+        atomic_inc(&cmd->device->iorequest_cnt);
+
+        /* check if the device is still usable */
+        if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
+                /* in SDEV_DEL we error all commands. DID_NO_CONNECT
+                 * returns an immediate error upwards, and signals
+                 * that the device is no longer present */
+                cmd->result = DID_NO_CONNECT << 16;
+                goto done;
+        }
+
+        /* Check to see if the scsi lld made this device blocked. */
+        if (unlikely(scsi_device_blocked(cmd->device))) {
+                /*
+                 * in blocked state, the command is just put back on
+                 * the device queue.  The suspend state has already
+                 * blocked the queue so future requests should not
+                 * occur until the device transitions out of the
+                 * suspend state.
+                 */
+                SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
+                        "queuecommand : device blocked\n"));
+                return SCSI_MLQUEUE_DEVICE_BUSY;
+        }
+
+        /* Store the LUN value in cmnd, if needed. */
+        if (cmd->device->lun_in_cdb)
+                cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
+                               (cmd->device->lun << 5 & 0xe0);
+
+        scsi_log_send(cmd);
+
+        /*
+         * Before we queue this command, check if the command
+         * length exceeds what the host adapter can handle.
+         */
+        if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
+                SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
+                               "queuecommand : command too long. "
+                               "cdb_size=%d host->max_cmd_len=%d\n",
+                               cmd->cmd_len, cmd->device->host->max_cmd_len));
+                cmd->result = (DID_ABORT << 16);
+                goto done;
+        }
+
+        if (unlikely(host->shost_state == SHOST_DEL)) {
+                cmd->result = (DID_NO_CONNECT << 16);
+                goto done;
+
+        }
+
+        trace_scsi_dispatch_cmd_start(cmd);
+        rtn = host->hostt->queuecommand(host, cmd);
+        if (rtn) {
+                trace_scsi_dispatch_cmd_error(cmd, rtn);
+                if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
+                    rtn != SCSI_MLQUEUE_TARGET_BUSY)
+                        rtn = SCSI_MLQUEUE_HOST_BUSY;
+
+                SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
+                        "queuecommand : request rejected\n"));
+        }
+
+        return rtn;
+ done:
+        cmd->scsi_done(cmd);
+        return 0;
+}
+
+/**
  * scsi_done - Invoke completion on finished SCSI command.
  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
@@ -1725,7 +1809,7 @@ static void scsi_request_fn(struct request_queue *q)
                  * we add the dev to the starved list so it eventually gets
                  * a run when a tag is freed.
                  */
-                if (blk_queue_tagged(q) && !blk_rq_tagged(req)) {
+                if (blk_queue_tagged(q) && !(req->cmd_flags & REQ_QUEUED)) {
                         spin_lock_irq(shost->host_lock);
                         if (list_empty(&sdev->starved_entry))
                                 list_add_tail(&sdev->starved_entry,
@@ -1739,6 +1823,11 @@ static void scsi_request_fn(struct request_queue *q)
 
                 if (!scsi_host_queue_ready(q, shost, sdev))
                         goto host_not_ready;
+        
+                if (sdev->simple_tags)
+                        cmd->flags |= SCMD_TAGGED;
+                else
+                        cmd->flags &= ~SCMD_TAGGED;
 
                 /*
                  * Finally, initialize any error handling parameters, and set up
@@ -1893,10 +1982,10 @@ static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *req,
                 blk_mq_start_request(req);
         }
 
-        if (blk_queue_tagged(q))
-                req->cmd_flags |= REQ_QUEUED;
+        if (sdev->simple_tags)
+                cmd->flags |= SCMD_TAGGED;
         else
-                req->cmd_flags &= ~REQ_QUEUED;
+                cmd->flags &= ~SCMD_TAGGED;
 
         scsi_init_cmd_errh(cmd);
         cmd->scsi_done = scsi_mq_done;
@@ -2091,7 +2180,7 @@ int scsi_mq_setup_tags(struct Scsi_Host *shost)
 
         memset(&shost->tag_set, 0, sizeof(shost->tag_set));
         shost->tag_set.ops = &scsi_mq_ops;
-        shost->tag_set.nr_hw_queues = 1;
+        shost->tag_set.nr_hw_queues = shost->nr_hw_queues ? : 1;
         shost->tag_set.queue_depth = shost->can_queue;
         shost->tag_set.cmd_size = cmd_size;
         shost->tag_set.numa_node = NUMA_NO_NODE;
diff --git a/drivers/scsi/scsi_logging.h b/drivers/scsi/scsi_logging.h
index 1f65139e14f8..7fe64a847143 100644
--- a/drivers/scsi/scsi_logging.h
+++ b/drivers/scsi/scsi_logging.h
@@ -51,6 +51,7 @@ do {								\
                 } while (0);                                    \
 } while (0)
 #else
+#define SCSI_LOG_LEVEL(SHIFT, BITS) 0
 #define SCSI_CHECK_LOGGING(SHIFT, BITS, LEVEL, CMD)
 #endif /* CONFIG_SCSI_LOGGING */
 
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index 12b8e1bee7f0..2dc4a83fb84c 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -29,7 +29,6 @@ extern int scsi_init_hosts(void);
 extern void scsi_exit_hosts(void);
 
 /* scsi.c */
-extern int scsi_dispatch_cmd(struct scsi_cmnd *cmd);
 extern int scsi_setup_command_freelist(struct Scsi_Host *shost);
 extern void scsi_destroy_command_freelist(struct Scsi_Host *shost);
 #ifdef CONFIG_SCSI_LOGGING
@@ -84,7 +83,6 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd);
 extern int scsi_maybe_unblock_host(struct scsi_device *sdev);
 extern void scsi_device_unbusy(struct scsi_device *sdev);
 extern void scsi_queue_insert(struct scsi_cmnd *cmd, int reason);
-extern void scsi_next_command(struct scsi_cmnd *cmd);
 extern void scsi_io_completion(struct scsi_cmnd *, unsigned int);
 extern void scsi_run_host_queues(struct Scsi_Host *shost);
 extern struct request_queue *scsi_alloc_queue(struct scsi_device *sdev);
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index ba3f1e8d0d57..983aed10ff2f 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -286,7 +286,13 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
         }
         WARN_ON_ONCE(!blk_get_queue(sdev->request_queue));
         sdev->request_queue->queuedata = sdev;
-        scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
+
+        if (!shost_use_blk_mq(sdev->host) &&
+            (shost->bqt || shost->hostt->use_blk_tags)) {
+                blk_queue_init_tags(sdev->request_queue,
+                                    sdev->host->cmd_per_lun, shost->bqt);
+        }
+        scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun);
 
         scsi_sysfs_device_initialize(sdev);
 
@@ -874,8 +880,10 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
                         (inq_result[3] & 0x0f) == 1 ? " CCS" : "");
 
         if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
-            !(*bflags & BLIST_NOTQ))
+            !(*bflags & BLIST_NOTQ)) {
                 sdev->tagged_supported = 1;
+                sdev->simple_tags = 1;
+        }
 
         /*
          * Some devices (Texel CD ROM drives) have handshaking problems
@@ -1214,9 +1222,9 @@ static void scsi_sequential_lun_scan(struct scsi_target *starget,
                 sparse_lun = 0;
 
         /*
-         * If less than SCSI_1_CSS, and no special lun scaning, stop
+         * If less than SCSI_1_CCS, and no special lun scanning, stop
          * scanning; this matches 2.4 behaviour, but could just be a bug
-         * (to continue scanning a SCSI_1_CSS device).
+         * (to continue scanning a SCSI_1_CCS device).
          *
          * This test is broken.  We might not have any device on lun0 for
          * a sparselun device, and if that's the case then how would we
@@ -1585,16 +1593,15 @@ EXPORT_SYMBOL(scsi_add_device);
 
 void scsi_rescan_device(struct device *dev)
 {
-        struct scsi_driver *drv;
-        
         if (!dev->driver)
                 return;
 
-        drv = to_scsi_driver(dev->driver);
-        if (try_module_get(drv->owner)) {
+        if (try_module_get(dev->driver->owner)) {
+                struct scsi_driver *drv = to_scsi_driver(dev->driver);
+
                 if (drv->rescan)
                         drv->rescan(dev);
-                module_put(drv->owner);
+                module_put(dev->driver->owner);
         }
 }
 EXPORT_SYMBOL(scsi_rescan_device);
@@ -1727,7 +1734,7 @@ int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
 
         if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
             ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
-            ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
+            ((lun != SCAN_WILD_CARD) && (lun >= shost->max_lun)))
                 return -EINVAL;
 
         mutex_lock(&shost->scan_mutex);
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index f4cb7b3e9e23..1cb64a8e18c9 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -727,9 +727,7 @@ show_queue_type_field(struct device *dev, struct device_attribute *attr,
         struct scsi_device *sdev = to_scsi_device(dev);
         const char *name = "none";
 
-        if (sdev->ordered_tags)
-                name = "ordered";
-        else if (sdev->simple_tags)
+        if (sdev->simple_tags)
                 name = "simple";
 
         return snprintf(buf, 20, "%s\n", name);
@@ -747,9 +745,12 @@ store_queue_type_field(struct device *dev, struct device_attribute *attr,
         if (!sdev->tagged_supported || !sht->change_queue_type)
                 return -EINVAL;
 
-        if (strncmp(buf, "ordered", 7) == 0)
-                tag_type = MSG_ORDERED_TAG;
-        else if (strncmp(buf, "simple", 6) == 0)
+        /*
+         * We're never issueing order tags these days, but allow the value
+         * for backwards compatibility.
+         */
+        if (strncmp(buf, "ordered", 7) == 0 ||
+            strncmp(buf, "simple", 6) == 0)
                 tag_type = MSG_SIMPLE_TAG;
         else if (strncmp(buf, "none", 4) != 0)
                 return -EINVAL;
@@ -876,11 +877,10 @@ sdev_store_queue_depth(struct device *dev, struct device_attribute *attr,
 
         depth = simple_strtoul(buf, NULL, 0);
 
-        if (depth < 1)
+        if (depth < 1 || depth > sht->can_queue)
                 return -EINVAL;
 
-        retval = sht->change_queue_depth(sdev, depth,
-                                         SCSI_QDEPTH_DEFAULT);
+        retval = sht->change_queue_depth(sdev, depth);
         if (retval < 0)
                 return retval;
 
diff --git a/drivers/scsi/scsi_trace.c b/drivers/scsi/scsi_trace.c
index 503594e5f76d..82af28b90294 100644
--- a/drivers/scsi/scsi_trace.c
+++ b/drivers/scsi/scsi_trace.c
@@ -278,7 +278,7 @@ scsi_trace_parse_cdb(struct trace_seq *p, unsigned char *cdb, int len)
                 return scsi_trace_rw16(p, cdb, len);
         case UNMAP:
                 return scsi_trace_unmap(p, cdb, len);
-        case SERVICE_ACTION_IN:
+        case SERVICE_ACTION_IN_16:
                 return scsi_trace_service_action_in(p, cdb, len);
         case VARIABLE_LENGTH_CMD:
                 return scsi_trace_varlen(p, cdb, len);
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index cf08071a9b6e..fa2aece76cc2 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -32,6 +32,7 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_eh.h>
+#include <scsi/scsi_tcq.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_transport_spi.h>
 
@@ -1207,6 +1208,28 @@ int spi_populate_ppr_msg(unsigned char *msg, int period, int offset,
 }
 EXPORT_SYMBOL_GPL(spi_populate_ppr_msg);
 
+/**
+ * spi_populate_tag_msg - place a tag message in a buffer
+ * @msg:        pointer to the area to place the tag
+ * @cmd:        pointer to the scsi command for the tag
+ *
+ * Notes:
+ *      designed to create the correct type of tag message for the 
+ *      particular request.  Returns the size of the tag message.
+ *      May return 0 if TCQ is disabled for this device.
+ **/
+int spi_populate_tag_msg(unsigned char *msg, struct scsi_cmnd *cmd)
+{
+        if (cmd->flags & SCMD_TAGGED) {
+                *msg++ = MSG_SIMPLE_TAG;
+                *msg++ = cmd->request->tag;
+                return 2;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(spi_populate_tag_msg);
+
 #ifdef CONFIG_SCSI_CONSTANTS
 static const char * const one_byte_msgs[] = {
 /* 0x00 */ "Task Complete", NULL /* Extended Message */, "Save Pointers",
diff --git a/drivers/scsi/scsicam.c b/drivers/scsi/scsicam.c
index 92d24d6dcb39..910f4a7a3924 100644
--- a/drivers/scsi/scsicam.c
+++ b/drivers/scsi/scsicam.c
@@ -163,8 +163,8 @@ int scsi_partsize(unsigned char *buf, unsigned long capacity,
                     end_head * end_sector + end_sector;
 
                 /* This is the actual _sector_ number at the end */
-                logical_end = get_unaligned(&largest->start_sect)
-                    + get_unaligned(&largest->nr_sects);
+                logical_end = get_unaligned_le32(&largest->start_sect)
+                    + get_unaligned_le32(&largest->nr_sects);
 
                 /* This is for >1023 cylinders */
                 ext_cyl = (logical_end - (end_head * end_sector + end_sector))
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index cfba74cd8e8b..fedab3c21ddf 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -116,7 +116,7 @@ static int sd_eh_action(struct scsi_cmnd *, int);
 static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
 static void scsi_disk_release(struct device *cdev);
 static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
-static void sd_print_result(struct scsi_disk *, int);
+static void sd_print_result(const struct scsi_disk *, const char *, int);
 
 static DEFINE_SPINLOCK(sd_index_lock);
 static DEFINE_IDA(sd_index_ida);
@@ -510,9 +510,9 @@ static const struct dev_pm_ops sd_pm_ops = {
 };
 
 static struct scsi_driver sd_template = {
-        .owner                  = THIS_MODULE,
         .gendrv = {
                 .name           = "sd",
+                .owner          = THIS_MODULE,
                 .probe          = sd_probe,
                 .remove         = sd_remove,
                 .shutdown       = sd_shutdown,
@@ -656,7 +656,7 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
         unsigned int logical_block_size = sdkp->device->sector_size;
         unsigned int max_blocks = 0;
 
-        q->limits.discard_zeroes_data = sdkp->lbprz;
+        q->limits.discard_zeroes_data = 0;
         q->limits.discard_alignment = sdkp->unmap_alignment *
                 logical_block_size;
         q->limits.discard_granularity =
@@ -680,11 +680,13 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
         case SD_LBP_WS16:
                 max_blocks = min_not_zero(sdkp->max_ws_blocks,
                                           (u32)SD_MAX_WS16_BLOCKS);
+                q->limits.discard_zeroes_data = sdkp->lbprz;
                 break;
 
         case SD_LBP_WS10:
                 max_blocks = min_not_zero(sdkp->max_ws_blocks,
                                           (u32)SD_MAX_WS10_BLOCKS);
+                q->limits.discard_zeroes_data = sdkp->lbprz;
                 break;
 
         case SD_LBP_ZERO:
@@ -784,7 +786,7 @@ static int sd_setup_discard_cmnd(struct scsi_cmnd *cmd)
          * amount of blocks described by the request.
          */
         blk_add_request_payload(rq, page, len);
-        ret = scsi_init_io(cmd, GFP_ATOMIC);
+        ret = scsi_init_io(cmd);
         rq->__data_len = nr_bytes;
 
 out:
@@ -878,7 +880,7 @@ static int sd_setup_write_same_cmnd(struct scsi_cmnd *cmd)
          * knows how much to actually write.
          */
         rq->__data_len = sdp->sector_size;
-        ret = scsi_init_io(cmd, GFP_ATOMIC);
+        ret = scsi_init_io(cmd);
         rq->__data_len = nr_bytes;
         return ret;
 }
@@ -912,7 +914,7 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
         int ret;
         unsigned char protect;
 
-        ret = scsi_init_io(SCpnt, GFP_ATOMIC);
+        ret = scsi_init_io(SCpnt);
         if (ret != BLKPREP_OK)
                 goto out;
         SCpnt = rq->special;
@@ -1334,9 +1336,9 @@ static int sd_ioctl(struct block_device *bdev, fmode_t mode,
          * may try and take the device offline, in which case all further
          * access to the device is prohibited.
          */
-        error = scsi_nonblockable_ioctl(sdp, cmd, p,
-                                        (mode & FMODE_NDELAY) != 0);
-        if (!scsi_block_when_processing_errors(sdp) || !error)
+        error = scsi_ioctl_block_when_processing_errors(sdp, cmd,
+                        (mode & FMODE_NDELAY) != 0);
+        if (error)
                 goto out;
 
         /*
@@ -1492,7 +1494,7 @@ static int sd_sync_cache(struct scsi_disk *sdkp)
         }
 
         if (res) {
-                sd_print_result(sdkp, res);
+                sd_print_result(sdkp, "Synchronize Cache(10) failed", res);
 
                 if (driver_byte(res) & DRIVER_SENSE)
                         sd_print_sense_hdr(sdkp, &sshdr);
@@ -1541,31 +1543,19 @@ static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
                            unsigned int cmd, unsigned long arg)
 {
         struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
-        int ret;
-
-        ret = scsi_verify_blk_ioctl(bdev, cmd);
-        if (ret < 0)
-                return ret;
+        int error;
 
-        /*
-         * If we are in the middle of error recovery, don't let anyone
-         * else try and use this device.  Also, if error recovery fails, it
-         * may try and take the device offline, in which case all further
-         * access to the device is prohibited.
-         */
-        if (!scsi_block_when_processing_errors(sdev))
-                return -ENODEV;
+        error = scsi_ioctl_block_when_processing_errors(sdev, cmd,
+                        (mode & FMODE_NDELAY) != 0);
+        if (error)
+                return error;
                
-        if (sdev->host->hostt->compat_ioctl) {
-                ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
-
-                return ret;
-        }
-
         /* 
          * Let the static ioctl translation table take care of it.
          */
-        return -ENOIOCTLCMD; 
+        if (!sdev->host->hostt->compat_ioctl)
+                return -ENOIOCTLCMD; 
+        return sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
 }
 #endif
 
@@ -1713,17 +1703,6 @@ static int sd_done(struct scsi_cmnd *SCpnt)
                 if (sense_valid)
                         sense_deferred = scsi_sense_is_deferred(&sshdr);
         }
-#ifdef CONFIG_SCSI_LOGGING
-        SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
-        if (sense_valid) {
-                SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
-                                                   "sd_done: sb[respc,sk,asc,"
-                                                   "ascq]=%x,%x,%x,%x\n",
-                                                   sshdr.response_code,
-                                                   sshdr.sense_key, sshdr.asc,
-                                                   sshdr.ascq));
-        }
-#endif
         sdkp->medium_access_timed_out = 0;
 
         if (driver_byte(result) != DRIVER_SENSE &&
@@ -1743,7 +1722,6 @@ static int sd_done(struct scsi_cmnd *SCpnt)
                  * unknown amount of data was transferred so treat it as an
                  * error.
                  */
-                scsi_print_sense("sd", SCpnt);
                 SCpnt->result = 0;
                 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
                 break;
@@ -1779,6 +1757,10 @@ static int sd_done(struct scsi_cmnd *SCpnt)
                 break;
         }
  out:
+        SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
+                                           "sd_done: completed %d of %d bytes\n",
+                                           good_bytes, scsi_bufflen(SCpnt)));
+
         if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt))
                 sd_dif_complete(SCpnt, good_bytes);
 
@@ -1834,12 +1816,12 @@ sd_spinup_disk(struct scsi_disk *sdkp)
                         /* no sense, TUR either succeeded or failed
                          * with a status error */
                         if(!spintime && !scsi_status_is_good(the_result)) {
-                                sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
-                                sd_print_result(sdkp, the_result);
+                                sd_print_result(sdkp, "Test Unit Ready failed",
+                                                the_result);
                         }
                         break;
                 }
-                                        
+
                 /*
                  * The device does not want the automatic start to be issued.
                  */
@@ -1955,7 +1937,6 @@ static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
                         struct scsi_sense_hdr *sshdr, int sense_valid,
                         int the_result)
 {
-        sd_print_result(sdkp, the_result);
         if (driver_byte(the_result) & DRIVER_SENSE)
                 sd_print_sense_hdr(sdkp, sshdr);
         else
@@ -2001,7 +1982,7 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
 
         do {
                 memset(cmd, 0, 16);
-                cmd[0] = SERVICE_ACTION_IN;
+                cmd[0] = SERVICE_ACTION_IN_16;
                 cmd[1] = SAI_READ_CAPACITY_16;
                 cmd[13] = RC16_LEN;
                 memset(buffer, 0, RC16_LEN);
@@ -2036,7 +2017,7 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
         } while (the_result && retries);
 
         if (the_result) {
-                sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
+                sd_print_result(sdkp, "Read Capacity(16) failed", the_result);
                 read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
                 return -EINVAL;
         }
@@ -2118,7 +2099,7 @@ static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
         } while (the_result && retries);
 
         if (the_result) {
-                sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
+                sd_print_result(sdkp, "Read Capacity(10) failed", the_result);
                 read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
                 return -EINVAL;
         }
@@ -2643,12 +2624,12 @@ static void sd_read_block_limits(struct scsi_disk *sdkp)
 
                 } else {        /* LBP VPD page tells us what to use */
 
-                        if (sdkp->lbpu && sdkp->max_unmap_blocks)
-                                sd_config_discard(sdkp, SD_LBP_UNMAP);
-                        else if (sdkp->lbpws)
+                        if (sdkp->lbpws)
                                 sd_config_discard(sdkp, SD_LBP_WS16);
                         else if (sdkp->lbpws10)
                                 sd_config_discard(sdkp, SD_LBP_WS10);
+                        else if (sdkp->lbpu && sdkp->max_unmap_blocks)
+                                sd_config_discard(sdkp, SD_LBP_UNMAP);
                         else
                                 sd_config_discard(sdkp, SD_LBP_DISABLE);
                 }
@@ -3142,8 +3123,7 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
         res = scsi_execute_req_flags(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
                                SD_TIMEOUT, SD_MAX_RETRIES, NULL, REQ_PM);
         if (res) {
-                sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
-                sd_print_result(sdkp, res);
+                sd_print_result(sdkp, "Start/Stop Unit failed", res);
                 if (driver_byte(res) & DRIVER_SENSE)
                         sd_print_sense_hdr(sdkp, &sshdr);
                 if (scsi_sense_valid(&sshdr) &&
@@ -3337,15 +3317,27 @@ module_exit(exit_sd);
 static void sd_print_sense_hdr(struct scsi_disk *sdkp,
                                struct scsi_sense_hdr *sshdr)
 {
-        sd_printk(KERN_INFO, sdkp, " ");
-        scsi_show_sense_hdr(sshdr);
-        sd_printk(KERN_INFO, sdkp, " ");
-        scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
+        scsi_show_sense_hdr(sdkp->device,
+                            sdkp->disk ? sdkp->disk->disk_name : NULL, sshdr);
+        scsi_show_extd_sense(sdkp->device,
+                             sdkp->disk ? sdkp->disk->disk_name : NULL,
+                             sshdr->asc, sshdr->ascq);
 }
 
-static void sd_print_result(struct scsi_disk *sdkp, int result)
+static void sd_print_result(const struct scsi_disk *sdkp, const char *msg,
+                            int result)
 {
-        sd_printk(KERN_INFO, sdkp, " ");
-        scsi_show_result(result);
+        const char *hb_string = scsi_hostbyte_string(result);
+        const char *db_string = scsi_driverbyte_string(result);
+
+        if (hb_string || db_string)
+                sd_printk(KERN_INFO, sdkp,
+                          "%s: Result: hostbyte=%s driverbyte=%s\n", msg,
+                          hb_string ? hb_string : "invalid",
+                          db_string ? db_string : "invalid");
+        else
+                sd_printk(KERN_INFO, sdkp,
+                          "%s: Result: hostbyte=0x%02x driverbyte=0x%02x\n",
+                          msg, host_byte(result), driver_byte(result));
 }
 
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index 467377884b63..63ba5ca7f9a1 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -103,9 +103,9 @@ static inline struct scsi_disk *scsi_disk(struct gendisk *disk)
 
 #define sd_printk(prefix, sdsk, fmt, a...)                              \
         (sdsk)->disk ?                                                  \
-        sdev_printk(prefix, (sdsk)->device, "[%s] " fmt,                \
-                    (sdsk)->disk->disk_name, ##a) :                     \
-        sdev_printk(prefix, (sdsk)->device, fmt, ##a)
+              sdev_prefix_printk(prefix, (sdsk)->device,                \
+                                 (sdsk)->disk->disk_name, fmt, ##a) :   \
+              sdev_printk(prefix, (sdsk)->device, fmt, ##a)
 
 #define sd_first_printk(prefix, sdsk, fmt, a...)                        \
         do {                                                            \
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index 80bfece1a2de..b7e79e7646ad 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -693,9 +693,9 @@ static struct class_interface ses_interface = {
 };
 
 static struct scsi_driver ses_template = {
-        .owner                  = THIS_MODULE,
         .gendrv = {
                 .name           = "ses",
+                .owner          = THIS_MODULE,
                 .probe          = ses_probe,
                 .remove         = ses_remove,
         },
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 60354449d9ed..b14f64cb9724 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -219,8 +219,8 @@ static void sg_device_destroy(struct kref *kref);
 #define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
 
 #define sg_printk(prefix, sdp, fmt, a...) \
-        sdev_printk(prefix, (sdp)->device, "[%s] " fmt, \
-                    (sdp)->disk->disk_name, ##a)
+        sdev_prefix_printk(prefix, (sdp)->device,               \
+                           (sdp)->disk->disk_name, fmt, ##a)
 
 static int sg_allow_access(struct file *filp, unsigned char *cmd)
 {
@@ -1071,39 +1071,6 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
                 if (atomic_read(&sdp->detaching))
                         return -ENODEV;
                 return put_user(sdp->device->host->hostt->emulated, ip);
-        case SG_SCSI_RESET:
-                if (atomic_read(&sdp->detaching))
-                        return -ENODEV;
-                if (filp->f_flags & O_NONBLOCK) {
-                        if (scsi_host_in_recovery(sdp->device->host))
-                                return -EBUSY;
-                } else if (!scsi_block_when_processing_errors(sdp->device))
-                        return -EBUSY;
-                result = get_user(val, ip);
-                if (result)
-                        return result;
-                if (SG_SCSI_RESET_NOTHING == val)
-                        return 0;
-                switch (val) {
-                case SG_SCSI_RESET_DEVICE:
-                        val = SCSI_TRY_RESET_DEVICE;
-                        break;
-                case SG_SCSI_RESET_TARGET:
-                        val = SCSI_TRY_RESET_TARGET;
-                        break;
-                case SG_SCSI_RESET_BUS:
-                        val = SCSI_TRY_RESET_BUS;
-                        break;
-                case SG_SCSI_RESET_HOST:
-                        val = SCSI_TRY_RESET_HOST;
-                        break;
-                default:
-                        return -EINVAL;
-                }
-                if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
-                        return -EACCES;
-                return (scsi_reset_provider(sdp->device, val) ==
-                        SUCCESS) ? 0 : -EIO;
         case SCSI_IOCTL_SEND_COMMAND:
                 if (atomic_read(&sdp->detaching))
                         return -ENODEV;
@@ -1123,13 +1090,6 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
                         return result;
                 sdp->sgdebug = (char) val;
                 return 0;
-        case SCSI_IOCTL_GET_IDLUN:
-        case SCSI_IOCTL_GET_BUS_NUMBER:
-        case SCSI_IOCTL_PROBE_HOST:
-        case SG_GET_TRANSFORM:
-                if (atomic_read(&sdp->detaching))
-                        return -ENODEV;
-                return scsi_ioctl(sdp->device, cmd_in, p);
         case BLKSECTGET:
                 return put_user(max_sectors_bytes(sdp->device->request_queue),
                                 ip);
@@ -1145,11 +1105,25 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
                 return blk_trace_startstop(sdp->device->request_queue, 0);
         case BLKTRACETEARDOWN:
                 return blk_trace_remove(sdp->device->request_queue);
+        case SCSI_IOCTL_GET_IDLUN:
+        case SCSI_IOCTL_GET_BUS_NUMBER:
+        case SCSI_IOCTL_PROBE_HOST:
+        case SG_GET_TRANSFORM:
+        case SG_SCSI_RESET:
+                if (atomic_read(&sdp->detaching))
+                        return -ENODEV;
+                break;
         default:
                 if (read_only)
                         return -EPERM;  /* don't know so take safe approach */
-                return scsi_ioctl(sdp->device, cmd_in, p);
+                break;
         }
+
+        result = scsi_ioctl_block_when_processing_errors(sdp->device,
+                        cmd_in, filp->f_flags & O_NDELAY);
+        if (result)
+                return result;
+        return scsi_ioctl(sdp->device, cmd_in, p);
 }
 
 #ifdef CONFIG_COMPAT
@@ -1360,7 +1334,7 @@ sg_rq_end_io(struct request *rq, int uptodate)
                 if ((sdp->sgdebug > 0) &&
                     ((CHECK_CONDITION == srp->header.masked_status) ||
                      (COMMAND_TERMINATED == srp->header.masked_status)))
-                        __scsi_print_sense(__func__, sense,
+                        __scsi_print_sense(sdp->device, __func__, sense,
                                            SCSI_SENSE_BUFFERSIZE);
 
                 /* Following if statement is a patch supplied by Eric Youngdale */
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 2de44cc58b1a..8bd54a64efd6 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -88,9 +88,9 @@ static struct dev_pm_ops sr_pm_ops = {
 };
 
 static struct scsi_driver sr_template = {
-        .owner                  = THIS_MODULE,
         .gendrv = {
                 .name           = "sr",
+                .owner          = THIS_MODULE,
                 .probe          = sr_probe,
                 .remove         = sr_remove,
                 .pm             = &sr_pm_ops,
@@ -387,7 +387,7 @@ static int sr_init_command(struct scsi_cmnd *SCpnt)
         struct request *rq = SCpnt->request;
         int ret;
 
-        ret = scsi_init_io(SCpnt, GFP_ATOMIC);
+        ret = scsi_init_io(SCpnt);
         if (ret != BLKPREP_OK)
                 goto out;
         SCpnt = rq->special;
@@ -549,6 +549,11 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
 
         mutex_lock(&sr_mutex);
 
+        ret = scsi_ioctl_block_when_processing_errors(sdev, cmd,
+                        (mode & FMODE_NDELAY) != 0);
+        if (ret)
+                goto out;
+
         /*
          * Send SCSI addressing ioctls directly to mid level, send other
          * ioctls to cdrom/block level.
@@ -564,16 +569,6 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
         if (ret != -ENOSYS)
                 goto out;
 
-        /*
-         * ENODEV means that we didn't recognise the ioctl, or that we
-         * cannot execute it in the current device state.  In either
-         * case fall through to scsi_ioctl, which will return ENDOEV again
-         * if it doesn't recognise the ioctl
-         */
-        ret = scsi_nonblockable_ioctl(sdev, cmd, argp,
-                                        (mode & FMODE_NDELAY) != 0);
-        if (ret != -ENODEV)
-                goto out;
         ret = scsi_ioctl(sdev, cmd, argp);
 
 out:
diff --git a/drivers/scsi/sr.h b/drivers/scsi/sr.h
index 1d1f6f416c59..1de33719ad8e 100644
--- a/drivers/scsi/sr.h
+++ b/drivers/scsi/sr.h
@@ -57,8 +57,7 @@ typedef struct scsi_cd {
 } Scsi_CD;
 
 #define sr_printk(prefix, cd, fmt, a...) \
-        sdev_printk(prefix, (cd)->device, "[%s] " fmt, \
-                    (cd)->cdi.name, ##a)
+        sdev_prefix_printk(prefix, (cd)->device, (cd)->cdi.name, fmt, ##a)
 
 int sr_do_ioctl(Scsi_CD *, struct packet_command *);
 
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index 6389fcff12ec..fb929fac22ba 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -246,7 +246,7 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
                                           "CDROM not ready.  Make sure there "
                                           "is a disc in the drive.\n");
 #ifdef DEBUG
-                        scsi_print_sense_hdr("sr", &sshdr);
+                        scsi_print_sense_hdr(cd->device, cd->cdi.name, &sshdr);
 #endif
                         err = -ENOMEDIUM;
                         break;
@@ -257,15 +257,15 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
                                 /* sense: Invalid command operation code */
                                 err = -EDRIVE_CANT_DO_THIS;
 #ifdef DEBUG
-                        __scsi_print_command(cgc->cmd);
-                        scsi_print_sense_hdr("sr", &sshdr);
+                        __scsi_print_command(cgc->cmd, CDROM_PACKET_SIZE);
+                        scsi_print_sense_hdr(cd->device, cd->cdi.name, &sshdr);
 #endif
                         break;
                 default:
                         sr_printk(KERN_ERR, cd,
                                   "CDROM (ioctl) error, command: ");
-                        __scsi_print_command(cgc->cmd);
-                        scsi_print_sense_hdr("sr", &sshdr);
+                        __scsi_print_command(cgc->cmd, CDROM_PACKET_SIZE);
+                        scsi_print_sense_hdr(cd->device, cd->cdi.name, &sshdr);
                         err = -EIO;
                 }
         }
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 4daa372ed381..128d3b55bdd9 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -56,7 +56,8 @@ static const char *verstr = "20101219";
 
 /* The driver prints some debugging information on the console if DEBUG
    is defined and non-zero. */
-#define DEBUG 0
+#define DEBUG 1
+#define NO_DEBUG 0
 
 #define ST_DEB_MSG  KERN_NOTICE
 #if DEBUG
@@ -80,6 +81,7 @@ static int max_sg_segs;
 static int try_direct_io = TRY_DIRECT_IO;
 static int try_rdio = 1;
 static int try_wdio = 1;
+static int debug_flag;
 
 static struct class st_sysfs_class;
 static const struct attribute_group *st_dev_groups[];
@@ -100,6 +102,9 @@ module_param_named(max_sg_segs, max_sg_segs, int, 0);
 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
 module_param_named(try_direct_io, try_direct_io, int, 0);
 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
+module_param_named(debug_flag, debug_flag, int, 0);
+MODULE_PARM_DESC(debug_flag, "Enable DEBUG, same as setting debugging=1");
+
 
 /* Extra parameters for testing */
 module_param_named(try_rdio, try_rdio, int, 0);
@@ -124,6 +129,9 @@ static struct st_dev_parm {
         },
         {
                 "try_direct_io", &try_direct_io
+        },
+        {
+                "debug_flag", &debug_flag
         }
 };
 #endif
@@ -194,9 +202,9 @@ static int do_create_sysfs_files(void);
 static void do_remove_sysfs_files(void);
 
 static struct scsi_driver st_template = {
-        .owner                  = THIS_MODULE,
         .gendrv = {
                 .name           = "st",
+                .owner          = THIS_MODULE,
                 .probe          = st_probe,
                 .remove         = st_remove,
         },
@@ -306,8 +314,7 @@ static inline char *tape_name(struct scsi_tape *tape)
 }
 
 #define st_printk(prefix, t, fmt, a...) \
-        sdev_printk(prefix, (t)->device, "%s: " fmt, \
-                    tape_name(t), ##a)
+        sdev_prefix_printk(prefix, (t)->device, tape_name(t), fmt, ##a)
 #ifdef DEBUG
 #define DEBC_printk(t, fmt, a...) \
         if (debugging) { st_printk(ST_DEB_MSG, t, fmt, ##a ); }
@@ -374,7 +381,8 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
                             SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
                             SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
                 if (cmdstatp->have_sense)
-                         __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
+                        __scsi_print_sense(STp->device, name,
+                                           SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
         } ) /* end DEB */
         if (!debugging) { /* Abnormal conditions for tape */
                 if (!cmdstatp->have_sense)
@@ -390,7 +398,8 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
                          SRpnt->cmd[0] != MODE_SENSE &&
                          SRpnt->cmd[0] != TEST_UNIT_READY) {
 
-                        __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
+                        __scsi_print_sense(STp->device, name,
+                                           SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
                 }
         }
 
@@ -852,17 +861,16 @@ static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
 /* Lock or unlock the drive door. Don't use when st_request allocated. */
 static int do_door_lock(struct scsi_tape * STp, int do_lock)
 {
-        int retval, cmd;
+        int retval;
 
-        cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
         DEBC_printk(STp, "%socking drive door.\n", do_lock ? "L" : "Unl");
-        retval = scsi_ioctl(STp->device, cmd, NULL);
-        if (!retval) {
+
+        retval = scsi_set_medium_removal(STp->device,
+                        do_lock ? SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW);
+        if (!retval)
                 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
-        }
-        else {
+        else
                 STp->door_locked = ST_LOCK_FAILS;
-        }
         return retval;
 }
 
@@ -3367,11 +3375,10 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
          * may try and take the device offline, in which case all further
          * access to the device is prohibited.
          */
-        retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
-                                        file->f_flags & O_NDELAY);
-        if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
+        retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in,
+                        file->f_flags & O_NDELAY);
+        if (retval)
                 goto out;
-        retval = 0;
 
         cmd_type = _IOC_TYPE(cmd_in);
         cmd_nr = _IOC_NR(cmd_in);
@@ -4309,6 +4316,12 @@ static int __init init_st(void)
         printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
                 verstr, st_fixed_buffer_size, st_max_sg_segs);
 
+        debugging = (debug_flag > 0) ? debug_flag : NO_DEBUG;
+        if (debugging) {
+                printk(KERN_INFO "st: Debugging enabled debug_flag = %d\n",
+                        debugging);
+        }
+
         err = class_register(&st_sysfs_class);
         if (err) {
                 pr_err("Unable register sysfs class for SCSI tapes\n");
diff --git a/drivers/scsi/stex.c b/drivers/scsi/stex.c
index 1aa4befcfbd0..98a62bc15069 100644
--- a/drivers/scsi/stex.c
+++ b/drivers/scsi/stex.c
@@ -544,33 +544,15 @@ stex_ss_send_cmd(struct st_hba *hba, struct req_msg *req, u16 tag)
 }
 
 static int
-stex_slave_alloc(struct scsi_device *sdev)
-{
-        /* Cheat: usually extracted from Inquiry data */
-        sdev->tagged_supported = 1;
-
-        scsi_activate_tcq(sdev, sdev->host->can_queue);
-
-        return 0;
-}
-
-static int
 stex_slave_config(struct scsi_device *sdev)
 {
         sdev->use_10_for_rw = 1;
         sdev->use_10_for_ms = 1;
         blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
-        sdev->tagged_supported = 1;
 
         return 0;
 }
 
-static void
-stex_slave_destroy(struct scsi_device *sdev)
-{
-        scsi_deactivate_tcq(sdev, 1);
-}
-
 static int
 stex_queuecommand_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
 {
@@ -1162,9 +1144,7 @@ static int stex_abort(struct scsi_cmnd *cmd)
         int result = SUCCESS;
         unsigned long flags;
 
-        printk(KERN_INFO DRV_NAME
-                "(%s): aborting command\n", pci_name(hba->pdev));
-        scsi_print_command(cmd);
+        scmd_printk(KERN_INFO, cmd, "aborting command\n");
 
         base = hba->mmio_base;
         spin_lock_irqsave(host->host_lock, flags);
@@ -1352,9 +1332,8 @@ static int stex_reset(struct scsi_cmnd *cmd)
 
         hba = (struct st_hba *) &cmd->device->host->hostdata[0];
 
-        printk(KERN_INFO DRV_NAME
-                "(%s): resetting host\n", pci_name(hba->pdev));
-        scsi_print_command(cmd);
+        shost_printk(KERN_INFO, cmd->device->host,
+                     "resetting host\n");
 
         return stex_do_reset(hba) ? FAILED : SUCCESS;
 }
@@ -1391,12 +1370,11 @@ static struct scsi_host_template driver_template = {
         .proc_name                      = DRV_NAME,
         .bios_param                     = stex_biosparam,
         .queuecommand                   = stex_queuecommand,
-        .slave_alloc                    = stex_slave_alloc,
         .slave_configure                = stex_slave_config,
-        .slave_destroy                  = stex_slave_destroy,
         .eh_abort_handler               = stex_abort,
         .eh_host_reset_handler          = stex_reset,
         .this_id                        = -1,
+        .use_blk_tags                   = 1,
 };
 
 static struct pci_device_id stex_pci_tbl[] = {
diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
index 733e5f759518..e3ba251fb6e7 100644
--- a/drivers/scsi/storvsc_drv.c
+++ b/drivers/scsi/storvsc_drv.c
@@ -1097,7 +1097,8 @@ static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request)
         if (scmnd->result) {
                 if (scsi_normalize_sense(scmnd->sense_buffer,
                                 SCSI_SENSE_BUFFERSIZE, &sense_hdr))
-                        scsi_print_sense_hdr("storvsc", &sense_hdr);
+                        scsi_print_sense_hdr(scmnd->device, "storvsc",
+                                             &sense_hdr);
         }
 
         if (vm_srb->srb_status != SRB_STATUS_SUCCESS)
@@ -1428,8 +1429,7 @@ static void storvsc_device_destroy(struct scsi_device *sdevice)
 
 static int storvsc_device_configure(struct scsi_device *sdevice)
 {
-        scsi_adjust_queue_depth(sdevice, MSG_SIMPLE_TAG,
-                                STORVSC_MAX_IO_REQUESTS);
+        scsi_change_queue_depth(sdevice, STORVSC_MAX_IO_REQUESTS);
 
         blk_queue_max_segment_size(sdevice->request_queue, PAGE_SIZE);
 
diff --git a/drivers/scsi/sun3_NCR5380.c b/drivers/scsi/sun3_NCR5380.c
deleted file mode 100644
index 1a2367a1b1f2..000000000000
--- a/drivers/scsi/sun3_NCR5380.c
+++ /dev/null
@@ -1,2933 +0,0 @@
-/* sun3_NCR5380.c -- adapted from atari_NCR5380.c for the sun3 by 
-   Sam Creasey. */ 
-/* 
- * NCR 5380 generic driver routines.  These should make it *trivial*
- *      to implement 5380 SCSI drivers under Linux with a non-trantor
- *      architecture.
- *
- *      Note that these routines also work with NR53c400 family chips.
- *
- * Copyright 1993, Drew Eckhardt
- *      Visionary Computing 
- *      (Unix and Linux consulting and custom programming)
- *      drew@colorado.edu
- *      +1 (303) 666-5836
- *
- * DISTRIBUTION RELEASE 6. 
- *
- * For more information, please consult 
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
- */
-
-/*
- * ++roman: To port the 5380 driver to the Atari, I had to do some changes in
- * this file, too:
- *
- *  - Some of the debug statements were incorrect (undefined variables and the
- *    like). I fixed that.
- *
- *  - In information_transfer(), I think a #ifdef was wrong. Looking at the
- *    possible DMA transfer size should also happen for REAL_DMA. I added this
- *    in the #if statement.
- *
- *  - When using real DMA, information_transfer() should return in a DATAOUT
- *    phase after starting the DMA. It has nothing more to do.
- *
- *  - The interrupt service routine should run main after end of DMA, too (not
- *    only after RESELECTION interrupts). Additionally, it should _not_ test
- *    for more interrupts after running main, since a DMA process may have
- *    been started and interrupts are turned on now. The new int could happen
- *    inside the execution of NCR5380_intr(), leading to recursive
- *    calls.
- *
- * - I've deleted all the stuff for AUTOPROBE_IRQ, REAL_DMA_POLL, PSEUDO_DMA
- *    and USLEEP, because these were messing up readability and will never be
- *    needed for Atari SCSI.
- * 
- * - I've revised the NCR5380_main() calling scheme (relax the 'main_running'
- *   stuff), and 'main' is executed in a bottom half if awoken by an
- *   interrupt.
- *
- * - The code was quite cluttered up by "#if (NDEBUG & NDEBUG_*) printk..."
- *   constructs. In my eyes, this made the source rather unreadable, so I
- *   finally replaced that by the *_PRINTK() macros.
- *
- */
-#include <scsi/scsi_dbg.h>
-#include <scsi/scsi_transport_spi.h>
-
-/*
- * Further development / testing that should be done : 
- * 1.  Test linked command handling code after Eric is ready with 
- *     the high level code.
- */
-
-#if (NDEBUG & NDEBUG_LISTS)
-#define LIST(x,y) \
-  { printk("LINE:%d   Adding %p to %p\n", __LINE__, (void*)(x), (void*)(y)); \
-    if ((x)==(y)) udelay(5); }
-#define REMOVE(w,x,y,z) \
-  { printk("LINE:%d   Removing: %p->%p  %p->%p \n", __LINE__, \
-           (void*)(w), (void*)(x), (void*)(y), (void*)(z)); \
-    if ((x)==(y)) udelay(5); }
-#else
-#define LIST(x,y)
-#define REMOVE(w,x,y,z)
-#endif
-
-#ifndef notyet
-#undef LINKED
-#endif
-
-/*
- * Design
- * Issues :
- *
- * The other Linux SCSI drivers were written when Linux was Intel PC-only,
- * and specifically for each board rather than each chip.  This makes their
- * adaptation to platforms like the Mac (Some of which use NCR5380's)
- * more difficult than it has to be.
- *
- * Also, many of the SCSI drivers were written before the command queuing
- * routines were implemented, meaning their implementations of queued 
- * commands were hacked on rather than designed in from the start.
- *
- * When I designed the Linux SCSI drivers I figured that 
- * while having two different SCSI boards in a system might be useful
- * for debugging things, two of the same type wouldn't be used.
- * Well, I was wrong and a number of users have mailed me about running
- * multiple high-performance SCSI boards in a server.
- *
- * Finally, when I get questions from users, I have no idea what 
- * revision of my driver they are running.
- *
- * This driver attempts to address these problems :
- * This is a generic 5380 driver.  To use it on a different platform, 
- * one simply writes appropriate system specific macros (ie, data
- * transfer - some PC's will use the I/O bus, 68K's must use 
- * memory mapped) and drops this file in their 'C' wrapper.
- *
- * As far as command queueing, two queues are maintained for 
- * each 5380 in the system - commands that haven't been issued yet,
- * and commands that are currently executing.  This means that an 
- * unlimited number of commands may be queued, letting 
- * more commands propagate from the higher driver levels giving higher 
- * throughput.  Note that both I_T_L and I_T_L_Q nexuses are supported, 
- * allowing multiple commands to propagate all the way to a SCSI-II device 
- * while a command is already executing.
- *
- * To solve the multiple-boards-in-the-same-system problem, 
- * there is a separate instance structure for each instance
- * of a 5380 in the system.  So, multiple NCR5380 drivers will
- * be able to coexist with appropriate changes to the high level
- * SCSI code.  
- *
- * A NCR5380_PUBLIC_REVISION macro is provided, with the release
- * number (updated for each public release) printed by the 
- * NCR5380_print_options command, which should be called from the 
- * wrapper detect function, so that I know what release of the driver
- * users are using.
- *
- * Issues specific to the NCR5380 : 
- *
- * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead 
- * piece of hardware that requires you to sit in a loop polling for 
- * the REQ signal as long as you are connected.  Some devices are 
- * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect 
- * while doing long seek operations.
- * 
- * The workaround for this is to keep track of devices that have
- * disconnected.  If the device hasn't disconnected, for commands that
- * should disconnect, we do something like 
- *
- * while (!REQ is asserted) { sleep for N usecs; poll for M usecs }
- * 
- * Some tweaking of N and M needs to be done.  An algorithm based 
- * on "time to data" would give the best results as long as short time
- * to datas (ie, on the same track) were considered, however these 
- * broken devices are the exception rather than the rule and I'd rather
- * spend my time optimizing for the normal case.
- *
- * Architecture :
- *
- * At the heart of the design is a coroutine, NCR5380_main,
- * which is started when not running by the interrupt handler,
- * timer, and queue command function.  It attempts to establish
- * I_T_L or I_T_L_Q nexuses by removing the commands from the 
- * issue queue and calling NCR5380_select() if a nexus 
- * is not established. 
- *
- * Once a nexus is established, the NCR5380_information_transfer()
- * phase goes through the various phases as instructed by the target.
- * if the target goes into MSG IN and sends a DISCONNECT message,
- * the command structure is placed into the per instance disconnected
- * queue, and NCR5380_main tries to find more work.  If USLEEP
- * was defined, and the target is idle for too long, the system
- * will try to sleep.
- *
- * If a command has disconnected, eventually an interrupt will trigger,
- * calling NCR5380_intr()  which will in turn call NCR5380_reselect
- * to reestablish a nexus.  This will run main if necessary.
- *
- * On command termination, the done function will be called as 
- * appropriate.
- *
- * SCSI pointers are maintained in the SCp field of SCSI command 
- * structures, being initialized after the command is connected
- * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
- * Note that in violation of the standard, an implicit SAVE POINTERS operation
- * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
- */
-
-/*
- * Using this file :
- * This file a skeleton Linux SCSI driver for the NCR 5380 series
- * of chips.  To use it, you write an architecture specific functions 
- * and macros and include this file in your driver.
- *
- * These macros control options : 
- * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
- *      for commands that return with a CHECK CONDITION status. 
- *
- * LINKED - if defined, linked commands are supported.
- *
- * REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
- *
- * SUPPORT_TAGS - if defined, SCSI-2 tagged queuing is used where possible
- *
- * These macros MUST be defined :
- * 
- * NCR5380_read(register)  - read from the specified register
- *
- * NCR5380_write(register, value) - write to the specific register 
- *
- * Either real DMA *or* pseudo DMA may be implemented
- * REAL functions : 
- * NCR5380_REAL_DMA should be defined if real DMA is to be used.
- * Note that the DMA setup functions should return the number of bytes 
- *      that they were able to program the controller for.
- *
- * Also note that generic i386/PC versions of these macros are 
- *      available as NCR5380_i386_dma_write_setup,
- *      NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
- *
- * NCR5380_dma_write_setup(instance, src, count) - initialize
- * NCR5380_dma_read_setup(instance, dst, count) - initialize
- * NCR5380_dma_residual(instance); - residual count
- *
- * PSEUDO functions :
- * NCR5380_pwrite(instance, src, count)
- * NCR5380_pread(instance, dst, count);
- *
- * If nothing specific to this implementation needs doing (ie, with external
- * hardware), you must also define 
- *  
- * NCR5380_queue_command
- * NCR5380_reset
- * NCR5380_abort
- * NCR5380_proc_info
- *
- * to be the global entry points into the specific driver, ie 
- * #define NCR5380_queue_command t128_queue_command.
- *
- * If this is not done, the routines will be defined as static functions
- * with the NCR5380* names and the user must provide a globally
- * accessible wrapper function.
- *
- * The generic driver is initialized by calling NCR5380_init(instance),
- * after setting the appropriate host specific fields and ID.  If the 
- * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
- * possible) function may be used.  Before the specific driver initialization
- * code finishes, NCR5380_print_options should be called.
- */
-
-static struct Scsi_Host *first_instance = NULL;
-static struct scsi_host_template *the_template = NULL;
-
-/* Macros ease life... :-) */
-#define SETUP_HOSTDATA(in)                              \
-    struct NCR5380_hostdata *hostdata =                 \
-        (struct NCR5380_hostdata *)(in)->hostdata
-#define HOSTDATA(in) ((struct NCR5380_hostdata *)(in)->hostdata)
-
-#define NEXT(cmd)               ((struct scsi_cmnd *)(cmd)->host_scribble)
-#define SET_NEXT(cmd, next)     ((cmd)->host_scribble = (void *)(next))
-#define NEXTADDR(cmd)           ((struct scsi_cmnd **)&((cmd)->host_scribble))
-
-#define HOSTNO          instance->host_no
-#define H_NO(cmd)       (cmd)->device->host->host_no
-
-#define SGADDR(buffer) (void *)(((unsigned long)sg_virt(((buffer)))))
-
-#ifdef SUPPORT_TAGS
-
-/*
- * Functions for handling tagged queuing
- * =====================================
- *
- * ++roman (01/96): Now I've implemented SCSI-2 tagged queuing. Some notes:
- *
- * Using consecutive numbers for the tags is no good idea in my eyes. There
- * could be wrong re-usings if the counter (8 bit!) wraps and some early
- * command has been preempted for a long time. My solution: a bitfield for
- * remembering used tags.
- *
- * There's also the problem that each target has a certain queue size, but we
- * cannot know it in advance :-( We just see a QUEUE_FULL status being
- * returned. So, in this case, the driver internal queue size assumption is
- * reduced to the number of active tags if QUEUE_FULL is returned by the
- * target. The command is returned to the mid-level, but with status changed
- * to BUSY, since --as I've seen-- the mid-level can't handle QUEUE_FULL
- * correctly.
- *
- * We're also not allowed running tagged commands as long as an untagged
- * command is active. And REQUEST SENSE commands after a contingent allegiance
- * condition _must_ be untagged. To keep track whether an untagged command has
- * been issued, the host->busy array is still employed, as it is without
- * support for tagged queuing.
- *
- * One could suspect that there are possible race conditions between
- * is_lun_busy(), cmd_get_tag() and cmd_free_tag(). But I think this isn't the
- * case: is_lun_busy() and cmd_get_tag() are both called from NCR5380_main(),
- * which already guaranteed to be running at most once. It is also the only
- * place where tags/LUNs are allocated. So no other allocation can slip
- * between that pair, there could only happen a reselection, which can free a
- * tag, but that doesn't hurt. Only the sequence in cmd_free_tag() becomes
- * important: the tag bit must be cleared before 'nr_allocated' is decreased.
- */
-
-/* -1 for TAG_NONE is not possible with unsigned char cmd->tag */
-#undef TAG_NONE
-#define TAG_NONE 0xff
-
-/* For the m68k, the number of bits in 'allocated' must be a multiple of 32! */
-#if (MAX_TAGS % 32) != 0
-#error "MAX_TAGS must be a multiple of 32!"
-#endif
-
-typedef struct {
-    char        allocated[MAX_TAGS/8];
-    int         nr_allocated;
-    int         queue_size;
-} TAG_ALLOC;
-
-static TAG_ALLOC TagAlloc[8][8]; /* 8 targets and 8 LUNs */
-
-
-static void __init init_tags( void )
-{
-    int target, lun;
-    TAG_ALLOC *ta;
-    
-    if (!setup_use_tagged_queuing)
-        return;
-    
-    for( target = 0; target < 8; ++target ) {
-        for( lun = 0; lun < 8; ++lun ) {
-            ta = &TagAlloc[target][lun];
-            memset( &ta->allocated, 0, MAX_TAGS/8 );
-            ta->nr_allocated = 0;
-            /* At the beginning, assume the maximum queue size we could
-             * support (MAX_TAGS). This value will be decreased if the target
-             * returns QUEUE_FULL status.
-             */
-            ta->queue_size = MAX_TAGS;
-        }
-    }
-}
-
-
-/* Check if we can issue a command to this LUN: First see if the LUN is marked
- * busy by an untagged command. If the command should use tagged queuing, also
- * check that there is a free tag and the target's queue won't overflow. This
- * function should be called with interrupts disabled to avoid race
- * conditions.
- */ 
-
-static int is_lun_busy(struct scsi_cmnd *cmd, int should_be_tagged)
-{
-    u8 lun = cmd->device->lun;
-    SETUP_HOSTDATA(cmd->device->host);
-
-    if (hostdata->busy[cmd->device->id] & (1 << lun))
-        return( 1 );
-    if (!should_be_tagged ||
-        !setup_use_tagged_queuing || !cmd->device->tagged_supported)
-        return( 0 );
-    if (TagAlloc[cmd->device->id][lun].nr_allocated >=
-        TagAlloc[cmd->device->id][lun].queue_size ) {
-        dprintk(NDEBUG_TAGS,  "scsi%d: target %d lun %d: no free tags\n",
-                    H_NO(cmd), cmd->device->id, lun );
-        return( 1 );
-    }
-    return( 0 );
-}
-
-
-/* Allocate a tag for a command (there are no checks anymore, check_lun_busy()
- * must be called before!), or reserve the LUN in 'busy' if the command is
- * untagged.
- */
-
-static void cmd_get_tag(struct scsi_cmnd *cmd, int should_be_tagged)
-{
-    u8 lun = cmd->device->lun;
-    SETUP_HOSTDATA(cmd->device->host);
-
-    /* If we or the target don't support tagged queuing, allocate the LUN for
-     * an untagged command.
-     */
-    if (!should_be_tagged ||
-        !setup_use_tagged_queuing || !cmd->device->tagged_supported) {
-        cmd->tag = TAG_NONE;
-        hostdata->busy[cmd->device->id] |= (1 << lun);
-        dprintk(NDEBUG_TAGS,  "scsi%d: target %d lun %d now allocated by untagged "
-                    "command\n", H_NO(cmd), cmd->device->id, lun );
-    }
-    else {
-        TAG_ALLOC *ta = &TagAlloc[cmd->device->id][lun];
-
-        cmd->tag = find_first_zero_bit( &ta->allocated, MAX_TAGS );
-        set_bit( cmd->tag, &ta->allocated );
-        ta->nr_allocated++;
-        dprintk(NDEBUG_TAGS,  "scsi%d: using tag %d for target %d lun %d "
-                    "(now %d tags in use)\n",
-                    H_NO(cmd), cmd->tag, cmd->device->id, lun,
-                    ta->nr_allocated );
-    }
-}
-
-
-/* Mark the tag of command 'cmd' as free, or in case of an untagged command,
- * unlock the LUN.
- */
-
-static void cmd_free_tag(struct scsi_cmnd *cmd)
-{
-    u8 lun = cmd->device->lun;
-    SETUP_HOSTDATA(cmd->device->host);
-
-    if (cmd->tag == TAG_NONE) {
-        hostdata->busy[cmd->device->id] &= ~(1 << lun);
-        dprintk(NDEBUG_TAGS,  "scsi%d: target %d lun %d untagged cmd finished\n",
-                    H_NO(cmd), cmd->device->id, lun );
-    }
-    else if (cmd->tag >= MAX_TAGS) {
-        printk(KERN_NOTICE "scsi%d: trying to free bad tag %d!\n",
-                H_NO(cmd), cmd->tag );
-    }
-    else {
-        TAG_ALLOC *ta = &TagAlloc[cmd->device->id][lun];
-        clear_bit( cmd->tag, &ta->allocated );
-        ta->nr_allocated--;
-        dprintk(NDEBUG_TAGS,  "scsi%d: freed tag %d for target %d lun %d\n",
-                    H_NO(cmd), cmd->tag, cmd->device->id, lun );
-    }
-}
-
-
-static void free_all_tags( void )
-{
-    int target, lun;
-    TAG_ALLOC *ta;
-
-    if (!setup_use_tagged_queuing)
-        return;
-    
-    for( target = 0; target < 8; ++target ) {
-        for( lun = 0; lun < 8; ++lun ) {
-            ta = &TagAlloc[target][lun];
-            memset( &ta->allocated, 0, MAX_TAGS/8 );
-            ta->nr_allocated = 0;
-        }
-    }
-}
-
-#endif /* SUPPORT_TAGS */
-
-
-/*
- * Function : void initialize_SCp(struct scsi_cmnd *cmd)
- *
- * Purpose : initialize the saved data pointers for cmd to point to the 
- *      start of the buffer.
- *
- * Inputs : cmd - struct scsi_cmnd structure to have pointers reset.
- */
-
-static __inline__ void initialize_SCp(struct scsi_cmnd *cmd)
-{
-    /* 
-     * Initialize the Scsi Pointer field so that all of the commands in the 
-     * various queues are valid.
-     */
-
-    if (scsi_bufflen(cmd)) {
-        cmd->SCp.buffer = scsi_sglist(cmd);
-        cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
-        cmd->SCp.ptr = (char *) SGADDR(cmd->SCp.buffer);
-        cmd->SCp.this_residual = cmd->SCp.buffer->length;
-    } else {
-        cmd->SCp.buffer = NULL;
-        cmd->SCp.buffers_residual = 0;
-        cmd->SCp.ptr = NULL;
-        cmd->SCp.this_residual = 0;
-    }
-    
-}
-
-#include <linux/delay.h>
-
-#if NDEBUG
-static struct {
-    unsigned char mask;
-    const char * name;} 
-signals[] = {{ SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" }, 
-    { SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD,  "CD" }, { SR_IO, "IO" }, 
-    { SR_SEL, "SEL" }, {0, NULL}}, 
-basrs[] = {{BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}},
-icrs[] = {{ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"},
-    {ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"}, 
-    {ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"}, 
-    {0, NULL}},
-mrs[] = {{MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"}, 
-    {MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR, 
-    "MODE PARITY INTR"}, {MR_ENABLE_EOP_INTR,"MODE EOP INTR"},
-    {MR_MONITOR_BSY, "MODE MONITOR BSY"},
-    {MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"}, 
-    {0, NULL}};
-
-/*
- * Function : void NCR5380_print(struct Scsi_Host *instance)
- *
- * Purpose : print the SCSI bus signals for debugging purposes
- *
- * Input : instance - which NCR5380
- */
-
-static void NCR5380_print(struct Scsi_Host *instance) {
-    unsigned char status, data, basr, mr, icr, i;
-    unsigned long flags;
-
-    local_irq_save(flags);
-    data = NCR5380_read(CURRENT_SCSI_DATA_REG);
-    status = NCR5380_read(STATUS_REG);
-    mr = NCR5380_read(MODE_REG);
-    icr = NCR5380_read(INITIATOR_COMMAND_REG);
-    basr = NCR5380_read(BUS_AND_STATUS_REG);
-    local_irq_restore(flags);
-    printk("STATUS_REG: %02x ", status);
-    for (i = 0; signals[i].mask ; ++i) 
-        if (status & signals[i].mask)
-            printk(",%s", signals[i].name);
-    printk("\nBASR: %02x ", basr);
-    for (i = 0; basrs[i].mask ; ++i) 
-        if (basr & basrs[i].mask)
-            printk(",%s", basrs[i].name);
-    printk("\nICR: %02x ", icr);
-    for (i = 0; icrs[i].mask; ++i) 
-        if (icr & icrs[i].mask)
-            printk(",%s", icrs[i].name);
-    printk("\nMODE: %02x ", mr);
-    for (i = 0; mrs[i].mask; ++i) 
-        if (mr & mrs[i].mask)
-            printk(",%s", mrs[i].name);
-    printk("\n");
-}
-
-static struct {
-    unsigned char value;
-    const char *name;
-} phases[] = {
-    {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
-    {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
-    {PHASE_UNKNOWN, "UNKNOWN"}};
-
-/* 
- * Function : void NCR5380_print_phase(struct Scsi_Host *instance)
- *
- * Purpose : print the current SCSI phase for debugging purposes
- *
- * Input : instance - which NCR5380
- */
-
-static void NCR5380_print_phase(struct Scsi_Host *instance)
-{
-    unsigned char status;
-    int i;
-
-    status = NCR5380_read(STATUS_REG);
-    if (!(status & SR_REQ)) 
-        printk(KERN_DEBUG "scsi%d: REQ not asserted, phase unknown.\n", HOSTNO);
-    else {
-        for (i = 0; (phases[i].value != PHASE_UNKNOWN) && 
-            (phases[i].value != (status & PHASE_MASK)); ++i); 
-        printk(KERN_DEBUG "scsi%d: phase %s\n", HOSTNO, phases[i].name);
-    }
-}
-
-#endif
-
-/*
- * ++roman: New scheme of calling NCR5380_main()
- * 
- * If we're not in an interrupt, we can call our main directly, it cannot be
- * already running. Else, we queue it on a task queue, if not 'main_running'
- * tells us that a lower level is already executing it. This way,
- * 'main_running' needs not be protected in a special way.
- *
- * queue_main() is a utility function for putting our main onto the task
- * queue, if main_running is false. It should be called only from a
- * interrupt or bottom half.
- */
-
-#include <linux/gfp.h>
-#include <linux/workqueue.h>
-#include <linux/interrupt.h>
-
-static volatile int main_running = 0;
-static DECLARE_WORK(NCR5380_tqueue, NCR5380_main);
-
-static __inline__ void queue_main(void)
-{
-    if (!main_running) {
-        /* If in interrupt and NCR5380_main() not already running,
-           queue it on the 'immediate' task queue, to be processed
-           immediately after the current interrupt processing has
-           finished. */
-        schedule_work(&NCR5380_tqueue);
-    }
-    /* else: nothing to do: the running NCR5380_main() will pick up
-       any newly queued command. */
-}
-
-
-static inline void NCR5380_all_init (void)
-{
-    static int done = 0;
-    if (!done) {
-        dprintk(NDEBUG_INIT, "scsi : NCR5380_all_init()\n");
-        done = 1;
-    }
-}
-
- 
-/*
- * Function : void NCR58380_print_options (struct Scsi_Host *instance)
- *
- * Purpose : called by probe code indicating the NCR5380 driver
- *           options that were selected.
- *
- * Inputs : instance, pointer to this instance.  Unused.
- */
-
-static void __init NCR5380_print_options (struct Scsi_Host *instance)
-{
-    printk(" generic options"
-#ifdef AUTOSENSE 
-    " AUTOSENSE"
-#endif
-#ifdef REAL_DMA
-    " REAL DMA"
-#endif
-#ifdef PARITY
-    " PARITY"
-#endif
-#ifdef SUPPORT_TAGS
-    " SCSI-2 TAGGED QUEUING"
-#endif
-    );
-    printk(" generic release=%d", NCR5380_PUBLIC_RELEASE);
-}
-
-/*
- * Function : void NCR5380_print_status (struct Scsi_Host *instance)
- *
- * Purpose : print commands in the various queues, called from
- *      NCR5380_abort and NCR5380_debug to aid debugging.
- *
- * Inputs : instance, pointer to this instance.  
- */
-
-static void lprint_Scsi_Cmnd(Scsi_Cmnd *cmd)
-{
-        int i, s;
-        unsigned char *command;
-        printk("scsi%d: destination target %d, lun %llu\n",
-                H_NO(cmd), cmd->device->id, cmd->device->lun);
-        printk(KERN_CONT "        command = ");
-        command = cmd->cmnd;
-        printk(KERN_CONT "%2d (0x%02x)", command[0], command[0]);
-        for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
-                printk(KERN_CONT " %02x", command[i]);
-        printk("\n");
-}
-
-static void NCR5380_print_status(struct Scsi_Host *instance)
-{
-        struct NCR5380_hostdata *hostdata;
-        Scsi_Cmnd *ptr;
-        unsigned long flags;
-
-        NCR5380_dprint(NDEBUG_ANY, instance);
-        NCR5380_dprint_phase(NDEBUG_ANY, instance);
-
-        hostdata = (struct NCR5380_hostdata *)instance->hostdata;
-
-        printk("\nNCR5380 core release=%d.\n", NCR5380_PUBLIC_RELEASE);
-        local_irq_save(flags);
-        printk("NCR5380: coroutine is%s running.\n",
-                main_running ? "" : "n't");
-        if (!hostdata->connected)
-                printk("scsi%d: no currently connected command\n", HOSTNO);
-        else
-                lprint_Scsi_Cmnd((Scsi_Cmnd *) hostdata->connected);
-        printk("scsi%d: issue_queue\n", HOSTNO);
-        for (ptr = (Scsi_Cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr))
-                lprint_Scsi_Cmnd(ptr);
-
-        printk("scsi%d: disconnected_queue\n", HOSTNO);
-        for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr;
-             ptr = NEXT(ptr))
-                lprint_Scsi_Cmnd(ptr);
-
-        local_irq_restore(flags);
-        printk("\n");
-}
-
-static void show_Scsi_Cmnd(Scsi_Cmnd *cmd, struct seq_file *m)
-{
-        int i, s;
-        unsigned char *command;
-        seq_printf(m, "scsi%d: destination target %d, lun %llu\n",
-                H_NO(cmd), cmd->device->id, cmd->device->lun);
-        seq_printf(m, "        command = ");
-        command = cmd->cmnd;
-        seq_printf(m, "%2d (0x%02x)", command[0], command[0]);
-        for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
-                seq_printf(m, " %02x", command[i]);
-        seq_printf(m, "\n");
-}
-
-static int NCR5380_show_info(struct seq_file *m, struct Scsi_Host *instance)
-{
-        struct NCR5380_hostdata *hostdata;
-        Scsi_Cmnd *ptr;
-        unsigned long flags;
-
-        hostdata = (struct NCR5380_hostdata *)instance->hostdata;
-
-        seq_printf(m, "NCR5380 core release=%d.\n", NCR5380_PUBLIC_RELEASE);
-        local_irq_save(flags);
-        seq_printf(m, "NCR5380: coroutine is%s running.\n",
-                main_running ? "" : "n't");
-        if (!hostdata->connected)
-                seq_printf(m, "scsi%d: no currently connected command\n", HOSTNO);
-        else
-                show_Scsi_Cmnd((Scsi_Cmnd *) hostdata->connected, m);
-        seq_printf(m, "scsi%d: issue_queue\n", HOSTNO);
-        for (ptr = (Scsi_Cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr))
-                show_Scsi_Cmnd(ptr, m);
-
-        seq_printf(m, "scsi%d: disconnected_queue\n", HOSTNO);
-        for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr;
-             ptr = NEXT(ptr))
-                show_Scsi_Cmnd(ptr, m);
-
-        local_irq_restore(flags);
-        return 0;
-}
-
-/* 
- * Function : void NCR5380_init (struct Scsi_Host *instance)
- *
- * Purpose : initializes *instance and corresponding 5380 chip.
- *
- * Inputs : instance - instantiation of the 5380 driver.  
- *
- * Notes : I assume that the host, hostno, and id bits have been
- *      set correctly.  I don't care about the irq and other fields. 
- * 
- */
-
-static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
-{
-    int i;
-    SETUP_HOSTDATA(instance);
-
-    NCR5380_all_init();
-
-    hostdata->aborted = 0;
-    hostdata->id_mask = 1 << instance->this_id;
-    hostdata->id_higher_mask = 0;
-    for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
-        if (i > hostdata->id_mask)
-            hostdata->id_higher_mask |= i;
-    for (i = 0; i < 8; ++i)
-        hostdata->busy[i] = 0;
-#ifdef SUPPORT_TAGS
-    init_tags();
-#endif
-#if defined (REAL_DMA)
-    hostdata->dma_len = 0;
-#endif
-    hostdata->targets_present = 0;
-    hostdata->connected = NULL;
-    hostdata->issue_queue = NULL;
-    hostdata->disconnected_queue = NULL;
-    hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT;
-
-    if (!the_template) {
-        the_template = instance->hostt;
-        first_instance = instance;
-    }
-        
-
-#ifndef AUTOSENSE
-    if ((instance->cmd_per_lun > 1) || (instance->can_queue > 1))
-         printk("scsi%d: WARNING : support for multiple outstanding commands enabled\n"
-                "        without AUTOSENSE option, contingent allegiance conditions may\n"
-                "        be incorrectly cleared.\n", HOSTNO);
-#endif /* def AUTOSENSE */
-
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-    NCR5380_write(MODE_REG, MR_BASE);
-    NCR5380_write(TARGET_COMMAND_REG, 0);
-    NCR5380_write(SELECT_ENABLE_REG, 0);
-
-    return 0;
-}
-
-static void NCR5380_exit(struct Scsi_Host *instance)
-{
-        /* Empty, as we didn't schedule any delayed work */
-}
-
-/* 
- * Function : int NCR5380_queue_command (struct scsi_cmnd *cmd,
- *      void (*done)(struct scsi_cmnd *))
- *
- * Purpose :  enqueues a SCSI command
- *
- * Inputs : cmd - SCSI command, done - function called on completion, with
- *      a pointer to the command descriptor.
- * 
- * Returns : 0
- *
- * Side effects : 
- *      cmd is added to the per instance issue_queue, with minor 
- *      twiddling done to the host specific fields of cmd.  If the 
- *      main coroutine is not running, it is restarted.
- *
- */
-
-/* Only make static if a wrapper function is used */
-static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd,
-                                 void (*done)(struct scsi_cmnd *))
-{
-    SETUP_HOSTDATA(cmd->device->host);
-    struct scsi_cmnd *tmp;
-    unsigned long flags;
-
-#if (NDEBUG & NDEBUG_NO_WRITE)
-    switch (cmd->cmnd[0]) {
-    case WRITE_6:
-    case WRITE_10:
-        printk(KERN_NOTICE "scsi%d: WRITE attempted with NO_WRITE debugging flag set\n",
-               H_NO(cmd));
-        cmd->result = (DID_ERROR << 16);
-        done(cmd);
-        return 0;
-    }
-#endif /* (NDEBUG & NDEBUG_NO_WRITE) */
-
-
-#ifdef NCR5380_STATS
-# if 0
-    if (!hostdata->connected && !hostdata->issue_queue &&
-        !hostdata->disconnected_queue) {
-        hostdata->timebase = jiffies;
-    }
-# endif
-# ifdef NCR5380_STAT_LIMIT
-    if (scsi_bufflen(cmd) > NCR5380_STAT_LIMIT)
-# endif
-        switch (cmd->cmnd[0])
-        {
-            case WRITE:
-            case WRITE_6:
-            case WRITE_10:
-                hostdata->time_write[cmd->device->id] -= (jiffies - hostdata->timebase);
-                hostdata->bytes_write[cmd->device->id] += scsi_bufflen(cmd);
-                hostdata->pendingw++;
-                break;
-            case READ:
-            case READ_6:
-            case READ_10:
-                hostdata->time_read[cmd->device->id] -= (jiffies - hostdata->timebase);
-                hostdata->bytes_read[cmd->device->id] += scsi_bufflen(cmd);
-                hostdata->pendingr++;
-                break;
-        }
-#endif
-
-    /* 
-     * We use the host_scribble field as a pointer to the next command  
-     * in a queue 
-     */
-
-    SET_NEXT(cmd, NULL);
-    cmd->scsi_done = done;
-
-    cmd->result = 0;
-
-
-    /* 
-     * Insert the cmd into the issue queue. Note that REQUEST SENSE 
-     * commands are added to the head of the queue since any command will
-     * clear the contingent allegiance condition that exists and the 
-     * sense data is only guaranteed to be valid while the condition exists.
-     */
-
-    local_irq_save(flags);
-    /* ++guenther: now that the issue queue is being set up, we can lock ST-DMA.
-     * Otherwise a running NCR5380_main may steal the lock.
-     * Lock before actually inserting due to fairness reasons explained in
-     * atari_scsi.c. If we insert first, then it's impossible for this driver
-     * to release the lock.
-     * Stop timer for this command while waiting for the lock, or timeouts
-     * may happen (and they really do), and it's no good if the command doesn't
-     * appear in any of the queues.
-     * ++roman: Just disabling the NCR interrupt isn't sufficient here,
-     * because also a timer int can trigger an abort or reset, which would
-     * alter queues and touch the lock.
-     */
-    if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
-        LIST(cmd, hostdata->issue_queue);
-        SET_NEXT(cmd, hostdata->issue_queue);
-        hostdata->issue_queue = cmd;
-    } else {
-        for (tmp = (struct scsi_cmnd *)hostdata->issue_queue;
-             NEXT(tmp); tmp = NEXT(tmp))
-            ;
-        LIST(cmd, tmp);
-        SET_NEXT(tmp, cmd);
-    }
-
-    local_irq_restore(flags);
-
-    dprintk(NDEBUG_QUEUES, "scsi%d: command added to %s of queue\n", H_NO(cmd),
-              (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
-
-    /* If queue_command() is called from an interrupt (real one or bottom
-     * half), we let queue_main() do the job of taking care about main. If it
-     * is already running, this is a no-op, else main will be queued.
-     *
-     * If we're not in an interrupt, we can call NCR5380_main()
-     * unconditionally, because it cannot be already running.
-     */
-    if (in_interrupt() || ((flags >> 8) & 7) >= 6)
-        queue_main();
-    else
-        NCR5380_main(NULL);
-    return 0;
-}
-
-static DEF_SCSI_QCMD(NCR5380_queue_command)
-
-/*
- * Function : NCR5380_main (void) 
- *
- * Purpose : NCR5380_main is a coroutine that runs as long as more work can 
- *      be done on the NCR5380 host adapters in a system.  Both 
- *      NCR5380_queue_command() and NCR5380_intr() will try to start it 
- *      in case it is not running.
- * 
- * NOTE : NCR5380_main exits with interrupts *disabled*, the caller should 
- *  reenable them.  This prevents reentrancy and kernel stack overflow.
- */     
-    
-static void NCR5380_main (struct work_struct *bl)
-{
-    struct scsi_cmnd *tmp, *prev;
-    struct Scsi_Host *instance = first_instance;
-    struct NCR5380_hostdata *hostdata = HOSTDATA(instance);
-    int done;
-    unsigned long flags;
-    
-    /*
-     * We run (with interrupts disabled) until we're sure that none of 
-     * the host adapters have anything that can be done, at which point 
-     * we set main_running to 0 and exit.
-     *
-     * Interrupts are enabled before doing various other internal 
-     * instructions, after we've decided that we need to run through
-     * the loop again.
-     *
-     * this should prevent any race conditions.
-     * 
-     * ++roman: Just disabling the NCR interrupt isn't sufficient here,
-     * because also a timer int can trigger an abort or reset, which can
-     * alter queues and touch the Falcon lock.
-     */
-
-    /* Tell int handlers main() is now already executing.  Note that
-       no races are possible here. If an int comes in before
-       'main_running' is set here, and queues/executes main via the
-       task queue, it doesn't do any harm, just this instance of main
-       won't find any work left to do. */
-    if (main_running)
-        return;
-    main_running = 1;
-
-    local_save_flags(flags);
-    do {
-        local_irq_disable(); /* Freeze request queues */
-        done = 1;
-        
-        if (!hostdata->connected) {
-            dprintk(NDEBUG_MAIN,  "scsi%d: not connected\n", HOSTNO );
-            /*
-             * Search through the issue_queue for a command destined
-             * for a target that's not busy.
-             */
-#if (NDEBUG & NDEBUG_LISTS)
-            for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL;
-                 tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp))
-                ;
-            if ((tmp == prev) && tmp) printk(" LOOP\n");/* else printk("\n");*/
-#endif
-            for (tmp = (struct scsi_cmnd *) hostdata->issue_queue,
-                 prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp) ) {
-
-                if (prev != tmp)
-                        dprintk(NDEBUG_LISTS, "MAIN tmp=%p   target=%d   busy=%d lun=%llu\n", tmp, tmp->device->id, hostdata->busy[tmp->device->id], tmp->device->lun);
-                /*  When we find one, remove it from the issue queue. */
-                /* ++guenther: possible race with Falcon locking */
-                if (
-#ifdef SUPPORT_TAGS
-                    !is_lun_busy( tmp, tmp->cmnd[0] != REQUEST_SENSE)
-#else
-                    !(hostdata->busy[tmp->device->id] & (1 << tmp->device->lun))
-#endif
-                    ) {
-                    /* ++guenther: just to be sure, this must be atomic */
-                    local_irq_disable();
-                    if (prev) {
-                        REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
-                        SET_NEXT(prev, NEXT(tmp));
-                    } else {
-                        REMOVE(-1, hostdata->issue_queue, tmp, NEXT(tmp));
-                        hostdata->issue_queue = NEXT(tmp);
-                    }
-                    SET_NEXT(tmp, NULL);
-                    
-                    /* reenable interrupts after finding one */
-                    local_irq_restore(flags);
-                    
-                    /* 
-                     * Attempt to establish an I_T_L nexus here. 
-                     * On success, instance->hostdata->connected is set.
-                     * On failure, we must add the command back to the
-                     *   issue queue so we can keep trying.     
-                     */
-                    dprintk(NDEBUG_MAIN, "scsi%d: main(): command for target %d "
-                                "lun %llu removed from issue_queue\n",
-                                HOSTNO, tmp->device->id, tmp->device->lun);
-                    /* 
-                     * REQUEST SENSE commands are issued without tagged
-                     * queueing, even on SCSI-II devices because the 
-                     * contingent allegiance condition exists for the 
-                     * entire unit.
-                     */
-                    /* ++roman: ...and the standard also requires that
-                     * REQUEST SENSE command are untagged.
-                     */
-                    
-#ifdef SUPPORT_TAGS
-                    cmd_get_tag( tmp, tmp->cmnd[0] != REQUEST_SENSE );
-#endif
-                    if (!NCR5380_select(instance, tmp, 
-                            (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : 
-                            TAG_NEXT)) {
-                        break;
-                    } else {
-                        local_irq_disable();
-                        LIST(tmp, hostdata->issue_queue);
-                        SET_NEXT(tmp, hostdata->issue_queue);
-                        hostdata->issue_queue = tmp;
-#ifdef SUPPORT_TAGS
-                        cmd_free_tag( tmp );
-#endif
-                        local_irq_restore(flags);
-                        dprintk(NDEBUG_MAIN, "scsi%d: main(): select() failed, "
-                                    "returned to issue_queue\n", HOSTNO);
-                        if (hostdata->connected)
-                            break;
-                    }
-                } /* if target/lun/target queue is not busy */
-            } /* for issue_queue */
-        } /* if (!hostdata->connected) */
-        if (hostdata->connected 
-#ifdef REAL_DMA
-            && !hostdata->dma_len
-#endif
-            ) {
-            local_irq_restore(flags);
-            dprintk(NDEBUG_MAIN, "scsi%d: main: performing information transfer\n",
-                        HOSTNO);
-            NCR5380_information_transfer(instance);
-            dprintk(NDEBUG_MAIN, "scsi%d: main: done set false\n", HOSTNO);
-            done = 0;
-        }
-    } while (!done);
-
-    /* Better allow ints _after_ 'main_running' has been cleared, else
-       an interrupt could believe we'll pick up the work it left for
-       us, but we won't see it anymore here... */
-    main_running = 0;
-    local_irq_restore(flags);
-}
-
-
-#ifdef REAL_DMA
-/*
- * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
- *
- * Purpose : Called by interrupt handler when DMA finishes or a phase
- *      mismatch occurs (which would finish the DMA transfer).  
- *
- * Inputs : instance - this instance of the NCR5380.
- *
- */
-
-static void NCR5380_dma_complete( struct Scsi_Host *instance )
-{
-    SETUP_HOSTDATA(instance);
-    int           transfered;
-    unsigned char **data;
-    volatile int  *count;
-
-    if (!hostdata->connected) {
-        printk(KERN_WARNING "scsi%d: received end of DMA interrupt with "
-               "no connected cmd\n", HOSTNO);
-        return;
-    }
-
-    dprintk(NDEBUG_DMA, "scsi%d: real DMA transfer complete, basr 0x%X, sr 0x%X\n",
-               HOSTNO, NCR5380_read(BUS_AND_STATUS_REG),
-               NCR5380_read(STATUS_REG));
-
-    if((sun3scsi_dma_finish(rq_data_dir(hostdata->connected->request)))) {
-            printk("scsi%d: overrun in UDC counter -- not prepared to deal with this!\n", HOSTNO);
-            printk("please e-mail sammy@sammy.net with a description of how this\n");
-            printk("error was produced.\n");
-            BUG();
-    }
-
-    /* make sure we're not stuck in a data phase */
-    if((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH |
-                                            BASR_ACK)) ==
-       (BASR_PHASE_MATCH | BASR_ACK)) {
-            printk("scsi%d: BASR %02x\n", HOSTNO, NCR5380_read(BUS_AND_STATUS_REG));
-            printk("scsi%d: bus stuck in data phase -- probably a single byte "
-                   "overrun!\n", HOSTNO);
-            printk("not prepared for this error!\n");
-            printk("please e-mail sammy@sammy.net with a description of how this\n");
-            printk("error was produced.\n");
-            BUG();
-    }
-
-
-
-    (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-    NCR5380_write(MODE_REG, MR_BASE);
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-
-    transfered = hostdata->dma_len - NCR5380_dma_residual(instance);
-    hostdata->dma_len = 0;
-
-    data = (unsigned char **) &(hostdata->connected->SCp.ptr);
-    count = &(hostdata->connected->SCp.this_residual);
-    *data += transfered;
-    *count -= transfered;
-
-}
-#endif /* REAL_DMA */
-
-
-/*
- * Function : void NCR5380_intr (int irq)
- * 
- * Purpose : handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
- *      from the disconnected queue, and restarting NCR5380_main() 
- *      as required.
- *
- * Inputs : int irq, irq that caused this interrupt.
- *
- */
-
-static irqreturn_t NCR5380_intr (int irq, void *dev_id)
-{
-    struct Scsi_Host *instance = first_instance;
-    int done = 1, handled = 0;
-    unsigned char basr;
-
-    dprintk(NDEBUG_INTR, "scsi%d: NCR5380 irq triggered\n", HOSTNO);
-
-    /* Look for pending interrupts */
-    basr = NCR5380_read(BUS_AND_STATUS_REG);
-    dprintk(NDEBUG_INTR, "scsi%d: BASR=%02x\n", HOSTNO, basr);
-    /* dispatch to appropriate routine if found and done=0 */
-    if (basr & BASR_IRQ) {
-        NCR5380_dprint(NDEBUG_INTR, instance);
-        if ((NCR5380_read(STATUS_REG) & (SR_SEL|SR_IO)) == (SR_SEL|SR_IO)) {
-            done = 0;
-//          ENABLE_IRQ();
-            dprintk(NDEBUG_INTR, "scsi%d: SEL interrupt\n", HOSTNO);
-            NCR5380_reselect(instance);
-            (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-        }
-        else if (basr & BASR_PARITY_ERROR) {
-            dprintk(NDEBUG_INTR, "scsi%d: PARITY interrupt\n", HOSTNO);
-            (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-        }
-        else if ((NCR5380_read(STATUS_REG) & SR_RST) == SR_RST) {
-            dprintk(NDEBUG_INTR, "scsi%d: RESET interrupt\n", HOSTNO);
-            (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-        }
-        else {
-            /*  
-             * The rest of the interrupt conditions can occur only during a
-             * DMA transfer
-             */
-
-#if defined(REAL_DMA)
-            /*
-             * We should only get PHASE MISMATCH and EOP interrupts if we have
-             * DMA enabled, so do a sanity check based on the current setting
-             * of the MODE register.
-             */
-
-            if ((NCR5380_read(MODE_REG) & MR_DMA_MODE) &&
-                ((basr & BASR_END_DMA_TRANSFER) || 
-                 !(basr & BASR_PHASE_MATCH))) {
-                    
-                dprintk(NDEBUG_INTR, "scsi%d: PHASE MISM or EOP interrupt\n", HOSTNO);
-                NCR5380_dma_complete( instance );
-                done = 0;
-//              ENABLE_IRQ();
-            } else
-#endif /* REAL_DMA */
-            {
-/* MS: Ignore unknown phase mismatch interrupts (caused by EOP interrupt) */
-                if (basr & BASR_PHASE_MATCH)
-                   dprintk(NDEBUG_INTR, "scsi%d: unknown interrupt, "
-                           "BASR 0x%x, MR 0x%x, SR 0x%x\n",
-                           HOSTNO, basr, NCR5380_read(MODE_REG),
-                           NCR5380_read(STATUS_REG));
-                (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-#ifdef SUN3_SCSI_VME
-                dregs->csr |= CSR_DMA_ENABLE;
-#endif
-            }
-        } /* if !(SELECTION || PARITY) */
-        handled = 1;
-    } /* BASR & IRQ */
-    else {
-
-        printk(KERN_NOTICE "scsi%d: interrupt without IRQ bit set in BASR, "
-               "BASR 0x%X, MR 0x%X, SR 0x%x\n", HOSTNO, basr,
-               NCR5380_read(MODE_REG), NCR5380_read(STATUS_REG));
-        (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-#ifdef SUN3_SCSI_VME
-                dregs->csr |= CSR_DMA_ENABLE;
-#endif
-    }
-    
-    if (!done) {
-        dprintk(NDEBUG_INTR, "scsi%d: in int routine, calling main\n", HOSTNO);
-        /* Put a call to NCR5380_main() on the queue... */
-        queue_main();
-    }
-    return IRQ_RETVAL(handled);
-}
-
-#ifdef NCR5380_STATS
-static void collect_stats(struct NCR5380_hostdata *hostdata,
-                          struct scsi_cmnd *cmd)
-{
-# ifdef NCR5380_STAT_LIMIT
-    if (scsi_bufflen(cmd) > NCR5380_STAT_LIMIT)
-# endif
-        switch (cmd->cmnd[0])
-        {
-            case WRITE:
-            case WRITE_6:
-            case WRITE_10:
-                hostdata->time_write[cmd->device->id] += (jiffies - hostdata->timebase);
-                /*hostdata->bytes_write[cmd->device->id] += scsi_bufflen(cmd);*/
-                hostdata->pendingw--;
-                break;
-            case READ:
-            case READ_6:
-            case READ_10:
-                hostdata->time_read[cmd->device->id] += (jiffies - hostdata->timebase);
-                /*hostdata->bytes_read[cmd->device->id] += scsi_bufflen(cmd);*/
-                hostdata->pendingr--;
-                break;
-        }
-}
-#endif
-
-/* 
- * Function : int NCR5380_select(struct Scsi_Host *instance,
- *                               struct scsi_cmnd *cmd, int tag);
- *
- * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
- *      including ARBITRATION, SELECTION, and initial message out for 
- *      IDENTIFY and queue messages. 
- *
- * Inputs : instance - instantiation of the 5380 driver on which this 
- *      target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for 
- *      new tag, TAG_NONE for untagged queueing, otherwise set to the tag for 
- *      the command that is presently connected.
- * 
- * Returns : -1 if selection could not execute for some reason,
- *      0 if selection succeeded or failed because the target 
- *      did not respond.
- *
- * Side effects : 
- *      If bus busy, arbitration failed, etc, NCR5380_select() will exit 
- *              with registers as they should have been on entry - ie
- *              SELECT_ENABLE will be set appropriately, the NCR5380
- *              will cease to drive any SCSI bus signals.
- *
- *      If successful : I_T_L or I_T_L_Q nexus will be established, 
- *              instance->connected will be set to cmd.  
- *              SELECT interrupt will be disabled.
- *
- *      If failed (no target) : cmd->scsi_done() will be called, and the 
- *              cmd->result host byte set to DID_BAD_TARGET.
- */
-
-static int NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd,
-                          int tag)
-{
-    SETUP_HOSTDATA(instance);
-    unsigned char tmp[3], phase;
-    unsigned char *data;
-    int len;
-    unsigned long timeout;
-    unsigned long flags;
-
-    hostdata->restart_select = 0;
-    NCR5380_dprint(NDEBUG_ARBITRATION, instance);
-    dprintk(NDEBUG_ARBITRATION, "scsi%d: starting arbitration, id = %d\n", HOSTNO,
-               instance->this_id);
-
-    /* 
-     * Set the phase bits to 0, otherwise the NCR5380 won't drive the 
-     * data bus during SELECTION.
-     */
-
-    local_irq_save(flags);
-    if (hostdata->connected) {
-        local_irq_restore(flags);
-        return -1;
-    }
-    NCR5380_write(TARGET_COMMAND_REG, 0);
-
-
-    /* 
-     * Start arbitration.
-     */
-    
-    NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
-    NCR5380_write(MODE_REG, MR_ARBITRATE);
-
-    local_irq_restore(flags);
-
-    /* Wait for arbitration logic to complete */
-#ifdef NCR_TIMEOUT
-    {
-      unsigned long timeout = jiffies + 2*NCR_TIMEOUT;
-
-      while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS)
-           && time_before(jiffies, timeout) && !hostdata->connected)
-        ;
-      if (time_after_eq(jiffies, timeout))
-      {
-        printk("scsi : arbitration timeout at %d\n", __LINE__);
-        NCR5380_write(MODE_REG, MR_BASE);
-        NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-        return -1;
-      }
-    }
-#else /* NCR_TIMEOUT */
-    while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS)
-         && !hostdata->connected);
-#endif
-
-    dprintk(NDEBUG_ARBITRATION, "scsi%d: arbitration complete\n", HOSTNO);
-
-    if (hostdata->connected) {
-        NCR5380_write(MODE_REG, MR_BASE); 
-        return -1;
-    }
-    /* 
-     * The arbitration delay is 2.2us, but this is a minimum and there is 
-     * no maximum so we can safely sleep for ceil(2.2) usecs to accommodate
-     * the integral nature of udelay().
-     *
-     */
-
-    udelay(3);
-
-    /* Check for lost arbitration */
-    if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
-        (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
-        (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
-        hostdata->connected) {
-        NCR5380_write(MODE_REG, MR_BASE); 
-        dprintk(NDEBUG_ARBITRATION, "scsi%d: lost arbitration, deasserting MR_ARBITRATE\n",
-                   HOSTNO);
-        return -1;
-    }
-
-     /* after/during arbitration, BSY should be asserted.
-        IBM DPES-31080 Version S31Q works now */
-     /* Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman) */
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_SEL |
-                                         ICR_ASSERT_BSY ) ;
-    
-    if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
-        hostdata->connected) {
-        NCR5380_write(MODE_REG, MR_BASE);
-        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-        dprintk(NDEBUG_ARBITRATION, "scsi%d: lost arbitration, deasserting ICR_ASSERT_SEL\n",
-                   HOSTNO);
-        return -1;
-    }
-
-    /* 
-     * Again, bus clear + bus settle time is 1.2us, however, this is 
-     * a minimum so we'll udelay ceil(1.2)
-     */
-
-#ifdef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
-    /* ++roman: But some targets (see above :-) seem to need a bit more... */
-    udelay(15);
-#else
-    udelay(2);
-#endif
-    
-    if (hostdata->connected) {
-        NCR5380_write(MODE_REG, MR_BASE);
-        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-        return -1;
-    }
-
-    dprintk(NDEBUG_ARBITRATION, "scsi%d: won arbitration\n", HOSTNO);
-
-    /* 
-     * Now that we have won arbitration, start Selection process, asserting 
-     * the host and target ID's on the SCSI bus.
-     */
-
-    NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->device->id)));
-
-    /* 
-     * Raise ATN while SEL is true before BSY goes false from arbitration,
-     * since this is the only way to guarantee that we'll get a MESSAGE OUT
-     * phase immediately after selection.
-     */
-
-    NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY | 
-        ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL ));
-    NCR5380_write(MODE_REG, MR_BASE);
-
-    /* 
-     * Reselect interrupts must be turned off prior to the dropping of BSY,
-     * otherwise we will trigger an interrupt.
-     */
-
-    if (hostdata->connected) {
-        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-        return -1;
-    }
-
-    NCR5380_write(SELECT_ENABLE_REG, 0);
-
-    /*
-     * The initiator shall then wait at least two deskew delays and release 
-     * the BSY signal.
-     */
-    udelay(1);        /* wingel -- wait two bus deskew delay >2*45ns */
-
-    /* Reset BSY */
-    NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA | 
-        ICR_ASSERT_ATN | ICR_ASSERT_SEL));
-
-    /* 
-     * Something weird happens when we cease to drive BSY - looks
-     * like the board/chip is letting us do another read before the 
-     * appropriate propagation delay has expired, and we're confusing
-     * a BSY signal from ourselves as the target's response to SELECTION.
-     *
-     * A small delay (the 'C++' frontend breaks the pipeline with an
-     * unnecessary jump, making it work on my 386-33/Trantor T128, the
-     * tighter 'C' code breaks and requires this) solves the problem - 
-     * the 1 us delay is arbitrary, and only used because this delay will 
-     * be the same on other platforms and since it works here, it should 
-     * work there.
-     *
-     * wingel suggests that this could be due to failing to wait
-     * one deskew delay.
-     */
-
-    udelay(1);
-
-    dprintk(NDEBUG_SELECTION, "scsi%d: selecting target %d\n", HOSTNO, cmd->device->id);
-
-    /* 
-     * The SCSI specification calls for a 250 ms timeout for the actual 
-     * selection.
-     */
-
-    timeout = jiffies + 25; 
-
-    /* 
-     * XXX very interesting - we're seeing a bounce where the BSY we 
-     * asserted is being reflected / still asserted (propagation delay?)
-     * and it's detecting as true.  Sigh.
-     */
-
-#if 0
-    /* ++roman: If a target conformed to the SCSI standard, it wouldn't assert
-     * IO while SEL is true. But again, there are some disks out the in the
-     * world that do that nevertheless. (Somebody claimed that this announces
-     * reselection capability of the target.) So we better skip that test and
-     * only wait for BSY... (Famous german words: Der Klügere gibt nach :-)
-     */
-
-    while (time_before(jiffies, timeout) && !(NCR5380_read(STATUS_REG) & 
-        (SR_BSY | SR_IO)));
-
-    if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == 
-            (SR_SEL | SR_IO)) {
-            NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-            NCR5380_reselect(instance);
-            printk (KERN_ERR "scsi%d: reselection after won arbitration?\n",
-                    HOSTNO);
-            NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-            return -1;
-    }
-#else
-    while (time_before(jiffies, timeout) && !(NCR5380_read(STATUS_REG) & SR_BSY));
-#endif
-
-    /* 
-     * No less than two deskew delays after the initiator detects the 
-     * BSY signal is true, it shall release the SEL signal and may 
-     * change the DATA BUS.                                     -wingel
-     */
-
-    udelay(1);
-
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
-
-    if (!(NCR5380_read(STATUS_REG) & SR_BSY)) {
-        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-        if (hostdata->targets_present & (1 << cmd->device->id)) {
-            printk(KERN_ERR "scsi%d: weirdness\n", HOSTNO);
-            if (hostdata->restart_select)
-                printk(KERN_NOTICE "\trestart select\n");
-            NCR5380_dprint(NDEBUG_ANY, instance);
-            NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-            return -1;
-        }
-        cmd->result = DID_BAD_TARGET << 16;
-#ifdef NCR5380_STATS
-        collect_stats(hostdata, cmd);
-#endif
-#ifdef SUPPORT_TAGS
-        cmd_free_tag( cmd );
-#endif
-        cmd->scsi_done(cmd);
-        NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-        dprintk(NDEBUG_SELECTION, "scsi%d: target did not respond within 250ms\n", HOSTNO);
-        NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-        return 0;
-    } 
-
-    hostdata->targets_present |= (1 << cmd->device->id);
-
-    /*
-     * Since we followed the SCSI spec, and raised ATN while SEL 
-     * was true but before BSY was false during selection, the information
-     * transfer phase should be a MESSAGE OUT phase so that we can send the
-     * IDENTIFY message.
-     * 
-     * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG
-     * message (2 bytes) with a tag ID that we increment with every command
-     * until it wraps back to 0.
-     *
-     * XXX - it turns out that there are some broken SCSI-II devices,
-     *       which claim to support tagged queuing but fail when more than
-     *       some number of commands are issued at once.
-     */
-
-    /* Wait for start of REQ/ACK handshake */
-    while (!(NCR5380_read(STATUS_REG) & SR_REQ));
-
-    dprintk(NDEBUG_SELECTION, "scsi%d: target %d selected, going into MESSAGE OUT phase.\n",
-               HOSTNO, cmd->device->id);
-    tmp[0] = IDENTIFY(1, cmd->device->lun);
-
-#ifdef SUPPORT_TAGS
-    if (cmd->tag != TAG_NONE) {
-        tmp[1] = hostdata->last_message = SIMPLE_QUEUE_TAG;
-        tmp[2] = cmd->tag;
-        len = 3;
-    } else 
-        len = 1;
-#else
-    len = 1;
-    cmd->tag=0;
-#endif /* SUPPORT_TAGS */
-
-    /* Send message(s) */
-    data = tmp;
-    phase = PHASE_MSGOUT;
-    NCR5380_transfer_pio(instance, &phase, &len, &data);
-    dprintk(NDEBUG_SELECTION, "scsi%d: nexus established.\n", HOSTNO);
-    /* XXX need to handle errors here */
-    hostdata->connected = cmd;
-#ifndef SUPPORT_TAGS
-    hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
-#endif    
-#ifdef SUN3_SCSI_VME
-    dregs->csr |= CSR_INTR;
-#endif
-    initialize_SCp(cmd);
-
-
-    return 0;
-}
-
-/* 
- * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance, 
- *      unsigned char *phase, int *count, unsigned char **data)
- *
- * Purpose : transfers data in given phase using polled I/O
- *
- * Inputs : instance - instance of driver, *phase - pointer to 
- *      what phase is expected, *count - pointer to number of 
- *      bytes to transfer, **data - pointer to data pointer.
- * 
- * Returns : -1 when different phase is entered without transferring
- *      maximum number of bytes, 0 if all bytes are transferred or exit
- *      is in same phase.
- *
- *      Also, *phase, *count, *data are modified in place.
- *
- * XXX Note : handling for bus free may be useful.
- */
-
-/*
- * Note : this code is not as quick as it could be, however it 
- * IS 100% reliable, and for the actual data transfer where speed
- * counts, we will always do a pseudo DMA or DMA transfer.
- */
-
-static int NCR5380_transfer_pio( struct Scsi_Host *instance, 
-                                 unsigned char *phase, int *count,
-                                 unsigned char **data)
-{
-    register unsigned char p = *phase, tmp;
-    register int c = *count;
-    register unsigned char *d = *data;
-
-    /* 
-     * The NCR5380 chip will only drive the SCSI bus when the 
-     * phase specified in the appropriate bits of the TARGET COMMAND
-     * REGISTER match the STATUS REGISTER
-     */
-
-    NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
-
-    do {
-        /* 
-         * Wait for assertion of REQ, after which the phase bits will be 
-         * valid 
-         */
-        while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ));
-
-        dprintk(NDEBUG_HANDSHAKE, "scsi%d: REQ detected\n", HOSTNO);
-
-        /* Check for phase mismatch */  
-        if ((tmp & PHASE_MASK) != p) {
-            dprintk(NDEBUG_PIO, "scsi%d: phase mismatch\n", HOSTNO);
-            NCR5380_dprint_phase(NDEBUG_PIO, instance);
-            break;
-        }
-
-        /* Do actual transfer from SCSI bus to / from memory */
-        if (!(p & SR_IO)) 
-            NCR5380_write(OUTPUT_DATA_REG, *d);
-        else 
-            *d = NCR5380_read(CURRENT_SCSI_DATA_REG);
-
-        ++d;
-
-        /* 
-         * The SCSI standard suggests that in MSGOUT phase, the initiator
-         * should drop ATN on the last byte of the message phase
-         * after REQ has been asserted for the handshake but before
-         * the initiator raises ACK.
-         */
-
-        if (!(p & SR_IO)) {
-            if (!((p & SR_MSG) && c > 1)) {
-                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
-                    ICR_ASSERT_DATA);
-                NCR5380_dprint(NDEBUG_PIO, instance);
-                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
-                        ICR_ASSERT_DATA | ICR_ASSERT_ACK);
-            } else {
-                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
-                    ICR_ASSERT_DATA | ICR_ASSERT_ATN);
-                NCR5380_dprint(NDEBUG_PIO, instance);
-                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
-                    ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
-            }
-        } else {
-            NCR5380_dprint(NDEBUG_PIO, instance);
-            NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
-        }
-
-        while (NCR5380_read(STATUS_REG) & SR_REQ);
-
-        dprintk(NDEBUG_HANDSHAKE, "scsi%d: req false, handshake complete\n", HOSTNO);
-
-/*
- * We have several special cases to consider during REQ/ACK handshaking : 
- * 1.  We were in MSGOUT phase, and we are on the last byte of the 
- *      message.  ATN must be dropped as ACK is dropped.
- *
- * 2.  We are in a MSGIN phase, and we are on the last byte of the  
- *      message.  We must exit with ACK asserted, so that the calling
- *      code may raise ATN before dropping ACK to reject the message.
- *
- * 3.  ACK and ATN are clear and the target may proceed as normal.
- */
-        if (!(p == PHASE_MSGIN && c == 1)) {  
-            if (p == PHASE_MSGOUT && c > 1)
-                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
-            else
-                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-        } 
-    } while (--c);
-
-    dprintk(NDEBUG_PIO, "scsi%d: residual %d\n", HOSTNO, c);
-
-    *count = c;
-    *data = d;
-    tmp = NCR5380_read(STATUS_REG);
-    /* The phase read from the bus is valid if either REQ is (already)
-     * asserted or if ACK hasn't been released yet. The latter is the case if
-     * we're in MSGIN and all wanted bytes have been received. */
-    if ((tmp & SR_REQ) || (p == PHASE_MSGIN && c == 0))
-        *phase = tmp & PHASE_MASK;
-    else 
-        *phase = PHASE_UNKNOWN;
-
-    if (!c || (*phase == p))
-        return 0;
-    else 
-        return -1;
-}
-
-/*
- * Function : do_abort (Scsi_Host *host)
- * 
- * Purpose : abort the currently established nexus.  Should only be 
- *      called from a routine which can drop into a 
- * 
- * Returns : 0 on success, -1 on failure.
- */
-
-static int do_abort (struct Scsi_Host *host) 
-{
-    unsigned char tmp, *msgptr, phase;
-    int len;
-
-    /* Request message out phase */
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
-
-    /* 
-     * Wait for the target to indicate a valid phase by asserting 
-     * REQ.  Once this happens, we'll have either a MSGOUT phase 
-     * and can immediately send the ABORT message, or we'll have some 
-     * other phase and will have to source/sink data.
-     * 
-     * We really don't care what value was on the bus or what value
-     * the target sees, so we just handshake.
-     */
-    
-    while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ));
-
-    NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
-
-    if ((tmp & PHASE_MASK) != PHASE_MSGOUT) {
-        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | 
-                      ICR_ASSERT_ACK);
-        while (NCR5380_read(STATUS_REG) & SR_REQ);
-        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
-    }
-   
-    tmp = ABORT;
-    msgptr = &tmp;
-    len = 1;
-    phase = PHASE_MSGOUT;
-    NCR5380_transfer_pio (host, &phase, &len, &msgptr);
-
-    /*
-     * If we got here, and the command completed successfully,
-     * we're about to go into bus free state.
-     */
-
-    return len ? -1 : 0;
-}
-
-#if defined(REAL_DMA)
-/* 
- * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance, 
- *      unsigned char *phase, int *count, unsigned char **data)
- *
- * Purpose : transfers data in given phase using either real
- *      or pseudo DMA.
- *
- * Inputs : instance - instance of driver, *phase - pointer to 
- *      what phase is expected, *count - pointer to number of 
- *      bytes to transfer, **data - pointer to data pointer.
- * 
- * Returns : -1 when different phase is entered without transferring
- *      maximum number of bytes, 0 if all bytes or transferred or exit
- *      is in same phase.
- *
- *      Also, *phase, *count, *data are modified in place.
- *
- */
-
-
-static int NCR5380_transfer_dma( struct Scsi_Host *instance, 
-                                 unsigned char *phase, int *count,
-                                 unsigned char **data)
-{
-    SETUP_HOSTDATA(instance);
-    register int c = *count;
-    register unsigned char p = *phase;
-    unsigned long flags;
-
-    /* sanity check */
-    if(!sun3_dma_setup_done) {
-         printk("scsi%d: transfer_dma without setup!\n", HOSTNO);
-         BUG();
-    }
-    hostdata->dma_len = c;
-
-    dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
-               HOSTNO, (p & SR_IO) ? "reading" : "writing",
-               c, (p & SR_IO) ? "to" : "from", *data);
-
-    /* netbsd turns off ints here, why not be safe and do it too */
-    local_irq_save(flags);
-    
-    /* send start chain */
-    sun3scsi_dma_start(c, *data);
-    
-    if (p & SR_IO) {
-            NCR5380_write(TARGET_COMMAND_REG, 1);
-            NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-            NCR5380_write(INITIATOR_COMMAND_REG, 0);
-            NCR5380_write(MODE_REG, (NCR5380_read(MODE_REG) | MR_DMA_MODE | MR_ENABLE_EOP_INTR));
-            NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
-    } else {
-            NCR5380_write(TARGET_COMMAND_REG, 0);
-            NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-            NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_DATA);
-            NCR5380_write(MODE_REG, (NCR5380_read(MODE_REG) | MR_DMA_MODE | MR_ENABLE_EOP_INTR));
-            NCR5380_write(START_DMA_SEND_REG, 0);
-    }
-
-#ifdef SUN3_SCSI_VME
-    dregs->csr |= CSR_DMA_ENABLE;
-#endif
-
-    local_irq_restore(flags);
-
-    sun3_dma_active = 1;
-    return 0;
-}
-#endif /* defined(REAL_DMA) */
-
-/*
- * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
- *
- * Purpose : run through the various SCSI phases and do as the target 
- *      directs us to.  Operates on the currently connected command, 
- *      instance->connected.
- *
- * Inputs : instance, instance for which we are doing commands
- *
- * Side effects : SCSI things happen, the disconnected queue will be 
- *      modified if a command disconnects, *instance->connected will
- *      change.
- *
- * XXX Note : we need to watch for bus free or a reset condition here 
- *      to recover from an unexpected bus free condition.
- */
- 
-static void NCR5380_information_transfer (struct Scsi_Host *instance)
-{
-    SETUP_HOSTDATA(instance);
-    unsigned long flags;
-    unsigned char msgout = NOP;
-    int sink = 0;
-    int len;
-#if defined(REAL_DMA)
-    int transfersize;
-#endif
-    unsigned char *data;
-    unsigned char phase, tmp, extended_msg[10], old_phase=0xff;
-    struct scsi_cmnd *cmd = (struct scsi_cmnd *) hostdata->connected;
-
-#ifdef SUN3_SCSI_VME
-    dregs->csr |= CSR_INTR;
-#endif
-
-    while (1) {
-        tmp = NCR5380_read(STATUS_REG);
-        /* We only have a valid SCSI phase when REQ is asserted */
-        if (tmp & SR_REQ) {
-            phase = (tmp & PHASE_MASK); 
-            if (phase != old_phase) {
-                old_phase = phase;
-                NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
-            }
-
-            if(phase == PHASE_CMDOUT) {
-                    void *d;
-                    unsigned long count;
-
-                if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
-                        count = cmd->SCp.buffer->length;
-                        d = SGADDR(cmd->SCp.buffer);
-                } else {
-                        count = cmd->SCp.this_residual;
-                        d = cmd->SCp.ptr;
-                }
-#ifdef REAL_DMA
-                /* this command setup for dma yet? */
-                if((count > SUN3_DMA_MINSIZE) && (sun3_dma_setup_done
-                                                  != cmd))
-                {
-                        if (cmd->request->cmd_type == REQ_TYPE_FS) {
-                                sun3scsi_dma_setup(d, count,
-                                                   rq_data_dir(cmd->request));
-                                sun3_dma_setup_done = cmd;
-                        }
-                }
-#endif
-#ifdef SUN3_SCSI_VME
-                dregs->csr |= CSR_INTR;
-#endif
-            }
-
-            
-            if (sink && (phase != PHASE_MSGOUT)) {
-                NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
-
-                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | 
-                    ICR_ASSERT_ACK);
-                while (NCR5380_read(STATUS_REG) & SR_REQ);
-                NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
-                    ICR_ASSERT_ATN);
-                sink = 0;
-                continue;
-            }
-
-            switch (phase) {
-            case PHASE_DATAOUT:
-#if (NDEBUG & NDEBUG_NO_DATAOUT)
-                printk("scsi%d: NDEBUG_NO_DATAOUT set, attempted DATAOUT "
-                       "aborted\n", HOSTNO);
-                sink = 1;
-                do_abort(instance);
-                cmd->result = DID_ERROR  << 16;
-                cmd->scsi_done(cmd);
-                return;
-#endif
-            case PHASE_DATAIN:
-                /* 
-                 * If there is no room left in the current buffer in the
-                 * scatter-gather list, move onto the next one.
-                 */
-                if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
-                    ++cmd->SCp.buffer;
-                    --cmd->SCp.buffers_residual;
-                    cmd->SCp.this_residual = cmd->SCp.buffer->length;
-                    cmd->SCp.ptr = SGADDR(cmd->SCp.buffer);
-                    dprintk(NDEBUG_INFORMATION, "scsi%d: %d bytes and %d buffers left\n",
-                               HOSTNO, cmd->SCp.this_residual,
-                               cmd->SCp.buffers_residual);
-                }
-
-                /*
-                 * The preferred transfer method is going to be 
-                 * PSEUDO-DMA for systems that are strictly PIO,
-                 * since we can let the hardware do the handshaking.
-                 *
-                 * For this to work, we need to know the transfersize
-                 * ahead of time, since the pseudo-DMA code will sit
-                 * in an unconditional loop.
-                 */
-
-/* ++roman: I suggest, this should be
- *   #if def(REAL_DMA)
- * instead of leaving REAL_DMA out.
- */
-
-#if defined(REAL_DMA)
-//              if (!cmd->device->borken &&
-                if((transfersize =
-                    NCR5380_dma_xfer_len(instance,cmd,phase)) > SUN3_DMA_MINSIZE) {
-                    len = transfersize;
-                    cmd->SCp.phase = phase;
-
-                    if (NCR5380_transfer_dma(instance, &phase,
-                        &len, (unsigned char **) &cmd->SCp.ptr)) {
-                        /*
-                         * If the watchdog timer fires, all future
-                         * accesses to this device will use the
-                         * polled-IO. */ 
-                        printk(KERN_NOTICE "scsi%d: switching target %d "
-                               "lun %llu to slow handshake\n", HOSTNO,
-                               cmd->device->id, cmd->device->lun);
-                        cmd->device->borken = 1;
-                        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
-                            ICR_ASSERT_ATN);
-                        sink = 1;
-                        do_abort(instance);
-                        cmd->result = DID_ERROR  << 16;
-                        cmd->scsi_done(cmd);
-                        /* XXX - need to source or sink data here, as appropriate */
-                    } else {
-#ifdef REAL_DMA
-                        /* ++roman: When using real DMA,
-                         * information_transfer() should return after
-                         * starting DMA since it has nothing more to
-                         * do.
-                         */
-                                    return;
-#else                   
-                        cmd->SCp.this_residual -= transfersize - len;
-#endif
-                    }
-                } else 
-#endif /* defined(REAL_DMA) */
-                  NCR5380_transfer_pio(instance, &phase, 
-                    (int *) &cmd->SCp.this_residual, (unsigned char **)
-                    &cmd->SCp.ptr);
-#ifdef REAL_DMA
-                /* if we had intended to dma that command clear it */
-                if(sun3_dma_setup_done == cmd)
-                        sun3_dma_setup_done = NULL;
-#endif
-
-                break;
-            case PHASE_MSGIN:
-                len = 1;
-                data = &tmp;
-                NCR5380_write(SELECT_ENABLE_REG, 0);    /* disable reselects */
-                NCR5380_transfer_pio(instance, &phase, &len, &data);
-                cmd->SCp.Message = tmp;
-                
-                switch (tmp) {
-                /*
-                 * Linking lets us reduce the time required to get the 
-                 * next command out to the device, hopefully this will
-                 * mean we don't waste another revolution due to the delays
-                 * required by ARBITRATION and another SELECTION.
-                 *
-                 * In the current implementation proposal, low level drivers
-                 * merely have to start the next command, pointed to by 
-                 * next_link, done() is called as with unlinked commands.
-                 */
-#ifdef LINKED
-                case LINKED_CMD_COMPLETE:
-                case LINKED_FLG_CMD_COMPLETE:
-                    /* Accept message by clearing ACK */
-                    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-                    
-                    dprintk(NDEBUG_LINKED, "scsi%d: target %d lun %llu linked command "
-                               "complete.\n", HOSTNO, cmd->device->id, cmd->device->lun);
-
-                    /* Enable reselect interrupts */
-                    NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-                    /*
-                     * Sanity check : A linked command should only terminate
-                     * with one of these messages if there are more linked
-                     * commands available.
-                     */
-
-                    if (!cmd->next_link) {
-                         printk(KERN_NOTICE "scsi%d: target %d lun %llu "
-                                "linked command complete, no next_link\n",
-                                HOSTNO, cmd->device->id, cmd->device->lun);
-                            sink = 1;
-                            do_abort (instance);
-                            return;
-                    }
-
-                    initialize_SCp(cmd->next_link);
-                    /* The next command is still part of this process; copy it
-                     * and don't free it! */
-                    cmd->next_link->tag = cmd->tag;
-                    cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
-                    dprintk(NDEBUG_LINKED, "scsi%d: target %d lun %llu linked request "
-                               "done, calling scsi_done().\n",
-                               HOSTNO, cmd->device->id, cmd->device->lun);
-#ifdef NCR5380_STATS
-                    collect_stats(hostdata, cmd);
-#endif
-                    cmd->scsi_done(cmd);
-                    cmd = hostdata->connected;
-                    break;
-#endif /* def LINKED */
-                case ABORT:
-                case COMMAND_COMPLETE: 
-                    /* Accept message by clearing ACK */
-                    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-                    hostdata->connected = NULL;
-                    dprintk(NDEBUG_QUEUES, "scsi%d: command for target %d, lun %llu "
-                              "completed\n", HOSTNO, cmd->device->id, cmd->device->lun);
-#ifdef SUPPORT_TAGS
-                    cmd_free_tag( cmd );
-                    if (status_byte(cmd->SCp.Status) == QUEUE_FULL) {
-                        /* Turn a QUEUE FULL status into BUSY, I think the
-                         * mid level cannot handle QUEUE FULL :-( (The
-                         * command is retried after BUSY). Also update our
-                         * queue size to the number of currently issued
-                         * commands now.
-                         */
-                        /* ++Andreas: the mid level code knows about
-                           QUEUE_FULL now. */
-                        TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun];
-                        dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu returned "
-                                   "QUEUE_FULL after %d commands\n",
-                                   HOSTNO, cmd->device->id, cmd->device->lun,
-                                   ta->nr_allocated);
-                        if (ta->queue_size > ta->nr_allocated)
-                            ta->nr_allocated = ta->queue_size;
-                    }
-#else
-                    hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
-#endif
-                    /* Enable reselect interrupts */
-                    NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-
-                    /* 
-                     * I'm not sure what the correct thing to do here is : 
-                     * 
-                     * If the command that just executed is NOT a request 
-                     * sense, the obvious thing to do is to set the result
-                     * code to the values of the stored parameters.
-                     * 
-                     * If it was a REQUEST SENSE command, we need some way to
-                     * differentiate between the failure code of the original
-                     * and the failure code of the REQUEST sense - the obvious
-                     * case is success, where we fall through and leave the
-                     * result code unchanged.
-                     * 
-                     * The non-obvious place is where the REQUEST SENSE failed
-                     */
-
-                    if (cmd->cmnd[0] != REQUEST_SENSE) 
-                        cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
-                    else if (status_byte(cmd->SCp.Status) != GOOD)
-                        cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
-                    
-#ifdef AUTOSENSE
-                    if ((cmd->cmnd[0] == REQUEST_SENSE) &&
-                                                hostdata->ses.cmd_len) {
-                        scsi_eh_restore_cmnd(cmd, &hostdata->ses);
-                        hostdata->ses.cmd_len = 0 ;
-                    }
-
-                    if ((cmd->cmnd[0] != REQUEST_SENSE) && 
-                        (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
-                        scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
-                        dprintk(NDEBUG_AUTOSENSE, "scsi%d: performing request sense\n",
-                                    HOSTNO);
-                        /* this is initialized from initialize_SCp 
-                        cmd->SCp.buffer = NULL;
-                        cmd->SCp.buffers_residual = 0;
-                        */
-
-                        local_irq_save(flags);
-                        LIST(cmd,hostdata->issue_queue);
-                        SET_NEXT(cmd, hostdata->issue_queue);
-                        hostdata->issue_queue = (struct scsi_cmnd *) cmd;
-                        local_irq_restore(flags);
-                        dprintk(NDEBUG_QUEUES, "scsi%d: REQUEST SENSE added to head of "
-                                  "issue queue\n", H_NO(cmd));
-                   } else
-#endif /* def AUTOSENSE */
-                   {
-#ifdef NCR5380_STATS
-                       collect_stats(hostdata, cmd);
-#endif
-                       cmd->scsi_done(cmd);
-                    }
-
-                    NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-                    /* 
-                     * Restore phase bits to 0 so an interrupted selection, 
-                     * arbitration can resume.
-                     */
-                    NCR5380_write(TARGET_COMMAND_REG, 0);
-                    
-                    while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
-                        barrier();
-
-                    return;
-                case MESSAGE_REJECT:
-                    /* Accept message by clearing ACK */
-                    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-                    /* Enable reselect interrupts */
-                    NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-                    switch (hostdata->last_message) {
-                    case HEAD_OF_QUEUE_TAG:
-                    case ORDERED_QUEUE_TAG:
-                    case SIMPLE_QUEUE_TAG:
-                        /* The target obviously doesn't support tagged
-                         * queuing, even though it announced this ability in
-                         * its INQUIRY data ?!? (maybe only this LUN?) Ok,
-                         * clear 'tagged_supported' and lock the LUN, since
-                         * the command is treated as untagged further on.
-                         */
-                        cmd->device->tagged_supported = 0;
-                        hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
-                        cmd->tag = TAG_NONE;
-                        dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu rejected "
-                                   "QUEUE_TAG message; tagged queuing "
-                                   "disabled\n",
-                                   HOSTNO, cmd->device->id, cmd->device->lun);
-                        break;
-                    }
-                    break;
-                case DISCONNECT:
-                    /* Accept message by clearing ACK */
-                    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-                    local_irq_save(flags);
-                    cmd->device->disconnect = 1;
-                    LIST(cmd,hostdata->disconnected_queue);
-                    SET_NEXT(cmd, hostdata->disconnected_queue);
-                    hostdata->connected = NULL;
-                    hostdata->disconnected_queue = cmd;
-                    local_irq_restore(flags);
-                    dprintk(NDEBUG_QUEUES, "scsi%d: command for target %d lun %llu was "
-                              "moved from connected to the "
-                              "disconnected_queue\n", HOSTNO, 
-                              cmd->device->id, cmd->device->lun);
-                    /* 
-                     * Restore phase bits to 0 so an interrupted selection, 
-                     * arbitration can resume.
-                     */
-                    NCR5380_write(TARGET_COMMAND_REG, 0);
-
-                    /* Enable reselect interrupts */
-                    NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-                    /* Wait for bus free to avoid nasty timeouts */
-                    while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
-                        barrier();
-#ifdef SUN3_SCSI_VME
-                    dregs->csr |= CSR_DMA_ENABLE;
-#endif
-                    return;
-                /* 
-                 * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
-                 * operation, in violation of the SCSI spec so we can safely 
-                 * ignore SAVE/RESTORE pointers calls.
-                 *
-                 * Unfortunately, some disks violate the SCSI spec and 
-                 * don't issue the required SAVE_POINTERS message before
-                 * disconnecting, and we have to break spec to remain 
-                 * compatible.
-                 */
-                case SAVE_POINTERS:
-                case RESTORE_POINTERS:
-                    /* Accept message by clearing ACK */
-                    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-                    /* Enable reselect interrupts */
-                    NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-                    break;
-                case EXTENDED_MESSAGE:
-/* 
- * Extended messages are sent in the following format :
- * Byte         
- * 0            EXTENDED_MESSAGE == 1
- * 1            length (includes one byte for code, doesn't 
- *              include first two bytes)
- * 2            code
- * 3..length+1  arguments
- *
- * Start the extended message buffer with the EXTENDED_MESSAGE
- * byte, since spi_print_msg() wants the whole thing.  
- */
-                    extended_msg[0] = EXTENDED_MESSAGE;
-                    /* Accept first byte by clearing ACK */
-                    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-
-                    dprintk(NDEBUG_EXTENDED, "scsi%d: receiving extended message\n", HOSTNO);
-
-                    len = 2;
-                    data = extended_msg + 1;
-                    phase = PHASE_MSGIN;
-                    NCR5380_transfer_pio(instance, &phase, &len, &data);
-                    dprintk(NDEBUG_EXTENDED, "scsi%d: length=%d, code=0x%02x\n", HOSTNO,
-                               (int)extended_msg[1], (int)extended_msg[2]);
-
-                    if (!len && extended_msg[1] <= 
-                        (sizeof (extended_msg) - 1)) {
-                        /* Accept third byte by clearing ACK */
-                        NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-                        len = extended_msg[1] - 1;
-                        data = extended_msg + 3;
-                        phase = PHASE_MSGIN;
-
-                        NCR5380_transfer_pio(instance, &phase, &len, &data);
-                        dprintk(NDEBUG_EXTENDED, "scsi%d: message received, residual %d\n",
-                                   HOSTNO, len);
-
-                        switch (extended_msg[2]) {
-                        case EXTENDED_SDTR:
-                        case EXTENDED_WDTR:
-                        case EXTENDED_MODIFY_DATA_POINTER:
-                        case EXTENDED_EXTENDED_IDENTIFY:
-                            tmp = 0;
-                        }
-                    } else if (len) {
-                        printk(KERN_NOTICE "scsi%d: error receiving "
-                               "extended message\n", HOSTNO);
-                        tmp = 0;
-                    } else {
-                        printk(KERN_NOTICE "scsi%d: extended message "
-                               "code %02x length %d is too long\n",
-                               HOSTNO, extended_msg[2], extended_msg[1]);
-                        tmp = 0;
-                    }
-                /* Fall through to reject message */
-
-                /* 
-                 * If we get something weird that we aren't expecting, 
-                 * reject it.
-                 */
-                default:
-                    if (!tmp) {
-                        printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO);
-                        spi_print_msg(extended_msg);
-                        printk("\n");
-                    } else if (tmp != EXTENDED_MESSAGE)
-                        printk(KERN_DEBUG "scsi%d: rejecting unknown "
-                               "message %02x from target %d, lun %llu\n",
-                               HOSTNO, tmp, cmd->device->id, cmd->device->lun);
-                    else
-                        printk(KERN_DEBUG "scsi%d: rejecting unknown "
-                               "extended message "
-                               "code %02x, length %d from target %d, lun %llu\n",
-                               HOSTNO, extended_msg[1], extended_msg[0],
-                               cmd->device->id, cmd->device->lun);
-   
-
-                    msgout = MESSAGE_REJECT;
-                    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
-                        ICR_ASSERT_ATN);
-                    break;
-                } /* switch (tmp) */
-                break;
-            case PHASE_MSGOUT:
-                len = 1;
-                data = &msgout;
-                hostdata->last_message = msgout;
-                NCR5380_transfer_pio(instance, &phase, &len, &data);
-                if (msgout == ABORT) {
-#ifdef SUPPORT_TAGS
-                    cmd_free_tag( cmd );
-#else
-                    hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
-#endif
-                    hostdata->connected = NULL;
-                    cmd->result = DID_ERROR << 16;
-#ifdef NCR5380_STATS
-                    collect_stats(hostdata, cmd);
-#endif
-                    cmd->scsi_done(cmd);
-                    NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
-                    return;
-                }
-                msgout = NOP;
-                break;
-            case PHASE_CMDOUT:
-                len = cmd->cmd_len;
-                data = cmd->cmnd;
-                /* 
-                 * XXX for performance reasons, on machines with a 
-                 * PSEUDO-DMA architecture we should probably 
-                 * use the dma transfer function.  
-                 */
-                NCR5380_transfer_pio(instance, &phase, &len, 
-                    &data);
-                break;
-            case PHASE_STATIN:
-                len = 1;
-                data = &tmp;
-                NCR5380_transfer_pio(instance, &phase, &len, &data);
-                cmd->SCp.Status = tmp;
-                break;
-            default:
-                printk("scsi%d: unknown phase\n", HOSTNO);
-                NCR5380_dprint(NDEBUG_ANY, instance);
-            } /* switch(phase) */
-        } /* if (tmp * SR_REQ) */ 
-    } /* while (1) */
-}
-
-/*
- * Function : void NCR5380_reselect (struct Scsi_Host *instance)
- *
- * Purpose : does reselection, initializing the instance->connected 
- *      field to point to the struct scsi_cmnd for which the I_T_L or I_T_L_Q
- *      nexus has been reestablished,
- *      
- * Inputs : instance - this instance of the NCR5380.
- *
- */
-
-/* it might eventually prove necessary to do a dma setup on
-   reselection, but it doesn't seem to be needed now -- sam */
-
-static void NCR5380_reselect (struct Scsi_Host *instance)
-{
-    SETUP_HOSTDATA(instance);
-    unsigned char target_mask;
-    unsigned char lun;
-#ifdef SUPPORT_TAGS
-    unsigned char tag;
-#endif
-    unsigned char msg[3];
-    struct scsi_cmnd *tmp = NULL, *prev;
-/*    unsigned long flags; */
-
-    /*
-     * Disable arbitration, etc. since the host adapter obviously
-     * lost, and tell an interrupted NCR5380_select() to restart.
-     */
-
-    NCR5380_write(MODE_REG, MR_BASE);
-    hostdata->restart_select = 1;
-
-    target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
-
-    dprintk(NDEBUG_RESELECTION, "scsi%d: reselect\n", HOSTNO);
-
-    /* 
-     * At this point, we have detected that our SCSI ID is on the bus,
-     * SEL is true and BSY was false for at least one bus settle delay
-     * (400 ns).
-     *
-     * We must assert BSY ourselves, until the target drops the SEL
-     * signal.
-     */
-
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
-    
-    while (NCR5380_read(STATUS_REG) & SR_SEL);
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-
-    /*
-     * Wait for target to go into MSGIN.
-     */
-
-    while (!(NCR5380_read(STATUS_REG) & SR_REQ));
-
-#if 1
-    // acknowledge toggle to MSGIN
-    NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(PHASE_MSGIN));
-
-    // peek at the byte without really hitting the bus
-    msg[0] = NCR5380_read(CURRENT_SCSI_DATA_REG);
-#endif
-
-    if (!(msg[0] & 0x80)) {
-        printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO);
-        spi_print_msg(msg);
-        do_abort(instance);
-        return;
-    }
-    lun = (msg[0] & 0x07);
-
-    /* 
-     * Find the command corresponding to the I_T_L or I_T_L_Q  nexus we 
-     * just reestablished, and remove it from the disconnected queue.
-     */
-
-    for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL;
-         tmp; prev = tmp, tmp = NEXT(tmp) ) {
-        if ((target_mask == (1 << tmp->device->id)) && (lun == tmp->device->lun)
-#ifdef SUPPORT_TAGS
-            && (tag == tmp->tag) 
-#endif
-            ) {
-            if (prev) {
-                REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
-                SET_NEXT(prev, NEXT(tmp));
-            } else {
-                REMOVE(-1, hostdata->disconnected_queue, tmp, NEXT(tmp));
-                hostdata->disconnected_queue = NEXT(tmp);
-            }
-            SET_NEXT(tmp, NULL);
-            break;
-        }
-    }
-    
-    if (!tmp) {
-        printk(KERN_WARNING "scsi%d: warning: target bitmask %02x lun %d "
-#ifdef SUPPORT_TAGS
-                "tag %d "
-#endif
-                "not in disconnected_queue.\n",
-                HOSTNO, target_mask, lun
-#ifdef SUPPORT_TAGS
-                , tag
-#endif
-                );
-        /* 
-         * Since we have an established nexus that we can't do anything
-         * with, we must abort it.  
-         */
-        do_abort(instance);
-        return;
-    }
-#if 1
-    /* engage dma setup for the command we just saw */
-    {
-            void *d;
-            unsigned long count;
-
-            if (!tmp->SCp.this_residual && tmp->SCp.buffers_residual) {
-                    count = tmp->SCp.buffer->length;
-                    d = SGADDR(tmp->SCp.buffer);
-            } else {
-                    count = tmp->SCp.this_residual;
-                    d = tmp->SCp.ptr;
-            }
-#ifdef REAL_DMA
-            /* setup this command for dma if not already */
-            if((count > SUN3_DMA_MINSIZE) && (sun3_dma_setup_done != tmp))
-            {
-                    sun3scsi_dma_setup(d, count, rq_data_dir(tmp->request));
-                    sun3_dma_setup_done = tmp;
-            }
-#endif
-    }
-#endif
-
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
-    /* Accept message by clearing ACK */
-    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
-
-#ifdef SUPPORT_TAGS
-    /* If the phase is still MSGIN, the target wants to send some more
-     * messages. In case it supports tagged queuing, this is probably a
-     * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
-     */
-    tag = TAG_NONE;
-    if (phase == PHASE_MSGIN && setup_use_tagged_queuing) {
-        /* Accept previous IDENTIFY message by clearing ACK */
-        NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE );
-        len = 2;
-        data = msg+1;
-        if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
-            msg[1] == SIMPLE_QUEUE_TAG)
-            tag = msg[2];
-        dprintk(NDEBUG_TAGS, "scsi%d: target mask %02x, lun %d sent tag %d at "
-                   "reselection\n", HOSTNO, target_mask, lun, tag);
-    }
-#endif
-    
-    hostdata->connected = tmp;
-    dprintk(NDEBUG_RESELECTION, "scsi%d: nexus established, target = %d, lun = %llu, tag = %d\n",
-               HOSTNO, tmp->device->id, tmp->device->lun, tmp->tag);
-}
-
-
-/*
- * Function : int NCR5380_abort(struct scsi_cmnd *cmd)
- *
- * Purpose : abort a command
- *
- * Inputs : cmd - the struct scsi_cmnd to abort, code - code to set the
- *      host byte of the result field to, if zero DID_ABORTED is 
- *      used.
- *
- * Returns : 0 - success, -1 on failure.
- *
- * XXX - there is no way to abort the command that is currently 
- *       connected, you have to wait for it to complete.  If this is 
- *       a problem, we could implement longjmp() / setjmp(), setjmp()
- *       called where the loop started in NCR5380_main().
- */
-
-static int NCR5380_abort(struct scsi_cmnd *cmd)
-{
-    struct Scsi_Host *instance = cmd->device->host;
-    SETUP_HOSTDATA(instance);
-    struct scsi_cmnd *tmp, **prev;
-    unsigned long flags;
-
-    printk(KERN_NOTICE "scsi%d: aborting command\n", HOSTNO);
-    scsi_print_command(cmd);
-
-    NCR5380_print_status (instance);
-
-    local_irq_save(flags);
-    
-    dprintk(NDEBUG_ABORT, "scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO,
-                NCR5380_read(BUS_AND_STATUS_REG),
-                NCR5380_read(STATUS_REG));
-
-#if 1
-/* 
- * Case 1 : If the command is the currently executing command, 
- * we'll set the aborted flag and return control so that 
- * information transfer routine can exit cleanly.
- */
-
-    if (hostdata->connected == cmd) {
-
-        dprintk(NDEBUG_ABORT, "scsi%d: aborting connected command\n", HOSTNO);
-/*
- * We should perform BSY checking, and make sure we haven't slipped
- * into BUS FREE.
- */
-
-/*      NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN); */
-/* 
- * Since we can't change phases until we've completed the current 
- * handshake, we have to source or sink a byte of data if the current
- * phase is not MSGOUT.
- */
-
-/* 
- * Return control to the executing NCR drive so we can clear the
- * aborted flag and get back into our main loop.
- */ 
-
-        if (do_abort(instance) == 0) {
-          hostdata->aborted = 1;
-          hostdata->connected = NULL;
-          cmd->result = DID_ABORT << 16;
-#ifdef SUPPORT_TAGS
-          cmd_free_tag( cmd );
-#else
-          hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
-#endif
-          local_irq_restore(flags);
-          cmd->scsi_done(cmd);
-          return SUCCESS;
-        } else {
-/*        local_irq_restore(flags); */
-          printk("scsi%d: abort of connected command failed!\n", HOSTNO);
-          return FAILED;
-        } 
-   }
-#endif
-
-/* 
- * Case 2 : If the command hasn't been issued yet, we simply remove it 
- *          from the issue queue.
- */
-    for (prev = (struct scsi_cmnd **) &(hostdata->issue_queue),
-        tmp = (struct scsi_cmnd *) hostdata->issue_queue;
-        tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp))
-        if (cmd == tmp) {
-            REMOVE(5, *prev, tmp, NEXT(tmp));
-            (*prev) = NEXT(tmp);
-            SET_NEXT(tmp, NULL);
-            tmp->result = DID_ABORT << 16;
-            local_irq_restore(flags);
-            dprintk(NDEBUG_ABORT, "scsi%d: abort removed command from issue queue.\n",
-                        HOSTNO);
-            /* Tagged queuing note: no tag to free here, hasn't been assigned
-             * yet... */
-            tmp->scsi_done(tmp);
-            return SUCCESS;
-        }
-
-/* 
- * Case 3 : If any commands are connected, we're going to fail the abort
- *          and let the high level SCSI driver retry at a later time or 
- *          issue a reset.
- *
- *          Timeouts, and therefore aborted commands, will be highly unlikely
- *          and handling them cleanly in this situation would make the common
- *          case of noresets less efficient, and would pollute our code.  So,
- *          we fail.
- */
-
-    if (hostdata->connected) {
-        local_irq_restore(flags);
-        dprintk(NDEBUG_ABORT, "scsi%d: abort failed, command connected.\n", HOSTNO);
-        return FAILED;
-    }
-
-/*
- * Case 4: If the command is currently disconnected from the bus, and 
- *      there are no connected commands, we reconnect the I_T_L or 
- *      I_T_L_Q nexus associated with it, go into message out, and send 
- *      an abort message.
- *
- * This case is especially ugly. In order to reestablish the nexus, we
- * need to call NCR5380_select().  The easiest way to implement this 
- * function was to abort if the bus was busy, and let the interrupt
- * handler triggered on the SEL for reselect take care of lost arbitrations
- * where necessary, meaning interrupts need to be enabled.
- *
- * When interrupts are enabled, the queues may change - so we 
- * can't remove it from the disconnected queue before selecting it
- * because that could cause a failure in hashing the nexus if that 
- * device reselected.
- * 
- * Since the queues may change, we can't use the pointers from when we
- * first locate it.
- *
- * So, we must first locate the command, and if NCR5380_select()
- * succeeds, then issue the abort, relocate the command and remove
- * it from the disconnected queue.
- */
-
-    for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp;
-         tmp = NEXT(tmp)) 
-        if (cmd == tmp) {
-            local_irq_restore(flags);
-            dprintk(NDEBUG_ABORT, "scsi%d: aborting disconnected command.\n", HOSTNO);
-  
-            if (NCR5380_select (instance, cmd, (int) cmd->tag)) 
-                return FAILED;
-
-            dprintk(NDEBUG_ABORT, "scsi%d: nexus reestablished.\n", HOSTNO);
-
-            do_abort (instance);
-
-            local_irq_save(flags);
-            for (prev = (struct scsi_cmnd **) &(hostdata->disconnected_queue),
-                tmp = (struct scsi_cmnd *) hostdata->disconnected_queue;
-                tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp) )
-                    if (cmd == tmp) {
-                    REMOVE(5, *prev, tmp, NEXT(tmp));
-                    *prev = NEXT(tmp);
-                    SET_NEXT(tmp, NULL);
-                    tmp->result = DID_ABORT << 16;
-                    /* We must unlock the tag/LUN immediately here, since the
-                     * target goes to BUS FREE and doesn't send us another
-                     * message (COMMAND_COMPLETE or the like)
-                     */
-#ifdef SUPPORT_TAGS
-                    cmd_free_tag( tmp );
-#else
-                    hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
-#endif
-                    local_irq_restore(flags);
-                    tmp->scsi_done(tmp);
-                    return SUCCESS;
-                }
-        }
-
-/*
- * Case 5 : If we reached this point, the command was not found in any of 
- *          the queues.
- *
- * We probably reached this point because of an unlikely race condition
- * between the command completing successfully and the abortion code,
- * so we won't panic, but we will notify the user in case something really
- * broke.
- */
-
-    local_irq_restore(flags);
-    printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully before abortion\n", HOSTNO); 
-
-    return FAILED;
-}
-
-
-/* 
- * Function : int NCR5380_bus_reset(struct scsi_cmnd *cmd)
- * 
- * Purpose : reset the SCSI bus.
- *
- * Returns : SUCCESS or FAILURE
- *
- */ 
-
-static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
-{
-    SETUP_HOSTDATA(cmd->device->host);
-    int           i;
-    unsigned long flags;
-#if defined(RESET_RUN_DONE)
-    struct scsi_cmnd *connected, *disconnected_queue;
-#endif
-
-
-    NCR5380_print_status (cmd->device->host);
-
-    /* get in phase */
-    NCR5380_write( TARGET_COMMAND_REG,
-                   PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) ));
-    /* assert RST */
-    NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST );
-    udelay (40);
-    /* reset NCR registers */
-    NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE );
-    NCR5380_write( MODE_REG, MR_BASE );
-    NCR5380_write( TARGET_COMMAND_REG, 0 );
-    NCR5380_write( SELECT_ENABLE_REG, 0 );
-    /* ++roman: reset interrupt condition! otherwise no interrupts don't get
-     * through anymore ... */
-    (void)NCR5380_read( RESET_PARITY_INTERRUPT_REG );
-
-        /* MSch 20140115 - looking at the generic NCR5380 driver, all of this
-         * should go.
-         * Catch-22: if we don't clear all queues, the SCSI driver lock will
-         * not be released by atari_scsi_reset()!
-         */
-
-#if defined(RESET_RUN_DONE)
-        /* XXX Should now be done by midlevel code, but it's broken XXX */
-        /* XXX see below                                            XXX */
-
-    /* MSch: old-style reset: actually abort all command processing here */
-
-    /* After the reset, there are no more connected or disconnected commands
-     * and no busy units; to avoid problems with re-inserting the commands
-     * into the issue_queue (via scsi_done()), the aborted commands are
-     * remembered in local variables first.
-     */
-    local_irq_save(flags);
-    connected = (struct scsi_cmnd *)hostdata->connected;
-    hostdata->connected = NULL;
-    disconnected_queue = (struct scsi_cmnd *)hostdata->disconnected_queue;
-    hostdata->disconnected_queue = NULL;
-#ifdef SUPPORT_TAGS
-    free_all_tags();
-#endif
-    for( i = 0; i < 8; ++i )
-        hostdata->busy[i] = 0;
-#ifdef REAL_DMA
-    hostdata->dma_len = 0;
-#endif
-    local_irq_restore(flags);
-
-    /* In order to tell the mid-level code which commands were aborted, 
-     * set the command status to DID_RESET and call scsi_done() !!!
-     * This ultimately aborts processing of these commands in the mid-level.
-     */
-
-    if ((cmd = connected)) {
-        dprintk(NDEBUG_ABORT, "scsi%d: reset aborted a connected command\n", H_NO(cmd));
-        cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
-        cmd->scsi_done( cmd );
-    }
-
-    for (i = 0; (cmd = disconnected_queue); ++i) {
-        disconnected_queue = NEXT(cmd);
-        SET_NEXT(cmd, NULL);
-        cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
-        cmd->scsi_done( cmd );
-    }
-    if (i > 0)
-        dprintk(NDEBUG_ABORT, "scsi: reset aborted %d disconnected command(s)\n", i);
-
-
-    /* since all commands have been explicitly terminated, we need to tell
-     * the midlevel code that the reset was SUCCESSFUL, and there is no 
-     * need to 'wake up' the commands by a request_sense
-     */
-    return SUCCESS;
-#else /* 1 */
-
-    /* MSch: new-style reset handling: let the mid-level do what it can */
-
-    /* ++guenther: MID-LEVEL IS STILL BROKEN.
-     * Mid-level is supposed to requeue all commands that were active on the
-     * various low-level queues. In fact it does this, but that's not enough
-     * because all these commands are subject to timeout. And if a timeout
-     * happens for any removed command, *_abort() is called but all queues
-     * are now empty. Abort then gives up the falcon lock, which is fatal,
-     * since the mid-level will queue more commands and must have the lock
-     * (it's all happening inside timer interrupt handler!!).
-     * Even worse, abort will return NOT_RUNNING for all those commands not
-     * on any queue, so they won't be retried ...
-     *
-     * Conclusion: either scsi.c disables timeout for all resetted commands
-     * immediately, or we lose!  As of linux-2.0.20 it doesn't.
-     */
-
-    /* After the reset, there are no more connected or disconnected commands
-     * and no busy units; so clear the low-level status here to avoid 
-     * conflicts when the mid-level code tries to wake up the affected 
-     * commands!
-     */
-
-    if (hostdata->issue_queue)
-        dprintk(NDEBUG_ABORT, "scsi%d: reset aborted issued command(s)\n", H_NO(cmd));
-    if (hostdata->connected) 
-        dprintk(NDEBUG_ABORT, "scsi%d: reset aborted a connected command\n", H_NO(cmd));
-    if (hostdata->disconnected_queue)
-        dprintk(NDEBUG_ABORT, "scsi%d: reset aborted disconnected command(s)\n", H_NO(cmd));
-
-    local_irq_save(flags);
-    hostdata->issue_queue = NULL;
-    hostdata->connected = NULL;
-    hostdata->disconnected_queue = NULL;
-#ifdef SUPPORT_TAGS
-    free_all_tags();
-#endif
-    for( i = 0; i < 8; ++i )
-        hostdata->busy[i] = 0;
-#ifdef REAL_DMA
-    hostdata->dma_len = 0;
-#endif
-    local_irq_restore(flags);
-
-    /* we did no complete reset of all commands, so a wakeup is required */
-    return SUCCESS;
-#endif /* 1 */
-}
-
-/* Local Variables: */
-/* tab-width: 8     */
-/* End:             */
diff --git a/drivers/scsi/sun3_scsi.c b/drivers/scsi/sun3_scsi.c
index 9707b7494a89..2a906d1d34ba 100644
--- a/drivers/scsi/sun3_scsi.c
+++ b/drivers/scsi/sun3_scsi.c
@@ -20,89 +20,58 @@
  * Generic Generic NCR5380 driver
  *
  * Copyright 1995, Russell King
- *
- * ALPHA RELEASE 1.
- *
- * For more information, please consult
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
-
-/*
- * This is from mac_scsi.h, but hey, maybe this is useful for Sun3 too! :)
- *
- * Options :
- *
- * PARITY - enable parity checking.  Not supported.
- *
- * SCSI2 - enable support for SCSI-II tagged queueing.  Untested.
- *
- * USLEEP - enable support for devices that don't disconnect.  Untested.
- */
-
-#define AUTOSENSE
-
 #include <linux/types.h>
-#include <linux/stddef.h>
-#include <linux/ctype.h>
 #include <linux/delay.h>
-
 #include <linux/module.h>
-#include <linux/signal.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
+#include <linux/platform_device.h>
 
 #include <asm/io.h>
-
-#include <asm/sun3ints.h>
 #include <asm/dvma.h>
-#include <asm/idprom.h>
-#include <asm/machines.h>
 
-/* dma on! */
-#define REAL_DMA
-
-#include "scsi.h"
 #include <scsi/scsi_host.h>
 #include "sun3_scsi.h"
-#include "NCR5380.h"
 
-extern int sun3_map_test(unsigned long, char *);
+/* Definitions for the core NCR5380 driver. */
 
-#define USE_WRAPPER
-/*#define RESET_BOOT */
-#define DRIVER_SETUP
+#define REAL_DMA
+/* #define SUPPORT_TAGS */
+/* minimum number of bytes to do dma on */
+#define DMA_MIN_SIZE                    129
 
-/*
- * BUG can be used to trigger a strange code-size related hang on 2.1 kernels
- */
-#ifdef BUG
-#undef RESET_BOOT
-#undef DRIVER_SETUP
-#endif
+/* #define MAX_TAGS                     32 */
 
-/* #define SUPPORT_TAGS */
+#define NCR5380_implementation_fields   /* none */
 
-#ifdef SUN3_SCSI_VME
-#define ENABLE_IRQ()
-#else
-#define ENABLE_IRQ()    enable_irq( IRQ_SUN3_SCSI ); 
-#endif
+#define NCR5380_read(reg)               sun3scsi_read(reg)
+#define NCR5380_write(reg, value)       sun3scsi_write(reg, value)
+
+#define NCR5380_queue_command           sun3scsi_queue_command
+#define NCR5380_bus_reset               sun3scsi_bus_reset
+#define NCR5380_abort                   sun3scsi_abort
+#define NCR5380_show_info               sun3scsi_show_info
+#define NCR5380_info                    sun3scsi_info
 
+#define NCR5380_dma_read_setup(instance, data, count) \
+        sun3scsi_dma_setup(data, count, 0)
+#define NCR5380_dma_write_setup(instance, data, count) \
+        sun3scsi_dma_setup(data, count, 1)
+#define NCR5380_dma_residual(instance) \
+        sun3scsi_dma_residual(instance)
+#define NCR5380_dma_xfer_len(instance, cmd, phase) \
+        sun3scsi_dma_xfer_len(cmd->SCp.this_residual, cmd, !((phase) & SR_IO))
 
-static irqreturn_t scsi_sun3_intr(int irq, void *dummy);
-static inline unsigned char sun3scsi_read(int reg);
-static inline void sun3scsi_write(int reg, int value);
+#define NCR5380_acquire_dma_irq(instance)    (1)
+#define NCR5380_release_dma_irq(instance)
+
+#include "NCR5380.h"
+
+
+extern int sun3_map_test(unsigned long, char *);
 
 static int setup_can_queue = -1;
 module_param(setup_can_queue, int, 0);
@@ -117,9 +86,7 @@ module_param(setup_use_tagged_queuing, int, 0);
 static int setup_hostid = -1;
 module_param(setup_hostid, int, 0);
 
-static struct scsi_cmnd *sun3_dma_setup_done = NULL;
-
-#define RESET_RUN_DONE
+/* #define RESET_BOOT */
 
 #define AFTER_RESET_DELAY       (HZ/2)
 
@@ -129,18 +96,15 @@ static struct scsi_cmnd *sun3_dma_setup_done = NULL;
 /* dvma buffer to allocate -- 32k should hopefully be more than sufficient */
 #define SUN3_DVMA_BUFSIZE 0xe000
 
-/* minimum number of bytes to do dma on */
-#define SUN3_DMA_MINSIZE 128
-
-static volatile unsigned char *sun3_scsi_regp;
+static struct scsi_cmnd *sun3_dma_setup_done;
+static unsigned char *sun3_scsi_regp;
 static volatile struct sun3_dma_regs *dregs;
-#ifndef SUN3_SCSI_VME
-static struct sun3_udc_regs *udc_regs = NULL;
-#endif
+static struct sun3_udc_regs *udc_regs;
 static unsigned char *sun3_dma_orig_addr = NULL;
 static unsigned long sun3_dma_orig_count = 0;
 static int sun3_dma_active = 0;
 static unsigned long last_residual = 0;
+static struct Scsi_Host *default_instance;
 
 /*
  * NCR 5380 register access functions
@@ -148,12 +112,12 @@ static unsigned long last_residual = 0;
 
 static inline unsigned char sun3scsi_read(int reg)
 {
-        return( sun3_scsi_regp[reg] );
+        return in_8(sun3_scsi_regp + reg);
 }
 
 static inline void sun3scsi_write(int reg, int value)
 {
-        sun3_scsi_regp[reg] = value;
+        out_8(sun3_scsi_regp + reg, value);
 }
 
 #ifndef SUN3_SCSI_VME
@@ -180,213 +144,10 @@ static inline void sun3_udc_write(unsigned short val, unsigned char reg)
 }
 #endif
 
-/*
- * XXX: status debug
- */
-static struct Scsi_Host *default_instance;
-
-/*
- * Function : int sun3scsi_detect(struct scsi_host_template * tpnt)
- *
- * Purpose : initializes mac NCR5380 driver based on the
- *      command line / compile time port and irq definitions.
- *
- * Inputs : tpnt - template for this SCSI adapter.
- *
- * Returns : 1 if a host adapter was found, 0 if not.
- *
- */
- 
-static int __init sun3scsi_detect(struct scsi_host_template *tpnt)
-{
-        unsigned long ioaddr, irq;
-        static int called = 0;
-        struct Scsi_Host *instance;
-#ifdef SUN3_SCSI_VME
-        int i;
-        unsigned long addrs[3] = { IOBASE_SUN3_VMESCSI,
-                                   IOBASE_SUN3_VMESCSI + 0x4000,
-                                   0 };
-        unsigned long vecs[3] = { SUN3_VEC_VMESCSI0,
-                                  SUN3_VEC_VMESCSI1,
-                                  0 };
-#endif
-
-        /* check that this machine has an onboard 5380 */
-        switch(idprom->id_machtype) {
-#ifdef SUN3_SCSI_VME
-        case SM_SUN3|SM_3_160:
-        case SM_SUN3|SM_3_260:
-                break;
-#else
-        case SM_SUN3|SM_3_50:
-        case SM_SUN3|SM_3_60:
-                break;
-#endif
-
-        default:
-                return 0;
-        }
-
-        if(called)
-                return 0;
-
-#ifdef SUN3_SCSI_VME
-        tpnt->proc_name = "Sun3 5380 VME SCSI";
-#else
-        tpnt->proc_name = "Sun3 5380 SCSI";
-#endif
-
-        /* setup variables */
-        tpnt->can_queue =
-                (setup_can_queue > 0) ? setup_can_queue : CAN_QUEUE;
-        tpnt->cmd_per_lun =
-                (setup_cmd_per_lun > 0) ? setup_cmd_per_lun : CMD_PER_LUN;
-        tpnt->sg_tablesize = 
-                (setup_sg_tablesize >= 0) ? setup_sg_tablesize : SG_TABLESIZE;
-
-        if (setup_hostid >= 0)
-                tpnt->this_id = setup_hostid;
-        else {
-                /* use 7 as default */
-                tpnt->this_id = 7;
-        }
-
-#ifdef SUN3_SCSI_VME
-        ioaddr = 0;
-        for (i = 0; addrs[i] != 0; i++) {
-                unsigned char x;
-
-                ioaddr = (unsigned long)sun3_ioremap(addrs[i], PAGE_SIZE,
-                                                     SUN3_PAGE_TYPE_VME16);
-                irq = vecs[i];
-                sun3_scsi_regp = (unsigned char *)ioaddr;
-
-                dregs = (struct sun3_dma_regs *)(((unsigned char *)ioaddr) + 8);
-
-                if (sun3_map_test((unsigned long)dregs, &x)) {
-                        unsigned short oldcsr;
-
-                        oldcsr = dregs->csr;
-                        dregs->csr = 0;
-                        udelay(SUN3_DMA_DELAY);
-                        if (dregs->csr == 0x1400)
-                                break;
-
-                        dregs->csr = oldcsr;
-                }
-
-                iounmap((void *)ioaddr);
-                ioaddr = 0;
-        }
-
-        if (!ioaddr)
-                return 0;
-#else
-        irq = IRQ_SUN3_SCSI;
-        ioaddr = (unsigned long)ioremap(IOBASE_SUN3_SCSI, PAGE_SIZE);
-        sun3_scsi_regp = (unsigned char *)ioaddr;
-
-        dregs = (struct sun3_dma_regs *)(((unsigned char *)ioaddr) + 8);
-
-        if((udc_regs = dvma_malloc(sizeof(struct sun3_udc_regs)))
-           == NULL) {
-             printk("SUN3 Scsi couldn't allocate DVMA memory!\n");
-             return 0;
-        }
-#endif
-#ifdef SUPPORT_TAGS
-        if (setup_use_tagged_queuing < 0)
-                setup_use_tagged_queuing = USE_TAGGED_QUEUING;
-#endif
-
-        instance = scsi_register (tpnt, sizeof(struct NCR5380_hostdata));
-        if(instance == NULL)
-                return 0;
-                
-        default_instance = instance;
-
-        instance->io_port = (unsigned long) ioaddr;
-        instance->irq = irq;
-
-        NCR5380_init(instance, 0);
-
-        instance->n_io_port = 32;
-
-        ((struct NCR5380_hostdata *)instance->hostdata)->ctrl = 0;
-
-        if (request_irq(instance->irq, scsi_sun3_intr,
-                             0, "Sun3SCSI-5380", instance)) {
-#ifndef REAL_DMA
-                printk("scsi%d: IRQ%d not free, interrupts disabled\n",
-                       instance->host_no, instance->irq);
-                instance->irq = SCSI_IRQ_NONE;
-#else
-                printk("scsi%d: IRQ%d not free, bailing out\n",
-                       instance->host_no, instance->irq);
-                return 0;
-#endif
-        }
-        
-        pr_info("scsi%d: %s at port %lX irq", instance->host_no,
-                tpnt->proc_name, instance->io_port);
-        if (instance->irq == SCSI_IRQ_NONE)
-                printk ("s disabled");
-        else
-                printk (" %d", instance->irq);
-        printk(" options CAN_QUEUE=%d CMD_PER_LUN=%d release=%d",
-               instance->can_queue, instance->cmd_per_lun,
-               SUN3SCSI_PUBLIC_RELEASE);
-        printk("\nscsi%d:", instance->host_no);
-        NCR5380_print_options(instance);
-        printk("\n");
-
-        dregs->csr = 0;
-        udelay(SUN3_DMA_DELAY);
-        dregs->csr = CSR_SCSI | CSR_FIFO | CSR_INTR;
-        udelay(SUN3_DMA_DELAY);
-        dregs->fifo_count = 0;
-#ifdef SUN3_SCSI_VME
-        dregs->fifo_count_hi = 0;
-        dregs->dma_addr_hi = 0;
-        dregs->dma_addr_lo = 0;
-        dregs->dma_count_hi = 0;
-        dregs->dma_count_lo = 0;
-
-        dregs->ivect = VME_DATA24 | (instance->irq & 0xff);
-#endif
-
-        called = 1;
-
-#ifdef RESET_BOOT
-        sun3_scsi_reset_boot(instance);
-#endif
-
-        return 1;
-}
-
-int sun3scsi_release (struct Scsi_Host *shpnt)
-{
-        if (shpnt->irq != SCSI_IRQ_NONE)
-                free_irq(shpnt->irq, shpnt);
-
-        iounmap((void *)sun3_scsi_regp);
-
-        NCR5380_exit(shpnt);
-        return 0;
-}
-
 #ifdef RESET_BOOT
-/*
- * Our 'bus reset on boot' function
- */
-
 static void sun3_scsi_reset_boot(struct Scsi_Host *instance)
 {
         unsigned long end;
-
-        NCR5380_local_declare();
-        NCR5380_setup(instance);
         
         /*
          * Do a SCSI reset to clean up the bus during initialization. No
@@ -422,11 +183,6 @@ static void sun3_scsi_reset_boot(struct Scsi_Host *instance)
 }
 #endif
 
-static const char *sun3scsi_info(struct Scsi_Host *spnt)
-{
-    return "";
-}
-
 // safe bits for the CSR
 #define CSR_GOOD 0x060f
 
@@ -468,7 +224,6 @@ static irqreturn_t scsi_sun3_intr(int irq, void *dummy)
 void sun3_sun3_debug (void)
 {
         unsigned long flags;
-        NCR5380_local_declare();
 
         if (default_instance) {
                         local_irq_save(flags);
@@ -732,25 +487,200 @@ static int sun3scsi_dma_finish(int write_flag)
 
 }
         
-#include "sun3_NCR5380.c"
+#include "atari_NCR5380.c"
 
-static struct scsi_host_template driver_template = {
+#ifdef SUN3_SCSI_VME
+#define SUN3_SCSI_NAME          "Sun3 NCR5380 VME SCSI"
+#define DRV_MODULE_NAME         "sun3_scsi_vme"
+#else
+#define SUN3_SCSI_NAME          "Sun3 NCR5380 SCSI"
+#define DRV_MODULE_NAME         "sun3_scsi"
+#endif
+
+#define PFX                     DRV_MODULE_NAME ": "
+
+static struct scsi_host_template sun3_scsi_template = {
+        .module                 = THIS_MODULE,
+        .proc_name              = DRV_MODULE_NAME,
         .show_info              = sun3scsi_show_info,
         .name                   = SUN3_SCSI_NAME,
-        .detect                 = sun3scsi_detect,
-        .release                = sun3scsi_release,
         .info                   = sun3scsi_info,
         .queuecommand           = sun3scsi_queue_command,
         .eh_abort_handler       = sun3scsi_abort,
         .eh_bus_reset_handler   = sun3scsi_bus_reset,
-        .can_queue              = CAN_QUEUE,
+        .can_queue              = 16,
         .this_id                = 7,
-        .sg_tablesize           = SG_TABLESIZE,
-        .cmd_per_lun            = CMD_PER_LUN,
+        .sg_tablesize           = SG_NONE,
+        .cmd_per_lun            = 2,
         .use_clustering         = DISABLE_CLUSTERING
 };
 
+static int __init sun3_scsi_probe(struct platform_device *pdev)
+{
+        struct Scsi_Host *instance;
+        int error;
+        struct resource *irq, *mem;
+        unsigned char *ioaddr;
+        int host_flags = 0;
+#ifdef SUN3_SCSI_VME
+        int i;
+#endif
+
+        if (setup_can_queue > 0)
+                sun3_scsi_template.can_queue = setup_can_queue;
+        if (setup_cmd_per_lun > 0)
+                sun3_scsi_template.cmd_per_lun = setup_cmd_per_lun;
+        if (setup_sg_tablesize >= 0)
+                sun3_scsi_template.sg_tablesize = setup_sg_tablesize;
+        if (setup_hostid >= 0)
+                sun3_scsi_template.this_id = setup_hostid & 7;
+
+#ifdef SUN3_SCSI_VME
+        ioaddr = NULL;
+        for (i = 0; i < 2; i++) {
+                unsigned char x;
+
+                irq = platform_get_resource(pdev, IORESOURCE_IRQ, i);
+                mem = platform_get_resource(pdev, IORESOURCE_MEM, i);
+                if (!irq || !mem)
+                        break;
+
+                ioaddr = sun3_ioremap(mem->start, resource_size(mem),
+                                      SUN3_PAGE_TYPE_VME16);
+                dregs = (struct sun3_dma_regs *)(ioaddr + 8);
+
+                if (sun3_map_test((unsigned long)dregs, &x)) {
+                        unsigned short oldcsr;
+
+                        oldcsr = dregs->csr;
+                        dregs->csr = 0;
+                        udelay(SUN3_DMA_DELAY);
+                        if (dregs->csr == 0x1400)
+                                break;
+
+                        dregs->csr = oldcsr;
+                }
+
+                iounmap(ioaddr);
+                ioaddr = NULL;
+        }
+        if (!ioaddr)
+                return -ENODEV;
+#else
+        irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!irq || !mem)
+                return -ENODEV;
+
+        ioaddr = ioremap(mem->start, resource_size(mem));
+        dregs = (struct sun3_dma_regs *)(ioaddr + 8);
+
+        udc_regs = dvma_malloc(sizeof(struct sun3_udc_regs));
+        if (!udc_regs) {
+                pr_err(PFX "couldn't allocate DVMA memory!\n");
+                iounmap(ioaddr);
+                return -ENOMEM;
+        }
+#endif
+
+        sun3_scsi_regp = ioaddr;
+
+        instance = scsi_host_alloc(&sun3_scsi_template,
+                                   sizeof(struct NCR5380_hostdata));
+        if (!instance) {
+                error = -ENOMEM;
+                goto fail_alloc;
+        }
+        default_instance = instance;
+
+        instance->io_port = (unsigned long)ioaddr;
+        instance->irq = irq->start;
+
+#ifdef SUPPORT_TAGS
+        host_flags |= setup_use_tagged_queuing > 0 ? FLAG_TAGGED_QUEUING : 0;
+#endif
+
+        NCR5380_init(instance, host_flags);
+
+        error = request_irq(instance->irq, scsi_sun3_intr, 0,
+                            "NCR5380", instance);
+        if (error) {
+#ifdef REAL_DMA
+                pr_err(PFX "scsi%d: IRQ %d not free, bailing out\n",
+                       instance->host_no, instance->irq);
+                goto fail_irq;
+#else
+                pr_warn(PFX "scsi%d: IRQ %d not free, interrupts disabled\n",
+                        instance->host_no, instance->irq);
+                instance->irq = NO_IRQ;
+#endif
+        }
+
+        dregs->csr = 0;
+        udelay(SUN3_DMA_DELAY);
+        dregs->csr = CSR_SCSI | CSR_FIFO | CSR_INTR;
+        udelay(SUN3_DMA_DELAY);
+        dregs->fifo_count = 0;
+#ifdef SUN3_SCSI_VME
+        dregs->fifo_count_hi = 0;
+        dregs->dma_addr_hi = 0;
+        dregs->dma_addr_lo = 0;
+        dregs->dma_count_hi = 0;
+        dregs->dma_count_lo = 0;
+
+        dregs->ivect = VME_DATA24 | (instance->irq & 0xff);
+#endif
+
+#ifdef RESET_BOOT
+        sun3_scsi_reset_boot(instance);
+#endif
+
+        error = scsi_add_host(instance, NULL);
+        if (error)
+                goto fail_host;
+
+        platform_set_drvdata(pdev, instance);
+
+        scsi_scan_host(instance);
+        return 0;
+
+fail_host:
+        if (instance->irq != NO_IRQ)
+                free_irq(instance->irq, instance);
+fail_irq:
+        NCR5380_exit(instance);
+        scsi_host_put(instance);
+fail_alloc:
+        if (udc_regs)
+                dvma_free(udc_regs);
+        iounmap(sun3_scsi_regp);
+        return error;
+}
+
+static int __exit sun3_scsi_remove(struct platform_device *pdev)
+{
+        struct Scsi_Host *instance = platform_get_drvdata(pdev);
+
+        scsi_remove_host(instance);
+        if (instance->irq != NO_IRQ)
+                free_irq(instance->irq, instance);
+        NCR5380_exit(instance);
+        scsi_host_put(instance);
+        if (udc_regs)
+                dvma_free(udc_regs);
+        iounmap(sun3_scsi_regp);
+        return 0;
+}
+
+static struct platform_driver sun3_scsi_driver = {
+        .remove = __exit_p(sun3_scsi_remove),
+        .driver = {
+                .name   = DRV_MODULE_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
 
-#include "scsi_module.c"
+module_platform_driver_probe(sun3_scsi_driver, sun3_scsi_probe);
 
+MODULE_ALIAS("platform:" DRV_MODULE_NAME);
 MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/sun3_scsi.h b/drivers/scsi/sun3_scsi.h
index e96a37cf06ac..d22745fae328 100644
--- a/drivers/scsi/sun3_scsi.h
+++ b/drivers/scsi/sun3_scsi.h
@@ -13,95 +13,11 @@
  *      (Unix and Linux consulting and custom programming)
  *      drew@colorado.edu
  *      +1 (303) 440-4894
- *
- * ALPHA RELEASE 1.
- *
- * For more information, please consult
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 #ifndef SUN3_SCSI_H
 #define SUN3_SCSI_H
 
-#define SUN3SCSI_PUBLIC_RELEASE 1
-
-/*
- * Int: level 2 autovector
- * IO: type 1, base 0x00140000, 5 bits phys space: A<4..0>
- */
-#define IRQ_SUN3_SCSI 2
-#define IOBASE_SUN3_SCSI 0x00140000
-
-#define IOBASE_SUN3_VMESCSI 0xff200000
-
-static int sun3scsi_abort(struct scsi_cmnd *);
-static int sun3scsi_detect (struct scsi_host_template *);
-static const char *sun3scsi_info (struct Scsi_Host *);
-static int sun3scsi_bus_reset(struct scsi_cmnd *);
-static int sun3scsi_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
-static int sun3scsi_release (struct Scsi_Host *);
-
-#ifndef CMD_PER_LUN
-#define CMD_PER_LUN 2
-#endif
-
-#ifndef CAN_QUEUE
-#define CAN_QUEUE 16
-#endif
-
-#ifndef SG_TABLESIZE
-#define SG_TABLESIZE SG_NONE
-#endif
-
-#ifndef MAX_TAGS
-#define MAX_TAGS 32
-#endif
-
-#ifndef USE_TAGGED_QUEUING
-#define USE_TAGGED_QUEUING 1
-#endif
-
-#include <scsi/scsicam.h>
-
-#ifdef SUN3_SCSI_VME
-#define SUN3_SCSI_NAME "Sun3 NCR5380 VME SCSI"
-#else
-#define SUN3_SCSI_NAME "Sun3 NCR5380 SCSI"
-#endif
-
-#define NCR5380_implementation_fields \
-    int port, ctrl
-
-#define NCR5380_local_declare() \
-        struct Scsi_Host *_instance
-
-#define NCR5380_setup(instance) \
-        _instance = instance
-
-#define NCR5380_read(reg) sun3scsi_read(reg)
-#define NCR5380_write(reg, value) sun3scsi_write(reg, value)
-
-#define NCR5380_intr sun3scsi_intr
-#define NCR5380_queue_command sun3scsi_queue_command
-#define NCR5380_bus_reset sun3scsi_bus_reset
-#define NCR5380_abort sun3scsi_abort
-#define NCR5380_show_info sun3scsi_show_info
-#define NCR5380_dma_xfer_len(i, cmd, phase) \
-        sun3scsi_dma_xfer_len(cmd->SCp.this_residual,cmd,((phase) & SR_IO) ? 0 : 1)
-
-#define NCR5380_dma_write_setup(instance, data, count) sun3scsi_dma_setup(data, count, 1)
-#define NCR5380_dma_read_setup(instance, data, count) sun3scsi_dma_setup(data, count, 0)
-#define NCR5380_dma_residual sun3scsi_dma_residual
-
 /* additional registers - mainly DMA control regs */
 /* these start at regbase + 8 -- directly after the NCR regs */
 struct sun3_dma_regs {
diff --git a/drivers/scsi/sym53c8xx_2/sym_glue.c b/drivers/scsi/sym53c8xx_2/sym_glue.c
index e59e6f96b725..5d00e514ff28 100644
--- a/drivers/scsi/sym53c8xx_2/sym_glue.c
+++ b/drivers/scsi/sym53c8xx_2/sym_glue.c
@@ -820,9 +820,7 @@ static int sym53c8xx_slave_configure(struct scsi_device *sdev)
         if (reqtags > SYM_CONF_MAX_TAG)
                 reqtags = SYM_CONF_MAX_TAG;
         depth_to_use = reqtags ? reqtags : 1;
-        scsi_adjust_queue_depth(sdev,
-                                sdev->tagged_supported ? MSG_SIMPLE_TAG : 0,
-                                depth_to_use);
+        scsi_change_queue_depth(sdev, depth_to_use);
         lp->s.scdev_depth = depth_to_use;
         sym_tune_dev_queuing(tp, sdev->lun, reqtags);
 
diff --git a/drivers/scsi/t128.c b/drivers/scsi/t128.c
index 8cc80931df14..87828acbf7c6 100644
--- a/drivers/scsi/t128.c
+++ b/drivers/scsi/t128.c
@@ -1,4 +1,3 @@
-#define AUTOSENSE
 #define PSEUDO_DMA
 
 /*
@@ -12,8 +11,6 @@
  *      drew@colorado.edu
  *      +1 (303) 440-4894
  *
- * DISTRIBUTION RELEASE 3.
- *
  * For more information, please consult 
  *
  * Trantor Systems, Ltd.
@@ -24,40 +21,9 @@
  * 5415 Randall Place
  * Fremont, CA 94538
  * 1+ (415) 770-1400, FAX 1+ (415) 770-9910
- * 
- * and 
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 /*
- * Options : 
- * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
- *      for commands that return with a CHECK CONDITION status. 
- *
- * PSEUDO_DMA - enables PSEUDO-DMA hardware, should give a 3-4X performance
- * increase compared to polled I/O.
- *
- * PARITY - enable parity checking.  Not supported.
- * 
- * SCSI2 - enable support for SCSI-II tagged queueing.  Untested.
- *
- *
- * UNSAFE - leave interrupts enabled during pseudo-DMA transfers.  You
- *          only really want to use this if you're having a problem with
- *          dropped characters during high speed communications, and even
- *          then, you're going to be better off twiddling with transfersize.
- *
- * USLEEP - enable support for devices that don't disconnect.  Untested.
- *
  * The card is detected and initialized in one of several ways : 
  * 1.  Autoprobe (default) - since the board is memory mapped, 
  *     a BIOS signature is scanned for to locate the registers.
@@ -111,7 +77,6 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 
-#include "scsi.h"
 #include <scsi/scsi_host.h>
 #include "t128.h"
 #define AUTOPROBE_IRQ
@@ -148,6 +113,7 @@ static struct signature {
 
 #define NO_SIGNATURES ARRAY_SIZE(signatures)
 
+#ifndef MODULE
 /*
  * Function : t128_setup(char *str, int *ints)
  *
@@ -158,9 +124,13 @@ static struct signature {
  *
  */
 
-void __init t128_setup(char *str, int *ints){
+static int __init t128_setup(char *str)
+{
     static int commandline_current = 0;
     int i;
+    int ints[10];
+
+    get_options(str, ARRAY_SIZE(ints), ints);
     if (ints[0] != 2) 
         printk("t128_setup : usage t128=address,irq\n");
     else 
@@ -174,8 +144,12 @@ void __init t128_setup(char *str, int *ints){
                 }
             ++commandline_current;
         }
+    return 1;
 }
 
+__setup("t128=", t128_setup);
+#endif
+
 /* 
  * Function : int t128_detect(struct scsi_host_template * tpnt)
  *
@@ -189,17 +163,14 @@ void __init t128_setup(char *str, int *ints){
  *
  */
 
-int __init t128_detect(struct scsi_host_template * tpnt){
+static int __init t128_detect(struct scsi_host_template *tpnt)
+{
     static int current_override = 0, current_base = 0;
     struct Scsi_Host *instance;
     unsigned long base;
     void __iomem *p;
     int sig, count;
 
-    tpnt->proc_name = "t128";
-    tpnt->show_info = t128_show_info;
-    tpnt->write_info = t128_write_info;
-
     for (count = 0; current_override < NO_OVERRIDES; ++current_override) {
         base = 0;
         p = NULL;
@@ -254,15 +225,19 @@ found:
         else 
             instance->irq = NCR5380_probe_irq(instance, T128_IRQS);
 
-        if (instance->irq != SCSI_IRQ_NONE) 
+        /* Compatibility with documented NCR5380 kernel parameters */
+        if (instance->irq == 255)
+                instance->irq = NO_IRQ;
+
+        if (instance->irq != NO_IRQ)
             if (request_irq(instance->irq, t128_intr, 0, "t128",
                             instance)) {
                 printk("scsi%d : IRQ%d not free, interrupts disabled\n", 
                     instance->host_no, instance->irq);
-                instance->irq = SCSI_IRQ_NONE;
+                instance->irq = NO_IRQ;
             } 
 
-        if (instance->irq == SCSI_IRQ_NONE) {
+        if (instance->irq == NO_IRQ) {
             printk("scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
             printk("scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
         }
@@ -271,16 +246,6 @@ found:
         printk("scsi%d : irq = %d\n", instance->host_no, instance->irq);
 #endif
 
-        printk("scsi%d : at 0x%08lx", instance->host_no, instance->base);
-        if (instance->irq == SCSI_IRQ_NONE)
-            printk (" interrupts disabled");
-        else 
-            printk (" irq %d", instance->irq);
-        printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d",
-            CAN_QUEUE, CMD_PER_LUN, T128_PUBLIC_RELEASE);
-        NCR5380_print_options(instance);
-        printk("\n");
-
         ++current_override;
         ++count;
     }
@@ -291,7 +256,7 @@ static int t128_release(struct Scsi_Host *shost)
 {
         NCR5380_local_declare();
         NCR5380_setup(shost);
-        if (shost->irq)
+        if (shost->irq != NO_IRQ)
                 free_irq(shost->irq, shost);
         NCR5380_exit(shost);
         if (shost->io_port && shost->n_io_port)
@@ -321,8 +286,8 @@ static int t128_release(struct Scsi_Host *shost)
  * and matching the H_C_S coordinates to what DOS uses.
  */
 
-int t128_biosparam(struct scsi_device *sdev, struct block_device *bdev,
-                sector_t capacity, int * ip)
+static int t128_biosparam(struct scsi_device *sdev, struct block_device *bdev,
+                          sector_t capacity, int *ip)
 {
   ip[0] = 64;
   ip[1] = 32;
@@ -430,6 +395,10 @@ static struct scsi_host_template driver_template = {
         .name           = "Trantor T128/T128F/T228",
         .detect         = t128_detect,
         .release        = t128_release,
+        .proc_name      = "t128",
+        .show_info      = t128_show_info,
+        .write_info     = t128_write_info,
+        .info           = t128_info,
         .queuecommand   = t128_queue_command,
         .eh_abort_handler = t128_abort,
         .eh_bus_reset_handler    = t128_bus_reset,
diff --git a/drivers/scsi/t128.h b/drivers/scsi/t128.h
index fd68cecc62af..2c7371454dfd 100644
--- a/drivers/scsi/t128.h
+++ b/drivers/scsi/t128.h
@@ -8,8 +8,6 @@
  *      drew@colorado.edu
  *      +1 (303) 440-4894
  *
- * DISTRIBUTION RELEASE 3.
- *
  * For more information, please consult
  *
  * Trantor Systems, Ltd.
@@ -20,25 +18,11 @@
  * 5415 Randall Place
  * Fremont, CA 94538
  * 1+ (415) 770-1400, FAX 1+ (415) 770-9910
- *
- * and
- *
- * NCR 5380 Family
- * SCSI Protocol Controller
- * Databook
- *
- * NCR Microelectronics
- * 1635 Aeroplaza Drive
- * Colorado Springs, CO 80916
- * 1+ (719) 578-3400
- * 1+ (800) 334-5454
  */
 
 #ifndef T128_H
 #define T128_H
 
-#define T128_PUBLIC_RELEASE 3
-
 #define TDEBUG          0
 #define TDEBUG_INIT     0x1
 #define TDEBUG_TRANSFER 0x2
@@ -88,12 +72,6 @@
 #define T_DATA_REG_OFFSET       0x1e00  /* rw 512 bytes long */
 
 #ifndef ASM
-static int t128_abort(struct scsi_cmnd *);
-static int t128_biosparam(struct scsi_device *, struct block_device *,
-                          sector_t, int*);
-static int t128_detect(struct scsi_host_template *);
-static int t128_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
-static int t128_bus_reset(struct scsi_cmnd *);
 
 #ifndef CMD_PER_LUN
 #define CMD_PER_LUN 2
@@ -134,6 +112,7 @@ static int t128_bus_reset(struct scsi_cmnd *);
 #define NCR5380_queue_command t128_queue_command
 #define NCR5380_abort t128_abort
 #define NCR5380_bus_reset t128_bus_reset
+#define NCR5380_info t128_info
 #define NCR5380_show_info t128_show_info
 #define NCR5380_write_info t128_write_info
 
diff --git a/drivers/scsi/tmscsim.c b/drivers/scsi/tmscsim.c
deleted file mode 100644
index 764575726c85..000000000000
--- a/drivers/scsi/tmscsim.c
+++ /dev/null
@@ -1,2620 +0,0 @@
-/************************************************************************
- *      FILE NAME : TMSCSIM.C                                           *
- *           BY   : C.L. Huang,  ching@tekram.com.tw                    *
- *      Description: Device Driver for Tekram DC-390(T) PCI SCSI        *
- *                   Bus Master Host Adapter                            *
- * (C)Copyright 1995-1996 Tekram Technology Co., Ltd.                   *
- ************************************************************************
- * (C) Copyright: put under GNU GPL in 10/96                            *
- *                              (see Documentation/scsi/tmscsim.txt)    *
- ************************************************************************
- * $Id: tmscsim.c,v 2.60.2.30 2000/12/20 01:07:12 garloff Exp $         *
- *      Enhancements and bugfixes by                                    *
- *      Kurt Garloff <kurt@garloff.de>  <garloff@suse.de>               *
- ************************************************************************
- *      HISTORY:                                                        *
- *                                                                      *
- *      REV#    DATE    NAME    DESCRIPTION                             *
- *      1.00  96/04/24  CLH     First release                           *
- *      1.01  96/06/12  CLH     Fixed bug of Media Change for Removable *
- *                              Device, scan all LUN. Support Pre2.0.10 *
- *      1.02  96/06/18  CLH     Fixed bug of Command timeout ...        *
- *      1.03  96/09/25  KG      Added tmscsim_proc_info()               *
- *      1.04  96/10/11  CLH     Updating for support KV 2.0.x           *
- *      1.05  96/10/18  KG      Fixed bug in DC390_abort(null ptr deref)*
- *      1.06  96/10/25  KG      Fixed module support                    *
- *      1.07  96/11/09  KG      Fixed tmscsim_proc_info()               *
- *      1.08  96/11/18  KG      Fixed null ptr in DC390_Disconnect()    *
- *      1.09  96/11/30  KG      Added register the allocated IO space   *
- *      1.10  96/12/05  CLH     Modified tmscsim_proc_info(), and reset *
- *                              pending interrupt in DC390_detect()     *
- *      1.11  97/02/05  KG/CLH  Fixeds problem with partitions greater  *
- *                              than 1GB                                *
- *      1.12  98/02/15  MJ      Rewritten PCI probing                   *
- *      1.13  98/04/08  KG      Support for non DC390, __initfunc decls,*
- *                              changed max devs from 10 to 16          *
- *      1.14a 98/05/05  KG      Dynamic DCB allocation, add-single-dev  *
- *                              for LUNs if LUN_SCAN (BIOS) not set     *
- *                              runtime config using /proc interface    *
- *      1.14b 98/05/06  KG      eliminated cli (); sti (); spinlocks    *
- *      1.14c 98/05/07  KG      2.0.x compatibility                     *
- *      1.20a 98/05/07  KG      changed names of funcs to be consistent *
- *                              DC390_ (entry points), dc390_ (internal)*
- *                              reworked locking                        *
- *      1.20b 98/05/12  KG      bugs: version, kfree, _ctmp             *
- *                              debug output                            *
- *      1.20c 98/05/12  KG      bugs: kfree, parsing, EEpromDefaults    *
- *      1.20d 98/05/14  KG      bugs: list linkage, clear flag after    *
- *                              reset on startup, code cleanup          *
- *      1.20e 98/05/15  KG      spinlock comments, name space cleanup   *
- *                              pLastDCB now part of ACB structure      *
- *                              added stats, timeout for 2.1, TagQ bug  *
- *                              RESET and INQUIRY interface commands    *
- *      1.20f 98/05/18  KG      spinlocks fixes, max_lun fix, free DCBs *
- *                              for missing LUNs, pending int           *
- *      1.20g 98/05/19  KG      Clean up: Avoid short                   *
- *      1.20h 98/05/21  KG      Remove AdaptSCSIID, max_lun ...         *
- *      1.20i 98/05/21  KG      Aiiie: Bug with TagQMask                *
- *      1.20j 98/05/24  KG      Handle STAT_BUSY, handle pACB->pLinkDCB *
- *                              == 0 in remove_dev and DoingSRB_Done    *
- *      1.20k 98/05/25  KG      DMA_INT (experimental)                  *
- *      1.20l 98/05/27  KG      remove DMA_INT; DMA_IDLE cmds added;    *
- *      1.20m 98/06/10  KG      glitch configurable; made some global   *
- *                              vars part of ACB; use DC390_readX       *
- *      1.20n 98/06/11  KG      startup params                          *
- *      1.20o 98/06/15  KG      added TagMaxNum to boot/module params   *
- *                              Device Nr -> Idx, TagMaxNum power of 2  *
- *      1.20p 98/06/17  KG      Docu updates. Reset depends on settings *
- *                              pci_set_master added; 2.0.xx: pcibios_* *
- *                              used instead of MechNum things ...      *
- *      1.20q 98/06/23  KG      Changed defaults. Added debug code for  *
- *                              removable media and fixed it. TagMaxNum *
- *                              fixed for DC390. Locking: ACB, DRV for  *
- *                              better IRQ sharing. Spelling: Queueing  *
- *                              Parsing and glitch_cfg changes. Display *
- *                              real SyncSpeed value. Made DisConn      *
- *                              functional (!)                          *
- *      1.20r 98/06/30  KG      Debug macros, allow disabling DsCn, set *
- *                              BIT4 in CtrlR4, EN_PAGE_INT, 2.0 module *
- *                              param -1 fixed.                         *
- *      1.20s 98/08/20  KG      Debug info on abort(), try to check PCI,*
- *                              phys_to_bus instead of phys_to_virt,    *
- *                              fixed sel. process, fixed locking,      *
- *                              added MODULE_XXX infos, changed IRQ     *
- *                              request flags, disable DMA_INT          *
- *      1.20t 98/09/07  KG      TagQ report fixed; Write Erase DMA Stat;*
- *                              initfunc -> __init; better abort;       *
- *                              Timeout for XFER_DONE & BLAST_COMPLETE; *
- *                              Allow up to 33 commands being processed *
- *      2.0a  98/10/14  KG      Max Cmnds back to 17. DMA_Stat clearing *
- *                              all flags. Clear within while() loops   *
- *                              in DataIn_0/Out_0. Null ptr in dumpinfo *
- *                              for pSRB==0. Better locking during init.*
- *                              bios_param() now respects part. table.  *
- *      2.0b  98/10/24  KG      Docu fixes. Timeout Msg in DMA Blast.   *
- *                              Disallow illegal idx in INQUIRY/REMOVE  *
- *      2.0c  98/11/19  KG      Cleaned up detect/init for SMP boxes,   *
- *                              Write Erase DMA (1.20t) caused problems *
- *      2.0d  98/12/25  KG      Christmas release ;-) Message handling  *
- *                              completely reworked. Handle target ini- *
- *                              tiated SDTR correctly.                  *
- *      2.0d1 99/01/25  KG      Try to handle RESTORE_PTR               *
- *      2.0d2 99/02/08  KG      Check for failure of kmalloc, correct   *
- *                              inclusion of scsicam.h, DelayReset      *
- *      2.0d3 99/05/31  KG      DRIVER_OK -> DID_OK, DID_NO_CONNECT,    *
- *                              detect Target mode and warn.            *
- *                              pcmd->result handling cleaned up.       *
- *      2.0d4 99/06/01  KG      Cleaned selection process. Found bug    *
- *                              which prevented more than 16 tags. Now: *
- *                              24. SDTR cleanup. Cleaner multi-LUN     *
- *                              handling. Don't modify ControlRegs/FIFO *
- *                              when connected.                         *
- *      2.0d5 99/06/01  KG      Clear DevID, Fix INQUIRY after cfg chg. *
- *      2.0d6 99/06/02  KG      Added ADD special command to allow cfg. *
- *                              before detection. Reset SYNC_NEGO_DONE  *
- *                              after a bus reset.                      *
- *      2.0d7 99/06/03  KG      Fixed bugs wrt add,remove commands      *
- *      2.0d8 99/06/04  KG      Removed copying of cmnd into CmdBlock.  *
- *                              Fixed Oops in _release().               *
- *      2.0d9 99/06/06  KG      Also tag queue INQUIRY, T_U_R, ...      *
- *                              Allow arb. no. of Tagged Cmnds. Max 32  *
- *      2.0d1099/06/20  KG      TagMaxNo changes now honoured! Queueing *
- *                              clearified (renamed ..) TagMask handling*
- *                              cleaned.                                *
- *      2.0d1199/06/28  KG      cmd->result now identical to 2.0d2      *
- *      2.0d1299/07/04  KG      Changed order of processing in IRQ      *
- *      2.0d1399/07/05  KG      Don't update DCB fields if removed      *
- *      2.0d1499/07/05  KG      remove_dev: Move kfree() to the end     *
- *      2.0d1599/07/12  KG      use_new_eh_code: 0, ULONG -> UINT where *
- *                              appropriate                             *
- *      2.0d1699/07/13  KG      Reenable StartSCSI interrupt, Retry msg *
- *      2.0d1799/07/15  KG      Remove debug msg. Disable recfg. when   *
- *                              there are queued cmnds                  *
- *      2.0d1899/07/18  KG      Selection timeout: Don't requeue        *
- *      2.0d1999/07/18  KG      Abort: Only call scsi_done if dequeued  *
- *      2.0d2099/07/19  KG      Rst_Detect: DoingSRB_Done               *
- *      2.0d2199/08/15  KG      dev_id for request/free_irq, cmnd[0] for*
- *                              RETRY, SRBdone does DID_ABORT for the   *
- *                              cmd passed by DC390_reset()             *
- *      2.0d2299/08/25  KG      dev_id fixed. can_queue: 42             *
- *      2.0d2399/08/25  KG      Removed some debugging code. dev_id     *
- *                              now is set to pACB. Use u8,u16,u32.     *
- *      2.0d2499/11/14  KG      Unreg. I/O if failed IRQ alloc. Call    *
- *                              done () w/ DID_BAD_TARGET in case of    *
- *                              missing DCB. We are old EH!!            *
- *      2.0d2500/01/15  KG      2.3.3x compat from Andreas Schultz      *
- *                              set unique_id. Disable RETRY message.   *
- *      2.0d2600/01/29  KG      Go to new EH.                           *
- *      2.0d2700/01/31  KG      ... but maintain 2.0 compat.            *
- *                              and fix DCB freeing                     *
- *      2.0d2800/02/14  KG      Queue statistics fixed, dump special cmd*
- *                              Waiting_Timer for failed StartSCSI      *
- *                              New EH: Don't return cmnds to ML on RST *
- *                              Use old EH (don't have new EH fns yet)  *
- *                              Reset: Unlock, but refuse to queue      *
- *                              2.3 __setup function                    *
- *      2.0e  00/05/22  KG      Return residual for 2.3                 *
- *      2.0e1 00/05/25  KG      Compile fixes for 2.3.99                *
- *      2.0e2 00/05/27  KG      Jeff Garzik's pci_enable_device()       *
- *      2.0e3 00/09/29  KG      Some 2.4 changes. Don't try Sync Nego   *
- *                              before INQUIRY has reported ability.    *
- *                              Recognise INQUIRY as scanning command.  *
- *      2.0e4 00/10/13  KG      Allow compilation into 2.4 kernel       *
- *      2.0e5 00/11/17  KG      Store Inq.flags in DCB                  *
- *      2.0e6 00/11/22  KG      2.4 init function (Thx to O.Schumann)   *
- *                              2.4 PCI device table (Thx to A.Richter) *
- *      2.0e7 00/11/28  KG      Allow overriding of BIOS settings       *
- *      2.0f  00/12/20  KG      Handle failed INQUIRYs during scan      *
- *      2.1a  03/11/29  GL, KG  Initial fixing for 2.6. Convert to      *
- *                              use the current PCI-mapping API, update *
- *                              command-queuing.                        *
- *      2.1b  04/04/13  GL      Fix for 64-bit platforms                *
- *      2.1b1 04/01/31  GL      (applied 05.04) Remove internal         *
- *                              command-queuing.                        *
- *      2.1b2 04/02/01  CH      (applied 05.04) Fix error-handling      *
- *      2.1c  04/05/23  GL      Update to use the new pci_driver API,   *
- *                              some scsi EH updates, more cleanup.     *
- *      2.1d  04/05/27  GL      Moved setting of scan_devices to        *
- *                              slave_alloc/_configure/_destroy, as     *
- *                              suggested by CH.                        *
- ***********************************************************************/
-
-/* DEBUG options */
-//#define DC390_DEBUG0
-//#define DC390_DEBUG1
-//#define DC390_DCBDEBUG
-//#define DC390_PARSEDEBUG
-//#define DC390_REMOVABLEDEBUG
-//#define DC390_LOCKDEBUG
-
-//#define NOP do{}while(0)
-#define C_NOP
-
-/* Debug definitions */
-#ifdef DC390_DEBUG0
-# define DEBUG0(x) x
-#else
-# define DEBUG0(x) C_NOP
-#endif
-#ifdef DC390_DEBUG1
-# define DEBUG1(x) x
-#else
-# define DEBUG1(x) C_NOP
-#endif
-#ifdef DC390_DCBDEBUG
-# define DCBDEBUG(x) x
-#else
-# define DCBDEBUG(x) C_NOP
-#endif
-#ifdef DC390_PARSEDEBUG
-# define PARSEDEBUG(x) x
-#else
-# define PARSEDEBUG(x) C_NOP
-#endif
-#ifdef DC390_REMOVABLEDEBUG
-# define REMOVABLEDEBUG(x) x
-#else
-# define REMOVABLEDEBUG(x) C_NOP
-#endif
-#define DCBDEBUG1(x) C_NOP
-
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/signal.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/ioport.h>
-#include <linux/pci.h>
-#include <linux/proc_fs.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/blkdev.h>
-#include <linux/timer.h>
-#include <linux/interrupt.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/slab.h>
-#include <asm/io.h>
-
-#include <scsi/scsi.h>
-#include <scsi/scsi_cmnd.h>
-#include <scsi/scsi_device.h>
-#include <scsi/scsi_host.h>
-#include <scsi/scsicam.h>
-#include <scsi/scsi_tcq.h>
-
-
-#define DC390_BANNER "Tekram DC390/AM53C974"
-#define DC390_VERSION "2.1d 2004-05-27"
-
-#define PCI_DEVICE_ID_AMD53C974         PCI_DEVICE_ID_AMD_SCSI
-
-#include "tmscsim.h"
-
-
-static void dc390_DataOut_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_DataIn_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_Command_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_Status_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_MsgOut_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_MsgIn_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_DataOutPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_DataInPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_CommandPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_StatusPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_MsgOutPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_MsgInPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_Nop_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-static void dc390_Nop_1( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus);
-
-static void dc390_SetXferRate( struct dc390_acb* pACB, struct dc390_dcb* pDCB );
-static void dc390_Disconnect( struct dc390_acb* pACB );
-static void dc390_Reselect( struct dc390_acb* pACB );
-static void dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb* pSRB );
-static void dc390_ScsiRstDetect( struct dc390_acb* pACB );
-static void dc390_EnableMsgOut_Abort(struct dc390_acb*, struct dc390_srb*);
-static void dc390_dumpinfo(struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb* pSRB);
-static void dc390_ResetDevParam(struct dc390_acb* pACB);
-
-static u32      dc390_laststatus = 0;
-static u8       dc390_adapterCnt = 0;
-
-static int disable_clustering;
-module_param(disable_clustering, int, S_IRUGO);
-MODULE_PARM_DESC(disable_clustering, "If you experience problems with your devices, try setting to 1");
-
-/* Startup values, to be overriden on the commandline */
-static int tmscsim[] = {-2, -2, -2, -2, -2, -2};
-
-module_param_array(tmscsim, int, NULL, 0);
-MODULE_PARM_DESC(tmscsim, "Host SCSI ID, Speed (0=10MHz), Device Flags, Adapter Flags, Max Tags (log2(tags)-1), DelayReset (s)");
-MODULE_AUTHOR("C.L. Huang / Kurt Garloff");
-MODULE_DESCRIPTION("SCSI host adapter driver for Tekram DC390 and other AMD53C974A based PCI SCSI adapters");
-MODULE_LICENSE("GPL");
-MODULE_SUPPORTED_DEVICE("sd,sr,sg,st");
-
-static void *dc390_phase0[]={
-       dc390_DataOut_0,
-       dc390_DataIn_0,
-       dc390_Command_0,
-       dc390_Status_0,
-       dc390_Nop_0,
-       dc390_Nop_0,
-       dc390_MsgOut_0,
-       dc390_MsgIn_0,
-       dc390_Nop_1
-       };
-
-static void *dc390_phase1[]={
-       dc390_DataOutPhase,
-       dc390_DataInPhase,
-       dc390_CommandPhase,
-       dc390_StatusPhase,
-       dc390_Nop_0,
-       dc390_Nop_0,
-       dc390_MsgOutPhase,
-       dc390_MsgInPhase,
-       dc390_Nop_1
-       };
-
-#ifdef DC390_DEBUG1
-static char* dc390_p0_str[] = {
-       "dc390_DataOut_0",
-       "dc390_DataIn_0",
-       "dc390_Command_0",
-       "dc390_Status_0",
-       "dc390_Nop_0",
-       "dc390_Nop_0",
-       "dc390_MsgOut_0",
-       "dc390_MsgIn_0",
-       "dc390_Nop_1"
-       };
-     
-static char* dc390_p1_str[] = {
-       "dc390_DataOutPhase",
-       "dc390_DataInPhase",
-       "dc390_CommandPhase",
-       "dc390_StatusPhase",
-       "dc390_Nop_0",
-       "dc390_Nop_0",
-       "dc390_MsgOutPhase",
-       "dc390_MsgInPhase",
-       "dc390_Nop_1"
-       };
-#endif   
-
-static u8  dc390_eepromBuf[MAX_ADAPTER_NUM][EE_LEN];
-static u8  dc390_clock_period1[] = {4, 5, 6, 7, 8, 10, 13, 20};
-static u8  dc390_clock_speed[] = {100,80,67,57,50, 40, 31, 20};
-
-/***********************************************************************
- * Functions for the management of the internal structures 
- * (DCBs, SRBs, Queueing)
- *
- **********************************************************************/
-static void inline dc390_start_segment(struct dc390_srb* pSRB)
-{
-        struct scatterlist *psgl = pSRB->pSegmentList;
-
-        /* start new sg segment */
-        pSRB->SGBusAddr = sg_dma_address(psgl);
-        pSRB->SGToBeXferLen = sg_dma_len(psgl);
-}
-
-static unsigned long inline dc390_advance_segment(struct dc390_srb* pSRB, u32 residue)
-{
-        unsigned long xfer = pSRB->SGToBeXferLen - residue;
-
-        /* xfer more bytes transferred */
-        pSRB->SGBusAddr += xfer;
-        pSRB->TotalXferredLen += xfer;
-        pSRB->SGToBeXferLen = residue;
-
-        return xfer;
-}
-
-static struct dc390_dcb __inline__ *dc390_findDCB ( struct dc390_acb* pACB, u8 id, u8 lun)
-{
-   struct dc390_dcb* pDCB = pACB->pLinkDCB; if (!pDCB) return NULL;
-   while (pDCB->TargetID != id || pDCB->TargetLUN != lun)
-     {
-        pDCB = pDCB->pNextDCB;
-        if (pDCB == pACB->pLinkDCB)
-             return NULL;
-     }
-   DCBDEBUG1( printk (KERN_DEBUG "DCB %p (%02x,%02x) found.\n", \
-                      pDCB, pDCB->TargetID, pDCB->TargetLUN));
-   return pDCB;
-}
-
-/* Insert SRB oin top of free list */
-static __inline__ void dc390_Free_insert (struct dc390_acb* pACB, struct dc390_srb* pSRB)
-{
-    DEBUG0(printk ("DC390: Free SRB %p\n", pSRB));
-    pSRB->pNextSRB = pACB->pFreeSRB;
-    pACB->pFreeSRB = pSRB;
-}
-
-static __inline__ void dc390_Going_append (struct dc390_dcb* pDCB, struct dc390_srb* pSRB)
-{
-    pDCB->GoingSRBCnt++;
-    DEBUG0(printk("DC390: Append SRB %p to Going\n", pSRB));
-    /* Append to the list of Going commands */
-    if( pDCB->pGoingSRB )
-        pDCB->pGoingLast->pNextSRB = pSRB;
-    else
-        pDCB->pGoingSRB = pSRB;
-
-    pDCB->pGoingLast = pSRB;
-    /* No next one in sent list */
-    pSRB->pNextSRB = NULL;
-}
-
-static __inline__ void dc390_Going_remove (struct dc390_dcb* pDCB, struct dc390_srb* pSRB)
-{
-        DEBUG0(printk("DC390: Remove SRB %p from Going\n", pSRB));
-   if (pSRB == pDCB->pGoingSRB)
-        pDCB->pGoingSRB = pSRB->pNextSRB;
-   else
-     {
-        struct dc390_srb* psrb = pDCB->pGoingSRB;
-        while (psrb && psrb->pNextSRB != pSRB)
-          psrb = psrb->pNextSRB;
-        if (!psrb) 
-          { printk (KERN_ERR "DC390: Remove non-ex. SRB %p from Going!\n", pSRB); return; }
-        psrb->pNextSRB = pSRB->pNextSRB;
-        if (pSRB == pDCB->pGoingLast)
-          pDCB->pGoingLast = psrb;
-     }
-   pDCB->GoingSRBCnt--;
-}
-
-static struct scatterlist* dc390_sg_build_single(struct scatterlist *sg, void *addr, unsigned int length)
-{
-        sg_init_one(sg, addr, length);
-        return sg;
-}
-
-/* Create pci mapping */
-static int dc390_pci_map (struct dc390_srb* pSRB)
-{
-        int error = 0;
-        struct scsi_cmnd *pcmd = pSRB->pcmd;
-        struct pci_dev *pdev = pSRB->pSRBDCB->pDCBACB->pdev;
-        dc390_cmd_scp_t* cmdp = ((dc390_cmd_scp_t*)(&pcmd->SCp));
-
-        /* Map sense buffer */
-        if (pSRB->SRBFlag & AUTO_REQSENSE) {
-                pSRB->pSegmentList      = dc390_sg_build_single(&pSRB->Segmentx, pcmd->sense_buffer, SCSI_SENSE_BUFFERSIZE);
-                pSRB->SGcount           = pci_map_sg(pdev, pSRB->pSegmentList, 1,
-                                                     DMA_FROM_DEVICE);
-                cmdp->saved_dma_handle  = sg_dma_address(pSRB->pSegmentList);
-
-                /* TODO: error handling */
-                if (pSRB->SGcount != 1)
-                        error = 1;
-                DEBUG1(printk("%s(): Mapped sense buffer %p at %x\n", __func__, pcmd->sense_buffer, cmdp->saved_dma_handle));
-        /* Map SG list */
-        } else if (scsi_sg_count(pcmd)) {
-                int nseg;
-
-                nseg = scsi_dma_map(pcmd);
-
-                pSRB->pSegmentList      = scsi_sglist(pcmd);
-                pSRB->SGcount           = nseg;
-
-                /* TODO: error handling */
-                if (nseg < 0)
-                        error = 1;
-                DEBUG1(printk("%s(): Mapped SG %p with %d (%d) elements\n",\
-                              __func__, scsi_sglist(pcmd), nseg, scsi_sg_count(pcmd)));
-        /* Map single segment */
-        } else
-                pSRB->SGcount = 0;
-
-        return error;
-}
-
-/* Remove pci mapping */
-static void dc390_pci_unmap (struct dc390_srb* pSRB)
-{
-        struct scsi_cmnd *pcmd = pSRB->pcmd;
-        struct pci_dev *pdev = pSRB->pSRBDCB->pDCBACB->pdev;
-        DEBUG1(dc390_cmd_scp_t* cmdp = ((dc390_cmd_scp_t*)(&pcmd->SCp)));
-
-        if (pSRB->SRBFlag) {
-                pci_unmap_sg(pdev, &pSRB->Segmentx, 1, DMA_FROM_DEVICE);
-                DEBUG1(printk("%s(): Unmapped sense buffer at %x\n", __func__, cmdp->saved_dma_handle));
-        } else {
-                scsi_dma_unmap(pcmd);
-                DEBUG1(printk("%s(): Unmapped SG at %p with %d elements\n",
-                              __func__, scsi_sglist(pcmd), scsi_sg_count(pcmd)));
-        }
-}
-
-static void __inline__
-dc390_freetag (struct dc390_dcb* pDCB, struct dc390_srb* pSRB)
-{
-        if (pSRB->TagNumber != SCSI_NO_TAG) {
-                pDCB->TagMask &= ~(1 << pSRB->TagNumber);   /* free tag mask */
-                pSRB->TagNumber = SCSI_NO_TAG;
-        }
-}
-
-
-static int
-dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb* pSRB )
-{
-    struct scsi_cmnd *scmd = pSRB->pcmd;
-    struct scsi_device *sdev = scmd->device;
-    u8 cmd, disc_allowed, try_sync_nego;
-    char tag[2];
-
-    pSRB->ScsiPhase = SCSI_NOP0;
-
-    if (pACB->Connected)
-    {
-        // Should not happen normally
-        printk (KERN_WARNING "DC390: Can't select when connected! (%08x,%02x)\n",
-                pSRB->SRBState, pSRB->SRBFlag);
-        pSRB->SRBState = SRB_READY;
-        pACB->SelConn++;
-        return 1;
-    }
-    if (time_before (jiffies, pACB->last_reset))
-    {
-        DEBUG0(printk ("DC390: We were just reset and don't accept commands yet!\n"));
-        return 1;
-    }
-    /* KG: Moved pci mapping here */
-    dc390_pci_map(pSRB);
-    /* TODO: error handling */
-    DC390_write8 (Scsi_Dest_ID, pDCB->TargetID);
-    DC390_write8 (Sync_Period, pDCB->SyncPeriod);
-    DC390_write8 (Sync_Offset, pDCB->SyncOffset);
-    DC390_write8 (CtrlReg1, pDCB->CtrlR1);
-    DC390_write8 (CtrlReg3, pDCB->CtrlR3);
-    DC390_write8 (CtrlReg4, pDCB->CtrlR4);
-    DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);             /* Flush FIFO */
-    DEBUG1(printk (KERN_INFO "DC390: Start SCSI command: %02x (Sync:%02x)\n",\
-            scmd->cmnd[0], pDCB->SyncMode));
-
-    /* Don't disconnect on AUTO_REQSENSE, cause it might be an
-     * Contingent Allegiance Condition (6.6), where no tags should be used.
-     * All other have to be allowed to disconnect to prevent Incorrect 
-     * Initiator Connection (6.8.2/6.5.2) */
-    /* Changed KG, 99/06/06 */
-    if (! (pSRB->SRBFlag & AUTO_REQSENSE))
-        disc_allowed = pDCB->DevMode & EN_DISCONNECT_;
-    else
-        disc_allowed = 0;
-
-    if ((pDCB->SyncMode & SYNC_ENABLE) && pDCB->TargetLUN == 0 && sdev->sdtr &&
-        (((scmd->cmnd[0] == REQUEST_SENSE || (pSRB->SRBFlag & AUTO_REQSENSE)) &&
-          !(pDCB->SyncMode & SYNC_NEGO_DONE)) || scmd->cmnd[0] == INQUIRY))
-      try_sync_nego = 1;
-    else
-      try_sync_nego = 0;
-
-    pSRB->MsgCnt = 0;
-    cmd = SEL_W_ATN;
-    DC390_write8 (ScsiFifo, IDENTIFY(disc_allowed, pDCB->TargetLUN));
-    /* Change 99/05/31: Don't use tags when not disconnecting (BUSY) */
-    if ((pDCB->SyncMode & EN_TAG_QUEUEING) && disc_allowed && scsi_populate_tag_msg(scmd, tag)) {
-        DC390_write8(ScsiFifo, tag[0]);
-        pDCB->TagMask |= 1 << tag[1];
-        pSRB->TagNumber = tag[1];
-        DC390_write8(ScsiFifo, tag[1]);
-        DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for SRB %p, block tag %02x\n", pSRB, tag[1]));
-        cmd = SEL_W_ATN3;
-    } else {
-        /* No TagQ */
-//no_tag:
-        DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for SRB %p, No TagQ\n", disc_allowed ? "" : "o", pSRB));
-    }
-
-    pSRB->SRBState = SRB_START_;
-
-    if (try_sync_nego)
-      { 
-        u8 Sync_Off = pDCB->SyncOffset;
-        DEBUG0(printk (KERN_INFO "DC390: NEW Sync Nego code triggered (%i %i)\n", pDCB->TargetID, pDCB->TargetLUN));
-        pSRB->MsgOutBuf[0] = EXTENDED_MESSAGE;
-        pSRB->MsgOutBuf[1] = 3;
-        pSRB->MsgOutBuf[2] = EXTENDED_SDTR;
-        pSRB->MsgOutBuf[3] = pDCB->NegoPeriod;
-        if (!(Sync_Off & 0x0f)) Sync_Off = SYNC_NEGO_OFFSET;
-        pSRB->MsgOutBuf[4] = Sync_Off;
-        pSRB->MsgCnt = 5;
-        //pSRB->SRBState = SRB_MSGOUT_;
-        pSRB->SRBState |= DO_SYNC_NEGO;
-        cmd = SEL_W_ATN_STOP;
-      }
-
-    /* Command is written in CommandPhase, if SEL_W_ATN_STOP ... */
-    if (cmd != SEL_W_ATN_STOP)
-      {
-        if( pSRB->SRBFlag & AUTO_REQSENSE )
-          {
-            DC390_write8 (ScsiFifo, REQUEST_SENSE);
-            DC390_write8 (ScsiFifo, pDCB->TargetLUN << 5);
-            DC390_write8 (ScsiFifo, 0);
-            DC390_write8 (ScsiFifo, 0);
-            DC390_write8 (ScsiFifo, SCSI_SENSE_BUFFERSIZE);
-            DC390_write8 (ScsiFifo, 0);
-            DEBUG1(printk (KERN_DEBUG "DC390: AutoReqSense !\n"));
-          }
-        else    /* write cmnd to bus */ 
-          {
-            u8 *ptr; u8 i;
-            ptr = (u8 *)scmd->cmnd;
-            for (i = 0; i < scmd->cmd_len; i++)
-              DC390_write8 (ScsiFifo, *(ptr++));
-          }
-      }
-    DEBUG0(if (pACB->pActiveDCB)        \
-           printk (KERN_WARNING "DC390: ActiveDCB != 0\n"));
-    DEBUG0(if (pDCB->pActiveSRB)        \
-           printk (KERN_WARNING "DC390: ActiveSRB != 0\n"));
-    //DC390_write8 (DMA_Cmd, DMA_IDLE_CMD);
-    if (DC390_read8 (Scsi_Status) & INTERRUPT)
-    {
-        dc390_freetag (pDCB, pSRB);
-        DEBUG0(printk ("DC390: Interrupt during Start SCSI (target %02i-%02i)\n",
-                       scmd->device->id, (u8)scmd->device->lun));
-        pSRB->SRBState = SRB_READY;
-        //DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-        pACB->SelLost++;
-        return 1;
-    }
-    DC390_write8 (ScsiCmd, cmd);
-    pACB->pActiveDCB = pDCB;
-    pDCB->pActiveSRB = pSRB;
-    pACB->Connected = 1;
-    pSRB->ScsiPhase = SCSI_NOP1;
-    return 0;
-}
-
-
-static void __inline__
-dc390_InvalidCmd(struct dc390_acb* pACB)
-{
-        if (pACB->pActiveDCB->pActiveSRB->SRBState & (SRB_START_ | SRB_MSGOUT))
-                DC390_write8(ScsiCmd, CLEAR_FIFO_CMD);
-}
-
-
-static irqreturn_t __inline__
-DC390_Interrupt(void *dev_id)
-{
-    struct dc390_acb *pACB = dev_id;
-    struct dc390_dcb *pDCB;
-    struct dc390_srb *pSRB;
-    u8  sstatus=0;
-    u8  phase;
-    void   (*stateV)( struct dc390_acb*, struct dc390_srb*, u8 *);
-    u8  istate, istatus;
-
-    sstatus = DC390_read8 (Scsi_Status);
-    if( !(sstatus & INTERRUPT) )
-        return IRQ_NONE;
-
-    DEBUG1(printk (KERN_DEBUG "sstatus=%02x,", sstatus));
-
-    //DC390_write32 (DMA_ScsiBusCtrl, WRT_ERASE_DMA_STAT | EN_INT_ON_PCI_ABORT);
-    //dstatus = DC390_read8 (DMA_Status);
-    //DC390_write32 (DMA_ScsiBusCtrl, EN_INT_ON_PCI_ABORT);
-
-    spin_lock_irq(pACB->pScsiHost->host_lock);
-
-    istate = DC390_read8 (Intern_State);
-    istatus = DC390_read8 (INT_Status); /* This clears Scsi_Status, Intern_State and INT_Status ! */
-
-    DEBUG1(printk (KERN_INFO "Istatus(Res,Inv,Dis,Serv,Succ,ReS,SelA,Sel)=%02x,",istatus));
-    dc390_laststatus &= ~0x00ffffff;
-    dc390_laststatus |= /* dstatus<<24 | */ sstatus<<16 | istate<<8 | istatus;
-
-    if (sstatus & ILLEGAL_OP_ERR)
-    {
-        printk ("DC390: Illegal Operation detected (%08x)!\n", dc390_laststatus);
-        dc390_dumpinfo (pACB, pACB->pActiveDCB, pACB->pActiveDCB->pActiveSRB);
-    }
-        
-    else if (istatus &  INVALID_CMD)
-    {
-        printk ("DC390: Invalid Command detected (%08x)!\n", dc390_laststatus);
-        dc390_InvalidCmd( pACB );
-        goto unlock;
-    }
-
-    if (istatus &  SCSI_RESET)
-    {
-        dc390_ScsiRstDetect( pACB );
-        goto unlock;
-    }
-
-    if (istatus &  DISCONNECTED)
-    {
-        dc390_Disconnect( pACB );
-        goto unlock;
-    }
-
-    if (istatus &  RESELECTED)
-    {
-        dc390_Reselect( pACB );
-        goto unlock;
-    }
-
-    else if (istatus & (SELECTED | SEL_ATTENTION))
-    {
-        printk (KERN_ERR "DC390: Target mode not supported!\n");
-        goto unlock;
-    }
-
-    if (istatus & (SUCCESSFUL_OP|SERVICE_REQUEST) )
-    {
-        pDCB = pACB->pActiveDCB;
-        if (!pDCB)
-        {
-                printk (KERN_ERR "DC390: Suc. op/ Serv. req: pActiveDCB = 0!\n");
-                goto unlock;
-        }
-        pSRB = pDCB->pActiveSRB;
-        if( pDCB->DCBFlag & ABORT_DEV_ )
-          dc390_EnableMsgOut_Abort (pACB, pSRB);
-
-        phase = pSRB->ScsiPhase;
-        DEBUG1(printk (KERN_INFO "DC390: [%i]%s(0) (%02x)\n", phase, dc390_p0_str[phase], sstatus));
-        stateV = (void *) dc390_phase0[phase];
-        ( *stateV )( pACB, pSRB, &sstatus );
-
-        pSRB->ScsiPhase = sstatus & 7;
-        phase = (u8) sstatus & 7;
-        DEBUG1(printk (KERN_INFO "DC390: [%i]%s(1) (%02x)\n", phase, dc390_p1_str[phase], sstatus));
-        stateV = (void *) dc390_phase1[phase];
-        ( *stateV )( pACB, pSRB, &sstatus );
-    }
-
- unlock:
-    spin_unlock_irq(pACB->pScsiHost->host_lock);
-    return IRQ_HANDLED;
-}
-
-static irqreturn_t do_DC390_Interrupt(int irq, void *dev_id)
-{
-    irqreturn_t ret;
-    DEBUG1(printk (KERN_INFO "DC390: Irq (%i) caught: ", irq));
-    /* Locking is done in DC390_Interrupt */
-    ret = DC390_Interrupt(dev_id);
-    DEBUG1(printk (".. IRQ returned\n"));
-    return ret;
-}
-
-static void
-dc390_DataOut_0(struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    u8   sstatus;
-    u32  ResidCnt;
-    u8   dstate = 0;
-
-    sstatus = *psstatus;
-
-    if( !(pSRB->SRBState & SRB_XFERPAD) )
-    {
-        if( sstatus & (PARITY_ERR | ILLEGAL_OP_ERR) )
-            pSRB->SRBStatus |= PARITY_ERROR;
-
-        if( sstatus & COUNT_2_ZERO )
-        {
-            unsigned long timeout = jiffies + HZ;
-
-            /* Function called from the ISR with the host_lock held and interrupts disabled */
-            if (pSRB->SGToBeXferLen)
-                while (time_before(jiffies, timeout) && !((dstate = DC390_read8 (DMA_Status)) & DMA_XFER_DONE)) {
-                    spin_unlock_irq(pACB->pScsiHost->host_lock);
-                    udelay(50);
-                    spin_lock_irq(pACB->pScsiHost->host_lock);
-                }
-            if (!time_before(jiffies, timeout))
-                printk (KERN_CRIT "DC390: Deadlock in DataOut_0: DMA aborted unfinished: %06x bytes remain!!\n",
-                        DC390_read32 (DMA_Wk_ByteCntr));
-            dc390_laststatus &= ~0xff000000;
-            dc390_laststatus |= dstate << 24;
-            pSRB->TotalXferredLen += pSRB->SGToBeXferLen;
-            pSRB->SGIndex++;
-            if( pSRB->SGIndex < pSRB->SGcount )
-            {
-                pSRB->pSegmentList++;
-
-                dc390_start_segment(pSRB);
-            }
-            else
-                pSRB->SGToBeXferLen = 0;
-        }
-        else
-        {
-            ResidCnt = ((u32) DC390_read8 (Current_Fifo) & 0x1f) +
-                    (((u32) DC390_read8 (CtcReg_High) << 16) |
-                     ((u32) DC390_read8 (CtcReg_Mid) << 8) |
-                     (u32) DC390_read8 (CtcReg_Low));
-
-            dc390_advance_segment(pSRB, ResidCnt);
-        }
-    }
-    if ((*psstatus & 7) != SCSI_DATA_OUT)
-    {
-            DC390_write8 (DMA_Cmd, WRITE_DIRECTION+DMA_IDLE_CMD);
-            DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-    }       
-}
-
-static void
-dc390_DataIn_0(struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    u8   sstatus, residual, bval;
-    u32  ResidCnt, i;
-    unsigned long   xferCnt;
-
-    sstatus = *psstatus;
-
-    if( !(pSRB->SRBState & SRB_XFERPAD) )
-    {
-        if( sstatus & (PARITY_ERR | ILLEGAL_OP_ERR))
-            pSRB->SRBStatus |= PARITY_ERROR;
-
-        if( sstatus & COUNT_2_ZERO )
-        {
-            int dstate = 0;
-            unsigned long timeout = jiffies + HZ;
-
-            /* Function called from the ISR with the host_lock held and interrupts disabled */
-            if (pSRB->SGToBeXferLen)
-                while (time_before(jiffies, timeout) && !((dstate = DC390_read8 (DMA_Status)) & DMA_XFER_DONE)) {
-                    spin_unlock_irq(pACB->pScsiHost->host_lock);
-                    udelay(50);
-                    spin_lock_irq(pACB->pScsiHost->host_lock);
-                }
-            if (!time_before(jiffies, timeout)) {
-                printk (KERN_CRIT "DC390: Deadlock in DataIn_0: DMA aborted unfinished: %06x bytes remain!!\n",
-                        DC390_read32 (DMA_Wk_ByteCntr));
-                printk (KERN_CRIT "DC390: DataIn_0: DMA State: %i\n", dstate);
-            }
-            dc390_laststatus &= ~0xff000000;
-            dc390_laststatus |= dstate << 24;
-            DEBUG1(ResidCnt = ((unsigned long) DC390_read8 (CtcReg_High) << 16) \
-                + ((unsigned long) DC390_read8 (CtcReg_Mid) << 8)               \
-                + ((unsigned long) DC390_read8 (CtcReg_Low)));
-            DEBUG1(printk (KERN_DEBUG "Count_2_Zero (ResidCnt=%u,ToBeXfer=%lu),", ResidCnt, pSRB->SGToBeXferLen));
-
-            DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD);
-
-            pSRB->TotalXferredLen += pSRB->SGToBeXferLen;
-            pSRB->SGIndex++;
-            if( pSRB->SGIndex < pSRB->SGcount )
-            {
-                pSRB->pSegmentList++;
-
-                dc390_start_segment(pSRB);
-            }
-            else
-                pSRB->SGToBeXferLen = 0;
-        }
-        else    /* phase changed */
-        {
-            residual = 0;
-            bval = DC390_read8 (Current_Fifo);
-            while( bval & 0x1f )
-            {
-                DEBUG1(printk (KERN_DEBUG "Check for residuals,"));
-                if( (bval & 0x1f) == 1 )
-                {
-                    for(i=0; i < 0x100; i++)
-                    {
-                        bval = DC390_read8 (Current_Fifo);
-                        if( !(bval & 0x1f) )
-                            goto din_1;
-                        else if( i == 0x0ff )
-                        {
-                            residual = 1;   /* ;1 residual byte */
-                            goto din_1;
-                        }
-                    }
-                }
-                else
-                    bval = DC390_read8 (Current_Fifo);
-            }
-din_1:
-            DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_BLAST_CMD);
-            for (i = 0xa000; i; i--)
-            {
-                bval = DC390_read8 (DMA_Status);
-                if (bval & BLAST_COMPLETE)
-                    break;
-            }
-            /* It seems a DMA Blast abort isn't that bad ... */
-            if (!i) printk (KERN_ERR "DC390: DMA Blast aborted unfinished!\n");
-            //DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD);
-            dc390_laststatus &= ~0xff000000;
-            dc390_laststatus |= bval << 24;
-
-            DEBUG1(printk (KERN_DEBUG "Blast: Read %i times DMA_Status %02x", 0xa000-i, bval));
-            ResidCnt = (((u32) DC390_read8 (CtcReg_High) << 16) |
-                        ((u32) DC390_read8 (CtcReg_Mid) << 8)) |
-                    (u32) DC390_read8 (CtcReg_Low);
-
-            xferCnt = dc390_advance_segment(pSRB, ResidCnt);
-
-            if (residual) {
-                size_t count = 1;
-                size_t offset = pSRB->SGBusAddr - sg_dma_address(pSRB->pSegmentList);
-                unsigned long flags;
-                u8 *ptr;
-
-                bval = DC390_read8 (ScsiFifo);      /* get one residual byte */
-
-                local_irq_save(flags);
-                ptr = scsi_kmap_atomic_sg(pSRB->pSegmentList, pSRB->SGcount, &offset, &count);
-                if (likely(ptr)) {
-                        *(ptr + offset) = bval;
-                        scsi_kunmap_atomic_sg(ptr);
-                }
-                local_irq_restore(flags);
-                WARN_ON(!ptr);
-
-                /* 1 more byte read */
-                xferCnt += dc390_advance_segment(pSRB, pSRB->SGToBeXferLen - 1);
-            }
-            DEBUG1(printk (KERN_DEBUG "Xfered: %lu, Total: %lu, Remaining: %lu\n", xferCnt,\
-                           pSRB->TotalXferredLen, pSRB->SGToBeXferLen));
-        }
-    }
-    if ((*psstatus & 7) != SCSI_DATA_IN)
-    {
-            DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-            DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD);
-    }
-}
-
-static void
-dc390_Command_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-}
-
-static void
-dc390_Status_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-
-    pSRB->TargetStatus = DC390_read8 (ScsiFifo);
-    //udelay (1);
-    pSRB->EndMessage = DC390_read8 (ScsiFifo);  /* get message */
-
-    *psstatus = SCSI_NOP0;
-    pSRB->SRBState = SRB_COMPLETED;
-    DC390_write8 (ScsiCmd, MSG_ACCEPTED_CMD);
-}
-
-static void
-dc390_MsgOut_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    if( pSRB->SRBState & (SRB_UNEXPECT_RESEL+SRB_ABORT_SENT) )
-        *psstatus = SCSI_NOP0;
-    //DC390_write8 (DMA_Cmd, DMA_IDLE_CMD);
-}
-
-
-static void __inline__
-dc390_reprog (struct dc390_acb* pACB, struct dc390_dcb* pDCB)
-{
-  DC390_write8 (Sync_Period, pDCB->SyncPeriod);
-  DC390_write8 (Sync_Offset, pDCB->SyncOffset);
-  DC390_write8 (CtrlReg3, pDCB->CtrlR3);
-  DC390_write8 (CtrlReg4, pDCB->CtrlR4);
-  dc390_SetXferRate (pACB, pDCB);
-}
-
-
-#ifdef DC390_DEBUG0
-static void
-dc390_printMsg (u8 *MsgBuf, u8 len)
-{
-  int i;
-  printk (" %02x", MsgBuf[0]);
-  for (i = 1; i < len; i++)
-    printk (" %02x", MsgBuf[i]);
-  printk ("\n");
-}
-#endif
-
-#define DC390_ENABLE_MSGOUT DC390_write8 (ScsiCmd, SET_ATN_CMD)
-
-/* reject_msg */
-static void __inline__
-dc390_MsgIn_reject (struct dc390_acb* pACB, struct dc390_srb* pSRB)
-{
-  pSRB->MsgOutBuf[0] = MESSAGE_REJECT;
-  pSRB->MsgCnt = 1;
-  DC390_ENABLE_MSGOUT;
-  DEBUG0 (printk (KERN_INFO "DC390: Reject message\n"));
-}
-
-/* abort command */
-static void
-dc390_EnableMsgOut_Abort ( struct dc390_acb* pACB, struct dc390_srb* pSRB )
-{
-    pSRB->MsgOutBuf[0] = ABORT; 
-    pSRB->MsgCnt = 1; DC390_ENABLE_MSGOUT;
-    pSRB->pSRBDCB->DCBFlag &= ~ABORT_DEV_;
-}
-
-static struct dc390_srb*
-dc390_MsgIn_QTag (struct dc390_acb* pACB, struct dc390_dcb* pDCB, s8 tag)
-{
-  struct dc390_srb* pSRB = pDCB->pGoingSRB;
-
-  if (pSRB)
-    {
-        struct scsi_cmnd *scmd = scsi_find_tag(pSRB->pcmd->device, tag);
-        pSRB = (struct dc390_srb *)scmd->host_scribble;
-
-        if (pDCB->DCBFlag & ABORT_DEV_)
-        {
-          pSRB->SRBState = SRB_ABORT_SENT;
-          dc390_EnableMsgOut_Abort( pACB, pSRB );
-        }
-
-        if (!(pSRB->SRBState & SRB_DISCONNECT))
-                goto mingx0;
-
-        pDCB->pActiveSRB = pSRB;
-        pSRB->SRBState = SRB_DATA_XFER;
-    }
-  else
-    {
-    mingx0:
-      pSRB = pACB->pTmpSRB;
-      pSRB->SRBState = SRB_UNEXPECT_RESEL;
-      pDCB->pActiveSRB = pSRB;
-      pSRB->MsgOutBuf[0] = ABORT_TAG;
-      pSRB->MsgCnt = 1; DC390_ENABLE_MSGOUT;
-    }
-  return pSRB;
-}
-
-
-/* set async transfer mode */
-static void 
-dc390_MsgIn_set_async (struct dc390_acb* pACB, struct dc390_srb* pSRB)
-{
-  struct dc390_dcb* pDCB = pSRB->pSRBDCB;
-  if (!(pSRB->SRBState & DO_SYNC_NEGO)) 
-    printk (KERN_INFO "DC390: Target %i initiates Non-Sync?\n", pDCB->TargetID);
-  pSRB->SRBState &= ~DO_SYNC_NEGO;
-  pDCB->SyncMode &= ~(SYNC_ENABLE+SYNC_NEGO_DONE);
-  pDCB->SyncPeriod = 0;
-  pDCB->SyncOffset = 0;
-  //pDCB->NegoPeriod = 50; /* 200ns <=> 5 MHz */
-  pDCB->CtrlR3 = FAST_CLK;      /* fast clock / normal scsi */
-  pDCB->CtrlR4 &= 0x3f;
-  pDCB->CtrlR4 |= pACB->glitch_cfg;     /* glitch eater */
-  dc390_reprog (pACB, pDCB);
-}
-
-/* set sync transfer mode */
-static void
-dc390_MsgIn_set_sync (struct dc390_acb* pACB, struct dc390_srb* pSRB)
-{
-  u8 bval;
-  u16 wval, wval1;
-  struct dc390_dcb* pDCB = pSRB->pSRBDCB;
-  u8 oldsyncperiod = pDCB->SyncPeriod;
-  u8 oldsyncoffset = pDCB->SyncOffset;
-  
-  if (!(pSRB->SRBState & DO_SYNC_NEGO))
-    {
-      printk (KERN_INFO "DC390: Target %i initiates Sync: %ins %i ... answer ...\n", 
-              pDCB->TargetID, pSRB->MsgInBuf[3]<<2, pSRB->MsgInBuf[4]);
-
-      /* reject */
-      //dc390_MsgIn_reject (pACB, pSRB);
-      //return dc390_MsgIn_set_async (pACB, pSRB);
-
-      /* Reply with corrected SDTR Message */
-      if (pSRB->MsgInBuf[4] > 15)
-        { 
-          printk (KERN_INFO "DC390: Lower Sync Offset to 15\n");
-          pSRB->MsgInBuf[4] = 15;
-        }
-      if (pSRB->MsgInBuf[3] < pDCB->NegoPeriod)
-        {
-          printk (KERN_INFO "DC390: Set sync nego period to %ins\n", pDCB->NegoPeriod << 2);
-          pSRB->MsgInBuf[3] = pDCB->NegoPeriod;
-        }
-      memcpy (pSRB->MsgOutBuf, pSRB->MsgInBuf, 5);
-      pSRB->MsgCnt = 5;
-      DC390_ENABLE_MSGOUT;
-    }
-
-  pSRB->SRBState &= ~DO_SYNC_NEGO;
-  pDCB->SyncMode |= SYNC_ENABLE+SYNC_NEGO_DONE;
-  pDCB->SyncOffset &= 0x0f0;
-  pDCB->SyncOffset |= pSRB->MsgInBuf[4];
-  pDCB->NegoPeriod = pSRB->MsgInBuf[3];
-
-  wval = (u16) pSRB->MsgInBuf[3];
-  wval = wval << 2; wval -= 3; wval1 = wval / 25;       /* compute speed */
-  if( (wval1 * 25) != wval) wval1++;
-  bval = FAST_CLK+FAST_SCSI;    /* fast clock / fast scsi */
-
-  pDCB->CtrlR4 &= 0x3f;         /* Glitch eater: 12ns less than normal */
-  if (pACB->glitch_cfg != NS_TO_GLITCH(0))
-    pDCB->CtrlR4 |= NS_TO_GLITCH(((GLITCH_TO_NS(pACB->glitch_cfg)) - 1));
-  else
-    pDCB->CtrlR4 |= NS_TO_GLITCH(0);
-  if (wval1 < 4) pDCB->CtrlR4 |= NS_TO_GLITCH(0); /* Ultra */
-
-  if (wval1 >= 8)
-    {
-      wval1--;  /* Timing computation differs by 1 from FAST_SCSI */
-      bval = FAST_CLK;          /* fast clock / normal scsi */
-      pDCB->CtrlR4 |= pACB->glitch_cfg;         /* glitch eater */
-    }
-
-  pDCB->CtrlR3 = bval;
-  pDCB->SyncPeriod = (u8)wval1;
-  
-  if ((oldsyncperiod != wval1 || oldsyncoffset != pDCB->SyncOffset) && pDCB->TargetLUN == 0)
-    {
-      if (! (bval & FAST_SCSI)) wval1++;
-      printk (KERN_INFO "DC390: Target %i: Sync transfer %i.%1i MHz, Offset %i\n", pDCB->TargetID, 
-              40/wval1, ((40%wval1)*10+wval1/2)/wval1, pDCB->SyncOffset & 0x0f);
-    }
-  
-  dc390_reprog (pACB, pDCB);
-}
-
-
-/* handle RESTORE_PTR */
-/* This doesn't look very healthy... to-be-fixed */
-static void 
-dc390_restore_ptr (struct dc390_acb* pACB, struct dc390_srb* pSRB)
-{
-    struct scsi_cmnd *pcmd = pSRB->pcmd;
-    struct scatterlist *psgl;
-    pSRB->TotalXferredLen = 0;
-    pSRB->SGIndex = 0;
-    if (scsi_sg_count(pcmd)) {
-        size_t saved;
-        pSRB->pSegmentList = scsi_sglist(pcmd);
-        psgl = pSRB->pSegmentList;
-        //dc390_pci_sync(pSRB);
-
-        while (pSRB->TotalXferredLen + (unsigned long) sg_dma_len(psgl) < pSRB->Saved_Ptr)
-        {
-            pSRB->TotalXferredLen += (unsigned long) sg_dma_len(psgl);
-            pSRB->SGIndex++;
-            if( pSRB->SGIndex < pSRB->SGcount )
-            {
-                pSRB->pSegmentList++;
-
-                dc390_start_segment(pSRB);
-            }
-            else
-                pSRB->SGToBeXferLen = 0;
-        }
-
-        saved = pSRB->Saved_Ptr - pSRB->TotalXferredLen;
-        pSRB->SGToBeXferLen -= saved;
-        pSRB->SGBusAddr += saved;
-        printk (KERN_INFO "DC390: Pointer restored. Segment %i, Total %li, Bus %08lx\n",
-                pSRB->SGIndex, pSRB->Saved_Ptr, pSRB->SGBusAddr);
-
-    } else {
-         pSRB->SGcount = 0;
-         printk (KERN_INFO "DC390: RESTORE_PTR message for Transfer without Scatter-Gather ??\n");
-    }
-
-  pSRB->TotalXferredLen = pSRB->Saved_Ptr;
-}
-
-
-/* According to the docs, the AM53C974 reads the message and 
- * generates a Successful Operation IRQ before asserting ACK for
- * the last byte (how does it know whether it's the last ?) */
-/* The old code handled it in another way, indicating, that on
- * every message byte an IRQ is generated and every byte has to
- * be manually ACKed. Hmmm ?  (KG, 98/11/28) */
-/* The old implementation was correct. Sigh! */
-
-/* Check if the message is complete */
-static u8 __inline__
-dc390_MsgIn_complete (u8 *msgbuf, u32 len)
-{ 
-  if (*msgbuf == EXTENDED_MESSAGE)
-  {
-        if (len < 2) return 0;
-        if (len < msgbuf[1] + 2) return 0;
-  }
-  else if (*msgbuf >= 0x20 && *msgbuf <= 0x2f) // two byte messages
-        if (len < 2) return 0;
-  return 1;
-}
-
-
-
-/* read and eval received messages */
-static void
-dc390_MsgIn_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    struct dc390_dcb*   pDCB = pACB->pActiveDCB;
-
-    /* Read the msg */
-
-    pSRB->MsgInBuf[pACB->MsgLen++] = DC390_read8 (ScsiFifo);
-    //pSRB->SRBState = 0;
-
-    /* Msg complete ? */
-    if (dc390_MsgIn_complete (pSRB->MsgInBuf, pACB->MsgLen))
-      {
-        DEBUG0 (printk (KERN_INFO "DC390: MsgIn:"); dc390_printMsg (pSRB->MsgInBuf, pACB->MsgLen));
-        /* Now eval the msg */
-        switch (pSRB->MsgInBuf[0]) 
-          {
-          case DISCONNECT: 
-            pSRB->SRBState = SRB_DISCONNECT; break;
-            
-          case SIMPLE_QUEUE_TAG:
-          case HEAD_OF_QUEUE_TAG:
-          case ORDERED_QUEUE_TAG:
-            pSRB = dc390_MsgIn_QTag (pACB, pDCB, pSRB->MsgInBuf[1]);
-            break;
-            
-          case MESSAGE_REJECT: 
-            DC390_write8 (ScsiCmd, RESET_ATN_CMD);
-            pDCB->NegoPeriod = 50; /* 200ns <=> 5 MHz */
-            if( pSRB->SRBState & DO_SYNC_NEGO)
-              dc390_MsgIn_set_async (pACB, pSRB);
-            break;
-            
-          case EXTENDED_MESSAGE:
-            /* reject every extended msg but SDTR */
-            if (pSRB->MsgInBuf[1] != 3 || pSRB->MsgInBuf[2] != EXTENDED_SDTR)
-              dc390_MsgIn_reject (pACB, pSRB);
-            else
-              {
-                if (pSRB->MsgInBuf[3] == 0 || pSRB->MsgInBuf[4] == 0)
-                  dc390_MsgIn_set_async (pACB, pSRB);
-                else
-                  dc390_MsgIn_set_sync (pACB, pSRB);
-              }
-            
-            // nothing has to be done
-          case COMMAND_COMPLETE: break;
-            
-            // SAVE POINTER may be ignored as we have the struct dc390_srb* associated with the
-            // scsi command. Thanks, Gerard, for pointing it out.
-          case SAVE_POINTERS: 
-            pSRB->Saved_Ptr = pSRB->TotalXferredLen;
-            break;
-            // The device might want to restart transfer with a RESTORE
-          case RESTORE_POINTERS:
-            DEBUG0(printk ("DC390: RESTORE POINTER message received ... try to handle\n"));
-            dc390_restore_ptr (pACB, pSRB);
-            break;
-
-            // reject unknown messages
-          default: dc390_MsgIn_reject (pACB, pSRB);
-          }
-        
-        /* Clear counter and MsgIn state */
-        pSRB->SRBState &= ~SRB_MSGIN;
-        pACB->MsgLen = 0;
-      }
-
-    *psstatus = SCSI_NOP0;
-    DC390_write8 (ScsiCmd, MSG_ACCEPTED_CMD);
-    //DC390_write8 (DMA_Cmd, DMA_IDLE_CMD);
-}
-
-
-static void
-dc390_DataIO_Comm( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 ioDir)
-{
-    unsigned long  lval;
-    struct dc390_dcb*   pDCB = pACB->pActiveDCB;
-
-    if (pSRB == pACB->pTmpSRB)
-    {
-        if (pDCB)
-                printk(KERN_ERR "DC390: pSRB == pTmpSRB! (TagQ Error?) (%02i-%i)\n", pDCB->TargetID, pDCB->TargetLUN);
-        else
-                printk(KERN_ERR "DC390: pSRB == pTmpSRB! (TagQ Error?) (DCB 0!)\n");
-
-        /* Try to recover - some broken disks react badly to tagged INQUIRY */
-        if (pDCB && pACB->scan_devices && pDCB->GoingSRBCnt == 1) {
-                pSRB = pDCB->pGoingSRB;
-                pDCB->pActiveSRB = pSRB;
-        } else {
-                pSRB->pSRBDCB = pDCB;
-                dc390_EnableMsgOut_Abort(pACB, pSRB);
-                if (pDCB)
-                        pDCB->DCBFlag |= ABORT_DEV;
-                return;
-        }
-    }
-
-    if( pSRB->SGIndex < pSRB->SGcount )
-    {
-        DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir);
-        if( !pSRB->SGToBeXferLen )
-        {
-            dc390_start_segment(pSRB);
-
-            DEBUG1(printk (KERN_DEBUG " DC390: Next SG segment."));
-        }
-        lval = pSRB->SGToBeXferLen;
-        DEBUG1(printk (KERN_DEBUG " DC390: Start transfer: %li bytes (address %08lx)\n", lval, pSRB->SGBusAddr));
-        DC390_write8 (CtcReg_Low, (u8) lval);
-        lval >>= 8;
-        DC390_write8 (CtcReg_Mid, (u8) lval);
-        lval >>= 8;
-        DC390_write8 (CtcReg_High, (u8) lval);
-
-        DC390_write32 (DMA_XferCnt, pSRB->SGToBeXferLen);
-        DC390_write32 (DMA_XferAddr, pSRB->SGBusAddr);
-
-        //DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir);
-        pSRB->SRBState = SRB_DATA_XFER;
-
-        DC390_write8 (ScsiCmd, DMA_COMMAND+INFO_XFER_CMD);
-
-        DC390_write8 (DMA_Cmd, DMA_START_CMD | ioDir);
-        //DEBUG1(DC390_write32 (DMA_ScsiBusCtrl, WRT_ERASE_DMA_STAT | EN_INT_ON_PCI_ABORT));
-        //DEBUG1(printk (KERN_DEBUG "DC390: DMA_Status: %02x\n", DC390_read8 (DMA_Status)));
-        //DEBUG1(DC390_write32 (DMA_ScsiBusCtrl, EN_INT_ON_PCI_ABORT));
-    }
-    else    /* xfer pad */
-    {
-        if( pSRB->SGcount )
-        {
-            pSRB->AdaptStatus = H_OVER_UNDER_RUN;
-            pSRB->SRBStatus |= OVER_RUN;
-            DEBUG0(printk (KERN_WARNING " DC390: Overrun -"));
-        }
-        DEBUG0(printk (KERN_WARNING " Clear transfer pad \n"));
-        DC390_write8 (CtcReg_Low, 0);
-        DC390_write8 (CtcReg_Mid, 0);
-        DC390_write8 (CtcReg_High, 0);
-
-        pSRB->SRBState |= SRB_XFERPAD;
-        DC390_write8 (ScsiCmd, DMA_COMMAND+XFER_PAD_BYTE);
-/*
-        DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir);
-        DC390_write8 (DMA_Cmd, DMA_START_CMD | ioDir);
-*/
-    }
-}
-
-
-static void
-dc390_DataOutPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    dc390_DataIO_Comm (pACB, pSRB, WRITE_DIRECTION);
-}
-
-static void
-dc390_DataInPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    dc390_DataIO_Comm (pACB, pSRB, READ_DIRECTION);
-}
-
-static void
-dc390_CommandPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    struct dc390_dcb*   pDCB;
-    u8  i, cnt;
-    u8     *ptr;
-
-    DC390_write8 (ScsiCmd, RESET_ATN_CMD);
-    DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-    if( !(pSRB->SRBFlag & AUTO_REQSENSE) )
-    {
-        cnt = (u8) pSRB->pcmd->cmd_len;
-        ptr = (u8 *) pSRB->pcmd->cmnd;
-        for(i=0; i < cnt; i++)
-            DC390_write8 (ScsiFifo, *(ptr++));
-    }
-    else
-    {
-        DC390_write8 (ScsiFifo, REQUEST_SENSE);
-        pDCB = pACB->pActiveDCB;
-        DC390_write8 (ScsiFifo, pDCB->TargetLUN << 5);
-        DC390_write8 (ScsiFifo, 0);
-        DC390_write8 (ScsiFifo, 0);
-        DC390_write8 (ScsiFifo, SCSI_SENSE_BUFFERSIZE);
-        DC390_write8 (ScsiFifo, 0);
-        DEBUG0(printk(KERN_DEBUG "DC390: AutoReqSense (CmndPhase)!\n"));
-    }
-    pSRB->SRBState = SRB_COMMAND;
-    DC390_write8 (ScsiCmd, INFO_XFER_CMD);
-}
-
-static void
-dc390_StatusPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-    pSRB->SRBState = SRB_STATUS;
-    DC390_write8 (ScsiCmd, INITIATOR_CMD_CMPLTE);
-    //DC390_write8 (DMA_Cmd, DMA_IDLE_CMD);
-}
-
-static void
-dc390_MsgOutPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    u8   bval, i, cnt;
-    u8     *ptr;
-    struct dc390_dcb*    pDCB;
-
-    DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-    pDCB = pACB->pActiveDCB;
-    if( !(pSRB->SRBState & SRB_MSGOUT) )
-    {
-        cnt = pSRB->MsgCnt;
-        if( cnt )
-        {
-            ptr = (u8 *) pSRB->MsgOutBuf;
-            for(i=0; i < cnt; i++)
-                DC390_write8 (ScsiFifo, *(ptr++));
-            pSRB->MsgCnt = 0;
-            if( (pDCB->DCBFlag & ABORT_DEV_) &&
-                (pSRB->MsgOutBuf[0] == ABORT) )
-                pSRB->SRBState = SRB_ABORT_SENT;
-        }
-        else
-        {
-            bval = ABORT;       /* ??? MSG_NOP */
-            if( (pSRB->pcmd->cmnd[0] == INQUIRY ) ||
-                (pSRB->pcmd->cmnd[0] == REQUEST_SENSE) ||
-                (pSRB->SRBFlag & AUTO_REQSENSE) )
-            {
-                if( pDCB->SyncMode & SYNC_ENABLE )
-                    goto  mop1;
-            }
-            DC390_write8 (ScsiFifo, bval);
-        }
-        DC390_write8 (ScsiCmd, INFO_XFER_CMD);
-    }
-    else
-    {
-mop1:
-        printk (KERN_ERR "DC390: OLD Sync Nego code triggered! (%i %i)\n", pDCB->TargetID, pDCB->TargetLUN);
-        DC390_write8 (ScsiFifo, EXTENDED_MESSAGE);
-        DC390_write8 (ScsiFifo, 3);     /*    ;length of extended msg */
-        DC390_write8 (ScsiFifo, EXTENDED_SDTR); /*    ; sync nego */
-        DC390_write8 (ScsiFifo, pDCB->NegoPeriod);
-        if (pDCB->SyncOffset & 0x0f)
-                    DC390_write8 (ScsiFifo, pDCB->SyncOffset);
-        else
-                    DC390_write8 (ScsiFifo, SYNC_NEGO_OFFSET);              
-        pSRB->SRBState |= DO_SYNC_NEGO;
-        DC390_write8 (ScsiCmd, INFO_XFER_CMD);
-    }
-}
-
-static void
-dc390_MsgInPhase( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-    DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-    if( !(pSRB->SRBState & SRB_MSGIN) )
-    {
-        pSRB->SRBState &= ~SRB_DISCONNECT;
-        pSRB->SRBState |= SRB_MSGIN;
-    }
-    DC390_write8 (ScsiCmd, INFO_XFER_CMD);
-    //DC390_write8 (DMA_Cmd, DMA_IDLE_CMD);
-}
-
-static void
-dc390_Nop_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-}
-
-static void
-dc390_Nop_1( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
-{
-}
-
-
-static void
-dc390_SetXferRate( struct dc390_acb* pACB, struct dc390_dcb* pDCB )
-{
-    u8  bval, i, cnt;
-    struct dc390_dcb*   ptr;
-
-    if( !(pDCB->TargetLUN) )
-    {
-        if( !pACB->scan_devices )
-        {
-            ptr = pACB->pLinkDCB;
-            cnt = pACB->DCBCnt;
-            bval = pDCB->TargetID;
-            for(i=0; i<cnt; i++)
-            {
-                if( ptr->TargetID == bval )
-                {
-                    ptr->SyncPeriod = pDCB->SyncPeriod;
-                    ptr->SyncOffset = pDCB->SyncOffset;
-                    ptr->CtrlR3 = pDCB->CtrlR3;
-                    ptr->CtrlR4 = pDCB->CtrlR4;
-                    ptr->SyncMode = pDCB->SyncMode;
-                }
-                ptr = ptr->pNextDCB;
-            }
-        }
-    }
-    return;
-}
-
-
-static void
-dc390_Disconnect( struct dc390_acb* pACB )
-{
-    struct dc390_dcb *pDCB;
-    struct dc390_srb *pSRB, *psrb;
-    u8  i, cnt;
-
-    DEBUG0(printk(KERN_INFO "DISC,"));
-
-    if (!pACB->Connected) printk(KERN_ERR "DC390: Disconnect not-connected bus?\n");
-    pACB->Connected = 0;
-    pDCB = pACB->pActiveDCB;
-    if (!pDCB)
-     {
-        DEBUG0(printk(KERN_ERR "ACB:%p->ActiveDCB:%p IOPort:%04x IRQ:%02x !\n",\
-               pACB, pDCB, pACB->IOPortBase, pACB->IRQLevel));
-        mdelay(400);
-        DC390_read8 (INT_Status);       /* Reset Pending INT */
-        DC390_write8 (ScsiCmd, EN_SEL_RESEL);
-        return;
-     }
-    DC390_write8 (ScsiCmd, EN_SEL_RESEL);
-    pSRB = pDCB->pActiveSRB;
-    pACB->pActiveDCB = NULL;
-    pSRB->ScsiPhase = SCSI_NOP0;
-    if( pSRB->SRBState & SRB_UNEXPECT_RESEL )
-        pSRB->SRBState = 0;
-    else if( pSRB->SRBState & SRB_ABORT_SENT )
-    {
-        pDCB->TagMask = 0;
-        pDCB->DCBFlag = 0;
-        cnt = pDCB->GoingSRBCnt;
-        pDCB->GoingSRBCnt = 0;
-        pSRB = pDCB->pGoingSRB;
-        for( i=0; i < cnt; i++)
-        {
-            psrb = pSRB->pNextSRB;
-            dc390_Free_insert (pACB, pSRB);
-            pSRB = psrb;
-        }
-        pDCB->pGoingSRB = NULL;
-    }
-    else
-    {
-        if( (pSRB->SRBState & (SRB_START_+SRB_MSGOUT)) ||
-           !(pSRB->SRBState & (SRB_DISCONNECT+SRB_COMPLETED)) )
-        {       /* Selection time out */
-                pSRB->AdaptStatus = H_SEL_TIMEOUT;
-                pSRB->TargetStatus = 0;
-                goto  disc1;
-        }
-        else if (!(pSRB->SRBState & SRB_DISCONNECT) && (pSRB->SRBState & SRB_COMPLETED))
-        {
-disc1:
-            dc390_freetag (pDCB, pSRB);
-            pDCB->pActiveSRB = NULL;
-            pSRB->SRBState = SRB_FREE;
-            dc390_SRBdone( pACB, pDCB, pSRB);
-        }
-    }
-    pACB->MsgLen = 0;
-}
-
-
-static void
-dc390_Reselect( struct dc390_acb* pACB )
-{
-    struct dc390_dcb*   pDCB;
-    struct dc390_srb*   pSRB;
-    u8  id, lun;
-
-    DEBUG0(printk(KERN_INFO "RSEL,"));
-    pACB->Connected = 1;
-    pDCB = pACB->pActiveDCB;
-    if( pDCB )
-    {   /* Arbitration lost but Reselection won */
-        DEBUG0(printk ("DC390: (ActiveDCB != 0: Arb. lost but resel. won)!\n"));
-        pSRB = pDCB->pActiveSRB;
-        if( !( pACB->scan_devices ) )
-        {
-            struct scsi_cmnd *pcmd = pSRB->pcmd;
-            scsi_set_resid(pcmd, scsi_bufflen(pcmd));
-            SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
-            dc390_Going_remove(pDCB, pSRB);
-            dc390_Free_insert(pACB, pSRB);
-            pcmd->scsi_done (pcmd);
-            DEBUG0(printk(KERN_DEBUG"DC390: Return SRB %p to free\n", pSRB));
-        }
-    }
-    /* Get ID */
-    lun = DC390_read8 (ScsiFifo);
-    DEBUG0(printk ("Dev %02x,", lun));
-    if (!(lun & (1 << pACB->pScsiHost->this_id)))
-      printk (KERN_ERR "DC390: Reselection must select host adapter: %02x!\n", lun);
-    else
-      lun ^= 1 << pACB->pScsiHost->this_id; /* Mask AdapterID */
-    id = 0; while (lun >>= 1) id++;
-    /* Get LUN */
-    lun = DC390_read8 (ScsiFifo);
-    if (!(lun & IDENTIFY_BASE)) printk (KERN_ERR "DC390: Resel: Expect identify message!\n");
-    lun &= 7;
-    DEBUG0(printk ("(%02i-%i),", id, lun));
-    pDCB = dc390_findDCB (pACB, id, lun);
-    if (!pDCB)
-    {
-        printk (KERN_ERR "DC390: Reselect from non existing device (%02i-%i)\n",
-                    id, lun);
-        return;
-    }
-    pACB->pActiveDCB = pDCB;
-    /* TagQ: We expect a message soon, so never mind the exact SRB */
-    if( pDCB->SyncMode & EN_TAG_QUEUEING )
-    {
-        pSRB = pACB->pTmpSRB;
-        pDCB->pActiveSRB = pSRB;
-    }
-    else
-    {
-        pSRB = pDCB->pActiveSRB;
-        if( !pSRB || !(pSRB->SRBState & SRB_DISCONNECT) )
-        {
-            pSRB= pACB->pTmpSRB;
-            pSRB->SRBState = SRB_UNEXPECT_RESEL;
-            printk (KERN_ERR "DC390: Reselect without outstanding cmnd (%02i-%i)\n",
-                    id, lun);
-            pDCB->pActiveSRB = pSRB;
-            dc390_EnableMsgOut_Abort ( pACB, pSRB );
-        }
-        else
-        {
-            if( pDCB->DCBFlag & ABORT_DEV_ )
-            {
-                pSRB->SRBState = SRB_ABORT_SENT;
-                printk (KERN_INFO "DC390: Reselect: Abort (%02i-%i)\n",
-                        id, lun);
-                dc390_EnableMsgOut_Abort( pACB, pSRB );
-            }
-            else
-                pSRB->SRBState = SRB_DATA_XFER;
-        }
-    }
-
-    DEBUG1(printk (KERN_DEBUG "Resel SRB(%p): TagNum (%02x)\n", pSRB, pSRB->TagNumber));
-    pSRB->ScsiPhase = SCSI_NOP0;
-    DC390_write8 (Scsi_Dest_ID, pDCB->TargetID);
-    DC390_write8 (Sync_Period, pDCB->SyncPeriod);
-    DC390_write8 (Sync_Offset, pDCB->SyncOffset);
-    DC390_write8 (CtrlReg1, pDCB->CtrlR1);
-    DC390_write8 (CtrlReg3, pDCB->CtrlR3);
-    DC390_write8 (CtrlReg4, pDCB->CtrlR4);      /* ; Glitch eater */
-    DC390_write8 (ScsiCmd, MSG_ACCEPTED_CMD);   /* ;to release the /ACK signal */
-}
-
-static int __inline__
-dc390_RequestSense(struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb* pSRB)
-{
-        struct scsi_cmnd *pcmd;
-
-        pcmd = pSRB->pcmd;
-
-        REMOVABLEDEBUG(printk(KERN_INFO "DC390: RequestSense(Cmd %02x, Id %02x, LUN %02x)\n",\
-                              pcmd->cmnd[0], pDCB->TargetID, pDCB->TargetLUN));
-
-        pSRB->SRBFlag |= AUTO_REQSENSE;
-        pSRB->SavedTotXLen = pSRB->TotalXferredLen;
-        pSRB->AdaptStatus = 0;
-        pSRB->TargetStatus = 0; /* CHECK_CONDITION<<1; */
-
-        /* We are called from SRBdone, original PCI mapping has been removed
-         * already, new one is set up from StartSCSI */
-        pSRB->SGIndex = 0;
-
-        pSRB->TotalXferredLen = 0;
-        pSRB->SGToBeXferLen = 0;
-        return dc390_StartSCSI(pACB, pDCB, pSRB);
-}
-
-
-static void
-dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb* pSRB )
-{
-    u8 status;
-    struct scsi_cmnd *pcmd;
-
-    pcmd = pSRB->pcmd;
-    /* KG: Moved pci_unmap here */
-    dc390_pci_unmap(pSRB);
-
-    status = pSRB->TargetStatus;
-
-    DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p\n", status, pcmd->result, pSRB));
-    if(pSRB->SRBFlag & AUTO_REQSENSE)
-    {   /* Last command was a Request Sense */
-        pSRB->SRBFlag &= ~AUTO_REQSENSE;
-        pSRB->AdaptStatus = 0;
-        pSRB->TargetStatus = SAM_STAT_CHECK_CONDITION;
-
-        //pcmd->result = MK_RES(DRIVER_SENSE,DID_OK,0,status);
-        if (status == SAM_STAT_CHECK_CONDITION)
-            pcmd->result = MK_RES_LNX(0, DID_BAD_TARGET, 0, /*CHECK_CONDITION*/0);
-        else /* Retry */
-        {
-            if( pSRB->pcmd->cmnd[0] == TEST_UNIT_READY /* || pSRB->pcmd->cmnd[0] == START_STOP */)
-            {
-                /* Don't retry on TEST_UNIT_READY */
-                pcmd->result = MK_RES_LNX(DRIVER_SENSE, DID_OK, 0, SAM_STAT_CHECK_CONDITION);
-                REMOVABLEDEBUG(printk(KERN_INFO "Cmd=%02x, Result=%08x, XferL=%08x\n",pSRB->pcmd->cmnd[0],\
-                       (u32) pcmd->result, (u32) pSRB->TotalXferredLen));
-            } else {
-                SET_RES_DRV(pcmd->result, DRIVER_SENSE);
-                //pSRB->ScsiCmdLen       = (u8) (pSRB->Segment1[0] >> 8);
-                DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, (u8)pcmd->device->lun));
-                pSRB->TotalXferredLen = 0;
-                SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
-            }
-        }
-        goto cmd_done;
-    }
-    if( status )
-    {
-        if (status == SAM_STAT_CHECK_CONDITION)
-        {
-            if (dc390_RequestSense(pACB, pDCB, pSRB)) {
-                SET_RES_DID(pcmd->result, DID_ERROR);
-                goto cmd_done;
-            }
-            return;
-        }
-        else if (status == SAM_STAT_TASK_SET_FULL)
-        {
-            scsi_track_queue_full(pcmd->device, pDCB->GoingSRBCnt - 1);
-            DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, (u8)pcmd->device->lun));
-            pSRB->TotalXferredLen = 0;
-            SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
-        }
-        else if (status == SAM_STAT_BUSY &&
-                 (pcmd->cmnd[0] == TEST_UNIT_READY || pcmd->cmnd[0] == INQUIRY) &&
-                 pACB->scan_devices)
-        {
-            pSRB->AdaptStatus = 0;
-            pSRB->TargetStatus = status;
-            pcmd->result = MK_RES(0,0,pSRB->EndMessage,/*status*/0);
-        }
-        else
-        {   /* Another error */
-            pSRB->TotalXferredLen = 0;
-            SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
-            goto cmd_done;
-        }
-    }
-    else
-    {   /*  Target status == 0 */
-        status = pSRB->AdaptStatus;
-        if (status == H_OVER_UNDER_RUN)
-        {
-            pSRB->TargetStatus = 0;
-            SET_RES_DID(pcmd->result,DID_OK);
-            SET_RES_MSG(pcmd->result,pSRB->EndMessage);
-        }
-        else if (status == H_SEL_TIMEOUT)
-        {
-            pcmd->result = MK_RES(0, DID_NO_CONNECT, 0, 0);
-            /* Devices are removed below ... */
-        }
-        else if( pSRB->SRBStatus & PARITY_ERROR)
-        {
-            //pcmd->result = MK_RES(0,DID_PARITY,pSRB->EndMessage,0);
-            SET_RES_DID(pcmd->result,DID_PARITY);
-            SET_RES_MSG(pcmd->result,pSRB->EndMessage);
-        }
-        else                   /* No error */
-        {
-            pSRB->AdaptStatus = 0;
-            pSRB->TargetStatus = 0;
-            SET_RES_DID(pcmd->result,DID_OK);
-        }
-    }
-
-cmd_done:
-    scsi_set_resid(pcmd, scsi_bufflen(pcmd) - pSRB->TotalXferredLen);
-
-    dc390_Going_remove (pDCB, pSRB);
-    /* Add to free list */
-    dc390_Free_insert (pACB, pSRB);
-
-    DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done\n"));
-    pcmd->scsi_done (pcmd);
-
-    return;
-}
-
-
-/* Remove all SRBs from Going list and inform midlevel */
-static void
-dc390_DoingSRB_Done(struct dc390_acb* pACB, struct scsi_cmnd *cmd)
-{
-    struct dc390_dcb *pDCB, *pdcb;
-    struct dc390_srb *psrb, *psrb2;
-    int i;
-    struct scsi_cmnd *pcmd;
-
-    pDCB = pACB->pLinkDCB;
-    pdcb = pDCB;
-    if (! pdcb) return;
-    do
-    {
-        psrb = pdcb->pGoingSRB;
-        for (i = 0; i < pdcb->GoingSRBCnt; i++)
-        {
-            psrb2 = psrb->pNextSRB;
-            pcmd = psrb->pcmd;
-            dc390_Free_insert (pACB, psrb);
-            psrb  = psrb2;
-        }
-        pdcb->GoingSRBCnt = 0;
-        pdcb->pGoingSRB = NULL;
-        pdcb->TagMask = 0;
-        pdcb = pdcb->pNextDCB;
-    } while( pdcb != pDCB );
-}
-
-
-static void
-dc390_ResetSCSIBus( struct dc390_acb* pACB )
-{
-    //DC390_write8 (ScsiCmd, RST_DEVICE_CMD);
-    //udelay (250);
-    //DC390_write8 (ScsiCmd, NOP_CMD);
-
-    DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-    DC390_write8 (DMA_Cmd, DMA_IDLE_CMD);
-    DC390_write8 (ScsiCmd, RST_SCSI_BUS_CMD);
-    pACB->Connected = 0;
-
-    return;
-}
-
-static void
-dc390_ScsiRstDetect( struct dc390_acb* pACB )
-{
-    printk ("DC390: Rst_Detect: laststat = %08x\n", dc390_laststatus);
-    //DEBUG0(printk(KERN_INFO "RST_DETECT,"));
-
-    DC390_write8 (DMA_Cmd, DMA_IDLE_CMD);
-    /* Unlock before ? */
-    /* delay half a second */
-    udelay (1000);
-    DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-    pACB->last_reset = jiffies + 5*HZ/2
-                    + HZ * dc390_eepromBuf[pACB->AdapterIndex][EE_DELAY];
-    pACB->Connected = 0;
-
-    if( pACB->ACBFlag & RESET_DEV )
-        pACB->ACBFlag |= RESET_DONE;
-    else
-    {   /* Reset was issued by sb else */
-        pACB->ACBFlag |= RESET_DETECT;
-
-        dc390_ResetDevParam( pACB );
-        dc390_DoingSRB_Done( pACB, NULL);
-        //dc390_RecoverSRB( pACB );
-        pACB->pActiveDCB = NULL;
-        pACB->ACBFlag = 0;
-    }
-    return;
-}
-
-static int DC390_queuecommand_lck(struct scsi_cmnd *cmd,
-                void (*done)(struct scsi_cmnd *))
-{
-        struct scsi_device *sdev = cmd->device;
-        struct dc390_acb *acb = (struct dc390_acb *)sdev->host->hostdata;
-        struct dc390_dcb *dcb = sdev->hostdata;
-        struct dc390_srb *srb;
-
-        if (sdev->queue_depth <= dcb->GoingSRBCnt)
-                goto device_busy;
-        if (acb->pActiveDCB)
-                goto host_busy;
-        if (acb->ACBFlag & (RESET_DETECT|RESET_DONE|RESET_DEV))
-                goto host_busy;
-
-        srb = acb->pFreeSRB;
-        if (unlikely(srb == NULL))
-                goto host_busy;
-
-        cmd->scsi_done = done;
-        cmd->result = 0;
-        acb->Cmds++;
-
-        acb->pFreeSRB = srb->pNextSRB;
-        srb->pNextSRB = NULL;
-
-        srb->pSRBDCB = dcb;
-        srb->pcmd = cmd;
-        cmd->host_scribble = (char *)srb;
-    
-        srb->SGIndex = 0;
-        srb->AdaptStatus = 0;
-        srb->TargetStatus = 0;
-        srb->MsgCnt = 0;
-
-        srb->SRBStatus = 0;
-        srb->SRBFlag = 0;
-        srb->SRBState = 0;
-        srb->TotalXferredLen = 0;
-        srb->SGBusAddr = 0;
-        srb->SGToBeXferLen = 0;
-        srb->ScsiPhase = 0;
-        srb->EndMessage = 0;
-        srb->TagNumber = SCSI_NO_TAG;
-
-        if (dc390_StartSCSI(acb, dcb, srb)) {
-                dc390_Free_insert(acb, srb);
-                goto host_busy;
-        }
-
-        dc390_Going_append(dcb, srb);
-
-        return 0;
-
- host_busy:
-        return SCSI_MLQUEUE_HOST_BUSY;
-
- device_busy:
-        return SCSI_MLQUEUE_DEVICE_BUSY;
-}
-
-static DEF_SCSI_QCMD(DC390_queuecommand)
-
-static void dc390_dumpinfo (struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb* pSRB)
-{
-    struct pci_dev *pdev;
-    u16 pstat;
-
-    if (!pDCB) pDCB = pACB->pActiveDCB;
-    if (!pSRB && pDCB) pSRB = pDCB->pActiveSRB;
-
-    if (pSRB) 
-    {
-        printk ("DC390: SRB: Xferred %08lx, Remain %08lx, State %08x, Phase %02x\n",
-                pSRB->TotalXferredLen, pSRB->SGToBeXferLen, pSRB->SRBState,
-                pSRB->ScsiPhase);
-        printk ("DC390: AdpaterStatus: %02x, SRB Status %02x\n", pSRB->AdaptStatus, pSRB->SRBStatus);
-    }
-    printk ("DC390: Status of last IRQ (DMA/SC/Int/IRQ): %08x\n", dc390_laststatus);
-    printk ("DC390: Register dump: SCSI block:\n");
-    printk ("DC390: XferCnt  Cmd Stat IntS IRQS FFIS Ctl1 Ctl2 Ctl3 Ctl4\n");
-    printk ("DC390:  %06x   %02x   %02x   %02x",
-            DC390_read8(CtcReg_Low) + (DC390_read8(CtcReg_Mid) << 8) + (DC390_read8(CtcReg_High) << 16),
-            DC390_read8(ScsiCmd), DC390_read8(Scsi_Status), DC390_read8(Intern_State));
-    printk ("   %02x   %02x   %02x   %02x   %02x   %02x\n",
-            DC390_read8(INT_Status), DC390_read8(Current_Fifo), DC390_read8(CtrlReg1),
-            DC390_read8(CtrlReg2), DC390_read8(CtrlReg3), DC390_read8(CtrlReg4));
-    DC390_write32 (DMA_ScsiBusCtrl, WRT_ERASE_DMA_STAT | EN_INT_ON_PCI_ABORT);
-    if (DC390_read8(Current_Fifo) & 0x1f)
-      {
-        printk ("DC390: FIFO:");
-        while (DC390_read8(Current_Fifo) & 0x1f) printk (" %02x", DC390_read8(ScsiFifo));
-        printk ("\n");
-      }
-    printk ("DC390: Register dump: DMA engine:\n");
-    printk ("DC390: Cmd   STrCnt    SBusA    WrkBC    WrkAC Stat SBusCtrl\n");
-    printk ("DC390:  %02x %08x %08x %08x %08x   %02x %08x\n",
-            DC390_read8(DMA_Cmd), DC390_read32(DMA_XferCnt), DC390_read32(DMA_XferAddr),
-            DC390_read32(DMA_Wk_ByteCntr), DC390_read32(DMA_Wk_AddrCntr),
-            DC390_read8(DMA_Status), DC390_read32(DMA_ScsiBusCtrl));
-    DC390_write32 (DMA_ScsiBusCtrl, EN_INT_ON_PCI_ABORT);
-
-    pdev = pACB->pdev;
-    pci_read_config_word(pdev, PCI_STATUS, &pstat);
-    printk ("DC390: Register dump: PCI Status: %04x\n", pstat);
-    printk ("DC390: In case of driver trouble read Documentation/scsi/tmscsim.txt\n");
-}
-
-
-static int DC390_abort(struct scsi_cmnd *cmd)
-{
-        struct dc390_acb *pACB = (struct dc390_acb*) cmd->device->host->hostdata;
-        struct dc390_dcb *pDCB = (struct dc390_dcb*) cmd->device->hostdata;
-
-        scmd_printk(KERN_WARNING, cmd, "DC390: Abort command\n");
-
-        /* abort() is too stupid for already sent commands at the moment. 
-         * If it's called we are in trouble anyway, so let's dump some info 
-         * into the syslog at least. (KG, 98/08/20,99/06/20) */
-        dc390_dumpinfo(pACB, pDCB, NULL);
-
-        pDCB->DCBFlag |= ABORT_DEV_;
-        printk(KERN_INFO "DC390: Aborted.\n");
-
-        return FAILED;
-}
-
-
-static void dc390_ResetDevParam( struct dc390_acb* pACB )
-{
-    struct dc390_dcb *pDCB, *pdcb;
-
-    pDCB = pACB->pLinkDCB;
-    if (! pDCB) return;
-    pdcb = pDCB;
-    do
-    {
-        pDCB->SyncMode &= ~SYNC_NEGO_DONE;
-        pDCB->SyncPeriod = 0;
-        pDCB->SyncOffset = 0;
-        pDCB->TagMask = 0;
-        pDCB->CtrlR3 = FAST_CLK;
-        pDCB->CtrlR4 &= NEGATE_REQACKDATA | CTRL4_RESERVED | NEGATE_REQACK;
-        pDCB->CtrlR4 |= pACB->glitch_cfg;
-        pDCB = pDCB->pNextDCB;
-    }
-    while( pdcb != pDCB );
-    pACB->ACBFlag &= ~(RESET_DEV | RESET_DONE | RESET_DETECT);
-
-}
-
-static int DC390_bus_reset (struct scsi_cmnd *cmd)
-{
-        struct dc390_acb*    pACB = (struct dc390_acb*) cmd->device->host->hostdata;
-        u8   bval;
-
-        spin_lock_irq(cmd->device->host->host_lock);
-
-        bval = DC390_read8(CtrlReg1) | DIS_INT_ON_SCSI_RST;
-        DC390_write8(CtrlReg1, bval);   /* disable IRQ on bus reset */
-
-        pACB->ACBFlag |= RESET_DEV;
-        dc390_ResetSCSIBus(pACB);
-
-        dc390_ResetDevParam(pACB);
-        mdelay(1);
-        pACB->last_reset = jiffies + 3*HZ/2
-                + HZ * dc390_eepromBuf[pACB->AdapterIndex][EE_DELAY];
-
-        DC390_write8(ScsiCmd, CLEAR_FIFO_CMD);
-        DC390_read8(INT_Status);                /* Reset Pending INT */
-
-        dc390_DoingSRB_Done(pACB, cmd);
-
-        pACB->pActiveDCB = NULL;
-        pACB->ACBFlag = 0;
-
-        bval = DC390_read8(CtrlReg1) & ~DIS_INT_ON_SCSI_RST;
-        DC390_write8(CtrlReg1, bval);   /* re-enable interrupt */
-
-        spin_unlock_irq(cmd->device->host->host_lock);
-
-        return SUCCESS;
-}
-
-/**
- * dc390_slave_alloc - Called by the scsi mid layer to tell us about a new
- * scsi device that we need to deal with.
- *
- * @scsi_device: The new scsi device that we need to handle.
- */
-static int dc390_slave_alloc(struct scsi_device *scsi_device)
-{
-        struct dc390_acb *pACB = (struct dc390_acb*) scsi_device->host->hostdata;
-        struct dc390_dcb *pDCB, *pDCB2 = NULL;
-        uint id = scsi_device->id;
-        uint lun = scsi_device->lun;
-
-        pDCB = kzalloc(sizeof(struct dc390_dcb), GFP_KERNEL);
-        if (!pDCB)
-                return -ENOMEM;
-
-        if (!pACB->DCBCnt++) {
-                pACB->pLinkDCB = pDCB;
-                pACB->pDCBRunRobin = pDCB;
-        } else {
-                pACB->pLastDCB->pNextDCB = pDCB;
-        }
-   
-        pDCB->pNextDCB = pACB->pLinkDCB;
-        pACB->pLastDCB = pDCB;
-
-        pDCB->pDCBACB = pACB;
-        pDCB->TargetID = id;
-        pDCB->TargetLUN = lun;
-
-        /*
-         * Some values are for all LUNs: Copy them 
-         * In a clean way: We would have an own structure for a SCSI-ID 
-         */
-        if (lun && (pDCB2 = dc390_findDCB(pACB, id, 0))) {
-                pDCB->DevMode = pDCB2->DevMode;
-                pDCB->SyncMode = pDCB2->SyncMode & SYNC_NEGO_DONE;
-                pDCB->SyncPeriod = pDCB2->SyncPeriod;
-                pDCB->SyncOffset = pDCB2->SyncOffset;
-                pDCB->NegoPeriod = pDCB2->NegoPeriod;
-      
-                pDCB->CtrlR3 = pDCB2->CtrlR3;
-                pDCB->CtrlR4 = pDCB2->CtrlR4;
-        } else {
-                u8 index = pACB->AdapterIndex;
-                PEEprom prom = (PEEprom) &dc390_eepromBuf[index][id << 2];
-
-                pDCB->DevMode = prom->EE_MODE1;
-                pDCB->NegoPeriod =
-                        (dc390_clock_period1[prom->EE_SPEED] * 25) >> 2;
-                pDCB->CtrlR3 = FAST_CLK;
-                pDCB->CtrlR4 = pACB->glitch_cfg | CTRL4_RESERVED;
-                if (dc390_eepromBuf[index][EE_MODE2] & ACTIVE_NEGATION)
-                        pDCB->CtrlR4 |= NEGATE_REQACKDATA | NEGATE_REQACK;
-        }
-
-        if (pDCB->DevMode & SYNC_NEGO_)
-                pDCB->SyncMode |= SYNC_ENABLE;
-        else {
-                pDCB->SyncMode = 0;
-                pDCB->SyncOffset &= ~0x0f;
-        }
-
-        pDCB->CtrlR1 = pACB->pScsiHost->this_id;
-        if (pDCB->DevMode & PARITY_CHK_)
-                pDCB->CtrlR1 |= PARITY_ERR_REPO;
-
-        pACB->scan_devices = 1;
-        scsi_device->hostdata = pDCB;
-        return 0;
-}
-
-/**
- * dc390_slave_destroy - Called by the scsi mid layer to tell us about a
- * device that is going away.
- *
- * @scsi_device: The scsi device that we need to remove.
- */
-static void dc390_slave_destroy(struct scsi_device *scsi_device)
-{
-        struct dc390_acb* pACB = (struct dc390_acb*) scsi_device->host->hostdata;
-        struct dc390_dcb* pDCB = (struct dc390_dcb*) scsi_device->hostdata;
-        struct dc390_dcb* pPrevDCB = pACB->pLinkDCB;
-
-        pACB->scan_devices = 0;
-
-        BUG_ON(pDCB->GoingSRBCnt > 1);
-        
-        if (pDCB == pACB->pLinkDCB) {
-                if (pACB->pLastDCB == pDCB) {
-                        pDCB->pNextDCB = NULL;
-                        pACB->pLastDCB = NULL;
-                }
-                pACB->pLinkDCB = pDCB->pNextDCB;
-        } else {
-                while (pPrevDCB->pNextDCB != pDCB)
-                        pPrevDCB = pPrevDCB->pNextDCB;
-                pPrevDCB->pNextDCB = pDCB->pNextDCB;
-                if (pDCB == pACB->pLastDCB)
-                        pACB->pLastDCB = pPrevDCB;
-        }
-
-        if (pDCB == pACB->pActiveDCB)
-                pACB->pActiveDCB = NULL;
-        if (pDCB == pACB->pLinkDCB)
-                pACB->pLinkDCB = pDCB->pNextDCB;
-        if (pDCB == pACB->pDCBRunRobin)
-                pACB->pDCBRunRobin = pDCB->pNextDCB;
-        kfree(pDCB); 
-        
-        pACB->DCBCnt--;
-}
-
-static int dc390_slave_configure(struct scsi_device *sdev)
-{
-        struct dc390_acb *acb = (struct dc390_acb *)sdev->host->hostdata;
-        struct dc390_dcb *dcb = (struct dc390_dcb *)sdev->hostdata;
-
-        acb->scan_devices = 0;
-        if (sdev->tagged_supported && (dcb->DevMode & TAG_QUEUEING_)) {
-                dcb->SyncMode |= EN_TAG_QUEUEING;
-                scsi_activate_tcq(sdev, acb->TagMaxNum);
-        }
-
-        return 0;
-}
-
-static struct scsi_host_template driver_template = {
-        .module                 = THIS_MODULE,
-        .proc_name              = "tmscsim", 
-        .name                   = DC390_BANNER " V" DC390_VERSION,
-        .slave_alloc            = dc390_slave_alloc,
-        .slave_configure        = dc390_slave_configure,
-        .slave_destroy          = dc390_slave_destroy,
-        .queuecommand           = DC390_queuecommand,
-        .eh_abort_handler       = DC390_abort,
-        .eh_bus_reset_handler   = DC390_bus_reset,
-        .can_queue              = 1,
-        .this_id                = 7,
-        .sg_tablesize           = SG_ALL,
-        .cmd_per_lun            = 1,
-        .use_clustering         = ENABLE_CLUSTERING,
-        .max_sectors            = 0x4000, /* 8MiB = 16 * 1024 * 512 */
-};
-
-/***********************************************************************
- * Functions for access to DC390 EEPROM
- * and some to emulate it
- *
- **********************************************************************/
-
-static void dc390_eeprom_prepare_read(struct pci_dev *pdev, u8 cmd)
-{
-        u8 carryFlag = 1, j = 0x80, bval;
-        int i;
-
-        for (i = 0; i < 9; i++) {
-                if (carryFlag) {
-                        pci_write_config_byte(pdev, 0x80, 0x40);
-                        bval = 0xc0;
-                } else
-                        bval = 0x80;
-
-                udelay(160);
-                pci_write_config_byte(pdev, 0x80, bval);
-                udelay(160);
-                pci_write_config_byte(pdev, 0x80, 0);
-                udelay(160);
-
-                carryFlag = (cmd & j) ? 1 : 0;
-                j >>= 1;
-        }
-}
-
-static u16 dc390_eeprom_get_data(struct pci_dev *pdev)
-{
-        int i;
-        u16 wval = 0;
-        u8 bval;
-
-        for (i = 0; i < 16; i++) {
-                wval <<= 1;
-
-                pci_write_config_byte(pdev, 0x80, 0x80);
-                udelay(160);
-                pci_write_config_byte(pdev, 0x80, 0x40);
-                udelay(160);
-                pci_read_config_byte(pdev, 0x00, &bval);
-
-                if (bval == 0x22)
-                        wval |= 1;
-        }
-
-        return wval;
-}
-
-static void dc390_read_eeprom(struct pci_dev *pdev, u16 *ptr)
-{
-        u8 cmd = EEPROM_READ, i;
-
-        for (i = 0; i < 0x40; i++) {
-                pci_write_config_byte(pdev, 0xc0, 0);
-                udelay(160);
-
-                dc390_eeprom_prepare_read(pdev, cmd++);
-                *ptr++ = dc390_eeprom_get_data(pdev);
-
-                pci_write_config_byte(pdev, 0x80, 0);
-                pci_write_config_byte(pdev, 0x80, 0);
-                udelay(160);
-        }
-}
-
-/* Override EEprom values with explicitly set values */
-static void dc390_eeprom_override(u8 index)
-{
-        u8 *ptr = (u8 *) dc390_eepromBuf[index], id;
-
-        /* Adapter Settings */
-        if (tmscsim[0] != -2)
-                ptr[EE_ADAPT_SCSI_ID] = (u8)tmscsim[0]; /* Adapter ID */
-        if (tmscsim[3] != -2)
-                ptr[EE_MODE2] = (u8)tmscsim[3];
-        if (tmscsim[5] != -2)
-                ptr[EE_DELAY] = tmscsim[5];             /* Reset delay */
-        if (tmscsim[4] != -2)
-                ptr[EE_TAG_CMD_NUM] = (u8)tmscsim[4];   /* Tagged Cmds */
-
-        /* Device Settings */
-        for (id = 0; id < MAX_SCSI_ID; id++) {
-                if (tmscsim[2] != -2)
-                        ptr[id << 2] = (u8)tmscsim[2];          /* EE_MODE1 */
-                if (tmscsim[1] != -2)
-                        ptr[(id << 2) + 1] = (u8)tmscsim[1];    /* EE_Speed */
-        }
-}
-
-static int tmscsim_def[] = {
-        7,
-        0 /* 10MHz */,
-        PARITY_CHK_ | SEND_START_ | EN_DISCONNECT_ | SYNC_NEGO_ | TAG_QUEUEING_,
-        MORE2_DRV | GREATER_1G | RST_SCSI_BUS | ACTIVE_NEGATION | LUN_CHECK,
-        3 /* 16 Tags per LUN */,
-        1 /* s delay after Reset */,
-};
-
-/* Copy defaults over set values where missing */
-static void dc390_fill_with_defaults (void)
-{
-        int i;
-
-        for (i = 0; i < 6; i++) {
-                if (tmscsim[i] < 0 || tmscsim[i] > 255)
-                        tmscsim[i] = tmscsim_def[i];
-        }
-
-        /* Sanity checks */
-        if (tmscsim[0] > 7)
-                tmscsim[0] = 7;
-        if (tmscsim[1] > 7)
-                tmscsim[1] = 4;
-        if (tmscsim[4] > 5)
-                tmscsim[4] = 4;
-        if (tmscsim[5] > 180)
-                tmscsim[5] = 180;
-}
-
-static void dc390_check_eeprom(struct pci_dev *pdev, u8 index)
-{
-        u8 interpd[] = {1, 3, 5, 10, 16, 30, 60, 120};
-        u8 EEbuf[128];
-        u16 *ptr = (u16 *)EEbuf, wval = 0;
-        int i;
-
-        dc390_read_eeprom(pdev, ptr);
-        memcpy(dc390_eepromBuf[index], EEbuf, EE_ADAPT_SCSI_ID);
-        memcpy(&dc390_eepromBuf[index][EE_ADAPT_SCSI_ID], 
-               &EEbuf[REAL_EE_ADAPT_SCSI_ID], EE_LEN - EE_ADAPT_SCSI_ID);
-
-        dc390_eepromBuf[index][EE_DELAY] = interpd[dc390_eepromBuf[index][EE_DELAY]];
-
-        for (i = 0; i < 0x40; i++, ptr++)
-                wval += *ptr;
-
-        /* no Tekram EEprom found */
-        if (wval != 0x1234) {
-                int speed;
-
-                printk(KERN_INFO "DC390_init: No EEPROM found! Trying default settings ...\n");
-
-                /*
-                 * XXX(hch): bogus, because we might have tekram and
-                 *           non-tekram hbas in a single machine.
-                 */
-                dc390_fill_with_defaults();
-
-                speed = dc390_clock_speed[tmscsim[1]];
-                printk(KERN_INFO "DC390: Used defaults: AdaptID=%i, SpeedIdx=%i (%i.%i MHz), "
-                       "DevMode=0x%02x, AdaptMode=0x%02x, TaggedCmnds=%i (%i), DelayReset=%is\n", 
-                       tmscsim[0], tmscsim[1], speed / 10, speed % 10,
-                       (u8)tmscsim[2], (u8)tmscsim[3], tmscsim[4], 2 << (tmscsim[4]), tmscsim[5]);
-        }
-}
-
-static void dc390_init_hw(struct dc390_acb *pACB, u8 index)
-{
-        struct Scsi_Host *shost = pACB->pScsiHost;
-        u8 dstate;
-
-        /* Disable SCSI bus reset interrupt */
-        DC390_write8(CtrlReg1, DIS_INT_ON_SCSI_RST | shost->this_id);
-
-        if (pACB->Gmode2 & RST_SCSI_BUS) {
-                dc390_ResetSCSIBus(pACB);
-                udelay(1000);
-                pACB->last_reset = jiffies + HZ/2 +
-                        HZ * dc390_eepromBuf[pACB->AdapterIndex][EE_DELAY];
-        }
-
-        pACB->ACBFlag = 0;
-
-        /* Reset Pending INT */
-        DC390_read8(INT_Status);
-        
-        /* 250ms selection timeout */
-        DC390_write8(Scsi_TimeOut, SEL_TIMEOUT);
-        
-        /* Conversion factor = 0 , 40MHz clock */
-        DC390_write8(Clk_Factor, CLK_FREQ_40MHZ);
-        
-        /* NOP cmd - clear command register */
-        DC390_write8(ScsiCmd, NOP_CMD);
-        
-        /* Enable Feature and SCSI-2 */
-        DC390_write8(CtrlReg2, EN_FEATURE+EN_SCSI2_CMD);
-        
-        /* Fast clock */
-        DC390_write8(CtrlReg3, FAST_CLK);
-
-        /* Negation */
-        DC390_write8(CtrlReg4, pACB->glitch_cfg | /* glitch eater */
-                (dc390_eepromBuf[index][EE_MODE2] & ACTIVE_NEGATION) ?
-                 NEGATE_REQACKDATA : 0);
-        
-        /* Clear Transfer Count High: ID */
-        DC390_write8(CtcReg_High, 0);
-        DC390_write8(DMA_Cmd, DMA_IDLE_CMD);
-        DC390_write8(ScsiCmd, CLEAR_FIFO_CMD);
-        DC390_write32(DMA_ScsiBusCtrl, EN_INT_ON_PCI_ABORT);
-
-        dstate = DC390_read8(DMA_Status);
-        DC390_write8(DMA_Status, dstate);
-}
-
-static int dc390_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
-{
-        struct dc390_acb *pACB;
-        struct Scsi_Host *shost;
-        unsigned long io_port;
-        int error = -ENODEV, i;
-
-        if (pci_enable_device(pdev))
-                goto out;
-
-        pci_set_master(pdev);
-
-        error = -ENOMEM;
-        if (disable_clustering)
-                driver_template.use_clustering = DISABLE_CLUSTERING;
-        shost = scsi_host_alloc(&driver_template, sizeof(struct dc390_acb));
-        if (!shost)
-                goto out_disable_device;
-
-        pACB = (struct dc390_acb *)shost->hostdata;
-        memset(pACB, 0, sizeof(struct dc390_acb));
-
-        dc390_check_eeprom(pdev, dc390_adapterCnt);
-        dc390_eeprom_override(dc390_adapterCnt);
-
-        io_port = pci_resource_start(pdev, 0);
-
-        shost->this_id = dc390_eepromBuf[dc390_adapterCnt][EE_ADAPT_SCSI_ID];
-        shost->io_port = io_port;
-        shost->n_io_port = 0x80;
-        shost->irq = pdev->irq;
-        shost->base = io_port;
-        shost->unique_id = io_port;
-
-        pACB->last_reset = jiffies;
-        pACB->pScsiHost = shost;
-        pACB->IOPortBase = (u16) io_port;
-        pACB->IRQLevel = pdev->irq;
-        
-        shost->max_id = 8;
-
-        if (shost->max_id - 1 ==
-            dc390_eepromBuf[dc390_adapterCnt][EE_ADAPT_SCSI_ID])
-                shost->max_id--;
-
-        if (dc390_eepromBuf[dc390_adapterCnt][EE_MODE2] & LUN_CHECK)
-                shost->max_lun = 8;
-        else
-                shost->max_lun = 1;
-
-        pACB->pFreeSRB = pACB->SRB_array;
-        pACB->SRBCount = MAX_SRB_CNT;
-        pACB->AdapterIndex = dc390_adapterCnt;
-        pACB->TagMaxNum =
-                2 << dc390_eepromBuf[dc390_adapterCnt][EE_TAG_CMD_NUM];
-        pACB->Gmode2 = dc390_eepromBuf[dc390_adapterCnt][EE_MODE2];
-
-        for (i = 0; i < pACB->SRBCount-1; i++)
-                pACB->SRB_array[i].pNextSRB = &pACB->SRB_array[i+1];
-        pACB->SRB_array[pACB->SRBCount-1].pNextSRB = NULL;
-        pACB->pTmpSRB = &pACB->TmpSRB;
-
-        pACB->sel_timeout = SEL_TIMEOUT;
-        pACB->glitch_cfg = EATER_25NS;
-        pACB->pdev = pdev;
-
-        if (!request_region(io_port, shost->n_io_port, "tmscsim")) {
-                printk(KERN_ERR "DC390: register IO ports error!\n");
-                goto out_host_put;
-        }
-
-        /* Reset Pending INT */
-        DC390_read8_(INT_Status, io_port);
-
-        if (request_irq(pdev->irq, do_DC390_Interrupt, IRQF_SHARED,
-                                "tmscsim", pACB)) {
-                printk(KERN_ERR "DC390: register IRQ error!\n");
-                goto out_release_region;
-        }
-
-        dc390_init_hw(pACB, dc390_adapterCnt);
-        
-        dc390_adapterCnt++;
-
-        pci_set_drvdata(pdev, shost);
-
-        error = scsi_add_host(shost, &pdev->dev);
-        if (error)
-                goto out_free_irq;
-        scsi_scan_host(shost);
-        return 0;
-
- out_free_irq:
-        free_irq(pdev->irq, pACB);
- out_release_region:
-        release_region(io_port, shost->n_io_port);
- out_host_put:
-        scsi_host_put(shost);
- out_disable_device:
-        pci_disable_device(pdev);
- out:
-        return error;
-}
-
-/**
- * dc390_remove_one - Called to remove a single instance of the adapter.
- *
- * @dev: The PCI device to remove.
- */
-static void dc390_remove_one(struct pci_dev *dev)
-{
-        struct Scsi_Host *scsi_host = pci_get_drvdata(dev);
-        unsigned long iflags;
-        struct dc390_acb* pACB = (struct dc390_acb*) scsi_host->hostdata;
-        u8 bval;
-
-        scsi_remove_host(scsi_host);
-
-        spin_lock_irqsave(scsi_host->host_lock, iflags);
-        pACB->ACBFlag = RESET_DEV;
-        bval = DC390_read8(CtrlReg1) | DIS_INT_ON_SCSI_RST;
-        DC390_write8 (CtrlReg1, bval);  /* disable interrupt */
-        if (pACB->Gmode2 & RST_SCSI_BUS)
-                dc390_ResetSCSIBus(pACB);
-        spin_unlock_irqrestore(scsi_host->host_lock, iflags);
-
-        free_irq(scsi_host->irq, pACB);
-        release_region(scsi_host->io_port, scsi_host->n_io_port);
-
-        pci_disable_device(dev);
-        scsi_host_put(scsi_host);
-}
-
-static struct pci_device_id tmscsim_pci_tbl[] = {
-        { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD53C974,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(pci, tmscsim_pci_tbl);
-
-static struct pci_driver dc390_driver = {
-        .name           = "tmscsim",
-        .id_table       = tmscsim_pci_tbl,
-        .probe          = dc390_probe_one,
-        .remove         = dc390_remove_one,
-};
-
-static int __init dc390_module_init(void)
-{
-        if (!disable_clustering) {
-                printk(KERN_INFO "DC390: clustering now enabled by default. If you get problems load\n");
-                printk(KERN_INFO "       with \"disable_clustering=1\" and report to maintainers\n");
-        }
-
-        if (tmscsim[0] == -1 || tmscsim[0] > 15) {
-                tmscsim[0] = 7;
-                tmscsim[1] = 4;
-                tmscsim[2] = PARITY_CHK_ | TAG_QUEUEING_;
-                tmscsim[3] = MORE2_DRV | GREATER_1G | RST_SCSI_BUS | ACTIVE_NEGATION;
-                tmscsim[4] = 2;
-                tmscsim[5] = 10;
-                printk (KERN_INFO "DC390: Using safe settings.\n");
-        }
-
-        return pci_register_driver(&dc390_driver);
-}
-
-static void __exit dc390_module_exit(void)
-{
-        pci_unregister_driver(&dc390_driver);
-}
-
-module_init(dc390_module_init);
-module_exit(dc390_module_exit);
-
-#ifndef MODULE
-static int __init dc390_setup (char *str)
-{       
-        int ints[8],i, im;
-
-        get_options(str, ARRAY_SIZE(ints), ints);
-        im = ints[0];
-
-        if (im > 6) {
-                printk (KERN_NOTICE "DC390: ignore extra params!\n");
-                im = 6;
-        }
-
-        for (i = 0; i < im; i++)
-                tmscsim[i] = ints[i+1];
-        /* dc390_checkparams (); */
-        return 1;
-}
-
-__setup("tmscsim=", dc390_setup);
-#endif
diff --git a/drivers/scsi/tmscsim.h b/drivers/scsi/tmscsim.h
deleted file mode 100644
index 3d1bb4ad1826..000000000000
--- a/drivers/scsi/tmscsim.h
+++ /dev/null
@@ -1,551 +0,0 @@
-/***********************************************************************
-;*      File Name : TMSCSIM.H                                          *
-;*                  TEKRAM DC-390(T) PCI SCSI Bus Master Host Adapter  *
-;*                  Device Driver                                      *
-;***********************************************************************/
-/* $Id: tmscsim.h,v 2.15.2.3 2000/11/17 20:52:27 garloff Exp $ */
-
-#ifndef _TMSCSIM_H
-#define _TMSCSIM_H
-
-#include <linux/types.h>
-
-#define SCSI_IRQ_NONE 255
-
-#define MAX_ADAPTER_NUM         4
-#define MAX_SG_LIST_BUF         16      /* Not used */
-#define MAX_SCSI_ID             8
-#define MAX_SRB_CNT             50      /* Max number of started commands */
-
-#define SEL_TIMEOUT             153     /* 250 ms selection timeout (@ 40 MHz) */
-
-/*
-;-----------------------------------------------------------------------
-; SCSI Request Block
-;-----------------------------------------------------------------------
-*/
-struct dc390_srb
-{
-//u8            CmdBlock[12];
-
-struct dc390_srb        *pNextSRB;
-struct dc390_dcb        *pSRBDCB;
-struct scsi_cmnd        *pcmd;
-struct scatterlist      *pSegmentList;
-
-struct scatterlist Segmentx;    /* make a one entry of S/G list table */
-
-unsigned long   SGBusAddr;      /*;a segment starting address as seen by AM53C974A
-                                  in CPU endianness. We're only getting 32-bit bus
-                                  addresses by default */
-unsigned long   SGToBeXferLen;  /*; to be xfer length */
-unsigned long   TotalXferredLen;
-unsigned long   SavedTotXLen;
-unsigned long   Saved_Ptr;
-u32             SRBState;
-
-u8              SRBStatus;
-u8              SRBFlag;        /*; b0-AutoReqSense,b6-Read,b7-write */
-                                /*; b4-settimeout,b5-Residual valid */
-u8              AdaptStatus;
-u8              TargetStatus;
-
-u8              ScsiPhase;
-s8              TagNumber;
-u8              SGIndex;
-u8              SGcount;
-
-u8              MsgCnt;
-u8              EndMessage;
-
-u8              MsgInBuf[6];
-u8              MsgOutBuf[6];
-
-//u8            IORBFlag;       /*;81h-Reset, 2-retry */
-};
-
-
-/*
-;-----------------------------------------------------------------------
-; Device Control Block
-;-----------------------------------------------------------------------
-*/
-struct dc390_dcb
-{
-struct dc390_dcb        *pNextDCB;
-struct dc390_acb        *pDCBACB;
-
-/* Queued SRBs */
-struct dc390_srb        *pGoingSRB;
-struct dc390_srb        *pGoingLast;
-struct dc390_srb        *pActiveSRB;
-u8              GoingSRBCnt;
-
-u32             TagMask;
-
-u8              TargetID;       /*; SCSI Target ID  (SCSI Only) */
-u8              TargetLUN;      /*; SCSI Log.  Unit (SCSI Only) */
-u8              DevMode;
-u8              DCBFlag;
-
-u8              CtrlR1;
-u8              CtrlR3;
-u8              CtrlR4;
-
-u8              SyncMode;       /*; 0:async mode */
-u8              NegoPeriod;     /*;for nego. */
-u8              SyncPeriod;     /*;for reg. */
-u8              SyncOffset;     /*;for reg. and nego.(low nibble) */
-};
-
-
-/*
-;-----------------------------------------------------------------------
-; Adapter Control Block
-;-----------------------------------------------------------------------
-*/
-struct dc390_acb
-{
-struct Scsi_Host *pScsiHost;
-u16             IOPortBase;
-u8              IRQLevel;
-u8              status;
-
-u8              SRBCount;
-u8              AdapterIndex;   /*; nth Adapter this driver */
-u8              DCBCnt;
-
-u8              TagMaxNum;
-u8              ACBFlag;
-u8              Gmode2;
-u8              scan_devices;
-
-struct dc390_dcb        *pLinkDCB;
-struct dc390_dcb        *pLastDCB;
-struct dc390_dcb        *pDCBRunRobin;
-
-struct dc390_dcb        *pActiveDCB;
-struct dc390_srb        *pFreeSRB;
-struct dc390_srb        *pTmpSRB;
-
-u8              msgin123[4];
-u8              Connected;
-u8              pad;
-
-#if defined(USE_SPINLOCKS) && USE_SPINLOCKS > 1 && (defined(CONFIG_SMP) || DEBUG_SPINLOCKS > 0)
-spinlock_t      lock;
-#endif
-u8              sel_timeout;
-u8              glitch_cfg;
-
-u8              MsgLen;
-u8              Ignore_IRQ;     /* Not used */
-
-struct pci_dev  *pdev;
-
-unsigned long   last_reset;
-unsigned long   Cmds;
-u32             SelLost;
-u32             SelConn;
-u32             CmdInQ;
-u32             CmdOutOfSRB;
-
-struct dc390_srb        TmpSRB;
-struct dc390_srb        SRB_array[MAX_SRB_CNT];         /* 50 SRBs */
-};
-
-
-/*;-----------------------------------------------------------------------*/
-
-
-#define BIT31   0x80000000
-#define BIT30   0x40000000
-#define BIT29   0x20000000
-#define BIT28   0x10000000
-#define BIT27   0x08000000
-#define BIT26   0x04000000
-#define BIT25   0x02000000
-#define BIT24   0x01000000
-#define BIT23   0x00800000
-#define BIT22   0x00400000
-#define BIT21   0x00200000
-#define BIT20   0x00100000
-#define BIT19   0x00080000
-#define BIT18   0x00040000
-#define BIT17   0x00020000
-#define BIT16   0x00010000
-#define BIT15   0x00008000
-#define BIT14   0x00004000
-#define BIT13   0x00002000
-#define BIT12   0x00001000
-#define BIT11   0x00000800
-#define BIT10   0x00000400
-#define BIT9    0x00000200
-#define BIT8    0x00000100
-#define BIT7    0x00000080
-#define BIT6    0x00000040
-#define BIT5    0x00000020
-#define BIT4    0x00000010
-#define BIT3    0x00000008
-#define BIT2    0x00000004
-#define BIT1    0x00000002
-#define BIT0    0x00000001
-
-/*;---UnitCtrlFlag */
-#define UNIT_ALLOCATED  BIT0
-#define UNIT_INFO_CHANGED BIT1
-#define FORMATING_MEDIA BIT2
-#define UNIT_RETRY      BIT3
-
-/*;---UnitFlags */
-#define DASD_SUPPORT    BIT0
-#define SCSI_SUPPORT    BIT1
-#define ASPI_SUPPORT    BIT2
-
-/*;----SRBState machine definition */
-#define SRB_FREE        0
-#define SRB_WAIT        BIT0
-#define SRB_READY       BIT1
-#define SRB_MSGOUT      BIT2    /*;arbitration+msg_out 1st byte*/
-#define SRB_MSGIN       BIT3
-#define SRB_MSGIN_MULTI BIT4
-#define SRB_COMMAND     BIT5
-#define SRB_START_      BIT6    /*;arbitration+msg_out+command_out*/
-#define SRB_DISCONNECT  BIT7
-#define SRB_DATA_XFER   BIT8
-#define SRB_XFERPAD     BIT9
-#define SRB_STATUS      BIT10
-#define SRB_COMPLETED   BIT11
-#define SRB_ABORT_SENT  BIT12
-#define DO_SYNC_NEGO    BIT13
-#define SRB_UNEXPECT_RESEL BIT14
-
-/*;---SRBstatus */
-#define SRB_OK          BIT0
-#define ABORTION        BIT1
-#define OVER_RUN        BIT2
-#define UNDER_RUN       BIT3
-#define PARITY_ERROR    BIT4
-#define SRB_ERROR       BIT5
-
-/*;---ACBFlag */
-#define RESET_DEV       BIT0
-#define RESET_DETECT    BIT1
-#define RESET_DONE      BIT2
-
-/*;---DCBFlag */
-#define ABORT_DEV_      BIT0
-
-/*;---SRBFlag */
-#define DATAOUT         BIT7
-#define DATAIN          BIT6
-#define RESIDUAL_VALID  BIT5
-#define ENABLE_TIMER    BIT4
-#define RESET_DEV0      BIT2
-#define ABORT_DEV       BIT1
-#define AUTO_REQSENSE   BIT0
-
-/*;---Adapter status */
-#define H_STATUS_GOOD    0
-#define H_SEL_TIMEOUT    0x11
-#define H_OVER_UNDER_RUN 0x12
-#define H_UNEXP_BUS_FREE 0x13
-#define H_TARGET_PHASE_F 0x14
-#define H_INVALID_CCB_OP 0x16
-#define H_LINK_CCB_BAD   0x17
-#define H_BAD_TARGET_DIR 0x18
-#define H_DUPLICATE_CCB  0x19
-#define H_BAD_CCB_OR_SG  0x1A
-#define H_ABORT          0x0FF
-
-/* cmd->result */
-#define RES_TARGET              0x000000FF      /* Target State */
-#define RES_TARGET_LNX          STATUS_MASK     /* Only official ... */
-#define RES_ENDMSG              0x0000FF00      /* End Message */
-#define RES_DID                 0x00FF0000      /* DID_ codes */
-#define RES_DRV                 0xFF000000      /* DRIVER_ codes */
-
-#define MK_RES(drv,did,msg,tgt) ((int)(drv)<<24 | (int)(did)<<16 | (int)(msg)<<8 | (int)(tgt))
-#define MK_RES_LNX(drv,did,msg,tgt) ((int)(drv)<<24 | (int)(did)<<16 | (int)(msg)<<8 | (int)(tgt))
-
-#define SET_RES_TARGET(who, tgt) do { who &= ~RES_TARGET; who |= (int)(tgt); } while (0)
-#define SET_RES_TARGET_LNX(who, tgt) do { who &= ~RES_TARGET_LNX; who |= (int)(tgt) << 1; } while (0)
-#define SET_RES_MSG(who, msg) do { who &= ~RES_ENDMSG; who |= (int)(msg) << 8; } while (0)
-#define SET_RES_DID(who, did) do { who &= ~RES_DID; who |= (int)(did) << 16; } while (0)
-#define SET_RES_DRV(who, drv) do { who &= ~RES_DRV; who |= (int)(drv) << 24; } while (0)
-
-/*;---Sync_Mode */
-#define SYNC_DISABLE    0
-#define SYNC_ENABLE     BIT0
-#define SYNC_NEGO_DONE  BIT1
-#define WIDE_ENABLE     BIT2    /* Not used ;-) */
-#define WIDE_NEGO_DONE  BIT3    /* Not used ;-) */
-#define EN_TAG_QUEUEING BIT4
-#define EN_ATN_STOP     BIT5
-
-#define SYNC_NEGO_OFFSET 15
-
-/*;---SCSI bus phase*/
-#define SCSI_DATA_OUT   0
-#define SCSI_DATA_IN    1
-#define SCSI_COMMAND    2
-#define SCSI_STATUS_    3
-#define SCSI_NOP0       4
-#define SCSI_NOP1       5
-#define SCSI_MSG_OUT    6
-#define SCSI_MSG_IN     7
-
-/*;----SCSI MSG BYTE*/ /* see scsi/scsi.h */ /* One is missing ! */
-#define ABORT_TAG       0x0d
-
-/*
- *      SISC query queue
- */
-typedef struct {
-        dma_addr_t              saved_dma_handle;
-} dc390_cmd_scp_t;
-
-/*
-;==========================================================
-; EEPROM byte offset
-;==========================================================
-*/
-typedef  struct  _EEprom
-{
-u8      EE_MODE1;
-u8      EE_SPEED;
-u8      xx1;
-u8      xx2;
-} EEprom, *PEEprom;
-
-#define REAL_EE_ADAPT_SCSI_ID 64
-#define REAL_EE_MODE2   65
-#define REAL_EE_DELAY   66
-#define REAL_EE_TAG_CMD_NUM     67
-
-#define EE_ADAPT_SCSI_ID 32
-#define EE_MODE2        33
-#define EE_DELAY        34
-#define EE_TAG_CMD_NUM  35
-
-#define EE_LEN          40
-
-/*; EE_MODE1 bits definition*/
-#define PARITY_CHK_     BIT0
-#define SYNC_NEGO_      BIT1
-#define EN_DISCONNECT_  BIT2
-#define SEND_START_     BIT3
-#define TAG_QUEUEING_   BIT4
-
-/*; EE_MODE2 bits definition*/
-#define MORE2_DRV       BIT0
-#define GREATER_1G      BIT1
-#define RST_SCSI_BUS    BIT2
-#define ACTIVE_NEGATION BIT3
-#define NO_SEEK         BIT4
-#define LUN_CHECK       BIT5
-
-#define ENABLE_CE       1
-#define DISABLE_CE      0
-#define EEPROM_READ     0x80
-
-/*
-;==========================================================
-;       AMD 53C974 Registers bit Definition
-;==========================================================
-*/
-/*
-;====================
-; SCSI Register
-;====================
-*/
-
-/*; Command Reg.(+0CH) (rw) */
-#define DMA_COMMAND             BIT7
-#define NOP_CMD                 0
-#define CLEAR_FIFO_CMD          1
-#define RST_DEVICE_CMD          2
-#define RST_SCSI_BUS_CMD        3
-
-#define INFO_XFER_CMD           0x10
-#define INITIATOR_CMD_CMPLTE    0x11
-#define MSG_ACCEPTED_CMD        0x12
-#define XFER_PAD_BYTE           0x18
-#define SET_ATN_CMD             0x1A
-#define RESET_ATN_CMD           0x1B
-
-#define SEL_WO_ATN              0x41    /* currently not used */
-#define SEL_W_ATN               0x42
-#define SEL_W_ATN_STOP          0x43
-#define SEL_W_ATN3              0x46
-#define EN_SEL_RESEL            0x44
-#define DIS_SEL_RESEL           0x45    /* currently not used */
-#define RESEL                   0x40    /* " */
-#define RESEL_ATN3              0x47    /* " */
-
-#define DATA_XFER_CMD           INFO_XFER_CMD
-
-
-/*; SCSI Status Reg.(+10H) (r) */
-#define INTERRUPT               BIT7
-#define ILLEGAL_OP_ERR          BIT6
-#define PARITY_ERR              BIT5
-#define COUNT_2_ZERO            BIT4
-#define GROUP_CODE_VALID        BIT3
-#define SCSI_PHASE_MASK         (BIT2+BIT1+BIT0) 
-/* BIT2: MSG phase; BIT1: C/D physe; BIT0: I/O phase */
-
-/*; Interrupt Status Reg.(+14H) (r) */
-#define SCSI_RESET              BIT7
-#define INVALID_CMD             BIT6
-#define DISCONNECTED            BIT5
-#define SERVICE_REQUEST         BIT4
-#define SUCCESSFUL_OP           BIT3
-#define RESELECTED              BIT2
-#define SEL_ATTENTION           BIT1
-#define SELECTED                BIT0
-
-/*; Internal State Reg.(+18H) (r) */
-#define SYNC_OFFSET_FLAG        BIT3
-#define INTRN_STATE_MASK        (BIT2+BIT1+BIT0)
-/* 0x04: Sel. successful (w/o stop), 0x01: Sel. successful (w/ stop) */
-
-/*; Clock Factor Reg.(+24H) (w) */
-#define CLK_FREQ_40MHZ          0
-#define CLK_FREQ_35MHZ          (BIT2+BIT1+BIT0)
-#define CLK_FREQ_30MHZ          (BIT2+BIT1)
-#define CLK_FREQ_25MHZ          (BIT2+BIT0)
-#define CLK_FREQ_20MHZ          BIT2
-#define CLK_FREQ_15MHZ          (BIT1+BIT0)
-#define CLK_FREQ_10MHZ          BIT1
-
-/*; Control Reg. 1(+20H) (rw) */
-#define EXTENDED_TIMING         BIT7
-#define DIS_INT_ON_SCSI_RST     BIT6
-#define PARITY_ERR_REPO         BIT4
-#define SCSI_ID_ON_BUS          (BIT2+BIT1+BIT0) /* host adapter ID */
-
-/*; Control Reg. 2(+2CH) (rw) */
-#define EN_FEATURE              BIT6
-#define EN_SCSI2_CMD            BIT3
-
-/*; Control Reg. 3(+30H) (rw) */
-#define ID_MSG_CHECK            BIT7
-#define EN_QTAG_MSG             BIT6
-#define EN_GRP2_CMD             BIT5
-#define FAST_SCSI               BIT4    /* ;10MB/SEC */
-#define FAST_CLK                BIT3    /* ;25 - 40 MHZ */
-
-/*; Control Reg. 4(+34H) (rw) */
-#define EATER_12NS              0
-#define EATER_25NS              BIT7
-#define EATER_35NS              BIT6
-#define EATER_0NS               (BIT7+BIT6)
-#define REDUCED_POWER           BIT5
-#define CTRL4_RESERVED          BIT4    /* must be 1 acc. to AM53C974.c */
-#define NEGATE_REQACKDATA       BIT2
-#define NEGATE_REQACK           BIT3
-
-#define GLITCH_TO_NS(x) (((~x>>6 & 2) >> 1) | ((x>>6 & 1) << 1 ^ (x>>6 & 2)))
-#define NS_TO_GLITCH(y) (((~y<<7) | ~((y<<6) ^ ((y<<5 & 1<<6) | ~0x40))) & 0xc0)
-
-/*
-;====================
-; DMA Register
-;====================
-*/
-/*; DMA Command Reg.(+40H) (rw) */
-#define READ_DIRECTION          BIT7
-#define WRITE_DIRECTION         0
-#define EN_DMA_INT              BIT6
-#define EN_PAGE_INT             BIT5    /* page transfer interrupt enable */
-#define MAP_TO_MDL              BIT4
-#define DIAGNOSTIC              BIT2
-#define DMA_IDLE_CMD            0
-#define DMA_BLAST_CMD           BIT0
-#define DMA_ABORT_CMD           BIT1
-#define DMA_START_CMD           (BIT1+BIT0)
-
-/*; DMA Status Reg.(+54H) (r) */
-#define PCI_MS_ABORT            BIT6
-#define BLAST_COMPLETE          BIT5
-#define SCSI_INTERRUPT          BIT4
-#define DMA_XFER_DONE           BIT3
-#define DMA_XFER_ABORT          BIT2
-#define DMA_XFER_ERROR          BIT1
-#define POWER_DOWN              BIT0
-
-/*; DMA SCSI Bus and Ctrl.(+70H) */
-#define EN_INT_ON_PCI_ABORT     BIT25
-#define WRT_ERASE_DMA_STAT      BIT24
-#define PW_DOWN_CTRL            BIT21
-#define SCSI_BUSY               BIT20
-#define SCLK                    BIT19
-#define SCAM                    BIT18
-#define SCSI_LINES              0x0003ffff
-
-/*
-;==========================================================
-; SCSI Chip register address offset
-;==========================================================
-;Registers are rw unless declared otherwise 
-*/
-#define CtcReg_Low      0x00    /* r    curr. transfer count */
-#define CtcReg_Mid      0x04    /* r */
-#define CtcReg_High     0x38    /* r */
-#define ScsiFifo        0x08
-#define ScsiCmd         0x0C
-#define Scsi_Status     0x10    /* r */
-#define INT_Status      0x14    /* r */
-#define Sync_Period     0x18    /* w */
-#define Sync_Offset     0x1C    /* w */
-#define Clk_Factor      0x24    /* w */
-#define CtrlReg1        0x20    
-#define CtrlReg2        0x2C
-#define CtrlReg3        0x30
-#define CtrlReg4        0x34
-#define DMA_Cmd         0x40
-#define DMA_XferCnt     0x44    /* rw   starting transfer count (32 bit) */
-#define DMA_XferAddr    0x48    /* rw   starting physical address (32 bit) */
-#define DMA_Wk_ByteCntr 0x4C    /* r    working byte counter */
-#define DMA_Wk_AddrCntr 0x50    /* r    working address counter */
-#define DMA_Status      0x54    /* r */
-#define DMA_MDL_Addr    0x58    /* rw   starting MDL address */
-#define DMA_Wk_MDL_Cntr 0x5C    /* r    working MDL counter */
-#define DMA_ScsiBusCtrl 0x70    /* rw   SCSI Bus, PCI/DMA Ctrl */
-
-#define StcReg_Low      CtcReg_Low      /* w    start transfer count */
-#define StcReg_Mid      CtcReg_Mid      /* w */
-#define StcReg_High     CtcReg_High     /* w */
-#define Scsi_Dest_ID    Scsi_Status     /* w */
-#define Scsi_TimeOut    INT_Status      /* w */
-#define Intern_State    Sync_Period     /* r */
-#define Current_Fifo    Sync_Offset     /* r    Curr. FIFO / int. state */
-
-
-#define DC390_read8(address)                    \
-        (inb (pACB->IOPortBase + (address)))
-
-#define DC390_read8_(address, base)             \
-        (inb ((u16)(base) + (address)))
-
-#define DC390_read16(address)                   \
-        (inw (pACB->IOPortBase + (address)))
-
-#define DC390_read32(address)                   \
-        (inl (pACB->IOPortBase + (address)))
-
-#define DC390_write8(address,value)             \
-        outb ((value), pACB->IOPortBase + (address))
-
-#define DC390_write8_(address,value,base)       \
-        outb ((value), (u16)(base) + (address))
-
-#define DC390_write16(address,value)            \
-        outw ((value), pACB->IOPortBase + (address))
-
-#define DC390_write32(address,value)            \
-        outl ((value), pACB->IOPortBase + (address))
-
-
-#endif /* _TMSCSIM_H */
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index d8dcf36aed11..14eb50b95a1e 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -696,25 +696,25 @@ static int u14_34f_slave_configure(struct scsi_device *dev) {
    if (TLDEV(dev->type) && dev->tagged_supported)
 
       if (tag_mode == TAG_SIMPLE) {
-         scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
+         scsi_change_queue_depth(dev, tqd);
          tag_suffix = ", simple tags";
          }
       else if (tag_mode == TAG_ORDERED) {
-         scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
+         scsi_change_queue_depth(dev, tqd);
          tag_suffix = ", ordered tags";
          }
       else {
-         scsi_adjust_queue_depth(dev, 0, tqd);
+         scsi_change_queue_depth(dev, tqd);
          tag_suffix = ", no tags";
          }
 
    else if (TLDEV(dev->type) && linked_comm) {
-      scsi_adjust_queue_depth(dev, 0, tqd);
+      scsi_change_queue_depth(dev, tqd);
       tag_suffix = ", untagged";
       }
 
    else {
-      scsi_adjust_queue_depth(dev, 0, utqd);
+      scsi_change_queue_depth(dev, utqd);
       tag_suffix = "";
       }
 
diff --git a/drivers/scsi/ufs/ufshcd-pltfrm.c b/drivers/scsi/ufs/ufshcd-pltfrm.c
index 8adf067ff019..1c3467b82566 100644
--- a/drivers/scsi/ufs/ufshcd-pltfrm.c
+++ b/drivers/scsi/ufs/ufshcd-pltfrm.c
@@ -102,7 +102,6 @@ static int ufshcd_parse_clock_info(struct ufs_hba *hba)
         clkfreq = devm_kzalloc(dev, sz * sizeof(*clkfreq),
                         GFP_KERNEL);
         if (!clkfreq) {
-                dev_err(dev, "%s: no memory\n", "freq-table-hz");
                 ret = -ENOMEM;
                 goto out;
         }
@@ -112,19 +111,19 @@ static int ufshcd_parse_clock_info(struct ufs_hba *hba)
         if (ret && (ret != -EINVAL)) {
                 dev_err(dev, "%s: error reading array %d\n",
                                 "freq-table-hz", ret);
-                goto free_clkfreq;
+                return ret;
         }
 
         for (i = 0; i < sz; i += 2) {
                 ret = of_property_read_string_index(np,
                                 "clock-names", i/2, (const char **)&name);
                 if (ret)
-                        goto free_clkfreq;
+                        goto out;
 
                 clki = devm_kzalloc(dev, sizeof(*clki), GFP_KERNEL);
                 if (!clki) {
                         ret = -ENOMEM;
-                        goto free_clkfreq;
+                        goto out;
                 }
 
                 clki->min_freq = clkfreq[i];
@@ -134,8 +133,6 @@ static int ufshcd_parse_clock_info(struct ufs_hba *hba)
                                 clki->min_freq, clki->max_freq, clki->name);
                 list_add_tail(&clki->list, &hba->clk_list_head);
         }
-free_clkfreq:
-        kfree(clkfreq);
 out:
         return ret;
 }
@@ -162,10 +159,8 @@ static int ufshcd_populate_vreg(struct device *dev, const char *name,
         }
 
         vreg = devm_kzalloc(dev, sizeof(*vreg), GFP_KERNEL);
-        if (!vreg) {
-                dev_err(dev, "No memory for %s regulator\n", name);
-                goto out;
-        }
+        if (!vreg)
+                return -ENOMEM;
 
         vreg->name = kstrdup(name, GFP_KERNEL);
 
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 497c38a4a866..2e4614b9dddf 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -744,6 +744,8 @@ static void ufshcd_exit_clk_gating(struct ufs_hba *hba)
         if (!ufshcd_is_clkgating_allowed(hba))
                 return;
         device_remove_file(hba->dev, &hba->clk_gating.delay_attr);
+        cancel_work_sync(&hba->clk_gating.ungate_work);
+        cancel_delayed_work_sync(&hba->clk_gating.gate_work);
 }
 
 /* Must be called with host lock acquired */
@@ -2246,6 +2248,22 @@ static int ufshcd_uic_hibern8_exit(struct ufs_hba *hba)
         return ret;
 }
 
+ /**
+ * ufshcd_init_pwr_info - setting the POR (power on reset)
+ * values in hba power info
+ * @hba: per-adapter instance
+ */
+static void ufshcd_init_pwr_info(struct ufs_hba *hba)
+{
+        hba->pwr_info.gear_rx = UFS_PWM_G1;
+        hba->pwr_info.gear_tx = UFS_PWM_G1;
+        hba->pwr_info.lane_rx = 1;
+        hba->pwr_info.lane_tx = 1;
+        hba->pwr_info.pwr_rx = SLOWAUTO_MODE;
+        hba->pwr_info.pwr_tx = SLOWAUTO_MODE;
+        hba->pwr_info.hs_rate = 0;
+}
+
 /**
  * ufshcd_get_max_pwr_mode - reads the max power mode negotiated with device
  * @hba: per-adapter instance
@@ -2695,7 +2713,7 @@ static void ufshcd_set_queue_depth(struct scsi_device *sdev)
 
         dev_dbg(hba->dev, "%s: activate tcq with queue depth %d\n",
                         __func__, lun_qdepth);
-        scsi_activate_tcq(sdev, lun_qdepth);
+        scsi_change_queue_depth(sdev, lun_qdepth);
 }
 
 /*
@@ -2765,11 +2783,9 @@ static int ufshcd_slave_alloc(struct scsi_device *sdev)
         struct ufs_hba *hba;
 
         hba = shost_priv(sdev->host);
-        sdev->tagged_supported = 1;
 
         /* Mode sense(6) is not supported by UFS, so use Mode sense(10) */
         sdev->use_10_for_ms = 1;
-        scsi_set_tag_type(sdev, MSG_SIMPLE_TAG);
 
         /* allow SCSI layer to restart the device in case of errors */
         sdev->allow_restart = 1;
@@ -2789,34 +2805,16 @@ static int ufshcd_slave_alloc(struct scsi_device *sdev)
  * ufshcd_change_queue_depth - change queue depth
  * @sdev: pointer to SCSI device
  * @depth: required depth to set
- * @reason: reason for changing the depth
  *
- * Change queue depth according to the reason and make sure
- * the max. limits are not crossed.
+ * Change queue depth and make sure the max. limits are not crossed.
  */
-static int ufshcd_change_queue_depth(struct scsi_device *sdev,
-                int depth, int reason)
+static int ufshcd_change_queue_depth(struct scsi_device *sdev, int depth)
 {
         struct ufs_hba *hba = shost_priv(sdev->host);
 
         if (depth > hba->nutrs)
                 depth = hba->nutrs;
-
-        switch (reason) {
-        case SCSI_QDEPTH_DEFAULT:
-        case SCSI_QDEPTH_RAMP_UP:
-                if (!sdev->tagged_supported)
-                        depth = 1;
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
-                break;
-        case SCSI_QDEPTH_QFULL:
-                scsi_track_queue_full(sdev, depth);
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-
-        return depth;
+        return scsi_change_queue_depth(sdev, depth);
 }
 
 /**
@@ -2842,10 +2840,14 @@ static void ufshcd_slave_destroy(struct scsi_device *sdev)
         struct ufs_hba *hba;
 
         hba = shost_priv(sdev->host);
-        scsi_deactivate_tcq(sdev, hba->nutrs);
         /* Drop the reference as it won't be needed anymore */
-        if (ufshcd_scsi_to_upiu_lun(sdev->lun) == UFS_UPIU_UFS_DEVICE_WLUN)
+        if (ufshcd_scsi_to_upiu_lun(sdev->lun) == UFS_UPIU_UFS_DEVICE_WLUN) {
+                unsigned long flags;
+
+                spin_lock_irqsave(hba->host->host_lock, flags);
                 hba->sdev_ufs_device = NULL;
+                spin_unlock_irqrestore(hba->host->host_lock, flags);
+        }
 }
 
 /**
@@ -4062,6 +4064,8 @@ static void ufshcd_init_icc_levels(struct ufs_hba *hba)
 static int ufshcd_scsi_add_wlus(struct ufs_hba *hba)
 {
         int ret = 0;
+        struct scsi_device *sdev_rpmb;
+        struct scsi_device *sdev_boot;
 
         hba->sdev_ufs_device = __scsi_add_device(hba->host, 0, 0,
                 ufshcd_upiu_wlun_to_scsi_wlun(UFS_UPIU_UFS_DEVICE_WLUN), NULL);
@@ -4070,26 +4074,27 @@ static int ufshcd_scsi_add_wlus(struct ufs_hba *hba)
                 hba->sdev_ufs_device = NULL;
                 goto out;
         }
+        scsi_device_put(hba->sdev_ufs_device);
 
-        hba->sdev_boot = __scsi_add_device(hba->host, 0, 0,
+        sdev_boot = __scsi_add_device(hba->host, 0, 0,
                 ufshcd_upiu_wlun_to_scsi_wlun(UFS_UPIU_BOOT_WLUN), NULL);
-        if (IS_ERR(hba->sdev_boot)) {
-                ret = PTR_ERR(hba->sdev_boot);
-                hba->sdev_boot = NULL;
+        if (IS_ERR(sdev_boot)) {
+                ret = PTR_ERR(sdev_boot);
                 goto remove_sdev_ufs_device;
         }
+        scsi_device_put(sdev_boot);
 
-        hba->sdev_rpmb = __scsi_add_device(hba->host, 0, 0,
+        sdev_rpmb = __scsi_add_device(hba->host, 0, 0,
                 ufshcd_upiu_wlun_to_scsi_wlun(UFS_UPIU_RPMB_WLUN), NULL);
-        if (IS_ERR(hba->sdev_rpmb)) {
-                ret = PTR_ERR(hba->sdev_rpmb);
-                hba->sdev_rpmb = NULL;
+        if (IS_ERR(sdev_rpmb)) {
+                ret = PTR_ERR(sdev_rpmb);
                 goto remove_sdev_boot;
         }
+        scsi_device_put(sdev_rpmb);
         goto out;
 
 remove_sdev_boot:
-        scsi_remove_device(hba->sdev_boot);
+        scsi_remove_device(sdev_boot);
 remove_sdev_ufs_device:
         scsi_remove_device(hba->sdev_ufs_device);
 out:
@@ -4097,30 +4102,6 @@ out:
 }
 
 /**
- * ufshcd_scsi_remove_wlus - Removes the W-LUs which were added by
- *                           ufshcd_scsi_add_wlus()
- * @hba: per-adapter instance
- *
- */
-static void ufshcd_scsi_remove_wlus(struct ufs_hba *hba)
-{
-        if (hba->sdev_ufs_device) {
-                scsi_remove_device(hba->sdev_ufs_device);
-                hba->sdev_ufs_device = NULL;
-        }
-
-        if (hba->sdev_boot) {
-                scsi_remove_device(hba->sdev_boot);
-                hba->sdev_boot = NULL;
-        }
-
-        if (hba->sdev_rpmb) {
-                scsi_remove_device(hba->sdev_rpmb);
-                hba->sdev_rpmb = NULL;
-        }
-}
-
-/**
  * ufshcd_probe_hba - probe hba to detect device and initialize
  * @hba: per-adapter instance
  *
@@ -4134,6 +4115,8 @@ static int ufshcd_probe_hba(struct ufs_hba *hba)
         if (ret)
                 goto out;
 
+        ufshcd_init_pwr_info(hba);
+
         /* UniPro link is active now */
         ufshcd_set_link_active(hba);
 
@@ -4235,6 +4218,8 @@ static struct scsi_host_template ufshcd_driver_template = {
         .cmd_per_lun            = UFSHCD_CMD_PER_LUN,
         .can_queue              = UFSHCD_CAN_QUEUE,
         .max_host_blocked       = 1,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
 
 static int ufshcd_config_vreg_load(struct device *dev, struct ufs_vreg *vreg,
@@ -4264,12 +4249,18 @@ static int ufshcd_config_vreg_load(struct device *dev, struct ufs_vreg *vreg,
 static inline int ufshcd_config_vreg_lpm(struct ufs_hba *hba,
                                          struct ufs_vreg *vreg)
 {
+        if (!vreg)
+                return 0;
+
         return ufshcd_config_vreg_load(hba->dev, vreg, UFS_VREG_LPM_LOAD_UA);
 }
 
 static inline int ufshcd_config_vreg_hpm(struct ufs_hba *hba,
                                          struct ufs_vreg *vreg)
 {
+        if (!vreg)
+                return 0;
+
         return ufshcd_config_vreg_load(hba->dev, vreg, vreg->max_uA);
 }
 
@@ -4471,7 +4462,7 @@ out:
                         if (!IS_ERR_OR_NULL(clki->clk) && clki->enabled)
                                 clk_disable_unprepare(clki->clk);
                 }
-        } else if (!ret && on) {
+        } else if (on) {
                 spin_lock_irqsave(hba->host->host_lock, flags);
                 hba->clk_gating.state = CLKS_ON;
                 spin_unlock_irqrestore(hba->host->host_lock, flags);
@@ -4675,11 +4666,25 @@ static int ufshcd_set_dev_pwr_mode(struct ufs_hba *hba,
 {
         unsigned char cmd[6] = { START_STOP };
         struct scsi_sense_hdr sshdr;
-        struct scsi_device *sdp = hba->sdev_ufs_device;
+        struct scsi_device *sdp;
+        unsigned long flags;
         int ret;
 
-        if (!sdp || !scsi_device_online(sdp))
-                return -ENODEV;
+        spin_lock_irqsave(hba->host->host_lock, flags);
+        sdp = hba->sdev_ufs_device;
+        if (sdp) {
+                ret = scsi_device_get(sdp);
+                if (!ret && !scsi_device_online(sdp)) {
+                        ret = -ENODEV;
+                        scsi_device_put(sdp);
+                }
+        } else {
+                ret = -ENODEV;
+        }
+        spin_unlock_irqrestore(hba->host->host_lock, flags);
+
+        if (ret)
+                return ret;
 
         /*
          * If scsi commands fail, the scsi mid-layer schedules scsi error-
@@ -4707,17 +4712,18 @@ static int ufshcd_set_dev_pwr_mode(struct ufs_hba *hba,
                                      START_STOP_TIMEOUT, 0, NULL, REQ_PM);
         if (ret) {
                 sdev_printk(KERN_WARNING, sdp,
-                          "START_STOP failed for power mode: %d\n", pwr_mode);
-                scsi_show_result(ret);
+                            "START_STOP failed for power mode: %d, result %x\n",
+                            pwr_mode, ret);
                 if (driver_byte(ret) & DRIVER_SENSE) {
-                        scsi_show_sense_hdr(&sshdr);
-                        scsi_show_extd_sense(sshdr.asc, sshdr.ascq);
+                        scsi_show_sense_hdr(sdp, NULL, &sshdr);
+                        scsi_show_extd_sense(sdp, NULL, sshdr.asc, sshdr.ascq);
                 }
         }
 
         if (!ret)
                 hba->curr_dev_pwr_mode = pwr_mode;
 out:
+        scsi_device_put(sdp);
         hba->host->eh_noresume = 0;
         return ret;
 }
@@ -5087,7 +5093,7 @@ int ufshcd_system_suspend(struct ufs_hba *hba)
         int ret = 0;
 
         if (!hba || !hba->is_powered)
-                goto out;
+                return 0;
 
         if (pm_runtime_suspended(hba->dev)) {
                 if (hba->rpm_lvl == hba->spm_lvl)
@@ -5231,7 +5237,6 @@ EXPORT_SYMBOL(ufshcd_shutdown);
 void ufshcd_remove(struct ufs_hba *hba)
 {
         scsi_remove_host(hba->host);
-        ufshcd_scsi_remove_wlus(hba);
         /* disable interrupts */
         ufshcd_disable_intr(hba, hba->intr_mask);
         ufshcd_hba_stop(hba);
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index 58ecdff5065c..4a574aa45855 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
@@ -392,8 +392,6 @@ struct ufs_hba {
          * "UFS device" W-LU.
          */
         struct scsi_device *sdev_ufs_device;
-        struct scsi_device *sdev_rpmb;
-        struct scsi_device *sdev_boot;
 
         enum ufs_dev_pwr_mode curr_dev_pwr_mode;
         enum uic_link_state uic_link_state;
diff --git a/drivers/scsi/virtio_scsi.c b/drivers/scsi/virtio_scsi.c
index b83846fc7859..c52bb5dfaedb 100644
--- a/drivers/scsi/virtio_scsi.c
+++ b/drivers/scsi/virtio_scsi.c
@@ -158,7 +158,7 @@ static void virtscsi_complete_cmd(struct virtio_scsi *vscsi, void *buf)
                 sc, resp->response, resp->status, resp->sense_len);
 
         sc->result = resp->status;
-        virtscsi_compute_resid(sc, resp->resid);
+        virtscsi_compute_resid(sc, virtio32_to_cpu(vscsi->vdev, resp->resid));
         switch (resp->response) {
         case VIRTIO_SCSI_S_OK:
                 set_host_byte(sc, DID_OK);
@@ -196,10 +196,13 @@ static void virtscsi_complete_cmd(struct virtio_scsi *vscsi, void *buf)
                 break;
         }
 
-        WARN_ON(resp->sense_len > VIRTIO_SCSI_SENSE_SIZE);
+        WARN_ON(virtio32_to_cpu(vscsi->vdev, resp->sense_len) >
+                VIRTIO_SCSI_SENSE_SIZE);
         if (sc->sense_buffer) {
                 memcpy(sc->sense_buffer, resp->sense,
-                       min_t(u32, resp->sense_len, VIRTIO_SCSI_SENSE_SIZE));
+                       min_t(u32,
+                             virtio32_to_cpu(vscsi->vdev, resp->sense_len),
+                             VIRTIO_SCSI_SENSE_SIZE));
                 if (resp->sense_len)
                         set_driver_byte(sc, DRIVER_SENSE);
         }
@@ -323,7 +326,7 @@ static void virtscsi_handle_transport_reset(struct virtio_scsi *vscsi,
         unsigned int target = event->lun[1];
         unsigned int lun = (event->lun[2] << 8) | event->lun[3];
 
-        switch (event->reason) {
+        switch (virtio32_to_cpu(vscsi->vdev, event->reason)) {
         case VIRTIO_SCSI_EVT_RESET_RESCAN:
                 scsi_add_device(shost, 0, target, lun);
                 break;
@@ -349,8 +352,8 @@ static void virtscsi_handle_param_change(struct virtio_scsi *vscsi,
         struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);
         unsigned int target = event->lun[1];
         unsigned int lun = (event->lun[2] << 8) | event->lun[3];
-        u8 asc = event->reason & 255;
-        u8 ascq = event->reason >> 8;
+        u8 asc = virtio32_to_cpu(vscsi->vdev, event->reason) & 255;
+        u8 ascq = virtio32_to_cpu(vscsi->vdev, event->reason) >> 8;
 
         sdev = scsi_device_lookup(shost, 0, target, lun);
         if (!sdev) {
@@ -374,12 +377,14 @@ static void virtscsi_handle_event(struct work_struct *work)
         struct virtio_scsi *vscsi = event_node->vscsi;
         struct virtio_scsi_event *event = &event_node->event;
 
-        if (event->event & VIRTIO_SCSI_T_EVENTS_MISSED) {
-                event->event &= ~VIRTIO_SCSI_T_EVENTS_MISSED;
+        if (event->event &
+            cpu_to_virtio32(vscsi->vdev, VIRTIO_SCSI_T_EVENTS_MISSED)) {
+                event->event &= ~cpu_to_virtio32(vscsi->vdev,
+                                                   VIRTIO_SCSI_T_EVENTS_MISSED);
                 scsi_scan_host(virtio_scsi_host(vscsi->vdev));
         }
 
-        switch (event->event) {
+        switch (virtio32_to_cpu(vscsi->vdev, event->event)) {
         case VIRTIO_SCSI_T_NO_EVENT:
                 break;
         case VIRTIO_SCSI_T_TRANSPORT_RESET:
@@ -482,26 +487,28 @@ static int virtscsi_kick_cmd(struct virtio_scsi_vq *vq,
         return err;
 }
 
-static void virtio_scsi_init_hdr(struct virtio_scsi_cmd_req *cmd,
+static void virtio_scsi_init_hdr(struct virtio_device *vdev,
+                                 struct virtio_scsi_cmd_req *cmd,
                                  struct scsi_cmnd *sc)
 {
         cmd->lun[0] = 1;
         cmd->lun[1] = sc->device->id;
         cmd->lun[2] = (sc->device->lun >> 8) | 0x40;
         cmd->lun[3] = sc->device->lun & 0xff;
-        cmd->tag = (unsigned long)sc;
+        cmd->tag = cpu_to_virtio64(vdev, (unsigned long)sc);
         cmd->task_attr = VIRTIO_SCSI_S_SIMPLE;
         cmd->prio = 0;
         cmd->crn = 0;
 }
 
-static void virtio_scsi_init_hdr_pi(struct virtio_scsi_cmd_req_pi *cmd_pi,
+static void virtio_scsi_init_hdr_pi(struct virtio_device *vdev,
+                                    struct virtio_scsi_cmd_req_pi *cmd_pi,
                                     struct scsi_cmnd *sc)
 {
         struct request *rq = sc->request;
         struct blk_integrity *bi;
 
-        virtio_scsi_init_hdr((struct virtio_scsi_cmd_req *)cmd_pi, sc);
+        virtio_scsi_init_hdr(vdev, (struct virtio_scsi_cmd_req *)cmd_pi, sc);
 
         if (!rq || !scsi_prot_sg_count(sc))
                 return;
@@ -509,9 +516,13 @@ static void virtio_scsi_init_hdr_pi(struct virtio_scsi_cmd_req_pi *cmd_pi,
         bi = blk_get_integrity(rq->rq_disk);
 
         if (sc->sc_data_direction == DMA_TO_DEVICE)
-                cmd_pi->pi_bytesout = blk_rq_sectors(rq) * bi->tuple_size;
+                cmd_pi->pi_bytesout = cpu_to_virtio32(vdev,
+                                                        blk_rq_sectors(rq) *
+                                                        bi->tuple_size);
         else if (sc->sc_data_direction == DMA_FROM_DEVICE)
-                cmd_pi->pi_bytesin = blk_rq_sectors(rq) * bi->tuple_size;
+                cmd_pi->pi_bytesin = cpu_to_virtio32(vdev,
+                                                       blk_rq_sectors(rq) *
+                                                       bi->tuple_size);
 }
 
 static int virtscsi_queuecommand(struct virtio_scsi *vscsi,
@@ -536,11 +547,11 @@ static int virtscsi_queuecommand(struct virtio_scsi *vscsi,
         BUG_ON(sc->cmd_len > VIRTIO_SCSI_CDB_SIZE);
 
         if (virtio_has_feature(vscsi->vdev, VIRTIO_SCSI_F_T10_PI)) {
-                virtio_scsi_init_hdr_pi(&cmd->req.cmd_pi, sc);
+                virtio_scsi_init_hdr_pi(vscsi->vdev, &cmd->req.cmd_pi, sc);
                 memcpy(cmd->req.cmd_pi.cdb, sc->cmnd, sc->cmd_len);
                 req_size = sizeof(cmd->req.cmd_pi);
         } else {
-                virtio_scsi_init_hdr(&cmd->req.cmd, sc);
+                virtio_scsi_init_hdr(vscsi->vdev, &cmd->req.cmd, sc);
                 memcpy(cmd->req.cmd.cdb, sc->cmnd, sc->cmd_len);
                 req_size = sizeof(cmd->req.cmd);
         }
@@ -561,6 +572,15 @@ static int virtscsi_queuecommand_single(struct Scsi_Host *sh,
         return virtscsi_queuecommand(vscsi, &vscsi->req_vqs[0], sc);
 }
 
+static struct virtio_scsi_vq *virtscsi_pick_vq_mq(struct virtio_scsi *vscsi,
+                                                  struct scsi_cmnd *sc)
+{
+        u32 tag = blk_mq_unique_tag(sc->request);
+        u16 hwq = blk_mq_unique_tag_to_hwq(tag);
+
+        return &vscsi->req_vqs[hwq];
+}
+
 static struct virtio_scsi_vq *virtscsi_pick_vq(struct virtio_scsi *vscsi,
                                                struct virtio_scsi_target_state *tgt)
 {
@@ -604,7 +624,12 @@ static int virtscsi_queuecommand_multi(struct Scsi_Host *sh,
         struct virtio_scsi *vscsi = shost_priv(sh);
         struct virtio_scsi_target_state *tgt =
                                 scsi_target(sc->device)->hostdata;
-        struct virtio_scsi_vq *req_vq = virtscsi_pick_vq(vscsi, tgt);
+        struct virtio_scsi_vq *req_vq;
+
+        if (shost_use_blk_mq(sh))
+                req_vq = virtscsi_pick_vq_mq(vscsi, sc);
+        else
+                req_vq = virtscsi_pick_vq(vscsi, tgt);
 
         return virtscsi_queuecommand(vscsi, req_vq, sc);
 }
@@ -655,7 +680,8 @@ static int virtscsi_device_reset(struct scsi_cmnd *sc)
         cmd->sc = sc;
         cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
                 .type = VIRTIO_SCSI_T_TMF,
-                .subtype = VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET,
+                .subtype = cpu_to_virtio32(vscsi->vdev,
+                                             VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET),
                 .lun[0] = 1,
                 .lun[1] = sc->device->id,
                 .lun[2] = (sc->device->lun >> 8) | 0x40,
@@ -668,30 +694,13 @@ static int virtscsi_device_reset(struct scsi_cmnd *sc)
  * virtscsi_change_queue_depth() - Change a virtscsi target's queue depth
  * @sdev:       Virtscsi target whose queue depth to change
  * @qdepth:     New queue depth
- * @reason:     Reason for the queue depth change.
  */
-static int virtscsi_change_queue_depth(struct scsi_device *sdev,
-                                       int qdepth,
-                                       int reason)
+static int virtscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
         struct Scsi_Host *shost = sdev->host;
         int max_depth = shost->cmd_per_lun;
 
-        switch (reason) {
-        case SCSI_QDEPTH_QFULL: /* Drop qdepth in response to BUSY state */
-                scsi_track_queue_full(sdev, qdepth);
-                break;
-        case SCSI_QDEPTH_RAMP_UP: /* Raise qdepth after BUSY state resolved */
-        case SCSI_QDEPTH_DEFAULT: /* Manual change via sysfs */
-                scsi_adjust_queue_depth(sdev,
-                                        scsi_get_tag_type(sdev),
-                                        min(max_depth, qdepth));
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-
-        return sdev->queue_depth;
+        return scsi_change_queue_depth(sdev, min(max_depth, qdepth));
 }
 
 static int virtscsi_abort(struct scsi_cmnd *sc)
@@ -713,7 +722,7 @@ static int virtscsi_abort(struct scsi_cmnd *sc)
                 .lun[1] = sc->device->id,
                 .lun[2] = (sc->device->lun >> 8) | 0x40,
                 .lun[3] = sc->device->lun & 0xff,
-                .tag = (unsigned long)sc,
+                .tag = cpu_to_virtio64(vscsi->vdev, (unsigned long)sc),
         };
         return virtscsi_tmf(vscsi, cmd);
 }
@@ -758,6 +767,7 @@ static struct scsi_host_template virtscsi_host_template_single = {
         .use_clustering = ENABLE_CLUSTERING,
         .target_alloc = virtscsi_target_alloc,
         .target_destroy = virtscsi_target_destroy,
+        .track_queue_depth = 1,
 };
 
 static struct scsi_host_template virtscsi_host_template_multi = {
@@ -776,6 +786,7 @@ static struct scsi_host_template virtscsi_host_template_multi = {
         .use_clustering = ENABLE_CLUSTERING,
         .target_alloc = virtscsi_target_alloc,
         .target_destroy = virtscsi_target_destroy,
+        .track_queue_depth = 1,
 };
 
 #define virtscsi_config_get(vdev, fld) \
@@ -983,6 +994,7 @@ static int virtscsi_probe(struct virtio_device *vdev)
         shost->max_id = num_targets;
         shost->max_channel = 0;
         shost->max_cmd_len = VIRTIO_SCSI_CDB_SIZE;
+        shost->nr_hw_queues = num_queues;
 
         if (virtio_has_feature(vdev, VIRTIO_SCSI_F_T10_PI)) {
                 host_prot = SHOST_DIF_TYPE1_PROTECTION | SHOST_DIF_TYPE2_PROTECTION |
diff --git a/drivers/scsi/vmw_pvscsi.c b/drivers/scsi/vmw_pvscsi.c
index 598f65efaaec..0f133c1817de 100644
--- a/drivers/scsi/vmw_pvscsi.c
+++ b/drivers/scsi/vmw_pvscsi.c
@@ -504,33 +504,11 @@ static void pvscsi_setup_all_rings(const struct pvscsi_adapter *adapter)
         }
 }
 
-static int pvscsi_change_queue_depth(struct scsi_device *sdev,
-                                     int qdepth,
-                                     int reason)
+static int pvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
 {
-        int max_depth;
-        struct Scsi_Host *shost = sdev->host;
-
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                /*
-                 * We support only changing default.
-                 */
-                return -EOPNOTSUPP;
-
-        max_depth = shost->can_queue;
         if (!sdev->tagged_supported)
-                max_depth = 1;
-        if (qdepth > max_depth)
-                qdepth = max_depth;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
-
-        if (sdev->inquiry_len > 7)
-                sdev_printk(KERN_INFO, sdev,
-                            "qdepth(%d), tagged(%d), simple(%d), ordered(%d), scsi_level(%d), cmd_que(%d)\n",
-                            sdev->queue_depth, sdev->tagged_supported,
-                            sdev->simple_tags, sdev->ordered_tags,
-                            sdev->scsi_level, (sdev->inquiry[7] & 2) >> 1);
-        return sdev->queue_depth;
+                qdepth = 1;
+        return scsi_change_queue_depth(sdev, qdepth);
 }
 
 /*
@@ -723,10 +701,6 @@ static int pvscsi_queue_ring(struct pvscsi_adapter *adapter,
         memcpy(e->cdb, cmd->cmnd, e->cdbLen);
 
         e->tag = SIMPLE_QUEUE_TAG;
-        if (sdev->tagged_supported &&
-            (cmd->tag == HEAD_OF_QUEUE_TAG ||
-             cmd->tag == ORDERED_QUEUE_TAG))
-                e->tag = cmd->tag;
 
         if (cmd->sc_data_direction == DMA_FROM_DEVICE)
                 e->flags = PVSCSI_FLAG_CMD_DIR_TOHOST;
diff --git a/drivers/scsi/wd7000.c b/drivers/scsi/wd7000.c
index 32674236fec7..f94d73611ab4 100644
--- a/drivers/scsi/wd7000.c
+++ b/drivers/scsi/wd7000.c
@@ -1653,7 +1653,6 @@ static struct scsi_host_template driver_template = {
         .can_queue              = WD7000_Q,
         .this_id                = 7,
         .sg_tablesize           = WD7000_SG,
-        .cmd_per_lun            = 1,
         .unchecked_isa_dma      = 1,
         .use_clustering         = ENABLE_CLUSTERING,
 };
diff --git a/drivers/scsi/wd719x.c b/drivers/scsi/wd719x.c
new file mode 100644
index 000000000000..7702664d7ed3
--- /dev/null
+++ b/drivers/scsi/wd719x.c
@@ -0,0 +1,996 @@
+/*
+ * Driver for Western Digital WD7193, WD7197 and WD7296 SCSI cards
+ * Copyright 2013 Ondrej Zary
+ *
+ * Original driver by
+ * Aaron Dewell <dewell@woods.net>
+ * Gaerti <Juergen.Gaertner@mbox.si.uni-hannover.de>
+ *
+ * HW documentation available in book:
+ *
+ * SPIDER Command Protocol
+ * by Chandru M. Sippy
+ * SCSI Storage Products (MCP)
+ * Western Digital Corporation
+ * 09-15-95
+ *
+ * http://web.archive.org/web/20070717175254/http://sun1.rrzn.uni-hannover.de/gaertner.juergen/wd719x/Linux/Docu/Spider/
+ */
+
+/*
+ * Driver workflow:
+ * 1. SCSI command is transformed to SCB (Spider Control Block) by the
+ *    queuecommand function.
+ * 2. The address of the SCB is stored in a list to be able to access it, if
+ *    something goes wrong.
+ * 3. The address of the SCB is written to the Controller, which loads the SCB
+ *    via BM-DMA and processes it.
+ * 4. After it has finished, it generates an interrupt, and sets registers.
+ *
+ * flaws:
+ *  - abort/reset functions
+ *
+ * ToDo:
+ *  - tagged queueing
+ */
+
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/firmware.h>
+#include <linux/eeprom_93cx6.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+#include "wd719x.h"
+
+/* low-level register access */
+static inline u8 wd719x_readb(struct wd719x *wd, u8 reg)
+{
+        return ioread8(wd->base + reg);
+}
+
+static inline u32 wd719x_readl(struct wd719x *wd, u8 reg)
+{
+        return ioread32(wd->base + reg);
+}
+
+static inline void wd719x_writeb(struct wd719x *wd, u8 reg, u8 val)
+{
+        iowrite8(val, wd->base + reg);
+}
+
+static inline void wd719x_writew(struct wd719x *wd, u8 reg, u16 val)
+{
+        iowrite16(val, wd->base + reg);
+}
+
+static inline void wd719x_writel(struct wd719x *wd, u8 reg, u32 val)
+{
+        iowrite32(val, wd->base + reg);
+}
+
+/* wait until the command register is ready */
+static inline int wd719x_wait_ready(struct wd719x *wd)
+{
+        int i = 0;
+
+        do {
+                if (wd719x_readb(wd, WD719X_AMR_COMMAND) == WD719X_CMD_READY)
+                        return 0;
+                udelay(1);
+        } while (i++ < WD719X_WAIT_FOR_CMD_READY);
+
+        dev_err(&wd->pdev->dev, "command register is not ready: 0x%02x\n",
+                wd719x_readb(wd, WD719X_AMR_COMMAND));
+
+        return -ETIMEDOUT;
+}
+
+/* poll interrupt status register until command finishes */
+static inline int wd719x_wait_done(struct wd719x *wd, int timeout)
+{
+        u8 status;
+
+        while (timeout > 0) {
+                status = wd719x_readb(wd, WD719X_AMR_INT_STATUS);
+                if (status)
+                        break;
+                timeout--;
+                udelay(1);
+        }
+
+        if (timeout <= 0) {
+                dev_err(&wd->pdev->dev, "direct command timed out\n");
+                return -ETIMEDOUT;
+        }
+
+        if (status != WD719X_INT_NOERRORS) {
+                dev_err(&wd->pdev->dev, "direct command failed, status 0x%02x, SUE 0x%02x\n",
+                        status, wd719x_readb(wd, WD719X_AMR_SCB_ERROR));
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int wd719x_direct_cmd(struct wd719x *wd, u8 opcode, u8 dev, u8 lun,
+                             u8 tag, dma_addr_t data, int timeout)
+{
+        int ret = 0;
+
+        /* clear interrupt status register (allow command register to clear) */
+        wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
+
+        /* Wait for the Command register to become free */
+        if (wd719x_wait_ready(wd))
+                return -ETIMEDOUT;
+
+        /* make sure we get NO interrupts */
+        dev |= WD719X_DISABLE_INT;
+        wd719x_writeb(wd, WD719X_AMR_CMD_PARAM, dev);
+        wd719x_writeb(wd, WD719X_AMR_CMD_PARAM_2, lun);
+        wd719x_writeb(wd, WD719X_AMR_CMD_PARAM_3, tag);
+        if (data)
+                wd719x_writel(wd, WD719X_AMR_SCB_IN, data);
+
+        /* clear interrupt status register again */
+        wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
+
+        /* Now, write the command */
+        wd719x_writeb(wd, WD719X_AMR_COMMAND, opcode);
+
+        if (timeout)    /* wait for the command to complete */
+                ret = wd719x_wait_done(wd, timeout);
+
+        /* clear interrupt status register (clean up) */
+        if (opcode != WD719X_CMD_READ_FIRMVER)
+                wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
+
+        return ret;
+}
+
+static void wd719x_destroy(struct wd719x *wd)
+{
+        struct wd719x_scb *scb;
+
+        /* stop the RISC */
+        if (wd719x_direct_cmd(wd, WD719X_CMD_SLEEP, 0, 0, 0, 0,
+                              WD719X_WAIT_FOR_RISC))
+                dev_warn(&wd->pdev->dev, "RISC sleep command failed\n");
+        /* disable RISC */
+        wd719x_writeb(wd, WD719X_PCI_MODE_SELECT, 0);
+
+        /* free all SCBs */
+        list_for_each_entry(scb, &wd->active_scbs, list)
+                pci_free_consistent(wd->pdev, sizeof(struct wd719x_scb), scb,
+                                    scb->phys);
+        list_for_each_entry(scb, &wd->free_scbs, list)
+                pci_free_consistent(wd->pdev, sizeof(struct wd719x_scb), scb,
+                                    scb->phys);
+        /* free internal buffers */
+        pci_free_consistent(wd->pdev, wd->fw_size, wd->fw_virt, wd->fw_phys);
+        wd->fw_virt = NULL;
+        pci_free_consistent(wd->pdev, WD719X_HASH_TABLE_SIZE, wd->hash_virt,
+                            wd->hash_phys);
+        wd->hash_virt = NULL;
+        pci_free_consistent(wd->pdev, sizeof(struct wd719x_host_param),
+                            wd->params, wd->params_phys);
+        wd->params = NULL;
+        free_irq(wd->pdev->irq, wd);
+}
+
+/* finish a SCSI command, mark SCB (if any) as free, unmap buffers */
+static void wd719x_finish_cmd(struct scsi_cmnd *cmd, int result)
+{
+        struct wd719x *wd = shost_priv(cmd->device->host);
+        struct wd719x_scb *scb = (struct wd719x_scb *) cmd->host_scribble;
+
+        if (scb) {
+                list_move(&scb->list, &wd->free_scbs);
+                dma_unmap_single(&wd->pdev->dev, cmd->SCp.dma_handle,
+                                 SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
+                scsi_dma_unmap(cmd);
+        }
+        cmd->result = result << 16;
+        cmd->scsi_done(cmd);
+}
+
+/* Build a SCB and send it to the card */
+static int wd719x_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
+{
+        int i, count_sg;
+        unsigned long flags;
+        struct wd719x_scb *scb;
+        struct wd719x *wd = shost_priv(sh);
+        dma_addr_t phys;
+
+        cmd->host_scribble = NULL;
+
+        /* get a free SCB - either from existing ones or allocate a new one */
+        spin_lock_irqsave(wd->sh->host_lock, flags);
+        scb = list_first_entry_or_null(&wd->free_scbs, struct wd719x_scb, list);
+        if (scb) {
+                list_del(&scb->list);
+                phys = scb->phys;
+        } else {
+                spin_unlock_irqrestore(wd->sh->host_lock, flags);
+                scb = pci_alloc_consistent(wd->pdev, sizeof(struct wd719x_scb),
+                                           &phys);
+                spin_lock_irqsave(wd->sh->host_lock, flags);
+                if (!scb) {
+                        dev_err(&wd->pdev->dev, "unable to allocate SCB\n");
+                        wd719x_finish_cmd(cmd, DID_ERROR);
+                        spin_unlock_irqrestore(wd->sh->host_lock, flags);
+                        return 0;
+                }
+        }
+        memset(scb, 0, sizeof(struct wd719x_scb));
+        list_add(&scb->list, &wd->active_scbs);
+
+        scb->phys = phys;
+        scb->cmd = cmd;
+        cmd->host_scribble = (char *) scb;
+
+        scb->CDB_tag = 0;       /* Tagged queueing not supported yet */
+        scb->devid = cmd->device->id;
+        scb->lun = cmd->device->lun;
+
+        /* copy the command */
+        memcpy(scb->CDB, cmd->cmnd, cmd->cmd_len);
+
+        /* map sense buffer */
+        scb->sense_buf_length = SCSI_SENSE_BUFFERSIZE;
+        cmd->SCp.dma_handle = dma_map_single(&wd->pdev->dev, cmd->sense_buffer,
+                        SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
+        scb->sense_buf = cpu_to_le32(cmd->SCp.dma_handle);
+
+        /* request autosense */
+        scb->SCB_options |= WD719X_SCB_FLAGS_AUTO_REQUEST_SENSE;
+
+        /* check direction */
+        if (cmd->sc_data_direction == DMA_TO_DEVICE)
+                scb->SCB_options |= WD719X_SCB_FLAGS_CHECK_DIRECTION
+                                 |  WD719X_SCB_FLAGS_PCI_TO_SCSI;
+        else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
+                scb->SCB_options |= WD719X_SCB_FLAGS_CHECK_DIRECTION;
+
+        /* Scather/gather */
+        count_sg = scsi_dma_map(cmd);
+        if (count_sg < 0) {
+                wd719x_finish_cmd(cmd, DID_ERROR);
+                spin_unlock_irqrestore(wd->sh->host_lock, flags);
+                return 0;
+        }
+        BUG_ON(count_sg > WD719X_SG);
+
+        if (count_sg) {
+                struct scatterlist *sg;
+
+                scb->data_length = cpu_to_le32(count_sg *
+                                               sizeof(struct wd719x_sglist));
+                scb->data_p = cpu_to_le32(scb->phys +
+                                          offsetof(struct wd719x_scb, sg_list));
+
+                scsi_for_each_sg(cmd, sg, count_sg, i) {
+                        scb->sg_list[i].ptr = cpu_to_le32(sg_dma_address(sg));
+                        scb->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
+                }
+                scb->SCB_options |= WD719X_SCB_FLAGS_DO_SCATTER_GATHER;
+        } else { /* zero length */
+                scb->data_length = 0;
+                scb->data_p = 0;
+        }
+
+        /* check if the Command register is free */
+        if (wd719x_readb(wd, WD719X_AMR_COMMAND) != WD719X_CMD_READY) {
+                spin_unlock_irqrestore(wd->sh->host_lock, flags);
+                return SCSI_MLQUEUE_HOST_BUSY;
+        }
+
+        /* write pointer to the AMR */
+        wd719x_writel(wd, WD719X_AMR_SCB_IN, scb->phys);
+        /* send SCB opcode */
+        wd719x_writeb(wd, WD719X_AMR_COMMAND, WD719X_CMD_PROCESS_SCB);
+
+        spin_unlock_irqrestore(wd->sh->host_lock, flags);
+
+        return 0;
+}
+
+static int wd719x_chip_init(struct wd719x *wd)
+{
+        int i, ret;
+        u32 risc_init[3];
+        const struct firmware *fw_wcs, *fw_risc;
+        const char fwname_wcs[] = "wd719x-wcs.bin";
+        const char fwname_risc[] = "wd719x-risc.bin";
+
+        memset(wd->hash_virt, 0, WD719X_HASH_TABLE_SIZE);
+
+        /* WCS (sequencer) firmware */
+        ret = request_firmware(&fw_wcs, fwname_wcs, &wd->pdev->dev);
+        if (ret) {
+                dev_err(&wd->pdev->dev, "Unable to load firmware %s: %d\n",
+                        fwname_wcs, ret);
+                return ret;
+        }
+        /* RISC firmware */
+        ret = request_firmware(&fw_risc, fwname_risc, &wd->pdev->dev);
+        if (ret) {
+                dev_err(&wd->pdev->dev, "Unable to load firmware %s: %d\n",
+                        fwname_risc, ret);
+                release_firmware(fw_wcs);
+                return ret;
+        }
+        wd->fw_size = ALIGN(fw_wcs->size, 4) + fw_risc->size;
+
+        if (!wd->fw_virt)
+                wd->fw_virt = pci_alloc_consistent(wd->pdev, wd->fw_size,
+                                                   &wd->fw_phys);
+        if (!wd->fw_virt) {
+                ret = -ENOMEM;
+                goto wd719x_init_end;
+        }
+
+        /* make a fresh copy of WCS and RISC code */
+        memcpy(wd->fw_virt, fw_wcs->data, fw_wcs->size);
+        memcpy(wd->fw_virt + ALIGN(fw_wcs->size, 4), fw_risc->data,
+                fw_risc->size);
+
+        /* Reset the Spider Chip and adapter itself */
+        wd719x_writeb(wd, WD719X_PCI_PORT_RESET, WD719X_PCI_RESET);
+        udelay(WD719X_WAIT_FOR_RISC);
+        /* Clear PIO mode bits set by BIOS */
+        wd719x_writeb(wd, WD719X_AMR_CMD_PARAM, 0);
+        /* ensure RISC is not running */
+        wd719x_writeb(wd, WD719X_PCI_MODE_SELECT, 0);
+        /* ensure command port is ready */
+        wd719x_writeb(wd, WD719X_AMR_COMMAND, 0);
+        if (wd719x_wait_ready(wd)) {
+                ret = -ETIMEDOUT;
+                goto wd719x_init_end;
+        }
+
+        /* Transfer the first 2K words of RISC code to kick start the uP */
+        risc_init[0] = wd->fw_phys;                             /* WCS FW */
+        risc_init[1] = wd->fw_phys + ALIGN(fw_wcs->size, 4);    /* RISC FW */
+        risc_init[2] = wd->hash_phys;                           /* hash table */
+
+        /* clear DMA status */
+        wd719x_writeb(wd, WD719X_PCI_CHANNEL2_3STATUS, 0);
+
+        /* address to read firmware from */
+        wd719x_writel(wd, WD719X_PCI_EXTERNAL_ADDR, risc_init[1]);
+        /* base address to write firmware to (on card) */
+        wd719x_writew(wd, WD719X_PCI_INTERNAL_ADDR, WD719X_PRAM_BASE_ADDR);
+        /* size: first 2K words */
+        wd719x_writew(wd, WD719X_PCI_DMA_TRANSFER_SIZE, 2048 * 2);
+        /* start DMA */
+        wd719x_writeb(wd, WD719X_PCI_CHANNEL2_3CMD, WD719X_START_CHANNEL2_3DMA);
+
+        /* wait for DMA to complete */
+        i = WD719X_WAIT_FOR_RISC;
+        while (i-- > 0) {
+                u8 status = wd719x_readb(wd, WD719X_PCI_CHANNEL2_3STATUS);
+                if (status == WD719X_START_CHANNEL2_3DONE)
+                        break;
+                if (status == WD719X_START_CHANNEL2_3ABORT) {
+                        dev_warn(&wd->pdev->dev, "RISC bootstrap failed: DMA aborted\n");
+                        ret = -EIO;
+                        goto wd719x_init_end;
+                }
+                udelay(1);
+        }
+        if (i < 1) {
+                dev_warn(&wd->pdev->dev, "RISC bootstrap failed: DMA timeout\n");
+                ret = -ETIMEDOUT;
+                goto wd719x_init_end;
+        }
+
+        /* firmware is loaded, now initialize and wake up the RISC */
+        /* write RISC initialization long words to Spider */
+        wd719x_writel(wd, WD719X_AMR_SCB_IN, risc_init[0]);
+        wd719x_writel(wd, WD719X_AMR_SCB_IN + 4, risc_init[1]);
+        wd719x_writel(wd, WD719X_AMR_SCB_IN + 8, risc_init[2]);
+
+        /* disable interrupts during initialization of RISC */
+        wd719x_writeb(wd, WD719X_AMR_CMD_PARAM, WD719X_DISABLE_INT);
+
+        /* issue INITIALIZE RISC comand */
+        wd719x_writeb(wd, WD719X_AMR_COMMAND, WD719X_CMD_INIT_RISC);
+        /* enable advanced mode (wake up RISC) */
+        wd719x_writeb(wd, WD719X_PCI_MODE_SELECT, WD719X_ENABLE_ADVANCE_MODE);
+        udelay(WD719X_WAIT_FOR_RISC);
+
+        ret = wd719x_wait_done(wd, WD719X_WAIT_FOR_RISC);
+        /* clear interrupt status register */
+        wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
+        if (ret) {
+                dev_warn(&wd->pdev->dev, "Unable to initialize RISC\n");
+                goto wd719x_init_end;
+        }
+        /* RISC is up and running */
+
+        /* Read FW version from RISC */
+        ret = wd719x_direct_cmd(wd, WD719X_CMD_READ_FIRMVER, 0, 0, 0, 0,
+                                WD719X_WAIT_FOR_RISC);
+        if (ret) {
+                dev_warn(&wd->pdev->dev, "Unable to read firmware version\n");
+                goto wd719x_init_end;
+        }
+        dev_info(&wd->pdev->dev, "RISC initialized with firmware version %.2x.%.2x\n",
+                        wd719x_readb(wd, WD719X_AMR_SCB_OUT + 1),
+                        wd719x_readb(wd, WD719X_AMR_SCB_OUT));
+
+        /* RESET SCSI bus */
+        ret = wd719x_direct_cmd(wd, WD719X_CMD_BUSRESET, 0, 0, 0, 0,
+                                WD719X_WAIT_FOR_SCSI_RESET);
+        if (ret) {
+                dev_warn(&wd->pdev->dev, "SCSI bus reset failed\n");
+                goto wd719x_init_end;
+        }
+
+        /* use HostParameter structure to set Spider's Host Parameter Block */
+        ret = wd719x_direct_cmd(wd, WD719X_CMD_SET_PARAM, 0,
+                                sizeof(struct wd719x_host_param), 0,
+                                wd->params_phys, WD719X_WAIT_FOR_RISC);
+        if (ret) {
+                dev_warn(&wd->pdev->dev, "Failed to set HOST PARAMETERS\n");
+                goto wd719x_init_end;
+        }
+
+        /* initiate SCAM (does nothing if disabled in BIOS) */
+        /* bug?: we should pass a mask of static IDs which we don't have */
+        ret = wd719x_direct_cmd(wd, WD719X_CMD_INIT_SCAM, 0, 0, 0, 0,
+                                WD719X_WAIT_FOR_SCSI_RESET);
+        if (ret) {
+                dev_warn(&wd->pdev->dev, "SCAM initialization failed\n");
+                goto wd719x_init_end;
+        }
+
+        /* clear AMR_BIOS_SHARE_INT register */
+        wd719x_writeb(wd, WD719X_AMR_BIOS_SHARE_INT, 0);
+
+wd719x_init_end:
+        release_firmware(fw_wcs);
+        release_firmware(fw_risc);
+
+        return ret;
+}
+
+static int wd719x_abort(struct scsi_cmnd *cmd)
+{
+        int action, result;
+        unsigned long flags;
+        struct wd719x_scb *scb = (struct wd719x_scb *)cmd->host_scribble;
+        struct wd719x *wd = shost_priv(cmd->device->host);
+
+        dev_info(&wd->pdev->dev, "abort command, tag: %x\n", cmd->tag);
+
+        action = /*cmd->tag ? WD719X_CMD_ABORT_TAG : */WD719X_CMD_ABORT;
+
+        spin_lock_irqsave(wd->sh->host_lock, flags);
+        result = wd719x_direct_cmd(wd, action, cmd->device->id,
+                                   cmd->device->lun, cmd->tag, scb->phys, 0);
+        spin_unlock_irqrestore(wd->sh->host_lock, flags);
+        if (result)
+                return FAILED;
+
+        return SUCCESS;
+}
+
+static int wd719x_reset(struct scsi_cmnd *cmd, u8 opcode, u8 device)
+{
+        int result;
+        unsigned long flags;
+        struct wd719x *wd = shost_priv(cmd->device->host);
+
+        dev_info(&wd->pdev->dev, "%s reset requested\n",
+                 (opcode == WD719X_CMD_BUSRESET) ? "bus" : "device");
+
+        spin_lock_irqsave(wd->sh->host_lock, flags);
+        result = wd719x_direct_cmd(wd, opcode, device, 0, 0, 0,
+                                   WD719X_WAIT_FOR_SCSI_RESET);
+        spin_unlock_irqrestore(wd->sh->host_lock, flags);
+        if (result)
+                return FAILED;
+
+        return SUCCESS;
+}
+
+static int wd719x_dev_reset(struct scsi_cmnd *cmd)
+{
+        return wd719x_reset(cmd, WD719X_CMD_RESET, cmd->device->id);
+}
+
+static int wd719x_bus_reset(struct scsi_cmnd *cmd)
+{
+        return wd719x_reset(cmd, WD719X_CMD_BUSRESET, 0);
+}
+
+static int wd719x_host_reset(struct scsi_cmnd *cmd)
+{
+        struct wd719x *wd = shost_priv(cmd->device->host);
+        struct wd719x_scb *scb, *tmp;
+        unsigned long flags;
+        int result;
+
+        dev_info(&wd->pdev->dev, "host reset requested\n");
+        spin_lock_irqsave(wd->sh->host_lock, flags);
+        /* Try to reinit the RISC */
+        if (wd719x_chip_init(wd) == 0)
+                result = SUCCESS;
+        else
+                result = FAILED;
+
+        /* flush all SCBs */
+        list_for_each_entry_safe(scb, tmp, &wd->active_scbs, list) {
+                struct scsi_cmnd *tmp_cmd = scb->cmd;
+                wd719x_finish_cmd(tmp_cmd, result);
+        }
+        spin_unlock_irqrestore(wd->sh->host_lock, flags);
+
+        return result;
+}
+
+static int wd719x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
+                            sector_t capacity, int geom[])
+{
+        if (capacity >= 0x200000) {
+                geom[0] = 255;  /* heads */
+                geom[1] = 63;   /* sectors */
+        } else {
+                geom[0] = 64;   /* heads */
+                geom[1] = 32;   /* sectors */
+        }
+        geom[2] = sector_div(capacity, geom[0] * geom[1]);      /* cylinders */
+
+        return 0;
+}
+
+/* process a SCB-completion interrupt */
+static inline void wd719x_interrupt_SCB(struct wd719x *wd,
+                                        union wd719x_regs regs,
+                                        struct wd719x_scb *scb)
+{
+        struct scsi_cmnd *cmd;
+        int result;
+
+        /* now have to find result from card */
+        switch (regs.bytes.SUE) {
+        case WD719X_SUE_NOERRORS:
+                result = DID_OK;
+                break;
+        case WD719X_SUE_REJECTED:
+                dev_err(&wd->pdev->dev, "command rejected\n");
+                result = DID_ERROR;
+                break;
+        case WD719X_SUE_SCBQFULL:
+                dev_err(&wd->pdev->dev, "SCB queue is full\n");
+                result = DID_ERROR;
+                break;
+        case WD719X_SUE_TERM:
+                dev_dbg(&wd->pdev->dev, "SCB terminated by direct command\n");
+                result = DID_ABORT;     /* or DID_RESET? */
+                break;
+        case WD719X_SUE_CHAN1ABORT:
+        case WD719X_SUE_CHAN23ABORT:
+                result = DID_ABORT;
+                dev_err(&wd->pdev->dev, "DMA abort\n");
+                break;
+        case WD719X_SUE_CHAN1PAR:
+        case WD719X_SUE_CHAN23PAR:
+                result = DID_PARITY;
+                dev_err(&wd->pdev->dev, "DMA parity error\n");
+                break;
+        case WD719X_SUE_TIMEOUT:
+                result = DID_TIME_OUT;
+                dev_dbg(&wd->pdev->dev, "selection timeout\n");
+                break;
+        case WD719X_SUE_RESET:
+                dev_dbg(&wd->pdev->dev, "bus reset occured\n");
+                result = DID_RESET;
+                break;
+        case WD719X_SUE_BUSERROR:
+                dev_dbg(&wd->pdev->dev, "SCSI bus error\n");
+                result = DID_ERROR;
+                break;
+        case WD719X_SUE_WRONGWAY:
+                dev_err(&wd->pdev->dev, "wrong data transfer direction\n");
+                result = DID_ERROR;
+                break;
+        case WD719X_SUE_BADPHASE:
+                dev_err(&wd->pdev->dev, "invalid SCSI phase\n");
+                result = DID_ERROR;
+                break;
+        case WD719X_SUE_TOOLONG:
+                dev_err(&wd->pdev->dev, "record too long\n");
+                result = DID_ERROR;
+                break;
+        case WD719X_SUE_BUSFREE:
+                dev_err(&wd->pdev->dev, "unexpected bus free\n");
+                result = DID_NO_CONNECT; /* or DID_ERROR ???*/
+                break;
+        case WD719X_SUE_ARSDONE:
+                dev_dbg(&wd->pdev->dev, "auto request sense\n");
+                if (regs.bytes.SCSI == 0)
+                        result = DID_OK;
+                else
+                        result = DID_PARITY;
+                break;
+        case WD719X_SUE_IGNORED:
+                dev_err(&wd->pdev->dev, "target id %d ignored command\n",
+                        scb->cmd->device->id);
+                result = DID_NO_CONNECT;
+                break;
+        case WD719X_SUE_WRONGTAGS:
+                dev_err(&wd->pdev->dev, "reversed tags\n");
+                result = DID_ERROR;
+                break;
+        case WD719X_SUE_BADTAGS:
+                dev_err(&wd->pdev->dev, "tag type not supported by target\n");
+                result = DID_ERROR;
+                break;
+        case WD719X_SUE_NOSCAMID:
+                dev_err(&wd->pdev->dev, "no SCAM soft ID available\n");
+                result = DID_ERROR;
+                break;
+        default:
+                dev_warn(&wd->pdev->dev, "unknown SUE error code: 0x%x\n",
+                         regs.bytes.SUE);
+                result = DID_ERROR;
+                break;
+        }
+        cmd = scb->cmd;
+
+        wd719x_finish_cmd(cmd, result);
+}
+
+static irqreturn_t wd719x_interrupt(int irq, void *dev_id)
+{
+        struct wd719x *wd = dev_id;
+        union wd719x_regs regs;
+        unsigned long flags;
+        u32 SCB_out;
+
+        spin_lock_irqsave(wd->sh->host_lock, flags);
+        /* read SCB pointer back from card */
+        SCB_out = wd719x_readl(wd, WD719X_AMR_SCB_OUT);
+        /* read all status info at once */
+        regs.all = cpu_to_le32(wd719x_readl(wd, WD719X_AMR_OP_CODE));
+
+        switch (regs.bytes.INT) {
+        case WD719X_INT_NONE:
+                spin_unlock_irqrestore(wd->sh->host_lock, flags);
+                return IRQ_NONE;
+        case WD719X_INT_LINKNOSTATUS:
+                dev_err(&wd->pdev->dev, "linked command completed with no status\n");
+                break;
+        case WD719X_INT_BADINT:
+                dev_err(&wd->pdev->dev, "unsolicited interrupt\n");
+                break;
+        case WD719X_INT_NOERRORS:
+        case WD719X_INT_LINKNOERRORS:
+        case WD719X_INT_ERRORSLOGGED:
+        case WD719X_INT_SPIDERFAILED:
+                /* was the cmd completed a direct or SCB command? */
+                if (regs.bytes.OPC == WD719X_CMD_PROCESS_SCB) {
+                        struct wd719x_scb *scb;
+                        list_for_each_entry(scb, &wd->active_scbs, list)
+                                if (SCB_out == scb->phys)
+                                        break;
+                        if (SCB_out == scb->phys)
+                                wd719x_interrupt_SCB(wd, regs, scb);
+                        else
+                                dev_err(&wd->pdev->dev, "card returned invalid SCB pointer\n");
+                } else
+                        dev_warn(&wd->pdev->dev, "direct command 0x%x completed\n",
+                                 regs.bytes.OPC);
+                break;
+        case WD719X_INT_PIOREADY:
+                dev_err(&wd->pdev->dev, "card indicates PIO data ready but we never use PIO\n");
+                /* interrupt will not be cleared until all data is read */
+                break;
+        default:
+                dev_err(&wd->pdev->dev, "unknown interrupt reason: %d\n",
+                        regs.bytes.INT);
+
+        }
+        /* clear interrupt so another can happen */
+        wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
+        spin_unlock_irqrestore(wd->sh->host_lock, flags);
+
+        return IRQ_HANDLED;
+}
+
+static void wd719x_eeprom_reg_read(struct eeprom_93cx6 *eeprom)
+{
+        struct wd719x *wd = eeprom->data;
+        u8 reg = wd719x_readb(wd, WD719X_PCI_GPIO_DATA);
+
+        eeprom->reg_data_out = reg & WD719X_EE_DO;
+}
+
+static void wd719x_eeprom_reg_write(struct eeprom_93cx6 *eeprom)
+{
+        struct wd719x *wd = eeprom->data;
+        u8 reg = 0;
+
+        if (eeprom->reg_data_in)
+                reg |= WD719X_EE_DI;
+        if (eeprom->reg_data_clock)
+                reg |= WD719X_EE_CLK;
+        if (eeprom->reg_chip_select)
+                reg |= WD719X_EE_CS;
+
+        wd719x_writeb(wd, WD719X_PCI_GPIO_DATA, reg);
+}
+
+/* read config from EEPROM so it can be downloaded by the RISC on (re-)init */
+static void wd719x_read_eeprom(struct wd719x *wd)
+{
+        struct eeprom_93cx6 eeprom;
+        u8 gpio;
+        struct wd719x_eeprom_header header;
+
+        eeprom.data = wd;
+        eeprom.register_read = wd719x_eeprom_reg_read;
+        eeprom.register_write = wd719x_eeprom_reg_write;
+        eeprom.width = PCI_EEPROM_WIDTH_93C46;
+
+        /* set all outputs to low */
+        wd719x_writeb(wd, WD719X_PCI_GPIO_DATA, 0);
+        /* configure GPIO pins */
+        gpio = wd719x_readb(wd, WD719X_PCI_GPIO_CONTROL);
+        /* GPIO outputs */
+        gpio &= (~(WD719X_EE_CLK | WD719X_EE_DI | WD719X_EE_CS));
+        /* GPIO input */
+        gpio |= WD719X_EE_DO;
+        wd719x_writeb(wd, WD719X_PCI_GPIO_CONTROL, gpio);
+
+        /* read EEPROM header */
+        eeprom_93cx6_multireadb(&eeprom, 0, (u8 *)&header, sizeof(header));
+
+        if (header.sig1 == 'W' && header.sig2 == 'D')
+                eeprom_93cx6_multireadb(&eeprom, header.cfg_offset,
+                                        (u8 *)wd->params,
+                                        sizeof(struct wd719x_host_param));
+        else { /* default EEPROM values */
+                dev_warn(&wd->pdev->dev, "EEPROM signature is invalid (0x%02x 0x%02x), using default values\n",
+                         header.sig1, header.sig2);
+                wd->params->ch_1_th     = 0x10; /* 16 DWs = 64 B */
+                wd->params->scsi_conf   = 0x4c; /* 48ma, spue, parity check */
+                wd->params->own_scsi_id = 0x07; /* ID 7, SCAM disabled */
+                wd->params->sel_timeout = 0x4d; /* 250 ms */
+                wd->params->sleep_timer = 0x01;
+                wd->params->cdb_size    = cpu_to_le16(0x5555);  /* all 6 B */
+                wd->params->scsi_pad    = 0x1b;
+                if (wd->type == WD719X_TYPE_7193) /* narrow card - disable */
+                        wd->params->wide = cpu_to_le32(0x00000000);
+                else    /* initiate & respond to WIDE messages */
+                        wd->params->wide = cpu_to_le32(0xffffffff);
+                wd->params->sync        = cpu_to_le32(0xffffffff);
+                wd->params->soft_mask   = 0x00; /* all disabled */
+                wd->params->unsol_mask  = 0x00; /* all disabled */
+        }
+        /* disable TAGGED messages */
+        wd->params->tag_en = cpu_to_le16(0x0000);
+}
+
+/* Read card type from GPIO bits 1 and 3 */
+static enum wd719x_card_type wd719x_detect_type(struct wd719x *wd)
+{
+        u8 card = wd719x_readb(wd, WD719X_PCI_GPIO_CONTROL);
+
+        card |= WD719X_GPIO_ID_BITS;
+        wd719x_writeb(wd, WD719X_PCI_GPIO_CONTROL, card);
+        card = wd719x_readb(wd, WD719X_PCI_GPIO_DATA) & WD719X_GPIO_ID_BITS;
+        switch (card) {
+        case 0x08:
+                return WD719X_TYPE_7193;
+        case 0x02:
+                return WD719X_TYPE_7197;
+        case 0x00:
+                return WD719X_TYPE_7296;
+        default:
+                dev_warn(&wd->pdev->dev, "unknown card type 0x%x\n", card);
+                return WD719X_TYPE_UNKNOWN;
+        }
+}
+
+static int wd719x_board_found(struct Scsi_Host *sh)
+{
+        struct wd719x *wd = shost_priv(sh);
+        char *card_types[] = { "Unknown card", "WD7193", "WD7197", "WD7296" };
+        int ret;
+
+        INIT_LIST_HEAD(&wd->active_scbs);
+        INIT_LIST_HEAD(&wd->free_scbs);
+
+        sh->base = pci_resource_start(wd->pdev, 0);
+
+        wd->type = wd719x_detect_type(wd);
+
+        wd->sh = sh;
+        sh->irq = wd->pdev->irq;
+        wd->fw_virt = NULL;
+
+        /* memory area for host (EEPROM) parameters */
+        wd->params = pci_alloc_consistent(wd->pdev,
+                                          sizeof(struct wd719x_host_param),
+                                          &wd->params_phys);
+        if (!wd->params) {
+                dev_warn(&wd->pdev->dev, "unable to allocate parameter buffer\n");
+                return -ENOMEM;
+        }
+
+        /* memory area for the RISC for hash table of outstanding requests */
+        wd->hash_virt = pci_alloc_consistent(wd->pdev, WD719X_HASH_TABLE_SIZE,
+                                             &wd->hash_phys);
+        if (!wd->hash_virt) {
+                dev_warn(&wd->pdev->dev, "unable to allocate hash buffer\n");
+                ret = -ENOMEM;
+                goto fail_free_params;
+        }
+
+        ret = request_irq(wd->pdev->irq, wd719x_interrupt, IRQF_SHARED,
+                          "wd719x", wd);
+        if (ret) {
+                dev_warn(&wd->pdev->dev, "unable to assign IRQ %d\n",
+                         wd->pdev->irq);
+                goto fail_free_hash;
+        }
+
+        /* read parameters from EEPROM */
+        wd719x_read_eeprom(wd);
+
+        ret = wd719x_chip_init(wd);
+        if (ret)
+                goto fail_free_irq;
+
+        sh->this_id = wd->params->own_scsi_id & WD719X_EE_SCSI_ID_MASK;
+
+        dev_info(&wd->pdev->dev, "%s at I/O 0x%lx, IRQ %u, SCSI ID %d\n",
+                 card_types[wd->type], sh->base, sh->irq, sh->this_id);
+
+        return 0;
+
+fail_free_irq:
+        free_irq(wd->pdev->irq, wd);
+fail_free_hash:
+        pci_free_consistent(wd->pdev, WD719X_HASH_TABLE_SIZE, wd->hash_virt,
+                            wd->hash_phys);
+fail_free_params:
+        pci_free_consistent(wd->pdev, sizeof(struct wd719x_host_param),
+                            wd->params, wd->params_phys);
+
+        return ret;
+}
+
+static struct scsi_host_template wd719x_template = {
+        .name                           = "Western Digital 719x",
+        .queuecommand                   = wd719x_queuecommand,
+        .eh_abort_handler               = wd719x_abort,
+        .eh_device_reset_handler        = wd719x_dev_reset,
+        .eh_bus_reset_handler           = wd719x_bus_reset,
+        .eh_host_reset_handler          = wd719x_host_reset,
+        .bios_param                     = wd719x_biosparam,
+        .proc_name                      = "wd719x",
+        .can_queue                      = 255,
+        .this_id                        = 7,
+        .sg_tablesize                   = WD719X_SG,
+        .cmd_per_lun                    = WD719X_CMD_PER_LUN,
+        .use_clustering                 = ENABLE_CLUSTERING,
+};
+
+static int wd719x_pci_probe(struct pci_dev *pdev, const struct pci_device_id *d)
+{
+        int err;
+        struct Scsi_Host *sh;
+        struct wd719x *wd;
+
+        err = pci_enable_device(pdev);
+        if (err)
+                goto fail;
+
+        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
+                dev_warn(&pdev->dev, "Unable to set 32-bit DMA mask\n");
+                goto disable_device;
+        }
+
+        err = pci_request_regions(pdev, "wd719x");
+        if (err)
+                goto disable_device;
+        pci_set_master(pdev);
+
+        err = -ENODEV;
+        if (pci_resource_len(pdev, 0) == 0)
+                goto release_region;
+
+        err = -ENOMEM;
+        sh = scsi_host_alloc(&wd719x_template, sizeof(struct wd719x));
+        if (!sh)
+                goto release_region;
+
+        wd = shost_priv(sh);
+        wd->base = pci_iomap(pdev, 0, 0);
+        if (!wd->base)
+                goto free_host;
+        wd->pdev = pdev;
+
+        err = wd719x_board_found(sh);
+        if (err)
+                goto unmap;
+
+        err = scsi_add_host(sh, &wd->pdev->dev);
+        if (err)
+                goto destroy;
+
+        scsi_scan_host(sh);
+
+        pci_set_drvdata(pdev, sh);
+        return 0;
+
+destroy:
+        wd719x_destroy(wd);
+unmap:
+        pci_iounmap(pdev, wd->base);
+free_host:
+        scsi_host_put(sh);
+release_region:
+        pci_release_regions(pdev);
+disable_device:
+        pci_disable_device(pdev);
+fail:
+        return err;
+}
+
+
+static void wd719x_pci_remove(struct pci_dev *pdev)
+{
+        struct Scsi_Host *sh = pci_get_drvdata(pdev);
+        struct wd719x *wd = shost_priv(sh);
+
+        scsi_remove_host(sh);
+        wd719x_destroy(wd);
+        pci_iounmap(pdev, wd->base);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+
+        scsi_host_put(sh);
+}
+
+static DEFINE_PCI_DEVICE_TABLE(wd719x_pci_table) = {
+        { PCI_DEVICE(PCI_VENDOR_ID_WD, 0x3296) },
+        {}
+};
+
+MODULE_DEVICE_TABLE(pci, wd719x_pci_table);
+
+static struct pci_driver wd719x_pci_driver = {
+        .name =         "wd719x",
+        .id_table =     wd719x_pci_table,
+        .probe =        wd719x_pci_probe,
+        .remove =       wd719x_pci_remove,
+};
+
+static int __init wd719x_init(void)
+{
+        return pci_register_driver(&wd719x_pci_driver);
+}
+
+static void __exit wd719x_exit(void)
+{
+        pci_unregister_driver(&wd719x_pci_driver);
+}
+
+module_init(wd719x_init);
+module_exit(wd719x_exit);
+
+MODULE_DESCRIPTION("Western Digital WD7193/7197/7296 SCSI driver");
+MODULE_AUTHOR("Ondrej Zary, Aaron Dewell, Juergen Gaertner");
+MODULE_LICENSE("GPL");
+MODULE_FIRMWARE("wd719x-wcs.bin");
+MODULE_FIRMWARE("wd719x-risc.bin");
diff --git a/drivers/scsi/wd719x.h b/drivers/scsi/wd719x.h
new file mode 100644
index 000000000000..185e30e4eb93
--- /dev/null
+++ b/drivers/scsi/wd719x.h
@@ -0,0 +1,249 @@
+#ifndef _WD719X_H_
+#define _WD719X_H_
+
+#define WD719X_SG 255           /* Scatter/gather size */
+#define WD719X_CMD_PER_LUN 1    /* We should be able to do linked commands, but
+                                 * this is 1 for now to be safe. */
+
+struct wd719x_sglist {
+        __le32 ptr;
+        __le32 length;
+} __packed;
+
+enum wd719x_card_type {
+        WD719X_TYPE_UNKNOWN = 0,
+        WD719X_TYPE_7193,
+        WD719X_TYPE_7197,
+        WD719X_TYPE_7296,
+};
+
+union wd719x_regs {
+        __le32 all;     /* All Status at once */
+        struct {
+                u8 OPC;         /* Opcode register */
+                u8 SCSI;        /* SCSI Errors */
+                u8 SUE;         /* Spider unique Errors */
+                u8 INT;         /* Interrupt Status */
+        } bytes;
+};
+
+/* Spider Command Block (SCB) */
+struct wd719x_scb {
+        __le32 Int_SCB; /* 00-03 Internal SCB link pointer (must be cleared) */
+        u8 SCB_opcode;  /* 04 SCB Command opcode */
+        u8 CDB_tag;     /* 05 SCSI Tag byte for CDB queues (0 if untagged) */
+        u8 lun;         /* 06 SCSI LUN */
+        u8 devid;       /* 07 SCSI Device ID */
+        u8 CDB[16];     /* 08-23 SCSI CDB (16 bytes as defined by ANSI spec. */
+        __le32 data_p;  /* 24-27 Data transfer address (or SG list address) */
+        __le32 data_length; /* 28-31 Data transfer Length (or SG list length) */
+        __le32 CDB_link;    /* 32-35 SCSI CDB Link Ptr */
+        __le32 sense_buf;   /* 36-39 Auto request sense buffer address */
+        u8 sense_buf_length;/* 40 Auto request sense transfer length */
+        u8 reserved;    /* 41 reserved */
+        u8 SCB_options; /* 42 SCB-options */
+        u8 SCB_tag_msg; /* 43 Tagged messages options */
+        /* Not filled in by host */
+        __le32 req_ptr; /* 44-47 Ptr to Host Request returned on interrupt */
+        u8 host_opcode; /* 48 Host Command Opcode (same as AMR_00) */
+        u8 scsi_stat;   /* 49 SCSI Status returned */
+        u8 ret_error;   /* 50 SPIDER Unique Error Code returned (SUE) */
+        u8 int_stat;    /* 51 Message u8 / Interrupt Status byte returned */
+        __le32 transferred; /* 52-55 Bytes Transferred */
+        u8 last_trans[3];  /* 56-58 Bytes Transferred in last session */
+        u8 length;      /* 59 SCSI Messages Length (1-8) */
+        u8 sync_offset; /* 60 Synchronous offset */
+        u8 sync_rate;   /* 61 Synchronous rate */
+        u8 flags[2];    /* 62-63 SCB specific flags (local to each thread) */
+        /* everything below is for driver use (not used by card) */
+        dma_addr_t phys;        /* bus address of the SCB */
+        struct scsi_cmnd *cmd;  /* a copy of the pointer we were passed */
+        struct list_head list;
+        struct wd719x_sglist sg_list[WD719X_SG] __aligned(8); /* SG list */
+} __packed;
+
+struct wd719x {
+        struct Scsi_Host *sh;   /* pointer to host structure */
+        struct pci_dev *pdev;
+        void __iomem *base;
+        enum wd719x_card_type type; /* type of card */
+        void *fw_virt;          /* firmware buffer CPU address */
+        dma_addr_t fw_phys;     /* firmware buffer bus address */
+        size_t fw_size;         /* firmware buffer size */
+        struct wd719x_host_param *params; /* host parameters (EEPROM) */
+        dma_addr_t params_phys; /* host parameters bus address */
+        void *hash_virt;        /* hash table CPU address */
+        dma_addr_t hash_phys;   /* hash table bus address */
+        struct list_head active_scbs;
+        struct list_head free_scbs;
+};
+
+/* timeout delays in microsecs */
+#define WD719X_WAIT_FOR_CMD_READY       500
+#define WD719X_WAIT_FOR_RISC            2000
+#define WD719X_WAIT_FOR_SCSI_RESET      3000000
+
+/* All commands except 0x00 generate an interrupt */
+#define WD719X_CMD_READY        0x00 /* Command register ready (or noop) */
+#define WD719X_CMD_INIT_RISC    0x01 /* Initialize RISC */
+/* 0x02 is reserved */
+#define WD719X_CMD_BUSRESET     0x03 /* Assert SCSI bus reset */
+#define WD719X_CMD_READ_FIRMVER 0x04 /* Read the Firmware Revision */
+#define WD719X_CMD_ECHO_BYTES   0x05 /* Echo command bytes (DW) */
+/* 0x06 is reserved */
+/* 0x07 is reserved */
+#define WD719X_CMD_GET_PARAM    0x08 /* Get programmable parameters */
+#define WD719X_CMD_SET_PARAM    0x09 /* Set programmable parameters */
+#define WD719X_CMD_SLEEP        0x0a /* Put SPIDER to sleep */
+#define WD719X_CMD_READ_INIT    0x0b /* Read initialization parameters */
+#define WD719X_CMD_RESTORE_INIT 0x0c /* Restore initialization parameters */
+/* 0x0d is reserved */
+/* 0x0e is reserved */
+/* 0x0f is reserved */
+#define WD719X_CMD_ABORT_TAG    0x10 /* Send Abort tag message to target */
+#define WD719X_CMD_ABORT        0x11 /* Send Abort message to target */
+#define WD719X_CMD_RESET        0x12 /* Send Reset message to target */
+#define WD719X_CMD_INIT_SCAM    0x13 /* Initiate SCAM */
+#define WD719X_CMD_GET_SYNC     0x14 /* Get synchronous rates */
+#define WD719X_CMD_SET_SYNC     0x15 /* Set synchronous rates */
+#define WD719X_CMD_GET_WIDTH    0x16 /* Get SCSI bus width */
+#define WD719X_CMD_SET_WIDTH    0x17 /* Set SCSI bus width */
+#define WD719X_CMD_GET_TAGS     0x18 /* Get tag flags */
+#define WD719X_CMD_SET_TAGS     0x19 /* Set tag flags */
+#define WD719X_CMD_GET_PARAM2   0x1a /* Get programmable params (format 2) */
+#define WD719X_CMD_SET_PARAM2   0x1b /* Set programmable params (format 2) */
+/* Commands with request pointers (mailbox) */
+#define WD719X_CMD_PROCESS_SCB  0x80 /* Process SCSI Control Block (SCB) */
+/* No interrupt generated on acceptance of SCB pointer */
+
+/* interrupt status defines */
+#define WD719X_INT_NONE         0x00 /* No interrupt pending */
+#define WD719X_INT_NOERRORS     0x01 /* Command completed with no errors */
+#define WD719X_INT_LINKNOERRORS 0x02 /* link cmd completed with no errors */
+#define WD719X_INT_LINKNOSTATUS 0x03 /* link cmd completed with no flag set */
+#define WD719X_INT_ERRORSLOGGED 0x04 /* cmd completed with errors logged */
+#define WD719X_INT_SPIDERFAILED 0x05 /* cmd failed without valid SCSI status */
+#define WD719X_INT_BADINT       0x80 /* unsolicited interrupt */
+#define WD719X_INT_PIOREADY     0xf0 /* data ready for PIO output */
+
+/* Spider Unique Error Codes (SUE) */
+#define WD719X_SUE_NOERRORS     0x00 /* No errors detected by SPIDER */
+#define WD719X_SUE_REJECTED     0x01 /* Command Rejected (bad opcode/param) */
+#define WD719X_SUE_SCBQFULL     0x02 /* SCB queue full */
+/* 0x03 is reserved */
+#define WD719X_SUE_TERM         0x04 /* Host terminated SCB via primative cmd */
+#define WD719X_SUE_CHAN1PAR     0x05 /* PCI Channel 1 parity error occurred */
+#define WD719X_SUE_CHAN1ABORT   0x06 /* PCI Channel 1 system abort occurred */
+#define WD719X_SUE_CHAN23PAR    0x07 /* PCI Channel 2/3 parity error occurred */
+#define WD719X_SUE_CHAN23ABORT  0x08 /* PCI Channel 2/3 system abort occurred */
+#define WD719X_SUE_TIMEOUT      0x10 /* Selection/reselection timeout */
+#define WD719X_SUE_RESET        0x11 /* SCSI bus reset occurred */
+#define WD719X_SUE_BUSERROR     0x12 /* SCSI bus error */
+#define WD719X_SUE_WRONGWAY     0x13 /* Wrong data transfer dir set by target */
+#define WD719X_SUE_BADPHASE     0x14 /* SCSI phase illegal or unexpected */
+#define WD719X_SUE_TOOLONG      0x15 /* target requested too much data */
+#define WD719X_SUE_BUSFREE      0x16 /* Unexpected SCSI bus free */
+#define WD719X_SUE_ARSDONE      0x17 /* Auto request sense executed */
+#define WD719X_SUE_IGNORED      0x18 /* SCSI message was ignored by target */
+#define WD719X_SUE_WRONGTAGS    0x19 /* Tagged SCB & tags off (or vice versa) */
+#define WD719X_SUE_BADTAGS      0x1a /* Wrong tag message type for target */
+#define WD719X_SUE_NOSCAMID     0x1b /* No SCAM soft ID available */
+
+/* code sizes */
+#define WD719X_HASH_TABLE_SIZE  4096
+
+/* Advanced Mode Registers */
+/* Regs 0x00..0x1f are for Advanced Mode of the card (RISC is running). */
+#define WD719X_AMR_COMMAND              0x00
+#define WD719X_AMR_CMD_PARAM            0x01
+#define WD719X_AMR_CMD_PARAM_2          0x02
+#define WD719X_AMR_CMD_PARAM_3          0x03
+#define WD719X_AMR_SCB_IN               0x04
+
+#define WD719X_AMR_BIOS_SHARE_INT       0x0f
+
+#define WD719X_AMR_SCB_OUT              0x18
+#define WD719X_AMR_OP_CODE              0x1c
+#define WD719X_AMR_SCSI_STATUS          0x1d
+#define WD719X_AMR_SCB_ERROR            0x1e
+#define WD719X_AMR_INT_STATUS           0x1f
+
+#define WD719X_DISABLE_INT      0x80
+
+/* SCB flags */
+#define WD719X_SCB_FLAGS_CHECK_DIRECTION        0x01
+#define WD719X_SCB_FLAGS_PCI_TO_SCSI            0x02
+#define WD719X_SCB_FLAGS_AUTO_REQUEST_SENSE     0x10
+#define WD719X_SCB_FLAGS_DO_SCATTER_GATHER      0x20
+#define WD719X_SCB_FLAGS_NO_DISCONNECT          0x40
+
+/* PCI Registers used for reset, initial code download */
+/* Regs 0x20..0x3f are for Normal (DOS) mode (RISC is asleep). */
+#define WD719X_PCI_GPIO_CONTROL         0x3C
+#define WD719X_PCI_GPIO_DATA            0x3D
+#define WD719X_PCI_PORT_RESET           0x3E
+#define WD719X_PCI_MODE_SELECT          0x3F
+
+#define WD719X_PCI_EXTERNAL_ADDR        0x60
+#define WD719X_PCI_INTERNAL_ADDR        0x64
+#define WD719X_PCI_DMA_TRANSFER_SIZE    0x66
+#define WD719X_PCI_CHANNEL2_3CMD        0x68
+#define WD719X_PCI_CHANNEL2_3STATUS     0x69
+
+#define WD719X_GPIO_ID_BITS             0x0a
+#define WD719X_PRAM_BASE_ADDR           0x00
+
+/* codes written to or read from the card */
+#define WD719X_PCI_RESET                 0x01
+#define WD719X_ENABLE_ADVANCE_MODE       0x01
+
+#define WD719X_START_CHANNEL2_3DMA       0x17
+#define WD719X_START_CHANNEL2_3DONE      0x01
+#define WD719X_START_CHANNEL2_3ABORT     0x20
+
+/* 33C296 GPIO bits for EEPROM pins */
+#define WD719X_EE_DI    (1 << 1)
+#define WD719X_EE_CS    (1 << 2)
+#define WD719X_EE_CLK   (1 << 3)
+#define WD719X_EE_DO    (1 << 4)
+
+/* EEPROM contents */
+struct wd719x_eeprom_header {
+        u8 sig1;
+        u8 sig2;
+        u8 version;
+        u8 checksum;
+        u8 cfg_offset;
+        u8 cfg_size;
+        u8 setup_offset;
+        u8 setup_size;
+} __packed;
+
+#define WD719X_EE_SIG1          0
+#define WD719X_EE_SIG2          1
+#define WD719X_EE_VERSION       2
+#define WD719X_EE_CHECKSUM      3
+#define WD719X_EE_CFG_OFFSET    4
+#define WD719X_EE_CFG_SIZE      5
+#define WD719X_EE_SETUP_OFFSET  6
+#define WD719X_EE_SETUP_SIZE    7
+
+#define WD719X_EE_SCSI_ID_MASK  0xf
+
+/* SPIDER Host Parameters Block (=EEPROM configuration block) */
+struct wd719x_host_param {
+        u8 ch_1_th;     /* FIFO threshold */
+        u8 scsi_conf;   /* SCSI configuration */
+        u8 own_scsi_id; /* controller SCSI ID */
+        u8 sel_timeout; /* selection timeout*/
+        u8 sleep_timer; /* seep timer */
+        __le16 cdb_size;/* CDB size groups */
+        __le16 tag_en;  /* Tag msg enables (ID 0-15) */
+        u8 scsi_pad;    /* SCSI pad control */
+        __le32 wide;    /* WIDE msg options (ID 0-15) */
+        __le32 sync;    /* SYNC msg options (ID 0-15) */
+        u8 soft_mask;   /* soft error mask */
+        u8 unsol_mask;  /* unsolicited error mask */
+} __packed;
+
+#endif /* _WD719X_H_ */
diff --git a/drivers/sh/pm_runtime.c b/drivers/sh/pm_runtime.c
index fe2c2d595f59..f3ee439d6f0e 100644
--- a/drivers/sh/pm_runtime.c
+++ b/drivers/sh/pm_runtime.c
@@ -20,7 +20,7 @@
 #include <linux/bitmap.h>
 #include <linux/slab.h>
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int sh_pm_runtime_suspend(struct device *dev)
 {
         int ret;
@@ -68,7 +68,7 @@ static struct dev_pm_domain default_pm_domain = {
 
 #define DEFAULT_PM_DOMAIN_PTR   NULL
 
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
 static struct pm_clk_notifier_block platform_bus_notifier = {
         .pm_domain = DEFAULT_PM_DOMAIN_PTR,
diff --git a/drivers/soc/ti/knav_qmss.h b/drivers/soc/ti/knav_qmss.h
index bc9dcc8cc3ce..51da2341280d 100644
--- a/drivers/soc/ti/knav_qmss.h
+++ b/drivers/soc/ti/knav_qmss.h
@@ -348,15 +348,15 @@ struct knav_range_info {
         list_for_each_entry(region, &kdev->regions, list)
 
 #define first_region(kdev)                                      \
-        list_first_entry(&kdev->regions, \
-                        struct knav_region, list)
+        list_first_entry_or_null(&kdev->regions, \
+                                 struct knav_region, list)
 
 #define for_each_queue_range(kdev, range)                       \
         list_for_each_entry(range, &kdev->queue_ranges, list)
 
 #define first_queue_range(kdev)                                 \
-        list_first_entry(&kdev->queue_ranges, \
-                        struct knav_range_info, list)
+        list_first_entry_or_null(&kdev->queue_ranges, \
+                                 struct knav_range_info, list)
 
 #define for_each_pool(kdev, pool)                               \
         list_for_each_entry(pool, &kdev->pools, list)
diff --git a/drivers/soc/ti/knav_qmss_queue.c b/drivers/soc/ti/knav_qmss_queue.c
index 0a2c8634c48b..9b8dd6732681 100644
--- a/drivers/soc/ti/knav_qmss_queue.c
+++ b/drivers/soc/ti/knav_qmss_queue.c
@@ -785,7 +785,7 @@ void *knav_pool_create(const char *name,
                 dev_err(kdev->dev, "out of descs in region(%d) for pool(%s)\n",
                         region_id, name);
                 ret = -ENOMEM;
-                goto err;
+                goto err_unlock;
         }
 
         /* Region maintains a sorted (by region offset) list of pools
@@ -815,15 +815,16 @@ void *knav_pool_create(const char *name,
                 dev_err(kdev->dev, "pool(%s) create failed: fragmented desc pool in region(%d)\n",
                         name, region_id);
                 ret = -ENOMEM;
-                goto err;
+                goto err_unlock;
         }
 
         mutex_unlock(&knav_dev_lock);
         kdesc_fill_pool(pool);
         return pool;
 
-err:
+err_unlock:
         mutex_unlock(&knav_dev_lock);
+err:
         kfree(pool->name);
         devm_kfree(kdev->dev, pool);
         return ERR_PTR(ret);
@@ -1305,14 +1306,14 @@ static void knav_free_queue_ranges(struct knav_device *kdev)
 static void knav_queue_free_regions(struct knav_device *kdev)
 {
         struct knav_region *region;
-        struct knav_pool *pool;
+        struct knav_pool *pool, *tmp;
         unsigned size;
 
         for (;;) {
                 region = first_region(kdev);
                 if (!region)
                         break;
-                list_for_each_entry(pool, &region->pools, region_inst)
+                list_for_each_entry_safe(pool, tmp, &region->pools, region_inst)
                         knav_pool_destroy(pool);
 
                 size = region->virt_end - region->virt_start;
@@ -1639,7 +1640,7 @@ static int knav_queue_init_queues(struct knav_device *kdev)
         size = (1 << kdev->inst_shift) * kdev->num_queues_in_use;
         kdev->instances = devm_kzalloc(kdev->dev, size, GFP_KERNEL);
         if (!kdev->instances)
-                return -1;
+                return -ENOMEM;
 
         for_each_queue_range(kdev, range) {
                 if (range->ops && range->ops->init_range)
diff --git a/drivers/soc/versatile/Kconfig b/drivers/soc/versatile/Kconfig
index bf5ee9c85330..a928a7fc6be4 100644
--- a/drivers/soc/versatile/Kconfig
+++ b/drivers/soc/versatile/Kconfig
@@ -1,6 +1,15 @@
 #
 # ARM Versatile SoC drivers
 #
+config SOC_INTEGRATOR_CM
+        bool "SoC bus device for the ARM Integrator platform core modules"
+        depends on ARCH_INTEGRATOR
+        select SOC_BUS
+        help
+          Include support for the SoC bus on the ARM Integrator platform
+          core modules providing some sysfs information about the ASIC
+          variant.
+
 config SOC_REALVIEW
         bool "SoC bus device for the ARM RealView platforms"
         depends on ARCH_REALVIEW
diff --git a/drivers/soc/versatile/Makefile b/drivers/soc/versatile/Makefile
index ad547435648e..cf612fe3a659 100644
--- a/drivers/soc/versatile/Makefile
+++ b/drivers/soc/versatile/Makefile
@@ -1 +1,2 @@
+obj-$(CONFIG_SOC_INTEGRATOR_CM) += soc-integrator.o
 obj-$(CONFIG_SOC_REALVIEW)      += soc-realview.o
diff --git a/drivers/soc/versatile/soc-integrator.c b/drivers/soc/versatile/soc-integrator.c
new file mode 100644
index 000000000000..a5d7d39ae0ad
--- /dev/null
+++ b/drivers/soc/versatile/soc-integrator.c
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2014 Linaro Ltd.
+ *
+ * Author: Linus Walleij <linus.walleij@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2, as
+ * published by the Free Software Foundation.
+ *
+ */
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/sys_soc.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
+#include <linux/of.h>
+
+#define INTEGRATOR_HDR_ID_OFFSET        0x00
+
+static u32 integrator_coreid;
+
+static const struct of_device_id integrator_cm_match[] = {
+        { .compatible = "arm,core-module-integrator", },
+        { }
+};
+
+static const char *integrator_arch_str(u32 id)
+{
+        switch ((id >> 16) & 0xff) {
+        case 0x00:
+                return "ASB little-endian";
+        case 0x01:
+                return "AHB little-endian";
+        case 0x03:
+                return "AHB-Lite system bus, bi-endian";
+        case 0x04:
+                return "AHB";
+        case 0x08:
+                return "AHB system bus, ASB processor bus";
+        default:
+                return "Unknown";
+        }
+}
+
+static const char *integrator_fpga_str(u32 id)
+{
+        switch ((id >> 12) & 0xf) {
+        case 0x01:
+                return "XC4062";
+        case 0x02:
+                return "XC4085";
+        case 0x03:
+                return "XVC600";
+        case 0x04:
+                return "EPM7256AE (Altera PLD)";
+        default:
+                return "Unknown";
+        }
+}
+
+static ssize_t integrator_get_manf(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        return sprintf(buf, "%02x\n", integrator_coreid >> 24);
+}
+
+static struct device_attribute integrator_manf_attr =
+        __ATTR(manufacturer,  S_IRUGO, integrator_get_manf,  NULL);
+
+static ssize_t integrator_get_arch(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        return sprintf(buf, "%s\n", integrator_arch_str(integrator_coreid));
+}
+
+static struct device_attribute integrator_arch_attr =
+        __ATTR(arch,  S_IRUGO, integrator_get_arch,  NULL);
+
+static ssize_t integrator_get_fpga(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        return sprintf(buf, "%s\n", integrator_fpga_str(integrator_coreid));
+}
+
+static struct device_attribute integrator_fpga_attr =
+        __ATTR(fpga,  S_IRUGO, integrator_get_fpga,  NULL);
+
+static ssize_t integrator_get_build(struct device *dev,
+                               struct device_attribute *attr,
+                               char *buf)
+{
+        return sprintf(buf, "%02x\n", (integrator_coreid >> 4) & 0xFF);
+}
+
+static struct device_attribute integrator_build_attr =
+        __ATTR(build,  S_IRUGO, integrator_get_build,  NULL);
+
+static int __init integrator_soc_init(void)
+{
+        static struct regmap *syscon_regmap;
+        struct soc_device *soc_dev;
+        struct soc_device_attribute *soc_dev_attr;
+        struct device_node *np;
+        struct device *dev;
+        u32 val;
+        int ret;
+
+        np = of_find_matching_node(NULL, integrator_cm_match);
+        if (!np)
+                return -ENODEV;
+
+        syscon_regmap = syscon_node_to_regmap(np);
+        if (IS_ERR(syscon_regmap))
+                return PTR_ERR(syscon_regmap);
+
+        ret = regmap_read(syscon_regmap, INTEGRATOR_HDR_ID_OFFSET,
+                          &val);
+        if (ret)
+                return -ENODEV;
+        integrator_coreid = val;
+
+        soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL);
+        if (!soc_dev_attr)
+                return -ENOMEM;
+
+        soc_dev_attr->soc_id = "Integrator";
+        soc_dev_attr->machine = "Integrator";
+        soc_dev_attr->family = "Versatile";
+        soc_dev = soc_device_register(soc_dev_attr);
+        if (IS_ERR(soc_dev)) {
+                kfree(soc_dev_attr);
+                return -ENODEV;
+        }
+        dev = soc_device_to_device(soc_dev);
+
+        device_create_file(dev, &integrator_manf_attr);
+        device_create_file(dev, &integrator_arch_attr);
+        device_create_file(dev, &integrator_fpga_attr);
+        device_create_file(dev, &integrator_build_attr);
+
+        dev_info(dev, "Detected ARM core module:\n");
+        dev_info(dev, "    Manufacturer: %02x\n", (val >> 24));
+        dev_info(dev, "    Architecture: %s\n", integrator_arch_str(val));
+        dev_info(dev, "    FPGA: %s\n", integrator_fpga_str(val));
+        dev_info(dev, "    Build: %02x\n", (val >> 4) & 0xFF);
+        dev_info(dev, "    Rev: %c\n", ('A' + (val & 0x03)));
+
+        return 0;
+}
+device_initcall(integrator_soc_init);
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 84e7c9e6ccef..99829985c1a1 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -225,6 +225,13 @@ config SPI_GPIO
           GPIO operations, you should be able to leverage that for better
           speed with a custom version of this driver; see the source code.
 
+config SPI_IMG_SPFI
+        tristate "IMG SPFI controller"
+        depends on MIPS || COMPILE_TEST
+        help
+          This enables support for the SPFI master controller found on
+          IMG SoCs.
+
 config SPI_IMX
         tristate "Freescale i.MX SPI controllers"
         depends on ARCH_MXC || COMPILE_TEST
@@ -301,6 +308,14 @@ config SPI_FSL_ESPI
           From MPC8536, 85xx platform uses the controller, and all P10xx,
           P20xx, P30xx,P40xx, P50xx uses this controller.
 
+config SPI_MESON_SPIFC
+        tristate "Amlogic Meson SPIFC controller"
+        depends on ARCH_MESON || COMPILE_TEST
+        select REGMAP_MMIO
+        help
+          This enables master mode support for the SPIFC (SPI flash
+          controller) available in Amlogic Meson SoCs.
+
 config SPI_OC_TINY
         tristate "OpenCores tiny SPI"
         depends on GPIOLIB
@@ -444,7 +459,7 @@ config SPI_S3C24XX_FIQ
 
 config SPI_S3C64XX
         tristate "Samsung S3C64XX series type SPI"
-        depends on PLAT_SAMSUNG
+        depends on (PLAT_SAMSUNG || ARCH_EXYNOS)
         select S3C64XX_PL080 if ARCH_S3C64XX
         help
           SPI driver for Samsung S3C64XX and newer SoCs.
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index 78f24ca36fcf..6b9d2ac629cc 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -40,8 +40,10 @@ obj-$(CONFIG_SPI_FSL_LIB)		+= spi-fsl-lib.o
 obj-$(CONFIG_SPI_FSL_ESPI)              += spi-fsl-espi.o
 obj-$(CONFIG_SPI_FSL_SPI)               += spi-fsl-spi.o
 obj-$(CONFIG_SPI_GPIO)                  += spi-gpio.o
+obj-$(CONFIG_SPI_IMG_SPFI)              += spi-img-spfi.o
 obj-$(CONFIG_SPI_IMX)                   += spi-imx.o
 obj-$(CONFIG_SPI_LM70_LLP)              += spi-lm70llp.o
+obj-$(CONFIG_SPI_MESON_SPIFC)           += spi-meson-spifc.o
 obj-$(CONFIG_SPI_MPC512x_PSC)           += spi-mpc512x-psc.o
 obj-$(CONFIG_SPI_MPC52xx_PSC)           += spi-mpc52xx-psc.o
 obj-$(CONFIG_SPI_MPC52xx)               += spi-mpc52xx.o
diff --git a/drivers/spi/spi-atmel.c b/drivers/spi/spi-atmel.c
index 113c83f44b5c..e4193ccc4970 100644
--- a/drivers/spi/spi-atmel.c
+++ b/drivers/spi/spi-atmel.c
@@ -26,6 +26,7 @@
 #include <linux/io.h>
 #include <linux/gpio.h>
 #include <linux/pinctrl/consumer.h>
+#include <linux/pm_runtime.h>
 
 /* SPI register offsets */
 #define SPI_CR                                  0x0000
@@ -191,6 +192,8 @@
 
 #define SPI_DMA_TIMEOUT         (msecs_to_jiffies(1000))
 
+#define AUTOSUSPEND_TIMEOUT     2000
+
 struct atmel_spi_dma {
         struct dma_chan                 *chan_rx;
         struct dma_chan                 *chan_tx;
@@ -414,23 +417,6 @@ static int atmel_spi_dma_slave_config(struct atmel_spi *as,
         return err;
 }
 
-static bool filter(struct dma_chan *chan, void *pdata)
-{
-        struct atmel_spi_dma *sl_pdata = pdata;
-        struct at_dma_slave *sl;
-
-        if (!sl_pdata)
-                return false;
-
-        sl = &sl_pdata->dma_slave;
-        if (sl->dma_dev == chan->device->dev) {
-                chan->private = sl;
-                return true;
-        } else {
-                return false;
-        }
-}
-
 static int atmel_spi_configure_dma(struct atmel_spi *as)
 {
         struct dma_slave_config slave_config;
@@ -441,19 +427,24 @@ static int atmel_spi_configure_dma(struct atmel_spi *as)
         dma_cap_zero(mask);
         dma_cap_set(DMA_SLAVE, mask);
 
-        as->dma.chan_tx = dma_request_slave_channel_compat(mask, filter,
-                                                           &as->dma,
-                                                           dev, "tx");
-        if (!as->dma.chan_tx) {
+        as->dma.chan_tx = dma_request_slave_channel_reason(dev, "tx");
+        if (IS_ERR(as->dma.chan_tx)) {
+                err = PTR_ERR(as->dma.chan_tx);
+                if (err == -EPROBE_DEFER) {
+                        dev_warn(dev, "no DMA channel available at the moment\n");
+                        return err;
+                }
                 dev_err(dev,
                         "DMA TX channel not available, SPI unable to use DMA\n");
                 err = -EBUSY;
                 goto error;
         }
 
-        as->dma.chan_rx = dma_request_slave_channel_compat(mask, filter,
-                                                           &as->dma,
-                                                           dev, "rx");
+        /*
+         * No reason to check EPROBE_DEFER here since we have already requested
+         * tx channel. If it fails here, it's for another reason.
+         */
+        as->dma.chan_rx = dma_request_slave_channel(dev, "rx");
 
         if (!as->dma.chan_rx) {
                 dev_err(dev,
@@ -474,7 +465,7 @@ static int atmel_spi_configure_dma(struct atmel_spi *as)
 error:
         if (as->dma.chan_rx)
                 dma_release_channel(as->dma.chan_rx);
-        if (as->dma.chan_tx)
+        if (!IS_ERR(as->dma.chan_tx))
                 dma_release_channel(as->dma.chan_tx);
         return err;
 }
@@ -482,11 +473,9 @@ error:
 static void atmel_spi_stop_dma(struct atmel_spi *as)
 {
         if (as->dma.chan_rx)
-                as->dma.chan_rx->device->device_control(as->dma.chan_rx,
-                                                        DMA_TERMINATE_ALL, 0);
+                dmaengine_terminate_all(as->dma.chan_rx);
         if (as->dma.chan_tx)
-                as->dma.chan_tx->device->device_control(as->dma.chan_tx,
-                                                        DMA_TERMINATE_ALL, 0);
+                dmaengine_terminate_all(as->dma.chan_tx);
 }
 
 static void atmel_spi_release_dma(struct atmel_spi *as)
@@ -1315,6 +1304,7 @@ static int atmel_spi_probe(struct platform_device *pdev)
         master->setup = atmel_spi_setup;
         master->transfer_one_message = atmel_spi_transfer_one_message;
         master->cleanup = atmel_spi_cleanup;
+        master->auto_runtime_pm = true;
         platform_set_drvdata(pdev, master);
 
         as = spi_master_get_devdata(master);
@@ -1347,8 +1337,11 @@ static int atmel_spi_probe(struct platform_device *pdev)
         as->use_dma = false;
         as->use_pdc = false;
         if (as->caps.has_dma_support) {
-                if (atmel_spi_configure_dma(as) == 0)
+                ret = atmel_spi_configure_dma(as);
+                if (ret == 0)
                         as->use_dma = true;
+                else if (ret == -EPROBE_DEFER)
+                        return ret;
         } else {
                 as->use_pdc = true;
         }
@@ -1387,6 +1380,11 @@ static int atmel_spi_probe(struct platform_device *pdev)
         dev_info(&pdev->dev, "Atmel SPI Controller at 0x%08lx (irq %d)\n",
                         (unsigned long)regs->start, irq);
 
+        pm_runtime_set_autosuspend_delay(&pdev->dev, AUTOSUSPEND_TIMEOUT);
+        pm_runtime_use_autosuspend(&pdev->dev);
+        pm_runtime_set_active(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
         ret = devm_spi_register_master(&pdev->dev, master);
         if (ret)
                 goto out_free_dma;
@@ -1394,6 +1392,9 @@ static int atmel_spi_probe(struct platform_device *pdev)
         return 0;
 
 out_free_dma:
+        pm_runtime_disable(&pdev->dev);
+        pm_runtime_set_suspended(&pdev->dev);
+
         if (as->use_dma)
                 atmel_spi_release_dma(as);
 
@@ -1415,6 +1416,8 @@ static int atmel_spi_remove(struct platform_device *pdev)
         struct spi_master       *master = platform_get_drvdata(pdev);
         struct atmel_spi        *as = spi_master_get_devdata(master);
 
+        pm_runtime_get_sync(&pdev->dev);
+
         /* reset the hardware and block queue progress */
         spin_lock_irq(&as->lock);
         if (as->use_dma) {
@@ -1432,14 +1435,37 @@ static int atmel_spi_remove(struct platform_device *pdev)
 
         clk_disable_unprepare(as->clk);
 
+        pm_runtime_put_noidle(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
+
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
+static int atmel_spi_runtime_suspend(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct atmel_spi *as = spi_master_get_devdata(master);
+
+        clk_disable_unprepare(as->clk);
+        pinctrl_pm_select_sleep_state(dev);
+
+        return 0;
+}
+
+static int atmel_spi_runtime_resume(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct atmel_spi *as = spi_master_get_devdata(master);
+
+        pinctrl_pm_select_default_state(dev);
+
+        return clk_prepare_enable(as->clk);
+}
+
 static int atmel_spi_suspend(struct device *dev)
 {
-        struct spi_master       *master = dev_get_drvdata(dev);
-        struct atmel_spi        *as = spi_master_get_devdata(master);
+        struct spi_master *master = dev_get_drvdata(dev);
         int ret;
 
         /* Stop the queue running */
@@ -1449,22 +1475,22 @@ static int atmel_spi_suspend(struct device *dev)
                 return ret;
         }
 
-        clk_disable_unprepare(as->clk);
-
-        pinctrl_pm_select_sleep_state(dev);
+        if (!pm_runtime_suspended(dev))
+                atmel_spi_runtime_suspend(dev);
 
         return 0;
 }
 
 static int atmel_spi_resume(struct device *dev)
 {
-        struct spi_master       *master = dev_get_drvdata(dev);
-        struct atmel_spi        *as = spi_master_get_devdata(master);
+        struct spi_master *master = dev_get_drvdata(dev);
         int ret;
 
-        pinctrl_pm_select_default_state(dev);
-
-        clk_prepare_enable(as->clk);
+        if (!pm_runtime_suspended(dev)) {
+                ret = atmel_spi_runtime_resume(dev);
+                if (ret)
+                        return ret;
+        }
 
         /* Start the queue running */
         ret = spi_master_resume(master);
@@ -1474,8 +1500,11 @@ static int atmel_spi_resume(struct device *dev)
         return ret;
 }
 
-static SIMPLE_DEV_PM_OPS(atmel_spi_pm_ops, atmel_spi_suspend, atmel_spi_resume);
-
+static const struct dev_pm_ops atmel_spi_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(atmel_spi_suspend, atmel_spi_resume)
+        SET_RUNTIME_PM_OPS(atmel_spi_runtime_suspend,
+                           atmel_spi_runtime_resume, NULL)
+};
 #define ATMEL_SPI_PM_OPS        (&atmel_spi_pm_ops)
 #else
 #define ATMEL_SPI_PM_OPS        NULL
diff --git a/drivers/spi/spi-cadence.c b/drivers/spi/spi-cadence.c
index 7b811e38c7ad..5a6749881ff9 100644
--- a/drivers/spi/spi-cadence.c
+++ b/drivers/spi/spi-cadence.c
@@ -47,6 +47,7 @@
 #define CDNS_SPI_CR_CPHA_MASK           0x00000004 /* Clock Phase Control */
 #define CDNS_SPI_CR_CPOL_MASK           0x00000002 /* Clock Polarity Control */
 #define CDNS_SPI_CR_SSCTRL_MASK         0x00003C00 /* Slave Select Mask */
+#define CDNS_SPI_CR_PERI_SEL_MASK       0x00000200 /* Peripheral Select Decode */
 #define CDNS_SPI_CR_BAUD_DIV_MASK       0x00000038 /* Baud Rate Divisor Mask */
 #define CDNS_SPI_CR_MSTREN_MASK         0x00000001 /* Master Enable Mask */
 #define CDNS_SPI_CR_MANSTRTEN_MASK      0x00008000 /* Manual TX Enable Mask */
@@ -148,6 +149,11 @@ static inline void cdns_spi_write(struct cdns_spi *xspi, u32 offset, u32 val)
  */
 static void cdns_spi_init_hw(struct cdns_spi *xspi)
 {
+        u32 ctrl_reg = CDNS_SPI_CR_DEFAULT_MASK;
+
+        if (xspi->is_decoded_cs)
+                ctrl_reg |= CDNS_SPI_CR_PERI_SEL_MASK;
+
         cdns_spi_write(xspi, CDNS_SPI_ER_OFFSET,
                        CDNS_SPI_ER_DISABLE_MASK);
         cdns_spi_write(xspi, CDNS_SPI_IDR_OFFSET,
@@ -160,8 +166,7 @@ static void cdns_spi_init_hw(struct cdns_spi *xspi)
 
         cdns_spi_write(xspi, CDNS_SPI_ISR_OFFSET,
                        CDNS_SPI_IXR_ALL_MASK);
-        cdns_spi_write(xspi, CDNS_SPI_CR_OFFSET,
-                       CDNS_SPI_CR_DEFAULT_MASK);
+        cdns_spi_write(xspi, CDNS_SPI_CR_OFFSET, ctrl_reg);
         cdns_spi_write(xspi, CDNS_SPI_ER_OFFSET,
                        CDNS_SPI_ER_ENABLE_MASK);
 }
@@ -516,6 +521,17 @@ static int cdns_spi_probe(struct platform_device *pdev)
                 goto clk_dis_apb;
         }
 
+        ret = of_property_read_u32(pdev->dev.of_node, "num-cs", &num_cs);
+        if (ret < 0)
+                master->num_chipselect = CDNS_SPI_DEFAULT_NUM_CS;
+        else
+                master->num_chipselect = num_cs;
+
+        ret = of_property_read_u32(pdev->dev.of_node, "is-decoded-cs",
+                                   &xspi->is_decoded_cs);
+        if (ret < 0)
+                xspi->is_decoded_cs = 0;
+
         /* SPI controller initializations */
         cdns_spi_init_hw(xspi);
 
@@ -534,19 +550,6 @@ static int cdns_spi_probe(struct platform_device *pdev)
                 goto remove_master;
         }
 
-        ret = of_property_read_u32(pdev->dev.of_node, "num-cs", &num_cs);
-
-        if (ret < 0)
-                master->num_chipselect = CDNS_SPI_DEFAULT_NUM_CS;
-        else
-                master->num_chipselect = num_cs;
-
-        ret = of_property_read_u32(pdev->dev.of_node, "is-decoded-cs",
-                                   &xspi->is_decoded_cs);
-
-        if (ret < 0)
-                xspi->is_decoded_cs = 0;
-
         master->prepare_transfer_hardware = cdns_prepare_transfer_hardware;
         master->prepare_message = cdns_prepare_message;
         master->transfer_one = cdns_transfer_one;
diff --git a/drivers/spi/spi-dw-mid.c b/drivers/spi/spi-dw-mid.c
index 46c6d58e1fda..7281316a5ecb 100644
--- a/drivers/spi/spi-dw-mid.c
+++ b/drivers/spi/spi-dw-mid.c
@@ -26,6 +26,9 @@
 #include <linux/intel_mid_dma.h>
 #include <linux/pci.h>
 
+#define RX_BUSY         0
+#define TX_BUSY         1
+
 struct mid_dma {
         struct intel_mid_dma_slave      dmas_tx;
         struct intel_mid_dma_slave      dmas_rx;
@@ -98,41 +101,26 @@ static void mid_spi_dma_exit(struct dw_spi *dws)
 }
 
 /*
- * dws->dma_chan_done is cleared before the dma transfer starts,
- * callback for rx/tx channel will each increment it by 1.
- * Reaching 2 means the whole spi transaction is done.
+ * dws->dma_chan_busy is set before the dma transfer starts, callback for tx
+ * channel will clear a corresponding bit.
  */
-static void dw_spi_dma_done(void *arg)
+static void dw_spi_dma_tx_done(void *arg)
 {
         struct dw_spi *dws = arg;
 
-        if (++dws->dma_chan_done != 2)
+        if (test_and_clear_bit(TX_BUSY, &dws->dma_chan_busy) & BIT(RX_BUSY))
                 return;
         dw_spi_xfer_done(dws);
 }
 
-static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
+static struct dma_async_tx_descriptor *dw_spi_dma_prepare_tx(struct dw_spi *dws)
 {
-        struct dma_async_tx_descriptor *txdesc, *rxdesc;
-        struct dma_slave_config txconf, rxconf;
-        u16 dma_ctrl = 0;
-
-        /* 1. setup DMA related registers */
-        if (cs_change) {
-                spi_enable_chip(dws, 0);
-                dw_writew(dws, DW_SPI_DMARDLR, 0xf);
-                dw_writew(dws, DW_SPI_DMATDLR, 0x10);
-                if (dws->tx_dma)
-                        dma_ctrl |= SPI_DMA_TDMAE;
-                if (dws->rx_dma)
-                        dma_ctrl |= SPI_DMA_RDMAE;
-                dw_writew(dws, DW_SPI_DMACR, dma_ctrl);
-                spi_enable_chip(dws, 1);
-        }
+        struct dma_slave_config txconf;
+        struct dma_async_tx_descriptor *txdesc;
 
-        dws->dma_chan_done = 0;
+        if (!dws->tx_dma)
+                return NULL;
 
-        /* 2. Prepare the TX dma transfer */
         txconf.direction = DMA_MEM_TO_DEV;
         txconf.dst_addr = dws->dma_addr;
         txconf.dst_maxburst = LNW_DMA_MSIZE_16;
@@ -151,10 +139,33 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
                                 1,
                                 DMA_MEM_TO_DEV,
                                 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-        txdesc->callback = dw_spi_dma_done;
+        txdesc->callback = dw_spi_dma_tx_done;
         txdesc->callback_param = dws;
 
-        /* 3. Prepare the RX dma transfer */
+        return txdesc;
+}
+
+/*
+ * dws->dma_chan_busy is set before the dma transfer starts, callback for rx
+ * channel will clear a corresponding bit.
+ */
+static void dw_spi_dma_rx_done(void *arg)
+{
+        struct dw_spi *dws = arg;
+
+        if (test_and_clear_bit(RX_BUSY, &dws->dma_chan_busy) & BIT(TX_BUSY))
+                return;
+        dw_spi_xfer_done(dws);
+}
+
+static struct dma_async_tx_descriptor *dw_spi_dma_prepare_rx(struct dw_spi *dws)
+{
+        struct dma_slave_config rxconf;
+        struct dma_async_tx_descriptor *rxdesc;
+
+        if (!dws->rx_dma)
+                return NULL;
+
         rxconf.direction = DMA_DEV_TO_MEM;
         rxconf.src_addr = dws->dma_addr;
         rxconf.src_maxburst = LNW_DMA_MSIZE_16;
@@ -173,15 +184,56 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
                                 1,
                                 DMA_DEV_TO_MEM,
                                 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-        rxdesc->callback = dw_spi_dma_done;
+        rxdesc->callback = dw_spi_dma_rx_done;
         rxdesc->callback_param = dws;
 
+        return rxdesc;
+}
+
+static void dw_spi_dma_setup(struct dw_spi *dws)
+{
+        u16 dma_ctrl = 0;
+
+        spi_enable_chip(dws, 0);
+
+        dw_writew(dws, DW_SPI_DMARDLR, 0xf);
+        dw_writew(dws, DW_SPI_DMATDLR, 0x10);
+
+        if (dws->tx_dma)
+                dma_ctrl |= SPI_DMA_TDMAE;
+        if (dws->rx_dma)
+                dma_ctrl |= SPI_DMA_RDMAE;
+        dw_writew(dws, DW_SPI_DMACR, dma_ctrl);
+
+        spi_enable_chip(dws, 1);
+}
+
+static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
+{
+        struct dma_async_tx_descriptor *txdesc, *rxdesc;
+
+        /* 1. setup DMA related registers */
+        if (cs_change)
+                dw_spi_dma_setup(dws);
+
+        /* 2. Prepare the TX dma transfer */
+        txdesc = dw_spi_dma_prepare_tx(dws);
+
+        /* 3. Prepare the RX dma transfer */
+        rxdesc = dw_spi_dma_prepare_rx(dws);
+
         /* rx must be started before tx due to spi instinct */
-        dmaengine_submit(rxdesc);
-        dma_async_issue_pending(dws->rxchan);
+        if (rxdesc) {
+                set_bit(RX_BUSY, &dws->dma_chan_busy);
+                dmaengine_submit(rxdesc);
+                dma_async_issue_pending(dws->rxchan);
+        }
 
-        dmaengine_submit(txdesc);
-        dma_async_issue_pending(dws->txchan);
+        if (txdesc) {
+                set_bit(TX_BUSY, &dws->dma_chan_busy);
+                dmaengine_submit(txdesc);
+                dma_async_issue_pending(dws->txchan);
+        }
 
         return 0;
 }
diff --git a/drivers/spi/spi-dw.c b/drivers/spi/spi-dw.c
index 72e12bad14b9..d0d5542efc06 100644
--- a/drivers/spi/spi-dw.c
+++ b/drivers/spi/spi-dw.c
@@ -376,9 +376,6 @@ static void pump_transfers(unsigned long data)
         chip = dws->cur_chip;
         spi = message->spi;
 
-        if (unlikely(!chip->clk_div))
-                chip->clk_div = dws->max_freq / chip->speed_hz;
-
         if (message->state == ERROR_STATE) {
                 message->status = -EIO;
                 goto early_exit;
@@ -419,7 +416,7 @@ static void pump_transfers(unsigned long data)
         if (transfer->speed_hz) {
                 speed = chip->speed_hz;
 
-                if (transfer->speed_hz != speed) {
+                if ((transfer->speed_hz != speed) || (!chip->clk_div)) {
                         speed = transfer->speed_hz;
 
                         /* clk_div doesn't support odd number */
@@ -581,7 +578,6 @@ static int dw_spi_setup(struct spi_device *spi)
                 dev_err(&spi->dev, "No max speed HZ parameter\n");
                 return -EINVAL;
         }
-        chip->speed_hz = spi->max_speed_hz;
 
         chip->tmode = 0; /* Tx & Rx */
         /* Default SPI mode is SCPOL = 0, SCPH = 0 */
diff --git a/drivers/spi/spi-dw.h b/drivers/spi/spi-dw.h
index 83a103a76481..3d32be68c142 100644
--- a/drivers/spi/spi-dw.h
+++ b/drivers/spi/spi-dw.h
@@ -139,7 +139,7 @@ struct dw_spi {
         struct scatterlist      tx_sgl;
         struct dma_chan         *rxchan;
         struct scatterlist      rx_sgl;
-        int                     dma_chan_done;
+        unsigned long           dma_chan_busy;
         struct device           *dma_dev;
         dma_addr_t              dma_addr; /* phy address of the Data register */
         struct dw_spi_dma_ops   *dma_ops;
diff --git a/drivers/spi/spi-fsl-cpm.c b/drivers/spi/spi-fsl-cpm.c
index c5dd20beee22..e85ab1cb17a2 100644
--- a/drivers/spi/spi-fsl-cpm.c
+++ b/drivers/spi/spi-fsl-cpm.c
@@ -56,12 +56,15 @@ void fsl_spi_cpm_reinit_txrx(struct mpc8xxx_spi *mspi)
                 qe_issue_cmd(QE_INIT_TX_RX, mspi->subblock,
                              QE_CR_PROTOCOL_UNSPECIFIED, 0);
         } else {
-                cpm_command(CPM_SPI_CMD, CPM_CR_INIT_TRX);
                 if (mspi->flags & SPI_CPM1) {
+                        out_be32(&mspi->pram->rstate, 0);
                         out_be16(&mspi->pram->rbptr,
                                  in_be16(&mspi->pram->rbase));
+                        out_be32(&mspi->pram->tstate, 0);
                         out_be16(&mspi->pram->tbptr,
                                  in_be16(&mspi->pram->tbase));
+                } else {
+                        cpm_command(CPM_SPI_CMD, CPM_CR_INIT_TRX);
                 }
         }
 }
diff --git a/drivers/spi/spi-fsl-dspi.c b/drivers/spi/spi-fsl-dspi.c
index 831ceb4a91f6..4cda994d3f40 100644
--- a/drivers/spi/spi-fsl-dspi.c
+++ b/drivers/spi/spi-fsl-dspi.c
@@ -438,7 +438,7 @@ static int dspi_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(dspi_pm, dspi_suspend, dspi_resume);
 
-static struct regmap_config dspi_regmap_config = {
+static const struct regmap_config dspi_regmap_config = {
         .reg_bits = 32,
         .val_bits = 32,
         .reg_stride = 4,
@@ -492,7 +492,6 @@ static int dspi_probe(struct platform_device *pdev)
                 goto out_master_put;
         }
 
-        dspi_regmap_config.lock_arg = dspi;
         dspi->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "dspi", base,
                                                 &dspi_regmap_config);
         if (IS_ERR(dspi->regmap)) {
diff --git a/drivers/spi/spi-fsl-espi.c b/drivers/spi/spi-fsl-espi.c
index a7f94b6a9e70..56cadf13519e 100644
--- a/drivers/spi/spi-fsl-espi.c
+++ b/drivers/spi/spi-fsl-espi.c
@@ -411,7 +411,8 @@ static void fsl_espi_rw_trans(struct spi_message *m,
         kfree(local_buf);
 }
 
-static void fsl_espi_do_one_msg(struct spi_message *m)
+static int fsl_espi_do_one_msg(struct spi_master *master,
+                               struct spi_message *m)
 {
         struct spi_transfer *t;
         u8 *rx_buf = NULL;
@@ -441,8 +442,8 @@ static void fsl_espi_do_one_msg(struct spi_message *m)
 
         m->actual_length = espi_trans.actual_length;
         m->status = espi_trans.status;
-        if (m->complete)
-                m->complete(m->context);
+        spi_finalize_current_message(master);
+        return 0;
 }
 
 static int fsl_espi_setup(struct spi_device *spi)
@@ -587,6 +588,38 @@ static void fsl_espi_remove(struct mpc8xxx_spi *mspi)
         iounmap(mspi->reg_base);
 }
 
+static int fsl_espi_suspend(struct spi_master *master)
+{
+        struct mpc8xxx_spi *mpc8xxx_spi;
+        struct fsl_espi_reg *reg_base;
+        u32 regval;
+
+        mpc8xxx_spi = spi_master_get_devdata(master);
+        reg_base = mpc8xxx_spi->reg_base;
+
+        regval = mpc8xxx_spi_read_reg(&reg_base->mode);
+        regval &= ~SPMODE_ENABLE;
+        mpc8xxx_spi_write_reg(&reg_base->mode, regval);
+
+        return 0;
+}
+
+static int fsl_espi_resume(struct spi_master *master)
+{
+        struct mpc8xxx_spi *mpc8xxx_spi;
+        struct fsl_espi_reg *reg_base;
+        u32 regval;
+
+        mpc8xxx_spi = spi_master_get_devdata(master);
+        reg_base = mpc8xxx_spi->reg_base;
+
+        regval = mpc8xxx_spi_read_reg(&reg_base->mode);
+        regval |= SPMODE_ENABLE;
+        mpc8xxx_spi_write_reg(&reg_base->mode, regval);
+
+        return 0;
+}
+
 static struct spi_master * fsl_espi_probe(struct device *dev,
                 struct resource *mem, unsigned int irq)
 {
@@ -607,16 +640,16 @@ static struct spi_master * fsl_espi_probe(struct device *dev,
 
         dev_set_drvdata(dev, master);
 
-        ret = mpc8xxx_spi_probe(dev, mem, irq);
-        if (ret)
-                goto err_probe;
+        mpc8xxx_spi_probe(dev, mem, irq);
 
         master->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 16);
         master->setup = fsl_espi_setup;
         master->cleanup = fsl_espi_cleanup;
+        master->transfer_one_message = fsl_espi_do_one_msg;
+        master->prepare_transfer_hardware = fsl_espi_resume;
+        master->unprepare_transfer_hardware = fsl_espi_suspend;
 
         mpc8xxx_spi = spi_master_get_devdata(master);
-        mpc8xxx_spi->spi_do_one_msg = fsl_espi_do_one_msg;
         mpc8xxx_spi->spi_remove = fsl_espi_remove;
 
         mpc8xxx_spi->reg_base = ioremap(mem->start, resource_size(mem));
@@ -762,25 +795,15 @@ static int of_fsl_espi_remove(struct platform_device *dev)
 static int of_fsl_espi_suspend(struct device *dev)
 {
         struct spi_master *master = dev_get_drvdata(dev);
-        struct mpc8xxx_spi *mpc8xxx_spi;
-        struct fsl_espi_reg *reg_base;
-        u32 regval;
         int ret;
 
-        mpc8xxx_spi = spi_master_get_devdata(master);
-        reg_base = mpc8xxx_spi->reg_base;
-
         ret = spi_master_suspend(master);
         if (ret) {
                 dev_warn(dev, "cannot suspend master\n");
                 return ret;
         }
 
-        regval = mpc8xxx_spi_read_reg(&reg_base->mode);
-        regval &= ~SPMODE_ENABLE;
-        mpc8xxx_spi_write_reg(&reg_base->mode, regval);
-
-        return 0;
+        return fsl_espi_suspend(master);
 }
 
 static int of_fsl_espi_resume(struct device *dev)
diff --git a/drivers/spi/spi-fsl-lib.c b/drivers/spi/spi-fsl-lib.c
index 5ddb5b098e4e..446b737e1532 100644
--- a/drivers/spi/spi-fsl-lib.c
+++ b/drivers/spi/spi-fsl-lib.c
@@ -61,44 +61,6 @@ struct mpc8xxx_spi_probe_info *to_of_pinfo(struct fsl_spi_platform_data *pdata)
         return container_of(pdata, struct mpc8xxx_spi_probe_info, pdata);
 }
 
-static void mpc8xxx_spi_work(struct work_struct *work)
-{
-        struct mpc8xxx_spi *mpc8xxx_spi = container_of(work, struct mpc8xxx_spi,
-                                                       work);
-
-        spin_lock_irq(&mpc8xxx_spi->lock);
-        while (!list_empty(&mpc8xxx_spi->queue)) {
-                struct spi_message *m = container_of(mpc8xxx_spi->queue.next,
-                                                   struct spi_message, queue);
-
-                list_del_init(&m->queue);
-                spin_unlock_irq(&mpc8xxx_spi->lock);
-
-                if (mpc8xxx_spi->spi_do_one_msg)
-                        mpc8xxx_spi->spi_do_one_msg(m);
-
-                spin_lock_irq(&mpc8xxx_spi->lock);
-        }
-        spin_unlock_irq(&mpc8xxx_spi->lock);
-}
-
-int mpc8xxx_spi_transfer(struct spi_device *spi,
-                                struct spi_message *m)
-{
-        struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
-        unsigned long flags;
-
-        m->actual_length = 0;
-        m->status = -EINPROGRESS;
-
-        spin_lock_irqsave(&mpc8xxx_spi->lock, flags);
-        list_add_tail(&m->queue, &mpc8xxx_spi->queue);
-        queue_work(mpc8xxx_spi->workqueue, &mpc8xxx_spi->work);
-        spin_unlock_irqrestore(&mpc8xxx_spi->lock, flags);
-
-        return 0;
-}
-
 const char *mpc8xxx_spi_strmode(unsigned int flags)
 {
         if (flags & SPI_QE_CPU_MODE) {
@@ -114,13 +76,12 @@ const char *mpc8xxx_spi_strmode(unsigned int flags)
         return "CPU";
 }
 
-int mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
+void mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
                         unsigned int irq)
 {
         struct fsl_spi_platform_data *pdata = dev_get_platdata(dev);
         struct spi_master *master;
         struct mpc8xxx_spi *mpc8xxx_spi;
-        int ret = 0;
 
         master = dev_get_drvdata(dev);
 
@@ -128,7 +89,6 @@ int mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH
                         | SPI_LSB_FIRST | SPI_LOOP;
 
-        master->transfer = mpc8xxx_spi_transfer;
         master->dev.of_node = dev->of_node;
 
         mpc8xxx_spi = spi_master_get_devdata(master);
@@ -147,22 +107,7 @@ int mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
         master->bus_num = pdata->bus_num;
         master->num_chipselect = pdata->max_chipselect;
 
-        spin_lock_init(&mpc8xxx_spi->lock);
         init_completion(&mpc8xxx_spi->done);
-        INIT_WORK(&mpc8xxx_spi->work, mpc8xxx_spi_work);
-        INIT_LIST_HEAD(&mpc8xxx_spi->queue);
-
-        mpc8xxx_spi->workqueue = create_singlethread_workqueue(
-                dev_name(master->dev.parent));
-        if (mpc8xxx_spi->workqueue == NULL) {
-                ret = -EBUSY;
-                goto err;
-        }
-
-        return 0;
-
-err:
-        return ret;
 }
 
 int mpc8xxx_spi_remove(struct device *dev)
@@ -173,8 +118,6 @@ int mpc8xxx_spi_remove(struct device *dev)
         master = dev_get_drvdata(dev);
         mpc8xxx_spi = spi_master_get_devdata(master);
 
-        flush_workqueue(mpc8xxx_spi->workqueue);
-        destroy_workqueue(mpc8xxx_spi->workqueue);
         spi_unregister_master(master);
 
         free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
diff --git a/drivers/spi/spi-fsl-lib.h b/drivers/spi/spi-fsl-lib.h
index 2fcbfd01d109..b4ed04e8862f 100644
--- a/drivers/spi/spi-fsl-lib.h
+++ b/drivers/spi/spi-fsl-lib.h
@@ -55,7 +55,6 @@ struct mpc8xxx_spi {
         u32(*get_tx) (struct mpc8xxx_spi *);
 
         /* hooks for different controller driver */
-        void (*spi_do_one_msg) (struct spi_message *m);
         void (*spi_remove) (struct mpc8xxx_spi *mspi);
 
         unsigned int count;
@@ -78,12 +77,6 @@ struct mpc8xxx_spi {
                            int bits_per_word, int msb_first);
 #endif
 
-        struct workqueue_struct *workqueue;
-        struct work_struct work;
-
-        struct list_head queue;
-        spinlock_t lock;
-
         struct completion done;
 };
 
@@ -123,9 +116,8 @@ extern struct mpc8xxx_spi_probe_info *to_of_pinfo(
                 struct fsl_spi_platform_data *pdata);
 extern int mpc8xxx_spi_bufs(struct mpc8xxx_spi *mspi,
                 struct spi_transfer *t, unsigned int len);
-extern int mpc8xxx_spi_transfer(struct spi_device *spi, struct spi_message *m);
 extern const char *mpc8xxx_spi_strmode(unsigned int flags);
-extern int mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
+extern void mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
                 unsigned int irq);
 extern int mpc8xxx_spi_remove(struct device *dev);
 extern int of_mpc8xxx_spi_probe(struct platform_device *ofdev);
diff --git a/drivers/spi/spi-fsl-spi.c b/drivers/spi/spi-fsl-spi.c
index ed792880c9d6..3b159364c459 100644
--- a/drivers/spi/spi-fsl-spi.c
+++ b/drivers/spi/spi-fsl-spi.c
@@ -353,7 +353,8 @@ static int fsl_spi_bufs(struct spi_device *spi, struct spi_transfer *t,
         return mpc8xxx_spi->count;
 }
 
-static void fsl_spi_do_one_msg(struct spi_message *m)
+static int fsl_spi_do_one_msg(struct spi_master *master,
+                              struct spi_message *m)
 {
         struct spi_device *spi = m->spi;
         struct spi_transfer *t, *first;
@@ -367,10 +368,9 @@ static void fsl_spi_do_one_msg(struct spi_message *m)
         list_for_each_entry(t, &m->transfers, transfer_list) {
                 if ((first->bits_per_word != t->bits_per_word) ||
                         (first->speed_hz != t->speed_hz)) {
-                        status = -EINVAL;
                         dev_err(&spi->dev,
                                 "bits_per_word/speed_hz should be same for the same SPI transfer\n");
-                        return;
+                        return -EINVAL;
                 }
         }
 
@@ -408,8 +408,7 @@ static void fsl_spi_do_one_msg(struct spi_message *m)
         }
 
         m->status = status;
-        if (m->complete)
-                m->complete(m->context);
+        spi_finalize_current_message(master);
 
         if (status || !cs_change) {
                 ndelay(nsecs);
@@ -417,6 +416,7 @@ static void fsl_spi_do_one_msg(struct spi_message *m)
         }
 
         fsl_spi_setup_transfer(spi, NULL);
+        return 0;
 }
 
 static int fsl_spi_setup(struct spi_device *spi)
@@ -624,15 +624,13 @@ static struct spi_master * fsl_spi_probe(struct device *dev,
 
         dev_set_drvdata(dev, master);
 
-        ret = mpc8xxx_spi_probe(dev, mem, irq);
-        if (ret)
-                goto err_probe;
+        mpc8xxx_spi_probe(dev, mem, irq);
 
         master->setup = fsl_spi_setup;
         master->cleanup = fsl_spi_cleanup;
+        master->transfer_one_message = fsl_spi_do_one_msg;
 
         mpc8xxx_spi = spi_master_get_devdata(master);
-        mpc8xxx_spi->spi_do_one_msg = fsl_spi_do_one_msg;
         mpc8xxx_spi->spi_remove = fsl_spi_remove;
         mpc8xxx_spi->max_bits_per_word = 32;
         mpc8xxx_spi->type = fsl_spi_get_type(dev);
@@ -704,7 +702,6 @@ free_irq:
 err_ioremap:
         fsl_spi_cpm_free(mpc8xxx_spi);
 err_cpm_init:
-err_probe:
         spi_master_put(master);
 err:
         return ERR_PTR(ret);
diff --git a/drivers/spi/spi-gpio.c b/drivers/spi/spi-gpio.c
index 9f595535cf27..4b600d4f8548 100644
--- a/drivers/spi/spi-gpio.c
+++ b/drivers/spi/spi-gpio.c
@@ -48,7 +48,7 @@ struct spi_gpio {
         struct spi_bitbang              bitbang;
         struct spi_gpio_platform_data   pdata;
         struct platform_device          *pdev;
-        int                             cs_gpios[0];
+        unsigned long                   cs_gpios[0];
 };
 
 /*----------------------------------------------------------------------*/
@@ -220,7 +220,7 @@ static u32 spi_gpio_spec_txrx_word_mode3(struct spi_device *spi,
 static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
 {
         struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
-        unsigned int cs = spi_gpio->cs_gpios[spi->chip_select];
+        unsigned long cs = spi_gpio->cs_gpios[spi->chip_select];
 
         /* set initial clock polarity */
         if (is_active)
@@ -234,7 +234,7 @@ static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
 
 static int spi_gpio_setup(struct spi_device *spi)
 {
-        unsigned int            cs;
+        unsigned long           cs;
         int                     status = 0;
         struct spi_gpio         *spi_gpio = spi_to_spi_gpio(spi);
         struct device_node      *np = spi->master->dev.of_node;
@@ -249,7 +249,7 @@ static int spi_gpio_setup(struct spi_device *spi)
                 /*
                  * ... otherwise, take it from spi->controller_data
                  */
-                cs = (unsigned int)(uintptr_t) spi->controller_data;
+                cs = (uintptr_t) spi->controller_data;
         }
 
         if (!spi->controller_state) {
@@ -277,7 +277,7 @@ static int spi_gpio_setup(struct spi_device *spi)
 static void spi_gpio_cleanup(struct spi_device *spi)
 {
         struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
-        unsigned int cs = spi_gpio->cs_gpios[spi->chip_select];
+        unsigned long cs = spi_gpio->cs_gpios[spi->chip_select];
 
         if (cs != SPI_GPIO_NO_CHIPSELECT)
                 gpio_free(cs);
@@ -413,6 +413,7 @@ static int spi_gpio_probe(struct platform_device *pdev)
         struct spi_gpio_platform_data   *pdata;
         u16 master_flags = 0;
         bool use_of = 0;
+        int num_devices;
 
         status = spi_gpio_probe_dt(pdev);
         if (status < 0)
@@ -422,16 +423,21 @@ static int spi_gpio_probe(struct platform_device *pdev)
 
         pdata = dev_get_platdata(&pdev->dev);
 #ifdef GENERIC_BITBANG
-        if (!pdata || !pdata->num_chipselect)
+        if (!pdata || (!use_of && !pdata->num_chipselect))
                 return -ENODEV;
 #endif
 
+        if (use_of && !SPI_N_CHIPSEL)
+                num_devices = 1;
+        else
+                num_devices = SPI_N_CHIPSEL;
+
         status = spi_gpio_request(pdata, dev_name(&pdev->dev), &master_flags);
         if (status < 0)
                 return status;
 
         master = spi_alloc_master(&pdev->dev, sizeof(*spi_gpio) +
-                                        (sizeof(int) * SPI_N_CHIPSEL));
+                                        (sizeof(unsigned long) * num_devices));
         if (!master) {
                 status = -ENOMEM;
                 goto gpio_free;
@@ -446,7 +452,7 @@ static int spi_gpio_probe(struct platform_device *pdev)
         master->bits_per_word_mask = SPI_BPW_RANGE_MASK(1, 32);
         master->flags = master_flags;
         master->bus_num = pdev->id;
-        master->num_chipselect = SPI_N_CHIPSEL;
+        master->num_chipselect = num_devices;
         master->setup = spi_gpio_setup;
         master->cleanup = spi_gpio_cleanup;
 #ifdef CONFIG_OF
@@ -461,9 +467,18 @@ static int spi_gpio_probe(struct platform_device *pdev)
                  * property of the node.
                  */
 
-                for (i = 0; i < SPI_N_CHIPSEL; i++)
-                        spi_gpio->cs_gpios[i] =
-                                of_get_named_gpio(np, "cs-gpios", i);
+                if (!SPI_N_CHIPSEL)
+                        spi_gpio->cs_gpios[0] = SPI_GPIO_NO_CHIPSELECT;
+                else
+                        for (i = 0; i < SPI_N_CHIPSEL; i++) {
+                                status = of_get_named_gpio(np, "cs-gpios", i);
+                                if (status < 0) {
+                                        dev_err(&pdev->dev,
+                                                "invalid cs-gpios property\n");
+                                        goto gpio_free;
+                                }
+                                spi_gpio->cs_gpios[i] = status;
+                        }
         }
 #endif
 
diff --git a/drivers/spi/spi-img-spfi.c b/drivers/spi/spi-img-spfi.c
new file mode 100644
index 000000000000..43781c9fe521
--- /dev/null
+++ b/drivers/spi/spi-img-spfi.c
@@ -0,0 +1,746 @@
+/*
+ * IMG SPFI controller driver
+ *
+ * Copyright (C) 2007,2008,2013 Imagination Technologies Ltd.
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/dmaengine.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/scatterlist.h>
+#include <linux/slab.h>
+#include <linux/spi/spi.h>
+#include <linux/spinlock.h>
+
+#define SPFI_DEVICE_PARAMETER(x)                (0x00 + 0x4 * (x))
+#define SPFI_DEVICE_PARAMETER_BITCLK_SHIFT      24
+#define SPFI_DEVICE_PARAMETER_BITCLK_MASK       0xff
+#define SPFI_DEVICE_PARAMETER_CSSETUP_SHIFT     16
+#define SPFI_DEVICE_PARAMETER_CSSETUP_MASK      0xff
+#define SPFI_DEVICE_PARAMETER_CSHOLD_SHIFT      8
+#define SPFI_DEVICE_PARAMETER_CSHOLD_MASK       0xff
+#define SPFI_DEVICE_PARAMETER_CSDELAY_SHIFT     0
+#define SPFI_DEVICE_PARAMETER_CSDELAY_MASK      0xff
+
+#define SPFI_CONTROL                            0x14
+#define SPFI_CONTROL_CONTINUE                   BIT(12)
+#define SPFI_CONTROL_SOFT_RESET                 BIT(11)
+#define SPFI_CONTROL_SEND_DMA                   BIT(10)
+#define SPFI_CONTROL_GET_DMA                    BIT(9)
+#define SPFI_CONTROL_TMODE_SHIFT                5
+#define SPFI_CONTROL_TMODE_MASK                 0x7
+#define SPFI_CONTROL_TMODE_SINGLE               0
+#define SPFI_CONTROL_TMODE_DUAL                 1
+#define SPFI_CONTROL_TMODE_QUAD                 2
+#define SPFI_CONTROL_SPFI_EN                    BIT(0)
+
+#define SPFI_TRANSACTION                        0x18
+#define SPFI_TRANSACTION_TSIZE_SHIFT            16
+#define SPFI_TRANSACTION_TSIZE_MASK             0xffff
+
+#define SPFI_PORT_STATE                         0x1c
+#define SPFI_PORT_STATE_DEV_SEL_SHIFT           20
+#define SPFI_PORT_STATE_DEV_SEL_MASK            0x7
+#define SPFI_PORT_STATE_CK_POL(x)               BIT(19 - (x))
+#define SPFI_PORT_STATE_CK_PHASE(x)             BIT(14 - (x))
+
+#define SPFI_TX_32BIT_VALID_DATA                0x20
+#define SPFI_TX_8BIT_VALID_DATA                 0x24
+#define SPFI_RX_32BIT_VALID_DATA                0x28
+#define SPFI_RX_8BIT_VALID_DATA                 0x2c
+
+#define SPFI_INTERRUPT_STATUS                   0x30
+#define SPFI_INTERRUPT_ENABLE                   0x34
+#define SPFI_INTERRUPT_CLEAR                    0x38
+#define SPFI_INTERRUPT_IACCESS                  BIT(12)
+#define SPFI_INTERRUPT_GDEX8BIT                 BIT(11)
+#define SPFI_INTERRUPT_ALLDONETRIG              BIT(9)
+#define SPFI_INTERRUPT_GDFUL                    BIT(8)
+#define SPFI_INTERRUPT_GDHF                     BIT(7)
+#define SPFI_INTERRUPT_GDEX32BIT                BIT(6)
+#define SPFI_INTERRUPT_GDTRIG                   BIT(5)
+#define SPFI_INTERRUPT_SDFUL                    BIT(3)
+#define SPFI_INTERRUPT_SDHF                     BIT(2)
+#define SPFI_INTERRUPT_SDE                      BIT(1)
+#define SPFI_INTERRUPT_SDTRIG                   BIT(0)
+
+/*
+ * There are four parallel FIFOs of 16 bytes each.  The word buffer
+ * (*_32BIT_VALID_DATA) accesses all four FIFOs at once, resulting in an
+ * effective FIFO size of 64 bytes.  The byte buffer (*_8BIT_VALID_DATA)
+ * accesses only a single FIFO, resulting in an effective FIFO size of
+ * 16 bytes.
+ */
+#define SPFI_32BIT_FIFO_SIZE                    64
+#define SPFI_8BIT_FIFO_SIZE                     16
+
+struct img_spfi {
+        struct device *dev;
+        struct spi_master *master;
+        spinlock_t lock;
+
+        void __iomem *regs;
+        phys_addr_t phys;
+        int irq;
+        struct clk *spfi_clk;
+        struct clk *sys_clk;
+
+        struct dma_chan *rx_ch;
+        struct dma_chan *tx_ch;
+        bool tx_dma_busy;
+        bool rx_dma_busy;
+};
+
+static inline u32 spfi_readl(struct img_spfi *spfi, u32 reg)
+{
+        return readl(spfi->regs + reg);
+}
+
+static inline void spfi_writel(struct img_spfi *spfi, u32 val, u32 reg)
+{
+        writel(val, spfi->regs + reg);
+}
+
+static inline void spfi_start(struct img_spfi *spfi)
+{
+        u32 val;
+
+        val = spfi_readl(spfi, SPFI_CONTROL);
+        val |= SPFI_CONTROL_SPFI_EN;
+        spfi_writel(spfi, val, SPFI_CONTROL);
+}
+
+static inline void spfi_stop(struct img_spfi *spfi)
+{
+        u32 val;
+
+        val = spfi_readl(spfi, SPFI_CONTROL);
+        val &= ~SPFI_CONTROL_SPFI_EN;
+        spfi_writel(spfi, val, SPFI_CONTROL);
+}
+
+static inline void spfi_reset(struct img_spfi *spfi)
+{
+        spfi_writel(spfi, SPFI_CONTROL_SOFT_RESET, SPFI_CONTROL);
+        udelay(1);
+        spfi_writel(spfi, 0, SPFI_CONTROL);
+}
+
+static void spfi_flush_tx_fifo(struct img_spfi *spfi)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(10);
+
+        spfi_writel(spfi, SPFI_INTERRUPT_SDE, SPFI_INTERRUPT_CLEAR);
+        while (time_before(jiffies, timeout)) {
+                if (spfi_readl(spfi, SPFI_INTERRUPT_STATUS) &
+                    SPFI_INTERRUPT_SDE)
+                        return;
+                cpu_relax();
+        }
+
+        dev_err(spfi->dev, "Timed out waiting for FIFO to drain\n");
+        spfi_reset(spfi);
+}
+
+static unsigned int spfi_pio_write32(struct img_spfi *spfi, const u32 *buf,
+                                     unsigned int max)
+{
+        unsigned int count = 0;
+        u32 status;
+
+        while (count < max) {
+                spfi_writel(spfi, SPFI_INTERRUPT_SDFUL, SPFI_INTERRUPT_CLEAR);
+                status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
+                if (status & SPFI_INTERRUPT_SDFUL)
+                        break;
+                spfi_writel(spfi, buf[count / 4], SPFI_TX_32BIT_VALID_DATA);
+                count += 4;
+        }
+
+        return count;
+}
+
+static unsigned int spfi_pio_write8(struct img_spfi *spfi, const u8 *buf,
+                                    unsigned int max)
+{
+        unsigned int count = 0;
+        u32 status;
+
+        while (count < max) {
+                spfi_writel(spfi, SPFI_INTERRUPT_SDFUL, SPFI_INTERRUPT_CLEAR);
+                status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
+                if (status & SPFI_INTERRUPT_SDFUL)
+                        break;
+                spfi_writel(spfi, buf[count], SPFI_TX_8BIT_VALID_DATA);
+                count++;
+        }
+
+        return count;
+}
+
+static unsigned int spfi_pio_read32(struct img_spfi *spfi, u32 *buf,
+                                    unsigned int max)
+{
+        unsigned int count = 0;
+        u32 status;
+
+        while (count < max) {
+                spfi_writel(spfi, SPFI_INTERRUPT_GDEX32BIT,
+                            SPFI_INTERRUPT_CLEAR);
+                status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
+                if (!(status & SPFI_INTERRUPT_GDEX32BIT))
+                        break;
+                buf[count / 4] = spfi_readl(spfi, SPFI_RX_32BIT_VALID_DATA);
+                count += 4;
+        }
+
+        return count;
+}
+
+static unsigned int spfi_pio_read8(struct img_spfi *spfi, u8 *buf,
+                                   unsigned int max)
+{
+        unsigned int count = 0;
+        u32 status;
+
+        while (count < max) {
+                spfi_writel(spfi, SPFI_INTERRUPT_GDEX8BIT,
+                            SPFI_INTERRUPT_CLEAR);
+                status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
+                if (!(status & SPFI_INTERRUPT_GDEX8BIT))
+                        break;
+                buf[count] = spfi_readl(spfi, SPFI_RX_8BIT_VALID_DATA);
+                count++;
+        }
+
+        return count;
+}
+
+static int img_spfi_start_pio(struct spi_master *master,
+                               struct spi_device *spi,
+                               struct spi_transfer *xfer)
+{
+        struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+        unsigned int tx_bytes = 0, rx_bytes = 0;
+        const void *tx_buf = xfer->tx_buf;
+        void *rx_buf = xfer->rx_buf;
+        unsigned long timeout;
+
+        if (tx_buf)
+                tx_bytes = xfer->len;
+        if (rx_buf)
+                rx_bytes = xfer->len;
+
+        spfi_start(spfi);
+
+        timeout = jiffies +
+                msecs_to_jiffies(xfer->len * 8 * 1000 / xfer->speed_hz + 100);
+        while ((tx_bytes > 0 || rx_bytes > 0) &&
+               time_before(jiffies, timeout)) {
+                unsigned int tx_count, rx_count;
+
+                switch (xfer->bits_per_word) {
+                case 32:
+                        tx_count = spfi_pio_write32(spfi, tx_buf, tx_bytes);
+                        rx_count = spfi_pio_read32(spfi, rx_buf, rx_bytes);
+                        break;
+                case 8:
+                default:
+                        tx_count = spfi_pio_write8(spfi, tx_buf, tx_bytes);
+                        rx_count = spfi_pio_read8(spfi, rx_buf, rx_bytes);
+                        break;
+                }
+
+                tx_buf += tx_count;
+                rx_buf += rx_count;
+                tx_bytes -= tx_count;
+                rx_bytes -= rx_count;
+
+                cpu_relax();
+        }
+
+        if (rx_bytes > 0 || tx_bytes > 0) {
+                dev_err(spfi->dev, "PIO transfer timed out\n");
+                spfi_reset(spfi);
+                return -ETIMEDOUT;
+        }
+
+        if (tx_buf)
+                spfi_flush_tx_fifo(spfi);
+        spfi_stop(spfi);
+
+        return 0;
+}
+
+static void img_spfi_dma_rx_cb(void *data)
+{
+        struct img_spfi *spfi = data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&spfi->lock, flags);
+
+        spfi->rx_dma_busy = false;
+        if (!spfi->tx_dma_busy) {
+                spfi_stop(spfi);
+                spi_finalize_current_transfer(spfi->master);
+        }
+
+        spin_unlock_irqrestore(&spfi->lock, flags);
+}
+
+static void img_spfi_dma_tx_cb(void *data)
+{
+        struct img_spfi *spfi = data;
+        unsigned long flags;
+
+        spfi_flush_tx_fifo(spfi);
+
+        spin_lock_irqsave(&spfi->lock, flags);
+
+        spfi->tx_dma_busy = false;
+        if (!spfi->rx_dma_busy) {
+                spfi_stop(spfi);
+                spi_finalize_current_transfer(spfi->master);
+        }
+
+        spin_unlock_irqrestore(&spfi->lock, flags);
+}
+
+static int img_spfi_start_dma(struct spi_master *master,
+                              struct spi_device *spi,
+                              struct spi_transfer *xfer)
+{
+        struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+        struct dma_async_tx_descriptor *rxdesc = NULL, *txdesc = NULL;
+        struct dma_slave_config rxconf, txconf;
+
+        spfi->rx_dma_busy = false;
+        spfi->tx_dma_busy = false;
+
+        if (xfer->rx_buf) {
+                rxconf.direction = DMA_DEV_TO_MEM;
+                switch (xfer->bits_per_word) {
+                case 32:
+                        rxconf.src_addr = spfi->phys + SPFI_RX_32BIT_VALID_DATA;
+                        rxconf.src_addr_width = 4;
+                        rxconf.src_maxburst = 4;
+                        break;
+                case 8:
+                default:
+                        rxconf.src_addr = spfi->phys + SPFI_RX_8BIT_VALID_DATA;
+                        rxconf.src_addr_width = 1;
+                        rxconf.src_maxburst = 1;
+                }
+                dmaengine_slave_config(spfi->rx_ch, &rxconf);
+
+                rxdesc = dmaengine_prep_slave_sg(spfi->rx_ch, xfer->rx_sg.sgl,
+                                                 xfer->rx_sg.nents,
+                                                 DMA_DEV_TO_MEM,
+                                                 DMA_PREP_INTERRUPT);
+                if (!rxdesc)
+                        goto stop_dma;
+
+                rxdesc->callback = img_spfi_dma_rx_cb;
+                rxdesc->callback_param = spfi;
+        }
+
+        if (xfer->tx_buf) {
+                txconf.direction = DMA_MEM_TO_DEV;
+                switch (xfer->bits_per_word) {
+                case 32:
+                        txconf.dst_addr = spfi->phys + SPFI_TX_32BIT_VALID_DATA;
+                        txconf.dst_addr_width = 4;
+                        txconf.dst_maxburst = 4;
+                        break;
+                case 8:
+                default:
+                        txconf.dst_addr = spfi->phys + SPFI_TX_8BIT_VALID_DATA;
+                        txconf.dst_addr_width = 1;
+                        txconf.dst_maxburst = 1;
+                        break;
+                }
+                dmaengine_slave_config(spfi->tx_ch, &txconf);
+
+                txdesc = dmaengine_prep_slave_sg(spfi->tx_ch, xfer->tx_sg.sgl,
+                                                 xfer->tx_sg.nents,
+                                                 DMA_MEM_TO_DEV,
+                                                 DMA_PREP_INTERRUPT);
+                if (!txdesc)
+                        goto stop_dma;
+
+                txdesc->callback = img_spfi_dma_tx_cb;
+                txdesc->callback_param = spfi;
+        }
+
+        if (xfer->rx_buf) {
+                spfi->rx_dma_busy = true;
+                dmaengine_submit(rxdesc);
+                dma_async_issue_pending(spfi->rx_ch);
+        }
+
+        if (xfer->tx_buf) {
+                spfi->tx_dma_busy = true;
+                dmaengine_submit(txdesc);
+                dma_async_issue_pending(spfi->tx_ch);
+        }
+
+        spfi_start(spfi);
+
+        return 1;
+
+stop_dma:
+        dmaengine_terminate_all(spfi->rx_ch);
+        dmaengine_terminate_all(spfi->tx_ch);
+        return -EIO;
+}
+
+static void img_spfi_config(struct spi_master *master, struct spi_device *spi,
+                            struct spi_transfer *xfer)
+{
+        struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+        u32 val, div;
+
+        /*
+         * output = spfi_clk * (BITCLK / 512), where BITCLK must be a
+         * power of 2 up to 256 (where 255 == 256 since BITCLK is 8 bits)
+         */
+        div = DIV_ROUND_UP(master->max_speed_hz, xfer->speed_hz);
+        div = clamp(512 / (1 << get_count_order(div)), 1, 255);
+
+        val = spfi_readl(spfi, SPFI_DEVICE_PARAMETER(spi->chip_select));
+        val &= ~(SPFI_DEVICE_PARAMETER_BITCLK_MASK <<
+                 SPFI_DEVICE_PARAMETER_BITCLK_SHIFT);
+        val |= div << SPFI_DEVICE_PARAMETER_BITCLK_SHIFT;
+        spfi_writel(spfi, val, SPFI_DEVICE_PARAMETER(spi->chip_select));
+
+        val = spfi_readl(spfi, SPFI_CONTROL);
+        val &= ~(SPFI_CONTROL_SEND_DMA | SPFI_CONTROL_GET_DMA);
+        if (xfer->tx_buf)
+                val |= SPFI_CONTROL_SEND_DMA;
+        if (xfer->rx_buf)
+                val |= SPFI_CONTROL_GET_DMA;
+        val &= ~(SPFI_CONTROL_TMODE_MASK << SPFI_CONTROL_TMODE_SHIFT);
+        if (xfer->tx_nbits == SPI_NBITS_DUAL &&
+            xfer->rx_nbits == SPI_NBITS_DUAL)
+                val |= SPFI_CONTROL_TMODE_DUAL << SPFI_CONTROL_TMODE_SHIFT;
+        else if (xfer->tx_nbits == SPI_NBITS_QUAD &&
+                 xfer->rx_nbits == SPI_NBITS_QUAD)
+                val |= SPFI_CONTROL_TMODE_QUAD << SPFI_CONTROL_TMODE_SHIFT;
+        val &= ~SPFI_CONTROL_CONTINUE;
+        if (!xfer->cs_change && !list_is_last(&xfer->transfer_list,
+                                              &master->cur_msg->transfers))
+                val |= SPFI_CONTROL_CONTINUE;
+        spfi_writel(spfi, val, SPFI_CONTROL);
+
+        val = spfi_readl(spfi, SPFI_PORT_STATE);
+        if (spi->mode & SPI_CPHA)
+                val |= SPFI_PORT_STATE_CK_PHASE(spi->chip_select);
+        else
+                val &= ~SPFI_PORT_STATE_CK_PHASE(spi->chip_select);
+        if (spi->mode & SPI_CPOL)
+                val |= SPFI_PORT_STATE_CK_POL(spi->chip_select);
+        else
+                val &= ~SPFI_PORT_STATE_CK_POL(spi->chip_select);
+        spfi_writel(spfi, val, SPFI_PORT_STATE);
+
+        spfi_writel(spfi, xfer->len << SPFI_TRANSACTION_TSIZE_SHIFT,
+                    SPFI_TRANSACTION);
+}
+
+static int img_spfi_transfer_one(struct spi_master *master,
+                                 struct spi_device *spi,
+                                 struct spi_transfer *xfer)
+{
+        struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+        bool dma_reset = false;
+        unsigned long flags;
+        int ret;
+
+        /*
+         * Stop all DMA and reset the controller if the previous transaction
+         * timed-out and never completed it's DMA.
+         */
+        spin_lock_irqsave(&spfi->lock, flags);
+        if (spfi->tx_dma_busy || spfi->rx_dma_busy) {
+                dev_err(spfi->dev, "SPI DMA still busy\n");
+                dma_reset = true;
+        }
+        spin_unlock_irqrestore(&spfi->lock, flags);
+
+        if (dma_reset) {
+                dmaengine_terminate_all(spfi->tx_ch);
+                dmaengine_terminate_all(spfi->rx_ch);
+                spfi_reset(spfi);
+        }
+
+        img_spfi_config(master, spi, xfer);
+        if (master->can_dma && master->can_dma(master, spi, xfer))
+                ret = img_spfi_start_dma(master, spi, xfer);
+        else
+                ret = img_spfi_start_pio(master, spi, xfer);
+
+        return ret;
+}
+
+static void img_spfi_set_cs(struct spi_device *spi, bool enable)
+{
+        struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+        u32 val;
+
+        val = spfi_readl(spfi, SPFI_PORT_STATE);
+        val &= ~(SPFI_PORT_STATE_DEV_SEL_MASK << SPFI_PORT_STATE_DEV_SEL_SHIFT);
+        val |= spi->chip_select << SPFI_PORT_STATE_DEV_SEL_SHIFT;
+        spfi_writel(spfi, val, SPFI_PORT_STATE);
+}
+
+static bool img_spfi_can_dma(struct spi_master *master, struct spi_device *spi,
+                             struct spi_transfer *xfer)
+{
+        if (xfer->bits_per_word == 8 && xfer->len > SPFI_8BIT_FIFO_SIZE)
+                return true;
+        if (xfer->bits_per_word == 32 && xfer->len > SPFI_32BIT_FIFO_SIZE)
+                return true;
+        return false;
+}
+
+static irqreturn_t img_spfi_irq(int irq, void *dev_id)
+{
+        struct img_spfi *spfi = (struct img_spfi *)dev_id;
+        u32 status;
+
+        status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
+        if (status & SPFI_INTERRUPT_IACCESS) {
+                spfi_writel(spfi, SPFI_INTERRUPT_IACCESS, SPFI_INTERRUPT_CLEAR);
+                dev_err(spfi->dev, "Illegal access interrupt");
+                return IRQ_HANDLED;
+        }
+
+        return IRQ_NONE;
+}
+
+static int img_spfi_probe(struct platform_device *pdev)
+{
+        struct spi_master *master;
+        struct img_spfi *spfi;
+        struct resource *res;
+        int ret;
+
+        master = spi_alloc_master(&pdev->dev, sizeof(*spfi));
+        if (!master)
+                return -ENOMEM;
+        platform_set_drvdata(pdev, master);
+
+        spfi = spi_master_get_devdata(master);
+        spfi->dev = &pdev->dev;
+        spfi->master = master;
+        spin_lock_init(&spfi->lock);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        spfi->regs = devm_ioremap_resource(spfi->dev, res);
+        if (IS_ERR(spfi->regs)) {
+                ret = PTR_ERR(spfi->regs);
+                goto put_spi;
+        }
+        spfi->phys = res->start;
+
+        spfi->irq = platform_get_irq(pdev, 0);
+        if (spfi->irq < 0) {
+                ret = spfi->irq;
+                goto put_spi;
+        }
+        ret = devm_request_irq(spfi->dev, spfi->irq, img_spfi_irq,
+                               IRQ_TYPE_LEVEL_HIGH, dev_name(spfi->dev), spfi);
+        if (ret)
+                goto put_spi;
+
+        spfi->sys_clk = devm_clk_get(spfi->dev, "sys");
+        if (IS_ERR(spfi->sys_clk)) {
+                ret = PTR_ERR(spfi->sys_clk);
+                goto put_spi;
+        }
+        spfi->spfi_clk = devm_clk_get(spfi->dev, "spfi");
+        if (IS_ERR(spfi->spfi_clk)) {
+                ret = PTR_ERR(spfi->spfi_clk);
+                goto put_spi;
+        }
+
+        ret = clk_prepare_enable(spfi->sys_clk);
+        if (ret)
+                goto put_spi;
+        ret = clk_prepare_enable(spfi->spfi_clk);
+        if (ret)
+                goto disable_pclk;
+
+        spfi_reset(spfi);
+        /*
+         * Only enable the error (IACCESS) interrupt.  In PIO mode we'll
+         * poll the status of the FIFOs.
+         */
+        spfi_writel(spfi, SPFI_INTERRUPT_IACCESS, SPFI_INTERRUPT_ENABLE);
+
+        master->auto_runtime_pm = true;
+        master->bus_num = pdev->id;
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_TX_DUAL | SPI_RX_DUAL;
+        if (of_property_read_bool(spfi->dev->of_node, "img,supports-quad-mode"))
+                master->mode_bits |= SPI_TX_QUAD | SPI_RX_QUAD;
+        master->num_chipselect = 5;
+        master->dev.of_node = pdev->dev.of_node;
+        master->bits_per_word_mask = SPI_BPW_MASK(32) | SPI_BPW_MASK(8);
+        master->max_speed_hz = clk_get_rate(spfi->spfi_clk);
+        master->min_speed_hz = master->max_speed_hz / 512;
+
+        master->set_cs = img_spfi_set_cs;
+        master->transfer_one = img_spfi_transfer_one;
+
+        spfi->tx_ch = dma_request_slave_channel(spfi->dev, "tx");
+        spfi->rx_ch = dma_request_slave_channel(spfi->dev, "rx");
+        if (!spfi->tx_ch || !spfi->rx_ch) {
+                if (spfi->tx_ch)
+                        dma_release_channel(spfi->tx_ch);
+                if (spfi->rx_ch)
+                        dma_release_channel(spfi->rx_ch);
+                dev_warn(spfi->dev, "Failed to get DMA channels, falling back to PIO mode\n");
+        } else {
+                master->dma_tx = spfi->tx_ch;
+                master->dma_rx = spfi->rx_ch;
+                master->can_dma = img_spfi_can_dma;
+        }
+
+        pm_runtime_set_active(spfi->dev);
+        pm_runtime_enable(spfi->dev);
+
+        ret = devm_spi_register_master(spfi->dev, master);
+        if (ret)
+                goto disable_pm;
+
+        return 0;
+
+disable_pm:
+        pm_runtime_disable(spfi->dev);
+        if (spfi->rx_ch)
+                dma_release_channel(spfi->rx_ch);
+        if (spfi->tx_ch)
+                dma_release_channel(spfi->tx_ch);
+        clk_disable_unprepare(spfi->spfi_clk);
+disable_pclk:
+        clk_disable_unprepare(spfi->sys_clk);
+put_spi:
+        spi_master_put(master);
+
+        return ret;
+}
+
+static int img_spfi_remove(struct platform_device *pdev)
+{
+        struct spi_master *master = platform_get_drvdata(pdev);
+        struct img_spfi *spfi = spi_master_get_devdata(master);
+
+        if (spfi->tx_ch)
+                dma_release_channel(spfi->tx_ch);
+        if (spfi->rx_ch)
+                dma_release_channel(spfi->rx_ch);
+
+        pm_runtime_disable(spfi->dev);
+        if (!pm_runtime_status_suspended(spfi->dev)) {
+                clk_disable_unprepare(spfi->spfi_clk);
+                clk_disable_unprepare(spfi->sys_clk);
+        }
+
+        spi_master_put(master);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_RUNTIME
+static int img_spfi_runtime_suspend(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct img_spfi *spfi = spi_master_get_devdata(master);
+
+        clk_disable_unprepare(spfi->spfi_clk);
+        clk_disable_unprepare(spfi->sys_clk);
+
+        return 0;
+}
+
+static int img_spfi_runtime_resume(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct img_spfi *spfi = spi_master_get_devdata(master);
+        int ret;
+
+        ret = clk_prepare_enable(spfi->sys_clk);
+        if (ret)
+                return ret;
+        ret = clk_prepare_enable(spfi->spfi_clk);
+        if (ret) {
+                clk_disable_unprepare(spfi->sys_clk);
+                return ret;
+        }
+
+        return 0;
+}
+#endif /* CONFIG_PM_RUNTIME */
+
+#ifdef CONFIG_PM_SLEEP
+static int img_spfi_suspend(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+
+        return spi_master_suspend(master);
+}
+
+static int img_spfi_resume(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct img_spfi *spfi = spi_master_get_devdata(master);
+        int ret;
+
+        ret = pm_runtime_get_sync(dev);
+        if (ret)
+                return ret;
+        spfi_reset(spfi);
+        pm_runtime_put(dev);
+
+        return spi_master_resume(master);
+}
+#endif /* CONFIG_PM_SLEEP */
+
+static const struct dev_pm_ops img_spfi_pm_ops = {
+        SET_RUNTIME_PM_OPS(img_spfi_runtime_suspend, img_spfi_runtime_resume,
+                           NULL)
+        SET_SYSTEM_SLEEP_PM_OPS(img_spfi_suspend, img_spfi_resume)
+};
+
+static const struct of_device_id img_spfi_of_match[] = {
+        { .compatible = "img,spfi", },
+        { },
+};
+MODULE_DEVICE_TABLE(of, img_spfi_of_match);
+
+static struct platform_driver img_spfi_driver = {
+        .driver = {
+                .name = "img-spfi",
+                .pm = &img_spfi_pm_ops,
+                .of_match_table = of_match_ptr(img_spfi_of_match),
+        },
+        .probe = img_spfi_probe,
+        .remove = img_spfi_remove,
+};
+module_platform_driver(img_spfi_driver);
+
+MODULE_DESCRIPTION("IMG SPFI controller driver");
+MODULE_AUTHOR("Andrew Bresticker <abrestic@chromium.org>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/spi-meson-spifc.c b/drivers/spi/spi-meson-spifc.c
new file mode 100644
index 000000000000..0e48f8c2037d
--- /dev/null
+++ b/drivers/spi/spi-meson-spifc.c
@@ -0,0 +1,462 @@
+/*
+ * Driver for Amlogic Meson SPI flash controller (SPIFC)
+ *
+ * Copyright (C) 2014 Beniamino Galvani <b.galvani@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/regmap.h>
+#include <linux/spi/spi.h>
+#include <linux/types.h>
+
+/* register map */
+#define REG_CMD                 0x00
+#define REG_ADDR                0x04
+#define REG_CTRL                0x08
+#define REG_CTRL1               0x0c
+#define REG_STATUS              0x10
+#define REG_CTRL2               0x14
+#define REG_CLOCK               0x18
+#define REG_USER                0x1c
+#define REG_USER1               0x20
+#define REG_USER2               0x24
+#define REG_USER3               0x28
+#define REG_USER4               0x2c
+#define REG_SLAVE               0x30
+#define REG_SLAVE1              0x34
+#define REG_SLAVE2              0x38
+#define REG_SLAVE3              0x3c
+#define REG_C0                  0x40
+#define REG_B8                  0x60
+#define REG_MAX                 0x7c
+
+/* register fields */
+#define CMD_USER                BIT(18)
+#define CTRL_ENABLE_AHB         BIT(17)
+#define CLOCK_SOURCE            BIT(31)
+#define CLOCK_DIV_SHIFT         12
+#define CLOCK_DIV_MASK          (0x3f << CLOCK_DIV_SHIFT)
+#define CLOCK_CNT_HIGH_SHIFT    6
+#define CLOCK_CNT_HIGH_MASK     (0x3f << CLOCK_CNT_HIGH_SHIFT)
+#define CLOCK_CNT_LOW_SHIFT     0
+#define CLOCK_CNT_LOW_MASK      (0x3f << CLOCK_CNT_LOW_SHIFT)
+#define USER_DIN_EN_MS          BIT(0)
+#define USER_CMP_MODE           BIT(2)
+#define USER_UC_DOUT_SEL        BIT(27)
+#define USER_UC_DIN_SEL         BIT(28)
+#define USER_UC_MASK            ((BIT(5) - 1) << 27)
+#define USER1_BN_UC_DOUT_SHIFT  17
+#define USER1_BN_UC_DOUT_MASK   (0xff << 16)
+#define USER1_BN_UC_DIN_SHIFT   8
+#define USER1_BN_UC_DIN_MASK    (0xff << 8)
+#define USER4_CS_ACT            BIT(30)
+#define SLAVE_TRST_DONE         BIT(4)
+#define SLAVE_OP_MODE           BIT(30)
+#define SLAVE_SW_RST            BIT(31)
+
+#define SPIFC_BUFFER_SIZE       64
+
+/**
+ * struct meson_spifc
+ * @master:     the SPI master
+ * @regmap:     regmap for device registers
+ * @clk:        input clock of the built-in baud rate generator
+ * @device:     the device structure
+ */
+struct meson_spifc {
+        struct spi_master *master;
+        struct regmap *regmap;
+        struct clk *clk;
+        struct device *dev;
+};
+
+static struct regmap_config spifc_regmap_config = {
+        .reg_bits = 32,
+        .val_bits = 32,
+        .reg_stride = 4,
+        .max_register = REG_MAX,
+};
+
+/**
+ * meson_spifc_wait_ready() - wait for the current operation to terminate
+ * @spifc:      the Meson SPI device
+ * Return:      0 on success, a negative value on error
+ */
+static int meson_spifc_wait_ready(struct meson_spifc *spifc)
+{
+        unsigned long deadline = jiffies + msecs_to_jiffies(5);
+        u32 data;
+
+        do {
+                regmap_read(spifc->regmap, REG_SLAVE, &data);
+                if (data & SLAVE_TRST_DONE)
+                        return 0;
+                cond_resched();
+        } while (!time_after(jiffies, deadline));
+
+        return -ETIMEDOUT;
+}
+
+/**
+ * meson_spifc_drain_buffer() - copy data from device buffer to memory
+ * @spifc:      the Meson SPI device
+ * @buf:        the destination buffer
+ * @len:        number of bytes to copy
+ */
+static void meson_spifc_drain_buffer(struct meson_spifc *spifc, u8 *buf,
+                                     int len)
+{
+        u32 data;
+        int i = 0;
+
+        while (i < len) {
+                regmap_read(spifc->regmap, REG_C0 + i, &data);
+
+                if (len - i >= 4) {
+                        *((u32 *)buf) = data;
+                        buf += 4;
+                } else {
+                        memcpy(buf, &data, len - i);
+                        break;
+                }
+                i += 4;
+        }
+}
+
+/**
+ * meson_spifc_fill_buffer() - copy data from memory to device buffer
+ * @spifc:      the Meson SPI device
+ * @buf:        the source buffer
+ * @len:        number of bytes to copy
+ */
+static void meson_spifc_fill_buffer(struct meson_spifc *spifc, const u8 *buf,
+                                    int len)
+{
+        u32 data;
+        int i = 0;
+
+        while (i < len) {
+                if (len - i >= 4)
+                        data = *(u32 *)buf;
+                else
+                        memcpy(&data, buf, len - i);
+
+                regmap_write(spifc->regmap, REG_C0 + i, data);
+
+                buf += 4;
+                i += 4;
+        }
+}
+
+/**
+ * meson_spifc_setup_speed() - program the clock divider
+ * @spifc:      the Meson SPI device
+ * @speed:      desired speed in Hz
+ */
+static void meson_spifc_setup_speed(struct meson_spifc *spifc, u32 speed)
+{
+        unsigned long parent, value;
+        int n;
+
+        parent = clk_get_rate(spifc->clk);
+        n = max_t(int, parent / speed - 1, 1);
+
+        dev_dbg(spifc->dev, "parent %lu, speed %u, n %d\n", parent,
+                speed, n);
+
+        value = (n << CLOCK_DIV_SHIFT) & CLOCK_DIV_MASK;
+        value |= (n << CLOCK_CNT_LOW_SHIFT) & CLOCK_CNT_LOW_MASK;
+        value |= (((n + 1) / 2 - 1) << CLOCK_CNT_HIGH_SHIFT) &
+                CLOCK_CNT_HIGH_MASK;
+
+        regmap_write(spifc->regmap, REG_CLOCK, value);
+}
+
+/**
+ * meson_spifc_txrx() - transfer a chunk of data
+ * @spifc:      the Meson SPI device
+ * @xfer:       the current SPI transfer
+ * @offset:     offset of the data to transfer
+ * @len:        length of the data to transfer
+ * @last_xfer:  whether this is the last transfer of the message
+ * @last_chunk: whether this is the last chunk of the transfer
+ * Return:      0 on success, a negative value on error
+ */
+static int meson_spifc_txrx(struct meson_spifc *spifc,
+                            struct spi_transfer *xfer,
+                            int offset, int len, bool last_xfer,
+                            bool last_chunk)
+{
+        bool keep_cs = true;
+        int ret;
+
+        if (xfer->tx_buf)
+                meson_spifc_fill_buffer(spifc, xfer->tx_buf + offset, len);
+
+        /* enable DOUT stage */
+        regmap_update_bits(spifc->regmap, REG_USER, USER_UC_MASK,
+                           USER_UC_DOUT_SEL);
+        regmap_write(spifc->regmap, REG_USER1,
+                     (8 * len - 1) << USER1_BN_UC_DOUT_SHIFT);
+
+        /* enable data input during DOUT */
+        regmap_update_bits(spifc->regmap, REG_USER, USER_DIN_EN_MS,
+                           USER_DIN_EN_MS);
+
+        if (last_chunk) {
+                if (last_xfer)
+                        keep_cs = xfer->cs_change;
+                else
+                        keep_cs = !xfer->cs_change;
+        }
+
+        regmap_update_bits(spifc->regmap, REG_USER4, USER4_CS_ACT,
+                           keep_cs ? USER4_CS_ACT : 0);
+
+        /* clear transition done bit */
+        regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_TRST_DONE, 0);
+        /* start transfer */
+        regmap_update_bits(spifc->regmap, REG_CMD, CMD_USER, CMD_USER);
+
+        ret = meson_spifc_wait_ready(spifc);
+
+        if (!ret && xfer->rx_buf)
+                meson_spifc_drain_buffer(spifc, xfer->rx_buf + offset, len);
+
+        return ret;
+}
+
+/**
+ * meson_spifc_transfer_one() - perform a single transfer
+ * @master:     the SPI master
+ * @spi:        the SPI device
+ * @xfer:       the current SPI transfer
+ * Return:      0 on success, a negative value on error
+ */
+static int meson_spifc_transfer_one(struct spi_master *master,
+                                    struct spi_device *spi,
+                                    struct spi_transfer *xfer)
+{
+        struct meson_spifc *spifc = spi_master_get_devdata(master);
+        int len, done = 0, ret = 0;
+
+        meson_spifc_setup_speed(spifc, xfer->speed_hz);
+
+        regmap_update_bits(spifc->regmap, REG_CTRL, CTRL_ENABLE_AHB, 0);
+
+        while (done < xfer->len && !ret) {
+                len = min_t(int, xfer->len - done, SPIFC_BUFFER_SIZE);
+                ret = meson_spifc_txrx(spifc, xfer, done, len,
+                                       spi_transfer_is_last(master, xfer),
+                                       done + len >= xfer->len);
+                done += len;
+        }
+
+        regmap_update_bits(spifc->regmap, REG_CTRL, CTRL_ENABLE_AHB,
+                           CTRL_ENABLE_AHB);
+
+        return ret;
+}
+
+/**
+ * meson_spifc_hw_init() - reset and initialize the SPI controller
+ * @spifc:      the Meson SPI device
+ */
+static void meson_spifc_hw_init(struct meson_spifc *spifc)
+{
+        /* reset device */
+        regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_SW_RST,
+                           SLAVE_SW_RST);
+        /* disable compatible mode */
+        regmap_update_bits(spifc->regmap, REG_USER, USER_CMP_MODE, 0);
+        /* set master mode */
+        regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_OP_MODE, 0);
+}
+
+static int meson_spifc_probe(struct platform_device *pdev)
+{
+        struct spi_master *master;
+        struct meson_spifc *spifc;
+        struct resource *res;
+        void __iomem *base;
+        unsigned int rate;
+        int ret = 0;
+
+        master = spi_alloc_master(&pdev->dev, sizeof(struct meson_spifc));
+        if (!master)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, master);
+
+        spifc = spi_master_get_devdata(master);
+        spifc->dev = &pdev->dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        base = devm_ioremap_resource(spifc->dev, res);
+        if (IS_ERR(base)) {
+                ret = PTR_ERR(base);
+                goto out_err;
+        }
+
+        spifc->regmap = devm_regmap_init_mmio(spifc->dev, base,
+                                              &spifc_regmap_config);
+        if (IS_ERR(spifc->regmap)) {
+                ret = PTR_ERR(spifc->regmap);
+                goto out_err;
+        }
+
+        spifc->clk = devm_clk_get(spifc->dev, NULL);
+        if (IS_ERR(spifc->clk)) {
+                dev_err(spifc->dev, "missing clock\n");
+                ret = PTR_ERR(spifc->clk);
+                goto out_err;
+        }
+
+        ret = clk_prepare_enable(spifc->clk);
+        if (ret) {
+                dev_err(spifc->dev, "can't prepare clock\n");
+                goto out_err;
+        }
+
+        rate = clk_get_rate(spifc->clk);
+
+        master->num_chipselect = 1;
+        master->dev.of_node = pdev->dev.of_node;
+        master->bits_per_word_mask = SPI_BPW_MASK(8);
+        master->auto_runtime_pm = true;
+        master->transfer_one = meson_spifc_transfer_one;
+        master->min_speed_hz = rate >> 6;
+        master->max_speed_hz = rate >> 1;
+
+        meson_spifc_hw_init(spifc);
+
+        pm_runtime_set_active(spifc->dev);
+        pm_runtime_enable(spifc->dev);
+
+        ret = devm_spi_register_master(spifc->dev, master);
+        if (ret) {
+                dev_err(spifc->dev, "failed to register spi master\n");
+                goto out_clk;
+        }
+
+        return 0;
+out_clk:
+        clk_disable_unprepare(spifc->clk);
+out_err:
+        spi_master_put(master);
+        return ret;
+}
+
+static int meson_spifc_remove(struct platform_device *pdev)
+{
+        struct spi_master *master = platform_get_drvdata(pdev);
+        struct meson_spifc *spifc = spi_master_get_devdata(master);
+
+        pm_runtime_get_sync(&pdev->dev);
+        clk_disable_unprepare(spifc->clk);
+        pm_runtime_disable(&pdev->dev);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int meson_spifc_suspend(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct meson_spifc *spifc = spi_master_get_devdata(master);
+        int ret;
+
+        ret = spi_master_suspend(master);
+        if (ret)
+                return ret;
+
+        if (!pm_runtime_suspended(dev))
+                clk_disable_unprepare(spifc->clk);
+
+        return 0;
+}
+
+static int meson_spifc_resume(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct meson_spifc *spifc = spi_master_get_devdata(master);
+        int ret;
+
+        if (!pm_runtime_suspended(dev)) {
+                ret = clk_prepare_enable(spifc->clk);
+                if (ret)
+                        return ret;
+        }
+
+        meson_spifc_hw_init(spifc);
+
+        ret = spi_master_resume(master);
+        if (ret)
+                clk_disable_unprepare(spifc->clk);
+
+        return ret;
+}
+#endif /* CONFIG_PM_SLEEP */
+
+#ifdef CONFIG_PM_RUNTIME
+static int meson_spifc_runtime_suspend(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct meson_spifc *spifc = spi_master_get_devdata(master);
+
+        clk_disable_unprepare(spifc->clk);
+
+        return 0;
+}
+
+static int meson_spifc_runtime_resume(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct meson_spifc *spifc = spi_master_get_devdata(master);
+
+        return clk_prepare_enable(spifc->clk);
+}
+#endif /* CONFIG_PM_RUNTIME */
+
+static const struct dev_pm_ops meson_spifc_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(meson_spifc_suspend, meson_spifc_resume)
+        SET_RUNTIME_PM_OPS(meson_spifc_runtime_suspend,
+                           meson_spifc_runtime_resume,
+                           NULL)
+};
+
+static const struct of_device_id meson_spifc_dt_match[] = {
+        { .compatible = "amlogic,meson6-spifc", },
+        { },
+};
+
+static struct platform_driver meson_spifc_driver = {
+        .probe  = meson_spifc_probe,
+        .remove = meson_spifc_remove,
+        .driver = {
+                .name           = "meson-spifc",
+                .of_match_table = of_match_ptr(meson_spifc_dt_match),
+                .pm             = &meson_spifc_pm_ops,
+        },
+};
+
+module_platform_driver(meson_spifc_driver);
+
+MODULE_AUTHOR("Beniamino Galvani <b.galvani@gmail.com>");
+MODULE_DESCRIPTION("Amlogic Meson SPIFC driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/spi-mxs.c b/drivers/spi/spi-mxs.c
index 51460878af04..06a11546a1a7 100644
--- a/drivers/spi/spi-mxs.c
+++ b/drivers/spi/spi-mxs.c
@@ -182,7 +182,6 @@ static int mxs_spi_txrx_dma(struct mxs_spi *spi,
         int min, ret;
         u32 ctrl0;
         struct page *vm_page;
-        void *sg_buf;
         struct {
                 u32                     pio[4];
                 struct scatterlist      sg;
@@ -232,13 +231,14 @@ static int mxs_spi_txrx_dma(struct mxs_spi *spi,
                                 ret = -ENOMEM;
                                 goto err_vmalloc;
                         }
-                        sg_buf = page_address(vm_page) +
-                                ((size_t)buf & ~PAGE_MASK);
+
+                        sg_init_table(&dma_xfer[sg_count].sg, 1);
+                        sg_set_page(&dma_xfer[sg_count].sg, vm_page,
+                                    min, offset_in_page(buf));
                 } else {
-                        sg_buf = buf;
+                        sg_init_one(&dma_xfer[sg_count].sg, buf, min);
                 }
 
-                sg_init_one(&dma_xfer[sg_count].sg, sg_buf, min);
                 ret = dma_map_sg(ssp->dev, &dma_xfer[sg_count].sg, 1,
                         (flags & TXRX_WRITE) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
 
@@ -511,7 +511,7 @@ static int mxs_spi_probe(struct platform_device *pdev)
         init_completion(&spi->c);
 
         ret = devm_request_irq(&pdev->dev, irq_err, mxs_ssp_irq_handler, 0,
-                               DRIVER_NAME, ssp);
+                               dev_name(&pdev->dev), ssp);
         if (ret)
                 goto out_master_free;
 
diff --git a/drivers/spi/spi-pl022.c b/drivers/spi/spi-pl022.c
index fc2dd8441608..89ca162801da 100644
--- a/drivers/spi/spi-pl022.c
+++ b/drivers/spi/spi-pl022.c
@@ -2377,7 +2377,7 @@ static int pl022_runtime_resume(struct device *dev)
 
 static const struct dev_pm_ops pl022_dev_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(pl022_suspend, pl022_resume)
-        SET_PM_RUNTIME_PM_OPS(pl022_runtime_suspend, pl022_runtime_resume, NULL)
+        SET_RUNTIME_PM_OPS(pl022_runtime_suspend, pl022_runtime_resume, NULL)
 };
 
 static struct vendor_data vendor_arm = {
diff --git a/drivers/spi/spi-pxa2xx-pci.c b/drivers/spi/spi-pxa2xx-pci.c
index 6beee8ce2d68..fa7399e84bbb 100644
--- a/drivers/spi/spi-pxa2xx-pci.c
+++ b/drivers/spi/spi-pxa2xx-pci.c
@@ -19,6 +19,7 @@ enum {
         PORT_BSW0,
         PORT_BSW1,
         PORT_BSW2,
+        PORT_QUARK_X1000,
 };
 
 struct pxa_spi_info {
@@ -92,6 +93,12 @@ static struct pxa_spi_info spi_info_configs[] = {
                 .tx_param = &bsw2_tx_param,
                 .rx_param = &bsw2_rx_param,
         },
+        [PORT_QUARK_X1000] = {
+                .type = QUARK_X1000_SSP,
+                .port_id = -1,
+                .num_chipselect = 1,
+                .max_clk_rate = 50000000,
+        },
 };
 
 static int pxa2xx_spi_pci_probe(struct pci_dev *dev,
@@ -191,6 +198,7 @@ static void pxa2xx_spi_pci_remove(struct pci_dev *dev)
 
 static const struct pci_device_id pxa2xx_spi_pci_devices[] = {
         { PCI_VDEVICE(INTEL, 0x2e6a), PORT_CE4100 },
+        { PCI_VDEVICE(INTEL, 0x0935), PORT_QUARK_X1000 },
         { PCI_VDEVICE(INTEL, 0x0f0e), PORT_BYT },
         { PCI_VDEVICE(INTEL, 0x228e), PORT_BSW0 },
         { PCI_VDEVICE(INTEL, 0x2290), PORT_BSW1 },
diff --git a/drivers/spi/spi-pxa2xx.c b/drivers/spi/spi-pxa2xx.c
index 9e9e0f971e6c..1a1df5092aca 100644
--- a/drivers/spi/spi-pxa2xx.c
+++ b/drivers/spi/spi-pxa2xx.c
@@ -63,10 +63,64 @@ MODULE_ALIAS("platform:pxa2xx-spi");
                                 | SSCR1_RFT | SSCR1_TFT | SSCR1_MWDS \
                                 | SSCR1_SPH | SSCR1_SPO | SSCR1_LBM)
 
+#define QUARK_X1000_SSCR1_CHANGE_MASK (QUARK_X1000_SSCR1_STRF   \
+                                | QUARK_X1000_SSCR1_EFWR        \
+                                | QUARK_X1000_SSCR1_RFT         \
+                                | QUARK_X1000_SSCR1_TFT         \
+                                | SSCR1_SPH | SSCR1_SPO | SSCR1_LBM)
+
 #define LPSS_RX_THRESH_DFLT     64
 #define LPSS_TX_LOTHRESH_DFLT   160
 #define LPSS_TX_HITHRESH_DFLT   224
 
+struct quark_spi_rate {
+        u32 bitrate;
+        u32 dds_clk_rate;
+        u32 clk_div;
+};
+
+/*
+ * 'rate', 'dds', 'clk_div' lookup table, which is defined in
+ * the Quark SPI datasheet.
+ */
+static const struct quark_spi_rate quark_spi_rate_table[] = {
+/*      bitrate,        dds_clk_rate,   clk_div */
+        {50000000,      0x800000,       0},
+        {40000000,      0x666666,       0},
+        {25000000,      0x400000,       0},
+        {20000000,      0x666666,       1},
+        {16667000,      0x800000,       2},
+        {13333000,      0x666666,       2},
+        {12500000,      0x200000,       0},
+        {10000000,      0x800000,       4},
+        {8000000,       0x666666,       4},
+        {6250000,       0x400000,       3},
+        {5000000,       0x400000,       4},
+        {4000000,       0x666666,       9},
+        {3125000,       0x80000,        0},
+        {2500000,       0x400000,       9},
+        {2000000,       0x666666,       19},
+        {1563000,       0x40000,        0},
+        {1250000,       0x200000,       9},
+        {1000000,       0x400000,       24},
+        {800000,        0x666666,       49},
+        {781250,        0x20000,        0},
+        {625000,        0x200000,       19},
+        {500000,        0x400000,       49},
+        {400000,        0x666666,       99},
+        {390625,        0x10000,        0},
+        {250000,        0x400000,       99},
+        {200000,        0x666666,       199},
+        {195313,        0x8000,         0},
+        {125000,        0x100000,       49},
+        {100000,        0x200000,       124},
+        {50000,         0x100000,       124},
+        {25000,         0x80000,        124},
+        {10016,         0x20000,        77},
+        {5040,          0x20000,        154},
+        {1002,          0x8000,         194},
+};
+
 /* Offset from drv_data->lpss_base */
 #define GENERAL_REG             0x08
 #define GENERAL_REG_RXTO_HOLDOFF_DISABLE BIT(24)
@@ -80,6 +134,96 @@ static bool is_lpss_ssp(const struct driver_data *drv_data)
         return drv_data->ssp_type == LPSS_SSP;
 }
 
+static bool is_quark_x1000_ssp(const struct driver_data *drv_data)
+{
+        return drv_data->ssp_type == QUARK_X1000_SSP;
+}
+
+static u32 pxa2xx_spi_get_ssrc1_change_mask(const struct driver_data *drv_data)
+{
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                return QUARK_X1000_SSCR1_CHANGE_MASK;
+        default:
+                return SSCR1_CHANGE_MASK;
+        }
+}
+
+static u32
+pxa2xx_spi_get_rx_default_thre(const struct driver_data *drv_data)
+{
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                return RX_THRESH_QUARK_X1000_DFLT;
+        default:
+                return RX_THRESH_DFLT;
+        }
+}
+
+static bool pxa2xx_spi_txfifo_full(const struct driver_data *drv_data)
+{
+        void __iomem *reg = drv_data->ioaddr;
+        u32 mask;
+
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                mask = QUARK_X1000_SSSR_TFL_MASK;
+                break;
+        default:
+                mask = SSSR_TFL_MASK;
+                break;
+        }
+
+        return (read_SSSR(reg) & mask) == mask;
+}
+
+static void pxa2xx_spi_clear_rx_thre(const struct driver_data *drv_data,
+                                     u32 *sccr1_reg)
+{
+        u32 mask;
+
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                mask = QUARK_X1000_SSCR1_RFT;
+                break;
+        default:
+                mask = SSCR1_RFT;
+                break;
+        }
+        *sccr1_reg &= ~mask;
+}
+
+static void pxa2xx_spi_set_rx_thre(const struct driver_data *drv_data,
+                                   u32 *sccr1_reg, u32 threshold)
+{
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                *sccr1_reg |= QUARK_X1000_SSCR1_RxTresh(threshold);
+                break;
+        default:
+                *sccr1_reg |= SSCR1_RxTresh(threshold);
+                break;
+        }
+}
+
+static u32 pxa2xx_configure_sscr0(const struct driver_data *drv_data,
+                                  u32 clk_div, u8 bits)
+{
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                return clk_div
+                        | QUARK_X1000_SSCR0_Motorola
+                        | QUARK_X1000_SSCR0_DataSize(bits > 32 ? 8 : bits)
+                        | SSCR0_SSE;
+        default:
+                return clk_div
+                        | SSCR0_Motorola
+                        | SSCR0_DataSize(bits > 16 ? bits - 16 : bits)
+                        | SSCR0_SSE
+                        | (bits > 16 ? SSCR0_EDSS : 0);
+        }
+}
+
 /*
  * Read and write LPSS SSP private registers. Caller must first check that
  * is_lpss_ssp() returns true before these can be called.
@@ -234,7 +378,7 @@ static int null_writer(struct driver_data *drv_data)
         void __iomem *reg = drv_data->ioaddr;
         u8 n_bytes = drv_data->n_bytes;
 
-        if (((read_SSSR(reg) & SSSR_TFL_MASK) == SSSR_TFL_MASK)
+        if (pxa2xx_spi_txfifo_full(drv_data)
                 || (drv_data->tx == drv_data->tx_end))
                 return 0;
 
@@ -262,7 +406,7 @@ static int u8_writer(struct driver_data *drv_data)
 {
         void __iomem *reg = drv_data->ioaddr;
 
-        if (((read_SSSR(reg) & SSSR_TFL_MASK) == SSSR_TFL_MASK)
+        if (pxa2xx_spi_txfifo_full(drv_data)
                 || (drv_data->tx == drv_data->tx_end))
                 return 0;
 
@@ -289,7 +433,7 @@ static int u16_writer(struct driver_data *drv_data)
 {
         void __iomem *reg = drv_data->ioaddr;
 
-        if (((read_SSSR(reg) & SSSR_TFL_MASK) == SSSR_TFL_MASK)
+        if (pxa2xx_spi_txfifo_full(drv_data)
                 || (drv_data->tx == drv_data->tx_end))
                 return 0;
 
@@ -316,7 +460,7 @@ static int u32_writer(struct driver_data *drv_data)
 {
         void __iomem *reg = drv_data->ioaddr;
 
-        if (((read_SSSR(reg) & SSSR_TFL_MASK) == SSSR_TFL_MASK)
+        if (pxa2xx_spi_txfifo_full(drv_data)
                 || (drv_data->tx == drv_data->tx_end))
                 return 0;
 
@@ -508,8 +652,9 @@ static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
                  * remaining RX bytes.
                  */
                 if (pxa25x_ssp_comp(drv_data)) {
+                        u32 rx_thre;
 
-                        sccr1_reg &= ~SSCR1_RFT;
+                        pxa2xx_spi_clear_rx_thre(drv_data, &sccr1_reg);
 
                         bytes_left = drv_data->rx_end - drv_data->rx;
                         switch (drv_data->n_bytes) {
@@ -519,10 +664,11 @@ static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
                                 bytes_left >>= 1;
                         }
 
-                        if (bytes_left > RX_THRESH_DFLT)
-                                bytes_left = RX_THRESH_DFLT;
+                        rx_thre = pxa2xx_spi_get_rx_default_thre(drv_data);
+                        if (rx_thre > bytes_left)
+                                rx_thre = bytes_left;
 
-                        sccr1_reg |= SSCR1_RxTresh(bytes_left);
+                        pxa2xx_spi_set_rx_thre(drv_data, &sccr1_reg, rx_thre);
                 }
                 write_SSCR1(sccr1_reg, reg);
         }
@@ -585,6 +731,28 @@ static irqreturn_t ssp_int(int irq, void *dev_id)
         return drv_data->transfer_handler(drv_data);
 }
 
+/*
+ * The Quark SPI data sheet gives a table, and for the given 'rate',
+ * the 'dds' and 'clk_div' can be found in the table.
+ */
+static u32 quark_x1000_set_clk_regvals(u32 rate, u32 *dds, u32 *clk_div)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(quark_spi_rate_table); i++) {
+                if (rate >= quark_spi_rate_table[i].bitrate) {
+                        *dds = quark_spi_rate_table[i].dds_clk_rate;
+                        *clk_div = quark_spi_rate_table[i].clk_div;
+                        return quark_spi_rate_table[i].bitrate;
+                }
+        }
+
+        *dds = quark_spi_rate_table[i-1].dds_clk_rate;
+        *clk_div = quark_spi_rate_table[i-1].clk_div;
+
+        return quark_spi_rate_table[i-1].bitrate;
+}
+
 static unsigned int ssp_get_clk_div(struct driver_data *drv_data, int rate)
 {
         unsigned long ssp_clk = drv_data->max_clk_rate;
@@ -598,6 +766,20 @@ static unsigned int ssp_get_clk_div(struct driver_data *drv_data, int rate)
                 return ((ssp_clk / rate - 1) & 0xfff) << 8;
 }
 
+static unsigned int pxa2xx_ssp_get_clk_div(struct driver_data *drv_data,
+                                           struct chip_data *chip, int rate)
+{
+        u32 clk_div;
+
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                quark_x1000_set_clk_regvals(rate, &chip->dds_rate, &clk_div);
+                return clk_div << 8;
+        default:
+                return ssp_get_clk_div(drv_data, rate);
+        }
+}
+
 static void pump_transfers(unsigned long data)
 {
         struct driver_data *drv_data = (struct driver_data *)data;
@@ -613,6 +795,7 @@ static void pump_transfers(unsigned long data)
         u32 cr1;
         u32 dma_thresh = drv_data->cur_chip->dma_threshold;
         u32 dma_burst = drv_data->cur_chip->dma_burst_size;
+        u32 change_mask = pxa2xx_spi_get_ssrc1_change_mask(drv_data);
 
         /* Get current state information */
         message = drv_data->cur_msg;
@@ -699,7 +882,7 @@ static void pump_transfers(unsigned long data)
                 if (transfer->bits_per_word)
                         bits = transfer->bits_per_word;
 
-                clk_div = ssp_get_clk_div(drv_data, speed);
+                clk_div = pxa2xx_ssp_get_clk_div(drv_data, chip, speed);
 
                 if (bits <= 8) {
                         drv_data->n_bytes = 1;
@@ -731,11 +914,7 @@ static void pump_transfers(unsigned long data)
                                                      "pump_transfers: DMA burst size reduced to match bits_per_word\n");
                 }
 
-                cr0 = clk_div
-                        | SSCR0_Motorola
-                        | SSCR0_DataSize(bits > 16 ? bits - 16 : bits)
-                        | SSCR0_SSE
-                        | (bits > 16 ? SSCR0_EDSS : 0);
+                cr0 = pxa2xx_configure_sscr0(drv_data, clk_div, bits);
         }
 
         message->state = RUNNING_STATE;
@@ -771,17 +950,20 @@ static void pump_transfers(unsigned long data)
                         write_SSITF(chip->lpss_tx_threshold, reg);
         }
 
+        if (is_quark_x1000_ssp(drv_data) &&
+            (read_DDS_RATE(reg) != chip->dds_rate))
+                write_DDS_RATE(chip->dds_rate, reg);
+
         /* see if we need to reload the config registers */
-        if ((read_SSCR0(reg) != cr0)
-                || (read_SSCR1(reg) & SSCR1_CHANGE_MASK) !=
-                        (cr1 & SSCR1_CHANGE_MASK)) {
+        if ((read_SSCR0(reg) != cr0) ||
+            (read_SSCR1(reg) & change_mask) != (cr1 & change_mask)) {
 
                 /* stop the SSP, and update the other bits */
                 write_SSCR0(cr0 & ~SSCR0_SSE, reg);
                 if (!pxa25x_ssp_comp(drv_data))
                         write_SSTO(chip->timeout, reg);
                 /* first set CR1 without interrupt and service enables */
-                write_SSCR1(cr1 & SSCR1_CHANGE_MASK, reg);
+                write_SSCR1(cr1 & change_mask, reg);
                 /* restart the SSP */
                 write_SSCR0(cr0, reg);
 
@@ -875,14 +1057,22 @@ static int setup(struct spi_device *spi)
         unsigned int clk_div;
         uint tx_thres, tx_hi_thres, rx_thres;
 
-        if (is_lpss_ssp(drv_data)) {
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                tx_thres = TX_THRESH_QUARK_X1000_DFLT;
+                tx_hi_thres = 0;
+                rx_thres = RX_THRESH_QUARK_X1000_DFLT;
+                break;
+        case LPSS_SSP:
                 tx_thres = LPSS_TX_LOTHRESH_DFLT;
                 tx_hi_thres = LPSS_TX_HITHRESH_DFLT;
                 rx_thres = LPSS_RX_THRESH_DFLT;
-        } else {
+                break;
+        default:
                 tx_thres = TX_THRESH_DFLT;
                 tx_hi_thres = 0;
                 rx_thres = RX_THRESH_DFLT;
+                break;
         }
 
         /* Only alloc on first setup */
@@ -935,9 +1125,6 @@ static int setup(struct spi_device *spi)
                 chip->enable_dma = drv_data->master_info->enable_dma;
         }
 
-        chip->threshold = (SSCR1_RxTresh(rx_thres) & SSCR1_RFT) |
-                        (SSCR1_TxTresh(tx_thres) & SSCR1_TFT);
-
         chip->lpss_rx_threshold = SSIRF_RxThresh(rx_thres);
         chip->lpss_tx_threshold = SSITF_TxLoThresh(tx_thres)
                                 | SSITF_TxHiThresh(tx_hi_thres);
@@ -956,15 +1143,24 @@ static int setup(struct spi_device *spi)
                 }
         }
 
-        clk_div = ssp_get_clk_div(drv_data, spi->max_speed_hz);
+        clk_div = pxa2xx_ssp_get_clk_div(drv_data, chip, spi->max_speed_hz);
         chip->speed_hz = spi->max_speed_hz;
 
-        chip->cr0 = clk_div
-                        | SSCR0_Motorola
-                        | SSCR0_DataSize(spi->bits_per_word > 16 ?
-                                spi->bits_per_word - 16 : spi->bits_per_word)
-                        | SSCR0_SSE
-                        | (spi->bits_per_word > 16 ? SSCR0_EDSS : 0);
+        chip->cr0 = pxa2xx_configure_sscr0(drv_data, clk_div,
+                                           spi->bits_per_word);
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                chip->threshold = (QUARK_X1000_SSCR1_RxTresh(rx_thres)
+                                   & QUARK_X1000_SSCR1_RFT)
+                                   | (QUARK_X1000_SSCR1_TxTresh(tx_thres)
+                                   & QUARK_X1000_SSCR1_TFT);
+                break;
+        default:
+                chip->threshold = (SSCR1_RxTresh(rx_thres) & SSCR1_RFT) |
+                        (SSCR1_TxTresh(tx_thres) & SSCR1_TFT);
+                break;
+        }
+
         chip->cr1 &= ~(SSCR1_SPO | SSCR1_SPH);
         chip->cr1 |= (((spi->mode & SPI_CPHA) != 0) ? SSCR1_SPH : 0)
                         | (((spi->mode & SPI_CPOL) != 0) ? SSCR1_SPO : 0);
@@ -993,7 +1189,8 @@ static int setup(struct spi_device *spi)
                 chip->read = u16_reader;
                 chip->write = u16_writer;
         } else if (spi->bits_per_word <= 32) {
-                chip->cr0 |= SSCR0_EDSS;
+                if (!is_quark_x1000_ssp(drv_data))
+                        chip->cr0 |= SSCR0_EDSS;
                 chip->n_bytes = 4;
                 chip->read = u32_reader;
                 chip->write = u32_writer;
@@ -1144,7 +1341,15 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
         drv_data->ioaddr = ssp->mmio_base;
         drv_data->ssdr_physical = ssp->phys_base + SSDR;
         if (pxa25x_ssp_comp(drv_data)) {
-                master->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 16);
+                switch (drv_data->ssp_type) {
+                case QUARK_X1000_SSP:
+                        master->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 32);
+                        break;
+                default:
+                        master->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 16);
+                        break;
+                }
+
                 drv_data->int_cr1 = SSCR1_TIE | SSCR1_RIE;
                 drv_data->dma_cr1 = 0;
                 drv_data->clear_sr = SSSR_ROR;
@@ -1182,16 +1387,35 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
 
         /* Load default SSP configuration */
         write_SSCR0(0, drv_data->ioaddr);
-        write_SSCR1(SSCR1_RxTresh(RX_THRESH_DFLT) |
-                                SSCR1_TxTresh(TX_THRESH_DFLT),
-                                drv_data->ioaddr);
-        write_SSCR0(SSCR0_SCR(2)
-                        | SSCR0_Motorola
-                        | SSCR0_DataSize(8),
-                        drv_data->ioaddr);
+        switch (drv_data->ssp_type) {
+        case QUARK_X1000_SSP:
+                write_SSCR1(QUARK_X1000_SSCR1_RxTresh(
+                                        RX_THRESH_QUARK_X1000_DFLT) |
+                            QUARK_X1000_SSCR1_TxTresh(
+                                        TX_THRESH_QUARK_X1000_DFLT),
+                            drv_data->ioaddr);
+
+                /* using the Motorola SPI protocol and use 8 bit frame */
+                write_SSCR0(QUARK_X1000_SSCR0_Motorola
+                            | QUARK_X1000_SSCR0_DataSize(8),
+                            drv_data->ioaddr);
+                break;
+        default:
+                write_SSCR1(SSCR1_RxTresh(RX_THRESH_DFLT) |
+                            SSCR1_TxTresh(TX_THRESH_DFLT),
+                            drv_data->ioaddr);
+                write_SSCR0(SSCR0_SCR(2)
+                            | SSCR0_Motorola
+                            | SSCR0_DataSize(8),
+                            drv_data->ioaddr);
+                break;
+        }
+
         if (!pxa25x_ssp_comp(drv_data))
                 write_SSTO(0, drv_data->ioaddr);
-        write_SSPSP(0, drv_data->ioaddr);
+
+        if (!is_quark_x1000_ssp(drv_data))
+                write_SSPSP(0, drv_data->ioaddr);
 
         lpss_ssp_setup(drv_data);
 
diff --git a/drivers/spi/spi-pxa2xx.h b/drivers/spi/spi-pxa2xx.h
index 5adc2a11c7bc..6bec59c90cd4 100644
--- a/drivers/spi/spi-pxa2xx.h
+++ b/drivers/spi/spi-pxa2xx.h
@@ -93,6 +93,7 @@ struct driver_data {
 struct chip_data {
         u32 cr0;
         u32 cr1;
+        u32 dds_rate;
         u32 psp;
         u32 timeout;
         u8 n_bytes;
@@ -126,6 +127,7 @@ DEFINE_SSP_REG(SSCR1, 0x04)
 DEFINE_SSP_REG(SSSR, 0x08)
 DEFINE_SSP_REG(SSITR, 0x0c)
 DEFINE_SSP_REG(SSDR, 0x10)
+DEFINE_SSP_REG(DDS_RATE, 0x28)  /* DDS Clock Rate */
 DEFINE_SSP_REG(SSTO, 0x28)
 DEFINE_SSP_REG(SSPSP, 0x2c)
 DEFINE_SSP_REG(SSITF, SSITF)
@@ -141,18 +143,22 @@ DEFINE_SSP_REG(SSIRF, SSIRF)
 
 static inline int pxa25x_ssp_comp(struct driver_data *drv_data)
 {
-        if (drv_data->ssp_type == PXA25x_SSP)
+        switch (drv_data->ssp_type) {
+        case PXA25x_SSP:
+        case CE4100_SSP:
+        case QUARK_X1000_SSP:
                 return 1;
-        if (drv_data->ssp_type == CE4100_SSP)
-                return 1;
-        return 0;
+        default:
+                return 0;
+        }
 }
 
 static inline void write_SSSR_CS(struct driver_data *drv_data, u32 val)
 {
         void __iomem *reg = drv_data->ioaddr;
 
-        if (drv_data->ssp_type == CE4100_SSP)
+        if (drv_data->ssp_type == CE4100_SSP ||
+            drv_data->ssp_type == QUARK_X1000_SSP)
                 val |= read_SSSR(reg) & SSSR_ALT_FRM_MASK;
 
         write_SSSR(val, reg);
diff --git a/drivers/spi/spi-rockchip.c b/drivers/spi/spi-rockchip.c
index 87bc16f491f0..80637e9406e2 100644
--- a/drivers/spi/spi-rockchip.c
+++ b/drivers/spi/spi-rockchip.c
@@ -749,8 +749,6 @@ static int rockchip_spi_remove(struct platform_device *pdev)
         if (rs->dma_rx.ch)
                 dma_release_channel(rs->dma_rx.ch);
 
-        spi_master_put(master);
-
         return 0;
 }
 
diff --git a/drivers/spi/spi-s3c64xx.c b/drivers/spi/spi-s3c64xx.c
index 480133ee1eb3..0f602cba1989 100644
--- a/drivers/spi/spi-s3c64xx.c
+++ b/drivers/spi/spi-s3c64xx.c
@@ -33,8 +33,9 @@
 
 #include <linux/platform_data/spi-s3c64xx.h>
 
-#define MAX_SPI_PORTS           3
+#define MAX_SPI_PORTS           6
 #define S3C64XX_SPI_QUIRK_POLL          (1 << 0)
+#define S3C64XX_SPI_QUIRK_CS_AUTO       (1 << 1)
 
 /* Registers and bit-fields */
 
@@ -78,6 +79,7 @@
 
 #define S3C64XX_SPI_SLAVE_AUTO                  (1<<1)
 #define S3C64XX_SPI_SLAVE_SIG_INACT             (1<<0)
+#define S3C64XX_SPI_SLAVE_NSC_CNT_2             (2<<4)
 
 #define S3C64XX_SPI_INT_TRAILING_EN             (1<<6)
 #define S3C64XX_SPI_INT_RX_OVERRUN_EN           (1<<5)
@@ -344,16 +346,8 @@ static int s3c64xx_spi_prepare_transfer(struct spi_master *spi)
                 spi->dma_tx = sdd->tx_dma.ch;
         }
 
-        ret = pm_runtime_get_sync(&sdd->pdev->dev);
-        if (ret < 0) {
-                dev_err(dev, "Failed to enable device: %d\n", ret);
-                goto out_tx;
-        }
-
         return 0;
 
-out_tx:
-        dma_release_channel(sdd->tx_dma.ch);
 out_rx:
         dma_release_channel(sdd->rx_dma.ch);
 out:
@@ -370,7 +364,6 @@ static int s3c64xx_spi_unprepare_transfer(struct spi_master *spi)
                 dma_release_channel(sdd->tx_dma.ch);
         }
 
-        pm_runtime_put(&sdd->pdev->dev);
         return 0;
 }
 
@@ -717,7 +710,12 @@ static int s3c64xx_spi_transfer_one(struct spi_master *master,
         enable_datapath(sdd, spi, xfer, use_dma);
 
         /* Start the signals */
-        writel(0, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
+        if (!(sdd->port_conf->quirks & S3C64XX_SPI_QUIRK_CS_AUTO))
+                writel(0, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
+        else
+                writel(readl(sdd->regs + S3C64XX_SPI_SLAVE_SEL)
+                        | S3C64XX_SPI_SLAVE_AUTO | S3C64XX_SPI_SLAVE_NSC_CNT_2,
+                        sdd->regs + S3C64XX_SPI_SLAVE_SEL);
 
         spin_unlock_irqrestore(&sdd->lock, flags);
 
@@ -866,13 +864,15 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
         }
 
         pm_runtime_put(&sdd->pdev->dev);
-        writel(S3C64XX_SPI_SLAVE_SIG_INACT, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
+        if (!(sdd->port_conf->quirks & S3C64XX_SPI_QUIRK_CS_AUTO))
+                writel(S3C64XX_SPI_SLAVE_SIG_INACT, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
         return 0;
 
 setup_exit:
         pm_runtime_put(&sdd->pdev->dev);
         /* setup() returns with device de-selected */
-        writel(S3C64XX_SPI_SLAVE_SIG_INACT, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
+        if (!(sdd->port_conf->quirks & S3C64XX_SPI_QUIRK_CS_AUTO))
+                writel(S3C64XX_SPI_SLAVE_SIG_INACT, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
 
         if (gpio_is_valid(spi->cs_gpio))
                 gpio_free(spi->cs_gpio);
@@ -946,7 +946,8 @@ static void s3c64xx_spi_hwinit(struct s3c64xx_spi_driver_data *sdd, int channel)
 
         sdd->cur_speed = 0;
 
-        writel(S3C64XX_SPI_SLAVE_SIG_INACT, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
+        if (!(sdd->port_conf->quirks & S3C64XX_SPI_QUIRK_CS_AUTO))
+                writel(S3C64XX_SPI_SLAVE_SIG_INACT, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
 
         /* Disable Interrupts - we use Polling if not DMA mode */
         writel(0, regs + S3C64XX_SPI_INT_EN);
@@ -1341,6 +1342,15 @@ static struct s3c64xx_spi_port_config exynos5440_spi_port_config = {
         .quirks         = S3C64XX_SPI_QUIRK_POLL,
 };
 
+static struct s3c64xx_spi_port_config exynos7_spi_port_config = {
+        .fifo_lvl_mask  = { 0x1ff, 0x7F, 0x7F, 0x7F, 0x7F, 0x1ff},
+        .rx_lvl_offset  = 15,
+        .tx_st_done     = 25,
+        .high_speed     = true,
+        .clk_from_cmu   = true,
+        .quirks         = S3C64XX_SPI_QUIRK_CS_AUTO,
+};
+
 static struct platform_device_id s3c64xx_spi_driver_ids[] = {
         {
                 .name           = "s3c2443-spi",
@@ -1374,6 +1384,9 @@ static const struct of_device_id s3c64xx_spi_dt_match[] = {
         { .compatible = "samsung,exynos5440-spi",
                         .data = (void *)&exynos5440_spi_port_config,
         },
+        { .compatible = "samsung,exynos7-spi",
+                        .data = (void *)&exynos7_spi_port_config,
+        },
         { },
 };
 MODULE_DEVICE_TABLE(of, s3c64xx_spi_dt_match);
diff --git a/drivers/spi/spi-sirf.c b/drivers/spi/spi-sirf.c
index 39e2c0a55a28..73a88b33f810 100644
--- a/drivers/spi/spi-sirf.c
+++ b/drivers/spi/spi-sirf.c
@@ -23,6 +23,7 @@
 #include <linux/dmaengine.h>
 #include <linux/dma-direction.h>
 #include <linux/dma-mapping.h>
+#include <linux/reset.h>
 
 #define DRIVER_NAME "sirfsoc_spi"
 
@@ -134,6 +135,7 @@
         ALIGNED(x->len) && (x->len < 2 * PAGE_SIZE))
 
 #define SIRFSOC_MAX_CMD_BYTES   4
+#define SIRFSOC_SPI_DEFAULT_FRQ 1000000
 
 struct sirfsoc_spi {
         struct spi_bitbang bitbang;
@@ -562,9 +564,9 @@ spi_sirfsoc_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
 
         sspi->word_width = DIV_ROUND_UP(bits_per_word, 8);
         txfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
-                                           sspi->word_width;
+                                           (sspi->word_width >> 1);
         rxfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
-                                           sspi->word_width;
+                                           (sspi->word_width >> 1);
 
         if (!(spi->mode & SPI_CS_HIGH))
                 regval |= SIRFSOC_SPI_CS_IDLE_STAT;
@@ -629,9 +631,6 @@ static int spi_sirfsoc_setup(struct spi_device *spi)
 {
         struct sirfsoc_spi *sspi;
 
-        if (!spi->max_speed_hz)
-                return -EINVAL;
-
         sspi = spi_master_get_devdata(spi->master);
 
         if (spi->cs_gpio == -ENOENT)
@@ -649,6 +648,12 @@ static int spi_sirfsoc_probe(struct platform_device *pdev)
         int irq;
         int i, ret;
 
+        ret = device_reset(&pdev->dev);
+        if (ret) {
+                dev_err(&pdev->dev, "SPI reset failed!\n");
+                return ret;
+        }
+
         master = spi_alloc_master(&pdev->dev, sizeof(*sspi));
         if (!master) {
                 dev_err(&pdev->dev, "Unable to allocate SPI master\n");
@@ -683,6 +688,7 @@ static int spi_sirfsoc_probe(struct platform_device *pdev)
         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST | SPI_CS_HIGH;
         master->bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(12) |
                                         SPI_BPW_MASK(16) | SPI_BPW_MASK(32);
+        master->max_speed_hz = SIRFSOC_SPI_DEFAULT_FRQ;
         sspi->bitbang.master->dev.of_node = pdev->dev.of_node;
 
         /* request DMA channels */
diff --git a/drivers/spi/spi-txx9.c b/drivers/spi/spi-txx9.c
index 2501a8373e89..f2ab827c81bb 100644
--- a/drivers/spi/spi-txx9.c
+++ b/drivers/spi/spi-txx9.c
@@ -402,8 +402,7 @@ exit_busy:
 exit:
         if (c->workqueue)
                 destroy_workqueue(c->workqueue);
-        if (c->clk)
-                clk_disable(c->clk);
+        clk_disable(c->clk);
         spi_master_put(master);
         return ret;
 }
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index cf4ed29c7ee6..66a70e9bc743 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -615,13 +615,13 @@ static int spi_map_buf(struct spi_master *master, struct device *dev,
                                 sg_free_table(sgt);
                                 return -ENOMEM;
                         }
-                        sg_buf = page_address(vm_page) +
-                                ((size_t)buf & ~PAGE_MASK);
+                        sg_set_page(&sgt->sgl[i], vm_page,
+                                    min, offset_in_page(buf));
                 } else {
                         sg_buf = buf;
+                        sg_set_buf(&sgt->sgl[i], sg_buf, min);
                 }
 
-                sg_set_buf(&sgt->sgl[i], sg_buf, min);
 
                 buf += min;
                 len -= min;
@@ -1001,7 +1001,7 @@ static int spi_init_queue(struct spi_master *master)
                                            dev_name(&master->dev));
         if (IS_ERR(master->kworker_task)) {
                 dev_err(&master->dev, "failed to create message pump task\n");
-                return -ENOMEM;
+                return PTR_ERR(master->kworker_task);
         }
         init_kthread_work(&master->pump_messages, spi_pump_messages);
 
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index e50039fb1474..6941e04afb8c 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -87,6 +87,7 @@ struct spidev_data {
         unsigned                users;
         u8                      *tx_buffer;
         u8                      *rx_buffer;
+        u32                     speed_hz;
 };
 
 static LIST_HEAD(device_list);
@@ -138,6 +139,7 @@ spidev_sync_write(struct spidev_data *spidev, size_t len)
         struct spi_transfer     t = {
                         .tx_buf         = spidev->tx_buffer,
                         .len            = len,
+                        .speed_hz       = spidev->speed_hz,
                 };
         struct spi_message      m;
 
@@ -152,6 +154,7 @@ spidev_sync_read(struct spidev_data *spidev, size_t len)
         struct spi_transfer     t = {
                         .rx_buf         = spidev->rx_buffer,
                         .len            = len,
+                        .speed_hz       = spidev->speed_hz,
                 };
         struct spi_message      m;
 
@@ -274,6 +277,8 @@ static int spidev_message(struct spidev_data *spidev,
                 k_tmp->bits_per_word = u_tmp->bits_per_word;
                 k_tmp->delay_usecs = u_tmp->delay_usecs;
                 k_tmp->speed_hz = u_tmp->speed_hz;
+                if (!k_tmp->speed_hz)
+                        k_tmp->speed_hz = spidev->speed_hz;
 #ifdef VERBOSE
                 dev_dbg(&spidev->spi->dev,
                         "  xfer len %zd %s%s%s%dbits %u usec %uHz\n",
@@ -377,7 +382,7 @@ spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
                 break;
         case SPI_IOC_RD_MAX_SPEED_HZ:
-                retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
+                retval = __put_user(spidev->speed_hz, (__u32 __user *)arg);
                 break;
 
         /* write requests */
@@ -441,10 +446,11 @@ spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
                         spi->max_speed_hz = tmp;
                         retval = spi_setup(spi);
-                        if (retval < 0)
-                                spi->max_speed_hz = save;
+                        if (retval >= 0)
+                                spidev->speed_hz = tmp;
                         else
                                 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
+                        spi->max_speed_hz = save;
                 }
                 break;
 
@@ -570,6 +576,8 @@ static int spidev_release(struct inode *inode, struct file *filp)
                 kfree(spidev->rx_buffer);
                 spidev->rx_buffer = NULL;
 
+                spidev->speed_hz = spidev->spi->max_speed_hz;
+
                 /* ... after we unbound from the underlying device? */
                 spin_lock_irq(&spidev->spi_lock);
                 dofree = (spidev->spi == NULL);
@@ -650,6 +658,8 @@ static int spidev_probe(struct spi_device *spi)
         }
         mutex_unlock(&device_list_lock);
 
+        spidev->speed_hz = spi->max_speed_hz;
+
         if (status == 0)
                 spi_set_drvdata(spi, spidev);
         else
diff --git a/drivers/staging/iio/light/isl29028.c b/drivers/staging/iio/light/isl29028.c
index 6014625920b0..e969107ddb47 100644
--- a/drivers/staging/iio/light/isl29028.c
+++ b/drivers/staging/iio/light/isl29028.c
@@ -537,7 +537,8 @@ static const struct i2c_device_id isl29028_id[] = {
 MODULE_DEVICE_TABLE(i2c, isl29028_id);
 
 static const struct of_device_id isl29028_of_match[] = {
-        { .compatible = "isil,isl29028", },
+        { .compatible = "isl,isl29028", },
+        { .compatible = "isil,isl29028", },/* deprecated, don't use */
         { },
 };
 MODULE_DEVICE_TABLE(of, isl29028_of_match);
diff --git a/drivers/staging/lustre/lustre/libcfs/tracefile.c b/drivers/staging/lustre/lustre/libcfs/tracefile.c
index 7e3f6a45da00..7561030c96e6 100644
--- a/drivers/staging/lustre/lustre/libcfs/tracefile.c
+++ b/drivers/staging/lustre/lustre/libcfs/tracefile.c
@@ -1025,8 +1025,8 @@ static int tracefiled(void *arg)
 
                         if (f_pos >= (off_t)cfs_tracefile_size)
                                 f_pos = 0;
-                        else if (f_pos > i_size_read(filp->f_dentry->d_inode))
-                                f_pos = i_size_read(filp->f_dentry->d_inode);
+                        else if (f_pos > i_size_read(file_inode(filp)))
+                                f_pos = i_size_read(file_inode(filp));
 
                         buf = kmap(tage->page);
                         rc = vfs_write(filp, (__force const char __user *)buf,
diff --git a/drivers/staging/lustre/lustre/llite/dcache.c b/drivers/staging/lustre/lustre/llite/dcache.c
index 439e4875b05c..f692261e9b5c 100644
--- a/drivers/staging/lustre/lustre/llite/dcache.c
+++ b/drivers/staging/lustre/lustre/llite/dcache.c
@@ -151,10 +151,10 @@ static int ll_ddelete(const struct dentry *de)
 {
         LASSERT(de);
 
-        CDEBUG(D_DENTRY, "%s dentry %.*s (%p, parent %p, inode %p) %s%s\n",
+        CDEBUG(D_DENTRY, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
                d_lustre_invalid((struct dentry *)de) ? "deleting" : "keeping",
-               de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
-               d_unhashed((struct dentry *)de) ? "" : "hashed,",
+               de, de, de->d_parent, de->d_inode,
+               d_unhashed(de) ? "" : "hashed,",
                list_empty(&de->d_subdirs) ? "" : "subdirs");
 
         /* kernel >= 2.6.38 last refcount is decreased after this function. */
@@ -180,8 +180,8 @@ int ll_d_init(struct dentry *de)
 {
         LASSERT(de != NULL);
 
-        CDEBUG(D_DENTRY, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
-                de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
+        CDEBUG(D_DENTRY, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n",
+                de, de, de->d_parent, de->d_inode,
                 d_count(de));
 
         if (de->d_fsdata == NULL) {
@@ -258,10 +258,9 @@ void ll_invalidate_aliases(struct inode *inode)
                inode->i_ino, inode->i_generation, inode);
 
         ll_lock_dcache(inode);
-        ll_d_hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
-                CDEBUG(D_DENTRY, "dentry in drop %.*s (%p) parent %p "
-                       "inode %p flags %d\n", dentry->d_name.len,
-                       dentry->d_name.name, dentry, dentry->d_parent,
+        ll_d_hlist_for_each_entry(dentry, p, &inode->i_dentry, d_u.d_alias) {
+                CDEBUG(D_DENTRY, "dentry in drop %pd (%p) parent %p "
+                       "inode %p flags %d\n", dentry, dentry, dentry->d_parent,
                        dentry->d_inode, dentry->d_flags);
 
                 if (unlikely(dentry == dentry->d_sb->s_root)) {
@@ -352,8 +351,8 @@ static int ll_revalidate_nd(struct dentry *dentry, unsigned int flags)
 {
         int rc;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%s, flags=%u\n",
-               dentry->d_name.name, flags);
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, flags=%u\n",
+               dentry, flags);
 
         rc = ll_revalidate_dentry(dentry, flags);
         return rc;
diff --git a/drivers/staging/lustre/lustre/llite/dir.c b/drivers/staging/lustre/lustre/llite/dir.c
index b0bb7095dde5..a79fd65ec4c6 100644
--- a/drivers/staging/lustre/lustre/llite/dir.c
+++ b/drivers/staging/lustre/lustre/llite/dir.c
@@ -593,7 +593,7 @@ int ll_dir_read(struct inode *inode, struct dir_context *ctx)
 
 static int ll_readdir(struct file *filp, struct dir_context *ctx)
 {
-        struct inode            *inode  = filp->f_dentry->d_inode;
+        struct inode            *inode  = file_inode(filp);
         struct ll_file_data     *lfd    = LUSTRE_FPRIVATE(filp);
         struct ll_sb_info       *sbi    = ll_i2sbi(inode);
         int                     hash64  = sbi->ll_flags & LL_SBI_64BIT_HASH;
@@ -1242,7 +1242,7 @@ ll_getname(const char __user *filename)
 
 static long ll_dir_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct obd_ioctl_data *data;
         int rc = 0;
@@ -1389,7 +1389,7 @@ lmv_out_free:
                                 return -EFAULT;
                 }
 
-                if (inode->i_sb->s_root == file->f_dentry)
+                if (is_root_inode(inode))
                         set_default = 1;
 
                 /* in v1 and v3 cases lumv1 points to data */
@@ -1780,8 +1780,7 @@ out_quotactl:
                 return ll_flush_ctx(inode);
 #ifdef CONFIG_FS_POSIX_ACL
         case LL_IOC_RMTACL: {
-            if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
-                inode == inode->i_sb->s_root->d_inode) {
+            if (sbi->ll_flags & LL_SBI_RMT_CLIENT && is_root_inode(inode)) {
                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 
                 LASSERT(fd != NULL);
diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index c99b74117152..a2ae9a68a9a0 100644
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -266,6 +266,10 @@ static int ll_md_close(struct obd_export *md_exp, struct inode *inode,
 {
         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
         struct ll_inode_info *lli = ll_i2info(inode);
+        int lockmode;
+        __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
+        struct lustre_handle lockh;
+        ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
         int rc = 0;
 
         /* clear group lock, if present */
@@ -292,39 +296,26 @@ static int ll_md_close(struct obd_export *md_exp, struct inode *inode,
 
         /* Let's see if we have good enough OPEN lock on the file and if
            we can skip talking to MDS */
-        if (file->f_dentry->d_inode) { /* Can this ever be false? */
-                int lockmode;
-                __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
-                struct lustre_handle lockh;
-                struct inode *inode = file->f_dentry->d_inode;
-                ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
-
-                mutex_lock(&lli->lli_och_mutex);
-                if (fd->fd_omode & FMODE_WRITE) {
-                        lockmode = LCK_CW;
-                        LASSERT(lli->lli_open_fd_write_count);
-                        lli->lli_open_fd_write_count--;
-                } else if (fd->fd_omode & FMODE_EXEC) {
-                        lockmode = LCK_PR;
-                        LASSERT(lli->lli_open_fd_exec_count);
-                        lli->lli_open_fd_exec_count--;
-                } else {
-                        lockmode = LCK_CR;
-                        LASSERT(lli->lli_open_fd_read_count);
-                        lli->lli_open_fd_read_count--;
-                }
-                mutex_unlock(&lli->lli_och_mutex);
 
-                if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
-                                   LDLM_IBITS, &policy, lockmode,
-                                   &lockh)) {
-                        rc = ll_md_real_close(file->f_dentry->d_inode,
-                                              fd->fd_omode);
-                }
+        mutex_lock(&lli->lli_och_mutex);
+        if (fd->fd_omode & FMODE_WRITE) {
+                lockmode = LCK_CW;
+                LASSERT(lli->lli_open_fd_write_count);
+                lli->lli_open_fd_write_count--;
+        } else if (fd->fd_omode & FMODE_EXEC) {
+                lockmode = LCK_PR;
+                LASSERT(lli->lli_open_fd_exec_count);
+                lli->lli_open_fd_exec_count--;
         } else {
-                CERROR("Releasing a file %p with negative dentry %p. Name %s",
-                       file, file->f_dentry, file->f_dentry->d_name.name);
+                lockmode = LCK_CR;
+                LASSERT(lli->lli_open_fd_read_count);
+                lli->lli_open_fd_read_count--;
         }
+        mutex_unlock(&lli->lli_och_mutex);
+
+        if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
+                           LDLM_IBITS, &policy, lockmode, &lockh))
+                rc = ll_md_real_close(inode, fd->fd_omode);
 
 out:
         LUSTRE_FPRIVATE(file) = NULL;
@@ -350,8 +341,7 @@ int ll_file_release(struct inode *inode, struct file *file)
                inode->i_generation, inode);
 
 #ifdef CONFIG_FS_POSIX_ACL
-        if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
-            inode == inode->i_sb->s_root->d_inode) {
+        if (sbi->ll_flags & LL_SBI_RMT_CLIENT && is_root_inode(inode)) {
                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 
                 LASSERT(fd != NULL);
@@ -363,7 +353,7 @@ int ll_file_release(struct inode *inode, struct file *file)
         }
 #endif
 
-        if (inode->i_sb->s_root != file->f_dentry)
+        if (!is_root_inode(inode))
                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
         fd = LUSTRE_FPRIVATE(file);
         LASSERT(fd != NULL);
@@ -375,7 +365,7 @@ int ll_file_release(struct inode *inode, struct file *file)
             lli->lli_opendir_pid != 0)
                 ll_stop_statahead(inode, lli->lli_opendir_key);
 
-        if (inode->i_sb->s_root == file->f_dentry) {
+        if (is_root_inode(inode)) {
                 LUSTRE_FPRIVATE(file) = NULL;
                 ll_file_data_put(fd);
                 return 0;
@@ -394,21 +384,19 @@ int ll_file_release(struct inode *inode, struct file *file)
         return rc;
 }
 
-static int ll_intent_file_open(struct file *file, void *lmm,
+static int ll_intent_file_open(struct dentry *dentry, void *lmm,
                                int lmmsize, struct lookup_intent *itp)
 {
-        struct ll_sb_info *sbi = ll_i2sbi(file->f_dentry->d_inode);
-        struct dentry *parent = file->f_dentry->d_parent;
-        const char *name = file->f_dentry->d_name.name;
-        const int len = file->f_dentry->d_name.len;
+        struct inode *inode = dentry->d_inode;
+        struct ll_sb_info *sbi = ll_i2sbi(inode);
+        struct dentry *parent = dentry->d_parent;
+        const char *name = dentry->d_name.name;
+        const int len = dentry->d_name.len;
         struct md_op_data *op_data;
         struct ptlrpc_request *req;
         __u32 opc = LUSTRE_OPC_ANY;
         int rc;
 
-        if (!parent)
-                return -ENOENT;
-
         /* Usually we come here only for NFSD, and we want open lock.
            But we can also get here with pre 2.6.15 patchless kernels, and in
            that case that lock is also ok */
@@ -425,7 +413,7 @@ static int ll_intent_file_open(struct file *file, void *lmm,
         }
 
         op_data  = ll_prep_md_op_data(NULL, parent->d_inode,
-                                      file->f_dentry->d_inode, name, len,
+                                      inode, name, len,
                                       O_RDWR, opc, NULL);
         if (IS_ERR(op_data))
                 return PTR_ERR(op_data);
@@ -441,7 +429,7 @@ static int ll_intent_file_open(struct file *file, void *lmm,
                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
                      it_open_error(DISP_OPEN_OPEN, itp))
                         goto out;
-                ll_release_openhandle(file->f_dentry, itp);
+                ll_release_openhandle(inode, itp);
                 goto out;
         }
 
@@ -456,10 +444,9 @@ static int ll_intent_file_open(struct file *file, void *lmm,
                 goto out;
         }
 
-        rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL, itp);
+        rc = ll_prep_inode(&inode, req, NULL, itp);
         if (!rc && itp->d.lustre.it_lock_mode)
-                ll_set_lock_data(sbi->ll_md_exp, file->f_dentry->d_inode,
-                                 itp, NULL);
+                ll_set_lock_data(sbi->ll_md_exp, inode, itp, NULL);
 
 out:
         ptlrpc_req_finished(req);
@@ -501,7 +488,7 @@ static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
 static int ll_local_open(struct file *file, struct lookup_intent *it,
                          struct ll_file_data *fd, struct obd_client_handle *och)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_inode_info *lli = ll_i2info(inode);
 
         LASSERT(!LUSTRE_FPRIVATE(file));
@@ -574,7 +561,7 @@ int ll_file_open(struct inode *inode, struct file *file)
                 spin_unlock(&lli->lli_sa_lock);
         }
 
-        if (inode->i_sb->s_root == file->f_dentry) {
+        if (is_root_inode(inode)) {
                 LUSTRE_FPRIVATE(file) = fd;
                 return 0;
         }
@@ -632,7 +619,7 @@ restart:
                                 goto out_openerr;
                         }
 
-                        ll_release_openhandle(file->f_dentry, it);
+                        ll_release_openhandle(inode, it);
                 }
                 (*och_usecount)++;
 
@@ -652,7 +639,7 @@ restart:
                            result in a deadlock */
                         mutex_unlock(&lli->lli_och_mutex);
                         it->it_create_mode |= M_CHECK_STALE;
-                        rc = ll_intent_file_open(file, NULL, 0, it);
+                        rc = ll_intent_file_open(file->f_path.dentry, NULL, 0, it);
                         it->it_create_mode &= ~M_CHECK_STALE;
                         if (rc)
                                 goto out_openerr;
@@ -1065,7 +1052,7 @@ int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm,
 static bool file_is_noatime(const struct file *file)
 {
         const struct vfsmount *mnt = file->f_path.mnt;
-        const struct inode *inode = file->f_path.dentry->d_inode;
+        const struct inode *inode = file_inode(file);
 
         /* Adapted from file_accessed() and touch_atime().*/
         if (file->f_flags & O_NOATIME)
@@ -1091,7 +1078,7 @@ static bool file_is_noatime(const struct file *file)
 
 void ll_io_init(struct cl_io *io, const struct file *file, int write)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
         if (write) {
@@ -1117,7 +1104,7 @@ ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
                    struct file *file, enum cl_io_type iot,
                    loff_t *ppos, size_t count)
 {
-        struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode);
+        struct ll_inode_info *lli = ll_i2info(file_inode(file));
         struct ll_file_data  *fd  = LUSTRE_FPRIVATE(file);
         struct cl_io     *io;
         ssize_t        result;
@@ -1178,20 +1165,20 @@ out:
         /* If any bit been read/written (result != 0), we just return
          * short read/write instead of restart io. */
         if ((result == 0 || result == -ENODATA) && io->ci_need_restart) {
-                CDEBUG(D_VFSTRACE, "Restart %s on %s from %lld, count:%zd\n",
+                CDEBUG(D_VFSTRACE, "Restart %s on %pD from %lld, count:%zd\n",
                        iot == CIT_READ ? "read" : "write",
-                       file->f_dentry->d_name.name, *ppos, count);
+                       file, *ppos, count);
                 LASSERTF(io->ci_nob == 0, "%zd", io->ci_nob);
                 goto restart;
         }
 
         if (iot == CIT_READ) {
                 if (result >= 0)
-                        ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
+                        ll_stats_ops_tally(ll_i2sbi(file_inode(file)),
                                            LPROC_LL_READ_BYTES, result);
         } else if (iot == CIT_WRITE) {
                 if (result >= 0) {
-                        ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
+                        ll_stats_ops_tally(ll_i2sbi(file_inode(file)),
                                            LPROC_LL_WRITE_BYTES, result);
                         fd->fd_write_failed = false;
                 } else if (result != -ERESTARTSYS) {
@@ -1354,7 +1341,7 @@ static int ll_lov_recreate_fid(struct inode *inode, unsigned long arg)
         return ll_lov_recreate(inode, &oi, ost_idx);
 }
 
-int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
+int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
                              int flags, struct lov_user_md *lum, int lum_size)
 {
         struct lov_stripe_md *lsm = NULL;
@@ -1371,21 +1358,20 @@ int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
         }
 
         ll_inode_size_lock(inode);
-        rc = ll_intent_file_open(file, lum, lum_size, &oit);
+        rc = ll_intent_file_open(dentry, lum, lum_size, &oit);
         if (rc)
                 goto out_unlock;
         rc = oit.d.lustre.it_status;
         if (rc < 0)
                 goto out_req_free;
 
-        ll_release_openhandle(file->f_dentry, &oit);
+        ll_release_openhandle(inode, &oit);
 
 out_unlock:
         ll_inode_size_unlock(inode);
         ll_intent_release(&oit);
         ccc_inode_lsm_put(inode, lsm);
 out:
-        cl_lov_delay_create_clear(&file->f_flags);
         return rc;
 out_req_free:
         ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
@@ -1499,7 +1485,9 @@ static int ll_lov_setea(struct inode *inode, struct file *file,
                 return -EFAULT;
         }
 
-        rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
+        rc = ll_lov_setstripe_ea_info(inode, file->f_path.dentry, flags, lump,
+                                     lum_size);
+        cl_lov_delay_create_clear(&file->f_flags);
 
         OBD_FREE_LARGE(lump, lum_size);
         return rc;
@@ -1526,7 +1514,9 @@ static int ll_lov_setstripe(struct inode *inode, struct file *file,
                         return -EFAULT;
         }
 
-        rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size);
+        rc = ll_lov_setstripe_ea_info(inode, file->f_path.dentry, flags, lumv1,
+                                      lum_size);
+        cl_lov_delay_create_clear(&file->f_flags);
         if (rc == 0) {
                 struct lov_stripe_md *lsm;
                 __u32 gen;
@@ -1631,22 +1621,21 @@ int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg)
 /**
  * Close inode open handle
  *
- * \param dentry [in]     dentry which contains the inode
+ * \param inode  [in]     inode in question
  * \param it     [in,out] intent which contains open info and result
  *
  * \retval 0     success
  * \retval <0    failure
  */
-int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
+int ll_release_openhandle(struct inode *inode, struct lookup_intent *it)
 {
-        struct inode *inode = dentry->d_inode;
         struct obd_client_handle *och;
         int rc;
 
         LASSERT(inode);
 
         /* Root ? Do nothing. */
-        if (dentry->d_inode->i_sb->s_root == dentry)
+        if (is_root_inode(inode))
                 return 0;
 
         /* No open handle to close? Move away */
@@ -1959,8 +1948,8 @@ static int ll_swap_layouts(struct file *file1, struct file *file2,
         if (!llss)
                 return -ENOMEM;
 
-        llss->inode1 = file1->f_dentry->d_inode;
-        llss->inode2 = file2->f_dentry->d_inode;
+        llss->inode1 = file_inode(file1);
+        llss->inode2 = file_inode(file2);
 
         if (!S_ISREG(llss->inode2->i_mode)) {
                 rc = -EINVAL;
@@ -2092,7 +2081,7 @@ putgl:
         rc = 0;
         if (llss->ia2.ia_valid != 0) {
                 mutex_lock(&llss->inode1->i_mutex);
-                rc = ll_setattr(file1->f_dentry, &llss->ia2);
+                rc = ll_setattr(file1->f_path.dentry, &llss->ia2);
                 mutex_unlock(&llss->inode1->i_mutex);
         }
 
@@ -2100,7 +2089,7 @@ putgl:
                 int rc1;
 
                 mutex_lock(&llss->inode2->i_mutex);
-                rc1 = ll_setattr(file2->f_dentry, &llss->ia1);
+                rc1 = ll_setattr(file2->f_path.dentry, &llss->ia1);
                 mutex_unlock(&llss->inode2->i_mutex);
                 if (rc == 0)
                         rc = rc1;
@@ -2185,7 +2174,7 @@ static int ll_hsm_import(struct inode *inode, struct file *file,
 
         mutex_lock(&inode->i_mutex);
 
-        rc = ll_setattr_raw(file->f_dentry, attr, true);
+        rc = ll_setattr_raw(file->f_path.dentry, attr, true);
         if (rc == -ENODATA)
                 rc = 0;
 
@@ -2204,7 +2193,7 @@ out:
 static long
 ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode            *inode = file->f_dentry->d_inode;
+        struct inode            *inode = file_inode(file);
         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
         int                      flags, rc;
 
@@ -2523,7 +2512,7 @@ ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
 static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         loff_t retval, eof = 0;
 
         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
@@ -2547,7 +2536,7 @@ static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
 
 static int ll_flush(struct file *file, fl_owner_t id)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_inode_info *lli = ll_i2info(inode);
         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
         int rc, err;
@@ -2622,16 +2611,9 @@ int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
         return result;
 }
 
-/*
- * When dentry is provided (the 'else' case), *file->f_dentry may be
- * null and dentry must be used directly rather than pulled from
- * *file->f_dentry as is done otherwise.
- */
-
 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
-        struct dentry *dentry = file->f_dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_inode_info *lli = ll_i2info(inode);
         struct ptlrpc_request *req;
         struct obd_capa *oc;
@@ -2684,7 +2666,7 @@ int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 static int
 ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct ldlm_enqueue_info einfo = {
                 .ei_type        = LDLM_FLOCK,
@@ -2908,8 +2890,8 @@ static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
 
         LASSERT(inode != NULL);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
-               inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
+        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%pd\n",
+               inode->i_ino, inode->i_generation, inode, dentry);
 
         exp = ll_i2mdexp(inode);
 
@@ -3119,7 +3101,7 @@ int ll_inode_permission(struct inode *inode, int mask)
        /* as root inode are NOT getting validated in lookup operation,
         * need to do it before permission check. */
 
-        if (inode == inode->i_sb->s_root->d_inode) {
+        if (is_root_inode(inode)) {
                 rc = __ll_inode_revalidate(inode->i_sb->s_root,
                                            MDS_INODELOCK_LOOKUP);
                 if (rc)
diff --git a/drivers/staging/lustre/lustre/llite/llite_internal.h b/drivers/staging/lustre/lustre/llite/llite_internal.h
index 36aa0fd147f2..77d1c12704b4 100644
--- a/drivers/staging/lustre/lustre/llite/llite_internal.h
+++ b/drivers/staging/lustre/lustre/llite/llite_internal.h
@@ -748,7 +748,7 @@ int ll_file_release(struct inode *inode, struct file *file);
 int ll_glimpse_ioctl(struct ll_sb_info *sbi,
                      struct lov_stripe_md *lsm, lstat_t *st);
 void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch);
-int ll_release_openhandle(struct dentry *, struct lookup_intent *);
+int ll_release_openhandle(struct inode *, struct lookup_intent *);
 int ll_md_real_close(struct inode *inode, fmode_t fmode);
 void ll_ioepoch_close(struct inode *inode, struct md_op_data *op_data,
                       struct obd_client_handle **och, unsigned long flags);
@@ -763,7 +763,7 @@ struct posix_acl *ll_get_acl(struct inode *inode, int type);
 
 int ll_inode_permission(struct inode *inode, int mask);
 
-int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
+int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
                              int flags, struct lov_user_md *lum,
                              int lum_size);
 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
@@ -1413,7 +1413,7 @@ extern ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io,
 static inline int ll_file_nolock(const struct file *file)
 {
         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         LASSERT(fd != NULL);
         return ((fd->fd_flags & LL_FILE_IGNORE_LOCK) ||
@@ -1489,8 +1489,8 @@ static inline void __d_lustre_invalidate(struct dentry *dentry)
  */
 static inline void d_lustre_invalidate(struct dentry *dentry, int nested)
 {
-        CDEBUG(D_DENTRY, "invalidate dentry %.*s (%p) parent %p inode %p "
-               "refc %d\n", dentry->d_name.len, dentry->d_name.name, dentry,
+        CDEBUG(D_DENTRY, "invalidate dentry %pd (%p) parent %p inode %p "
+               "refc %d\n", dentry, dentry,
                dentry->d_parent, dentry->d_inode, d_count(dentry));
 
         spin_lock_nested(&dentry->d_lock,
diff --git a/drivers/staging/lustre/lustre/llite/llite_lib.c b/drivers/staging/lustre/lustre/llite/llite_lib.c
index a8bcc51057f1..7b6b9e2e0102 100644
--- a/drivers/staging/lustre/lustre/llite/llite_lib.c
+++ b/drivers/staging/lustre/lustre/llite/llite_lib.c
@@ -698,10 +698,8 @@ void lustre_dump_dentry(struct dentry *dentry, int recur)
         list_for_each(tmp, &dentry->d_subdirs)
                 subdirs++;
 
-        CERROR("dentry %p dump: name=%.*s parent=%.*s (%p), inode=%p, count=%u,"
-               " flags=0x%x, fsdata=%p, %d subdirs\n", dentry,
-               dentry->d_name.len, dentry->d_name.name,
-               dentry->d_parent->d_name.len, dentry->d_parent->d_name.name,
+        CERROR("dentry %p dump: name=%pd parent=%p, inode=%p, count=%u,"
+               " flags=0x%x, fsdata=%p, %d subdirs\n", dentry, dentry,
                dentry->d_parent, dentry->d_inode, d_count(dentry),
                dentry->d_flags, dentry->d_fsdata, subdirs);
         if (dentry->d_inode != NULL)
@@ -711,7 +709,7 @@ void lustre_dump_dentry(struct dentry *dentry, int recur)
                 return;
 
         list_for_each(tmp, &dentry->d_subdirs) {
-                struct dentry *d = list_entry(tmp, struct dentry, d_u.d_child);
+                struct dentry *d = list_entry(tmp, struct dentry, d_child);
                 lustre_dump_dentry(d, recur - 1);
         }
 }
diff --git a/drivers/staging/lustre/lustre/llite/llite_mmap.c b/drivers/staging/lustre/lustre/llite/llite_mmap.c
index ae605a6d9dc2..ba1c047ae927 100644
--- a/drivers/staging/lustre/lustre/llite/llite_mmap.c
+++ b/drivers/staging/lustre/lustre/llite/llite_mmap.c
@@ -100,7 +100,7 @@ ll_fault_io_init(struct vm_area_struct *vma, struct lu_env **env_ret,
                  unsigned long *ra_flags)
 {
         struct file            *file = vma->vm_file;
-        struct inode           *inode = file->f_dentry->d_inode;
+        struct inode           *inode = file_inode(file);
         struct cl_io           *io;
         struct cl_fault_io     *fio;
         struct lu_env          *env;
@@ -213,7 +213,7 @@ static int ll_page_mkwrite0(struct vm_area_struct *vma, struct page *vmpage,
         cfs_restore_sigs(set);
 
         if (result == 0) {
-                struct inode *inode = vma->vm_file->f_dentry->d_inode;
+                struct inode *inode = file_inode(vma->vm_file);
                 struct ll_inode_info *lli = ll_i2info(inode);
 
                 lock_page(vmpage);
@@ -396,7 +396,7 @@ static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
                         CWARN("app(%s): the page %lu of file %lu is under heavy"
                               " contention.\n",
                               current->comm, vmf->pgoff,
-                              vma->vm_file->f_dentry->d_inode->i_ino);
+                              file_inode(vma->vm_file)->i_ino);
                         printed = true;
                 }
         } while (retry);
@@ -430,7 +430,7 @@ static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
  */
 static void ll_vm_open(struct vm_area_struct *vma)
 {
-        struct inode *inode    = vma->vm_file->f_dentry->d_inode;
+        struct inode *inode    = file_inode(vma->vm_file);
         struct ccc_object *vob = cl_inode2ccc(inode);
 
         LASSERT(vma->vm_file);
@@ -443,7 +443,7 @@ static void ll_vm_open(struct vm_area_struct *vma)
  */
 static void ll_vm_close(struct vm_area_struct *vma)
 {
-        struct inode      *inode = vma->vm_file->f_dentry->d_inode;
+        struct inode      *inode = file_inode(vma->vm_file);
         struct ccc_object *vob   = cl_inode2ccc(inode);
 
         LASSERT(vma->vm_file);
@@ -476,7 +476,7 @@ static const struct vm_operations_struct ll_file_vm_ops = {
 
 int ll_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         int rc;
 
         if (ll_file_nolock(file))
diff --git a/drivers/staging/lustre/lustre/llite/llite_nfs.c b/drivers/staging/lustre/lustre/llite/llite_nfs.c
index ae3a12ab7fa1..243a7840457f 100644
--- a/drivers/staging/lustre/lustre/llite/llite_nfs.c
+++ b/drivers/staging/lustre/lustre/llite/llite_nfs.c
@@ -207,13 +207,15 @@ static int ll_encode_fh(struct inode *inode, __u32 *fh, int *plen,
         return LUSTRE_NFS_FID;
 }
 
-static int ll_nfs_get_name_filldir(void *cookie, const char *name, int namelen,
-                                   loff_t hash, u64 ino, unsigned type)
+static int ll_nfs_get_name_filldir(struct dir_context *ctx, const char *name,
+                                   int namelen, loff_t hash, u64 ino,
+                                   unsigned type)
 {
         /* It is hack to access lde_fid for comparison with lgd_fid.
          * So the input 'name' must be part of the 'lu_dirent'. */
         struct lu_dirent *lde = container_of0(name, struct lu_dirent, lde_name);
-        struct ll_getname_data *lgd = cookie;
+        struct ll_getname_data *lgd =
+                container_of(ctx, struct ll_getname_data, ctx);
         struct lu_fid fid;
 
         fid_le_to_cpu(&fid, &lde->lde_fid);
diff --git a/drivers/staging/lustre/lustre/llite/lloop.c b/drivers/staging/lustre/lustre/llite/lloop.c
index 264e5ec3fed6..9e31b789b790 100644
--- a/drivers/staging/lustre/lustre/llite/lloop.c
+++ b/drivers/staging/lustre/lustre/llite/lloop.c
@@ -187,7 +187,7 @@ static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head)
 {
         const struct lu_env  *env   = lo->lo_env;
         struct cl_io     *io    = &lo->lo_io;
-        struct inode     *inode = lo->lo_backing_file->f_dentry->d_inode;
+        struct inode     *inode = file_inode(lo->lo_backing_file);
         struct cl_object     *obj = ll_i2info(inode)->lli_clob;
         pgoff_t        offset;
         int                ret;
@@ -626,7 +626,7 @@ static int lo_ioctl(struct block_device *bdev, fmode_t mode,
                         break;
                 }
                 if (inode == NULL)
-                        inode = lo->lo_backing_file->f_dentry->d_inode;
+                        inode = file_inode(lo->lo_backing_file);
                 if (lo->lo_state == LLOOP_BOUND)
                         fid = ll_i2info(inode)->lli_fid;
                 else
@@ -692,8 +692,7 @@ static enum llioc_iter lloop_ioctl(struct inode *unused, struct file *file,
                                         lo_free = lo;
                                 continue;
                         }
-                        if (lo->lo_backing_file->f_dentry->d_inode ==
-                            file->f_dentry->d_inode)
+                        if (file_inode(lo->lo_backing_file) == file_inode(file))
                                 break;
                 }
                 if (lo || !lo_free) {
diff --git a/drivers/staging/lustre/lustre/llite/namei.c b/drivers/staging/lustre/lustre/llite/namei.c
index 7a68c1e027e0..8e926b385a60 100644
--- a/drivers/staging/lustre/lustre/llite/namei.c
+++ b/drivers/staging/lustre/lustre/llite/namei.c
@@ -54,27 +54,6 @@
 static int ll_create_it(struct inode *, struct dentry *,
                         int, struct lookup_intent *);
 
-/*
- * Check if we have something mounted at the named dchild.
- * In such a case there would always be dentry present.
- */
-static int ll_d_mountpoint(struct dentry *dparent, struct dentry *dchild,
-                           struct qstr *name)
-{
-        int mounted = 0;
-
-        if (unlikely(dchild)) {
-                mounted = d_mountpoint(dchild);
-        } else if (dparent) {
-                dchild = d_lookup(dparent, name);
-                if (dchild) {
-                        mounted = d_mountpoint(dchild);
-                        dput(dchild);
-                }
-        }
-        return mounted;
-}
-
 /* called from iget5_locked->find_inode() under inode_hash_lock spinlock */
 static int ll_test_inode(struct inode *inode, void *opaque)
 {
@@ -167,14 +146,14 @@ static void ll_invalidate_negative_children(struct inode *dir)
         struct ll_d_hlist_node *p;
 
         ll_lock_dcache(dir);
-        ll_d_hlist_for_each_entry(dentry, p, &dir->i_dentry, d_alias) {
+        ll_d_hlist_for_each_entry(dentry, p, &dir->i_dentry, d_u.d_alias) {
                 spin_lock(&dentry->d_lock);
                 if (!list_empty(&dentry->d_subdirs)) {
                         struct dentry *child;
 
                         list_for_each_entry_safe(child, tmp_subdir,
                                                  &dentry->d_subdirs,
-                                                 d_u.d_child) {
+                                                 d_child) {
                                 if (child->d_inode == NULL)
                                         d_lustre_invalidate(child, 1);
                         }
@@ -285,7 +264,7 @@ int ll_md_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
 
                 if ((bits & (MDS_INODELOCK_LOOKUP | MDS_INODELOCK_PERM)) &&
                     inode->i_sb->s_root != NULL &&
-                    inode != inode->i_sb->s_root->d_inode)
+                    is_root_inode(inode))
                         ll_invalidate_aliases(inode);
 
                 iput(inode);
@@ -362,7 +341,7 @@ static struct dentry *ll_find_alias(struct inode *inode, struct dentry *dentry)
         discon_alias = invalid_alias = NULL;
 
         ll_lock_dcache(inode);
-        ll_d_hlist_for_each_entry(alias, p, &inode->i_dentry, d_alias) {
+        ll_d_hlist_for_each_entry(alias, p, &inode->i_dentry, d_u.d_alias) {
                 LASSERT(alias != dentry);
 
                 spin_lock(&alias->d_lock);
@@ -509,8 +488,8 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
         if (dentry->d_name.len > ll_i2sbi(parent)->ll_namelen)
                 return ERR_PTR(-ENAMETOOLONG);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
-               dentry->d_name.len, dentry->d_name.name, parent->i_ino,
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),intent=%s\n",
+               dentry, parent->i_ino,
                parent->i_generation, parent, LL_IT2STR(it));
 
         if (d_mountpoint(dentry))
@@ -563,7 +542,7 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
         if ((it->it_op & IT_OPEN) && dentry->d_inode &&
             !S_ISREG(dentry->d_inode->i_mode) &&
             !S_ISDIR(dentry->d_inode->i_mode)) {
-                ll_release_openhandle(dentry, it);
+                ll_release_openhandle(dentry->d_inode, it);
         }
         ll_lookup_finish_locks(it, dentry);
 
@@ -586,8 +565,8 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
         struct lookup_intent *itp, it = { .it_op = IT_GETATTR };
         struct dentry *de;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),flags=%u\n",
-               dentry->d_name.len, dentry->d_name.name, parent->i_ino,
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),flags=%u\n",
+               dentry, parent->i_ino,
                parent->i_generation, parent, flags);
 
         /* Optimize away (CREATE && !OPEN). Let .create handle the race. */
@@ -619,9 +598,9 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
         long long lookup_flags = LOOKUP_OPEN;
         int rc = 0;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),file %p,"
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),file %p,"
                            "open_flags %x,mode %x opened %d\n",
-               dentry->d_name.len, dentry->d_name.name, dir->i_ino,
+               dentry, dir->i_ino,
                dir->i_generation, dir, file, open_flags, mode, *opened);
 
         it = kzalloc(sizeof(*it), GFP_NOFS);
@@ -741,8 +720,8 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
         struct inode *inode;
         int rc = 0;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
-               dentry->d_name.len, dentry->d_name.name, dir->i_ino,
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),intent=%s\n",
+               dentry, dir->i_ino,
                dir->i_generation, dir, LL_IT2STR(it));
 
         rc = it_open_error(DISP_OPEN_CREATE, it);
@@ -775,9 +754,9 @@ static void ll_update_times(struct ptlrpc_request *request,
                 LTIME_S(inode->i_ctime) = body->ctime;
 }
 
-static int ll_new_node(struct inode *dir, struct qstr *name,
+static int ll_new_node(struct inode *dir, struct dentry *dentry,
                        const char *tgt, int mode, int rdev,
-                       struct dentry *dchild, __u32 opc)
+                       __u32 opc)
 {
         struct ptlrpc_request *request = NULL;
         struct md_op_data *op_data;
@@ -789,8 +768,10 @@ static int ll_new_node(struct inode *dir, struct qstr *name,
         if (unlikely(tgt != NULL))
                 tgt_len = strlen(tgt) + 1;
 
-        op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name,
-                                     name->len, 0, opc, NULL);
+        op_data = ll_prep_md_op_data(NULL, dir, NULL,
+                                     dentry->d_name.name,
+                                     dentry->d_name.len,
+                                     0, opc, NULL);
         if (IS_ERR(op_data)) {
                 err = PTR_ERR(op_data);
                 goto err_exit;
@@ -806,27 +787,25 @@ static int ll_new_node(struct inode *dir, struct qstr *name,
 
         ll_update_times(request, dir);
 
-        if (dchild) {
-                err = ll_prep_inode(&inode, request, dchild->d_sb, NULL);
-                if (err)
-                        goto err_exit;
+        err = ll_prep_inode(&inode, request, dir->i_sb, NULL);
+        if (err)
+                goto err_exit;
 
-                d_instantiate(dchild, inode);
-        }
+        d_instantiate(dentry, inode);
 err_exit:
         ptlrpc_req_finished(request);
 
         return err;
 }
 
-static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode,
-                            unsigned rdev, struct dentry *dchild)
+static int ll_mknod(struct inode *dir, struct dentry *dchild,
+                    umode_t mode, dev_t rdev)
 {
         int err;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p) mode %o dev %x\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir,
-               mode, rdev);
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p) mode %o dev %x\n",
+               dchild, dir->i_ino, dir->i_generation, dir,
+               mode, old_encode_dev(rdev));
 
         if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
                 mode &= ~current_umask();
@@ -839,7 +818,8 @@ static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode,
         case S_IFBLK:
         case S_IFIFO:
         case S_IFSOCK:
-                err = ll_new_node(dir, name, NULL, mode, rdev, dchild,
+                err = ll_new_node(dir, dchild, NULL, mode,
+                                  old_encode_dev(rdev),
                                   LUSTRE_OPC_MKNOD);
                 break;
         case S_IFDIR:
@@ -863,134 +843,25 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry,
 {
         int rc;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),"
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),"
                            "flags=%u, excl=%d\n",
-               dentry->d_name.len, dentry->d_name.name, dir->i_ino,
+               dentry, dir->i_ino,
                dir->i_generation, dir, mode, want_excl);
 
-        rc = ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry);
+        rc = ll_mknod(dir, dentry, mode, 0);
 
         ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_CREATE, 1);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, unhashed %d\n",
-               dentry->d_name.len, dentry->d_name.name, d_unhashed(dentry));
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, unhashed %d\n",
+               dentry, d_unhashed(dentry));
 
         return rc;
 }
 
-static int ll_symlink_generic(struct inode *dir, struct qstr *name,
-                              const char *tgt, struct dentry *dchild)
+static inline void ll_get_child_fid(struct dentry *child, struct lu_fid *fid)
 {
-        int err;
-
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),target=%.*s\n",
-               name->len, name->name, dir->i_ino, dir->i_generation,
-               dir, 3000, tgt);
-
-        err = ll_new_node(dir, name, (char *)tgt, S_IFLNK | S_IRWXUGO,
-                          0, dchild, LUSTRE_OPC_SYMLINK);
-
-        if (!err)
-                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_SYMLINK, 1);
-
-        return err;
-}
-
-static int ll_link_generic(struct inode *src,  struct inode *dir,
-                           struct qstr *name, struct dentry *dchild)
-{
-        struct ll_sb_info *sbi = ll_i2sbi(dir);
-        struct ptlrpc_request *request = NULL;
-        struct md_op_data *op_data;
-        int err;
-
-        CDEBUG(D_VFSTRACE,
-               "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
-               src->i_ino, src->i_generation, src, dir->i_ino,
-               dir->i_generation, dir, name->len, name->name);
-
-        op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len,
-                                     0, LUSTRE_OPC_ANY, NULL);
-        if (IS_ERR(op_data))
-                return PTR_ERR(op_data);
-
-        err = md_link(sbi->ll_md_exp, op_data, &request);
-        ll_finish_md_op_data(op_data);
-        if (err)
-                goto out;
-
-        ll_update_times(request, dir);
-        ll_stats_ops_tally(sbi, LPROC_LL_LINK, 1);
-out:
-        ptlrpc_req_finished(request);
-        return err;
-}
-
-static int ll_mkdir_generic(struct inode *dir, struct qstr *name,
-                            int mode, struct dentry *dchild)
-
-{
-        int err;
-
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
-
-        if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
-                mode &= ~current_umask();
-        mode = (mode & (S_IRWXUGO|S_ISVTX)) | S_IFDIR;
-        err = ll_new_node(dir, name, NULL, mode, 0, dchild, LUSTRE_OPC_MKDIR);
-
-        if (!err)
-                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_MKDIR, 1);
-
-        return err;
-}
-
-/* Try to find the child dentry by its name.
-   If found, put the result fid into @fid. */
-static void ll_get_child_fid(struct inode * dir, struct qstr *name,
-                             struct lu_fid *fid)
-{
-        struct dentry *parent, *child;
-
-        parent = ll_d_hlist_entry(dir->i_dentry, struct dentry, d_alias);
-        child = d_lookup(parent, name);
-        if (child) {
-                if (child->d_inode)
-                        *fid = *ll_inode2fid(child->d_inode);
-                dput(child);
-        }
-}
-
-static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent,
-                            struct dentry *dchild, struct qstr *name)
-{
-        struct ptlrpc_request *request = NULL;
-        struct md_op_data *op_data;
-        int rc;
-
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
-
-        if (unlikely(ll_d_mountpoint(dparent, dchild, name)))
-                return -EBUSY;
-
-        op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len,
-                                     S_IFDIR, LUSTRE_OPC_ANY, NULL);
-        if (IS_ERR(op_data))
-                return PTR_ERR(op_data);
-
-        ll_get_child_fid(dir, name, &op_data->op_fid3);
-        op_data->op_fid2 = op_data->op_fid3;
-        rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
-        ll_finish_md_op_data(op_data);
-        if (rc == 0) {
-                ll_update_times(request, dir);
-                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_RMDIR, 1);
-        }
-
-        ptlrpc_req_finished(request);
-        return rc;
+        if (child->d_inode)
+                *fid = *ll_inode2fid(child->d_inode);
 }
 
 /**
@@ -1099,32 +970,26 @@ out:
         return rc;
 }
 
-/* ll_unlink_generic() doesn't update the inode with the new link count.
+/* ll_unlink() doesn't update the inode with the new link count.
  * Instead, ll_ddelete() and ll_d_iput() will update it based upon if there
  * is any lock existing. They will recycle dentries and inodes based upon locks
  * too. b=20433 */
-static int ll_unlink_generic(struct inode *dir, struct dentry *dparent,
-                             struct dentry *dchild, struct qstr *name)
+static int ll_unlink(struct inode * dir, struct dentry *dentry)
 {
         struct ptlrpc_request *request = NULL;
         struct md_op_data *op_data;
         int rc;
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
-
-        /*
-         * XXX: unlink bind mountpoint maybe call to here,
-         * just check it as vfs_unlink does.
-         */
-        if (unlikely(ll_d_mountpoint(dparent, dchild, name)))
-                return -EBUSY;
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p)\n",
+               dentry, dir->i_ino, dir->i_generation, dir);
 
-        op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name,
-                                     name->len, 0, LUSTRE_OPC_ANY, NULL);
+        op_data = ll_prep_md_op_data(NULL, dir, NULL,
+                                     dentry->d_name.name,
+                                     dentry->d_name.len,
+                                     0, LUSTRE_OPC_ANY, NULL);
         if (IS_ERR(op_data))
                 return PTR_ERR(op_data);
 
-        ll_get_child_fid(dir, name, &op_data->op_fid3);
+        ll_get_child_fid(dentry, &op_data->op_fid3);
         op_data->op_fid2 = op_data->op_fid3;
         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
         ll_finish_md_op_data(op_data);
@@ -1140,95 +1005,140 @@ static int ll_unlink_generic(struct inode *dir, struct dentry *dparent,
         return rc;
 }
 
-static int ll_rename_generic(struct inode *src, struct dentry *src_dparent,
-                             struct dentry *src_dchild, struct qstr *src_name,
-                             struct inode *tgt, struct dentry *tgt_dparent,
-                             struct dentry *tgt_dchild, struct qstr *tgt_name)
+static int ll_mkdir(struct inode *dir, struct dentry *dentry, ll_umode_t mode)
 {
-        struct ptlrpc_request *request = NULL;
-        struct ll_sb_info *sbi = ll_i2sbi(src);
-        struct md_op_data *op_data;
         int err;
 
-        CDEBUG(D_VFSTRACE,
-               "VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
-               "tgt_dir=%lu/%u(%p)\n", src_name->len, src_name->name,
-               src->i_ino, src->i_generation, src, tgt_name->len,
-               tgt_name->name, tgt->i_ino, tgt->i_generation, tgt);
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p)\n",
+               dentry, dir->i_ino, dir->i_generation, dir);
 
-        if (unlikely(ll_d_mountpoint(src_dparent, src_dchild, src_name) ||
-            ll_d_mountpoint(tgt_dparent, tgt_dchild, tgt_name)))
-                return -EBUSY;
+        if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
+                mode &= ~current_umask();
+        mode = (mode & (S_IRWXUGO|S_ISVTX)) | S_IFDIR;
+        err = ll_new_node(dir, dentry, NULL, mode, 0, LUSTRE_OPC_MKDIR);
 
-        op_data = ll_prep_md_op_data(NULL, src, tgt, NULL, 0, 0,
-                                     LUSTRE_OPC_ANY, NULL);
+        if (!err)
+                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_MKDIR, 1);
+
+        return err;
+}
+
+static int ll_rmdir(struct inode *dir, struct dentry *dentry)
+{
+        struct ptlrpc_request *request = NULL;
+        struct md_op_data *op_data;
+        int rc;
+
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p)\n",
+               dentry, dir->i_ino, dir->i_generation, dir);
+
+        op_data = ll_prep_md_op_data(NULL, dir, NULL,
+                                     dentry->d_name.name, 
+                                     dentry->d_name.len,
+                                     S_IFDIR, LUSTRE_OPC_ANY, NULL);
         if (IS_ERR(op_data))
                 return PTR_ERR(op_data);
 
-        ll_get_child_fid(src, src_name, &op_data->op_fid3);
-        ll_get_child_fid(tgt, tgt_name, &op_data->op_fid4);
-        err = md_rename(sbi->ll_md_exp, op_data,
-                        src_name->name, src_name->len,
-                        tgt_name->name, tgt_name->len, &request);
+        ll_get_child_fid(dentry, &op_data->op_fid3);
+        op_data->op_fid2 = op_data->op_fid3;
+        rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
         ll_finish_md_op_data(op_data);
-        if (!err) {
-                ll_update_times(request, src);
-                ll_update_times(request, tgt);
-                ll_stats_ops_tally(sbi, LPROC_LL_RENAME, 1);
-                err = ll_objects_destroy(request, src);
+        if (rc == 0) {
+                ll_update_times(request, dir);
+                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_RMDIR, 1);
         }
 
         ptlrpc_req_finished(request);
-
-        return err;
+        return rc;
 }
 
-static int ll_mknod(struct inode *dir, struct dentry *dchild, ll_umode_t mode,
-                    dev_t rdev)
+static int ll_symlink(struct inode *dir, struct dentry *dentry,
+                      const char *oldname)
 {
-        return ll_mknod_generic(dir, &dchild->d_name, mode,
-                                old_encode_dev(rdev), dchild);
-}
+        int err;
 
-static int ll_unlink(struct inode * dir, struct dentry *dentry)
-{
-        return ll_unlink_generic(dir, NULL, dentry, &dentry->d_name);
-}
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),target=%.*s\n",
+               dentry, dir->i_ino, dir->i_generation,
+               dir, 3000, oldname);
 
-static int ll_mkdir(struct inode *dir, struct dentry *dentry, ll_umode_t mode)
-{
-        return ll_mkdir_generic(dir, &dentry->d_name, mode, dentry);
-}
+        err = ll_new_node(dir, dentry, oldname, S_IFLNK | S_IRWXUGO,
+                        0, LUSTRE_OPC_SYMLINK);
 
-static int ll_rmdir(struct inode *dir, struct dentry *dentry)
-{
-        return ll_rmdir_generic(dir, NULL, dentry, &dentry->d_name);
-}
+        if (!err)
+                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_SYMLINK, 1);
 
-static int ll_symlink(struct inode *dir, struct dentry *dentry,
-                      const char *oldname)
-{
-        return ll_symlink_generic(dir, &dentry->d_name, oldname, dentry);
+        return err;
 }
 
 static int ll_link(struct dentry *old_dentry, struct inode *dir,
                    struct dentry *new_dentry)
 {
-        return ll_link_generic(old_dentry->d_inode, dir, &new_dentry->d_name,
-                               new_dentry);
+        struct inode *src = old_dentry->d_inode;
+        struct ll_sb_info *sbi = ll_i2sbi(dir);
+        struct ptlrpc_request *request = NULL;
+        struct md_op_data *op_data;
+        int err;
+
+        CDEBUG(D_VFSTRACE,
+               "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%pd\n",
+               src->i_ino, src->i_generation, src, dir->i_ino,
+               dir->i_generation, dir, new_dentry);
+
+        op_data = ll_prep_md_op_data(NULL, src, dir, new_dentry->d_name.name,
+                                     new_dentry->d_name.len,
+                                     0, LUSTRE_OPC_ANY, NULL);
+        if (IS_ERR(op_data))
+                return PTR_ERR(op_data);
+
+        err = md_link(sbi->ll_md_exp, op_data, &request);
+        ll_finish_md_op_data(op_data);
+        if (err)
+                goto out;
+
+        ll_update_times(request, dir);
+        ll_stats_ops_tally(sbi, LPROC_LL_LINK, 1);
+out:
+        ptlrpc_req_finished(request);
+        return err;
 }
 
 static int ll_rename(struct inode *old_dir, struct dentry *old_dentry,
                      struct inode *new_dir, struct dentry *new_dentry)
 {
+        struct ptlrpc_request *request = NULL;
+        struct ll_sb_info *sbi = ll_i2sbi(old_dir);
+        struct md_op_data *op_data;
         int err;
-        err = ll_rename_generic(old_dir, NULL,
-                                 old_dentry, &old_dentry->d_name,
-                                 new_dir, NULL, new_dentry,
-                                 &new_dentry->d_name);
+
+        CDEBUG(D_VFSTRACE,
+               "VFS Op:oldname=%pd,src_dir=%lu/%u(%p),newname=%pd,"
+               "tgt_dir=%lu/%u(%p)\n", old_dentry,
+               old_dir->i_ino, old_dir->i_generation, old_dir, new_dentry,
+               new_dir->i_ino, new_dir->i_generation, new_dir);
+
+        op_data = ll_prep_md_op_data(NULL, old_dir, new_dir, NULL, 0, 0,
+                                     LUSTRE_OPC_ANY, NULL);
+        if (IS_ERR(op_data))
+                return PTR_ERR(op_data);
+
+        ll_get_child_fid(old_dentry, &op_data->op_fid3);
+        ll_get_child_fid(new_dentry, &op_data->op_fid4);
+        err = md_rename(sbi->ll_md_exp, op_data,
+                        old_dentry->d_name.name,
+                        old_dentry->d_name.len,
+                        new_dentry->d_name.name,
+                        new_dentry->d_name.len, &request);
+        ll_finish_md_op_data(op_data);
         if (!err) {
-                        d_move(old_dentry, new_dentry);
+                ll_update_times(request, old_dir);
+                ll_update_times(request, new_dir);
+                ll_stats_ops_tally(sbi, LPROC_LL_RENAME, 1);
+                err = ll_objects_destroy(request, old_dir);
         }
+
+        ptlrpc_req_finished(request);
+        if (!err)
+                d_move(old_dentry, new_dentry);
         return err;
 }
 
diff --git a/drivers/staging/lustre/lustre/llite/statahead.c b/drivers/staging/lustre/lustre/llite/statahead.c
index 06b71bcf97a7..09d965e76842 100644
--- a/drivers/staging/lustre/lustre/llite/statahead.c
+++ b/drivers/staging/lustre/lustre/llite/statahead.c
@@ -969,8 +969,8 @@ static int ll_agl_thread(void *arg)
         struct l_wait_info      lwi    = { 0 };
 
         thread->t_pid = current_pid();
-        CDEBUG(D_READA, "agl thread started: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "agl thread started: sai %p, parent %pd\n",
+               sai, parent);
 
         atomic_inc(&sbi->ll_agl_total);
         spin_lock(&plli->lli_agl_lock);
@@ -1019,8 +1019,8 @@ static int ll_agl_thread(void *arg)
         spin_unlock(&plli->lli_agl_lock);
         wake_up(&thread->t_ctl_waitq);
         ll_sai_put(sai);
-        CDEBUG(D_READA, "agl thread stopped: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "agl thread stopped: sai %p, parent %pd\n",
+               sai, parent);
         return 0;
 }
 
@@ -1031,8 +1031,8 @@ static void ll_start_agl(struct dentry *parent, struct ll_statahead_info *sai)
         struct ll_inode_info  *plli;
         struct task_struct *task;
 
-        CDEBUG(D_READA, "start agl thread: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "start agl thread: sai %p, parent %pd\n",
+               sai, parent);
 
         plli = ll_i2info(parent->d_inode);
         task = kthread_run(ll_agl_thread, parent,
@@ -1066,8 +1066,8 @@ static int ll_statahead_thread(void *arg)
         struct l_wait_info      lwi    = { 0 };
 
         thread->t_pid = current_pid();
-        CDEBUG(D_READA, "statahead thread starting: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "statahead thread starting: sai %p, parent %pd\n",
+               sai, parent);
 
         if (sbi->ll_flags & LL_SBI_AGL_ENABLED)
                 ll_start_agl(parent, sai);
@@ -1288,8 +1288,8 @@ out:
         wake_up(&thread->t_ctl_waitq);
         ll_sai_put(sai);
         dput(parent);
-        CDEBUG(D_READA, "statahead thread stopped: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "statahead thread stopped: sai %p, parent %pd\n",
+               sai, parent);
         return rc;
 }
 
@@ -1612,10 +1612,9 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                                 } else if ((*dentryp)->d_inode != inode) {
                                         /* revalidate, but inode is recreated */
                                         CDEBUG(D_READA,
-                                              "stale dentry %.*s inode %lu/%u, "
+                                              "stale dentry %pd inode %lu/%u, "
                                               "statahead inode %lu/%u\n",
-                                              (*dentryp)->d_name.len,
-                                              (*dentryp)->d_name.name,
+                                              *dentryp,
                                               (*dentryp)->d_inode->i_ino,
                                               (*dentryp)->d_inode->i_generation,
                                               inode->i_ino,
@@ -1666,9 +1665,9 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
         if (unlikely(sai->sai_inode != parent->d_inode)) {
                 struct ll_inode_info *nlli = ll_i2info(parent->d_inode);
 
-                CWARN("Race condition, someone changed %.*s just now: "
+                CWARN("Race condition, someone changed %pd just now: "
                       "old parent "DFID", new parent "DFID"\n",
-                      (*dentryp)->d_name.len, (*dentryp)->d_name.name,
+                      *dentryp,
                       PFID(&lli->lli_fid), PFID(&nlli->lli_fid));
                 dput(parent);
                 iput(sai->sai_inode);
@@ -1676,8 +1675,8 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                 goto out;
         }
 
-        CDEBUG(D_READA, "start statahead thread: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "start statahead thread: sai %p, parent %pd\n",
+               sai, parent);
 
         /* The sai buffer already has one reference taken at allocation time,
          * but as soon as we expose the sai by attaching it to the lli that
diff --git a/drivers/staging/lustre/lustre/llite/vvp_io.c b/drivers/staging/lustre/lustre/llite/vvp_io.c
index d3f967a78138..e540a6d286f8 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_io.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_io.c
@@ -108,7 +108,7 @@ static int vvp_io_fault_iter_init(const struct lu_env *env,
         struct inode  *inode = ccc_object_inode(ios->cis_obj);
 
         LASSERT(inode ==
-                cl2ccc_io(env, ios)->cui_fd->fd_file->f_dentry->d_inode);
+                file_inode(cl2ccc_io(env, ios)->cui_fd->fd_file));
         vio->u.fault.ft_mtime = LTIME_S(inode->i_mtime);
         return 0;
 }
@@ -239,7 +239,7 @@ static int vvp_mmap_locks(const struct lu_env *env,
 
                 down_read(&mm->mmap_sem);
                 while ((vma = our_vma(mm, addr, count)) != NULL) {
-                        struct inode *inode = vma->vm_file->f_dentry->d_inode;
+                        struct inode *inode = file_inode(vma->vm_file);
                         int flags = CEF_MUST;
 
                         if (ll_file_nolock(vma->vm_file)) {
diff --git a/drivers/staging/lustre/lustre/llite/xattr.c b/drivers/staging/lustre/lustre/llite/xattr.c
index 252a6194ed9b..3151baf5585c 100644
--- a/drivers/staging/lustre/lustre/llite/xattr.c
+++ b/drivers/staging/lustre/lustre/llite/xattr.c
@@ -241,14 +241,11 @@ int ll_setxattr(struct dentry *dentry, const char *name,
                         lump->lmm_stripe_offset = -1;
 
                 if (lump != NULL && S_ISREG(inode->i_mode)) {
-                        struct file f;
                         int flags = FMODE_WRITE;
                         int lum_size = (lump->lmm_magic == LOV_USER_MAGIC_V1) ?
                                 sizeof(*lump) : sizeof(struct lov_user_md_v3);
 
-                        memset(&f, 0, sizeof(f)); /* f.f_flags is used below */
-                        f.f_dentry = dentry;
-                        rc = ll_lov_setstripe_ea_info(inode, &f, flags, lump,
+                        rc = ll_lov_setstripe_ea_info(inode, dentry, flags, lump,
                                                       lum_size);
                         /* b10667: rc always be 0 here for now */
                         rc = 0;
@@ -519,8 +516,8 @@ ssize_t ll_getxattr(struct dentry *dentry, const char *name,
                 }
 
                 if (size < lmmsize) {
-                        CERROR("server bug: replied size %d > %d for %s (%s)\n",
-                               lmmsize, (int)size, dentry->d_name.name, name);
+                        CERROR("server bug: replied size %d > %d for %pd (%s)\n",
+                               lmmsize, (int)size, dentry, name);
                         rc = -ERANGE;
                         goto out;
                 }
diff --git a/drivers/staging/media/Kconfig b/drivers/staging/media/Kconfig
index 655cf5037b0b..96498b7fc20e 100644
--- a/drivers/staging/media/Kconfig
+++ b/drivers/staging/media/Kconfig
@@ -27,7 +27,9 @@ source "drivers/staging/media/davinci_vpfe/Kconfig"
 
 source "drivers/staging/media/dt3155v4l/Kconfig"
 
-source "drivers/staging/media/omap24xx/Kconfig"
+source "drivers/staging/media/mn88472/Kconfig"
+
+source "drivers/staging/media/mn88473/Kconfig"
 
 source "drivers/staging/media/omap4iss/Kconfig"
 
diff --git a/drivers/staging/media/Makefile b/drivers/staging/media/Makefile
index 6dbe578178cd..30fb352fc4a9 100644
--- a/drivers/staging/media/Makefile
+++ b/drivers/staging/media/Makefile
@@ -4,6 +4,6 @@ obj-$(CONFIG_LIRC_STAGING)	+= lirc/
 obj-$(CONFIG_VIDEO_DT3155)      += dt3155v4l/
 obj-$(CONFIG_VIDEO_DM365_VPFE)  += davinci_vpfe/
 obj-$(CONFIG_VIDEO_OMAP4)       += omap4iss/
-obj-$(CONFIG_VIDEO_OMAP2)       += omap24xx/
-obj-$(CONFIG_VIDEO_TCM825X)     += omap24xx/
+obj-$(CONFIG_DVB_MN88472)       += mn88472/
+obj-$(CONFIG_DVB_MN88473)       += mn88473/
 
diff --git a/drivers/staging/media/bcm2048/radio-bcm2048.c b/drivers/staging/media/bcm2048/radio-bcm2048.c
index 2bba370a47ca..60a57b2a8fb2 100644
--- a/drivers/staging/media/bcm2048/radio-bcm2048.c
+++ b/drivers/staging/media/bcm2048/radio-bcm2048.c
@@ -2327,9 +2327,10 @@ static int bcm2048_vidioc_querycap(struct file *file, void *priv,
         strlcpy(capability->card, BCM2048_DRIVER_CARD,
                 sizeof(capability->card));
         snprintf(capability->bus_info, 32, "I2C: 0x%X", bdev->client->addr);
-        capability->version = BCM2048_DRIVER_VERSION;
-        capability->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO |
+        capability->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO |
                                         V4L2_CAP_HW_FREQ_SEEK;
+        capability->capabilities = capability->device_caps |
+                V4L2_CAP_DEVICE_CAPS;
 
         return 0;
 }
@@ -2707,7 +2708,7 @@ static int __exit bcm2048_i2c_driver_remove(struct i2c_client *client)
  *      bcm2048_i2c_driver - i2c driver interface
  */
 static const struct i2c_device_id bcm2048_id[] = {
-        { "bcm2048" , 0 },
+        { "bcm2048", 0 },
         { },
 };
 MODULE_DEVICE_TABLE(i2c, bcm2048_id);
diff --git a/drivers/staging/media/davinci_vpfe/dm365_ipipe.c b/drivers/staging/media/davinci_vpfe/dm365_ipipe.c
index bdc7f005b3ba..704fa202ee18 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_ipipe.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_ipipe.c
@@ -37,15 +37,15 @@
 
 /* ipipe input format's */
 static const unsigned int ipipe_input_fmts[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_SGRBG12_1X12,
-        V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_SGRBG12_1X12,
+        MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8,
 };
 
 /* ipipe output format's */
 static const unsigned int ipipe_output_fmts[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
 };
 
 static int ipipe_validate_lutdpc_params(struct vpfe_ipipe_lutdpc *lutdpc)
@@ -1457,7 +1457,7 @@ ipipe_try_format(struct vpfe_ipipe_device *ipipe,
 
                 /* If not found, use SBGGR10 as default */
                 if (i >= ARRAY_SIZE(ipipe_input_fmts))
-                        fmt->code = V4L2_MBUS_FMT_SGRBG12_1X12;
+                        fmt->code = MEDIA_BUS_FMT_SGRBG12_1X12;
         } else if (pad == IPIPE_PAD_SOURCE) {
                 for (i = 0; i < ARRAY_SIZE(ipipe_output_fmts); i++)
                         if (fmt->code == ipipe_output_fmts[i])
@@ -1465,7 +1465,7 @@ ipipe_try_format(struct vpfe_ipipe_device *ipipe,
 
                 /* If not found, use UYVY as default */
                 if (i >= ARRAY_SIZE(ipipe_output_fmts))
-                        fmt->code = V4L2_MBUS_FMT_UYVY8_2X8;
+                        fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
         }
 
         fmt->width = clamp_t(u32, fmt->width, MIN_OUT_HEIGHT, max_out_width);
@@ -1642,7 +1642,7 @@ ipipe_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = IPIPE_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
+        format.format.code = MEDIA_BUS_FMT_SGRBG12_1X12;
         format.format.width = IPIPE_MAX_OUTPUT_WIDTH_A;
         format.format.height = IPIPE_MAX_OUTPUT_HEIGHT_A;
         ipipe_set_format(sd, fh, &format);
@@ -1650,7 +1650,7 @@ ipipe_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = IPIPE_PAD_SOURCE;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_UYVY8_2X8;
+        format.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
         format.format.width = IPIPE_MAX_OUTPUT_WIDTH_A;
         format.format.height = IPIPE_MAX_OUTPUT_HEIGHT_A;
         ipipe_set_format(sd, fh, &format);
diff --git a/drivers/staging/media/davinci_vpfe/dm365_ipipe_hw.c b/drivers/staging/media/davinci_vpfe/dm365_ipipe_hw.c
index b2daf5e63f88..6461de1a61fd 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_ipipe_hw.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_ipipe_hw.c
@@ -196,12 +196,12 @@ ipipe_setup_resizer(void *__iomem rsz_base, struct resizer_params *params)
                 rsz_set_rsz_regs(rsz_base, RSZ_B, params);
 }
 
-static u32 ipipe_get_color_pat(enum v4l2_mbus_pixelcode pix)
+static u32 ipipe_get_color_pat(u32 pix)
 {
         switch (pix) {
-        case V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8:
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
+        case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
                 return ipipe_sgrbg_pattern;
 
         default:
@@ -211,23 +211,23 @@ static u32 ipipe_get_color_pat(enum v4l2_mbus_pixelcode pix)
 
 static int ipipe_get_data_path(struct vpfe_ipipe_device *ipipe)
 {
-        enum v4l2_mbus_pixelcode temp_pix_fmt;
+        u32 temp_pix_fmt;
 
         switch (ipipe->formats[IPIPE_PAD_SINK].code) {
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
-        case V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8:
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
-                temp_pix_fmt = V4L2_MBUS_FMT_SGRBG12_1X12;
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
+                temp_pix_fmt = MEDIA_BUS_FMT_SGRBG12_1X12;
                 break;
 
         default:
-                temp_pix_fmt = V4L2_MBUS_FMT_UYVY8_2X8;
+                temp_pix_fmt = MEDIA_BUS_FMT_UYVY8_2X8;
         }
 
-        if (temp_pix_fmt == V4L2_MBUS_FMT_SGRBG12_1X12) {
+        if (temp_pix_fmt == MEDIA_BUS_FMT_SGRBG12_1X12) {
                 if (ipipe->formats[IPIPE_PAD_SOURCE].code ==
-                        V4L2_MBUS_FMT_SGRBG12_1X12)
+                        MEDIA_BUS_FMT_SGRBG12_1X12)
                         return IPIPE_RAW2RAW;
                 return IPIPE_RAW2YUV;
         }
diff --git a/drivers/staging/media/davinci_vpfe/dm365_ipipeif.c b/drivers/staging/media/davinci_vpfe/dm365_ipipeif.c
index 6d4893b44c1f..a86f16ff5818 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_ipipeif.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_ipipeif.c
@@ -23,42 +23,42 @@
 #include "vpfe_mc_capture.h"
 
 static const unsigned int ipipeif_input_fmts[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_SGRBG12_1X12,
-        V4L2_MBUS_FMT_Y8_1X8,
-        V4L2_MBUS_FMT_UV8_1X8,
-        V4L2_MBUS_FMT_YDYUYDYV8_1X16,
-        V4L2_MBUS_FMT_SBGGR8_1X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_SGRBG12_1X12,
+        MEDIA_BUS_FMT_Y8_1X8,
+        MEDIA_BUS_FMT_UV8_1X8,
+        MEDIA_BUS_FMT_YDYUYDYV8_1X16,
+        MEDIA_BUS_FMT_SBGGR8_1X8,
 };
 
 static const unsigned int ipipeif_output_fmts[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_SGRBG12_1X12,
-        V4L2_MBUS_FMT_Y8_1X8,
-        V4L2_MBUS_FMT_UV8_1X8,
-        V4L2_MBUS_FMT_YDYUYDYV8_1X16,
-        V4L2_MBUS_FMT_SBGGR8_1X8,
-        V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_SGRBG12_1X12,
+        MEDIA_BUS_FMT_Y8_1X8,
+        MEDIA_BUS_FMT_UV8_1X8,
+        MEDIA_BUS_FMT_YDYUYDYV8_1X16,
+        MEDIA_BUS_FMT_SBGGR8_1X8,
+        MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8,
 };
 
 static int
-ipipeif_get_pack_mode(enum v4l2_mbus_pixelcode in_pix_fmt)
+ipipeif_get_pack_mode(u32 in_pix_fmt)
 {
         switch (in_pix_fmt) {
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
-        case V4L2_MBUS_FMT_Y8_1X8:
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_UV8_1X8:
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_UV8_1X8:
                 return IPIPEIF_5_1_PACK_8_BIT;
 
-        case V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8:
                 return IPIPEIF_5_1_PACK_8_BIT_A_LAW;
 
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
                 return IPIPEIF_5_1_PACK_16_BIT;
 
-        case V4L2_MBUS_FMT_SBGGR12_1X12:
+        case MEDIA_BUS_FMT_SBGGR12_1X12:
                 return IPIPEIF_5_1_PACK_12_BIT;
 
         default:
@@ -107,8 +107,8 @@ ipipeif_get_cfg_src1(struct vpfe_ipipeif_device *ipipeif)
 
         informat = &ipipeif->formats[IPIPEIF_PAD_SINK];
         if (ipipeif->input == IPIPEIF_INPUT_MEMORY &&
-           (informat->code == V4L2_MBUS_FMT_Y8_1X8 ||
-            informat->code == V4L2_MBUS_FMT_UV8_1X8))
+           (informat->code == MEDIA_BUS_FMT_Y8_1X8 ||
+            informat->code == MEDIA_BUS_FMT_UV8_1X8))
                 return IPIPEIF_CCDC;
 
         return IPIPEIF_SRC1_PARALLEL_PORT;
@@ -122,11 +122,11 @@ ipipeif_get_data_shift(struct vpfe_ipipeif_device *ipipeif)
         informat = &ipipeif->formats[IPIPEIF_PAD_SINK];
 
         switch (informat->code) {
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
                 return IPIPEIF_5_1_BITS11_0;
 
-        case V4L2_MBUS_FMT_Y8_1X8:
-        case V4L2_MBUS_FMT_UV8_1X8:
+        case MEDIA_BUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_UV8_1X8:
                 return IPIPEIF_5_1_BITS11_0;
 
         default:
@@ -143,7 +143,7 @@ ipipeif_get_source(struct vpfe_ipipeif_device *ipipeif)
         if (ipipeif->input == IPIPEIF_INPUT_ISIF)
                 return IPIPEIF_CCDC;
 
-        if (informat->code == V4L2_MBUS_FMT_UYVY8_2X8)
+        if (informat->code == MEDIA_BUS_FMT_UYVY8_2X8)
                 return IPIPEIF_SDRAM_YUV;
 
         return IPIPEIF_SDRAM_RAW;
@@ -190,7 +190,7 @@ static int ipipeif_hw_setup(struct v4l2_subdev *sd)
         struct v4l2_mbus_framefmt *informat, *outformat;
         struct ipipeif_params params = ipipeif->config;
         enum ipipeif_input_source ipipeif_source;
-        enum v4l2_mbus_pixelcode isif_port_if;
+        u32 isif_port_if;
         void *ipipeif_base_addr;
         unsigned int val;
         int data_shift;
@@ -268,16 +268,16 @@ static int ipipeif_hw_setup(struct v4l2_subdev *sd)
         ipipeif_write(val, ipipeif_base_addr, IPIPEIF_INIRSZ);
         isif_port_if = informat->code;
 
-        if (isif_port_if == V4L2_MBUS_FMT_Y8_1X8)
-                isif_port_if = V4L2_MBUS_FMT_YUYV8_1X16;
-        else if (isif_port_if == V4L2_MBUS_FMT_UV8_1X8)
-                isif_port_if = V4L2_MBUS_FMT_SGRBG12_1X12;
+        if (isif_port_if == MEDIA_BUS_FMT_Y8_1X8)
+                isif_port_if = MEDIA_BUS_FMT_YUYV8_1X16;
+        else if (isif_port_if == MEDIA_BUS_FMT_UV8_1X8)
+                isif_port_if = MEDIA_BUS_FMT_SGRBG12_1X12;
 
         /* Enable DPCM decompression */
         switch (ipipeif_source) {
         case IPIPEIF_SDRAM_RAW:
                 val = 0;
-                if (outformat->code == V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8) {
+                if (outformat->code == MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8) {
                         val = 1;
                         val |= (IPIPEIF_DPCM_8BIT_10BIT & 1) <<
                                 IPIPEIF_DPCM_BITS_SHIFT;
@@ -296,9 +296,9 @@ static int ipipeif_hw_setup(struct v4l2_subdev *sd)
                 /* configure CFG2 */
                 val = ipipeif_read(ipipeif_base_addr, IPIPEIF_CFG2);
                 switch (isif_port_if) {
-                case V4L2_MBUS_FMT_YUYV8_1X16:
-                case V4L2_MBUS_FMT_UYVY8_2X8:
-                case V4L2_MBUS_FMT_Y8_1X8:
+                case MEDIA_BUS_FMT_YUYV8_1X16:
+                case MEDIA_BUS_FMT_UYVY8_2X8:
+                case MEDIA_BUS_FMT_Y8_1X8:
                         RESETBIT(val, IPIPEIF_CFG2_YUV8_SHIFT);
                         SETBIT(val, IPIPEIF_CFG2_YUV16_SHIFT);
                         ipipeif_write(val, ipipeif_base_addr, IPIPEIF_CFG2);
@@ -344,16 +344,16 @@ static int ipipeif_hw_setup(struct v4l2_subdev *sd)
                 val |= VPFE_PINPOL_POSITIVE << IPIPEIF_CFG2_VDPOL_SHIFT;
 
                 switch (isif_port_if) {
-                case V4L2_MBUS_FMT_YUYV8_1X16:
-                case V4L2_MBUS_FMT_YUYV10_1X20:
+                case MEDIA_BUS_FMT_YUYV8_1X16:
+                case MEDIA_BUS_FMT_YUYV10_1X20:
                         RESETBIT(val, IPIPEIF_CFG2_YUV8_SHIFT);
                         SETBIT(val, IPIPEIF_CFG2_YUV16_SHIFT);
                         break;
 
-                case V4L2_MBUS_FMT_YUYV8_2X8:
-                case V4L2_MBUS_FMT_UYVY8_2X8:
-                case V4L2_MBUS_FMT_Y8_1X8:
-                case V4L2_MBUS_FMT_YUYV10_2X10:
+                case MEDIA_BUS_FMT_YUYV8_2X8:
+                case MEDIA_BUS_FMT_UYVY8_2X8:
+                case MEDIA_BUS_FMT_Y8_1X8:
+                case MEDIA_BUS_FMT_YUYV10_2X10:
                         SETBIT(val, IPIPEIF_CFG2_YUV8_SHIFT);
                         SETBIT(val, IPIPEIF_CFG2_YUV16_SHIFT);
                         val |= IPIPEIF_CBCR_Y << IPIPEIF_CFG2_YUV8P_SHIFT;
@@ -625,7 +625,7 @@ ipipeif_try_format(struct vpfe_ipipeif_device *ipipeif,
 
                 /* If not found, use SBGGR10 as default */
                 if (i >= ARRAY_SIZE(ipipeif_input_fmts))
-                        fmt->code = V4L2_MBUS_FMT_SGRBG12_1X12;
+                        fmt->code = MEDIA_BUS_FMT_SGRBG12_1X12;
         } else if (pad == IPIPEIF_PAD_SOURCE) {
                 for (i = 0; i < ARRAY_SIZE(ipipeif_output_fmts); i++)
                         if (fmt->code == ipipeif_output_fmts[i])
@@ -633,7 +633,7 @@ ipipeif_try_format(struct vpfe_ipipeif_device *ipipeif,
 
                 /* If not found, use UYVY as default */
                 if (i >= ARRAY_SIZE(ipipeif_output_fmts))
-                        fmt->code = V4L2_MBUS_FMT_UYVY8_2X8;
+                        fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
         }
 
         fmt->width = clamp_t(u32, fmt->width, MIN_OUT_HEIGHT, max_out_width);
@@ -770,7 +770,7 @@ ipipeif_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = IPIPEIF_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
+        format.format.code = MEDIA_BUS_FMT_SGRBG12_1X12;
         format.format.width = IPIPE_MAX_OUTPUT_WIDTH_A;
         format.format.height = IPIPE_MAX_OUTPUT_HEIGHT_A;
         ipipeif_set_format(sd, fh, &format);
@@ -778,7 +778,7 @@ ipipeif_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = IPIPEIF_PAD_SOURCE;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_UYVY8_2X8;
+        format.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
         format.format.width = IPIPE_MAX_OUTPUT_WIDTH_A;
         format.format.height = IPIPE_MAX_OUTPUT_HEIGHT_A;
         ipipeif_set_format(sd, fh, &format);
@@ -805,9 +805,9 @@ ipipeif_video_in_queue(struct vpfe_device *vpfe_dev, unsigned long addr)
                 return -EINVAL;
 
         switch (ipipeif->formats[IPIPEIF_PAD_SINK].code) {
-        case V4L2_MBUS_FMT_Y8_1X8:
-        case V4L2_MBUS_FMT_UV8_1X8:
-        case V4L2_MBUS_FMT_YDYUYDYV8_1X16:
+        case MEDIA_BUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_UV8_1X8:
+        case MEDIA_BUS_FMT_YDYUYDYV8_1X16:
                 adofs = ipipeif->formats[IPIPEIF_PAD_SINK].width;
                 break;
 
diff --git a/drivers/staging/media/davinci_vpfe/dm365_isif.c b/drivers/staging/media/davinci_vpfe/dm365_isif.c
index 0d535b062e4e..fa26f63831b7 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_isif.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_isif.c
@@ -27,13 +27,13 @@
 #define MAX_HEIGHT      4096
 
 static const unsigned int isif_fmts[] = {
-        V4L2_MBUS_FMT_YUYV8_2X8,
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_YUYV8_1X16,
-        V4L2_MBUS_FMT_YUYV10_1X20,
-        V4L2_MBUS_FMT_SGRBG12_1X12,
-        V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8,
-        V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
+        MEDIA_BUS_FMT_YUYV8_2X8,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_YUYV8_1X16,
+        MEDIA_BUS_FMT_YUYV10_1X20,
+        MEDIA_BUS_FMT_SGRBG12_1X12,
+        MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8,
+        MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
 };
 
 #define ISIF_COLPTN_R_Ye        0x0
@@ -154,7 +154,7 @@ enum v4l2_field vpfe_isif_get_fid(struct vpfe_device *vpfe_dev)
 static int
 isif_set_pixel_format(struct vpfe_isif_device *isif, unsigned int pixfmt)
 {
-        if (isif->formats[ISIF_PAD_SINK].code == V4L2_MBUS_FMT_SGRBG12_1X12) {
+        if (isif->formats[ISIF_PAD_SINK].code == MEDIA_BUS_FMT_SGRBG12_1X12) {
                 if (pixfmt == V4L2_PIX_FMT_SBGGR16)
                         isif->isif_cfg.data_pack = ISIF_PACK_16BIT;
                 else if ((pixfmt == V4L2_PIX_FMT_SGRBG10DPCM8) ||
@@ -184,7 +184,7 @@ static int
 isif_set_frame_format(struct vpfe_isif_device *isif,
                       enum isif_frmfmt frm_fmt)
 {
-        if (isif->formats[ISIF_PAD_SINK].code == V4L2_MBUS_FMT_SGRBG12_1X12)
+        if (isif->formats[ISIF_PAD_SINK].code == MEDIA_BUS_FMT_SGRBG12_1X12)
                 isif->isif_cfg.bayer.frm_fmt = frm_fmt;
         else
                 isif->isif_cfg.ycbcr.frm_fmt = frm_fmt;
@@ -196,7 +196,7 @@ static int isif_set_image_window(struct vpfe_isif_device *isif)
 {
         struct v4l2_rect *win = &isif->crop;
 
-        if (isif->formats[ISIF_PAD_SINK].code == V4L2_MBUS_FMT_SGRBG12_1X12) {
+        if (isif->formats[ISIF_PAD_SINK].code == MEDIA_BUS_FMT_SGRBG12_1X12) {
                 isif->isif_cfg.bayer.win.top = win->top;
                 isif->isif_cfg.bayer.win.left = win->left;
                 isif->isif_cfg.bayer.win.width = win->width;
@@ -214,7 +214,7 @@ static int isif_set_image_window(struct vpfe_isif_device *isif)
 static int
 isif_set_buftype(struct vpfe_isif_device *isif, enum isif_buftype buf_type)
 {
-        if (isif->formats[ISIF_PAD_SINK].code == V4L2_MBUS_FMT_SGRBG12_1X12)
+        if (isif->formats[ISIF_PAD_SINK].code == MEDIA_BUS_FMT_SGRBG12_1X12)
                 isif->isif_cfg.bayer.buf_type = buf_type;
         else
                 isif->isif_cfg.ycbcr.buf_type = buf_type;
@@ -296,7 +296,7 @@ isif_try_format(struct vpfe_isif_device *isif, struct v4l2_subdev_fh *fh,
 
         /* If not found, use YUYV8_2x8 as default */
         if (i >= ARRAY_SIZE(isif_fmts))
-                fmt->format.code = V4L2_MBUS_FMT_YUYV8_2X8;
+                fmt->format.code = MEDIA_BUS_FMT_YUYV8_2X8;
 
         /* Clamp the size. */
         fmt->format.width = clamp_t(u32, width, 32, MAX_WIDTH);
@@ -429,7 +429,7 @@ static int isif_get_params(struct v4l2_subdev *sd, void *params)
         struct vpfe_isif_device *isif = v4l2_get_subdevdata(sd);
 
         /* only raw module parameters can be set through the IOCTL */
-        if (isif->formats[ISIF_PAD_SINK].code != V4L2_MBUS_FMT_SGRBG12_1X12)
+        if (isif->formats[ISIF_PAD_SINK].code != MEDIA_BUS_FMT_SGRBG12_1X12)
                 return -EINVAL;
         memcpy(params, &isif->isif_cfg.bayer.config_params,
                         sizeof(isif->isif_cfg.bayer.config_params));
@@ -604,7 +604,7 @@ static int isif_set_params(struct v4l2_subdev *sd, void *params)
         int ret = -EINVAL;
 
         /* only raw module parameters can be set through the IOCTL */
-        if (isif->formats[ISIF_PAD_SINK].code != V4L2_MBUS_FMT_SGRBG12_1X12)
+        if (isif->formats[ISIF_PAD_SINK].code != MEDIA_BUS_FMT_SGRBG12_1X12)
                 return ret;
 
         memcpy(&isif_raw_params, params, sizeof(isif_raw_params));
@@ -1041,19 +1041,19 @@ isif_config_culling(struct vpfe_isif_device *isif, struct vpfe_isif_cul *cul)
 static int isif_get_pix_fmt(u32 mbus_code)
 {
         switch (mbus_code) {
-        case V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8:
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
+        case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
                 return ISIF_PIXFMT_RAW;
 
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
-        case V4L2_MBUS_FMT_YUYV10_2X10:
-        case V4L2_MBUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_YUYV10_2X10:
+        case MEDIA_BUS_FMT_Y8_1X8:
                 return ISIF_PIXFMT_YCBCR_8BIT;
 
-        case V4L2_MBUS_FMT_YUYV8_1X16:
-        case V4L2_MBUS_FMT_YUYV10_1X20:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_YUYV10_1X20:
                 return ISIF_PIXFMT_YCBCR_16BIT;
 
         default:
@@ -1121,11 +1121,11 @@ static int isif_config_raw(struct v4l2_subdev *sd, int mode)
               ISIF_FRM_FMT_MASK) << ISIF_FRM_FMT_SHIFT) | ((pix_fmt &
               ISIF_INPUT_MASK) << ISIF_INPUT_SHIFT);
 
-        /* currently only V4L2_MBUS_FMT_SGRBG12_1X12 is
+        /* currently only MEDIA_BUS_FMT_SGRBG12_1X12 is
          * supported. shift appropriately depending on
          * different MBUS fmt's added
          */
-        if (format->code == V4L2_MBUS_FMT_SGRBG12_1X12)
+        if (format->code == MEDIA_BUS_FMT_SGRBG12_1X12)
                 val |= ((VPFE_ISIF_NO_SHIFT &
                         ISIF_DATASFT_MASK) << ISIF_DATASFT_SHIFT);
 
@@ -1154,7 +1154,7 @@ static int isif_config_raw(struct v4l2_subdev *sd, int mode)
         /* Configure Gain & Offset */
         isif_config_gain_offset(isif);
         /* Configure Color pattern */
-        if (format->code == V4L2_MBUS_FMT_SGRBG12_1X12)
+        if (format->code == MEDIA_BUS_FMT_SGRBG12_1X12)
                 val = isif_sgrbg_pattern;
         else
                 /* default set to rggb */
@@ -1254,8 +1254,8 @@ static int isif_config_ycbcr(struct v4l2_subdev *sd, int mode)
                   (((params->vd_pol & ISIF_VD_POL_MASK) << ISIF_VD_POL_SHIFT));
         /* pack the data to 8-bit CCDCCFG */
         switch (format->code) {
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 if (pix_fmt != ISIF_PIXFMT_YCBCR_8BIT) {
                         pr_debug("Invalid pix_fmt(input mode)\n");
                         return -EINVAL;
@@ -1266,7 +1266,7 @@ static int isif_config_ycbcr(struct v4l2_subdev *sd, int mode)
                 ccdcfg = ccdcfg | ISIF_PACK_8BIT | ISIF_YCINSWP_YCBCR;
                 break;
 
-        case V4L2_MBUS_FMT_YUYV10_2X10:
+        case MEDIA_BUS_FMT_YUYV10_2X10:
                 if (pix_fmt != ISIF_PIXFMT_YCBCR_8BIT) {
                         pr_debug("Invalid pix_fmt(input mode)\n");
                         return -EINVAL;
@@ -1278,7 +1278,7 @@ static int isif_config_ycbcr(struct v4l2_subdev *sd, int mode)
                         ISIF_BW656_ENABLE;
                 break;
 
-        case V4L2_MBUS_FMT_YUYV10_1X20:
+        case MEDIA_BUS_FMT_YUYV10_1X20:
                 if (pix_fmt != ISIF_PIXFMT_YCBCR_16BIT) {
                         pr_debug("Invalid pix_fmt(input mode)\n");
                         return -EINVAL;
@@ -1286,7 +1286,7 @@ static int isif_config_ycbcr(struct v4l2_subdev *sd, int mode)
                 isif_write(isif->isif_cfg.base_addr, 3, REC656IF);
                 break;
 
-        case V4L2_MBUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_Y8_1X8:
                 ccdcfg |= ISIF_PACK_8BIT;
                 ccdcfg |= ISIF_YCINSWP_YCBCR;
                 if (pix_fmt != ISIF_PIXFMT_YCBCR_8BIT) {
@@ -1295,7 +1295,7 @@ static int isif_config_ycbcr(struct v4l2_subdev *sd, int mode)
                 }
                 break;
 
-        case V4L2_MBUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
                 if (pix_fmt != ISIF_PIXFMT_YCBCR_16BIT) {
                         pr_debug("Invalid pix_fmt(input mode)\n");
                         return -EINVAL;
@@ -1313,8 +1313,8 @@ static int isif_config_ycbcr(struct v4l2_subdev *sd, int mode)
                 ISIF_PIX_ORDER_SHIFT;
         isif_write(isif->isif_cfg.base_addr, ccdcfg, CCDCFG);
         /* configure video window */
-        if (format->code == V4L2_MBUS_FMT_YUYV10_1X20 ||
-                        format->code == V4L2_MBUS_FMT_YUYV8_1X16)
+        if (format->code == MEDIA_BUS_FMT_YUYV10_1X20 ||
+                        format->code == MEDIA_BUS_FMT_YUYV8_1X16)
                 isif_setwin(isif, &params->win, params->frm_fmt, 1, mode);
         else
                 isif_setwin(isif, &params->win, params->frm_fmt, 2, mode);
@@ -1345,17 +1345,17 @@ static int isif_configure(struct v4l2_subdev *sd, int mode)
         format = &isif->formats[ISIF_PAD_SINK];
 
         switch (format->code) {
-        case V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8:
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
+        case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
                 return isif_config_raw(sd, mode);
 
-        case V4L2_MBUS_FMT_YUYV8_2X8:
-        case V4L2_MBUS_FMT_UYVY8_2X8:
-        case V4L2_MBUS_FMT_YUYV10_2X10:
-        case V4L2_MBUS_FMT_Y8_1X8:
-        case V4L2_MBUS_FMT_YUYV8_1X16:
-        case V4L2_MBUS_FMT_YUYV10_1X20:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_YUYV10_2X10:
+        case MEDIA_BUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_YUYV10_1X20:
                 return isif_config_ycbcr(sd, mode);
 
         default:
@@ -1630,7 +1630,7 @@ isif_init_formats(struct v4l2_subdev *sd,
         memset(&format, 0, sizeof(format));
         format.pad = ISIF_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
+        format.format.code = MEDIA_BUS_FMT_SGRBG12_1X12;
         format.format.width = MAX_WIDTH;
         format.format.height = MAX_HEIGHT;
         isif_set_format(sd, fh, &format);
@@ -1638,7 +1638,7 @@ isif_init_formats(struct v4l2_subdev *sd,
         memset(&format, 0, sizeof(format));
         format.pad = ISIF_PAD_SOURCE;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG12_1X12;
+        format.format.code = MEDIA_BUS_FMT_SGRBG12_1X12;
         format.format.width = MAX_WIDTH;
         format.format.height = MAX_HEIGHT;
         isif_set_format(sd, fh, &format);
diff --git a/drivers/staging/media/davinci_vpfe/dm365_resizer.c b/drivers/staging/media/davinci_vpfe/dm365_resizer.c
index 8828d6c2aab1..e0b29c8ca221 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_resizer.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_resizer.c
@@ -35,18 +35,18 @@
 #define MIN_OUT_HEIGHT          2
 
 static const unsigned int resizer_input_formats[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_Y8_1X8,
-        V4L2_MBUS_FMT_UV8_1X8,
-        V4L2_MBUS_FMT_SGRBG12_1X12,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_Y8_1X8,
+        MEDIA_BUS_FMT_UV8_1X8,
+        MEDIA_BUS_FMT_SGRBG12_1X12,
 };
 
 static const unsigned int resizer_output_formats[] = {
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_Y8_1X8,
-        V4L2_MBUS_FMT_UV8_1X8,
-        V4L2_MBUS_FMT_YDYUYDYV8_1X16,
-        V4L2_MBUS_FMT_SGRBG12_1X12,
+        MEDIA_BUS_FMT_UYVY8_2X8,
+        MEDIA_BUS_FMT_Y8_1X8,
+        MEDIA_BUS_FMT_UV8_1X8,
+        MEDIA_BUS_FMT_YDYUYDYV8_1X16,
+        MEDIA_BUS_FMT_SGRBG12_1X12,
 };
 
 /* resizer_calculate_line_length() - This function calculates the line length of
@@ -54,17 +54,17 @@ static const unsigned int resizer_output_formats[] = {
  *                                   output.
  */
 static void
-resizer_calculate_line_length(enum v4l2_mbus_pixelcode pix, int width,
-                      int height, int *line_len, int *line_len_c)
+resizer_calculate_line_length(u32 pix, int width, int height,
+                              int *line_len, int *line_len_c)
 {
         *line_len = 0;
         *line_len_c = 0;
 
-        if (pix == V4L2_MBUS_FMT_UYVY8_2X8 ||
-            pix == V4L2_MBUS_FMT_SGRBG12_1X12) {
+        if (pix == MEDIA_BUS_FMT_UYVY8_2X8 ||
+            pix == MEDIA_BUS_FMT_SGRBG12_1X12) {
                 *line_len = width << 1;
-        } else if (pix == V4L2_MBUS_FMT_Y8_1X8 ||
-                   pix == V4L2_MBUS_FMT_UV8_1X8) {
+        } else if (pix == MEDIA_BUS_FMT_Y8_1X8 ||
+                   pix == MEDIA_BUS_FMT_UV8_1X8) {
                 *line_len = width;
                 *line_len_c = width;
         } else {
@@ -85,11 +85,11 @@ resizer_validate_output_image_format(struct device *dev,
                                      struct v4l2_mbus_framefmt *format,
                                      int *in_line_len, int *in_line_len_c)
 {
-        if (format->code != V4L2_MBUS_FMT_UYVY8_2X8 &&
-            format->code != V4L2_MBUS_FMT_Y8_1X8 &&
-            format->code != V4L2_MBUS_FMT_UV8_1X8 &&
-            format->code != V4L2_MBUS_FMT_YDYUYDYV8_1X16 &&
-            format->code != V4L2_MBUS_FMT_SGRBG12_1X12) {
+        if (format->code != MEDIA_BUS_FMT_UYVY8_2X8 &&
+            format->code != MEDIA_BUS_FMT_Y8_1X8 &&
+            format->code != MEDIA_BUS_FMT_UV8_1X8 &&
+            format->code != MEDIA_BUS_FMT_YDYUYDYV8_1X16 &&
+            format->code != MEDIA_BUS_FMT_SGRBG12_1X12) {
                 dev_err(dev, "Invalid Mbus format, %d\n", format->code);
                 return -EINVAL;
         }
@@ -281,7 +281,7 @@ resizer_calculate_sdram_offsets(struct vpfe_resizer_device *resizer, int index)
         param->ext_mem_param[index].c_offset = 0;
         param->ext_mem_param[index].flip_ofst_y = 0;
         param->ext_mem_param[index].flip_ofst_c = 0;
-        if (outformat->code == V4L2_MBUS_FMT_YDYUYDYV8_1X16) {
+        if (outformat->code == MEDIA_BUS_FMT_YDYUYDYV8_1X16) {
                 /* YUV 420 */
                 yuv_420 = 1;
                 bytesperpixel = 1;
@@ -322,7 +322,7 @@ static int resizer_configure_output_win(struct vpfe_resizer_device *resizer)
         outformat = &resizer->resizer_a.formats[RESIZER_PAD_SOURCE];
 
         output_specs.vst_y = param->user_config.vst;
-        if (outformat->code == V4L2_MBUS_FMT_YDYUYDYV8_1X16)
+        if (outformat->code == MEDIA_BUS_FMT_YDYUYDYV8_1X16)
                 output_specs.vst_c = param->user_config.vst;
 
         configure_resizer_out_params(resizer, RSZ_A, &output_specs, 0, 0);
@@ -336,7 +336,7 @@ static int resizer_configure_output_win(struct vpfe_resizer_device *resizer)
         if (param->rsz_en[RSZ_B])
                 resizer_calculate_resize_ratios(resizer, RSZ_B);
 
-        if (outformat->code == V4L2_MBUS_FMT_YDYUYDYV8_1X16)
+        if (outformat->code == MEDIA_BUS_FMT_YDYUYDYV8_1X16)
                 resizer_enable_422_420_conversion(param, RSZ_A, ENABLE);
         else
                 resizer_enable_422_420_conversion(param, RSZ_A, DISABLE);
@@ -447,26 +447,26 @@ resizer_configure_common_in_params(struct vpfe_resizer_device *resizer)
                 param->rsz_common.source = IPIPE_DATA;
 
         switch (informat->code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 param->rsz_common.src_img_fmt = RSZ_IMG_422;
                 param->rsz_common.raw_flip = 0;
                 break;
 
-        case V4L2_MBUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_Y8_1X8:
                 param->rsz_common.src_img_fmt = RSZ_IMG_420;
                 /* Select y */
                 param->rsz_common.y_c = 0;
                 param->rsz_common.raw_flip = 0;
                 break;
 
-        case V4L2_MBUS_FMT_UV8_1X8:
+        case MEDIA_BUS_FMT_UV8_1X8:
                 param->rsz_common.src_img_fmt = RSZ_IMG_420;
                 /* Select y */
                 param->rsz_common.y_c = 1;
                 param->rsz_common.raw_flip = 0;
                 break;
 
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
                 param->rsz_common.raw_flip = 1;
                 break;
 
@@ -519,7 +519,7 @@ resizer_configure_in_continious_mode(struct vpfe_resizer_device *resizer)
                 param->ext_mem_param[RSZ_B].rsz_sdr_oft_c = line_len_c;
                 configure_resizer_out_params(resizer, RSZ_B,
                                                 &cont_config->output2, 0, 1);
-                if (outformat2->code == V4L2_MBUS_FMT_YDYUYDYV8_1X16)
+                if (outformat2->code == MEDIA_BUS_FMT_YDYUYDYV8_1X16)
                         resizer_enable_422_420_conversion(param,
                                                           RSZ_B, ENABLE);
                 else
@@ -540,15 +540,15 @@ resizer_configure_in_continious_mode(struct vpfe_resizer_device *resizer)
 
 static inline int
 resizer_validate_input_image_format(struct device *dev,
-                                    enum v4l2_mbus_pixelcode pix,
+                                    u32 pix,
                                     int width, int height, int *line_len)
 {
         int val;
 
-        if (pix != V4L2_MBUS_FMT_UYVY8_2X8 &&
-            pix != V4L2_MBUS_FMT_Y8_1X8 &&
-            pix != V4L2_MBUS_FMT_UV8_1X8 &&
-            pix != V4L2_MBUS_FMT_SGRBG12_1X12) {
+        if (pix != MEDIA_BUS_FMT_UYVY8_2X8 &&
+            pix != MEDIA_BUS_FMT_Y8_1X8 &&
+            pix != MEDIA_BUS_FMT_UV8_1X8 &&
+            pix != MEDIA_BUS_FMT_SGRBG12_1X12) {
                 dev_err(dev,
                 "resizer validate output: pix format not supported, %d\n", pix);
                 return -EINVAL;
@@ -560,7 +560,7 @@ resizer_validate_input_image_format(struct device *dev,
                 return -EINVAL;
         }
 
-        if (pix == V4L2_MBUS_FMT_UV8_1X8)
+        if (pix == MEDIA_BUS_FMT_UV8_1X8)
                 resizer_calculate_line_length(pix, width,
                                               height, &val, line_len);
         else
@@ -709,12 +709,12 @@ resizer_configure_in_single_shot_mode(struct vpfe_resizer_device *resizer)
                 configure_resizer_out_params(resizer, RSZ_A,
                                         &param->user_config.output1, 0, 1);
 
-                if (outformat1->code == V4L2_MBUS_FMT_SGRBG12_1X12)
+                if (outformat1->code == MEDIA_BUS_FMT_SGRBG12_1X12)
                         param->rsz_common.raw_flip = 1;
                 else
                         param->rsz_common.raw_flip = 0;
 
-                if (outformat1->code == V4L2_MBUS_FMT_YDYUYDYV8_1X16)
+                if (outformat1->code == MEDIA_BUS_FMT_YDYUYDYV8_1X16)
                         resizer_enable_422_420_conversion(param,
                                                           RSZ_A, ENABLE);
                 else
@@ -732,7 +732,7 @@ resizer_configure_in_single_shot_mode(struct vpfe_resizer_device *resizer)
                 param->ext_mem_param[RSZ_B].rsz_sdr_oft_c = line_len_c;
                 configure_resizer_out_params(resizer, RSZ_B,
                                         &param->user_config.output2, 0, 1);
-                if (outformat2->code == V4L2_MBUS_FMT_YDYUYDYV8_1X16)
+                if (outformat2->code == MEDIA_BUS_FMT_YDYUYDYV8_1X16)
                         resizer_enable_422_420_conversion(param,
                                                           RSZ_B, ENABLE);
                 else
@@ -745,7 +745,7 @@ resizer_configure_in_single_shot_mode(struct vpfe_resizer_device *resizer)
                 resizer_calculate_resize_ratios(resizer, RSZ_A);
                 resizer_calculate_sdram_offsets(resizer, RSZ_A);
                 /* Overriding resize ratio calculation */
-                if (informat->code == V4L2_MBUS_FMT_UV8_1X8) {
+                if (informat->code == MEDIA_BUS_FMT_UV8_1X8) {
                         param->rsz_rsc_param[RSZ_A].v_dif =
                                 (((informat->height + 1) * 2) * 256) /
                                 (param->rsz_rsc_param[RSZ_A].o_vsz + 1);
@@ -756,7 +756,7 @@ resizer_configure_in_single_shot_mode(struct vpfe_resizer_device *resizer)
                 resizer_calculate_resize_ratios(resizer, RSZ_B);
                 resizer_calculate_sdram_offsets(resizer, RSZ_B);
                 /* Overriding resize ratio calculation */
-                if (informat->code == V4L2_MBUS_FMT_UV8_1X8) {
+                if (informat->code == MEDIA_BUS_FMT_UV8_1X8) {
                         param->rsz_rsc_param[RSZ_B].v_dif =
                                 (((informat->height + 1) * 2) * 256) /
                                 (param->rsz_rsc_param[RSZ_B].o_vsz + 1);
@@ -1340,7 +1340,7 @@ resizer_try_format(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
                 }
                 /* If not found, use UYVY as default */
                 if (i >= ARRAY_SIZE(resizer_input_formats))
-                        fmt->code = V4L2_MBUS_FMT_UYVY8_2X8;
+                        fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
 
                 fmt->width = clamp_t(u32, fmt->width, MIN_IN_WIDTH,
                                         MAX_IN_WIDTH);
@@ -1357,7 +1357,7 @@ resizer_try_format(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
                 }
                 /* If not found, use UYVY as default */
                 if (i >= ARRAY_SIZE(resizer_output_formats))
-                        fmt->code = V4L2_MBUS_FMT_UYVY8_2X8;
+                        fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
 
                 fmt->width = clamp_t(u32, fmt->width, MIN_OUT_WIDTH,
                                         max_out_width);
@@ -1375,7 +1375,7 @@ resizer_try_format(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
                 }
                 /* If not found, use UYVY as default */
                 if (i >= ARRAY_SIZE(resizer_output_formats))
-                        fmt->code = V4L2_MBUS_FMT_UYVY8_2X8;
+                        fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
 
                 fmt->width = clamp_t(u32, fmt->width, MIN_OUT_WIDTH,
                                         max_out_width);
@@ -1548,7 +1548,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
                 memset(&format, 0, sizeof(format));
                 format.pad = RESIZER_CROP_PAD_SINK;
                 format.which = which;
-                format.format.code = V4L2_MBUS_FMT_YUYV8_2X8;
+                format.format.code = MEDIA_BUS_FMT_YUYV8_2X8;
                 format.format.width = MAX_IN_WIDTH;
                 format.format.height = MAX_IN_HEIGHT;
                 resizer_set_format(sd, fh, &format);
@@ -1556,7 +1556,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
                 memset(&format, 0, sizeof(format));
                 format.pad = RESIZER_CROP_PAD_SOURCE;
                 format.which = which;
-                format.format.code = V4L2_MBUS_FMT_UYVY8_2X8;
+                format.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
                 format.format.width = MAX_IN_WIDTH;
                 format.format.height = MAX_IN_WIDTH;
                 resizer_set_format(sd, fh, &format);
@@ -1564,7 +1564,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
                 memset(&format, 0, sizeof(format));
                 format.pad = RESIZER_CROP_PAD_SOURCE2;
                 format.which = which;
-                format.format.code = V4L2_MBUS_FMT_UYVY8_2X8;
+                format.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
                 format.format.width = MAX_IN_WIDTH;
                 format.format.height = MAX_IN_WIDTH;
                 resizer_set_format(sd, fh, &format);
@@ -1572,7 +1572,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
                 memset(&format, 0, sizeof(format));
                 format.pad = RESIZER_PAD_SINK;
                 format.which = which;
-                format.format.code = V4L2_MBUS_FMT_YUYV8_2X8;
+                format.format.code = MEDIA_BUS_FMT_YUYV8_2X8;
                 format.format.width = MAX_IN_WIDTH;
                 format.format.height = MAX_IN_HEIGHT;
                 resizer_set_format(sd, fh, &format);
@@ -1580,7 +1580,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
                 memset(&format, 0, sizeof(format));
                 format.pad = RESIZER_PAD_SOURCE;
                 format.which = which;
-                format.format.code = V4L2_MBUS_FMT_UYVY8_2X8;
+                format.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
                 format.format.width = IPIPE_MAX_OUTPUT_WIDTH_A;
                 format.format.height = IPIPE_MAX_OUTPUT_HEIGHT_A;
                 resizer_set_format(sd, fh, &format);
@@ -1588,7 +1588,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
                 memset(&format, 0, sizeof(format));
                 format.pad = RESIZER_PAD_SINK;
                 format.which = which;
-                format.format.code = V4L2_MBUS_FMT_YUYV8_2X8;
+                format.format.code = MEDIA_BUS_FMT_YUYV8_2X8;
                 format.format.width = MAX_IN_WIDTH;
                 format.format.height = MAX_IN_HEIGHT;
                 resizer_set_format(sd, fh, &format);
@@ -1596,7 +1596,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
                 memset(&format, 0, sizeof(format));
                 format.pad = RESIZER_PAD_SOURCE;
                 format.which = which;
-                format.format.code = V4L2_MBUS_FMT_UYVY8_2X8;
+                format.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
                 format.format.width = IPIPE_MAX_OUTPUT_WIDTH_B;
                 format.format.height = IPIPE_MAX_OUTPUT_HEIGHT_B;
                 resizer_set_format(sd, fh, &format);
diff --git a/drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c b/drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c
index a862b28092e4..bf45d2cc5965 100644
--- a/drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c
+++ b/drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c
@@ -99,47 +99,47 @@ void mbus_to_pix(const struct v4l2_mbus_framefmt *mbus,
                            struct v4l2_pix_format *pix)
 {
         switch (mbus->code) {
-        case V4L2_MBUS_FMT_UYVY8_2X8:
+        case MEDIA_BUS_FMT_UYVY8_2X8:
                 pix->pixelformat = V4L2_PIX_FMT_UYVY;
                 pix->bytesperline = pix->width * 2;
                 break;
 
-        case V4L2_MBUS_FMT_YUYV8_2X8:
+        case MEDIA_BUS_FMT_YUYV8_2X8:
                 pix->pixelformat = V4L2_PIX_FMT_YUYV;
                 pix->bytesperline = pix->width * 2;
                 break;
 
-        case V4L2_MBUS_FMT_YUYV10_1X20:
+        case MEDIA_BUS_FMT_YUYV10_1X20:
                 pix->pixelformat = V4L2_PIX_FMT_UYVY;
                 pix->bytesperline = pix->width * 2;
                 break;
 
-        case V4L2_MBUS_FMT_SGRBG12_1X12:
+        case MEDIA_BUS_FMT_SGRBG12_1X12:
                 pix->pixelformat = V4L2_PIX_FMT_SBGGR16;
                 pix->bytesperline = pix->width * 2;
                 break;
 
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
                 pix->pixelformat = V4L2_PIX_FMT_SGRBG10DPCM8;
                 pix->bytesperline = pix->width;
                 break;
 
-        case V4L2_MBUS_FMT_SGRBG10_ALAW8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8:
                 pix->pixelformat = V4L2_PIX_FMT_SGRBG10ALAW8;
                 pix->bytesperline = pix->width;
                 break;
 
-        case V4L2_MBUS_FMT_YDYUYDYV8_1X16:
+        case MEDIA_BUS_FMT_YDYUYDYV8_1X16:
                 pix->pixelformat = V4L2_PIX_FMT_NV12;
                 pix->bytesperline = pix->width;
                 break;
 
-        case V4L2_MBUS_FMT_Y8_1X8:
+        case MEDIA_BUS_FMT_Y8_1X8:
                 pix->pixelformat = V4L2_PIX_FMT_GREY;
                 pix->bytesperline = pix->width;
                 break;
 
-        case V4L2_MBUS_FMT_UV8_1X8:
+        case MEDIA_BUS_FMT_UV8_1X8:
                 pix->pixelformat = V4L2_PIX_FMT_UV8;
                 pix->bytesperline = pix->width;
                 break;
diff --git a/drivers/staging/media/davinci_vpfe/vpfe_video.c b/drivers/staging/media/davinci_vpfe/vpfe_video.c
index 6f9171c39bdc..06d48d5eb0a0 100644
--- a/drivers/staging/media/davinci_vpfe/vpfe_video.c
+++ b/drivers/staging/media/davinci_vpfe/vpfe_video.c
@@ -600,11 +600,11 @@ static int vpfe_querycap(struct file *file, void  *priv,
         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querycap\n");
 
         if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+                cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
         else
-                cap->capabilities = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
-        cap->device_caps = cap->capabilities;
-        cap->version = VPFE_CAPTURE_VERSION_CODE;
+                cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
+        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT |
+                            V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
         strlcpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver));
         strlcpy(cap->bus_info, "VPFE", sizeof(cap->bus_info));
         strlcpy(cap->card, vpfe_dev->cfg->card_name, sizeof(cap->card));
diff --git a/drivers/staging/media/dt3155v4l/dt3155v4l.c b/drivers/staging/media/dt3155v4l/dt3155v4l.c
index 40580228a6c7..293ffda503e0 100644
--- a/drivers/staging/media/dt3155v4l/dt3155v4l.c
+++ b/drivers/staging/media/dt3155v4l/dt3155v4l.c
@@ -512,10 +512,9 @@ dt3155_ioc_querycap(struct file *filp, void *p, struct v4l2_capability *cap)
         strcpy(cap->driver, DT3155_NAME);
         strcpy(cap->card, DT3155_NAME " frame grabber");
         sprintf(cap->bus_info, "PCI:%s", pci_name(pd->pdev));
-        cap->version =
-               KERNEL_VERSION(DT3155_VER_MAJ, DT3155_VER_MIN, DT3155_VER_EXT);
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
+        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
                                 DT3155_CAPTURE_METHOD;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
         return 0;
 }
 
diff --git a/drivers/staging/media/lirc/Kconfig b/drivers/staging/media/lirc/Kconfig
index e60a59fc252b..6879c4651b46 100644
--- a/drivers/staging/media/lirc/Kconfig
+++ b/drivers/staging/media/lirc/Kconfig
@@ -18,12 +18,6 @@ config LIRC_BT829
         help
           Driver for the IR interface on BT829-based hardware
 
-config LIRC_IGORPLUGUSB
-        tristate "Igor Cesko's USB IR Receiver"
-        depends on LIRC && USB
-        help
-          Driver for Igor Cesko's USB IR Receiver
-
 config LIRC_IMON
         tristate "Legacy SoundGraph iMON Receiver and Display"
         depends on LIRC && USB
diff --git a/drivers/staging/media/lirc/Makefile b/drivers/staging/media/lirc/Makefile
index b90fcabddab6..5430adf0475d 100644
--- a/drivers/staging/media/lirc/Makefile
+++ b/drivers/staging/media/lirc/Makefile
@@ -4,7 +4,6 @@
 # Each configuration option enables a list of files.
 
 obj-$(CONFIG_LIRC_BT829)        += lirc_bt829.o
-obj-$(CONFIG_LIRC_IGORPLUGUSB)  += lirc_igorplugusb.o
 obj-$(CONFIG_LIRC_IMON)         += lirc_imon.o
 obj-$(CONFIG_LIRC_PARALLEL)     += lirc_parallel.o
 obj-$(CONFIG_LIRC_SASEM)        += lirc_sasem.o
diff --git a/drivers/staging/media/lirc/lirc_igorplugusb.c b/drivers/staging/media/lirc/lirc_igorplugusb.c
deleted file mode 100644
index 431d1e86ebf9..000000000000
--- a/drivers/staging/media/lirc/lirc_igorplugusb.c
+++ /dev/null
@@ -1,508 +0,0 @@
-/*
- * lirc_igorplugusb - USB remote support for LIRC
- *
- * Supports the standard homebrew IgorPlugUSB receiver with Igor's firmware.
- * See http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20(AVR)_eng.htm
- *
- * The device can only record bursts of up to 36 pulses/spaces.
- * Works fine with RC5. Longer commands lead to device buffer overrun.
- * (Maybe a better firmware or a microcontroller with more ram can help?)
- *
- * Version 0.1  [beta status]
- *
- * Copyright (C) 2004 Jan M. Hochstein
- *      <hochstein@algo.informatik.tu-darmstadt.de>
- *
- * This driver was derived from:
- *   Paul Miller <pmiller9@users.sourceforge.net>
- *      "lirc_atiusb" module
- *   Vladimir Dergachev <volodya@minspring.com>'s 2002
- *      "USB ATI Remote support" (input device)
- *   Adrian Dewhurst <sailor-lk@sailorfrag.net>'s 2002
- *      "USB StreamZap remote driver" (LIRC)
- *   Artur Lipowski <alipowski@kki.net.pl>'s 2002
- *      "lirc_dev" and "lirc_gpio" LIRC modules
- */
-
-/*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/kmod.h>
-#include <linux/sched.h>
-#include <linux/errno.h>
-#include <linux/fs.h>
-#include <linux/usb.h>
-#include <linux/time.h>
-
-#include <media/lirc.h>
-#include <media/lirc_dev.h>
-
-
-/* module identification */
-#define DRIVER_VERSION          "0.2"
-#define DRIVER_AUTHOR           \
-        "Jan M. Hochstein <hochstein@algo.informatik.tu-darmstadt.de>"
-#define DRIVER_DESC             "Igorplug USB remote driver for LIRC"
-#define DRIVER_NAME             "lirc_igorplugusb"
-
-/* One mode2 pulse/space has 4 bytes. */
-#define CODE_LENGTH          sizeof(int)
-
-/* Igor's firmware cannot record bursts longer than 36. */
-#define DEVICE_BUFLEN      36
-
-/*
- * Header at the beginning of the device's buffer:
- *      unsigned char data_length
- *      unsigned char data_start    (!=0 means ring-buffer overrun)
- *      unsigned char counter       (incremented by each burst)
- */
-#define DEVICE_HEADERLEN        3
-
-/* This is for the gap */
-#define ADDITIONAL_LIRC_BYTES   2
-
-/* times to poll per second */
-#define SAMPLE_RATE          100
-static int sample_rate = SAMPLE_RATE;
-
-
-/**** Igor's USB Request Codes */
-
-#define SET_INFRABUFFER_EMPTY   1
-/**
- * Params: none
- * Answer: empty
- */
-
-#define GET_INFRACODE      2
-/**
- * Params:
- *   wValue: offset to begin reading infra buffer
- *
- * Answer: infra data
- */
-
-#define SET_DATAPORT_DIRECTION  3
-/**
- * Params:
- *   wValue: (byte) 1 bit for each data port pin (0=in, 1=out)
- *
- * Answer: empty
- */
-
-#define GET_DATAPORT_DIRECTION  4
-/**
- * Params: none
- *
- * Answer: (byte) 1 bit for each data port pin (0=in, 1=out)
- */
-
-#define SET_OUT_DATAPORT        5
-/**
- * Params:
- *   wValue: byte to write to output data port
- *
- * Answer: empty
- */
-
-#define GET_OUT_DATAPORT        6
-/**
- * Params: none
- *
- * Answer: least significant 3 bits read from output data port
- */
-
-#define GET_IN_DATAPORT  7
-/**
- * Params: none
- *
- * Answer: least significant 3 bits read from input data port
- */
-
-#define READ_EEPROM          8
-/**
- * Params:
- *   wValue: offset to begin reading EEPROM
- *
- * Answer: EEPROM bytes
- */
-
-#define WRITE_EEPROM        9
-/**
- * Params:
- *   wValue: offset to EEPROM byte
- *   wIndex: byte to write
- *
- * Answer: empty
- */
-
-#define SEND_RS232            10
-/**
- * Params:
- *   wValue: byte to send
- *
- * Answer: empty
- */
-
-#define RECV_RS232            11
-/**
- * Params: none
- *
- * Answer: byte received
- */
-
-#define SET_RS232_BAUD    12
-/**
- * Params:
- *   wValue: byte to write to UART bit rate register (UBRR)
- *
- * Answer: empty
- */
-
-#define GET_RS232_BAUD    13
-/**
- * Params: none
- *
- * Answer: byte read from UART bit rate register (UBRR)
- */
-
-
-/* data structure for each usb remote */
-struct igorplug {
-
-        /* usb */
-        struct usb_device *usbdev;
-        int devnum;
-
-        unsigned char *buf_in;
-        unsigned int len_in;
-        int in_space;
-        struct timeval last_time;
-
-        dma_addr_t dma_in;
-
-        /* lirc */
-        struct lirc_driver *d;
-
-        /* handle sending (init strings) */
-        int send_flags;
-};
-
-static int unregister_from_lirc(struct igorplug *ir)
-{
-        struct lirc_driver *d;
-        int devnum;
-
-        devnum = ir->devnum;
-        d = ir->d;
-
-        if (!d) {
-                dev_err(&ir->usbdev->dev,
-                        "%s: called with NULL lirc driver struct!\n", __func__);
-                return -EINVAL;
-        }
-
-        dev_dbg(&ir->usbdev->dev, "calling lirc_unregister_driver\n");
-        lirc_unregister_driver(d->minor);
-
-        return devnum;
-}
-
-static int set_use_inc(void *data)
-{
-        struct igorplug *ir = data;
-
-        if (!ir) {
-                printk(DRIVER_NAME "[?]: set_use_inc called with no context\n");
-                return -EIO;
-        }
-
-        dev_dbg(&ir->usbdev->dev, "set use inc\n");
-
-        if (!ir->usbdev)
-                return -ENODEV;
-
-        return 0;
-}
-
-static void set_use_dec(void *data)
-{
-        struct igorplug *ir = data;
-
-        if (!ir) {
-                printk(DRIVER_NAME "[?]: set_use_dec called with no context\n");
-                return;
-        }
-
-        dev_dbg(&ir->usbdev->dev, "set use dec\n");
-}
-
-static void send_fragment(struct igorplug *ir, struct lirc_buffer *buf,
-                           int i, int max)
-{
-        int code;
-
-        /* MODE2: pulse/space (PULSE_BIT) in 1us units */
-        while (i < max) {
-                /* 1 Igor-tick = 85.333333 us */
-                code = (unsigned int)ir->buf_in[i] * 85 +
-                        (unsigned int)ir->buf_in[i] / 3;
-                ir->last_time.tv_usec += code;
-                if (ir->in_space)
-                        code |= PULSE_BIT;
-                lirc_buffer_write(buf, (unsigned char *)&code);
-                /* 1 chunk = CODE_LENGTH bytes */
-                ir->in_space ^= 1;
-                ++i;
-        }
-}
-
-/**
- * Called in user context.
- * return 0 if data was added to the buffer and
- * -ENODATA if none was available. This should add some number of bits
- * evenly divisible by code_length to the buffer
- */
-static int igorplugusb_remote_poll(void *data, struct lirc_buffer *buf)
-{
-        int ret;
-        struct igorplug *ir = (struct igorplug *)data;
-
-        if (!ir || !ir->usbdev)  /* Has the device been removed? */
-                return -ENODEV;
-
-        memset(ir->buf_in, 0, ir->len_in);
-
-        ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
-                              GET_INFRACODE, USB_TYPE_VENDOR | USB_DIR_IN,
-                              0/* offset */, /*unused*/0,
-                              ir->buf_in, ir->len_in,
-                              /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
-        if (ret > 0) {
-                int code, timediff;
-                struct timeval now;
-
-                /* ACK packet has 1 byte --> ignore */
-                if (ret < DEVICE_HEADERLEN)
-                        return -ENODATA;
-
-                dev_dbg(&ir->usbdev->dev, "Got %d bytes. Header: %*ph\n",
-                        ret, 3, ir->buf_in);
-
-                do_gettimeofday(&now);
-                timediff = now.tv_sec - ir->last_time.tv_sec;
-                if (timediff + 1 > PULSE_MASK / 1000000)
-                        timediff = PULSE_MASK;
-                else {
-                        timediff *= 1000000;
-                        timediff += now.tv_usec - ir->last_time.tv_usec;
-                }
-                ir->last_time.tv_sec = now.tv_sec;
-                ir->last_time.tv_usec = now.tv_usec;
-
-                /* create leading gap  */
-                code = timediff;
-                lirc_buffer_write(buf, (unsigned char *)&code);
-                ir->in_space = 1;   /* next comes a pulse */
-
-                if (ir->buf_in[2] == 0)
-                        send_fragment(ir, buf, DEVICE_HEADERLEN, ret);
-                else {
-                        dev_warn(&ir->usbdev->dev,
-                                 "[%d]: Device buffer overrun.\n", ir->devnum);
-                        /* HHHNNNNNNNNNNNOOOOOOOO H = header
-                              <---[2]--->         N = newer
-                           <---------ret--------> O = older */
-                        ir->buf_in[2] %= ret - DEVICE_HEADERLEN; /* sanitize */
-                        /* keep even-ness to not desync pulse/pause */
-                        send_fragment(ir, buf, DEVICE_HEADERLEN +
-                                      ir->buf_in[2] - (ir->buf_in[2] & 1), ret);
-                        send_fragment(ir, buf, DEVICE_HEADERLEN,
-                                      DEVICE_HEADERLEN + ir->buf_in[2]);
-                }
-
-                ret = usb_control_msg(
-                      ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
-                      SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
-                      /*unused*/0, /*unused*/0,
-                      /*dummy*/ir->buf_in, /*dummy*/ir->len_in,
-                      /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
-                if (ret < 0)
-                        printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
-                               ir->devnum, ret);
-                return 0;
-        } else if (ret < 0)
-                printk(DRIVER_NAME "[%d]: GET_INFRACODE: error %d\n",
-                        ir->devnum, ret);
-
-        return -ENODATA;
-}
-
-static int igorplugusb_remote_probe(struct usb_interface *intf,
-                                    const struct usb_device_id *id)
-{
-        struct usb_device *dev;
-        struct usb_host_interface *idesc = NULL;
-        struct usb_endpoint_descriptor *ep;
-        struct igorplug *ir = NULL;
-        struct lirc_driver *driver = NULL;
-        int devnum, pipe, maxp;
-        char buf[63], name[128] = "";
-        int ret;
-
-        dev_dbg(&intf->dev, "%s: usb probe called.\n", __func__);
-
-        dev = interface_to_usbdev(intf);
-
-        idesc = intf->cur_altsetting;
-
-        if (idesc->desc.bNumEndpoints != 1)
-                return -ENODEV;
-
-        ep = &idesc->endpoint->desc;
-        if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
-            != USB_DIR_IN)
-            || (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-            != USB_ENDPOINT_XFER_CONTROL)
-                return -ENODEV;
-
-        pipe = usb_rcvctrlpipe(dev, ep->bEndpointAddress);
-        devnum = dev->devnum;
-        maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
-
-        dev_dbg(&intf->dev, "%s: bytes_in_key=%zu maxp=%d\n",
-                __func__, CODE_LENGTH, maxp);
-
-        ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);
-        if (!ir)
-                return -ENOMEM;
-
-        driver = devm_kzalloc(&intf->dev, sizeof(*driver), GFP_KERNEL);
-        if (!driver)
-                return -ENOMEM;
-
-        ir->buf_in = usb_alloc_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
-                                        GFP_ATOMIC, &ir->dma_in);
-        if (!ir->buf_in)
-                return -ENOMEM;
-
-        strcpy(driver->name, DRIVER_NAME " ");
-        driver->minor = -1;
-        driver->code_length = CODE_LENGTH * 8; /* in bits */
-        driver->features = LIRC_CAN_REC_MODE2;
-        driver->data = ir;
-        driver->chunk_size = CODE_LENGTH;
-        driver->buffer_size = DEVICE_BUFLEN + ADDITIONAL_LIRC_BYTES;
-        driver->set_use_inc = &set_use_inc;
-        driver->set_use_dec = &set_use_dec;
-        driver->sample_rate = sample_rate;    /* per second */
-        driver->add_to_buf = &igorplugusb_remote_poll;
-        driver->dev = &intf->dev;
-        driver->owner = THIS_MODULE;
-
-        ret = lirc_register_driver(driver);
-        if (ret < 0) {
-                usb_free_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
-                        ir->buf_in, ir->dma_in);
-                return ret;
-        }
-
-        driver->minor = ret;
-        ir->d = driver;
-        ir->devnum = devnum;
-        ir->usbdev = dev;
-        ir->len_in = DEVICE_BUFLEN + DEVICE_HEADERLEN;
-        ir->in_space = 1; /* First mode2 event is a space. */
-        do_gettimeofday(&ir->last_time);
-
-        if (dev->descriptor.iManufacturer
-            && usb_string(dev, dev->descriptor.iManufacturer,
-                          buf, sizeof(buf)) > 0)
-                strlcpy(name, buf, sizeof(name));
-        if (dev->descriptor.iProduct
-            && usb_string(dev, dev->descriptor.iProduct, buf, sizeof(buf)) > 0)
-                snprintf(name + strlen(name), sizeof(name) - strlen(name),
-                         " %s", buf);
-        printk(DRIVER_NAME "[%d]: %s on usb%d:%d\n", devnum, name,
-               dev->bus->busnum, devnum);
-
-        /* clear device buffer */
-        ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
-                SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
-                /*unused*/0, /*unused*/0,
-                /*dummy*/ir->buf_in, /*dummy*/ir->len_in,
-                /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
-        if (ret < 0)
-                printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
-                        devnum, ret);
-
-        usb_set_intfdata(intf, ir);
-        return 0;
-}
-
-static void igorplugusb_remote_disconnect(struct usb_interface *intf)
-{
-        struct usb_device *usbdev = interface_to_usbdev(intf);
-        struct igorplug *ir = usb_get_intfdata(intf);
-        struct device *dev = &intf->dev;
-        int devnum;
-
-        usb_set_intfdata(intf, NULL);
-
-        if (!ir || !ir->d)
-                return;
-
-        ir->usbdev = NULL;
-
-        usb_free_coherent(usbdev, ir->len_in, ir->buf_in, ir->dma_in);
-
-        devnum = unregister_from_lirc(ir);
-
-        dev_info(dev, DRIVER_NAME "[%d]: %s done\n", devnum, __func__);
-}
-
-static struct usb_device_id igorplugusb_remote_id_table[] = {
-        /* Igor Plug USB (Atmel's Manufact. ID) */
-        { USB_DEVICE(0x03eb, 0x0002) },
-        /* Fit PC2 Infrared Adapter */
-        { USB_DEVICE(0x03eb, 0x21fe) },
-
-        /* Terminating entry */
-        { }
-};
-
-static struct usb_driver igorplugusb_remote_driver = {
-        .name =         DRIVER_NAME,
-        .probe =        igorplugusb_remote_probe,
-        .disconnect =   igorplugusb_remote_disconnect,
-        .id_table =     igorplugusb_remote_id_table
-};
-
-module_usb_driver(igorplugusb_remote_driver);
-
-#include <linux/vermagic.h>
-MODULE_INFO(vermagic, VERMAGIC_STRING);
-
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_LICENSE("GPL");
-MODULE_DEVICE_TABLE(usb, igorplugusb_remote_id_table);
-
-module_param(sample_rate, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(sample_rate, "Sampling rate in Hz (default: 100)");
diff --git a/drivers/staging/media/lirc/lirc_imon.c b/drivers/staging/media/lirc/lirc_imon.c
index 7aca44f28c5a..232edd5b1742 100644
--- a/drivers/staging/media/lirc/lirc_imon.c
+++ b/drivers/staging/media/lirc/lirc_imon.c
@@ -606,7 +606,6 @@ static void imon_incoming_packet(struct imon_context *context,
         struct device *dev = context->driver->dev;
         int octet, bit;
         unsigned char mask;
-        int i;
 
         /*
          * just bail out if no listening IR client
@@ -620,13 +619,8 @@ static void imon_incoming_packet(struct imon_context *context,
                 return;
         }
 
-        if (debug) {
-                dev_info(dev, "raw packet: ");
-                for (i = 0; i < len; ++i)
-                        printk("%02x ", buf[i]);
-                printk("\n");
-        }
-
+        if (debug)
+                dev_info(dev, "raw packet: %*ph\n", len, buf);
         /*
          * Translate received data to pulse and space lengths.
          * Received data is active low, i.e. pulses are 0 and
diff --git a/drivers/staging/media/lirc/lirc_sasem.c b/drivers/staging/media/lirc/lirc_sasem.c
index c20ef56202bf..2f0463eb9887 100644
--- a/drivers/staging/media/lirc/lirc_sasem.c
+++ b/drivers/staging/media/lirc/lirc_sasem.c
@@ -573,7 +573,6 @@ static void incoming_packet(struct sasem_context *context,
         unsigned char *buf = urb->transfer_buffer;
         long ms;
         struct timeval tv;
-        int i;
 
         if (len != 8) {
                 dev_warn(&context->dev->dev,
@@ -582,13 +581,8 @@ static void incoming_packet(struct sasem_context *context,
                 return;
         }
 
-        if (debug) {
-                printk(KERN_INFO "Incoming data: ");
-                for (i = 0; i < 8; ++i)
-                        printk(KERN_CONT "%02x ", buf[i]);
-                printk(KERN_CONT "\n");
-        }
-
+        if (debug)
+                dev_info(&context->dev->dev, "Incoming data: %*ph\n", len, buf);
         /*
          * Lirc could deal with the repeat code, but we really need to block it
          * if it arrives too late.  Otherwise we could repeat the wrong code.
diff --git a/drivers/staging/media/lirc/lirc_zilog.c b/drivers/staging/media/lirc/lirc_zilog.c
index 567feba0011c..1e15d2cab727 100644
--- a/drivers/staging/media/lirc/lirc_zilog.c
+++ b/drivers/staging/media/lirc/lirc_zilog.c
@@ -199,7 +199,7 @@ static void release_ir_device(struct kref *ref)
                 lirc_unregister_driver(ir->l.minor);
                 ir->l.minor = MAX_IRCTL_DEVICES;
         }
-        if (ir->rbuf.fifo_initialized)
+        if (kfifo_initialized(&ir->rbuf.fifo))
                 lirc_buffer_free(&ir->rbuf);
         list_del(&ir->list);
         kfree(ir);
@@ -730,11 +730,9 @@ static int send_boot_data(struct IR_tx *tx)
 static void fw_unload_locked(void)
 {
         if (tx_data) {
-                if (tx_data->code_sets)
-                        vfree(tx_data->code_sets);
+                vfree(tx_data->code_sets);
 
-                if (tx_data->datap)
-                        vfree(tx_data->datap);
+                vfree(tx_data->datap);
 
                 vfree(tx_data);
                 tx_data = NULL;
diff --git a/drivers/staging/media/mn88472/Kconfig b/drivers/staging/media/mn88472/Kconfig
new file mode 100644
index 000000000000..a85c90a60bce
--- /dev/null
+++ b/drivers/staging/media/mn88472/Kconfig
@@ -0,0 +1,7 @@
+config DVB_MN88472
+        tristate "Panasonic MN88472"
+        depends on DVB_CORE && I2C
+        select REGMAP_I2C
+        default m if !MEDIA_SUBDRV_AUTOSELECT
+        help
+          Say Y when you want to support this frontend.
diff --git a/drivers/staging/media/mn88472/Makefile b/drivers/staging/media/mn88472/Makefile
new file mode 100644
index 000000000000..5987b7e6d82a
--- /dev/null
+++ b/drivers/staging/media/mn88472/Makefile
@@ -0,0 +1,5 @@
+obj-$(CONFIG_DVB_MN88472) += mn88472.o
+
+ccflags-y += -Idrivers/media/dvb-core/
+ccflags-y += -Idrivers/media/dvb-frontends/
+ccflags-y += -Idrivers/media/tuners/
diff --git a/drivers/staging/media/mn88472/TODO b/drivers/staging/media/mn88472/TODO
new file mode 100644
index 000000000000..b90a14be3beb
--- /dev/null
+++ b/drivers/staging/media/mn88472/TODO
@@ -0,0 +1,21 @@
+Driver general quality is not good enough for mainline. Also, other
+device drivers (USB-bridge, tuner) needed for Astrometa receiver in
+question could need some changes. However, if that driver is mainlined
+due to some other device than Astrometa, unrelated TODOs could be
+skipped. In that case rtl28xxu driver needs module parameter to prevent
+driver loading.
+
+Required TODOs:
+* missing lock flags
+* I2C errors
+* tuner sensitivity
+
+*Do not* send any patch fixing checkpatch.pl issues. Currently it passes
+checkpatch.pl tests. I don't want waste my time to review this kind of
+trivial stuff. *Do not* add missing register I/O error checks. Those are
+missing for the reason it is much easier to compare I2C data sniffs when
+there is less lines. Those error checks are about the last thing to be added.
+
+Patches should be submitted to:
+linux-media@vger.kernel.org and Antti Palosaari <crope@iki.fi>
+
diff --git a/drivers/staging/media/mn88472/mn88472.c b/drivers/staging/media/mn88472/mn88472.c
new file mode 100644
index 000000000000..52de8f85d36c
--- /dev/null
+++ b/drivers/staging/media/mn88472/mn88472.c
@@ -0,0 +1,523 @@
+/*
+ * Panasonic MN88472 DVB-T/T2/C demodulator driver
+ *
+ * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#include "mn88472_priv.h"
+
+static int mn88472_get_tune_settings(struct dvb_frontend *fe,
+        struct dvb_frontend_tune_settings *s)
+{
+        s->min_delay_ms = 400;
+        return 0;
+}
+
+static int mn88472_set_frontend(struct dvb_frontend *fe)
+{
+        struct i2c_client *client = fe->demodulator_priv;
+        struct mn88472_dev *dev = i2c_get_clientdata(client);
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        int ret, i;
+        u32 if_frequency = 0;
+        u8 delivery_system_val, if_val[3], bw_val[7], bw_val2;
+
+        dev_dbg(&client->dev,
+                        "delivery_system=%d modulation=%d frequency=%d symbol_rate=%d inversion=%d\n",
+                        c->delivery_system, c->modulation,
+                        c->frequency, c->symbol_rate, c->inversion);
+
+        if (!dev->warm) {
+                ret = -EAGAIN;
+                goto err;
+        }
+
+        switch (c->delivery_system) {
+        case SYS_DVBT:
+                delivery_system_val = 0x02;
+                break;
+        case SYS_DVBT2:
+                delivery_system_val = 0x03;
+                break;
+        case SYS_DVBC_ANNEX_A:
+                delivery_system_val = 0x04;
+                break;
+        default:
+                ret = -EINVAL;
+                goto err;
+        }
+
+        switch (c->delivery_system) {
+        case SYS_DVBT:
+        case SYS_DVBT2:
+                if (c->bandwidth_hz <= 6000000) {
+                        /* IF 3570000 Hz, BW 6000000 Hz */
+                        memcpy(if_val, "\x2c\x94\xdb", 3);
+                        memcpy(bw_val, "\xbf\x55\x55\x15\x6b\x15\x6b", 7);
+                        bw_val2 = 0x02;
+                } else if (c->bandwidth_hz <= 7000000) {
+                        /* IF 4570000 Hz, BW 7000000 Hz */
+                        memcpy(if_val, "\x39\x11\xbc", 3);
+                        memcpy(bw_val, "\xa4\x00\x00\x0f\x2c\x0f\x2c", 7);
+                        bw_val2 = 0x01;
+                } else if (c->bandwidth_hz <= 8000000) {
+                        /* IF 4570000 Hz, BW 8000000 Hz */
+                        memcpy(if_val, "\x39\x11\xbc", 3);
+                        memcpy(bw_val, "\x8f\x80\x00\x08\xee\x08\xee", 7);
+                        bw_val2 = 0x00;
+                } else {
+                        ret = -EINVAL;
+                        goto err;
+                }
+                break;
+        case SYS_DVBC_ANNEX_A:
+                /* IF 5070000 Hz, BW 8000000 Hz */
+                memcpy(if_val, "\x3f\x50\x2c", 3);
+                memcpy(bw_val, "\x8f\x80\x00\x08\xee\x08\xee", 7);
+                bw_val2 = 0x00;
+                break;
+        default:
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* program tuner */
+        if (fe->ops.tuner_ops.set_params) {
+                ret = fe->ops.tuner_ops.set_params(fe);
+                if (ret)
+                        goto err;
+        }
+
+        if (fe->ops.tuner_ops.get_if_frequency) {
+                ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
+                if (ret)
+                        goto err;
+
+                dev_dbg(&client->dev, "get_if_frequency=%d\n", if_frequency);
+        }
+
+        switch (if_frequency) {
+        case 3570000:
+        case 4570000:
+        case 5070000:
+                break;
+        default:
+                dev_err(&client->dev, "IF frequency %d not supported\n",
+                                if_frequency);
+                ret = -EINVAL;
+                goto err;
+        }
+
+        ret = regmap_write(dev->regmap[2], 0xfb, 0x13);
+        ret = regmap_write(dev->regmap[2], 0xef, 0x13);
+        ret = regmap_write(dev->regmap[2], 0xf9, 0x13);
+        if (ret)
+                goto err;
+
+        ret = regmap_write(dev->regmap[2], 0x00, 0x66);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap[2], 0x01, 0x00);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap[2], 0x02, 0x01);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap[2], 0x03, delivery_system_val);
+        if (ret)
+                goto err;
+        ret = regmap_write(dev->regmap[2], 0x04, bw_val2);
+        if (ret)
+                goto err;
+
+        for (i = 0; i < sizeof(if_val); i++) {
+                ret = regmap_write(dev->regmap[2], 0x10 + i, if_val[i]);
+                if (ret)
+                        goto err;
+        }
+
+        for (i = 0; i < sizeof(bw_val); i++) {
+                ret = regmap_write(dev->regmap[2], 0x13 + i, bw_val[i]);
+                if (ret)
+                        goto err;
+        }
+
+        switch (c->delivery_system) {
+        case SYS_DVBT:
+                ret = regmap_write(dev->regmap[0], 0x07, 0x26);
+                ret = regmap_write(dev->regmap[0], 0xb0, 0x0a);
+                ret = regmap_write(dev->regmap[0], 0xb4, 0x00);
+                ret = regmap_write(dev->regmap[0], 0xcd, 0x1f);
+                ret = regmap_write(dev->regmap[0], 0xd4, 0x0a);
+                ret = regmap_write(dev->regmap[0], 0xd6, 0x48);
+                ret = regmap_write(dev->regmap[0], 0x00, 0xba);
+                ret = regmap_write(dev->regmap[0], 0x01, 0x13);
+                if (ret)
+                        goto err;
+                break;
+        case SYS_DVBT2:
+                ret = regmap_write(dev->regmap[2], 0x2b, 0x13);
+                ret = regmap_write(dev->regmap[2], 0x4f, 0x05);
+                ret = regmap_write(dev->regmap[1], 0xf6, 0x05);
+                ret = regmap_write(dev->regmap[0], 0xb0, 0x0a);
+                ret = regmap_write(dev->regmap[0], 0xb4, 0xf6);
+                ret = regmap_write(dev->regmap[0], 0xcd, 0x01);
+                ret = regmap_write(dev->regmap[0], 0xd4, 0x09);
+                ret = regmap_write(dev->regmap[0], 0xd6, 0x46);
+                ret = regmap_write(dev->regmap[2], 0x30, 0x80);
+                ret = regmap_write(dev->regmap[2], 0x32, 0x00);
+                if (ret)
+                        goto err;
+                break;
+        case SYS_DVBC_ANNEX_A:
+                ret = regmap_write(dev->regmap[0], 0xb0, 0x0b);
+                ret = regmap_write(dev->regmap[0], 0xb4, 0x00);
+                ret = regmap_write(dev->regmap[0], 0xcd, 0x17);
+                ret = regmap_write(dev->regmap[0], 0xd4, 0x09);
+                ret = regmap_write(dev->regmap[0], 0xd6, 0x48);
+                ret = regmap_write(dev->regmap[1], 0x00, 0xb0);
+                if (ret)
+                        goto err;
+                break;
+        default:
+                ret = -EINVAL;
+                goto err;
+        }
+
+        ret = regmap_write(dev->regmap[0], 0x46, 0x00);
+        ret = regmap_write(dev->regmap[0], 0xae, 0x00);
+        ret = regmap_write(dev->regmap[2], 0x08, 0x1d);
+        ret = regmap_write(dev->regmap[0], 0xd9, 0xe3);
+        ret = regmap_write(dev->regmap[2], 0xf8, 0x9f);
+        if (ret)
+                goto err;
+
+        dev->delivery_system = c->delivery_system;
+
+        return 0;
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int mn88472_read_status(struct dvb_frontend *fe, fe_status_t *status)
+{
+        struct i2c_client *client = fe->demodulator_priv;
+        struct mn88472_dev *dev = i2c_get_clientdata(client);
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        int ret;
+        unsigned int utmp;
+
+        *status = 0;
+
+        if (!dev->warm) {
+                ret = -EAGAIN;
+                goto err;
+        }
+
+        switch (c->delivery_system) {
+        case SYS_DVBT:
+        case SYS_DVBT2:
+                /* FIXME: implement me */
+                utmp = 0x08; /* DVB-C lock value */
+                break;
+        case SYS_DVBC_ANNEX_A:
+                ret = regmap_read(dev->regmap[1], 0x84, &utmp);
+                if (ret)
+                        goto err;
+                break;
+        default:
+                ret = -EINVAL;
+                goto err;
+        }
+
+        if (utmp == 0x08)
+                *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
+                                FE_HAS_SYNC | FE_HAS_LOCK;
+
+        return 0;
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int mn88472_init(struct dvb_frontend *fe)
+{
+        struct i2c_client *client = fe->demodulator_priv;
+        struct mn88472_dev *dev = i2c_get_clientdata(client);
+        int ret, len, remaining;
+        const struct firmware *fw = NULL;
+        u8 *fw_file = MN88472_FIRMWARE;
+
+        dev_dbg(&client->dev, "\n");
+
+        /* set cold state by default */
+        dev->warm = false;
+
+        /* power on */
+        ret = regmap_write(dev->regmap[2], 0x05, 0x00);
+        if (ret)
+                goto err;
+
+        ret = regmap_bulk_write(dev->regmap[2], 0x0b, "\x00\x00", 2);
+        if (ret)
+                goto err;
+
+        /* request the firmware, this will block and timeout */
+        ret = request_firmware(&fw, fw_file, &client->dev);
+        if (ret) {
+                dev_err(&client->dev, "firmare file '%s' not found\n",
+                                fw_file);
+                goto err;
+        }
+
+        dev_info(&client->dev, "downloading firmware from file '%s'\n",
+                        fw_file);
+
+        ret = regmap_write(dev->regmap[0], 0xf5, 0x03);
+        if (ret)
+                goto err;
+
+        for (remaining = fw->size; remaining > 0;
+                        remaining -= (dev->i2c_wr_max - 1)) {
+                len = remaining;
+                if (len > (dev->i2c_wr_max - 1))
+                        len = (dev->i2c_wr_max - 1);
+
+                ret = regmap_bulk_write(dev->regmap[0], 0xf6,
+                                &fw->data[fw->size - remaining], len);
+                if (ret) {
+                        dev_err(&client->dev,
+                                        "firmware download failed=%d\n", ret);
+                        goto err;
+                }
+        }
+
+        ret = regmap_write(dev->regmap[0], 0xf5, 0x00);
+        if (ret)
+                goto err;
+
+        release_firmware(fw);
+        fw = NULL;
+
+        /* warm state */
+        dev->warm = true;
+
+        return 0;
+err:
+        if (fw)
+                release_firmware(fw);
+
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int mn88472_sleep(struct dvb_frontend *fe)
+{
+        struct i2c_client *client = fe->demodulator_priv;
+        struct mn88472_dev *dev = i2c_get_clientdata(client);
+        int ret;
+
+        dev_dbg(&client->dev, "\n");
+
+        /* power off */
+        ret = regmap_write(dev->regmap[2], 0x0b, 0x30);
+
+        if (ret)
+                goto err;
+
+        ret = regmap_write(dev->regmap[2], 0x05, 0x3e);
+        if (ret)
+                goto err;
+
+        dev->delivery_system = SYS_UNDEFINED;
+
+        return 0;
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static struct dvb_frontend_ops mn88472_ops = {
+        .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A},
+        .info = {
+                .name = "Panasonic MN88472",
+                .caps = FE_CAN_FEC_1_2                 |
+                        FE_CAN_FEC_2_3                 |
+                        FE_CAN_FEC_3_4                 |
+                        FE_CAN_FEC_5_6                 |
+                        FE_CAN_FEC_7_8                 |
+                        FE_CAN_FEC_AUTO                |
+                        FE_CAN_QPSK                    |
+                        FE_CAN_QAM_16                  |
+                        FE_CAN_QAM_32                  |
+                        FE_CAN_QAM_64                  |
+                        FE_CAN_QAM_128                 |
+                        FE_CAN_QAM_256                 |
+                        FE_CAN_QAM_AUTO                |
+                        FE_CAN_TRANSMISSION_MODE_AUTO  |
+                        FE_CAN_GUARD_INTERVAL_AUTO     |
+                        FE_CAN_HIERARCHY_AUTO          |
+                        FE_CAN_MUTE_TS                 |
+                        FE_CAN_2G_MODULATION           |
+                        FE_CAN_MULTISTREAM
+        },
+
+        .get_tune_settings = mn88472_get_tune_settings,
+
+        .init = mn88472_init,
+        .sleep = mn88472_sleep,
+
+        .set_frontend = mn88472_set_frontend,
+
+        .read_status = mn88472_read_status,
+};
+
+static int mn88472_probe(struct i2c_client *client,
+                const struct i2c_device_id *id)
+{
+        struct mn88472_config *config = client->dev.platform_data;
+        struct mn88472_dev *dev;
+        int ret;
+        unsigned int utmp;
+        static const struct regmap_config regmap_config = {
+                .reg_bits = 8,
+                .val_bits = 8,
+        };
+
+        dev_dbg(&client->dev, "\n");
+
+        /* Caller really need to provide pointer for frontend we create. */
+        if (config->fe == NULL) {
+                dev_err(&client->dev, "frontend pointer not defined\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (dev == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        dev->i2c_wr_max = config->i2c_wr_max;
+        dev->client[0] = client;
+        dev->regmap[0] = regmap_init_i2c(dev->client[0], &regmap_config);
+        if (IS_ERR(dev->regmap[0])) {
+                ret = PTR_ERR(dev->regmap[0]);
+                goto err_kfree;
+        }
+
+        /* check demod answers to I2C */
+        ret = regmap_read(dev->regmap[0], 0x00, &utmp);
+        if (ret)
+                goto err_regmap_0_regmap_exit;
+
+        /*
+         * Chip has three I2C addresses for different register pages. Used
+         * addresses are 0x18, 0x1a and 0x1c. We register two dummy clients,
+         * 0x1a and 0x1c, in order to get own I2C client for each register page.
+         */
+        dev->client[1] = i2c_new_dummy(client->adapter, 0x1a);
+        if (dev->client[1] == NULL) {
+                ret = -ENODEV;
+                dev_err(&client->dev, "I2C registration failed\n");
+                if (ret)
+                        goto err_regmap_0_regmap_exit;
+        }
+        dev->regmap[1] = regmap_init_i2c(dev->client[1], &regmap_config);
+        if (IS_ERR(dev->regmap[1])) {
+                ret = PTR_ERR(dev->regmap[1]);
+                goto err_client_1_i2c_unregister_device;
+        }
+        i2c_set_clientdata(dev->client[1], dev);
+
+        dev->client[2] = i2c_new_dummy(client->adapter, 0x1c);
+        if (dev->client[2] == NULL) {
+                ret = -ENODEV;
+                dev_err(&client->dev, "2nd I2C registration failed\n");
+                if (ret)
+                        goto err_regmap_1_regmap_exit;
+        }
+        dev->regmap[2] = regmap_init_i2c(dev->client[2], &regmap_config);
+        if (IS_ERR(dev->regmap[2])) {
+                ret = PTR_ERR(dev->regmap[2]);
+                goto err_client_2_i2c_unregister_device;
+        }
+        i2c_set_clientdata(dev->client[2], dev);
+
+        /* create dvb_frontend */
+        memcpy(&dev->fe.ops, &mn88472_ops, sizeof(struct dvb_frontend_ops));
+        dev->fe.demodulator_priv = client;
+        *config->fe = &dev->fe;
+        i2c_set_clientdata(client, dev);
+
+        dev_info(&client->dev, "Panasonic MN88472 successfully attached\n");
+        return 0;
+
+err_client_2_i2c_unregister_device:
+        i2c_unregister_device(dev->client[2]);
+err_regmap_1_regmap_exit:
+        regmap_exit(dev->regmap[1]);
+err_client_1_i2c_unregister_device:
+        i2c_unregister_device(dev->client[1]);
+err_regmap_0_regmap_exit:
+        regmap_exit(dev->regmap[0]);
+err_kfree:
+        kfree(dev);
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int mn88472_remove(struct i2c_client *client)
+{
+        struct mn88472_dev *dev = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "\n");
+
+        regmap_exit(dev->regmap[2]);
+        i2c_unregister_device(dev->client[2]);
+
+        regmap_exit(dev->regmap[1]);
+        i2c_unregister_device(dev->client[1]);
+
+        regmap_exit(dev->regmap[0]);
+
+        kfree(dev);
+
+        return 0;
+}
+
+static const struct i2c_device_id mn88472_id_table[] = {
+        {"mn88472", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, mn88472_id_table);
+
+static struct i2c_driver mn88472_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "mn88472",
+        },
+        .probe          = mn88472_probe,
+        .remove         = mn88472_remove,
+        .id_table       = mn88472_id_table,
+};
+
+module_i2c_driver(mn88472_driver);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("Panasonic MN88472 DVB-T/T2/C demodulator driver");
+MODULE_LICENSE("GPL");
+MODULE_FIRMWARE(MN88472_FIRMWARE);
diff --git a/drivers/staging/media/mn88472/mn88472_priv.h b/drivers/staging/media/mn88472/mn88472_priv.h
new file mode 100644
index 000000000000..1095949f040d
--- /dev/null
+++ b/drivers/staging/media/mn88472/mn88472_priv.h
@@ -0,0 +1,36 @@
+/*
+ * Panasonic MN88472 DVB-T/T2/C demodulator driver
+ *
+ * Copyright (C) 2013 Antti Palosaari <crope@iki.fi>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#ifndef MN88472_PRIV_H
+#define MN88472_PRIV_H
+
+#include "dvb_frontend.h"
+#include "mn88472.h"
+#include <linux/firmware.h>
+#include <linux/regmap.h>
+
+#define MN88472_FIRMWARE "dvb-demod-mn88472-02.fw"
+
+struct mn88472_dev {
+        struct i2c_client *client[3];
+        struct regmap *regmap[3];
+        struct dvb_frontend fe;
+        u16 i2c_wr_max;
+        fe_delivery_system_t delivery_system;
+        bool warm; /* FW running */
+};
+
+#endif
diff --git a/drivers/staging/media/mn88473/Kconfig b/drivers/staging/media/mn88473/Kconfig
new file mode 100644
index 000000000000..6c9ebf51c2c7
--- /dev/null
+++ b/drivers/staging/media/mn88473/Kconfig
@@ -0,0 +1,7 @@
+config DVB_MN88473
+        tristate "Panasonic MN88473"
+        depends on DVB_CORE && I2C
+        select REGMAP_I2C
+        default m if !MEDIA_SUBDRV_AUTOSELECT
+        help
+          Say Y when you want to support this frontend.
diff --git a/drivers/staging/media/mn88473/Makefile b/drivers/staging/media/mn88473/Makefile
new file mode 100644
index 000000000000..fac55410ce55
--- /dev/null
+++ b/drivers/staging/media/mn88473/Makefile
@@ -0,0 +1,5 @@
+obj-$(CONFIG_DVB_MN88473) += mn88473.o
+
+ccflags-y += -Idrivers/media/dvb-core/
+ccflags-y += -Idrivers/media/dvb-frontends/
+ccflags-y += -Idrivers/media/tuners/
diff --git a/drivers/staging/media/mn88473/TODO b/drivers/staging/media/mn88473/TODO
new file mode 100644
index 000000000000..b90a14be3beb
--- /dev/null
+++ b/drivers/staging/media/mn88473/TODO
@@ -0,0 +1,21 @@
+Driver general quality is not good enough for mainline. Also, other
+device drivers (USB-bridge, tuner) needed for Astrometa receiver in
+question could need some changes. However, if that driver is mainlined
+due to some other device than Astrometa, unrelated TODOs could be
+skipped. In that case rtl28xxu driver needs module parameter to prevent
+driver loading.
+
+Required TODOs:
+* missing lock flags
+* I2C errors
+* tuner sensitivity
+
+*Do not* send any patch fixing checkpatch.pl issues. Currently it passes
+checkpatch.pl tests. I don't want waste my time to review this kind of
+trivial stuff. *Do not* add missing register I/O error checks. Those are
+missing for the reason it is much easier to compare I2C data sniffs when
+there is less lines. Those error checks are about the last thing to be added.
+
+Patches should be submitted to:
+linux-media@vger.kernel.org and Antti Palosaari <crope@iki.fi>
+
diff --git a/drivers/staging/media/mn88473/mn88473.c b/drivers/staging/media/mn88473/mn88473.c
new file mode 100644
index 000000000000..a333744b76b9
--- /dev/null
+++ b/drivers/staging/media/mn88473/mn88473.c
@@ -0,0 +1,464 @@
+/*
+ * Panasonic MN88473 DVB-T/T2/C demodulator driver
+ *
+ * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#include "mn88473_priv.h"
+
+static int mn88473_get_tune_settings(struct dvb_frontend *fe,
+        struct dvb_frontend_tune_settings *s)
+{
+        s->min_delay_ms = 1000;
+        return 0;
+}
+
+static int mn88473_set_frontend(struct dvb_frontend *fe)
+{
+        struct i2c_client *client = fe->demodulator_priv;
+        struct mn88473_dev *dev = i2c_get_clientdata(client);
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        int ret, i;
+        u32 if_frequency;
+        u8 delivery_system_val, if_val[3], bw_val[7];
+
+        dev_dbg(&client->dev,
+                        "delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%d stream_id=%d\n",
+                        c->delivery_system, c->modulation,
+                        c->frequency, c->bandwidth_hz, c->symbol_rate,
+                        c->inversion, c->stream_id);
+
+        if (!dev->warm) {
+                ret = -EAGAIN;
+                goto err;
+        }
+
+        switch (c->delivery_system) {
+        case SYS_DVBT:
+                delivery_system_val = 0x02;
+                break;
+        case SYS_DVBT2:
+                delivery_system_val = 0x03;
+                break;
+        case SYS_DVBC_ANNEX_A:
+                delivery_system_val = 0x04;
+                break;
+        default:
+                ret = -EINVAL;
+                goto err;
+        }
+
+        switch (c->delivery_system) {
+        case SYS_DVBT:
+        case SYS_DVBT2:
+                if (c->bandwidth_hz <= 6000000) {
+                        /* IF 3570000 Hz, BW 6000000 Hz */
+                        memcpy(if_val, "\x24\x8e\x8a", 3);
+                        memcpy(bw_val, "\xe9\x55\x55\x1c\x29\x1c\x29", 7);
+                } else if (c->bandwidth_hz <= 7000000) {
+                        /* IF 4570000 Hz, BW 7000000 Hz */
+                        memcpy(if_val, "\x2e\xcb\xfb", 3);
+                        memcpy(bw_val, "\xc8\x00\x00\x17\x0a\x17\x0a", 7);
+                } else if (c->bandwidth_hz <= 8000000) {
+                        /* IF 4570000 Hz, BW 8000000 Hz */
+                        memcpy(if_val, "\x2e\xcb\xfb", 3);
+                        memcpy(bw_val, "\xaf\x00\x00\x11\xec\x11\xec", 7);
+                } else {
+                        ret = -EINVAL;
+                        goto err;
+                }
+                break;
+        case SYS_DVBC_ANNEX_A:
+                /* IF 5070000 Hz, BW 8000000 Hz */
+                memcpy(if_val, "\x33\xea\xb3", 3);
+                memcpy(bw_val, "\xaf\x00\x00\x11\xec\x11\xec", 7);
+                break;
+        default:
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* program tuner */
+        if (fe->ops.tuner_ops.set_params) {
+                ret = fe->ops.tuner_ops.set_params(fe);
+                if (ret)
+                        goto err;
+        }
+
+        if (fe->ops.tuner_ops.get_if_frequency) {
+                ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
+                if (ret)
+                        goto err;
+
+                dev_dbg(&client->dev, "get_if_frequency=%d\n", if_frequency);
+        } else {
+                if_frequency = 0;
+        }
+
+        switch (if_frequency) {
+        case 3570000:
+        case 4570000:
+        case 5070000:
+                break;
+        default:
+                dev_err(&client->dev, "IF frequency %d not supported\n",
+                                if_frequency);
+                ret = -EINVAL;
+                goto err;
+        }
+
+        ret = regmap_write(dev->regmap[2], 0x05, 0x00);
+        ret = regmap_write(dev->regmap[2], 0xfb, 0x13);
+        ret = regmap_write(dev->regmap[2], 0xef, 0x13);
+        ret = regmap_write(dev->regmap[2], 0xf9, 0x13);
+        ret = regmap_write(dev->regmap[2], 0x00, 0x18);
+        ret = regmap_write(dev->regmap[2], 0x01, 0x01);
+        ret = regmap_write(dev->regmap[2], 0x02, 0x21);
+        ret = regmap_write(dev->regmap[2], 0x03, delivery_system_val);
+        ret = regmap_write(dev->regmap[2], 0x0b, 0x00);
+
+        for (i = 0; i < sizeof(if_val); i++) {
+                ret = regmap_write(dev->regmap[2], 0x10 + i, if_val[i]);
+                if (ret)
+                        goto err;
+        }
+
+        for (i = 0; i < sizeof(bw_val); i++) {
+                ret = regmap_write(dev->regmap[2], 0x13 + i, bw_val[i]);
+                if (ret)
+                        goto err;
+        }
+
+        ret = regmap_write(dev->regmap[2], 0x2d, 0x3b);
+        ret = regmap_write(dev->regmap[2], 0x2e, 0x00);
+        ret = regmap_write(dev->regmap[2], 0x56, 0x0d);
+        ret = regmap_write(dev->regmap[0], 0x01, 0xba);
+        ret = regmap_write(dev->regmap[0], 0x02, 0x13);
+        ret = regmap_write(dev->regmap[0], 0x03, 0x80);
+        ret = regmap_write(dev->regmap[0], 0x04, 0xba);
+        ret = regmap_write(dev->regmap[0], 0x05, 0x91);
+        ret = regmap_write(dev->regmap[0], 0x07, 0xe7);
+        ret = regmap_write(dev->regmap[0], 0x08, 0x28);
+        ret = regmap_write(dev->regmap[0], 0x0a, 0x1a);
+        ret = regmap_write(dev->regmap[0], 0x13, 0x1f);
+        ret = regmap_write(dev->regmap[0], 0x19, 0x03);
+        ret = regmap_write(dev->regmap[0], 0x1d, 0xb0);
+        ret = regmap_write(dev->regmap[0], 0x2a, 0x72);
+        ret = regmap_write(dev->regmap[0], 0x2d, 0x00);
+        ret = regmap_write(dev->regmap[0], 0x3c, 0x00);
+        ret = regmap_write(dev->regmap[0], 0x3f, 0xf8);
+        ret = regmap_write(dev->regmap[0], 0x40, 0xf4);
+        ret = regmap_write(dev->regmap[0], 0x41, 0x08);
+        ret = regmap_write(dev->regmap[0], 0xd2, 0x29);
+        ret = regmap_write(dev->regmap[0], 0xd4, 0x55);
+        ret = regmap_write(dev->regmap[1], 0x10, 0x10);
+        ret = regmap_write(dev->regmap[1], 0x11, 0xab);
+        ret = regmap_write(dev->regmap[1], 0x12, 0x0d);
+        ret = regmap_write(dev->regmap[1], 0x13, 0xae);
+        ret = regmap_write(dev->regmap[1], 0x14, 0x1d);
+        ret = regmap_write(dev->regmap[1], 0x15, 0x9d);
+        ret = regmap_write(dev->regmap[1], 0xbe, 0x08);
+        ret = regmap_write(dev->regmap[2], 0x09, 0x08);
+        ret = regmap_write(dev->regmap[2], 0x08, 0x1d);
+        ret = regmap_write(dev->regmap[0], 0xb2, 0x37);
+        ret = regmap_write(dev->regmap[0], 0xd7, 0x04);
+        ret = regmap_write(dev->regmap[2], 0x32, 0x80);
+        ret = regmap_write(dev->regmap[2], 0x36, 0x00);
+        ret = regmap_write(dev->regmap[2], 0xf8, 0x9f);
+        if (ret)
+                goto err;
+
+        dev->delivery_system = c->delivery_system;
+
+        return 0;
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int mn88473_read_status(struct dvb_frontend *fe, fe_status_t *status)
+{
+        struct i2c_client *client = fe->demodulator_priv;
+        struct mn88473_dev *dev = i2c_get_clientdata(client);
+        int ret;
+
+        *status = 0;
+
+        if (!dev->warm) {
+                ret = -EAGAIN;
+                goto err;
+        }
+
+        *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
+                        FE_HAS_SYNC | FE_HAS_LOCK;
+
+        return 0;
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int mn88473_init(struct dvb_frontend *fe)
+{
+        struct i2c_client *client = fe->demodulator_priv;
+        struct mn88473_dev *dev = i2c_get_clientdata(client);
+        int ret, len, remaining;
+        const struct firmware *fw = NULL;
+        u8 *fw_file = MN88473_FIRMWARE;
+
+        dev_dbg(&client->dev, "\n");
+
+        if (dev->warm)
+                return 0;
+
+        /* request the firmware, this will block and timeout */
+        ret = request_firmware(&fw, fw_file, &client->dev);
+        if (ret) {
+                dev_err(&client->dev, "firmare file '%s' not found\n", fw_file);
+                goto err_request_firmware;
+        }
+
+        dev_info(&client->dev, "downloading firmware from file '%s'\n",
+                        fw_file);
+
+        ret = regmap_write(dev->regmap[0], 0xf5, 0x03);
+        if (ret)
+                goto err;
+
+        for (remaining = fw->size; remaining > 0;
+                        remaining -= (dev->i2c_wr_max - 1)) {
+                len = remaining;
+                if (len > (dev->i2c_wr_max - 1))
+                        len = (dev->i2c_wr_max - 1);
+
+                ret = regmap_bulk_write(dev->regmap[0], 0xf6,
+                                &fw->data[fw->size - remaining], len);
+                if (ret) {
+                        dev_err(&client->dev, "firmware download failed=%d\n",
+                                        ret);
+                        goto err;
+                }
+        }
+
+        ret = regmap_write(dev->regmap[0], 0xf5, 0x00);
+        if (ret)
+                goto err;
+
+        release_firmware(fw);
+        fw = NULL;
+
+        /* warm state */
+        dev->warm = true;
+
+        return 0;
+
+err:
+        release_firmware(fw);
+err_request_firmware:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int mn88473_sleep(struct dvb_frontend *fe)
+{
+        struct i2c_client *client = fe->demodulator_priv;
+        struct mn88473_dev *dev = i2c_get_clientdata(client);
+        int ret;
+
+        dev_dbg(&client->dev, "\n");
+
+        ret = regmap_write(dev->regmap[2], 0x05, 0x3e);
+        if (ret)
+                goto err;
+
+        dev->delivery_system = SYS_UNDEFINED;
+
+        return 0;
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static struct dvb_frontend_ops mn88473_ops = {
+        .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_AC},
+        .info = {
+                .name = "Panasonic MN88473",
+                .caps = FE_CAN_FEC_1_2                 |
+                        FE_CAN_FEC_2_3                 |
+                        FE_CAN_FEC_3_4                 |
+                        FE_CAN_FEC_5_6                 |
+                        FE_CAN_FEC_7_8                 |
+                        FE_CAN_FEC_AUTO                |
+                        FE_CAN_QPSK                    |
+                        FE_CAN_QAM_16                  |
+                        FE_CAN_QAM_32                  |
+                        FE_CAN_QAM_64                  |
+                        FE_CAN_QAM_128                 |
+                        FE_CAN_QAM_256                 |
+                        FE_CAN_QAM_AUTO                |
+                        FE_CAN_TRANSMISSION_MODE_AUTO  |
+                        FE_CAN_GUARD_INTERVAL_AUTO     |
+                        FE_CAN_HIERARCHY_AUTO          |
+                        FE_CAN_MUTE_TS                 |
+                        FE_CAN_2G_MODULATION           |
+                        FE_CAN_MULTISTREAM
+        },
+
+        .get_tune_settings = mn88473_get_tune_settings,
+
+        .init = mn88473_init,
+        .sleep = mn88473_sleep,
+
+        .set_frontend = mn88473_set_frontend,
+
+        .read_status = mn88473_read_status,
+};
+
+static int mn88473_probe(struct i2c_client *client,
+                const struct i2c_device_id *id)
+{
+        struct mn88473_config *config = client->dev.platform_data;
+        struct mn88473_dev *dev;
+        int ret;
+        unsigned int utmp;
+        static const struct regmap_config regmap_config = {
+                .reg_bits = 8,
+                .val_bits = 8,
+        };
+
+        dev_dbg(&client->dev, "\n");
+
+        /* Caller really need to provide pointer for frontend we create. */
+        if (config->fe == NULL) {
+                dev_err(&client->dev, "frontend pointer not defined\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (dev == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        dev->i2c_wr_max = config->i2c_wr_max;
+        dev->client[0] = client;
+        dev->regmap[0] = regmap_init_i2c(dev->client[0], &regmap_config);
+        if (IS_ERR(dev->regmap[0])) {
+                ret = PTR_ERR(dev->regmap[0]);
+                goto err_kfree;
+        }
+
+        /* check demod answers to I2C */
+        ret = regmap_read(dev->regmap[0], 0x00, &utmp);
+        if (ret)
+                goto err_regmap_0_regmap_exit;
+
+        /*
+         * Chip has three I2C addresses for different register pages. Used
+         * addresses are 0x18, 0x1a and 0x1c. We register two dummy clients,
+         * 0x1a and 0x1c, in order to get own I2C client for each register page.
+         */
+        dev->client[1] = i2c_new_dummy(client->adapter, 0x1a);
+        if (dev->client[1] == NULL) {
+                ret = -ENODEV;
+                dev_err(&client->dev, "I2C registration failed\n");
+                if (ret)
+                        goto err_regmap_0_regmap_exit;
+        }
+        dev->regmap[1] = regmap_init_i2c(dev->client[1], &regmap_config);
+        if (IS_ERR(dev->regmap[1])) {
+                ret = PTR_ERR(dev->regmap[1]);
+                goto err_client_1_i2c_unregister_device;
+        }
+        i2c_set_clientdata(dev->client[1], dev);
+
+        dev->client[2] = i2c_new_dummy(client->adapter, 0x1c);
+        if (dev->client[2] == NULL) {
+                ret = -ENODEV;
+                dev_err(&client->dev, "2nd I2C registration failed\n");
+                if (ret)
+                        goto err_regmap_1_regmap_exit;
+        }
+        dev->regmap[2] = regmap_init_i2c(dev->client[2], &regmap_config);
+        if (IS_ERR(dev->regmap[2])) {
+                ret = PTR_ERR(dev->regmap[2]);
+                goto err_client_2_i2c_unregister_device;
+        }
+        i2c_set_clientdata(dev->client[2], dev);
+
+        /* create dvb_frontend */
+        memcpy(&dev->fe.ops, &mn88473_ops, sizeof(struct dvb_frontend_ops));
+        dev->fe.demodulator_priv = client;
+        *config->fe = &dev->fe;
+        i2c_set_clientdata(client, dev);
+
+        dev_info(&dev->client[0]->dev, "Panasonic MN88473 successfully attached\n");
+        return 0;
+
+err_client_2_i2c_unregister_device:
+        i2c_unregister_device(dev->client[2]);
+err_regmap_1_regmap_exit:
+        regmap_exit(dev->regmap[1]);
+err_client_1_i2c_unregister_device:
+        i2c_unregister_device(dev->client[1]);
+err_regmap_0_regmap_exit:
+        regmap_exit(dev->regmap[0]);
+err_kfree:
+        kfree(dev);
+err:
+        dev_dbg(&client->dev, "failed=%d\n", ret);
+        return ret;
+}
+
+static int mn88473_remove(struct i2c_client *client)
+{
+        struct mn88473_dev *dev = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "\n");
+
+        regmap_exit(dev->regmap[2]);
+        i2c_unregister_device(dev->client[2]);
+
+        regmap_exit(dev->regmap[1]);
+        i2c_unregister_device(dev->client[1]);
+
+        regmap_exit(dev->regmap[0]);
+
+        kfree(dev);
+
+        return 0;
+}
+
+static const struct i2c_device_id mn88473_id_table[] = {
+        {"mn88473", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, mn88473_id_table);
+
+static struct i2c_driver mn88473_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "mn88473",
+        },
+        .probe          = mn88473_probe,
+        .remove         = mn88473_remove,
+        .id_table       = mn88473_id_table,
+};
+
+module_i2c_driver(mn88473_driver);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("Panasonic MN88473 DVB-T/T2/C demodulator driver");
+MODULE_LICENSE("GPL");
+MODULE_FIRMWARE(MN88473_FIRMWARE);
diff --git a/drivers/staging/media/mn88473/mn88473_priv.h b/drivers/staging/media/mn88473/mn88473_priv.h
new file mode 100644
index 000000000000..78af112fb41d
--- /dev/null
+++ b/drivers/staging/media/mn88473/mn88473_priv.h
@@ -0,0 +1,36 @@
+/*
+ * Panasonic MN88473 DVB-T/T2/C demodulator driver
+ *
+ * Copyright (C) 2014 Antti Palosaari <crope@iki.fi>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ */
+
+#ifndef MN88473_PRIV_H
+#define MN88473_PRIV_H
+
+#include "dvb_frontend.h"
+#include "mn88473.h"
+#include <linux/firmware.h>
+#include <linux/regmap.h>
+
+#define MN88473_FIRMWARE "dvb-demod-mn88473-01.fw"
+
+struct mn88473_dev {
+        struct i2c_client *client[3];
+        struct regmap *regmap[3];
+        struct dvb_frontend fe;
+        u16 i2c_wr_max;
+        fe_delivery_system_t delivery_system;
+        bool warm; /* FW running */
+};
+
+#endif
diff --git a/drivers/staging/media/omap24xx/Kconfig b/drivers/staging/media/omap24xx/Kconfig
deleted file mode 100644
index 82e569a21c46..000000000000
--- a/drivers/staging/media/omap24xx/Kconfig
+++ /dev/null
@@ -1,35 +0,0 @@
-config VIDEO_V4L2_INT_DEVICE
-       tristate
-
-config VIDEO_OMAP2
-        tristate "OMAP2 Camera Capture Interface driver (DEPRECATED)"
-        depends on VIDEO_DEV && ARCH_OMAP2
-        select VIDEOBUF_DMA_SG
-        select VIDEO_V4L2_INT_DEVICE
-        ---help---
-          This is a v4l2 driver for the TI OMAP2 camera capture interface
-
-          It uses the deprecated int-device API. Since this driver is no
-          longer actively maintained and nobody is interested in converting
-          it to the subdev API, this driver will be removed soon.
-
-          If you do want to keep this driver in the kernel, and are willing
-          to convert it to the subdev API, then please contact the linux-media
-          mailinglist.
-
-config VIDEO_TCM825X
-        tristate "TCM825x camera sensor support (DEPRECATED)"
-        depends on I2C && VIDEO_V4L2
-        depends on MEDIA_CAMERA_SUPPORT
-        select VIDEO_V4L2_INT_DEVICE
-        ---help---
-          This is a driver for the Toshiba TCM825x VGA camera sensor.
-          It is used for example in Nokia N800.
-
-          It uses the deprecated int-device API. Since this driver is no
-          longer actively maintained and nobody is interested in converting
-          it to the subdev API, this driver will be removed soon.
-
-          If you do want to keep this driver in the kernel, and are willing
-          to convert it to the subdev API, then please contact the linux-media
-          mailinglist.
diff --git a/drivers/staging/media/omap24xx/Makefile b/drivers/staging/media/omap24xx/Makefile
deleted file mode 100644
index c2e7175599c2..000000000000
--- a/drivers/staging/media/omap24xx/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-omap2cam-objs   :=      omap24xxcam.o omap24xxcam-dma.o
-
-obj-$(CONFIG_VIDEO_OMAP2)   += omap2cam.o
-obj-$(CONFIG_VIDEO_TCM825X) += tcm825x.o
-obj-$(CONFIG_VIDEO_V4L2_INT_DEVICE) += v4l2-int-device.o
diff --git a/drivers/staging/media/omap24xx/omap24xxcam-dma.c b/drivers/staging/media/omap24xx/omap24xxcam-dma.c
deleted file mode 100644
index c427eb94ea66..000000000000
--- a/drivers/staging/media/omap24xx/omap24xxcam-dma.c
+++ /dev/null
@@ -1,598 +0,0 @@
-/*
- * drivers/media/platform/omap24xxcam-dma.c
- *
- * Copyright (C) 2004 MontaVista Software, Inc.
- * Copyright (C) 2004 Texas Instruments.
- * Copyright (C) 2007 Nokia Corporation.
- *
- * Contact: Sakari Ailus <sakari.ailus@nokia.com>
- *
- * Based on code from Andy Lowe <source@mvista.com> and
- *                    David Cohen <david.cohen@indt.org.br>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#include <linux/kernel.h>
-#include <linux/io.h>
-#include <linux/scatterlist.h>
-
-#include "omap24xxcam.h"
-
-/*
- *
- * DMA hardware.
- *
- */
-
-/* Ack all interrupt on CSR and IRQSTATUS_L0 */
-static void omap24xxcam_dmahw_ack_all(void __iomem *base)
-{
-        u32 csr;
-        int i;
-
-        for (i = 0; i < NUM_CAMDMA_CHANNELS; ++i) {
-                csr = omap24xxcam_reg_in(base, CAMDMA_CSR(i));
-                /* ack interrupt in CSR */
-                omap24xxcam_reg_out(base, CAMDMA_CSR(i), csr);
-        }
-        omap24xxcam_reg_out(base, CAMDMA_IRQSTATUS_L0, 0xf);
-}
-
-/* Ack dmach on CSR and IRQSTATUS_L0 */
-static u32 omap24xxcam_dmahw_ack_ch(void __iomem *base, int dmach)
-{
-        u32 csr;
-
-        csr = omap24xxcam_reg_in(base, CAMDMA_CSR(dmach));
-        /* ack interrupt in CSR */
-        omap24xxcam_reg_out(base, CAMDMA_CSR(dmach), csr);
-        /* ack interrupt in IRQSTATUS */
-        omap24xxcam_reg_out(base, CAMDMA_IRQSTATUS_L0, (1 << dmach));
-
-        return csr;
-}
-
-static int omap24xxcam_dmahw_running(void __iomem *base, int dmach)
-{
-        return omap24xxcam_reg_in(base, CAMDMA_CCR(dmach)) & CAMDMA_CCR_ENABLE;
-}
-
-static void omap24xxcam_dmahw_transfer_setup(void __iomem *base, int dmach,
-                                             dma_addr_t start, u32 len)
-{
-        omap24xxcam_reg_out(base, CAMDMA_CCR(dmach),
-                            CAMDMA_CCR_SEL_SRC_DST_SYNC
-                            | CAMDMA_CCR_BS
-                            | CAMDMA_CCR_DST_AMODE_POST_INC
-                            | CAMDMA_CCR_SRC_AMODE_POST_INC
-                            | CAMDMA_CCR_FS
-                            | CAMDMA_CCR_WR_ACTIVE
-                            | CAMDMA_CCR_RD_ACTIVE
-                            | CAMDMA_CCR_SYNCHRO_CAMERA);
-        omap24xxcam_reg_out(base, CAMDMA_CLNK_CTRL(dmach), 0);
-        omap24xxcam_reg_out(base, CAMDMA_CEN(dmach), len);
-        omap24xxcam_reg_out(base, CAMDMA_CFN(dmach), 1);
-        omap24xxcam_reg_out(base, CAMDMA_CSDP(dmach),
-                            CAMDMA_CSDP_WRITE_MODE_POSTED
-                            | CAMDMA_CSDP_DST_BURST_EN_32
-                            | CAMDMA_CSDP_DST_PACKED
-                            | CAMDMA_CSDP_SRC_BURST_EN_32
-                            | CAMDMA_CSDP_SRC_PACKED
-                            | CAMDMA_CSDP_DATA_TYPE_8BITS);
-        omap24xxcam_reg_out(base, CAMDMA_CSSA(dmach), 0);
-        omap24xxcam_reg_out(base, CAMDMA_CDSA(dmach), start);
-        omap24xxcam_reg_out(base, CAMDMA_CSEI(dmach), 0);
-        omap24xxcam_reg_out(base, CAMDMA_CSFI(dmach), DMA_THRESHOLD);
-        omap24xxcam_reg_out(base, CAMDMA_CDEI(dmach), 0);
-        omap24xxcam_reg_out(base, CAMDMA_CDFI(dmach), 0);
-        omap24xxcam_reg_out(base, CAMDMA_CSR(dmach),
-                            CAMDMA_CSR_MISALIGNED_ERR
-                            | CAMDMA_CSR_SECURE_ERR
-                            | CAMDMA_CSR_TRANS_ERR
-                            | CAMDMA_CSR_BLOCK
-                            | CAMDMA_CSR_DROP);
-        omap24xxcam_reg_out(base, CAMDMA_CICR(dmach),
-                            CAMDMA_CICR_MISALIGNED_ERR_IE
-                            | CAMDMA_CICR_SECURE_ERR_IE
-                            | CAMDMA_CICR_TRANS_ERR_IE
-                            | CAMDMA_CICR_BLOCK_IE
-                            | CAMDMA_CICR_DROP_IE);
-}
-
-static void omap24xxcam_dmahw_transfer_start(void __iomem *base, int dmach)
-{
-        omap24xxcam_reg_out(base, CAMDMA_CCR(dmach),
-                            CAMDMA_CCR_SEL_SRC_DST_SYNC
-                            | CAMDMA_CCR_BS
-                            | CAMDMA_CCR_DST_AMODE_POST_INC
-                            | CAMDMA_CCR_SRC_AMODE_POST_INC
-                            | CAMDMA_CCR_ENABLE
-                            | CAMDMA_CCR_FS
-                            | CAMDMA_CCR_SYNCHRO_CAMERA);
-}
-
-static void omap24xxcam_dmahw_transfer_chain(void __iomem *base, int dmach,
-                                             int free_dmach)
-{
-        int prev_dmach, ch;
-
-        if (dmach == 0)
-                prev_dmach = NUM_CAMDMA_CHANNELS - 1;
-        else
-                prev_dmach = dmach - 1;
-        omap24xxcam_reg_out(base, CAMDMA_CLNK_CTRL(prev_dmach),
-                            CAMDMA_CLNK_CTRL_ENABLE_LNK | dmach);
-        /* Did we chain the DMA transfer before the previous one
-         * finished?
-         */
-        ch = (dmach + free_dmach) % NUM_CAMDMA_CHANNELS;
-        while (!(omap24xxcam_reg_in(base, CAMDMA_CCR(ch))
-                 & CAMDMA_CCR_ENABLE)) {
-                if (ch == dmach) {
-                        /* The previous transfer has ended and this one
-                         * hasn't started, so we must not have chained
-                         * to the previous one in time.  We'll have to
-                         * start it now.
-                         */
-                        omap24xxcam_dmahw_transfer_start(base, dmach);
-                        break;
-                }
-                ch = (ch + 1) % NUM_CAMDMA_CHANNELS;
-        }
-}
-
-/* Abort all chained DMA transfers. After all transfers have been
- * aborted and the DMA controller is idle, the completion routines for
- * any aborted transfers will be called in sequence. The DMA
- * controller may not be idle after this routine completes, because
- * the completion routines might start new transfers.
- */
-static void omap24xxcam_dmahw_abort_ch(void __iomem *base, int dmach)
-{
-        /* mask all interrupts from this channel */
-        omap24xxcam_reg_out(base, CAMDMA_CICR(dmach), 0);
-        /* unlink this channel */
-        omap24xxcam_reg_merge(base, CAMDMA_CLNK_CTRL(dmach), 0,
-                              CAMDMA_CLNK_CTRL_ENABLE_LNK);
-        /* disable this channel */
-        omap24xxcam_reg_merge(base, CAMDMA_CCR(dmach), 0, CAMDMA_CCR_ENABLE);
-}
-
-static void omap24xxcam_dmahw_init(void __iomem *base)
-{
-        omap24xxcam_reg_out(base, CAMDMA_OCP_SYSCONFIG,
-                            CAMDMA_OCP_SYSCONFIG_MIDLEMODE_FSTANDBY
-                            | CAMDMA_OCP_SYSCONFIG_SIDLEMODE_FIDLE
-                            | CAMDMA_OCP_SYSCONFIG_AUTOIDLE);
-
-        omap24xxcam_reg_merge(base, CAMDMA_GCR, 0x10,
-                              CAMDMA_GCR_MAX_CHANNEL_FIFO_DEPTH);
-
-        omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L0, 0xf);
-}
-
-/*
- *
- * Individual DMA channel handling.
- *
- */
-
-/* Start a DMA transfer from the camera to memory.
- * Returns zero if the transfer was successfully started, or non-zero if all
- * DMA channels are already in use or starting is currently inhibited.
- */
-static int omap24xxcam_dma_start(struct omap24xxcam_dma *dma, dma_addr_t start,
-                                 u32 len, dma_callback_t callback, void *arg)
-{
-        unsigned long flags;
-        int dmach;
-
-        spin_lock_irqsave(&dma->lock, flags);
-
-        if (!dma->free_dmach || atomic_read(&dma->dma_stop)) {
-                spin_unlock_irqrestore(&dma->lock, flags);
-                return -EBUSY;
-        }
-
-        dmach = dma->next_dmach;
-
-        dma->ch_state[dmach].callback = callback;
-        dma->ch_state[dmach].arg = arg;
-
-        omap24xxcam_dmahw_transfer_setup(dma->base, dmach, start, len);
-
-        /* We're ready to start the DMA transfer. */
-
-        if (dma->free_dmach < NUM_CAMDMA_CHANNELS) {
-                /* A transfer is already in progress, so try to chain to it. */
-                omap24xxcam_dmahw_transfer_chain(dma->base, dmach,
-                                                 dma->free_dmach);
-        } else {
-                /* No transfer is in progress, so we'll just start this one
-                 * now.
-                 */
-                omap24xxcam_dmahw_transfer_start(dma->base, dmach);
-        }
-
-        dma->next_dmach = (dma->next_dmach + 1) % NUM_CAMDMA_CHANNELS;
-        dma->free_dmach--;
-
-        spin_unlock_irqrestore(&dma->lock, flags);
-
-        return 0;
-}
-
-/* Abort all chained DMA transfers. After all transfers have been
- * aborted and the DMA controller is idle, the completion routines for
- * any aborted transfers will be called in sequence. The DMA
- * controller may not be idle after this routine completes, because
- * the completion routines might start new transfers.
- */
-static void omap24xxcam_dma_abort(struct omap24xxcam_dma *dma, u32 csr)
-{
-        unsigned long flags;
-        int dmach, i, free_dmach;
-        dma_callback_t callback;
-        void *arg;
-
-        spin_lock_irqsave(&dma->lock, flags);
-
-        /* stop any DMA transfers in progress */
-        dmach = (dma->next_dmach + dma->free_dmach) % NUM_CAMDMA_CHANNELS;
-        for (i = 0; i < NUM_CAMDMA_CHANNELS; i++) {
-                omap24xxcam_dmahw_abort_ch(dma->base, dmach);
-                dmach = (dmach + 1) % NUM_CAMDMA_CHANNELS;
-        }
-
-        /* We have to be careful here because the callback routine
-         * might start a new DMA transfer, and we only want to abort
-         * transfers that were started before this routine was called.
-         */
-        free_dmach = dma->free_dmach;
-        while ((dma->free_dmach < NUM_CAMDMA_CHANNELS) &&
-               (free_dmach < NUM_CAMDMA_CHANNELS)) {
-                dmach = (dma->next_dmach + dma->free_dmach)
-                        % NUM_CAMDMA_CHANNELS;
-                callback = dma->ch_state[dmach].callback;
-                arg = dma->ch_state[dmach].arg;
-                dma->free_dmach++;
-                free_dmach++;
-                if (callback) {
-                        /* leave interrupts disabled during callback */
-                        spin_unlock(&dma->lock);
-                        (*callback) (dma, csr, arg);
-                        spin_lock(&dma->lock);
-                }
-        }
-
-        spin_unlock_irqrestore(&dma->lock, flags);
-}
-
-/* Abort all chained DMA transfers. After all transfers have been
- * aborted and the DMA controller is idle, the completion routines for
- * any aborted transfers will be called in sequence. If the completion
- * routines attempt to start a new DMA transfer it will fail, so the
- * DMA controller will be idle after this routine completes.
- */
-static void omap24xxcam_dma_stop(struct omap24xxcam_dma *dma, u32 csr)
-{
-        atomic_inc(&dma->dma_stop);
-        omap24xxcam_dma_abort(dma, csr);
-        atomic_dec(&dma->dma_stop);
-}
-
-/* Camera DMA interrupt service routine. */
-void omap24xxcam_dma_isr(struct omap24xxcam_dma *dma)
-{
-        int dmach;
-        dma_callback_t callback;
-        void *arg;
-        u32 csr;
-        const u32 csr_error = CAMDMA_CSR_MISALIGNED_ERR
-                | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
-                | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
-
-        spin_lock(&dma->lock);
-
-        if (dma->free_dmach == NUM_CAMDMA_CHANNELS) {
-                /* A camera DMA interrupt occurred while all channels
-                 * are idle, so we'll acknowledge the interrupt in the
-                 * IRQSTATUS register and exit.
-                 */
-                omap24xxcam_dmahw_ack_all(dma->base);
-                spin_unlock(&dma->lock);
-                return;
-        }
-
-        while (dma->free_dmach < NUM_CAMDMA_CHANNELS) {
-                dmach = (dma->next_dmach + dma->free_dmach)
-                        % NUM_CAMDMA_CHANNELS;
-                if (omap24xxcam_dmahw_running(dma->base, dmach)) {
-                        /* This buffer hasn't finished yet, so we're done. */
-                        break;
-                }
-                csr = omap24xxcam_dmahw_ack_ch(dma->base, dmach);
-                if (csr & csr_error) {
-                        /* A DMA error occurred, so stop all DMA
-                         * transfers in progress.
-                         */
-                        spin_unlock(&dma->lock);
-                        omap24xxcam_dma_stop(dma, csr);
-                        return;
-                }
-                callback = dma->ch_state[dmach].callback;
-                arg = dma->ch_state[dmach].arg;
-                dma->free_dmach++;
-                if (callback) {
-                        spin_unlock(&dma->lock);
-                        (*callback) (dma, csr, arg);
-                        spin_lock(&dma->lock);
-                }
-        }
-
-        spin_unlock(&dma->lock);
-
-        omap24xxcam_sgdma_process(
-                container_of(dma, struct omap24xxcam_sgdma, dma));
-}
-
-void omap24xxcam_dma_hwinit(struct omap24xxcam_dma *dma)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&dma->lock, flags);
-
-        omap24xxcam_dmahw_init(dma->base);
-
-        spin_unlock_irqrestore(&dma->lock, flags);
-}
-
-static void omap24xxcam_dma_init(struct omap24xxcam_dma *dma,
-                                 void __iomem *base)
-{
-        int ch;
-
-        /* group all channels on DMA IRQ0 and unmask irq */
-        spin_lock_init(&dma->lock);
-        dma->base = base;
-        dma->free_dmach = NUM_CAMDMA_CHANNELS;
-        dma->next_dmach = 0;
-        for (ch = 0; ch < NUM_CAMDMA_CHANNELS; ch++) {
-                dma->ch_state[ch].callback = NULL;
-                dma->ch_state[ch].arg = NULL;
-        }
-}
-
-/*
- *
- * Scatter-gather DMA.
- *
- * High-level DMA construct for transferring whole picture frames to
- * memory that is discontinuous.
- *
- */
-
-/* DMA completion routine for the scatter-gather DMA fragments. */
-static void omap24xxcam_sgdma_callback(struct omap24xxcam_dma *dma, u32 csr,
-                                       void *arg)
-{
-        struct omap24xxcam_sgdma *sgdma =
-                container_of(dma, struct omap24xxcam_sgdma, dma);
-        int sgslot = (int)arg;
-        struct sgdma_state *sg_state;
-        const u32 csr_error = CAMDMA_CSR_MISALIGNED_ERR
-                | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
-                | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
-
-        spin_lock(&sgdma->lock);
-
-        /* We got an interrupt, we can remove the timer */
-        del_timer(&sgdma->reset_timer);
-
-        sg_state = sgdma->sg_state + sgslot;
-        if (!sg_state->queued_sglist) {
-                spin_unlock(&sgdma->lock);
-                printk(KERN_ERR "%s: sgdma completed when none queued!\n",
-                       __func__);
-                return;
-        }
-
-        sg_state->csr |= csr;
-        if (!--sg_state->queued_sglist) {
-                /* Queue for this sglist is empty, so check to see if we're
-                 * done.
-                 */
-                if ((sg_state->next_sglist == sg_state->sglen)
-                    || (sg_state->csr & csr_error)) {
-                        sgdma_callback_t callback = sg_state->callback;
-                        void *arg = sg_state->arg;
-                        u32 sg_csr = sg_state->csr;
-                        /* All done with this sglist */
-                        sgdma->free_sgdma++;
-                        if (callback) {
-                                spin_unlock(&sgdma->lock);
-                                (*callback) (sgdma, sg_csr, arg);
-                                return;
-                        }
-                }
-        }
-
-        spin_unlock(&sgdma->lock);
-}
-
-/* Start queued scatter-gather DMA transfers. */
-void omap24xxcam_sgdma_process(struct omap24xxcam_sgdma *sgdma)
-{
-        unsigned long flags;
-        int queued_sgdma, sgslot;
-        struct sgdma_state *sg_state;
-        const u32 csr_error = CAMDMA_CSR_MISALIGNED_ERR
-                | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
-                | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
-
-        spin_lock_irqsave(&sgdma->lock, flags);
-
-        queued_sgdma = NUM_SG_DMA - sgdma->free_sgdma;
-        sgslot = (sgdma->next_sgdma + sgdma->free_sgdma) % NUM_SG_DMA;
-        while (queued_sgdma > 0) {
-                sg_state = sgdma->sg_state + sgslot;
-                while ((sg_state->next_sglist < sg_state->sglen) &&
-                       !(sg_state->csr & csr_error)) {
-                        const struct scatterlist *sglist;
-                        unsigned int len;
-
-                        sglist = sg_state->sglist + sg_state->next_sglist;
-                        /* try to start the next DMA transfer */
-                        if (sg_state->next_sglist + 1 == sg_state->sglen) {
-                                /*
-                                 *  On the last sg, we handle the case where
-                                 *  cam->img.pix.sizeimage % PAGE_ALIGN != 0
-                                 */
-                                len = sg_state->len - sg_state->bytes_read;
-                        } else {
-                                len = sg_dma_len(sglist);
-                        }
-
-                        if (omap24xxcam_dma_start(&sgdma->dma,
-                                                  sg_dma_address(sglist),
-                                                  len,
-                                                  omap24xxcam_sgdma_callback,
-                                                  (void *)sgslot)) {
-                                /* DMA start failed */
-                                spin_unlock_irqrestore(&sgdma->lock, flags);
-                                return;
-                        }
-                        /* DMA start was successful */
-                        sg_state->next_sglist++;
-                        sg_state->bytes_read += len;
-                        sg_state->queued_sglist++;
-
-                        /* We start the reset timer */
-                        mod_timer(&sgdma->reset_timer, jiffies + HZ);
-                }
-                queued_sgdma--;
-                sgslot = (sgslot + 1) % NUM_SG_DMA;
-        }
-
-        spin_unlock_irqrestore(&sgdma->lock, flags);
-}
-
-/*
- * Queue a scatter-gather DMA transfer from the camera to memory.
- * Returns zero if the transfer was successfully queued, or non-zero
- * if all of the scatter-gather slots are already in use.
- */
-int omap24xxcam_sgdma_queue(struct omap24xxcam_sgdma *sgdma,
-                            const struct scatterlist *sglist, int sglen,
-                            int len, sgdma_callback_t callback, void *arg)
-{
-        unsigned long flags;
-        struct sgdma_state *sg_state;
-
-        if ((sglen < 0) || ((sglen > 0) && !sglist))
-                return -EINVAL;
-
-        spin_lock_irqsave(&sgdma->lock, flags);
-
-        if (!sgdma->free_sgdma) {
-                spin_unlock_irqrestore(&sgdma->lock, flags);
-                return -EBUSY;
-        }
-
-        sg_state = sgdma->sg_state + sgdma->next_sgdma;
-
-        sg_state->sglist = sglist;
-        sg_state->sglen = sglen;
-        sg_state->next_sglist = 0;
-        sg_state->bytes_read = 0;
-        sg_state->len = len;
-        sg_state->queued_sglist = 0;
-        sg_state->csr = 0;
-        sg_state->callback = callback;
-        sg_state->arg = arg;
-
-        sgdma->next_sgdma = (sgdma->next_sgdma + 1) % NUM_SG_DMA;
-        sgdma->free_sgdma--;
-
-        spin_unlock_irqrestore(&sgdma->lock, flags);
-
-        omap24xxcam_sgdma_process(sgdma);
-
-        return 0;
-}
-
-/* Sync scatter-gather DMA by aborting any DMA transfers currently in progress.
- * Any queued scatter-gather DMA transactions that have not yet been started
- * will remain queued.  The DMA controller will be idle after this routine
- * completes.  When the scatter-gather queue is restarted, the next
- * scatter-gather DMA transfer will begin at the start of a new transaction.
- */
-void omap24xxcam_sgdma_sync(struct omap24xxcam_sgdma *sgdma)
-{
-        unsigned long flags;
-        int sgslot;
-        struct sgdma_state *sg_state;
-        u32 csr = CAMDMA_CSR_TRANS_ERR;
-
-        /* stop any DMA transfers in progress */
-        omap24xxcam_dma_stop(&sgdma->dma, csr);
-
-        spin_lock_irqsave(&sgdma->lock, flags);
-
-        if (sgdma->free_sgdma < NUM_SG_DMA) {
-                sgslot = (sgdma->next_sgdma + sgdma->free_sgdma) % NUM_SG_DMA;
-                sg_state = sgdma->sg_state + sgslot;
-                if (sg_state->next_sglist != 0) {
-                        /* This DMA transfer was in progress, so abort it. */
-                        sgdma_callback_t callback = sg_state->callback;
-                        void *arg = sg_state->arg;
-
-                        sgdma->free_sgdma++;
-                        if (callback) {
-                                /* leave interrupts masked */
-                                spin_unlock(&sgdma->lock);
-                                (*callback) (sgdma, csr, arg);
-                                spin_lock(&sgdma->lock);
-                        }
-                }
-        }
-
-        spin_unlock_irqrestore(&sgdma->lock, flags);
-}
-
-void omap24xxcam_sgdma_init(struct omap24xxcam_sgdma *sgdma,
-                            void __iomem *base,
-                            void (*reset_callback)(unsigned long data),
-                            unsigned long reset_callback_data)
-{
-        int sg;
-
-        spin_lock_init(&sgdma->lock);
-        sgdma->free_sgdma = NUM_SG_DMA;
-        sgdma->next_sgdma = 0;
-        for (sg = 0; sg < NUM_SG_DMA; sg++) {
-                sgdma->sg_state[sg].sglen = 0;
-                sgdma->sg_state[sg].next_sglist = 0;
-                sgdma->sg_state[sg].bytes_read = 0;
-                sgdma->sg_state[sg].queued_sglist = 0;
-                sgdma->sg_state[sg].csr = 0;
-                sgdma->sg_state[sg].callback = NULL;
-                sgdma->sg_state[sg].arg = NULL;
-        }
-
-        omap24xxcam_dma_init(&sgdma->dma, base);
-        setup_timer(&sgdma->reset_timer, reset_callback, reset_callback_data);
-}
diff --git a/drivers/staging/media/omap24xx/omap24xxcam.c b/drivers/staging/media/omap24xx/omap24xxcam.c
deleted file mode 100644
index d590b3e8b70c..000000000000
--- a/drivers/staging/media/omap24xx/omap24xxcam.c
+++ /dev/null
@@ -1,1882 +0,0 @@
-/*
- * drivers/media/platform/omap24xxcam.c
- *
- * OMAP 2 camera block driver.
- *
- * Copyright (C) 2004 MontaVista Software, Inc.
- * Copyright (C) 2004 Texas Instruments.
- * Copyright (C) 2007-2008 Nokia Corporation.
- *
- * Contact: Sakari Ailus <sakari.ailus@nokia.com>
- *
- * Based on code from Andy Lowe <source@mvista.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#include <linux/delay.h>
-#include <linux/kernel.h>
-#include <linux/interrupt.h>
-#include <linux/videodev2.h>
-#include <linux/pci.h>          /* needed for videobufs */
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/io.h>
-#include <linux/slab.h>
-#include <linux/sched.h>
-#include <linux/module.h>
-
-#include <media/v4l2-common.h>
-#include <media/v4l2-ioctl.h>
-
-#include "omap24xxcam.h"
-
-#define OMAP24XXCAM_VERSION "0.0.1"
-
-#define RESET_TIMEOUT_NS 10000
-
-static void omap24xxcam_reset(struct omap24xxcam_device *cam);
-static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam);
-static void omap24xxcam_device_unregister(struct v4l2_int_device *s);
-static int omap24xxcam_remove(struct platform_device *pdev);
-
-/* module parameters */
-static int video_nr = -1;       /* video device minor (-1 ==> auto assign) */
-/*
- * Maximum amount of memory to use for capture buffers.
- * Default is 4800KB, enough to double-buffer SXGA.
- */
-static int capture_mem = 1280 * 960 * 2 * 2;
-
-static struct v4l2_int_device omap24xxcam;
-
-/*
- *
- * Clocks.
- *
- */
-
-static void omap24xxcam_clock_put(struct omap24xxcam_device *cam)
-{
-        if (cam->ick != NULL && !IS_ERR(cam->ick))
-                clk_put(cam->ick);
-        if (cam->fck != NULL && !IS_ERR(cam->fck))
-                clk_put(cam->fck);
-
-        cam->ick = cam->fck = NULL;
-}
-
-static int omap24xxcam_clock_get(struct omap24xxcam_device *cam)
-{
-        int rval = 0;
-
-        cam->fck = clk_get(cam->dev, "fck");
-        if (IS_ERR(cam->fck)) {
-                dev_err(cam->dev, "can't get camera fck");
-                rval = PTR_ERR(cam->fck);
-                omap24xxcam_clock_put(cam);
-                return rval;
-        }
-
-        cam->ick = clk_get(cam->dev, "ick");
-        if (IS_ERR(cam->ick)) {
-                dev_err(cam->dev, "can't get camera ick");
-                rval = PTR_ERR(cam->ick);
-                omap24xxcam_clock_put(cam);
-        }
-
-        return rval;
-}
-
-static void omap24xxcam_clock_on(struct omap24xxcam_device *cam)
-{
-        clk_enable(cam->fck);
-        clk_enable(cam->ick);
-}
-
-static void omap24xxcam_clock_off(struct omap24xxcam_device *cam)
-{
-        clk_disable(cam->fck);
-        clk_disable(cam->ick);
-}
-
-/*
- *
- * Camera core
- *
- */
-
-/*
- * Set xclk.
- *
- * To disable xclk, use value zero.
- */
-static void omap24xxcam_core_xclk_set(const struct omap24xxcam_device *cam,
-                                      u32 xclk)
-{
-        if (xclk) {
-                u32 divisor = CAM_MCLK / xclk;
-
-                if (divisor == 1)
-                        omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
-                                            CC_CTRL_XCLK,
-                                            CC_CTRL_XCLK_DIV_BYPASS);
-                else
-                        omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
-                                            CC_CTRL_XCLK, divisor);
-        } else
-                omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
-                                    CC_CTRL_XCLK, CC_CTRL_XCLK_DIV_STABLE_LOW);
-}
-
-static void omap24xxcam_core_hwinit(const struct omap24xxcam_device *cam)
-{
-        /*
-         * Setting the camera core AUTOIDLE bit causes problems with frame
-         * synchronization, so we will clear the AUTOIDLE bit instead.
-         */
-        omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_SYSCONFIG,
-                            CC_SYSCONFIG_AUTOIDLE);
-
-        /* program the camera interface DMA packet size */
-        omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL_DMA,
-                            CC_CTRL_DMA_EN | (DMA_THRESHOLD / 4 - 1));
-
-        /* enable camera core error interrupts */
-        omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_IRQENABLE,
-                            CC_IRQENABLE_FW_ERR_IRQ
-                            | CC_IRQENABLE_FSC_ERR_IRQ
-                            | CC_IRQENABLE_SSC_ERR_IRQ
-                            | CC_IRQENABLE_FIFO_OF_IRQ);
-}
-
-/*
- * Enable the camera core.
- *
- * Data transfer to the camera DMA starts from next starting frame.
- */
-static void omap24xxcam_core_enable(const struct omap24xxcam_device *cam)
-{
-
-        omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL,
-                            cam->cc_ctrl);
-}
-
-/*
- * Disable camera core.
- *
- * The data transfer will be stopped immediately (CC_CTRL_CC_RST). The
- * core internal state machines will be reset. Use
- * CC_CTRL_CC_FRAME_TRIG instead if you want to transfer the current
- * frame completely.
- */
-static void omap24xxcam_core_disable(const struct omap24xxcam_device *cam)
-{
-        omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL,
-                            CC_CTRL_CC_RST);
-}
-
-/* Interrupt service routine for camera core interrupts. */
-static void omap24xxcam_core_isr(struct omap24xxcam_device *cam)
-{
-        u32 cc_irqstatus;
-        const u32 cc_irqstatus_err =
-                CC_IRQSTATUS_FW_ERR_IRQ
-                | CC_IRQSTATUS_FSC_ERR_IRQ
-                | CC_IRQSTATUS_SSC_ERR_IRQ
-                | CC_IRQSTATUS_FIFO_UF_IRQ
-                | CC_IRQSTATUS_FIFO_OF_IRQ;
-
-        cc_irqstatus = omap24xxcam_reg_in(cam->mmio_base + CC_REG_OFFSET,
-                                          CC_IRQSTATUS);
-        omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_IRQSTATUS,
-                            cc_irqstatus);
-
-        if (cc_irqstatus & cc_irqstatus_err
-            && !atomic_read(&cam->in_reset)) {
-                dev_dbg(cam->dev, "resetting camera, cc_irqstatus 0x%x\n",
-                        cc_irqstatus);
-                omap24xxcam_reset(cam);
-        }
-}
-
-/*
- *
- * videobuf_buffer handling.
- *
- * Memory for mmapped videobuf_buffers is not allocated
- * conventionally, but by several kmalloc allocations and then
- * creating the scatterlist on our own. User-space buffers are handled
- * normally.
- *
- */
-
-/*
- * Free the memory-mapped buffer memory allocated for a
- * videobuf_buffer and the associated scatterlist.
- */
-static void omap24xxcam_vbq_free_mmap_buffer(struct videobuf_buffer *vb)
-{
-        struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
-        size_t alloc_size;
-        struct page *page;
-        int i;
-
-        if (dma->sglist == NULL)
-                return;
-
-        i = dma->sglen;
-        while (i) {
-                i--;
-                alloc_size = sg_dma_len(&dma->sglist[i]);
-                page = sg_page(&dma->sglist[i]);
-                do {
-                        ClearPageReserved(page++);
-                } while (alloc_size -= PAGE_SIZE);
-                __free_pages(sg_page(&dma->sglist[i]),
-                             get_order(sg_dma_len(&dma->sglist[i])));
-        }
-
-        kfree(dma->sglist);
-        dma->sglist = NULL;
-}
-
-/* Release all memory related to the videobuf_queue. */
-static void omap24xxcam_vbq_free_mmap_buffers(struct videobuf_queue *vbq)
-{
-        int i;
-
-        mutex_lock(&vbq->vb_lock);
-
-        for (i = 0; i < VIDEO_MAX_FRAME; i++) {
-                if (NULL == vbq->bufs[i])
-                        continue;
-                if (V4L2_MEMORY_MMAP != vbq->bufs[i]->memory)
-                        continue;
-                vbq->ops->buf_release(vbq, vbq->bufs[i]);
-                omap24xxcam_vbq_free_mmap_buffer(vbq->bufs[i]);
-                kfree(vbq->bufs[i]);
-                vbq->bufs[i] = NULL;
-        }
-
-        mutex_unlock(&vbq->vb_lock);
-
-        videobuf_mmap_free(vbq);
-}
-
-/*
- * Allocate physically as contiguous as possible buffer for video
- * frame and allocate and build DMA scatter-gather list for it.
- */
-static int omap24xxcam_vbq_alloc_mmap_buffer(struct videobuf_buffer *vb)
-{
-        unsigned int order;
-        size_t alloc_size, size = vb->bsize; /* vb->bsize is page aligned */
-        struct page *page;
-        int max_pages, err = 0, i = 0;
-        struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
-
-        /*
-         * allocate maximum size scatter-gather list. Note this is
-         * overhead. We may not use as many entries as we allocate
-         */
-        max_pages = vb->bsize >> PAGE_SHIFT;
-        dma->sglist = kcalloc(max_pages, sizeof(*dma->sglist), GFP_KERNEL);
-        if (dma->sglist == NULL) {
-                err = -ENOMEM;
-                goto out;
-        }
-
-        while (size) {
-                order = get_order(size);
-                /*
-                 * do not over-allocate even if we would get larger
-                 * contiguous chunk that way
-                 */
-                if ((PAGE_SIZE << order) > size)
-                        order--;
-
-                /* try to allocate as many contiguous pages as possible */
-                page = alloc_pages(GFP_KERNEL, order);
-                /* if allocation fails, try to allocate smaller amount */
-                while (page == NULL) {
-                        order--;
-                        page = alloc_pages(GFP_KERNEL, order);
-                        if (page == NULL && !order) {
-                                err = -ENOMEM;
-                                goto out;
-                        }
-                }
-                size -= (PAGE_SIZE << order);
-
-                /* append allocated chunk of pages into scatter-gather list */
-                sg_set_page(&dma->sglist[i], page, PAGE_SIZE << order, 0);
-                dma->sglen++;
-                i++;
-
-                alloc_size = (PAGE_SIZE << order);
-
-                /* clear pages before giving them to user space */
-                memset(page_address(page), 0, alloc_size);
-
-                /* mark allocated pages reserved */
-                do {
-                        SetPageReserved(page++);
-                } while (alloc_size -= PAGE_SIZE);
-        }
-        /*
-         * REVISIT: not fully correct to assign nr_pages == sglen but
-         * video-buf is passing nr_pages for e.g. unmap_sg calls
-         */
-        dma->nr_pages = dma->sglen;
-        dma->direction = PCI_DMA_FROMDEVICE;
-
-        return 0;
-
-out:
-        omap24xxcam_vbq_free_mmap_buffer(vb);
-        return err;
-}
-
-static int omap24xxcam_vbq_alloc_mmap_buffers(struct videobuf_queue *vbq,
-                                              unsigned int count)
-{
-        int i, err = 0;
-        struct omap24xxcam_fh *fh =
-                container_of(vbq, struct omap24xxcam_fh, vbq);
-
-        mutex_lock(&vbq->vb_lock);
-
-        for (i = 0; i < count; i++) {
-                err = omap24xxcam_vbq_alloc_mmap_buffer(vbq->bufs[i]);
-                if (err)
-                        goto out;
-                dev_dbg(fh->cam->dev, "sglen is %d for buffer %d\n",
-                        videobuf_to_dma(vbq->bufs[i])->sglen, i);
-        }
-
-        mutex_unlock(&vbq->vb_lock);
-
-        return 0;
-out:
-        while (i) {
-                i--;
-                omap24xxcam_vbq_free_mmap_buffer(vbq->bufs[i]);
-        }
-
-        mutex_unlock(&vbq->vb_lock);
-
-        return err;
-}
-
-/*
- * This routine is called from interrupt context when a scatter-gather DMA
- * transfer of a videobuf_buffer completes.
- */
-static void omap24xxcam_vbq_complete(struct omap24xxcam_sgdma *sgdma,
-                                     u32 csr, void *arg)
-{
-        struct omap24xxcam_device *cam =
-                container_of(sgdma, struct omap24xxcam_device, sgdma);
-        struct omap24xxcam_fh *fh = cam->streaming->private_data;
-        struct videobuf_buffer *vb = (struct videobuf_buffer *)arg;
-        const u32 csr_error = CAMDMA_CSR_MISALIGNED_ERR
-                | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
-                | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
-        unsigned long flags;
-
-        spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
-        if (--cam->sgdma_in_queue == 0)
-                omap24xxcam_core_disable(cam);
-        spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
-
-        v4l2_get_timestamp(&vb->ts);
-        vb->field_count = atomic_add_return(2, &fh->field_count);
-        if (csr & csr_error) {
-                vb->state = VIDEOBUF_ERROR;
-                if (!atomic_read(&fh->cam->in_reset)) {
-                        dev_dbg(cam->dev, "resetting camera, csr 0x%x\n", csr);
-                        omap24xxcam_reset(cam);
-                }
-        } else
-                vb->state = VIDEOBUF_DONE;
-        wake_up(&vb->done);
-}
-
-static void omap24xxcam_vbq_release(struct videobuf_queue *vbq,
-                                    struct videobuf_buffer *vb)
-{
-        struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
-
-        /* wait for buffer, especially to get out of the sgdma queue */
-        videobuf_waiton(vbq, vb, 0, 0);
-        if (vb->memory == V4L2_MEMORY_MMAP) {
-                dma_unmap_sg(vbq->dev, dma->sglist, dma->sglen,
-                             dma->direction);
-                dma->direction = DMA_NONE;
-        } else {
-                videobuf_dma_unmap(vbq->dev, videobuf_to_dma(vb));
-                videobuf_dma_free(videobuf_to_dma(vb));
-        }
-
-        vb->state = VIDEOBUF_NEEDS_INIT;
-}
-
-/*
- * Limit the number of available kernel image capture buffers based on the
- * number requested, the currently selected image size, and the maximum
- * amount of memory permitted for kernel capture buffers.
- */
-static int omap24xxcam_vbq_setup(struct videobuf_queue *vbq, unsigned int *cnt,
-                                 unsigned int *size)
-{
-        struct omap24xxcam_fh *fh = vbq->priv_data;
-
-        if (*cnt <= 0)
-                *cnt = VIDEO_MAX_FRAME; /* supply a default number of buffers */
-
-        if (*cnt > VIDEO_MAX_FRAME)
-                *cnt = VIDEO_MAX_FRAME;
-
-        *size = fh->pix.sizeimage;
-
-        /* accessing fh->cam->capture_mem is ok, it's constant */
-        if (*size * *cnt > fh->cam->capture_mem)
-                *cnt = fh->cam->capture_mem / *size;
-
-        return 0;
-}
-
-static int omap24xxcam_dma_iolock(struct videobuf_queue *vbq,
-                                  struct videobuf_dmabuf *dma)
-{
-        int err = 0;
-
-        dma->direction = PCI_DMA_FROMDEVICE;
-        if (!dma_map_sg(vbq->dev, dma->sglist, dma->sglen, dma->direction)) {
-                kfree(dma->sglist);
-                dma->sglist = NULL;
-                dma->sglen = 0;
-                err = -EIO;
-        }
-
-        return err;
-}
-
-static int omap24xxcam_vbq_prepare(struct videobuf_queue *vbq,
-                                   struct videobuf_buffer *vb,
-                                   enum v4l2_field field)
-{
-        struct omap24xxcam_fh *fh = vbq->priv_data;
-        int err = 0;
-
-        /*
-         * Accessing pix here is okay since it's constant while
-         * streaming is on (and we only get called then).
-         */
-        if (vb->baddr) {
-                /* This is a userspace buffer. */
-                if (fh->pix.sizeimage > vb->bsize) {
-                        /* The buffer isn't big enough. */
-                        err = -EINVAL;
-                } else
-                        vb->size = fh->pix.sizeimage;
-        } else {
-                if (vb->state != VIDEOBUF_NEEDS_INIT) {
-                        /*
-                         * We have a kernel bounce buffer that has
-                         * already been allocated.
-                         */
-                        if (fh->pix.sizeimage > vb->size) {
-                                /*
-                                 * The image size has been changed to
-                                 * a larger size since this buffer was
-                                 * allocated, so we need to free and
-                                 * reallocate it.
-                                 */
-                                omap24xxcam_vbq_release(vbq, vb);
-                                vb->size = fh->pix.sizeimage;
-                        }
-                } else {
-                        /* We need to allocate a new kernel bounce buffer. */
-                        vb->size = fh->pix.sizeimage;
-                }
-        }
-
-        if (err)
-                return err;
-
-        vb->width = fh->pix.width;
-        vb->height = fh->pix.height;
-        vb->field = field;
-
-        if (vb->state == VIDEOBUF_NEEDS_INIT) {
-                if (vb->memory == V4L2_MEMORY_MMAP)
-                        /*
-                         * we have built the scatter-gather list by ourself so
-                         * do the scatter-gather mapping as well
-                         */
-                        err = omap24xxcam_dma_iolock(vbq, videobuf_to_dma(vb));
-                else
-                        err = videobuf_iolock(vbq, vb, NULL);
-        }
-
-        if (!err)
-                vb->state = VIDEOBUF_PREPARED;
-        else
-                omap24xxcam_vbq_release(vbq, vb);
-
-        return err;
-}
-
-static void omap24xxcam_vbq_queue(struct videobuf_queue *vbq,
-                                  struct videobuf_buffer *vb)
-{
-        struct omap24xxcam_fh *fh = vbq->priv_data;
-        struct omap24xxcam_device *cam = fh->cam;
-        enum videobuf_state state = vb->state;
-        unsigned long flags;
-        int err;
-
-        /*
-         * FIXME: We're marking the buffer active since we have no
-         * pretty way of marking it active exactly when the
-         * scatter-gather transfer starts.
-         */
-        vb->state = VIDEOBUF_ACTIVE;
-
-        err = omap24xxcam_sgdma_queue(&fh->cam->sgdma,
-                                      videobuf_to_dma(vb)->sglist,
-                                      videobuf_to_dma(vb)->sglen, vb->size,
-                                      omap24xxcam_vbq_complete, vb);
-
-        if (!err) {
-                spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
-                if (++cam->sgdma_in_queue == 1
-                    && !atomic_read(&cam->in_reset))
-                        omap24xxcam_core_enable(cam);
-                spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
-        } else {
-                /*
-                 * Oops. We're not supposed to get any errors here.
-                 * The only way we could get an error is if we ran out
-                 * of scatter-gather DMA slots, but we are supposed to
-                 * have at least as many scatter-gather DMA slots as
-                 * video buffers so that can't happen.
-                 */
-                dev_err(cam->dev, "failed to queue a video buffer for dma!\n");
-                dev_err(cam->dev, "likely a bug in the driver!\n");
-                vb->state = state;
-        }
-}
-
-static struct videobuf_queue_ops omap24xxcam_vbq_ops = {
-        .buf_setup   = omap24xxcam_vbq_setup,
-        .buf_prepare = omap24xxcam_vbq_prepare,
-        .buf_queue   = omap24xxcam_vbq_queue,
-        .buf_release = omap24xxcam_vbq_release,
-};
-
-/*
- *
- * OMAP main camera system
- *
- */
-
-/*
- * Reset camera block to power-on state.
- */
-static void omap24xxcam_poweron_reset(struct omap24xxcam_device *cam)
-{
-        int max_loop = RESET_TIMEOUT_NS;
-
-        /* Reset whole camera subsystem */
-        omap24xxcam_reg_out(cam->mmio_base,
-                            CAM_SYSCONFIG,
-                            CAM_SYSCONFIG_SOFTRESET);
-
-        /* Wait till it's finished */
-        while (!(omap24xxcam_reg_in(cam->mmio_base, CAM_SYSSTATUS)
-                 & CAM_SYSSTATUS_RESETDONE)
-               && --max_loop) {
-                ndelay(1);
-        }
-
-        if (!(omap24xxcam_reg_in(cam->mmio_base, CAM_SYSSTATUS)
-              & CAM_SYSSTATUS_RESETDONE))
-                dev_err(cam->dev, "camera soft reset timeout\n");
-}
-
-/*
- * (Re)initialise the camera block.
- */
-static void omap24xxcam_hwinit(struct omap24xxcam_device *cam)
-{
-        omap24xxcam_poweron_reset(cam);
-
-        /* set the camera subsystem autoidle bit */
-        omap24xxcam_reg_out(cam->mmio_base, CAM_SYSCONFIG,
-                            CAM_SYSCONFIG_AUTOIDLE);
-
-        /* set the camera MMU autoidle bit */
-        omap24xxcam_reg_out(cam->mmio_base,
-                            CAMMMU_REG_OFFSET + CAMMMU_SYSCONFIG,
-                            CAMMMU_SYSCONFIG_AUTOIDLE);
-
-        omap24xxcam_core_hwinit(cam);
-
-        omap24xxcam_dma_hwinit(&cam->sgdma.dma);
-}
-
-/*
- * Callback for dma transfer stalling.
- */
-static void omap24xxcam_stalled_dma_reset(unsigned long data)
-{
-        struct omap24xxcam_device *cam = (struct omap24xxcam_device *)data;
-
-        if (!atomic_read(&cam->in_reset)) {
-                dev_dbg(cam->dev, "dma stalled, resetting camera\n");
-                omap24xxcam_reset(cam);
-        }
-}
-
-/*
- * Stop capture. Mark we're doing a reset, stop DMA transfers and
- * core. (No new scatter-gather transfers will be queued whilst
- * in_reset is non-zero.)
- *
- * If omap24xxcam_capture_stop is called from several places at
- * once, only the first call will have an effect. Similarly, the last
- * call omap24xxcam_streaming_cont will have effect.
- *
- * Serialisation is ensured by using cam->core_enable_disable_lock.
- */
-static void omap24xxcam_capture_stop(struct omap24xxcam_device *cam)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
-
-        if (atomic_inc_return(&cam->in_reset) != 1) {
-                spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
-                return;
-        }
-
-        omap24xxcam_core_disable(cam);
-
-        spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
-
-        omap24xxcam_sgdma_sync(&cam->sgdma);
-}
-
-/*
- * Reset and continue streaming.
- *
- * Note: Resetting the camera FIFO via the CC_RST bit in the CC_CTRL
- * register is supposed to be sufficient to recover from a camera
- * interface error, but it doesn't seem to be enough. If we only do
- * that then subsequent image captures are out of sync by either one
- * or two times DMA_THRESHOLD bytes. Resetting and re-initializing the
- * entire camera subsystem prevents the problem with frame
- * synchronization.
- */
-static void omap24xxcam_capture_cont(struct omap24xxcam_device *cam)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
-
-        if (atomic_read(&cam->in_reset) != 1)
-                goto out;
-
-        omap24xxcam_hwinit(cam);
-
-        omap24xxcam_sensor_if_enable(cam);
-
-        omap24xxcam_sgdma_process(&cam->sgdma);
-
-        if (cam->sgdma_in_queue)
-                omap24xxcam_core_enable(cam);
-
-out:
-        atomic_dec(&cam->in_reset);
-        spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
-}
-
-static ssize_t
-omap24xxcam_streaming_show(struct device *dev, struct device_attribute *attr,
-                char *buf)
-{
-        struct omap24xxcam_device *cam = dev_get_drvdata(dev);
-
-        return sprintf(buf, "%s\n", cam->streaming ?  "active" : "inactive");
-}
-static DEVICE_ATTR(streaming, S_IRUGO, omap24xxcam_streaming_show, NULL);
-
-/*
- * Stop capture and restart it. I.e. reset the camera during use.
- */
-static void omap24xxcam_reset(struct omap24xxcam_device *cam)
-{
-        omap24xxcam_capture_stop(cam);
-        omap24xxcam_capture_cont(cam);
-}
-
-/*
- * The main interrupt handler.
- */
-static irqreturn_t omap24xxcam_isr(int irq, void *arg)
-{
-        struct omap24xxcam_device *cam = (struct omap24xxcam_device *)arg;
-        u32 irqstatus;
-        unsigned int irqhandled = 0;
-
-        irqstatus = omap24xxcam_reg_in(cam->mmio_base, CAM_IRQSTATUS);
-
-        if (irqstatus &
-            (CAM_IRQSTATUS_DMA_IRQ2 | CAM_IRQSTATUS_DMA_IRQ1
-             | CAM_IRQSTATUS_DMA_IRQ0)) {
-                omap24xxcam_dma_isr(&cam->sgdma.dma);
-                irqhandled = 1;
-        }
-        if (irqstatus & CAM_IRQSTATUS_CC_IRQ) {
-                omap24xxcam_core_isr(cam);
-                irqhandled = 1;
-        }
-        if (irqstatus & CAM_IRQSTATUS_MMU_IRQ)
-                dev_err(cam->dev, "unhandled camera MMU interrupt!\n");
-
-        return IRQ_RETVAL(irqhandled);
-}
-
-/*
- *
- * Sensor handling.
- *
- */
-
-/*
- * Enable the external sensor interface. Try to negotiate interface
- * parameters with the sensor and start using the new ones. The calls
- * to sensor_if_enable and sensor_if_disable need not to be balanced.
- */
-static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam)
-{
-        int rval;
-        struct v4l2_ifparm p;
-
-        rval = vidioc_int_g_ifparm(cam->sdev, &p);
-        if (rval) {
-                dev_err(cam->dev, "vidioc_int_g_ifparm failed with %d\n", rval);
-                return rval;
-        }
-
-        cam->if_type = p.if_type;
-
-        cam->cc_ctrl = CC_CTRL_CC_EN;
-
-        switch (p.if_type) {
-        case V4L2_IF_TYPE_BT656:
-                if (p.u.bt656.frame_start_on_rising_vs)
-                        cam->cc_ctrl |= CC_CTRL_NOBT_SYNCHRO;
-                if (p.u.bt656.bt_sync_correct)
-                        cam->cc_ctrl |= CC_CTRL_BT_CORRECT;
-                if (p.u.bt656.swap)
-                        cam->cc_ctrl |= CC_CTRL_PAR_ORDERCAM;
-                if (p.u.bt656.latch_clk_inv)
-                        cam->cc_ctrl |= CC_CTRL_PAR_CLK_POL;
-                if (p.u.bt656.nobt_hs_inv)
-                        cam->cc_ctrl |= CC_CTRL_NOBT_HS_POL;
-                if (p.u.bt656.nobt_vs_inv)
-                        cam->cc_ctrl |= CC_CTRL_NOBT_VS_POL;
-
-                switch (p.u.bt656.mode) {
-                case V4L2_IF_TYPE_BT656_MODE_NOBT_8BIT:
-                        cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT8;
-                        break;
-                case V4L2_IF_TYPE_BT656_MODE_NOBT_10BIT:
-                        cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT10;
-                        break;
-                case V4L2_IF_TYPE_BT656_MODE_NOBT_12BIT:
-                        cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT12;
-                        break;
-                case V4L2_IF_TYPE_BT656_MODE_BT_8BIT:
-                        cam->cc_ctrl |= CC_CTRL_PAR_MODE_BT8;
-                        break;
-                case V4L2_IF_TYPE_BT656_MODE_BT_10BIT:
-                        cam->cc_ctrl |= CC_CTRL_PAR_MODE_BT10;
-                        break;
-                default:
-                        dev_err(cam->dev,
-                                "bt656 interface mode %d not supported\n",
-                                p.u.bt656.mode);
-                        return -EINVAL;
-                }
-                /*
-                 * The clock rate that the sensor wants has changed.
-                 * We have to adjust the xclk from OMAP 2 side to
-                 * match the sensor's wish as closely as possible.
-                 */
-                if (p.u.bt656.clock_curr != cam->if_u.bt656.xclk) {
-                        u32 xclk = p.u.bt656.clock_curr;
-                        u32 divisor;
-
-                        if (xclk == 0)
-                                return -EINVAL;
-
-                        if (xclk > CAM_MCLK)
-                                xclk = CAM_MCLK;
-
-                        divisor = CAM_MCLK / xclk;
-                        if (divisor * xclk < CAM_MCLK)
-                                divisor++;
-                        if (CAM_MCLK / divisor < p.u.bt656.clock_min
-                            && divisor > 1)
-                                divisor--;
-                        if (divisor > 30)
-                                divisor = 30;
-
-                        xclk = CAM_MCLK / divisor;
-
-                        if (xclk < p.u.bt656.clock_min
-                            || xclk > p.u.bt656.clock_max)
-                                return -EINVAL;
-
-                        cam->if_u.bt656.xclk = xclk;
-                }
-                omap24xxcam_core_xclk_set(cam, cam->if_u.bt656.xclk);
-                break;
-        default:
-                /* FIXME: how about other interfaces? */
-                dev_err(cam->dev, "interface type %d not supported\n",
-                        p.if_type);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-static void omap24xxcam_sensor_if_disable(const struct omap24xxcam_device *cam)
-{
-        switch (cam->if_type) {
-        case V4L2_IF_TYPE_BT656:
-                omap24xxcam_core_xclk_set(cam, 0);
-                break;
-        }
-}
-
-/*
- * Initialise the sensor hardware.
- */
-static int omap24xxcam_sensor_init(struct omap24xxcam_device *cam)
-{
-        int err = 0;
-        struct v4l2_int_device *sdev = cam->sdev;
-
-        omap24xxcam_clock_on(cam);
-        err = omap24xxcam_sensor_if_enable(cam);
-        if (err) {
-                dev_err(cam->dev, "sensor interface could not be enabled at "
-                        "initialisation, %d\n", err);
-                cam->sdev = NULL;
-                goto out;
-        }
-
-        /* power up sensor during sensor initialization */
-        vidioc_int_s_power(sdev, 1);
-
-        err = vidioc_int_dev_init(sdev);
-        if (err) {
-                dev_err(cam->dev, "cannot initialize sensor, error %d\n", err);
-                /* Sensor init failed --- it's nonexistent to us! */
-                cam->sdev = NULL;
-                goto out;
-        }
-
-        dev_info(cam->dev, "sensor is %s\n", sdev->name);
-
-out:
-        omap24xxcam_sensor_if_disable(cam);
-        omap24xxcam_clock_off(cam);
-
-        vidioc_int_s_power(sdev, 0);
-
-        return err;
-}
-
-static void omap24xxcam_sensor_exit(struct omap24xxcam_device *cam)
-{
-        if (cam->sdev)
-                vidioc_int_dev_exit(cam->sdev);
-}
-
-static void omap24xxcam_sensor_disable(struct omap24xxcam_device *cam)
-{
-        omap24xxcam_sensor_if_disable(cam);
-        omap24xxcam_clock_off(cam);
-        vidioc_int_s_power(cam->sdev, 0);
-}
-
-/*
- * Power-up and configure camera sensor. It's ready for capturing now.
- */
-static int omap24xxcam_sensor_enable(struct omap24xxcam_device *cam)
-{
-        int rval;
-
-        omap24xxcam_clock_on(cam);
-
-        omap24xxcam_sensor_if_enable(cam);
-
-        rval = vidioc_int_s_power(cam->sdev, 1);
-        if (rval)
-                goto out;
-
-        rval = vidioc_int_init(cam->sdev);
-        if (rval)
-                goto out;
-
-        return 0;
-
-out:
-        omap24xxcam_sensor_disable(cam);
-
-        return rval;
-}
-
-static void omap24xxcam_sensor_reset_work(struct work_struct *work)
-{
-        struct omap24xxcam_device *cam =
-                container_of(work, struct omap24xxcam_device,
-                             sensor_reset_work);
-
-        if (atomic_read(&cam->reset_disable))
-                return;
-
-        omap24xxcam_capture_stop(cam);
-
-        if (vidioc_int_reset(cam->sdev) == 0) {
-                vidioc_int_init(cam->sdev);
-        } else {
-                /* Can't reset it by vidioc_int_reset. */
-                omap24xxcam_sensor_disable(cam);
-                omap24xxcam_sensor_enable(cam);
-        }
-
-        omap24xxcam_capture_cont(cam);
-}
-
-/*
- *
- * IOCTL interface.
- *
- */
-
-static int vidioc_querycap(struct file *file, void *fh,
-                           struct v4l2_capability *cap)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-
-        strlcpy(cap->driver, CAM_NAME, sizeof(cap->driver));
-        strlcpy(cap->card, cam->vfd->name, sizeof(cap->card));
-        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
-
-        return 0;
-}
-
-static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
-                                   struct v4l2_fmtdesc *f)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-
-        return vidioc_int_enum_fmt_cap(cam->sdev, f);
-}
-
-static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
-                                struct v4l2_format *f)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        rval = vidioc_int_g_fmt_cap(cam->sdev, f);
-        mutex_unlock(&cam->mutex);
-
-        return rval;
-}
-
-static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
-                                struct v4l2_format *f)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        if (cam->streaming) {
-                rval = -EBUSY;
-                goto out;
-        }
-
-        rval = vidioc_int_s_fmt_cap(cam->sdev, f);
-
-out:
-        mutex_unlock(&cam->mutex);
-
-        if (!rval) {
-                mutex_lock(&ofh->vbq.vb_lock);
-                ofh->pix = f->fmt.pix;
-                mutex_unlock(&ofh->vbq.vb_lock);
-        }
-
-        memset(f, 0, sizeof(*f));
-        vidioc_g_fmt_vid_cap(file, fh, f);
-
-        return rval;
-}
-
-static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
-                                  struct v4l2_format *f)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        rval = vidioc_int_try_fmt_cap(cam->sdev, f);
-        mutex_unlock(&cam->mutex);
-
-        return rval;
-}
-
-static int vidioc_reqbufs(struct file *file, void *fh,
-                          struct v4l2_requestbuffers *b)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        if (cam->streaming) {
-                mutex_unlock(&cam->mutex);
-                return -EBUSY;
-        }
-
-        omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
-        mutex_unlock(&cam->mutex);
-
-        rval = videobuf_reqbufs(&ofh->vbq, b);
-
-        /*
-         * Either videobuf_reqbufs failed or the buffers are not
-         * memory-mapped (which would need special attention).
-         */
-        if (rval < 0 || b->memory != V4L2_MEMORY_MMAP)
-                goto out;
-
-        rval = omap24xxcam_vbq_alloc_mmap_buffers(&ofh->vbq, rval);
-        if (rval)
-                omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
-
-out:
-        return rval;
-}
-
-static int vidioc_querybuf(struct file *file, void *fh,
-                           struct v4l2_buffer *b)
-{
-        struct omap24xxcam_fh *ofh = fh;
-
-        return videobuf_querybuf(&ofh->vbq, b);
-}
-
-static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
-{
-        struct omap24xxcam_fh *ofh = fh;
-
-        return videobuf_qbuf(&ofh->vbq, b);
-}
-
-static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        struct videobuf_buffer *vb;
-        int rval;
-
-videobuf_dqbuf_again:
-        rval = videobuf_dqbuf(&ofh->vbq, b, file->f_flags & O_NONBLOCK);
-        if (rval)
-                goto out;
-
-        vb = ofh->vbq.bufs[b->index];
-
-        mutex_lock(&cam->mutex);
-        /* _needs_reset returns -EIO if reset is required. */
-        rval = vidioc_int_g_needs_reset(cam->sdev, (void *)vb->baddr);
-        mutex_unlock(&cam->mutex);
-        if (rval == -EIO)
-                schedule_work(&cam->sensor_reset_work);
-        else
-                rval = 0;
-
-out:
-        /*
-         * This is a hack. We don't want to show -EIO to the user
-         * space. Requeue the buffer and try again if we're not doing
-         * this in non-blocking mode.
-         */
-        if (rval == -EIO) {
-                videobuf_qbuf(&ofh->vbq, b);
-                if (!(file->f_flags & O_NONBLOCK))
-                        goto videobuf_dqbuf_again;
-                /*
-                 * We don't have a videobuf_buffer now --- maybe next
-                 * time...
-                 */
-                rval = -EAGAIN;
-        }
-
-        return rval;
-}
-
-static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        if (cam->streaming) {
-                rval = -EBUSY;
-                goto out;
-        }
-
-        rval = omap24xxcam_sensor_if_enable(cam);
-        if (rval) {
-                dev_dbg(cam->dev, "vidioc_int_g_ifparm failed\n");
-                goto out;
-        }
-
-        rval = videobuf_streamon(&ofh->vbq);
-        if (!rval) {
-                cam->streaming = file;
-                sysfs_notify(&cam->dev->kobj, NULL, "streaming");
-        }
-
-out:
-        mutex_unlock(&cam->mutex);
-
-        return rval;
-}
-
-static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        struct videobuf_queue *q = &ofh->vbq;
-        int rval;
-
-        atomic_inc(&cam->reset_disable);
-
-        flush_work(&cam->sensor_reset_work);
-
-        rval = videobuf_streamoff(q);
-        if (!rval) {
-                mutex_lock(&cam->mutex);
-                cam->streaming = NULL;
-                mutex_unlock(&cam->mutex);
-                sysfs_notify(&cam->dev->kobj, NULL, "streaming");
-        }
-
-        atomic_dec(&cam->reset_disable);
-
-        return rval;
-}
-
-static int vidioc_enum_input(struct file *file, void *fh,
-                             struct v4l2_input *inp)
-{
-        if (inp->index > 0)
-                return -EINVAL;
-
-        strlcpy(inp->name, "camera", sizeof(inp->name));
-        inp->type = V4L2_INPUT_TYPE_CAMERA;
-
-        return 0;
-}
-
-static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
-{
-        *i = 0;
-
-        return 0;
-}
-
-static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
-{
-        if (i > 0)
-                return -EINVAL;
-
-        return 0;
-}
-
-static int vidioc_queryctrl(struct file *file, void *fh,
-                            struct v4l2_queryctrl *a)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-
-        return vidioc_int_queryctrl(cam->sdev, a);
-}
-
-static int vidioc_g_ctrl(struct file *file, void *fh,
-                         struct v4l2_control *a)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        rval = vidioc_int_g_ctrl(cam->sdev, a);
-        mutex_unlock(&cam->mutex);
-
-        return rval;
-}
-
-static int vidioc_s_ctrl(struct file *file, void *fh,
-                         struct v4l2_control *a)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        rval = vidioc_int_s_ctrl(cam->sdev, a);
-        mutex_unlock(&cam->mutex);
-
-        return rval;
-}
-
-static int vidioc_g_parm(struct file *file, void *fh,
-                         struct v4l2_streamparm *a) {
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        rval = vidioc_int_g_parm(cam->sdev, a);
-        mutex_unlock(&cam->mutex);
-
-        return rval;
-}
-
-static int vidioc_s_parm(struct file *file, void *fh,
-                         struct v4l2_streamparm *a)
-{
-        struct omap24xxcam_fh *ofh = fh;
-        struct omap24xxcam_device *cam = ofh->cam;
-        struct v4l2_streamparm old_streamparm;
-        int rval;
-
-        mutex_lock(&cam->mutex);
-        if (cam->streaming) {
-                rval = -EBUSY;
-                goto out;
-        }
-
-        old_streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-        rval = vidioc_int_g_parm(cam->sdev, &old_streamparm);
-        if (rval)
-                goto out;
-
-        rval = vidioc_int_s_parm(cam->sdev, a);
-        if (rval)
-                goto out;
-
-        rval = omap24xxcam_sensor_if_enable(cam);
-        /*
-         * Revert to old streaming parameters if enabling sensor
-         * interface with the new ones failed.
-         */
-        if (rval)
-                vidioc_int_s_parm(cam->sdev, &old_streamparm);
-
-out:
-        mutex_unlock(&cam->mutex);
-
-        return rval;
-}
-
-/*
- *
- * File operations.
- *
- */
-
-static unsigned int omap24xxcam_poll(struct file *file,
-                                     struct poll_table_struct *wait)
-{
-        struct omap24xxcam_fh *fh = file->private_data;
-        struct omap24xxcam_device *cam = fh->cam;
-        struct videobuf_buffer *vb;
-
-        mutex_lock(&cam->mutex);
-        if (cam->streaming != file) {
-                mutex_unlock(&cam->mutex);
-                return POLLERR;
-        }
-        mutex_unlock(&cam->mutex);
-
-        mutex_lock(&fh->vbq.vb_lock);
-        if (list_empty(&fh->vbq.stream)) {
-                mutex_unlock(&fh->vbq.vb_lock);
-                return POLLERR;
-        }
-        vb = list_entry(fh->vbq.stream.next, struct videobuf_buffer, stream);
-        mutex_unlock(&fh->vbq.vb_lock);
-
-        poll_wait(file, &vb->done, wait);
-
-        if (vb->state == VIDEOBUF_DONE || vb->state == VIDEOBUF_ERROR)
-                return POLLIN | POLLRDNORM;
-
-        return 0;
-}
-
-static int omap24xxcam_mmap_buffers(struct file *file,
-                                    struct vm_area_struct *vma)
-{
-        struct omap24xxcam_fh *fh = file->private_data;
-        struct omap24xxcam_device *cam = fh->cam;
-        struct videobuf_queue *vbq = &fh->vbq;
-        unsigned int first, last, size, i, j;
-        int err = 0;
-
-        mutex_lock(&cam->mutex);
-        if (cam->streaming) {
-                mutex_unlock(&cam->mutex);
-                return -EBUSY;
-        }
-        mutex_unlock(&cam->mutex);
-        mutex_lock(&vbq->vb_lock);
-
-        /* look for first buffer to map */
-        for (first = 0; first < VIDEO_MAX_FRAME; first++) {
-                if (NULL == vbq->bufs[first])
-                        continue;
-                if (V4L2_MEMORY_MMAP != vbq->bufs[first]->memory)
-                        continue;
-                if (vbq->bufs[first]->boff == (vma->vm_pgoff << PAGE_SHIFT))
-                        break;
-        }
-
-        /* look for last buffer to map */
-        for (size = 0, last = first; last < VIDEO_MAX_FRAME; last++) {
-                if (NULL == vbq->bufs[last])
-                        continue;
-                if (V4L2_MEMORY_MMAP != vbq->bufs[last]->memory)
-                        continue;
-                size += vbq->bufs[last]->bsize;
-                if (size == (vma->vm_end - vma->vm_start))
-                        break;
-        }
-
-        size = 0;
-        for (i = first; i <= last && i < VIDEO_MAX_FRAME; i++) {
-                struct videobuf_dmabuf *dma = videobuf_to_dma(vbq->bufs[i]);
-
-                for (j = 0; j < dma->sglen; j++) {
-                        err = remap_pfn_range(
-                                vma, vma->vm_start + size,
-                                page_to_pfn(sg_page(&dma->sglist[j])),
-                                sg_dma_len(&dma->sglist[j]), vma->vm_page_prot);
-                        if (err)
-                                goto out;
-                        size += sg_dma_len(&dma->sglist[j]);
-                }
-        }
-
-out:
-        mutex_unlock(&vbq->vb_lock);
-
-        return err;
-}
-
-static int omap24xxcam_mmap(struct file *file, struct vm_area_struct *vma)
-{
-        struct omap24xxcam_fh *fh = file->private_data;
-        int rval;
-
-        /* let the video-buf mapper check arguments and set-up structures */
-        rval = videobuf_mmap_mapper(&fh->vbq, vma);
-        if (rval)
-                return rval;
-
-        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-
-        /* do mapping to our allocated buffers */
-        rval = omap24xxcam_mmap_buffers(file, vma);
-        /*
-         * In case of error, free vma->vm_private_data allocated by
-         * videobuf_mmap_mapper.
-         */
-        if (rval)
-                kfree(vma->vm_private_data);
-
-        return rval;
-}
-
-static int omap24xxcam_open(struct file *file)
-{
-        struct omap24xxcam_device *cam = omap24xxcam.priv;
-        struct omap24xxcam_fh *fh;
-        struct v4l2_format format;
-
-        if (!cam || !cam->vfd)
-                return -ENODEV;
-
-        fh = kzalloc(sizeof(*fh), GFP_KERNEL);
-        if (fh == NULL)
-                return -ENOMEM;
-
-        mutex_lock(&cam->mutex);
-        if (cam->sdev == NULL || !try_module_get(cam->sdev->module)) {
-                mutex_unlock(&cam->mutex);
-                goto out_try_module_get;
-        }
-
-        if (atomic_inc_return(&cam->users) == 1) {
-                omap24xxcam_hwinit(cam);
-                if (omap24xxcam_sensor_enable(cam)) {
-                        mutex_unlock(&cam->mutex);
-                        goto out_omap24xxcam_sensor_enable;
-                }
-        }
-        mutex_unlock(&cam->mutex);
-
-        fh->cam = cam;
-        mutex_lock(&cam->mutex);
-        vidioc_int_g_fmt_cap(cam->sdev, &format);
-        mutex_unlock(&cam->mutex);
-        /* FIXME: how about fh->pix when there are more users? */
-        fh->pix = format.fmt.pix;
-
-        file->private_data = fh;
-
-        spin_lock_init(&fh->vbq_lock);
-
-        videobuf_queue_sg_init(&fh->vbq, &omap24xxcam_vbq_ops, NULL,
-                                &fh->vbq_lock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                                V4L2_FIELD_NONE,
-                                sizeof(struct videobuf_buffer), fh, NULL);
-
-        return 0;
-
-out_omap24xxcam_sensor_enable:
-        omap24xxcam_poweron_reset(cam);
-        module_put(cam->sdev->module);
-
-out_try_module_get:
-        kfree(fh);
-
-        return -ENODEV;
-}
-
-static int omap24xxcam_release(struct file *file)
-{
-        struct omap24xxcam_fh *fh = file->private_data;
-        struct omap24xxcam_device *cam = fh->cam;
-
-        atomic_inc(&cam->reset_disable);
-
-        flush_work(&cam->sensor_reset_work);
-
-        /* stop streaming capture */
-        videobuf_streamoff(&fh->vbq);
-
-        mutex_lock(&cam->mutex);
-        if (cam->streaming == file) {
-                cam->streaming = NULL;
-                mutex_unlock(&cam->mutex);
-                sysfs_notify(&cam->dev->kobj, NULL, "streaming");
-        } else {
-                mutex_unlock(&cam->mutex);
-        }
-
-        atomic_dec(&cam->reset_disable);
-
-        omap24xxcam_vbq_free_mmap_buffers(&fh->vbq);
-
-        /*
-         * Make sure the reset work we might have scheduled is not
-         * pending! It may be run *only* if we have users. (And it may
-         * not be scheduled anymore since streaming is already
-         * disabled.)
-         */
-        flush_work(&cam->sensor_reset_work);
-
-        mutex_lock(&cam->mutex);
-        if (atomic_dec_return(&cam->users) == 0) {
-                omap24xxcam_sensor_disable(cam);
-                omap24xxcam_poweron_reset(cam);
-        }
-        mutex_unlock(&cam->mutex);
-
-        file->private_data = NULL;
-
-        module_put(cam->sdev->module);
-        kfree(fh);
-
-        return 0;
-}
-
-static struct v4l2_file_operations omap24xxcam_fops = {
-        .ioctl   = video_ioctl2,
-        .poll    = omap24xxcam_poll,
-        .mmap    = omap24xxcam_mmap,
-        .open    = omap24xxcam_open,
-        .release = omap24xxcam_release,
-};
-
-/*
- *
- * Power management.
- *
- */
-
-#ifdef CONFIG_PM
-static int omap24xxcam_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
-
-        if (atomic_read(&cam->users) == 0)
-                return 0;
-
-        if (!atomic_read(&cam->reset_disable))
-                omap24xxcam_capture_stop(cam);
-
-        omap24xxcam_sensor_disable(cam);
-        omap24xxcam_poweron_reset(cam);
-
-        return 0;
-}
-
-static int omap24xxcam_resume(struct platform_device *pdev)
-{
-        struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
-
-        if (atomic_read(&cam->users) == 0)
-                return 0;
-
-        omap24xxcam_hwinit(cam);
-        omap24xxcam_sensor_enable(cam);
-
-        if (!atomic_read(&cam->reset_disable))
-                omap24xxcam_capture_cont(cam);
-
-        return 0;
-}
-#endif /* CONFIG_PM */
-
-static const struct v4l2_ioctl_ops omap24xxcam_ioctl_fops = {
-        .vidioc_querycap        = vidioc_querycap,
-        .vidioc_enum_fmt_vid_cap        = vidioc_enum_fmt_vid_cap,
-        .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
-        .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
-        .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
-        .vidioc_reqbufs         = vidioc_reqbufs,
-        .vidioc_querybuf        = vidioc_querybuf,
-        .vidioc_qbuf            = vidioc_qbuf,
-        .vidioc_dqbuf           = vidioc_dqbuf,
-        .vidioc_streamon        = vidioc_streamon,
-        .vidioc_streamoff       = vidioc_streamoff,
-        .vidioc_enum_input      = vidioc_enum_input,
-        .vidioc_g_input         = vidioc_g_input,
-        .vidioc_s_input         = vidioc_s_input,
-        .vidioc_queryctrl       = vidioc_queryctrl,
-        .vidioc_g_ctrl          = vidioc_g_ctrl,
-        .vidioc_s_ctrl          = vidioc_s_ctrl,
-        .vidioc_g_parm          = vidioc_g_parm,
-        .vidioc_s_parm          = vidioc_s_parm,
-};
-
-/*
- *
- * Camera device (i.e. /dev/video).
- *
- */
-
-static int omap24xxcam_device_register(struct v4l2_int_device *s)
-{
-        struct omap24xxcam_device *cam = s->u.slave->master->priv;
-        struct video_device *vfd;
-        int rval;
-
-        /* We already have a slave. */
-        if (cam->sdev)
-                return -EBUSY;
-
-        cam->sdev = s;
-
-        if (device_create_file(cam->dev, &dev_attr_streaming) != 0) {
-                dev_err(cam->dev, "could not register sysfs entry\n");
-                rval = -EBUSY;
-                goto err;
-        }
-
-        /* initialize the video_device struct */
-        vfd = cam->vfd = video_device_alloc();
-        if (!vfd) {
-                dev_err(cam->dev, "could not allocate video device struct\n");
-                rval = -ENOMEM;
-                goto err;
-        }
-        vfd->release = video_device_release;
-
-        vfd->v4l2_dev = &cam->v4l2_dev;
-
-        strlcpy(vfd->name, CAM_NAME, sizeof(vfd->name));
-        vfd->fops                = &omap24xxcam_fops;
-        vfd->ioctl_ops           = &omap24xxcam_ioctl_fops;
-
-        omap24xxcam_hwinit(cam);
-
-        rval = omap24xxcam_sensor_init(cam);
-        if (rval)
-                goto err;
-
-        if (video_register_device(vfd, VFL_TYPE_GRABBER, video_nr) < 0) {
-                dev_err(cam->dev, "could not register V4L device\n");
-                rval = -EBUSY;
-                goto err;
-        }
-
-        omap24xxcam_poweron_reset(cam);
-
-        dev_info(cam->dev, "registered device %s\n",
-                 video_device_node_name(vfd));
-
-        return 0;
-
-err:
-        omap24xxcam_device_unregister(s);
-
-        return rval;
-}
-
-static void omap24xxcam_device_unregister(struct v4l2_int_device *s)
-{
-        struct omap24xxcam_device *cam = s->u.slave->master->priv;
-
-        omap24xxcam_sensor_exit(cam);
-
-        if (cam->vfd) {
-                if (!video_is_registered(cam->vfd)) {
-                        /*
-                         * The device was never registered, so release the
-                         * video_device struct directly.
-                         */
-                        video_device_release(cam->vfd);
-                } else {
-                        /*
-                         * The unregister function will release the
-                         * video_device struct as well as
-                         * unregistering it.
-                         */
-                        video_unregister_device(cam->vfd);
-                }
-                cam->vfd = NULL;
-        }
-
-        device_remove_file(cam->dev, &dev_attr_streaming);
-
-        cam->sdev = NULL;
-}
-
-static struct v4l2_int_master omap24xxcam_master = {
-        .attach = omap24xxcam_device_register,
-        .detach = omap24xxcam_device_unregister,
-};
-
-static struct v4l2_int_device omap24xxcam = {
-        .module = THIS_MODULE,
-        .name   = CAM_NAME,
-        .type   = v4l2_int_type_master,
-        .u      = {
-                .master = &omap24xxcam_master
-        },
-};
-
-/*
- *
- * Driver initialisation and deinitialisation.
- *
- */
-
-static int omap24xxcam_probe(struct platform_device *pdev)
-{
-        struct omap24xxcam_device *cam;
-        struct resource *mem;
-        int irq;
-
-        cam = kzalloc(sizeof(*cam), GFP_KERNEL);
-        if (!cam) {
-                dev_err(&pdev->dev, "could not allocate memory\n");
-                goto err;
-        }
-
-        platform_set_drvdata(pdev, cam);
-
-        cam->dev = &pdev->dev;
-
-        if (v4l2_device_register(&pdev->dev, &cam->v4l2_dev)) {
-                dev_err(&pdev->dev, "v4l2_device_register failed\n");
-                goto err;
-        }
-
-        /*
-         * Impose a lower limit on the amount of memory allocated for
-         * capture. We require at least enough memory to double-buffer
-         * QVGA (300KB).
-         */
-        if (capture_mem < 320 * 240 * 2 * 2)
-                capture_mem = 320 * 240 * 2 * 2;
-        cam->capture_mem = capture_mem;
-
-        /* request the mem region for the camera registers */
-        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!mem) {
-                dev_err(cam->dev, "no mem resource?\n");
-                goto err;
-        }
-        if (!request_mem_region(mem->start, resource_size(mem), pdev->name)) {
-                dev_err(cam->dev,
-                        "cannot reserve camera register I/O region\n");
-                goto err;
-        }
-        cam->mmio_base_phys = mem->start;
-        cam->mmio_size = resource_size(mem);
-
-        /* map the region */
-        cam->mmio_base = ioremap_nocache(cam->mmio_base_phys, cam->mmio_size);
-        if (!cam->mmio_base) {
-                dev_err(cam->dev, "cannot map camera register I/O region\n");
-                goto err;
-        }
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq <= 0) {
-                dev_err(cam->dev, "no irq for camera?\n");
-                goto err;
-        }
-
-        /* install the interrupt service routine */
-        if (request_irq(irq, omap24xxcam_isr, 0, CAM_NAME, cam)) {
-                dev_err(cam->dev,
-                        "could not install interrupt service routine\n");
-                goto err;
-        }
-        cam->irq = irq;
-
-        if (omap24xxcam_clock_get(cam))
-                goto err;
-
-        INIT_WORK(&cam->sensor_reset_work, omap24xxcam_sensor_reset_work);
-
-        mutex_init(&cam->mutex);
-        spin_lock_init(&cam->core_enable_disable_lock);
-
-        omap24xxcam_sgdma_init(&cam->sgdma,
-                               cam->mmio_base + CAMDMA_REG_OFFSET,
-                               omap24xxcam_stalled_dma_reset,
-                               (unsigned long)cam);
-
-        omap24xxcam.priv = cam;
-
-        if (v4l2_int_device_register(&omap24xxcam))
-                goto err;
-
-        return 0;
-
-err:
-        omap24xxcam_remove(pdev);
-        return -ENODEV;
-}
-
-static int omap24xxcam_remove(struct platform_device *pdev)
-{
-        struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
-
-        if (!cam)
-                return 0;
-
-        if (omap24xxcam.priv != NULL)
-                v4l2_int_device_unregister(&omap24xxcam);
-        omap24xxcam.priv = NULL;
-
-        omap24xxcam_clock_put(cam);
-
-        if (cam->irq) {
-                free_irq(cam->irq, cam);
-                cam->irq = 0;
-        }
-
-        if (cam->mmio_base) {
-                iounmap((void *)cam->mmio_base);
-                cam->mmio_base = 0;
-        }
-
-        if (cam->mmio_base_phys) {
-                release_mem_region(cam->mmio_base_phys, cam->mmio_size);
-                cam->mmio_base_phys = 0;
-        }
-
-        v4l2_device_unregister(&cam->v4l2_dev);
-
-        kfree(cam);
-
-        return 0;
-}
-
-static struct platform_driver omap24xxcam_driver = {
-        .probe   = omap24xxcam_probe,
-        .remove  = omap24xxcam_remove,
-#ifdef CONFIG_PM
-        .suspend = omap24xxcam_suspend,
-        .resume  = omap24xxcam_resume,
-#endif
-        .driver  = {
-                .name = CAM_NAME,
-                .owner = THIS_MODULE,
-        },
-};
-
-module_platform_driver(omap24xxcam_driver);
-
-MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
-MODULE_DESCRIPTION("OMAP24xx Video for Linux camera driver");
-MODULE_LICENSE("GPL");
-MODULE_VERSION(OMAP24XXCAM_VERSION);
-module_param(video_nr, int, 0);
-MODULE_PARM_DESC(video_nr,
-                 "Minor number for video device (-1 ==> auto assign)");
-module_param(capture_mem, int, 0);
-MODULE_PARM_DESC(capture_mem, "Maximum amount of memory for capture "
-                 "buffers (default 4800kiB)");
diff --git a/drivers/staging/media/omap24xx/omap24xxcam.h b/drivers/staging/media/omap24xx/omap24xxcam.h
deleted file mode 100644
index 233bb40cfec3..000000000000
--- a/drivers/staging/media/omap24xx/omap24xxcam.h
+++ /dev/null
@@ -1,596 +0,0 @@
-/*
- * drivers/media/platform/omap24xxcam.h
- *
- * Copyright (C) 2004 MontaVista Software, Inc.
- * Copyright (C) 2004 Texas Instruments.
- * Copyright (C) 2007 Nokia Corporation.
- *
- * Contact: Sakari Ailus <sakari.ailus@nokia.com>
- *
- * Based on code from Andy Lowe <source@mvista.com>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#ifndef OMAP24XXCAM_H
-#define OMAP24XXCAM_H
-
-#include <media/videobuf-dma-sg.h>
-#include <media/v4l2-device.h>
-#include "v4l2-int-device.h"
-
-/*
- *
- * General driver related definitions.
- *
- */
-
-#define CAM_NAME                                "omap24xxcam"
-
-#define CAM_MCLK                                96000000
-
-/* number of bytes transferred per DMA request */
-#define DMA_THRESHOLD                           32
-
-/*
- * NUM_CAMDMA_CHANNELS is the number of logical channels provided by
- * the camera DMA controller.
- */
-#define NUM_CAMDMA_CHANNELS                     4
-
-/*
- * NUM_SG_DMA is the number of scatter-gather DMA transfers that can
- * be queued. (We don't have any overlay sglists now.)
- */
-#define NUM_SG_DMA                              (VIDEO_MAX_FRAME)
-
-/*
- *
- * Register definitions.
- *
- */
-
-/* subsystem register block offsets */
-#define CC_REG_OFFSET                           0x00000400
-#define CAMDMA_REG_OFFSET                       0x00000800
-#define CAMMMU_REG_OFFSET                       0x00000C00
-
-/* define camera subsystem register offsets */
-#define CAM_REVISION                            0x000
-#define CAM_SYSCONFIG                           0x010
-#define CAM_SYSSTATUS                           0x014
-#define CAM_IRQSTATUS                           0x018
-#define CAM_GPO                                 0x040
-#define CAM_GPI                                 0x050
-
-/* define camera core register offsets */
-#define CC_REVISION                             0x000
-#define CC_SYSCONFIG                            0x010
-#define CC_SYSSTATUS                            0x014
-#define CC_IRQSTATUS                            0x018
-#define CC_IRQENABLE                            0x01C
-#define CC_CTRL                                 0x040
-#define CC_CTRL_DMA                             0x044
-#define CC_CTRL_XCLK                            0x048
-#define CC_FIFODATA                             0x04C
-#define CC_TEST                                 0x050
-#define CC_GENPAR                               0x054
-#define CC_CCPFSCR                              0x058
-#define CC_CCPFECR                              0x05C
-#define CC_CCPLSCR                              0x060
-#define CC_CCPLECR                              0x064
-#define CC_CCPDFR                               0x068
-
-/* define camera dma register offsets */
-#define CAMDMA_REVISION                         0x000
-#define CAMDMA_IRQSTATUS_L0                     0x008
-#define CAMDMA_IRQSTATUS_L1                     0x00C
-#define CAMDMA_IRQSTATUS_L2                     0x010
-#define CAMDMA_IRQSTATUS_L3                     0x014
-#define CAMDMA_IRQENABLE_L0                     0x018
-#define CAMDMA_IRQENABLE_L1                     0x01C
-#define CAMDMA_IRQENABLE_L2                     0x020
-#define CAMDMA_IRQENABLE_L3                     0x024
-#define CAMDMA_SYSSTATUS                        0x028
-#define CAMDMA_OCP_SYSCONFIG                    0x02C
-#define CAMDMA_CAPS_0                           0x064
-#define CAMDMA_CAPS_2                           0x06C
-#define CAMDMA_CAPS_3                           0x070
-#define CAMDMA_CAPS_4                           0x074
-#define CAMDMA_GCR                              0x078
-#define CAMDMA_CCR(n)                           (0x080 + (n)*0x60)
-#define CAMDMA_CLNK_CTRL(n)                     (0x084 + (n)*0x60)
-#define CAMDMA_CICR(n)                          (0x088 + (n)*0x60)
-#define CAMDMA_CSR(n)                           (0x08C + (n)*0x60)
-#define CAMDMA_CSDP(n)                          (0x090 + (n)*0x60)
-#define CAMDMA_CEN(n)                           (0x094 + (n)*0x60)
-#define CAMDMA_CFN(n)                           (0x098 + (n)*0x60)
-#define CAMDMA_CSSA(n)                          (0x09C + (n)*0x60)
-#define CAMDMA_CDSA(n)                          (0x0A0 + (n)*0x60)
-#define CAMDMA_CSEI(n)                          (0x0A4 + (n)*0x60)
-#define CAMDMA_CSFI(n)                          (0x0A8 + (n)*0x60)
-#define CAMDMA_CDEI(n)                          (0x0AC + (n)*0x60)
-#define CAMDMA_CDFI(n)                          (0x0B0 + (n)*0x60)
-#define CAMDMA_CSAC(n)                          (0x0B4 + (n)*0x60)
-#define CAMDMA_CDAC(n)                          (0x0B8 + (n)*0x60)
-#define CAMDMA_CCEN(n)                          (0x0BC + (n)*0x60)
-#define CAMDMA_CCFN(n)                          (0x0C0 + (n)*0x60)
-#define CAMDMA_COLOR(n)                         (0x0C4 + (n)*0x60)
-
-/* define camera mmu register offsets */
-#define CAMMMU_REVISION                         0x000
-#define CAMMMU_SYSCONFIG                        0x010
-#define CAMMMU_SYSSTATUS                        0x014
-#define CAMMMU_IRQSTATUS                        0x018
-#define CAMMMU_IRQENABLE                        0x01C
-#define CAMMMU_WALKING_ST                       0x040
-#define CAMMMU_CNTL                             0x044
-#define CAMMMU_FAULT_AD                         0x048
-#define CAMMMU_TTB                              0x04C
-#define CAMMMU_LOCK                             0x050
-#define CAMMMU_LD_TLB                           0x054
-#define CAMMMU_CAM                              0x058
-#define CAMMMU_RAM                              0x05C
-#define CAMMMU_GFLUSH                           0x060
-#define CAMMMU_FLUSH_ENTRY                      0x064
-#define CAMMMU_READ_CAM                         0x068
-#define CAMMMU_READ_RAM                         0x06C
-#define CAMMMU_EMU_FAULT_AD                     0x070
-
-/* Define bit fields within selected registers */
-#define CAM_REVISION_MAJOR                      (15 << 4)
-#define CAM_REVISION_MAJOR_SHIFT                4
-#define CAM_REVISION_MINOR                      (15 << 0)
-#define CAM_REVISION_MINOR_SHIFT                0
-
-#define CAM_SYSCONFIG_SOFTRESET                 (1 <<  1)
-#define CAM_SYSCONFIG_AUTOIDLE                  (1 <<  0)
-
-#define CAM_SYSSTATUS_RESETDONE                 (1 <<  0)
-
-#define CAM_IRQSTATUS_CC_IRQ                    (1 <<  4)
-#define CAM_IRQSTATUS_MMU_IRQ                   (1 <<  3)
-#define CAM_IRQSTATUS_DMA_IRQ2                  (1 <<  2)
-#define CAM_IRQSTATUS_DMA_IRQ1                  (1 <<  1)
-#define CAM_IRQSTATUS_DMA_IRQ0                  (1 <<  0)
-
-#define CAM_GPO_CAM_S_P_EN                      (1 <<  1)
-#define CAM_GPO_CAM_CCP_MODE                    (1 <<  0)
-
-#define CAM_GPI_CC_DMA_REQ1                     (1 << 24)
-#define CAP_GPI_CC_DMA_REQ0                     (1 << 23)
-#define CAP_GPI_CAM_MSTANDBY                    (1 << 21)
-#define CAP_GPI_CAM_WAIT                        (1 << 20)
-#define CAP_GPI_CAM_S_DATA                      (1 << 17)
-#define CAP_GPI_CAM_S_CLK                       (1 << 16)
-#define CAP_GPI_CAM_P_DATA                      (0xFFF << 3)
-#define CAP_GPI_CAM_P_DATA_SHIFT                3
-#define CAP_GPI_CAM_P_VS                        (1 <<  2)
-#define CAP_GPI_CAM_P_HS                        (1 <<  1)
-#define CAP_GPI_CAM_P_CLK                       (1 <<  0)
-
-#define CC_REVISION_MAJOR                       (15 << 4)
-#define CC_REVISION_MAJOR_SHIFT                 4
-#define CC_REVISION_MINOR                       (15 << 0)
-#define CC_REVISION_MINOR_SHIFT                 0
-
-#define CC_SYSCONFIG_SIDLEMODE                  (3 <<  3)
-#define CC_SYSCONFIG_SIDLEMODE_FIDLE            (0 <<  3)
-#define CC_SYSCONFIG_SIDLEMODE_NIDLE            (1 <<  3)
-#define CC_SYSCONFIG_SOFTRESET                  (1 <<  1)
-#define CC_SYSCONFIG_AUTOIDLE                   (1 <<  0)
-
-#define CC_SYSSTATUS_RESETDONE                  (1 <<  0)
-
-#define CC_IRQSTATUS_FS_IRQ                     (1 << 19)
-#define CC_IRQSTATUS_LE_IRQ                     (1 << 18)
-#define CC_IRQSTATUS_LS_IRQ                     (1 << 17)
-#define CC_IRQSTATUS_FE_IRQ                     (1 << 16)
-#define CC_IRQSTATUS_FW_ERR_IRQ                 (1 << 10)
-#define CC_IRQSTATUS_FSC_ERR_IRQ                (1 <<  9)
-#define CC_IRQSTATUS_SSC_ERR_IRQ                (1 <<  8)
-#define CC_IRQSTATUS_FIFO_NOEMPTY_IRQ           (1 <<  4)
-#define CC_IRQSTATUS_FIFO_FULL_IRQ              (1 <<  3)
-#define CC_IRQSTATUS_FIFO_THR_IRQ               (1 <<  2)
-#define CC_IRQSTATUS_FIFO_OF_IRQ                (1 <<  1)
-#define CC_IRQSTATUS_FIFO_UF_IRQ                (1 <<  0)
-
-#define CC_IRQENABLE_FS_IRQ                     (1 << 19)
-#define CC_IRQENABLE_LE_IRQ                     (1 << 18)
-#define CC_IRQENABLE_LS_IRQ                     (1 << 17)
-#define CC_IRQENABLE_FE_IRQ                     (1 << 16)
-#define CC_IRQENABLE_FW_ERR_IRQ                 (1 << 10)
-#define CC_IRQENABLE_FSC_ERR_IRQ                (1 <<  9)
-#define CC_IRQENABLE_SSC_ERR_IRQ                (1 <<  8)
-#define CC_IRQENABLE_FIFO_NOEMPTY_IRQ           (1 <<  4)
-#define CC_IRQENABLE_FIFO_FULL_IRQ              (1 <<  3)
-#define CC_IRQENABLE_FIFO_THR_IRQ               (1 <<  2)
-#define CC_IRQENABLE_FIFO_OF_IRQ                (1 <<  1)
-#define CC_IRQENABLE_FIFO_UF_IRQ                (1 <<  0)
-
-#define CC_CTRL_CC_ONE_SHOT                     (1 << 20)
-#define CC_CTRL_CC_IF_SYNCHRO                   (1 << 19)
-#define CC_CTRL_CC_RST                          (1 << 18)
-#define CC_CTRL_CC_FRAME_TRIG                   (1 << 17)
-#define CC_CTRL_CC_EN                           (1 << 16)
-#define CC_CTRL_NOBT_SYNCHRO                    (1 << 13)
-#define CC_CTRL_BT_CORRECT                      (1 << 12)
-#define CC_CTRL_PAR_ORDERCAM                    (1 << 11)
-#define CC_CTRL_PAR_CLK_POL                     (1 << 10)
-#define CC_CTRL_NOBT_HS_POL                     (1 <<  9)
-#define CC_CTRL_NOBT_VS_POL                     (1 <<  8)
-#define CC_CTRL_PAR_MODE                        (7 <<  1)
-#define CC_CTRL_PAR_MODE_SHIFT                  1
-#define CC_CTRL_PAR_MODE_NOBT8                  (0 <<  1)
-#define CC_CTRL_PAR_MODE_NOBT10                 (1 <<  1)
-#define CC_CTRL_PAR_MODE_NOBT12                 (2 <<  1)
-#define CC_CTRL_PAR_MODE_BT8                    (4 <<  1)
-#define CC_CTRL_PAR_MODE_BT10                   (5 <<  1)
-#define CC_CTRL_PAR_MODE_FIFOTEST               (7 <<  1)
-#define CC_CTRL_CCP_MODE                        (1 <<  0)
-
-#define CC_CTRL_DMA_EN                          (1 <<  8)
-#define CC_CTRL_DMA_FIFO_THRESHOLD              (0x7F << 0)
-#define CC_CTRL_DMA_FIFO_THRESHOLD_SHIFT        0
-
-#define CC_CTRL_XCLK_DIV                        (0x1F << 0)
-#define CC_CTRL_XCLK_DIV_SHIFT                  0
-#define CC_CTRL_XCLK_DIV_STABLE_LOW             (0 <<  0)
-#define CC_CTRL_XCLK_DIV_STABLE_HIGH            (1 <<  0)
-#define CC_CTRL_XCLK_DIV_BYPASS                 (31 << 0)
-
-#define CC_TEST_FIFO_RD_POINTER                 (0xFF << 24)
-#define CC_TEST_FIFO_RD_POINTER_SHIFT           24
-#define CC_TEST_FIFO_WR_POINTER                 (0xFF << 16)
-#define CC_TEST_FIFO_WR_POINTER_SHIFT           16
-#define CC_TEST_FIFO_LEVEL                      (0xFF <<  8)
-#define CC_TEST_FIFO_LEVEL_SHIFT                8
-#define CC_TEST_FIFO_LEVEL_PEAK                 (0xFF <<  0)
-#define CC_TEST_FIFO_LEVEL_PEAK_SHIFT           0
-
-#define CC_GENPAR_FIFO_DEPTH                    (7 <<  0)
-#define CC_GENPAR_FIFO_DEPTH_SHIFT              0
-
-#define CC_CCPDFR_ALPHA                         (0xFF <<  8)
-#define CC_CCPDFR_ALPHA_SHIFT                   8
-#define CC_CCPDFR_DATAFORMAT                    (15 <<  0)
-#define CC_CCPDFR_DATAFORMAT_SHIFT              0
-#define CC_CCPDFR_DATAFORMAT_YUV422BE           (0 <<  0)
-#define CC_CCPDFR_DATAFORMAT_YUV422             (1 <<  0)
-#define CC_CCPDFR_DATAFORMAT_YUV420             (2 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RGB444             (4 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RGB565             (5 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RGB888NDE          (6 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RGB888             (7 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RAW8NDE            (8 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RAW8               (9 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RAW10NDE           (10 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RAW10              (11 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RAW12NDE           (12 <<  0)
-#define CC_CCPDFR_DATAFORMAT_RAW12              (13 <<  0)
-#define CC_CCPDFR_DATAFORMAT_JPEG8              (15 <<  0)
-
-#define CAMDMA_REVISION_MAJOR                   (15 << 4)
-#define CAMDMA_REVISION_MAJOR_SHIFT             4
-#define CAMDMA_REVISION_MINOR                   (15 << 0)
-#define CAMDMA_REVISION_MINOR_SHIFT             0
-
-#define CAMDMA_OCP_SYSCONFIG_MIDLEMODE          (3 << 12)
-#define CAMDMA_OCP_SYSCONFIG_MIDLEMODE_FSTANDBY (0 << 12)
-#define CAMDMA_OCP_SYSCONFIG_MIDLEMODE_NSTANDBY (1 << 12)
-#define CAMDMA_OCP_SYSCONFIG_MIDLEMODE_SSTANDBY (2 << 12)
-#define CAMDMA_OCP_SYSCONFIG_FUNC_CLOCK         (1 <<  9)
-#define CAMDMA_OCP_SYSCONFIG_OCP_CLOCK          (1 <<  8)
-#define CAMDMA_OCP_SYSCONFIG_EMUFREE            (1 <<  5)
-#define CAMDMA_OCP_SYSCONFIG_SIDLEMODE          (3 <<  3)
-#define CAMDMA_OCP_SYSCONFIG_SIDLEMODE_FIDLE    (0 <<  3)
-#define CAMDMA_OCP_SYSCONFIG_SIDLEMODE_NIDLE    (1 <<  3)
-#define CAMDMA_OCP_SYSCONFIG_SIDLEMODE_SIDLE    (2 <<  3)
-#define CAMDMA_OCP_SYSCONFIG_SOFTRESET          (1 <<  1)
-#define CAMDMA_OCP_SYSCONFIG_AUTOIDLE           (1 <<  0)
-
-#define CAMDMA_SYSSTATUS_RESETDONE              (1 <<  0)
-
-#define CAMDMA_GCR_ARBITRATION_RATE             (0xFF << 16)
-#define CAMDMA_GCR_ARBITRATION_RATE_SHIFT       16
-#define CAMDMA_GCR_MAX_CHANNEL_FIFO_DEPTH       (0xFF << 0)
-#define CAMDMA_GCR_MAX_CHANNEL_FIFO_DEPTH_SHIFT 0
-
-#define CAMDMA_CCR_SEL_SRC_DST_SYNC             (1 << 24)
-#define CAMDMA_CCR_PREFETCH                     (1 << 23)
-#define CAMDMA_CCR_SUPERVISOR                   (1 << 22)
-#define CAMDMA_CCR_SECURE                       (1 << 21)
-#define CAMDMA_CCR_BS                           (1 << 18)
-#define CAMDMA_CCR_TRANSPARENT_COPY_ENABLE      (1 << 17)
-#define CAMDMA_CCR_CONSTANT_FILL_ENABLE         (1 << 16)
-#define CAMDMA_CCR_DST_AMODE                    (3 << 14)
-#define CAMDMA_CCR_DST_AMODE_CONST_ADDR         (0 << 14)
-#define CAMDMA_CCR_DST_AMODE_POST_INC           (1 << 14)
-#define CAMDMA_CCR_DST_AMODE_SGL_IDX            (2 << 14)
-#define CAMDMA_CCR_DST_AMODE_DBL_IDX            (3 << 14)
-#define CAMDMA_CCR_SRC_AMODE                    (3 << 12)
-#define CAMDMA_CCR_SRC_AMODE_CONST_ADDR         (0 << 12)
-#define CAMDMA_CCR_SRC_AMODE_POST_INC           (1 << 12)
-#define CAMDMA_CCR_SRC_AMODE_SGL_IDX            (2 << 12)
-#define CAMDMA_CCR_SRC_AMODE_DBL_IDX            (3 << 12)
-#define CAMDMA_CCR_WR_ACTIVE                    (1 << 10)
-#define CAMDMA_CCR_RD_ACTIVE                    (1 <<  9)
-#define CAMDMA_CCR_SUSPEND_SENSITIVE            (1 <<  8)
-#define CAMDMA_CCR_ENABLE                       (1 <<  7)
-#define CAMDMA_CCR_PRIO                         (1 <<  6)
-#define CAMDMA_CCR_FS                           (1 <<  5)
-#define CAMDMA_CCR_SYNCHRO                      ((3 << 19) | (31 << 0))
-#define CAMDMA_CCR_SYNCHRO_CAMERA               0x01
-
-#define CAMDMA_CLNK_CTRL_ENABLE_LNK             (1 << 15)
-#define CAMDMA_CLNK_CTRL_NEXTLCH_ID             (0x1F << 0)
-#define CAMDMA_CLNK_CTRL_NEXTLCH_ID_SHIFT       0
-
-#define CAMDMA_CICR_MISALIGNED_ERR_IE           (1 << 11)
-#define CAMDMA_CICR_SUPERVISOR_ERR_IE           (1 << 10)
-#define CAMDMA_CICR_SECURE_ERR_IE               (1 <<  9)
-#define CAMDMA_CICR_TRANS_ERR_IE                (1 <<  8)
-#define CAMDMA_CICR_PACKET_IE                   (1 <<  7)
-#define CAMDMA_CICR_BLOCK_IE                    (1 <<  5)
-#define CAMDMA_CICR_LAST_IE                     (1 <<  4)
-#define CAMDMA_CICR_FRAME_IE                    (1 <<  3)
-#define CAMDMA_CICR_HALF_IE                     (1 <<  2)
-#define CAMDMA_CICR_DROP_IE                     (1 <<  1)
-
-#define CAMDMA_CSR_MISALIGNED_ERR               (1 << 11)
-#define CAMDMA_CSR_SUPERVISOR_ERR               (1 << 10)
-#define CAMDMA_CSR_SECURE_ERR                   (1 <<  9)
-#define CAMDMA_CSR_TRANS_ERR                    (1 <<  8)
-#define CAMDMA_CSR_PACKET                       (1 <<  7)
-#define CAMDMA_CSR_SYNC                         (1 <<  6)
-#define CAMDMA_CSR_BLOCK                        (1 <<  5)
-#define CAMDMA_CSR_LAST                         (1 <<  4)
-#define CAMDMA_CSR_FRAME                        (1 <<  3)
-#define CAMDMA_CSR_HALF                         (1 <<  2)
-#define CAMDMA_CSR_DROP                         (1 <<  1)
-
-#define CAMDMA_CSDP_SRC_ENDIANNESS              (1 << 21)
-#define CAMDMA_CSDP_SRC_ENDIANNESS_LOCK         (1 << 20)
-#define CAMDMA_CSDP_DST_ENDIANNESS              (1 << 19)
-#define CAMDMA_CSDP_DST_ENDIANNESS_LOCK         (1 << 18)
-#define CAMDMA_CSDP_WRITE_MODE                  (3 << 16)
-#define CAMDMA_CSDP_WRITE_MODE_WRNP             (0 << 16)
-#define CAMDMA_CSDP_WRITE_MODE_POSTED           (1 << 16)
-#define CAMDMA_CSDP_WRITE_MODE_POSTED_LAST_WRNP (2 << 16)
-#define CAMDMA_CSDP_DST_BURST_EN                (3 << 14)
-#define CAMDMA_CSDP_DST_BURST_EN_1              (0 << 14)
-#define CAMDMA_CSDP_DST_BURST_EN_16             (1 << 14)
-#define CAMDMA_CSDP_DST_BURST_EN_32             (2 << 14)
-#define CAMDMA_CSDP_DST_BURST_EN_64             (3 << 14)
-#define CAMDMA_CSDP_DST_PACKED                  (1 << 13)
-#define CAMDMA_CSDP_WR_ADD_TRSLT                (15 << 9)
-#define CAMDMA_CSDP_WR_ADD_TRSLT_ENABLE_MREQADD (3 <<  9)
-#define CAMDMA_CSDP_SRC_BURST_EN                (3 <<  7)
-#define CAMDMA_CSDP_SRC_BURST_EN_1              (0 <<  7)
-#define CAMDMA_CSDP_SRC_BURST_EN_16             (1 <<  7)
-#define CAMDMA_CSDP_SRC_BURST_EN_32             (2 <<  7)
-#define CAMDMA_CSDP_SRC_BURST_EN_64             (3 <<  7)
-#define CAMDMA_CSDP_SRC_PACKED                  (1 <<  6)
-#define CAMDMA_CSDP_RD_ADD_TRSLT                (15 << 2)
-#define CAMDMA_CSDP_RD_ADD_TRSLT_ENABLE_MREQADD (3 <<  2)
-#define CAMDMA_CSDP_DATA_TYPE                   (3 <<  0)
-#define CAMDMA_CSDP_DATA_TYPE_8BITS             (0 <<  0)
-#define CAMDMA_CSDP_DATA_TYPE_16BITS            (1 <<  0)
-#define CAMDMA_CSDP_DATA_TYPE_32BITS            (2 <<  0)
-
-#define CAMMMU_SYSCONFIG_AUTOIDLE               (1 <<  0)
-
-/*
- *
- * Declarations.
- *
- */
-
-/* forward declarations */
-struct omap24xxcam_sgdma;
-struct omap24xxcam_dma;
-
-typedef void (*sgdma_callback_t)(struct omap24xxcam_sgdma *cam,
-                                 u32 status, void *arg);
-typedef void (*dma_callback_t)(struct omap24xxcam_dma *cam,
-                               u32 status, void *arg);
-
-struct channel_state {
-        dma_callback_t callback;
-        void *arg;
-};
-
-/* sgdma state for each of the possible videobuf_buffers + 2 overlays */
-struct sgdma_state {
-        const struct scatterlist *sglist;
-        int sglen;               /* number of sglist entries */
-        int next_sglist;         /* index of next sglist entry to process */
-        unsigned int bytes_read; /* number of bytes read */
-        unsigned int len;        /* total length of sglist (excluding
-                                  * bytes due to page alignment) */
-        int queued_sglist;       /* number of sglist entries queued for DMA */
-        u32 csr;                 /* DMA return code */
-        sgdma_callback_t callback;
-        void *arg;
-};
-
-/* physical DMA channel management */
-struct omap24xxcam_dma {
-        spinlock_t lock;        /* Lock for the whole structure. */
-
-        void __iomem *base;     /* base address for dma controller */
-
-        /* While dma_stop!=0, an attempt to start a new DMA transfer will
-         * fail.
-         */
-        atomic_t dma_stop;
-        int free_dmach;         /* number of dma channels free */
-        int next_dmach;         /* index of next dma channel to use */
-        struct channel_state ch_state[NUM_CAMDMA_CHANNELS];
-};
-
-/* scatter-gather DMA (scatterlist stuff) management */
-struct omap24xxcam_sgdma {
-        struct omap24xxcam_dma dma;
-
-        spinlock_t lock;        /* Lock for the fields below. */
-        int free_sgdma;         /* number of free sg dma slots */
-        int next_sgdma;         /* index of next sg dma slot to use */
-        struct sgdma_state sg_state[NUM_SG_DMA];
-
-        /* Reset timer data */
-        struct timer_list reset_timer;
-};
-
-/* per-device data structure */
-struct omap24xxcam_device {
-        /*** mutex  ***/
-        /*
-         * mutex serialises access to this structure. Also camera
-         * opening and releasing is synchronised by this.
-         */
-        struct mutex mutex;
-
-        struct v4l2_device v4l2_dev;
-
-        /*** general driver state information ***/
-        atomic_t users;
-        /*
-         * Lock to serialise core enabling and disabling and access to
-         * sgdma_in_queue.
-         */
-        spinlock_t core_enable_disable_lock;
-        /*
-         * Number or sgdma requests in scatter-gather queue, protected
-         * by the lock above.
-         */
-        int sgdma_in_queue;
-        /*
-         * Sensor interface parameters: interface type, CC_CTRL
-         * register value and interface specific data.
-         */
-        int if_type;
-        union {
-                struct parallel {
-                        u32 xclk;
-                } bt656;
-        } if_u;
-        u32 cc_ctrl;
-
-        /*** subsystem structures ***/
-        struct omap24xxcam_sgdma sgdma;
-
-        /*** hardware resources ***/
-        unsigned int irq;
-        void __iomem *mmio_base;
-        unsigned long mmio_base_phys;
-        unsigned long mmio_size;
-
-        /*** interfaces and device ***/
-        struct v4l2_int_device *sdev;
-        struct device *dev;
-        struct video_device *vfd;
-
-        /*** camera and sensor reset related stuff ***/
-        struct work_struct sensor_reset_work;
-        /*
-         * We're in the middle of a reset. Don't enable core if this
-         * is non-zero! This exists to help decisionmaking in a case
-         * where videobuf_qbuf is called while we are in the middle of
-         * a reset.
-         */
-        atomic_t in_reset;
-        /*
-         * Non-zero if we don't want any resets for now. Used to
-         * prevent reset work to run when we're about to stop
-         * streaming.
-         */
-        atomic_t reset_disable;
-
-        /*** video device parameters ***/
-        int capture_mem;
-
-        /*** camera module clocks ***/
-        struct clk *fck;
-        struct clk *ick;
-
-        /*** capture data ***/
-        /* file handle, if streaming is on */
-        struct file *streaming;
-};
-
-/* Per-file handle data. */
-struct omap24xxcam_fh {
-        spinlock_t vbq_lock; /* spinlock for the videobuf queue */
-        struct videobuf_queue vbq;
-        struct v4l2_pix_format pix; /* serialise pix by vbq->lock */
-        atomic_t field_count; /* field counter for videobuf_buffer */
-        /* accessing cam here doesn't need serialisation: it's constant */
-        struct omap24xxcam_device *cam;
-};
-
-/*
- *
- * Register I/O functions.
- *
- */
-
-static inline u32 omap24xxcam_reg_in(u32 __iomem *base, u32 offset)
-{
-        return readl(base + offset);
-}
-
-static inline u32 omap24xxcam_reg_out(u32 __iomem *base, u32 offset,
-                                          u32 val)
-{
-        writel(val, base + offset);
-        return val;
-}
-
-static inline u32 omap24xxcam_reg_merge(u32 __iomem *base, u32 offset,
-                                            u32 val, u32 mask)
-{
-        u32 __iomem *addr = base + offset;
-        u32 new_val = (readl(addr) & ~mask) | (val & mask);
-
-        writel(new_val, addr);
-        return new_val;
-}
-
-/*
- *
- * Function prototypes.
- *
- */
-
-/* dma prototypes */
-
-void omap24xxcam_dma_hwinit(struct omap24xxcam_dma *dma);
-void omap24xxcam_dma_isr(struct omap24xxcam_dma *dma);
-
-/* sgdma prototypes */
-
-void omap24xxcam_sgdma_process(struct omap24xxcam_sgdma *sgdma);
-int omap24xxcam_sgdma_queue(struct omap24xxcam_sgdma *sgdma,
-                            const struct scatterlist *sglist, int sglen,
-                            int len, sgdma_callback_t callback, void *arg);
-void omap24xxcam_sgdma_sync(struct omap24xxcam_sgdma *sgdma);
-void omap24xxcam_sgdma_init(struct omap24xxcam_sgdma *sgdma,
-                            void __iomem *base,
-                            void (*reset_callback)(unsigned long data),
-                            unsigned long reset_callback_data);
-void omap24xxcam_sgdma_exit(struct omap24xxcam_sgdma *sgdma);
-
-#endif
diff --git a/drivers/staging/media/omap24xx/tcm825x.c b/drivers/staging/media/omap24xx/tcm825x.c
deleted file mode 100644
index 9d9ecf1fc4ae..000000000000
--- a/drivers/staging/media/omap24xx/tcm825x.c
+++ /dev/null
@@ -1,938 +0,0 @@
-/*
- * drivers/media/i2c/tcm825x.c
- *
- * TCM825X camera sensor driver.
- *
- * Copyright (C) 2007 Nokia Corporation.
- *
- * Contact: Sakari Ailus <sakari.ailus@nokia.com>
- *
- * Based on code from David Cohen <david.cohen@indt.org.br>
- *
- * This driver was based on ov9640 sensor driver from MontaVista
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#include <linux/i2c.h>
-#include <linux/module.h>
-#include "v4l2-int-device.h"
-
-#include "tcm825x.h"
-
-/*
- * The sensor has two fps modes: the lower one just gives half the fps
- * at the same xclk than the high one.
- */
-#define MAX_FPS 30
-#define MIN_FPS 8
-#define MAX_HALF_FPS (MAX_FPS / 2)
-#define HIGH_FPS_MODE_LOWER_LIMIT 14
-#define DEFAULT_FPS MAX_HALF_FPS
-
-struct tcm825x_sensor {
-        const struct tcm825x_platform_data *platform_data;
-        struct v4l2_int_device *v4l2_int_device;
-        struct i2c_client *i2c_client;
-        struct v4l2_pix_format pix;
-        struct v4l2_fract timeperframe;
-};
-
-/* list of image formats supported by TCM825X sensor */
-static const struct v4l2_fmtdesc tcm825x_formats[] = {
-        {
-                .description = "YUYV (YUV 4:2:2), packed",
-                .pixelformat = V4L2_PIX_FMT_UYVY,
-        }, {
-                /* Note:  V4L2 defines RGB565 as:
-                 *
-                 *      Byte 0                    Byte 1
-                 *      g2 g1 g0 r4 r3 r2 r1 r0   b4 b3 b2 b1 b0 g5 g4 g3
-                 *
-                 * We interpret RGB565 as:
-                 *
-                 *      Byte 0                    Byte 1
-                 *      g2 g1 g0 b4 b3 b2 b1 b0   r4 r3 r2 r1 r0 g5 g4 g3
-                 */
-                .description = "RGB565, le",
-                .pixelformat = V4L2_PIX_FMT_RGB565,
-        },
-};
-
-#define TCM825X_NUM_CAPTURE_FORMATS     ARRAY_SIZE(tcm825x_formats)
-
-/*
- * TCM825X register configuration for all combinations of pixel format and
- * image size
- */
-static const struct tcm825x_reg subqcif =       { 0x20, TCM825X_PICSIZ };
-static const struct tcm825x_reg qcif    =       { 0x18, TCM825X_PICSIZ };
-static const struct tcm825x_reg cif     =       { 0x14, TCM825X_PICSIZ };
-static const struct tcm825x_reg qqvga   =       { 0x0c, TCM825X_PICSIZ };
-static const struct tcm825x_reg qvga    =       { 0x04, TCM825X_PICSIZ };
-static const struct tcm825x_reg vga     =       { 0x00, TCM825X_PICSIZ };
-
-static const struct tcm825x_reg yuv422  =       { 0x00, TCM825X_PICFMT };
-static const struct tcm825x_reg rgb565  =       { 0x02, TCM825X_PICFMT };
-
-/* Our own specific controls */
-#define V4L2_CID_ALC                            V4L2_CID_PRIVATE_BASE
-#define V4L2_CID_H_EDGE_EN                      (V4L2_CID_PRIVATE_BASE + 1)
-#define V4L2_CID_V_EDGE_EN                      (V4L2_CID_PRIVATE_BASE + 2)
-#define V4L2_CID_LENS                           (V4L2_CID_PRIVATE_BASE + 3)
-#define V4L2_CID_MAX_EXPOSURE_TIME              (V4L2_CID_PRIVATE_BASE + 4)
-#define V4L2_CID_LAST_PRIV                      V4L2_CID_MAX_EXPOSURE_TIME
-
-/*  Video controls  */
-static struct vcontrol {
-        struct v4l2_queryctrl qc;
-        u16 reg;
-        u16 start_bit;
-} video_control[] = {
-        {
-                {
-                        .id = V4L2_CID_GAIN,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Gain",
-                        .minimum = 0,
-                        .maximum = 63,
-                        .step = 1,
-                },
-                .reg = TCM825X_AG,
-                .start_bit = 0,
-        },
-        {
-                {
-                        .id = V4L2_CID_RED_BALANCE,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Red Balance",
-                        .minimum = 0,
-                        .maximum = 255,
-                        .step = 1,
-                },
-                .reg = TCM825X_MRG,
-                .start_bit = 0,
-        },
-        {
-                {
-                        .id = V4L2_CID_BLUE_BALANCE,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Blue Balance",
-                        .minimum = 0,
-                        .maximum = 255,
-                        .step = 1,
-                },
-                .reg = TCM825X_MBG,
-                .start_bit = 0,
-        },
-        {
-                {
-                        .id = V4L2_CID_AUTO_WHITE_BALANCE,
-                        .type = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name = "Auto White Balance",
-                        .minimum = 0,
-                        .maximum = 1,
-                        .step = 0,
-                },
-                .reg = TCM825X_AWBSW,
-                .start_bit = 7,
-        },
-        {
-                {
-                        .id = V4L2_CID_EXPOSURE,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Exposure Time",
-                        .minimum = 0,
-                        .maximum = 0x1fff,
-                        .step = 1,
-                },
-                .reg = TCM825X_ESRSPD_U,
-                .start_bit = 0,
-        },
-        {
-                {
-                        .id = V4L2_CID_HFLIP,
-                        .type = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name = "Mirror Image",
-                        .minimum = 0,
-                        .maximum = 1,
-                        .step = 0,
-                },
-                .reg = TCM825X_H_INV,
-                .start_bit = 6,
-        },
-        {
-                {
-                        .id = V4L2_CID_VFLIP,
-                        .type = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name = "Vertical Flip",
-                        .minimum = 0,
-                        .maximum = 1,
-                        .step = 0,
-                },
-                .reg = TCM825X_V_INV,
-                .start_bit = 7,
-        },
-        /* Private controls */
-        {
-                {
-                        .id = V4L2_CID_ALC,
-                        .type = V4L2_CTRL_TYPE_BOOLEAN,
-                        .name = "Auto Luminance Control",
-                        .minimum = 0,
-                        .maximum = 1,
-                        .step = 0,
-                },
-                .reg = TCM825X_ALCSW,
-                .start_bit = 7,
-        },
-        {
-                {
-                        .id = V4L2_CID_H_EDGE_EN,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Horizontal Edge Enhancement",
-                        .minimum = 0,
-                        .maximum = 0xff,
-                        .step = 1,
-                },
-                .reg = TCM825X_HDTG,
-                .start_bit = 0,
-        },
-        {
-                {
-                        .id = V4L2_CID_V_EDGE_EN,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Vertical Edge Enhancement",
-                        .minimum = 0,
-                        .maximum = 0xff,
-                        .step = 1,
-                },
-                .reg = TCM825X_VDTG,
-                .start_bit = 0,
-        },
-        {
-                {
-                        .id = V4L2_CID_LENS,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Lens Shading Compensation",
-                        .minimum = 0,
-                        .maximum = 0x3f,
-                        .step = 1,
-                },
-                .reg = TCM825X_LENS,
-                .start_bit = 0,
-        },
-        {
-                {
-                        .id = V4L2_CID_MAX_EXPOSURE_TIME,
-                        .type = V4L2_CTRL_TYPE_INTEGER,
-                        .name = "Maximum Exposure Time",
-                        .minimum = 0,
-                        .maximum = 0x3,
-                        .step = 1,
-                },
-                .reg = TCM825X_ESRLIM,
-                .start_bit = 5,
-        },
-};
-
-
-static const struct tcm825x_reg *tcm825x_siz_reg[NUM_IMAGE_SIZES] = {
-        &subqcif, &qqvga, &qcif, &qvga, &cif, &vga };
-
-static const struct tcm825x_reg *tcm825x_fmt_reg[NUM_PIXEL_FORMATS] = {
-        &yuv422, &rgb565 };
-
-/*
- * Read a value from a register in an TCM825X sensor device.  The value is
- * returned in 'val'.
- * Returns zero if successful, or non-zero otherwise.
- */
-static int tcm825x_read_reg(struct i2c_client *client, int reg)
-{
-        int err;
-        struct i2c_msg msg[2];
-        u8 reg_buf, data_buf = 0;
-
-        if (!client->adapter)
-                return -ENODEV;
-
-        msg[0].addr = client->addr;
-        msg[0].flags = 0;
-        msg[0].len = 1;
-        msg[0].buf = &reg_buf;
-        msg[1].addr = client->addr;
-        msg[1].flags = I2C_M_RD;
-        msg[1].len = 1;
-        msg[1].buf = &data_buf;
-
-        reg_buf = reg;
-
-        err = i2c_transfer(client->adapter, msg, 2);
-        if (err < 0)
-                return err;
-        return data_buf;
-}
-
-/*
- * Write a value to a register in an TCM825X sensor device.
- * Returns zero if successful, or non-zero otherwise.
- */
-static int tcm825x_write_reg(struct i2c_client *client, u8 reg, u8 val)
-{
-        int err;
-        struct i2c_msg msg[1];
-        unsigned char data[2];
-
-        if (!client->adapter)
-                return -ENODEV;
-
-        msg->addr = client->addr;
-        msg->flags = 0;
-        msg->len = 2;
-        msg->buf = data;
-        data[0] = reg;
-        data[1] = val;
-        err = i2c_transfer(client->adapter, msg, 1);
-        if (err >= 0)
-                return 0;
-        return err;
-}
-
-static int __tcm825x_write_reg_mask(struct i2c_client *client,
-                                    u8 reg, u8 val, u8 mask)
-{
-        int rc;
-
-        /* need to do read - modify - write */
-        rc = tcm825x_read_reg(client, reg);
-        if (rc < 0)
-                return rc;
-
-        rc &= (~mask);  /* Clear the masked bits */
-        val &= mask;    /* Enforce mask on value */
-        val |= rc;
-
-        /* write the new value to the register */
-        rc = tcm825x_write_reg(client, reg, val);
-        if (rc)
-                return rc;
-
-        return 0;
-}
-
-#define tcm825x_write_reg_mask(client, regmask, val)                    \
-        __tcm825x_write_reg_mask(client, TCM825X_ADDR((regmask)), val,  \
-                                 TCM825X_MASK((regmask)))
-
-
-/*
- * Initialize a list of TCM825X registers.
- * The list of registers is terminated by the pair of values
- * { TCM825X_REG_TERM, TCM825X_VAL_TERM }.
- * Returns zero if successful, or non-zero otherwise.
- */
-static int tcm825x_write_default_regs(struct i2c_client *client,
-                                      const struct tcm825x_reg *reglist)
-{
-        int err;
-        const struct tcm825x_reg *next = reglist;
-
-        while (!((next->reg == TCM825X_REG_TERM)
-                 && (next->val == TCM825X_VAL_TERM))) {
-                err = tcm825x_write_reg(client, next->reg, next->val);
-                if (err) {
-                        dev_err(&client->dev, "register writing failed\n");
-                        return err;
-                }
-                next++;
-        }
-
-        return 0;
-}
-
-static struct vcontrol *find_vctrl(int id)
-{
-        int i;
-
-        if (id < V4L2_CID_BASE)
-                return NULL;
-
-        for (i = 0; i < ARRAY_SIZE(video_control); i++)
-                if (video_control[i].qc.id == id)
-                        return &video_control[i];
-
-        return NULL;
-}
-
-/*
- * Find the best match for a requested image capture size.  The best match
- * is chosen as the nearest match that has the same number or fewer pixels
- * as the requested size, or the smallest image size if the requested size
- * has fewer pixels than the smallest image.
- */
-static enum image_size tcm825x_find_size(struct v4l2_int_device *s,
-                                         unsigned int width,
-                                         unsigned int height)
-{
-        enum image_size isize;
-        unsigned long pixels = width * height;
-        struct tcm825x_sensor *sensor = s->priv;
-
-        for (isize = subQCIF; isize < VGA; isize++) {
-                if (tcm825x_sizes[isize + 1].height
-                    * tcm825x_sizes[isize + 1].width > pixels) {
-                        dev_dbg(&sensor->i2c_client->dev, "size %d\n", isize);
-
-                        return isize;
-                }
-        }
-
-        dev_dbg(&sensor->i2c_client->dev, "format default VGA\n");
-
-        return VGA;
-}
-
-/*
- * Configure the TCM825X for current image size, pixel format, and
- * frame period. fper is the frame period (in seconds) expressed as a
- * fraction. Returns zero if successful, or non-zero otherwise. The
- * actual frame period is returned in fper.
- */
-static int tcm825x_configure(struct v4l2_int_device *s)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        struct v4l2_pix_format *pix = &sensor->pix;
-        enum image_size isize = tcm825x_find_size(s, pix->width, pix->height);
-        struct v4l2_fract *fper = &sensor->timeperframe;
-        enum pixel_format pfmt;
-        int err;
-        u32 tgt_fps;
-        u8 val;
-
-        /* common register initialization */
-        err = tcm825x_write_default_regs(
-                sensor->i2c_client, sensor->platform_data->default_regs());
-        if (err)
-                return err;
-
-        /* configure image size */
-        val = tcm825x_siz_reg[isize]->val;
-        dev_dbg(&sensor->i2c_client->dev,
-                "configuring image size %d\n", isize);
-        err = tcm825x_write_reg_mask(sensor->i2c_client,
-                                     tcm825x_siz_reg[isize]->reg, val);
-        if (err)
-                return err;
-
-        /* configure pixel format */
-        switch (pix->pixelformat) {
-        default:
-        case V4L2_PIX_FMT_RGB565:
-                pfmt = RGB565;
-                break;
-        case V4L2_PIX_FMT_UYVY:
-                pfmt = YUV422;
-                break;
-        }
-
-        dev_dbg(&sensor->i2c_client->dev,
-                "configuring pixel format %d\n", pfmt);
-        val = tcm825x_fmt_reg[pfmt]->val;
-
-        err = tcm825x_write_reg_mask(sensor->i2c_client,
-                                     tcm825x_fmt_reg[pfmt]->reg, val);
-        if (err)
-                return err;
-
-        /*
-         * For frame rate < 15, the FPS reg (addr 0x02, bit 7) must be
-         * set. Frame rate will be halved from the normal.
-         */
-        tgt_fps = fper->denominator / fper->numerator;
-        if (tgt_fps <= HIGH_FPS_MODE_LOWER_LIMIT) {
-                val = tcm825x_read_reg(sensor->i2c_client, 0x02);
-                val |= 0x80;
-                tcm825x_write_reg(sensor->i2c_client, 0x02, val);
-        }
-
-        return 0;
-}
-
-static int ioctl_queryctrl(struct v4l2_int_device *s,
-                                struct v4l2_queryctrl *qc)
-{
-        struct vcontrol *control;
-
-        control = find_vctrl(qc->id);
-
-        if (control == NULL)
-                return -EINVAL;
-
-        *qc = control->qc;
-
-        return 0;
-}
-
-static int ioctl_g_ctrl(struct v4l2_int_device *s,
-                             struct v4l2_control *vc)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        struct i2c_client *client = sensor->i2c_client;
-        int val, r;
-        struct vcontrol *lvc;
-
-        /* exposure time is special, spread across 2 registers */
-        if (vc->id == V4L2_CID_EXPOSURE) {
-                int val_lower, val_upper;
-
-                val_upper = tcm825x_read_reg(client,
-                                             TCM825X_ADDR(TCM825X_ESRSPD_U));
-                if (val_upper < 0)
-                        return val_upper;
-                val_lower = tcm825x_read_reg(client,
-                                             TCM825X_ADDR(TCM825X_ESRSPD_L));
-                if (val_lower < 0)
-                        return val_lower;
-
-                vc->value = ((val_upper & 0x1f) << 8) | (val_lower);
-                return 0;
-        }
-
-        lvc = find_vctrl(vc->id);
-        if (lvc == NULL)
-                return -EINVAL;
-
-        r = tcm825x_read_reg(client, TCM825X_ADDR(lvc->reg));
-        if (r < 0)
-                return r;
-        val = r & TCM825X_MASK(lvc->reg);
-        val >>= lvc->start_bit;
-
-        if (val < 0)
-                return val;
-
-        if (vc->id == V4L2_CID_HFLIP || vc->id == V4L2_CID_VFLIP)
-                val ^= sensor->platform_data->is_upside_down();
-
-        vc->value = val;
-        return 0;
-}
-
-static int ioctl_s_ctrl(struct v4l2_int_device *s,
-                             struct v4l2_control *vc)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        struct i2c_client *client = sensor->i2c_client;
-        struct vcontrol *lvc;
-        int val = vc->value;
-
-        /* exposure time is special, spread across 2 registers */
-        if (vc->id == V4L2_CID_EXPOSURE) {
-                int val_lower, val_upper;
-
-                val_lower = val & TCM825X_MASK(TCM825X_ESRSPD_L);
-                val_upper = (val >> 8) & TCM825X_MASK(TCM825X_ESRSPD_U);
-
-                if (tcm825x_write_reg_mask(client,
-                                           TCM825X_ESRSPD_U, val_upper))
-                        return -EIO;
-
-                if (tcm825x_write_reg_mask(client,
-                                           TCM825X_ESRSPD_L, val_lower))
-                        return -EIO;
-
-                return 0;
-        }
-
-        lvc = find_vctrl(vc->id);
-        if (lvc == NULL)
-                return -EINVAL;
-
-        if (vc->id == V4L2_CID_HFLIP || vc->id == V4L2_CID_VFLIP)
-                val ^= sensor->platform_data->is_upside_down();
-
-        val = val << lvc->start_bit;
-        if (tcm825x_write_reg_mask(client, lvc->reg, val))
-                return -EIO;
-
-        return 0;
-}
-
-static int ioctl_enum_fmt_cap(struct v4l2_int_device *s,
-                                   struct v4l2_fmtdesc *fmt)
-{
-        int index = fmt->index;
-
-        switch (fmt->type) {
-        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-                if (index >= TCM825X_NUM_CAPTURE_FORMATS)
-                        return -EINVAL;
-                break;
-
-        default:
-                return -EINVAL;
-        }
-
-        fmt->flags = tcm825x_formats[index].flags;
-        strlcpy(fmt->description, tcm825x_formats[index].description,
-                sizeof(fmt->description));
-        fmt->pixelformat = tcm825x_formats[index].pixelformat;
-
-        return 0;
-}
-
-static int ioctl_try_fmt_cap(struct v4l2_int_device *s,
-                             struct v4l2_format *f)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        enum image_size isize;
-        int ifmt;
-        struct v4l2_pix_format *pix = &f->fmt.pix;
-
-        isize = tcm825x_find_size(s, pix->width, pix->height);
-        dev_dbg(&sensor->i2c_client->dev, "isize = %d num_capture = %lu\n",
-                isize, (unsigned long)TCM825X_NUM_CAPTURE_FORMATS);
-
-        pix->width = tcm825x_sizes[isize].width;
-        pix->height = tcm825x_sizes[isize].height;
-
-        for (ifmt = 0; ifmt < TCM825X_NUM_CAPTURE_FORMATS; ifmt++)
-                if (pix->pixelformat == tcm825x_formats[ifmt].pixelformat)
-                        break;
-
-        if (ifmt == TCM825X_NUM_CAPTURE_FORMATS)
-                ifmt = 0;       /* Default = YUV 4:2:2 */
-
-        pix->pixelformat = tcm825x_formats[ifmt].pixelformat;
-        pix->field = V4L2_FIELD_NONE;
-        pix->bytesperline = pix->width * TCM825X_BYTES_PER_PIXEL;
-        pix->sizeimage = pix->bytesperline * pix->height;
-        pix->priv = 0;
-        dev_dbg(&sensor->i2c_client->dev, "format = 0x%08x\n",
-                pix->pixelformat);
-
-        switch (pix->pixelformat) {
-        case V4L2_PIX_FMT_UYVY:
-        default:
-                pix->colorspace = V4L2_COLORSPACE_JPEG;
-                break;
-        case V4L2_PIX_FMT_RGB565:
-                pix->colorspace = V4L2_COLORSPACE_SRGB;
-                break;
-        }
-
-        return 0;
-}
-
-static int ioctl_s_fmt_cap(struct v4l2_int_device *s,
-                                struct v4l2_format *f)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        struct v4l2_pix_format *pix = &f->fmt.pix;
-        int rval;
-
-        rval = ioctl_try_fmt_cap(s, f);
-        if (rval)
-                return rval;
-
-        rval = tcm825x_configure(s);
-
-        sensor->pix = *pix;
-
-        return rval;
-}
-
-static int ioctl_g_fmt_cap(struct v4l2_int_device *s,
-                                struct v4l2_format *f)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-
-        f->fmt.pix = sensor->pix;
-
-        return 0;
-}
-
-static int ioctl_g_parm(struct v4l2_int_device *s,
-                             struct v4l2_streamparm *a)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        struct v4l2_captureparm *cparm = &a->parm.capture;
-
-        if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL;
-
-        memset(a, 0, sizeof(*a));
-        a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-        cparm->capability = V4L2_CAP_TIMEPERFRAME;
-        cparm->timeperframe = sensor->timeperframe;
-
-        return 0;
-}
-
-static int ioctl_s_parm(struct v4l2_int_device *s,
-                             struct v4l2_streamparm *a)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        struct v4l2_fract *timeperframe = &a->parm.capture.timeperframe;
-        u32 tgt_fps;    /* target frames per secound */
-        int rval;
-
-        if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL;
-
-        if ((timeperframe->numerator == 0)
-            || (timeperframe->denominator == 0)) {
-                timeperframe->denominator = DEFAULT_FPS;
-                timeperframe->numerator = 1;
-        }
-
-        tgt_fps = timeperframe->denominator / timeperframe->numerator;
-
-        if (tgt_fps > MAX_FPS) {
-                timeperframe->denominator = MAX_FPS;
-                timeperframe->numerator = 1;
-        } else if (tgt_fps < MIN_FPS) {
-                timeperframe->denominator = MIN_FPS;
-                timeperframe->numerator = 1;
-        }
-
-        sensor->timeperframe = *timeperframe;
-
-        rval = tcm825x_configure(s);
-
-        return rval;
-}
-
-static int ioctl_s_power(struct v4l2_int_device *s, int on)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-
-        return sensor->platform_data->power_set(on);
-}
-
-/*
- * Given the image capture format in pix, the nominal frame period in
- * timeperframe, calculate the required xclk frequency.
- *
- * TCM825X input frequency characteristics are:
- *     Minimum 11.9 MHz, Typical 24.57 MHz and maximum 25/27 MHz
- */
-
-static int ioctl_g_ifparm(struct v4l2_int_device *s, struct v4l2_ifparm *p)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        struct v4l2_fract *timeperframe = &sensor->timeperframe;
-        u32 tgt_xclk;   /* target xclk */
-        u32 tgt_fps;    /* target frames per secound */
-        int rval;
-
-        rval = sensor->platform_data->ifparm(p);
-        if (rval)
-                return rval;
-
-        tgt_fps = timeperframe->denominator / timeperframe->numerator;
-
-        tgt_xclk = (tgt_fps <= HIGH_FPS_MODE_LOWER_LIMIT) ?
-                (2457 * tgt_fps) / MAX_HALF_FPS :
-                (2457 * tgt_fps) / MAX_FPS;
-        tgt_xclk *= 10000;
-
-        tgt_xclk = min(tgt_xclk, (u32)TCM825X_XCLK_MAX);
-        tgt_xclk = max(tgt_xclk, (u32)TCM825X_XCLK_MIN);
-
-        p->u.bt656.clock_curr = tgt_xclk;
-
-        return 0;
-}
-
-static int ioctl_g_needs_reset(struct v4l2_int_device *s, void *buf)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-
-        return sensor->platform_data->needs_reset(s, buf, &sensor->pix);
-}
-
-static int ioctl_reset(struct v4l2_int_device *s)
-{
-        return -EBUSY;
-}
-
-static int ioctl_init(struct v4l2_int_device *s)
-{
-        return tcm825x_configure(s);
-}
-
-static int ioctl_dev_exit(struct v4l2_int_device *s)
-{
-        return 0;
-}
-
-static int ioctl_dev_init(struct v4l2_int_device *s)
-{
-        struct tcm825x_sensor *sensor = s->priv;
-        int r;
-
-        r = tcm825x_read_reg(sensor->i2c_client, 0x01);
-        if (r < 0)
-                return r;
-        if (r == 0) {
-                dev_err(&sensor->i2c_client->dev, "device not detected\n");
-                return -EIO;
-        }
-        return 0;
-}
-
-static struct v4l2_int_ioctl_desc tcm825x_ioctl_desc[] = {
-        { vidioc_int_dev_init_num,
-          (v4l2_int_ioctl_func *)ioctl_dev_init },
-        { vidioc_int_dev_exit_num,
-          (v4l2_int_ioctl_func *)ioctl_dev_exit },
-        { vidioc_int_s_power_num,
-          (v4l2_int_ioctl_func *)ioctl_s_power },
-        { vidioc_int_g_ifparm_num,
-          (v4l2_int_ioctl_func *)ioctl_g_ifparm },
-        { vidioc_int_g_needs_reset_num,
-          (v4l2_int_ioctl_func *)ioctl_g_needs_reset },
-        { vidioc_int_reset_num,
-          (v4l2_int_ioctl_func *)ioctl_reset },
-        { vidioc_int_init_num,
-          (v4l2_int_ioctl_func *)ioctl_init },
-        { vidioc_int_enum_fmt_cap_num,
-          (v4l2_int_ioctl_func *)ioctl_enum_fmt_cap },
-        { vidioc_int_try_fmt_cap_num,
-          (v4l2_int_ioctl_func *)ioctl_try_fmt_cap },
-        { vidioc_int_g_fmt_cap_num,
-          (v4l2_int_ioctl_func *)ioctl_g_fmt_cap },
-        { vidioc_int_s_fmt_cap_num,
-          (v4l2_int_ioctl_func *)ioctl_s_fmt_cap },
-        { vidioc_int_g_parm_num,
-          (v4l2_int_ioctl_func *)ioctl_g_parm },
-        { vidioc_int_s_parm_num,
-          (v4l2_int_ioctl_func *)ioctl_s_parm },
-        { vidioc_int_queryctrl_num,
-          (v4l2_int_ioctl_func *)ioctl_queryctrl },
-        { vidioc_int_g_ctrl_num,
-          (v4l2_int_ioctl_func *)ioctl_g_ctrl },
-        { vidioc_int_s_ctrl_num,
-          (v4l2_int_ioctl_func *)ioctl_s_ctrl },
-};
-
-static struct v4l2_int_slave tcm825x_slave = {
-        .ioctls = tcm825x_ioctl_desc,
-        .num_ioctls = ARRAY_SIZE(tcm825x_ioctl_desc),
-};
-
-static struct tcm825x_sensor tcm825x;
-
-static struct v4l2_int_device tcm825x_int_device = {
-        .module = THIS_MODULE,
-        .name = TCM825X_NAME,
-        .priv = &tcm825x,
-        .type = v4l2_int_type_slave,
-        .u = {
-                .slave = &tcm825x_slave,
-        },
-};
-
-static int tcm825x_probe(struct i2c_client *client,
-                         const struct i2c_device_id *did)
-{
-        struct tcm825x_sensor *sensor = &tcm825x;
-
-        if (i2c_get_clientdata(client))
-                return -EBUSY;
-
-        sensor->platform_data = client->dev.platform_data;
-
-        if (sensor->platform_data == NULL
-            || !sensor->platform_data->is_okay())
-                return -ENODEV;
-
-        sensor->v4l2_int_device = &tcm825x_int_device;
-
-        sensor->i2c_client = client;
-        i2c_set_clientdata(client, sensor);
-
-        /* Make the default capture format QVGA RGB565 */
-        sensor->pix.width = tcm825x_sizes[QVGA].width;
-        sensor->pix.height = tcm825x_sizes[QVGA].height;
-        sensor->pix.pixelformat = V4L2_PIX_FMT_RGB565;
-
-        return v4l2_int_device_register(sensor->v4l2_int_device);
-}
-
-static int tcm825x_remove(struct i2c_client *client)
-{
-        struct tcm825x_sensor *sensor = i2c_get_clientdata(client);
-
-        if (!client->adapter)
-                return -ENODEV; /* our client isn't attached */
-
-        v4l2_int_device_unregister(sensor->v4l2_int_device);
-
-        return 0;
-}
-
-static const struct i2c_device_id tcm825x_id[] = {
-        { "tcm825x", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, tcm825x_id);
-
-static struct i2c_driver tcm825x_i2c_driver = {
-        .driver = {
-                .name = TCM825X_NAME,
-        },
-        .probe  = tcm825x_probe,
-        .remove = tcm825x_remove,
-        .id_table = tcm825x_id,
-};
-
-static struct tcm825x_sensor tcm825x = {
-        .timeperframe = {
-                .numerator   = 1,
-                .denominator = DEFAULT_FPS,
-        },
-};
-
-static int __init tcm825x_init(void)
-{
-        int rval;
-
-        rval = i2c_add_driver(&tcm825x_i2c_driver);
-        if (rval)
-                pr_info("%s: failed registering " TCM825X_NAME "\n",
-                        __func__);
-
-        return rval;
-}
-
-static void __exit tcm825x_exit(void)
-{
-        i2c_del_driver(&tcm825x_i2c_driver);
-}
-
-/*
- * FIXME: Menelaus isn't ready (?) at module_init stage, so use
- * late_initcall for now.
- */
-late_initcall(tcm825x_init);
-module_exit(tcm825x_exit);
-
-MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
-MODULE_DESCRIPTION("TCM825x camera sensor driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/staging/media/omap24xx/tcm825x.h b/drivers/staging/media/omap24xx/tcm825x.h
deleted file mode 100644
index 8a29636d1ad4..000000000000
--- a/drivers/staging/media/omap24xx/tcm825x.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * drivers/media/i2c/tcm825x.h
- *
- * Register definitions for the TCM825X CameraChip.
- *
- * Author: David Cohen (david.cohen@indt.org.br)
- *
- * This file is licensed under the terms of the GNU General Public License
- * version 2. This program is licensed "as is" without any warranty of any
- * kind, whether express or implied.
- *
- * This file was based on ov9640.h from MontaVista
- */
-
-#ifndef TCM825X_H
-#define TCM825X_H
-
-#include <linux/videodev2.h>
-
-#include "v4l2-int-device.h"
-
-#define TCM825X_NAME "tcm825x"
-
-#define TCM825X_MASK(x) (x & 0x00ff)
-#define TCM825X_ADDR(x) ((x & 0xff00) >> 8)
-
-/* The TCM825X I2C sensor chip has a fixed slave address of 0x3d. */
-#define TCM825X_I2C_ADDR        0x3d
-
-/*
- * define register offsets for the TCM825X sensor chip
- * OFFSET(8 bits) + MASK(8 bits)
- * MASK bit 4 and 3 are used when the register uses more than one address
- */
-#define TCM825X_FPS             0x0280
-#define TCM825X_ACF             0x0240
-#define TCM825X_DOUTBUF         0x020C
-#define TCM825X_DCLKP           0x0202
-#define TCM825X_ACFDET          0x0201
-#define TCM825X_DOUTSW          0x0380
-#define TCM825X_DATAHZ          0x0340
-#define TCM825X_PICSIZ          0x033c
-#define TCM825X_PICFMT          0x0302
-#define TCM825X_V_INV           0x0480
-#define TCM825X_H_INV           0x0440
-#define TCM825X_ESRLSW          0x0430
-#define TCM825X_V_LENGTH        0x040F
-#define TCM825X_ALCSW           0x0580
-#define TCM825X_ESRLIM          0x0560
-#define TCM825X_ESRSPD_U        0x051F
-#define TCM825X_ESRSPD_L        0x06FF
-#define TCM825X_AG              0x07FF
-#define TCM825X_ESRSPD2         0x06FF
-#define TCM825X_ALCMODE         0x0830
-#define TCM825X_ALCH            0x080F
-#define TCM825X_ALCL            0x09FF
-#define TCM825X_AWBSW           0x0A80
-#define TCM825X_MRG             0x0BFF
-#define TCM825X_MBG             0x0CFF
-#define TCM825X_GAMSW           0x0D80
-#define TCM825X_HDTG            0x0EFF
-#define TCM825X_VDTG            0x0FFF
-#define TCM825X_HDTCORE         0x10F0
-#define TCM825X_VDTCORE         0x100F
-#define TCM825X_CONT            0x11FF
-#define TCM825X_BRIGHT          0x12FF
-#define TCM825X_VHUE            0x137F
-#define TCM825X_UHUE            0x147F
-#define TCM825X_VGAIN           0x153F
-#define TCM825X_UGAIN           0x163F
-#define TCM825X_UVCORE          0x170F
-#define TCM825X_SATU            0x187F
-#define TCM825X_MHMODE          0x1980
-#define TCM825X_MHLPFSEL        0x1940
-#define TCM825X_YMODE           0x1930
-#define TCM825X_MIXHG           0x1907
-#define TCM825X_LENS            0x1A3F
-#define TCM825X_AGLIM           0x1BE0
-#define TCM825X_LENSRPOL        0x1B10
-#define TCM825X_LENSRGAIN       0x1B0F
-#define TCM825X_ES100S          0x1CFF
-#define TCM825X_ES120S          0x1DFF
-#define TCM825X_DMASK           0x1EC0
-#define TCM825X_CODESW          0x1E20
-#define TCM825X_CODESEL         0x1E10
-#define TCM825X_TESPIC          0x1E04
-#define TCM825X_PICSEL          0x1E03
-#define TCM825X_HNUM            0x20FF
-#define TCM825X_VOUTPH          0x287F
-#define TCM825X_ESROUT          0x327F
-#define TCM825X_ESROUT2         0x33FF
-#define TCM825X_AGOUT           0x34FF
-#define TCM825X_DGOUT           0x353F
-#define TCM825X_AGSLOW1         0x39C0
-#define TCM825X_FLLSMODE        0x3930
-#define TCM825X_FLLSLIM         0x390F
-#define TCM825X_DETSEL          0x3AF0
-#define TCM825X_ACDETNC         0x3A0F
-#define TCM825X_AGSLOW2         0x3BC0
-#define TCM825X_DG              0x3B3F
-#define TCM825X_REJHLEV         0x3CFF
-#define TCM825X_ALCLOCK         0x3D80
-#define TCM825X_FPSLNKSW        0x3D40
-#define TCM825X_ALCSPD          0x3D30
-#define TCM825X_REJH            0x3D03
-#define TCM825X_SHESRSW         0x3E80
-#define TCM825X_ESLIMSEL        0x3E40
-#define TCM825X_SHESRSPD        0x3E30
-#define TCM825X_ELSTEP          0x3E0C
-#define TCM825X_ELSTART         0x3E03
-#define TCM825X_AGMIN           0x3FFF
-#define TCM825X_PREGRG          0x423F
-#define TCM825X_PREGBG          0x433F
-#define TCM825X_PRERG           0x443F
-#define TCM825X_PREBG           0x453F
-#define TCM825X_MSKBR           0x477F
-#define TCM825X_MSKGR           0x487F
-#define TCM825X_MSKRB           0x497F
-#define TCM825X_MSKGB           0x4A7F
-#define TCM825X_MSKRG           0x4B7F
-#define TCM825X_MSKBG           0x4C7F
-#define TCM825X_HDTCSW          0x4D80
-#define TCM825X_VDTCSW          0x4D40
-#define TCM825X_DTCYL           0x4D3F
-#define TCM825X_HDTPSW          0x4E80
-#define TCM825X_VDTPSW          0x4E40
-#define TCM825X_DTCGAIN         0x4E3F
-#define TCM825X_DTLLIMSW        0x4F10
-#define TCM825X_DTLYLIM         0x4F0F
-#define TCM825X_YLCUTLMSK       0x5080
-#define TCM825X_YLCUTL          0x503F
-#define TCM825X_YLCUTHMSK       0x5180
-#define TCM825X_YLCUTH          0x513F
-#define TCM825X_UVSKNC          0x527F
-#define TCM825X_UVLJ            0x537F
-#define TCM825X_WBGMIN          0x54FF
-#define TCM825X_WBGMAX          0x55FF
-#define TCM825X_WBSPDUP         0x5603
-#define TCM825X_ALLAREA         0x5820
-#define TCM825X_WBLOCK          0x5810
-#define TCM825X_WB2SP           0x580F
-#define TCM825X_KIZUSW          0x5920
-#define TCM825X_PBRSW           0x5910
-#define TCM825X_ABCSW           0x5903
-#define TCM825X_PBDLV           0x5AFF
-#define TCM825X_PBC1LV          0x5BFF
-
-#define TCM825X_NUM_REGS        (TCM825X_ADDR(TCM825X_PBC1LV) + 1)
-
-#define TCM825X_BYTES_PER_PIXEL 2
-
-#define TCM825X_REG_TERM 0xff           /* terminating list entry for reg */
-#define TCM825X_VAL_TERM 0xff           /* terminating list entry for val */
-
-/* define a structure for tcm825x register initialization values */
-struct tcm825x_reg {
-        u8 val;
-        u16 reg;
-};
-
-enum image_size { subQCIF = 0, QQVGA, QCIF, QVGA, CIF, VGA };
-enum pixel_format { YUV422 = 0, RGB565 };
-#define NUM_IMAGE_SIZES 6
-#define NUM_PIXEL_FORMATS 2
-
-#define TCM825X_XCLK_MIN        11900000
-#define TCM825X_XCLK_MAX        25000000
-
-struct capture_size {
-        unsigned long width;
-        unsigned long height;
-};
-
-struct tcm825x_platform_data {
-        /* Is the sensor usable? Doesn't yet mean it's there, but you
-         * can try! */
-        int (*is_okay)(void);
-        /* Set power state, zero is off, non-zero is on. */
-        int (*power_set)(int power);
-        /* Default registers written after power-on or reset. */
-        const struct tcm825x_reg * (*default_regs)(void);
-        int (*needs_reset)(struct v4l2_int_device *s, void *buf,
-                           struct v4l2_pix_format *fmt);
-        int (*ifparm)(struct v4l2_ifparm *p);
-        int (*is_upside_down)(void);
-};
-
-/* Array of image sizes supported by TCM825X.  These must be ordered from
- * smallest image size to largest.
- */
-static const struct capture_size tcm825x_sizes[] = {
-        { 128,  96 }, /* subQCIF */
-        { 160, 120 }, /* QQVGA */
-        { 176, 144 }, /* QCIF */
-        { 320, 240 }, /* QVGA */
-        { 352, 288 }, /* CIF */
-        { 640, 480 }, /* VGA */
-};
-
-#endif /* ifndef TCM825X_H */
diff --git a/drivers/staging/media/omap24xx/v4l2-int-device.c b/drivers/staging/media/omap24xx/v4l2-int-device.c
deleted file mode 100644
index 427a89033a1d..000000000000
--- a/drivers/staging/media/omap24xx/v4l2-int-device.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * drivers/media/video/v4l2-int-device.c
- *
- * V4L2 internal ioctl interface.
- *
- * Copyright (C) 2007 Nokia Corporation.
- *
- * Contact: Sakari Ailus <sakari.ailus@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#include <linux/kernel.h>
-#include <linux/list.h>
-#include <linux/sort.h>
-#include <linux/string.h>
-#include <linux/module.h>
-
-#include "v4l2-int-device.h"
-
-static DEFINE_MUTEX(mutex);
-static LIST_HEAD(int_list);
-
-void v4l2_int_device_try_attach_all(void)
-{
-        struct v4l2_int_device *m, *s;
-
-        list_for_each_entry(m, &int_list, head) {
-                if (m->type != v4l2_int_type_master)
-                        continue;
-
-                list_for_each_entry(s, &int_list, head) {
-                        if (s->type != v4l2_int_type_slave)
-                                continue;
-
-                        /* Slave is connected? */
-                        if (s->u.slave->master)
-                                continue;
-
-                        /* Slave wants to attach to master? */
-                        if (s->u.slave->attach_to[0] != 0
-                            && strncmp(m->name, s->u.slave->attach_to,
-                                       V4L2NAMESIZE))
-                                continue;
-
-                        if (!try_module_get(m->module))
-                                continue;
-
-                        s->u.slave->master = m;
-                        if (m->u.master->attach(s)) {
-                                s->u.slave->master = NULL;
-                                module_put(m->module);
-                                continue;
-                        }
-                }
-        }
-}
-EXPORT_SYMBOL_GPL(v4l2_int_device_try_attach_all);
-
-static int ioctl_sort_cmp(const void *a, const void *b)
-{
-        const struct v4l2_int_ioctl_desc *d1 = a, *d2 = b;
-
-        if (d1->num > d2->num)
-                return 1;
-
-        if (d1->num < d2->num)
-                return -1;
-
-        return 0;
-}
-
-int v4l2_int_device_register(struct v4l2_int_device *d)
-{
-        if (d->type == v4l2_int_type_slave)
-                sort(d->u.slave->ioctls, d->u.slave->num_ioctls,
-                     sizeof(struct v4l2_int_ioctl_desc),
-                     &ioctl_sort_cmp, NULL);
-        mutex_lock(&mutex);
-        list_add(&d->head, &int_list);
-        v4l2_int_device_try_attach_all();
-        mutex_unlock(&mutex);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(v4l2_int_device_register);
-
-void v4l2_int_device_unregister(struct v4l2_int_device *d)
-{
-        mutex_lock(&mutex);
-        list_del(&d->head);
-        if (d->type == v4l2_int_type_slave
-            && d->u.slave->master != NULL) {
-                d->u.slave->master->u.master->detach(d);
-                module_put(d->u.slave->master->module);
-                d->u.slave->master = NULL;
-        }
-        mutex_unlock(&mutex);
-}
-EXPORT_SYMBOL_GPL(v4l2_int_device_unregister);
-
-/* Adapted from search_extable in extable.c. */
-static v4l2_int_ioctl_func *find_ioctl(struct v4l2_int_slave *slave, int cmd,
-                                       v4l2_int_ioctl_func *no_such_ioctl)
-{
-        const struct v4l2_int_ioctl_desc *first = slave->ioctls;
-        const struct v4l2_int_ioctl_desc *last =
-                first + slave->num_ioctls - 1;
-
-        while (first <= last) {
-                const struct v4l2_int_ioctl_desc *mid;
-
-                mid = (last - first) / 2 + first;
-
-                if (mid->num < cmd)
-                        first = mid + 1;
-                else if (mid->num > cmd)
-                        last = mid - 1;
-                else
-                        return mid->func;
-        }
-
-        return no_such_ioctl;
-}
-
-static int no_such_ioctl_0(struct v4l2_int_device *d)
-{
-        return -ENOIOCTLCMD;
-}
-
-int v4l2_int_ioctl_0(struct v4l2_int_device *d, int cmd)
-{
-        return ((v4l2_int_ioctl_func_0 *)
-                find_ioctl(d->u.slave, cmd,
-                           (v4l2_int_ioctl_func *)no_such_ioctl_0))(d);
-}
-EXPORT_SYMBOL_GPL(v4l2_int_ioctl_0);
-
-static int no_such_ioctl_1(struct v4l2_int_device *d, void *arg)
-{
-        return -ENOIOCTLCMD;
-}
-
-int v4l2_int_ioctl_1(struct v4l2_int_device *d, int cmd, void *arg)
-{
-        return ((v4l2_int_ioctl_func_1 *)
-                find_ioctl(d->u.slave, cmd,
-                           (v4l2_int_ioctl_func *)no_such_ioctl_1))(d, arg);
-}
-EXPORT_SYMBOL_GPL(v4l2_int_ioctl_1);
-
-MODULE_LICENSE("GPL");
diff --git a/drivers/staging/media/omap24xx/v4l2-int-device.h b/drivers/staging/media/omap24xx/v4l2-int-device.h
deleted file mode 100644
index 0286c95814ff..000000000000
--- a/drivers/staging/media/omap24xx/v4l2-int-device.h
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- * include/media/v4l2-int-device.h
- *
- * V4L2 internal ioctl interface.
- *
- * Copyright (C) 2007 Nokia Corporation.
- *
- * Contact: Sakari Ailus <sakari.ailus@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#ifndef V4L2_INT_DEVICE_H
-#define V4L2_INT_DEVICE_H
-
-#include <media/v4l2-common.h>
-
-#define V4L2NAMESIZE 32
-
-/*
- *
- * The internal V4L2 device interface core.
- *
- */
-
-enum v4l2_int_type {
-        v4l2_int_type_master = 1,
-        v4l2_int_type_slave
-};
-
-struct module;
-
-struct v4l2_int_device;
-
-struct v4l2_int_master {
-        int (*attach)(struct v4l2_int_device *slave);
-        void (*detach)(struct v4l2_int_device *slave);
-};
-
-typedef int (v4l2_int_ioctl_func)(struct v4l2_int_device *);
-typedef int (v4l2_int_ioctl_func_0)(struct v4l2_int_device *);
-typedef int (v4l2_int_ioctl_func_1)(struct v4l2_int_device *, void *);
-
-struct v4l2_int_ioctl_desc {
-        int num;
-        v4l2_int_ioctl_func *func;
-};
-
-struct v4l2_int_slave {
-        /* Don't touch master. */
-        struct v4l2_int_device *master;
-
-        char attach_to[V4L2NAMESIZE];
-
-        int num_ioctls;
-        struct v4l2_int_ioctl_desc *ioctls;
-};
-
-struct v4l2_int_device {
-        /* Don't touch head. */
-        struct list_head head;
-
-        struct module *module;
-
-        char name[V4L2NAMESIZE];
-
-        enum v4l2_int_type type;
-        union {
-                struct v4l2_int_master *master;
-                struct v4l2_int_slave *slave;
-        } u;
-
-        void *priv;
-};
-
-void v4l2_int_device_try_attach_all(void);
-
-int v4l2_int_device_register(struct v4l2_int_device *d);
-void v4l2_int_device_unregister(struct v4l2_int_device *d);
-
-int v4l2_int_ioctl_0(struct v4l2_int_device *d, int cmd);
-int v4l2_int_ioctl_1(struct v4l2_int_device *d, int cmd, void *arg);
-
-/*
- *
- * Types and definitions for IOCTL commands.
- *
- */
-
-enum v4l2_power {
-        V4L2_POWER_OFF = 0,
-        V4L2_POWER_ON,
-        V4L2_POWER_STANDBY,
-};
-
-/* Slave interface type. */
-enum v4l2_if_type {
-        /*
-         * Parallel 8-, 10- or 12-bit interface, used by for example
-         * on certain image sensors.
-         */
-        V4L2_IF_TYPE_BT656,
-};
-
-enum v4l2_if_type_bt656_mode {
-        /*
-         * Modes without Bt synchronisation codes. Separate
-         * synchronisation signal lines are used.
-         */
-        V4L2_IF_TYPE_BT656_MODE_NOBT_8BIT,
-        V4L2_IF_TYPE_BT656_MODE_NOBT_10BIT,
-        V4L2_IF_TYPE_BT656_MODE_NOBT_12BIT,
-        /*
-         * Use Bt synchronisation codes. The vertical and horizontal
-         * synchronisation is done based on synchronisation codes.
-         */
-        V4L2_IF_TYPE_BT656_MODE_BT_8BIT,
-        V4L2_IF_TYPE_BT656_MODE_BT_10BIT,
-};
-
-struct v4l2_if_type_bt656 {
-        /*
-         * 0: Frame begins when vsync is high.
-         * 1: Frame begins when vsync changes from low to high.
-         */
-        unsigned frame_start_on_rising_vs:1;
-        /* Use Bt synchronisation codes for sync correction. */
-        unsigned bt_sync_correct:1;
-        /* Swap every two adjacent image data elements. */
-        unsigned swap:1;
-        /* Inverted latch clock polarity from slave. */
-        unsigned latch_clk_inv:1;
-        /* Hs polarity. 0 is active high, 1 active low. */
-        unsigned nobt_hs_inv:1;
-        /* Vs polarity. 0 is active high, 1 active low. */
-        unsigned nobt_vs_inv:1;
-        enum v4l2_if_type_bt656_mode mode;
-        /* Minimum accepted bus clock for slave (in Hz). */
-        u32 clock_min;
-        /* Maximum accepted bus clock for slave. */
-        u32 clock_max;
-        /*
-         * Current wish of the slave. May only change in response to
-         * ioctls that affect image capture.
-         */
-        u32 clock_curr;
-};
-
-struct v4l2_ifparm {
-        enum v4l2_if_type if_type;
-        union {
-                struct v4l2_if_type_bt656 bt656;
-        } u;
-};
-
-/* IOCTL command numbers. */
-enum v4l2_int_ioctl_num {
-        /*
-         *
-         * "Proper" V4L ioctls, as in struct video_device.
-         *
-         */
-        vidioc_int_enum_fmt_cap_num = 1,
-        vidioc_int_g_fmt_cap_num,
-        vidioc_int_s_fmt_cap_num,
-        vidioc_int_try_fmt_cap_num,
-        vidioc_int_queryctrl_num,
-        vidioc_int_g_ctrl_num,
-        vidioc_int_s_ctrl_num,
-        vidioc_int_cropcap_num,
-        vidioc_int_g_crop_num,
-        vidioc_int_s_crop_num,
-        vidioc_int_g_parm_num,
-        vidioc_int_s_parm_num,
-        vidioc_int_querystd_num,
-        vidioc_int_s_std_num,
-        vidioc_int_s_video_routing_num,
-
-        /*
-         *
-         * Strictly internal ioctls.
-         *
-         */
-        /* Initialise the device when slave attaches to the master. */
-        vidioc_int_dev_init_num = 1000,
-        /* Delinitialise the device at slave detach. */
-        vidioc_int_dev_exit_num,
-        /* Set device power state. */
-        vidioc_int_s_power_num,
-        /*
-        * Get slave private data, e.g. platform-specific slave
-        * configuration used by the master.
-        */
-        vidioc_int_g_priv_num,
-        /* Get slave interface parameters. */
-        vidioc_int_g_ifparm_num,
-        /* Does the slave need to be reset after VIDIOC_DQBUF? */
-        vidioc_int_g_needs_reset_num,
-        vidioc_int_enum_framesizes_num,
-        vidioc_int_enum_frameintervals_num,
-
-        /*
-         *
-         * VIDIOC_INT_* ioctls.
-         *
-         */
-        /* VIDIOC_INT_RESET */
-        vidioc_int_reset_num,
-        /* VIDIOC_INT_INIT */
-        vidioc_int_init_num,
-
-        /*
-         *
-         * Start of private ioctls.
-         *
-         */
-        vidioc_int_priv_start_num = 2000,
-};
-
-/*
- *
- * IOCTL wrapper functions for better type checking.
- *
- */
-
-#define V4L2_INT_WRAPPER_0(name)                                        \
-        static inline int vidioc_int_##name(struct v4l2_int_device *d)  \
-        {                                                               \
-                return v4l2_int_ioctl_0(d, vidioc_int_##name##_num);    \
-        }                                                               \
-                                                                        \
-        static inline struct v4l2_int_ioctl_desc                        \
-        vidioc_int_##name##_cb(int (*func)                              \
-                               (struct v4l2_int_device *))              \
-        {                                                               \
-                struct v4l2_int_ioctl_desc desc;                        \
-                                                                        \
-                desc.num = vidioc_int_##name##_num;                     \
-                desc.func = (v4l2_int_ioctl_func *)func;                \
-                                                                        \
-                return desc;                                            \
-        }
-
-#define V4L2_INT_WRAPPER_1(name, arg_type, asterisk)                    \
-        static inline int vidioc_int_##name(struct v4l2_int_device *d,  \
-                                            arg_type asterisk arg)      \
-        {                                                               \
-                return v4l2_int_ioctl_1(d, vidioc_int_##name##_num,     \
-                                        (void *)(unsigned long)arg);    \
-        }                                                               \
-                                                                        \
-        static inline struct v4l2_int_ioctl_desc                        \
-        vidioc_int_##name##_cb(int (*func)                              \
-                               (struct v4l2_int_device *,               \
-                                arg_type asterisk))                     \
-        {                                                               \
-                struct v4l2_int_ioctl_desc desc;                        \
-                                                                        \
-                desc.num = vidioc_int_##name##_num;                     \
-                desc.func = (v4l2_int_ioctl_func *)func;                \
-                                                                        \
-                return desc;                                            \
-        }
-
-V4L2_INT_WRAPPER_1(enum_fmt_cap, struct v4l2_fmtdesc, *);
-V4L2_INT_WRAPPER_1(g_fmt_cap, struct v4l2_format, *);
-V4L2_INT_WRAPPER_1(s_fmt_cap, struct v4l2_format, *);
-V4L2_INT_WRAPPER_1(try_fmt_cap, struct v4l2_format, *);
-V4L2_INT_WRAPPER_1(queryctrl, struct v4l2_queryctrl, *);
-V4L2_INT_WRAPPER_1(g_ctrl, struct v4l2_control, *);
-V4L2_INT_WRAPPER_1(s_ctrl, struct v4l2_control, *);
-V4L2_INT_WRAPPER_1(cropcap, struct v4l2_cropcap, *);
-V4L2_INT_WRAPPER_1(g_crop, struct v4l2_crop, *);
-V4L2_INT_WRAPPER_1(s_crop, struct v4l2_crop, *);
-V4L2_INT_WRAPPER_1(g_parm, struct v4l2_streamparm, *);
-V4L2_INT_WRAPPER_1(s_parm, struct v4l2_streamparm, *);
-V4L2_INT_WRAPPER_1(querystd, v4l2_std_id, *);
-V4L2_INT_WRAPPER_1(s_std, v4l2_std_id, *);
-V4L2_INT_WRAPPER_1(s_video_routing, struct v4l2_routing, *);
-
-V4L2_INT_WRAPPER_0(dev_init);
-V4L2_INT_WRAPPER_0(dev_exit);
-V4L2_INT_WRAPPER_1(s_power, enum v4l2_power, );
-V4L2_INT_WRAPPER_1(g_priv, void, *);
-V4L2_INT_WRAPPER_1(g_ifparm, struct v4l2_ifparm, *);
-V4L2_INT_WRAPPER_1(g_needs_reset, void, *);
-V4L2_INT_WRAPPER_1(enum_framesizes, struct v4l2_frmsizeenum, *);
-V4L2_INT_WRAPPER_1(enum_frameintervals, struct v4l2_frmivalenum, *);
-
-V4L2_INT_WRAPPER_0(reset);
-V4L2_INT_WRAPPER_0(init);
-
-#endif
diff --git a/drivers/staging/media/omap4iss/iss_csi2.c b/drivers/staging/media/omap4iss/iss_csi2.c
index 92c2d5b743c7..7dbf68cd3566 100644
--- a/drivers/staging/media/omap4iss/iss_csi2.c
+++ b/drivers/staging/media/omap4iss/iss_csi2.c
@@ -93,20 +93,20 @@ static void csi2_recv_config(struct iss_csi2_device *csi2,
 }
 
 static const unsigned int csi2_input_fmts[] = {
-        V4L2_MBUS_FMT_SGRBG10_1X10,
-        V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SRGGB10_1X10,
-        V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SBGGR10_1X10,
-        V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SGBRG10_1X10,
-        V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8,
-        V4L2_MBUS_FMT_SBGGR8_1X8,
-        V4L2_MBUS_FMT_SGBRG8_1X8,
-        V4L2_MBUS_FMT_SGRBG8_1X8,
-        V4L2_MBUS_FMT_SRGGB8_1X8,
-        V4L2_MBUS_FMT_UYVY8_1X16,
-        V4L2_MBUS_FMT_YUYV8_1X16,
+        MEDIA_BUS_FMT_SGRBG10_1X10,
+        MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SRGGB10_1X10,
+        MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SBGGR10_1X10,
+        MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SGBRG10_1X10,
+        MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8,
+        MEDIA_BUS_FMT_SBGGR8_1X8,
+        MEDIA_BUS_FMT_SGBRG8_1X8,
+        MEDIA_BUS_FMT_SGRBG8_1X8,
+        MEDIA_BUS_FMT_SRGGB8_1X8,
+        MEDIA_BUS_FMT_UYVY8_1X16,
+        MEDIA_BUS_FMT_YUYV8_1X16,
 };
 
 /* To set the format on the CSI2 requires a mapping function that takes
@@ -201,26 +201,26 @@ static u16 csi2_ctx_map_format(struct iss_csi2_device *csi2)
         int fmtidx, destidx;
 
         switch (fmt->code) {
-        case V4L2_MBUS_FMT_SGRBG10_1X10:
-        case V4L2_MBUS_FMT_SRGGB10_1X10:
-        case V4L2_MBUS_FMT_SBGGR10_1X10:
-        case V4L2_MBUS_FMT_SGBRG10_1X10:
+        case MEDIA_BUS_FMT_SGRBG10_1X10:
+        case MEDIA_BUS_FMT_SRGGB10_1X10:
+        case MEDIA_BUS_FMT_SBGGR10_1X10:
+        case MEDIA_BUS_FMT_SGBRG10_1X10:
                 fmtidx = 0;
                 break;
-        case V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8:
-        case V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8:
+        case MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8:
                 fmtidx = 1;
                 break;
-        case V4L2_MBUS_FMT_SBGGR8_1X8:
-        case V4L2_MBUS_FMT_SGBRG8_1X8:
-        case V4L2_MBUS_FMT_SGRBG8_1X8:
-        case V4L2_MBUS_FMT_SRGGB8_1X8:
+        case MEDIA_BUS_FMT_SBGGR8_1X8:
+        case MEDIA_BUS_FMT_SGBRG8_1X8:
+        case MEDIA_BUS_FMT_SGRBG8_1X8:
+        case MEDIA_BUS_FMT_SRGGB8_1X8:
                 fmtidx = 2;
                 break;
-        case V4L2_MBUS_FMT_UYVY8_1X16:
-        case V4L2_MBUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_UYVY8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
                 fmtidx = 3;
                 break;
         default:
@@ -817,7 +817,7 @@ csi2_try_format(struct iss_csi2_device *csi2, struct v4l2_subdev_fh *fh,
                 unsigned int pad, struct v4l2_mbus_framefmt *fmt,
                 enum v4l2_subdev_format_whence which)
 {
-        enum v4l2_mbus_pixelcode pixelcode;
+        u32 pixelcode;
         struct v4l2_mbus_framefmt *format;
         const struct iss_format_info *info;
         unsigned int i;
@@ -832,7 +832,7 @@ csi2_try_format(struct iss_csi2_device *csi2, struct v4l2_subdev_fh *fh,
 
                 /* If not found, use SGRBG10 as default */
                 if (i >= ARRAY_SIZE(csi2_input_fmts))
-                        fmt->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                        fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
 
                 fmt->width = clamp_t(u32, fmt->width, 1, 8191);
                 fmt->height = clamp_t(u32, fmt->height, 1, 8191);
@@ -1020,7 +1020,7 @@ static int csi2_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = CSI2_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        format.format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         format.format.width = 4096;
         format.format.height = 4096;
         csi2_set_format(sd, fh, &format);
diff --git a/drivers/staging/media/omap4iss/iss_ipipe.c b/drivers/staging/media/omap4iss/iss_ipipe.c
index 54042008154c..a1a46ef8319b 100644
--- a/drivers/staging/media/omap4iss/iss_ipipe.c
+++ b/drivers/staging/media/omap4iss/iss_ipipe.c
@@ -28,10 +28,10 @@ __ipipe_get_format(struct iss_ipipe_device *ipipe, struct v4l2_subdev_fh *fh,
                   unsigned int pad, enum v4l2_subdev_format_whence which);
 
 static const unsigned int ipipe_fmts[] = {
-        V4L2_MBUS_FMT_SGRBG10_1X10,
-        V4L2_MBUS_FMT_SRGGB10_1X10,
-        V4L2_MBUS_FMT_SBGGR10_1X10,
-        V4L2_MBUS_FMT_SGBRG10_1X10,
+        MEDIA_BUS_FMT_SGRBG10_1X10,
+        MEDIA_BUS_FMT_SRGGB10_1X10,
+        MEDIA_BUS_FMT_SBGGR10_1X10,
+        MEDIA_BUS_FMT_SGBRG10_1X10,
 };
 
 /*
@@ -211,7 +211,7 @@ ipipe_try_format(struct iss_ipipe_device *ipipe, struct v4l2_subdev_fh *fh,
 
                 /* If not found, use SGRBG10 as default */
                 if (i >= ARRAY_SIZE(ipipe_fmts))
-                        fmt->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                        fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
 
                 /* Clamp the input size. */
                 fmt->width = clamp_t(u32, width, 1, 8192);
@@ -223,7 +223,7 @@ ipipe_try_format(struct iss_ipipe_device *ipipe, struct v4l2_subdev_fh *fh,
                 format = __ipipe_get_format(ipipe, fh, IPIPE_PAD_SINK, which);
                 memcpy(fmt, format, sizeof(*fmt));
 
-                fmt->code = V4L2_MBUS_FMT_UYVY8_1X16;
+                fmt->code = MEDIA_BUS_FMT_UYVY8_1X16;
                 fmt->width = clamp_t(u32, width, 32, fmt->width);
                 fmt->height = clamp_t(u32, height, 32, fmt->height);
                 fmt->colorspace = V4L2_COLORSPACE_JPEG;
@@ -257,7 +257,7 @@ static int ipipe_enum_mbus_code(struct v4l2_subdev *sd,
                 if (code->index != 0)
                         return -EINVAL;
 
-                code->code = V4L2_MBUS_FMT_UYVY8_1X16;
+                code->code = MEDIA_BUS_FMT_UYVY8_1X16;
                 break;
 
         default:
@@ -385,7 +385,7 @@ static int ipipe_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
         memset(&format, 0, sizeof(format));
         format.pad = IPIPE_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        format.format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         format.format.width = 4096;
         format.format.height = 4096;
         ipipe_set_format(sd, fh, &format);
diff --git a/drivers/staging/media/omap4iss/iss_ipipeif.c b/drivers/staging/media/omap4iss/iss_ipipeif.c
index 75f6a15ad202..32a748398ced 100644
--- a/drivers/staging/media/omap4iss/iss_ipipeif.c
+++ b/drivers/staging/media/omap4iss/iss_ipipeif.c
@@ -24,12 +24,12 @@
 #include "iss_ipipeif.h"
 
 static const unsigned int ipipeif_fmts[] = {
-        V4L2_MBUS_FMT_SGRBG10_1X10,
-        V4L2_MBUS_FMT_SRGGB10_1X10,
-        V4L2_MBUS_FMT_SBGGR10_1X10,
-        V4L2_MBUS_FMT_SGBRG10_1X10,
-        V4L2_MBUS_FMT_UYVY8_1X16,
-        V4L2_MBUS_FMT_YUYV8_1X16,
+        MEDIA_BUS_FMT_SGRBG10_1X10,
+        MEDIA_BUS_FMT_SRGGB10_1X10,
+        MEDIA_BUS_FMT_SBGGR10_1X10,
+        MEDIA_BUS_FMT_SGBRG10_1X10,
+        MEDIA_BUS_FMT_UYVY8_1X16,
+        MEDIA_BUS_FMT_YUYV8_1X16,
 };
 
 /*
@@ -140,8 +140,8 @@ static void ipipeif_configure(struct iss_ipipeif_device *ipipeif)
 
         /* Select ISIF/IPIPEIF input format */
         switch (format->code) {
-        case V4L2_MBUS_FMT_UYVY8_1X16:
-        case V4L2_MBUS_FMT_YUYV8_1X16:
+        case MEDIA_BUS_FMT_UYVY8_1X16:
+        case MEDIA_BUS_FMT_YUYV8_1X16:
                 iss_reg_update(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_MODESET,
                                ISIF_MODESET_CCDMD | ISIF_MODESET_INPMOD_MASK |
                                ISIF_MODESET_CCDW_MASK,
@@ -151,25 +151,25 @@ static void ipipeif_configure(struct iss_ipipeif_device *ipipeif)
                                IPIPEIF_CFG2_YUV8, IPIPEIF_CFG2_YUV16);
 
                 break;
-        case V4L2_MBUS_FMT_SGRBG10_1X10:
+        case MEDIA_BUS_FMT_SGRBG10_1X10:
                 isif_ccolp = ISIF_CCOLP_CP0_F0_GR |
                         ISIF_CCOLP_CP1_F0_R |
                         ISIF_CCOLP_CP2_F0_B |
                         ISIF_CCOLP_CP3_F0_GB;
                 goto cont_raw;
-        case V4L2_MBUS_FMT_SRGGB10_1X10:
+        case MEDIA_BUS_FMT_SRGGB10_1X10:
                 isif_ccolp = ISIF_CCOLP_CP0_F0_R |
                         ISIF_CCOLP_CP1_F0_GR |
                         ISIF_CCOLP_CP2_F0_GB |
                         ISIF_CCOLP_CP3_F0_B;
                 goto cont_raw;
-        case V4L2_MBUS_FMT_SBGGR10_1X10:
+        case MEDIA_BUS_FMT_SBGGR10_1X10:
                 isif_ccolp = ISIF_CCOLP_CP0_F0_B |
                         ISIF_CCOLP_CP1_F0_GB |
                         ISIF_CCOLP_CP2_F0_GR |
                         ISIF_CCOLP_CP3_F0_R;
                 goto cont_raw;
-        case V4L2_MBUS_FMT_SGBRG10_1X10:
+        case MEDIA_BUS_FMT_SGBRG10_1X10:
                 isif_ccolp = ISIF_CCOLP_CP0_F0_GB |
                         ISIF_CCOLP_CP1_F0_B |
                         ISIF_CCOLP_CP2_F0_R |
@@ -415,7 +415,7 @@ ipipeif_try_format(struct iss_ipipeif_device *ipipeif,
 
                 /* If not found, use SGRBG10 as default */
                 if (i >= ARRAY_SIZE(ipipeif_fmts))
-                        fmt->code = V4L2_MBUS_FMT_SGRBG10_1X10;
+                        fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
 
                 /* Clamp the input size. */
                 fmt->width = clamp_t(u32, width, 1, 8192);
@@ -625,7 +625,7 @@ static int ipipeif_init_formats(struct v4l2_subdev *sd,
         memset(&format, 0, sizeof(format));
         format.pad = IPIPEIF_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
+        format.format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
         format.format.width = 4096;
         format.format.height = 4096;
         ipipeif_set_format(sd, fh, &format);
diff --git a/drivers/staging/media/omap4iss/iss_resizer.c b/drivers/staging/media/omap4iss/iss_resizer.c
index a21e356cce3a..88522a8cdf56 100644
--- a/drivers/staging/media/omap4iss/iss_resizer.c
+++ b/drivers/staging/media/omap4iss/iss_resizer.c
@@ -24,8 +24,8 @@
 #include "iss_resizer.h"
 
 static const unsigned int resizer_fmts[] = {
-        V4L2_MBUS_FMT_UYVY8_1X16,
-        V4L2_MBUS_FMT_YUYV8_1X16,
+        MEDIA_BUS_FMT_UYVY8_1X16,
+        MEDIA_BUS_FMT_YUYV8_1X16,
 };
 
 /*
@@ -156,8 +156,8 @@ static void resizer_set_outaddr(struct iss_resizer_device *resizer, u32 addr)
                       addr & 0xffff);
 
         /* Program UV buffer address... Hardcoded to be contiguous! */
-        if ((informat->code == V4L2_MBUS_FMT_UYVY8_1X16) &&
-            (outformat->code == V4L2_MBUS_FMT_YUYV8_1_5X8)) {
+        if ((informat->code == MEDIA_BUS_FMT_UYVY8_1X16) &&
+            (outformat->code == MEDIA_BUS_FMT_YUYV8_1_5X8)) {
                 u32 c_addr = addr + (resizer->video_out.bpl_value *
                                      (outformat->height - 1));
 
@@ -242,8 +242,8 @@ static void resizer_configure(struct iss_resizer_device *resizer)
                       resizer->video_out.bpl_value);
 
         /* UYVY -> NV12 conversion */
-        if ((informat->code == V4L2_MBUS_FMT_UYVY8_1X16) &&
-            (outformat->code == V4L2_MBUS_FMT_YUYV8_1_5X8)) {
+        if ((informat->code == MEDIA_BUS_FMT_UYVY8_1X16) &&
+            (outformat->code == MEDIA_BUS_FMT_YUYV8_1_5X8)) {
                 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_RESIZER, RZA_420,
                               RSZ_420_CEN | RSZ_420_YEN);
 
@@ -457,7 +457,7 @@ resizer_try_format(struct iss_resizer_device *resizer,
                    struct v4l2_mbus_framefmt *fmt,
                    enum v4l2_subdev_format_whence which)
 {
-        enum v4l2_mbus_pixelcode pixelcode;
+        u32 pixelcode;
         struct v4l2_mbus_framefmt *format;
         unsigned int width = fmt->width;
         unsigned int height = fmt->height;
@@ -472,7 +472,7 @@ resizer_try_format(struct iss_resizer_device *resizer,
 
                 /* If not found, use UYVY as default */
                 if (i >= ARRAY_SIZE(resizer_fmts))
-                        fmt->code = V4L2_MBUS_FMT_UYVY8_1X16;
+                        fmt->code = MEDIA_BUS_FMT_UYVY8_1X16;
 
                 /* Clamp the input size. */
                 fmt->width = clamp_t(u32, width, 1, 8192);
@@ -485,8 +485,8 @@ resizer_try_format(struct iss_resizer_device *resizer,
                                               which);
                 memcpy(fmt, format, sizeof(*fmt));
 
-                if ((pixelcode == V4L2_MBUS_FMT_YUYV8_1_5X8) &&
-                    (fmt->code == V4L2_MBUS_FMT_UYVY8_1X16))
+                if ((pixelcode == MEDIA_BUS_FMT_YUYV8_1_5X8) &&
+                    (fmt->code == MEDIA_BUS_FMT_UYVY8_1X16))
                         fmt->code = pixelcode;
 
                 /* The data formatter truncates the number of horizontal output
@@ -537,9 +537,9 @@ static int resizer_enum_mbus_code(struct v4l2_subdev *sd,
                 }
 
                 switch (format->code) {
-                case V4L2_MBUS_FMT_UYVY8_1X16:
+                case MEDIA_BUS_FMT_UYVY8_1X16:
                         if (code->index == 1)
-                                code->code = V4L2_MBUS_FMT_YUYV8_1_5X8;
+                                code->code = MEDIA_BUS_FMT_YUYV8_1_5X8;
                         else
                                 return -EINVAL;
                         break;
@@ -680,7 +680,7 @@ static int resizer_init_formats(struct v4l2_subdev *sd,
         memset(&format, 0, sizeof(format));
         format.pad = RESIZER_PAD_SINK;
         format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
-        format.format.code = V4L2_MBUS_FMT_UYVY8_1X16;
+        format.format.code = MEDIA_BUS_FMT_UYVY8_1X16;
         format.format.width = 4096;
         format.format.height = 4096;
         resizer_set_format(sd, fh, &format);
diff --git a/drivers/staging/media/omap4iss/iss_video.c b/drivers/staging/media/omap4iss/iss_video.c
index 5d6250337fec..cdee5966cbca 100644
--- a/drivers/staging/media/omap4iss/iss_video.c
+++ b/drivers/staging/media/omap4iss/iss_video.c
@@ -34,67 +34,67 @@ MODULE_PARM_DESC(debug, "activates debug info");
  */
 
 static struct iss_format_info formats[] = {
-        { V4L2_MBUS_FMT_Y8_1X8, V4L2_MBUS_FMT_Y8_1X8,
-          V4L2_MBUS_FMT_Y8_1X8, V4L2_MBUS_FMT_Y8_1X8,
+        { MEDIA_BUS_FMT_Y8_1X8, MEDIA_BUS_FMT_Y8_1X8,
+          MEDIA_BUS_FMT_Y8_1X8, MEDIA_BUS_FMT_Y8_1X8,
           V4L2_PIX_FMT_GREY, 8, "Greyscale 8 bpp", },
-        { V4L2_MBUS_FMT_Y10_1X10, V4L2_MBUS_FMT_Y10_1X10,
-          V4L2_MBUS_FMT_Y10_1X10, V4L2_MBUS_FMT_Y8_1X8,
+        { MEDIA_BUS_FMT_Y10_1X10, MEDIA_BUS_FMT_Y10_1X10,
+          MEDIA_BUS_FMT_Y10_1X10, MEDIA_BUS_FMT_Y8_1X8,
           V4L2_PIX_FMT_Y10, 10, "Greyscale 10 bpp", },
-        { V4L2_MBUS_FMT_Y12_1X12, V4L2_MBUS_FMT_Y10_1X10,
-          V4L2_MBUS_FMT_Y12_1X12, V4L2_MBUS_FMT_Y8_1X8,
+        { MEDIA_BUS_FMT_Y12_1X12, MEDIA_BUS_FMT_Y10_1X10,
+          MEDIA_BUS_FMT_Y12_1X12, MEDIA_BUS_FMT_Y8_1X8,
           V4L2_PIX_FMT_Y12, 12, "Greyscale 12 bpp", },
-        { V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_MBUS_FMT_SBGGR8_1X8,
-          V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_MBUS_FMT_SBGGR8_1X8,
+        { MEDIA_BUS_FMT_SBGGR8_1X8, MEDIA_BUS_FMT_SBGGR8_1X8,
+          MEDIA_BUS_FMT_SBGGR8_1X8, MEDIA_BUS_FMT_SBGGR8_1X8,
           V4L2_PIX_FMT_SBGGR8, 8, "BGGR Bayer 8 bpp", },
-        { V4L2_MBUS_FMT_SGBRG8_1X8, V4L2_MBUS_FMT_SGBRG8_1X8,
-          V4L2_MBUS_FMT_SGBRG8_1X8, V4L2_MBUS_FMT_SGBRG8_1X8,
+        { MEDIA_BUS_FMT_SGBRG8_1X8, MEDIA_BUS_FMT_SGBRG8_1X8,
+          MEDIA_BUS_FMT_SGBRG8_1X8, MEDIA_BUS_FMT_SGBRG8_1X8,
           V4L2_PIX_FMT_SGBRG8, 8, "GBRG Bayer 8 bpp", },
-        { V4L2_MBUS_FMT_SGRBG8_1X8, V4L2_MBUS_FMT_SGRBG8_1X8,
-          V4L2_MBUS_FMT_SGRBG8_1X8, V4L2_MBUS_FMT_SGRBG8_1X8,
+        { MEDIA_BUS_FMT_SGRBG8_1X8, MEDIA_BUS_FMT_SGRBG8_1X8,
+          MEDIA_BUS_FMT_SGRBG8_1X8, MEDIA_BUS_FMT_SGRBG8_1X8,
           V4L2_PIX_FMT_SGRBG8, 8, "GRBG Bayer 8 bpp", },
-        { V4L2_MBUS_FMT_SRGGB8_1X8, V4L2_MBUS_FMT_SRGGB8_1X8,
-          V4L2_MBUS_FMT_SRGGB8_1X8, V4L2_MBUS_FMT_SRGGB8_1X8,
+        { MEDIA_BUS_FMT_SRGGB8_1X8, MEDIA_BUS_FMT_SRGGB8_1X8,
+          MEDIA_BUS_FMT_SRGGB8_1X8, MEDIA_BUS_FMT_SRGGB8_1X8,
           V4L2_PIX_FMT_SRGGB8, 8, "RGGB Bayer 8 bpp", },
-        { V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8, V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
-          V4L2_MBUS_FMT_SGRBG10_1X10, 0,
+        { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
+          MEDIA_BUS_FMT_SGRBG10_1X10, 0,
           V4L2_PIX_FMT_SGRBG10DPCM8, 8, "GRBG Bayer 10 bpp DPCM8",  },
-        { V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_MBUS_FMT_SBGGR10_1X10,
-          V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_MBUS_FMT_SBGGR8_1X8,
+        { MEDIA_BUS_FMT_SBGGR10_1X10, MEDIA_BUS_FMT_SBGGR10_1X10,
+          MEDIA_BUS_FMT_SBGGR10_1X10, MEDIA_BUS_FMT_SBGGR8_1X8,
           V4L2_PIX_FMT_SBGGR10, 10, "BGGR Bayer 10 bpp", },
-        { V4L2_MBUS_FMT_SGBRG10_1X10, V4L2_MBUS_FMT_SGBRG10_1X10,
-          V4L2_MBUS_FMT_SGBRG10_1X10, V4L2_MBUS_FMT_SGBRG8_1X8,
+        { MEDIA_BUS_FMT_SGBRG10_1X10, MEDIA_BUS_FMT_SGBRG10_1X10,
+          MEDIA_BUS_FMT_SGBRG10_1X10, MEDIA_BUS_FMT_SGBRG8_1X8,
           V4L2_PIX_FMT_SGBRG10, 10, "GBRG Bayer 10 bpp", },
-        { V4L2_MBUS_FMT_SGRBG10_1X10, V4L2_MBUS_FMT_SGRBG10_1X10,
-          V4L2_MBUS_FMT_SGRBG10_1X10, V4L2_MBUS_FMT_SGRBG8_1X8,
+        { MEDIA_BUS_FMT_SGRBG10_1X10, MEDIA_BUS_FMT_SGRBG10_1X10,
+          MEDIA_BUS_FMT_SGRBG10_1X10, MEDIA_BUS_FMT_SGRBG8_1X8,
           V4L2_PIX_FMT_SGRBG10, 10, "GRBG Bayer 10 bpp", },
-        { V4L2_MBUS_FMT_SRGGB10_1X10, V4L2_MBUS_FMT_SRGGB10_1X10,
-          V4L2_MBUS_FMT_SRGGB10_1X10, V4L2_MBUS_FMT_SRGGB8_1X8,
+        { MEDIA_BUS_FMT_SRGGB10_1X10, MEDIA_BUS_FMT_SRGGB10_1X10,
+          MEDIA_BUS_FMT_SRGGB10_1X10, MEDIA_BUS_FMT_SRGGB8_1X8,
           V4L2_PIX_FMT_SRGGB10, 10, "RGGB Bayer 10 bpp", },
-        { V4L2_MBUS_FMT_SBGGR12_1X12, V4L2_MBUS_FMT_SBGGR10_1X10,
-          V4L2_MBUS_FMT_SBGGR12_1X12, V4L2_MBUS_FMT_SBGGR8_1X8,
+        { MEDIA_BUS_FMT_SBGGR12_1X12, MEDIA_BUS_FMT_SBGGR10_1X10,
+          MEDIA_BUS_FMT_SBGGR12_1X12, MEDIA_BUS_FMT_SBGGR8_1X8,
           V4L2_PIX_FMT_SBGGR12, 12, "BGGR Bayer 12 bpp", },
-        { V4L2_MBUS_FMT_SGBRG12_1X12, V4L2_MBUS_FMT_SGBRG10_1X10,
-          V4L2_MBUS_FMT_SGBRG12_1X12, V4L2_MBUS_FMT_SGBRG8_1X8,
+        { MEDIA_BUS_FMT_SGBRG12_1X12, MEDIA_BUS_FMT_SGBRG10_1X10,
+          MEDIA_BUS_FMT_SGBRG12_1X12, MEDIA_BUS_FMT_SGBRG8_1X8,
           V4L2_PIX_FMT_SGBRG12, 12, "GBRG Bayer 12 bpp", },
-        { V4L2_MBUS_FMT_SGRBG12_1X12, V4L2_MBUS_FMT_SGRBG10_1X10,
-          V4L2_MBUS_FMT_SGRBG12_1X12, V4L2_MBUS_FMT_SGRBG8_1X8,
+        { MEDIA_BUS_FMT_SGRBG12_1X12, MEDIA_BUS_FMT_SGRBG10_1X10,
+          MEDIA_BUS_FMT_SGRBG12_1X12, MEDIA_BUS_FMT_SGRBG8_1X8,
           V4L2_PIX_FMT_SGRBG12, 12, "GRBG Bayer 12 bpp", },
-        { V4L2_MBUS_FMT_SRGGB12_1X12, V4L2_MBUS_FMT_SRGGB10_1X10,
-          V4L2_MBUS_FMT_SRGGB12_1X12, V4L2_MBUS_FMT_SRGGB8_1X8,
+        { MEDIA_BUS_FMT_SRGGB12_1X12, MEDIA_BUS_FMT_SRGGB10_1X10,
+          MEDIA_BUS_FMT_SRGGB12_1X12, MEDIA_BUS_FMT_SRGGB8_1X8,
           V4L2_PIX_FMT_SRGGB12, 12, "RGGB Bayer 12 bpp", },
-        { V4L2_MBUS_FMT_UYVY8_1X16, V4L2_MBUS_FMT_UYVY8_1X16,
-          V4L2_MBUS_FMT_UYVY8_1X16, 0,
+        { MEDIA_BUS_FMT_UYVY8_1X16, MEDIA_BUS_FMT_UYVY8_1X16,
+          MEDIA_BUS_FMT_UYVY8_1X16, 0,
           V4L2_PIX_FMT_UYVY, 16, "YUV 4:2:2 (UYVY)", },
-        { V4L2_MBUS_FMT_YUYV8_1X16, V4L2_MBUS_FMT_YUYV8_1X16,
-          V4L2_MBUS_FMT_YUYV8_1X16, 0,
+        { MEDIA_BUS_FMT_YUYV8_1X16, MEDIA_BUS_FMT_YUYV8_1X16,
+          MEDIA_BUS_FMT_YUYV8_1X16, 0,
           V4L2_PIX_FMT_YUYV, 16, "YUV 4:2:2 (YUYV)", },
-        { V4L2_MBUS_FMT_YUYV8_1_5X8, V4L2_MBUS_FMT_YUYV8_1_5X8,
-          V4L2_MBUS_FMT_YUYV8_1_5X8, 0,
+        { MEDIA_BUS_FMT_YUYV8_1_5X8, MEDIA_BUS_FMT_YUYV8_1_5X8,
+          MEDIA_BUS_FMT_YUYV8_1_5X8, 0,
           V4L2_PIX_FMT_NV12, 8, "YUV 4:2:0 (NV12)", },
 };
 
 const struct iss_format_info *
-omap4iss_video_format_info(enum v4l2_mbus_pixelcode code)
+omap4iss_video_format_info(u32 code)
 {
         unsigned int i;
 
diff --git a/drivers/staging/media/omap4iss/iss_video.h b/drivers/staging/media/omap4iss/iss_video.h
index 9dccdb154e1a..f11fce2cb977 100644
--- a/drivers/staging/media/omap4iss/iss_video.h
+++ b/drivers/staging/media/omap4iss/iss_video.h
@@ -43,10 +43,10 @@ struct v4l2_pix_format;
  * @description: Human-readable format description
  */
 struct iss_format_info {
-        enum v4l2_mbus_pixelcode code;
-        enum v4l2_mbus_pixelcode truncated;
-        enum v4l2_mbus_pixelcode uncompressed;
-        enum v4l2_mbus_pixelcode flavor;
+        u32 code;
+        u32 truncated;
+        u32 uncompressed;
+        u32 flavor;
         u32 pixelformat;
         unsigned int bpp;
         const char *description;
@@ -199,6 +199,6 @@ void omap4iss_video_cancel_stream(struct iss_video *video);
 struct media_pad *omap4iss_video_remote_pad(struct iss_video *video);
 
 const struct iss_format_info *
-omap4iss_video_format_info(enum v4l2_mbus_pixelcode code);
+omap4iss_video_format_info(u32 code);
 
 #endif /* OMAP4_ISS_VIDEO_H */
diff --git a/drivers/staging/rtl8188eu/core/rtw_cmd.c b/drivers/staging/rtl8188eu/core/rtw_cmd.c
index 9935e66935af..eddef9cd2e16 100644
--- a/drivers/staging/rtl8188eu/core/rtw_cmd.c
+++ b/drivers/staging/rtl8188eu/core/rtw_cmd.c
@@ -275,11 +275,11 @@ u8 rtw_sitesurvey_cmd(struct adapter  *padapter, struct ndis_802_11_ssid *ssid,
         if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SCAN, 1);
 
-        ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+        ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
         if (ph2c == NULL)
                 return _FAIL;
 
-        psurveyPara = kzalloc(sizeof(struct sitesurvey_parm), GFP_KERNEL);
+        psurveyPara = kzalloc(sizeof(struct sitesurvey_parm), GFP_ATOMIC);
         if (psurveyPara == NULL) {
                 kfree(ph2c);
                 return _FAIL;
@@ -405,7 +405,7 @@ u8 rtw_joinbss_cmd(struct adapter  *padapter, struct wlan_network *pnetwork)
         else
                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+Join cmd: SSid =[%s]\n", pmlmepriv->assoc_ssid.Ssid));
 
-        pcmd = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+        pcmd = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
         if (pcmd == NULL) {
                 res = _FAIL;
                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd: memory allocate for cmd_obj fail!!!\n"));
@@ -755,13 +755,13 @@ u8 rtw_dynamic_chk_wk_cmd(struct adapter *padapter)
         u8      res = _SUCCESS;
 
 
-        ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+        ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
         if (ph2c == NULL) {
                 res = _FAIL;
                 goto exit;
         }
 
-        pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), GFP_KERNEL);
+        pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), GFP_ATOMIC);
         if (pdrvextra_cmd_parm == NULL) {
                 kfree(ph2c);
                 res = _FAIL;
@@ -967,13 +967,13 @@ u8 rtw_lps_ctrl_wk_cmd(struct adapter *padapter, u8 lps_ctrl_type, u8 enqueue)
         u8      res = _SUCCESS;
 
         if (enqueue) {
-                ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+                ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
                 if (ph2c == NULL) {
                         res = _FAIL;
                         goto exit;
                 }
 
-                pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), GFP_KERNEL);
+                pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), GFP_ATOMIC);
                 if (pdrvextra_cmd_parm == NULL) {
                         kfree(ph2c);
                         res = _FAIL;
@@ -1010,13 +1010,13 @@ u8 rtw_rpt_timer_cfg_cmd(struct adapter *padapter, u16 min_time)
 
         u8      res = _SUCCESS;
 
-        ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+        ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
         if (ph2c == NULL) {
                 res = _FAIL;
                 goto exit;
         }
 
-        pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), GFP_KERNEL);
+        pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), GFP_ATOMIC);
         if (pdrvextra_cmd_parm == NULL) {
                 kfree(ph2c);
                 res = _FAIL;
@@ -1088,13 +1088,13 @@ u8 rtw_ps_cmd(struct adapter *padapter)
 
         u8      res = _SUCCESS;
 
-        ppscmd = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+        ppscmd = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
         if (ppscmd == NULL) {
                 res = _FAIL;
                 goto exit;
         }
 
-        pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), GFP_KERNEL);
+        pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), GFP_ATOMIC);
         if (pdrvextra_cmd_parm == NULL) {
                 kfree(ppscmd);
                 res = _FAIL;
diff --git a/drivers/staging/rtl8188eu/core/rtw_mlme_ext.c b/drivers/staging/rtl8188eu/core/rtw_mlme_ext.c
index 5ba5099ec20d..70b1bc3e0e63 100644
--- a/drivers/staging/rtl8188eu/core/rtw_mlme_ext.c
+++ b/drivers/staging/rtl8188eu/core/rtw_mlme_ext.c
@@ -4241,12 +4241,12 @@ void report_survey_event(struct adapter *padapter,
         pcmdpriv = &padapter->cmdpriv;
 
 
-        pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+        pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
         if (pcmd_obj == NULL)
                 return;
 
         cmdsz = (sizeof(struct survey_event) + sizeof(struct C2HEvent_Header));
-        pevtcmd = kzalloc(cmdsz, GFP_KERNEL);
+        pevtcmd = kzalloc(cmdsz, GFP_ATOMIC);
         if (pevtcmd == NULL) {
                 kfree(pcmd_obj);
                 return;
@@ -4339,12 +4339,12 @@ void report_join_res(struct adapter *padapter, int res)
         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 
-        pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+        pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
         if (pcmd_obj == NULL)
                 return;
 
         cmdsz = (sizeof(struct joinbss_event) + sizeof(struct C2HEvent_Header));
-        pevtcmd = kzalloc(cmdsz, GFP_KERNEL);
+        pevtcmd = kzalloc(cmdsz, GFP_ATOMIC);
         if (pevtcmd == NULL) {
                 kfree(pcmd_obj);
                 return;
@@ -4854,11 +4854,11 @@ void survey_timer_hdl(void *function_context)
                         pmlmeext->scan_abort = false;/* reset */
                 }
 
-                ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
+                ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
                 if (ph2c == NULL)
                         goto exit_survey_timer_hdl;
 
-                psurveyPara = kzalloc(sizeof(struct sitesurvey_parm), GFP_KERNEL);
+                psurveyPara = kzalloc(sizeof(struct sitesurvey_parm), GFP_ATOMIC);
                 if (psurveyPara == NULL) {
                         kfree(ph2c);
                         goto exit_survey_timer_hdl;
diff --git a/drivers/staging/rtl8188eu/core/rtw_wlan_util.c b/drivers/staging/rtl8188eu/core/rtw_wlan_util.c
index 33ccbbbd8ed6..d300369977fa 100644
--- a/drivers/staging/rtl8188eu/core/rtw_wlan_util.c
+++ b/drivers/staging/rtl8188eu/core/rtw_wlan_util.c
@@ -935,7 +935,7 @@ int rtw_check_bcn_info(struct adapter  *Adapter, u8 *pframe, u32 packet_len)
                 return true;
         }
 
-        bssid = kzalloc(sizeof(struct wlan_bssid_ex), GFP_KERNEL);
+        bssid = kzalloc(sizeof(struct wlan_bssid_ex), GFP_ATOMIC);
 
         subtype = GetFrameSubType(pframe) >> 4;
 
diff --git a/drivers/staging/rtl8188eu/os_dep/usb_intf.c b/drivers/staging/rtl8188eu/os_dep/usb_intf.c
index 407a318b09db..2f87150a21b7 100644
--- a/drivers/staging/rtl8188eu/os_dep/usb_intf.c
+++ b/drivers/staging/rtl8188eu/os_dep/usb_intf.c
@@ -47,6 +47,7 @@ static struct usb_device_id rtw_usb_id_tbl[] = {
         {USB_DEVICE(0x07b8, 0x8179)}, /* Abocom - Abocom */
         {USB_DEVICE(0x2001, 0x330F)}, /* DLink DWA-125 REV D1 */
         {USB_DEVICE(0x2001, 0x3310)}, /* Dlink DWA-123 REV D1 */
+        {USB_DEVICE(0x2001, 0x3311)}, /* DLink GO-USB-N150 REV B1 */
         {USB_DEVICE(0x0df6, 0x0076)}, /* Sitecom N150 v2 */
         {}      /* Terminating entry */
 };
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index ab3ab27d49b7..4d1b7224a7f2 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -110,58 +110,6 @@ static struct device_driver tcm_loop_driverfs = {
  */
 struct device *tcm_loop_primary;
 
-/*
- * Copied from drivers/scsi/libfc/fc_fcp.c:fc_change_queue_depth() and
- * drivers/scsi/libiscsi.c:iscsi_change_queue_depth()
- */
-static int tcm_loop_change_queue_depth(
-        struct scsi_device *sdev,
-        int depth,
-        int reason)
-{
-        switch (reason) {
-        case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
-                break;
-        case SCSI_QDEPTH_QFULL:
-                scsi_track_queue_full(sdev, depth);
-                break;
-        case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
-                break;
-        default:
-                return -EOPNOTSUPP;
-        }
-        return sdev->queue_depth;
-}
-
-static int tcm_loop_change_queue_type(struct scsi_device *sdev, int tag)
-{
-        if (sdev->tagged_supported) {
-                scsi_set_tag_type(sdev, tag);
-
-                if (tag)
-                        scsi_activate_tcq(sdev, sdev->queue_depth);
-                else
-                        scsi_deactivate_tcq(sdev, sdev->queue_depth);
-        } else
-                tag = 0;
-
-        return tag;
-}
-
-/*
- * Locate the SAM Task Attr from struct scsi_cmnd *
- */
-static int tcm_loop_sam_attr(struct scsi_cmnd *sc, int tag)
-{
-        if (sc->device->tagged_supported &&
-            sc->device->ordered_tags && tag >= 0)
-                return MSG_ORDERED_TAG;
-
-        return MSG_SIMPLE_TAG;
-}
-
 static void tcm_loop_submission_work(struct work_struct *work)
 {
         struct tcm_loop_cmd *tl_cmd =
@@ -220,7 +168,7 @@ static void tcm_loop_submission_work(struct work_struct *work)
 
         rc = target_submit_cmd_map_sgls(se_cmd, tl_nexus->se_sess, sc->cmnd,
                         &tl_cmd->tl_sense_buf[0], tl_cmd->sc->device->lun,
-                        transfer_length, tcm_loop_sam_attr(sc, tl_cmd->sc_cmd_tag),
+                        transfer_length, MSG_SIMPLE_TAG,
                         sc->sc_data_direction, 0,
                         scsi_sglist(sc), scsi_sg_count(sc),
                         sgl_bidi, sgl_bidi_count,
@@ -431,27 +379,13 @@ static int tcm_loop_slave_alloc(struct scsi_device *sd)
         return 0;
 }
 
-static int tcm_loop_slave_configure(struct scsi_device *sd)
-{
-        if (sd->tagged_supported) {
-                scsi_activate_tcq(sd, sd->queue_depth);
-                scsi_adjust_queue_depth(sd, MSG_SIMPLE_TAG,
-                                        sd->host->cmd_per_lun);
-        } else {
-                scsi_adjust_queue_depth(sd, 0,
-                                        sd->host->cmd_per_lun);
-        }
-
-        return 0;
-}
-
 static struct scsi_host_template tcm_loop_driver_template = {
         .show_info              = tcm_loop_show_info,
         .proc_name              = "tcm_loopback",
         .name                   = "TCM_Loopback",
         .queuecommand           = tcm_loop_queuecommand,
-        .change_queue_depth     = tcm_loop_change_queue_depth,
-        .change_queue_type      = tcm_loop_change_queue_type,
+        .change_queue_depth     = scsi_change_queue_depth,
+        .change_queue_type      = scsi_change_queue_type,
         .eh_abort_handler = tcm_loop_abort_task,
         .eh_device_reset_handler = tcm_loop_device_reset,
         .eh_target_reset_handler = tcm_loop_target_reset,
@@ -462,8 +396,9 @@ static struct scsi_host_template tcm_loop_driver_template = {
         .max_sectors            = 0xFFFF,
         .use_clustering         = DISABLE_CLUSTERING,
         .slave_alloc            = tcm_loop_slave_alloc,
-        .slave_configure        = tcm_loop_slave_configure,
         .module                 = THIS_MODULE,
+        .use_blk_tags           = 1,
+        .track_queue_depth      = 1,
 };
 
 static int tcm_loop_driver_probe(struct device *dev)
diff --git a/drivers/target/target_core_alua.c b/drivers/target/target_core_alua.c
index fb87780929d2..75cbde1f7c5b 100644
--- a/drivers/target/target_core_alua.c
+++ b/drivers/target/target_core_alua.c
@@ -576,7 +576,7 @@ static inline int core_alua_state_standby(
         case SEND_DIAGNOSTIC:
         case READ_CAPACITY:
                 return 0;
-        case SERVICE_ACTION_IN:
+        case SERVICE_ACTION_IN_16:
                 switch (cdb[1] & 0x1f) {
                 case SAI_READ_CAPACITY_16:
                         return 0;
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 9f93b8234095..4c261c33cf55 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -459,7 +459,7 @@ static int core_scsi3_pr_seq_non_holder(
         case ACCESS_CONTROL_OUT:
         case INQUIRY:
         case LOG_SENSE:
-        case READ_MEDIA_SERIAL_NUMBER:
+        case SERVICE_ACTION_IN_12:
         case REPORT_LUNS:
         case REQUEST_SENSE:
         case PERSISTENT_RESERVE_IN:
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index ebe62afb957d..8d171ff77e75 100644
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -852,7 +852,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 size = READ_CAP_LEN;
                 cmd->execute_cmd = sbc_emulate_readcapacity;
                 break;
-        case SERVICE_ACTION_IN:
+        case SERVICE_ACTION_IN_16:
                 switch (cmd->t_task_cdb[1] & 0x1f) {
                 case SAI_READ_CAPACITY_16:
                         cmd->execute_cmd = sbc_emulate_readcapacity_16;
diff --git a/drivers/thermal/cpu_cooling.c b/drivers/thermal/cpu_cooling.c
index 1ab0018271c5..ad09e51ffae4 100644
--- a/drivers/thermal/cpu_cooling.c
+++ b/drivers/thermal/cpu_cooling.c
@@ -50,15 +50,14 @@ struct cpufreq_cooling_device {
         unsigned int cpufreq_state;
         unsigned int cpufreq_val;
         struct cpumask allowed_cpus;
+        struct list_head node;
 };
 static DEFINE_IDR(cpufreq_idr);
 static DEFINE_MUTEX(cooling_cpufreq_lock);
 
 static unsigned int cpufreq_dev_count;
 
-/* notify_table passes value to the CPUFREQ_ADJUST callback function. */
-#define NOTIFY_INVALID NULL
-static struct cpufreq_cooling_device *notify_device;
+static LIST_HEAD(cpufreq_dev_list);
 
 /**
  * get_idr - function to get a unique id.
@@ -287,15 +286,12 @@ static int cpufreq_apply_cooling(struct cpufreq_cooling_device *cpufreq_device,
 
         cpufreq_device->cpufreq_state = cooling_state;
         cpufreq_device->cpufreq_val = clip_freq;
-        notify_device = cpufreq_device;
 
         for_each_cpu(cpuid, mask) {
                 if (is_cpufreq_valid(cpuid))
                         cpufreq_update_policy(cpuid);
         }
 
-        notify_device = NOTIFY_INVALID;
-
         return 0;
 }
 
@@ -316,21 +312,28 @@ static int cpufreq_thermal_notifier(struct notifier_block *nb,
 {
         struct cpufreq_policy *policy = data;
         unsigned long max_freq = 0;
+        struct cpufreq_cooling_device *cpufreq_dev;
 
-        if (event != CPUFREQ_ADJUST || notify_device == NOTIFY_INVALID)
+        if (event != CPUFREQ_ADJUST)
                 return 0;
 
-        if (cpumask_test_cpu(policy->cpu, &notify_device->allowed_cpus))
-                max_freq = notify_device->cpufreq_val;
-        else
-                return 0;
+        mutex_lock(&cooling_cpufreq_lock);
+        list_for_each_entry(cpufreq_dev, &cpufreq_dev_list, node) {
+                if (!cpumask_test_cpu(policy->cpu,
+                                        &cpufreq_dev->allowed_cpus))
+                        continue;
+
+                if (!cpufreq_dev->cpufreq_val)
+                        cpufreq_dev->cpufreq_val = get_cpu_frequency(
+                                        cpumask_any(&cpufreq_dev->allowed_cpus),
+                                        cpufreq_dev->cpufreq_state);
 
-        /* Never exceed user_policy.max */
-        if (max_freq > policy->user_policy.max)
-                max_freq = policy->user_policy.max;
+                max_freq = cpufreq_dev->cpufreq_val;
 
-        if (policy->max != max_freq)
-                cpufreq_verify_within_limits(policy, 0, max_freq);
+                if (policy->max != max_freq)
+                        cpufreq_verify_within_limits(policy, 0, max_freq);
+        }
+        mutex_unlock(&cooling_cpufreq_lock);
 
         return 0;
 }
@@ -486,6 +489,7 @@ __cpufreq_cooling_register(struct device_node *np,
                 cpufreq_register_notifier(&thermal_cpufreq_notifier_block,
                                           CPUFREQ_POLICY_NOTIFIER);
         cpufreq_dev_count++;
+        list_add(&cpufreq_dev->node, &cpufreq_dev_list);
 
         mutex_unlock(&cooling_cpufreq_lock);
 
@@ -549,6 +553,7 @@ void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
 
         cpufreq_dev = cdev->devdata;
         mutex_lock(&cooling_cpufreq_lock);
+        list_del(&cpufreq_dev->node);
         cpufreq_dev_count--;
 
         /* Unregister the notifier for the last cpufreq cooling device */
diff --git a/drivers/thermal/samsung/exynos_thermal_common.c b/drivers/thermal/samsung/exynos_thermal_common.c
index 3f5ad25ddca8..b6be572704a4 100644
--- a/drivers/thermal/samsung/exynos_thermal_common.c
+++ b/drivers/thermal/samsung/exynos_thermal_common.c
@@ -417,13 +417,10 @@ void exynos_unregister_thermal(struct thermal_sensor_conf *sensor_conf)
 
         th_zone = sensor_conf->pzone_data;
 
-        if (th_zone->therm_dev)
-                thermal_zone_device_unregister(th_zone->therm_dev);
+        thermal_zone_device_unregister(th_zone->therm_dev);
 
-        for (i = 0; i < th_zone->cool_dev_size; i++) {
-                if (th_zone->cool_dev[i])
-                        cpufreq_cooling_unregister(th_zone->cool_dev[i]);
-        }
+        for (i = 0; i < th_zone->cool_dev_size; ++i)
+                cpufreq_cooling_unregister(th_zone->cool_dev[i]);
 
         dev_info(sensor_conf->dev,
                 "Exynos: Kernel Thermal management unregistered\n");
diff --git a/drivers/thermal/st/st_thermal.c b/drivers/thermal/st/st_thermal.c
index 90163b384660..d1ec5804c0bb 100644
--- a/drivers/thermal/st/st_thermal.c
+++ b/drivers/thermal/st/st_thermal.c
@@ -275,6 +275,7 @@ int st_thermal_unregister(struct platform_device *pdev)
 }
 EXPORT_SYMBOL_GPL(st_thermal_unregister);
 
+#ifdef CONFIG_PM_SLEEP
 static int st_thermal_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
@@ -305,6 +306,8 @@ static int st_thermal_resume(struct device *dev)
 
         return 0;
 }
+#endif
+
 SIMPLE_DEV_PM_OPS(st_thermal_pm_ops, st_thermal_suspend, st_thermal_resume);
 EXPORT_SYMBOL_GPL(st_thermal_pm_ops);
 
diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c
index 2e900a98c3e3..26f097f60b10 100644
--- a/drivers/tty/n_tty.c
+++ b/drivers/tty/n_tty.c
@@ -2123,7 +2123,7 @@ static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
 {
         struct n_tty_data *ldata = tty->disc_data;
         unsigned char __user *b = buf;
-        DECLARE_WAITQUEUE(wait, current);
+        DEFINE_WAIT_FUNC(wait, woken_wake_function);
         int c;
         int minimum, time;
         ssize_t retval = 0;
@@ -2186,10 +2186,6 @@ static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
                         nr--;
                         break;
                 }
-                /* This statement must be first before checking for input
-                   so that any interrupt will set the state back to
-                   TASK_RUNNING. */
-                set_current_state(TASK_INTERRUPTIBLE);
 
                 if (((minimum - (b - buf)) < ldata->minimum_to_wake) &&
                     ((minimum - (b - buf)) >= 1))
@@ -2220,13 +2216,13 @@ static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
                                 n_tty_set_room(tty);
                                 up_read(&tty->termios_rwsem);
 
-                                timeout = schedule_timeout(timeout);
+                                timeout = wait_woken(&wait, TASK_INTERRUPTIBLE,
+                                                     timeout);
 
                                 down_read(&tty->termios_rwsem);
                                 continue;
                         }
                 }
-                __set_current_state(TASK_RUNNING);
 
                 /* Deal with packet mode. */
                 if (packet && b == buf) {
@@ -2273,7 +2269,6 @@ static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
 
         mutex_unlock(&ldata->atomic_read_lock);
 
-        __set_current_state(TASK_RUNNING);
         if (b - buf)
                 retval = b - buf;
 
@@ -2306,7 +2301,7 @@ static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
                            const unsigned char *buf, size_t nr)
 {
         const unsigned char *b = buf;
-        DECLARE_WAITQUEUE(wait, current);
+        DEFINE_WAIT_FUNC(wait, woken_wake_function);
         int c;
         ssize_t retval = 0;
 
@@ -2324,7 +2319,6 @@ static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
 
         add_wait_queue(&tty->write_wait, &wait);
         while (1) {
-                set_current_state(TASK_INTERRUPTIBLE);
                 if (signal_pending(current)) {
                         retval = -ERESTARTSYS;
                         break;
@@ -2378,12 +2372,11 @@ static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
                 }
                 up_read(&tty->termios_rwsem);
 
-                schedule();
+                wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
 
                 down_read(&tty->termios_rwsem);
         }
 break_out:
-        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&tty->write_wait, &wait);
         if (b - buf != nr && tty->fasync)
                 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
diff --git a/drivers/tty/serial/Kconfig b/drivers/tty/serial/Kconfig
index 649b784081c7..98f8bcaf3e7e 100644
--- a/drivers/tty/serial/Kconfig
+++ b/drivers/tty/serial/Kconfig
@@ -249,14 +249,14 @@ config SERIAL_SAMSUNG
 
 config SERIAL_SAMSUNG_UARTS_4
         bool
-        depends on PLAT_SAMSUNG
+        depends on SERIAL_SAMSUNG
         default y if !(CPU_S3C2410 || CPU_S3C2412 || CPU_S3C2440 || CPU_S3C2442)
         help
           Internal node for the common case of 4 Samsung compatible UARTs
 
 config SERIAL_SAMSUNG_UARTS
         int
-        depends on PLAT_SAMSUNG
+        depends on SERIAL_SAMSUNG
         default 4 if SERIAL_SAMSUNG_UARTS_4 || CPU_S3C2416
         default 3
         help
diff --git a/drivers/tty/serial/of_serial.c b/drivers/tty/serial/of_serial.c
index 56982da4a9e9..bf355050eab6 100644
--- a/drivers/tty/serial/of_serial.c
+++ b/drivers/tty/serial/of_serial.c
@@ -240,32 +240,6 @@ static int of_platform_serial_remove(struct platform_device *ofdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int of_serial_suspend(struct device *dev)
-{
-        struct of_serial_info *info = dev_get_drvdata(dev);
-
-        serial8250_suspend_port(info->line);
-        if (info->clk)
-                clk_disable_unprepare(info->clk);
-
-        return 0;
-}
-
-static int of_serial_resume(struct device *dev)
-{
-        struct of_serial_info *info = dev_get_drvdata(dev);
-
-        if (info->clk)
-                clk_prepare_enable(info->clk);
-
-        serial8250_resume_port(info->line);
-
-        return 0;
-}
-#endif
-static SIMPLE_DEV_PM_OPS(of_serial_pm_ops, of_serial_suspend, of_serial_resume);
-
 /*
  * A few common types, add more as needed.
  */
@@ -297,7 +271,6 @@ static struct platform_driver of_platform_serial_driver = {
                 .name = "of_serial",
                 .owner = THIS_MODULE,
                 .of_match_table = of_platform_serial_table,
-                .pm = &of_serial_pm_ops,
         },
         .probe = of_platform_serial_probe,
         .remove = of_platform_serial_remove,
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 9bffd26cea05..874dec31a111 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -1493,10 +1493,6 @@ int usb_resume(struct device *dev, pm_message_t msg)
         return status;
 }
 
-#endif /* CONFIG_PM */
-
-#ifdef CONFIG_PM_RUNTIME
-
 /**
  * usb_enable_autosuspend - allow a USB device to be autosuspended
  * @udev: the USB device which may be autosuspended
@@ -1876,7 +1872,7 @@ int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
         return ret;
 }
 
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
 struct bus_type usb_bus_type = {
         .name =         "usb",
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index efc953119ce2..9eb1cff28bd4 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -429,7 +429,6 @@ static int check_root_hub_suspended(struct device *dev)
         return 0;
 }
 
-#if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM_RUNTIME)
 static int suspend_common(struct device *dev, bool do_wakeup)
 {
         struct pci_dev          *pci_dev = to_pci_dev(dev);
@@ -528,7 +527,6 @@ static int resume_common(struct device *dev, int event)
         }
         return retval;
 }
-#endif  /* SLEEP || RUNTIME */
 
 #ifdef  CONFIG_PM_SLEEP
 
@@ -607,8 +605,6 @@ static int hcd_pci_restore(struct device *dev)
 
 #endif  /* CONFIG_PM_SLEEP */
 
-#ifdef  CONFIG_PM_RUNTIME
-
 static int hcd_pci_runtime_suspend(struct device *dev)
 {
         int     retval;
@@ -630,13 +626,6 @@ static int hcd_pci_runtime_resume(struct device *dev)
         return retval;
 }
 
-#else
-
-#define hcd_pci_runtime_suspend NULL
-#define hcd_pci_runtime_resume  NULL
-
-#endif  /* CONFIG_PM_RUNTIME */
-
 const struct dev_pm_ops usb_hcd_pci_pm_ops = {
         .suspend        = hcd_pci_suspend,
         .suspend_noirq  = hcd_pci_suspend_noirq,
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index a6efb4184f2b..278be0515e8e 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -2258,10 +2258,6 @@ int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
         return status;
 }
 
-#endif  /* CONFIG_PM */
-
-#ifdef  CONFIG_PM_RUNTIME
-
 /* Workqueue routine for root-hub remote wakeup */
 static void hcd_resume_work(struct work_struct *work)
 {
@@ -2293,7 +2289,7 @@ void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
 }
 EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
 
-#endif  /* CONFIG_PM_RUNTIME */
+#endif  /* CONFIG_PM */
 
 /*-------------------------------------------------------------------------*/
 
@@ -2476,7 +2472,7 @@ struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver,
         init_timer(&hcd->rh_timer);
         hcd->rh_timer.function = rh_timer_func;
         hcd->rh_timer.data = (unsigned long) hcd;
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
 #endif
 
@@ -2790,7 +2786,7 @@ error_create_attr_group:
         hcd->rh_registered = 0;
         spin_unlock_irq(&hcd_root_hub_lock);
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         cancel_work_sync(&hcd->wakeup_work);
 #endif
         mutex_lock(&usb_bus_list_lock);
@@ -2858,7 +2854,7 @@ void usb_remove_hcd(struct usb_hcd *hcd)
         hcd->rh_registered = 0;
         spin_unlock_irq (&hcd_root_hub_lock);
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         cancel_work_sync(&hcd->wakeup_work);
 #endif
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index b649fef2e35d..c9596525ba8c 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -1737,7 +1737,7 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
          * - If user has indicated to prevent autosuspend by passing
          *   usbcore.autosuspend = -1 then keep autosuspend disabled.
          */
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         if (hdev->dev.power.autosuspend_delay >= 0)
                 pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
 #endif
@@ -3449,7 +3449,7 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         return status;
 }
 
-#ifdef  CONFIG_PM_RUNTIME
+#ifdef  CONFIG_PM
 
 int usb_remote_wakeup(struct usb_device *udev)
 {
@@ -4856,7 +4856,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         udev->state != USB_STATE_NOTATTACHED) {
                 if (portstatus & USB_PORT_STAT_ENABLE) {
                         status = 0;             /* Nothing to do */
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
                 } else if (udev->state == USB_STATE_SUSPENDED &&
                                 udev->persist_enabled) {
                         /* For a suspended device, treat this as a
diff --git a/drivers/usb/core/port.c b/drivers/usb/core/port.c
index cd3f9dc24a06..210618319f10 100644
--- a/drivers/usb/core/port.c
+++ b/drivers/usb/core/port.c
@@ -72,7 +72,7 @@ static void usb_port_device_release(struct device *dev)
         kfree(port_dev);
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int usb_port_runtime_resume(struct device *dev)
 {
         struct usb_port *port_dev = to_usb_port(dev);
@@ -171,7 +171,7 @@ static int usb_port_runtime_suspend(struct device *dev)
 #endif
 
 static const struct dev_pm_ops usb_port_pm_ops = {
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         .runtime_suspend =      usb_port_runtime_suspend,
         .runtime_resume =       usb_port_runtime_resume,
 #endif
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 39b4081b632d..96fafed92b76 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -44,6 +44,9 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* Creative SB Audigy 2 NX */
         { USB_DEVICE(0x041e, 0x3020), .driver_info = USB_QUIRK_RESET_RESUME },
 
+        /* Microsoft Wireless Laser Mouse 6000 Receiver */
+        { USB_DEVICE(0x045e, 0x00e1), .driver_info = USB_QUIRK_RESET_RESUME },
+
         /* Microsoft LifeCam-VX700 v2.0 */
         { USB_DEVICE(0x045e, 0x0770), .driver_info = USB_QUIRK_RESET_RESUME },
 
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 1236c6011c70..d26973844a4d 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -334,14 +334,6 @@ static void remove_persist_attributes(struct device *dev)
                         &dev_attr_persist.attr,
                         power_group_name);
 }
-#else
-
-#define add_persist_attributes(dev)     0
-#define remove_persist_attributes(dev)  do {} while (0)
-
-#endif  /* CONFIG_PM */
-
-#ifdef  CONFIG_PM_RUNTIME
 
 static ssize_t connected_duration_show(struct device *dev,
                                        struct device_attribute *attr, char *buf)
@@ -585,10 +577,13 @@ static void remove_power_attributes(struct device *dev)
 
 #else
 
+#define add_persist_attributes(dev)     0
+#define remove_persist_attributes(dev)  do {} while (0)
+
 #define add_power_attributes(dev)       0
 #define remove_power_attributes(dev)    do {} while (0)
 
-#endif  /* CONFIG_PM_RUNTIME */
+#endif  /* CONFIG_PM */
 
 
 /* Descriptor fields */
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 2dd2362198d2..2a92b97f0144 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -49,7 +49,7 @@ const char *usbcore_name = "usbcore";
 
 static bool nousb;      /* Disable USB when built into kernel image */
 
-#ifdef  CONFIG_PM_RUNTIME
+#ifdef  CONFIG_PM
 static int usb_autosuspend_delay = 2;           /* Default delay value,
                                                  * in seconds */
 module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
@@ -348,11 +348,9 @@ static const struct dev_pm_ops usb_device_pm_ops = {
         .thaw =         usb_dev_thaw,
         .poweroff =     usb_dev_poweroff,
         .restore =      usb_dev_restore,
-#ifdef CONFIG_PM_RUNTIME
         .runtime_suspend =      usb_runtime_suspend,
         .runtime_resume =       usb_runtime_resume,
         .runtime_idle =         usb_runtime_idle,
-#endif
 };
 
 #endif  /* CONFIG_PM */
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index b1b34d0557c9..7eb1e26798e5 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -75,6 +75,14 @@ extern int usb_resume_complete(struct device *dev);
 extern int usb_port_suspend(struct usb_device *dev, pm_message_t msg);
 extern int usb_port_resume(struct usb_device *dev, pm_message_t msg);
 
+extern void usb_autosuspend_device(struct usb_device *udev);
+extern int usb_autoresume_device(struct usb_device *udev);
+extern int usb_remote_wakeup(struct usb_device *dev);
+extern int usb_runtime_suspend(struct device *dev);
+extern int usb_runtime_resume(struct device *dev);
+extern int usb_runtime_idle(struct device *dev);
+extern int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable);
+
 #else
 
 static inline int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
@@ -87,20 +95,6 @@ static inline int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         return 0;
 }
 
-#endif
-
-#ifdef CONFIG_PM_RUNTIME
-
-extern void usb_autosuspend_device(struct usb_device *udev);
-extern int usb_autoresume_device(struct usb_device *udev);
-extern int usb_remote_wakeup(struct usb_device *dev);
-extern int usb_runtime_suspend(struct device *dev);
-extern int usb_runtime_resume(struct device *dev);
-extern int usb_runtime_idle(struct device *dev);
-extern int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable);
-
-#else
-
 #define usb_autosuspend_device(udev)            do {} while (0)
 static inline int usb_autoresume_device(struct usb_device *udev)
 {
@@ -111,6 +105,7 @@ static inline int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
 {
         return 0;
 }
+
 #endif
 
 extern struct bus_type usb_bus_type;
diff --git a/drivers/usb/dwc3/ep0.c b/drivers/usb/dwc3/ep0.c
index 711b23019d54..df38e7ef4976 100644
--- a/drivers/usb/dwc3/ep0.c
+++ b/drivers/usb/dwc3/ep0.c
@@ -791,6 +791,10 @@ static void dwc3_ep0_complete_data(struct dwc3 *dwc,
 
         trb = dwc->ep0_trb;
 
+        r = next_request(&ep0->request_list);
+        if (!r)
+                return;
+
         status = DWC3_TRB_SIZE_TRBSTS(trb->size);
         if (status == DWC3_TRBSTS_SETUP_PENDING) {
                 dwc3_trace(trace_dwc3_ep0, "Setup Pending received");
@@ -801,10 +805,6 @@ static void dwc3_ep0_complete_data(struct dwc3 *dwc,
                 return;
         }
 
-        r = next_request(&ep0->request_list);
-        if (!r)
-                return;
-
         ur = &r->request;
 
         length = trb->size & DWC3_TRB_SIZE_MASK;
diff --git a/drivers/usb/gadget/legacy/tcm_usb_gadget.c b/drivers/usb/gadget/legacy/tcm_usb_gadget.c
index 6cdb7a534f23..024f58475a94 100644
--- a/drivers/usb/gadget/legacy/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/legacy/tcm_usb_gadget.c
@@ -912,7 +912,7 @@ static int get_cmd_dir(const unsigned char *cdb)
         case INQUIRY:
         case MODE_SENSE:
         case MODE_SENSE_10:
-        case SERVICE_ACTION_IN:
+        case SERVICE_ACTION_IN_16:
         case MAINTENANCE_IN:
         case PERSISTENT_RESERVE_IN:
         case SECURITY_PROTOCOL_IN:
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index ca7b964124af..851006a0d97b 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -305,7 +305,7 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                 }
         }
 
-#ifdef  CONFIG_PM_RUNTIME
+#ifdef  CONFIG_PM
         if (ehci->no_selective_suspend && device_can_wakeup(&pdev->dev))
                 ehci_warn(ehci, "selective suspend/wakeup unavailable\n");
 #endif
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index ad0c348e68e9..25fb1da8d3d7 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -22,7 +22,7 @@
  * and usb-storage.
  *
  * TODO:
- * - usb suspend/resume triggered by sl811 (with PM_RUNTIME)
+ * - usb suspend/resume triggered by sl811
  * - various issues noted in the code
  * - performance work; use both register banks; ...
  * - use urb->iso_frame_desc[] with ISO transfers
@@ -1752,8 +1752,7 @@ sl811h_probe(struct platform_device *dev)
 #ifdef  CONFIG_PM
 
 /* for this device there's no useful distinction between the controller
- * and its root hub, except that the root hub only gets direct PM calls
- * when CONFIG_PM_RUNTIME is enabled.
+ * and its root hub.
  */
 
 static int
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index c0671750671f..bf86630b3cea 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -3144,8 +3144,7 @@ static int u132_probe(struct platform_device *pdev)
 #ifdef CONFIG_PM
 /*
  * for this device there's no useful distinction between the controller
- * and its root hub, except that the root hub only gets direct PM calls
- * when CONFIG_PM_RUNTIME is enabled.
+ * and its root hub.
  */
 static int u132_suspend(struct platform_device *pdev, pm_message_t state)
 {
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 696160d48ae8..a7865c4b0498 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -22,7 +22,6 @@
 
 
 #include <linux/slab.h>
-#include <linux/device.h>
 #include <asm/unaligned.h>
 
 #include "xhci.h"
@@ -1146,12 +1145,10 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
                         set_bit(port_index, &bus_state->bus_suspended);
                 }
                 /* USB core sets remote wake mask for USB 3.0 hubs,
-                 * including the USB 3.0 roothub, but only if CONFIG_PM_RUNTIME
+                 * including the USB 3.0 roothub, but only if CONFIG_PM
                  * is enabled, so also enable remote wake here.
                  */
-                if (hcd->self.root_hub->do_remote_wakeup
-                                && device_may_wakeup(hcd->self.controller)) {
-
+                if (hcd->self.root_hub->do_remote_wakeup) {
                         if (t1 & PORT_CONNECT) {
                                 t2 |= PORT_WKOC_E | PORT_WKDISC_E;
                                 t2 &= ~PORT_WKCONN_E;
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 9a69b1f1b300..142b601f9563 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -281,7 +281,7 @@ static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
         if (xhci->quirks & XHCI_COMP_MODE_QUIRK)
                 pdev->no_d3cold = true;
 
-        return xhci_suspend(xhci);
+        return xhci_suspend(xhci, do_wakeup);
 }
 
 static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 3d78b0cd674b..646300cbe5f7 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -204,7 +204,15 @@ static int xhci_plat_suspend(struct device *dev)
         struct usb_hcd  *hcd = dev_get_drvdata(dev);
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 
-        return xhci_suspend(xhci);
+        /*
+         * xhci_suspend() needs `do_wakeup` to know whether host is allowed
+         * to do wakeup during suspend. Since xhci_plat_suspend is currently
+         * only designed for system suspend, device_may_wakeup() is enough
+         * to dertermine whether host is allowed to do wakeup. Need to
+         * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
+         * also applies to runtime suspend.
+         */
+        return xhci_suspend(xhci, device_may_wakeup(dev));
 }
 
 static int xhci_plat_resume(struct device *dev)
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index bc6fcbc16f61..06433aec81d7 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -1067,9 +1067,8 @@ static void xhci_handle_cmd_reset_ep(struct xhci_hcd *xhci, int slot_id,
                                 false);
                 xhci_ring_cmd_db(xhci);
         } else {
-                /* Clear our internal halted state and restart the ring(s) */
+                /* Clear our internal halted state */
                 xhci->devs[slot_id]->eps[ep_index].ep_state &= ~EP_HALTED;
-                ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
         }
 }
 
@@ -1823,22 +1822,13 @@ static int finish_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 ep->stopped_td = td;
                 return 0;
         } else {
-                if (trb_comp_code == COMP_STALL) {
-                        /* The transfer is completed from the driver's
-                         * perspective, but we need to issue a set dequeue
-                         * command for this stalled endpoint to move the dequeue
-                         * pointer past the TD.  We can't do that here because
-                         * the halt condition must be cleared first.  Let the
-                         * USB class driver clear the stall later.
-                         */
-                        ep->stopped_td = td;
-                        ep->stopped_stream = ep_ring->stream_id;
-                } else if (xhci_requires_manual_halt_cleanup(xhci,
-                                        ep_ctx, trb_comp_code)) {
-                        /* Other types of errors halt the endpoint, but the
-                         * class driver doesn't call usb_reset_endpoint() unless
-                         * the error is -EPIPE.  Clear the halted status in the
-                         * xHCI hardware manually.
+                if (trb_comp_code == COMP_STALL ||
+                    xhci_requires_manual_halt_cleanup(xhci, ep_ctx,
+                                                      trb_comp_code)) {
+                        /* Issue a reset endpoint command to clear the host side
+                         * halt, followed by a set dequeue command to move the
+                         * dequeue pointer past the TD.
+                         * The class driver clears the device side halt later.
                          */
                         xhci_cleanup_halted_endpoint(xhci,
                                         slot_id, ep_index, ep_ring->stream_id,
@@ -1958,9 +1948,7 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 else
                         td->urb->actual_length = 0;
 
-                xhci_cleanup_halted_endpoint(xhci,
-                        slot_id, ep_index, 0, td, event_trb);
-                return finish_td(xhci, td, event_trb, event, ep, status, true);
+                return finish_td(xhci, td, event_trb, event, ep, status, false);
         }
         /*
          * Did we transfer any data, despite the errors that might have
@@ -2519,17 +2507,8 @@ cleanup:
                 if (ret) {
                         urb = td->urb;
                         urb_priv = urb->hcpriv;
-                        /* Leave the TD around for the reset endpoint function
-                         * to use(but only if it's not a control endpoint,
-                         * since we already queued the Set TR dequeue pointer
-                         * command for stalled control endpoints).
-                         */
-                        if (usb_endpoint_xfer_control(&urb->ep->desc) ||
-                                (trb_comp_code != COMP_STALL &&
-                                        trb_comp_code != COMP_BABBLE))
-                                xhci_urb_free_priv(xhci, urb_priv);
-                        else
-                                kfree(urb_priv);
+
+                        xhci_urb_free_priv(xhci, urb_priv);
 
                         usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb);
                         if ((urb->actual_length != urb->transfer_buffer_length &&
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 2a5d45b4cb15..cf3413116aff 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -35,6 +35,8 @@
 #define DRIVER_AUTHOR "Sarah Sharp"
 #define DRIVER_DESC "'eXtensible' Host Controller (xHC) Driver"
 
+#define PORT_WAKE_BITS  (PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E)
+
 /* Some 0.95 hardware can't handle the chain bit on a Link TRB being cleared */
 static int link_quirk;
 module_param(link_quirk, int, S_IRUGO | S_IWUSR);
@@ -851,13 +853,47 @@ static void xhci_clear_command_ring(struct xhci_hcd *xhci)
         xhci_set_cmd_ring_deq(xhci);
 }
 
+static void xhci_disable_port_wake_on_bits(struct xhci_hcd *xhci)
+{
+        int port_index;
+        __le32 __iomem **port_array;
+        unsigned long flags;
+        u32 t1, t2;
+
+        spin_lock_irqsave(&xhci->lock, flags);
+
+        /* disble usb3 ports Wake bits*/
+        port_index = xhci->num_usb3_ports;
+        port_array = xhci->usb3_ports;
+        while (port_index--) {
+                t1 = readl(port_array[port_index]);
+                t1 = xhci_port_state_to_neutral(t1);
+                t2 = t1 & ~PORT_WAKE_BITS;
+                if (t1 != t2)
+                        writel(t2, port_array[port_index]);
+        }
+
+        /* disble usb2 ports Wake bits*/
+        port_index = xhci->num_usb2_ports;
+        port_array = xhci->usb2_ports;
+        while (port_index--) {
+                t1 = readl(port_array[port_index]);
+                t1 = xhci_port_state_to_neutral(t1);
+                t2 = t1 & ~PORT_WAKE_BITS;
+                if (t1 != t2)
+                        writel(t2, port_array[port_index]);
+        }
+
+        spin_unlock_irqrestore(&xhci->lock, flags);
+}
+
 /*
  * Stop HC (not bus-specific)
  *
  * This is called when the machine transition into S3/S4 mode.
  *
  */
-int xhci_suspend(struct xhci_hcd *xhci)
+int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup)
 {
         int                     rc = 0;
         unsigned int            delay = XHCI_MAX_HALT_USEC;
@@ -868,6 +904,10 @@ int xhci_suspend(struct xhci_hcd *xhci)
                         xhci->shared_hcd->state != HC_STATE_SUSPENDED)
                 return -EINVAL;
 
+        /* Clear root port wake on bits if wakeup not allowed. */
+        if (!do_wakeup)
+                xhci_disable_port_wake_on_bits(xhci);
+
         /* Don't poll the roothubs on bus suspend. */
         xhci_dbg(xhci, "%s: stopping port polling.\n", __func__);
         clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
@@ -2912,68 +2952,33 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
         }
 }
 
-/* Deal with stalled endpoints.  The core should have sent the control message
- * to clear the halt condition.  However, we need to make the xHCI hardware
- * reset its sequence number, since a device will expect a sequence number of
- * zero after the halt condition is cleared.
+/* Called when clearing halted device. The core should have sent the control
+ * message to clear the device halt condition. The host side of the halt should
+ * already be cleared with a reset endpoint command issued when the STALL tx
+ * event was received.
+ *
  * Context: in_interrupt
  */
+
 void xhci_endpoint_reset(struct usb_hcd *hcd,
                 struct usb_host_endpoint *ep)
 {
         struct xhci_hcd *xhci;
-        struct usb_device *udev;
-        unsigned int ep_index;
-        unsigned long flags;
-        int ret;
-        struct xhci_virt_ep *virt_ep;
-        struct xhci_command *command;
 
         xhci = hcd_to_xhci(hcd);
-        udev = (struct usb_device *) ep->hcpriv;
-        /* Called with a root hub endpoint (or an endpoint that wasn't added
-         * with xhci_add_endpoint()
-         */
-        if (!ep->hcpriv)
-                return;
-        ep_index = xhci_get_endpoint_index(&ep->desc);
-        virt_ep = &xhci->devs[udev->slot_id]->eps[ep_index];
-        if (!virt_ep->stopped_td) {
-                xhci_dbg_trace(xhci, trace_xhci_dbg_reset_ep,
-                        "Endpoint 0x%x not halted, refusing to reset.",
-                        ep->desc.bEndpointAddress);
-                return;
-        }
-        if (usb_endpoint_xfer_control(&ep->desc)) {
-                xhci_dbg_trace(xhci, trace_xhci_dbg_reset_ep,
-                                "Control endpoint stall already handled.");
-                return;
-        }
 
-        command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
-        if (!command)
-                return;
-
-        xhci_dbg_trace(xhci, trace_xhci_dbg_reset_ep,
-                        "Queueing reset endpoint command");
-        spin_lock_irqsave(&xhci->lock, flags);
-        ret = xhci_queue_reset_ep(xhci, command, udev->slot_id, ep_index);
         /*
-         * Can't change the ring dequeue pointer until it's transitioned to the
-         * stopped state, which is only upon a successful reset endpoint
-         * command.  Better hope that last command worked!
+         * We might need to implement the config ep cmd in xhci 4.8.1 note:
+         * The Reset Endpoint Command may only be issued to endpoints in the
+         * Halted state. If software wishes reset the Data Toggle or Sequence
+         * Number of an endpoint that isn't in the Halted state, then software
+         * may issue a Configure Endpoint Command with the Drop and Add bits set
+         * for the target endpoint. that is in the Stopped state.
          */
-        if (!ret) {
-                xhci_cleanup_stalled_ring(xhci, udev, ep_index);
-                kfree(virt_ep->stopped_td);
-                xhci_ring_cmd_db(xhci);
-        }
-        virt_ep->stopped_td = NULL;
-        virt_ep->stopped_stream = 0;
-        spin_unlock_irqrestore(&xhci->lock, flags);
 
-        if (ret)
-                xhci_warn(xhci, "FIXME allocate a new ring segment\n");
+        /* For now just print debug to follow the situation */
+        xhci_dbg(xhci, "Endpoint 0x%x ep reset callback called\n",
+                 ep->desc.bEndpointAddress);
 }
 
 static int xhci_check_streams_endpoint(struct xhci_hcd *xhci,
@@ -4024,7 +4029,7 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci,
         return ret;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 
 /* BESL to HIRD Encoding array for USB2 LPM */
 static int xhci_besl_encoding[16] = {125, 150, 200, 300, 400, 500, 1000, 2000,
@@ -4239,24 +4244,8 @@ int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
         return 0;
 }
 
-#else
-
-int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
-                                struct usb_device *udev, int enable)
-{
-        return 0;
-}
-
-int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
-{
-        return 0;
-}
-
-#endif /* CONFIG_PM_RUNTIME */
-
 /*---------------------- USB 3.0 Link PM functions ------------------------*/
 
-#ifdef CONFIG_PM
 /* Service interval in nanoseconds = 2^(bInterval - 1) * 125us * 1000ns / 1us */
 static unsigned long long xhci_service_interval_to_ns(
                 struct usb_endpoint_descriptor *desc)
@@ -4687,6 +4676,17 @@ int xhci_disable_usb3_lpm_timeout(struct usb_hcd *hcd,
 }
 #else /* CONFIG_PM */
 
+int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
+                                struct usb_device *udev, int enable)
+{
+        return 0;
+}
+
+int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        return 0;
+}
+
 int xhci_enable_usb3_lpm_timeout(struct usb_hcd *hcd,
                         struct usb_device *udev, enum usb3_link_state state)
 {
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index df76d642e719..d745715a1e2f 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1746,7 +1746,7 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks);
 void xhci_init_driver(struct hc_driver *drv, int (*setup_fn)(struct usb_hcd *));
 
 #ifdef  CONFIG_PM
-int xhci_suspend(struct xhci_hcd *xhci);
+int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup);
 int xhci_resume(struct xhci_hcd *xhci, bool hibernated);
 #else
 #define xhci_suspend    NULL
diff --git a/drivers/usb/phy/phy-msm-usb.c b/drivers/usb/phy/phy-msm-usb.c
index 7843ef7dd0ff..29be0e654ecc 100644
--- a/drivers/usb/phy/phy-msm-usb.c
+++ b/drivers/usb/phy/phy-msm-usb.c
@@ -1761,7 +1761,7 @@ static int msm_otg_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 static int msm_otg_runtime_idle(struct device *dev)
 {
         struct msm_otg *motg = dev_get_drvdata(dev);
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index cfd009dc4018..6c4eb3cf5efd 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -120,6 +120,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0x85F8) }, /* Virtenio Preon32 */
         { USB_DEVICE(0x10C4, 0x8664) }, /* AC-Services CAN-IF */
         { USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
+        { USB_DEVICE(0x10C4, 0x8875) }, /* CEL MeshConnect USB Stick */
         { USB_DEVICE(0x10C4, 0x88A4) }, /* MMB Networks ZigBee USB Device */
         { USB_DEVICE(0x10C4, 0x88A5) }, /* Planet Innovation Ingeni ZigBee USB Device */
         { USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 0dad8ce5a609..1ebb351b9e9a 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -470,6 +470,39 @@ static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FD_PID) },
         { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FE_PID) },
         { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FF_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_4701_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9300_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9301_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9302_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9303_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9304_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9305_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9306_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9307_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9308_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9309_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_930A_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_930B_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_930C_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_930D_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_930E_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_930F_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9310_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9311_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9312_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9313_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9314_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9315_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9316_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9317_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9318_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_9319_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_931A_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_931B_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_931C_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_931D_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_931E_PID) },
+        { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_931F_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 6786b705ccf6..e52409c9be99 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -926,8 +926,8 @@
 #define BAYER_CONTOUR_CABLE_PID        0x6001
 
 /*
- * The following are the values for the Matrix Orbital FTDI Range
- * Anything in this range will use an FT232RL.
+ * Matrix Orbital Intelligent USB displays.
+ * http://www.matrixorbital.com
  */
 #define MTXORB_VID                      0x1B3D
 #define MTXORB_FTDI_RANGE_0100_PID      0x0100
@@ -1186,8 +1186,39 @@
 #define MTXORB_FTDI_RANGE_01FD_PID      0x01FD
 #define MTXORB_FTDI_RANGE_01FE_PID      0x01FE
 #define MTXORB_FTDI_RANGE_01FF_PID      0x01FF
-
-
+#define MTXORB_FTDI_RANGE_4701_PID      0x4701
+#define MTXORB_FTDI_RANGE_9300_PID      0x9300
+#define MTXORB_FTDI_RANGE_9301_PID      0x9301
+#define MTXORB_FTDI_RANGE_9302_PID      0x9302
+#define MTXORB_FTDI_RANGE_9303_PID      0x9303
+#define MTXORB_FTDI_RANGE_9304_PID      0x9304
+#define MTXORB_FTDI_RANGE_9305_PID      0x9305
+#define MTXORB_FTDI_RANGE_9306_PID      0x9306
+#define MTXORB_FTDI_RANGE_9307_PID      0x9307
+#define MTXORB_FTDI_RANGE_9308_PID      0x9308
+#define MTXORB_FTDI_RANGE_9309_PID      0x9309
+#define MTXORB_FTDI_RANGE_930A_PID      0x930A
+#define MTXORB_FTDI_RANGE_930B_PID      0x930B
+#define MTXORB_FTDI_RANGE_930C_PID      0x930C
+#define MTXORB_FTDI_RANGE_930D_PID      0x930D
+#define MTXORB_FTDI_RANGE_930E_PID      0x930E
+#define MTXORB_FTDI_RANGE_930F_PID      0x930F
+#define MTXORB_FTDI_RANGE_9310_PID      0x9310
+#define MTXORB_FTDI_RANGE_9311_PID      0x9311
+#define MTXORB_FTDI_RANGE_9312_PID      0x9312
+#define MTXORB_FTDI_RANGE_9313_PID      0x9313
+#define MTXORB_FTDI_RANGE_9314_PID      0x9314
+#define MTXORB_FTDI_RANGE_9315_PID      0x9315
+#define MTXORB_FTDI_RANGE_9316_PID      0x9316
+#define MTXORB_FTDI_RANGE_9317_PID      0x9317
+#define MTXORB_FTDI_RANGE_9318_PID      0x9318
+#define MTXORB_FTDI_RANGE_9319_PID      0x9319
+#define MTXORB_FTDI_RANGE_931A_PID      0x931A
+#define MTXORB_FTDI_RANGE_931B_PID      0x931B
+#define MTXORB_FTDI_RANGE_931C_PID      0x931C
+#define MTXORB_FTDI_RANGE_931D_PID      0x931D
+#define MTXORB_FTDI_RANGE_931E_PID      0x931E
+#define MTXORB_FTDI_RANGE_931F_PID      0x931F
 
 /*
  * The Mobility Lab (TML)
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 93cb7cebda62..077c714f1285 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -311,24 +311,30 @@ static void	usa26_indat_callback(struct urb *urb)
                 if ((data[0] & 0x80) == 0) {
                         /* no errors on individual bytes, only
                            possible overrun err */
-                        if (data[0] & RXERROR_OVERRUN)
-                                err = TTY_OVERRUN;
-                        else
-                                err = 0;
+                        if (data[0] & RXERROR_OVERRUN) {
+                                tty_insert_flip_char(&port->port, 0,
+                                                                TTY_OVERRUN);
+                        }
                         for (i = 1; i < urb->actual_length ; ++i)
-                                tty_insert_flip_char(&port->port, data[i], err);
+                                tty_insert_flip_char(&port->port, data[i],
+                                                                TTY_NORMAL);
                 } else {
                         /* some bytes had errors, every byte has status */
                         dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
                         for (i = 0; i + 1 < urb->actual_length; i += 2) {
-                                int stat = data[i], flag = 0;
-                                if (stat & RXERROR_OVERRUN)
-                                        flag |= TTY_OVERRUN;
-                                if (stat & RXERROR_FRAMING)
-                                        flag |= TTY_FRAME;
-                                if (stat & RXERROR_PARITY)
-                                        flag |= TTY_PARITY;
+                                int stat = data[i];
+                                int flag = TTY_NORMAL;
+
+                                if (stat & RXERROR_OVERRUN) {
+                                        tty_insert_flip_char(&port->port, 0,
+                                                                TTY_OVERRUN);
+                                }
                                 /* XXX should handle break (0x10) */
+                                if (stat & RXERROR_PARITY)
+                                        flag = TTY_PARITY;
+                                else if (stat & RXERROR_FRAMING)
+                                        flag = TTY_FRAME;
+
                                 tty_insert_flip_char(&port->port, data[i+1],
                                                 flag);
                         }
@@ -649,14 +655,19 @@ static void	usa49_indat_callback(struct urb *urb)
                 } else {
                         /* some bytes had errors, every byte has status */
                         for (i = 0; i + 1 < urb->actual_length; i += 2) {
-                                int stat = data[i], flag = 0;
-                                if (stat & RXERROR_OVERRUN)
-                                        flag |= TTY_OVERRUN;
-                                if (stat & RXERROR_FRAMING)
-                                        flag |= TTY_FRAME;
-                                if (stat & RXERROR_PARITY)
-                                        flag |= TTY_PARITY;
+                                int stat = data[i];
+                                int flag = TTY_NORMAL;
+
+                                if (stat & RXERROR_OVERRUN) {
+                                        tty_insert_flip_char(&port->port, 0,
+                                                                TTY_OVERRUN);
+                                }
                                 /* XXX should handle break (0x10) */
+                                if (stat & RXERROR_PARITY)
+                                        flag = TTY_PARITY;
+                                else if (stat & RXERROR_FRAMING)
+                                        flag = TTY_FRAME;
+
                                 tty_insert_flip_char(&port->port, data[i+1],
                                                 flag);
                         }
@@ -713,15 +724,19 @@ static void usa49wg_indat_callback(struct urb *urb)
                          */
                         for (x = 0; x + 1 < len &&
                                     i + 1 < urb->actual_length; x += 2) {
-                                int stat = data[i], flag = 0;
+                                int stat = data[i];
+                                int flag = TTY_NORMAL;
 
-                                if (stat & RXERROR_OVERRUN)
-                                        flag |= TTY_OVERRUN;
-                                if (stat & RXERROR_FRAMING)
-                                        flag |= TTY_FRAME;
-                                if (stat & RXERROR_PARITY)
-                                        flag |= TTY_PARITY;
+                                if (stat & RXERROR_OVERRUN) {
+                                        tty_insert_flip_char(&port->port, 0,
+                                                                TTY_OVERRUN);
+                                }
                                 /* XXX should handle break (0x10) */
+                                if (stat & RXERROR_PARITY)
+                                        flag = TTY_PARITY;
+                                else if (stat & RXERROR_FRAMING)
+                                        flag = TTY_FRAME;
+
                                 tty_insert_flip_char(&port->port, data[i+1],
                                                      flag);
                                 i += 2;
@@ -773,25 +788,31 @@ static void usa90_indat_callback(struct urb *urb)
                         if ((data[0] & 0x80) == 0) {
                                 /* no errors on individual bytes, only
                                    possible overrun err*/
-                                if (data[0] & RXERROR_OVERRUN)
-                                        err = TTY_OVERRUN;
-                                else
-                                        err = 0;
+                                if (data[0] & RXERROR_OVERRUN) {
+                                        tty_insert_flip_char(&port->port, 0,
+                                                                TTY_OVERRUN);
+                                }
                                 for (i = 1; i < urb->actual_length ; ++i)
                                         tty_insert_flip_char(&port->port,
-                                                        data[i], err);
+                                                        data[i], TTY_NORMAL);
                         }  else {
                         /* some bytes had errors, every byte has status */
                                 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
                                 for (i = 0; i + 1 < urb->actual_length; i += 2) {
-                                        int stat = data[i], flag = 0;
-                                        if (stat & RXERROR_OVERRUN)
-                                                flag |= TTY_OVERRUN;
-                                        if (stat & RXERROR_FRAMING)
-                                                flag |= TTY_FRAME;
-                                        if (stat & RXERROR_PARITY)
-                                                flag |= TTY_PARITY;
+                                        int stat = data[i];
+                                        int flag = TTY_NORMAL;
+
+                                        if (stat & RXERROR_OVERRUN) {
+                                                tty_insert_flip_char(
+                                                                &port->port, 0,
+                                                                TTY_OVERRUN);
+                                        }
                                         /* XXX should handle break (0x10) */
+                                        if (stat & RXERROR_PARITY)
+                                                flag = TTY_PARITY;
+                                        else if (stat & RXERROR_FRAMING)
+                                                flag = TTY_FRAME;
+
                                         tty_insert_flip_char(&port->port,
                                                         data[i+1], flag);
                                 }
diff --git a/drivers/usb/serial/ssu100.c b/drivers/usb/serial/ssu100.c
index a7fe664b6b7d..70a098de429f 100644
--- a/drivers/usb/serial/ssu100.c
+++ b/drivers/usb/serial/ssu100.c
@@ -490,10 +490,9 @@ static void ssu100_update_lsr(struct usb_serial_port *port, u8 lsr,
                         if (*tty_flag == TTY_NORMAL)
                                 *tty_flag = TTY_FRAME;
                 }
-                if (lsr & UART_LSR_OE){
+                if (lsr & UART_LSR_OE) {
                         port->icount.overrun++;
-                        if (*tty_flag == TTY_NORMAL)
-                                *tty_flag = TTY_OVERRUN;
+                        tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
                 }
         }
 
@@ -511,12 +510,8 @@ static void ssu100_process_read_urb(struct urb *urb)
         if ((len >= 4) &&
             (packet[0] == 0x1b) && (packet[1] == 0x1b) &&
             ((packet[2] == 0x00) || (packet[2] == 0x01))) {
-                if (packet[2] == 0x00) {
+                if (packet[2] == 0x00)
                         ssu100_update_lsr(port, packet[3], &flag);
-                        if (flag == TTY_OVERRUN)
-                                tty_insert_flip_char(&port->port, 0,
-                                                TTY_OVERRUN);
-                }
                 if (packet[2] == 0x01)
                         ssu100_update_msr(port, packet[3]);
 
diff --git a/drivers/usb/storage/debug.c b/drivers/usb/storage/debug.c
index e08f64780e30..2d81e1d8ee30 100644
--- a/drivers/usb/storage/debug.c
+++ b/drivers/usb/storage/debug.c
@@ -164,10 +164,10 @@ void usb_stor_show_sense(const struct us_data *us,
                          unsigned char asc,
                          unsigned char ascq)
 {
-        const char *what, *keystr;
+        const char *what, *keystr, *fmt;
 
         keystr = scsi_sense_key_string(key);
-        what = scsi_extd_sense_format(asc, ascq);
+        what = scsi_extd_sense_format(asc, ascq, &fmt);
 
         if (keystr == NULL)
                 keystr = "(Unknown Key)";
@@ -175,8 +175,10 @@ void usb_stor_show_sense(const struct us_data *us,
                 what = "(unknown ASC/ASCQ)";
 
         usb_stor_dbg(us, "%s: ", keystr);
-        US_DEBUGPX(what, ascq);
-        US_DEBUGPX("\n");
+        if (fmt)
+                US_DEBUGPX("%s (%s%x)\n", what, fmt, ascq);
+        else
+                US_DEBUGPX("%s\n", what);
 }
 
 int usb_stor_dbg(const struct us_data *us, const char *fmt, ...)
@@ -186,7 +188,7 @@ int usb_stor_dbg(const struct us_data *us, const char *fmt, ...)
 
         va_start(args, fmt);
 
-        r = dev_vprintk_emit(7, &us->pusb_dev->dev, fmt, args);
+        r = dev_vprintk_emit(LOGLEVEL_DEBUG, &us->pusb_dev->dev, fmt, args);
 
         va_end(args);
 
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
index 89b24349269e..4047edfb64e1 100644
--- a/drivers/usb/storage/uas.c
+++ b/drivers/usb/storage/uas.c
@@ -181,7 +181,7 @@ static int uas_get_tag(struct scsi_cmnd *cmnd)
 {
         int tag;
 
-        if (blk_rq_tagged(cmnd->request))
+        if (cmnd->flags & SCMD_TAGGED)
                 tag = cmnd->request->tag + 2;
         else
                 tag = 1;
@@ -799,8 +799,7 @@ static int uas_slave_configure(struct scsi_device *sdev)
         if (devinfo->flags & US_FL_NO_REPORT_OPCODES)
                 sdev->no_report_opcodes = 1;
 
-        scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
-        scsi_activate_tcq(sdev, devinfo->qdepth - 2);
+        scsi_change_queue_depth(sdev, devinfo->qdepth - 2);
         return 0;
 }
 
@@ -817,7 +816,6 @@ static struct scsi_host_template uas_host_template = {
         .sg_tablesize = SG_NONE,
         .cmd_per_lun = 1,       /* until we override it */
         .skip_settle_delay = 1,
-        .ordered_tag = 1,
 
         /*
          * The uas drivers expects tags not to be bigger than the maximum
@@ -825,6 +823,7 @@ static struct scsi_host_template uas_host_template = {
          * allocator.
          */
         .disable_blk_mq = true,
+        .use_blk_tags = 1,
 };
 
 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
diff --git a/drivers/usb/storage/unusual_uas.h b/drivers/usb/storage/unusual_uas.h
index 2fefaf923e4a..18a283d6de1c 100644
--- a/drivers/usb/storage/unusual_uas.h
+++ b/drivers/usb/storage/unusual_uas.h
@@ -103,3 +103,10 @@ UNUSUAL_DEV(0x2109, 0x0711, 0x0000, 0x9999,
                 "VL711",
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NO_ATA_1X),
+
+/* Reported-by: Hans de Goede <hdegoede@redhat.com> */
+UNUSUAL_DEV(0x4971, 0x1012, 0x0000, 0x9999,
+                "Hitachi",
+                "External HDD",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_IGNORE_UAS),
diff --git a/drivers/vfio/pci/vfio_pci_intrs.c b/drivers/vfio/pci/vfio_pci_intrs.c
index 553212f037c3..e8d695b3f54e 100644
--- a/drivers/vfio/pci/vfio_pci_intrs.c
+++ b/drivers/vfio/pci/vfio_pci_intrs.c
@@ -560,7 +560,7 @@ static int vfio_msi_set_vector_signal(struct vfio_pci_device *vdev,
                 struct msi_msg msg;
 
                 get_cached_msi_msg(irq, &msg);
-                write_msi_msg(irq, &msg);
+                pci_write_msi_msg(irq, &msg);
         }
 
         ret = request_irq(irq, vfio_msihandler, 0,
diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index 8dae2f724a35..a935c254749e 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -48,20 +48,21 @@ MODULE_PARM_DESC(experimental_zcopytx, "Enable Zero Copy TX;"
  * status internally; used for zerocopy tx only.
  */
 /* Lower device DMA failed */
-#define VHOST_DMA_FAILED_LEN    3
+#define VHOST_DMA_FAILED_LEN    ((__force __virtio32)3)
 /* Lower device DMA done */
-#define VHOST_DMA_DONE_LEN      2
+#define VHOST_DMA_DONE_LEN      ((__force __virtio32)2)
 /* Lower device DMA in progress */
-#define VHOST_DMA_IN_PROGRESS   1
+#define VHOST_DMA_IN_PROGRESS   ((__force __virtio32)1)
 /* Buffer unused */
-#define VHOST_DMA_CLEAR_LEN     0
+#define VHOST_DMA_CLEAR_LEN     ((__force __virtio32)0)
 
-#define VHOST_DMA_IS_DONE(len) ((len) >= VHOST_DMA_DONE_LEN)
+#define VHOST_DMA_IS_DONE(len) ((__force u32)(len) >= (__force u32)VHOST_DMA_DONE_LEN)
 
 enum {
         VHOST_NET_FEATURES = VHOST_FEATURES |
                          (1ULL << VHOST_NET_F_VIRTIO_NET_HDR) |
-                         (1ULL << VIRTIO_NET_F_MRG_RXBUF),
+                         (1ULL << VIRTIO_NET_F_MRG_RXBUF) |
+                         (1ULL << VIRTIO_F_VERSION_1),
 };
 
 enum {
@@ -416,7 +417,7 @@ static void handle_tx(struct vhost_net *net)
                         struct ubuf_info *ubuf;
                         ubuf = nvq->ubuf_info + nvq->upend_idx;
 
-                        vq->heads[nvq->upend_idx].id = head;
+                        vq->heads[nvq->upend_idx].id = cpu_to_vhost32(vq, head);
                         vq->heads[nvq->upend_idx].len = VHOST_DMA_IN_PROGRESS;
                         ubuf->callback = vhost_zerocopy_callback;
                         ubuf->ctx = nvq->ubufs;
@@ -500,6 +501,10 @@ static int get_rx_bufs(struct vhost_virtqueue *vq,
         int headcount = 0;
         unsigned d;
         int r, nlogs = 0;
+        /* len is always initialized before use since we are always called with
+         * datalen > 0.
+         */
+        u32 uninitialized_var(len);
 
         while (datalen > 0 && headcount < quota) {
                 if (unlikely(seg >= UIO_MAXIOV)) {
@@ -527,13 +532,14 @@ static int get_rx_bufs(struct vhost_virtqueue *vq,
                         nlogs += *log_num;
                         log += *log_num;
                 }
-                heads[headcount].id = d;
-                heads[headcount].len = iov_length(vq->iov + seg, in);
-                datalen -= heads[headcount].len;
+                heads[headcount].id = cpu_to_vhost32(vq, d);
+                len = iov_length(vq->iov + seg, in);
+                heads[headcount].len = cpu_to_vhost32(vq, len);
+                datalen -= len;
                 ++headcount;
                 seg += in;
         }
-        heads[headcount - 1].len += datalen;
+        heads[headcount - 1].len = cpu_to_vhost32(vq, len - datalen);
         *iovcount = seg;
         if (unlikely(log))
                 *log_num = nlogs;
@@ -1025,7 +1031,8 @@ static int vhost_net_set_features(struct vhost_net *n, u64 features)
         size_t vhost_hlen, sock_hlen, hdr_len;
         int i;
 
-        hdr_len = (features & (1 << VIRTIO_NET_F_MRG_RXBUF)) ?
+        hdr_len = (features & ((1ULL << VIRTIO_NET_F_MRG_RXBUF) |
+                               (1ULL << VIRTIO_F_VERSION_1))) ?
                         sizeof(struct virtio_net_hdr_mrg_rxbuf) :
                         sizeof(struct virtio_net_hdr);
         if (features & (1 << VHOST_NET_F_VIRTIO_NET_HDR)) {
diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
index a17f11850669..01c01cb3933f 100644
--- a/drivers/vhost/scsi.c
+++ b/drivers/vhost/scsi.c
@@ -168,6 +168,7 @@ enum {
         VHOST_SCSI_VQ_IO = 2,
 };
 
+/* Note: can't set VIRTIO_F_VERSION_1 yet, since that implies ANY_LAYOUT. */
 enum {
         VHOST_SCSI_FEATURES = VHOST_FEATURES | (1ULL << VIRTIO_SCSI_F_HOTPLUG) |
                                                (1ULL << VIRTIO_SCSI_F_T10_PI)
@@ -577,8 +578,8 @@ tcm_vhost_allocate_evt(struct vhost_scsi *vs,
                 return NULL;
         }
 
-        evt->event.event = event;
-        evt->event.reason = reason;
+        evt->event.event = cpu_to_vhost32(vq, event);
+        evt->event.reason = cpu_to_vhost32(vq, reason);
         vs->vs_events_nr++;
 
         return evt;
@@ -636,7 +637,7 @@ again:
         }
 
         if (vs->vs_events_missed) {
-                event->event |= VIRTIO_SCSI_T_EVENTS_MISSED;
+                event->event |= cpu_to_vhost32(vq, VIRTIO_SCSI_T_EVENTS_MISSED);
                 vs->vs_events_missed = false;
         }
 
@@ -695,12 +696,13 @@ static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
                         cmd, se_cmd->residual_count, se_cmd->scsi_status);
 
                 memset(&v_rsp, 0, sizeof(v_rsp));
-                v_rsp.resid = se_cmd->residual_count;
+                v_rsp.resid = cpu_to_vhost32(cmd->tvc_vq, se_cmd->residual_count);
                 /* TODO is status_qualifier field needed? */
                 v_rsp.status = se_cmd->scsi_status;
-                v_rsp.sense_len = se_cmd->scsi_sense_length;
+                v_rsp.sense_len = cpu_to_vhost32(cmd->tvc_vq,
+                                                 se_cmd->scsi_sense_length);
                 memcpy(v_rsp.sense, cmd->tvc_sense_buf,
-                       v_rsp.sense_len);
+                       se_cmd->scsi_sense_length);
                 ret = copy_to_user(cmd->tvc_resp, &v_rsp, sizeof(v_rsp));
                 if (likely(ret == 0)) {
                         struct vhost_scsi_virtqueue *q;
@@ -1095,14 +1097,14 @@ vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
                                                 ", but wrong data_direction\n");
                                         goto err_cmd;
                                 }
-                                prot_bytes = v_req_pi.pi_bytesout;
+                                prot_bytes = vhost32_to_cpu(vq, v_req_pi.pi_bytesout);
                         } else if (v_req_pi.pi_bytesin) {
                                 if (data_direction != DMA_FROM_DEVICE) {
                                         vq_err(vq, "Received non zero di_pi_niov"
                                                 ", but wrong data_direction\n");
                                         goto err_cmd;
                                 }
-                                prot_bytes = v_req_pi.pi_bytesin;
+                                prot_bytes = vhost32_to_cpu(vq, v_req_pi.pi_bytesin);
                         }
                         if (prot_bytes) {
                                 int tmp = 0;
@@ -1117,12 +1119,12 @@ vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
                                 data_first += prot_niov;
                                 data_niov = data_num - prot_niov;
                         }
-                        tag = v_req_pi.tag;
+                        tag = vhost64_to_cpu(vq, v_req_pi.tag);
                         task_attr = v_req_pi.task_attr;
                         cdb = &v_req_pi.cdb[0];
                         lun = ((v_req_pi.lun[2] << 8) | v_req_pi.lun[3]) & 0x3FFF;
                 } else {
-                        tag = v_req.tag;
+                        tag = vhost64_to_cpu(vq, v_req.tag);
                         task_attr = v_req.task_attr;
                         cdb = &v_req.cdb[0];
                         lun = ((v_req.lun[2] << 8) | v_req.lun[3]) & 0x3FFF;
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index c90f4374442a..ed71b5347a76 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -33,8 +33,8 @@ enum {
         VHOST_MEMORY_F_LOG = 0x1,
 };
 
-#define vhost_used_event(vq) ((u16 __user *)&vq->avail->ring[vq->num])
-#define vhost_avail_event(vq) ((u16 __user *)&vq->used->ring[vq->num])
+#define vhost_used_event(vq) ((__virtio16 __user *)&vq->avail->ring[vq->num])
+#define vhost_avail_event(vq) ((__virtio16 __user *)&vq->used->ring[vq->num])
 
 static void vhost_poll_func(struct file *file, wait_queue_head_t *wqh,
                             poll_table *pt)
@@ -1001,7 +1001,7 @@ EXPORT_SYMBOL_GPL(vhost_log_write);
 static int vhost_update_used_flags(struct vhost_virtqueue *vq)
 {
         void __user *used;
-        if (__put_user(vq->used_flags, &vq->used->flags) < 0)
+        if (__put_user(cpu_to_vhost16(vq, vq->used_flags), &vq->used->flags) < 0)
                 return -EFAULT;
         if (unlikely(vq->log_used)) {
                 /* Make sure the flag is seen before log. */
@@ -1019,7 +1019,7 @@ static int vhost_update_used_flags(struct vhost_virtqueue *vq)
 
 static int vhost_update_avail_event(struct vhost_virtqueue *vq, u16 avail_event)
 {
-        if (__put_user(vq->avail_idx, vhost_avail_event(vq)))
+        if (__put_user(cpu_to_vhost16(vq, vq->avail_idx), vhost_avail_event(vq)))
                 return -EFAULT;
         if (unlikely(vq->log_used)) {
                 void __user *used;
@@ -1038,6 +1038,7 @@ static int vhost_update_avail_event(struct vhost_virtqueue *vq, u16 avail_event)
 
 int vhost_init_used(struct vhost_virtqueue *vq)
 {
+        __virtio16 last_used_idx;
         int r;
         if (!vq->private_data)
                 return 0;
@@ -1046,7 +1047,13 @@ int vhost_init_used(struct vhost_virtqueue *vq)
         if (r)
                 return r;
         vq->signalled_used_valid = false;
-        return get_user(vq->last_used_idx, &vq->used->idx);
+        if (!access_ok(VERIFY_READ, &vq->used->idx, sizeof vq->used->idx))
+                return -EFAULT;
+        r = __get_user(last_used_idx, &vq->used->idx);
+        if (r)
+                return r;
+        vq->last_used_idx = vhost16_to_cpu(vq, last_used_idx);
+        return 0;
 }
 EXPORT_SYMBOL_GPL(vhost_init_used);
 
@@ -1087,16 +1094,16 @@ static int translate_desc(struct vhost_virtqueue *vq, u64 addr, u32 len,
 /* Each buffer in the virtqueues is actually a chain of descriptors.  This
  * function returns the next descriptor in the chain,
  * or -1U if we're at the end. */
-static unsigned next_desc(struct vring_desc *desc)
+static unsigned next_desc(struct vhost_virtqueue *vq, struct vring_desc *desc)
 {
         unsigned int next;
 
         /* If this descriptor says it doesn't chain, we're done. */
-        if (!(desc->flags & VRING_DESC_F_NEXT))
+        if (!(desc->flags & cpu_to_vhost16(vq, VRING_DESC_F_NEXT)))
                 return -1U;
 
         /* Check they're not leading us off end of descriptors. */
-        next = desc->next;
+        next = vhost16_to_cpu(vq, desc->next);
         /* Make sure compiler knows to grab that: we don't want it changing! */
         /* We will use the result as an index in an array, so most
          * architectures only need a compiler barrier here. */
@@ -1113,18 +1120,19 @@ static int get_indirect(struct vhost_virtqueue *vq,
 {
         struct vring_desc desc;
         unsigned int i = 0, count, found = 0;
+        u32 len = vhost32_to_cpu(vq, indirect->len);
         int ret;
 
         /* Sanity check */
-        if (unlikely(indirect->len % sizeof desc)) {
+        if (unlikely(len % sizeof desc)) {
                 vq_err(vq, "Invalid length in indirect descriptor: "
                        "len 0x%llx not multiple of 0x%zx\n",
-                       (unsigned long long)indirect->len,
+                       (unsigned long long)len,
                        sizeof desc);
                 return -EINVAL;
         }
 
-        ret = translate_desc(vq, indirect->addr, indirect->len, vq->indirect,
+        ret = translate_desc(vq, vhost64_to_cpu(vq, indirect->addr), len, vq->indirect,
                              UIO_MAXIOV);
         if (unlikely(ret < 0)) {
                 vq_err(vq, "Translation failure %d in indirect.\n", ret);
@@ -1135,7 +1143,7 @@ static int get_indirect(struct vhost_virtqueue *vq,
          * architectures only need a compiler barrier here. */
         read_barrier_depends();
 
-        count = indirect->len / sizeof desc;
+        count = len / sizeof desc;
         /* Buffers are chained via a 16 bit next field, so
          * we can have at most 2^16 of these. */
         if (unlikely(count > USHRT_MAX + 1)) {
@@ -1155,16 +1163,17 @@ static int get_indirect(struct vhost_virtqueue *vq,
                 if (unlikely(memcpy_fromiovec((unsigned char *)&desc,
                                               vq->indirect, sizeof desc))) {
                         vq_err(vq, "Failed indirect descriptor: idx %d, %zx\n",
-                               i, (size_t)indirect->addr + i * sizeof desc);
+                               i, (size_t)vhost64_to_cpu(vq, indirect->addr) + i * sizeof desc);
                         return -EINVAL;
                 }
-                if (unlikely(desc.flags & VRING_DESC_F_INDIRECT)) {
+                if (unlikely(desc.flags & cpu_to_vhost16(vq, VRING_DESC_F_INDIRECT))) {
                         vq_err(vq, "Nested indirect descriptor: idx %d, %zx\n",
-                               i, (size_t)indirect->addr + i * sizeof desc);
+                               i, (size_t)vhost64_to_cpu(vq, indirect->addr) + i * sizeof desc);
                         return -EINVAL;
                 }
 
-                ret = translate_desc(vq, desc.addr, desc.len, iov + iov_count,
+                ret = translate_desc(vq, vhost64_to_cpu(vq, desc.addr),
+                                     vhost32_to_cpu(vq, desc.len), iov + iov_count,
                                      iov_size - iov_count);
                 if (unlikely(ret < 0)) {
                         vq_err(vq, "Translation failure %d indirect idx %d\n",
@@ -1172,11 +1181,11 @@ static int get_indirect(struct vhost_virtqueue *vq,
                         return ret;
                 }
                 /* If this is an input descriptor, increment that count. */
-                if (desc.flags & VRING_DESC_F_WRITE) {
+                if (desc.flags & cpu_to_vhost16(vq, VRING_DESC_F_WRITE)) {
                         *in_num += ret;
                         if (unlikely(log)) {
-                                log[*log_num].addr = desc.addr;
-                                log[*log_num].len = desc.len;
+                                log[*log_num].addr = vhost64_to_cpu(vq, desc.addr);
+                                log[*log_num].len = vhost32_to_cpu(vq, desc.len);
                                 ++*log_num;
                         }
                 } else {
@@ -1189,7 +1198,7 @@ static int get_indirect(struct vhost_virtqueue *vq,
                         }
                         *out_num += ret;
                 }
-        } while ((i = next_desc(&desc)) != -1);
+        } while ((i = next_desc(vq, &desc)) != -1);
         return 0;
 }
 
@@ -1209,15 +1218,18 @@ int vhost_get_vq_desc(struct vhost_virtqueue *vq,
         struct vring_desc desc;
         unsigned int i, head, found = 0;
         u16 last_avail_idx;
+        __virtio16 avail_idx;
+        __virtio16 ring_head;
         int ret;
 
         /* Check it isn't doing very strange things with descriptor numbers. */
         last_avail_idx = vq->last_avail_idx;
-        if (unlikely(__get_user(vq->avail_idx, &vq->avail->idx))) {
+        if (unlikely(__get_user(avail_idx, &vq->avail->idx))) {
                 vq_err(vq, "Failed to access avail idx at %p\n",
                        &vq->avail->idx);
                 return -EFAULT;
         }
+        vq->avail_idx = vhost16_to_cpu(vq, avail_idx);
 
         if (unlikely((u16)(vq->avail_idx - last_avail_idx) > vq->num)) {
                 vq_err(vq, "Guest moved used index from %u to %u",
@@ -1234,7 +1246,7 @@ int vhost_get_vq_desc(struct vhost_virtqueue *vq,
 
         /* Grab the next descriptor number they're advertising, and increment
          * the index we've seen. */
-        if (unlikely(__get_user(head,
+        if (unlikely(__get_user(ring_head,
                                 &vq->avail->ring[last_avail_idx % vq->num]))) {
                 vq_err(vq, "Failed to read head: idx %d address %p\n",
                        last_avail_idx,
@@ -1242,6 +1254,8 @@ int vhost_get_vq_desc(struct vhost_virtqueue *vq,
                 return -EFAULT;
         }
 
+        head = vhost16_to_cpu(vq, ring_head);
+
         /* If their number is silly, that's an error. */
         if (unlikely(head >= vq->num)) {
                 vq_err(vq, "Guest says index %u > %u is available",
@@ -1274,7 +1288,7 @@ int vhost_get_vq_desc(struct vhost_virtqueue *vq,
                                i, vq->desc + i);
                         return -EFAULT;
                 }
-                if (desc.flags & VRING_DESC_F_INDIRECT) {
+                if (desc.flags & cpu_to_vhost16(vq, VRING_DESC_F_INDIRECT)) {
                         ret = get_indirect(vq, iov, iov_size,
                                            out_num, in_num,
                                            log, log_num, &desc);
@@ -1286,20 +1300,21 @@ int vhost_get_vq_desc(struct vhost_virtqueue *vq,
                         continue;
                 }
 
-                ret = translate_desc(vq, desc.addr, desc.len, iov + iov_count,
+                ret = translate_desc(vq, vhost64_to_cpu(vq, desc.addr),
+                                     vhost32_to_cpu(vq, desc.len), iov + iov_count,
                                      iov_size - iov_count);
                 if (unlikely(ret < 0)) {
                         vq_err(vq, "Translation failure %d descriptor idx %d\n",
                                ret, i);
                         return ret;
                 }
-                if (desc.flags & VRING_DESC_F_WRITE) {
+                if (desc.flags & cpu_to_vhost16(vq, VRING_DESC_F_WRITE)) {
                         /* If this is an input descriptor,
                          * increment that count. */
                         *in_num += ret;
                         if (unlikely(log)) {
-                                log[*log_num].addr = desc.addr;
-                                log[*log_num].len = desc.len;
+                                log[*log_num].addr = vhost64_to_cpu(vq, desc.addr);
+                                log[*log_num].len = vhost32_to_cpu(vq, desc.len);
                                 ++*log_num;
                         }
                 } else {
@@ -1312,7 +1327,7 @@ int vhost_get_vq_desc(struct vhost_virtqueue *vq,
                         }
                         *out_num += ret;
                 }
-        } while ((i = next_desc(&desc)) != -1);
+        } while ((i = next_desc(vq, &desc)) != -1);
 
         /* On success, increment avail index. */
         vq->last_avail_idx++;
@@ -1335,7 +1350,10 @@ EXPORT_SYMBOL_GPL(vhost_discard_vq_desc);
  * want to notify the guest, using eventfd. */
 int vhost_add_used(struct vhost_virtqueue *vq, unsigned int head, int len)
 {
-        struct vring_used_elem heads = { head, len };
+        struct vring_used_elem heads = {
+                cpu_to_vhost32(vq, head),
+                cpu_to_vhost32(vq, len)
+        };
 
         return vhost_add_used_n(vq, &heads, 1);
 }
@@ -1404,7 +1422,7 @@ int vhost_add_used_n(struct vhost_virtqueue *vq, struct vring_used_elem *heads,
 
         /* Make sure buffer is written before we update index. */
         smp_wmb();
-        if (put_user(vq->last_used_idx, &vq->used->idx)) {
+        if (__put_user(cpu_to_vhost16(vq, vq->last_used_idx), &vq->used->idx)) {
                 vq_err(vq, "Failed to increment used idx");
                 return -EFAULT;
         }
@@ -1422,7 +1440,8 @@ EXPORT_SYMBOL_GPL(vhost_add_used_n);
 
 static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
 {
-        __u16 old, new, event;
+        __u16 old, new;
+        __virtio16 event;
         bool v;
         /* Flush out used index updates. This is paired
          * with the barrier that the Guest executes when enabling
@@ -1434,12 +1453,12 @@ static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
                 return true;
 
         if (!vhost_has_feature(vq, VIRTIO_RING_F_EVENT_IDX)) {
-                __u16 flags;
+                __virtio16 flags;
                 if (__get_user(flags, &vq->avail->flags)) {
                         vq_err(vq, "Failed to get flags");
                         return true;
                 }
-                return !(flags & VRING_AVAIL_F_NO_INTERRUPT);
+                return !(flags & cpu_to_vhost16(vq, VRING_AVAIL_F_NO_INTERRUPT));
         }
         old = vq->signalled_used;
         v = vq->signalled_used_valid;
@@ -1449,11 +1468,11 @@ static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
         if (unlikely(!v))
                 return true;
 
-        if (get_user(event, vhost_used_event(vq))) {
+        if (__get_user(event, vhost_used_event(vq))) {
                 vq_err(vq, "Failed to get used event idx");
                 return true;
         }
-        return vring_need_event(event, new, old);
+        return vring_need_event(vhost16_to_cpu(vq, event), new, old);
 }
 
 /* This actually signals the guest, using eventfd. */
@@ -1488,7 +1507,7 @@ EXPORT_SYMBOL_GPL(vhost_add_used_and_signal_n);
 /* OK, now we need to know about added descriptors. */
 bool vhost_enable_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
 {
-        u16 avail_idx;
+        __virtio16 avail_idx;
         int r;
 
         if (!(vq->used_flags & VRING_USED_F_NO_NOTIFY))
@@ -1519,7 +1538,7 @@ bool vhost_enable_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
                 return false;
         }
 
-        return avail_idx != vq->avail_idx;
+        return vhost16_to_cpu(vq, avail_idx) != vq->avail_idx;
 }
 EXPORT_SYMBOL_GPL(vhost_enable_notify);
 
diff --git a/drivers/vhost/vhost.h b/drivers/vhost/vhost.h
index 3eda654b8f5a..8c1c792900ba 100644
--- a/drivers/vhost/vhost.h
+++ b/drivers/vhost/vhost.h
@@ -12,8 +12,6 @@
 #include <linux/virtio_ring.h>
 #include <linux/atomic.h>
 
-struct vhost_device;
-
 struct vhost_work;
 typedef void (*vhost_work_fn_t)(struct vhost_work *work);
 
@@ -54,8 +52,6 @@ struct vhost_log {
         u64 len;
 };
 
-struct vhost_virtqueue;
-
 /* The virtqueue structure describes a queue attached to a device. */
 struct vhost_virtqueue {
         struct vhost_dev *dev;
@@ -106,7 +102,7 @@ struct vhost_virtqueue {
         /* Protected by virtqueue mutex. */
         struct vhost_memory *memory;
         void *private_data;
-        unsigned acked_features;
+        u64 acked_features;
         /* Log write descriptors */
         void __user *log_base;
         struct vhost_log *log;
@@ -172,8 +168,39 @@ enum {
                          (1ULL << VHOST_F_LOG_ALL),
 };
 
-static inline int vhost_has_feature(struct vhost_virtqueue *vq, int bit)
+static inline bool vhost_has_feature(struct vhost_virtqueue *vq, int bit)
+{
+        return vq->acked_features & (1ULL << bit);
+}
+
+/* Memory accessors */
+static inline u16 vhost16_to_cpu(struct vhost_virtqueue *vq, __virtio16 val)
+{
+        return __virtio16_to_cpu(vhost_has_feature(vq, VIRTIO_F_VERSION_1), val);
+}
+
+static inline __virtio16 cpu_to_vhost16(struct vhost_virtqueue *vq, u16 val)
+{
+        return __cpu_to_virtio16(vhost_has_feature(vq, VIRTIO_F_VERSION_1), val);
+}
+
+static inline u32 vhost32_to_cpu(struct vhost_virtqueue *vq, __virtio32 val)
+{
+        return __virtio32_to_cpu(vhost_has_feature(vq, VIRTIO_F_VERSION_1), val);
+}
+
+static inline __virtio32 cpu_to_vhost32(struct vhost_virtqueue *vq, u32 val)
+{
+        return __cpu_to_virtio32(vhost_has_feature(vq, VIRTIO_F_VERSION_1), val);
+}
+
+static inline u64 vhost64_to_cpu(struct vhost_virtqueue *vq, __virtio64 val)
+{
+        return __virtio64_to_cpu(vhost_has_feature(vq, VIRTIO_F_VERSION_1), val);
+}
+
+static inline __virtio64 cpu_to_vhost64(struct vhost_virtqueue *vq, u64 val)
 {
-        return vq->acked_features & (1 << bit);
+        return __cpu_to_virtio64(vhost_has_feature(vq, VIRTIO_F_VERSION_1), val);
 }
 #endif
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 8d03924749b8..efb09046a8cf 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -168,7 +168,6 @@ if BACKLIGHT_CLASS_DEVICE
 config BACKLIGHT_ATMEL_LCDC
         bool "Atmel LCDC Contrast-as-Backlight control"
         depends on FB_ATMEL
-        default y if MACH_AT91SAM9261EK || MACH_AT91SAM9G10EK || MACH_AT91SAM9263EK
         help
           This provides a backlight control internal to the Atmel LCDC
           driver.  If the LCD "contrast control" on your board is wired
diff --git a/drivers/video/backlight/lp855x_bl.c b/drivers/video/backlight/lp855x_bl.c
index 25fb8e3d75b1..a26d3bb25650 100644
--- a/drivers/video/backlight/lp855x_bl.c
+++ b/drivers/video/backlight/lp855x_bl.c
@@ -17,6 +17,7 @@
 #include <linux/of.h>
 #include <linux/platform_data/lp855x.h>
 #include <linux/pwm.h>
+#include <linux/regulator/consumer.h>
 
 /* LP8550/1/2/3/6 Registers */
 #define LP855X_BRIGHTNESS_CTRL          0x00
@@ -341,8 +342,10 @@ static const struct attribute_group lp855x_attr_group = {
 };
 
 #ifdef CONFIG_OF
-static int lp855x_parse_dt(struct device *dev, struct device_node *node)
+static int lp855x_parse_dt(struct lp855x *lp)
 {
+        struct device *dev = lp->dev;
+        struct device_node *node = dev->of_node;
         struct lp855x_platform_data *pdata;
         int rom_length;
 
@@ -381,12 +384,19 @@ static int lp855x_parse_dt(struct device *dev, struct device_node *node)
                 pdata->rom_data = &rom[0];
         }
 
-        dev->platform_data = pdata;
+        pdata->supply = devm_regulator_get(dev, "power");
+        if (IS_ERR(pdata->supply)) {
+                if (PTR_ERR(pdata->supply) == -EPROBE_DEFER)
+                        return -EPROBE_DEFER;
+                pdata->supply = NULL;
+        }
+
+        lp->pdata = pdata;
 
         return 0;
 }
 #else
-static int lp855x_parse_dt(struct device *dev, struct device_node *node)
+static int lp855x_parse_dt(struct lp855x *lp)
 {
         return -EINVAL;
 }
@@ -395,18 +405,8 @@ static int lp855x_parse_dt(struct device *dev, struct device_node *node)
 static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
 {
         struct lp855x *lp;
-        struct lp855x_platform_data *pdata = dev_get_platdata(&cl->dev);
-        struct device_node *node = cl->dev.of_node;
         int ret;
 
-        if (!pdata) {
-                ret = lp855x_parse_dt(&cl->dev, node);
-                if (ret < 0)
-                        return ret;
-
-                pdata = dev_get_platdata(&cl->dev);
-        }
-
         if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
                 return -EIO;
 
@@ -414,16 +414,31 @@ static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
         if (!lp)
                 return -ENOMEM;
 
-        if (pdata->period_ns > 0)
-                lp->mode = PWM_BASED;
-        else
-                lp->mode = REGISTER_BASED;
-
         lp->client = cl;
         lp->dev = &cl->dev;
-        lp->pdata = pdata;
         lp->chipname = id->name;
         lp->chip_id = id->driver_data;
+        lp->pdata = dev_get_platdata(&cl->dev);
+
+        if (!lp->pdata) {
+                ret = lp855x_parse_dt(lp);
+                if (ret < 0)
+                        return ret;
+        }
+
+        if (lp->pdata->period_ns > 0)
+                lp->mode = PWM_BASED;
+        else
+                lp->mode = REGISTER_BASED;
+
+        if (lp->pdata->supply) {
+                ret = regulator_enable(lp->pdata->supply);
+                if (ret < 0) {
+                        dev_err(&cl->dev, "failed to enable supply: %d\n", ret);
+                        return ret;
+                }
+        }
+
         i2c_set_clientdata(cl, lp);
 
         ret = lp855x_configure(lp);
@@ -455,6 +470,8 @@ static int lp855x_remove(struct i2c_client *cl)
 
         lp->bl->props.brightness = 0;
         backlight_update_status(lp->bl);
+        if (lp->pdata->supply)
+                regulator_disable(lp->pdata->supply);
         sysfs_remove_group(&lp->dev->kobj, &lp855x_attr_group);
 
         return 0;
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index cb5ae4c08469..3a145a643e0d 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -34,6 +34,7 @@ struct pwm_bl_data {
         struct regulator        *power_supply;
         struct gpio_desc        *enable_gpio;
         unsigned int            scale;
+        bool                    legacy;
         int                     (*notify)(struct device *,
                                           int brightness);
         void                    (*notify_after)(struct device *,
@@ -274,7 +275,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
         pb->pwm = devm_pwm_get(&pdev->dev, NULL);
         if (IS_ERR(pb->pwm)) {
                 dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");
-
+                pb->legacy = true;
                 pb->pwm = pwm_request(data->pwm_id, "pwm-backlight");
                 if (IS_ERR(pb->pwm)) {
                         dev_err(&pdev->dev, "unable to request legacy PWM\n");
@@ -339,6 +340,8 @@ static int pwm_backlight_remove(struct platform_device *pdev)
 
         if (pb->exit)
                 pb->exit(&pdev->dev);
+        if (pb->legacy)
+                pwm_free(pb->pwm);
 
         return 0;
 }
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index eb976ee3a02f..ea437245562e 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -3624,7 +3624,7 @@ static int __init fb_console_init(void)
         return 0;
 }
 
-module_init(fb_console_init);
+fs_initcall(fb_console_init);
 
 #ifdef MODULE
 
diff --git a/drivers/video/fbdev/Kconfig b/drivers/video/fbdev/Kconfig
index c7bf606a8706..4916c97216f8 100644
--- a/drivers/video/fbdev/Kconfig
+++ b/drivers/video/fbdev/Kconfig
@@ -999,23 +999,6 @@ config FB_ATMEL
         help
           This enables support for the AT91/AT32 LCD Controller.
 
-config FB_INTSRAM
-        bool "Frame Buffer in internal SRAM"
-        depends on FB_ATMEL && ARCH_AT91SAM9261
-        help
-          Say Y if you want to map Frame Buffer in internal SRAM. Say N if you want
-          to let frame buffer in external SDRAM.
-
-config FB_ATMEL_STN
-        bool "Use a STN display with AT91/AT32 LCD Controller"
-        depends on FB_ATMEL && (MACH_AT91SAM9261EK || MACH_AT91SAM9G10EK)
-        default n
-        help
-          Say Y if you want to connect a STN LCD display to the AT91/AT32 LCD
-          Controller. Say N if you want to connect a TFT.
-
-          If unsure, say N.
-
 config FB_NVIDIA
         tristate "nVidia Framebuffer Support"
         depends on FB && PCI
@@ -2425,7 +2408,7 @@ config FB_JZ4740
 
 config FB_MXS
         tristate "MXS LCD framebuffer support"
-        depends on FB && ARCH_MXS
+        depends on FB && (ARCH_MXS || ARCH_MXC)
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
diff --git a/drivers/video/fbdev/amba-clcd.c b/drivers/video/fbdev/amba-clcd.c
index 6ad23bd3523a..32c0b6b28097 100644
--- a/drivers/video/fbdev/amba-clcd.c
+++ b/drivers/video/fbdev/amba-clcd.c
@@ -27,7 +27,6 @@
 #include <linux/bitops.h>
 #include <linux/clk.h>
 #include <linux/hardirq.h>
-#include <linux/dma-mapping.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/of_graph.h>
diff --git a/drivers/video/fbdev/arkfb.c b/drivers/video/fbdev/arkfb.c
index adc4ea2cc5a0..b305a1e7cc76 100644
--- a/drivers/video/fbdev/arkfb.c
+++ b/drivers/video/fbdev/arkfb.c
@@ -1016,7 +1016,7 @@ static int ark_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         pcibios_bus_to_resource(dev->bus, &vga_res, &bus_reg);
 
-        par->state.vgabase = (void __iomem *) vga_res.start;
+        par->state.vgabase = (void __iomem *) (unsigned long) vga_res.start;
 
         /* FIXME get memsize */
         regval = vga_rseq(par->state.vgabase, 0x10);
diff --git a/drivers/video/fbdev/gbefb.c b/drivers/video/fbdev/gbefb.c
index 4aa56ba78f32..6d9ef39810c8 100644
--- a/drivers/video/fbdev/gbefb.c
+++ b/drivers/video/fbdev/gbefb.c
@@ -54,7 +54,8 @@ struct gbefb_par {
 #endif
 #endif
 #ifdef CONFIG_X86
-#define pgprot_fb(_prot) ((_prot) | _PAGE_PCD)
+#define pgprot_fb(_prot) (((_prot) & ~_PAGE_CACHE_MASK) |       \
+                          cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS))
 #endif
 
 /*
diff --git a/drivers/video/fbdev/mmp/core.c b/drivers/video/fbdev/mmp/core.c
index b563b920f159..a0f496049db7 100644
--- a/drivers/video/fbdev/mmp/core.c
+++ b/drivers/video/fbdev/mmp/core.c
@@ -223,10 +223,10 @@ struct mmp_path *mmp_register_path(struct mmp_path_info *info)
 EXPORT_SYMBOL_GPL(mmp_register_path);
 
 /*
- * mmp_unregister_path - unregister and destory path
- * @p: path to be destoried.
+ * mmp_unregister_path - unregister and destroy path
+ * @p: path to be destroyed.
  *
- * this function registers path and destorys it.
+ * this function registers path and destroys it.
  */
 void mmp_unregister_path(struct mmp_path *path)
 {
diff --git a/drivers/video/fbdev/mmp/hw/mmp_ctrl.c b/drivers/video/fbdev/mmp/hw/mmp_ctrl.c
index 8621a9f2bdcc..3c12bd83b561 100644
--- a/drivers/video/fbdev/mmp/hw/mmp_ctrl.c
+++ b/drivers/video/fbdev/mmp/hw/mmp_ctrl.c
@@ -441,8 +441,7 @@ static void path_deinit(struct mmphw_path_plat *path_plat)
         if (!path_plat)
                 return;
 
-        if (path_plat->path)
-                mmp_unregister_path(path_plat->path);
+        mmp_unregister_path(path_plat->path);
 }
 
 static int mmphw_probe(struct platform_device *pdev)
diff --git a/drivers/video/fbdev/mx3fb.c b/drivers/video/fbdev/mx3fb.c
index 23ec781e9a61..f23fca0be9d7 100644
--- a/drivers/video/fbdev/mx3fb.c
+++ b/drivers/video/fbdev/mx3fb.c
@@ -334,8 +334,7 @@ static void mx3fb_init_backlight(struct mx3fb_data *fbd)
 
 static void mx3fb_exit_backlight(struct mx3fb_data *fbd)
 {
-        if (fbd->bl)
-                backlight_device_unregister(fbd->bl);
+        backlight_device_unregister(fbd->bl);
 }
 
 static void mx3fb_dma_done(void *);
diff --git a/drivers/video/fbdev/mxsfb.c b/drivers/video/fbdev/mxsfb.c
index accf48a2cce4..f8ac4a452f26 100644
--- a/drivers/video/fbdev/mxsfb.c
+++ b/drivers/video/fbdev/mxsfb.c
@@ -172,6 +172,8 @@ struct mxsfb_info {
         struct fb_info fb_info;
         struct platform_device *pdev;
         struct clk *clk;
+        struct clk *clk_axi;
+        struct clk *clk_disp_axi;
         void __iomem *base;     /* registers */
         unsigned allocated_size;
         int enabled;
@@ -331,6 +333,11 @@ static void mxsfb_enable_controller(struct fb_info *fb_info)
                 }
         }
 
+        if (host->clk_axi)
+                clk_prepare_enable(host->clk_axi);
+
+        if (host->clk_disp_axi)
+                clk_prepare_enable(host->clk_disp_axi);
         clk_prepare_enable(host->clk);
         clk_set_rate(host->clk, PICOS2KHZ(fb_info->var.pixclock) * 1000U);
 
@@ -374,6 +381,10 @@ static void mxsfb_disable_controller(struct fb_info *fb_info)
         writel(reg & ~VDCTRL4_SYNC_SIGNALS_ON, host->base + LCDC_VDCTRL4);
 
         clk_disable_unprepare(host->clk);
+        if (host->clk_disp_axi)
+                clk_disable_unprepare(host->clk_disp_axi);
+        if (host->clk_axi)
+                clk_disable_unprepare(host->clk_axi);
 
         host->enabled = 0;
 
@@ -867,6 +878,14 @@ static int mxsfb_probe(struct platform_device *pdev)
                 goto fb_release;
         }
 
+        host->clk_axi = devm_clk_get(&host->pdev->dev, "axi");
+        if (IS_ERR(host->clk_axi))
+                host->clk_axi = NULL;
+
+        host->clk_disp_axi = devm_clk_get(&host->pdev->dev, "disp_axi");
+        if (IS_ERR(host->clk_disp_axi))
+                host->clk_disp_axi = NULL;
+
         host->reg_lcd = devm_regulator_get(&pdev->dev, "lcd");
         if (IS_ERR(host->reg_lcd))
                 host->reg_lcd = NULL;
diff --git a/drivers/video/fbdev/omap2/displays-new/connector-dvi.c b/drivers/video/fbdev/omap2/displays-new/connector-dvi.c
index 2dfb6e5ff0cc..3d38e478bc64 100644
--- a/drivers/video/fbdev/omap2/displays-new/connector-dvi.c
+++ b/drivers/video/fbdev/omap2/displays-new/connector-dvi.c
@@ -262,8 +262,7 @@ static int dvic_probe_pdata(struct platform_device *pdev)
 
         in = omap_dss_find_output(pdata->source);
         if (in == NULL) {
-                if (ddata->i2c_adapter)
-                        i2c_put_adapter(ddata->i2c_adapter);
+                i2c_put_adapter(ddata->i2c_adapter);
 
                 dev_err(&pdev->dev, "Failed to find video source\n");
                 return -EPROBE_DEFER;
@@ -352,8 +351,7 @@ static int dvic_probe(struct platform_device *pdev)
 err_reg:
         omap_dss_put_device(ddata->in);
 
-        if (ddata->i2c_adapter)
-                i2c_put_adapter(ddata->i2c_adapter);
+        i2c_put_adapter(ddata->i2c_adapter);
 
         return r;
 }
@@ -371,8 +369,7 @@ static int __exit dvic_remove(struct platform_device *pdev)
 
         omap_dss_put_device(in);
 
-        if (ddata->i2c_adapter)
-                i2c_put_adapter(ddata->i2c_adapter);
+        i2c_put_adapter(ddata->i2c_adapter);
 
         return 0;
 }
diff --git a/drivers/video/fbdev/omap2/displays-new/connector-hdmi.c b/drivers/video/fbdev/omap2/displays-new/connector-hdmi.c
index 7b25967a91eb..219f14f59672 100644
--- a/drivers/video/fbdev/omap2/displays-new/connector-hdmi.c
+++ b/drivers/video/fbdev/omap2/displays-new/connector-hdmi.c
@@ -170,98 +170,6 @@ static bool hdmic_detect(struct omap_dss_device *dssdev)
                 return in->ops.hdmi->detect(in);
 }
 
-static int hdmic_audio_enable(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-        int r;
-
-        /* enable audio only if the display is active */
-        if (!omapdss_device_is_enabled(dssdev))
-                return -EPERM;
-
-        r = in->ops.hdmi->audio_enable(in);
-        if (r)
-                return r;
-
-        dssdev->audio_state = OMAP_DSS_AUDIO_ENABLED;
-
-        return 0;
-}
-
-static void hdmic_audio_disable(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        in->ops.hdmi->audio_disable(in);
-
-        dssdev->audio_state = OMAP_DSS_AUDIO_DISABLED;
-}
-
-static int hdmic_audio_start(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-        int r;
-
-        /*
-         * No need to check the panel state. It was checked when trasitioning
-         * to AUDIO_ENABLED.
-         */
-        if (dssdev->audio_state != OMAP_DSS_AUDIO_ENABLED)
-                return -EPERM;
-
-        r = in->ops.hdmi->audio_start(in);
-        if (r)
-                return r;
-
-        dssdev->audio_state = OMAP_DSS_AUDIO_PLAYING;
-
-        return 0;
-}
-
-static void hdmic_audio_stop(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        in->ops.hdmi->audio_stop(in);
-
-        dssdev->audio_state = OMAP_DSS_AUDIO_ENABLED;
-}
-
-static bool hdmic_audio_supported(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        if (!omapdss_device_is_enabled(dssdev))
-                return false;
-
-        return in->ops.hdmi->audio_supported(in);
-}
-
-static int hdmic_audio_config(struct omap_dss_device *dssdev,
-                struct omap_dss_audio *audio)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-        int r;
-
-        /* config audio only if the display is active */
-        if (!omapdss_device_is_enabled(dssdev))
-                return -EPERM;
-
-        r = in->ops.hdmi->audio_config(in, audio);
-        if (r)
-                return r;
-
-        dssdev->audio_state = OMAP_DSS_AUDIO_CONFIGURED;
-
-        return 0;
-}
-
 static int hdmic_set_hdmi_mode(struct omap_dss_device *dssdev, bool hdmi_mode)
 {
         struct panel_drv_data *ddata = to_panel_data(dssdev);
@@ -296,13 +204,6 @@ static struct omap_dss_driver hdmic_driver = {
         .detect                 = hdmic_detect,
         .set_hdmi_mode          = hdmic_set_hdmi_mode,
         .set_hdmi_infoframe     = hdmic_set_infoframe,
-
-        .audio_enable           = hdmic_audio_enable,
-        .audio_disable          = hdmic_audio_disable,
-        .audio_start            = hdmic_audio_start,
-        .audio_stop             = hdmic_audio_stop,
-        .audio_supported        = hdmic_audio_supported,
-        .audio_config           = hdmic_audio_config,
 };
 
 static int hdmic_probe_pdata(struct platform_device *pdev)
diff --git a/drivers/video/fbdev/omap2/displays-new/encoder-tfp410.c b/drivers/video/fbdev/omap2/displays-new/encoder-tfp410.c
index 47ee7cdee1c5..e349064ed615 100644
--- a/drivers/video/fbdev/omap2/displays-new/encoder-tfp410.c
+++ b/drivers/video/fbdev/omap2/displays-new/encoder-tfp410.c
@@ -249,6 +249,7 @@ static int tfp410_probe(struct platform_device *pdev)
         dssdev->output_type = OMAP_DISPLAY_TYPE_DVI;
         dssdev->owner = THIS_MODULE;
         dssdev->phy.dpi.data_lines = ddata->data_lines;
+        dssdev->port_num = 1;
 
         r = omapdss_register_output(dssdev);
         if (r) {
diff --git a/drivers/video/fbdev/omap2/displays-new/encoder-tpd12s015.c b/drivers/video/fbdev/omap2/displays-new/encoder-tpd12s015.c
index c4abd56dd846..c7a3ce2c5120 100644
--- a/drivers/video/fbdev/omap2/displays-new/encoder-tpd12s015.c
+++ b/drivers/video/fbdev/omap2/displays-new/encoder-tpd12s015.c
@@ -193,55 +193,6 @@ static bool tpd_detect(struct omap_dss_device *dssdev)
         return gpio_get_value_cansleep(ddata->hpd_gpio);
 }
 
-static int tpd_audio_enable(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        return in->ops.hdmi->audio_enable(in);
-}
-
-static void tpd_audio_disable(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        in->ops.hdmi->audio_disable(in);
-}
-
-static int tpd_audio_start(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        return in->ops.hdmi->audio_start(in);
-}
-
-static void tpd_audio_stop(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        in->ops.hdmi->audio_stop(in);
-}
-
-static bool tpd_audio_supported(struct omap_dss_device *dssdev)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        return in->ops.hdmi->audio_supported(in);
-}
-
-static int tpd_audio_config(struct omap_dss_device *dssdev,
-                struct omap_dss_audio *audio)
-{
-        struct panel_drv_data *ddata = to_panel_data(dssdev);
-        struct omap_dss_device *in = ddata->in;
-
-        return in->ops.hdmi->audio_config(in, audio);
-}
-
 static int tpd_set_infoframe(struct omap_dss_device *dssdev,
                 const struct hdmi_avi_infoframe *avi)
 {
@@ -275,13 +226,6 @@ static const struct omapdss_hdmi_ops tpd_hdmi_ops = {
         .detect                 = tpd_detect,
         .set_infoframe          = tpd_set_infoframe,
         .set_hdmi_mode          = tpd_set_hdmi_mode,
-
-        .audio_enable           = tpd_audio_enable,
-        .audio_disable          = tpd_audio_disable,
-        .audio_start            = tpd_audio_start,
-        .audio_stop             = tpd_audio_stop,
-        .audio_supported        = tpd_audio_supported,
-        .audio_config           = tpd_audio_config,
 };
 
 static int tpd_probe_pdata(struct platform_device *pdev)
@@ -409,6 +353,7 @@ static int tpd_probe(struct platform_device *pdev)
         dssdev->type = OMAP_DISPLAY_TYPE_HDMI;
         dssdev->output_type = OMAP_DISPLAY_TYPE_HDMI;
         dssdev->owner = THIS_MODULE;
+        dssdev->port_num = 1;
 
         in = ddata->in;
 
diff --git a/drivers/video/fbdev/omap2/dss/Kconfig b/drivers/video/fbdev/omap2/dss/Kconfig
index 3d5eb6c36c22..d1fa730c7d54 100644
--- a/drivers/video/fbdev/omap2/dss/Kconfig
+++ b/drivers/video/fbdev/omap2/dss/Kconfig
@@ -74,9 +74,6 @@ config OMAP4_DSS_HDMI
         help
           HDMI support for OMAP4 based SoCs.
 
-config OMAP4_DSS_HDMI_AUDIO
-        bool
-
 config OMAP5_DSS_HDMI
         bool "HDMI support for OMAP5"
         default n
@@ -86,10 +83,6 @@ config OMAP5_DSS_HDMI
           Definition Multimedia Interface. See http://www.hdmi.org/ for HDMI
           specification.
 
-config OMAP5_DSS_HDMI_AUDIO
-        depends on OMAP5_DSS_HDMI
-        bool
-
 config OMAP2_DSS_SDI
         bool "SDI support"
         default n
diff --git a/drivers/video/fbdev/omap2/dss/Makefile b/drivers/video/fbdev/omap2/dss/Makefile
index 245f933060ee..2ea9d382354c 100644
--- a/drivers/video/fbdev/omap2/dss/Makefile
+++ b/drivers/video/fbdev/omap2/dss/Makefile
@@ -2,7 +2,7 @@ obj-$(CONFIG_OMAP2_DSS_INIT) += omapdss-boot-init.o
 obj-$(CONFIG_OMAP2_DSS) += omapdss.o
 # Core DSS files
 omapdss-y := core.o dss.o dss_features.o dispc.o dispc_coefs.o display.o \
-        output.o dss-of.o
+        output.o dss-of.o pll.o
 # DSS compat layer files
 omapdss-y += manager.o manager-sysfs.o overlay.o overlay-sysfs.o apply.o \
         dispc-compat.o display-sysfs.o
diff --git a/drivers/video/fbdev/omap2/dss/dispc.c b/drivers/video/fbdev/omap2/dss/dispc.c
index 0e9a74bb9fc2..0729c08ac75a 100644
--- a/drivers/video/fbdev/omap2/dss/dispc.c
+++ b/drivers/video/fbdev/omap2/dss/dispc.c
@@ -3028,7 +3028,7 @@ static void dispc_mgr_get_lcd_divisor(enum omap_channel channel, int *lck_div,
 
 unsigned long dispc_fclk_rate(void)
 {
-        struct platform_device *dsidev;
+        struct dss_pll *pll;
         unsigned long r = 0;
 
         switch (dss_get_dispc_clk_source()) {
@@ -3036,12 +3036,12 @@ unsigned long dispc_fclk_rate(void)
                 r = dss_get_dispc_clk_rate();
                 break;
         case OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
-                dsidev = dsi_get_dsidev_from_id(0);
-                r = dsi_get_pll_hsdiv_dispc_rate(dsidev);
+                pll = dss_pll_find("dsi0");
+                r = pll->cinfo.clkout[0];
                 break;
         case OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC:
-                dsidev = dsi_get_dsidev_from_id(1);
-                r = dsi_get_pll_hsdiv_dispc_rate(dsidev);
+                pll = dss_pll_find("dsi1");
+                r = pll->cinfo.clkout[0];
                 break;
         default:
                 BUG();
@@ -3053,7 +3053,7 @@ unsigned long dispc_fclk_rate(void)
 
 unsigned long dispc_mgr_lclk_rate(enum omap_channel channel)
 {
-        struct platform_device *dsidev;
+        struct dss_pll *pll;
         int lcd;
         unsigned long r;
         u32 l;
@@ -3068,12 +3068,12 @@ unsigned long dispc_mgr_lclk_rate(enum omap_channel channel)
                         r = dss_get_dispc_clk_rate();
                         break;
                 case OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
-                        dsidev = dsi_get_dsidev_from_id(0);
-                        r = dsi_get_pll_hsdiv_dispc_rate(dsidev);
+                        pll = dss_pll_find("dsi0");
+                        r = pll->cinfo.clkout[0];
                         break;
                 case OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC:
-                        dsidev = dsi_get_dsidev_from_id(1);
-                        r = dsi_get_pll_hsdiv_dispc_rate(dsidev);
+                        pll = dss_pll_find("dsi1");
+                        r = pll->cinfo.clkout[0];
                         break;
                 default:
                         BUG();
diff --git a/drivers/video/fbdev/omap2/dss/dpi.c b/drivers/video/fbdev/omap2/dss/dpi.c
index 4a3363dae74a..2edf5caa002f 100644
--- a/drivers/video/fbdev/omap2/dss/dpi.c
+++ b/drivers/video/fbdev/omap2/dss/dpi.c
@@ -31,17 +31,20 @@
 #include <linux/regulator/consumer.h>
 #include <linux/string.h>
 #include <linux/of.h>
+#include <linux/clk.h>
 
 #include <video/omapdss.h>
 
 #include "dss.h"
 #include "dss_features.h"
 
-static struct {
+#define HSDIV_DISPC     0
+
+struct dpi_data {
         struct platform_device *pdev;
 
         struct regulator *vdds_dsi_reg;
-        struct platform_device *dsidev;
+        struct dss_pll *pll;
 
         struct mutex lock;
 
@@ -52,9 +55,20 @@ static struct {
         struct omap_dss_device output;
 
         bool port_initialized;
-} dpi;
+};
+
+static struct dpi_data *dpi_get_data_from_dssdev(struct omap_dss_device *dssdev)
+{
+        return container_of(dssdev, struct dpi_data, output);
+}
+
+/* only used in non-DT mode */
+static struct dpi_data *dpi_get_data_from_pdev(struct platform_device *pdev)
+{
+        return dev_get_drvdata(&pdev->dev);
+}
 
-static struct platform_device *dpi_get_dsidev(enum omap_channel channel)
+static struct dss_pll *dpi_get_pll(enum omap_channel channel)
 {
         /*
          * XXX we can't currently use DSI PLL for DPI with OMAP3, as the DSI PLL
@@ -75,9 +89,9 @@ static struct platform_device *dpi_get_dsidev(enum omap_channel channel)
         case OMAPDSS_VER_OMAP4:
                 switch (channel) {
                 case OMAP_DSS_CHANNEL_LCD:
-                        return dsi_get_dsidev_from_id(0);
+                        return dss_pll_find("dsi0");
                 case OMAP_DSS_CHANNEL_LCD2:
-                        return dsi_get_dsidev_from_id(1);
+                        return dss_pll_find("dsi1");
                 default:
                         return NULL;
                 }
@@ -85,9 +99,9 @@ static struct platform_device *dpi_get_dsidev(enum omap_channel channel)
         case OMAPDSS_VER_OMAP5:
                 switch (channel) {
                 case OMAP_DSS_CHANNEL_LCD:
-                        return dsi_get_dsidev_from_id(0);
+                        return dss_pll_find("dsi0");
                 case OMAP_DSS_CHANNEL_LCD3:
-                        return dsi_get_dsidev_from_id(1);
+                        return dss_pll_find("dsi1");
                 default:
                         return NULL;
                 }
@@ -114,7 +128,7 @@ static enum omap_dss_clk_source dpi_get_alt_clk_src(enum omap_channel channel)
 }
 
 struct dpi_clk_calc_ctx {
-        struct platform_device *dsidev;
+        struct dss_pll *pll;
 
         /* inputs */
 
@@ -122,7 +136,7 @@ struct dpi_clk_calc_ctx {
 
         /* outputs */
 
-        struct dsi_clock_info dsi_cinfo;
+        struct dss_pll_clock_info dsi_cinfo;
         unsigned long fck;
         struct dispc_clock_info dispc_cinfo;
 };
@@ -154,7 +168,7 @@ static bool dpi_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
 }
 
 
-static bool dpi_calc_hsdiv_cb(int regm_dispc, unsigned long dispc,
+static bool dpi_calc_hsdiv_cb(int m_dispc, unsigned long dispc,
                 void *data)
 {
         struct dpi_clk_calc_ctx *ctx = data;
@@ -164,30 +178,31 @@ static bool dpi_calc_hsdiv_cb(int regm_dispc, unsigned long dispc,
          * shifted. So skip all odd dividers when the pixel clock is on the
          * higher side.
          */
-        if (regm_dispc > 1 && regm_dispc % 2 != 0 && ctx->pck_min >= 100000000)
+        if (m_dispc > 1 && m_dispc % 2 != 0 && ctx->pck_min >= 100000000)
                 return false;
 
-        ctx->dsi_cinfo.regm_dispc = regm_dispc;
-        ctx->dsi_cinfo.dsi_pll_hsdiv_dispc_clk = dispc;
+        ctx->dsi_cinfo.mX[HSDIV_DISPC] = m_dispc;
+        ctx->dsi_cinfo.clkout[HSDIV_DISPC] = dispc;
 
         return dispc_div_calc(dispc, ctx->pck_min, ctx->pck_max,
                         dpi_calc_dispc_cb, ctx);
 }
 
 
-static bool dpi_calc_pll_cb(int regn, int regm, unsigned long fint,
-                unsigned long pll,
+static bool dpi_calc_pll_cb(int n, int m, unsigned long fint,
+                unsigned long clkdco,
                 void *data)
 {
         struct dpi_clk_calc_ctx *ctx = data;
 
-        ctx->dsi_cinfo.regn = regn;
-        ctx->dsi_cinfo.regm = regm;
+        ctx->dsi_cinfo.n = n;
+        ctx->dsi_cinfo.m = m;
         ctx->dsi_cinfo.fint = fint;
-        ctx->dsi_cinfo.clkin4ddr = pll;
+        ctx->dsi_cinfo.clkdco = clkdco;
 
-        return dsi_hsdiv_calc(ctx->dsidev, pll, ctx->pck_min,
-                        dpi_calc_hsdiv_cb, ctx);
+        return dss_pll_hsdiv_calc(ctx->pll, clkdco,
+                ctx->pck_min, dss_feat_get_param_max(FEAT_PARAM_DSS_FCK),
+                dpi_calc_hsdiv_cb, ctx);
 }
 
 static bool dpi_calc_dss_cb(unsigned long fck, void *data)
@@ -200,23 +215,23 @@ static bool dpi_calc_dss_cb(unsigned long fck, void *data)
                         dpi_calc_dispc_cb, ctx);
 }
 
-static bool dpi_dsi_clk_calc(unsigned long pck, struct dpi_clk_calc_ctx *ctx)
+static bool dpi_dsi_clk_calc(struct dpi_data *dpi, unsigned long pck,
+                struct dpi_clk_calc_ctx *ctx)
 {
         unsigned long clkin;
         unsigned long pll_min, pll_max;
 
-        clkin = dsi_get_pll_clkin(dpi.dsidev);
-
         memset(ctx, 0, sizeof(*ctx));
-        ctx->dsidev = dpi.dsidev;
+        ctx->pll = dpi->pll;
         ctx->pck_min = pck - 1000;
         ctx->pck_max = pck + 1000;
-        ctx->dsi_cinfo.clkin = clkin;
 
         pll_min = 0;
         pll_max = 0;
 
-        return dsi_pll_calc(dpi.dsidev, clkin,
+        clkin = clk_get_rate(ctx->pll->clkin);
+
+        return dss_pll_calc(ctx->pll, clkin,
                         pll_min, pll_max,
                         dpi_calc_pll_cb, ctx);
 }
@@ -252,7 +267,7 @@ static bool dpi_dss_clk_calc(unsigned long pck, struct dpi_clk_calc_ctx *ctx)
 
 
 
-static int dpi_set_dsi_clk(enum omap_channel channel,
+static int dpi_set_dsi_clk(struct dpi_data *dpi, enum omap_channel channel,
                 unsigned long pck_req, unsigned long *fck, int *lck_div,
                 int *pck_div)
 {
@@ -260,28 +275,28 @@ static int dpi_set_dsi_clk(enum omap_channel channel,
         int r;
         bool ok;
 
-        ok = dpi_dsi_clk_calc(pck_req, &ctx);
+        ok = dpi_dsi_clk_calc(dpi, pck_req, &ctx);
         if (!ok)
                 return -EINVAL;
 
-        r = dsi_pll_set_clock_div(dpi.dsidev, &ctx.dsi_cinfo);
+        r = dss_pll_set_config(dpi->pll, &ctx.dsi_cinfo);
         if (r)
                 return r;
 
         dss_select_lcd_clk_source(channel,
                         dpi_get_alt_clk_src(channel));
 
-        dpi.mgr_config.clock_info = ctx.dispc_cinfo;
+        dpi->mgr_config.clock_info = ctx.dispc_cinfo;
 
-        *fck = ctx.dsi_cinfo.dsi_pll_hsdiv_dispc_clk;
+        *fck = ctx.dsi_cinfo.clkout[HSDIV_DISPC];
         *lck_div = ctx.dispc_cinfo.lck_div;
         *pck_div = ctx.dispc_cinfo.pck_div;
 
         return 0;
 }
 
-static int dpi_set_dispc_clk(unsigned long pck_req, unsigned long *fck,
-                int *lck_div, int *pck_div)
+static int dpi_set_dispc_clk(struct dpi_data *dpi, unsigned long pck_req,
+                unsigned long *fck, int *lck_div, int *pck_div)
 {
         struct dpi_clk_calc_ctx ctx;
         int r;
@@ -295,7 +310,7 @@ static int dpi_set_dispc_clk(unsigned long pck_req, unsigned long *fck,
         if (r)
                 return r;
 
-        dpi.mgr_config.clock_info = ctx.dispc_cinfo;
+        dpi->mgr_config.clock_info = ctx.dispc_cinfo;
 
         *fck = ctx.fck;
         *lck_div = ctx.dispc_cinfo.lck_div;
@@ -304,19 +319,21 @@ static int dpi_set_dispc_clk(unsigned long pck_req, unsigned long *fck,
         return 0;
 }
 
-static int dpi_set_mode(struct omap_overlay_manager *mgr)
+static int dpi_set_mode(struct dpi_data *dpi)
 {
-        struct omap_video_timings *t = &dpi.timings;
+        struct omap_dss_device *out = &dpi->output;
+        struct omap_overlay_manager *mgr = out->manager;
+        struct omap_video_timings *t = &dpi->timings;
         int lck_div = 0, pck_div = 0;
         unsigned long fck = 0;
         unsigned long pck;
         int r = 0;
 
-        if (dpi.dsidev)
-                r = dpi_set_dsi_clk(mgr->id, t->pixelclock, &fck,
+        if (dpi->pll)
+                r = dpi_set_dsi_clk(dpi, mgr->id, t->pixelclock, &fck,
                                 &lck_div, &pck_div);
         else
-                r = dpi_set_dispc_clk(t->pixelclock, &fck,
+                r = dpi_set_dispc_clk(dpi, t->pixelclock, &fck,
                                 &lck_div, &pck_div);
         if (r)
                 return r;
@@ -335,28 +352,32 @@ static int dpi_set_mode(struct omap_overlay_manager *mgr)
         return 0;
 }
 
-static void dpi_config_lcd_manager(struct omap_overlay_manager *mgr)
+static void dpi_config_lcd_manager(struct dpi_data *dpi)
 {
-        dpi.mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS;
+        struct omap_dss_device *out = &dpi->output;
+        struct omap_overlay_manager *mgr = out->manager;
+
+        dpi->mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS;
 
-        dpi.mgr_config.stallmode = false;
-        dpi.mgr_config.fifohandcheck = false;
+        dpi->mgr_config.stallmode = false;
+        dpi->mgr_config.fifohandcheck = false;
 
-        dpi.mgr_config.video_port_width = dpi.data_lines;
+        dpi->mgr_config.video_port_width = dpi->data_lines;
 
-        dpi.mgr_config.lcden_sig_polarity = 0;
+        dpi->mgr_config.lcden_sig_polarity = 0;
 
-        dss_mgr_set_lcd_config(mgr, &dpi.mgr_config);
+        dss_mgr_set_lcd_config(mgr, &dpi->mgr_config);
 }
 
 static int dpi_display_enable(struct omap_dss_device *dssdev)
 {
-        struct omap_dss_device *out = &dpi.output;
+        struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
+        struct omap_dss_device *out = &dpi->output;
         int r;
 
-        mutex_lock(&dpi.lock);
+        mutex_lock(&dpi->lock);
 
-        if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI) && !dpi.vdds_dsi_reg) {
+        if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI) && !dpi->vdds_dsi_reg) {
                 DSSERR("no VDSS_DSI regulator\n");
                 r = -ENODEV;
                 goto err_no_reg;
@@ -369,7 +390,7 @@ static int dpi_display_enable(struct omap_dss_device *dssdev)
         }
 
         if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI)) {
-                r = regulator_enable(dpi.vdds_dsi_reg);
+                r = regulator_enable(dpi->vdds_dsi_reg);
                 if (r)
                         goto err_reg_enable;
         }
@@ -378,25 +399,21 @@ static int dpi_display_enable(struct omap_dss_device *dssdev)
         if (r)
                 goto err_get_dispc;
 
-        r = dss_dpi_select_source(out->manager->id);
+        r = dss_dpi_select_source(out->port_num, out->manager->id);
         if (r)
                 goto err_src_sel;
 
-        if (dpi.dsidev) {
-                r = dsi_runtime_get(dpi.dsidev);
-                if (r)
-                        goto err_get_dsi;
-
-                r = dsi_pll_init(dpi.dsidev, 0, 1);
+        if (dpi->pll) {
+                r = dss_pll_enable(dpi->pll);
                 if (r)
                         goto err_dsi_pll_init;
         }
 
-        r = dpi_set_mode(out->manager);
+        r = dpi_set_mode(dpi);
         if (r)
                 goto err_set_mode;
 
-        dpi_config_lcd_manager(out->manager);
+        dpi_config_lcd_manager(dpi);
 
         mdelay(2);
 
@@ -404,78 +421,80 @@ static int dpi_display_enable(struct omap_dss_device *dssdev)
         if (r)
                 goto err_mgr_enable;
 
-        mutex_unlock(&dpi.lock);
+        mutex_unlock(&dpi->lock);
 
         return 0;
 
 err_mgr_enable:
 err_set_mode:
-        if (dpi.dsidev)
-                dsi_pll_uninit(dpi.dsidev, true);
+        if (dpi->pll)
+                dss_pll_disable(dpi->pll);
 err_dsi_pll_init:
-        if (dpi.dsidev)
-                dsi_runtime_put(dpi.dsidev);
-err_get_dsi:
 err_src_sel:
         dispc_runtime_put();
 err_get_dispc:
         if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI))
-                regulator_disable(dpi.vdds_dsi_reg);
+                regulator_disable(dpi->vdds_dsi_reg);
 err_reg_enable:
 err_no_out_mgr:
 err_no_reg:
-        mutex_unlock(&dpi.lock);
+        mutex_unlock(&dpi->lock);
         return r;
 }
 
 static void dpi_display_disable(struct omap_dss_device *dssdev)
 {
-        struct omap_overlay_manager *mgr = dpi.output.manager;
+        struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
+        struct omap_overlay_manager *mgr = dpi->output.manager;
 
-        mutex_lock(&dpi.lock);
+        mutex_lock(&dpi->lock);
 
         dss_mgr_disable(mgr);
 
-        if (dpi.dsidev) {
+        if (dpi->pll) {
                 dss_select_lcd_clk_source(mgr->id, OMAP_DSS_CLK_SRC_FCK);
-                dsi_pll_uninit(dpi.dsidev, true);
-                dsi_runtime_put(dpi.dsidev);
+                dss_pll_disable(dpi->pll);
         }
 
         dispc_runtime_put();
 
         if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI))
-                regulator_disable(dpi.vdds_dsi_reg);
+                regulator_disable(dpi->vdds_dsi_reg);
 
-        mutex_unlock(&dpi.lock);
+        mutex_unlock(&dpi->lock);
 }
 
 static void dpi_set_timings(struct omap_dss_device *dssdev,
                 struct omap_video_timings *timings)
 {
+        struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
+
         DSSDBG("dpi_set_timings\n");
 
-        mutex_lock(&dpi.lock);
+        mutex_lock(&dpi->lock);
 
-        dpi.timings = *timings;
+        dpi->timings = *timings;
 
-        mutex_unlock(&dpi.lock);
+        mutex_unlock(&dpi->lock);
 }
 
 static void dpi_get_timings(struct omap_dss_device *dssdev,
                 struct omap_video_timings *timings)
 {
-        mutex_lock(&dpi.lock);
+        struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
+
+        mutex_lock(&dpi->lock);
 
-        *timings = dpi.timings;
+        *timings = dpi->timings;
 
-        mutex_unlock(&dpi.lock);
+        mutex_unlock(&dpi->lock);
 }
 
 static int dpi_check_timings(struct omap_dss_device *dssdev,
                         struct omap_video_timings *timings)
 {
-        struct omap_overlay_manager *mgr = dpi.output.manager;
+        struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
+        struct omap_overlay_manager *mgr = dpi->output.manager;
         int lck_div, pck_div;
         unsigned long fck;
         unsigned long pck;
@@ -488,12 +507,12 @@ static int dpi_check_timings(struct omap_dss_device *dssdev,
         if (timings->pixelclock == 0)
                 return -EINVAL;
 
-        if (dpi.dsidev) {
-                ok = dpi_dsi_clk_calc(timings->pixelclock, &ctx);
+        if (dpi->pll) {
+                ok = dpi_dsi_clk_calc(dpi, timings->pixelclock, &ctx);
                 if (!ok)
                         return -EINVAL;
 
-                fck = ctx.dsi_cinfo.dsi_pll_hsdiv_dispc_clk;
+                fck = ctx.dsi_cinfo.clkout[HSDIV_DISPC];
         } else {
                 ok = dpi_dss_clk_calc(timings->pixelclock, &ctx);
                 if (!ok)
@@ -514,74 +533,69 @@ static int dpi_check_timings(struct omap_dss_device *dssdev,
 
 static void dpi_set_data_lines(struct omap_dss_device *dssdev, int data_lines)
 {
-        mutex_lock(&dpi.lock);
+        struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
 
-        dpi.data_lines = data_lines;
+        mutex_lock(&dpi->lock);
 
-        mutex_unlock(&dpi.lock);
+        dpi->data_lines = data_lines;
+
+        mutex_unlock(&dpi->lock);
 }
 
-static int dpi_verify_dsi_pll(struct platform_device *dsidev)
+static int dpi_verify_dsi_pll(struct dss_pll *pll)
 {
         int r;
 
         /* do initial setup with the PLL to see if it is operational */
 
-        r = dsi_runtime_get(dsidev);
+        r = dss_pll_enable(pll);
         if (r)
                 return r;
 
-        r = dsi_pll_init(dsidev, 0, 1);
-        if (r) {
-                dsi_runtime_put(dsidev);
-                return r;
-        }
-
-        dsi_pll_uninit(dsidev, true);
-        dsi_runtime_put(dsidev);
+        dss_pll_disable(pll);
 
         return 0;
 }
 
-static int dpi_init_regulator(void)
+static int dpi_init_regulator(struct dpi_data *dpi)
 {
         struct regulator *vdds_dsi;
 
         if (!dss_has_feature(FEAT_DPI_USES_VDDS_DSI))
                 return 0;
 
-        if (dpi.vdds_dsi_reg)
+        if (dpi->vdds_dsi_reg)
                 return 0;
 
-        vdds_dsi = devm_regulator_get(&dpi.pdev->dev, "vdds_dsi");
+        vdds_dsi = devm_regulator_get(&dpi->pdev->dev, "vdds_dsi");
         if (IS_ERR(vdds_dsi)) {
                 if (PTR_ERR(vdds_dsi) != -EPROBE_DEFER)
                         DSSERR("can't get VDDS_DSI regulator\n");
                 return PTR_ERR(vdds_dsi);
         }
 
-        dpi.vdds_dsi_reg = vdds_dsi;
+        dpi->vdds_dsi_reg = vdds_dsi;
 
         return 0;
 }
 
-static void dpi_init_pll(void)
+static void dpi_init_pll(struct dpi_data *dpi)
 {
-        struct platform_device *dsidev;
+        struct dss_pll *pll;
 
-        if (dpi.dsidev)
+        if (dpi->pll)
                 return;
 
-        dsidev = dpi_get_dsidev(dpi.output.dispc_channel);
-        if (!dsidev)
+        pll = dpi_get_pll(dpi->output.dispc_channel);
+        if (!pll)
                 return;
 
-        if (dpi_verify_dsi_pll(dsidev)) {
+        if (dpi_verify_dsi_pll(pll)) {
                 DSSWARN("DSI PLL not operational\n");
                 return;
         }
 
-        dpi.dsidev = dsidev;
+        dpi->pll = pll;
 }
 
 /*
@@ -590,7 +604,7 @@ static void dpi_init_pll(void)
  * the channel in some more dynamic manner, or get the channel as a user
  * parameter.
  */
-static enum omap_channel dpi_get_channel(void)
+static enum omap_channel dpi_get_channel(int port_num)
 {
         switch (omapdss_get_version()) {
         case OMAPDSS_VER_OMAP24xx:
@@ -618,14 +632,15 @@ static enum omap_channel dpi_get_channel(void)
 static int dpi_connect(struct omap_dss_device *dssdev,
                 struct omap_dss_device *dst)
 {
+        struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
         struct omap_overlay_manager *mgr;
         int r;
 
-        r = dpi_init_regulator();
+        r = dpi_init_regulator(dpi);
         if (r)
                 return r;
 
-        dpi_init_pll();
+        dpi_init_pll(dpi);
 
         mgr = omap_dss_get_overlay_manager(dssdev->dispc_channel);
         if (!mgr)
@@ -676,13 +691,14 @@ static const struct omapdss_dpi_ops dpi_ops = {
 
 static void dpi_init_output(struct platform_device *pdev)
 {
-        struct omap_dss_device *out = &dpi.output;
+        struct dpi_data *dpi = dpi_get_data_from_pdev(pdev);
+        struct omap_dss_device *out = &dpi->output;
 
         out->dev = &pdev->dev;
         out->id = OMAP_DSS_OUTPUT_DPI;
         out->output_type = OMAP_DISPLAY_TYPE_DPI;
         out->name = "dpi.0";
-        out->dispc_channel = dpi_get_channel();
+        out->dispc_channel = dpi_get_channel(0);
         out->ops.dpi = &dpi_ops;
         out->owner = THIS_MODULE;
 
@@ -691,16 +707,69 @@ static void dpi_init_output(struct platform_device *pdev)
 
 static void __exit dpi_uninit_output(struct platform_device *pdev)
 {
-        struct omap_dss_device *out = &dpi.output;
+        struct dpi_data *dpi = dpi_get_data_from_pdev(pdev);
+        struct omap_dss_device *out = &dpi->output;
+
+        omapdss_unregister_output(out);
+}
+
+static void dpi_init_output_port(struct platform_device *pdev,
+        struct device_node *port)
+{
+        struct dpi_data *dpi = port->data;
+        struct omap_dss_device *out = &dpi->output;
+        int r;
+        u32 port_num;
+
+        r = of_property_read_u32(port, "reg", &port_num);
+        if (r)
+                port_num = 0;
+
+        switch (port_num) {
+        case 2:
+                out->name = "dpi.2";
+                break;
+        case 1:
+                out->name = "dpi.1";
+                break;
+        case 0:
+        default:
+                out->name = "dpi.0";
+                break;
+        }
+
+        out->dev = &pdev->dev;
+        out->id = OMAP_DSS_OUTPUT_DPI;
+        out->output_type = OMAP_DISPLAY_TYPE_DPI;
+        out->dispc_channel = dpi_get_channel(port_num);
+        out->port_num = port_num;
+        out->ops.dpi = &dpi_ops;
+        out->owner = THIS_MODULE;
+
+        omapdss_register_output(out);
+}
+
+static void __exit dpi_uninit_output_port(struct device_node *port)
+{
+        struct dpi_data *dpi = port->data;
+        struct omap_dss_device *out = &dpi->output;
 
         omapdss_unregister_output(out);
 }
 
 static int omap_dpi_probe(struct platform_device *pdev)
 {
-        dpi.pdev = pdev;
+        struct dpi_data *dpi;
+
+        dpi = devm_kzalloc(&pdev->dev, sizeof(*dpi), GFP_KERNEL);
+        if (!dpi)
+                return -ENOMEM;
 
-        mutex_init(&dpi.lock);
+        dpi->pdev = pdev;
+
+        dev_set_drvdata(&pdev->dev, dpi);
+
+        mutex_init(&dpi->lock);
 
         dpi_init_output(pdev);
 
@@ -736,10 +805,15 @@ void __exit dpi_uninit_platform_driver(void)
 
 int __init dpi_init_port(struct platform_device *pdev, struct device_node *port)
 {
+        struct dpi_data *dpi;
         struct device_node *ep;
         u32 datalines;
         int r;
 
+        dpi = devm_kzalloc(&pdev->dev, sizeof(*dpi), GFP_KERNEL);
+        if (!dpi)
+                return -ENOMEM;
+
         ep = omapdss_of_get_next_endpoint(port, NULL);
         if (!ep)
                 return 0;
@@ -750,17 +824,18 @@ int __init dpi_init_port(struct platform_device *pdev, struct device_node *port)
                 goto err_datalines;
         }
 
-        dpi.data_lines = datalines;
+        dpi->data_lines = datalines;
 
         of_node_put(ep);
 
-        dpi.pdev = pdev;
+        dpi->pdev = pdev;
+        port->data = dpi;
 
-        mutex_init(&dpi.lock);
+        mutex_init(&dpi->lock);
 
-        dpi_init_output(pdev);
+        dpi_init_output_port(pdev, port);
 
-        dpi.port_initialized = true;
+        dpi->port_initialized = true;
 
         return 0;
 
@@ -770,10 +845,12 @@ err_datalines:
         return r;
 }
 
-void __exit dpi_uninit_port(void)
+void __exit dpi_uninit_port(struct device_node *port)
 {
-        if (!dpi.port_initialized)
+        struct dpi_data *dpi = port->data;
+
+        if (!dpi->port_initialized)
                 return;
 
-        dpi_uninit_output(dpi.pdev);
+        dpi_uninit_output_port(port);
 }
diff --git a/drivers/video/fbdev/omap2/dss/dsi.c b/drivers/video/fbdev/omap2/dss/dsi.c
index 0793bc67a275..73af35159468 100644
--- a/drivers/video/fbdev/omap2/dss/dsi.c
+++ b/drivers/video/fbdev/omap2/dss/dsi.c
@@ -219,6 +219,10 @@ static void dsi_display_uninit_dispc(struct platform_device *dsidev,
 
 static int dsi_vc_send_null(struct omap_dss_device *dssdev, int channel);
 
+/* DSI PLL HSDIV indices */
+#define HSDIV_DISPC     0
+#define HSDIV_DSI       1
+
 #define DSI_MAX_NR_ISRS                2
 #define DSI_MAX_NR_LANES        5
 
@@ -271,6 +275,7 @@ struct dsi_isr_tables {
 
 struct dsi_clk_calc_ctx {
         struct platform_device *dsidev;
+        struct dss_pll *pll;
 
         /* inputs */
 
@@ -280,13 +285,18 @@ struct dsi_clk_calc_ctx {
 
         /* outputs */
 
-        struct dsi_clock_info dsi_cinfo;
+        struct dss_pll_clock_info dsi_cinfo;
         struct dispc_clock_info dispc_cinfo;
 
         struct omap_video_timings dispc_vm;
         struct omap_dss_dsi_videomode_timings dsi_vm;
 };
 
+struct dsi_lp_clock_info {
+        unsigned long lp_clk;
+        u16 lp_clk_div;
+};
+
 struct dsi_data {
         struct platform_device *pdev;
         void __iomem *proto_base;
@@ -300,12 +310,14 @@ struct dsi_data {
         bool is_enabled;
 
         struct clk *dss_clk;
-        struct clk *sys_clk;
 
         struct dispc_clock_info user_dispc_cinfo;
-        struct dsi_clock_info user_dsi_cinfo;
+        struct dss_pll_clock_info user_dsi_cinfo;
+
+        struct dsi_lp_clock_info user_lp_cinfo;
+        struct dsi_lp_clock_info current_lp_cinfo;
 
-        struct dsi_clock_info current_cinfo;
+        struct dss_pll pll;
 
         bool vdds_dsi_enabled;
         struct regulator *vdds_dsi_reg;
@@ -321,8 +333,6 @@ struct dsi_data {
         struct mutex lock;
         struct semaphore bus_lock;
 
-        unsigned pll_locked;
-
         spinlock_t irq_lock;
         struct dsi_isr_tables isr_tables;
         /* space for a copy used by the interrupt handler */
@@ -347,7 +357,7 @@ struct dsi_data {
 
         unsigned long cache_req_pck;
         unsigned long cache_clk_freq;
-        struct dsi_clock_info cache_cinfo;
+        struct dss_pll_clock_info cache_cinfo;
 
         u32             errors;
         spinlock_t      errors_lock;
@@ -362,11 +372,6 @@ struct dsi_data {
         spinlock_t irq_stats_lock;
         struct dsi_irq_stats irq_stats;
 #endif
-        /* DSI PLL Parameter Ranges */
-        unsigned long regm_max, regn_max;
-        unsigned long  regm_dispc_max, regm_dsi_max;
-        unsigned long  fint_min, fint_max;
-        unsigned long lpdiv_max;
 
         unsigned num_lanes_supported;
         unsigned line_buffer_size;
@@ -412,7 +417,7 @@ static inline struct platform_device *dsi_get_dsidev_from_dssdev(struct omap_dss
         return to_platform_device(dssdev->dev);
 }
 
-struct platform_device *dsi_get_dsidev_from_id(int module)
+static struct platform_device *dsi_get_dsidev_from_id(int module)
 {
         struct omap_dss_device *out;
         enum omap_dss_output_id id;
@@ -1134,7 +1139,7 @@ static u32 dsi_get_errors(struct platform_device *dsidev)
         return e;
 }
 
-int dsi_runtime_get(struct platform_device *dsidev)
+static int dsi_runtime_get(struct platform_device *dsidev)
 {
         int r;
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
@@ -1146,7 +1151,7 @@ int dsi_runtime_get(struct platform_device *dsidev)
         return r < 0 ? r : 0;
 }
 
-void dsi_runtime_put(struct platform_device *dsidev)
+static void dsi_runtime_put(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         int r;
@@ -1188,23 +1193,6 @@ static int dsi_regulator_init(struct platform_device *dsidev)
         return 0;
 }
 
-/* source clock for DSI PLL. this could also be PCLKFREE */
-static inline void dsi_enable_pll_clock(struct platform_device *dsidev,
-                bool enable)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-
-        if (enable)
-                clk_prepare_enable(dsi->sys_clk);
-        else
-                clk_disable_unprepare(dsi->sys_clk);
-
-        if (enable && dsi->pll_locked) {
-                if (wait_for_bit_change(dsidev, DSI_PLL_STATUS, 1, 1) != 1)
-                        DSSERR("cannot lock PLL when enabling clocks\n");
-        }
-}
-
 static void _dsi_print_reset_status(struct platform_device *dsidev)
 {
         u32 l;
@@ -1256,25 +1244,25 @@ static inline int dsi_if_enable(struct platform_device *dsidev, bool enable)
         return 0;
 }
 
-unsigned long dsi_get_pll_hsdiv_dispc_rate(struct platform_device *dsidev)
+static unsigned long dsi_get_pll_hsdiv_dispc_rate(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
-        return dsi->current_cinfo.dsi_pll_hsdiv_dispc_clk;
+        return dsi->pll.cinfo.clkout[HSDIV_DISPC];
 }
 
 static unsigned long dsi_get_pll_hsdiv_dsi_rate(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
-        return dsi->current_cinfo.dsi_pll_hsdiv_dsi_clk;
+        return dsi->pll.cinfo.clkout[HSDIV_DSI];
 }
 
 static unsigned long dsi_get_txbyteclkhs(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
-        return dsi->current_cinfo.clkin4ddr / 16;
+        return dsi->pll.cinfo.clkdco / 16;
 }
 
 static unsigned long dsi_fclk_rate(struct platform_device *dsidev)
@@ -1293,10 +1281,10 @@ static unsigned long dsi_fclk_rate(struct platform_device *dsidev)
         return r;
 }
 
-static int dsi_lp_clock_calc(struct dsi_clock_info *cinfo,
-                unsigned long lp_clk_min, unsigned long lp_clk_max)
+static int dsi_lp_clock_calc(unsigned long dsi_fclk,
+                unsigned long lp_clk_min, unsigned long lp_clk_max,
+                struct dsi_lp_clock_info *lp_cinfo)
 {
-        unsigned long dsi_fclk = cinfo->dsi_pll_hsdiv_dsi_clk;
         unsigned lp_clk_div;
         unsigned long lp_clk;
 
@@ -1306,8 +1294,8 @@ static int dsi_lp_clock_calc(struct dsi_clock_info *cinfo,
         if (lp_clk < lp_clk_min || lp_clk > lp_clk_max)
                 return -EINVAL;
 
-        cinfo->lp_clk_div = lp_clk_div;
-        cinfo->lp_clk = lp_clk;
+        lp_cinfo->lp_clk_div = lp_clk_div;
+        lp_cinfo->lp_clk = lp_clk;
 
         return 0;
 }
@@ -1318,10 +1306,12 @@ static int dsi_set_lp_clk_divisor(struct platform_device *dsidev)
         unsigned long dsi_fclk;
         unsigned lp_clk_div;
         unsigned long lp_clk;
+        unsigned lpdiv_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_LPDIV);
+
 
-        lp_clk_div = dsi->user_dsi_cinfo.lp_clk_div;
+        lp_clk_div = dsi->user_lp_cinfo.lp_clk_div;
 
-        if (lp_clk_div == 0 || lp_clk_div > dsi->lpdiv_max)
+        if (lp_clk_div == 0 || lp_clk_div > lpdiv_max)
                 return -EINVAL;
 
         dsi_fclk = dsi_fclk_rate(dsidev);
@@ -1329,8 +1319,8 @@ static int dsi_set_lp_clk_divisor(struct platform_device *dsidev)
         lp_clk = dsi_fclk / 2 / lp_clk_div;
 
         DSSDBG("LP_CLK_DIV %u, LP_CLK %lu\n", lp_clk_div, lp_clk);
-        dsi->current_cinfo.lp_clk = lp_clk;
-        dsi->current_cinfo.lp_clk_div = lp_clk_div;
+        dsi->current_lp_cinfo.lp_clk = lp_clk;
+        dsi->current_lp_cinfo.lp_clk_div = lp_clk_div;
 
         /* LP_CLK_DIVISOR */
         REG_FLD_MOD(dsidev, DSI_CLK_CTRL, lp_clk_div, 12, 0);
@@ -1391,286 +1381,33 @@ static int dsi_pll_power(struct platform_device *dsidev,
         return 0;
 }
 
-unsigned long dsi_get_pll_clkin(struct platform_device *dsidev)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        return clk_get_rate(dsi->sys_clk);
-}
-
-bool dsi_hsdiv_calc(struct platform_device *dsidev, unsigned long pll,
-                unsigned long out_min, dsi_hsdiv_calc_func func, void *data)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        int regm, regm_start, regm_stop;
-        unsigned long out_max;
-        unsigned long out;
-
-        out_min = out_min ? out_min : 1;
-        out_max = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
-
-        regm_start = max(DIV_ROUND_UP(pll, out_max), 1ul);
-        regm_stop = min(pll / out_min, dsi->regm_dispc_max);
-
-        for (regm = regm_start; regm <= regm_stop; ++regm) {
-                out = pll / regm;
-
-                if (func(regm, out, data))
-                        return true;
-        }
-
-        return false;
-}
-
-bool dsi_pll_calc(struct platform_device *dsidev, unsigned long clkin,
-                unsigned long pll_min, unsigned long pll_max,
-                dsi_pll_calc_func func, void *data)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        int regn, regn_start, regn_stop;
-        int regm, regm_start, regm_stop;
-        unsigned long fint, pll;
-        const unsigned long pll_hw_max = 1800000000;
-        unsigned long fint_hw_min, fint_hw_max;
-
-        fint_hw_min = dsi->fint_min;
-        fint_hw_max = dsi->fint_max;
 
-        regn_start = max(DIV_ROUND_UP(clkin, fint_hw_max), 1ul);
-        regn_stop = min(clkin / fint_hw_min, dsi->regn_max);
-
-        pll_max = pll_max ? pll_max : ULONG_MAX;
-
-        for (regn = regn_start; regn <= regn_stop; ++regn) {
-                fint = clkin / regn;
-
-                regm_start = max(DIV_ROUND_UP(DIV_ROUND_UP(pll_min, fint), 2),
-                                1ul);
-                regm_stop = min3(pll_max / fint / 2,
-                                pll_hw_max / fint / 2,
-                                dsi->regm_max);
-
-                for (regm = regm_start; regm <= regm_stop; ++regm) {
-                        pll = 2 * regm * fint;
-
-                        if (func(regn, regm, fint, pll, data))
-                                return true;
-                }
-        }
-
-        return false;
-}
-
-/* calculate clock rates using dividers in cinfo */
-static int dsi_calc_clock_rates(struct platform_device *dsidev,
-                struct dsi_clock_info *cinfo)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-
-        if (cinfo->regn == 0 || cinfo->regn > dsi->regn_max)
-                return -EINVAL;
-
-        if (cinfo->regm == 0 || cinfo->regm > dsi->regm_max)
-                return -EINVAL;
-
-        if (cinfo->regm_dispc > dsi->regm_dispc_max)
-                return -EINVAL;
-
-        if (cinfo->regm_dsi > dsi->regm_dsi_max)
-                return -EINVAL;
-
-        cinfo->clkin = clk_get_rate(dsi->sys_clk);
-        cinfo->fint = cinfo->clkin / cinfo->regn;
-
-        if (cinfo->fint > dsi->fint_max || cinfo->fint < dsi->fint_min)
-                return -EINVAL;
-
-        cinfo->clkin4ddr = 2 * cinfo->regm * cinfo->fint;
-
-        if (cinfo->clkin4ddr > 1800 * 1000 * 1000)
-                return -EINVAL;
-
-        if (cinfo->regm_dispc > 0)
-                cinfo->dsi_pll_hsdiv_dispc_clk =
-                        cinfo->clkin4ddr / cinfo->regm_dispc;
-        else
-                cinfo->dsi_pll_hsdiv_dispc_clk = 0;
-
-        if (cinfo->regm_dsi > 0)
-                cinfo->dsi_pll_hsdiv_dsi_clk =
-                        cinfo->clkin4ddr / cinfo->regm_dsi;
-        else
-                cinfo->dsi_pll_hsdiv_dsi_clk = 0;
-
-        return 0;
-}
-
-static void dsi_pll_calc_dsi_fck(struct dsi_clock_info *cinfo)
+static void dsi_pll_calc_dsi_fck(struct dss_pll_clock_info *cinfo)
 {
         unsigned long max_dsi_fck;
 
         max_dsi_fck = dss_feat_get_param_max(FEAT_PARAM_DSI_FCK);
 
-        cinfo->regm_dsi = DIV_ROUND_UP(cinfo->clkin4ddr, max_dsi_fck);
-        cinfo->dsi_pll_hsdiv_dsi_clk = cinfo->clkin4ddr / cinfo->regm_dsi;
+        cinfo->mX[HSDIV_DSI] = DIV_ROUND_UP(cinfo->clkdco, max_dsi_fck);
+        cinfo->clkout[HSDIV_DSI] = cinfo->clkdco / cinfo->mX[HSDIV_DSI];
 }
 
-int dsi_pll_set_clock_div(struct platform_device *dsidev,
-                struct dsi_clock_info *cinfo)
+static int dsi_pll_enable(struct dss_pll *pll)
 {
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct dsi_data *dsi = container_of(pll, struct dsi_data, pll);
+        struct platform_device *dsidev = dsi->pdev;
         int r = 0;
-        u32 l;
-        int f = 0;
-        u8 regn_start, regn_end, regm_start, regm_end;
-        u8 regm_dispc_start, regm_dispc_end, regm_dsi_start, regm_dsi_end;
-
-        DSSDBG("DSI PLL clock config starts");
-
-        dsi->current_cinfo.clkin = cinfo->clkin;
-        dsi->current_cinfo.fint = cinfo->fint;
-        dsi->current_cinfo.clkin4ddr = cinfo->clkin4ddr;
-        dsi->current_cinfo.dsi_pll_hsdiv_dispc_clk =
-                        cinfo->dsi_pll_hsdiv_dispc_clk;
-        dsi->current_cinfo.dsi_pll_hsdiv_dsi_clk =
-                        cinfo->dsi_pll_hsdiv_dsi_clk;
-
-        dsi->current_cinfo.regn = cinfo->regn;
-        dsi->current_cinfo.regm = cinfo->regm;
-        dsi->current_cinfo.regm_dispc = cinfo->regm_dispc;
-        dsi->current_cinfo.regm_dsi = cinfo->regm_dsi;
-
-        DSSDBG("DSI Fint %ld\n", cinfo->fint);
-
-        DSSDBG("clkin rate %ld\n", cinfo->clkin);
-
-        /* DSIPHY == CLKIN4DDR */
-        DSSDBG("CLKIN4DDR = 2 * %d / %d * %lu = %lu\n",
-                        cinfo->regm,
-                        cinfo->regn,
-                        cinfo->clkin,
-                        cinfo->clkin4ddr);
-
-        DSSDBG("Data rate on 1 DSI lane %ld Mbps\n",
-                        cinfo->clkin4ddr / 1000 / 1000 / 2);
-
-        DSSDBG("Clock lane freq %ld Hz\n", cinfo->clkin4ddr / 4);
-
-        DSSDBG("regm_dispc = %d, %s (%s) = %lu\n", cinfo->regm_dispc,
-                dss_get_generic_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC),
-                dss_feat_get_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC),
-                cinfo->dsi_pll_hsdiv_dispc_clk);
-        DSSDBG("regm_dsi = %d, %s (%s) = %lu\n", cinfo->regm_dsi,
-                dss_get_generic_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI),
-                dss_feat_get_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI),
-                cinfo->dsi_pll_hsdiv_dsi_clk);
-
-        dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGN, &regn_start, &regn_end);
-        dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM, &regm_start, &regm_end);
-        dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM_DISPC, &regm_dispc_start,
-                        &regm_dispc_end);
-        dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM_DSI, &regm_dsi_start,
-                        &regm_dsi_end);
-
-        /* DSI_PLL_AUTOMODE = manual */
-        REG_FLD_MOD(dsidev, DSI_PLL_CONTROL, 0, 0, 0);
-
-        l = dsi_read_reg(dsidev, DSI_PLL_CONFIGURATION1);
-        l = FLD_MOD(l, 1, 0, 0);                /* DSI_PLL_STOPMODE */
-        /* DSI_PLL_REGN */
-        l = FLD_MOD(l, cinfo->regn - 1, regn_start, regn_end);
-        /* DSI_PLL_REGM */
-        l = FLD_MOD(l, cinfo->regm, regm_start, regm_end);
-        /* DSI_CLOCK_DIV */
-        l = FLD_MOD(l, cinfo->regm_dispc > 0 ? cinfo->regm_dispc - 1 : 0,
-                        regm_dispc_start, regm_dispc_end);
-        /* DSIPROTO_CLOCK_DIV */
-        l = FLD_MOD(l, cinfo->regm_dsi > 0 ? cinfo->regm_dsi - 1 : 0,
-                        regm_dsi_start, regm_dsi_end);
-        dsi_write_reg(dsidev, DSI_PLL_CONFIGURATION1, l);
-
-        BUG_ON(cinfo->fint < dsi->fint_min || cinfo->fint > dsi->fint_max);
-
-        l = dsi_read_reg(dsidev, DSI_PLL_CONFIGURATION2);
-
-        if (dss_has_feature(FEAT_DSI_PLL_FREQSEL)) {
-                f = cinfo->fint < 1000000 ? 0x3 :
-                        cinfo->fint < 1250000 ? 0x4 :
-                        cinfo->fint < 1500000 ? 0x5 :
-                        cinfo->fint < 1750000 ? 0x6 :
-                        0x7;
-
-                l = FLD_MOD(l, f, 4, 1);        /* DSI_PLL_FREQSEL */
-        } else if (dss_has_feature(FEAT_DSI_PLL_SELFREQDCO)) {
-                f = cinfo->clkin4ddr < 1000000000 ? 0x2 : 0x4;
-
-                l = FLD_MOD(l, f, 3, 1);        /* PLL_SELFREQDCO */
-        }
-
-        l = FLD_MOD(l, 1, 13, 13);              /* DSI_PLL_REFEN */
-        l = FLD_MOD(l, 0, 14, 14);              /* DSIPHY_CLKINEN */
-        l = FLD_MOD(l, 1, 20, 20);              /* DSI_HSDIVBYPASS */
-        if (dss_has_feature(FEAT_DSI_PLL_REFSEL))
-                l = FLD_MOD(l, 3, 22, 21);      /* REF_SYSCLK = sysclk */
-        dsi_write_reg(dsidev, DSI_PLL_CONFIGURATION2, l);
-
-        REG_FLD_MOD(dsidev, DSI_PLL_GO, 1, 0, 0);       /* DSI_PLL_GO */
-
-        if (wait_for_bit_change(dsidev, DSI_PLL_GO, 0, 0) != 0) {
-                DSSERR("dsi pll go bit not going down.\n");
-                r = -EIO;
-                goto err;
-        }
-
-        if (wait_for_bit_change(dsidev, DSI_PLL_STATUS, 1, 1) != 1) {
-                DSSERR("cannot lock PLL\n");
-                r = -EIO;
-                goto err;
-        }
-
-        dsi->pll_locked = 1;
-
-        l = dsi_read_reg(dsidev, DSI_PLL_CONFIGURATION2);
-        l = FLD_MOD(l, 0, 0, 0);        /* DSI_PLL_IDLE */
-        l = FLD_MOD(l, 0, 5, 5);        /* DSI_PLL_PLLLPMODE */
-        l = FLD_MOD(l, 0, 6, 6);        /* DSI_PLL_LOWCURRSTBY */
-        l = FLD_MOD(l, 0, 7, 7);        /* DSI_PLL_TIGHTPHASELOCK */
-        l = FLD_MOD(l, 0, 8, 8);        /* DSI_PLL_DRIFTGUARDEN */
-        l = FLD_MOD(l, 0, 10, 9);       /* DSI_PLL_LOCKSEL */
-        l = FLD_MOD(l, 1, 13, 13);      /* DSI_PLL_REFEN */
-        l = FLD_MOD(l, 1, 14, 14);      /* DSIPHY_CLKINEN */
-        l = FLD_MOD(l, 0, 15, 15);      /* DSI_BYPASSEN */
-        l = FLD_MOD(l, 1, 16, 16);      /* DSS_CLOCK_EN */
-        l = FLD_MOD(l, 0, 17, 17);      /* DSS_CLOCK_PWDN */
-        l = FLD_MOD(l, 1, 18, 18);      /* DSI_PROTO_CLOCK_EN */
-        l = FLD_MOD(l, 0, 19, 19);      /* DSI_PROTO_CLOCK_PWDN */
-        l = FLD_MOD(l, 0, 20, 20);      /* DSI_HSDIVBYPASS */
-        dsi_write_reg(dsidev, DSI_PLL_CONFIGURATION2, l);
-
-        DSSDBG("PLL config done\n");
-err:
-        return r;
-}
-
-int dsi_pll_init(struct platform_device *dsidev, bool enable_hsclk,
-                bool enable_hsdiv)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        int r = 0;
-        enum dsi_pll_power_state pwstate;
 
         DSSDBG("PLL init\n");
 
-        /*
-         * It seems that on many OMAPs we need to enable both to have a
-         * functional HSDivider.
-         */
-        enable_hsclk = enable_hsdiv = true;
-
         r = dsi_regulator_init(dsidev);
         if (r)
                 return r;
 
-        dsi_enable_pll_clock(dsidev, 1);
+        r = dsi_runtime_get(dsidev);
+        if (r)
+                return r;
+
         /*
          * Note: SCP CLK is not required on OMAP3, but it is required on OMAP4.
          */
@@ -1697,16 +1434,7 @@ int dsi_pll_init(struct platform_device *dsidev, bool enable_hsclk,
          * fill the whole display. No idea about this */
         dispc_pck_free_enable(0);
 
-        if (enable_hsclk && enable_hsdiv)
-                pwstate = DSI_PLL_POWER_ON_ALL;
-        else if (enable_hsclk)
-                pwstate = DSI_PLL_POWER_ON_HSCLK;
-        else if (enable_hsdiv)
-                pwstate = DSI_PLL_POWER_ON_DIV;
-        else
-                pwstate = DSI_PLL_POWER_OFF;
-
-        r = dsi_pll_power(dsidev, pwstate);
+        r = dsi_pll_power(dsidev, DSI_PLL_POWER_ON_ALL);
 
         if (r)
                 goto err1;
@@ -1721,15 +1449,14 @@ err1:
         }
 err0:
         dsi_disable_scp_clk(dsidev);
-        dsi_enable_pll_clock(dsidev, 0);
+        dsi_runtime_put(dsidev);
         return r;
 }
 
-void dsi_pll_uninit(struct platform_device *dsidev, bool disconnect_lanes)
+static void dsi_pll_uninit(struct platform_device *dsidev, bool disconnect_lanes)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
-        dsi->pll_locked = 0;
         dsi_pll_power(dsidev, DSI_PLL_POWER_OFF);
         if (disconnect_lanes) {
                 WARN_ON(!dsi->vdds_dsi_enabled);
@@ -1738,18 +1465,27 @@ void dsi_pll_uninit(struct platform_device *dsidev, bool disconnect_lanes)
         }
 
         dsi_disable_scp_clk(dsidev);
-        dsi_enable_pll_clock(dsidev, 0);
+        dsi_runtime_put(dsidev);
 
         DSSDBG("PLL uninit done\n");
 }
 
+static void dsi_pll_disable(struct dss_pll *pll)
+{
+        struct dsi_data *dsi = container_of(pll, struct dsi_data, pll);
+        struct platform_device *dsidev = dsi->pdev;
+
+        dsi_pll_uninit(dsidev, true);
+}
+
 static void dsi_dump_dsidev_clocks(struct platform_device *dsidev,
                 struct seq_file *s)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct dsi_clock_info *cinfo = &dsi->current_cinfo;
+        struct dss_pll_clock_info *cinfo = &dsi->pll.cinfo;
         enum omap_dss_clk_source dispc_clk_src, dsi_clk_src;
         int dsi_module = dsi->module_id;
+        struct dss_pll *pll = &dsi->pll;
 
         dispc_clk_src = dss_get_dispc_clk_source();
         dsi_clk_src = dss_get_dsi_clk_source(dsi_module);
@@ -1759,28 +1495,28 @@ static void dsi_dump_dsidev_clocks(struct platform_device *dsidev,
 
         seq_printf(s,   "- DSI%d PLL -\n", dsi_module + 1);
 
-        seq_printf(s,   "dsi pll clkin\t%lu\n", cinfo->clkin);
+        seq_printf(s,   "dsi pll clkin\t%lu\n", clk_get_rate(pll->clkin));
 
-        seq_printf(s,   "Fint\t\t%-16luregn %u\n", cinfo->fint, cinfo->regn);
+        seq_printf(s,   "Fint\t\t%-16lun %u\n", cinfo->fint, cinfo->n);
 
-        seq_printf(s,   "CLKIN4DDR\t%-16luregm %u\n",
-                        cinfo->clkin4ddr, cinfo->regm);
+        seq_printf(s,   "CLKIN4DDR\t%-16lum %u\n",
+                        cinfo->clkdco, cinfo->m);
 
-        seq_printf(s,   "DSI_PLL_HSDIV_DISPC (%s)\t%-16luregm_dispc %u\t(%s)\n",
+        seq_printf(s,   "DSI_PLL_HSDIV_DISPC (%s)\t%-16lum_dispc %u\t(%s)\n",
                         dss_feat_get_clk_source_name(dsi_module == 0 ?
                                 OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC :
                                 OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC),
-                        cinfo->dsi_pll_hsdiv_dispc_clk,
-                        cinfo->regm_dispc,
+                        cinfo->clkout[HSDIV_DISPC],
+                        cinfo->mX[HSDIV_DISPC],
                         dispc_clk_src == OMAP_DSS_CLK_SRC_FCK ?
                         "off" : "on");
 
-        seq_printf(s,   "DSI_PLL_HSDIV_DSI (%s)\t%-16luregm_dsi %u\t(%s)\n",
+        seq_printf(s,   "DSI_PLL_HSDIV_DSI (%s)\t%-16lum_dsi %u\t(%s)\n",
                         dss_feat_get_clk_source_name(dsi_module == 0 ?
                                 OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI :
                                 OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DSI),
-                        cinfo->dsi_pll_hsdiv_dsi_clk,
-                        cinfo->regm_dsi,
+                        cinfo->clkout[HSDIV_DSI],
+                        cinfo->mX[HSDIV_DSI],
                         dsi_clk_src == OMAP_DSS_CLK_SRC_FCK ?
                         "off" : "on");
 
@@ -1793,11 +1529,11 @@ static void dsi_dump_dsidev_clocks(struct platform_device *dsidev,
         seq_printf(s,   "DSI_FCLK\t%lu\n", dsi_fclk_rate(dsidev));
 
         seq_printf(s,   "DDR_CLK\t\t%lu\n",
-                        cinfo->clkin4ddr / 4);
+                        cinfo->clkdco / 4);
 
         seq_printf(s,   "TxByteClkHS\t%lu\n", dsi_get_txbyteclkhs(dsidev));
 
-        seq_printf(s,   "LP_CLK\t\t%lu\n", cinfo->lp_clk);
+        seq_printf(s,   "LP_CLK\t\t%lu\n", dsi->current_lp_cinfo.lp_clk);
 
         dsi_runtime_put(dsidev);
 }
@@ -2132,7 +1868,7 @@ static inline unsigned ns2ddr(struct platform_device *dsidev, unsigned ns)
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
         /* convert time in ns to ddr ticks, rounding up */
-        unsigned long ddr_clk = dsi->current_cinfo.clkin4ddr / 4;
+        unsigned long ddr_clk = dsi->pll.cinfo.clkdco / 4;
         return (ns * (ddr_clk / 1000 / 1000) + 999) / 1000;
 }
 
@@ -2140,7 +1876,7 @@ static inline unsigned ddr2ns(struct platform_device *dsidev, unsigned ddr)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
-        unsigned long ddr_clk = dsi->current_cinfo.clkin4ddr / 4;
+        unsigned long ddr_clk = dsi->pll.cinfo.clkdco / 4;
         return ddr * 1000 * 1000 / (ddr_clk / 1000);
 }
 
@@ -3730,7 +3466,7 @@ static void dsi_config_cmd_mode_interleaving(struct platform_device *dsidev)
         struct omap_video_timings *timings = &dsi->timings;
         int bpp = dsi_get_pixel_size(dsi->pix_fmt);
         int ndl = dsi->num_lanes_used - 1;
-        int dsi_fclk_hsdiv = dsi->user_dsi_cinfo.regm_dsi + 1;
+        int dsi_fclk_hsdiv = dsi->user_dsi_cinfo.mX[HSDIV_DSI] + 1;
         int hsa_interleave_hs = 0, hsa_interleave_lp = 0;
         int hfp_interleave_hs = 0, hfp_interleave_lp = 0;
         int hbp_interleave_hs = 0, hbp_interleave_lp = 0;
@@ -4441,18 +4177,12 @@ static void dsi_display_uninit_dispc(struct platform_device *dsidev,
 static int dsi_configure_dsi_clocks(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-        struct dsi_clock_info cinfo;
+        struct dss_pll_clock_info cinfo;
         int r;
 
         cinfo = dsi->user_dsi_cinfo;
 
-        r = dsi_calc_clock_rates(dsidev, &cinfo);
-        if (r) {
-                DSSERR("Failed to calc dsi clocks\n");
-                return r;
-        }
-
-        r = dsi_pll_set_clock_div(dsidev, &cinfo);
+        r = dss_pll_set_config(&dsi->pll, &cinfo);
         if (r) {
                 DSSERR("Failed to set dsi clocks\n");
                 return r;
@@ -4466,7 +4196,7 @@ static int dsi_display_init_dsi(struct platform_device *dsidev)
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
         int r;
 
-        r = dsi_pll_init(dsidev, true, true);
+        r = dss_pll_enable(&dsi->pll);
         if (r)
                 goto err0;
 
@@ -4510,7 +4240,7 @@ err3:
 err2:
         dss_select_dsi_clk_source(dsi->module_id, OMAP_DSS_CLK_SRC_FCK);
 err1:
-        dsi_pll_uninit(dsidev, true);
+        dss_pll_disable(&dsi->pll);
 err0:
         return r;
 }
@@ -4551,8 +4281,6 @@ static int dsi_display_enable(struct omap_dss_device *dssdev)
         if (r)
                 goto err_get_dsi;
 
-        dsi_enable_pll_clock(dsidev, 1);
-
         _dsi_initialize_irq(dsidev);
 
         r = dsi_display_init_dsi(dsidev);
@@ -4564,7 +4292,6 @@ static int dsi_display_enable(struct omap_dss_device *dssdev)
         return 0;
 
 err_init_dsi:
-        dsi_enable_pll_clock(dsidev, 0);
         dsi_runtime_put(dsidev);
 err_get_dsi:
         mutex_unlock(&dsi->lock);
@@ -4592,7 +4319,6 @@ static void dsi_display_disable(struct omap_dss_device *dssdev,
         dsi_display_uninit_dsi(dsidev, disconnect_lanes, enter_ulps);
 
         dsi_runtime_put(dsidev);
-        dsi_enable_pll_clock(dsidev, 0);
 
         mutex_unlock(&dsi->lock);
 }
@@ -4713,29 +4439,30 @@ static bool dsi_cm_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
         return true;
 }
 
-static bool dsi_cm_calc_hsdiv_cb(int regm_dispc, unsigned long dispc,
+static bool dsi_cm_calc_hsdiv_cb(int m_dispc, unsigned long dispc,
                 void *data)
 {
         struct dsi_clk_calc_ctx *ctx = data;
 
-        ctx->dsi_cinfo.regm_dispc = regm_dispc;
-        ctx->dsi_cinfo.dsi_pll_hsdiv_dispc_clk = dispc;
+        ctx->dsi_cinfo.mX[HSDIV_DISPC] = m_dispc;
+        ctx->dsi_cinfo.clkout[HSDIV_DISPC] = dispc;
 
         return dispc_div_calc(dispc, ctx->req_pck_min, ctx->req_pck_max,
                         dsi_cm_calc_dispc_cb, ctx);
 }
 
-static bool dsi_cm_calc_pll_cb(int regn, int regm, unsigned long fint,
-                unsigned long pll, void *data)
+static bool dsi_cm_calc_pll_cb(int n, int m, unsigned long fint,
+                unsigned long clkdco, void *data)
 {
         struct dsi_clk_calc_ctx *ctx = data;
 
-        ctx->dsi_cinfo.regn = regn;
-        ctx->dsi_cinfo.regm = regm;
+        ctx->dsi_cinfo.n = n;
+        ctx->dsi_cinfo.m = m;
         ctx->dsi_cinfo.fint = fint;
-        ctx->dsi_cinfo.clkin4ddr = pll;
+        ctx->dsi_cinfo.clkdco = clkdco;
 
-        return dsi_hsdiv_calc(ctx->dsidev, pll, ctx->req_pck_min,
+        return dss_pll_hsdiv_calc(ctx->pll, clkdco, ctx->req_pck_min,
+                        dss_feat_get_param_max(FEAT_PARAM_DSS_FCK),
                         dsi_cm_calc_hsdiv_cb, ctx);
 }
 
@@ -4748,7 +4475,7 @@ static bool dsi_cm_calc(struct dsi_data *dsi,
         unsigned long pll_min, pll_max;
         unsigned long pck, txbyteclk;
 
-        clkin = clk_get_rate(dsi->sys_clk);
+        clkin = clk_get_rate(dsi->pll.clkin);
         bitspp = dsi_get_pixel_size(cfg->pixel_format);
         ndl = dsi->num_lanes_used - 1;
 
@@ -4764,16 +4491,16 @@ static bool dsi_cm_calc(struct dsi_data *dsi,
 
         memset(ctx, 0, sizeof(*ctx));
         ctx->dsidev = dsi->pdev;
+        ctx->pll = &dsi->pll;
         ctx->config = cfg;
         ctx->req_pck_min = pck;
         ctx->req_pck_nom = pck;
         ctx->req_pck_max = pck * 3 / 2;
-        ctx->dsi_cinfo.clkin = clkin;
 
         pll_min = max(cfg->hs_clk_min * 4, txbyteclk * 4 * 4);
         pll_max = cfg->hs_clk_max * 4;
 
-        return dsi_pll_calc(dsi->pdev, clkin,
+        return dss_pll_calc(ctx->pll, clkin,
                         pll_min, pll_max,
                         dsi_cm_calc_pll_cb, ctx);
 }
@@ -4784,7 +4511,7 @@ static bool dsi_vm_calc_blanking(struct dsi_clk_calc_ctx *ctx)
         const struct omap_dss_dsi_config *cfg = ctx->config;
         int bitspp = dsi_get_pixel_size(cfg->pixel_format);
         int ndl = dsi->num_lanes_used - 1;
-        unsigned long hsclk = ctx->dsi_cinfo.clkin4ddr / 4;
+        unsigned long hsclk = ctx->dsi_cinfo.clkdco / 4;
         unsigned long byteclk = hsclk / 4;
 
         unsigned long dispc_pck, req_pck_min, req_pck_nom, req_pck_max;
@@ -4999,14 +4726,14 @@ static bool dsi_vm_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
         return true;
 }
 
-static bool dsi_vm_calc_hsdiv_cb(int regm_dispc, unsigned long dispc,
+static bool dsi_vm_calc_hsdiv_cb(int m_dispc, unsigned long dispc,
                 void *data)
 {
         struct dsi_clk_calc_ctx *ctx = data;
         unsigned long pck_max;
 
-        ctx->dsi_cinfo.regm_dispc = regm_dispc;
-        ctx->dsi_cinfo.dsi_pll_hsdiv_dispc_clk = dispc;
+        ctx->dsi_cinfo.mX[HSDIV_DISPC] = m_dispc;
+        ctx->dsi_cinfo.clkout[HSDIV_DISPC] = dispc;
 
         /*
          * In burst mode we can let the dispc pck be arbitrarily high, but it
@@ -5022,17 +4749,18 @@ static bool dsi_vm_calc_hsdiv_cb(int regm_dispc, unsigned long dispc,
                         dsi_vm_calc_dispc_cb, ctx);
 }
 
-static bool dsi_vm_calc_pll_cb(int regn, int regm, unsigned long fint,
-                unsigned long pll, void *data)
+static bool dsi_vm_calc_pll_cb(int n, int m, unsigned long fint,
+                unsigned long clkdco, void *data)
 {
         struct dsi_clk_calc_ctx *ctx = data;
 
-        ctx->dsi_cinfo.regn = regn;
-        ctx->dsi_cinfo.regm = regm;
+        ctx->dsi_cinfo.n = n;
+        ctx->dsi_cinfo.m = m;
         ctx->dsi_cinfo.fint = fint;
-        ctx->dsi_cinfo.clkin4ddr = pll;
+        ctx->dsi_cinfo.clkdco = clkdco;
 
-        return dsi_hsdiv_calc(ctx->dsidev, pll, ctx->req_pck_min,
+        return dss_pll_hsdiv_calc(ctx->pll, clkdco, ctx->req_pck_min,
+                        dss_feat_get_param_max(FEAT_PARAM_DSS_FCK),
                         dsi_vm_calc_hsdiv_cb, ctx);
 }
 
@@ -5048,14 +4776,13 @@ static bool dsi_vm_calc(struct dsi_data *dsi,
         int bitspp = dsi_get_pixel_size(cfg->pixel_format);
         unsigned long byteclk_min;
 
-        clkin = clk_get_rate(dsi->sys_clk);
+        clkin = clk_get_rate(dsi->pll.clkin);
 
         memset(ctx, 0, sizeof(*ctx));
         ctx->dsidev = dsi->pdev;
+        ctx->pll = &dsi->pll;
         ctx->config = cfg;
 
-        ctx->dsi_cinfo.clkin = clkin;
-
         /* these limits should come from the panel driver */
         ctx->req_pck_min = t->pixelclock - 1000;
         ctx->req_pck_nom = t->pixelclock;
@@ -5074,7 +4801,7 @@ static bool dsi_vm_calc(struct dsi_data *dsi,
                 pll_max = byteclk_max * 4 * 4;
         }
 
-        return dsi_pll_calc(dsi->pdev, clkin,
+        return dss_pll_calc(ctx->pll, clkin,
                         pll_min, pll_max,
                         dsi_vm_calc_pll_cb, ctx);
 }
@@ -5106,8 +4833,8 @@ static int dsi_set_config(struct omap_dss_device *dssdev,
 
         dsi_pll_calc_dsi_fck(&ctx.dsi_cinfo);
 
-        r = dsi_lp_clock_calc(&ctx.dsi_cinfo, config->lp_clk_min,
-                        config->lp_clk_max);
+        r = dsi_lp_clock_calc(ctx.dsi_cinfo.clkout[HSDIV_DSI],
+                config->lp_clk_min, config->lp_clk_max, &dsi->user_lp_cinfo);
         if (r) {
                 DSSERR("failed to find suitable DSI LP clock settings\n");
                 goto err;
@@ -5234,35 +4961,6 @@ static void dsi_release_vc(struct omap_dss_device *dssdev, int channel)
         }
 }
 
-void dsi_wait_pll_hsdiv_dispc_active(struct platform_device *dsidev)
-{
-        if (wait_for_bit_change(dsidev, DSI_PLL_STATUS, 7, 1) != 1)
-                DSSERR("%s (%s) not active\n",
-                        dss_get_generic_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC),
-                        dss_feat_get_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC));
-}
-
-void dsi_wait_pll_hsdiv_dsi_active(struct platform_device *dsidev)
-{
-        if (wait_for_bit_change(dsidev, DSI_PLL_STATUS, 8, 1) != 1)
-                DSSERR("%s (%s) not active\n",
-                        dss_get_generic_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI),
-                        dss_feat_get_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI));
-}
-
-static void dsi_calc_clock_param_ranges(struct platform_device *dsidev)
-{
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
-
-        dsi->regn_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_REGN);
-        dsi->regm_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_REGM);
-        dsi->regm_dispc_max =
-                dss_feat_get_param_max(FEAT_PARAM_DSIPLL_REGM_DISPC);
-        dsi->regm_dsi_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_REGM_DSI);
-        dsi->fint_min = dss_feat_get_param_min(FEAT_PARAM_DSIPLL_FINT);
-        dsi->fint_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_FINT);
-        dsi->lpdiv_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_LPDIV);
-}
 
 static int dsi_get_clocks(struct platform_device *dsidev)
 {
@@ -5277,14 +4975,6 @@ static int dsi_get_clocks(struct platform_device *dsidev)
 
         dsi->dss_clk = clk;
 
-        clk = devm_clk_get(&dsidev->dev, "sys_clk");
-        if (IS_ERR(clk)) {
-                DSSERR("can't get sys_clk\n");
-                return PTR_ERR(clk);
-        }
-
-        dsi->sys_clk = clk;
-
         return 0;
 }
 
@@ -5453,6 +5143,135 @@ err:
         return r;
 }
 
+static const struct dss_pll_ops dsi_pll_ops = {
+        .enable = dsi_pll_enable,
+        .disable = dsi_pll_disable,
+        .set_config = dss_pll_write_config_type_a,
+};
+
+static const struct dss_pll_hw dss_omap3_dsi_pll_hw = {
+        .n_max = (1 << 7) - 1,
+        .m_max = (1 << 11) - 1,
+        .mX_max = (1 << 4) - 1,
+        .fint_min = 750000,
+        .fint_max = 2100000,
+        .clkdco_low = 1000000000,
+        .clkdco_max = 1800000000,
+
+        .n_msb = 7,
+        .n_lsb = 1,
+        .m_msb = 18,
+        .m_lsb = 8,
+
+        .mX_msb[0] = 22,
+        .mX_lsb[0] = 19,
+        .mX_msb[1] = 26,
+        .mX_lsb[1] = 23,
+
+        .has_stopmode = true,
+        .has_freqsel = true,
+        .has_selfreqdco = false,
+        .has_refsel = false,
+};
+
+static const struct dss_pll_hw dss_omap4_dsi_pll_hw = {
+        .n_max = (1 << 8) - 1,
+        .m_max = (1 << 12) - 1,
+        .mX_max = (1 << 5) - 1,
+        .fint_min = 500000,
+        .fint_max = 2500000,
+        .clkdco_low = 1000000000,
+        .clkdco_max = 1800000000,
+
+        .n_msb = 8,
+        .n_lsb = 1,
+        .m_msb = 20,
+        .m_lsb = 9,
+
+        .mX_msb[0] = 25,
+        .mX_lsb[0] = 21,
+        .mX_msb[1] = 30,
+        .mX_lsb[1] = 26,
+
+        .has_stopmode = true,
+        .has_freqsel = false,
+        .has_selfreqdco = false,
+        .has_refsel = false,
+};
+
+static const struct dss_pll_hw dss_omap5_dsi_pll_hw = {
+        .n_max = (1 << 8) - 1,
+        .m_max = (1 << 12) - 1,
+        .mX_max = (1 << 5) - 1,
+        .fint_min = 150000,
+        .fint_max = 52000000,
+        .clkdco_low = 1000000000,
+        .clkdco_max = 1800000000,
+
+        .n_msb = 8,
+        .n_lsb = 1,
+        .m_msb = 20,
+        .m_lsb = 9,
+
+        .mX_msb[0] = 25,
+        .mX_lsb[0] = 21,
+        .mX_msb[1] = 30,
+        .mX_lsb[1] = 26,
+
+        .has_stopmode = true,
+        .has_freqsel = false,
+        .has_selfreqdco = true,
+        .has_refsel = true,
+};
+
+static int dsi_init_pll_data(struct platform_device *dsidev)
+{
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct dss_pll *pll = &dsi->pll;
+        struct clk *clk;
+        int r;
+
+        clk = devm_clk_get(&dsidev->dev, "sys_clk");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get sys_clk\n");
+                return PTR_ERR(clk);
+        }
+
+        pll->name = dsi->module_id == 0 ? "dsi0" : "dsi1";
+        pll->clkin = clk;
+        pll->base = dsi->pll_base;
+
+        switch (omapdss_get_version()) {
+        case OMAPDSS_VER_OMAP34xx_ES1:
+        case OMAPDSS_VER_OMAP34xx_ES3:
+        case OMAPDSS_VER_OMAP3630:
+        case OMAPDSS_VER_AM35xx:
+                pll->hw = &dss_omap3_dsi_pll_hw;
+                break;
+
+        case OMAPDSS_VER_OMAP4430_ES1:
+        case OMAPDSS_VER_OMAP4430_ES2:
+        case OMAPDSS_VER_OMAP4:
+                pll->hw = &dss_omap4_dsi_pll_hw;
+                break;
+
+        case OMAPDSS_VER_OMAP5:
+                pll->hw = &dss_omap5_dsi_pll_hw;
+                break;
+
+        default:
+                return -ENODEV;
+        }
+
+        pll->ops = &dsi_pll_ops;
+
+        r = dss_pll_register(pll);
+        if (r)
+                return r;
+
+        return 0;
+}
+
 /* DSI1 HW IP initialisation */
 static int omap_dsihw_probe(struct platform_device *dsidev)
 {
@@ -5598,12 +5417,12 @@ static int omap_dsihw_probe(struct platform_device *dsidev)
                 dsi->vc[i].vc_id = 0;
         }
 
-        dsi_calc_clock_param_ranges(dsidev);
-
         r = dsi_get_clocks(dsidev);
         if (r)
                 return r;
 
+        dsi_init_pll_data(dsidev);
+
         pm_runtime_enable(&dsidev->dev);
 
         r = dsi_runtime_get(dsidev);
@@ -5672,6 +5491,8 @@ static int __exit omap_dsihw_remove(struct platform_device *dsidev)
 
         WARN_ON(dsi->scp_clk_refcount > 0);
 
+        dss_pll_unregister(&dsi->pll);
+
         dsi_uninit_output(dsidev);
 
         pm_runtime_disable(&dsidev->dev);
diff --git a/drivers/video/fbdev/omap2/dss/dss-of.c b/drivers/video/fbdev/omap2/dss/dss-of.c
index a4b20aaf6142..928ee639c0c1 100644
--- a/drivers/video/fbdev/omap2/dss/dss-of.c
+++ b/drivers/video/fbdev/omap2/dss/dss-of.c
@@ -20,6 +20,8 @@
 
 #include <video/omapdss.h>
 
+#include "dss.h"
+
 struct device_node *
 omapdss_of_get_next_port(const struct device_node *parent,
                          struct device_node *prev)
@@ -84,20 +86,17 @@ omapdss_of_get_next_endpoint(const struct device_node *parent,
 }
 EXPORT_SYMBOL_GPL(omapdss_of_get_next_endpoint);
 
-static struct device_node *
-omapdss_of_get_remote_device_node(const struct device_node *node)
+struct device_node *dss_of_port_get_parent_device(struct device_node *port)
 {
         struct device_node *np;
         int i;
 
-        np = of_parse_phandle(node, "remote-endpoint", 0);
-
-        if (!np)
+        if (!port)
                 return NULL;
 
-        np = of_get_next_parent(np);
+        np = of_get_next_parent(port);
 
-        for (i = 0; i < 3 && np; ++i) {
+        for (i = 0; i < 2 && np; ++i) {
                 struct property *prop;
 
                 prop = of_find_property(np, "compatible", NULL);
@@ -111,6 +110,31 @@ omapdss_of_get_remote_device_node(const struct device_node *node)
         return NULL;
 }
 
+u32 dss_of_port_get_port_number(struct device_node *port)
+{
+        int r;
+        u32 reg;
+
+        r = of_property_read_u32(port, "reg", &reg);
+        if (r)
+                reg = 0;
+
+        return reg;
+}
+
+static struct device_node *omapdss_of_get_remote_port(const struct device_node *node)
+{
+        struct device_node *np;
+
+        np = of_parse_phandle(node, "remote-endpoint", 0);
+        if (!np)
+                return NULL;
+
+        np = of_get_next_parent(np);
+
+        return np;
+}
+
 struct device_node *
 omapdss_of_get_first_endpoint(const struct device_node *parent)
 {
@@ -133,27 +157,25 @@ struct omap_dss_device *
 omapdss_of_find_source_for_first_ep(struct device_node *node)
 {
         struct device_node *ep;
-        struct device_node *src_node;
+        struct device_node *src_port;
         struct omap_dss_device *src;
 
         ep = omapdss_of_get_first_endpoint(node);
         if (!ep)
                 return ERR_PTR(-EINVAL);
 
-        src_node = omapdss_of_get_remote_device_node(ep);
-
-        of_node_put(ep);
-
-        if (!src_node)
+        src_port = omapdss_of_get_remote_port(ep);
+        if (!src_port) {
+                of_node_put(ep);
                 return ERR_PTR(-EINVAL);
+        }
 
-        src = omap_dss_find_output_by_node(src_node);
+        of_node_put(ep);
 
-        of_node_put(src_node);
+        src = omap_dss_find_output_by_port_node(src_port);
 
-        if (!src)
-                return ERR_PTR(-EPROBE_DEFER);
+        of_node_put(src_port);
 
-        return src;
+        return src ? src : ERR_PTR(-EPROBE_DEFER);
 }
 EXPORT_SYMBOL_GPL(omapdss_of_find_source_for_first_ep);
diff --git a/drivers/video/fbdev/omap2/dss/dss.c b/drivers/video/fbdev/omap2/dss/dss.c
index 14bcd6c43f72..702c495083ed 100644
--- a/drivers/video/fbdev/omap2/dss/dss.c
+++ b/drivers/video/fbdev/omap2/dss/dss.c
@@ -70,7 +70,9 @@ struct dss_features {
         u8 fck_div_max;
         u8 dss_fck_multiplier;
         const char *parent_clk_name;
-        int (*dpi_select_source)(enum omap_channel channel);
+        enum omap_display_type *ports;
+        int num_ports;
+        int (*dpi_select_source)(int port, enum omap_channel channel);
 };
 
 static struct {
@@ -294,7 +296,6 @@ static void dss_dump_regs(struct seq_file *s)
 
 static void dss_select_dispc_clk_source(enum omap_dss_clk_source clk_src)
 {
-        struct platform_device *dsidev;
         int b;
         u8 start, end;
 
@@ -304,13 +305,9 @@ static void dss_select_dispc_clk_source(enum omap_dss_clk_source clk_src)
                 break;
         case OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
                 b = 1;
-                dsidev = dsi_get_dsidev_from_id(0);
-                dsi_wait_pll_hsdiv_dispc_active(dsidev);
                 break;
         case OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC:
                 b = 2;
-                dsidev = dsi_get_dsidev_from_id(1);
-                dsi_wait_pll_hsdiv_dispc_active(dsidev);
                 break;
         default:
                 BUG();
@@ -327,7 +324,6 @@ static void dss_select_dispc_clk_source(enum omap_dss_clk_source clk_src)
 void dss_select_dsi_clk_source(int dsi_module,
                 enum omap_dss_clk_source clk_src)
 {
-        struct platform_device *dsidev;
         int b, pos;
 
         switch (clk_src) {
@@ -337,14 +333,10 @@ void dss_select_dsi_clk_source(int dsi_module,
         case OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI:
                 BUG_ON(dsi_module != 0);
                 b = 1;
-                dsidev = dsi_get_dsidev_from_id(0);
-                dsi_wait_pll_hsdiv_dsi_active(dsidev);
                 break;
         case OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DSI:
                 BUG_ON(dsi_module != 1);
                 b = 1;
-                dsidev = dsi_get_dsidev_from_id(1);
-                dsi_wait_pll_hsdiv_dsi_active(dsidev);
                 break;
         default:
                 BUG();
@@ -360,7 +352,6 @@ void dss_select_dsi_clk_source(int dsi_module,
 void dss_select_lcd_clk_source(enum omap_channel channel,
                 enum omap_dss_clk_source clk_src)
 {
-        struct platform_device *dsidev;
         int b, ix, pos;
 
         if (!dss_has_feature(FEAT_LCD_CLK_SRC)) {
@@ -375,15 +366,11 @@ void dss_select_lcd_clk_source(enum omap_channel channel,
         case OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
                 BUG_ON(channel != OMAP_DSS_CHANNEL_LCD);
                 b = 1;
-                dsidev = dsi_get_dsidev_from_id(0);
-                dsi_wait_pll_hsdiv_dispc_active(dsidev);
                 break;
         case OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC:
                 BUG_ON(channel != OMAP_DSS_CHANNEL_LCD2 &&
                        channel != OMAP_DSS_CHANNEL_LCD3);
                 b = 1;
-                dsidev = dsi_get_dsidev_from_id(1);
-                dsi_wait_pll_hsdiv_dispc_active(dsidev);
                 break;
         default:
                 BUG();
@@ -564,7 +551,7 @@ enum dss_hdmi_venc_clk_source_select dss_get_hdmi_venc_clk_source(void)
         return REG_GET(DSS_CONTROL, 15, 15);
 }
 
-static int dss_dpi_select_source_omap2_omap3(enum omap_channel channel)
+static int dss_dpi_select_source_omap2_omap3(int port, enum omap_channel channel)
 {
         if (channel != OMAP_DSS_CHANNEL_LCD)
                 return -EINVAL;
@@ -572,7 +559,7 @@ static int dss_dpi_select_source_omap2_omap3(enum omap_channel channel)
         return 0;
 }
 
-static int dss_dpi_select_source_omap4(enum omap_channel channel)
+static int dss_dpi_select_source_omap4(int port, enum omap_channel channel)
 {
         int val;
 
@@ -592,7 +579,7 @@ static int dss_dpi_select_source_omap4(enum omap_channel channel)
         return 0;
 }
 
-static int dss_dpi_select_source_omap5(enum omap_channel channel)
+static int dss_dpi_select_source_omap5(int port, enum omap_channel channel)
 {
         int val;
 
@@ -618,9 +605,9 @@ static int dss_dpi_select_source_omap5(enum omap_channel channel)
         return 0;
 }
 
-int dss_dpi_select_source(enum omap_channel channel)
+int dss_dpi_select_source(int port, enum omap_channel channel)
 {
-        return dss.feat->dpi_select_source(channel);
+        return dss.feat->dpi_select_source(port, channel);
 }
 
 static int dss_get_clocks(void)
@@ -689,6 +676,16 @@ void dss_debug_dump_clocks(struct seq_file *s)
 }
 #endif
 
+
+static enum omap_display_type omap2plus_ports[] = {
+        OMAP_DISPLAY_TYPE_DPI,
+};
+
+static enum omap_display_type omap34xx_ports[] = {
+        OMAP_DISPLAY_TYPE_DPI,
+        OMAP_DISPLAY_TYPE_SDI,
+};
+
 static const struct dss_features omap24xx_dss_feats __initconst = {
         /*
          * fck div max is really 16, but the divider range has gaps. The range
@@ -698,6 +695,8 @@ static const struct dss_features omap24xx_dss_feats __initconst = {
         .dss_fck_multiplier     =       2,
         .parent_clk_name        =       "core_ck",
         .dpi_select_source      =       &dss_dpi_select_source_omap2_omap3,
+        .ports                  =       omap2plus_ports,
+        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
 static const struct dss_features omap34xx_dss_feats __initconst = {
@@ -705,6 +704,8 @@ static const struct dss_features omap34xx_dss_feats __initconst = {
         .dss_fck_multiplier     =       2,
         .parent_clk_name        =       "dpll4_ck",
         .dpi_select_source      =       &dss_dpi_select_source_omap2_omap3,
+        .ports                  =       omap34xx_ports,
+        .num_ports              =       ARRAY_SIZE(omap34xx_ports),
 };
 
 static const struct dss_features omap3630_dss_feats __initconst = {
@@ -712,6 +713,8 @@ static const struct dss_features omap3630_dss_feats __initconst = {
         .dss_fck_multiplier     =       1,
         .parent_clk_name        =       "dpll4_ck",
         .dpi_select_source      =       &dss_dpi_select_source_omap2_omap3,
+        .ports                  =       omap2plus_ports,
+        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
 static const struct dss_features omap44xx_dss_feats __initconst = {
@@ -719,6 +722,8 @@ static const struct dss_features omap44xx_dss_feats __initconst = {
         .dss_fck_multiplier     =       1,
         .parent_clk_name        =       "dpll_per_x2_ck",
         .dpi_select_source      =       &dss_dpi_select_source_omap4,
+        .ports                  =       omap2plus_ports,
+        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
 static const struct dss_features omap54xx_dss_feats __initconst = {
@@ -726,6 +731,8 @@ static const struct dss_features omap54xx_dss_feats __initconst = {
         .dss_fck_multiplier     =       1,
         .parent_clk_name        =       "dpll_per_x2_ck",
         .dpi_select_source      =       &dss_dpi_select_source_omap5,
+        .ports                  =       omap2plus_ports,
+        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
 static const struct dss_features am43xx_dss_feats __initconst = {
@@ -733,6 +740,8 @@ static const struct dss_features am43xx_dss_feats __initconst = {
         .dss_fck_multiplier     =       0,
         .parent_clk_name        =       NULL,
         .dpi_select_source      =       &dss_dpi_select_source_omap2_omap3,
+        .ports                  =       omap2plus_ports,
+        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
 static int __init dss_init_features(struct platform_device *pdev)
@@ -798,37 +807,77 @@ static int __init dss_init_ports(struct platform_device *pdev)
         if (!port)
                 return 0;
 
+        if (dss.feat->num_ports == 0)
+                return 0;
+
         do {
+                enum omap_display_type port_type;
                 u32 reg;
 
                 r = of_property_read_u32(port, "reg", &reg);
                 if (r)
                         reg = 0;
 
-#ifdef CONFIG_OMAP2_DSS_DPI
-                if (reg == 0)
-                        dpi_init_port(pdev, port);
-#endif
+                if (reg >= dss.feat->num_ports)
+                        continue;
 
-#ifdef CONFIG_OMAP2_DSS_SDI
-                if (reg == 1)
-                        sdi_init_port(pdev, port);
-#endif
+                port_type = dss.feat->ports[reg];
 
+                switch (port_type) {
+                case OMAP_DISPLAY_TYPE_DPI:
+                        dpi_init_port(pdev, port);
+                        break;
+                case OMAP_DISPLAY_TYPE_SDI:
+                        sdi_init_port(pdev, port);
+                        break;
+                default:
+                        break;
+                }
         } while ((port = omapdss_of_get_next_port(parent, port)) != NULL);
 
         return 0;
 }
 
-static void __exit dss_uninit_ports(void)
+static void __exit dss_uninit_ports(struct platform_device *pdev)
 {
-#ifdef CONFIG_OMAP2_DSS_DPI
-        dpi_uninit_port();
-#endif
+        struct device_node *parent = pdev->dev.of_node;
+        struct device_node *port;
 
-#ifdef CONFIG_OMAP2_DSS_SDI
-        sdi_uninit_port();
-#endif
+        if (parent == NULL)
+                return;
+
+        port = omapdss_of_get_next_port(parent, NULL);
+        if (!port)
+                return;
+
+        if (dss.feat->num_ports == 0)
+                return;
+
+        do {
+                enum omap_display_type port_type;
+                u32 reg;
+                int r;
+
+                r = of_property_read_u32(port, "reg", &reg);
+                if (r)
+                        reg = 0;
+
+                if (reg >= dss.feat->num_ports)
+                        continue;
+
+                port_type = dss.feat->ports[reg];
+
+                switch (port_type) {
+                case OMAP_DISPLAY_TYPE_DPI:
+                        dpi_uninit_port(port);
+                        break;
+                case OMAP_DISPLAY_TYPE_SDI:
+                        sdi_uninit_port(port);
+                        break;
+                default:
+                        break;
+                }
+        } while ((port = omapdss_of_get_next_port(parent, port)) != NULL);
 }
 
 /* DSS HW IP initialisation */
@@ -910,7 +959,7 @@ err_setup_clocks:
 
 static int __exit omap_dsshw_remove(struct platform_device *pdev)
 {
-        dss_uninit_ports();
+        dss_uninit_ports(pdev);
 
         pm_runtime_disable(&pdev->dev);
 
diff --git a/drivers/video/fbdev/omap2/dss/dss.h b/drivers/video/fbdev/omap2/dss/dss.h
index 8ff22c134c62..14fb0c23f4a2 100644
--- a/drivers/video/fbdev/omap2/dss/dss.h
+++ b/drivers/video/fbdev/omap2/dss/dss.h
@@ -100,35 +100,77 @@ enum dss_writeback_channel {
         DSS_WB_LCD3_MGR =       7,
 };
 
-struct dispc_clock_info {
+struct dss_pll;
+
+#define DSS_PLL_MAX_HSDIVS 4
+
+/*
+ * Type-A PLLs: clkout[]/mX[] refer to hsdiv outputs m4, m5, m6, m7.
+ * Type-B PLLs: clkout[0] refers to m2.
+ */
+struct dss_pll_clock_info {
         /* rates that we get with dividers below */
-        unsigned long lck;
-        unsigned long pck;
+        unsigned long fint;
+        unsigned long clkdco;
+        unsigned long clkout[DSS_PLL_MAX_HSDIVS];
 
         /* dividers */
-        u16 lck_div;
-        u16 pck_div;
+        u16 n;
+        u16 m;
+        u32 mf;
+        u16 mX[DSS_PLL_MAX_HSDIVS];
+        u16 sd;
+};
+
+struct dss_pll_ops {
+        int (*enable)(struct dss_pll *pll);
+        void (*disable)(struct dss_pll *pll);
+        int (*set_config)(struct dss_pll *pll,
+                const struct dss_pll_clock_info *cinfo);
+};
+
+struct dss_pll_hw {
+        unsigned n_max;
+        unsigned m_min;
+        unsigned m_max;
+        unsigned mX_max;
+
+        unsigned long fint_min, fint_max;
+        unsigned long clkdco_min, clkdco_low, clkdco_max;
+
+        u8 n_msb, n_lsb;
+        u8 m_msb, m_lsb;
+        u8 mX_msb[DSS_PLL_MAX_HSDIVS], mX_lsb[DSS_PLL_MAX_HSDIVS];
+
+        bool has_stopmode;
+        bool has_freqsel;
+        bool has_selfreqdco;
+        bool has_refsel;
 };
 
-struct dsi_clock_info {
+struct dss_pll {
+        const char *name;
+
+        struct clk *clkin;
+        struct regulator *regulator;
+
+        void __iomem *base;
+
+        const struct dss_pll_hw *hw;
+
+        const struct dss_pll_ops *ops;
+
+        struct dss_pll_clock_info cinfo;
+};
+
+struct dispc_clock_info {
         /* rates that we get with dividers below */
-        unsigned long fint;
-        unsigned long clkin4ddr;
-        unsigned long clkin;
-        unsigned long dsi_pll_hsdiv_dispc_clk;  /* OMAP3: DSI1_PLL_CLK
-                                                 * OMAP4: PLLx_CLK1 */
-        unsigned long dsi_pll_hsdiv_dsi_clk;    /* OMAP3: DSI2_PLL_CLK
-                                                 * OMAP4: PLLx_CLK2 */
-        unsigned long lp_clk;
+        unsigned long lck;
+        unsigned long pck;
 
         /* dividers */
-        u16 regn;
-        u16 regm;
-        u16 regm_dispc; /* OMAP3: REGM3
-                         * OMAP4: REGM4 */
-        u16 regm_dsi;   /* OMAP3: REGM4
-                         * OMAP4: REGM5 */
-        u16 lp_clk_div;
+        u16 lck_div;
+        u16 pck_div;
 };
 
 struct dss_lcd_mgr_config {
@@ -209,12 +251,16 @@ int dss_init_platform_driver(void) __init;
 void dss_uninit_platform_driver(void);
 
 unsigned long dss_get_dispc_clk_rate(void);
-int dss_dpi_select_source(enum omap_channel channel);
+int dss_dpi_select_source(int port, enum omap_channel channel);
 void dss_select_hdmi_venc_clk_source(enum dss_hdmi_venc_clk_source_select);
 enum dss_hdmi_venc_clk_source_select dss_get_hdmi_venc_clk_source(void);
 const char *dss_get_generic_clk_source_name(enum omap_dss_clk_source clk_src);
 void dss_dump_clocks(struct seq_file *s);
 
+/* dss-of */
+struct device_node *dss_of_port_get_parent_device(struct device_node *port);
+u32 dss_of_port_get_port_number(struct device_node *port);
+
 #if defined(CONFIG_OMAP2_DSS_DEBUGFS)
 void dss_debug_dump_clocks(struct seq_file *s);
 #endif
@@ -244,16 +290,22 @@ bool dss_div_calc(unsigned long pck, unsigned long fck_min,
 int sdi_init_platform_driver(void) __init;
 void sdi_uninit_platform_driver(void) __exit;
 
+#ifdef CONFIG_OMAP2_DSS_SDI
 int sdi_init_port(struct platform_device *pdev, struct device_node *port) __init;
-void sdi_uninit_port(void) __exit;
+void sdi_uninit_port(struct device_node *port) __exit;
+#else
+static inline int __init sdi_init_port(struct platform_device *pdev,
+                struct device_node *port)
+{
+        return 0;
+}
+static inline void __exit sdi_uninit_port(struct device_node *port)
+{
+}
+#endif
 
 /* DSI */
 
-typedef bool (*dsi_pll_calc_func)(int regn, int regm, unsigned long fint,
-                unsigned long pll, void *data);
-typedef bool (*dsi_hsdiv_calc_func)(int regm_dispc, unsigned long dispc,
-                void *data);
-
 #ifdef CONFIG_OMAP2_DSS_DSI
 
 struct dentry;
@@ -262,104 +314,36 @@ struct file_operations;
 int dsi_init_platform_driver(void) __init;
 void dsi_uninit_platform_driver(void) __exit;
 
-int dsi_runtime_get(struct platform_device *dsidev);
-void dsi_runtime_put(struct platform_device *dsidev);
-
 void dsi_dump_clocks(struct seq_file *s);
 
 void dsi_irq_handler(void);
 u8 dsi_get_pixel_size(enum omap_dss_dsi_pixel_format fmt);
 
-unsigned long dsi_get_pll_clkin(struct platform_device *dsidev);
-
-bool dsi_hsdiv_calc(struct platform_device *dsidev, unsigned long pll,
-                unsigned long out_min, dsi_hsdiv_calc_func func, void *data);
-bool dsi_pll_calc(struct platform_device *dsidev, unsigned long clkin,
-                unsigned long pll_min, unsigned long pll_max,
-                dsi_pll_calc_func func, void *data);
-
-unsigned long dsi_get_pll_hsdiv_dispc_rate(struct platform_device *dsidev);
-int dsi_pll_set_clock_div(struct platform_device *dsidev,
-                struct dsi_clock_info *cinfo);
-int dsi_pll_init(struct platform_device *dsidev, bool enable_hsclk,
-                bool enable_hsdiv);
-void dsi_pll_uninit(struct platform_device *dsidev, bool disconnect_lanes);
-void dsi_wait_pll_hsdiv_dispc_active(struct platform_device *dsidev);
-void dsi_wait_pll_hsdiv_dsi_active(struct platform_device *dsidev);
-struct platform_device *dsi_get_dsidev_from_id(int module);
 #else
-static inline int dsi_runtime_get(struct platform_device *dsidev)
-{
-        return 0;
-}
-static inline void dsi_runtime_put(struct platform_device *dsidev)
-{
-}
 static inline u8 dsi_get_pixel_size(enum omap_dss_dsi_pixel_format fmt)
 {
         WARN("%s: DSI not compiled in, returning pixel_size as 0\n", __func__);
         return 0;
 }
-static inline unsigned long dsi_get_pll_hsdiv_dispc_rate(struct platform_device *dsidev)
-{
-        WARN("%s: DSI not compiled in, returning rate as 0\n", __func__);
-        return 0;
-}
-static inline int dsi_pll_set_clock_div(struct platform_device *dsidev,
-                struct dsi_clock_info *cinfo)
-{
-        WARN("%s: DSI not compiled in\n", __func__);
-        return -ENODEV;
-}
-static inline int dsi_pll_init(struct platform_device *dsidev,
-                bool enable_hsclk, bool enable_hsdiv)
-{
-        WARN("%s: DSI not compiled in\n", __func__);
-        return -ENODEV;
-}
-static inline void dsi_pll_uninit(struct platform_device *dsidev,
-                bool disconnect_lanes)
-{
-}
-static inline void dsi_wait_pll_hsdiv_dispc_active(struct platform_device *dsidev)
-{
-}
-static inline void dsi_wait_pll_hsdiv_dsi_active(struct platform_device *dsidev)
-{
-}
-static inline struct platform_device *dsi_get_dsidev_from_id(int module)
-{
-        return NULL;
-}
-
-static inline unsigned long dsi_get_pll_clkin(struct platform_device *dsidev)
-{
-        return 0;
-}
-
-static inline bool dsi_hsdiv_calc(struct platform_device *dsidev,
-                unsigned long pll, unsigned long out_min,
-                dsi_hsdiv_calc_func func, void *data)
-{
-        return false;
-}
-
-static inline bool dsi_pll_calc(struct platform_device *dsidev,
-                unsigned long clkin,
-                unsigned long pll_min, unsigned long pll_max,
-                dsi_pll_calc_func func, void *data)
-{
-        return false;
-}
-
 #endif
 
 /* DPI */
 int dpi_init_platform_driver(void) __init;
 void dpi_uninit_platform_driver(void) __exit;
 
+#ifdef CONFIG_OMAP2_DSS_DPI
 int dpi_init_port(struct platform_device *pdev, struct device_node *port) __init;
-void dpi_uninit_port(void) __exit;
+void dpi_uninit_port(struct device_node *port) __exit;
+#else
+static inline int __init dpi_init_port(struct platform_device *pdev,
+                struct device_node *port)
+{
+        return 0;
+}
+static inline void __exit dpi_uninit_port(struct device_node *port)
+{
+}
+#endif
 
 /* DISPC */
 int dispc_init_platform_driver(void) __init;
@@ -438,4 +422,29 @@ static inline void dss_collect_irq_stats(u32 irqstatus, unsigned *irq_arr)
 }
 #endif
 
+/* PLL */
+typedef bool (*dss_pll_calc_func)(int n, int m, unsigned long fint,
+                unsigned long clkdco, void *data);
+typedef bool (*dss_hsdiv_calc_func)(int m_dispc, unsigned long dispc,
+                void *data);
+
+int dss_pll_register(struct dss_pll *pll);
+void dss_pll_unregister(struct dss_pll *pll);
+struct dss_pll *dss_pll_find(const char *name);
+int dss_pll_enable(struct dss_pll *pll);
+void dss_pll_disable(struct dss_pll *pll);
+int dss_pll_set_config(struct dss_pll *pll,
+                const struct dss_pll_clock_info *cinfo);
+
+bool dss_pll_hsdiv_calc(const struct dss_pll *pll, unsigned long clkdco,
+                unsigned long out_min, unsigned long out_max,
+                dss_hsdiv_calc_func func, void *data);
+bool dss_pll_calc(const struct dss_pll *pll, unsigned long clkin,
+                unsigned long pll_min, unsigned long pll_max,
+                dss_pll_calc_func func, void *data);
+int dss_pll_write_config_type_a(struct dss_pll *pll,
+                const struct dss_pll_clock_info *cinfo);
+int dss_pll_write_config_type_b(struct dss_pll *pll,
+                const struct dss_pll_clock_info *cinfo);
+
 #endif
diff --git a/drivers/video/fbdev/omap2/dss/dss_features.c b/drivers/video/fbdev/omap2/dss/dss_features.c
index 15088df7bd16..0e3da809473c 100644
--- a/drivers/video/fbdev/omap2/dss/dss_features.c
+++ b/drivers/video/fbdev/omap2/dss/dss_features.c
@@ -72,10 +72,6 @@ static const struct dss_reg_field omap2_dss_reg_fields[] = {
         [FEAT_REG_HORIZONTALACCU]               = { 9, 0 },
         [FEAT_REG_VERTICALACCU]                 = { 25, 16 },
         [FEAT_REG_DISPC_CLK_SWITCH]             = { 0, 0 },
-        [FEAT_REG_DSIPLL_REGN]                  = { 0, 0 },
-        [FEAT_REG_DSIPLL_REGM]                  = { 0, 0 },
-        [FEAT_REG_DSIPLL_REGM_DISPC]            = { 0, 0 },
-        [FEAT_REG_DSIPLL_REGM_DSI]              = { 0, 0 },
 };
 
 static const struct dss_reg_field omap3_dss_reg_fields[] = {
@@ -87,10 +83,6 @@ static const struct dss_reg_field omap3_dss_reg_fields[] = {
         [FEAT_REG_HORIZONTALACCU]               = { 9, 0 },
         [FEAT_REG_VERTICALACCU]                 = { 25, 16 },
         [FEAT_REG_DISPC_CLK_SWITCH]             = { 0, 0 },
-        [FEAT_REG_DSIPLL_REGN]                  = { 7, 1 },
-        [FEAT_REG_DSIPLL_REGM]                  = { 18, 8 },
-        [FEAT_REG_DSIPLL_REGM_DISPC]            = { 22, 19 },
-        [FEAT_REG_DSIPLL_REGM_DSI]              = { 26, 23 },
 };
 
 static const struct dss_reg_field am43xx_dss_reg_fields[] = {
@@ -113,10 +105,6 @@ static const struct dss_reg_field omap4_dss_reg_fields[] = {
         [FEAT_REG_HORIZONTALACCU]               = { 10, 0 },
         [FEAT_REG_VERTICALACCU]                 = { 26, 16 },
         [FEAT_REG_DISPC_CLK_SWITCH]             = { 9, 8 },
-        [FEAT_REG_DSIPLL_REGN]                  = { 8, 1 },
-        [FEAT_REG_DSIPLL_REGM]                  = { 20, 9 },
-        [FEAT_REG_DSIPLL_REGM_DISPC]            = { 25, 21 },
-        [FEAT_REG_DSIPLL_REGM_DSI]              = { 30, 26 },
 };
 
 static const struct dss_reg_field omap5_dss_reg_fields[] = {
@@ -128,10 +116,6 @@ static const struct dss_reg_field omap5_dss_reg_fields[] = {
         [FEAT_REG_HORIZONTALACCU]               = { 10, 0 },
         [FEAT_REG_VERTICALACCU]                 = { 26, 16 },
         [FEAT_REG_DISPC_CLK_SWITCH]             = { 9, 7 },
-        [FEAT_REG_DSIPLL_REGN]                  = { 8, 1 },
-        [FEAT_REG_DSIPLL_REGM]                  = { 20, 9 },
-        [FEAT_REG_DSIPLL_REGM_DISPC]            = { 25, 21 },
-        [FEAT_REG_DSIPLL_REGM_DSI]              = { 30, 26 },
 };
 
 static const enum omap_display_type omap2_dss_supported_displays[] = {
@@ -437,12 +421,6 @@ static const char * const omap5_dss_clk_source_names[] = {
 static const struct dss_param_range omap2_dss_param_range[] = {
         [FEAT_PARAM_DSS_FCK]                    = { 0, 133000000 },
         [FEAT_PARAM_DSS_PCD]                    = { 2, 255 },
-        [FEAT_PARAM_DSIPLL_REGN]                = { 0, 0 },
-        [FEAT_PARAM_DSIPLL_REGM]                = { 0, 0 },
-        [FEAT_PARAM_DSIPLL_REGM_DISPC]          = { 0, 0 },
-        [FEAT_PARAM_DSIPLL_REGM_DSI]            = { 0, 0 },
-        [FEAT_PARAM_DSIPLL_FINT]                = { 0, 0 },
-        [FEAT_PARAM_DSIPLL_LPDIV]               = { 0, 0 },
         [FEAT_PARAM_DOWNSCALE]                  = { 1, 2 },
         /*
          * Assuming the line width buffer to be 768 pixels as OMAP2 DISPC
@@ -454,11 +432,6 @@ static const struct dss_param_range omap2_dss_param_range[] = {
 static const struct dss_param_range omap3_dss_param_range[] = {
         [FEAT_PARAM_DSS_FCK]                    = { 0, 173000000 },
         [FEAT_PARAM_DSS_PCD]                    = { 1, 255 },
-        [FEAT_PARAM_DSIPLL_REGN]                = { 0, (1 << 7) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM]                = { 0, (1 << 11) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM_DISPC]          = { 0, (1 << 4) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM_DSI]            = { 0, (1 << 4) - 1 },
-        [FEAT_PARAM_DSIPLL_FINT]                = { 750000, 2100000 },
         [FEAT_PARAM_DSIPLL_LPDIV]               = { 1, (1 << 13) - 1},
         [FEAT_PARAM_DSI_FCK]                    = { 0, 173000000 },
         [FEAT_PARAM_DOWNSCALE]                  = { 1, 4 },
@@ -475,11 +448,6 @@ static const struct dss_param_range am43xx_dss_param_range[] = {
 static const struct dss_param_range omap4_dss_param_range[] = {
         [FEAT_PARAM_DSS_FCK]                    = { 0, 186000000 },
         [FEAT_PARAM_DSS_PCD]                    = { 1, 255 },
-        [FEAT_PARAM_DSIPLL_REGN]                = { 0, (1 << 8) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM]                = { 0, (1 << 12) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM_DISPC]          = { 0, (1 << 5) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM_DSI]            = { 0, (1 << 5) - 1 },
-        [FEAT_PARAM_DSIPLL_FINT]                = { 500000, 2500000 },
         [FEAT_PARAM_DSIPLL_LPDIV]               = { 0, (1 << 13) - 1 },
         [FEAT_PARAM_DSI_FCK]                    = { 0, 170000000 },
         [FEAT_PARAM_DOWNSCALE]                  = { 1, 4 },
@@ -489,11 +457,6 @@ static const struct dss_param_range omap4_dss_param_range[] = {
 static const struct dss_param_range omap5_dss_param_range[] = {
         [FEAT_PARAM_DSS_FCK]                    = { 0, 209250000 },
         [FEAT_PARAM_DSS_PCD]                    = { 1, 255 },
-        [FEAT_PARAM_DSIPLL_REGN]                = { 0, (1 << 8) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM]                = { 0, (1 << 12) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM_DISPC]          = { 0, (1 << 5) - 1 },
-        [FEAT_PARAM_DSIPLL_REGM_DSI]            = { 0, (1 << 5) - 1 },
-        [FEAT_PARAM_DSIPLL_FINT]                = { 150000, 52000000 },
         [FEAT_PARAM_DSIPLL_LPDIV]               = { 0, (1 << 13) - 1 },
         [FEAT_PARAM_DSI_FCK]                    = { 0, 209250000 },
         [FEAT_PARAM_DOWNSCALE]                  = { 1, 4 },
@@ -517,7 +480,6 @@ static const enum dss_feat_id omap3430_dss_feat_list[] = {
         FEAT_LINEBUFFERSPLIT,
         FEAT_ROWREPEATENABLE,
         FEAT_RESIZECONF,
-        FEAT_DSI_PLL_FREQSEL,
         FEAT_DSI_REVERSE_TXCLKESC,
         FEAT_VENC_REQUIRES_TV_DAC_CLK,
         FEAT_CPR,
@@ -537,7 +499,6 @@ static const enum dss_feat_id am35xx_dss_feat_list[] = {
         FEAT_LINEBUFFERSPLIT,
         FEAT_ROWREPEATENABLE,
         FEAT_RESIZECONF,
-        FEAT_DSI_PLL_FREQSEL,
         FEAT_DSI_REVERSE_TXCLKESC,
         FEAT_VENC_REQUIRES_TV_DAC_CLK,
         FEAT_CPR,
@@ -572,7 +533,6 @@ static const enum dss_feat_id omap3630_dss_feat_list[] = {
         FEAT_ROWREPEATENABLE,
         FEAT_RESIZECONF,
         FEAT_DSI_PLL_PWR_BUG,
-        FEAT_DSI_PLL_FREQSEL,
         FEAT_CPR,
         FEAT_PRELOAD,
         FEAT_FIR_COEF_V,
@@ -654,8 +614,6 @@ static const enum dss_feat_id omap5_dss_feat_list[] = {
         FEAT_ALPHA_FREE_ZORDER,
         FEAT_FIFO_MERGE,
         FEAT_BURST_2D,
-        FEAT_DSI_PLL_SELFREQDCO,
-        FEAT_DSI_PLL_REFSEL,
         FEAT_DSI_PHY_DCC,
         FEAT_MFLAG,
 };
diff --git a/drivers/video/fbdev/omap2/dss/dss_features.h b/drivers/video/fbdev/omap2/dss/dss_features.h
index e3ef3b714896..100f7a2d0638 100644
--- a/drivers/video/fbdev/omap2/dss/dss_features.h
+++ b/drivers/video/fbdev/omap2/dss/dss_features.h
@@ -41,7 +41,6 @@ enum dss_feat_id {
         FEAT_LCD_CLK_SRC,
         /* DSI-PLL power command 0x3 is not working */
         FEAT_DSI_PLL_PWR_BUG,
-        FEAT_DSI_PLL_FREQSEL,
         FEAT_DSI_DCS_CMD_CONFIG_VC,
         FEAT_DSI_VC_OCP_WIDTH,
         FEAT_DSI_REVERSE_TXCLKESC,
@@ -61,8 +60,6 @@ enum dss_feat_id {
         /* An unknown HW bug causing the normal FIFO thresholds not to work */
         FEAT_OMAP3_DSI_FIFO_BUG,
         FEAT_BURST_2D,
-        FEAT_DSI_PLL_SELFREQDCO,
-        FEAT_DSI_PLL_REFSEL,
         FEAT_DSI_PHY_DCC,
         FEAT_MFLAG,
 };
@@ -77,20 +74,11 @@ enum dss_feat_reg_field {
         FEAT_REG_HORIZONTALACCU,
         FEAT_REG_VERTICALACCU,
         FEAT_REG_DISPC_CLK_SWITCH,
-        FEAT_REG_DSIPLL_REGN,
-        FEAT_REG_DSIPLL_REGM,
-        FEAT_REG_DSIPLL_REGM_DISPC,
-        FEAT_REG_DSIPLL_REGM_DSI,
 };
 
 enum dss_range_param {
         FEAT_PARAM_DSS_FCK,
         FEAT_PARAM_DSS_PCD,
-        FEAT_PARAM_DSIPLL_REGN,
-        FEAT_PARAM_DSIPLL_REGM,
-        FEAT_PARAM_DSIPLL_REGM_DISPC,
-        FEAT_PARAM_DSIPLL_REGM_DSI,
-        FEAT_PARAM_DSIPLL_FINT,
         FEAT_PARAM_DSIPLL_LPDIV,
         FEAT_PARAM_DSI_FCK,
         FEAT_PARAM_DOWNSCALE,
diff --git a/drivers/video/fbdev/omap2/dss/hdmi.h b/drivers/video/fbdev/omap2/dss/hdmi.h
index 262771b9b76b..e4a32fe77b02 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi.h
+++ b/drivers/video/fbdev/omap2/dss/hdmi.h
@@ -101,13 +101,6 @@ enum hdmi_core_hdmi_dvi {
         HDMI_HDMI = 1
 };
 
-enum hdmi_clk_refsel {
-        HDMI_REFSEL_PCLK = 0,
-        HDMI_REFSEL_REF1 = 1,
-        HDMI_REFSEL_REF2 = 2,
-        HDMI_REFSEL_SYSCLK = 3
-};
-
 enum hdmi_packing_mode {
         HDMI_PACK_10b_RGB_YUV444 = 0,
         HDMI_PACK_24b_RGB_YUV444_YUV422 = 1,
@@ -160,7 +153,8 @@ enum hdmi_audio_blk_strt_end_sig {
 
 enum hdmi_core_audio_layout {
         HDMI_AUDIO_LAYOUT_2CH = 0,
-        HDMI_AUDIO_LAYOUT_8CH = 1
+        HDMI_AUDIO_LAYOUT_8CH = 1,
+        HDMI_AUDIO_LAYOUT_6CH = 2
 };
 
 enum hdmi_core_cts_mode {
@@ -191,17 +185,6 @@ struct hdmi_config {
         enum hdmi_core_hdmi_dvi hdmi_dvi_mode;
 };
 
-/* HDMI PLL structure */
-struct hdmi_pll_info {
-        u16 regn;
-        u16 regm;
-        u32 regmf;
-        u16 regm2;
-        u16 regsd;
-        u16 dcofreq;
-        enum hdmi_clk_refsel refsel;
-};
-
 struct hdmi_audio_format {
         enum hdmi_stereo_channels               stereo_channels;
         u8                                      active_chnnls_msk;
@@ -249,12 +232,15 @@ struct hdmi_core_audio_config {
 
 struct hdmi_wp_data {
         void __iomem *base;
+        phys_addr_t phys_base;
 };
 
 struct hdmi_pll_data {
+        struct dss_pll pll;
+
         void __iomem *base;
 
-        struct hdmi_pll_info info;
+        struct hdmi_wp_data *wp;
 };
 
 struct hdmi_phy_data {
@@ -316,16 +302,19 @@ void hdmi_wp_video_config_timing(struct hdmi_wp_data *wp,
 void hdmi_wp_init_vid_fmt_timings(struct hdmi_video_format *video_fmt,
                 struct omap_video_timings *timings, struct hdmi_config *param);
 int hdmi_wp_init(struct platform_device *pdev, struct hdmi_wp_data *wp);
+phys_addr_t hdmi_wp_get_audio_dma_addr(struct hdmi_wp_data *wp);
 
 /* HDMI PLL funcs */
-int hdmi_pll_enable(struct hdmi_pll_data *pll, struct hdmi_wp_data *wp);
-void hdmi_pll_disable(struct hdmi_pll_data *pll, struct hdmi_wp_data *wp);
 void hdmi_pll_dump(struct hdmi_pll_data *pll, struct seq_file *s);
-void hdmi_pll_compute(struct hdmi_pll_data *pll, unsigned long clkin, int phy);
-int hdmi_pll_init(struct platform_device *pdev, struct hdmi_pll_data *pll);
+void hdmi_pll_compute(struct hdmi_pll_data *pll,
+        unsigned long target_tmds, struct dss_pll_clock_info *pi);
+int hdmi_pll_init(struct platform_device *pdev, struct hdmi_pll_data *pll,
+        struct hdmi_wp_data *wp);
+void hdmi_pll_uninit(struct hdmi_pll_data *hpll);
 
 /* HDMI PHY funcs */
-int hdmi_phy_configure(struct hdmi_phy_data *phy, struct hdmi_config *cfg);
+int hdmi_phy_configure(struct hdmi_phy_data *phy, unsigned long hfbitclk,
+        unsigned long lfbitclk);
 void hdmi_phy_dump(struct hdmi_phy_data *phy, struct seq_file *s);
 int hdmi_phy_init(struct platform_device *pdev, struct hdmi_phy_data *phy);
 int hdmi_phy_parse_lanes(struct hdmi_phy_data *phy, const u32 *lanes);
@@ -334,7 +323,7 @@ int hdmi_phy_parse_lanes(struct hdmi_phy_data *phy, const u32 *lanes);
 int hdmi_parse_lanes_of(struct platform_device *pdev, struct device_node *ep,
         struct hdmi_phy_data *phy);
 
-#if defined(CONFIG_OMAP4_DSS_HDMI_AUDIO) || defined(CONFIG_OMAP5_DSS_HDMI_AUDIO)
+/* Audio funcs */
 int hdmi_compute_acr(u32 pclk, u32 sample_freq, u32 *n, u32 *cts);
 int hdmi_wp_audio_enable(struct hdmi_wp_data *wp, bool enable);
 int hdmi_wp_audio_core_req_enable(struct hdmi_wp_data *wp, bool enable);
@@ -342,9 +331,33 @@ void hdmi_wp_audio_config_format(struct hdmi_wp_data *wp,
                 struct hdmi_audio_format *aud_fmt);
 void hdmi_wp_audio_config_dma(struct hdmi_wp_data *wp,
                 struct hdmi_audio_dma *aud_dma);
-static inline bool hdmi_mode_has_audio(int mode)
+static inline bool hdmi_mode_has_audio(struct hdmi_config *cfg)
 {
-        return mode == HDMI_HDMI ? true : false;
+        return cfg->hdmi_dvi_mode == HDMI_HDMI ? true : false;
 }
-#endif
+
+/* HDMI DRV data */
+struct omap_hdmi {
+        struct mutex lock;
+        struct platform_device *pdev;
+
+        struct hdmi_wp_data     wp;
+        struct hdmi_pll_data    pll;
+        struct hdmi_phy_data    phy;
+        struct hdmi_core_data   core;
+
+        struct hdmi_config cfg;
+
+        struct regulator *vdda_reg;
+
+        bool core_enabled;
+        bool display_enabled;
+
+        struct omap_dss_device output;
+
+        struct platform_device *audio_pdev;
+        void (*audio_abort_cb)(struct device *dev);
+        int wp_idlemode;
+};
+
 #endif
diff --git a/drivers/video/fbdev/omap2/dss/hdmi4.c b/drivers/video/fbdev/omap2/dss/hdmi4.c
index 9a8713ca090c..f1a02bf938ee 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi4.c
+++ b/drivers/video/fbdev/omap2/dss/hdmi4.c
@@ -33,29 +33,14 @@
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
 #include <video/omapdss.h>
+#include <sound/omap-hdmi-audio.h>
 
 #include "hdmi4_core.h"
 #include "dss.h"
 #include "dss_features.h"
+#include "hdmi.h"
 
-static struct {
-        struct mutex lock;
-        struct platform_device *pdev;
-
-        struct hdmi_wp_data     wp;
-        struct hdmi_pll_data    pll;
-        struct hdmi_phy_data    phy;
-        struct hdmi_core_data   core;
-
-        struct hdmi_config cfg;
-
-        struct clk *sys_clk;
-        struct regulator *vdda_hdmi_dac_reg;
-
-        bool core_enabled;
-
-        struct omap_dss_device output;
-} hdmi;
+static struct omap_hdmi hdmi;
 
 static int hdmi_runtime_get(void)
 {
@@ -117,7 +102,7 @@ static int hdmi_init_regulator(void)
         int r;
         struct regulator *reg;
 
-        if (hdmi.vdda_hdmi_dac_reg != NULL)
+        if (hdmi.vdda_reg != NULL)
                 return 0;
 
         reg = devm_regulator_get(&hdmi.pdev->dev, "vdda");
@@ -137,7 +122,7 @@ static int hdmi_init_regulator(void)
                 }
         }
 
-        hdmi.vdda_hdmi_dac_reg = reg;
+        hdmi.vdda_reg = reg;
 
         return 0;
 }
@@ -146,7 +131,7 @@ static int hdmi_power_on_core(struct omap_dss_device *dssdev)
 {
         int r;
 
-        r = regulator_enable(hdmi.vdda_hdmi_dac_reg);
+        r = regulator_enable(hdmi.vdda_reg);
         if (r)
                 return r;
 
@@ -162,7 +147,7 @@ static int hdmi_power_on_core(struct omap_dss_device *dssdev)
         return 0;
 
 err_runtime_get:
-        regulator_disable(hdmi.vdda_hdmi_dac_reg);
+        regulator_disable(hdmi.vdda_reg);
 
         return r;
 }
@@ -172,7 +157,7 @@ static void hdmi_power_off_core(struct omap_dss_device *dssdev)
         hdmi.core_enabled = false;
 
         hdmi_runtime_put();
-        regulator_disable(hdmi.vdda_hdmi_dac_reg);
+        regulator_disable(hdmi.vdda_reg);
 }
 
 static int hdmi_power_on_full(struct omap_dss_device *dssdev)
@@ -180,8 +165,8 @@ static int hdmi_power_on_full(struct omap_dss_device *dssdev)
         int r;
         struct omap_video_timings *p;
         struct omap_overlay_manager *mgr = hdmi.output.manager;
-        unsigned long phy;
         struct hdmi_wp_data *wp = &hdmi.wp;
+        struct dss_pll_clock_info hdmi_cinfo = { 0 };
 
         r = hdmi_power_on_core(dssdev);
         if (r)
@@ -195,19 +180,22 @@ static int hdmi_power_on_full(struct omap_dss_device *dssdev)
 
         DSSDBG("hdmi_power_on x_res= %d y_res = %d\n", p->x_res, p->y_res);
 
-        /* the functions below use kHz pixel clock. TODO: change to Hz */
-        phy = p->pixelclock / 1000;
-
-        hdmi_pll_compute(&hdmi.pll, clk_get_rate(hdmi.sys_clk), phy);
+        hdmi_pll_compute(&hdmi.pll, p->pixelclock, &hdmi_cinfo);
 
-        /* config the PLL and PHY hdmi_set_pll_pwrfirst */
-        r = hdmi_pll_enable(&hdmi.pll, &hdmi.wp);
+        r = dss_pll_enable(&hdmi.pll.pll);
         if (r) {
-                DSSDBG("Failed to lock PLL\n");
+                DSSERR("Failed to enable PLL\n");
                 goto err_pll_enable;
         }
 
-        r = hdmi_phy_configure(&hdmi.phy, &hdmi.cfg);
+        r = dss_pll_set_config(&hdmi.pll.pll, &hdmi_cinfo);
+        if (r) {
+                DSSERR("Failed to configure PLL\n");
+                goto err_pll_cfg;
+        }
+
+        r = hdmi_phy_configure(&hdmi.phy, hdmi_cinfo.clkdco,
+                hdmi_cinfo.clkout[0]);
         if (r) {
                 DSSDBG("Failed to configure PHY\n");
                 goto err_phy_cfg;
@@ -244,7 +232,8 @@ err_vid_enable:
 err_phy_cfg:
         hdmi_wp_set_phy_pwr(&hdmi.wp, HDMI_PHYPWRCMD_OFF);
 err_phy_pwr:
-        hdmi_pll_disable(&hdmi.pll, &hdmi.wp);
+err_pll_cfg:
+        dss_pll_disable(&hdmi.pll.pll);
 err_pll_enable:
         hdmi_power_off_core(dssdev);
         return -EIO;
@@ -262,7 +251,7 @@ static void hdmi_power_off_full(struct omap_dss_device *dssdev)
 
         hdmi_wp_set_phy_pwr(&hdmi.wp, HDMI_PHYPWRCMD_OFF);
 
-        hdmi_pll_disable(&hdmi.pll, &hdmi.wp);
+        dss_pll_disable(&hdmi.pll.pll);
 
         hdmi_power_off_core(dssdev);
 }
@@ -352,6 +341,8 @@ static int hdmi_display_enable(struct omap_dss_device *dssdev)
                 goto err0;
         }
 
+        hdmi.display_enabled = true;
+
         mutex_unlock(&hdmi.lock);
         return 0;
 
@@ -366,8 +357,13 @@ static void hdmi_display_disable(struct omap_dss_device *dssdev)
 
         mutex_lock(&hdmi.lock);
 
+        if (hdmi.audio_pdev && hdmi.audio_abort_cb)
+                hdmi.audio_abort_cb(&hdmi.audio_pdev->dev);
+
         hdmi_power_off_full(dssdev);
 
+        hdmi.display_enabled = false;
+
         mutex_unlock(&hdmi.lock);
 }
 
@@ -404,21 +400,6 @@ static void hdmi_core_disable(struct omap_dss_device *dssdev)
         mutex_unlock(&hdmi.lock);
 }
 
-static int hdmi_get_clocks(struct platform_device *pdev)
-{
-        struct clk *clk;
-
-        clk = devm_clk_get(&pdev->dev, "sys_clk");
-        if (IS_ERR(clk)) {
-                DSSERR("can't get sys_clk\n");
-                return PTR_ERR(clk);
-        }
-
-        hdmi.sys_clk = clk;
-
-        return 0;
-}
-
 static int hdmi_connect(struct omap_dss_device *dssdev,
                 struct omap_dss_device *dst)
 {
@@ -484,112 +465,6 @@ static int hdmi_read_edid(struct omap_dss_device *dssdev,
         return r;
 }
 
-#if defined(CONFIG_OMAP4_DSS_HDMI_AUDIO)
-static int hdmi_audio_enable(struct omap_dss_device *dssdev)
-{
-        int r;
-
-        mutex_lock(&hdmi.lock);
-
-        if (!hdmi_mode_has_audio(hdmi.cfg.hdmi_dvi_mode)) {
-                r = -EPERM;
-                goto err;
-        }
-
-        r = hdmi_wp_audio_enable(&hdmi.wp, true);
-        if (r)
-                goto err;
-
-        mutex_unlock(&hdmi.lock);
-        return 0;
-
-err:
-        mutex_unlock(&hdmi.lock);
-        return r;
-}
-
-static void hdmi_audio_disable(struct omap_dss_device *dssdev)
-{
-        hdmi_wp_audio_enable(&hdmi.wp, false);
-}
-
-static int hdmi_audio_start(struct omap_dss_device *dssdev)
-{
-        return hdmi4_audio_start(&hdmi.core, &hdmi.wp);
-}
-
-static void hdmi_audio_stop(struct omap_dss_device *dssdev)
-{
-        hdmi4_audio_stop(&hdmi.core, &hdmi.wp);
-}
-
-static bool hdmi_audio_supported(struct omap_dss_device *dssdev)
-{
-        bool r;
-
-        mutex_lock(&hdmi.lock);
-
-        r = hdmi_mode_has_audio(hdmi.cfg.hdmi_dvi_mode);
-
-        mutex_unlock(&hdmi.lock);
-        return r;
-}
-
-static int hdmi_audio_config(struct omap_dss_device *dssdev,
-                struct omap_dss_audio *audio)
-{
-        int r;
-        u32 pclk = hdmi.cfg.timings.pixelclock;
-
-        mutex_lock(&hdmi.lock);
-
-        if (!hdmi_mode_has_audio(hdmi.cfg.hdmi_dvi_mode)) {
-                r = -EPERM;
-                goto err;
-        }
-
-        r = hdmi4_audio_config(&hdmi.core, &hdmi.wp, audio, pclk);
-        if (r)
-                goto err;
-
-        mutex_unlock(&hdmi.lock);
-        return 0;
-
-err:
-        mutex_unlock(&hdmi.lock);
-        return r;
-}
-#else
-static int hdmi_audio_enable(struct omap_dss_device *dssdev)
-{
-        return -EPERM;
-}
-
-static void hdmi_audio_disable(struct omap_dss_device *dssdev)
-{
-}
-
-static int hdmi_audio_start(struct omap_dss_device *dssdev)
-{
-        return -EPERM;
-}
-
-static void hdmi_audio_stop(struct omap_dss_device *dssdev)
-{
-}
-
-static bool hdmi_audio_supported(struct omap_dss_device *dssdev)
-{
-        return false;
-}
-
-static int hdmi_audio_config(struct omap_dss_device *dssdev,
-                struct omap_dss_audio *audio)
-{
-        return -EPERM;
-}
-#endif
-
 static int hdmi_set_infoframe(struct omap_dss_device *dssdev,
                 const struct hdmi_avi_infoframe *avi)
 {
@@ -618,13 +493,6 @@ static const struct omapdss_hdmi_ops hdmi_ops = {
         .read_edid              = hdmi_read_edid,
         .set_infoframe          = hdmi_set_infoframe,
         .set_hdmi_mode          = hdmi_set_hdmi_mode,
-
-        .audio_enable           = hdmi_audio_enable,
-        .audio_disable          = hdmi_audio_disable,
-        .audio_start            = hdmi_audio_start,
-        .audio_stop             = hdmi_audio_stop,
-        .audio_supported        = hdmi_audio_supported,
-        .audio_config           = hdmi_audio_config,
 };
 
 static void hdmi_init_output(struct platform_device *pdev)
@@ -642,7 +510,7 @@ static void hdmi_init_output(struct platform_device *pdev)
         omapdss_register_output(out);
 }
 
-static void __exit hdmi_uninit_output(struct platform_device *pdev)
+static void hdmi_uninit_output(struct platform_device *pdev)
 {
         struct omap_dss_device *out = &hdmi.output;
 
@@ -671,6 +539,112 @@ err:
         return r;
 }
 
+/* Audio callbacks */
+static int hdmi_audio_startup(struct device *dev,
+                              void (*abort_cb)(struct device *dev))
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+        int ret = 0;
+
+        mutex_lock(&hd->lock);
+
+        if (!hdmi_mode_has_audio(&hd->cfg) || !hd->display_enabled) {
+                ret = -EPERM;
+                goto out;
+        }
+
+        hd->audio_abort_cb = abort_cb;
+
+out:
+        mutex_unlock(&hd->lock);
+
+        return ret;
+}
+
+static int hdmi_audio_shutdown(struct device *dev)
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+
+        mutex_lock(&hd->lock);
+        hd->audio_abort_cb = NULL;
+        mutex_unlock(&hd->lock);
+
+        return 0;
+}
+
+static int hdmi_audio_start(struct device *dev)
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+
+        WARN_ON(!hdmi_mode_has_audio(&hd->cfg));
+        WARN_ON(!hd->display_enabled);
+
+        hdmi_wp_audio_enable(&hd->wp, true);
+        hdmi4_audio_start(&hd->core, &hd->wp);
+
+        return 0;
+}
+
+static void hdmi_audio_stop(struct device *dev)
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+
+        WARN_ON(!hdmi_mode_has_audio(&hd->cfg));
+        WARN_ON(!hd->display_enabled);
+
+        hdmi4_audio_stop(&hd->core, &hd->wp);
+        hdmi_wp_audio_enable(&hd->wp, false);
+}
+
+static int hdmi_audio_config(struct device *dev,
+                             struct omap_dss_audio *dss_audio)
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+        int ret;
+
+        mutex_lock(&hd->lock);
+
+        if (!hdmi_mode_has_audio(&hd->cfg) || !hd->display_enabled) {
+                ret = -EPERM;
+                goto out;
+        }
+
+        ret = hdmi4_audio_config(&hd->core, &hd->wp, dss_audio,
+                                 hd->cfg.timings.pixelclock);
+
+out:
+        mutex_unlock(&hd->lock);
+
+        return ret;
+}
+
+static const struct omap_hdmi_audio_ops hdmi_audio_ops = {
+        .audio_startup = hdmi_audio_startup,
+        .audio_shutdown = hdmi_audio_shutdown,
+        .audio_start = hdmi_audio_start,
+        .audio_stop = hdmi_audio_stop,
+        .audio_config = hdmi_audio_config,
+};
+
+static int hdmi_audio_register(struct device *dev)
+{
+        struct omap_hdmi_audio_pdata pdata = {
+                .dev = dev,
+                .dss_version = omapdss_get_version(),
+                .audio_dma_addr = hdmi_wp_get_audio_dma_addr(&hdmi.wp),
+                .ops = &hdmi_audio_ops,
+        };
+
+        hdmi.audio_pdev = platform_device_register_data(
+                dev, "omap-hdmi-audio", PLATFORM_DEVID_AUTO,
+                &pdata, sizeof(pdata));
+
+        if (IS_ERR(hdmi.audio_pdev))
+                return PTR_ERR(hdmi.audio_pdev);
+
+        return 0;
+}
+
 /* HDMI HW IP initialisation */
 static int omapdss_hdmihw_probe(struct platform_device *pdev)
 {
@@ -678,6 +652,7 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
         int irq;
 
         hdmi.pdev = pdev;
+        dev_set_drvdata(&pdev->dev, &hdmi);
 
         mutex_init(&hdmi.lock);
 
@@ -691,28 +666,23 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
         if (r)
                 return r;
 
-        r = hdmi_pll_init(pdev, &hdmi.pll);
+        r = hdmi_pll_init(pdev, &hdmi.pll, &hdmi.wp);
         if (r)
                 return r;
 
         r = hdmi_phy_init(pdev, &hdmi.phy);
         if (r)
-                return r;
+                goto err;
 
         r = hdmi4_core_init(pdev, &hdmi.core);
         if (r)
-                return r;
-
-        r = hdmi_get_clocks(pdev);
-        if (r) {
-                DSSERR("can't get clocks\n");
-                return r;
-        }
+                goto err;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
                 DSSERR("platform_get_irq failed\n");
-                return -ENODEV;
+                r = -ENODEV;
+                goto err;
         }
 
         r = devm_request_threaded_irq(&pdev->dev, irq,
@@ -720,22 +690,38 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
                         IRQF_ONESHOT, "OMAP HDMI", &hdmi.wp);
         if (r) {
                 DSSERR("HDMI IRQ request failed\n");
-                return r;
+                goto err;
         }
 
         pm_runtime_enable(&pdev->dev);
 
         hdmi_init_output(pdev);
 
+        r = hdmi_audio_register(&pdev->dev);
+        if (r) {
+                DSSERR("Registering HDMI audio failed\n");
+                hdmi_uninit_output(pdev);
+                pm_runtime_disable(&pdev->dev);
+                return r;
+        }
+
         dss_debugfs_create_file("hdmi", hdmi_dump_regs);
 
         return 0;
+err:
+        hdmi_pll_uninit(&hdmi.pll);
+        return r;
 }
 
 static int __exit omapdss_hdmihw_remove(struct platform_device *pdev)
 {
+        if (hdmi.audio_pdev)
+                platform_device_unregister(hdmi.audio_pdev);
+
         hdmi_uninit_output(pdev);
 
+        hdmi_pll_uninit(&hdmi.pll);
+
         pm_runtime_disable(&pdev->dev);
 
         return 0;
@@ -743,8 +729,6 @@ static int __exit omapdss_hdmihw_remove(struct platform_device *pdev)
 
 static int hdmi_runtime_suspend(struct device *dev)
 {
-        clk_disable_unprepare(hdmi.sys_clk);
-
         dispc_runtime_put();
 
         return 0;
@@ -758,8 +742,6 @@ static int hdmi_runtime_resume(struct device *dev)
         if (r < 0)
                 return r;
 
-        clk_prepare_enable(hdmi.sys_clk);
-
         return 0;
 }
 
diff --git a/drivers/video/fbdev/omap2/dss/hdmi4_core.c b/drivers/video/fbdev/omap2/dss/hdmi4_core.c
index 4ad39cfce254..7eafea5b8e19 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi4_core.c
+++ b/drivers/video/fbdev/omap2/dss/hdmi4_core.c
@@ -31,10 +31,8 @@
 #include <linux/platform_device.h>
 #include <linux/string.h>
 #include <linux/seq_file.h>
-#if defined(CONFIG_OMAP4_DSS_HDMI_AUDIO)
 #include <sound/asound.h>
 #include <sound/asoundef.h>
-#endif
 
 #include "hdmi4_core.h"
 #include "dss_features.h"
@@ -530,7 +528,6 @@ void hdmi4_core_dump(struct hdmi_core_data *core, struct seq_file *s)
         DUMPCOREAV(HDMI_CORE_AV_CEC_ADDR_ID);
 }
 
-#if defined(CONFIG_OMAP4_DSS_HDMI_AUDIO)
 static void hdmi_core_audio_config(struct hdmi_core_data *core,
                                         struct hdmi_core_audio_config *cfg)
 {
@@ -877,17 +874,6 @@ void hdmi4_audio_stop(struct hdmi_core_data *core, struct hdmi_wp_data *wp)
         hdmi_wp_audio_core_req_enable(wp, false);
 }
 
-int hdmi4_audio_get_dma_port(u32 *offset, u32 *size)
-{
-        if (!offset || !size)
-                return -EINVAL;
-        *offset = HDMI_WP_AUDIO_DATA;
-        *size = 4;
-        return 0;
-}
-
-#endif
-
 int hdmi4_core_init(struct platform_device *pdev, struct hdmi_core_data *core)
 {
         struct resource *res;
diff --git a/drivers/video/fbdev/omap2/dss/hdmi4_core.h b/drivers/video/fbdev/omap2/dss/hdmi4_core.h
index 827909eb6c50..a069f96ec6f6 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi4_core.h
+++ b/drivers/video/fbdev/omap2/dss/hdmi4_core.h
@@ -266,12 +266,8 @@ void hdmi4_configure(struct hdmi_core_data *core, struct hdmi_wp_data *wp,
 void hdmi4_core_dump(struct hdmi_core_data *core, struct seq_file *s);
 int hdmi4_core_init(struct platform_device *pdev, struct hdmi_core_data *core);
 
-#if defined(CONFIG_OMAP4_DSS_HDMI_AUDIO)
 int hdmi4_audio_start(struct hdmi_core_data *core, struct hdmi_wp_data *wp);
 void hdmi4_audio_stop(struct hdmi_core_data *core, struct hdmi_wp_data *wp);
 int hdmi4_audio_config(struct hdmi_core_data *core, struct hdmi_wp_data *wp,
                 struct omap_dss_audio *audio, u32 pclk);
-int hdmi4_audio_get_dma_port(u32 *offset, u32 *size);
-#endif
-
 #endif
diff --git a/drivers/video/fbdev/omap2/dss/hdmi5.c b/drivers/video/fbdev/omap2/dss/hdmi5.c
index 169b764bb9d4..d9d0d781625a 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi5.c
+++ b/drivers/video/fbdev/omap2/dss/hdmi5.c
@@ -38,29 +38,13 @@
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
 #include <video/omapdss.h>
+#include <sound/omap-hdmi-audio.h>
 
 #include "hdmi5_core.h"
 #include "dss.h"
 #include "dss_features.h"
 
-static struct {
-        struct mutex lock;
-        struct platform_device *pdev;
-
-        struct hdmi_wp_data     wp;
-        struct hdmi_pll_data    pll;
-        struct hdmi_phy_data    phy;
-        struct hdmi_core_data   core;
-
-        struct hdmi_config cfg;
-
-        struct clk *sys_clk;
-        struct regulator *vdda_reg;
-
-        bool core_enabled;
-
-        struct omap_dss_device output;
-} hdmi;
+static struct omap_hdmi hdmi;
 
 static int hdmi_runtime_get(void)
 {
@@ -198,7 +182,7 @@ static int hdmi_power_on_full(struct omap_dss_device *dssdev)
         int r;
         struct omap_video_timings *p;
         struct omap_overlay_manager *mgr = hdmi.output.manager;
-        unsigned long phy;
+        struct dss_pll_clock_info hdmi_cinfo = { 0 };
 
         r = hdmi_power_on_core(dssdev);
         if (r)
@@ -208,24 +192,27 @@ static int hdmi_power_on_full(struct omap_dss_device *dssdev)
 
         DSSDBG("hdmi_power_on x_res= %d y_res = %d\n", p->x_res, p->y_res);
 
-        /* the functions below use kHz pixel clock. TODO: change to Hz */
-        phy = p->pixelclock / 1000;
-
-        hdmi_pll_compute(&hdmi.pll, clk_get_rate(hdmi.sys_clk), phy);
+        hdmi_pll_compute(&hdmi.pll, p->pixelclock, &hdmi_cinfo);
 
         /* disable and clear irqs */
         hdmi_wp_clear_irqenable(&hdmi.wp, 0xffffffff);
         hdmi_wp_set_irqstatus(&hdmi.wp,
                         hdmi_wp_get_irqstatus(&hdmi.wp));
 
-        /* config the PLL and PHY hdmi_set_pll_pwrfirst */
-        r = hdmi_pll_enable(&hdmi.pll, &hdmi.wp);
+        r = dss_pll_enable(&hdmi.pll.pll);
         if (r) {
-                DSSDBG("Failed to lock PLL\n");
+                DSSERR("Failed to enable PLL\n");
                 goto err_pll_enable;
         }
 
-        r = hdmi_phy_configure(&hdmi.phy, &hdmi.cfg);
+        r = dss_pll_set_config(&hdmi.pll.pll, &hdmi_cinfo);
+        if (r) {
+                DSSERR("Failed to configure PLL\n");
+                goto err_pll_cfg;
+        }
+
+        r = hdmi_phy_configure(&hdmi.phy, hdmi_cinfo.clkdco,
+                hdmi_cinfo.clkout[0]);
         if (r) {
                 DSSDBG("Failed to start PHY\n");
                 goto err_phy_cfg;
@@ -262,7 +249,8 @@ err_vid_enable:
         hdmi_wp_set_phy_pwr(&hdmi.wp, HDMI_PHYPWRCMD_OFF);
 err_phy_pwr:
 err_phy_cfg:
-        hdmi_pll_disable(&hdmi.pll, &hdmi.wp);
+err_pll_cfg:
+        dss_pll_disable(&hdmi.pll.pll);
 err_pll_enable:
         hdmi_power_off_core(dssdev);
         return -EIO;
@@ -280,7 +268,7 @@ static void hdmi_power_off_full(struct omap_dss_device *dssdev)
 
         hdmi_wp_set_phy_pwr(&hdmi.wp, HDMI_PHYPWRCMD_OFF);
 
-        hdmi_pll_disable(&hdmi.pll, &hdmi.wp);
+        dss_pll_disable(&hdmi.pll.pll);
 
         hdmi_power_off_core(dssdev);
 }
@@ -290,6 +278,10 @@ static int hdmi_display_check_timing(struct omap_dss_device *dssdev,
 {
         struct omap_dss_device *out = &hdmi.output;
 
+        /* TODO: proper interlace support */
+        if (timings->interlace)
+                return -EINVAL;
+
         if (!dispc_mgr_timings_ok(out->dispc_channel, timings))
                 return -EINVAL;
 
@@ -377,6 +369,8 @@ static int hdmi_display_enable(struct omap_dss_device *dssdev)
                 goto err0;
         }
 
+        hdmi.display_enabled = true;
+
         mutex_unlock(&hdmi.lock);
         return 0;
 
@@ -391,8 +385,13 @@ static void hdmi_display_disable(struct omap_dss_device *dssdev)
 
         mutex_lock(&hdmi.lock);
 
+        if (hdmi.audio_pdev && hdmi.audio_abort_cb)
+                hdmi.audio_abort_cb(&hdmi.audio_pdev->dev);
+
         hdmi_power_off_full(dssdev);
 
+        hdmi.display_enabled = false;
+
         mutex_unlock(&hdmi.lock);
 }
 
@@ -429,21 +428,6 @@ static void hdmi_core_disable(struct omap_dss_device *dssdev)
         mutex_unlock(&hdmi.lock);
 }
 
-static int hdmi_get_clocks(struct platform_device *pdev)
-{
-        struct clk *clk;
-
-        clk = devm_clk_get(&pdev->dev, "sys_clk");
-        if (IS_ERR(clk)) {
-                DSSERR("can't get sys_clk\n");
-                return PTR_ERR(clk);
-        }
-
-        hdmi.sys_clk = clk;
-
-        return 0;
-}
-
 static int hdmi_connect(struct omap_dss_device *dssdev,
                 struct omap_dss_device *dst)
 {
@@ -509,112 +493,6 @@ static int hdmi_read_edid(struct omap_dss_device *dssdev,
         return r;
 }
 
-#if defined(CONFIG_OMAP5_DSS_HDMI_AUDIO)
-static int hdmi_audio_enable(struct omap_dss_device *dssdev)
-{
-        int r;
-
-        mutex_lock(&hdmi.lock);
-
-        if (!hdmi_mode_has_audio(hdmi.cfg.hdmi_dvi_mode)) {
-                r = -EPERM;
-                goto err;
-        }
-
-        r = hdmi_wp_audio_enable(&hdmi.wp, true);
-        if (r)
-                goto err;
-
-        mutex_unlock(&hdmi.lock);
-        return 0;
-
-err:
-        mutex_unlock(&hdmi.lock);
-        return r;
-}
-
-static void hdmi_audio_disable(struct omap_dss_device *dssdev)
-{
-        hdmi_wp_audio_enable(&hdmi.wp, false);
-}
-
-static int hdmi_audio_start(struct omap_dss_device *dssdev)
-{
-        return hdmi_wp_audio_core_req_enable(&hdmi.wp, true);
-}
-
-static void hdmi_audio_stop(struct omap_dss_device *dssdev)
-{
-        hdmi_wp_audio_core_req_enable(&hdmi.wp, false);
-}
-
-static bool hdmi_audio_supported(struct omap_dss_device *dssdev)
-{
-        bool r;
-
-        mutex_lock(&hdmi.lock);
-
-        r = hdmi_mode_has_audio(hdmi.cfg.hdmi_dvi_mode);
-
-        mutex_unlock(&hdmi.lock);
-        return r;
-}
-
-static int hdmi_audio_config(struct omap_dss_device *dssdev,
-                struct omap_dss_audio *audio)
-{
-        int r;
-        u32 pclk = hdmi.cfg.timings.pixelclock;
-
-        mutex_lock(&hdmi.lock);
-
-        if (!hdmi_mode_has_audio(hdmi.cfg.hdmi_dvi_mode)) {
-                r = -EPERM;
-                goto err;
-        }
-
-        r = hdmi5_audio_config(&hdmi.core, &hdmi.wp, audio, pclk);
-        if (r)
-                goto err;
-
-        mutex_unlock(&hdmi.lock);
-        return 0;
-
-err:
-        mutex_unlock(&hdmi.lock);
-        return r;
-}
-#else
-static int hdmi_audio_enable(struct omap_dss_device *dssdev)
-{
-        return -EPERM;
-}
-
-static void hdmi_audio_disable(struct omap_dss_device *dssdev)
-{
-}
-
-static int hdmi_audio_start(struct omap_dss_device *dssdev)
-{
-        return -EPERM;
-}
-
-static void hdmi_audio_stop(struct omap_dss_device *dssdev)
-{
-}
-
-static bool hdmi_audio_supported(struct omap_dss_device *dssdev)
-{
-        return false;
-}
-
-static int hdmi_audio_config(struct omap_dss_device *dssdev,
-                struct omap_dss_audio *audio)
-{
-        return -EPERM;
-}
-#endif
-
 static int hdmi_set_infoframe(struct omap_dss_device *dssdev,
                 const struct hdmi_avi_infoframe *avi)
 {
@@ -643,13 +521,6 @@ static const struct omapdss_hdmi_ops hdmi_ops = {
         .read_edid              = hdmi_read_edid,
         .set_infoframe          = hdmi_set_infoframe,
         .set_hdmi_mode          = hdmi_set_hdmi_mode,
-
-        .audio_enable           = hdmi_audio_enable,
-        .audio_disable          = hdmi_audio_disable,
-        .audio_start            = hdmi_audio_start,
-        .audio_stop             = hdmi_audio_stop,
-        .audio_supported        = hdmi_audio_supported,
-        .audio_config           = hdmi_audio_config,
 };
 
 static void hdmi_init_output(struct platform_device *pdev)
@@ -667,7 +538,7 @@ static void hdmi_init_output(struct platform_device *pdev)
         omapdss_register_output(out);
 }
 
-static void __exit hdmi_uninit_output(struct platform_device *pdev)
+static void hdmi_uninit_output(struct platform_device *pdev)
 {
         struct omap_dss_device *out = &hdmi.output;
 
@@ -696,6 +567,119 @@ err:
         return r;
 }
 
+/* Audio callbacks */
+static int hdmi_audio_startup(struct device *dev,
+                              void (*abort_cb)(struct device *dev))
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+        int ret = 0;
+
+        mutex_lock(&hd->lock);
+
+        if (!hdmi_mode_has_audio(&hd->cfg) || !hd->display_enabled) {
+                ret = -EPERM;
+                goto out;
+        }
+
+        hd->audio_abort_cb = abort_cb;
+
+out:
+        mutex_unlock(&hd->lock);
+
+        return ret;
+}
+
+static int hdmi_audio_shutdown(struct device *dev)
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+
+        mutex_lock(&hd->lock);
+        hd->audio_abort_cb = NULL;
+        mutex_unlock(&hd->lock);
+
+        return 0;
+}
+
+static int hdmi_audio_start(struct device *dev)
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+
+        WARN_ON(!hdmi_mode_has_audio(&hd->cfg));
+        WARN_ON(!hd->display_enabled);
+
+        /* No-idle while playing audio, store the old value */
+        hd->wp_idlemode = REG_GET(hdmi.wp.base, HDMI_WP_SYSCONFIG, 3, 2);
+        REG_FLD_MOD(hdmi.wp.base, HDMI_WP_SYSCONFIG, 1, 3, 2);
+
+        hdmi_wp_audio_enable(&hd->wp, true);
+        hdmi_wp_audio_core_req_enable(&hd->wp, true);
+
+        return 0;
+}
+
+static void hdmi_audio_stop(struct device *dev)
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+
+        WARN_ON(!hdmi_mode_has_audio(&hd->cfg));
+        WARN_ON(!hd->display_enabled);
+
+        hdmi_wp_audio_core_req_enable(&hd->wp, false);
+        hdmi_wp_audio_enable(&hd->wp, false);
+
+        /* Playback stopped, restore original idlemode */
+        REG_FLD_MOD(hdmi.wp.base, HDMI_WP_SYSCONFIG, hd->wp_idlemode, 3, 2);
+}
+
+static int hdmi_audio_config(struct device *dev,
+                             struct omap_dss_audio *dss_audio)
+{
+        struct omap_hdmi *hd = dev_get_drvdata(dev);
+        int ret;
+
+        mutex_lock(&hd->lock);
+
+        if (!hdmi_mode_has_audio(&hd->cfg) || !hd->display_enabled) {
+                ret = -EPERM;
+                goto out;
+        }
+
+        ret = hdmi5_audio_config(&hd->core, &hd->wp, dss_audio,
+                                 hd->cfg.timings.pixelclock);
+
+out:
+        mutex_unlock(&hd->lock);
+
+        return ret;
+}
+
+static const struct omap_hdmi_audio_ops hdmi_audio_ops = {
+        .audio_startup = hdmi_audio_startup,
+        .audio_shutdown = hdmi_audio_shutdown,
+        .audio_start = hdmi_audio_start,
+        .audio_stop = hdmi_audio_stop,
+        .audio_config = hdmi_audio_config,
+};
+
+static int hdmi_audio_register(struct device *dev)
+{
+        struct omap_hdmi_audio_pdata pdata = {
+                .dev = dev,
+                .dss_version = omapdss_get_version(),
+                .audio_dma_addr = hdmi_wp_get_audio_dma_addr(&hdmi.wp),
+                .ops = &hdmi_audio_ops,
+        };
+
+        hdmi.audio_pdev = platform_device_register_data(
+                dev, "omap-hdmi-audio", PLATFORM_DEVID_AUTO,
+                &pdata, sizeof(pdata));
+
+        if (IS_ERR(hdmi.audio_pdev))
+                return PTR_ERR(hdmi.audio_pdev);
+
+        return 0;
+}
+
 /* HDMI HW IP initialisation */
 static int omapdss_hdmihw_probe(struct platform_device *pdev)
 {
@@ -703,6 +687,7 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
         int irq;
 
         hdmi.pdev = pdev;
+        dev_set_drvdata(&pdev->dev, &hdmi);
 
         mutex_init(&hdmi.lock);
 
@@ -716,28 +701,23 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
         if (r)
                 return r;
 
-        r = hdmi_pll_init(pdev, &hdmi.pll);
+        r = hdmi_pll_init(pdev, &hdmi.pll, &hdmi.wp);
         if (r)
                 return r;
 
         r = hdmi_phy_init(pdev, &hdmi.phy);
         if (r)
-                return r;
+                goto err;
 
         r = hdmi5_core_init(pdev, &hdmi.core);
         if (r)
-                return r;
-
-        r = hdmi_get_clocks(pdev);
-        if (r) {
-                DSSERR("can't get clocks\n");
-                return r;
-        }
+                goto err;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
                 DSSERR("platform_get_irq failed\n");
-                return -ENODEV;
+                r = -ENODEV;
+                goto err;
         }
 
         r = devm_request_threaded_irq(&pdev->dev, irq,
@@ -745,22 +725,38 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
                         IRQF_ONESHOT, "OMAP HDMI", &hdmi.wp);
         if (r) {
                 DSSERR("HDMI IRQ request failed\n");
-                return r;
+                goto err;
         }
 
         pm_runtime_enable(&pdev->dev);
 
         hdmi_init_output(pdev);
 
+        r = hdmi_audio_register(&pdev->dev);
+        if (r) {
+                DSSERR("Registering HDMI audio failed %d\n", r);
+                hdmi_uninit_output(pdev);
+                pm_runtime_disable(&pdev->dev);
+                return r;
+        }
+
         dss_debugfs_create_file("hdmi", hdmi_dump_regs);
 
         return 0;
+err:
+        hdmi_pll_uninit(&hdmi.pll);
+        return r;
 }
 
 static int __exit omapdss_hdmihw_remove(struct platform_device *pdev)
 {
+        if (hdmi.audio_pdev)
+                platform_device_unregister(hdmi.audio_pdev);
+
         hdmi_uninit_output(pdev);
 
+        hdmi_pll_uninit(&hdmi.pll);
+
         pm_runtime_disable(&pdev->dev);
 
         return 0;
@@ -768,8 +764,6 @@ static int __exit omapdss_hdmihw_remove(struct platform_device *pdev)
 
 static int hdmi_runtime_suspend(struct device *dev)
 {
-        clk_disable_unprepare(hdmi.sys_clk);
-
         dispc_runtime_put();
 
         return 0;
@@ -783,8 +777,6 @@ static int hdmi_runtime_resume(struct device *dev)
         if (r < 0)
                 return r;
 
-        clk_prepare_enable(hdmi.sys_clk);
-
         return 0;
 }
 
diff --git a/drivers/video/fbdev/omap2/dss/hdmi5_core.c b/drivers/video/fbdev/omap2/dss/hdmi5_core.c
index 83acbf7a8c89..a3cfe3d708f7 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi5_core.c
+++ b/drivers/video/fbdev/omap2/dss/hdmi5_core.c
@@ -30,10 +30,8 @@
 #include <linux/string.h>
 #include <linux/seq_file.h>
 #include <drm/drm_edid.h>
-#if defined(CONFIG_OMAP5_DSS_HDMI_AUDIO)
 #include <sound/asound.h>
 #include <sound/asoundef.h>
-#endif
 
 #include "hdmi5_core.h"
 
@@ -644,9 +642,6 @@ void hdmi5_configure(struct hdmi_core_data *core, struct hdmi_wp_data *wp,
         hdmi_core_enable_interrupts(core);
 }
 
-
-#if defined(CONFIG_OMAP5_DSS_HDMI_AUDIO)
-
 static void hdmi5_core_audio_config(struct hdmi_core_data *core,
                         struct hdmi_core_audio_config *cfg)
 {
@@ -721,7 +716,7 @@ static void hdmi5_core_audio_config(struct hdmi_core_data *core,
 
         /* Source number */
         val = cfg->iec60958_cfg->status[2] & IEC958_AES2_CON_SOURCE;
-        REG_FLD_MOD(base, HDMI_CORE_FC_AUDSCHNLS(2), val, 3, 4);
+        REG_FLD_MOD(base, HDMI_CORE_FC_AUDSCHNLS(2), val, 3, 0);
 
         /* Channel number right 0  */
         REG_FLD_MOD(base, HDMI_CORE_FC_AUDSCHNLS(3), 2, 3, 0);
@@ -879,6 +874,9 @@ int hdmi5_audio_config(struct hdmi_core_data *core, struct hdmi_wp_data *wp,
         /* only LPCM atm */
         audio_format.type = HDMI_AUDIO_TYPE_LPCM;
 
+        /* only allowed option */
+        audio_format.sample_order = HDMI_AUDIO_SAMPLE_LEFT_FIRST;
+
         /* disable start/stop signals of IEC 60958 blocks */
         audio_format.en_sig_blk_strt_end = HDMI_AUDIO_BLOCK_SIG_STARTEND_ON;
 
@@ -894,7 +892,6 @@ int hdmi5_audio_config(struct hdmi_core_data *core, struct hdmi_wp_data *wp,
 
         return 0;
 }
-#endif
 
 int hdmi5_core_init(struct platform_device *pdev, struct hdmi_core_data *core)
 {
diff --git a/drivers/video/fbdev/omap2/dss/hdmi5_core.h b/drivers/video/fbdev/omap2/dss/hdmi5_core.h
index ce7e9f376f04..f2f1022c5516 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi5_core.h
+++ b/drivers/video/fbdev/omap2/dss/hdmi5_core.h
@@ -299,8 +299,6 @@ void hdmi5_configure(struct hdmi_core_data *core, struct hdmi_wp_data *wp,
                         struct hdmi_config *cfg);
 int hdmi5_core_init(struct platform_device *pdev, struct hdmi_core_data *core);
 
-#if defined(CONFIG_OMAP5_DSS_HDMI_AUDIO)
 int hdmi5_audio_config(struct hdmi_core_data *core, struct hdmi_wp_data *wp,
                         struct omap_dss_audio *audio, u32 pclk);
 #endif
-#endif
diff --git a/drivers/video/fbdev/omap2/dss/hdmi_common.c b/drivers/video/fbdev/omap2/dss/hdmi_common.c
index 7d5f1039de9f..1b8fcc6c4ba1 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi_common.c
+++ b/drivers/video/fbdev/omap2/dss/hdmi_common.c
@@ -48,7 +48,6 @@ int hdmi_parse_lanes_of(struct platform_device *pdev, struct device_node *ep,
         return 0;
 }
 
-#if defined(CONFIG_OMAP4_DSS_HDMI_AUDIO)
 int hdmi_compute_acr(u32 pclk, u32 sample_freq, u32 *n, u32 *cts)
 {
         u32 deep_color;
@@ -147,4 +146,3 @@ int hdmi_compute_acr(u32 pclk, u32 sample_freq, u32 *n, u32 *cts)
 
         return 0;
 }
-#endif
diff --git a/drivers/video/fbdev/omap2/dss/hdmi_phy.c b/drivers/video/fbdev/omap2/dss/hdmi_phy.c
index e007ac892d79..bc9e07d2afbe 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi_phy.c
+++ b/drivers/video/fbdev/omap2/dss/hdmi_phy.c
@@ -20,9 +20,7 @@
 
 struct hdmi_phy_features {
         bool bist_ctrl;
-        bool calc_freqout;
         bool ldo_voltage;
-        unsigned long dcofreq_min;
         unsigned long max_phy;
 };
 
@@ -132,7 +130,8 @@ static void hdmi_phy_configure_lanes(struct hdmi_phy_data *phy)
         REG_FLD_MOD(phy->base, HDMI_TXPHY_PAD_CFG_CTRL, pol_val, 30, 27);
 }
 
-int hdmi_phy_configure(struct hdmi_phy_data *phy, struct hdmi_config *cfg)
+int hdmi_phy_configure(struct hdmi_phy_data *phy, unsigned long hfbitclk,
+        unsigned long lfbitclk)
 {
         u8 freqout;
 
@@ -149,20 +148,16 @@ int hdmi_phy_configure(struct hdmi_phy_data *phy, struct hdmi_config *cfg)
         if (phy_feat->bist_ctrl)
                 REG_FLD_MOD(phy->base, HDMI_TXPHY_BIST_CONTROL, 1, 11, 11);
 
-        if (phy_feat->calc_freqout) {
-                /* DCOCLK/10 is pixel clock, compare pclk with DCOCLK_MIN/10 */
-                u32 dco_min = phy_feat->dcofreq_min / 10;
-                u32 pclk = cfg->timings.pixelclock;
-
-                if (pclk < dco_min)
-                        freqout = 0;
-                else if ((pclk >= dco_min) && (pclk < phy_feat->max_phy))
-                        freqout = 1;
-                else
-                        freqout = 2;
-        } else {
+        /*
+         * If the hfbitclk != lfbitclk, it means the lfbitclk was configured
+         * to be used for TMDS.
+         */
+        if (hfbitclk != lfbitclk)
+                freqout = 0;
+        else if (hfbitclk / 10 < phy_feat->max_phy)
                 freqout = 1;
-        }
+        else
+                freqout = 2;
 
         /*
          * Write to phy address 0 to configure the clock
@@ -184,17 +179,13 @@ int hdmi_phy_configure(struct hdmi_phy_data *phy, struct hdmi_config *cfg)
 
 static const struct hdmi_phy_features omap44xx_phy_feats = {
         .bist_ctrl      =       false,
-        .calc_freqout   =       false,
         .ldo_voltage    =       true,
-        .dcofreq_min    =       500000000,
         .max_phy        =       185675000,
 };
 
 static const struct hdmi_phy_features omap54xx_phy_feats = {
         .bist_ctrl      =       true,
-        .calc_freqout   =       true,
         .ldo_voltage    =       false,
-        .dcofreq_min    =       750000000,
         .max_phy        =       186000000,
 };
 
diff --git a/drivers/video/fbdev/omap2/dss/hdmi_pll.c b/drivers/video/fbdev/omap2/dss/hdmi_pll.c
index 6d92bb32fe51..87accdb59c81 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi_pll.c
+++ b/drivers/video/fbdev/omap2/dss/hdmi_pll.c
@@ -15,26 +15,13 @@
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
+#include <linux/clk.h>
+
 #include <video/omapdss.h>
 
 #include "dss.h"
 #include "hdmi.h"
 
-#define HDMI_DEFAULT_REGN 16
-#define HDMI_DEFAULT_REGM2 1
-
-struct hdmi_pll_features {
-        bool sys_reset;
-        /* this is a hack, need to replace it with a better computation of M2 */
-        bool bound_dcofreq;
-        unsigned long fint_min, fint_max;
-        u16 regm_max;
-        unsigned long dcofreq_low_min, dcofreq_low_max;
-        unsigned long dcofreq_high_min, dcofreq_high_max;
-};
-
-static const struct hdmi_pll_features *pll_feat;
-
 void hdmi_pll_dump(struct hdmi_pll_data *pll, struct seq_file *s)
 {
 #define DUMPPLL(r) seq_printf(s, "%-35s %08x\n", #r,\
@@ -51,228 +38,189 @@ void hdmi_pll_dump(struct hdmi_pll_data *pll, struct seq_file *s)
         DUMPPLL(PLLCTRL_CFG4);
 }
 
-void hdmi_pll_compute(struct hdmi_pll_data *pll, unsigned long clkin, int phy)
+void hdmi_pll_compute(struct hdmi_pll_data *pll,
+        unsigned long target_tmds, struct dss_pll_clock_info *pi)
 {
-        struct hdmi_pll_info *pi = &pll->info;
-        unsigned long refclk;
-        u32 mf;
+        unsigned long fint, clkdco, clkout;
+        unsigned long target_bitclk, target_clkdco;
+        unsigned long min_dco;
+        unsigned n, m, mf, m2, sd;
+        unsigned long clkin;
+        const struct dss_pll_hw *hw = pll->pll.hw;
 
-        /* use our funky units */
-        clkin /= 10000;
+        clkin = clk_get_rate(pll->pll.clkin);
 
-        /*
-         * Input clock is predivided by N + 1
-         * out put of which is reference clk
-         */
+        DSSDBG("clkin %lu, target tmds %lu\n", clkin, target_tmds);
 
-        pi->regn = HDMI_DEFAULT_REGN;
+        target_bitclk = target_tmds * 10;
 
-        refclk = clkin / pi->regn;
+        /* Fint */
+        n = DIV_ROUND_UP(clkin, hw->fint_max);
+        fint = clkin / n;
 
-        /* temorary hack to make sure DCO freq isn't calculated too low */
-        if (pll_feat->bound_dcofreq && phy <= 65000)
-                pi->regm2 = 3;
-        else
-                pi->regm2 = HDMI_DEFAULT_REGM2;
-
-        /*
-         * multiplier is pixel_clk/ref_clk
-         * Multiplying by 100 to avoid fractional part removal
-         */
-        pi->regm = phy * pi->regm2 / refclk;
-
-        /*
-         * fractional multiplier is remainder of the difference between
-         * multiplier and actual phy(required pixel clock thus should be
-         * multiplied by 2^18(262144) divided by the reference clock
-         */
-        mf = (phy - pi->regm / pi->regm2 * refclk) * 262144;
-        pi->regmf = pi->regm2 * mf / refclk;
-
-        /*
-         * Dcofreq should be set to 1 if required pixel clock
-         * is greater than 1000MHz
-         */
-        pi->dcofreq = phy > 1000 * 100;
-        pi->regsd = ((pi->regm * clkin / 10) / (pi->regn * 250) + 5) / 10;
-
-        /* Set the reference clock to sysclk reference */
-        pi->refsel = HDMI_REFSEL_SYSCLK;
-
-        DSSDBG("M = %d Mf = %d\n", pi->regm, pi->regmf);
-        DSSDBG("range = %d sd = %d\n", pi->dcofreq, pi->regsd);
-}
+        /* adjust m2 so that the clkdco will be high enough */
+        min_dco = roundup(hw->clkdco_min, fint);
+        m2 = DIV_ROUND_UP(min_dco, target_bitclk);
+        if (m2 == 0)
+                m2 = 1;
 
+        target_clkdco = target_bitclk * m2;
+        m = target_clkdco / fint;
 
-static int hdmi_pll_config(struct hdmi_pll_data *pll)
-{
-        u32 r;
-        struct hdmi_pll_info *fmt = &pll->info;
+        clkdco = fint * m;
 
-        /* PLL start always use manual mode */
-        REG_FLD_MOD(pll->base, PLLCTRL_PLL_CONTROL, 0x0, 0, 0);
-
-        r = hdmi_read_reg(pll->base, PLLCTRL_CFG1);
-        r = FLD_MOD(r, fmt->regm, 20, 9);       /* CFG1_PLL_REGM */
-        r = FLD_MOD(r, fmt->regn - 1, 8, 1);    /* CFG1_PLL_REGN */
-        hdmi_write_reg(pll->base, PLLCTRL_CFG1, r);
-
-        r = hdmi_read_reg(pll->base, PLLCTRL_CFG2);
-
-        r = FLD_MOD(r, 0x0, 12, 12);    /* PLL_HIGHFREQ divide by 2 */
-        r = FLD_MOD(r, 0x1, 13, 13);    /* PLL_REFEN */
-        r = FLD_MOD(r, 0x0, 14, 14);    /* PHY_CLKINEN de-assert during locking */
-        r = FLD_MOD(r, fmt->refsel, 22, 21);    /* REFSEL */
-
-        if (fmt->dcofreq)
-                r = FLD_MOD(r, 0x4, 3, 1);      /* 1000MHz and 2000MHz */
+        /* adjust clkdco with fractional mf */
+        if (WARN_ON(target_clkdco - clkdco > fint))
+                mf = 0;
         else
-                r = FLD_MOD(r, 0x2, 3, 1);      /* 500MHz and 1000MHz */
-
-        hdmi_write_reg(pll->base, PLLCTRL_CFG2, r);
-
-        REG_FLD_MOD(pll->base, PLLCTRL_CFG3, fmt->regsd, 17, 10);
+                mf = (u32)div_u64(262144ull * (target_clkdco - clkdco), fint);
 
-        r = hdmi_read_reg(pll->base, PLLCTRL_CFG4);
-        r = FLD_MOD(r, fmt->regm2, 24, 18);
-        r = FLD_MOD(r, fmt->regmf, 17, 0);
-        hdmi_write_reg(pll->base, PLLCTRL_CFG4, r);
+        if (mf > 0)
+                clkdco += (u32)div_u64((u64)mf * fint, 262144);
 
-        /* go now */
-        REG_FLD_MOD(pll->base, PLLCTRL_PLL_GO, 0x1, 0, 0);
+        clkout = clkdco / m2;
 
-        /* wait for bit change */
-        if (hdmi_wait_for_bit_change(pll->base, PLLCTRL_PLL_GO,
-                        0, 0, 0) != 0) {
-                DSSERR("PLL GO bit not clearing\n");
-                return -ETIMEDOUT;
-        }
+        /* sigma-delta */
+        sd = DIV_ROUND_UP(fint * m, 250000000);
 
-        /* Wait till the lock bit is set in PLL status */
-        if (hdmi_wait_for_bit_change(pll->base,
-                        PLLCTRL_PLL_STATUS, 1, 1, 1) != 1) {
-                DSSERR("cannot lock PLL\n");
-                DSSERR("CFG1 0x%x\n",
-                        hdmi_read_reg(pll->base, PLLCTRL_CFG1));
-                DSSERR("CFG2 0x%x\n",
-                        hdmi_read_reg(pll->base, PLLCTRL_CFG2));
-                DSSERR("CFG4 0x%x\n",
-                        hdmi_read_reg(pll->base, PLLCTRL_CFG4));
-                return -ETIMEDOUT;
-        }
+        DSSDBG("N = %u, M = %u, M.f = %u, M2 = %u, SD = %u\n",
+                n, m, mf, m2, sd);
+        DSSDBG("Fint %lu, clkdco %lu, clkout %lu\n", fint, clkdco, clkout);
 
-        DSSDBG("PLL locked!\n");
+        pi->n = n;
+        pi->m = m;
+        pi->mf = mf;
+        pi->mX[0] = m2;
+        pi->sd = sd;
 
-        return 0;
+        pi->fint = fint;
+        pi->clkdco = clkdco;
+        pi->clkout[0] = clkout;
 }
 
-static int hdmi_pll_reset(struct hdmi_pll_data *pll)
-{
-        /* SYSRESET  controlled by power FSM */
-        REG_FLD_MOD(pll->base, PLLCTRL_PLL_CONTROL, pll_feat->sys_reset, 3, 3);
-
-        /* READ 0x0 reset is in progress */
-        if (hdmi_wait_for_bit_change(pll->base, PLLCTRL_PLL_STATUS, 0, 0, 1)
-                        != 1) {
-                DSSERR("Failed to sysreset PLL\n");
-                return -ETIMEDOUT;
-        }
-
-        return 0;
-}
-
-int hdmi_pll_enable(struct hdmi_pll_data *pll, struct hdmi_wp_data *wp)
+static int hdmi_pll_enable(struct dss_pll *dsspll)
 {
+        struct hdmi_pll_data *pll = container_of(dsspll, struct hdmi_pll_data, pll);
+        struct hdmi_wp_data *wp = pll->wp;
         u16 r = 0;
 
-        r = hdmi_wp_set_pll_pwr(wp, HDMI_PLLPWRCMD_ALLOFF);
-        if (r)
-                return r;
-
         r = hdmi_wp_set_pll_pwr(wp, HDMI_PLLPWRCMD_BOTHON_ALLCLKS);
         if (r)
                 return r;
 
-        r = hdmi_pll_reset(pll);
-        if (r)
-                return r;
-
-        r = hdmi_pll_config(pll);
-        if (r)
-                return r;
-
         return 0;
 }
 
-void hdmi_pll_disable(struct hdmi_pll_data *pll, struct hdmi_wp_data *wp)
+static void hdmi_pll_disable(struct dss_pll *dsspll)
 {
+        struct hdmi_pll_data *pll = container_of(dsspll, struct hdmi_pll_data, pll);
+        struct hdmi_wp_data *wp = pll->wp;
+
         hdmi_wp_set_pll_pwr(wp, HDMI_PLLPWRCMD_ALLOFF);
 }
 
-static const struct hdmi_pll_features omap44xx_pll_feats = {
-        .sys_reset              =       false,
-        .bound_dcofreq          =       false,
-        .fint_min               =       500000,
-        .fint_max               =       2500000,
-        .regm_max               =       4095,
-        .dcofreq_low_min        =       500000000,
-        .dcofreq_low_max        =       1000000000,
-        .dcofreq_high_min       =       1000000000,
-        .dcofreq_high_max       =       2000000000,
+static const struct dss_pll_ops dsi_pll_ops = {
+        .enable = hdmi_pll_enable,
+        .disable = hdmi_pll_disable,
+        .set_config = dss_pll_write_config_type_b,
 };
 
-static const struct hdmi_pll_features omap54xx_pll_feats = {
-        .sys_reset              =       true,
-        .bound_dcofreq          =       true,
-        .fint_min               =       620000,
-        .fint_max               =       2500000,
-        .regm_max               =       2046,
-        .dcofreq_low_min        =       750000000,
-        .dcofreq_low_max        =       1500000000,
-        .dcofreq_high_min       =       1250000000,
-        .dcofreq_high_max       =       2500000000UL,
+static const struct dss_pll_hw dss_omap4_hdmi_pll_hw = {
+        .n_max = 255,
+        .m_min = 20,
+        .m_max = 4095,
+        .mX_max = 127,
+        .fint_min = 500000,
+        .fint_max = 2500000,
+        .clkdco_max = 1800000000,
+
+        .clkdco_min = 500000000,
+        .clkdco_low = 1000000000,
+        .clkdco_max = 2000000000,
+
+        .n_msb = 8,
+        .n_lsb = 1,
+        .m_msb = 20,
+        .m_lsb = 9,
+
+        .mX_msb[0] = 24,
+        .mX_lsb[0] = 18,
+
+        .has_selfreqdco = true,
 };
 
-static int hdmi_pll_init_features(struct platform_device *pdev)
+static const struct dss_pll_hw dss_omap5_hdmi_pll_hw = {
+        .n_max = 255,
+        .m_min = 20,
+        .m_max = 2045,
+        .mX_max = 127,
+        .fint_min = 620000,
+        .fint_max = 2500000,
+        .clkdco_max = 1800000000,
+
+        .clkdco_min = 750000000,
+        .clkdco_low = 1500000000,
+        .clkdco_max = 2500000000UL,
+
+        .n_msb = 8,
+        .n_lsb = 1,
+        .m_msb = 20,
+        .m_lsb = 9,
+
+        .mX_msb[0] = 24,
+        .mX_lsb[0] = 18,
+
+        .has_selfreqdco = true,
+        .has_refsel = true,
+};
+
+static int dsi_init_pll_data(struct platform_device *pdev, struct hdmi_pll_data *hpll)
 {
-        struct hdmi_pll_features *dst;
-        const struct hdmi_pll_features *src;
+        struct dss_pll *pll = &hpll->pll;
+        struct clk *clk;
+        int r;
 
-        dst = devm_kzalloc(&pdev->dev, sizeof(*dst), GFP_KERNEL);
-        if (!dst) {
-                dev_err(&pdev->dev, "Failed to allocate HDMI PHY Features\n");
-                return -ENOMEM;
+        clk = devm_clk_get(&pdev->dev, "sys_clk");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get sys_clk\n");
+                return PTR_ERR(clk);
         }
 
+        pll->name = "hdmi";
+        pll->base = hpll->base;
+        pll->clkin = clk;
+
         switch (omapdss_get_version()) {
         case OMAPDSS_VER_OMAP4430_ES1:
         case OMAPDSS_VER_OMAP4430_ES2:
         case OMAPDSS_VER_OMAP4:
-                src = &omap44xx_pll_feats;
+                pll->hw = &dss_omap4_hdmi_pll_hw;
                 break;
 
         case OMAPDSS_VER_OMAP5:
-                src = &omap54xx_pll_feats;
+                pll->hw = &dss_omap5_hdmi_pll_hw;
                 break;
 
         default:
                 return -ENODEV;
         }
 
-        memcpy(dst, src, sizeof(*dst));
-        pll_feat = dst;
+        pll->ops = &dsi_pll_ops;
+
+        r = dss_pll_register(pll);
+        if (r)
+                return r;
 
         return 0;
 }
 
-int hdmi_pll_init(struct platform_device *pdev, struct hdmi_pll_data *pll)
+int hdmi_pll_init(struct platform_device *pdev, struct hdmi_pll_data *pll,
+        struct hdmi_wp_data *wp)
 {
         int r;
         struct resource *res;
 
-        r = hdmi_pll_init_features(pdev);
-        if (r)
-                return r;
+        pll->wp = wp;
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pll");
         if (!res) {
@@ -286,5 +234,18 @@ int hdmi_pll_init(struct platform_device *pdev, struct hdmi_pll_data *pll)
                 return PTR_ERR(pll->base);
         }
 
+        r = dsi_init_pll_data(pdev, pll);
+        if (r) {
+                DSSERR("failed to init HDMI PLL\n");
+                return r;
+        }
+
         return 0;
 }
+
+void hdmi_pll_uninit(struct hdmi_pll_data *hpll)
+{
+        struct dss_pll *pll = &hpll->pll;
+
+        dss_pll_unregister(pll);
+}
diff --git a/drivers/video/fbdev/omap2/dss/hdmi_wp.c b/drivers/video/fbdev/omap2/dss/hdmi_wp.c
index 496327e2b21b..c15377e242cc 100644
--- a/drivers/video/fbdev/omap2/dss/hdmi_wp.c
+++ b/drivers/video/fbdev/omap2/dss/hdmi_wp.c
@@ -185,7 +185,6 @@ void hdmi_wp_init_vid_fmt_timings(struct hdmi_video_format *video_fmt,
         timings->interlace = param->timings.interlace;
 }
 
-#if defined(CONFIG_OMAP4_DSS_HDMI_AUDIO) || defined(CONFIG_OMAP5_DSS_HDMI_AUDIO)
 void hdmi_wp_audio_config_format(struct hdmi_wp_data *wp,
                 struct hdmi_audio_format *aud_fmt)
 {
@@ -194,8 +193,12 @@ void hdmi_wp_audio_config_format(struct hdmi_wp_data *wp,
         DSSDBG("Enter hdmi_wp_audio_config_format\n");
 
         r = hdmi_read_reg(wp->base, HDMI_WP_AUDIO_CFG);
-        r = FLD_MOD(r, aud_fmt->stereo_channels, 26, 24);
-        r = FLD_MOD(r, aud_fmt->active_chnnls_msk, 23, 16);
+        if (omapdss_get_version() == OMAPDSS_VER_OMAP4430_ES1 ||
+            omapdss_get_version() == OMAPDSS_VER_OMAP4430_ES2 ||
+            omapdss_get_version() == OMAPDSS_VER_OMAP4) {
+                r = FLD_MOD(r, aud_fmt->stereo_channels, 26, 24);
+                r = FLD_MOD(r, aud_fmt->active_chnnls_msk, 23, 16);
+        }
         r = FLD_MOD(r, aud_fmt->en_sig_blk_strt_end, 5, 5);
         r = FLD_MOD(r, aud_fmt->type, 4, 4);
         r = FLD_MOD(r, aud_fmt->justification, 3, 3);
@@ -236,7 +239,6 @@ int hdmi_wp_audio_core_req_enable(struct hdmi_wp_data *wp, bool enable)
 
         return 0;
 }
-#endif
 
 int hdmi_wp_init(struct platform_device *pdev, struct hdmi_wp_data *wp)
 {
@@ -247,6 +249,7 @@ int hdmi_wp_init(struct platform_device *pdev, struct hdmi_wp_data *wp)
                 DSSERR("can't get WP mem resource\n");
                 return -EINVAL;
         }
+        wp->phys_base = res->start;
 
         wp->base = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(wp->base)) {
@@ -256,3 +259,8 @@ int hdmi_wp_init(struct platform_device *pdev, struct hdmi_wp_data *wp)
 
         return 0;
 }
+
+phys_addr_t hdmi_wp_get_audio_dma_addr(struct hdmi_wp_data *wp)
+{
+        return wp->phys_base + HDMI_WP_AUDIO_DATA;
+}
diff --git a/drivers/video/fbdev/omap2/dss/output.c b/drivers/video/fbdev/omap2/dss/output.c
index 2ab3afa615e8..16072159bd24 100644
--- a/drivers/video/fbdev/omap2/dss/output.c
+++ b/drivers/video/fbdev/omap2/dss/output.c
@@ -19,6 +19,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
+#include <linux/of.h>
 
 #include <video/omapdss.h>
 
@@ -131,18 +132,30 @@ struct omap_dss_device *omap_dss_find_output(const char *name)
 }
 EXPORT_SYMBOL(omap_dss_find_output);
 
-struct omap_dss_device *omap_dss_find_output_by_node(struct device_node *node)
+struct omap_dss_device *omap_dss_find_output_by_port_node(struct device_node *port)
 {
+        struct device_node *src_node;
         struct omap_dss_device *out;
+        u32 reg;
+
+        src_node = dss_of_port_get_parent_device(port);
+        if (!src_node)
+                return NULL;
+
+        reg = dss_of_port_get_port_number(port);
 
         list_for_each_entry(out, &output_list, list) {
-                if (out->dev->of_node == node)
+                if (out->dev->of_node == src_node && out->port_num == reg) {
+                        of_node_put(src_node);
                         return omap_dss_get_device(out);
+                }
         }
 
+        of_node_put(src_node);
+
         return NULL;
 }
-EXPORT_SYMBOL(omap_dss_find_output_by_node);
+EXPORT_SYMBOL(omap_dss_find_output_by_port_node);
 
 struct omap_dss_device *omapdss_find_output_from_display(struct omap_dss_device *dssdev)
 {
diff --git a/drivers/video/fbdev/omap2/dss/pll.c b/drivers/video/fbdev/omap2/dss/pll.c
new file mode 100644
index 000000000000..50bc62c5d367
--- /dev/null
+++ b/drivers/video/fbdev/omap2/dss/pll.c
@@ -0,0 +1,378 @@
+/*
+ * Copyright (C) 2014 Texas Instruments Incorporated
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define DSS_SUBSYS_NAME "PLL"
+
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/regulator/consumer.h>
+#include <linux/sched.h>
+
+#include <video/omapdss.h>
+
+#include "dss.h"
+
+#define PLL_CONTROL                     0x0000
+#define PLL_STATUS                      0x0004
+#define PLL_GO                          0x0008
+#define PLL_CONFIGURATION1              0x000C
+#define PLL_CONFIGURATION2              0x0010
+#define PLL_CONFIGURATION3              0x0014
+#define PLL_SSC_CONFIGURATION1          0x0018
+#define PLL_SSC_CONFIGURATION2          0x001C
+#define PLL_CONFIGURATION4              0x0020
+
+static struct dss_pll *dss_plls[4];
+
+int dss_pll_register(struct dss_pll *pll)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(dss_plls); ++i) {
+                if (!dss_plls[i]) {
+                        dss_plls[i] = pll;
+                        return 0;
+                }
+        }
+
+        return -EBUSY;
+}
+
+void dss_pll_unregister(struct dss_pll *pll)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(dss_plls); ++i) {
+                if (dss_plls[i] == pll) {
+                        dss_plls[i] = NULL;
+                        return;
+                }
+        }
+}
+
+struct dss_pll *dss_pll_find(const char *name)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(dss_plls); ++i) {
+                if (dss_plls[i] && strcmp(dss_plls[i]->name, name) == 0)
+                        return dss_plls[i];
+        }
+
+        return NULL;
+}
+
+int dss_pll_enable(struct dss_pll *pll)
+{
+        int r;
+
+        r = clk_prepare_enable(pll->clkin);
+        if (r)
+                return r;
+
+        if (pll->regulator) {
+                r = regulator_enable(pll->regulator);
+                if (r)
+                        goto err_reg;
+        }
+
+        r = pll->ops->enable(pll);
+        if (r)
+                goto err_enable;
+
+        return 0;
+
+err_enable:
+        regulator_disable(pll->regulator);
+err_reg:
+        clk_disable_unprepare(pll->clkin);
+        return r;
+}
+
+void dss_pll_disable(struct dss_pll *pll)
+{
+        pll->ops->disable(pll);
+
+        if (pll->regulator)
+                regulator_disable(pll->regulator);
+
+        clk_disable_unprepare(pll->clkin);
+
+        memset(&pll->cinfo, 0, sizeof(pll->cinfo));
+}
+
+int dss_pll_set_config(struct dss_pll *pll, const struct dss_pll_clock_info *cinfo)
+{
+        int r;
+
+        r = pll->ops->set_config(pll, cinfo);
+        if (r)
+                return r;
+
+        pll->cinfo = *cinfo;
+
+        return 0;
+}
+
+bool dss_pll_hsdiv_calc(const struct dss_pll *pll, unsigned long clkdco,
+                unsigned long out_min, unsigned long out_max,
+                dss_hsdiv_calc_func func, void *data)
+{
+        const struct dss_pll_hw *hw = pll->hw;
+        int m, m_start, m_stop;
+        unsigned long out;
+
+        out_min = out_min ? out_min : 1;
+        out_max = out_max ? out_max : ULONG_MAX;
+
+        m_start = max(DIV_ROUND_UP(clkdco, out_max), 1ul);
+
+        m_stop = min((unsigned)(clkdco / out_min), hw->mX_max);
+
+        for (m = m_start; m <= m_stop; ++m) {
+                out = clkdco / m;
+
+                if (func(m, out, data))
+                        return true;
+        }
+
+        return false;
+}
+
+bool dss_pll_calc(const struct dss_pll *pll, unsigned long clkin,
+                unsigned long pll_min, unsigned long pll_max,
+                dss_pll_calc_func func, void *data)
+{
+        const struct dss_pll_hw *hw = pll->hw;
+        int n, n_start, n_stop;
+        int m, m_start, m_stop;
+        unsigned long fint, clkdco;
+        unsigned long pll_hw_max;
+        unsigned long fint_hw_min, fint_hw_max;
+
+        pll_hw_max = hw->clkdco_max;
+
+        fint_hw_min = hw->fint_min;
+        fint_hw_max = hw->fint_max;
+
+        n_start = max(DIV_ROUND_UP(clkin, fint_hw_max), 1ul);
+        n_stop = min((unsigned)(clkin / fint_hw_min), hw->n_max);
+
+        pll_max = pll_max ? pll_max : ULONG_MAX;
+
+        for (n = n_start; n <= n_stop; ++n) {
+                fint = clkin / n;
+
+                m_start = max(DIV_ROUND_UP(DIV_ROUND_UP(pll_min, fint), 2),
+                                1ul);
+                m_stop = min3((unsigned)(pll_max / fint / 2),
+                                (unsigned)(pll_hw_max / fint / 2),
+                                hw->m_max);
+
+                for (m = m_start; m <= m_stop; ++m) {
+                        clkdco = 2 * m * fint;
+
+                        if (func(n, m, fint, clkdco, data))
+                                return true;
+                }
+        }
+
+        return false;
+}
+
+static int wait_for_bit_change(void __iomem *reg, int bitnum, int value)
+{
+        unsigned long timeout;
+        ktime_t wait;
+        int t;
+
+        /* first busyloop to see if the bit changes right away */
+        t = 100;
+        while (t-- > 0) {
+                if (FLD_GET(readl_relaxed(reg), bitnum, bitnum) == value)
+                        return value;
+        }
+
+        /* then loop for 500ms, sleeping for 1ms in between */
+        timeout = jiffies + msecs_to_jiffies(500);
+        while (time_before(jiffies, timeout)) {
+                if (FLD_GET(readl_relaxed(reg), bitnum, bitnum) == value)
+                        return value;
+
+                wait = ns_to_ktime(1000 * 1000);
+                set_current_state(TASK_UNINTERRUPTIBLE);
+                schedule_hrtimeout(&wait, HRTIMER_MODE_REL);
+        }
+
+        return !value;
+}
+
+static int dss_wait_hsdiv_ack(struct dss_pll *pll, u32 hsdiv_ack_mask)
+{
+        int t = 100;
+
+        while (t-- > 0) {
+                u32 v = readl_relaxed(pll->base + PLL_STATUS);
+                v &= hsdiv_ack_mask;
+                if (v == hsdiv_ack_mask)
+                        return 0;
+        }
+
+        return -ETIMEDOUT;
+}
+
+int dss_pll_write_config_type_a(struct dss_pll *pll,
+                const struct dss_pll_clock_info *cinfo)
+{
+        const struct dss_pll_hw *hw = pll->hw;
+        void __iomem *base = pll->base;
+        int r = 0;
+        u32 l;
+
+        l = 0;
+        if (hw->has_stopmode)
+                l = FLD_MOD(l, 1, 0, 0);                /* PLL_STOPMODE */
+        l = FLD_MOD(l, cinfo->n - 1, hw->n_msb, hw->n_lsb);     /* PLL_REGN */
+        l = FLD_MOD(l, cinfo->m, hw->m_msb, hw->m_lsb);         /* PLL_REGM */
+        /* M4 */
+        l = FLD_MOD(l, cinfo->mX[0] ? cinfo->mX[0] - 1 : 0,
+                        hw->mX_msb[0], hw->mX_lsb[0]);
+        /* M5 */
+        l = FLD_MOD(l, cinfo->mX[1] ? cinfo->mX[1] - 1 : 0,
+                        hw->mX_msb[1], hw->mX_lsb[1]);
+        writel_relaxed(l, base + PLL_CONFIGURATION1);
+
+        l = 0;
+        /* M6 */
+        l = FLD_MOD(l, cinfo->mX[2] ? cinfo->mX[2] - 1 : 0,
+                        hw->mX_msb[2], hw->mX_lsb[2]);
+        /* M7 */
+        l = FLD_MOD(l, cinfo->mX[3] ? cinfo->mX[3] - 1 : 0,
+                        hw->mX_msb[3], hw->mX_lsb[3]);
+        writel_relaxed(l, base + PLL_CONFIGURATION3);
+
+        l = readl_relaxed(base + PLL_CONFIGURATION2);
+        if (hw->has_freqsel) {
+                u32 f = cinfo->fint < 1000000 ? 0x3 :
+                        cinfo->fint < 1250000 ? 0x4 :
+                        cinfo->fint < 1500000 ? 0x5 :
+                        cinfo->fint < 1750000 ? 0x6 :
+                        0x7;
+
+                l = FLD_MOD(l, f, 4, 1);        /* PLL_FREQSEL */
+        } else if (hw->has_selfreqdco) {
+                u32 f = cinfo->clkdco < hw->clkdco_low ? 0x2 : 0x4;
+
+                l = FLD_MOD(l, f, 3, 1);        /* PLL_SELFREQDCO */
+        }
+        l = FLD_MOD(l, 1, 13, 13);              /* PLL_REFEN */
+        l = FLD_MOD(l, 0, 14, 14);              /* PHY_CLKINEN */
+        l = FLD_MOD(l, 0, 16, 16);              /* M4_CLOCK_EN */
+        l = FLD_MOD(l, 0, 18, 18);              /* M5_CLOCK_EN */
+        l = FLD_MOD(l, 1, 20, 20);              /* HSDIVBYPASS */
+        if (hw->has_refsel)
+                l = FLD_MOD(l, 3, 22, 21);      /* REFSEL = sysclk */
+        l = FLD_MOD(l, 0, 23, 23);              /* M6_CLOCK_EN */
+        l = FLD_MOD(l, 0, 25, 25);              /* M7_CLOCK_EN */
+        writel_relaxed(l, base + PLL_CONFIGURATION2);
+
+        writel_relaxed(1, base + PLL_GO);       /* PLL_GO */
+
+        if (wait_for_bit_change(base + PLL_GO, 0, 0) != 0) {
+                DSSERR("DSS DPLL GO bit not going down.\n");
+                r = -EIO;
+                goto err;
+        }
+
+        if (wait_for_bit_change(base + PLL_STATUS, 1, 1) != 1) {
+                DSSERR("cannot lock DSS DPLL\n");
+                r = -EIO;
+                goto err;
+        }
+
+        l = readl_relaxed(base + PLL_CONFIGURATION2);
+        l = FLD_MOD(l, 1, 14, 14);                      /* PHY_CLKINEN */
+        l = FLD_MOD(l, cinfo->mX[0] ? 1 : 0, 16, 16);   /* M4_CLOCK_EN */
+        l = FLD_MOD(l, cinfo->mX[1] ? 1 : 0, 18, 18);   /* M5_CLOCK_EN */
+        l = FLD_MOD(l, 0, 20, 20);                      /* HSDIVBYPASS */
+        l = FLD_MOD(l, cinfo->mX[2] ? 1 : 0, 23, 23);   /* M6_CLOCK_EN */
+        l = FLD_MOD(l, cinfo->mX[3] ? 1 : 0, 25, 25);   /* M7_CLOCK_EN */
+        writel_relaxed(l, base + PLL_CONFIGURATION2);
+
+        r = dss_wait_hsdiv_ack(pll,
+                (cinfo->mX[0] ? BIT(7) : 0) |
+                (cinfo->mX[1] ? BIT(8) : 0) |
+                (cinfo->mX[2] ? BIT(10) : 0) |
+                (cinfo->mX[3] ? BIT(11) : 0));
+        if (r) {
+                DSSERR("failed to enable HSDIV clocks\n");
+                goto err;
+        }
+
+err:
+        return r;
+}
+
+int dss_pll_write_config_type_b(struct dss_pll *pll,
+                const struct dss_pll_clock_info *cinfo)
+{
+        const struct dss_pll_hw *hw = pll->hw;
+        void __iomem *base = pll->base;
+        u32 l;
+
+        l = 0;
+        l = FLD_MOD(l, cinfo->m, 20, 9);        /* PLL_REGM */
+        l = FLD_MOD(l, cinfo->n - 1, 8, 1);     /* PLL_REGN */
+        writel_relaxed(l, base + PLL_CONFIGURATION1);
+
+        l = readl_relaxed(base + PLL_CONFIGURATION2);
+        l = FLD_MOD(l, 0x0, 12, 12);    /* PLL_HIGHFREQ divide by 2 */
+        l = FLD_MOD(l, 0x1, 13, 13);    /* PLL_REFEN */
+        l = FLD_MOD(l, 0x0, 14, 14);    /* PHY_CLKINEN */
+        if (hw->has_refsel)
+                l = FLD_MOD(l, 0x3, 22, 21);    /* REFSEL = SYSCLK */
+
+        /* PLL_SELFREQDCO */
+        if (cinfo->clkdco > hw->clkdco_low)
+                l = FLD_MOD(l, 0x4, 3, 1);
+        else
+                l = FLD_MOD(l, 0x2, 3, 1);
+        writel_relaxed(l, base + PLL_CONFIGURATION2);
+
+        l = readl_relaxed(base + PLL_CONFIGURATION3);
+        l = FLD_MOD(l, cinfo->sd, 17, 10);      /* PLL_REGSD */
+        writel_relaxed(l, base + PLL_CONFIGURATION3);
+
+        l = readl_relaxed(base + PLL_CONFIGURATION4);
+        l = FLD_MOD(l, cinfo->mX[0], 24, 18);   /* PLL_REGM2 */
+        l = FLD_MOD(l, cinfo->mf, 17, 0);       /* PLL_REGM_F */
+        writel_relaxed(l, base + PLL_CONFIGURATION4);
+
+        writel_relaxed(1, base + PLL_GO);       /* PLL_GO */
+
+        if (wait_for_bit_change(base + PLL_GO, 0, 0) != 0) {
+                DSSERR("DSS DPLL GO bit not going down.\n");
+                return -EIO;
+        }
+
+        if (wait_for_bit_change(base + PLL_STATUS, 1, 1) != 1) {
+                DSSERR("cannot lock DSS DPLL\n");
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
diff --git a/drivers/video/fbdev/omap2/dss/sdi.c b/drivers/video/fbdev/omap2/dss/sdi.c
index 4c9c46d4ea60..d9b10f27be20 100644
--- a/drivers/video/fbdev/omap2/dss/sdi.c
+++ b/drivers/video/fbdev/omap2/dss/sdi.c
@@ -425,7 +425,7 @@ err_datapairs:
         return r;
 }
 
-void __exit sdi_uninit_port(void)
+void __exit sdi_uninit_port(struct device_node *port)
 {
         if (!sdi.port_initialized)
                 return;
diff --git a/drivers/video/fbdev/s3fb.c b/drivers/video/fbdev/s3fb.c
index c43b969e1e23..f0ae61a37f04 100644
--- a/drivers/video/fbdev/s3fb.c
+++ b/drivers/video/fbdev/s3fb.c
@@ -1182,7 +1182,7 @@ static int s3_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         pcibios_bus_to_resource(dev->bus, &vga_res, &bus_reg);
 
-        par->state.vgabase = (void __iomem *) vga_res.start;
+        par->state.vgabase = (void __iomem *) (unsigned long) vga_res.start;
 
         /* Unlock regs */
         cr38 = vga_rcrt(par->state.vgabase, 0x38);
diff --git a/drivers/video/fbdev/sh_mobile_lcdcfb.c b/drivers/video/fbdev/sh_mobile_lcdcfb.c
index 2bcc84ac18c7..cfde21d81c15 100644
--- a/drivers/video/fbdev/sh_mobile_lcdcfb.c
+++ b/drivers/video/fbdev/sh_mobile_lcdcfb.c
@@ -2181,8 +2181,7 @@ sh_mobile_lcdc_channel_fb_cleanup(struct sh_mobile_lcdc_chan *ch)
         if (!info || !info->device)
                 return;
 
-        if (ch->sglist)
-                vfree(ch->sglist);
+        vfree(ch->sglist);
 
         fb_dealloc_cmap(&info->cmap);
         framebuffer_release(info);
diff --git a/drivers/video/fbdev/simplefb.c b/drivers/video/fbdev/simplefb.c
index 210f3a02121a..b2ae9254fd75 100644
--- a/drivers/video/fbdev/simplefb.c
+++ b/drivers/video/fbdev/simplefb.c
@@ -26,6 +26,8 @@
 #include <linux/module.h>
 #include <linux/platform_data/simplefb.h>
 #include <linux/platform_device.h>
+#include <linux/clk-provider.h>
+#include <linux/of_platform.h>
 
 static struct fb_fix_screeninfo simplefb_fix = {
         .id             = "simple",
@@ -41,6 +43,8 @@ static struct fb_var_screeninfo simplefb_var = {
         .vmode          = FB_VMODE_NONINTERLACED,
 };
 
+#define PSEUDO_PALETTE_SIZE 16
+
 static int simplefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
                               u_int transp, struct fb_info *info)
 {
@@ -50,7 +54,7 @@ static int simplefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
         u32 cb = blue >> (16 - info->var.blue.length);
         u32 value;
 
-        if (regno >= 16)
+        if (regno >= PSEUDO_PALETTE_SIZE)
                 return -EINVAL;
 
         value = (cr << info->var.red.offset) |
@@ -163,11 +167,113 @@ static int simplefb_parse_pd(struct platform_device *pdev,
         return 0;
 }
 
+struct simplefb_par {
+        u32 palette[PSEUDO_PALETTE_SIZE];
+#if defined CONFIG_OF && defined CONFIG_COMMON_CLK
+        int clk_count;
+        struct clk **clks;
+#endif
+};
+
+#if defined CONFIG_OF && defined CONFIG_COMMON_CLK
+/*
+ * Clock handling code.
+ *
+ * Here we handle the clocks property of our "simple-framebuffer" dt node.
+ * This is necessary so that we can make sure that any clocks needed by
+ * the display engine that the bootloader set up for us (and for which it
+ * provided a simplefb dt node), stay up, for the life of the simplefb
+ * driver.
+ *
+ * When the driver unloads, we cleanly disable, and then release the clocks.
+ *
+ * We only complain about errors here, no action is taken as the most likely
+ * error can only happen due to a mismatch between the bootloader which set
+ * up simplefb, and the clock definitions in the device tree. Chances are
+ * that there are no adverse effects, and if there are, a clean teardown of
+ * the fb probe will not help us much either. So just complain and carry on,
+ * and hope that the user actually gets a working fb at the end of things.
+ */
+static int simplefb_clocks_init(struct simplefb_par *par,
+                                struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct clk *clock;
+        int i, ret;
+
+        if (dev_get_platdata(&pdev->dev) || !np)
+                return 0;
+
+        par->clk_count = of_clk_get_parent_count(np);
+        if (par->clk_count <= 0)
+                return 0;
+
+        par->clks = kcalloc(par->clk_count, sizeof(struct clk *), GFP_KERNEL);
+        if (!par->clks)
+                return -ENOMEM;
+
+        for (i = 0; i < par->clk_count; i++) {
+                clock = of_clk_get(np, i);
+                if (IS_ERR(clock)) {
+                        if (PTR_ERR(clock) == -EPROBE_DEFER) {
+                                while (--i >= 0) {
+                                        if (par->clks[i])
+                                                clk_put(par->clks[i]);
+                                }
+                                kfree(par->clks);
+                                return -EPROBE_DEFER;
+                        }
+                        dev_err(&pdev->dev, "%s: clock %d not found: %ld\n",
+                                __func__, i, PTR_ERR(clock));
+                        continue;
+                }
+                par->clks[i] = clock;
+        }
+
+        for (i = 0; i < par->clk_count; i++) {
+                if (par->clks[i]) {
+                        ret = clk_prepare_enable(par->clks[i]);
+                        if (ret) {
+                                dev_err(&pdev->dev,
+                                        "%s: failed to enable clock %d: %d\n",
+                                        __func__, i, ret);
+                                clk_put(par->clks[i]);
+                                par->clks[i] = NULL;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+static void simplefb_clocks_destroy(struct simplefb_par *par)
+{
+        int i;
+
+        if (!par->clks)
+                return;
+
+        for (i = 0; i < par->clk_count; i++) {
+                if (par->clks[i]) {
+                        clk_disable_unprepare(par->clks[i]);
+                        clk_put(par->clks[i]);
+                }
+        }
+
+        kfree(par->clks);
+}
+#else
+static int simplefb_clocks_init(struct simplefb_par *par,
+        struct platform_device *pdev) { return 0; }
+static void simplefb_clocks_destroy(struct simplefb_par *par) { }
+#endif
+
 static int simplefb_probe(struct platform_device *pdev)
 {
         int ret;
         struct simplefb_params params;
         struct fb_info *info;
+        struct simplefb_par *par;
         struct resource *mem;
 
         if (fb_get_options("simplefb", NULL))
@@ -188,11 +294,13 @@ static int simplefb_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        info = framebuffer_alloc(sizeof(u32) * 16, &pdev->dev);
+        info = framebuffer_alloc(sizeof(struct simplefb_par), &pdev->dev);
         if (!info)
                 return -ENOMEM;
         platform_set_drvdata(pdev, info);
 
+        par = info->par;
+
         info->fix = simplefb_fix;
         info->fix.smem_start = mem->start;
         info->fix.smem_len = resource_size(mem);
@@ -211,8 +319,8 @@ static int simplefb_probe(struct platform_device *pdev)
 
         info->apertures = alloc_apertures(1);
         if (!info->apertures) {
-                framebuffer_release(info);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto error_fb_release;
         }
         info->apertures->ranges[0].base = info->fix.smem_start;
         info->apertures->ranges[0].size = info->fix.smem_len;
@@ -222,10 +330,14 @@ static int simplefb_probe(struct platform_device *pdev)
         info->screen_base = ioremap_wc(info->fix.smem_start,
                                        info->fix.smem_len);
         if (!info->screen_base) {
-                framebuffer_release(info);
-                return -ENODEV;
+                ret = -ENOMEM;
+                goto error_fb_release;
         }
-        info->pseudo_palette = (void *)(info + 1);
+        info->pseudo_palette = par->palette;
+
+        ret = simplefb_clocks_init(par, pdev);
+        if (ret < 0)
+                goto error_unmap;
 
         dev_info(&pdev->dev, "framebuffer at 0x%lx, 0x%x bytes, mapped to 0x%p\n",
                              info->fix.smem_start, info->fix.smem_len,
@@ -238,21 +350,29 @@ static int simplefb_probe(struct platform_device *pdev)
         ret = register_framebuffer(info);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Unable to register simplefb: %d\n", ret);
-                iounmap(info->screen_base);
-                framebuffer_release(info);
-                return ret;
+                goto error_clocks;
         }
 
         dev_info(&pdev->dev, "fb%d: simplefb registered!\n", info->node);
 
         return 0;
+
+error_clocks:
+        simplefb_clocks_destroy(par);
+error_unmap:
+        iounmap(info->screen_base);
+error_fb_release:
+        framebuffer_release(info);
+        return ret;
 }
 
 static int simplefb_remove(struct platform_device *pdev)
 {
         struct fb_info *info = platform_get_drvdata(pdev);
+        struct simplefb_par *par = info->par;
 
         unregister_framebuffer(info);
+        simplefb_clocks_destroy(par);
         framebuffer_release(info);
 
         return 0;
@@ -273,7 +393,27 @@ static struct platform_driver simplefb_driver = {
         .probe = simplefb_probe,
         .remove = simplefb_remove,
 };
-module_platform_driver(simplefb_driver);
+
+static int __init simplefb_init(void)
+{
+        int ret;
+        struct device_node *np;
+
+        ret = platform_driver_register(&simplefb_driver);
+        if (ret)
+                return ret;
+
+        if (IS_ENABLED(CONFIG_OF) && of_chosen) {
+                for_each_child_of_node(of_chosen, np) {
+                        if (of_device_is_compatible(np, "simple-framebuffer"))
+                                of_platform_device_create(np, NULL, NULL);
+                }
+        }
+
+        return 0;
+}
+
+fs_initcall(simplefb_init);
 
 MODULE_AUTHOR("Stephen Warren <swarren@wwwdotorg.org>");
 MODULE_DESCRIPTION("Simple framebuffer driver");
diff --git a/drivers/video/fbdev/sis/sis_main.c b/drivers/video/fbdev/sis/sis_main.c
index e5d11b1892e8..fcf610edf217 100644
--- a/drivers/video/fbdev/sis/sis_main.c
+++ b/drivers/video/fbdev/sis/sis_main.c
@@ -5989,7 +5989,7 @@ static int sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         if(!ivideo->sisvga_enabled) {
                 if(pci_enable_device(pdev)) {
-                        if(ivideo->nbridge) pci_dev_put(ivideo->nbridge);
+                        pci_dev_put(ivideo->nbridge);
                         framebuffer_release(sis_fb_info);
                         return -EIO;
                 }
@@ -6202,10 +6202,8 @@ error_0:	iounmap(ivideo->video_vbase);
 error_1:        release_mem_region(ivideo->video_base, ivideo->video_size);
 error_2:        release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
 error_3:        vfree(ivideo->bios_abase);
-                if(ivideo->lpcdev)
-                        pci_dev_put(ivideo->lpcdev);
-                if(ivideo->nbridge)
-                        pci_dev_put(ivideo->nbridge);
+                pci_dev_put(ivideo->lpcdev);
+                pci_dev_put(ivideo->nbridge);
                 if(!ivideo->sisvga_enabled)
                         pci_disable_device(pdev);
                 framebuffer_release(sis_fb_info);
@@ -6505,11 +6503,9 @@ static void sisfb_remove(struct pci_dev *pdev)
 
         vfree(ivideo->bios_abase);
 
-        if(ivideo->lpcdev)
-                pci_dev_put(ivideo->lpcdev);
+        pci_dev_put(ivideo->lpcdev);
 
-        if(ivideo->nbridge)
-                pci_dev_put(ivideo->nbridge);
+        pci_dev_put(ivideo->nbridge);
 
 #ifdef CONFIG_MTRR
         /* Release MTRR region */
diff --git a/drivers/video/fbdev/sm501fb.c b/drivers/video/fbdev/sm501fb.c
index 9e74e8fbe074..8b98b011fc04 100644
--- a/drivers/video/fbdev/sm501fb.c
+++ b/drivers/video/fbdev/sm501fb.c
@@ -1988,6 +1988,7 @@ static int sm501fb_probe(struct platform_device *pdev)
         if (info->fb[HEAD_PANEL] == NULL &&
             info->fb[HEAD_CRT] == NULL) {
                 dev_err(dev, "no framebuffers found\n");
+                ret = -ENODEV;
                 goto err_alloc;
         }
 
diff --git a/drivers/video/fbdev/smscufx.c b/drivers/video/fbdev/smscufx.c
index d513ed6a49f2..9279e5f6696e 100644
--- a/drivers/video/fbdev/smscufx.c
+++ b/drivers/video/fbdev/smscufx.c
@@ -1142,8 +1142,7 @@ static void ufx_free_framebuffer_work(struct work_struct *work)
                 fb_dealloc_cmap(&info->cmap);
         if (info->monspecs.modedb)
                 fb_destroy_modedb(info->monspecs.modedb);
-        if (info->screen_base)
-                vfree(info->screen_base);
+        vfree(info->screen_base);
 
         fb_destroy_modelist(&info->modelist);
 
@@ -1743,8 +1742,7 @@ error:
                                 fb_dealloc_cmap(&info->cmap);
                         if (info->monspecs.modedb)
                                 fb_destroy_modedb(info->monspecs.modedb);
-                        if (info->screen_base)
-                                vfree(info->screen_base);
+                        vfree(info->screen_base);
 
                         fb_destroy_modelist(&info->modelist);
 
diff --git a/drivers/video/fbdev/udlfb.c b/drivers/video/fbdev/udlfb.c
index 046d51d83d74..ff2b8731a2dc 100644
--- a/drivers/video/fbdev/udlfb.c
+++ b/drivers/video/fbdev/udlfb.c
@@ -922,8 +922,7 @@ static void dlfb_free(struct kref *kref)
 {
         struct dlfb_data *dev = container_of(kref, struct dlfb_data, kref);
 
-        if (dev->backing_buffer)
-                vfree(dev->backing_buffer);
+        vfree(dev->backing_buffer);
 
         kfree(dev->edid);
 
@@ -953,8 +952,7 @@ static void dlfb_free_framebuffer(struct dlfb_data *dev)
                         fb_dealloc_cmap(&info->cmap);
                 if (info->monspecs.modedb)
                         fb_destroy_modedb(info->monspecs.modedb);
-                if (info->screen_base)
-                        vfree(info->screen_base);
+                vfree(info->screen_base);
 
                 fb_destroy_modelist(&info->modelist);
 
@@ -1203,8 +1201,7 @@ static int dlfb_realloc_framebuffer(struct dlfb_data *dev, struct fb_info *info)
                 if (!new_back)
                         pr_info("No shadow/backing buffer allocated\n");
                 else {
-                        if (dev->backing_buffer)
-                                vfree(dev->backing_buffer);
+                        vfree(dev->backing_buffer);
                         dev->backing_buffer = new_back;
                 }
         }
diff --git a/drivers/video/fbdev/uvesafb.c b/drivers/video/fbdev/uvesafb.c
index 509d452e8f91..d32d1c4d1b99 100644
--- a/drivers/video/fbdev/uvesafb.c
+++ b/drivers/video/fbdev/uvesafb.c
@@ -1219,8 +1219,7 @@ static int uvesafb_release(struct fb_info *info, int user)
         uvesafb_vbe_state_restore(par, par->vbe_state_orig);
 out:
         atomic_dec(&par->ref_count);
-        if (task)
-                uvesafb_free(task);
+        uvesafb_free(task);
         return 0;
 }
 
@@ -1923,8 +1922,7 @@ static int uvesafb_init(void)
                         err = -ENOMEM;
 
                 if (err) {
-                        if (uvesafb_device)
-                                platform_device_put(uvesafb_device);
+                        platform_device_put(uvesafb_device);
                         platform_driver_unregister(&uvesafb_driver);
                         cn_del_callback(&uvesafb_cn_id);
                         return err;
diff --git a/drivers/video/fbdev/vermilion/vermilion.c b/drivers/video/fbdev/vermilion/vermilion.c
index 5f930aeccf1f..6b70d7f62b2f 100644
--- a/drivers/video/fbdev/vermilion/vermilion.c
+++ b/drivers/video/fbdev/vermilion/vermilion.c
@@ -1003,13 +1003,15 @@ static int vmlfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
         struct vml_info *vinfo = container_of(info, struct vml_info, info);
         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
         int ret;
+        unsigned long prot;
 
         ret = vmlfb_vram_offset(vinfo, offset);
         if (ret)
                 return -EINVAL;
 
-        pgprot_val(vma->vm_page_prot) |= _PAGE_PCD;
-        pgprot_val(vma->vm_page_prot) &= ~_PAGE_PWT;
+        prot = pgprot_val(vma->vm_page_prot) & ~_PAGE_CACHE_MASK;
+        pgprot_val(vma->vm_page_prot) =
+                prot | cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS);
 
         return vm_iomap_memory(vma, vinfo->vram_start,
                         vinfo->vram_contig_size);
diff --git a/drivers/video/fbdev/via/viafbdev.c b/drivers/video/fbdev/via/viafbdev.c
index 325c43c6ff97..f9718f012aae 100644
--- a/drivers/video/fbdev/via/viafbdev.c
+++ b/drivers/video/fbdev/via/viafbdev.c
@@ -1937,8 +1937,7 @@ out_fb1_unreg_lcd_cle266:
 out_dealloc_cmap:
         fb_dealloc_cmap(&viafbinfo->cmap);
 out_fb1_release:
-        if (viafbinfo1)
-                framebuffer_release(viafbinfo1);
+        framebuffer_release(viafbinfo1);
 out_fb_release:
         i2c_bus_free(viaparinfo->shared);
         framebuffer_release(viafbinfo);
diff --git a/drivers/video/fbdev/vt8623fb.c b/drivers/video/fbdev/vt8623fb.c
index 5c7cbc6c6236..ea7f056ed5fe 100644
--- a/drivers/video/fbdev/vt8623fb.c
+++ b/drivers/video/fbdev/vt8623fb.c
@@ -731,7 +731,7 @@ static int vt8623_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         pcibios_bus_to_resource(dev->bus, &vga_res, &bus_reg);
 
-        par->state.vgabase = (void __iomem *) vga_res.start;
+        par->state.vgabase = (void __iomem *) (unsigned long) vga_res.start;
 
         /* Find how many physical memory there is on card */
         memsize1 = (vga_rseq(par->state.vgabase, 0x34) + 1) >> 1;
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index 9076635697bb..bf5104b56894 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -1,4 +1,5 @@
 obj-$(CONFIG_VIRTIO) += virtio.o virtio_ring.o
 obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o
 obj-$(CONFIG_VIRTIO_PCI) += virtio_pci.o
+virtio_pci-y := virtio_pci_legacy.o virtio_pci_common.o
 obj-$(CONFIG_VIRTIO_BALLOON) += virtio_balloon.o
diff --git a/drivers/virtio/virtio.c b/drivers/virtio/virtio.c
index df598dd8c5c8..f22665868781 100644
--- a/drivers/virtio/virtio.c
+++ b/drivers/virtio/virtio.c
@@ -3,6 +3,7 @@
 #include <linux/virtio_config.h>
 #include <linux/module.h>
 #include <linux/idr.h>
+#include <uapi/linux/virtio_ids.h>
 
 /* Unique numbering for virtio devices. */
 static DEFINE_IDA(virtio_index_ida);
@@ -49,9 +50,9 @@ static ssize_t features_show(struct device *_d,
 
         /* We actually represent this as a bitstring, as it could be
          * arbitrary length in future. */
-        for (i = 0; i < ARRAY_SIZE(dev->features)*BITS_PER_LONG; i++)
+        for (i = 0; i < sizeof(dev->features)*8; i++)
                 len += sprintf(buf+len, "%c",
-                               test_bit(i, dev->features) ? '1' : '0');
+                               __virtio_test_bit(dev, i) ? '1' : '0');
         len += sprintf(buf+len, "\n");
         return len;
 }
@@ -113,6 +114,13 @@ void virtio_check_driver_offered_feature(const struct virtio_device *vdev,
         for (i = 0; i < drv->feature_table_size; i++)
                 if (drv->feature_table[i] == fbit)
                         return;
+
+        if (drv->feature_table_legacy) {
+                for (i = 0; i < drv->feature_table_size_legacy; i++)
+                        if (drv->feature_table_legacy[i] == fbit)
+                                return;
+        }
+
         BUG();
 }
 EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature);
@@ -159,7 +167,10 @@ static int virtio_dev_probe(struct device *_d)
         int err, i;
         struct virtio_device *dev = dev_to_virtio(_d);
         struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
-        u32 device_features;
+        u64 device_features;
+        u64 driver_features;
+        u64 driver_features_legacy;
+        unsigned status;
 
         /* We have a driver! */
         add_status(dev, VIRTIO_CONFIG_S_DRIVER);
@@ -167,34 +178,66 @@ static int virtio_dev_probe(struct device *_d)
         /* Figure out what features the device supports. */
         device_features = dev->config->get_features(dev);
 
-        /* Features supported by both device and driver into dev->features. */
-        memset(dev->features, 0, sizeof(dev->features));
+        /* Figure out what features the driver supports. */
+        driver_features = 0;
         for (i = 0; i < drv->feature_table_size; i++) {
                 unsigned int f = drv->feature_table[i];
-                BUG_ON(f >= 32);
-                if (device_features & (1 << f))
-                        set_bit(f, dev->features);
+                BUG_ON(f >= 64);
+                driver_features |= (1ULL << f);
+        }
+
+        /* Some drivers have a separate feature table for virtio v1.0 */
+        if (drv->feature_table_legacy) {
+                driver_features_legacy = 0;
+                for (i = 0; i < drv->feature_table_size_legacy; i++) {
+                        unsigned int f = drv->feature_table_legacy[i];
+                        BUG_ON(f >= 64);
+                        driver_features_legacy |= (1ULL << f);
+                }
+        } else {
+                driver_features_legacy = driver_features;
         }
 
+        if (device_features & (1ULL << VIRTIO_F_VERSION_1))
+                dev->features = driver_features & device_features;
+        else
+                dev->features = driver_features_legacy & device_features;
+
         /* Transport features always preserved to pass to finalize_features. */
         for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)
-                if (device_features & (1 << i))
-                        set_bit(i, dev->features);
+                if (device_features & (1ULL << i))
+                        __virtio_set_bit(dev, i);
 
-        dev->config->finalize_features(dev);
+        err = dev->config->finalize_features(dev);
+        if (err)
+                goto err;
+
+        if (virtio_has_feature(dev, VIRTIO_F_VERSION_1)) {
+                add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK);
+                status = dev->config->get_status(dev);
+                if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
+                        dev_err(_d, "virtio: device refuses features: %x\n",
+                               status);
+                        err = -ENODEV;
+                        goto err;
+                }
+        }
 
         err = drv->probe(dev);
         if (err)
-                add_status(dev, VIRTIO_CONFIG_S_FAILED);
-        else {
-                add_status(dev, VIRTIO_CONFIG_S_DRIVER_OK);
-                if (drv->scan)
-                        drv->scan(dev);
+                goto err;
 
-                virtio_config_enable(dev);
-        }
+        add_status(dev, VIRTIO_CONFIG_S_DRIVER_OK);
+        if (drv->scan)
+                drv->scan(dev);
+
+        virtio_config_enable(dev);
 
+        return 0;
+err:
+        add_status(dev, VIRTIO_CONFIG_S_FAILED);
         return err;
+
 }
 
 static int virtio_dev_remove(struct device *_d)
@@ -223,6 +266,12 @@ static struct bus_type virtio_bus = {
         .remove = virtio_dev_remove,
 };
 
+bool virtio_device_is_legacy_only(struct virtio_device_id id)
+{
+        return id.device == VIRTIO_ID_BALLOON;
+}
+EXPORT_SYMBOL_GPL(virtio_device_is_legacy_only);
+
 int register_virtio_driver(struct virtio_driver *driver)
 {
         /* Catch this early. */
@@ -303,6 +352,7 @@ EXPORT_SYMBOL_GPL(virtio_device_freeze);
 int virtio_device_restore(struct virtio_device *dev)
 {
         struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
+        int ret;
 
         /* We always start by resetting the device, in case a previous
          * driver messed it up. */
@@ -322,14 +372,14 @@ int virtio_device_restore(struct virtio_device *dev)
         /* We have a driver! */
         add_status(dev, VIRTIO_CONFIG_S_DRIVER);
 
-        dev->config->finalize_features(dev);
+        ret = dev->config->finalize_features(dev);
+        if (ret)
+                goto err;
 
         if (drv->restore) {
-                int ret = drv->restore(dev);
-                if (ret) {
-                        add_status(dev, VIRTIO_CONFIG_S_FAILED);
-                        return ret;
-                }
+                ret = drv->restore(dev);
+                if (ret)
+                        goto err;
         }
 
         /* Finally, tell the device we're all set */
@@ -338,6 +388,10 @@ int virtio_device_restore(struct virtio_device *dev)
         virtio_config_enable(dev);
 
         return 0;
+
+err:
+        add_status(dev, VIRTIO_CONFIG_S_FAILED);
+        return ret;
 }
 EXPORT_SYMBOL_GPL(virtio_device_restore);
 #endif
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
index ef9a1650bb80..5219210d31ce 100644
--- a/drivers/virtio/virtio_mmio.c
+++ b/drivers/virtio/virtio_mmio.c
@@ -142,7 +142,7 @@ struct virtio_mmio_vq_info {
 
 /* Configuration interface */
 
-static u32 vm_get_features(struct virtio_device *vdev)
+static u64 vm_get_features(struct virtio_device *vdev)
 {
         struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
 
@@ -152,19 +152,20 @@ static u32 vm_get_features(struct virtio_device *vdev)
         return readl(vm_dev->base + VIRTIO_MMIO_HOST_FEATURES);
 }
 
-static void vm_finalize_features(struct virtio_device *vdev)
+static int vm_finalize_features(struct virtio_device *vdev)
 {
         struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
-        int i;
 
         /* Give virtio_ring a chance to accept features. */
         vring_transport_features(vdev);
 
-        for (i = 0; i < ARRAY_SIZE(vdev->features); i++) {
-                writel(i, vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES_SEL);
-                writel(vdev->features[i],
-                                vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES);
-        }
+        /* Make sure we don't have any features > 32 bits! */
+        BUG_ON((u32)vdev->features != vdev->features);
+
+        writel(0, vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES_SEL);
+        writel(vdev->features, vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES);
+
+        return 0;
 }
 
 static void vm_get(struct virtio_device *vdev, unsigned offset,
diff --git a/drivers/virtio/virtio_pci.c b/drivers/virtio/virtio_pci.c
deleted file mode 100644
index d34ebfa604f3..000000000000
--- a/drivers/virtio/virtio_pci.c
+++ /dev/null
@@ -1,802 +0,0 @@
-/*
- * Virtio PCI driver
- *
- * This module allows virtio devices to be used over a virtual PCI device.
- * This can be used with QEMU based VMMs like KVM or Xen.
- *
- * Copyright IBM Corp. 2007
- *
- * Authors:
- *  Anthony Liguori  <aliguori@us.ibm.com>
- *
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
- * See the COPYING file in the top-level directory.
- *
- */
-
-#include <linux/module.h>
-#include <linux/list.h>
-#include <linux/pci.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/virtio.h>
-#include <linux/virtio_config.h>
-#include <linux/virtio_ring.h>
-#include <linux/virtio_pci.h>
-#include <linux/highmem.h>
-#include <linux/spinlock.h>
-
-MODULE_AUTHOR("Anthony Liguori <aliguori@us.ibm.com>");
-MODULE_DESCRIPTION("virtio-pci");
-MODULE_LICENSE("GPL");
-MODULE_VERSION("1");
-
-/* Our device structure */
-struct virtio_pci_device
-{
-        struct virtio_device vdev;
-        struct pci_dev *pci_dev;
-
-        /* the IO mapping for the PCI config space */
-        void __iomem *ioaddr;
-
-        /* a list of queues so we can dispatch IRQs */
-        spinlock_t lock;
-        struct list_head virtqueues;
-
-        /* MSI-X support */
-        int msix_enabled;
-        int intx_enabled;
-        struct msix_entry *msix_entries;
-        cpumask_var_t *msix_affinity_masks;
-        /* Name strings for interrupts. This size should be enough,
-         * and I'm too lazy to allocate each name separately. */
-        char (*msix_names)[256];
-        /* Number of available vectors */
-        unsigned msix_vectors;
-        /* Vectors allocated, excluding per-vq vectors if any */
-        unsigned msix_used_vectors;
-
-        /* Whether we have vector per vq */
-        bool per_vq_vectors;
-};
-
-/* Constants for MSI-X */
-/* Use first vector for configuration changes, second and the rest for
- * virtqueues Thus, we need at least 2 vectors for MSI. */
-enum {
-        VP_MSIX_CONFIG_VECTOR = 0,
-        VP_MSIX_VQ_VECTOR = 1,
-};
-
-struct virtio_pci_vq_info
-{
-        /* the actual virtqueue */
-        struct virtqueue *vq;
-
-        /* the number of entries in the queue */
-        int num;
-
-        /* the virtual address of the ring queue */
-        void *queue;
-
-        /* the list node for the virtqueues list */
-        struct list_head node;
-
-        /* MSI-X vector (or none) */
-        unsigned msix_vector;
-};
-
-/* Qumranet donated their vendor ID for devices 0x1000 thru 0x10FF. */
-static const struct pci_device_id virtio_pci_id_table[] = {
-        { PCI_DEVICE(0x1af4, PCI_ANY_ID) },
-        { 0 }
-};
-
-MODULE_DEVICE_TABLE(pci, virtio_pci_id_table);
-
-/* Convert a generic virtio device to our structure */
-static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev)
-{
-        return container_of(vdev, struct virtio_pci_device, vdev);
-}
-
-/* virtio config->get_features() implementation */
-static u32 vp_get_features(struct virtio_device *vdev)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-
-        /* When someone needs more than 32 feature bits, we'll need to
-         * steal a bit to indicate that the rest are somewhere else. */
-        return ioread32(vp_dev->ioaddr + VIRTIO_PCI_HOST_FEATURES);
-}
-
-/* virtio config->finalize_features() implementation */
-static void vp_finalize_features(struct virtio_device *vdev)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-
-        /* Give virtio_ring a chance to accept features. */
-        vring_transport_features(vdev);
-
-        /* We only support 32 feature bits. */
-        BUILD_BUG_ON(ARRAY_SIZE(vdev->features) != 1);
-        iowrite32(vdev->features[0], vp_dev->ioaddr+VIRTIO_PCI_GUEST_FEATURES);
-}
-
-/* virtio config->get() implementation */
-static void vp_get(struct virtio_device *vdev, unsigned offset,
-                   void *buf, unsigned len)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        void __iomem *ioaddr = vp_dev->ioaddr +
-                                VIRTIO_PCI_CONFIG(vp_dev) + offset;
-        u8 *ptr = buf;
-        int i;
-
-        for (i = 0; i < len; i++)
-                ptr[i] = ioread8(ioaddr + i);
-}
-
-/* the config->set() implementation.  it's symmetric to the config->get()
- * implementation */
-static void vp_set(struct virtio_device *vdev, unsigned offset,
-                   const void *buf, unsigned len)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        void __iomem *ioaddr = vp_dev->ioaddr +
-                                VIRTIO_PCI_CONFIG(vp_dev) + offset;
-        const u8 *ptr = buf;
-        int i;
-
-        for (i = 0; i < len; i++)
-                iowrite8(ptr[i], ioaddr + i);
-}
-
-/* config->{get,set}_status() implementations */
-static u8 vp_get_status(struct virtio_device *vdev)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        return ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS);
-}
-
-static void vp_set_status(struct virtio_device *vdev, u8 status)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        /* We should never be setting status to 0. */
-        BUG_ON(status == 0);
-        iowrite8(status, vp_dev->ioaddr + VIRTIO_PCI_STATUS);
-}
-
-/* wait for pending irq handlers */
-static void vp_synchronize_vectors(struct virtio_device *vdev)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        int i;
-
-        if (vp_dev->intx_enabled)
-                synchronize_irq(vp_dev->pci_dev->irq);
-
-        for (i = 0; i < vp_dev->msix_vectors; ++i)
-                synchronize_irq(vp_dev->msix_entries[i].vector);
-}
-
-static void vp_reset(struct virtio_device *vdev)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        /* 0 status means a reset. */
-        iowrite8(0, vp_dev->ioaddr + VIRTIO_PCI_STATUS);
-        /* Flush out the status write, and flush in device writes,
-         * including MSi-X interrupts, if any. */
-        ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS);
-        /* Flush pending VQ/configuration callbacks. */
-        vp_synchronize_vectors(vdev);
-}
-
-/* the notify function used when creating a virt queue */
-static bool vp_notify(struct virtqueue *vq)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
-
-        /* we write the queue's selector into the notification register to
-         * signal the other end */
-        iowrite16(vq->index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY);
-        return true;
-}
-
-/* Handle a configuration change: Tell driver if it wants to know. */
-static irqreturn_t vp_config_changed(int irq, void *opaque)
-{
-        struct virtio_pci_device *vp_dev = opaque;
-
-        virtio_config_changed(&vp_dev->vdev);
-        return IRQ_HANDLED;
-}
-
-/* Notify all virtqueues on an interrupt. */
-static irqreturn_t vp_vring_interrupt(int irq, void *opaque)
-{
-        struct virtio_pci_device *vp_dev = opaque;
-        struct virtio_pci_vq_info *info;
-        irqreturn_t ret = IRQ_NONE;
-        unsigned long flags;
-
-        spin_lock_irqsave(&vp_dev->lock, flags);
-        list_for_each_entry(info, &vp_dev->virtqueues, node) {
-                if (vring_interrupt(irq, info->vq) == IRQ_HANDLED)
-                        ret = IRQ_HANDLED;
-        }
-        spin_unlock_irqrestore(&vp_dev->lock, flags);
-
-        return ret;
-}
-
-/* A small wrapper to also acknowledge the interrupt when it's handled.
- * I really need an EIO hook for the vring so I can ack the interrupt once we
- * know that we'll be handling the IRQ but before we invoke the callback since
- * the callback may notify the host which results in the host attempting to
- * raise an interrupt that we would then mask once we acknowledged the
- * interrupt. */
-static irqreturn_t vp_interrupt(int irq, void *opaque)
-{
-        struct virtio_pci_device *vp_dev = opaque;
-        u8 isr;
-
-        /* reading the ISR has the effect of also clearing it so it's very
-         * important to save off the value. */
-        isr = ioread8(vp_dev->ioaddr + VIRTIO_PCI_ISR);
-
-        /* It's definitely not us if the ISR was not high */
-        if (!isr)
-                return IRQ_NONE;
-
-        /* Configuration change?  Tell driver if it wants to know. */
-        if (isr & VIRTIO_PCI_ISR_CONFIG)
-                vp_config_changed(irq, opaque);
-
-        return vp_vring_interrupt(irq, opaque);
-}
-
-static void vp_free_vectors(struct virtio_device *vdev)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        int i;
-
-        if (vp_dev->intx_enabled) {
-                free_irq(vp_dev->pci_dev->irq, vp_dev);
-                vp_dev->intx_enabled = 0;
-        }
-
-        for (i = 0; i < vp_dev->msix_used_vectors; ++i)
-                free_irq(vp_dev->msix_entries[i].vector, vp_dev);
-
-        for (i = 0; i < vp_dev->msix_vectors; i++)
-                if (vp_dev->msix_affinity_masks[i])
-                        free_cpumask_var(vp_dev->msix_affinity_masks[i]);
-
-        if (vp_dev->msix_enabled) {
-                /* Disable the vector used for configuration */
-                iowrite16(VIRTIO_MSI_NO_VECTOR,
-                          vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
-                /* Flush the write out to device */
-                ioread16(vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
-
-                pci_disable_msix(vp_dev->pci_dev);
-                vp_dev->msix_enabled = 0;
-        }
-
-        vp_dev->msix_vectors = 0;
-        vp_dev->msix_used_vectors = 0;
-        kfree(vp_dev->msix_names);
-        vp_dev->msix_names = NULL;
-        kfree(vp_dev->msix_entries);
-        vp_dev->msix_entries = NULL;
-        kfree(vp_dev->msix_affinity_masks);
-        vp_dev->msix_affinity_masks = NULL;
-}
-
-static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
-                                   bool per_vq_vectors)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        const char *name = dev_name(&vp_dev->vdev.dev);
-        unsigned i, v;
-        int err = -ENOMEM;
-
-        vp_dev->msix_vectors = nvectors;
-
-        vp_dev->msix_entries = kmalloc(nvectors * sizeof *vp_dev->msix_entries,
-                                       GFP_KERNEL);
-        if (!vp_dev->msix_entries)
-                goto error;
-        vp_dev->msix_names = kmalloc(nvectors * sizeof *vp_dev->msix_names,
-                                     GFP_KERNEL);
-        if (!vp_dev->msix_names)
-                goto error;
-        vp_dev->msix_affinity_masks
-                = kzalloc(nvectors * sizeof *vp_dev->msix_affinity_masks,
-                          GFP_KERNEL);
-        if (!vp_dev->msix_affinity_masks)
-                goto error;
-        for (i = 0; i < nvectors; ++i)
-                if (!alloc_cpumask_var(&vp_dev->msix_affinity_masks[i],
-                                        GFP_KERNEL))
-                        goto error;
-
-        for (i = 0; i < nvectors; ++i)
-                vp_dev->msix_entries[i].entry = i;
-
-        err = pci_enable_msix_exact(vp_dev->pci_dev,
-                                    vp_dev->msix_entries, nvectors);
-        if (err)
-                goto error;
-        vp_dev->msix_enabled = 1;
-
-        /* Set the vector used for configuration */
-        v = vp_dev->msix_used_vectors;
-        snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
-                 "%s-config", name);
-        err = request_irq(vp_dev->msix_entries[v].vector,
-                          vp_config_changed, 0, vp_dev->msix_names[v],
-                          vp_dev);
-        if (err)
-                goto error;
-        ++vp_dev->msix_used_vectors;
-
-        iowrite16(v, vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
-        /* Verify we had enough resources to assign the vector */
-        v = ioread16(vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
-        if (v == VIRTIO_MSI_NO_VECTOR) {
-                err = -EBUSY;
-                goto error;
-        }
-
-        if (!per_vq_vectors) {
-                /* Shared vector for all VQs */
-                v = vp_dev->msix_used_vectors;
-                snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
-                         "%s-virtqueues", name);
-                err = request_irq(vp_dev->msix_entries[v].vector,
-                                  vp_vring_interrupt, 0, vp_dev->msix_names[v],
-                                  vp_dev);
-                if (err)
-                        goto error;
-                ++vp_dev->msix_used_vectors;
-        }
-        return 0;
-error:
-        vp_free_vectors(vdev);
-        return err;
-}
-
-static int vp_request_intx(struct virtio_device *vdev)
-{
-        int err;
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-
-        err = request_irq(vp_dev->pci_dev->irq, vp_interrupt,
-                          IRQF_SHARED, dev_name(&vdev->dev), vp_dev);
-        if (!err)
-                vp_dev->intx_enabled = 1;
-        return err;
-}
-
-static struct virtqueue *setup_vq(struct virtio_device *vdev, unsigned index,
-                                  void (*callback)(struct virtqueue *vq),
-                                  const char *name,
-                                  u16 msix_vec)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        struct virtio_pci_vq_info *info;
-        struct virtqueue *vq;
-        unsigned long flags, size;
-        u16 num;
-        int err;
-
-        /* Select the queue we're interested in */
-        iowrite16(index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
-
-        /* Check if queue is either not available or already active. */
-        num = ioread16(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NUM);
-        if (!num || ioread32(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN))
-                return ERR_PTR(-ENOENT);
-
-        /* allocate and fill out our structure the represents an active
-         * queue */
-        info = kmalloc(sizeof(struct virtio_pci_vq_info), GFP_KERNEL);
-        if (!info)
-                return ERR_PTR(-ENOMEM);
-
-        info->num = num;
-        info->msix_vector = msix_vec;
-
-        size = PAGE_ALIGN(vring_size(num, VIRTIO_PCI_VRING_ALIGN));
-        info->queue = alloc_pages_exact(size, GFP_KERNEL|__GFP_ZERO);
-        if (info->queue == NULL) {
-                err = -ENOMEM;
-                goto out_info;
-        }
-
-        /* activate the queue */
-        iowrite32(virt_to_phys(info->queue) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
-                  vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
-
-        /* create the vring */
-        vq = vring_new_virtqueue(index, info->num, VIRTIO_PCI_VRING_ALIGN, vdev,
-                                 true, info->queue, vp_notify, callback, name);
-        if (!vq) {
-                err = -ENOMEM;
-                goto out_activate_queue;
-        }
-
-        vq->priv = info;
-        info->vq = vq;
-
-        if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
-                iowrite16(msix_vec, vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
-                msix_vec = ioread16(vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
-                if (msix_vec == VIRTIO_MSI_NO_VECTOR) {
-                        err = -EBUSY;
-                        goto out_assign;
-                }
-        }
-
-        if (callback) {
-                spin_lock_irqsave(&vp_dev->lock, flags);
-                list_add(&info->node, &vp_dev->virtqueues);
-                spin_unlock_irqrestore(&vp_dev->lock, flags);
-        } else {
-                INIT_LIST_HEAD(&info->node);
-        }
-
-        return vq;
-
-out_assign:
-        vring_del_virtqueue(vq);
-out_activate_queue:
-        iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
-        free_pages_exact(info->queue, size);
-out_info:
-        kfree(info);
-        return ERR_PTR(err);
-}
-
-static void vp_del_vq(struct virtqueue *vq)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
-        struct virtio_pci_vq_info *info = vq->priv;
-        unsigned long flags, size;
-
-        spin_lock_irqsave(&vp_dev->lock, flags);
-        list_del(&info->node);
-        spin_unlock_irqrestore(&vp_dev->lock, flags);
-
-        iowrite16(vq->index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
-
-        if (vp_dev->msix_enabled) {
-                iowrite16(VIRTIO_MSI_NO_VECTOR,
-                          vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
-                /* Flush the write out to device */
-                ioread8(vp_dev->ioaddr + VIRTIO_PCI_ISR);
-        }
-
-        vring_del_virtqueue(vq);
-
-        /* Select and deactivate the queue */
-        iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
-
-        size = PAGE_ALIGN(vring_size(info->num, VIRTIO_PCI_VRING_ALIGN));
-        free_pages_exact(info->queue, size);
-        kfree(info);
-}
-
-/* the config->del_vqs() implementation */
-static void vp_del_vqs(struct virtio_device *vdev)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        struct virtqueue *vq, *n;
-        struct virtio_pci_vq_info *info;
-
-        list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
-                info = vq->priv;
-                if (vp_dev->per_vq_vectors &&
-                        info->msix_vector != VIRTIO_MSI_NO_VECTOR)
-                        free_irq(vp_dev->msix_entries[info->msix_vector].vector,
-                                 vq);
-                vp_del_vq(vq);
-        }
-        vp_dev->per_vq_vectors = false;
-
-        vp_free_vectors(vdev);
-}
-
-static int vp_try_to_find_vqs(struct virtio_device *vdev, unsigned nvqs,
-                              struct virtqueue *vqs[],
-                              vq_callback_t *callbacks[],
-                              const char *names[],
-                              bool use_msix,
-                              bool per_vq_vectors)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        u16 msix_vec;
-        int i, err, nvectors, allocated_vectors;
-
-        if (!use_msix) {
-                /* Old style: one normal interrupt for change and all vqs. */
-                err = vp_request_intx(vdev);
-                if (err)
-                        goto error_request;
-        } else {
-                if (per_vq_vectors) {
-                        /* Best option: one for change interrupt, one per vq. */
-                        nvectors = 1;
-                        for (i = 0; i < nvqs; ++i)
-                                if (callbacks[i])
-                                        ++nvectors;
-                } else {
-                        /* Second best: one for change, shared for all vqs. */
-                        nvectors = 2;
-                }
-
-                err = vp_request_msix_vectors(vdev, nvectors, per_vq_vectors);
-                if (err)
-                        goto error_request;
-        }
-
-        vp_dev->per_vq_vectors = per_vq_vectors;
-        allocated_vectors = vp_dev->msix_used_vectors;
-        for (i = 0; i < nvqs; ++i) {
-                if (!names[i]) {
-                        vqs[i] = NULL;
-                        continue;
-                } else if (!callbacks[i] || !vp_dev->msix_enabled)
-                        msix_vec = VIRTIO_MSI_NO_VECTOR;
-                else if (vp_dev->per_vq_vectors)
-                        msix_vec = allocated_vectors++;
-                else
-                        msix_vec = VP_MSIX_VQ_VECTOR;
-                vqs[i] = setup_vq(vdev, i, callbacks[i], names[i], msix_vec);
-                if (IS_ERR(vqs[i])) {
-                        err = PTR_ERR(vqs[i]);
-                        goto error_find;
-                }
-
-                if (!vp_dev->per_vq_vectors || msix_vec == VIRTIO_MSI_NO_VECTOR)
-                        continue;
-
-                /* allocate per-vq irq if available and necessary */
-                snprintf(vp_dev->msix_names[msix_vec],
-                         sizeof *vp_dev->msix_names,
-                         "%s-%s",
-                         dev_name(&vp_dev->vdev.dev), names[i]);
-                err = request_irq(vp_dev->msix_entries[msix_vec].vector,
-                                  vring_interrupt, 0,
-                                  vp_dev->msix_names[msix_vec],
-                                  vqs[i]);
-                if (err) {
-                        vp_del_vq(vqs[i]);
-                        goto error_find;
-                }
-        }
-        return 0;
-
-error_find:
-        vp_del_vqs(vdev);
-
-error_request:
-        return err;
-}
-
-/* the config->find_vqs() implementation */
-static int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs,
-                       struct virtqueue *vqs[],
-                       vq_callback_t *callbacks[],
-                       const char *names[])
-{
-        int err;
-
-        /* Try MSI-X with one vector per queue. */
-        err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, true, true);
-        if (!err)
-                return 0;
-        /* Fallback: MSI-X with one vector for config, one shared for queues. */
-        err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,
-                                 true, false);
-        if (!err)
-                return 0;
-        /* Finally fall back to regular interrupts. */
-        return vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,
-                                  false, false);
-}
-
-static const char *vp_bus_name(struct virtio_device *vdev)
-{
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-
-        return pci_name(vp_dev->pci_dev);
-}
-
-/* Setup the affinity for a virtqueue:
- * - force the affinity for per vq vector
- * - OR over all affinities for shared MSI
- * - ignore the affinity request if we're using INTX
- */
-static int vp_set_vq_affinity(struct virtqueue *vq, int cpu)
-{
-        struct virtio_device *vdev = vq->vdev;
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        struct virtio_pci_vq_info *info = vq->priv;
-        struct cpumask *mask;
-        unsigned int irq;
-
-        if (!vq->callback)
-                return -EINVAL;
-
-        if (vp_dev->msix_enabled) {
-                mask = vp_dev->msix_affinity_masks[info->msix_vector];
-                irq = vp_dev->msix_entries[info->msix_vector].vector;
-                if (cpu == -1)
-                        irq_set_affinity_hint(irq, NULL);
-                else {
-                        cpumask_set_cpu(cpu, mask);
-                        irq_set_affinity_hint(irq, mask);
-                }
-        }
-        return 0;
-}
-
-static const struct virtio_config_ops virtio_pci_config_ops = {
-        .get            = vp_get,
-        .set            = vp_set,
-        .get_status     = vp_get_status,
-        .set_status     = vp_set_status,
-        .reset          = vp_reset,
-        .find_vqs       = vp_find_vqs,
-        .del_vqs        = vp_del_vqs,
-        .get_features   = vp_get_features,
-        .finalize_features = vp_finalize_features,
-        .bus_name       = vp_bus_name,
-        .set_vq_affinity = vp_set_vq_affinity,
-};
-
-static void virtio_pci_release_dev(struct device *_d)
-{
-        /*
-         * No need for a release method as we allocate/free
-         * all devices together with the pci devices.
-         * Provide an empty one to avoid getting a warning from core.
-         */
-}
-
-/* the PCI probing function */
-static int virtio_pci_probe(struct pci_dev *pci_dev,
-                            const struct pci_device_id *id)
-{
-        struct virtio_pci_device *vp_dev;
-        int err;
-
-        /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */
-        if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f)
-                return -ENODEV;
-
-        if (pci_dev->revision != VIRTIO_PCI_ABI_VERSION) {
-                printk(KERN_ERR "virtio_pci: expected ABI version %d, got %d\n",
-                       VIRTIO_PCI_ABI_VERSION, pci_dev->revision);
-                return -ENODEV;
-        }
-
-        /* allocate our structure and fill it out */
-        vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL);
-        if (vp_dev == NULL)
-                return -ENOMEM;
-
-        vp_dev->vdev.dev.parent = &pci_dev->dev;
-        vp_dev->vdev.dev.release = virtio_pci_release_dev;
-        vp_dev->vdev.config = &virtio_pci_config_ops;
-        vp_dev->pci_dev = pci_dev;
-        INIT_LIST_HEAD(&vp_dev->virtqueues);
-        spin_lock_init(&vp_dev->lock);
-
-        /* Disable MSI/MSIX to bring device to a known good state. */
-        pci_msi_off(pci_dev);
-
-        /* enable the device */
-        err = pci_enable_device(pci_dev);
-        if (err)
-                goto out;
-
-        err = pci_request_regions(pci_dev, "virtio-pci");
-        if (err)
-                goto out_enable_device;
-
-        vp_dev->ioaddr = pci_iomap(pci_dev, 0, 0);
-        if (vp_dev->ioaddr == NULL) {
-                err = -ENOMEM;
-                goto out_req_regions;
-        }
-
-        pci_set_drvdata(pci_dev, vp_dev);
-        pci_set_master(pci_dev);
-
-        /* we use the subsystem vendor/device id as the virtio vendor/device
-         * id.  this allows us to use the same PCI vendor/device id for all
-         * virtio devices and to identify the particular virtio driver by
-         * the subsystem ids */
-        vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor;
-        vp_dev->vdev.id.device = pci_dev->subsystem_device;
-
-        /* finally register the virtio device */
-        err = register_virtio_device(&vp_dev->vdev);
-        if (err)
-                goto out_set_drvdata;
-
-        return 0;
-
-out_set_drvdata:
-        pci_iounmap(pci_dev, vp_dev->ioaddr);
-out_req_regions:
-        pci_release_regions(pci_dev);
-out_enable_device:
-        pci_disable_device(pci_dev);
-out:
-        kfree(vp_dev);
-        return err;
-}
-
-static void virtio_pci_remove(struct pci_dev *pci_dev)
-{
-        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
-
-        unregister_virtio_device(&vp_dev->vdev);
-
-        vp_del_vqs(&vp_dev->vdev);
-        pci_iounmap(pci_dev, vp_dev->ioaddr);
-        pci_release_regions(pci_dev);
-        pci_disable_device(pci_dev);
-        kfree(vp_dev);
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int virtio_pci_freeze(struct device *dev)
-{
-        struct pci_dev *pci_dev = to_pci_dev(dev);
-        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
-        int ret;
-
-        ret = virtio_device_freeze(&vp_dev->vdev);
-
-        if (!ret)
-                pci_disable_device(pci_dev);
-        return ret;
-}
-
-static int virtio_pci_restore(struct device *dev)
-{
-        struct pci_dev *pci_dev = to_pci_dev(dev);
-        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
-        int ret;
-
-        ret = pci_enable_device(pci_dev);
-        if (ret)
-                return ret;
-
-        pci_set_master(pci_dev);
-        return virtio_device_restore(&vp_dev->vdev);
-}
-
-static const struct dev_pm_ops virtio_pci_pm_ops = {
-        SET_SYSTEM_SLEEP_PM_OPS(virtio_pci_freeze, virtio_pci_restore)
-};
-#endif
-
-static struct pci_driver virtio_pci_driver = {
-        .name           = "virtio-pci",
-        .id_table       = virtio_pci_id_table,
-        .probe          = virtio_pci_probe,
-        .remove         = virtio_pci_remove,
-#ifdef CONFIG_PM_SLEEP
-        .driver.pm      = &virtio_pci_pm_ops,
-#endif
-};
-
-module_pci_driver(virtio_pci_driver);
diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
new file mode 100644
index 000000000000..953057d84185
--- /dev/null
+++ b/drivers/virtio/virtio_pci_common.c
@@ -0,0 +1,464 @@
+/*
+ * Virtio PCI driver - common functionality for all device versions
+ *
+ * This module allows virtio devices to be used over a virtual PCI device.
+ * This can be used with QEMU based VMMs like KVM or Xen.
+ *
+ * Copyright IBM Corp. 2007
+ * Copyright Red Hat, Inc. 2014
+ *
+ * Authors:
+ *  Anthony Liguori  <aliguori@us.ibm.com>
+ *  Rusty Russell <rusty@rustcorp.com.au>
+ *  Michael S. Tsirkin <mst@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "virtio_pci_common.h"
+
+/* wait for pending irq handlers */
+void vp_synchronize_vectors(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        int i;
+
+        if (vp_dev->intx_enabled)
+                synchronize_irq(vp_dev->pci_dev->irq);
+
+        for (i = 0; i < vp_dev->msix_vectors; ++i)
+                synchronize_irq(vp_dev->msix_entries[i].vector);
+}
+
+/* the notify function used when creating a virt queue */
+bool vp_notify(struct virtqueue *vq)
+{
+        /* we write the queue's selector into the notification register to
+         * signal the other end */
+        iowrite16(vq->index, (void __iomem *)vq->priv);
+        return true;
+}
+
+/* Handle a configuration change: Tell driver if it wants to know. */
+static irqreturn_t vp_config_changed(int irq, void *opaque)
+{
+        struct virtio_pci_device *vp_dev = opaque;
+
+        virtio_config_changed(&vp_dev->vdev);
+        return IRQ_HANDLED;
+}
+
+/* Notify all virtqueues on an interrupt. */
+static irqreturn_t vp_vring_interrupt(int irq, void *opaque)
+{
+        struct virtio_pci_device *vp_dev = opaque;
+        struct virtio_pci_vq_info *info;
+        irqreturn_t ret = IRQ_NONE;
+        unsigned long flags;
+
+        spin_lock_irqsave(&vp_dev->lock, flags);
+        list_for_each_entry(info, &vp_dev->virtqueues, node) {
+                if (vring_interrupt(irq, info->vq) == IRQ_HANDLED)
+                        ret = IRQ_HANDLED;
+        }
+        spin_unlock_irqrestore(&vp_dev->lock, flags);
+
+        return ret;
+}
+
+/* A small wrapper to also acknowledge the interrupt when it's handled.
+ * I really need an EIO hook for the vring so I can ack the interrupt once we
+ * know that we'll be handling the IRQ but before we invoke the callback since
+ * the callback may notify the host which results in the host attempting to
+ * raise an interrupt that we would then mask once we acknowledged the
+ * interrupt. */
+static irqreturn_t vp_interrupt(int irq, void *opaque)
+{
+        struct virtio_pci_device *vp_dev = opaque;
+        u8 isr;
+
+        /* reading the ISR has the effect of also clearing it so it's very
+         * important to save off the value. */
+        isr = ioread8(vp_dev->isr);
+
+        /* It's definitely not us if the ISR was not high */
+        if (!isr)
+                return IRQ_NONE;
+
+        /* Configuration change?  Tell driver if it wants to know. */
+        if (isr & VIRTIO_PCI_ISR_CONFIG)
+                vp_config_changed(irq, opaque);
+
+        return vp_vring_interrupt(irq, opaque);
+}
+
+static void vp_free_vectors(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        int i;
+
+        if (vp_dev->intx_enabled) {
+                free_irq(vp_dev->pci_dev->irq, vp_dev);
+                vp_dev->intx_enabled = 0;
+        }
+
+        for (i = 0; i < vp_dev->msix_used_vectors; ++i)
+                free_irq(vp_dev->msix_entries[i].vector, vp_dev);
+
+        for (i = 0; i < vp_dev->msix_vectors; i++)
+                if (vp_dev->msix_affinity_masks[i])
+                        free_cpumask_var(vp_dev->msix_affinity_masks[i]);
+
+        if (vp_dev->msix_enabled) {
+                /* Disable the vector used for configuration */
+                vp_dev->config_vector(vp_dev, VIRTIO_MSI_NO_VECTOR);
+
+                pci_disable_msix(vp_dev->pci_dev);
+                vp_dev->msix_enabled = 0;
+        }
+
+        vp_dev->msix_vectors = 0;
+        vp_dev->msix_used_vectors = 0;
+        kfree(vp_dev->msix_names);
+        vp_dev->msix_names = NULL;
+        kfree(vp_dev->msix_entries);
+        vp_dev->msix_entries = NULL;
+        kfree(vp_dev->msix_affinity_masks);
+        vp_dev->msix_affinity_masks = NULL;
+}
+
+static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
+                                   bool per_vq_vectors)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        const char *name = dev_name(&vp_dev->vdev.dev);
+        unsigned i, v;
+        int err = -ENOMEM;
+
+        vp_dev->msix_vectors = nvectors;
+
+        vp_dev->msix_entries = kmalloc(nvectors * sizeof *vp_dev->msix_entries,
+                                       GFP_KERNEL);
+        if (!vp_dev->msix_entries)
+                goto error;
+        vp_dev->msix_names = kmalloc(nvectors * sizeof *vp_dev->msix_names,
+                                     GFP_KERNEL);
+        if (!vp_dev->msix_names)
+                goto error;
+        vp_dev->msix_affinity_masks
+                = kzalloc(nvectors * sizeof *vp_dev->msix_affinity_masks,
+                          GFP_KERNEL);
+        if (!vp_dev->msix_affinity_masks)
+                goto error;
+        for (i = 0; i < nvectors; ++i)
+                if (!alloc_cpumask_var(&vp_dev->msix_affinity_masks[i],
+                                        GFP_KERNEL))
+                        goto error;
+
+        for (i = 0; i < nvectors; ++i)
+                vp_dev->msix_entries[i].entry = i;
+
+        err = pci_enable_msix_exact(vp_dev->pci_dev,
+                                    vp_dev->msix_entries, nvectors);
+        if (err)
+                goto error;
+        vp_dev->msix_enabled = 1;
+
+        /* Set the vector used for configuration */
+        v = vp_dev->msix_used_vectors;
+        snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
+                 "%s-config", name);
+        err = request_irq(vp_dev->msix_entries[v].vector,
+                          vp_config_changed, 0, vp_dev->msix_names[v],
+                          vp_dev);
+        if (err)
+                goto error;
+        ++vp_dev->msix_used_vectors;
+
+        v = vp_dev->config_vector(vp_dev, v);
+        /* Verify we had enough resources to assign the vector */
+        if (v == VIRTIO_MSI_NO_VECTOR) {
+                err = -EBUSY;
+                goto error;
+        }
+
+        if (!per_vq_vectors) {
+                /* Shared vector for all VQs */
+                v = vp_dev->msix_used_vectors;
+                snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
+                         "%s-virtqueues", name);
+                err = request_irq(vp_dev->msix_entries[v].vector,
+                                  vp_vring_interrupt, 0, vp_dev->msix_names[v],
+                                  vp_dev);
+                if (err)
+                        goto error;
+                ++vp_dev->msix_used_vectors;
+        }
+        return 0;
+error:
+        vp_free_vectors(vdev);
+        return err;
+}
+
+static int vp_request_intx(struct virtio_device *vdev)
+{
+        int err;
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+
+        err = request_irq(vp_dev->pci_dev->irq, vp_interrupt,
+                          IRQF_SHARED, dev_name(&vdev->dev), vp_dev);
+        if (!err)
+                vp_dev->intx_enabled = 1;
+        return err;
+}
+
+static struct virtqueue *vp_setup_vq(struct virtio_device *vdev, unsigned index,
+                                     void (*callback)(struct virtqueue *vq),
+                                     const char *name,
+                                     u16 msix_vec)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        struct virtio_pci_vq_info *info = kmalloc(sizeof *info, GFP_KERNEL);
+        struct virtqueue *vq;
+        unsigned long flags;
+
+        /* fill out our structure that represents an active queue */
+        if (!info)
+                return ERR_PTR(-ENOMEM);
+
+        vq = vp_dev->setup_vq(vp_dev, info, index, callback, name, msix_vec);
+        if (IS_ERR(vq))
+                goto out_info;
+
+        info->vq = vq;
+        if (callback) {
+                spin_lock_irqsave(&vp_dev->lock, flags);
+                list_add(&info->node, &vp_dev->virtqueues);
+                spin_unlock_irqrestore(&vp_dev->lock, flags);
+        } else {
+                INIT_LIST_HEAD(&info->node);
+        }
+
+        vp_dev->vqs[index] = info;
+        return vq;
+
+out_info:
+        kfree(info);
+        return vq;
+}
+
+static void vp_del_vq(struct virtqueue *vq)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
+        struct virtio_pci_vq_info *info = vp_dev->vqs[vq->index];
+        unsigned long flags;
+
+        spin_lock_irqsave(&vp_dev->lock, flags);
+        list_del(&info->node);
+        spin_unlock_irqrestore(&vp_dev->lock, flags);
+
+        vp_dev->del_vq(info);
+        kfree(info);
+}
+
+/* the config->del_vqs() implementation */
+void vp_del_vqs(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        struct virtqueue *vq, *n;
+        struct virtio_pci_vq_info *info;
+
+        list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
+                info = vp_dev->vqs[vq->index];
+                if (vp_dev->per_vq_vectors &&
+                        info->msix_vector != VIRTIO_MSI_NO_VECTOR)
+                        free_irq(vp_dev->msix_entries[info->msix_vector].vector,
+                                 vq);
+                vp_del_vq(vq);
+        }
+        vp_dev->per_vq_vectors = false;
+
+        vp_free_vectors(vdev);
+        kfree(vp_dev->vqs);
+}
+
+static int vp_try_to_find_vqs(struct virtio_device *vdev, unsigned nvqs,
+                              struct virtqueue *vqs[],
+                              vq_callback_t *callbacks[],
+                              const char *names[],
+                              bool use_msix,
+                              bool per_vq_vectors)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        u16 msix_vec;
+        int i, err, nvectors, allocated_vectors;
+
+        vp_dev->vqs = kmalloc(nvqs * sizeof *vp_dev->vqs, GFP_KERNEL);
+        if (!vp_dev->vqs)
+                return -ENOMEM;
+
+        if (!use_msix) {
+                /* Old style: one normal interrupt for change and all vqs. */
+                err = vp_request_intx(vdev);
+                if (err)
+                        goto error_find;
+        } else {
+                if (per_vq_vectors) {
+                        /* Best option: one for change interrupt, one per vq. */
+                        nvectors = 1;
+                        for (i = 0; i < nvqs; ++i)
+                                if (callbacks[i])
+                                        ++nvectors;
+                } else {
+                        /* Second best: one for change, shared for all vqs. */
+                        nvectors = 2;
+                }
+
+                err = vp_request_msix_vectors(vdev, nvectors, per_vq_vectors);
+                if (err)
+                        goto error_find;
+        }
+
+        vp_dev->per_vq_vectors = per_vq_vectors;
+        allocated_vectors = vp_dev->msix_used_vectors;
+        for (i = 0; i < nvqs; ++i) {
+                if (!names[i]) {
+                        vqs[i] = NULL;
+                        continue;
+                } else if (!callbacks[i] || !vp_dev->msix_enabled)
+                        msix_vec = VIRTIO_MSI_NO_VECTOR;
+                else if (vp_dev->per_vq_vectors)
+                        msix_vec = allocated_vectors++;
+                else
+                        msix_vec = VP_MSIX_VQ_VECTOR;
+                vqs[i] = vp_setup_vq(vdev, i, callbacks[i], names[i], msix_vec);
+                if (IS_ERR(vqs[i])) {
+                        err = PTR_ERR(vqs[i]);
+                        goto error_find;
+                }
+
+                if (!vp_dev->per_vq_vectors || msix_vec == VIRTIO_MSI_NO_VECTOR)
+                        continue;
+
+                /* allocate per-vq irq if available and necessary */
+                snprintf(vp_dev->msix_names[msix_vec],
+                         sizeof *vp_dev->msix_names,
+                         "%s-%s",
+                         dev_name(&vp_dev->vdev.dev), names[i]);
+                err = request_irq(vp_dev->msix_entries[msix_vec].vector,
+                                  vring_interrupt, 0,
+                                  vp_dev->msix_names[msix_vec],
+                                  vqs[i]);
+                if (err) {
+                        vp_del_vq(vqs[i]);
+                        goto error_find;
+                }
+        }
+        return 0;
+
+error_find:
+        vp_del_vqs(vdev);
+        return err;
+}
+
+/* the config->find_vqs() implementation */
+int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs,
+                struct virtqueue *vqs[],
+                vq_callback_t *callbacks[],
+                const char *names[])
+{
+        int err;
+
+        /* Try MSI-X with one vector per queue. */
+        err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, true, true);
+        if (!err)
+                return 0;
+        /* Fallback: MSI-X with one vector for config, one shared for queues. */
+        err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,
+                                 true, false);
+        if (!err)
+                return 0;
+        /* Finally fall back to regular interrupts. */
+        return vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,
+                                  false, false);
+}
+
+const char *vp_bus_name(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+
+        return pci_name(vp_dev->pci_dev);
+}
+
+/* Setup the affinity for a virtqueue:
+ * - force the affinity for per vq vector
+ * - OR over all affinities for shared MSI
+ * - ignore the affinity request if we're using INTX
+ */
+int vp_set_vq_affinity(struct virtqueue *vq, int cpu)
+{
+        struct virtio_device *vdev = vq->vdev;
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        struct virtio_pci_vq_info *info = vp_dev->vqs[vq->index];
+        struct cpumask *mask;
+        unsigned int irq;
+
+        if (!vq->callback)
+                return -EINVAL;
+
+        if (vp_dev->msix_enabled) {
+                mask = vp_dev->msix_affinity_masks[info->msix_vector];
+                irq = vp_dev->msix_entries[info->msix_vector].vector;
+                if (cpu == -1)
+                        irq_set_affinity_hint(irq, NULL);
+                else {
+                        cpumask_set_cpu(cpu, mask);
+                        irq_set_affinity_hint(irq, mask);
+                }
+        }
+        return 0;
+}
+
+void virtio_pci_release_dev(struct device *_d)
+{
+        /*
+         * No need for a release method as we allocate/free
+         * all devices together with the pci devices.
+         * Provide an empty one to avoid getting a warning from core.
+         */
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int virtio_pci_freeze(struct device *dev)
+{
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
+        int ret;
+
+        ret = virtio_device_freeze(&vp_dev->vdev);
+
+        if (!ret)
+                pci_disable_device(pci_dev);
+        return ret;
+}
+
+static int virtio_pci_restore(struct device *dev)
+{
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
+        int ret;
+
+        ret = pci_enable_device(pci_dev);
+        if (ret)
+                return ret;
+
+        pci_set_master(pci_dev);
+        return virtio_device_restore(&vp_dev->vdev);
+}
+
+const struct dev_pm_ops virtio_pci_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(virtio_pci_freeze, virtio_pci_restore)
+};
+#endif
diff --git a/drivers/virtio/virtio_pci_common.h b/drivers/virtio/virtio_pci_common.h
new file mode 100644
index 000000000000..d840dad4149d
--- /dev/null
+++ b/drivers/virtio/virtio_pci_common.h
@@ -0,0 +1,136 @@
+#ifndef _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H
+#define _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H
+/*
+ * Virtio PCI driver - APIs for common functionality for all device versions
+ *
+ * This module allows virtio devices to be used over a virtual PCI device.
+ * This can be used with QEMU based VMMs like KVM or Xen.
+ *
+ * Copyright IBM Corp. 2007
+ * Copyright Red Hat, Inc. 2014
+ *
+ * Authors:
+ *  Anthony Liguori  <aliguori@us.ibm.com>
+ *  Rusty Russell <rusty@rustcorp.com.au>
+ *  Michael S. Tsirkin <mst@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/list.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/virtio.h>
+#include <linux/virtio_config.h>
+#include <linux/virtio_ring.h>
+#define VIRTIO_PCI_NO_LEGACY
+#include <linux/virtio_pci.h>
+#include <linux/highmem.h>
+#include <linux/spinlock.h>
+
+struct virtio_pci_vq_info {
+        /* the actual virtqueue */
+        struct virtqueue *vq;
+
+        /* the number of entries in the queue */
+        int num;
+
+        /* the virtual address of the ring queue */
+        void *queue;
+
+        /* the list node for the virtqueues list */
+        struct list_head node;
+
+        /* MSI-X vector (or none) */
+        unsigned msix_vector;
+};
+
+/* Our device structure */
+struct virtio_pci_device {
+        struct virtio_device vdev;
+        struct pci_dev *pci_dev;
+
+        /* the IO mapping for the PCI config space */
+        void __iomem *ioaddr;
+
+        /* the IO mapping for ISR operation */
+        void __iomem *isr;
+
+        /* a list of queues so we can dispatch IRQs */
+        spinlock_t lock;
+        struct list_head virtqueues;
+
+        /* array of all queues for house-keeping */
+        struct virtio_pci_vq_info **vqs;
+
+        /* MSI-X support */
+        int msix_enabled;
+        int intx_enabled;
+        struct msix_entry *msix_entries;
+        cpumask_var_t *msix_affinity_masks;
+        /* Name strings for interrupts. This size should be enough,
+         * and I'm too lazy to allocate each name separately. */
+        char (*msix_names)[256];
+        /* Number of available vectors */
+        unsigned msix_vectors;
+        /* Vectors allocated, excluding per-vq vectors if any */
+        unsigned msix_used_vectors;
+
+        /* Whether we have vector per vq */
+        bool per_vq_vectors;
+
+        struct virtqueue *(*setup_vq)(struct virtio_pci_device *vp_dev,
+                                      struct virtio_pci_vq_info *info,
+                                      unsigned idx,
+                                      void (*callback)(struct virtqueue *vq),
+                                      const char *name,
+                                      u16 msix_vec);
+        void (*del_vq)(struct virtio_pci_vq_info *info);
+
+        u16 (*config_vector)(struct virtio_pci_device *vp_dev, u16 vector);
+};
+
+/* Constants for MSI-X */
+/* Use first vector for configuration changes, second and the rest for
+ * virtqueues Thus, we need at least 2 vectors for MSI. */
+enum {
+        VP_MSIX_CONFIG_VECTOR = 0,
+        VP_MSIX_VQ_VECTOR = 1,
+};
+
+/* Convert a generic virtio device to our structure */
+static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev)
+{
+        return container_of(vdev, struct virtio_pci_device, vdev);
+}
+
+/* wait for pending irq handlers */
+void vp_synchronize_vectors(struct virtio_device *vdev);
+/* the notify function used when creating a virt queue */
+bool vp_notify(struct virtqueue *vq);
+/* the config->del_vqs() implementation */
+void vp_del_vqs(struct virtio_device *vdev);
+/* the config->find_vqs() implementation */
+int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs,
+                       struct virtqueue *vqs[],
+                       vq_callback_t *callbacks[],
+                       const char *names[]);
+const char *vp_bus_name(struct virtio_device *vdev);
+
+/* Setup the affinity for a virtqueue:
+ * - force the affinity for per vq vector
+ * - OR over all affinities for shared MSI
+ * - ignore the affinity request if we're using INTX
+ */
+int vp_set_vq_affinity(struct virtqueue *vq, int cpu);
+void virtio_pci_release_dev(struct device *);
+
+#ifdef CONFIG_PM_SLEEP
+extern const struct dev_pm_ops virtio_pci_pm_ops;
+#endif
+
+#endif
diff --git a/drivers/virtio/virtio_pci_legacy.c b/drivers/virtio/virtio_pci_legacy.c
new file mode 100644
index 000000000000..2588252e5c1c
--- /dev/null
+++ b/drivers/virtio/virtio_pci_legacy.c
@@ -0,0 +1,326 @@
+/*
+ * Virtio PCI driver - legacy device support
+ *
+ * This module allows virtio devices to be used over a virtual PCI device.
+ * This can be used with QEMU based VMMs like KVM or Xen.
+ *
+ * Copyright IBM Corp. 2007
+ * Copyright Red Hat, Inc. 2014
+ *
+ * Authors:
+ *  Anthony Liguori  <aliguori@us.ibm.com>
+ *  Rusty Russell <rusty@rustcorp.com.au>
+ *  Michael S. Tsirkin <mst@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "virtio_pci_common.h"
+
+/* Qumranet donated their vendor ID for devices 0x1000 thru 0x10FF. */
+static const struct pci_device_id virtio_pci_id_table[] = {
+        { PCI_DEVICE(0x1af4, PCI_ANY_ID) },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(pci, virtio_pci_id_table);
+
+/* virtio config->get_features() implementation */
+static u64 vp_get_features(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+
+        /* When someone needs more than 32 feature bits, we'll need to
+         * steal a bit to indicate that the rest are somewhere else. */
+        return ioread32(vp_dev->ioaddr + VIRTIO_PCI_HOST_FEATURES);
+}
+
+/* virtio config->finalize_features() implementation */
+static int vp_finalize_features(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+
+        /* Give virtio_ring a chance to accept features. */
+        vring_transport_features(vdev);
+
+        /* Make sure we don't have any features > 32 bits! */
+        BUG_ON((u32)vdev->features != vdev->features);
+
+        /* We only support 32 feature bits. */
+        iowrite32(vdev->features, vp_dev->ioaddr + VIRTIO_PCI_GUEST_FEATURES);
+
+        return 0;
+}
+
+/* virtio config->get() implementation */
+static void vp_get(struct virtio_device *vdev, unsigned offset,
+                   void *buf, unsigned len)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        void __iomem *ioaddr = vp_dev->ioaddr +
+                                VIRTIO_PCI_CONFIG(vp_dev) + offset;
+        u8 *ptr = buf;
+        int i;
+
+        for (i = 0; i < len; i++)
+                ptr[i] = ioread8(ioaddr + i);
+}
+
+/* the config->set() implementation.  it's symmetric to the config->get()
+ * implementation */
+static void vp_set(struct virtio_device *vdev, unsigned offset,
+                   const void *buf, unsigned len)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        void __iomem *ioaddr = vp_dev->ioaddr +
+                                VIRTIO_PCI_CONFIG(vp_dev) + offset;
+        const u8 *ptr = buf;
+        int i;
+
+        for (i = 0; i < len; i++)
+                iowrite8(ptr[i], ioaddr + i);
+}
+
+/* config->{get,set}_status() implementations */
+static u8 vp_get_status(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        return ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS);
+}
+
+static void vp_set_status(struct virtio_device *vdev, u8 status)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        /* We should never be setting status to 0. */
+        BUG_ON(status == 0);
+        iowrite8(status, vp_dev->ioaddr + VIRTIO_PCI_STATUS);
+}
+
+static void vp_reset(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        /* 0 status means a reset. */
+        iowrite8(0, vp_dev->ioaddr + VIRTIO_PCI_STATUS);
+        /* Flush out the status write, and flush in device writes,
+         * including MSi-X interrupts, if any. */
+        ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS);
+        /* Flush pending VQ/configuration callbacks. */
+        vp_synchronize_vectors(vdev);
+}
+
+static u16 vp_config_vector(struct virtio_pci_device *vp_dev, u16 vector)
+{
+        /* Setup the vector used for configuration events */
+        iowrite16(vector, vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
+        /* Verify we had enough resources to assign the vector */
+        /* Will also flush the write out to device */
+        return ioread16(vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
+}
+
+static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
+                                  struct virtio_pci_vq_info *info,
+                                  unsigned index,
+                                  void (*callback)(struct virtqueue *vq),
+                                  const char *name,
+                                  u16 msix_vec)
+{
+        struct virtqueue *vq;
+        unsigned long size;
+        u16 num;
+        int err;
+
+        /* Select the queue we're interested in */
+        iowrite16(index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
+
+        /* Check if queue is either not available or already active. */
+        num = ioread16(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NUM);
+        if (!num || ioread32(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN))
+                return ERR_PTR(-ENOENT);
+
+        info->num = num;
+        info->msix_vector = msix_vec;
+
+        size = PAGE_ALIGN(vring_size(num, VIRTIO_PCI_VRING_ALIGN));
+        info->queue = alloc_pages_exact(size, GFP_KERNEL|__GFP_ZERO);
+        if (info->queue == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        /* activate the queue */
+        iowrite32(virt_to_phys(info->queue) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
+                  vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
+
+        /* create the vring */
+        vq = vring_new_virtqueue(index, info->num,
+                                 VIRTIO_PCI_VRING_ALIGN, &vp_dev->vdev,
+                                 true, info->queue, vp_notify, callback, name);
+        if (!vq) {
+                err = -ENOMEM;
+                goto out_activate_queue;
+        }
+
+        vq->priv = (void __force *)vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY;
+
+        if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
+                iowrite16(msix_vec, vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
+                msix_vec = ioread16(vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
+                if (msix_vec == VIRTIO_MSI_NO_VECTOR) {
+                        err = -EBUSY;
+                        goto out_assign;
+                }
+        }
+
+        return vq;
+
+out_assign:
+        vring_del_virtqueue(vq);
+out_activate_queue:
+        iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
+        free_pages_exact(info->queue, size);
+        return ERR_PTR(err);
+}
+
+static void del_vq(struct virtio_pci_vq_info *info)
+{
+        struct virtqueue *vq = info->vq;
+        struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
+        unsigned long size;
+
+        iowrite16(vq->index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
+
+        if (vp_dev->msix_enabled) {
+                iowrite16(VIRTIO_MSI_NO_VECTOR,
+                          vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
+                /* Flush the write out to device */
+                ioread8(vp_dev->ioaddr + VIRTIO_PCI_ISR);
+        }
+
+        vring_del_virtqueue(vq);
+
+        /* Select and deactivate the queue */
+        iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
+
+        size = PAGE_ALIGN(vring_size(info->num, VIRTIO_PCI_VRING_ALIGN));
+        free_pages_exact(info->queue, size);
+}
+
+static const struct virtio_config_ops virtio_pci_config_ops = {
+        .get            = vp_get,
+        .set            = vp_set,
+        .get_status     = vp_get_status,
+        .set_status     = vp_set_status,
+        .reset          = vp_reset,
+        .find_vqs       = vp_find_vqs,
+        .del_vqs        = vp_del_vqs,
+        .get_features   = vp_get_features,
+        .finalize_features = vp_finalize_features,
+        .bus_name       = vp_bus_name,
+        .set_vq_affinity = vp_set_vq_affinity,
+};
+
+/* the PCI probing function */
+static int virtio_pci_probe(struct pci_dev *pci_dev,
+                            const struct pci_device_id *id)
+{
+        struct virtio_pci_device *vp_dev;
+        int err;
+
+        /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */
+        if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f)
+                return -ENODEV;
+
+        if (pci_dev->revision != VIRTIO_PCI_ABI_VERSION) {
+                printk(KERN_ERR "virtio_pci: expected ABI version %d, got %d\n",
+                       VIRTIO_PCI_ABI_VERSION, pci_dev->revision);
+                return -ENODEV;
+        }
+
+        /* allocate our structure and fill it out */
+        vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL);
+        if (vp_dev == NULL)
+                return -ENOMEM;
+
+        vp_dev->vdev.dev.parent = &pci_dev->dev;
+        vp_dev->vdev.dev.release = virtio_pci_release_dev;
+        vp_dev->vdev.config = &virtio_pci_config_ops;
+        vp_dev->pci_dev = pci_dev;
+        INIT_LIST_HEAD(&vp_dev->virtqueues);
+        spin_lock_init(&vp_dev->lock);
+
+        /* Disable MSI/MSIX to bring device to a known good state. */
+        pci_msi_off(pci_dev);
+
+        /* enable the device */
+        err = pci_enable_device(pci_dev);
+        if (err)
+                goto out;
+
+        err = pci_request_regions(pci_dev, "virtio-pci");
+        if (err)
+                goto out_enable_device;
+
+        vp_dev->ioaddr = pci_iomap(pci_dev, 0, 0);
+        if (vp_dev->ioaddr == NULL) {
+                err = -ENOMEM;
+                goto out_req_regions;
+        }
+
+        vp_dev->isr = vp_dev->ioaddr + VIRTIO_PCI_ISR;
+
+        pci_set_drvdata(pci_dev, vp_dev);
+        pci_set_master(pci_dev);
+
+        /* we use the subsystem vendor/device id as the virtio vendor/device
+         * id.  this allows us to use the same PCI vendor/device id for all
+         * virtio devices and to identify the particular virtio driver by
+         * the subsystem ids */
+        vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor;
+        vp_dev->vdev.id.device = pci_dev->subsystem_device;
+
+        vp_dev->config_vector = vp_config_vector;
+        vp_dev->setup_vq = setup_vq;
+        vp_dev->del_vq = del_vq;
+
+        /* finally register the virtio device */
+        err = register_virtio_device(&vp_dev->vdev);
+        if (err)
+                goto out_set_drvdata;
+
+        return 0;
+
+out_set_drvdata:
+        pci_iounmap(pci_dev, vp_dev->ioaddr);
+out_req_regions:
+        pci_release_regions(pci_dev);
+out_enable_device:
+        pci_disable_device(pci_dev);
+out:
+        kfree(vp_dev);
+        return err;
+}
+
+static void virtio_pci_remove(struct pci_dev *pci_dev)
+{
+        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
+
+        unregister_virtio_device(&vp_dev->vdev);
+
+        vp_del_vqs(&vp_dev->vdev);
+        pci_iounmap(pci_dev, vp_dev->ioaddr);
+        pci_release_regions(pci_dev);
+        pci_disable_device(pci_dev);
+        kfree(vp_dev);
+}
+
+static struct pci_driver virtio_pci_driver = {
+        .name           = "virtio-pci",
+        .id_table       = virtio_pci_id_table,
+        .probe          = virtio_pci_probe,
+        .remove         = virtio_pci_remove,
+#ifdef CONFIG_PM_SLEEP
+        .driver.pm      = &virtio_pci_pm_ops,
+#endif
+};
+
+module_pci_driver(virtio_pci_driver);
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 3b1f89b6e743..00ec6b3f96b2 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -99,7 +99,8 @@ struct vring_virtqueue
 
 #define to_vvq(_vq) container_of(_vq, struct vring_virtqueue, vq)
 
-static struct vring_desc *alloc_indirect(unsigned int total_sg, gfp_t gfp)
+static struct vring_desc *alloc_indirect(struct virtqueue *_vq,
+                                         unsigned int total_sg, gfp_t gfp)
 {
         struct vring_desc *desc;
         unsigned int i;
@@ -116,7 +117,7 @@ static struct vring_desc *alloc_indirect(unsigned int total_sg, gfp_t gfp)
                 return NULL;
 
         for (i = 0; i < total_sg; i++)
-                desc[i].next = i+1;
+                desc[i].next = cpu_to_virtio16(_vq->vdev, i + 1);
         return desc;
 }
 
@@ -165,17 +166,17 @@ static inline int virtqueue_add(struct virtqueue *_vq,
         /* If the host supports indirect descriptor tables, and we have multiple
          * buffers, then go indirect. FIXME: tune this threshold */
         if (vq->indirect && total_sg > 1 && vq->vq.num_free)
-                desc = alloc_indirect(total_sg, gfp);
+                desc = alloc_indirect(_vq, total_sg, gfp);
         else
                 desc = NULL;
 
         if (desc) {
                 /* Use a single buffer which doesn't continue */
-                vq->vring.desc[head].flags = VRING_DESC_F_INDIRECT;
-                vq->vring.desc[head].addr = virt_to_phys(desc);
+                vq->vring.desc[head].flags = cpu_to_virtio16(_vq->vdev, VRING_DESC_F_INDIRECT);
+                vq->vring.desc[head].addr = cpu_to_virtio64(_vq->vdev, virt_to_phys(desc));
                 /* avoid kmemleak false positive (hidden by virt_to_phys) */
                 kmemleak_ignore(desc);
-                vq->vring.desc[head].len = total_sg * sizeof(struct vring_desc);
+                vq->vring.desc[head].len = cpu_to_virtio32(_vq->vdev, total_sg * sizeof(struct vring_desc));
 
                 /* Set up rest to use this indirect table. */
                 i = 0;
@@ -205,28 +206,28 @@ static inline int virtqueue_add(struct virtqueue *_vq,
 
         for (n = 0; n < out_sgs; n++) {
                 for (sg = sgs[n]; sg; sg = sg_next(sg)) {
-                        desc[i].flags = VRING_DESC_F_NEXT;
-                        desc[i].addr = sg_phys(sg);
-                        desc[i].len = sg->length;
+                        desc[i].flags = cpu_to_virtio16(_vq->vdev, VRING_DESC_F_NEXT);
+                        desc[i].addr = cpu_to_virtio64(_vq->vdev, sg_phys(sg));
+                        desc[i].len = cpu_to_virtio32(_vq->vdev, sg->length);
                         prev = i;
-                        i = desc[i].next;
+                        i = virtio16_to_cpu(_vq->vdev, desc[i].next);
                 }
         }
         for (; n < (out_sgs + in_sgs); n++) {
                 for (sg = sgs[n]; sg; sg = sg_next(sg)) {
-                        desc[i].flags = VRING_DESC_F_NEXT|VRING_DESC_F_WRITE;
-                        desc[i].addr = sg_phys(sg);
-                        desc[i].len = sg->length;
+                        desc[i].flags = cpu_to_virtio16(_vq->vdev, VRING_DESC_F_NEXT | VRING_DESC_F_WRITE);
+                        desc[i].addr = cpu_to_virtio64(_vq->vdev, sg_phys(sg));
+                        desc[i].len = cpu_to_virtio32(_vq->vdev, sg->length);
                         prev = i;
-                        i = desc[i].next;
+                        i = virtio16_to_cpu(_vq->vdev, desc[i].next);
                 }
         }
         /* Last one doesn't continue. */
-        desc[prev].flags &= ~VRING_DESC_F_NEXT;
+        desc[prev].flags &= cpu_to_virtio16(_vq->vdev, ~VRING_DESC_F_NEXT);
 
         /* Update free pointer */
         if (indirect)
-                vq->free_head = vq->vring.desc[head].next;
+                vq->free_head = virtio16_to_cpu(_vq->vdev, vq->vring.desc[head].next);
         else
                 vq->free_head = i;
 
@@ -235,13 +236,13 @@ static inline int virtqueue_add(struct virtqueue *_vq,
 
         /* Put entry in available array (but don't update avail->idx until they
          * do sync). */
-        avail = (vq->vring.avail->idx & (vq->vring.num-1));
-        vq->vring.avail->ring[avail] = head;
+        avail = virtio16_to_cpu(_vq->vdev, vq->vring.avail->idx) & (vq->vring.num - 1);
+        vq->vring.avail->ring[avail] = cpu_to_virtio16(_vq->vdev, head);
 
         /* Descriptors and available array need to be set before we expose the
          * new available array entries. */
         virtio_wmb(vq->weak_barriers);
-        vq->vring.avail->idx++;
+        vq->vring.avail->idx = cpu_to_virtio16(_vq->vdev, virtio16_to_cpu(_vq->vdev, vq->vring.avail->idx) + 1);
         vq->num_added++;
 
         /* This is very unlikely, but theoretically possible.  Kick
@@ -354,8 +355,8 @@ bool virtqueue_kick_prepare(struct virtqueue *_vq)
          * event. */
         virtio_mb(vq->weak_barriers);
 
-        old = vq->vring.avail->idx - vq->num_added;
-        new = vq->vring.avail->idx;
+        old = virtio16_to_cpu(_vq->vdev, vq->vring.avail->idx) - vq->num_added;
+        new = virtio16_to_cpu(_vq->vdev, vq->vring.avail->idx);
         vq->num_added = 0;
 
 #ifdef DEBUG
@@ -367,10 +368,10 @@ bool virtqueue_kick_prepare(struct virtqueue *_vq)
 #endif
 
         if (vq->event) {
-                needs_kick = vring_need_event(vring_avail_event(&vq->vring),
+                needs_kick = vring_need_event(virtio16_to_cpu(_vq->vdev, vring_avail_event(&vq->vring)),
                                               new, old);
         } else {
-                needs_kick = !(vq->vring.used->flags & VRING_USED_F_NO_NOTIFY);
+                needs_kick = !(vq->vring.used->flags & cpu_to_virtio16(_vq->vdev, VRING_USED_F_NO_NOTIFY));
         }
         END_USE(vq);
         return needs_kick;
@@ -432,15 +433,15 @@ static void detach_buf(struct vring_virtqueue *vq, unsigned int head)
         i = head;
 
         /* Free the indirect table */
-        if (vq->vring.desc[i].flags & VRING_DESC_F_INDIRECT)
-                kfree(phys_to_virt(vq->vring.desc[i].addr));
+        if (vq->vring.desc[i].flags & cpu_to_virtio16(vq->vq.vdev, VRING_DESC_F_INDIRECT))
+                kfree(phys_to_virt(virtio64_to_cpu(vq->vq.vdev, vq->vring.desc[i].addr)));
 
-        while (vq->vring.desc[i].flags & VRING_DESC_F_NEXT) {
-                i = vq->vring.desc[i].next;
+        while (vq->vring.desc[i].flags & cpu_to_virtio16(vq->vq.vdev, VRING_DESC_F_NEXT)) {
+                i = virtio16_to_cpu(vq->vq.vdev, vq->vring.desc[i].next);
                 vq->vq.num_free++;
         }
 
-        vq->vring.desc[i].next = vq->free_head;
+        vq->vring.desc[i].next = cpu_to_virtio16(vq->vq.vdev, vq->free_head);
         vq->free_head = head;
         /* Plus final descriptor */
         vq->vq.num_free++;
@@ -448,7 +449,7 @@ static void detach_buf(struct vring_virtqueue *vq, unsigned int head)
 
 static inline bool more_used(const struct vring_virtqueue *vq)
 {
-        return vq->last_used_idx != vq->vring.used->idx;
+        return vq->last_used_idx != virtio16_to_cpu(vq->vq.vdev, vq->vring.used->idx);
 }
 
 /**
@@ -491,8 +492,8 @@ void *virtqueue_get_buf(struct virtqueue *_vq, unsigned int *len)
         virtio_rmb(vq->weak_barriers);
 
         last_used = (vq->last_used_idx & (vq->vring.num - 1));
-        i = vq->vring.used->ring[last_used].id;
-        *len = vq->vring.used->ring[last_used].len;
+        i = virtio32_to_cpu(_vq->vdev, vq->vring.used->ring[last_used].id);
+        *len = virtio32_to_cpu(_vq->vdev, vq->vring.used->ring[last_used].len);
 
         if (unlikely(i >= vq->vring.num)) {
                 BAD_RING(vq, "id %u out of range\n", i);
@@ -510,8 +511,8 @@ void *virtqueue_get_buf(struct virtqueue *_vq, unsigned int *len)
         /* If we expect an interrupt for the next entry, tell host
          * by writing event index and flush out the write before
          * the read in the next get_buf call. */
-        if (!(vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)) {
-                vring_used_event(&vq->vring) = vq->last_used_idx;
+        if (!(vq->vring.avail->flags & cpu_to_virtio16(_vq->vdev, VRING_AVAIL_F_NO_INTERRUPT))) {
+                vring_used_event(&vq->vring) = cpu_to_virtio16(_vq->vdev, vq->last_used_idx);
                 virtio_mb(vq->weak_barriers);
         }
 
@@ -537,7 +538,7 @@ void virtqueue_disable_cb(struct virtqueue *_vq)
 {
         struct vring_virtqueue *vq = to_vvq(_vq);
 
-        vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
+        vq->vring.avail->flags |= cpu_to_virtio16(_vq->vdev, VRING_AVAIL_F_NO_INTERRUPT);
 }
 EXPORT_SYMBOL_GPL(virtqueue_disable_cb);
 
@@ -565,8 +566,8 @@ unsigned virtqueue_enable_cb_prepare(struct virtqueue *_vq)
         /* Depending on the VIRTIO_RING_F_EVENT_IDX feature, we need to
          * either clear the flags bit or point the event index at the next
          * entry. Always do both to keep code simple. */
-        vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
-        vring_used_event(&vq->vring) = last_used_idx = vq->last_used_idx;
+        vq->vring.avail->flags &= cpu_to_virtio16(_vq->vdev, ~VRING_AVAIL_F_NO_INTERRUPT);
+        vring_used_event(&vq->vring) = cpu_to_virtio16(_vq->vdev, last_used_idx = vq->last_used_idx);
         END_USE(vq);
         return last_used_idx;
 }
@@ -586,7 +587,7 @@ bool virtqueue_poll(struct virtqueue *_vq, unsigned last_used_idx)
         struct vring_virtqueue *vq = to_vvq(_vq);
 
         virtio_mb(vq->weak_barriers);
-        return (u16)last_used_idx != vq->vring.used->idx;
+        return (u16)last_used_idx != virtio16_to_cpu(_vq->vdev, vq->vring.used->idx);
 }
 EXPORT_SYMBOL_GPL(virtqueue_poll);
 
@@ -633,12 +634,12 @@ bool virtqueue_enable_cb_delayed(struct virtqueue *_vq)
         /* Depending on the VIRTIO_RING_F_USED_EVENT_IDX feature, we need to
          * either clear the flags bit or point the event index at the next
          * entry. Always do both to keep code simple. */
-        vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
+        vq->vring.avail->flags &= cpu_to_virtio16(_vq->vdev, ~VRING_AVAIL_F_NO_INTERRUPT);
         /* TODO: tune this threshold */
-        bufs = (u16)(vq->vring.avail->idx - vq->last_used_idx) * 3 / 4;
-        vring_used_event(&vq->vring) = vq->last_used_idx + bufs;
+        bufs = (u16)(virtio16_to_cpu(_vq->vdev, vq->vring.avail->idx) - vq->last_used_idx) * 3 / 4;
+        vring_used_event(&vq->vring) = cpu_to_virtio16(_vq->vdev, vq->last_used_idx + bufs);
         virtio_mb(vq->weak_barriers);
-        if (unlikely((u16)(vq->vring.used->idx - vq->last_used_idx) > bufs)) {
+        if (unlikely((u16)(virtio16_to_cpu(_vq->vdev, vq->vring.used->idx) - vq->last_used_idx) > bufs)) {
                 END_USE(vq);
                 return false;
         }
@@ -670,7 +671,7 @@ void *virtqueue_detach_unused_buf(struct virtqueue *_vq)
                 /* detach_buf clears data, so grab it now. */
                 buf = vq->data[i];
                 detach_buf(vq, i);
-                vq->vring.avail->idx--;
+                vq->vring.avail->idx = cpu_to_virtio16(_vq->vdev, virtio16_to_cpu(_vq->vdev, vq->vring.avail->idx) - 1);
                 END_USE(vq);
                 return buf;
         }
@@ -747,12 +748,12 @@ struct virtqueue *vring_new_virtqueue(unsigned int index,
 
         /* No callback?  Tell other side not to bother us. */
         if (!callback)
-                vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
+                vq->vring.avail->flags |= cpu_to_virtio16(vdev, VRING_AVAIL_F_NO_INTERRUPT);
 
         /* Put everything in free lists. */
         vq->free_head = 0;
         for (i = 0; i < num-1; i++) {
-                vq->vring.desc[i].next = i+1;
+                vq->vring.desc[i].next = cpu_to_virtio16(vdev, i + 1);
                 vq->data[i] = NULL;
         }
         vq->data[i] = NULL;
@@ -779,9 +780,11 @@ void vring_transport_features(struct virtio_device *vdev)
                         break;
                 case VIRTIO_RING_F_EVENT_IDX:
                         break;
+                case VIRTIO_F_VERSION_1:
+                        break;
                 default:
                         /* We don't understand this bit. */
-                        clear_bit(i, vdev->features);
+                        __virtio_clear_bit(vdev, i);
                 }
         }
 }
@@ -826,4 +829,20 @@ void virtio_break_device(struct virtio_device *dev)
 }
 EXPORT_SYMBOL_GPL(virtio_break_device);
 
+void *virtqueue_get_avail(struct virtqueue *_vq)
+{
+        struct vring_virtqueue *vq = to_vvq(_vq);
+
+        return vq->vring.avail;
+}
+EXPORT_SYMBOL_GPL(virtqueue_get_avail);
+
+void *virtqueue_get_used(struct virtqueue *_vq)
+{
+        struct vring_virtqueue *vq = to_vvq(_vq);
+
+        return vq->vring.used;
+}
+EXPORT_SYMBOL_GPL(virtqueue_get_used);
+
 MODULE_LICENSE("GPL");
diff --git a/drivers/w1/masters/omap_hdq.c b/drivers/w1/masters/omap_hdq.c
index 9900e8ec7393..03321d6a2684 100644
--- a/drivers/w1/masters/omap_hdq.c
+++ b/drivers/w1/masters/omap_hdq.c
@@ -72,11 +72,18 @@ struct hdq_data {
 static int omap_hdq_probe(struct platform_device *pdev);
 static int omap_hdq_remove(struct platform_device *pdev);
 
+static struct of_device_id omap_hdq_dt_ids[] = {
+        { .compatible = "ti,omap3-1w" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, omap_hdq_dt_ids);
+
 static struct platform_driver omap_hdq_driver = {
         .probe =        omap_hdq_probe,
         .remove =       omap_hdq_remove,
         .driver =       {
                 .name = "omap_hdq",
+                .of_match_table = omap_hdq_dt_ids,
         },
 };
 
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index d0107d424ee4..08f41add1461 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -154,14 +154,14 @@ config ARM_SP805_WATCHDOG
 
 config AT91RM9200_WATCHDOG
         tristate "AT91RM9200 watchdog"
-        depends on ARCH_AT91RM9200
+        depends on SOC_AT91RM9200
         help
           Watchdog timer embedded into AT91RM9200 chips. This will reboot your
           system when the timeout is reached.
 
 config AT91SAM9X_WATCHDOG
         tristate "AT91SAM9X / AT91CAP9 watchdog"
-        depends on ARCH_AT91 && !ARCH_AT91RM9200
+        depends on ARCH_AT91
         select WATCHDOG_CORE
         help
           Watchdog timer embedded into AT91SAM9X and AT91CAP9 chips. This will
diff --git a/drivers/watchdog/orion_wdt.c b/drivers/watchdog/orion_wdt.c
index 00d0741228fc..8cb1ff3bcd90 100644
--- a/drivers/watchdog/orion_wdt.c
+++ b/drivers/watchdog/orion_wdt.c
@@ -114,6 +114,46 @@ static int armada370_wdt_clock_init(struct platform_device *pdev,
         return 0;
 }
 
+static int armada375_wdt_clock_init(struct platform_device *pdev,
+                                    struct orion_watchdog *dev)
+{
+        int ret;
+
+        dev->clk = of_clk_get_by_name(pdev->dev.of_node, "fixed");
+        if (!IS_ERR(dev->clk)) {
+                ret = clk_prepare_enable(dev->clk);
+                if (ret) {
+                        clk_put(dev->clk);
+                        return ret;
+                }
+
+                atomic_io_modify(dev->reg + TIMER_CTRL,
+                                WDT_AXP_FIXED_ENABLE_BIT,
+                                WDT_AXP_FIXED_ENABLE_BIT);
+                dev->clk_rate = clk_get_rate(dev->clk);
+
+                return 0;
+        }
+
+        /* Mandatory fallback for proper devicetree backward compatibility */
+        dev->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(dev->clk))
+                return PTR_ERR(dev->clk);
+
+        ret = clk_prepare_enable(dev->clk);
+        if (ret) {
+                clk_put(dev->clk);
+                return ret;
+        }
+
+        atomic_io_modify(dev->reg + TIMER_CTRL,
+                        WDT_A370_RATIO_MASK(WDT_A370_RATIO_SHIFT),
+                        WDT_A370_RATIO_MASK(WDT_A370_RATIO_SHIFT));
+        dev->clk_rate = clk_get_rate(dev->clk) / WDT_A370_RATIO;
+
+        return 0;
+}
+
 static int armadaxp_wdt_clock_init(struct platform_device *pdev,
                                    struct orion_watchdog *dev)
 {
@@ -394,7 +434,7 @@ static const struct orion_watchdog_data armada375_data = {
         .rstout_mask_bit = BIT(10),
         .wdt_enable_bit = BIT(8),
         .wdt_counter_offset = 0x34,
-        .clock_init = armada370_wdt_clock_init,
+        .clock_init = armada375_wdt_clock_init,
         .enabled = armada375_enabled,
         .start = armada375_start,
         .stop = armada375_stop,
diff --git a/drivers/watchdog/s3c2410_wdt.c b/drivers/watchdog/s3c2410_wdt.c
index 8532c3e2aea7..1626dc66e763 100644
--- a/drivers/watchdog/s3c2410_wdt.c
+++ b/drivers/watchdog/s3c2410_wdt.c
@@ -161,7 +161,7 @@ static const struct s3c2410_wdt_variant drv_data_exynos5420 = {
 static const struct s3c2410_wdt_variant drv_data_exynos7 = {
         .disable_reg = EXYNOS5_WDT_DISABLE_REG_OFFSET,
         .mask_reset_reg = EXYNOS5_WDT_MASK_RESET_REG_OFFSET,
-        .mask_bit = 0,
+        .mask_bit = 23,
         .rst_stat_reg = EXYNOS5_RST_STAT_REG_OFFSET,
         .rst_stat_bit = 23,     /* A57 WDTRESET */
         .quirks = QUIRK_HAS_PMU_CONFIG | QUIRK_HAS_RST_STAT,
diff --git a/drivers/xen/efi.c b/drivers/xen/efi.c
index 1f850c97482f..f745db270171 100644
--- a/drivers/xen/efi.c
+++ b/drivers/xen/efi.c
@@ -294,6 +294,7 @@ static const struct efi efi_xen __initconst = {
         .acpi                     = EFI_INVALID_TABLE_ADDR,
         .acpi20                   = EFI_INVALID_TABLE_ADDR,
         .smbios                   = EFI_INVALID_TABLE_ADDR,
+        .smbios3                  = EFI_INVALID_TABLE_ADDR,
         .sal_systab               = EFI_INVALID_TABLE_ADDR,
         .boot_info                = EFI_INVALID_TABLE_ADDR,
         .hcdp                     = EFI_INVALID_TABLE_ADDR,
diff --git a/drivers/xen/xen-scsiback.c b/drivers/xen/xen-scsiback.c
index 3e32146472a5..50610a6acf3d 100644
--- a/drivers/xen/xen-scsiback.c
+++ b/drivers/xen/xen-scsiback.c
@@ -274,10 +274,6 @@ static void scsiback_print_status(char *sense_buffer, int errors,
                tpg->tport->tport_name, pending_req->v2p->lun,
                pending_req->cmnd[0], status_byte(errors), msg_byte(errors),
                host_byte(errors), driver_byte(errors));
-
-        if (CHECK_CONDITION & status_byte(errors))
-                __scsi_print_sense("xen-pvscsi", sense_buffer,
-                                   SCSI_SENSE_BUFFERSIZE);
 }
 
 static void scsiback_fast_flush_area(struct vscsibk_pend *req)