Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Conflicts:
	drivers/net/ethernet/rocker/rocker.c

The rocker commit was two overlapping changes, one to rename
the ->vport member to ->pport, and another making the bitmask
expression use '1ULL' instead of plain '1'.

Signed-off-by: David S. Miller <davem@davemloft.net>

579 files changed, 30059 insertions, 10709 deletions

diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index b18cd2151ddb..623b117ad1a2 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -55,6 +55,7 @@ acpi-$(CONFIG_ACPI_PROCFS_POWER) += cm_sbs.o
 ifdef CONFIG_ACPI_VIDEO
 acpi-y                          += video_detect.o
 endif
+acpi-y                          += acpi_lpat.o
 
 # These are (potentially) separate modules
 
diff --git a/drivers/acpi/acpi_lpat.c b/drivers/acpi/acpi_lpat.c
new file mode 100644
index 000000000000..feb61c1630eb
--- /dev/null
+++ b/drivers/acpi/acpi_lpat.c
@@ -0,0 +1,161 @@
+/*
+ * acpi_lpat.c - LPAT table processing functions
+ *
+ * Copyright (C) 2015 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 <acpi/acpi_lpat.h>
+
+/**
+ * acpi_lpat_raw_to_temp(): Return temperature from raw value through
+ * LPAT conversion table
+ *
+ * @lpat_table: the temperature_raw mapping table structure
+ * @raw: the raw value, used as a key to get the temerature from the
+ *       above mapping table
+ *
+ * A positive converted temperarure value will be returned on success,
+ * a negative errno will be returned in error cases.
+ */
+int acpi_lpat_raw_to_temp(struct acpi_lpat_conversion_table *lpat_table,
+                          int raw)
+{
+        int i, delta_temp, delta_raw, temp;
+        struct acpi_lpat *lpat = lpat_table->lpat;
+
+        for (i = 0; i < lpat_table->lpat_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 == lpat_table->lpat_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;
+}
+EXPORT_SYMBOL_GPL(acpi_lpat_raw_to_temp);
+
+/**
+ * acpi_lpat_temp_to_raw(): Return raw value from temperature through
+ * LPAT conversion table
+ *
+ * @lpat: the temperature_raw mapping table
+ * @temp: the temperature, used as a key to get the raw value from the
+ *        above mapping table
+ *
+ * A positive converted temperature value will be returned on success,
+ * a negative errno will be returned in error cases.
+ */
+int acpi_lpat_temp_to_raw(struct acpi_lpat_conversion_table *lpat_table,
+                          int temp)
+{
+        int i, delta_temp, delta_raw, raw;
+        struct acpi_lpat *lpat = lpat_table->lpat;
+
+        for (i = 0; i < lpat_table->lpat_count - 1; i++) {
+                if (temp >= lpat[i].temp && temp <= lpat[i+1].temp)
+                        break;
+        }
+
+        if (i ==  lpat_table->lpat_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;
+}
+EXPORT_SYMBOL_GPL(acpi_lpat_temp_to_raw);
+
+/**
+ * acpi_lpat_get_conversion_table(): Parse ACPI LPAT table if present.
+ *
+ * @handle: Handle to acpi device
+ *
+ * Parse LPAT table to a struct of type acpi_lpat_table. On success
+ * it returns a pointer to newly allocated table. This table must
+ * be freed by the caller when finished processing, using a call to
+ * acpi_lpat_free_conversion_table.
+ */
+struct acpi_lpat_conversion_table *acpi_lpat_get_conversion_table(acpi_handle
+                                                                  handle)
+{
+        struct acpi_lpat_conversion_table *lpat_table = NULL;
+        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 NULL;
+
+        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 = kcalloc(obj_p->package.count, sizeof(int), 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) {
+                        kfree(lpat);
+                        goto out;
+                }
+                lpat[i] = (s64)obj_e->integer.value;
+        }
+
+        lpat_table = kzalloc(sizeof(*lpat_table), GFP_KERNEL);
+        if (!lpat_table) {
+                kfree(lpat);
+                goto out;
+        }
+
+        lpat_table->lpat = (struct acpi_lpat *)lpat;
+        lpat_table->lpat_count = obj_p->package.count / 2;
+
+out:
+        kfree(buffer.pointer);
+        return lpat_table;
+}
+EXPORT_SYMBOL_GPL(acpi_lpat_get_conversion_table);
+
+/**
+ * acpi_lpat_free_conversion_table(): Free LPAT table.
+ *
+ * @lpat_table: the temperature_raw mapping table structure
+ *
+ * Frees the LPAT table previously allocated by a call to
+ * acpi_lpat_get_conversion_table.
+ */
+void acpi_lpat_free_conversion_table(struct acpi_lpat_conversion_table
+                                     *lpat_table)
+{
+        if (lpat_table) {
+                kfree(lpat_table->lpat);
+                kfree(lpat_table);
+        }
+}
+EXPORT_SYMBOL_GPL(acpi_lpat_free_conversion_table);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c
index 02e835f3cf8a..657964e8ab7e 100644
--- a/drivers/acpi/acpi_lpss.c
+++ b/drivers/acpi/acpi_lpss.c
@@ -105,7 +105,7 @@ static void lpss_uart_setup(struct lpss_private_data *pdata)
         }
 }
 
-static void byt_i2c_setup(struct lpss_private_data *pdata)
+static void lpss_deassert_reset(struct lpss_private_data *pdata)
 {
         unsigned int offset;
         u32 val;
@@ -114,9 +114,18 @@ static void byt_i2c_setup(struct lpss_private_data *pdata)
         val = readl(pdata->mmio_base + offset);
         val |= LPSS_RESETS_RESET_APB | LPSS_RESETS_RESET_FUNC;
         writel(val, pdata->mmio_base + offset);
+}
+
+#define LPSS_I2C_ENABLE                 0x6c
+
+static void byt_i2c_setup(struct lpss_private_data *pdata)
+{
+        lpss_deassert_reset(pdata);
 
         if (readl(pdata->mmio_base + pdata->dev_desc->prv_offset))
                 pdata->fixed_clk_rate = 133000000;
+
+        writel(0, pdata->mmio_base + LPSS_I2C_ENABLE);
 }
 
 static struct lpss_device_desc lpt_dev_desc = {
@@ -125,7 +134,7 @@ static struct lpss_device_desc lpt_dev_desc = {
 };
 
 static struct lpss_device_desc lpt_i2c_dev_desc = {
-        .flags = LPSS_CLK | LPSS_LTR,
+        .flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_LTR,
         .prv_offset = 0x800,
 };
 
@@ -166,6 +175,12 @@ static struct lpss_device_desc byt_i2c_dev_desc = {
         .setup = byt_i2c_setup,
 };
 
+static struct lpss_device_desc bsw_spi_dev_desc = {
+        .flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX,
+        .prv_offset = 0x400,
+        .setup = lpss_deassert_reset,
+};
+
 #else
 
 #define LPSS_ADDR(desc) (0UL)
@@ -198,7 +213,7 @@ static const struct acpi_device_id acpi_lpss_device_ids[] = {
         /* Braswell LPSS devices */
         { "80862288", LPSS_ADDR(byt_pwm_dev_desc) },
         { "8086228A", LPSS_ADDR(byt_uart_dev_desc) },
-        { "8086228E", LPSS_ADDR(byt_spi_dev_desc) },
+        { "8086228E", LPSS_ADDR(bsw_spi_dev_desc) },
         { "808622C1", LPSS_ADDR(byt_i2c_dev_desc) },
 
         { "INT3430", LPSS_ADDR(lpt_dev_desc) },
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 982b67faaaf3..a8dd2f763382 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -680,7 +680,7 @@ static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
                 /* Enable GPE for event processing (SCI_EVT=1) */
                 if (!resuming)
                         acpi_ec_submit_request(ec);
-                pr_info("+++++ EC started +++++\n");
+                pr_debug("EC started\n");
         }
         spin_unlock_irqrestore(&ec->lock, flags);
 }
@@ -712,7 +712,7 @@ static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
                         acpi_ec_complete_request(ec);
                 clear_bit(EC_FLAGS_STARTED, &ec->flags);
                 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
-                pr_info("+++++ EC stopped +++++\n");
+                pr_debug("EC stopped\n");
         }
         spin_unlock_irqrestore(&ec->lock, flags);
 }
diff --git a/drivers/acpi/pmic/intel_pmic.c b/drivers/acpi/pmic/intel_pmic.c
index a732e5d7e322..bd772cd56494 100644
--- a/drivers/acpi/pmic/intel_pmic.c
+++ b/drivers/acpi/pmic/intel_pmic.c
@@ -16,20 +16,15 @@
 #include <linux/module.h>
 #include <linux/acpi.h>
 #include <linux/regmap.h>
+#include <acpi/acpi_lpat.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 acpi_lpat_conversion_table *lpat_table;
         struct regmap *regmap;
         struct intel_pmic_opregion_data *data;
 };
@@ -50,105 +45,6 @@ static int pmic_get_reg_bit(int address, struct pmic_table *table,
         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)
@@ -192,12 +88,12 @@ static int pmic_read_temp(struct intel_pmic_opregion *opregion,
         if (raw_temp < 0)
                 return raw_temp;
 
-        if (!opregion->lpat) {
+        if (!opregion->lpat_table) {
                 *value = raw_temp;
                 return 0;
         }
 
-        temp = raw_to_temp(opregion->lpat, opregion->lpat_count, raw_temp);
+        temp = acpi_lpat_raw_to_temp(opregion->lpat_table, raw_temp);
         if (temp < 0)
                 return temp;
 
@@ -223,9 +119,8 @@ static int pmic_thermal_aux(struct intel_pmic_opregion *opregion, int reg,
         if (!opregion->data->update_aux)
                 return -ENXIO;
 
-        if (opregion->lpat) {
-                raw_temp = temp_to_raw(opregion->lpat, opregion->lpat_count,
-                                       *value);
+        if (opregion->lpat_table) {
+                raw_temp = acpi_lpat_temp_to_raw(opregion->lpat_table, *value);
                 if (raw_temp < 0)
                         return raw_temp;
         } else {
@@ -314,6 +209,7 @@ int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle,
 {
         acpi_status status;
         struct intel_pmic_opregion *opregion;
+        int ret;
 
         if (!dev || !regmap || !d)
                 return -EINVAL;
@@ -327,14 +223,16 @@ int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle,
 
         mutex_init(&opregion->lock);
         opregion->regmap = regmap;
-        pmic_thermal_lpat(opregion, handle, dev);
+        opregion->lpat_table = acpi_lpat_get_conversion_table(handle);
 
         status = acpi_install_address_space_handler(handle,
                                                     PMIC_POWER_OPREGION_ID,
                                                     intel_pmic_power_handler,
                                                     NULL, opregion);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
+        if (ACPI_FAILURE(status)) {
+                ret = -ENODEV;
+                goto out_error;
+        }
 
         status = acpi_install_address_space_handler(handle,
                                                     PMIC_THERMAL_OPREGION_ID,
@@ -343,11 +241,16 @@ int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle,
         if (ACPI_FAILURE(status)) {
                 acpi_remove_address_space_handler(handle, PMIC_POWER_OPREGION_ID,
                                                   intel_pmic_power_handler);
-                return -ENODEV;
+                ret = -ENODEV;
+                goto out_error;
         }
 
         opregion->data = d;
         return 0;
+
+out_error:
+        acpi_lpat_free_conversion_table(opregion->lpat_table);
+        return ret;
 }
 EXPORT_SYMBOL_GPL(intel_pmic_install_opregion_handler);
 
diff --git a/drivers/acpi/resource.c b/drivers/acpi/resource.c
index 4752b9939987..c723668e3e27 100644
--- a/drivers/acpi/resource.c
+++ b/drivers/acpi/resource.c
@@ -46,7 +46,7 @@ static bool acpi_dev_resource_len_valid(u64 start, u64 end, u64 len, bool io)
         if (len && reslen && reslen == len && start <= end)
                 return true;
 
-        pr_info("ACPI: invalid or unassigned resource %s [%016llx - %016llx] length [%016llx]\n",
+        pr_debug("ACPI: invalid or unassigned resource %s [%016llx - %016llx] length [%016llx]\n",
                 io ? "io" : "mem", start, end, len);
 
         return false;
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 88a4f99dd2a7..debd30917010 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -540,6 +540,15 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
                 DMI_MATCH(DMI_PRODUCT_NAME, "730U3E/740U3E"),
                 },
         },
+        {
+         /* https://bugs.freedesktop.org/show_bug.cgi?id=87286 */
+         .callback = video_disable_native_backlight,
+         .ident = "SAMSUNG 900X3C/900X3D/900X3E/900X4C/900X4D",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                DMI_MATCH(DMI_PRODUCT_NAME, "900X3C/900X3D/900X3E/900X4C/900X4D"),
+                },
+        },
 
         {
          /* https://bugzilla.redhat.com/show_bug.cgi?id=1163574 */
diff --git a/drivers/block/nvme-core.c b/drivers/block/nvme-core.c
index cbdfbbf98392..ceb32dd52a6c 100644
--- a/drivers/block/nvme-core.c
+++ b/drivers/block/nvme-core.c
@@ -37,17 +37,18 @@
 #include <linux/ptrace.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/t10-pi.h>
 #include <linux/types.h>
 #include <scsi/sg.h>
 #include <asm-generic/io-64-nonatomic-lo-hi.h>
 
+#define NVME_MINORS             (1U << MINORBITS)
 #define NVME_Q_DEPTH            1024
 #define NVME_AQ_DEPTH           64
 #define SQ_SIZE(depth)          (depth * sizeof(struct nvme_command))
 #define CQ_SIZE(depth)          (depth * sizeof(struct nvme_completion))
 #define ADMIN_TIMEOUT           (admin_timeout * HZ)
 #define SHUTDOWN_TIMEOUT        (shutdown_timeout * HZ)
-#define IOD_TIMEOUT             (retry_time * HZ)
 
 static unsigned char admin_timeout = 60;
 module_param(admin_timeout, byte, 0644);
@@ -57,10 +58,6 @@ unsigned char nvme_io_timeout = 30;
 module_param_named(io_timeout, nvme_io_timeout, byte, 0644);
 MODULE_PARM_DESC(io_timeout, "timeout in seconds for I/O");
 
-static unsigned char retry_time = 30;
-module_param(retry_time, byte, 0644);
-MODULE_PARM_DESC(retry_time, "time in seconds to retry failed I/O");
-
 static unsigned char shutdown_timeout = 5;
 module_param(shutdown_timeout, byte, 0644);
 MODULE_PARM_DESC(shutdown_timeout, "timeout in seconds for controller shutdown");
@@ -68,6 +65,9 @@ MODULE_PARM_DESC(shutdown_timeout, "timeout in seconds for controller shutdown")
 static int nvme_major;
 module_param(nvme_major, int, 0);
 
+static int nvme_char_major;
+module_param(nvme_char_major, int, 0);
+
 static int use_threaded_interrupts;
 module_param(use_threaded_interrupts, int, 0);
 
@@ -76,7 +76,8 @@ static LIST_HEAD(dev_list);
 static struct task_struct *nvme_thread;
 static struct workqueue_struct *nvme_workq;
 static wait_queue_head_t nvme_kthread_wait;
-static struct notifier_block nvme_nb;
+
+static struct class *nvme_class;
 
 static void nvme_reset_failed_dev(struct work_struct *ws);
 static int nvme_process_cq(struct nvme_queue *nvmeq);
@@ -95,7 +96,6 @@ struct async_cmd_info {
  * commands and one for I/O commands).
  */
 struct nvme_queue {
-        struct llist_node node;
         struct device *q_dmadev;
         struct nvme_dev *dev;
         char irqname[24];       /* nvme4294967295-65535\0 */
@@ -482,6 +482,115 @@ static int nvme_error_status(u16 status)
         }
 }
 
+#ifdef CONFIG_BLK_DEV_INTEGRITY
+static void nvme_dif_prep(u32 p, u32 v, struct t10_pi_tuple *pi)
+{
+        if (be32_to_cpu(pi->ref_tag) == v)
+                pi->ref_tag = cpu_to_be32(p);
+}
+
+static void nvme_dif_complete(u32 p, u32 v, struct t10_pi_tuple *pi)
+{
+        if (be32_to_cpu(pi->ref_tag) == p)
+                pi->ref_tag = cpu_to_be32(v);
+}
+
+/**
+ * nvme_dif_remap - remaps ref tags to bip seed and physical lba
+ *
+ * The virtual start sector is the one that was originally submitted by the
+ * block layer. Due to partitioning, MD/DM cloning, etc. the actual physical
+ * start sector may be different. Remap protection information to match the
+ * physical LBA on writes, and back to the original seed on reads.
+ *
+ * Type 0 and 3 do not have a ref tag, so no remapping required.
+ */
+static void nvme_dif_remap(struct request *req,
+                        void (*dif_swap)(u32 p, u32 v, struct t10_pi_tuple *pi))
+{
+        struct nvme_ns *ns = req->rq_disk->private_data;
+        struct bio_integrity_payload *bip;
+        struct t10_pi_tuple *pi;
+        void *p, *pmap;
+        u32 i, nlb, ts, phys, virt;
+
+        if (!ns->pi_type || ns->pi_type == NVME_NS_DPS_PI_TYPE3)
+                return;
+
+        bip = bio_integrity(req->bio);
+        if (!bip)
+                return;
+
+        pmap = kmap_atomic(bip->bip_vec->bv_page) + bip->bip_vec->bv_offset;
+        if (!pmap)
+                return;
+
+        p = pmap;
+        virt = bip_get_seed(bip);
+        phys = nvme_block_nr(ns, blk_rq_pos(req));
+        nlb = (blk_rq_bytes(req) >> ns->lba_shift);
+        ts = ns->disk->integrity->tuple_size;
+
+        for (i = 0; i < nlb; i++, virt++, phys++) {
+                pi = (struct t10_pi_tuple *)p;
+                dif_swap(phys, virt, pi);
+                p += ts;
+        }
+        kunmap_atomic(pmap);
+}
+
+static int nvme_noop_verify(struct blk_integrity_iter *iter)
+{
+        return 0;
+}
+
+static int nvme_noop_generate(struct blk_integrity_iter *iter)
+{
+        return 0;
+}
+
+struct blk_integrity nvme_meta_noop = {
+        .name                   = "NVME_META_NOOP",
+        .generate_fn            = nvme_noop_generate,
+        .verify_fn              = nvme_noop_verify,
+};
+
+static void nvme_init_integrity(struct nvme_ns *ns)
+{
+        struct blk_integrity integrity;
+
+        switch (ns->pi_type) {
+        case NVME_NS_DPS_PI_TYPE3:
+                integrity = t10_pi_type3_crc;
+                break;
+        case NVME_NS_DPS_PI_TYPE1:
+        case NVME_NS_DPS_PI_TYPE2:
+                integrity = t10_pi_type1_crc;
+                break;
+        default:
+                integrity = nvme_meta_noop;
+                break;
+        }
+        integrity.tuple_size = ns->ms;
+        blk_integrity_register(ns->disk, &integrity);
+        blk_queue_max_integrity_segments(ns->queue, 1);
+}
+#else /* CONFIG_BLK_DEV_INTEGRITY */
+static void nvme_dif_remap(struct request *req,
+                        void (*dif_swap)(u32 p, u32 v, struct t10_pi_tuple *pi))
+{
+}
+static void nvme_dif_prep(u32 p, u32 v, struct t10_pi_tuple *pi)
+{
+}
+static void nvme_dif_complete(u32 p, u32 v, struct t10_pi_tuple *pi)
+{
+}
+static void nvme_init_integrity(struct nvme_ns *ns)
+{
+}
+#endif
+
 static void req_completion(struct nvme_queue *nvmeq, void *ctx,
                                                 struct nvme_completion *cqe)
 {
@@ -512,9 +621,16 @@ static void req_completion(struct nvme_queue *nvmeq, void *ctx,
                         "completing aborted command with status:%04x\n",
                         status);
 
-        if (iod->nents)
+        if (iod->nents) {
                 dma_unmap_sg(&nvmeq->dev->pci_dev->dev, iod->sg, iod->nents,
                         rq_data_dir(req) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                if (blk_integrity_rq(req)) {
+                        if (!rq_data_dir(req))
+                                nvme_dif_remap(req, nvme_dif_complete);
+                        dma_unmap_sg(&nvmeq->dev->pci_dev->dev, iod->meta_sg, 1,
+                                rq_data_dir(req) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                }
+        }
         nvme_free_iod(nvmeq->dev, iod);
 
         blk_mq_complete_request(req);
@@ -670,6 +786,24 @@ static int nvme_submit_iod(struct nvme_queue *nvmeq, struct nvme_iod *iod,
         cmnd->rw.prp2 = cpu_to_le64(iod->first_dma);
         cmnd->rw.slba = cpu_to_le64(nvme_block_nr(ns, blk_rq_pos(req)));
         cmnd->rw.length = cpu_to_le16((blk_rq_bytes(req) >> ns->lba_shift) - 1);
+
+        if (blk_integrity_rq(req)) {
+                cmnd->rw.metadata = cpu_to_le64(sg_dma_address(iod->meta_sg));
+                switch (ns->pi_type) {
+                case NVME_NS_DPS_PI_TYPE3:
+                        control |= NVME_RW_PRINFO_PRCHK_GUARD;
+                        break;
+                case NVME_NS_DPS_PI_TYPE1:
+                case NVME_NS_DPS_PI_TYPE2:
+                        control |= NVME_RW_PRINFO_PRCHK_GUARD |
+                                        NVME_RW_PRINFO_PRCHK_REF;
+                        cmnd->rw.reftag = cpu_to_le32(
+                                        nvme_block_nr(ns, blk_rq_pos(req)));
+                        break;
+                }
+        } else if (ns->ms)
+                control |= NVME_RW_PRINFO_PRACT;
+
         cmnd->rw.control = cpu_to_le16(control);
         cmnd->rw.dsmgmt = cpu_to_le32(dsmgmt);
 
@@ -690,6 +824,19 @@ static int nvme_queue_rq(struct blk_mq_hw_ctx *hctx,
         struct nvme_iod *iod;
         enum dma_data_direction dma_dir;
 
+        /*
+         * If formated with metadata, require the block layer provide a buffer
+         * unless this namespace is formated such that the metadata can be
+         * stripped/generated by the controller with PRACT=1.
+         */
+        if (ns->ms && !blk_integrity_rq(req)) {
+                if (!(ns->pi_type && ns->ms == 8)) {
+                        req->errors = -EFAULT;
+                        blk_mq_complete_request(req);
+                        return BLK_MQ_RQ_QUEUE_OK;
+                }
+        }
+
         iod = nvme_alloc_iod(req, ns->dev, GFP_ATOMIC);
         if (!iod)
                 return BLK_MQ_RQ_QUEUE_BUSY;
@@ -725,6 +872,21 @@ static int nvme_queue_rq(struct blk_mq_hw_ctx *hctx,
                                         iod->nents, dma_dir);
                         goto retry_cmd;
                 }
+                if (blk_integrity_rq(req)) {
+                        if (blk_rq_count_integrity_sg(req->q, req->bio) != 1)
+                                goto error_cmd;
+
+                        sg_init_table(iod->meta_sg, 1);
+                        if (blk_rq_map_integrity_sg(
+                                        req->q, req->bio, iod->meta_sg) != 1)
+                                goto error_cmd;
+
+                        if (rq_data_dir(req))
+                                nvme_dif_remap(req, nvme_dif_prep);
+
+                        if (!dma_map_sg(nvmeq->q_dmadev, iod->meta_sg, 1, dma_dir))
+                                goto error_cmd;
+                }
         }
 
         nvme_set_info(cmd, iod, req_completion);
@@ -817,14 +979,6 @@ static irqreturn_t nvme_irq_check(int irq, void *data)
         return IRQ_WAKE_THREAD;
 }
 
-static void nvme_abort_cmd_info(struct nvme_queue *nvmeq, struct nvme_cmd_info *
-                                                                cmd_info)
-{
-        spin_lock_irq(&nvmeq->q_lock);
-        cancel_cmd_info(cmd_info, NULL);
-        spin_unlock_irq(&nvmeq->q_lock);
-}
-
 struct sync_cmd_info {
         struct task_struct *task;
         u32 result;
@@ -847,7 +1001,6 @@ static void sync_completion(struct nvme_queue *nvmeq, void *ctx,
 static int nvme_submit_sync_cmd(struct request *req, struct nvme_command *cmd,
                                                 u32 *result, unsigned timeout)
 {
-        int ret;
         struct sync_cmd_info cmdinfo;
         struct nvme_cmd_info *cmd_rq = blk_mq_rq_to_pdu(req);
         struct nvme_queue *nvmeq = cmd_rq->nvmeq;
@@ -859,29 +1012,12 @@ static int nvme_submit_sync_cmd(struct request *req, struct nvme_command *cmd,
 
         nvme_set_info(cmd_rq, &cmdinfo, sync_completion);
 
-        set_current_state(TASK_KILLABLE);
-        ret = nvme_submit_cmd(nvmeq, cmd);
-        if (ret) {
-                nvme_finish_cmd(nvmeq, req->tag, NULL);
-                set_current_state(TASK_RUNNING);
-        }
-        ret = schedule_timeout(timeout);
-
-        /*
-         * Ensure that sync_completion has either run, or that it will
-         * never run.
-         */
-        nvme_abort_cmd_info(nvmeq, blk_mq_rq_to_pdu(req));
-
-        /*
-         * We never got the completion
-         */
-        if (cmdinfo.status == -EINTR)
-                return -EINTR;
+        set_current_state(TASK_UNINTERRUPTIBLE);
+        nvme_submit_cmd(nvmeq, cmd);
+        schedule();
 
         if (result)
                 *result = cmdinfo.result;
-
         return cmdinfo.status;
 }
 
@@ -1158,29 +1294,18 @@ static enum blk_eh_timer_return nvme_timeout(struct request *req, bool reserved)
         struct nvme_cmd_info *cmd = blk_mq_rq_to_pdu(req);
         struct nvme_queue *nvmeq = cmd->nvmeq;
 
-        /*
-         * The aborted req will be completed on receiving the abort req.
-         * We enable the timer again. If hit twice, it'll cause a device reset,
-         * as the device then is in a faulty state.
-         */
-        int ret = BLK_EH_RESET_TIMER;
-
         dev_warn(nvmeq->q_dmadev, "Timeout I/O %d QID %d\n", req->tag,
                                                         nvmeq->qid);
-
         spin_lock_irq(&nvmeq->q_lock);
-        if (!nvmeq->dev->initialized) {
-                /*
-                 * Force cancelled command frees the request, which requires we
-                 * return BLK_EH_NOT_HANDLED.
-                 */
-                nvme_cancel_queue_ios(nvmeq->hctx, req, nvmeq, reserved);
-                ret = BLK_EH_NOT_HANDLED;
-        } else
-                nvme_abort_req(req);
+        nvme_abort_req(req);
         spin_unlock_irq(&nvmeq->q_lock);
 
-        return ret;
+        /*
+         * The aborted req will be completed on receiving the abort req.
+         * We enable the timer again. If hit twice, it'll cause a device reset,
+         * as the device then is in a faulty state.
+         */
+        return BLK_EH_RESET_TIMER;
 }
 
 static void nvme_free_queue(struct nvme_queue *nvmeq)
@@ -1233,7 +1358,6 @@ static void nvme_clear_queue(struct nvme_queue *nvmeq)
         struct blk_mq_hw_ctx *hctx = nvmeq->hctx;
 
         spin_lock_irq(&nvmeq->q_lock);
-        nvme_process_cq(nvmeq);
         if (hctx && hctx->tags)
                 blk_mq_tag_busy_iter(hctx, nvme_cancel_queue_ios, nvmeq);
         spin_unlock_irq(&nvmeq->q_lock);
@@ -1256,7 +1380,10 @@ static void nvme_disable_queue(struct nvme_dev *dev, int qid)
         }
         if (!qid && dev->admin_q)
                 blk_mq_freeze_queue_start(dev->admin_q);
-        nvme_clear_queue(nvmeq);
+
+        spin_lock_irq(&nvmeq->q_lock);
+        nvme_process_cq(nvmeq);
+        spin_unlock_irq(&nvmeq->q_lock);
 }
 
 static struct nvme_queue *nvme_alloc_queue(struct nvme_dev *dev, int qid,
@@ -1875,13 +2002,24 @@ static int nvme_getgeo(struct block_device *bd, struct hd_geometry *geo)
         return 0;
 }
 
+static void nvme_config_discard(struct nvme_ns *ns)
+{
+        u32 logical_block_size = queue_logical_block_size(ns->queue);
+        ns->queue->limits.discard_zeroes_data = 0;
+        ns->queue->limits.discard_alignment = logical_block_size;
+        ns->queue->limits.discard_granularity = logical_block_size;
+        ns->queue->limits.max_discard_sectors = 0xffffffff;
+        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, ns->queue);
+}
+
 static int nvme_revalidate_disk(struct gendisk *disk)
 {
         struct nvme_ns *ns = disk->private_data;
         struct nvme_dev *dev = ns->dev;
         struct nvme_id_ns *id;
         dma_addr_t dma_addr;
-        int lbaf;
+        int lbaf, pi_type, old_ms;
+        unsigned short bs;
 
         id = dma_alloc_coherent(&dev->pci_dev->dev, 4096, &dma_addr,
                                                                 GFP_KERNEL);
@@ -1890,16 +2028,51 @@ static int nvme_revalidate_disk(struct gendisk *disk)
                                                                 __func__);
                 return 0;
         }
+        if (nvme_identify(dev, ns->ns_id, 0, dma_addr)) {
+                dev_warn(&dev->pci_dev->dev,
+                        "identify failed ns:%d, setting capacity to 0\n",
+                        ns->ns_id);
+                memset(id, 0, sizeof(*id));
+        }
 
-        if (nvme_identify(dev, ns->ns_id, 0, dma_addr))
-                goto free;
-
-        lbaf = id->flbas & 0xf;
+        old_ms = ns->ms;
+        lbaf = id->flbas & NVME_NS_FLBAS_LBA_MASK;
         ns->lba_shift = id->lbaf[lbaf].ds;
+        ns->ms = le16_to_cpu(id->lbaf[lbaf].ms);
+
+        /*
+         * If identify namespace failed, use default 512 byte block size so
+         * block layer can use before failing read/write for 0 capacity.
+         */
+        if (ns->lba_shift == 0)
+                ns->lba_shift = 9;
+        bs = 1 << ns->lba_shift;
+
+        /* XXX: PI implementation requires metadata equal t10 pi tuple size */
+        pi_type = ns->ms == sizeof(struct t10_pi_tuple) ?
+                                        id->dps & NVME_NS_DPS_PI_MASK : 0;
+
+        if (blk_get_integrity(disk) && (ns->pi_type != pi_type ||
+                                ns->ms != old_ms ||
+                                bs != queue_logical_block_size(disk->queue) ||
+                                (ns->ms && id->flbas & NVME_NS_FLBAS_META_EXT)))
+                blk_integrity_unregister(disk);
+
+        ns->pi_type = pi_type;
+        blk_queue_logical_block_size(ns->queue, bs);
+
+        if (ns->ms && !blk_get_integrity(disk) && (disk->flags & GENHD_FL_UP) &&
+                                !(id->flbas & NVME_NS_FLBAS_META_EXT))
+                nvme_init_integrity(ns);
+
+        if (id->ncap == 0 || (ns->ms && !blk_get_integrity(disk)))
+                set_capacity(disk, 0);
+        else
+                set_capacity(disk, le64_to_cpup(&id->nsze) << (ns->lba_shift - 9));
+
+        if (dev->oncs & NVME_CTRL_ONCS_DSM)
+                nvme_config_discard(ns);
 
-        blk_queue_logical_block_size(ns->queue, 1 << ns->lba_shift);
-        set_capacity(disk, le64_to_cpup(&id->nsze) << (ns->lba_shift - 9));
- free:
         dma_free_coherent(&dev->pci_dev->dev, 4096, id, dma_addr);
         return 0;
 }
@@ -1923,8 +2096,7 @@ static int nvme_kthread(void *data)
                 spin_lock(&dev_list_lock);
                 list_for_each_entry_safe(dev, next, &dev_list, node) {
                         int i;
-                        if (readl(&dev->bar->csts) & NVME_CSTS_CFS &&
-                                                        dev->initialized) {
+                        if (readl(&dev->bar->csts) & NVME_CSTS_CFS) {
                                 if (work_busy(&dev->reset_work))
                                         continue;
                                 list_del_init(&dev->node);
@@ -1956,30 +2128,16 @@ static int nvme_kthread(void *data)
         return 0;
 }
 
-static void nvme_config_discard(struct nvme_ns *ns)
-{
-        u32 logical_block_size = queue_logical_block_size(ns->queue);
-        ns->queue->limits.discard_zeroes_data = 0;
-        ns->queue->limits.discard_alignment = logical_block_size;
-        ns->queue->limits.discard_granularity = logical_block_size;
-        ns->queue->limits.max_discard_sectors = 0xffffffff;
-        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, ns->queue);
-}
-
-static struct nvme_ns *nvme_alloc_ns(struct nvme_dev *dev, unsigned nsid,
-                        struct nvme_id_ns *id, struct nvme_lba_range_type *rt)
+static void nvme_alloc_ns(struct nvme_dev *dev, unsigned nsid)
 {
         struct nvme_ns *ns;
         struct gendisk *disk;
         int node = dev_to_node(&dev->pci_dev->dev);
-        int lbaf;
-
-        if (rt->attributes & NVME_LBART_ATTRIB_HIDE)
-                return NULL;
 
         ns = kzalloc_node(sizeof(*ns), GFP_KERNEL, node);
         if (!ns)
-                return NULL;
+                return;
+
         ns->queue = blk_mq_init_queue(&dev->tagset);
         if (IS_ERR(ns->queue))
                 goto out_free_ns;
@@ -1995,9 +2153,9 @@ static struct nvme_ns *nvme_alloc_ns(struct nvme_dev *dev, unsigned nsid,
 
         ns->ns_id = nsid;
         ns->disk = disk;
-        lbaf = id->flbas & 0xf;
-        ns->lba_shift = id->lbaf[lbaf].ds;
-        ns->ms = le16_to_cpu(id->lbaf[lbaf].ms);
+        ns->lba_shift = 9; /* set to a default value for 512 until disk is validated */
+        list_add_tail(&ns->list, &dev->namespaces);
+
         blk_queue_logical_block_size(ns->queue, 1 << ns->lba_shift);
         if (dev->max_hw_sectors)
                 blk_queue_max_hw_sectors(ns->queue, dev->max_hw_sectors);
@@ -2011,21 +2169,26 @@ static struct nvme_ns *nvme_alloc_ns(struct nvme_dev *dev, unsigned nsid,
         disk->fops = &nvme_fops;
         disk->private_data = ns;
         disk->queue = ns->queue;
-        disk->driverfs_dev = &dev->pci_dev->dev;
+        disk->driverfs_dev = dev->device;
         disk->flags = GENHD_FL_EXT_DEVT;
         sprintf(disk->disk_name, "nvme%dn%d", dev->instance, nsid);
-        set_capacity(disk, le64_to_cpup(&id->nsze) << (ns->lba_shift - 9));
-
-        if (dev->oncs & NVME_CTRL_ONCS_DSM)
-                nvme_config_discard(ns);
-
-        return ns;
 
+        /*
+         * Initialize capacity to 0 until we establish the namespace format and
+         * setup integrity extentions if necessary. The revalidate_disk after
+         * add_disk allows the driver to register with integrity if the format
+         * requires it.
+         */
+        set_capacity(disk, 0);
+        nvme_revalidate_disk(ns->disk);
+        add_disk(ns->disk);
+        if (ns->ms)
+                revalidate_disk(ns->disk);
+        return;
  out_free_queue:
         blk_cleanup_queue(ns->queue);
  out_free_ns:
         kfree(ns);
-        return NULL;
 }
 
 static void nvme_create_io_queues(struct nvme_dev *dev)
@@ -2150,22 +2313,20 @@ static int nvme_dev_add(struct nvme_dev *dev)
         struct pci_dev *pdev = dev->pci_dev;
         int res;
         unsigned nn, i;
-        struct nvme_ns *ns;
         struct nvme_id_ctrl *ctrl;
-        struct nvme_id_ns *id_ns;
         void *mem;
         dma_addr_t dma_addr;
         int shift = NVME_CAP_MPSMIN(readq(&dev->bar->cap)) + 12;
 
-        mem = dma_alloc_coherent(&pdev->dev, 8192, &dma_addr, GFP_KERNEL);
+        mem = dma_alloc_coherent(&pdev->dev, 4096, &dma_addr, GFP_KERNEL);
         if (!mem)
                 return -ENOMEM;
 
         res = nvme_identify(dev, 0, 1, dma_addr);
         if (res) {
                 dev_err(&pdev->dev, "Identify Controller failed (%d)\n", res);
-                res = -EIO;
-                goto out;
+                dma_free_coherent(&dev->pci_dev->dev, 4096, mem, dma_addr);
+                return -EIO;
         }
 
         ctrl = mem;
@@ -2191,6 +2352,7 @@ static int nvme_dev_add(struct nvme_dev *dev)
                 } else
                         dev->max_hw_sectors = max_hw_sectors;
         }
+        dma_free_coherent(&dev->pci_dev->dev, 4096, mem, dma_addr);
 
         dev->tagset.ops = &nvme_mq_ops;
         dev->tagset.nr_hw_queues = dev->online_queues - 1;
@@ -2203,33 +2365,12 @@ static int nvme_dev_add(struct nvme_dev *dev)
         dev->tagset.driver_data = dev;
 
         if (blk_mq_alloc_tag_set(&dev->tagset))
-                goto out;
-
-        id_ns = mem;
-        for (i = 1; i <= nn; i++) {
-                res = nvme_identify(dev, i, 0, dma_addr);
-                if (res)
-                        continue;
-
-                if (id_ns->ncap == 0)
-                        continue;
-
-                res = nvme_get_features(dev, NVME_FEAT_LBA_RANGE, i,
-                                                        dma_addr + 4096, NULL);
-                if (res)
-                        memset(mem + 4096, 0, 4096);
+                return 0;
 
-                ns = nvme_alloc_ns(dev, i, mem, mem + 4096);
-                if (ns)
-                        list_add_tail(&ns->list, &dev->namespaces);
-        }
-        list_for_each_entry(ns, &dev->namespaces, list)
-                add_disk(ns->disk);
-        res = 0;
+        for (i = 1; i <= nn; i++)
+                nvme_alloc_ns(dev, i);
 
- out:
-        dma_free_coherent(&dev->pci_dev->dev, 8192, mem, dma_addr);
-        return res;
+        return 0;
 }
 
 static int nvme_dev_map(struct nvme_dev *dev)
@@ -2358,8 +2499,6 @@ static struct nvme_delq_ctx *nvme_get_dq(struct nvme_delq_ctx *dq)
 static void nvme_del_queue_end(struct nvme_queue *nvmeq)
 {
         struct nvme_delq_ctx *dq = nvmeq->cmdinfo.ctx;
-
-        nvme_clear_queue(nvmeq);
         nvme_put_dq(dq);
 }
 
@@ -2502,7 +2641,6 @@ static void nvme_dev_shutdown(struct nvme_dev *dev)
         int i;
         u32 csts = -1;
 
-        dev->initialized = 0;
         nvme_dev_list_remove(dev);
 
         if (dev->bar) {
@@ -2513,7 +2651,6 @@ static void nvme_dev_shutdown(struct nvme_dev *dev)
                 for (i = dev->queue_count - 1; i >= 0; i--) {
                         struct nvme_queue *nvmeq = dev->queues[i];
                         nvme_suspend_queue(nvmeq);
-                        nvme_clear_queue(nvmeq);
                 }
         } else {
                 nvme_disable_io_queues(dev);
@@ -2521,6 +2658,9 @@ static void nvme_dev_shutdown(struct nvme_dev *dev)
                 nvme_disable_queue(dev, 0);
         }
         nvme_dev_unmap(dev);
+
+        for (i = dev->queue_count - 1; i >= 0; i--)
+                nvme_clear_queue(dev->queues[i]);
 }
 
 static void nvme_dev_remove(struct nvme_dev *dev)
@@ -2528,8 +2668,11 @@ static void nvme_dev_remove(struct nvme_dev *dev)
         struct nvme_ns *ns;
 
         list_for_each_entry(ns, &dev->namespaces, list) {
-                if (ns->disk->flags & GENHD_FL_UP)
+                if (ns->disk->flags & GENHD_FL_UP) {
+                        if (blk_get_integrity(ns->disk))
+                                blk_integrity_unregister(ns->disk);
                         del_gendisk(ns->disk);
+                }
                 if (!blk_queue_dying(ns->queue)) {
                         blk_mq_abort_requeue_list(ns->queue);
                         blk_cleanup_queue(ns->queue);
@@ -2611,6 +2754,7 @@ static void nvme_free_dev(struct kref *kref)
         struct nvme_dev *dev = container_of(kref, struct nvme_dev, kref);
 
         pci_dev_put(dev->pci_dev);
+        put_device(dev->device);
         nvme_free_namespaces(dev);
         nvme_release_instance(dev);
         blk_mq_free_tag_set(&dev->tagset);
@@ -2622,11 +2766,27 @@ static void nvme_free_dev(struct kref *kref)
 
 static int nvme_dev_open(struct inode *inode, struct file *f)
 {
-        struct nvme_dev *dev = container_of(f->private_data, struct nvme_dev,
-                                                                miscdev);
-        kref_get(&dev->kref);
-        f->private_data = dev;
-        return 0;
+        struct nvme_dev *dev;
+        int instance = iminor(inode);
+        int ret = -ENODEV;
+
+        spin_lock(&dev_list_lock);
+        list_for_each_entry(dev, &dev_list, node) {
+                if (dev->instance == instance) {
+                        if (!dev->admin_q) {
+                                ret = -EWOULDBLOCK;
+                                break;
+                        }
+                        if (!kref_get_unless_zero(&dev->kref))
+                                break;
+                        f->private_data = dev;
+                        ret = 0;
+                        break;
+                }
+        }
+        spin_unlock(&dev_list_lock);
+
+        return ret;
 }
 
 static int nvme_dev_release(struct inode *inode, struct file *f)
@@ -2768,7 +2928,6 @@ static int nvme_dev_resume(struct nvme_dev *dev)
                 nvme_unfreeze_queues(dev);
                 nvme_set_irq_hints(dev);
         }
-        dev->initialized = 1;
         return 0;
 }
 
@@ -2799,6 +2958,7 @@ static void nvme_reset_workfn(struct work_struct *work)
         dev->reset_workfn(work);
 }
 
+static void nvme_async_probe(struct work_struct *work);
 static int nvme_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 {
         int node, result = -ENOMEM;
@@ -2834,37 +2994,20 @@ static int nvme_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 goto release;
 
         kref_init(&dev->kref);
-        result = nvme_dev_start(dev);
-        if (result)
+        dev->device = device_create(nvme_class, &pdev->dev,
+                                MKDEV(nvme_char_major, dev->instance),
+                                dev, "nvme%d", dev->instance);
+        if (IS_ERR(dev->device)) {
+                result = PTR_ERR(dev->device);
                 goto release_pools;
+        }
+        get_device(dev->device);
 
-        if (dev->online_queues > 1)
-                result = nvme_dev_add(dev);
-        if (result)
-                goto shutdown;
-
-        scnprintf(dev->name, sizeof(dev->name), "nvme%d", dev->instance);
-        dev->miscdev.minor = MISC_DYNAMIC_MINOR;
-        dev->miscdev.parent = &pdev->dev;
-        dev->miscdev.name = dev->name;
-        dev->miscdev.fops = &nvme_dev_fops;
-        result = misc_register(&dev->miscdev);
-        if (result)
-                goto remove;
-
-        nvme_set_irq_hints(dev);
-
-        dev->initialized = 1;
+        INIT_WORK(&dev->probe_work, nvme_async_probe);
+        schedule_work(&dev->probe_work);
         return 0;
 
- remove:
-        nvme_dev_remove(dev);
-        nvme_dev_remove_admin(dev);
-        nvme_free_namespaces(dev);
- shutdown:
-        nvme_dev_shutdown(dev);
  release_pools:
-        nvme_free_queues(dev, 0);
         nvme_release_prp_pools(dev);
  release:
         nvme_release_instance(dev);
@@ -2877,6 +3020,29 @@ static int nvme_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         return result;
 }
 
+static void nvme_async_probe(struct work_struct *work)
+{
+        struct nvme_dev *dev = container_of(work, struct nvme_dev, probe_work);
+        int result;
+
+        result = nvme_dev_start(dev);
+        if (result)
+                goto reset;
+
+        if (dev->online_queues > 1)
+                result = nvme_dev_add(dev);
+        if (result)
+                goto reset;
+
+        nvme_set_irq_hints(dev);
+        return;
+ reset:
+        if (!work_busy(&dev->reset_work)) {
+                dev->reset_workfn = nvme_reset_failed_dev;
+                queue_work(nvme_workq, &dev->reset_work);
+        }
+}
+
 static void nvme_reset_notify(struct pci_dev *pdev, bool prepare)
 {
         struct nvme_dev *dev = pci_get_drvdata(pdev);
@@ -2902,11 +3068,12 @@ static void nvme_remove(struct pci_dev *pdev)
         spin_unlock(&dev_list_lock);
 
         pci_set_drvdata(pdev, NULL);
+        flush_work(&dev->probe_work);
         flush_work(&dev->reset_work);
-        misc_deregister(&dev->miscdev);
         nvme_dev_shutdown(dev);
         nvme_dev_remove(dev);
         nvme_dev_remove_admin(dev);
+        device_destroy(nvme_class, MKDEV(nvme_char_major, dev->instance));
         nvme_free_queues(dev, 0);
         nvme_release_prp_pools(dev);
         kref_put(&dev->kref, nvme_free_dev);
@@ -2990,11 +3157,26 @@ static int __init nvme_init(void)
         else if (result > 0)
                 nvme_major = result;
 
+        result = __register_chrdev(nvme_char_major, 0, NVME_MINORS, "nvme",
+                                                        &nvme_dev_fops);
+        if (result < 0)
+                goto unregister_blkdev;
+        else if (result > 0)
+                nvme_char_major = result;
+
+        nvme_class = class_create(THIS_MODULE, "nvme");
+        if (!nvme_class)
+                goto unregister_chrdev;
+
         result = pci_register_driver(&nvme_driver);
         if (result)
-                goto unregister_blkdev;
+                goto destroy_class;
         return 0;
 
+ destroy_class:
+        class_destroy(nvme_class);
+ unregister_chrdev:
+        __unregister_chrdev(nvme_char_major, 0, NVME_MINORS, "nvme");
  unregister_blkdev:
         unregister_blkdev(nvme_major, "nvme");
  kill_workq:
@@ -3005,9 +3187,10 @@ static int __init nvme_init(void)
 static void __exit nvme_exit(void)
 {
         pci_unregister_driver(&nvme_driver);
-        unregister_hotcpu_notifier(&nvme_nb);
         unregister_blkdev(nvme_major, "nvme");
         destroy_workqueue(nvme_workq);
+        class_destroy(nvme_class);
+        __unregister_chrdev(nvme_char_major, 0, NVME_MINORS, "nvme");
         BUG_ON(nvme_thread && !IS_ERR(nvme_thread));
         _nvme_check_size();
 }
diff --git a/drivers/block/nvme-scsi.c b/drivers/block/nvme-scsi.c
index 5e78568026c3..e10196e0182d 100644
--- a/drivers/block/nvme-scsi.c
+++ b/drivers/block/nvme-scsi.c
@@ -779,10 +779,8 @@ static int nvme_trans_device_id_page(struct nvme_ns *ns, struct sg_io_hdr *hdr,
         struct nvme_dev *dev = ns->dev;
         dma_addr_t dma_addr;
         void *mem;
-        struct nvme_id_ctrl *id_ctrl;
         int res = SNTI_TRANSLATION_SUCCESS;
         int nvme_sc;
-        u8 ieee[4];
         int xfer_len;
         __be32 tmp_id = cpu_to_be32(ns->ns_id);
 
@@ -793,46 +791,60 @@ static int nvme_trans_device_id_page(struct nvme_ns *ns, struct sg_io_hdr *hdr,
                 goto out_dma;
         }
 
-        /* nvme controller identify */
-        nvme_sc = nvme_identify(dev, 0, 1, dma_addr);
-        res = nvme_trans_status_code(hdr, nvme_sc);
-        if (res)
-                goto out_free;
-        if (nvme_sc) {
-                res = nvme_sc;
-                goto out_free;
-        }
-        id_ctrl = mem;
-
-        /* Since SCSI tried to save 4 bits... [SPC-4(r34) Table 591] */
-        ieee[0] = id_ctrl->ieee[0] << 4;
-        ieee[1] = id_ctrl->ieee[0] >> 4 | id_ctrl->ieee[1] << 4;
-        ieee[2] = id_ctrl->ieee[1] >> 4 | id_ctrl->ieee[2] << 4;
-        ieee[3] = id_ctrl->ieee[2] >> 4;
-
-        memset(inq_response, 0, STANDARD_INQUIRY_LENGTH);
+        memset(inq_response, 0, alloc_len);
         inq_response[1] = INQ_DEVICE_IDENTIFICATION_PAGE;    /* Page Code */
-        inq_response[3] = 20;      /* Page Length */
-        /* Designation Descriptor start */
-        inq_response[4] = 0x01;    /* Proto ID=0h | Code set=1h */
-        inq_response[5] = 0x03;    /* PIV=0b | Asso=00b | Designator Type=3h */
-        inq_response[6] = 0x00;    /* Rsvd */
-        inq_response[7] = 16;      /* Designator Length */
-        /* Designator start */
-        inq_response[8] = 0x60 | ieee[3]; /* NAA=6h | IEEE ID MSB, High nibble*/
-        inq_response[9] = ieee[2];        /* IEEE ID */
-        inq_response[10] = ieee[1];       /* IEEE ID */
-        inq_response[11] = ieee[0];       /* IEEE ID| Vendor Specific ID... */
-        inq_response[12] = (dev->pci_dev->vendor & 0xFF00) >> 8;
-        inq_response[13] = (dev->pci_dev->vendor & 0x00FF);
-        inq_response[14] = dev->serial[0];
-        inq_response[15] = dev->serial[1];
-        inq_response[16] = dev->model[0];
-        inq_response[17] = dev->model[1];
-        memcpy(&inq_response[18], &tmp_id, sizeof(u32));
-        /* Last 2 bytes are zero */
+        if (readl(&dev->bar->vs) >= NVME_VS(1, 1)) {
+                struct nvme_id_ns *id_ns = mem;
+                void *eui = id_ns->eui64;
+                int len = sizeof(id_ns->eui64);
 
-        xfer_len = min(alloc_len, STANDARD_INQUIRY_LENGTH);
+                nvme_sc = nvme_identify(dev, ns->ns_id, 0, dma_addr);
+                res = nvme_trans_status_code(hdr, nvme_sc);
+                if (res)
+                        goto out_free;
+                if (nvme_sc) {
+                        res = nvme_sc;
+                        goto out_free;
+                }
+
+                if (readl(&dev->bar->vs) >= NVME_VS(1, 2)) {
+                        if (bitmap_empty(eui, len * 8)) {
+                                eui = id_ns->nguid;
+                                len = sizeof(id_ns->nguid);
+                        }
+                }
+                if (bitmap_empty(eui, len * 8))
+                        goto scsi_string;
+
+                inq_response[3] = 4 + len; /* Page Length */
+                /* Designation Descriptor start */
+                inq_response[4] = 0x01;    /* Proto ID=0h | Code set=1h */
+                inq_response[5] = 0x02;    /* PIV=0b | Asso=00b | Designator Type=2h */
+                inq_response[6] = 0x00;    /* Rsvd */
+                inq_response[7] = len;     /* Designator Length */
+                memcpy(&inq_response[8], eui, len);
+        } else {
+ scsi_string:
+                if (alloc_len < 72) {
+                        res = nvme_trans_completion(hdr,
+                                        SAM_STAT_CHECK_CONDITION,
+                                        ILLEGAL_REQUEST, SCSI_ASC_INVALID_CDB,
+                                        SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
+                        goto out_free;
+                }
+                inq_response[3] = 0x48;    /* Page Length */
+                /* Designation Descriptor start */
+                inq_response[4] = 0x03;    /* Proto ID=0h | Code set=3h */
+                inq_response[5] = 0x08;    /* PIV=0b | Asso=00b | Designator Type=8h */
+                inq_response[6] = 0x00;    /* Rsvd */
+                inq_response[7] = 0x44;    /* Designator Length */
+
+                sprintf(&inq_response[8], "%04x", dev->pci_dev->vendor);
+                memcpy(&inq_response[12], dev->model, sizeof(dev->model));
+                sprintf(&inq_response[52], "%04x", tmp_id);
+                memcpy(&inq_response[56], dev->serial, sizeof(dev->serial));
+        }
+        xfer_len = alloc_len;
         res = nvme_trans_copy_to_user(hdr, inq_response, xfer_len);
 
  out_free:
@@ -1600,7 +1612,7 @@ static inline void nvme_trans_modesel_get_bd_len(u8 *parm_list, u8 cdb10,
                 /* 10 Byte CDB */
                 *bd_len = (parm_list[MODE_SELECT_10_BD_OFFSET] << 8) +
                         parm_list[MODE_SELECT_10_BD_OFFSET + 1];
-                *llbaa = parm_list[MODE_SELECT_10_LLBAA_OFFSET] &&
+                *llbaa = parm_list[MODE_SELECT_10_LLBAA_OFFSET] &
                                 MODE_SELECT_10_LLBAA_MASK;
         } else {
                 /* 6 Byte CDB */
@@ -2222,7 +2234,7 @@ static int nvme_trans_inquiry(struct nvme_ns *ns, struct sg_io_hdr *hdr,
         page_code = GET_INQ_PAGE_CODE(cmd);
         alloc_len = GET_INQ_ALLOC_LENGTH(cmd);
 
-        inq_response = kmalloc(STANDARD_INQUIRY_LENGTH, GFP_KERNEL);
+        inq_response = kmalloc(alloc_len, GFP_KERNEL);
         if (inq_response == NULL) {
                 res = -ENOMEM;
                 goto out_mem;
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 8a86b62466f7..b40af3203089 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -38,6 +38,7 @@
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/module.h>
+#include <linux/blk-mq.h>
 #include <linux/fs.h>
 #include <linux/blkdev.h>
 #include <linux/slab.h>
@@ -340,9 +341,7 @@ struct rbd_device {
 
         char                    name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */
 
-        struct list_head        rq_queue;       /* incoming rq queue */
         spinlock_t              lock;           /* queue, flags, open_count */
-        struct work_struct      rq_work;
 
         struct rbd_image_header header;
         unsigned long           flags;          /* possibly lock protected */
@@ -360,6 +359,9 @@ struct rbd_device {
         atomic_t                parent_ref;
         struct rbd_device       *parent;
 
+        /* Block layer tags. */
+        struct blk_mq_tag_set   tag_set;
+
         /* protects updating the header */
         struct rw_semaphore     header_rwsem;
 
@@ -1817,7 +1819,8 @@ static void rbd_osd_req_callback(struct ceph_osd_request *osd_req,
 
         /*
          * We support a 64-bit length, but ultimately it has to be
-         * passed to blk_end_request(), which takes an unsigned int.
+         * passed to the block layer, which just supports a 32-bit
+         * length field.
          */
         obj_request->xferred = osd_req->r_reply_op_len[0];
         rbd_assert(obj_request->xferred < (u64)UINT_MAX);
@@ -2275,7 +2278,10 @@ static bool rbd_img_obj_end_request(struct rbd_obj_request *obj_request)
                 more = obj_request->which < img_request->obj_request_count - 1;
         } else {
                 rbd_assert(img_request->rq != NULL);
-                more = blk_end_request(img_request->rq, result, xferred);
+
+                more = blk_update_request(img_request->rq, result, xferred);
+                if (!more)
+                        __blk_mq_end_request(img_request->rq, result);
         }
 
         return more;
@@ -3304,8 +3310,10 @@ out:
         return ret;
 }
 
-static void rbd_handle_request(struct rbd_device *rbd_dev, struct request *rq)
+static void rbd_queue_workfn(struct work_struct *work)
 {
+        struct request *rq = blk_mq_rq_from_pdu(work);
+        struct rbd_device *rbd_dev = rq->q->queuedata;
         struct rbd_img_request *img_request;
         struct ceph_snap_context *snapc = NULL;
         u64 offset = (u64)blk_rq_pos(rq) << SECTOR_SHIFT;
@@ -3314,6 +3322,13 @@ static void rbd_handle_request(struct rbd_device *rbd_dev, struct request *rq)
         u64 mapping_size;
         int result;
 
+        if (rq->cmd_type != REQ_TYPE_FS) {
+                dout("%s: non-fs request type %d\n", __func__,
+                        (int) rq->cmd_type);
+                result = -EIO;
+                goto err;
+        }
+
         if (rq->cmd_flags & REQ_DISCARD)
                 op_type = OBJ_OP_DISCARD;
         else if (rq->cmd_flags & REQ_WRITE)
@@ -3359,6 +3374,8 @@ static void rbd_handle_request(struct rbd_device *rbd_dev, struct request *rq)
                 goto err_rq;    /* Shouldn't happen */
         }
 
+        blk_mq_start_request(rq);
+
         down_read(&rbd_dev->header_rwsem);
         mapping_size = rbd_dev->mapping.size;
         if (op_type != OBJ_OP_READ) {
@@ -3404,53 +3421,18 @@ err_rq:
                 rbd_warn(rbd_dev, "%s %llx at %llx result %d",
                          obj_op_name(op_type), length, offset, result);
         ceph_put_snap_context(snapc);
-        blk_end_request_all(rq, result);
+err:
+        blk_mq_end_request(rq, result);
 }
 
-static void rbd_request_workfn(struct work_struct *work)
+static int rbd_queue_rq(struct blk_mq_hw_ctx *hctx,
+                const struct blk_mq_queue_data *bd)
 {
-        struct rbd_device *rbd_dev =
-            container_of(work, struct rbd_device, rq_work);
-        struct request *rq, *next;
-        LIST_HEAD(requests);
-
-        spin_lock_irq(&rbd_dev->lock); /* rq->q->queue_lock */
-        list_splice_init(&rbd_dev->rq_queue, &requests);
-        spin_unlock_irq(&rbd_dev->lock);
+        struct request *rq = bd->rq;
+        struct work_struct *work = blk_mq_rq_to_pdu(rq);
 
-        list_for_each_entry_safe(rq, next, &requests, queuelist) {
-                list_del_init(&rq->queuelist);
-                rbd_handle_request(rbd_dev, rq);
-        }
-}
-
-/*
- * Called with q->queue_lock held and interrupts disabled, possibly on
- * the way to schedule().  Do not sleep here!
- */
-static void rbd_request_fn(struct request_queue *q)
-{
-        struct rbd_device *rbd_dev = q->queuedata;
-        struct request *rq;
-        int queued = 0;
-
-        rbd_assert(rbd_dev);
-
-        while ((rq = blk_fetch_request(q))) {
-                /* Ignore any non-FS requests that filter through. */
-                if (rq->cmd_type != REQ_TYPE_FS) {
-                        dout("%s: non-fs request type %d\n", __func__,
-                                (int) rq->cmd_type);
-                        __blk_end_request_all(rq, 0);
-                        continue;
-                }
-
-                list_add_tail(&rq->queuelist, &rbd_dev->rq_queue);
-                queued++;
-        }
-
-        if (queued)
-                queue_work(rbd_wq, &rbd_dev->rq_work);
+        queue_work(rbd_wq, work);
+        return BLK_MQ_RQ_QUEUE_OK;
 }
 
 /*
@@ -3511,6 +3493,7 @@ static void rbd_free_disk(struct rbd_device *rbd_dev)
                 del_gendisk(disk);
                 if (disk->queue)
                         blk_cleanup_queue(disk->queue);
+                blk_mq_free_tag_set(&rbd_dev->tag_set);
         }
         put_disk(disk);
 }
@@ -3694,7 +3677,7 @@ static int rbd_dev_refresh(struct rbd_device *rbd_dev)
 
         ret = rbd_dev_header_info(rbd_dev);
         if (ret)
-                return ret;
+                goto out;
 
         /*
          * If there is a parent, see if it has disappeared due to the
@@ -3703,30 +3686,46 @@ static int rbd_dev_refresh(struct rbd_device *rbd_dev)
         if (rbd_dev->parent) {
                 ret = rbd_dev_v2_parent_info(rbd_dev);
                 if (ret)
-                        return ret;
+                        goto out;
         }
 
         if (rbd_dev->spec->snap_id == CEPH_NOSNAP) {
-                if (rbd_dev->mapping.size != rbd_dev->header.image_size)
-                        rbd_dev->mapping.size = rbd_dev->header.image_size;
+                rbd_dev->mapping.size = rbd_dev->header.image_size;
         } else {
                 /* validate mapped snapshot's EXISTS flag */
                 rbd_exists_validate(rbd_dev);
         }
 
+out:
         up_write(&rbd_dev->header_rwsem);
-
-        if (mapping_size != rbd_dev->mapping.size)
+        if (!ret && mapping_size != rbd_dev->mapping.size)
                 rbd_dev_update_size(rbd_dev);
 
+        return ret;
+}
+
+static int rbd_init_request(void *data, struct request *rq,
+                unsigned int hctx_idx, unsigned int request_idx,
+                unsigned int numa_node)
+{
+        struct work_struct *work = blk_mq_rq_to_pdu(rq);
+
+        INIT_WORK(work, rbd_queue_workfn);
         return 0;
 }
 
+static struct blk_mq_ops rbd_mq_ops = {
+        .queue_rq       = rbd_queue_rq,
+        .map_queue      = blk_mq_map_queue,
+        .init_request   = rbd_init_request,
+};
+
 static int rbd_init_disk(struct rbd_device *rbd_dev)
 {
         struct gendisk *disk;
         struct request_queue *q;
         u64 segment_size;
+        int err;
 
         /* create gendisk info */
         disk = alloc_disk(single_major ?
@@ -3744,10 +3743,25 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)
         disk->fops = &rbd_bd_ops;
         disk->private_data = rbd_dev;
 
-        q = blk_init_queue(rbd_request_fn, &rbd_dev->lock);
-        if (!q)
+        memset(&rbd_dev->tag_set, 0, sizeof(rbd_dev->tag_set));
+        rbd_dev->tag_set.ops = &rbd_mq_ops;
+        rbd_dev->tag_set.queue_depth = BLKDEV_MAX_RQ;
+        rbd_dev->tag_set.numa_node = NUMA_NO_NODE;
+        rbd_dev->tag_set.flags =
+                BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE;
+        rbd_dev->tag_set.nr_hw_queues = 1;
+        rbd_dev->tag_set.cmd_size = sizeof(struct work_struct);
+
+        err = blk_mq_alloc_tag_set(&rbd_dev->tag_set);
+        if (err)
                 goto out_disk;
 
+        q = blk_mq_init_queue(&rbd_dev->tag_set);
+        if (IS_ERR(q)) {
+                err = PTR_ERR(q);
+                goto out_tag_set;
+        }
+
         /* We use the default size, but let's be explicit about it. */
         blk_queue_physical_block_size(q, SECTOR_SIZE);
 
@@ -3773,10 +3787,11 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)
         rbd_dev->disk = disk;
 
         return 0;
+out_tag_set:
+        blk_mq_free_tag_set(&rbd_dev->tag_set);
 out_disk:
         put_disk(disk);
-
-        return -ENOMEM;
+        return err;
 }
 
 /*
@@ -4033,8 +4048,6 @@ static struct rbd_device *rbd_dev_create(struct rbd_client *rbdc,
                 return NULL;
 
         spin_lock_init(&rbd_dev->lock);
-        INIT_LIST_HEAD(&rbd_dev->rq_queue);
-        INIT_WORK(&rbd_dev->rq_work, rbd_request_workfn);
         rbd_dev->flags = 0;
         atomic_set(&rbd_dev->parent_ref, 0);
         INIT_LIST_HEAD(&rbd_dev->node);
@@ -4274,32 +4287,22 @@ static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev)
         }
 
         /*
-         * We always update the parent overlap.  If it's zero we
-         * treat it specially.
+         * We always update the parent overlap.  If it's zero we issue
+         * a warning, as we will proceed as if there was no parent.
          */
-        rbd_dev->parent_overlap = overlap;
         if (!overlap) {
-
-                /* A null parent_spec indicates it's the initial probe */
-
                 if (parent_spec) {
-                        /*
-                         * The overlap has become zero, so the clone
-                         * must have been resized down to 0 at some
-                         * point.  Treat this the same as a flatten.
-                         */
-                        rbd_dev_parent_put(rbd_dev);
-                        pr_info("%s: clone image now standalone\n",
-                                rbd_dev->disk->disk_name);
+                        /* refresh, careful to warn just once */
+                        if (rbd_dev->parent_overlap)
+                                rbd_warn(rbd_dev,
+                                    "clone now standalone (overlap became 0)");
                 } else {
-                        /*
-                         * For the initial probe, if we find the
-                         * overlap is zero we just pretend there was
-                         * no parent image.
-                         */
-                        rbd_warn(rbd_dev, "ignoring parent with overlap 0");
+                        /* initial probe */
+                        rbd_warn(rbd_dev, "clone is standalone (overlap 0)");
                 }
         }
+        rbd_dev->parent_overlap = overlap;
+
 out:
         ret = 0;
 out_err:
@@ -4771,36 +4774,6 @@ static inline size_t next_token(const char **buf)
 }
 
 /*
- * Finds the next token in *buf, and if the provided token buffer is
- * big enough, copies the found token into it.  The result, if
- * copied, is guaranteed to be terminated with '\0'.  Note that *buf
- * must be terminated with '\0' on entry.
- *
- * Returns the length of the token found (not including the '\0').
- * Return value will be 0 if no token is found, and it will be >=
- * token_size if the token would not fit.
- *
- * The *buf pointer will be updated to point beyond the end of the
- * found token.  Note that this occurs even if the token buffer is
- * too small to hold it.
- */
-static inline size_t copy_token(const char **buf,
-                                char *token,
-                                size_t token_size)
-{
-        size_t len;
-
-        len = next_token(buf);
-        if (len < token_size) {
-                memcpy(token, *buf, len);
-                *(token + len) = '\0';
-        }
-        *buf += len;
-
-        return len;
-}
-
-/*
  * Finds the next token in *buf, dynamically allocates a buffer big
  * enough to hold a copy of it, and copies the token into the new
  * buffer.  The copy is guaranteed to be terminated with '\0'.  Note
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index cdfbd21e3597..655e570b9b31 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -28,8 +28,7 @@ struct virtio_blk_vq {
         char name[VQ_NAME_LEN];
 } ____cacheline_aligned_in_smp;
 
-struct virtio_blk
-{
+struct virtio_blk {
         struct virtio_device *vdev;
 
         /* The disk structure for the kernel. */
@@ -52,8 +51,7 @@ struct virtio_blk
         struct virtio_blk_vq *vqs;
 };
 
-struct virtblk_req
-{
+struct virtblk_req {
         struct request *req;
         struct virtio_blk_outhdr out_hdr;
         struct virtio_scsi_inhdr in_hdr;
@@ -575,6 +573,12 @@ static int virtblk_probe(struct virtio_device *vdev)
         u16 min_io_size;
         u8 physical_block_exp, alignment_offset;
 
+        if (!vdev->config->get) {
+                dev_err(&vdev->dev, "%s failure: config access disabled\n",
+                        __func__);
+                return -EINVAL;
+        }
+
         err = ida_simple_get(&vd_index_ida, 0, minor_to_index(1 << MINORBITS),
                              GFP_KERNEL);
         if (err < 0)
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 8e233edd7a09..871bd3550cb0 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -528,7 +528,7 @@ out_cleanup:
 static inline void update_used_max(struct zram *zram,
                                         const unsigned long pages)
 {
-        int old_max, cur_max;
+        unsigned long old_max, cur_max;
 
         old_max = atomic_long_read(&zram->stats.max_used_pages);
 
diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
index 3ca2e1bf7bfa..8c1bf6190533 100644
--- a/drivers/bluetooth/btusb.c
+++ b/drivers/bluetooth/btusb.c
@@ -273,6 +273,7 @@ static const struct usb_device_id blacklist_table[] = {
         { USB_DEVICE(0x1286, 0x2046), .driver_info = BTUSB_MARVELL },
 
         /* Intel Bluetooth devices */
+        { USB_DEVICE(0x8087, 0x07da), .driver_info = BTUSB_CSR },
         { USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },
         { USB_DEVICE(0x8087, 0x0a2a), .driver_info = BTUSB_INTEL },
         { USB_DEVICE(0x8087, 0x0a2b), .driver_info = BTUSB_INTEL_NEW },
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index ec318bf434a6..1786574536b2 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -157,12 +157,16 @@ static int ipmi_release(struct inode *inode, struct file *file)
 {
         struct ipmi_file_private *priv = file->private_data;
         int                      rv;
+        struct  ipmi_recv_msg *msg, *next;
 
         rv = ipmi_destroy_user(priv->user);
         if (rv)
                 return rv;
 
-        /* FIXME - free the messages in the list. */
+        list_for_each_entry_safe(msg, next, &priv->recv_msgs, link)
+                ipmi_free_recv_msg(msg);
+
+
         kfree(priv);
 
         return 0;
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 6b65fa4e0c55..9bb592872532 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -1483,14 +1483,10 @@ static inline void format_lan_msg(struct ipmi_smi_msg   *smi_msg,
         smi_msg->msgid = msgid;
 }
 
-static void smi_send(ipmi_smi_t intf, struct ipmi_smi_handlers *handlers,
-                     struct ipmi_smi_msg *smi_msg, int priority)
+static struct ipmi_smi_msg *smi_add_send_msg(ipmi_smi_t intf,
+                                             struct ipmi_smi_msg *smi_msg,
+                                             int priority)
 {
-        int run_to_completion = intf->run_to_completion;
-        unsigned long flags;
-
-        if (!run_to_completion)
-                spin_lock_irqsave(&intf->xmit_msgs_lock, flags);
         if (intf->curr_msg) {
                 if (priority > 0)
                         list_add_tail(&smi_msg->link, &intf->hp_xmit_msgs);
@@ -1500,8 +1496,25 @@ static void smi_send(ipmi_smi_t intf, struct ipmi_smi_handlers *handlers,
         } else {
                 intf->curr_msg = smi_msg;
         }
-        if (!run_to_completion)
+
+        return smi_msg;
+}
+
+
+static void smi_send(ipmi_smi_t intf, struct ipmi_smi_handlers *handlers,
+                     struct ipmi_smi_msg *smi_msg, int priority)
+{
+        int run_to_completion = intf->run_to_completion;
+
+        if (run_to_completion) {
+                smi_msg = smi_add_send_msg(intf, smi_msg, priority);
+        } else {
+                unsigned long flags;
+
+                spin_lock_irqsave(&intf->xmit_msgs_lock, flags);
+                smi_msg = smi_add_send_msg(intf, smi_msg, priority);
                 spin_unlock_irqrestore(&intf->xmit_msgs_lock, flags);
+        }
 
         if (smi_msg)
                 handlers->sender(intf->send_info, smi_msg);
@@ -1985,7 +1998,9 @@ static int smi_ipmb_proc_show(struct seq_file *m, void *v)
         seq_printf(m, "%x", intf->channels[0].address);
         for (i = 1; i < IPMI_MAX_CHANNELS; i++)
                 seq_printf(m, " %x", intf->channels[i].address);
-        return seq_putc(m, '\n');
+        seq_putc(m, '\n');
+
+        return seq_has_overflowed(m);
 }
 
 static int smi_ipmb_proc_open(struct inode *inode, struct file *file)
@@ -2004,9 +2019,11 @@ static int smi_version_proc_show(struct seq_file *m, void *v)
 {
         ipmi_smi_t intf = m->private;
 
-        return seq_printf(m, "%u.%u\n",
-                       ipmi_version_major(&intf->bmc->id),
-                       ipmi_version_minor(&intf->bmc->id));
+        seq_printf(m, "%u.%u\n",
+                   ipmi_version_major(&intf->bmc->id),
+                   ipmi_version_minor(&intf->bmc->id));
+
+        return seq_has_overflowed(m);
 }
 
 static int smi_version_proc_open(struct inode *inode, struct file *file)
@@ -2353,11 +2370,28 @@ static struct attribute *bmc_dev_attrs[] = {
         &dev_attr_additional_device_support.attr,
         &dev_attr_manufacturer_id.attr,
         &dev_attr_product_id.attr,
+        &dev_attr_aux_firmware_revision.attr,
+        &dev_attr_guid.attr,
         NULL
 };
 
+static umode_t bmc_dev_attr_is_visible(struct kobject *kobj,
+                                       struct attribute *attr, int idx)
+{
+        struct device *dev = kobj_to_dev(kobj);
+        struct bmc_device *bmc = to_bmc_device(dev);
+        umode_t mode = attr->mode;
+
+        if (attr == &dev_attr_aux_firmware_revision.attr)
+                return bmc->id.aux_firmware_revision_set ? mode : 0;
+        if (attr == &dev_attr_guid.attr)
+                return bmc->guid_set ? mode : 0;
+        return mode;
+}
+
 static struct attribute_group bmc_dev_attr_group = {
         .attrs          = bmc_dev_attrs,
+        .is_visible     = bmc_dev_attr_is_visible,
 };
 
 static const struct attribute_group *bmc_dev_attr_groups[] = {
@@ -2380,13 +2414,6 @@ cleanup_bmc_device(struct kref *ref)
 {
         struct bmc_device *bmc = container_of(ref, struct bmc_device, usecount);
 
-        if (bmc->id.aux_firmware_revision_set)
-                device_remove_file(&bmc->pdev.dev,
-                                   &dev_attr_aux_firmware_revision);
-        if (bmc->guid_set)
-                device_remove_file(&bmc->pdev.dev,
-                                   &dev_attr_guid);
-
         platform_device_unregister(&bmc->pdev);
 }
 
@@ -2407,33 +2434,6 @@ static void ipmi_bmc_unregister(ipmi_smi_t intf)
         mutex_unlock(&ipmidriver_mutex);
 }
 
-static int create_bmc_files(struct bmc_device *bmc)
-{
-        int err;
-
-        if (bmc->id.aux_firmware_revision_set) {
-                err = device_create_file(&bmc->pdev.dev,
-                                         &dev_attr_aux_firmware_revision);
-                if (err)
-                        goto out;
-        }
-        if (bmc->guid_set) {
-                err = device_create_file(&bmc->pdev.dev,
-                                         &dev_attr_guid);
-                if (err)
-                        goto out_aux_firm;
-        }
-
-        return 0;
-
-out_aux_firm:
-        if (bmc->id.aux_firmware_revision_set)
-                device_remove_file(&bmc->pdev.dev,
-                                   &dev_attr_aux_firmware_revision);
-out:
-        return err;
-}
-
 static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
 {
         int               rv;
@@ -2522,15 +2522,6 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
                         return rv;
                 }
 
-                rv = create_bmc_files(bmc);
-                if (rv) {
-                        mutex_lock(&ipmidriver_mutex);
-                        platform_device_unregister(&bmc->pdev);
-                        mutex_unlock(&ipmidriver_mutex);
-
-                        return rv;
-                }
-
                 dev_info(intf->si_dev, "Found new BMC (man_id: 0x%6.6x, "
                          "prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
                          bmc->id.manufacturer_id,
@@ -4212,7 +4203,6 @@ static void need_waiter(ipmi_smi_t intf)
 static atomic_t smi_msg_inuse_count = ATOMIC_INIT(0);
 static atomic_t recv_msg_inuse_count = ATOMIC_INIT(0);
 
-/* FIXME - convert these to slabs. */
 static void free_smi_msg(struct ipmi_smi_msg *msg)
 {
         atomic_dec(&smi_msg_inuse_count);
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 967b73aa4e66..f6646ed3047e 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -321,6 +321,18 @@ static int try_smi_init(struct smi_info *smi);
 static void cleanup_one_si(struct smi_info *to_clean);
 static void cleanup_ipmi_si(void);
 
+#ifdef DEBUG_TIMING
+void debug_timestamp(char *msg)
+{
+        struct timespec64 t;
+
+        getnstimeofday64(&t);
+        pr_debug("**%s: %lld.%9.9ld\n", msg, (long long) t.tv_sec, t.tv_nsec);
+}
+#else
+#define debug_timestamp(x)
+#endif
+
 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
 static int register_xaction_notifier(struct notifier_block *nb)
 {
@@ -358,9 +370,6 @@ static void return_hosed_msg(struct smi_info *smi_info, int cCode)
 static enum si_sm_result start_next_msg(struct smi_info *smi_info)
 {
         int              rv;
-#ifdef DEBUG_TIMING
-        struct timeval t;
-#endif
 
         if (!smi_info->waiting_msg) {
                 smi_info->curr_msg = NULL;
@@ -370,10 +379,7 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
 
                 smi_info->curr_msg = smi_info->waiting_msg;
                 smi_info->waiting_msg = NULL;
-#ifdef DEBUG_TIMING
-                do_gettimeofday(&t);
-                printk(KERN_DEBUG "**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
-#endif
+                debug_timestamp("Start2");
                 err = atomic_notifier_call_chain(&xaction_notifier_list,
                                 0, smi_info);
                 if (err & NOTIFY_STOP_MASK) {
@@ -582,12 +588,8 @@ static void check_bt_irq(struct smi_info *smi_info, bool irq_on)
 static void handle_transaction_done(struct smi_info *smi_info)
 {
         struct ipmi_smi_msg *msg;
-#ifdef DEBUG_TIMING
-        struct timeval t;
 
-        do_gettimeofday(&t);
-        printk(KERN_DEBUG "**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
-#endif
+        debug_timestamp("Done");
         switch (smi_info->si_state) {
         case SI_NORMAL:
                 if (!smi_info->curr_msg)
@@ -929,24 +931,15 @@ static void sender(void                *send_info,
         struct smi_info   *smi_info = send_info;
         enum si_sm_result result;
         unsigned long     flags;
-#ifdef DEBUG_TIMING
-        struct timeval    t;
-#endif
-
-        BUG_ON(smi_info->waiting_msg);
-        smi_info->waiting_msg = msg;
 
-#ifdef DEBUG_TIMING
-        do_gettimeofday(&t);
-        printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
-#endif
+        debug_timestamp("Enqueue");
 
         if (smi_info->run_to_completion) {
                 /*
                  * If we are running to completion, start it and run
                  * transactions until everything is clear.
                  */
-                smi_info->curr_msg = smi_info->waiting_msg;
+                smi_info->curr_msg = msg;
                 smi_info->waiting_msg = NULL;
 
                 /*
@@ -964,6 +957,15 @@ static void sender(void                *send_info,
         }
 
         spin_lock_irqsave(&smi_info->si_lock, flags);
+        /*
+         * The following two lines don't need to be under the lock for
+         * the lock's sake, but they do need SMP memory barriers to
+         * avoid getting things out of order.  We are already claiming
+         * the lock, anyway, so just do it under the lock to avoid the
+         * ordering problem.
+         */
+        BUG_ON(smi_info->waiting_msg);
+        smi_info->waiting_msg = msg;
         check_start_timer_thread(smi_info);
         spin_unlock_irqrestore(&smi_info->si_lock, flags);
 }
@@ -989,18 +991,18 @@ static void set_run_to_completion(void *send_info, bool i_run_to_completion)
  * we are spinning in kipmid looking for something and not delaying
  * between checks
  */
-static inline void ipmi_si_set_not_busy(struct timespec *ts)
+static inline void ipmi_si_set_not_busy(struct timespec64 *ts)
 {
         ts->tv_nsec = -1;
 }
-static inline int ipmi_si_is_busy(struct timespec *ts)
+static inline int ipmi_si_is_busy(struct timespec64 *ts)
 {
         return ts->tv_nsec != -1;
 }
 
 static inline int ipmi_thread_busy_wait(enum si_sm_result smi_result,
                                         const struct smi_info *smi_info,
-                                        struct timespec *busy_until)
+                                        struct timespec64 *busy_until)
 {
         unsigned int max_busy_us = 0;
 
@@ -1009,12 +1011,13 @@ static inline int ipmi_thread_busy_wait(enum si_sm_result smi_result,
         if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
                 ipmi_si_set_not_busy(busy_until);
         else if (!ipmi_si_is_busy(busy_until)) {
-                getnstimeofday(busy_until);
-                timespec_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
+                getnstimeofday64(busy_until);
+                timespec64_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
         } else {
-                struct timespec now;
-                getnstimeofday(&now);
-                if (unlikely(timespec_compare(&now, busy_until) > 0)) {
+                struct timespec64 now;
+
+                getnstimeofday64(&now);
+                if (unlikely(timespec64_compare(&now, busy_until) > 0)) {
                         ipmi_si_set_not_busy(busy_until);
                         return 0;
                 }
@@ -1037,7 +1040,7 @@ static int ipmi_thread(void *data)
         struct smi_info *smi_info = data;
         unsigned long flags;
         enum si_sm_result smi_result;
-        struct timespec busy_until;
+        struct timespec64 busy_until;
 
         ipmi_si_set_not_busy(&busy_until);
         set_user_nice(current, MAX_NICE);
@@ -1128,15 +1131,10 @@ static void smi_timeout(unsigned long data)
         unsigned long     jiffies_now;
         long              time_diff;
         long              timeout;
-#ifdef DEBUG_TIMING
-        struct timeval    t;
-#endif
 
         spin_lock_irqsave(&(smi_info->si_lock), flags);
-#ifdef DEBUG_TIMING
-        do_gettimeofday(&t);
-        printk(KERN_DEBUG "**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
-#endif
+        debug_timestamp("Timer");
+
         jiffies_now = jiffies;
         time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
                      * SI_USEC_PER_JIFFY);
@@ -1173,18 +1171,13 @@ static irqreturn_t si_irq_handler(int irq, void *data)
 {
         struct smi_info *smi_info = data;
         unsigned long   flags;
-#ifdef DEBUG_TIMING
-        struct timeval  t;
-#endif
 
         spin_lock_irqsave(&(smi_info->si_lock), flags);
 
         smi_inc_stat(smi_info, interrupts);
 
-#ifdef DEBUG_TIMING
-        do_gettimeofday(&t);
-        printk(KERN_DEBUG "**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
-#endif
+        debug_timestamp("Interrupt");
+
         smi_event_handler(smi_info, 0);
         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
         return IRQ_HANDLED;
@@ -2038,18 +2031,13 @@ static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
 {
         struct smi_info *smi_info = context;
         unsigned long   flags;
-#ifdef DEBUG_TIMING
-        struct timeval t;
-#endif
 
         spin_lock_irqsave(&(smi_info->si_lock), flags);
 
         smi_inc_stat(smi_info, interrupts);
 
-#ifdef DEBUG_TIMING
-        do_gettimeofday(&t);
-        printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
-#endif
+        debug_timestamp("ACPI_GPE");
+
         smi_event_handler(smi_info, 0);
         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 
@@ -2071,7 +2059,6 @@ static int acpi_gpe_irq_setup(struct smi_info *info)
         if (!info->irq)
                 return 0;
 
-        /* FIXME - is level triggered right? */
         status = acpi_install_gpe_handler(NULL,
                                           info->irq,
                                           ACPI_GPE_LEVEL_TRIGGERED,
@@ -2998,7 +2985,9 @@ static int smi_type_proc_show(struct seq_file *m, void *v)
 {
         struct smi_info *smi = m->private;
 
-        return seq_printf(m, "%s\n", si_to_str[smi->si_type]);
+        seq_printf(m, "%s\n", si_to_str[smi->si_type]);
+
+        return seq_has_overflowed(m);
 }
 
 static int smi_type_proc_open(struct inode *inode, struct file *file)
@@ -3060,16 +3049,18 @@ static int smi_params_proc_show(struct seq_file *m, void *v)
 {
         struct smi_info *smi = m->private;
 
-        return seq_printf(m,
-                       "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
-                       si_to_str[smi->si_type],
-                       addr_space_to_str[smi->io.addr_type],
-                       smi->io.addr_data,
-                       smi->io.regspacing,
-                       smi->io.regsize,
-                       smi->io.regshift,
-                       smi->irq,
-                       smi->slave_addr);
+        seq_printf(m,
+                   "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
+                   si_to_str[smi->si_type],
+                   addr_space_to_str[smi->io.addr_type],
+                   smi->io.addr_data,
+                   smi->io.regspacing,
+                   smi->io.regsize,
+                   smi->io.regshift,
+                   smi->irq,
+                   smi->slave_addr);
+
+        return seq_has_overflowed(m);
 }
 
 static int smi_params_proc_open(struct inode *inode, struct file *file)
diff --git a/drivers/char/ipmi/ipmi_ssif.c b/drivers/char/ipmi/ipmi_ssif.c
index 982b96323f82..f6e378dac5f5 100644
--- a/drivers/char/ipmi/ipmi_ssif.c
+++ b/drivers/char/ipmi/ipmi_ssif.c
@@ -1097,8 +1097,6 @@ static int ssif_remove(struct i2c_client *client)
         if (!ssif_info)
                 return 0;
 
-        i2c_set_clientdata(client, NULL);
-
         /*
          * After this point, we won't deliver anything asychronously
          * to the message handler.  We can unregister ourself.
@@ -1198,7 +1196,9 @@ static int ssif_detect(struct i2c_client *client, struct i2c_board_info *info)
 
 static int smi_type_proc_show(struct seq_file *m, void *v)
 {
-        return seq_puts(m, "ssif\n");
+        seq_puts(m, "ssif\n");
+
+        return seq_has_overflowed(m);
 }
 
 static int smi_type_proc_open(struct inode *inode, struct file *file)
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index 26afb56a8073..fae2dbbf5745 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -1986,7 +1986,10 @@ static int virtcons_probe(struct virtio_device *vdev)
         bool multiport;
         bool early = early_put_chars != NULL;
 
-        if (!vdev->config->get) {
+        /* We only need a config space if features are offered */
+        if (!vdev->config->get &&
+            (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)
+             || virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT))) {
                 dev_err(&vdev->dev, "%s failure: config access disabled\n",
                         __func__);
                 return -EINVAL;
diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig
index 91f86131bb7a..0b474a04730f 100644
--- a/drivers/clk/Kconfig
+++ b/drivers/clk/Kconfig
@@ -102,12 +102,12 @@ config COMMON_CLK_AXI_CLKGEN
           Support for the Analog Devices axi-clkgen pcore clock generator for Xilinx
           FPGAs. It is commonly used in Analog Devices' reference designs.
 
-config CLK_PPC_CORENET
-        bool "Clock driver for PowerPC corenet platforms"
-        depends on PPC_E500MC && OF
+config CLK_QORIQ
+        bool "Clock driver for Freescale QorIQ platforms"
+        depends on (PPC_E500MC || ARM) && OF
         ---help---
-          This adds the clock driver support for Freescale PowerPC corenet
-          platforms using common clock framework.
+          This adds the clock driver support for Freescale QorIQ platforms
+          using common clock framework.
 
 config COMMON_CLK_XGENE
         bool "Clock driver for APM XGene SoC"
@@ -135,6 +135,14 @@ config COMMON_CLK_PXA
         ---help---
           Sypport for the Marvell PXA SoC.
 
+config COMMON_CLK_CDCE706
+        tristate "Clock driver for TI CDCE706 clock synthesizer"
+        depends on I2C
+        select REGMAP_I2C
+        select RATIONAL
+        ---help---
+          This driver supports TI CDCE706 programmable 3-PLL clock synthesizer.
+
 source "drivers/clk/qcom/Kconfig"
 
 endmenu
diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile
index d5fba5bc6e1b..d478ceb69c5f 100644
--- a/drivers/clk/Makefile
+++ b/drivers/clk/Makefile
@@ -16,9 +16,11 @@ endif
 
 # hardware specific clock types
 # please keep this section sorted lexicographically by file/directory path name
+obj-$(CONFIG_MACH_ASM9260)              += clk-asm9260.o
 obj-$(CONFIG_COMMON_CLK_AXI_CLKGEN)     += clk-axi-clkgen.o
 obj-$(CONFIG_ARCH_AXXIA)                += clk-axm5516.o
 obj-$(CONFIG_ARCH_BCM2835)              += clk-bcm2835.o
+obj-$(CONFIG_COMMON_CLK_CDCE706)        += clk-cdce706.o
 obj-$(CONFIG_ARCH_CLPS711X)             += clk-clps711x.o
 obj-$(CONFIG_ARCH_EFM32)                += clk-efm32gg.o
 obj-$(CONFIG_ARCH_HIGHBANK)             += clk-highbank.o
@@ -30,7 +32,7 @@ obj-$(CONFIG_ARCH_MOXART)		+= clk-moxart.o
 obj-$(CONFIG_ARCH_NOMADIK)              += clk-nomadik.o
 obj-$(CONFIG_ARCH_NSPIRE)               += clk-nspire.o
 obj-$(CONFIG_COMMON_CLK_PALMAS)         += clk-palmas.o
-obj-$(CONFIG_CLK_PPC_CORENET)           += clk-ppc-corenet.o
+obj-$(CONFIG_CLK_QORIQ)                 += clk-qoriq.o
 obj-$(CONFIG_COMMON_CLK_RK808)          += clk-rk808.o
 obj-$(CONFIG_COMMON_CLK_S2MPS11)        += clk-s2mps11.o
 obj-$(CONFIG_COMMON_CLK_SI5351)         += clk-si5351.o
diff --git a/drivers/clk/at91/clk-programmable.c b/drivers/clk/at91/clk-programmable.c
index bbdb1b985c91..86c8a073dcc3 100644
--- a/drivers/clk/at91/clk-programmable.c
+++ b/drivers/clk/at91/clk-programmable.c
@@ -56,6 +56,8 @@ static unsigned long clk_programmable_recalc_rate(struct clk_hw *hw,
 
 static long clk_programmable_determine_rate(struct clk_hw *hw,
                                             unsigned long rate,
+                                            unsigned long min_rate,
+                                            unsigned long max_rate,
                                             unsigned long *best_parent_rate,
                                             struct clk_hw **best_parent_hw)
 {
diff --git a/drivers/clk/bcm/clk-kona.c b/drivers/clk/bcm/clk-kona.c
index 1c06f6f3a8c5..05abae89262e 100644
--- a/drivers/clk/bcm/clk-kona.c
+++ b/drivers/clk/bcm/clk-kona.c
@@ -1032,6 +1032,8 @@ static long kona_peri_clk_round_rate(struct clk_hw *hw, unsigned long rate,
 }
 
 static long kona_peri_clk_determine_rate(struct clk_hw *hw, unsigned long rate,
+                unsigned long min_rate,
+                unsigned long max_rate,
                 unsigned long *best_parent_rate, struct clk_hw **best_parent)
 {
         struct kona_clk *bcm_clk = to_kona_clk(hw);
diff --git a/drivers/clk/clk-asm9260.c b/drivers/clk/clk-asm9260.c
new file mode 100644
index 000000000000..88f4ff6916fe
--- /dev/null
+++ b/drivers/clk/clk-asm9260.c
@@ -0,0 +1,348 @@
+/*
+ * Copyright (c) 2014 Oleksij Rempel <linux@rempel-privat.de>.
+ *
+ * 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/clkdev.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/clk-provider.h>
+#include <linux/spinlock.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <dt-bindings/clock/alphascale,asm9260.h>
+
+#define HW_AHBCLKCTRL0          0x0020
+#define HW_AHBCLKCTRL1          0x0030
+#define HW_SYSPLLCTRL           0x0100
+#define HW_MAINCLKSEL           0x0120
+#define HW_MAINCLKUEN           0x0124
+#define HW_UARTCLKSEL           0x0128
+#define HW_UARTCLKUEN           0x012c
+#define HW_I2S0CLKSEL           0x0130
+#define HW_I2S0CLKUEN           0x0134
+#define HW_I2S1CLKSEL           0x0138
+#define HW_I2S1CLKUEN           0x013c
+#define HW_WDTCLKSEL            0x0160
+#define HW_WDTCLKUEN            0x0164
+#define HW_CLKOUTCLKSEL         0x0170
+#define HW_CLKOUTCLKUEN         0x0174
+#define HW_CPUCLKDIV            0x017c
+#define HW_SYSAHBCLKDIV         0x0180
+#define HW_I2S0MCLKDIV          0x0190
+#define HW_I2S0SCLKDIV          0x0194
+#define HW_I2S1MCLKDIV          0x0188
+#define HW_I2S1SCLKDIV          0x018c
+#define HW_UART0CLKDIV          0x0198
+#define HW_UART1CLKDIV          0x019c
+#define HW_UART2CLKDIV          0x01a0
+#define HW_UART3CLKDIV          0x01a4
+#define HW_UART4CLKDIV          0x01a8
+#define HW_UART5CLKDIV          0x01ac
+#define HW_UART6CLKDIV          0x01b0
+#define HW_UART7CLKDIV          0x01b4
+#define HW_UART8CLKDIV          0x01b8
+#define HW_UART9CLKDIV          0x01bc
+#define HW_SPI0CLKDIV           0x01c0
+#define HW_SPI1CLKDIV           0x01c4
+#define HW_QUADSPICLKDIV        0x01c8
+#define HW_SSP0CLKDIV           0x01d0
+#define HW_NANDCLKDIV           0x01d4
+#define HW_TRACECLKDIV          0x01e0
+#define HW_CAMMCLKDIV           0x01e8
+#define HW_WDTCLKDIV            0x01ec
+#define HW_CLKOUTCLKDIV         0x01f4
+#define HW_MACCLKDIV            0x01f8
+#define HW_LCDCLKDIV            0x01fc
+#define HW_ADCANACLKDIV         0x0200
+
+static struct clk *clks[MAX_CLKS];
+static struct clk_onecell_data clk_data;
+static DEFINE_SPINLOCK(asm9260_clk_lock);
+
+struct asm9260_div_clk {
+        unsigned int idx;
+        const char *name;
+        const char *parent_name;
+        u32 reg;
+};
+
+struct asm9260_gate_data {
+        unsigned int idx;
+        const char *name;
+        const char *parent_name;
+        u32 reg;
+        u8 bit_idx;
+        unsigned long flags;
+};
+
+struct asm9260_mux_clock {
+        u8                      mask;
+        u32                     *table;
+        const char              *name;
+        const char              **parent_names;
+        u8                      num_parents;
+        unsigned long           offset;
+        unsigned long           flags;
+};
+
+static void __iomem *base;
+
+static const struct asm9260_div_clk asm9260_div_clks[] __initconst = {
+        { CLKID_SYS_CPU,        "cpu_div", "main_gate", HW_CPUCLKDIV },
+        { CLKID_SYS_AHB,        "ahb_div", "cpu_div", HW_SYSAHBCLKDIV },
+
+        /* i2s has two deviders: one for only external mclk and internal
+         * devider for all clks. */
+        { CLKID_SYS_I2S0M,      "i2s0m_div", "i2s0_mclk",  HW_I2S0MCLKDIV },
+        { CLKID_SYS_I2S1M,      "i2s1m_div", "i2s1_mclk",  HW_I2S1MCLKDIV },
+        { CLKID_SYS_I2S0S,      "i2s0s_div", "i2s0_gate",  HW_I2S0SCLKDIV },
+        { CLKID_SYS_I2S1S,      "i2s1s_div", "i2s0_gate",  HW_I2S1SCLKDIV },
+
+        { CLKID_SYS_UART0,      "uart0_div", "uart_gate", HW_UART0CLKDIV },
+        { CLKID_SYS_UART1,      "uart1_div", "uart_gate", HW_UART1CLKDIV },
+        { CLKID_SYS_UART2,      "uart2_div", "uart_gate", HW_UART2CLKDIV },
+        { CLKID_SYS_UART3,      "uart3_div", "uart_gate", HW_UART3CLKDIV },
+        { CLKID_SYS_UART4,      "uart4_div", "uart_gate", HW_UART4CLKDIV },
+        { CLKID_SYS_UART5,      "uart5_div", "uart_gate", HW_UART5CLKDIV },
+        { CLKID_SYS_UART6,      "uart6_div", "uart_gate", HW_UART6CLKDIV },
+        { CLKID_SYS_UART7,      "uart7_div", "uart_gate", HW_UART7CLKDIV },
+        { CLKID_SYS_UART8,      "uart8_div", "uart_gate", HW_UART8CLKDIV },
+        { CLKID_SYS_UART9,      "uart9_div", "uart_gate", HW_UART9CLKDIV },
+
+        { CLKID_SYS_SPI0,       "spi0_div",     "main_gate", HW_SPI0CLKDIV },
+        { CLKID_SYS_SPI1,       "spi1_div",     "main_gate", HW_SPI1CLKDIV },
+        { CLKID_SYS_QUADSPI,    "quadspi_div",  "main_gate", HW_QUADSPICLKDIV },
+        { CLKID_SYS_SSP0,       "ssp0_div",     "main_gate", HW_SSP0CLKDIV },
+        { CLKID_SYS_NAND,       "nand_div",     "main_gate", HW_NANDCLKDIV },
+        { CLKID_SYS_TRACE,      "trace_div",    "main_gate", HW_TRACECLKDIV },
+        { CLKID_SYS_CAMM,       "camm_div",     "main_gate", HW_CAMMCLKDIV },
+        { CLKID_SYS_MAC,        "mac_div",      "main_gate", HW_MACCLKDIV },
+        { CLKID_SYS_LCD,        "lcd_div",      "main_gate", HW_LCDCLKDIV },
+        { CLKID_SYS_ADCANA,     "adcana_div",   "main_gate", HW_ADCANACLKDIV },
+
+        { CLKID_SYS_WDT,        "wdt_div",      "wdt_gate",    HW_WDTCLKDIV },
+        { CLKID_SYS_CLKOUT,     "clkout_div",   "clkout_gate", HW_CLKOUTCLKDIV },
+};
+
+static const struct asm9260_gate_data asm9260_mux_gates[] __initconst = {
+        { 0, "main_gate",       "main_mux",     HW_MAINCLKUEN,  0 },
+        { 0, "uart_gate",       "uart_mux",     HW_UARTCLKUEN,  0 },
+        { 0, "i2s0_gate",       "i2s0_mux",     HW_I2S0CLKUEN,  0 },
+        { 0, "i2s1_gate",       "i2s1_mux",     HW_I2S1CLKUEN,  0 },
+        { 0, "wdt_gate",        "wdt_mux",      HW_WDTCLKUEN,   0 },
+        { 0, "clkout_gate",     "clkout_mux",   HW_CLKOUTCLKUEN, 0 },
+};
+static const struct asm9260_gate_data asm9260_ahb_gates[] __initconst = {
+        /* ahb gates */
+        { CLKID_AHB_ROM,        "rom",          "ahb_div",
+                HW_AHBCLKCTRL0, 1, CLK_IGNORE_UNUSED},
+        { CLKID_AHB_RAM,        "ram",          "ahb_div",
+                HW_AHBCLKCTRL0, 2, CLK_IGNORE_UNUSED},
+        { CLKID_AHB_GPIO,       "gpio",         "ahb_div",
+                HW_AHBCLKCTRL0, 4 },
+        { CLKID_AHB_MAC,        "mac",          "ahb_div",
+                HW_AHBCLKCTRL0, 5 },
+        { CLKID_AHB_EMI,        "emi",          "ahb_div",
+                HW_AHBCLKCTRL0, 6, CLK_IGNORE_UNUSED},
+        { CLKID_AHB_USB0,       "usb0",         "ahb_div",
+                HW_AHBCLKCTRL0, 7 },
+        { CLKID_AHB_USB1,       "usb1",         "ahb_div",
+                HW_AHBCLKCTRL0, 8 },
+        { CLKID_AHB_DMA0,       "dma0",         "ahb_div",
+                HW_AHBCLKCTRL0, 9 },
+        { CLKID_AHB_DMA1,       "dma1",         "ahb_div",
+                HW_AHBCLKCTRL0, 10 },
+        { CLKID_AHB_UART0,      "uart0",        "ahb_div",
+                HW_AHBCLKCTRL0, 11 },
+        { CLKID_AHB_UART1,      "uart1",        "ahb_div",
+                HW_AHBCLKCTRL0, 12 },
+        { CLKID_AHB_UART2,      "uart2",        "ahb_div",
+                HW_AHBCLKCTRL0, 13 },
+        { CLKID_AHB_UART3,      "uart3",        "ahb_div",
+                HW_AHBCLKCTRL0, 14 },
+        { CLKID_AHB_UART4,      "uart4",        "ahb_div",
+                HW_AHBCLKCTRL0, 15 },
+        { CLKID_AHB_UART5,      "uart5",        "ahb_div",
+                HW_AHBCLKCTRL0, 16 },
+        { CLKID_AHB_UART6,      "uart6",        "ahb_div",
+                HW_AHBCLKCTRL0, 17 },
+        { CLKID_AHB_UART7,      "uart7",        "ahb_div",
+                HW_AHBCLKCTRL0, 18 },
+        { CLKID_AHB_UART8,      "uart8",        "ahb_div",
+                HW_AHBCLKCTRL0, 19 },
+        { CLKID_AHB_UART9,      "uart9",        "ahb_div",
+                HW_AHBCLKCTRL0, 20 },
+        { CLKID_AHB_I2S0,       "i2s0",         "ahb_div",
+                HW_AHBCLKCTRL0, 21 },
+        { CLKID_AHB_I2C0,       "i2c0",         "ahb_div",
+                HW_AHBCLKCTRL0, 22 },
+        { CLKID_AHB_I2C1,       "i2c1",         "ahb_div",
+                HW_AHBCLKCTRL0, 23 },
+        { CLKID_AHB_SSP0,       "ssp0",         "ahb_div",
+                HW_AHBCLKCTRL0, 24 },
+        { CLKID_AHB_IOCONFIG,   "ioconf",       "ahb_div",
+                HW_AHBCLKCTRL0, 25 },
+        { CLKID_AHB_WDT,        "wdt",          "ahb_div",
+                HW_AHBCLKCTRL0, 26 },
+        { CLKID_AHB_CAN0,       "can0",         "ahb_div",
+                HW_AHBCLKCTRL0, 27 },
+        { CLKID_AHB_CAN1,       "can1",         "ahb_div",
+                HW_AHBCLKCTRL0, 28 },
+        { CLKID_AHB_MPWM,       "mpwm",         "ahb_div",
+                HW_AHBCLKCTRL0, 29 },
+        { CLKID_AHB_SPI0,       "spi0",         "ahb_div",
+                HW_AHBCLKCTRL0, 30 },
+        { CLKID_AHB_SPI1,       "spi1",         "ahb_div",
+                HW_AHBCLKCTRL0, 31 },
+
+        { CLKID_AHB_QEI,        "qei",          "ahb_div",
+                HW_AHBCLKCTRL1, 0 },
+        { CLKID_AHB_QUADSPI0,   "quadspi0",     "ahb_div",
+                HW_AHBCLKCTRL1, 1 },
+        { CLKID_AHB_CAMIF,      "capmif",       "ahb_div",
+                HW_AHBCLKCTRL1, 2 },
+        { CLKID_AHB_LCDIF,      "lcdif",        "ahb_div",
+                HW_AHBCLKCTRL1, 3 },
+        { CLKID_AHB_TIMER0,     "timer0",       "ahb_div",
+                HW_AHBCLKCTRL1, 4 },
+        { CLKID_AHB_TIMER1,     "timer1",       "ahb_div",
+                HW_AHBCLKCTRL1, 5 },
+        { CLKID_AHB_TIMER2,     "timer2",       "ahb_div",
+                HW_AHBCLKCTRL1, 6 },
+        { CLKID_AHB_TIMER3,     "timer3",       "ahb_div",
+                HW_AHBCLKCTRL1, 7 },
+        { CLKID_AHB_IRQ,        "irq",          "ahb_div",
+                HW_AHBCLKCTRL1, 8, CLK_IGNORE_UNUSED},
+        { CLKID_AHB_RTC,        "rtc",          "ahb_div",
+                HW_AHBCLKCTRL1, 9 },
+        { CLKID_AHB_NAND,       "nand",         "ahb_div",
+                HW_AHBCLKCTRL1, 10 },
+        { CLKID_AHB_ADC0,       "adc0",         "ahb_div",
+                HW_AHBCLKCTRL1, 11 },
+        { CLKID_AHB_LED,        "led",          "ahb_div",
+                HW_AHBCLKCTRL1, 12 },
+        { CLKID_AHB_DAC0,       "dac0",         "ahb_div",
+                HW_AHBCLKCTRL1, 13 },
+        { CLKID_AHB_LCD,        "lcd",          "ahb_div",
+                HW_AHBCLKCTRL1, 14 },
+        { CLKID_AHB_I2S1,       "i2s1",         "ahb_div",
+                HW_AHBCLKCTRL1, 15 },
+        { CLKID_AHB_MAC1,       "mac1",         "ahb_div",
+                HW_AHBCLKCTRL1, 16 },
+};
+
+static const char __initdata *main_mux_p[] =   { NULL, NULL };
+static const char __initdata *i2s0_mux_p[] =   { NULL, NULL, "i2s0m_div"};
+static const char __initdata *i2s1_mux_p[] =   { NULL, NULL, "i2s1m_div"};
+static const char __initdata *clkout_mux_p[] = { NULL, NULL, "rtc"};
+static u32 three_mux_table[] = {0, 1, 3};
+
+static struct asm9260_mux_clock asm9260_mux_clks[] __initdata = {
+        { 1, three_mux_table, "main_mux",       main_mux_p,
+                ARRAY_SIZE(main_mux_p), HW_MAINCLKSEL, },
+        { 1, three_mux_table, "uart_mux",       main_mux_p,
+                ARRAY_SIZE(main_mux_p), HW_UARTCLKSEL, },
+        { 1, three_mux_table, "wdt_mux",        main_mux_p,
+                ARRAY_SIZE(main_mux_p), HW_WDTCLKSEL, },
+        { 3, three_mux_table, "i2s0_mux",       i2s0_mux_p,
+                ARRAY_SIZE(i2s0_mux_p), HW_I2S0CLKSEL, },
+        { 3, three_mux_table, "i2s1_mux",       i2s1_mux_p,
+                ARRAY_SIZE(i2s1_mux_p), HW_I2S1CLKSEL, },
+        { 3, three_mux_table, "clkout_mux",     clkout_mux_p,
+                ARRAY_SIZE(clkout_mux_p), HW_CLKOUTCLKSEL, },
+};
+
+static void __init asm9260_acc_init(struct device_node *np)
+{
+        struct clk *clk;
+        const char *ref_clk, *pll_clk = "pll";
+        u32 rate;
+        int n;
+        u32 accuracy = 0;
+
+        base = of_io_request_and_map(np, 0, np->name);
+        if (!base)
+                panic("%s: unable to map resource", np->name);
+
+        /* register pll */
+        rate = (ioread32(base + HW_SYSPLLCTRL) & 0xffff) * 1000000;
+
+        ref_clk = of_clk_get_parent_name(np, 0);
+        accuracy = clk_get_accuracy(__clk_lookup(ref_clk));
+        clk = clk_register_fixed_rate_with_accuracy(NULL, pll_clk,
+                        ref_clk, 0, rate, accuracy);
+
+        if (IS_ERR(clk))
+                panic("%s: can't register REFCLK. Check DT!", np->name);
+
+        for (n = 0; n < ARRAY_SIZE(asm9260_mux_clks); n++) {
+                const struct asm9260_mux_clock *mc = &asm9260_mux_clks[n];
+
+                mc->parent_names[0] = ref_clk;
+                mc->parent_names[1] = pll_clk;
+                clk = clk_register_mux_table(NULL, mc->name, mc->parent_names,
+                                mc->num_parents, mc->flags, base + mc->offset,
+                                0, mc->mask, 0, mc->table, &asm9260_clk_lock);
+        }
+
+        /* clock mux gate cells */
+        for (n = 0; n < ARRAY_SIZE(asm9260_mux_gates); n++) {
+                const struct asm9260_gate_data *gd = &asm9260_mux_gates[n];
+
+                clk = clk_register_gate(NULL, gd->name,
+                        gd->parent_name, gd->flags | CLK_SET_RATE_PARENT,
+                        base + gd->reg, gd->bit_idx, 0, &asm9260_clk_lock);
+        }
+
+        /* clock div cells */
+        for (n = 0; n < ARRAY_SIZE(asm9260_div_clks); n++) {
+                const struct asm9260_div_clk *dc = &asm9260_div_clks[n];
+
+                clks[dc->idx] = clk_register_divider(NULL, dc->name,
+                                dc->parent_name, CLK_SET_RATE_PARENT,
+                                base + dc->reg, 0, 8, CLK_DIVIDER_ONE_BASED,
+                                &asm9260_clk_lock);
+        }
+
+        /* clock ahb gate cells */
+        for (n = 0; n < ARRAY_SIZE(asm9260_ahb_gates); n++) {
+                const struct asm9260_gate_data *gd = &asm9260_ahb_gates[n];
+
+                clks[gd->idx] = clk_register_gate(NULL, gd->name,
+                                gd->parent_name, gd->flags, base + gd->reg,
+                                gd->bit_idx, 0, &asm9260_clk_lock);
+        }
+
+        /* check for errors on leaf clocks */
+        for (n = 0; n < MAX_CLKS; n++) {
+                if (!IS_ERR(clks[n]))
+                        continue;
+
+                pr_err("%s: Unable to register leaf clock %d\n",
+                                np->full_name, n);
+                goto fail;
+        }
+
+        /* register clk-provider */
+        clk_data.clks = clks;
+        clk_data.clk_num = MAX_CLKS;
+        of_clk_add_provider(np, of_clk_src_onecell_get, &clk_data);
+        return;
+fail:
+        iounmap(base);
+}
+CLK_OF_DECLARE(asm9260_acc, "alphascale,asm9260-clock-controller",
+                asm9260_acc_init);
diff --git a/drivers/clk/clk-cdce706.c b/drivers/clk/clk-cdce706.c
new file mode 100644
index 000000000000..c386ad25beb4
--- /dev/null
+++ b/drivers/clk/clk-cdce706.c
@@ -0,0 +1,700 @@
+/*
+ * TI CDCE706 programmable 3-PLL clock synthesizer driver
+ *
+ * Copyright (c) 2014 Cadence Design Systems Inc.
+ *
+ * Reference: http://www.ti.com/lit/ds/symlink/cdce706.pdf
+ *
+ * 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-provider.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/rational.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+
+#define CDCE706_CLKIN_CLOCK             10
+#define CDCE706_CLKIN_SOURCE            11
+#define CDCE706_PLL_M_LOW(pll)          (1 + 3 * (pll))
+#define CDCE706_PLL_N_LOW(pll)          (2 + 3 * (pll))
+#define CDCE706_PLL_HI(pll)             (3 + 3 * (pll))
+#define CDCE706_PLL_MUX                 3
+#define CDCE706_PLL_FVCO                6
+#define CDCE706_DIVIDER(div)            (13 + (div))
+#define CDCE706_CLKOUT(out)             (19 + (out))
+
+#define CDCE706_CLKIN_CLOCK_MASK        0x10
+#define CDCE706_CLKIN_SOURCE_SHIFT      6
+#define CDCE706_CLKIN_SOURCE_MASK       0xc0
+#define CDCE706_CLKIN_SOURCE_LVCMOS     0x40
+
+#define CDCE706_PLL_MUX_MASK(pll)       (0x80 >> (pll))
+#define CDCE706_PLL_LOW_M_MASK          0xff
+#define CDCE706_PLL_LOW_N_MASK          0xff
+#define CDCE706_PLL_HI_M_MASK           0x1
+#define CDCE706_PLL_HI_N_MASK           0x1e
+#define CDCE706_PLL_HI_N_SHIFT          1
+#define CDCE706_PLL_M_MAX               0x1ff
+#define CDCE706_PLL_N_MAX               0xfff
+#define CDCE706_PLL_FVCO_MASK(pll)      (0x80 >> (pll))
+#define CDCE706_PLL_FREQ_MIN             80000000
+#define CDCE706_PLL_FREQ_MAX            300000000
+#define CDCE706_PLL_FREQ_HI             180000000
+
+#define CDCE706_DIVIDER_PLL(div)        (9 + (div) - ((div) > 2) - ((div) > 4))
+#define CDCE706_DIVIDER_PLL_SHIFT(div)  ((div) < 2 ? 5 : 3 * ((div) & 1))
+#define CDCE706_DIVIDER_PLL_MASK(div)   (0x7 << CDCE706_DIVIDER_PLL_SHIFT(div))
+#define CDCE706_DIVIDER_DIVIDER_MASK    0x7f
+#define CDCE706_DIVIDER_DIVIDER_MAX     0x7f
+
+#define CDCE706_CLKOUT_DIVIDER_MASK     0x7
+#define CDCE706_CLKOUT_ENABLE_MASK      0x8
+
+static struct regmap_config cdce706_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .val_format_endian = REGMAP_ENDIAN_NATIVE,
+};
+
+#define to_hw_data(phw) (container_of((phw), struct cdce706_hw_data, hw))
+
+struct cdce706_hw_data {
+        struct cdce706_dev_data *dev_data;
+        unsigned idx;
+        unsigned parent;
+        struct clk *clk;
+        struct clk_hw hw;
+        unsigned div;
+        unsigned mul;
+        unsigned mux;
+};
+
+struct cdce706_dev_data {
+        struct i2c_client *client;
+        struct regmap *regmap;
+        struct clk_onecell_data onecell;
+        struct clk *clks[6];
+        struct clk *clkin_clk[2];
+        const char *clkin_name[2];
+        struct cdce706_hw_data clkin[1];
+        struct cdce706_hw_data pll[3];
+        struct cdce706_hw_data divider[6];
+        struct cdce706_hw_data clkout[6];
+};
+
+static const char * const cdce706_source_name[] = {
+        "clk_in0", "clk_in1",
+};
+
+static const char *cdce706_clkin_name[] = {
+        "clk_in",
+};
+
+static const char * const cdce706_pll_name[] = {
+        "pll1", "pll2", "pll3",
+};
+
+static const char *cdce706_divider_parent_name[] = {
+        "clk_in", "pll1", "pll2", "pll2", "pll3",
+};
+
+static const char *cdce706_divider_name[] = {
+        "p0", "p1", "p2", "p3", "p4", "p5",
+};
+
+static const char * const cdce706_clkout_name[] = {
+        "clk_out0", "clk_out1", "clk_out2", "clk_out3", "clk_out4", "clk_out5",
+};
+
+static int cdce706_reg_read(struct cdce706_dev_data *dev_data, unsigned reg,
+                            unsigned *val)
+{
+        int rc = regmap_read(dev_data->regmap, reg | 0x80, val);
+
+        if (rc < 0)
+                dev_err(&dev_data->client->dev, "error reading reg %u", reg);
+        return rc;
+}
+
+static int cdce706_reg_write(struct cdce706_dev_data *dev_data, unsigned reg,
+                             unsigned val)
+{
+        int rc = regmap_write(dev_data->regmap, reg | 0x80, val);
+
+        if (rc < 0)
+                dev_err(&dev_data->client->dev, "error writing reg %u", reg);
+        return rc;
+}
+
+static int cdce706_reg_update(struct cdce706_dev_data *dev_data, unsigned reg,
+                              unsigned mask, unsigned val)
+{
+        int rc = regmap_update_bits(dev_data->regmap, reg | 0x80, mask, val);
+
+        if (rc < 0)
+                dev_err(&dev_data->client->dev, "error updating reg %u", reg);
+        return rc;
+}
+
+static int cdce706_clkin_set_parent(struct clk_hw *hw, u8 index)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        hwd->parent = index;
+        return 0;
+}
+
+static u8 cdce706_clkin_get_parent(struct clk_hw *hw)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        return hwd->parent;
+}
+
+static const struct clk_ops cdce706_clkin_ops = {
+        .set_parent = cdce706_clkin_set_parent,
+        .get_parent = cdce706_clkin_get_parent,
+};
+
+static unsigned long cdce706_pll_recalc_rate(struct clk_hw *hw,
+                                             unsigned long parent_rate)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        dev_dbg(&hwd->dev_data->client->dev,
+                "%s, pll: %d, mux: %d, mul: %u, div: %u\n",
+                __func__, hwd->idx, hwd->mux, hwd->mul, hwd->div);
+
+        if (!hwd->mux) {
+                if (hwd->div && hwd->mul) {
+                        u64 res = (u64)parent_rate * hwd->mul;
+
+                        do_div(res, hwd->div);
+                        return res;
+                }
+        } else {
+                if (hwd->div)
+                        return parent_rate / hwd->div;
+        }
+        return 0;
+}
+
+static long cdce706_pll_round_rate(struct clk_hw *hw, unsigned long rate,
+                                   unsigned long *parent_rate)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+        unsigned long mul, div;
+        u64 res;
+
+        dev_dbg(&hwd->dev_data->client->dev,
+                "%s, rate: %lu, parent_rate: %lu\n",
+                __func__, rate, *parent_rate);
+
+        rational_best_approximation(rate, *parent_rate,
+                                    CDCE706_PLL_N_MAX, CDCE706_PLL_M_MAX,
+                                    &mul, &div);
+        hwd->mul = mul;
+        hwd->div = div;
+
+        dev_dbg(&hwd->dev_data->client->dev,
+                "%s, pll: %d, mul: %lu, div: %lu\n",
+                __func__, hwd->idx, mul, div);
+
+        res = (u64)*parent_rate * hwd->mul;
+        do_div(res, hwd->div);
+        return res;
+}
+
+static int cdce706_pll_set_rate(struct clk_hw *hw, unsigned long rate,
+                                unsigned long parent_rate)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+        unsigned long mul = hwd->mul, div = hwd->div;
+        int err;
+
+        dev_dbg(&hwd->dev_data->client->dev,
+                "%s, pll: %d, mul: %lu, div: %lu\n",
+                __func__, hwd->idx, mul, div);
+
+        err = cdce706_reg_update(hwd->dev_data,
+                                 CDCE706_PLL_HI(hwd->idx),
+                                 CDCE706_PLL_HI_M_MASK | CDCE706_PLL_HI_N_MASK,
+                                 ((div >> 8) & CDCE706_PLL_HI_M_MASK) |
+                                 ((mul >> (8 - CDCE706_PLL_HI_N_SHIFT)) &
+                                  CDCE706_PLL_HI_N_MASK));
+        if (err < 0)
+                return err;
+
+        err = cdce706_reg_write(hwd->dev_data,
+                                CDCE706_PLL_M_LOW(hwd->idx),
+                                div & CDCE706_PLL_LOW_M_MASK);
+        if (err < 0)
+                return err;
+
+        err = cdce706_reg_write(hwd->dev_data,
+                                CDCE706_PLL_N_LOW(hwd->idx),
+                                mul & CDCE706_PLL_LOW_N_MASK);
+        if (err < 0)
+                return err;
+
+        err = cdce706_reg_update(hwd->dev_data,
+                                 CDCE706_PLL_FVCO,
+                                 CDCE706_PLL_FVCO_MASK(hwd->idx),
+                                 rate > CDCE706_PLL_FREQ_HI ?
+                                 CDCE706_PLL_FVCO_MASK(hwd->idx) : 0);
+        return err;
+}
+
+static const struct clk_ops cdce706_pll_ops = {
+        .recalc_rate = cdce706_pll_recalc_rate,
+        .round_rate = cdce706_pll_round_rate,
+        .set_rate = cdce706_pll_set_rate,
+};
+
+static int cdce706_divider_set_parent(struct clk_hw *hw, u8 index)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        if (hwd->parent == index)
+                return 0;
+        hwd->parent = index;
+        return cdce706_reg_update(hwd->dev_data,
+                                  CDCE706_DIVIDER_PLL(hwd->idx),
+                                  CDCE706_DIVIDER_PLL_MASK(hwd->idx),
+                                  index << CDCE706_DIVIDER_PLL_SHIFT(hwd->idx));
+}
+
+static u8 cdce706_divider_get_parent(struct clk_hw *hw)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        return hwd->parent;
+}
+
+static unsigned long cdce706_divider_recalc_rate(struct clk_hw *hw,
+                                                 unsigned long parent_rate)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        dev_dbg(&hwd->dev_data->client->dev,
+                "%s, divider: %d, div: %u\n",
+                __func__, hwd->idx, hwd->div);
+        if (hwd->div)
+                return parent_rate / hwd->div;
+        return 0;
+}
+
+static long cdce706_divider_round_rate(struct clk_hw *hw, unsigned long rate,
+                                       unsigned long *parent_rate)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+        struct cdce706_dev_data *cdce = hwd->dev_data;
+        unsigned long mul, div;
+
+        dev_dbg(&hwd->dev_data->client->dev,
+                "%s, rate: %lu, parent_rate: %lu\n",
+                __func__, rate, *parent_rate);
+
+        rational_best_approximation(rate, *parent_rate,
+                                    1, CDCE706_DIVIDER_DIVIDER_MAX,
+                                    &mul, &div);
+        if (!mul)
+                div = CDCE706_DIVIDER_DIVIDER_MAX;
+
+        if (__clk_get_flags(hw->clk) & CLK_SET_RATE_PARENT) {
+                unsigned long best_diff = rate;
+                unsigned long best_div = 0;
+                struct clk *gp_clk = cdce->clkin_clk[cdce->clkin[0].parent];
+                unsigned long gp_rate = gp_clk ? clk_get_rate(gp_clk) : 0;
+
+                for (div = CDCE706_PLL_FREQ_MIN / rate; best_diff &&
+                     div <= CDCE706_PLL_FREQ_MAX / rate; ++div) {
+                        unsigned long n, m;
+                        unsigned long diff;
+                        unsigned long div_rate;
+                        u64 div_rate64;
+
+                        if (rate * div < CDCE706_PLL_FREQ_MIN)
+                                continue;
+
+                        rational_best_approximation(rate * div, gp_rate,
+                                                    CDCE706_PLL_N_MAX,
+                                                    CDCE706_PLL_M_MAX,
+                                                    &n, &m);
+                        div_rate64 = (u64)gp_rate * n;
+                        do_div(div_rate64, m);
+                        do_div(div_rate64, div);
+                        div_rate = div_rate64;
+                        diff = max(div_rate, rate) - min(div_rate, rate);
+
+                        if (diff < best_diff) {
+                                best_diff = diff;
+                                best_div = div;
+                                dev_dbg(&hwd->dev_data->client->dev,
+                                        "%s, %lu * %lu / %lu / %lu = %lu\n",
+                                        __func__, gp_rate, n, m, div, div_rate);
+                        }
+                }
+
+                div = best_div;
+
+                dev_dbg(&hwd->dev_data->client->dev,
+                        "%s, altering parent rate: %lu -> %lu\n",
+                        __func__, *parent_rate, rate * div);
+                *parent_rate = rate * div;
+        }
+        hwd->div = div;
+
+        dev_dbg(&hwd->dev_data->client->dev,
+                "%s, divider: %d, div: %lu\n",
+                __func__, hwd->idx, div);
+
+        return *parent_rate / div;
+}
+
+static int cdce706_divider_set_rate(struct clk_hw *hw, unsigned long rate,
+                                    unsigned long parent_rate)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        dev_dbg(&hwd->dev_data->client->dev,
+                "%s, divider: %d, div: %u\n",
+                __func__, hwd->idx, hwd->div);
+
+        return cdce706_reg_update(hwd->dev_data,
+                                  CDCE706_DIVIDER(hwd->idx),
+                                  CDCE706_DIVIDER_DIVIDER_MASK,
+                                  hwd->div);
+}
+
+static const struct clk_ops cdce706_divider_ops = {
+        .set_parent = cdce706_divider_set_parent,
+        .get_parent = cdce706_divider_get_parent,
+        .recalc_rate = cdce706_divider_recalc_rate,
+        .round_rate = cdce706_divider_round_rate,
+        .set_rate = cdce706_divider_set_rate,
+};
+
+static int cdce706_clkout_prepare(struct clk_hw *hw)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        return cdce706_reg_update(hwd->dev_data, CDCE706_CLKOUT(hwd->idx),
+                                  CDCE706_CLKOUT_ENABLE_MASK,
+                                  CDCE706_CLKOUT_ENABLE_MASK);
+}
+
+static void cdce706_clkout_unprepare(struct clk_hw *hw)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        cdce706_reg_update(hwd->dev_data, CDCE706_CLKOUT(hwd->idx),
+                           CDCE706_CLKOUT_ENABLE_MASK, 0);
+}
+
+static int cdce706_clkout_set_parent(struct clk_hw *hw, u8 index)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        if (hwd->parent == index)
+                return 0;
+        hwd->parent = index;
+        return cdce706_reg_update(hwd->dev_data,
+                                  CDCE706_CLKOUT(hwd->idx),
+                                  CDCE706_CLKOUT_ENABLE_MASK, index);
+}
+
+static u8 cdce706_clkout_get_parent(struct clk_hw *hw)
+{
+        struct cdce706_hw_data *hwd = to_hw_data(hw);
+
+        return hwd->parent;
+}
+
+static unsigned long cdce706_clkout_recalc_rate(struct clk_hw *hw,
+                                                unsigned long parent_rate)
+{
+        return parent_rate;
+}
+
+static long cdce706_clkout_round_rate(struct clk_hw *hw, unsigned long rate,
+                                      unsigned long *parent_rate)
+{
+        *parent_rate = rate;
+        return rate;
+}
+
+static int cdce706_clkout_set_rate(struct clk_hw *hw, unsigned long rate,
+                                   unsigned long parent_rate)
+{
+        return 0;
+}
+
+static const struct clk_ops cdce706_clkout_ops = {
+        .prepare = cdce706_clkout_prepare,
+        .unprepare = cdce706_clkout_unprepare,
+        .set_parent = cdce706_clkout_set_parent,
+        .get_parent = cdce706_clkout_get_parent,
+        .recalc_rate = cdce706_clkout_recalc_rate,
+        .round_rate = cdce706_clkout_round_rate,
+        .set_rate = cdce706_clkout_set_rate,
+};
+
+static int cdce706_register_hw(struct cdce706_dev_data *cdce,
+                               struct cdce706_hw_data *hw, unsigned num_hw,
+                               const char * const *clk_names,
+                               struct clk_init_data *init)
+{
+        unsigned i;
+
+        for (i = 0; i < num_hw; ++i, ++hw) {
+                init->name = clk_names[i];
+                hw->dev_data = cdce;
+                hw->idx = i;
+                hw->hw.init = init;
+                hw->clk = devm_clk_register(&cdce->client->dev,
+                                            &hw->hw);
+                if (IS_ERR(hw->clk)) {
+                        dev_err(&cdce->client->dev, "Failed to register %s\n",
+                                clk_names[i]);
+                        return PTR_ERR(hw->clk);
+                }
+        }
+        return 0;
+}
+
+static int cdce706_register_clkin(struct cdce706_dev_data *cdce)
+{
+        struct clk_init_data init = {
+                .ops = &cdce706_clkin_ops,
+                .parent_names = cdce->clkin_name,
+                .num_parents = ARRAY_SIZE(cdce->clkin_name),
+        };
+        unsigned i;
+        int ret;
+        unsigned clock, source;
+
+        for (i = 0; i < ARRAY_SIZE(cdce->clkin_name); ++i) {
+                struct clk *parent = devm_clk_get(&cdce->client->dev,
+                                                  cdce706_source_name[i]);
+
+                if (IS_ERR(parent)) {
+                        cdce->clkin_name[i] = cdce706_source_name[i];
+                } else {
+                        cdce->clkin_name[i] = __clk_get_name(parent);
+                        cdce->clkin_clk[i] = parent;
+                }
+        }
+
+        ret = cdce706_reg_read(cdce, CDCE706_CLKIN_SOURCE, &source);
+        if (ret < 0)
+                return ret;
+        if ((source & CDCE706_CLKIN_SOURCE_MASK) ==
+            CDCE706_CLKIN_SOURCE_LVCMOS) {
+                ret = cdce706_reg_read(cdce, CDCE706_CLKIN_CLOCK, &clock);
+                if (ret < 0)
+                        return ret;
+                cdce->clkin[0].parent = !!(clock & CDCE706_CLKIN_CLOCK_MASK);
+        }
+
+        ret = cdce706_register_hw(cdce, cdce->clkin,
+                                  ARRAY_SIZE(cdce->clkin),
+                                  cdce706_clkin_name, &init);
+        return ret;
+}
+
+static int cdce706_register_plls(struct cdce706_dev_data *cdce)
+{
+        struct clk_init_data init = {
+                .ops = &cdce706_pll_ops,
+                .parent_names = cdce706_clkin_name,
+                .num_parents = ARRAY_SIZE(cdce706_clkin_name),
+        };
+        unsigned i;
+        int ret;
+        unsigned mux;
+
+        ret = cdce706_reg_read(cdce, CDCE706_PLL_MUX, &mux);
+        if (ret < 0)
+                return ret;
+
+        for (i = 0; i < ARRAY_SIZE(cdce->pll); ++i) {
+                unsigned m, n, v;
+
+                ret = cdce706_reg_read(cdce, CDCE706_PLL_M_LOW(i), &m);
+                if (ret < 0)
+                        return ret;
+                ret = cdce706_reg_read(cdce, CDCE706_PLL_N_LOW(i), &n);
+                if (ret < 0)
+                        return ret;
+                ret = cdce706_reg_read(cdce, CDCE706_PLL_HI(i), &v);
+                if (ret < 0)
+                        return ret;
+                cdce->pll[i].div = m | ((v & CDCE706_PLL_HI_M_MASK) << 8);
+                cdce->pll[i].mul = n | ((v & CDCE706_PLL_HI_N_MASK) <<
+                                        (8 - CDCE706_PLL_HI_N_SHIFT));
+                cdce->pll[i].mux = mux & CDCE706_PLL_MUX_MASK(i);
+                dev_dbg(&cdce->client->dev,
+                        "%s: i: %u, div: %u, mul: %u, mux: %d\n", __func__, i,
+                        cdce->pll[i].div, cdce->pll[i].mul, cdce->pll[i].mux);
+        }
+
+        ret = cdce706_register_hw(cdce, cdce->pll,
+                                  ARRAY_SIZE(cdce->pll),
+                                  cdce706_pll_name, &init);
+        return ret;
+}
+
+static int cdce706_register_dividers(struct cdce706_dev_data *cdce)
+{
+        struct clk_init_data init = {
+                .ops = &cdce706_divider_ops,
+                .parent_names = cdce706_divider_parent_name,
+                .num_parents = ARRAY_SIZE(cdce706_divider_parent_name),
+                .flags = CLK_SET_RATE_PARENT,
+        };
+        unsigned i;
+        int ret;
+
+        for (i = 0; i < ARRAY_SIZE(cdce->divider); ++i) {
+                unsigned val;
+
+                ret = cdce706_reg_read(cdce, CDCE706_DIVIDER_PLL(i), &val);
+                if (ret < 0)
+                        return ret;
+                cdce->divider[i].parent =
+                        (val & CDCE706_DIVIDER_PLL_MASK(i)) >>
+                        CDCE706_DIVIDER_PLL_SHIFT(i);
+
+                ret = cdce706_reg_read(cdce, CDCE706_DIVIDER(i), &val);
+                if (ret < 0)
+                        return ret;
+                cdce->divider[i].div = val & CDCE706_DIVIDER_DIVIDER_MASK;
+                dev_dbg(&cdce->client->dev,
+                        "%s: i: %u, parent: %u, div: %u\n", __func__, i,
+                        cdce->divider[i].parent, cdce->divider[i].div);
+        }
+
+        ret = cdce706_register_hw(cdce, cdce->divider,
+                                  ARRAY_SIZE(cdce->divider),
+                                  cdce706_divider_name, &init);
+        return ret;
+}
+
+static int cdce706_register_clkouts(struct cdce706_dev_data *cdce)
+{
+        struct clk_init_data init = {
+                .ops = &cdce706_clkout_ops,
+                .parent_names = cdce706_divider_name,
+                .num_parents = ARRAY_SIZE(cdce706_divider_name),
+                .flags = CLK_SET_RATE_PARENT,
+        };
+        unsigned i;
+        int ret;
+
+        for (i = 0; i < ARRAY_SIZE(cdce->clkout); ++i) {
+                unsigned val;
+
+                ret = cdce706_reg_read(cdce, CDCE706_CLKOUT(i), &val);
+                if (ret < 0)
+                        return ret;
+                cdce->clkout[i].parent = val & CDCE706_CLKOUT_DIVIDER_MASK;
+                dev_dbg(&cdce->client->dev,
+                        "%s: i: %u, parent: %u\n", __func__, i,
+                        cdce->clkout[i].parent);
+        }
+
+        ret = cdce706_register_hw(cdce, cdce->clkout,
+                                  ARRAY_SIZE(cdce->clkout),
+                                  cdce706_clkout_name, &init);
+        for (i = 0; i < ARRAY_SIZE(cdce->clkout); ++i)
+                cdce->clks[i] = cdce->clkout[i].clk;
+
+        return ret;
+}
+
+static int cdce706_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+        struct cdce706_dev_data *cdce;
+        int ret;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -EIO;
+
+        cdce = devm_kzalloc(&client->dev, sizeof(*cdce), GFP_KERNEL);
+        if (!cdce)
+                return -ENOMEM;
+
+        cdce->client = client;
+        cdce->regmap = devm_regmap_init_i2c(client, &cdce706_regmap_config);
+        if (IS_ERR(cdce->regmap)) {
+                dev_err(&client->dev, "Failed to initialize regmap\n");
+                return -EINVAL;
+        }
+
+        i2c_set_clientdata(client, cdce);
+
+        ret = cdce706_register_clkin(cdce);
+        if (ret < 0)
+                return ret;
+        ret = cdce706_register_plls(cdce);
+        if (ret < 0)
+                return ret;
+        ret = cdce706_register_dividers(cdce);
+        if (ret < 0)
+                return ret;
+        ret = cdce706_register_clkouts(cdce);
+        if (ret < 0)
+                return ret;
+        cdce->onecell.clks = cdce->clks;
+        cdce->onecell.clk_num = ARRAY_SIZE(cdce->clks);
+        ret = of_clk_add_provider(client->dev.of_node, of_clk_src_onecell_get,
+                                  &cdce->onecell);
+
+        return ret;
+}
+
+static int cdce706_remove(struct i2c_client *client)
+{
+        return 0;
+}
+
+
+#ifdef CONFIG_OF
+static const struct of_device_id cdce706_dt_match[] = {
+        { .compatible = "ti,cdce706" },
+        { },
+};
+MODULE_DEVICE_TABLE(of, cdce706_dt_match);
+#endif
+
+static const struct i2c_device_id cdce706_id[] = {
+        { "cdce706", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, cdce706_id);
+
+static struct i2c_driver cdce706_i2c_driver = {
+        .driver = {
+                .name   = "cdce706",
+                .of_match_table = of_match_ptr(cdce706_dt_match),
+        },
+        .probe          = cdce706_probe,
+        .remove         = cdce706_remove,
+        .id_table       = cdce706_id,
+};
+module_i2c_driver(cdce706_i2c_driver);
+
+MODULE_AUTHOR("Max Filippov <jcmvbkbc@gmail.com>");
+MODULE_DESCRIPTION("TI CDCE 706 clock synthesizer driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/clk/clk-composite.c b/drivers/clk/clk-composite.c
index 4386697236a7..956b7e54fa1c 100644
--- a/drivers/clk/clk-composite.c
+++ b/drivers/clk/clk-composite.c
@@ -27,7 +27,7 @@ static u8 clk_composite_get_parent(struct clk_hw *hw)
         const struct clk_ops *mux_ops = composite->mux_ops;
         struct clk_hw *mux_hw = composite->mux_hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         return mux_ops->get_parent(mux_hw);
 }
@@ -38,7 +38,7 @@ static int clk_composite_set_parent(struct clk_hw *hw, u8 index)
         const struct clk_ops *mux_ops = composite->mux_ops;
         struct clk_hw *mux_hw = composite->mux_hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         return mux_ops->set_parent(mux_hw, index);
 }
@@ -50,12 +50,14 @@ static unsigned long clk_composite_recalc_rate(struct clk_hw *hw,
         const struct clk_ops *rate_ops = composite->rate_ops;
         struct clk_hw *rate_hw = composite->rate_hw;
 
-        rate_hw->clk = hw->clk;
+        __clk_hw_set_clk(rate_hw, hw);
 
         return rate_ops->recalc_rate(rate_hw, parent_rate);
 }
 
 static long clk_composite_determine_rate(struct clk_hw *hw, unsigned long rate,
+                                        unsigned long min_rate,
+                                        unsigned long max_rate,
                                         unsigned long *best_parent_rate,
                                         struct clk_hw **best_parent_p)
 {
@@ -72,8 +74,10 @@ static long clk_composite_determine_rate(struct clk_hw *hw, unsigned long rate,
         int i;
 
         if (rate_hw && rate_ops && rate_ops->determine_rate) {
-                rate_hw->clk = hw->clk;
-                return rate_ops->determine_rate(rate_hw, rate, best_parent_rate,
+                __clk_hw_set_clk(rate_hw, hw);
+                return rate_ops->determine_rate(rate_hw, rate, min_rate,
+                                                max_rate,
+                                                best_parent_rate,
                                                 best_parent_p);
         } else if (rate_hw && rate_ops && rate_ops->round_rate &&
                    mux_hw && mux_ops && mux_ops->set_parent) {
@@ -116,8 +120,9 @@ static long clk_composite_determine_rate(struct clk_hw *hw, unsigned long rate,
 
                 return best_rate;
         } else if (mux_hw && mux_ops && mux_ops->determine_rate) {
-                mux_hw->clk = hw->clk;
-                return mux_ops->determine_rate(mux_hw, rate, best_parent_rate,
+                __clk_hw_set_clk(mux_hw, hw);
+                return mux_ops->determine_rate(mux_hw, rate, min_rate,
+                                               max_rate, best_parent_rate,
                                                best_parent_p);
         } else {
                 pr_err("clk: clk_composite_determine_rate function called, but no mux or rate callback set!\n");
@@ -132,7 +137,7 @@ static long clk_composite_round_rate(struct clk_hw *hw, unsigned long rate,
         const struct clk_ops *rate_ops = composite->rate_ops;
         struct clk_hw *rate_hw = composite->rate_hw;
 
-        rate_hw->clk = hw->clk;
+        __clk_hw_set_clk(rate_hw, hw);
 
         return rate_ops->round_rate(rate_hw, rate, prate);
 }
@@ -144,7 +149,7 @@ static int clk_composite_set_rate(struct clk_hw *hw, unsigned long rate,
         const struct clk_ops *rate_ops = composite->rate_ops;
         struct clk_hw *rate_hw = composite->rate_hw;
 
-        rate_hw->clk = hw->clk;
+        __clk_hw_set_clk(rate_hw, hw);
 
         return rate_ops->set_rate(rate_hw, rate, parent_rate);
 }
@@ -155,7 +160,7 @@ static int clk_composite_is_enabled(struct clk_hw *hw)
         const struct clk_ops *gate_ops = composite->gate_ops;
         struct clk_hw *gate_hw = composite->gate_hw;
 
-        gate_hw->clk = hw->clk;
+        __clk_hw_set_clk(gate_hw, hw);
 
         return gate_ops->is_enabled(gate_hw);
 }
@@ -166,7 +171,7 @@ static int clk_composite_enable(struct clk_hw *hw)
         const struct clk_ops *gate_ops = composite->gate_ops;
         struct clk_hw *gate_hw = composite->gate_hw;
 
-        gate_hw->clk = hw->clk;
+        __clk_hw_set_clk(gate_hw, hw);
 
         return gate_ops->enable(gate_hw);
 }
@@ -177,7 +182,7 @@ static void clk_composite_disable(struct clk_hw *hw)
         const struct clk_ops *gate_ops = composite->gate_ops;
         struct clk_hw *gate_hw = composite->gate_hw;
 
-        gate_hw->clk = hw->clk;
+        __clk_hw_set_clk(gate_hw, hw);
 
         gate_ops->disable(gate_hw);
 }
diff --git a/drivers/clk/clk-divider.c b/drivers/clk/clk-divider.c
index c0a842b335c5..db7f8bce7467 100644
--- a/drivers/clk/clk-divider.c
+++ b/drivers/clk/clk-divider.c
@@ -30,7 +30,7 @@
 
 #define to_clk_divider(_hw) container_of(_hw, struct clk_divider, hw)
 
-#define div_mask(d)     ((1 << ((d)->width)) - 1)
+#define div_mask(width) ((1 << (width)) - 1)
 
 static unsigned int _get_table_maxdiv(const struct clk_div_table *table)
 {
@@ -54,15 +54,16 @@ static unsigned int _get_table_mindiv(const struct clk_div_table *table)
         return mindiv;
 }
 
-static unsigned int _get_maxdiv(struct clk_divider *divider)
+static unsigned int _get_maxdiv(const struct clk_div_table *table, u8 width,
+                                unsigned long flags)
 {
-        if (divider->flags & CLK_DIVIDER_ONE_BASED)
-                return div_mask(divider);
-        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
-                return 1 << div_mask(divider);
-        if (divider->table)
-                return _get_table_maxdiv(divider->table);
-        return div_mask(divider) + 1;
+        if (flags & CLK_DIVIDER_ONE_BASED)
+                return div_mask(width);
+        if (flags & CLK_DIVIDER_POWER_OF_TWO)
+                return 1 << div_mask(width);
+        if (table)
+                return _get_table_maxdiv(table);
+        return div_mask(width) + 1;
 }
 
 static unsigned int _get_table_div(const struct clk_div_table *table,
@@ -76,14 +77,15 @@ static unsigned int _get_table_div(const struct clk_div_table *table,
         return 0;
 }
 
-static unsigned int _get_div(struct clk_divider *divider, unsigned int val)
+static unsigned int _get_div(const struct clk_div_table *table,
+                             unsigned int val, unsigned long flags)
 {
-        if (divider->flags & CLK_DIVIDER_ONE_BASED)
+        if (flags & CLK_DIVIDER_ONE_BASED)
                 return val;
-        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+        if (flags & CLK_DIVIDER_POWER_OF_TWO)
                 return 1 << val;
-        if (divider->table)
-                return _get_table_div(divider->table, val);
+        if (table)
+                return _get_table_div(table, val);
         return val + 1;
 }
 
@@ -98,29 +100,28 @@ static unsigned int _get_table_val(const struct clk_div_table *table,
         return 0;
 }
 
-static unsigned int _get_val(struct clk_divider *divider, unsigned int div)
+static unsigned int _get_val(const struct clk_div_table *table,
+                             unsigned int div, unsigned long flags)
 {
-        if (divider->flags & CLK_DIVIDER_ONE_BASED)
+        if (flags & CLK_DIVIDER_ONE_BASED)
                 return div;
-        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+        if (flags & CLK_DIVIDER_POWER_OF_TWO)
                 return __ffs(div);
-        if (divider->table)
-                return  _get_table_val(divider->table, div);
+        if (table)
+                return  _get_table_val(table, div);
         return div - 1;
 }
 
-static unsigned long clk_divider_recalc_rate(struct clk_hw *hw,
-                unsigned long parent_rate)
+unsigned long divider_recalc_rate(struct clk_hw *hw, unsigned long parent_rate,
+                                  unsigned int val,
+                                  const struct clk_div_table *table,
+                                  unsigned long flags)
 {
-        struct clk_divider *divider = to_clk_divider(hw);
-        unsigned int div, val;
+        unsigned int div;
 
-        val = clk_readl(divider->reg) >> divider->shift;
-        val &= div_mask(divider);
-
-        div = _get_div(divider, val);
+        div = _get_div(table, val, flags);
         if (!div) {
-                WARN(!(divider->flags & CLK_DIVIDER_ALLOW_ZERO),
+                WARN(!(flags & CLK_DIVIDER_ALLOW_ZERO),
                         "%s: Zero divisor and CLK_DIVIDER_ALLOW_ZERO not set\n",
                         __clk_get_name(hw->clk));
                 return parent_rate;
@@ -128,6 +129,20 @@ static unsigned long clk_divider_recalc_rate(struct clk_hw *hw,
 
         return DIV_ROUND_UP(parent_rate, div);
 }
+EXPORT_SYMBOL_GPL(divider_recalc_rate);
+
+static unsigned long clk_divider_recalc_rate(struct clk_hw *hw,
+                unsigned long parent_rate)
+{
+        struct clk_divider *divider = to_clk_divider(hw);
+        unsigned int val;
+
+        val = clk_readl(divider->reg) >> divider->shift;
+        val &= div_mask(divider->width);
+
+        return divider_recalc_rate(hw, parent_rate, val, divider->table,
+                                   divider->flags);
+}
 
 /*
  * The reverse of DIV_ROUND_UP: The maximum number which
@@ -146,12 +161,13 @@ static bool _is_valid_table_div(const struct clk_div_table *table,
         return false;
 }
 
-static bool _is_valid_div(struct clk_divider *divider, unsigned int div)
+static bool _is_valid_div(const struct clk_div_table *table, unsigned int div,
+                          unsigned long flags)
 {
-        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+        if (flags & CLK_DIVIDER_POWER_OF_TWO)
                 return is_power_of_2(div);
-        if (divider->table)
-                return _is_valid_table_div(divider->table, div);
+        if (table)
+                return _is_valid_table_div(table, div);
         return true;
 }
 
@@ -191,71 +207,76 @@ static int _round_down_table(const struct clk_div_table *table, int div)
         return down;
 }
 
-static int _div_round_up(struct clk_divider *divider,
-                unsigned long parent_rate, unsigned long rate)
+static int _div_round_up(const struct clk_div_table *table,
+                         unsigned long parent_rate, unsigned long rate,
+                         unsigned long flags)
 {
         int div = DIV_ROUND_UP(parent_rate, rate);
 
-        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+        if (flags & CLK_DIVIDER_POWER_OF_TWO)
                 div = __roundup_pow_of_two(div);
-        if (divider->table)
-                div = _round_up_table(divider->table, div);
+        if (table)
+                div = _round_up_table(table, div);
 
         return div;
 }
 
-static int _div_round_closest(struct clk_divider *divider,
-                unsigned long parent_rate, unsigned long rate)
+static int _div_round_closest(const struct clk_div_table *table,
+                              unsigned long parent_rate, unsigned long rate,
+                              unsigned long flags)
 {
         int up, down, div;
 
         up = down = div = DIV_ROUND_CLOSEST(parent_rate, rate);
 
-        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO) {
+        if (flags & CLK_DIVIDER_POWER_OF_TWO) {
                 up = __roundup_pow_of_two(div);
                 down = __rounddown_pow_of_two(div);
-        } else if (divider->table) {
-                up = _round_up_table(divider->table, div);
-                down = _round_down_table(divider->table, div);
+        } else if (table) {
+                up = _round_up_table(table, div);
+                down = _round_down_table(table, div);
         }
 
         return (up - div) <= (div - down) ? up : down;
 }
 
-static int _div_round(struct clk_divider *divider, unsigned long parent_rate,
-                unsigned long rate)
+static int _div_round(const struct clk_div_table *table,
+                      unsigned long parent_rate, unsigned long rate,
+                      unsigned long flags)
 {
-        if (divider->flags & CLK_DIVIDER_ROUND_CLOSEST)
-                return _div_round_closest(divider, parent_rate, rate);
+        if (flags & CLK_DIVIDER_ROUND_CLOSEST)
+                return _div_round_closest(table, parent_rate, rate, flags);
 
-        return _div_round_up(divider, parent_rate, rate);
+        return _div_round_up(table, parent_rate, rate, flags);
 }
 
-static bool _is_best_div(struct clk_divider *divider,
-                unsigned long rate, unsigned long now, unsigned long best)
+static bool _is_best_div(unsigned long rate, unsigned long now,
+                         unsigned long best, unsigned long flags)
 {
-        if (divider->flags & CLK_DIVIDER_ROUND_CLOSEST)
+        if (flags & CLK_DIVIDER_ROUND_CLOSEST)
                 return abs(rate - now) < abs(rate - best);
 
         return now <= rate && now > best;
 }
 
-static int _next_div(struct clk_divider *divider, int div)
+static int _next_div(const struct clk_div_table *table, int div,
+                     unsigned long flags)
 {
         div++;
 
-        if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
+        if (flags & CLK_DIVIDER_POWER_OF_TWO)
                 return __roundup_pow_of_two(div);
-        if (divider->table)
-                return _round_up_table(divider->table, div);
+        if (table)
+                return _round_up_table(table, div);
 
         return div;
 }
 
 static int clk_divider_bestdiv(struct clk_hw *hw, unsigned long rate,
-                unsigned long *best_parent_rate)
+                               unsigned long *best_parent_rate,
+                               const struct clk_div_table *table, u8 width,
+                               unsigned long flags)
 {
-        struct clk_divider *divider = to_clk_divider(hw);
         int i, bestdiv = 0;
         unsigned long parent_rate, best = 0, now, maxdiv;
         unsigned long parent_rate_saved = *best_parent_rate;
@@ -263,19 +284,11 @@ 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);
+        maxdiv = _get_maxdiv(table, width, flags);
 
         if (!(__clk_get_flags(hw->clk) & CLK_SET_RATE_PARENT)) {
                 parent_rate = *best_parent_rate;
-                bestdiv = _div_round(divider, parent_rate, rate);
+                bestdiv = _div_round(table, parent_rate, rate, flags);
                 bestdiv = bestdiv == 0 ? 1 : bestdiv;
                 bestdiv = bestdiv > maxdiv ? maxdiv : bestdiv;
                 return bestdiv;
@@ -287,8 +300,8 @@ static int clk_divider_bestdiv(struct clk_hw *hw, unsigned long rate,
          */
         maxdiv = min(ULONG_MAX / rate, maxdiv);
 
-        for (i = 1; i <= maxdiv; i = _next_div(divider, i)) {
-                if (!_is_valid_div(divider, i))
+        for (i = 1; i <= maxdiv; i = _next_div(table, i, flags)) {
+                if (!_is_valid_div(table, i, flags))
                         continue;
                 if (rate * i == parent_rate_saved) {
                         /*
@@ -302,7 +315,7 @@ static int clk_divider_bestdiv(struct clk_hw *hw, unsigned long rate,
                 parent_rate = __clk_round_rate(__clk_get_parent(hw->clk),
                                 MULT_ROUND_UP(rate, i));
                 now = DIV_ROUND_UP(parent_rate, i);
-                if (_is_best_div(divider, rate, now, best)) {
+                if (_is_best_div(rate, now, best, flags)) {
                         bestdiv = i;
                         best = now;
                         *best_parent_rate = parent_rate;
@@ -310,48 +323,79 @@ static int clk_divider_bestdiv(struct clk_hw *hw, unsigned long rate,
         }
 
         if (!bestdiv) {
-                bestdiv = _get_maxdiv(divider);
+                bestdiv = _get_maxdiv(table, width, flags);
                 *best_parent_rate = __clk_round_rate(__clk_get_parent(hw->clk), 1);
         }
 
         return bestdiv;
 }
 
-static long clk_divider_round_rate(struct clk_hw *hw, unsigned long rate,
-                                unsigned long *prate)
+long divider_round_rate(struct clk_hw *hw, unsigned long rate,
+                        unsigned long *prate, const struct clk_div_table *table,
+                        u8 width, unsigned long flags)
 {
         int div;
-        div = clk_divider_bestdiv(hw, rate, prate);
+
+        div = clk_divider_bestdiv(hw, rate, prate, table, width, flags);
 
         return DIV_ROUND_UP(*prate, div);
 }
+EXPORT_SYMBOL_GPL(divider_round_rate);
 
-static int clk_divider_set_rate(struct clk_hw *hw, unsigned long rate,
-                                unsigned long parent_rate)
+static long clk_divider_round_rate(struct clk_hw *hw, unsigned long rate,
+                                unsigned long *prate)
 {
         struct clk_divider *divider = to_clk_divider(hw);
+        int bestdiv;
+
+        /* if read only, just return current value */
+        if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+                bestdiv = readl(divider->reg) >> divider->shift;
+                bestdiv &= div_mask(divider->width);
+                bestdiv = _get_div(divider->table, bestdiv, divider->flags);
+                return bestdiv;
+        }
+
+        return divider_round_rate(hw, rate, prate, divider->table,
+                                  divider->width, divider->flags);
+}
+
+int divider_get_val(unsigned long rate, unsigned long parent_rate,
+                    const struct clk_div_table *table, u8 width,
+                    unsigned long flags)
+{
         unsigned int div, value;
-        unsigned long flags = 0;
-        u32 val;
 
         div = DIV_ROUND_UP(parent_rate, rate);
 
-        if (!_is_valid_div(divider, div))
+        if (!_is_valid_div(table, div, flags))
                 return -EINVAL;
 
-        value = _get_val(divider, div);
+        value = _get_val(table, div, flags);
+
+        return min_t(unsigned int, value, div_mask(width));
+}
+EXPORT_SYMBOL_GPL(divider_get_val);
+
+static int clk_divider_set_rate(struct clk_hw *hw, unsigned long rate,
+                                unsigned long parent_rate)
+{
+        struct clk_divider *divider = to_clk_divider(hw);
+        unsigned int value;
+        unsigned long flags = 0;
+        u32 val;
 
-        if (value > div_mask(divider))
-                value = div_mask(divider);
+        value = divider_get_val(rate, parent_rate, divider->table,
+                                divider->width, divider->flags);
 
         if (divider->lock)
                 spin_lock_irqsave(divider->lock, flags);
 
         if (divider->flags & CLK_DIVIDER_HIWORD_MASK) {
-                val = div_mask(divider) << (divider->shift + 16);
+                val = div_mask(divider->width) << (divider->shift + 16);
         } else {
                 val = clk_readl(divider->reg);
-                val &= ~(div_mask(divider) << divider->shift);
+                val &= ~(div_mask(divider->width) << divider->shift);
         }
         val |= value << divider->shift;
         clk_writel(val, divider->reg);
@@ -463,3 +507,19 @@ struct clk *clk_register_divider_table(struct device *dev, const char *name,
                         width, clk_divider_flags, table, lock);
 }
 EXPORT_SYMBOL_GPL(clk_register_divider_table);
+
+void clk_unregister_divider(struct clk *clk)
+{
+        struct clk_divider *div;
+        struct clk_hw *hw;
+
+        hw = __clk_get_hw(clk);
+        if (!hw)
+                return;
+
+        div = to_clk_divider(hw);
+
+        clk_unregister(clk);
+        kfree(div);
+}
+EXPORT_SYMBOL_GPL(clk_unregister_divider);
diff --git a/drivers/clk/clk-gate.c b/drivers/clk/clk-gate.c
index 51fd87fb7ba6..3f0e4200cb5d 100644
--- a/drivers/clk/clk-gate.c
+++ b/drivers/clk/clk-gate.c
@@ -128,7 +128,7 @@ struct clk *clk_register_gate(struct device *dev, const char *name,
         struct clk_init_data init;
 
         if (clk_gate_flags & CLK_GATE_HIWORD_MASK) {
-                if (bit_idx > 16) {
+                if (bit_idx > 15) {
                         pr_err("gate bit exceeds LOWORD field\n");
                         return ERR_PTR(-EINVAL);
                 }
@@ -162,3 +162,19 @@ struct clk *clk_register_gate(struct device *dev, const char *name,
         return clk;
 }
 EXPORT_SYMBOL_GPL(clk_register_gate);
+
+void clk_unregister_gate(struct clk *clk)
+{
+        struct clk_gate *gate;
+        struct clk_hw *hw;
+
+        hw = __clk_get_hw(clk);
+        if (!hw)
+                return;
+
+        gate = to_clk_gate(hw);
+
+        clk_unregister(clk);
+        kfree(gate);
+}
+EXPORT_SYMBOL_GPL(clk_unregister_gate);
diff --git a/drivers/clk/clk-mux.c b/drivers/clk/clk-mux.c
index 6e1ecf94bf58..69a094c3783d 100644
--- a/drivers/clk/clk-mux.c
+++ b/drivers/clk/clk-mux.c
@@ -177,3 +177,19 @@ struct clk *clk_register_mux(struct device *dev, const char *name,
                                       NULL, lock);
 }
 EXPORT_SYMBOL_GPL(clk_register_mux);
+
+void clk_unregister_mux(struct clk *clk)
+{
+        struct clk_mux *mux;
+        struct clk_hw *hw;
+
+        hw = __clk_get_hw(clk);
+        if (!hw)
+                return;
+
+        mux = to_clk_mux(hw);
+
+        clk_unregister(clk);
+        kfree(mux);
+}
+EXPORT_SYMBOL_GPL(clk_unregister_mux);
diff --git a/drivers/clk/clk-ppc-corenet.c b/drivers/clk/clk-qoriq.c
index 0a47d6f49cd6..cda90a971e39 100644
--- a/drivers/clk/clk-ppc-corenet.c
+++ b/drivers/clk/clk-qoriq.c
@@ -5,8 +5,11 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * clock driver for Freescale PowerPC corenet SoCs.
+ * clock driver for Freescale QorIQ SoCs.
  */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/clk-provider.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
@@ -19,6 +22,7 @@
 struct cmux_clk {
         struct clk_hw hw;
         void __iomem *reg;
+        unsigned int clk_per_pll;
         u32 flags;
 };
 
@@ -27,14 +31,12 @@ struct cmux_clk {
 #define CLKSEL_ADJUST           BIT(0)
 #define to_cmux_clk(p)          container_of(p, struct cmux_clk, hw)
 
-static unsigned int clocks_per_pll;
-
 static int cmux_set_parent(struct clk_hw *hw, u8 idx)
 {
         struct cmux_clk *clk = to_cmux_clk(hw);
         u32 clksel;
 
-        clksel = ((idx / clocks_per_pll) << 2) + idx % clocks_per_pll;
+        clksel = ((idx / clk->clk_per_pll) << 2) + idx % clk->clk_per_pll;
         if (clk->flags & CLKSEL_ADJUST)
                 clksel += 8;
         clksel = (clksel & 0xf) << CLKSEL_SHIFT;
@@ -52,12 +54,12 @@ static u8 cmux_get_parent(struct clk_hw *hw)
         clksel = (clksel >> CLKSEL_SHIFT) & 0xf;
         if (clk->flags & CLKSEL_ADJUST)
                 clksel -= 8;
-        clksel = (clksel >> 2) * clocks_per_pll + clksel % 4;
+        clksel = (clksel >> 2) * clk->clk_per_pll + clksel % 4;
 
         return clksel;
 }
 
-const struct clk_ops cmux_ops = {
+static const struct clk_ops cmux_ops = {
         .get_parent = cmux_get_parent,
         .set_parent = cmux_set_parent,
 };
@@ -72,6 +74,7 @@ static void __init core_mux_init(struct device_node *np)
         u32     offset;
         const char *clk_name;
         const char **parent_names;
+        struct of_phandle_args clkspec;
 
         rc = of_property_read_u32(np, "reg", &offset);
         if (rc) {
@@ -85,32 +88,40 @@ static void __init core_mux_init(struct device_node *np)
                 pr_err("%s: get clock count error\n", np->name);
                 return;
         }
-        parent_names = kzalloc((sizeof(char *) * count), GFP_KERNEL);
-        if (!parent_names) {
-                pr_err("%s: could not allocate parent_names\n", __func__);
+        parent_names = kcalloc(count, sizeof(char *), GFP_KERNEL);
+        if (!parent_names)
                 return;
-        }
 
         for (i = 0; i < count; i++)
                 parent_names[i] = of_clk_get_parent_name(np, i);
 
-        cmux_clk = kzalloc(sizeof(struct cmux_clk), GFP_KERNEL);
-        if (!cmux_clk) {
-                pr_err("%s: could not allocate cmux_clk\n", __func__);
+        cmux_clk = kzalloc(sizeof(*cmux_clk), GFP_KERNEL);
+        if (!cmux_clk)
                 goto err_name;
-        }
+
         cmux_clk->reg = of_iomap(np, 0);
         if (!cmux_clk->reg) {
                 pr_err("%s: could not map register\n", __func__);
                 goto err_clk;
         }
 
+        rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", 0,
+                                        &clkspec);
+        if (rc) {
+                pr_err("%s: parse clock node error\n", __func__);
+                goto err_clk;
+        }
+
+        cmux_clk->clk_per_pll = of_property_count_strings(clkspec.np,
+                        "clock-output-names");
+        of_node_put(clkspec.np);
+
         node = of_find_compatible_node(NULL, NULL, "fsl,p4080-clockgen");
         if (node && (offset >= 0x80))
                 cmux_clk->flags = CLKSEL_ADJUST;
 
         rc = of_property_read_string_index(np, "clock-output-names",
-                        0, &clk_name);
+                                           0, &clk_name);
         if (rc) {
                 pr_err("%s: read clock names error\n", np->name);
                 goto err_clk;
@@ -132,7 +143,7 @@ static void __init core_mux_init(struct device_node *np)
         rc = of_clk_add_provider(np, of_clk_src_simple_get, clk);
         if (rc) {
                 pr_err("Could not register clock provider for node:%s\n",
-                         np->name);
+                       np->name);
                 goto err_clk;
         }
         goto err_name;
@@ -155,7 +166,7 @@ static void __init core_pll_init(struct device_node *np)
 
         base = of_iomap(np, 0);
         if (!base) {
-                pr_err("clk-ppc: iomap error\n");
+                pr_err("iomap error\n");
                 return;
         }
 
@@ -181,24 +192,17 @@ static void __init core_pll_init(struct device_node *np)
                 goto err_map;
         }
 
-        /* output clock number per PLL */
-        clocks_per_pll = count;
-
-        subclks = kzalloc(sizeof(struct clk *) * count, GFP_KERNEL);
-        if (!subclks) {
-                pr_err("%s: could not allocate subclks\n", __func__);
+        subclks = kcalloc(count, sizeof(struct clk *), GFP_KERNEL);
+        if (!subclks)
                 goto err_map;
-        }
 
-        onecell_data = kzalloc(sizeof(struct clk_onecell_data), GFP_KERNEL);
-        if (!onecell_data) {
-                pr_err("%s: could not allocate onecell_data\n", __func__);
+        onecell_data = kmalloc(sizeof(*onecell_data), GFP_KERNEL);
+        if (!onecell_data)
                 goto err_clks;
-        }
 
         for (i = 0; i < count; i++) {
                 rc = of_property_read_string_index(np, "clock-output-names",
-                                i, &clk_name);
+                                                   i, &clk_name);
                 if (rc) {
                         pr_err("%s: could not get clock names\n", np->name);
                         goto err_cell;
@@ -230,7 +234,7 @@ static void __init core_pll_init(struct device_node *np)
         rc = of_clk_add_provider(np, of_clk_src_onecell_get, onecell_data);
         if (rc) {
                 pr_err("Could not register clk provider for node:%s\n",
-                         np->name);
+                       np->name);
                 goto err_cell;
         }
 
@@ -252,7 +256,7 @@ static void __init sysclk_init(struct device_node *node)
         u32 rate;
 
         if (!np) {
-                pr_err("ppc-clk: could not get parent node\n");
+                pr_err("could not get parent node\n");
                 return;
         }
 
@@ -268,39 +272,91 @@ static void __init sysclk_init(struct device_node *node)
                 of_clk_add_provider(np, of_clk_src_simple_get, clk);
 }
 
-static const struct of_device_id clk_match[] __initconst = {
-        { .compatible = "fsl,qoriq-sysclk-1.0", .data = sysclk_init, },
-        { .compatible = "fsl,qoriq-sysclk-2.0", .data = sysclk_init, },
-        { .compatible = "fsl,qoriq-core-pll-1.0", .data = core_pll_init, },
-        { .compatible = "fsl,qoriq-core-pll-2.0", .data = core_pll_init, },
-        { .compatible = "fsl,qoriq-core-mux-1.0", .data = core_mux_init, },
-        { .compatible = "fsl,qoriq-core-mux-2.0", .data = core_mux_init, },
-        {}
-};
-
-static int __init ppc_corenet_clk_probe(struct platform_device *pdev)
+static void __init pltfrm_pll_init(struct device_node *np)
 {
-        of_clk_init(clk_match);
+        void __iomem *base;
+        uint32_t mult;
+        const char *parent_name, *clk_name;
+        int i, _errno;
+        struct clk_onecell_data *cod;
 
-        return 0;
-}
+        base = of_iomap(np, 0);
+        if (!base) {
+                pr_err("%s(): %s: of_iomap() failed\n", __func__, np->name);
+                return;
+        }
 
-static const struct of_device_id ppc_clk_ids[] __initconst = {
-        { .compatible = "fsl,qoriq-clockgen-1.0", },
-        { .compatible = "fsl,qoriq-clockgen-2.0", },
-        {}
-};
+        /* Get the multiple of PLL */
+        mult = ioread32be(base);
 
-static struct platform_driver ppc_corenet_clk_driver = {
-        .driver = {
-                .name = "ppc_corenet_clock",
-                .of_match_table = ppc_clk_ids,
-        },
-        .probe = ppc_corenet_clk_probe,
-};
+        iounmap(base);
 
-static int __init ppc_corenet_clk_init(void)
-{
-        return platform_driver_register(&ppc_corenet_clk_driver);
+        /* Check if this PLL is disabled */
+        if (mult & PLL_KILL) {
+                pr_debug("%s(): %s: Disabled\n", __func__, np->name);
+                return;
+        }
+        mult = (mult & GENMASK(6, 1)) >> 1;
+
+        parent_name = of_clk_get_parent_name(np, 0);
+        if (!parent_name) {
+                pr_err("%s(): %s: of_clk_get_parent_name() failed\n",
+                       __func__, np->name);
+                return;
+        }
+
+        i = of_property_count_strings(np, "clock-output-names");
+        if (i < 0) {
+                pr_err("%s(): %s: of_property_count_strings(clock-output-names) = %d\n",
+                       __func__, np->name, i);
+                return;
+        }
+
+        cod = kmalloc(sizeof(*cod) + i * sizeof(struct clk *), GFP_KERNEL);
+        if (!cod)
+                return;
+        cod->clks = (struct clk **)(cod + 1);
+        cod->clk_num = i;
+
+        for (i = 0; i < cod->clk_num; i++) {
+                _errno = of_property_read_string_index(np, "clock-output-names",
+                                                       i, &clk_name);
+                if (_errno < 0) {
+                        pr_err("%s(): %s: of_property_read_string_index(clock-output-names) = %d\n",
+                               __func__, np->name, _errno);
+                        goto return_clk_unregister;
+                }
+
+                cod->clks[i] = clk_register_fixed_factor(NULL, clk_name,
+                                               parent_name, 0, mult, 1 + i);
+                if (IS_ERR(cod->clks[i])) {
+                        pr_err("%s(): %s: clk_register_fixed_factor(%s) = %ld\n",
+                               __func__, np->name,
+                               clk_name, PTR_ERR(cod->clks[i]));
+                        goto return_clk_unregister;
+                }
+        }
+
+        _errno = of_clk_add_provider(np, of_clk_src_onecell_get, cod);
+        if (_errno < 0) {
+                pr_err("%s(): %s: of_clk_add_provider() = %d\n",
+                       __func__, np->name, _errno);
+                goto return_clk_unregister;
+        }
+
+        return;
+
+return_clk_unregister:
+        while (--i >= 0)
+                clk_unregister(cod->clks[i]);
+        kfree(cod);
 }
-subsys_initcall(ppc_corenet_clk_init);
+
+CLK_OF_DECLARE(qoriq_sysclk_1, "fsl,qoriq-sysclk-1.0", sysclk_init);
+CLK_OF_DECLARE(qoriq_sysclk_2, "fsl,qoriq-sysclk-2.0", sysclk_init);
+CLK_OF_DECLARE(qoriq_core_pll_1, "fsl,qoriq-core-pll-1.0", core_pll_init);
+CLK_OF_DECLARE(qoriq_core_pll_2, "fsl,qoriq-core-pll-2.0", core_pll_init);
+CLK_OF_DECLARE(qoriq_core_mux_1, "fsl,qoriq-core-mux-1.0", core_mux_init);
+CLK_OF_DECLARE(qoriq_core_mux_2, "fsl,qoriq-core-mux-2.0", core_mux_init);
+CLK_OF_DECLARE(qoriq_pltfrm_pll_1, "fsl,qoriq-platform-pll-1.0", pltfrm_pll_init);
+CLK_OF_DECLARE(qoriq_pltfrm_pll_2, "fsl,qoriq-platform-pll-2.0", pltfrm_pll_init);
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 642cf37124d3..eb0152961d3c 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -9,7 +9,7 @@
  * Standard functionality for the common clock API.  See Documentation/clk.txt
  */
 
-#include <linux/clk-private.h>
+#include <linux/clk-provider.h>
 #include <linux/clk/clk-conf.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
@@ -37,6 +37,55 @@ static HLIST_HEAD(clk_root_list);
 static HLIST_HEAD(clk_orphan_list);
 static LIST_HEAD(clk_notifier_list);
 
+static long clk_core_get_accuracy(struct clk_core *clk);
+static unsigned long clk_core_get_rate(struct clk_core *clk);
+static int clk_core_get_phase(struct clk_core *clk);
+static bool clk_core_is_prepared(struct clk_core *clk);
+static bool clk_core_is_enabled(struct clk_core *clk);
+static struct clk_core *clk_core_lookup(const char *name);
+
+/***    private data structures    ***/
+
+struct clk_core {
+        const char              *name;
+        const struct clk_ops    *ops;
+        struct clk_hw           *hw;
+        struct module           *owner;
+        struct clk_core         *parent;
+        const char              **parent_names;
+        struct clk_core         **parents;
+        u8                      num_parents;
+        u8                      new_parent_index;
+        unsigned long           rate;
+        unsigned long           req_rate;
+        unsigned long           new_rate;
+        struct clk_core         *new_parent;
+        struct clk_core         *new_child;
+        unsigned long           flags;
+        unsigned int            enable_count;
+        unsigned int            prepare_count;
+        unsigned long           accuracy;
+        int                     phase;
+        struct hlist_head       children;
+        struct hlist_node       child_node;
+        struct hlist_node       debug_node;
+        struct hlist_head       clks;
+        unsigned int            notifier_count;
+#ifdef CONFIG_DEBUG_FS
+        struct dentry           *dentry;
+#endif
+        struct kref             ref;
+};
+
+struct clk {
+        struct clk_core *core;
+        const char *dev_id;
+        const char *con_id;
+        unsigned long min_rate;
+        unsigned long max_rate;
+        struct hlist_node child_node;
+};
+
 /***           locking             ***/
 static void clk_prepare_lock(void)
 {
@@ -114,7 +163,8 @@ static struct hlist_head *orphan_list[] = {
         NULL,
 };
 
-static void clk_summary_show_one(struct seq_file *s, struct clk *c, int level)
+static void clk_summary_show_one(struct seq_file *s, struct clk_core *c,
+                                 int level)
 {
         if (!c)
                 return;
@@ -122,14 +172,14 @@ static void clk_summary_show_one(struct seq_file *s, struct clk *c, int level)
         seq_printf(s, "%*s%-*s %11d %12d %11lu %10lu %-3d\n",
                    level * 3 + 1, "",
                    30 - level * 3, c->name,
-                   c->enable_count, c->prepare_count, clk_get_rate(c),
-                   clk_get_accuracy(c), clk_get_phase(c));
+                   c->enable_count, c->prepare_count, clk_core_get_rate(c),
+                   clk_core_get_accuracy(c), clk_core_get_phase(c));
 }
 
-static void clk_summary_show_subtree(struct seq_file *s, struct clk *c,
+static void clk_summary_show_subtree(struct seq_file *s, struct clk_core *c,
                                      int level)
 {
-        struct clk *child;
+        struct clk_core *child;
 
         if (!c)
                 return;
@@ -142,7 +192,7 @@ static void clk_summary_show_subtree(struct seq_file *s, struct clk *c,
 
 static int clk_summary_show(struct seq_file *s, void *data)
 {
-        struct clk *c;
+        struct clk_core *c;
         struct hlist_head **lists = (struct hlist_head **)s->private;
 
         seq_puts(s, "   clock                         enable_cnt  prepare_cnt        rate   accuracy   phase\n");
@@ -172,7 +222,7 @@ static const struct file_operations clk_summary_fops = {
         .release        = single_release,
 };
 
-static void clk_dump_one(struct seq_file *s, struct clk *c, int level)
+static void clk_dump_one(struct seq_file *s, struct clk_core *c, int level)
 {
         if (!c)
                 return;
@@ -180,14 +230,14 @@ static void clk_dump_one(struct seq_file *s, struct clk *c, int level)
         seq_printf(s, "\"%s\": { ", c->name);
         seq_printf(s, "\"enable_count\": %d,", c->enable_count);
         seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
-        seq_printf(s, "\"rate\": %lu", clk_get_rate(c));
-        seq_printf(s, "\"accuracy\": %lu", clk_get_accuracy(c));
-        seq_printf(s, "\"phase\": %d", clk_get_phase(c));
+        seq_printf(s, "\"rate\": %lu", clk_core_get_rate(c));
+        seq_printf(s, "\"accuracy\": %lu", clk_core_get_accuracy(c));
+        seq_printf(s, "\"phase\": %d", clk_core_get_phase(c));
 }
 
-static void clk_dump_subtree(struct seq_file *s, struct clk *c, int level)
+static void clk_dump_subtree(struct seq_file *s, struct clk_core *c, int level)
 {
-        struct clk *child;
+        struct clk_core *child;
 
         if (!c)
                 return;
@@ -204,7 +254,7 @@ static void clk_dump_subtree(struct seq_file *s, struct clk *c, int level)
 
 static int clk_dump(struct seq_file *s, void *data)
 {
-        struct clk *c;
+        struct clk_core *c;
         bool first_node = true;
         struct hlist_head **lists = (struct hlist_head **)s->private;
 
@@ -240,7 +290,7 @@ static const struct file_operations clk_dump_fops = {
         .release        = single_release,
 };
 
-static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry)
+static int clk_debug_create_one(struct clk_core *clk, struct dentry *pdentry)
 {
         struct dentry *d;
         int ret = -ENOMEM;
@@ -315,7 +365,7 @@ out:
  * initialized.  Otherwise it bails out early since the debugfs clk tree
  * will be created lazily by clk_debug_init as part of a late_initcall.
  */
-static int clk_debug_register(struct clk *clk)
+static int clk_debug_register(struct clk_core *clk)
 {
         int ret = 0;
 
@@ -340,16 +390,12 @@ unlock:
  * debugfs clk tree if clk->dentry points to debugfs created by
  * clk_debug_register in __clk_init.
  */
-static void clk_debug_unregister(struct clk *clk)
+static void clk_debug_unregister(struct clk_core *clk)
 {
         mutex_lock(&clk_debug_lock);
-        if (!clk->dentry)
-                goto out;
-
         hlist_del_init(&clk->debug_node);
         debugfs_remove_recursive(clk->dentry);
         clk->dentry = NULL;
-out:
         mutex_unlock(&clk_debug_lock);
 }
 
@@ -358,8 +404,9 @@ struct dentry *clk_debugfs_add_file(struct clk_hw *hw, char *name, umode_t mode,
 {
         struct dentry *d = NULL;
 
-        if (hw->clk->dentry)
-                d = debugfs_create_file(name, mode, hw->clk->dentry, data, fops);
+        if (hw->core->dentry)
+                d = debugfs_create_file(name, mode, hw->core->dentry, data,
+                                        fops);
 
         return d;
 }
@@ -379,7 +426,7 @@ EXPORT_SYMBOL_GPL(clk_debugfs_add_file);
  */
 static int __init clk_debug_init(void)
 {
-        struct clk *clk;
+        struct clk_core *clk;
         struct dentry *d;
 
         rootdir = debugfs_create_dir("clk", NULL);
@@ -418,22 +465,20 @@ static int __init clk_debug_init(void)
 }
 late_initcall(clk_debug_init);
 #else
-static inline int clk_debug_register(struct clk *clk) { return 0; }
-static inline void clk_debug_reparent(struct clk *clk, struct clk *new_parent)
+static inline int clk_debug_register(struct clk_core *clk) { return 0; }
+static inline void clk_debug_reparent(struct clk_core *clk,
+                                      struct clk_core *new_parent)
 {
 }
-static inline void clk_debug_unregister(struct clk *clk)
+static inline void clk_debug_unregister(struct clk_core *clk)
 {
 }
 #endif
 
 /* caller must hold prepare_lock */
-static void clk_unprepare_unused_subtree(struct clk *clk)
+static void clk_unprepare_unused_subtree(struct clk_core *clk)
 {
-        struct clk *child;
-
-        if (!clk)
-                return;
+        struct clk_core *child;
 
         hlist_for_each_entry(child, &clk->children, child_node)
                 clk_unprepare_unused_subtree(child);
@@ -444,7 +489,7 @@ static void clk_unprepare_unused_subtree(struct clk *clk)
         if (clk->flags & CLK_IGNORE_UNUSED)
                 return;
 
-        if (__clk_is_prepared(clk)) {
+        if (clk_core_is_prepared(clk)) {
                 if (clk->ops->unprepare_unused)
                         clk->ops->unprepare_unused(clk->hw);
                 else if (clk->ops->unprepare)
@@ -453,14 +498,11 @@ static void clk_unprepare_unused_subtree(struct clk *clk)
 }
 
 /* caller must hold prepare_lock */
-static void clk_disable_unused_subtree(struct clk *clk)
+static void clk_disable_unused_subtree(struct clk_core *clk)
 {
-        struct clk *child;
+        struct clk_core *child;
         unsigned long flags;
 
-        if (!clk)
-                goto out;
-
         hlist_for_each_entry(child, &clk->children, child_node)
                 clk_disable_unused_subtree(child);
 
@@ -477,7 +519,7 @@ static void clk_disable_unused_subtree(struct clk *clk)
          * sequence.  call .disable_unused if available, otherwise fall
          * back to .disable
          */
-        if (__clk_is_enabled(clk)) {
+        if (clk_core_is_enabled(clk)) {
                 if (clk->ops->disable_unused)
                         clk->ops->disable_unused(clk->hw);
                 else if (clk->ops->disable)
@@ -486,9 +528,6 @@ static void clk_disable_unused_subtree(struct clk *clk)
 
 unlock_out:
         clk_enable_unlock(flags);
-
-out:
-        return;
 }
 
 static bool clk_ignore_unused;
@@ -501,7 +540,7 @@ __setup("clk_ignore_unused", clk_ignore_unused_setup);
 
 static int clk_disable_unused(void)
 {
-        struct clk *clk;
+        struct clk_core *clk;
 
         if (clk_ignore_unused) {
                 pr_warn("clk: Not disabling unused clocks\n");
@@ -532,48 +571,65 @@ late_initcall_sync(clk_disable_unused);
 
 const char *__clk_get_name(struct clk *clk)
 {
-        return !clk ? NULL : clk->name;
+        return !clk ? NULL : clk->core->name;
 }
 EXPORT_SYMBOL_GPL(__clk_get_name);
 
 struct clk_hw *__clk_get_hw(struct clk *clk)
 {
-        return !clk ? NULL : clk->hw;
+        return !clk ? NULL : clk->core->hw;
 }
 EXPORT_SYMBOL_GPL(__clk_get_hw);
 
 u8 __clk_get_num_parents(struct clk *clk)
 {
-        return !clk ? 0 : clk->num_parents;
+        return !clk ? 0 : clk->core->num_parents;
 }
 EXPORT_SYMBOL_GPL(__clk_get_num_parents);
 
 struct clk *__clk_get_parent(struct clk *clk)
 {
-        return !clk ? NULL : clk->parent;
+        if (!clk)
+                return NULL;
+
+        /* TODO: Create a per-user clk and change callers to call clk_put */
+        return !clk->core->parent ? NULL : clk->core->parent->hw->clk;
 }
 EXPORT_SYMBOL_GPL(__clk_get_parent);
 
-struct clk *clk_get_parent_by_index(struct clk *clk, u8 index)
+static struct clk_core *clk_core_get_parent_by_index(struct clk_core *clk,
+                                                         u8 index)
 {
         if (!clk || index >= clk->num_parents)
                 return NULL;
         else if (!clk->parents)
-                return __clk_lookup(clk->parent_names[index]);
+                return clk_core_lookup(clk->parent_names[index]);
         else if (!clk->parents[index])
                 return clk->parents[index] =
-                        __clk_lookup(clk->parent_names[index]);
+                        clk_core_lookup(clk->parent_names[index]);
         else
                 return clk->parents[index];
 }
+
+struct clk *clk_get_parent_by_index(struct clk *clk, u8 index)
+{
+        struct clk_core *parent;
+
+        if (!clk)
+                return NULL;
+
+        parent = clk_core_get_parent_by_index(clk->core, index);
+
+        return !parent ? NULL : parent->hw->clk;
+}
 EXPORT_SYMBOL_GPL(clk_get_parent_by_index);
 
 unsigned int __clk_get_enable_count(struct clk *clk)
 {
-        return !clk ? 0 : clk->enable_count;
+        return !clk ? 0 : clk->core->enable_count;
 }
 
-unsigned long __clk_get_rate(struct clk *clk)
+static unsigned long clk_core_get_rate_nolock(struct clk_core *clk)
 {
         unsigned long ret;
 
@@ -593,9 +649,17 @@ unsigned long __clk_get_rate(struct clk *clk)
 out:
         return ret;
 }
+
+unsigned long __clk_get_rate(struct clk *clk)
+{
+        if (!clk)
+                return 0;
+
+        return clk_core_get_rate_nolock(clk->core);
+}
 EXPORT_SYMBOL_GPL(__clk_get_rate);
 
-static unsigned long __clk_get_accuracy(struct clk *clk)
+static unsigned long __clk_get_accuracy(struct clk_core *clk)
 {
         if (!clk)
                 return 0;
@@ -605,11 +669,11 @@ static unsigned long __clk_get_accuracy(struct clk *clk)
 
 unsigned long __clk_get_flags(struct clk *clk)
 {
-        return !clk ? 0 : clk->flags;
+        return !clk ? 0 : clk->core->flags;
 }
 EXPORT_SYMBOL_GPL(__clk_get_flags);
 
-bool __clk_is_prepared(struct clk *clk)
+static bool clk_core_is_prepared(struct clk_core *clk)
 {
         int ret;
 
@@ -630,7 +694,15 @@ out:
         return !!ret;
 }
 
-bool __clk_is_enabled(struct clk *clk)
+bool __clk_is_prepared(struct clk *clk)
+{
+        if (!clk)
+                return false;
+
+        return clk_core_is_prepared(clk->core);
+}
+
+static bool clk_core_is_enabled(struct clk_core *clk)
 {
         int ret;
 
@@ -650,12 +722,21 @@ bool __clk_is_enabled(struct clk *clk)
 out:
         return !!ret;
 }
+
+bool __clk_is_enabled(struct clk *clk)
+{
+        if (!clk)
+                return false;
+
+        return clk_core_is_enabled(clk->core);
+}
 EXPORT_SYMBOL_GPL(__clk_is_enabled);
 
-static struct clk *__clk_lookup_subtree(const char *name, struct clk *clk)
+static struct clk_core *__clk_lookup_subtree(const char *name,
+                                             struct clk_core *clk)
 {
-        struct clk *child;
-        struct clk *ret;
+        struct clk_core *child;
+        struct clk_core *ret;
 
         if (!strcmp(clk->name, name))
                 return clk;
@@ -669,10 +750,10 @@ static struct clk *__clk_lookup_subtree(const char *name, struct clk *clk)
         return NULL;
 }
 
-struct clk *__clk_lookup(const char *name)
+static struct clk_core *clk_core_lookup(const char *name)
 {
-        struct clk *root_clk;
-        struct clk *ret;
+        struct clk_core *root_clk;
+        struct clk_core *ret;
 
         if (!name)
                 return NULL;
@@ -694,42 +775,53 @@ struct clk *__clk_lookup(const char *name)
         return NULL;
 }
 
-/*
- * Helper for finding best parent to provide a given frequency. This can be used
- * directly as a determine_rate callback (e.g. for a mux), or from a more
- * complex clock that may combine a mux with other operations.
- */
-long __clk_mux_determine_rate(struct clk_hw *hw, unsigned long rate,
-                              unsigned long *best_parent_rate,
-                              struct clk_hw **best_parent_p)
+static bool mux_is_better_rate(unsigned long rate, unsigned long now,
+                           unsigned long best, unsigned long flags)
 {
-        struct clk *clk = hw->clk, *parent, *best_parent = NULL;
+        if (flags & CLK_MUX_ROUND_CLOSEST)
+                return abs(now - rate) < abs(best - rate);
+
+        return now <= rate && now > best;
+}
+
+static long
+clk_mux_determine_rate_flags(struct clk_hw *hw, unsigned long rate,
+                             unsigned long min_rate,
+                             unsigned long max_rate,
+                             unsigned long *best_parent_rate,
+                             struct clk_hw **best_parent_p,
+                             unsigned long flags)
+{
+        struct clk_core *core = hw->core, *parent, *best_parent = NULL;
         int i, num_parents;
         unsigned long parent_rate, best = 0;
 
         /* if NO_REPARENT flag set, pass through to current parent */
-        if (clk->flags & CLK_SET_RATE_NO_REPARENT) {
-                parent = clk->parent;
-                if (clk->flags & CLK_SET_RATE_PARENT)
-                        best = __clk_round_rate(parent, rate);
+        if (core->flags & CLK_SET_RATE_NO_REPARENT) {
+                parent = core->parent;
+                if (core->flags & CLK_SET_RATE_PARENT)
+                        best = __clk_determine_rate(parent ? parent->hw : NULL,
+                                                    rate, min_rate, max_rate);
                 else if (parent)
-                        best = __clk_get_rate(parent);
+                        best = clk_core_get_rate_nolock(parent);
                 else
-                        best = __clk_get_rate(clk);
+                        best = clk_core_get_rate_nolock(core);
                 goto out;
         }
 
         /* find the parent that can provide the fastest rate <= rate */
-        num_parents = clk->num_parents;
+        num_parents = core->num_parents;
         for (i = 0; i < num_parents; i++) {
-                parent = clk_get_parent_by_index(clk, i);
+                parent = clk_core_get_parent_by_index(core, i);
                 if (!parent)
                         continue;
-                if (clk->flags & CLK_SET_RATE_PARENT)
-                        parent_rate = __clk_round_rate(parent, rate);
+                if (core->flags & CLK_SET_RATE_PARENT)
+                        parent_rate = __clk_determine_rate(parent->hw, rate,
+                                                           min_rate,
+                                                           max_rate);
                 else
-                        parent_rate = __clk_get_rate(parent);
-                if (parent_rate <= rate && parent_rate > best) {
+                        parent_rate = clk_core_get_rate_nolock(parent);
+                if (mux_is_better_rate(rate, parent_rate, best, flags)) {
                         best_parent = parent;
                         best = parent_rate;
                 }
@@ -742,11 +834,63 @@ out:
 
         return best;
 }
+
+struct clk *__clk_lookup(const char *name)
+{
+        struct clk_core *core = clk_core_lookup(name);
+
+        return !core ? NULL : core->hw->clk;
+}
+
+static void clk_core_get_boundaries(struct clk_core *clk,
+                                    unsigned long *min_rate,
+                                    unsigned long *max_rate)
+{
+        struct clk *clk_user;
+
+        *min_rate = 0;
+        *max_rate = ULONG_MAX;
+
+        hlist_for_each_entry(clk_user, &clk->clks, child_node)
+                *min_rate = max(*min_rate, clk_user->min_rate);
+
+        hlist_for_each_entry(clk_user, &clk->clks, child_node)
+                *max_rate = min(*max_rate, clk_user->max_rate);
+}
+
+/*
+ * Helper for finding best parent to provide a given frequency. This can be used
+ * directly as a determine_rate callback (e.g. for a mux), or from a more
+ * complex clock that may combine a mux with other operations.
+ */
+long __clk_mux_determine_rate(struct clk_hw *hw, unsigned long rate,
+                              unsigned long min_rate,
+                              unsigned long max_rate,
+                              unsigned long *best_parent_rate,
+                              struct clk_hw **best_parent_p)
+{
+        return clk_mux_determine_rate_flags(hw, rate, min_rate, max_rate,
+                                            best_parent_rate,
+                                            best_parent_p, 0);
+}
 EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
 
+long __clk_mux_determine_rate_closest(struct clk_hw *hw, unsigned long rate,
+                              unsigned long min_rate,
+                              unsigned long max_rate,
+                              unsigned long *best_parent_rate,
+                              struct clk_hw **best_parent_p)
+{
+        return clk_mux_determine_rate_flags(hw, rate, min_rate, max_rate,
+                                            best_parent_rate,
+                                            best_parent_p,
+                                            CLK_MUX_ROUND_CLOSEST);
+}
+EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest);
+
 /***        clk api        ***/
 
-void __clk_unprepare(struct clk *clk)
+static void clk_core_unprepare(struct clk_core *clk)
 {
         if (!clk)
                 return;
@@ -762,7 +906,7 @@ void __clk_unprepare(struct clk *clk)
         if (clk->ops->unprepare)
                 clk->ops->unprepare(clk->hw);
 
-        __clk_unprepare(clk->parent);
+        clk_core_unprepare(clk->parent);
 }
 
 /**
@@ -782,12 +926,12 @@ void clk_unprepare(struct clk *clk)
                 return;
 
         clk_prepare_lock();
-        __clk_unprepare(clk);
+        clk_core_unprepare(clk->core);
         clk_prepare_unlock();
 }
 EXPORT_SYMBOL_GPL(clk_unprepare);
 
-int __clk_prepare(struct clk *clk)
+static int clk_core_prepare(struct clk_core *clk)
 {
         int ret = 0;
 
@@ -795,14 +939,14 @@ int __clk_prepare(struct clk *clk)
                 return 0;
 
         if (clk->prepare_count == 0) {
-                ret = __clk_prepare(clk->parent);
+                ret = clk_core_prepare(clk->parent);
                 if (ret)
                         return ret;
 
                 if (clk->ops->prepare) {
                         ret = clk->ops->prepare(clk->hw);
                         if (ret) {
-                                __clk_unprepare(clk->parent);
+                                clk_core_unprepare(clk->parent);
                                 return ret;
                         }
                 }
@@ -829,15 +973,18 @@ int clk_prepare(struct clk *clk)
 {
         int ret;
 
+        if (!clk)
+                return 0;
+
         clk_prepare_lock();
-        ret = __clk_prepare(clk);
+        ret = clk_core_prepare(clk->core);
         clk_prepare_unlock();
 
         return ret;
 }
 EXPORT_SYMBOL_GPL(clk_prepare);
 
-static void __clk_disable(struct clk *clk)
+static void clk_core_disable(struct clk_core *clk)
 {
         if (!clk)
                 return;
@@ -851,7 +998,15 @@ static void __clk_disable(struct clk *clk)
         if (clk->ops->disable)
                 clk->ops->disable(clk->hw);
 
-        __clk_disable(clk->parent);
+        clk_core_disable(clk->parent);
+}
+
+static void __clk_disable(struct clk *clk)
+{
+        if (!clk)
+                return;
+
+        clk_core_disable(clk->core);
 }
 
 /**
@@ -879,7 +1034,7 @@ void clk_disable(struct clk *clk)
 }
 EXPORT_SYMBOL_GPL(clk_disable);
 
-static int __clk_enable(struct clk *clk)
+static int clk_core_enable(struct clk_core *clk)
 {
         int ret = 0;
 
@@ -890,7 +1045,7 @@ static int __clk_enable(struct clk *clk)
                 return -ESHUTDOWN;
 
         if (clk->enable_count == 0) {
-                ret = __clk_enable(clk->parent);
+                ret = clk_core_enable(clk->parent);
 
                 if (ret)
                         return ret;
@@ -898,7 +1053,7 @@ static int __clk_enable(struct clk *clk)
                 if (clk->ops->enable) {
                         ret = clk->ops->enable(clk->hw);
                         if (ret) {
-                                __clk_disable(clk->parent);
+                                clk_core_disable(clk->parent);
                                 return ret;
                         }
                 }
@@ -908,6 +1063,14 @@ static int __clk_enable(struct clk *clk)
         return 0;
 }
 
+static int __clk_enable(struct clk *clk)
+{
+        if (!clk)
+                return 0;
+
+        return clk_core_enable(clk->core);
+}
+
 /**
  * clk_enable - ungate a clock
  * @clk: the clk being ungated
@@ -934,17 +1097,13 @@ int clk_enable(struct clk *clk)
 }
 EXPORT_SYMBOL_GPL(clk_enable);
 
-/**
- * __clk_round_rate - round the given rate for a clk
- * @clk: round the rate of this clock
- * @rate: the rate which is to be rounded
- *
- * Caller must hold prepare_lock.  Useful for clk_ops such as .set_rate
- */
-unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)
+static unsigned long clk_core_round_rate_nolock(struct clk_core *clk,
+                                                unsigned long rate,
+                                                unsigned long min_rate,
+                                                unsigned long max_rate)
 {
         unsigned long parent_rate = 0;
-        struct clk *parent;
+        struct clk_core *parent;
         struct clk_hw *parent_hw;
 
         if (!clk)
@@ -956,15 +1115,59 @@ unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)
 
         if (clk->ops->determine_rate) {
                 parent_hw = parent ? parent->hw : NULL;
-                return clk->ops->determine_rate(clk->hw, rate, &parent_rate,
-                                                &parent_hw);
+                return clk->ops->determine_rate(clk->hw, rate,
+                                                min_rate, max_rate,
+                                                &parent_rate, &parent_hw);
         } else if (clk->ops->round_rate)
                 return clk->ops->round_rate(clk->hw, rate, &parent_rate);
         else if (clk->flags & CLK_SET_RATE_PARENT)
-                return __clk_round_rate(clk->parent, rate);
+                return clk_core_round_rate_nolock(clk->parent, rate, min_rate,
+                                                  max_rate);
         else
                 return clk->rate;
 }
+
+/**
+ * __clk_determine_rate - get the closest rate actually supported by a clock
+ * @hw: determine the rate of this clock
+ * @rate: target rate
+ * @min_rate: returned rate must be greater than this rate
+ * @max_rate: returned rate must be less than this rate
+ *
+ * Caller must hold prepare_lock.  Useful for clk_ops such as .set_rate and
+ * .determine_rate.
+ */
+unsigned long __clk_determine_rate(struct clk_hw *hw,
+                                   unsigned long rate,
+                                   unsigned long min_rate,
+                                   unsigned long max_rate)
+{
+        if (!hw)
+                return 0;
+
+        return clk_core_round_rate_nolock(hw->core, rate, min_rate, max_rate);
+}
+EXPORT_SYMBOL_GPL(__clk_determine_rate);
+
+/**
+ * __clk_round_rate - round the given rate for a clk
+ * @clk: round the rate of this clock
+ * @rate: the rate which is to be rounded
+ *
+ * Caller must hold prepare_lock.  Useful for clk_ops such as .set_rate
+ */
+unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)
+{
+        unsigned long min_rate;
+        unsigned long max_rate;
+
+        if (!clk)
+                return 0;
+
+        clk_core_get_boundaries(clk->core, &min_rate, &max_rate);
+
+        return clk_core_round_rate_nolock(clk->core, rate, min_rate, max_rate);
+}
 EXPORT_SYMBOL_GPL(__clk_round_rate);
 
 /**
@@ -980,6 +1183,9 @@ long clk_round_rate(struct clk *clk, unsigned long rate)
 {
         unsigned long ret;
 
+        if (!clk)
+                return 0;
+
         clk_prepare_lock();
         ret = __clk_round_rate(clk, rate);
         clk_prepare_unlock();
@@ -1002,22 +1208,21 @@ EXPORT_SYMBOL_GPL(clk_round_rate);
  * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
  * a driver returns that.
  */
-static int __clk_notify(struct clk *clk, unsigned long msg,
+static int __clk_notify(struct clk_core *clk, unsigned long msg,
                 unsigned long old_rate, unsigned long new_rate)
 {
         struct clk_notifier *cn;
         struct clk_notifier_data cnd;
         int ret = NOTIFY_DONE;
 
-        cnd.clk = clk;
         cnd.old_rate = old_rate;
         cnd.new_rate = new_rate;
 
         list_for_each_entry(cn, &clk_notifier_list, node) {
-                if (cn->clk == clk) {
+                if (cn->clk->core == clk) {
+                        cnd.clk = cn->clk;
                         ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
                                         &cnd);
-                        break;
                 }
         }
 
@@ -1035,10 +1240,10 @@ static int __clk_notify(struct clk *clk, unsigned long msg,
  *
  * Caller must hold prepare_lock.
  */
-static void __clk_recalc_accuracies(struct clk *clk)
+static void __clk_recalc_accuracies(struct clk_core *clk)
 {
         unsigned long parent_accuracy = 0;
-        struct clk *child;
+        struct clk_core *child;
 
         if (clk->parent)
                 parent_accuracy = clk->parent->accuracy;
@@ -1053,6 +1258,20 @@ static void __clk_recalc_accuracies(struct clk *clk)
                 __clk_recalc_accuracies(child);
 }
 
+static long clk_core_get_accuracy(struct clk_core *clk)
+{
+        unsigned long accuracy;
+
+        clk_prepare_lock();
+        if (clk && (clk->flags & CLK_GET_ACCURACY_NOCACHE))
+                __clk_recalc_accuracies(clk);
+
+        accuracy = __clk_get_accuracy(clk);
+        clk_prepare_unlock();
+
+        return accuracy;
+}
+
 /**
  * clk_get_accuracy - return the accuracy of clk
  * @clk: the clk whose accuracy is being returned
@@ -1064,20 +1283,15 @@ static void __clk_recalc_accuracies(struct clk *clk)
  */
 long clk_get_accuracy(struct clk *clk)
 {
-        unsigned long accuracy;
-
-        clk_prepare_lock();
-        if (clk && (clk->flags & CLK_GET_ACCURACY_NOCACHE))
-                __clk_recalc_accuracies(clk);
-
-        accuracy = __clk_get_accuracy(clk);
-        clk_prepare_unlock();
+        if (!clk)
+                return 0;
 
-        return accuracy;
+        return clk_core_get_accuracy(clk->core);
 }
 EXPORT_SYMBOL_GPL(clk_get_accuracy);
 
-static unsigned long clk_recalc(struct clk *clk, unsigned long parent_rate)
+static unsigned long clk_recalc(struct clk_core *clk,
+                                unsigned long parent_rate)
 {
         if (clk->ops->recalc_rate)
                 return clk->ops->recalc_rate(clk->hw, parent_rate);
@@ -1098,11 +1312,11 @@ static unsigned long clk_recalc(struct clk *clk, unsigned long parent_rate)
  *
  * Caller must hold prepare_lock.
  */
-static void __clk_recalc_rates(struct clk *clk, unsigned long msg)
+static void __clk_recalc_rates(struct clk_core *clk, unsigned long msg)
 {
         unsigned long old_rate;
         unsigned long parent_rate = 0;
-        struct clk *child;
+        struct clk_core *child;
 
         old_rate = clk->rate;
 
@@ -1122,15 +1336,7 @@ static void __clk_recalc_rates(struct clk *clk, unsigned long msg)
                 __clk_recalc_rates(child, msg);
 }
 
-/**
- * clk_get_rate - return the rate of clk
- * @clk: the clk whose rate is being returned
- *
- * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
- * is set, which means a recalc_rate will be issued.
- * If clk is NULL then returns 0.
- */
-unsigned long clk_get_rate(struct clk *clk)
+static unsigned long clk_core_get_rate(struct clk_core *clk)
 {
         unsigned long rate;
 
@@ -1139,14 +1345,32 @@ unsigned long clk_get_rate(struct clk *clk)
         if (clk && (clk->flags & CLK_GET_RATE_NOCACHE))
                 __clk_recalc_rates(clk, 0);
 
-        rate = __clk_get_rate(clk);
+        rate = clk_core_get_rate_nolock(clk);
         clk_prepare_unlock();
 
         return rate;
 }
+EXPORT_SYMBOL_GPL(clk_core_get_rate);
+
+/**
+ * clk_get_rate - return the rate of clk
+ * @clk: the clk whose rate is being returned
+ *
+ * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
+ * is set, which means a recalc_rate will be issued.
+ * If clk is NULL then returns 0.
+ */
+unsigned long clk_get_rate(struct clk *clk)
+{
+        if (!clk)
+                return 0;
+
+        return clk_core_get_rate(clk->core);
+}
 EXPORT_SYMBOL_GPL(clk_get_rate);
 
-static int clk_fetch_parent_index(struct clk *clk, struct clk *parent)
+static int clk_fetch_parent_index(struct clk_core *clk,
+                                  struct clk_core *parent)
 {
         int i;
 
@@ -1160,7 +1384,7 @@ static int clk_fetch_parent_index(struct clk *clk, struct clk *parent)
         /*
          * find index of new parent clock using cached parent ptrs,
          * or if not yet cached, use string name comparison and cache
-         * them now to avoid future calls to __clk_lookup.
+         * them now to avoid future calls to clk_core_lookup.
          */
         for (i = 0; i < clk->num_parents; i++) {
                 if (clk->parents[i] == parent)
@@ -1170,7 +1394,7 @@ static int clk_fetch_parent_index(struct clk *clk, struct clk *parent)
                         continue;
 
                 if (!strcmp(clk->parent_names[i], parent->name)) {
-                        clk->parents[i] = __clk_lookup(parent->name);
+                        clk->parents[i] = clk_core_lookup(parent->name);
                         return i;
                 }
         }
@@ -1178,7 +1402,7 @@ static int clk_fetch_parent_index(struct clk *clk, struct clk *parent)
         return -EINVAL;
 }
 
-static void clk_reparent(struct clk *clk, struct clk *new_parent)
+static void clk_reparent(struct clk_core *clk, struct clk_core *new_parent)
 {
         hlist_del(&clk->child_node);
 
@@ -1195,10 +1419,11 @@ static void clk_reparent(struct clk *clk, struct clk *new_parent)
         clk->parent = new_parent;
 }
 
-static struct clk *__clk_set_parent_before(struct clk *clk, struct clk *parent)
+static struct clk_core *__clk_set_parent_before(struct clk_core *clk,
+                                           struct clk_core *parent)
 {
         unsigned long flags;
-        struct clk *old_parent = clk->parent;
+        struct clk_core *old_parent = clk->parent;
 
         /*
          * Migrate prepare state between parents and prevent race with
@@ -1218,9 +1443,9 @@ static struct clk *__clk_set_parent_before(struct clk *clk, struct clk *parent)
          * See also: Comment for clk_set_parent() below.
          */
         if (clk->prepare_count) {
-                __clk_prepare(parent);
-                clk_enable(parent);
-                clk_enable(clk);
+                clk_core_prepare(parent);
+                clk_core_enable(parent);
+                clk_core_enable(clk);
         }
 
         /* update the clk tree topology */
@@ -1231,25 +1456,27 @@ static struct clk *__clk_set_parent_before(struct clk *clk, struct clk *parent)
         return old_parent;
 }
 
-static void __clk_set_parent_after(struct clk *clk, struct clk *parent,
-                struct clk *old_parent)
+static void __clk_set_parent_after(struct clk_core *core,
+                                   struct clk_core *parent,
+                                   struct clk_core *old_parent)
 {
         /*
          * Finish the migration of prepare state and undo the changes done
          * for preventing a race with clk_enable().
          */
-        if (clk->prepare_count) {
-                clk_disable(clk);
-                clk_disable(old_parent);
-                __clk_unprepare(old_parent);
+        if (core->prepare_count) {
+                clk_core_disable(core);
+                clk_core_disable(old_parent);
+                clk_core_unprepare(old_parent);
         }
 }
 
-static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
+static int __clk_set_parent(struct clk_core *clk, struct clk_core *parent,
+                            u8 p_index)
 {
         unsigned long flags;
         int ret = 0;
-        struct clk *old_parent;
+        struct clk_core *old_parent;
 
         old_parent = __clk_set_parent_before(clk, parent);
 
@@ -1263,9 +1490,9 @@ static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
                 clk_enable_unlock(flags);
 
                 if (clk->prepare_count) {
-                        clk_disable(clk);
-                        clk_disable(parent);
-                        __clk_unprepare(parent);
+                        clk_core_disable(clk);
+                        clk_core_disable(parent);
+                        clk_core_unprepare(parent);
                 }
                 return ret;
         }
@@ -1291,9 +1518,10 @@ static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
  *
  * Caller must hold prepare_lock.
  */
-static int __clk_speculate_rates(struct clk *clk, unsigned long parent_rate)
+static int __clk_speculate_rates(struct clk_core *clk,
+                                 unsigned long parent_rate)
 {
-        struct clk *child;
+        struct clk_core *child;
         unsigned long new_rate;
         int ret = NOTIFY_DONE;
 
@@ -1319,10 +1547,10 @@ out:
         return ret;
 }
 
-static void clk_calc_subtree(struct clk *clk, unsigned long new_rate,
-                             struct clk *new_parent, u8 p_index)
+static void clk_calc_subtree(struct clk_core *clk, unsigned long new_rate,
+                             struct clk_core *new_parent, u8 p_index)
 {
-        struct clk *child;
+        struct clk_core *child;
 
         clk->new_rate = new_rate;
         clk->new_parent = new_parent;
@@ -1342,13 +1570,16 @@ static void clk_calc_subtree(struct clk *clk, unsigned long new_rate,
  * calculate the new rates returning the topmost clock that has to be
  * changed.
  */
-static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate)
+static struct clk_core *clk_calc_new_rates(struct clk_core *clk,
+                                           unsigned long rate)
 {
-        struct clk *top = clk;
-        struct clk *old_parent, *parent;
+        struct clk_core *top = clk;
+        struct clk_core *old_parent, *parent;
         struct clk_hw *parent_hw;
         unsigned long best_parent_rate = 0;
         unsigned long new_rate;
+        unsigned long min_rate;
+        unsigned long max_rate;
         int p_index = 0;
 
         /* sanity */
@@ -1360,16 +1591,22 @@ static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate)
         if (parent)
                 best_parent_rate = parent->rate;
 
+        clk_core_get_boundaries(clk, &min_rate, &max_rate);
+
         /* find the closest rate and parent clk/rate */
         if (clk->ops->determine_rate) {
                 parent_hw = parent ? parent->hw : NULL;
                 new_rate = clk->ops->determine_rate(clk->hw, rate,
+                                                    min_rate,
+                                                    max_rate,
                                                     &best_parent_rate,
                                                     &parent_hw);
-                parent = parent_hw ? parent_hw->clk : NULL;
+                parent = parent_hw ? parent_hw->core : NULL;
         } else if (clk->ops->round_rate) {
                 new_rate = clk->ops->round_rate(clk->hw, rate,
                                                 &best_parent_rate);
+                if (new_rate < min_rate || new_rate > max_rate)
+                        return NULL;
         } else if (!parent || !(clk->flags & CLK_SET_RATE_PARENT)) {
                 /* pass-through clock without adjustable parent */
                 clk->new_rate = clk->rate;
@@ -1390,7 +1627,7 @@ static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate)
         }
 
         /* try finding the new parent index */
-        if (parent) {
+        if (parent && clk->num_parents > 1) {
                 p_index = clk_fetch_parent_index(clk, parent);
                 if (p_index < 0) {
                         pr_debug("%s: clk %s can not be parent of clk %s\n",
@@ -1414,9 +1651,10 @@ out:
  * so that in case of an error we can walk down the whole tree again and
  * abort the change.
  */
-static struct clk *clk_propagate_rate_change(struct clk *clk, unsigned long event)
+static struct clk_core *clk_propagate_rate_change(struct clk_core *clk,
+                                                  unsigned long event)
 {
-        struct clk *child, *tmp_clk, *fail_clk = NULL;
+        struct clk_core *child, *tmp_clk, *fail_clk = NULL;
         int ret = NOTIFY_DONE;
 
         if (clk->rate == clk->new_rate)
@@ -1451,14 +1689,14 @@ static struct clk *clk_propagate_rate_change(struct clk *clk, unsigned long even
  * walk down a subtree and set the new rates notifying the rate
  * change on the way
  */
-static void clk_change_rate(struct clk *clk)
+static void clk_change_rate(struct clk_core *clk)
 {
-        struct clk *child;
+        struct clk_core *child;
         struct hlist_node *tmp;
         unsigned long old_rate;
         unsigned long best_parent_rate = 0;
         bool skip_set_rate = false;
-        struct clk *old_parent;
+        struct clk_core *old_parent;
 
         old_rate = clk->rate;
 
@@ -1506,6 +1744,45 @@ static void clk_change_rate(struct clk *clk)
                 clk_change_rate(clk->new_child);
 }
 
+static int clk_core_set_rate_nolock(struct clk_core *clk,
+                                    unsigned long req_rate)
+{
+        struct clk_core *top, *fail_clk;
+        unsigned long rate = req_rate;
+        int ret = 0;
+
+        if (!clk)
+                return 0;
+
+        /* bail early if nothing to do */
+        if (rate == clk_core_get_rate_nolock(clk))
+                return 0;
+
+        if ((clk->flags & CLK_SET_RATE_GATE) && clk->prepare_count)
+                return -EBUSY;
+
+        /* calculate new rates and get the topmost changed clock */
+        top = clk_calc_new_rates(clk, rate);
+        if (!top)
+                return -EINVAL;
+
+        /* notify that we are about to change rates */
+        fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
+        if (fail_clk) {
+                pr_debug("%s: failed to set %s rate\n", __func__,
+                                fail_clk->name);
+                clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
+                return -EBUSY;
+        }
+
+        /* change the rates */
+        clk_change_rate(top);
+
+        clk->req_rate = req_rate;
+
+        return ret;
+}
+
 /**
  * clk_set_rate - specify a new rate for clk
  * @clk: the clk whose rate is being changed
@@ -1529,8 +1806,7 @@ static void clk_change_rate(struct clk *clk)
  */
 int clk_set_rate(struct clk *clk, unsigned long rate)
 {
-        struct clk *top, *fail_clk;
-        int ret = 0;
+        int ret;
 
         if (!clk)
                 return 0;
@@ -1538,41 +1814,81 @@ int clk_set_rate(struct clk *clk, unsigned long rate)
         /* prevent racing with updates to the clock topology */
         clk_prepare_lock();
 
-        /* bail early if nothing to do */
-        if (rate == clk_get_rate(clk))
-                goto out;
+        ret = clk_core_set_rate_nolock(clk->core, rate);
 
-        if ((clk->flags & CLK_SET_RATE_GATE) && clk->prepare_count) {
-                ret = -EBUSY;
-                goto out;
-        }
+        clk_prepare_unlock();
 
-        /* calculate new rates and get the topmost changed clock */
-        top = clk_calc_new_rates(clk, rate);
-        if (!top) {
-                ret = -EINVAL;
-                goto out;
-        }
+        return ret;
+}
+EXPORT_SYMBOL_GPL(clk_set_rate);
 
-        /* notify that we are about to change rates */
-        fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
-        if (fail_clk) {
-                pr_debug("%s: failed to set %s rate\n", __func__,
-                                fail_clk->name);
-                clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
-                ret = -EBUSY;
-                goto out;
+/**
+ * clk_set_rate_range - set a rate range for a clock source
+ * @clk: clock source
+ * @min: desired minimum clock rate in Hz, inclusive
+ * @max: desired maximum clock rate in Hz, inclusive
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max)
+{
+        int ret = 0;
+
+        if (!clk)
+                return 0;
+
+        if (min > max) {
+                pr_err("%s: clk %s dev %s con %s: invalid range [%lu, %lu]\n",
+                       __func__, clk->core->name, clk->dev_id, clk->con_id,
+                       min, max);
+                return -EINVAL;
         }
 
-        /* change the rates */
-        clk_change_rate(top);
+        clk_prepare_lock();
+
+        if (min != clk->min_rate || max != clk->max_rate) {
+                clk->min_rate = min;
+                clk->max_rate = max;
+                ret = clk_core_set_rate_nolock(clk->core, clk->core->req_rate);
+        }
 
-out:
         clk_prepare_unlock();
 
         return ret;
 }
-EXPORT_SYMBOL_GPL(clk_set_rate);
+EXPORT_SYMBOL_GPL(clk_set_rate_range);
+
+/**
+ * clk_set_min_rate - set a minimum clock rate for a clock source
+ * @clk: clock source
+ * @rate: desired minimum clock rate in Hz, inclusive
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_set_min_rate(struct clk *clk, unsigned long rate)
+{
+        if (!clk)
+                return 0;
+
+        return clk_set_rate_range(clk, rate, clk->max_rate);
+}
+EXPORT_SYMBOL_GPL(clk_set_min_rate);
+
+/**
+ * clk_set_max_rate - set a maximum clock rate for a clock source
+ * @clk: clock source
+ * @rate: desired maximum clock rate in Hz, inclusive
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_set_max_rate(struct clk *clk, unsigned long rate)
+{
+        if (!clk)
+                return 0;
+
+        return clk_set_rate_range(clk, clk->min_rate, rate);
+}
+EXPORT_SYMBOL_GPL(clk_set_max_rate);
 
 /**
  * clk_get_parent - return the parent of a clk
@@ -1599,11 +1915,11 @@ EXPORT_SYMBOL_GPL(clk_get_parent);
  *
  * For single-parent clocks without .get_parent, first check to see if the
  * .parents array exists, and if so use it to avoid an expensive tree
- * traversal.  If .parents does not exist then walk the tree with __clk_lookup.
+ * traversal.  If .parents does not exist then walk the tree.
  */
-static struct clk *__clk_init_parent(struct clk *clk)
+static struct clk_core *__clk_init_parent(struct clk_core *clk)
 {
-        struct clk *ret = NULL;
+        struct clk_core *ret = NULL;
         u8 index;
 
         /* handle the trivial cases */
@@ -1613,7 +1929,7 @@ static struct clk *__clk_init_parent(struct clk *clk)
 
         if (clk->num_parents == 1) {
                 if (IS_ERR_OR_NULL(clk->parent))
-                        clk->parent = __clk_lookup(clk->parent_names[0]);
+                        clk->parent = clk_core_lookup(clk->parent_names[0]);
                 ret = clk->parent;
                 goto out;
         }
@@ -1627,8 +1943,8 @@ static struct clk *__clk_init_parent(struct clk *clk)
 
         /*
          * Do our best to cache parent clocks in clk->parents.  This prevents
-         * unnecessary and expensive calls to __clk_lookup.  We don't set
-         * clk->parent here; that is done by the calling function
+         * unnecessary and expensive lookups.  We don't set clk->parent here;
+         * that is done by the calling function.
          */
 
         index = clk->ops->get_parent(clk->hw);
@@ -1638,13 +1954,14 @@ static struct clk *__clk_init_parent(struct clk *clk)
                         kcalloc(clk->num_parents, sizeof(struct clk *),
                                         GFP_KERNEL);
 
-        ret = clk_get_parent_by_index(clk, index);
+        ret = clk_core_get_parent_by_index(clk, index);
 
 out:
         return ret;
 }
 
-void __clk_reparent(struct clk *clk, struct clk *new_parent)
+static void clk_core_reparent(struct clk_core *clk,
+                                  struct clk_core *new_parent)
 {
         clk_reparent(clk, new_parent);
         __clk_recalc_accuracies(clk);
@@ -1652,23 +1969,40 @@ void __clk_reparent(struct clk *clk, struct clk *new_parent)
 }
 
 /**
- * clk_set_parent - switch the parent of a mux clk
- * @clk: the mux clk whose input we are switching
- * @parent: the new input to clk
+ * clk_has_parent - check if a clock is a possible parent for another
+ * @clk: clock source
+ * @parent: parent clock source
  *
- * Re-parent clk to use parent as its new input source.  If clk is in
- * prepared state, the clk will get enabled for the duration of this call. If
- * that's not acceptable for a specific clk (Eg: the consumer can't handle
- * that, the reparenting is glitchy in hardware, etc), use the
- * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
- *
- * After successfully changing clk's parent clk_set_parent will update the
- * clk topology, sysfs topology and propagate rate recalculation via
- * __clk_recalc_rates.
+ * This function can be used in drivers that need to check that a clock can be
+ * the parent of another without actually changing the parent.
  *
- * Returns 0 on success, -EERROR otherwise.
+ * Returns true if @parent is a possible parent for @clk, false otherwise.
  */
-int clk_set_parent(struct clk *clk, struct clk *parent)
+bool clk_has_parent(struct clk *clk, struct clk *parent)
+{
+        struct clk_core *core, *parent_core;
+        unsigned int i;
+
+        /* NULL clocks should be nops, so return success if either is NULL. */
+        if (!clk || !parent)
+                return true;
+
+        core = clk->core;
+        parent_core = parent->core;
+
+        /* Optimize for the case where the parent is already the parent. */
+        if (core->parent == parent_core)
+                return true;
+
+        for (i = 0; i < core->num_parents; i++)
+                if (strcmp(core->parent_names[i], parent_core->name) == 0)
+                        return true;
+
+        return false;
+}
+EXPORT_SYMBOL_GPL(clk_has_parent);
+
+static int clk_core_set_parent(struct clk_core *clk, struct clk_core *parent)
 {
         int ret = 0;
         int p_index = 0;
@@ -1728,6 +2062,31 @@ out:
 
         return ret;
 }
+
+/**
+ * clk_set_parent - switch the parent of a mux clk
+ * @clk: the mux clk whose input we are switching
+ * @parent: the new input to clk
+ *
+ * Re-parent clk to use parent as its new input source.  If clk is in
+ * prepared state, the clk will get enabled for the duration of this call. If
+ * that's not acceptable for a specific clk (Eg: the consumer can't handle
+ * that, the reparenting is glitchy in hardware, etc), use the
+ * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
+ *
+ * After successfully changing clk's parent clk_set_parent will update the
+ * clk topology, sysfs topology and propagate rate recalculation via
+ * __clk_recalc_rates.
+ *
+ * Returns 0 on success, -EERROR otherwise.
+ */
+int clk_set_parent(struct clk *clk, struct clk *parent)
+{
+        if (!clk)
+                return 0;
+
+        return clk_core_set_parent(clk->core, parent ? parent->core : NULL);
+}
 EXPORT_SYMBOL_GPL(clk_set_parent);
 
 /**
@@ -1764,13 +2123,13 @@ int clk_set_phase(struct clk *clk, int degrees)
 
         clk_prepare_lock();
 
-        if (!clk->ops->set_phase)
+        if (!clk->core->ops->set_phase)
                 goto out_unlock;
 
-        ret = clk->ops->set_phase(clk->hw, degrees);
+        ret = clk->core->ops->set_phase(clk->core->hw, degrees);
 
         if (!ret)
-                clk->phase = degrees;
+                clk->core->phase = degrees;
 
 out_unlock:
         clk_prepare_unlock();
@@ -1778,15 +2137,9 @@ out_unlock:
 out:
         return ret;
 }
+EXPORT_SYMBOL_GPL(clk_set_phase);
 
-/**
- * clk_get_phase - return the phase shift of a clock signal
- * @clk: clock signal source
- *
- * Returns the phase shift of a clock node in degrees, otherwise returns
- * -EERROR.
- */
-int clk_get_phase(struct clk *clk)
+static int clk_core_get_phase(struct clk_core *clk)
 {
         int ret = 0;
 
@@ -1800,28 +2153,48 @@ int clk_get_phase(struct clk *clk)
 out:
         return ret;
 }
+EXPORT_SYMBOL_GPL(clk_get_phase);
+
+/**
+ * clk_get_phase - return the phase shift of a clock signal
+ * @clk: clock signal source
+ *
+ * Returns the phase shift of a clock node in degrees, otherwise returns
+ * -EERROR.
+ */
+int clk_get_phase(struct clk *clk)
+{
+        if (!clk)
+                return 0;
+
+        return clk_core_get_phase(clk->core);
+}
 
 /**
  * __clk_init - initialize the data structures in a struct clk
  * @dev:        device initializing this clk, placeholder for now
  * @clk:        clk being initialized
  *
- * Initializes the lists in struct clk, queries the hardware for the
+ * Initializes the lists in struct clk_core, queries the hardware for the
  * parent and rate and sets them both.
  */
-int __clk_init(struct device *dev, struct clk *clk)
+static int __clk_init(struct device *dev, struct clk *clk_user)
 {
         int i, ret = 0;
-        struct clk *orphan;
+        struct clk_core *orphan;
         struct hlist_node *tmp2;
+        struct clk_core *clk;
+        unsigned long rate;
 
-        if (!clk)
+        if (!clk_user)
                 return -EINVAL;
 
+        clk = clk_user->core;
+
         clk_prepare_lock();
 
         /* check to see if a clock with this name is already registered */
-        if (__clk_lookup(clk->name)) {
+        if (clk_core_lookup(clk->name)) {
                 pr_debug("%s: clk %s already initialized\n",
                                 __func__, clk->name);
                 ret = -EEXIST;
@@ -1873,7 +2246,7 @@ int __clk_init(struct device *dev, struct clk *clk)
                 clk->parents = kcalloc(clk->num_parents, sizeof(struct clk *),
                                         GFP_KERNEL);
                 /*
-                 * __clk_lookup returns NULL for parents that have not been
+                 * clk_core_lookup returns NULL for parents that have not been
                  * clk_init'd; thus any access to clk->parents[] must check
                  * for a NULL pointer.  We can always perform lazy lookups for
                  * missing parents later on.
@@ -1881,7 +2254,7 @@ int __clk_init(struct device *dev, struct clk *clk)
                 if (clk->parents)
                         for (i = 0; i < clk->num_parents; i++)
                                 clk->parents[i] =
-                                        __clk_lookup(clk->parent_names[i]);
+                                        clk_core_lookup(clk->parent_names[i]);
         }
 
         clk->parent = __clk_init_parent(clk);
@@ -1936,12 +2309,13 @@ int __clk_init(struct device *dev, struct clk *clk)
          * then rate is set to zero.
          */
         if (clk->ops->recalc_rate)
-                clk->rate = clk->ops->recalc_rate(clk->hw,
-                                __clk_get_rate(clk->parent));
+                rate = clk->ops->recalc_rate(clk->hw,
+                                clk_core_get_rate_nolock(clk->parent));
         else if (clk->parent)
-                clk->rate = clk->parent->rate;
+                rate = clk->parent->rate;
         else
-                clk->rate = 0;
+                rate = 0;
+        clk->rate = clk->req_rate = rate;
 
         /*
          * walk the list of orphan clocks and reparent any that are children of
@@ -1951,13 +2325,13 @@ int __clk_init(struct device *dev, struct clk *clk)
                 if (orphan->num_parents && orphan->ops->get_parent) {
                         i = orphan->ops->get_parent(orphan->hw);
                         if (!strcmp(clk->name, orphan->parent_names[i]))
-                                __clk_reparent(orphan, clk);
+                                clk_core_reparent(orphan, clk);
                         continue;
                 }
 
                 for (i = 0; i < orphan->num_parents; i++)
                         if (!strcmp(clk->name, orphan->parent_names[i])) {
-                                __clk_reparent(orphan, clk);
+                                clk_core_reparent(orphan, clk);
                                 break;
                         }
          }
@@ -1983,47 +2357,39 @@ out:
         return ret;
 }
 
-/**
- * __clk_register - register a clock and return a cookie.
- *
- * Same as clk_register, except that the .clk field inside hw shall point to a
- * preallocated (generally statically allocated) struct clk. None of the fields
- * of the struct clk need to be initialized.
- *
- * The data pointed to by .init and .clk field shall NOT be marked as init
- * data.
- *
- * __clk_register is only exposed via clk-private.h and is intended for use with
- * very large numbers of clocks that need to be statically initialized.  It is
- * a layering violation to include clk-private.h from any code which implements
- * a clock's .ops; as such any statically initialized clock data MUST be in a
- * separate C file from the logic that implements its operations.  Returns 0
- * on success, otherwise an error code.
- */
-struct clk *__clk_register(struct device *dev, struct clk_hw *hw)
+struct clk *__clk_create_clk(struct clk_hw *hw, const char *dev_id,
+                             const char *con_id)
 {
-        int ret;
         struct clk *clk;
 
-        clk = hw->clk;
-        clk->name = hw->init->name;
-        clk->ops = hw->init->ops;
-        clk->hw = hw;
-        clk->flags = hw->init->flags;
-        clk->parent_names = hw->init->parent_names;
-        clk->num_parents = hw->init->num_parents;
-        if (dev && dev->driver)
-                clk->owner = dev->driver->owner;
-        else
-                clk->owner = NULL;
+        /* This is to allow this function to be chained to others */
+        if (!hw || IS_ERR(hw))
+                return (struct clk *) hw;
 
-        ret = __clk_init(dev, clk);
-        if (ret)
-                return ERR_PTR(ret);
+        clk = kzalloc(sizeof(*clk), GFP_KERNEL);
+        if (!clk)
+                return ERR_PTR(-ENOMEM);
+
+        clk->core = hw->core;
+        clk->dev_id = dev_id;
+        clk->con_id = con_id;
+        clk->max_rate = ULONG_MAX;
+
+        clk_prepare_lock();
+        hlist_add_head(&clk->child_node, &hw->core->clks);
+        clk_prepare_unlock();
 
         return clk;
 }
-EXPORT_SYMBOL_GPL(__clk_register);
+
+void __clk_free_clk(struct clk *clk)
+{
+        clk_prepare_lock();
+        hlist_del(&clk->child_node);
+        clk_prepare_unlock();
+
+        kfree(clk);
+}
 
 /**
  * clk_register - allocate a new clock, register it and return an opaque cookie
@@ -2039,7 +2405,7 @@ EXPORT_SYMBOL_GPL(__clk_register);
 struct clk *clk_register(struct device *dev, struct clk_hw *hw)
 {
         int i, ret;
-        struct clk *clk;
+        struct clk_core *clk;
 
         clk = kzalloc(sizeof(*clk), GFP_KERNEL);
         if (!clk) {
@@ -2060,7 +2426,7 @@ struct clk *clk_register(struct device *dev, struct clk_hw *hw)
         clk->hw = hw;
         clk->flags = hw->init->flags;
         clk->num_parents = hw->init->num_parents;
-        hw->clk = clk;
+        hw->core = clk;
 
         /* allocate local copy in case parent_names is __initdata */
         clk->parent_names = kcalloc(clk->num_parents, sizeof(char *),
@@ -2084,9 +2450,21 @@ struct clk *clk_register(struct device *dev, struct clk_hw *hw)
                 }
         }
 
-        ret = __clk_init(dev, clk);
+        INIT_HLIST_HEAD(&clk->clks);
+
+        hw->clk = __clk_create_clk(hw, NULL, NULL);
+        if (IS_ERR(hw->clk)) {
+                pr_err("%s: could not allocate per-user clk\n", __func__);
+                ret = PTR_ERR(hw->clk);
+                goto fail_parent_names_copy;
+        }
+
+        ret = __clk_init(dev, hw->clk);
         if (!ret)
-                return clk;
+                return hw->clk;
+
+        __clk_free_clk(hw->clk);
+        hw->clk = NULL;
 
 fail_parent_names_copy:
         while (--i >= 0)
@@ -2107,7 +2485,7 @@ EXPORT_SYMBOL_GPL(clk_register);
  */
 static void __clk_release(struct kref *ref)
 {
-        struct clk *clk = container_of(ref, struct clk, ref);
+        struct clk_core *clk = container_of(ref, struct clk_core, ref);
         int i = clk->num_parents;
 
         kfree(clk->parents);
@@ -2165,12 +2543,13 @@ void clk_unregister(struct clk *clk)
         if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
                 return;
 
-        clk_debug_unregister(clk);
+        clk_debug_unregister(clk->core);
 
         clk_prepare_lock();
 
-        if (clk->ops == &clk_nodrv_ops) {
-                pr_err("%s: unregistered clock: %s\n", __func__, clk->name);
+        if (clk->core->ops == &clk_nodrv_ops) {
+                pr_err("%s: unregistered clock: %s\n", __func__,
+                       clk->core->name);
                 return;
         }
         /*
@@ -2178,24 +2557,25 @@ void clk_unregister(struct clk *clk)
          * a reference to this clock.
          */
         flags = clk_enable_lock();
-        clk->ops = &clk_nodrv_ops;
+        clk->core->ops = &clk_nodrv_ops;
         clk_enable_unlock(flags);
 
-        if (!hlist_empty(&clk->children)) {
-                struct clk *child;
+        if (!hlist_empty(&clk->core->children)) {
+                struct clk_core *child;
                 struct hlist_node *t;
 
                 /* Reparent all children to the orphan list. */
-                hlist_for_each_entry_safe(child, t, &clk->children, child_node)
-                        clk_set_parent(child, NULL);
+                hlist_for_each_entry_safe(child, t, &clk->core->children,
+                                          child_node)
+                        clk_core_set_parent(child, NULL);
         }
 
-        hlist_del_init(&clk->child_node);
+        hlist_del_init(&clk->core->child_node);
 
-        if (clk->prepare_count)
+        if (clk->core->prepare_count)
                 pr_warn("%s: unregistering prepared clock: %s\n",
-                                        __func__, clk->name);
-        kref_put(&clk->ref, __clk_release);
+                                        __func__, clk->core->name);
+        kref_put(&clk->core->ref, __clk_release);
 
         clk_prepare_unlock();
 }
@@ -2263,11 +2643,13 @@ EXPORT_SYMBOL_GPL(devm_clk_unregister);
  */
 int __clk_get(struct clk *clk)
 {
-        if (clk) {
-                if (!try_module_get(clk->owner))
+        struct clk_core *core = !clk ? NULL : clk->core;
+
+        if (core) {
+                if (!try_module_get(core->owner))
                         return 0;
 
-                kref_get(&clk->ref);
+                kref_get(&core->ref);
         }
         return 1;
 }
@@ -2280,11 +2662,20 @@ void __clk_put(struct clk *clk)
                 return;
 
         clk_prepare_lock();
-        owner = clk->owner;
-        kref_put(&clk->ref, __clk_release);
+
+        hlist_del(&clk->child_node);
+        if (clk->min_rate > clk->core->req_rate ||
+            clk->max_rate < clk->core->req_rate)
+                clk_core_set_rate_nolock(clk->core, clk->core->req_rate);
+
+        owner = clk->core->owner;
+        kref_put(&clk->core->ref, __clk_release);
+
         clk_prepare_unlock();
 
         module_put(owner);
+
+        kfree(clk);
 }
 
 /***        clk rate change notifiers        ***/
@@ -2339,7 +2730,7 @@ int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
 
         ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
 
-        clk->notifier_count++;
+        clk->core->notifier_count++;
 
 out:
         clk_prepare_unlock();
@@ -2376,7 +2767,7 @@ int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
         if (cn->clk == clk) {
                 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
 
-                clk->notifier_count--;
+                clk->core->notifier_count--;
 
                 /* XXX the notifier code should handle this better */
                 if (!cn->notifier_head.head) {
@@ -2506,7 +2897,8 @@ void of_clk_del_provider(struct device_node *np)
 }
 EXPORT_SYMBOL_GPL(of_clk_del_provider);
 
-struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec)
+struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec,
+                                       const char *dev_id, const char *con_id)
 {
         struct of_clk_provider *provider;
         struct clk *clk = ERR_PTR(-EPROBE_DEFER);
@@ -2515,8 +2907,17 @@ struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec)
         list_for_each_entry(provider, &of_clk_providers, link) {
                 if (provider->node == clkspec->np)
                         clk = provider->get(clkspec, provider->data);
-                if (!IS_ERR(clk))
+                if (!IS_ERR(clk)) {
+                        clk = __clk_create_clk(__clk_get_hw(clk), dev_id,
+                                               con_id);
+
+                        if (!IS_ERR(clk) && !__clk_get(clk)) {
+                                __clk_free_clk(clk);
+                                clk = ERR_PTR(-ENOENT);
+                        }
+
                         break;
+                }
         }
 
         return clk;
@@ -2527,7 +2928,7 @@ struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
         struct clk *clk;
 
         mutex_lock(&of_clk_mutex);
-        clk = __of_clk_get_from_provider(clkspec);
+        clk = __of_clk_get_from_provider(clkspec, NULL, __func__);
         mutex_unlock(&of_clk_mutex);
 
         return clk;
diff --git a/drivers/clk/clk.h b/drivers/clk/clk.h
index c798138f023f..ba845408cc3e 100644
--- a/drivers/clk/clk.h
+++ b/drivers/clk/clk.h
@@ -9,9 +9,31 @@
  * published by the Free Software Foundation.
  */
 
+struct clk_hw;
+
 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
 struct clk *of_clk_get_by_clkspec(struct of_phandle_args *clkspec);
-struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec);
+struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec,
+                                       const char *dev_id, const char *con_id);
 void of_clk_lock(void);
 void of_clk_unlock(void);
 #endif
+
+#ifdef CONFIG_COMMON_CLK
+struct clk *__clk_create_clk(struct clk_hw *hw, const char *dev_id,
+                             const char *con_id);
+void __clk_free_clk(struct clk *clk);
+#else
+/* All these casts to avoid ifdefs in clkdev... */
+static inline struct clk *
+__clk_create_clk(struct clk_hw *hw, const char *dev_id, const char *con_id)
+{
+        return (struct clk *)hw;
+}
+static inline void __clk_free_clk(struct clk *clk) { }
+static struct clk_hw *__clk_get_hw(struct clk *clk)
+{
+        return (struct clk_hw *)clk;
+}
+
+#endif
diff --git a/drivers/clk/clkdev.c b/drivers/clk/clkdev.c
index da4bda8b7fc7..043fd3633373 100644
--- a/drivers/clk/clkdev.c
+++ b/drivers/clk/clkdev.c
@@ -19,6 +19,7 @@
 #include <linux/mutex.h>
 #include <linux/clk.h>
 #include <linux/clkdev.h>
+#include <linux/clk-provider.h>
 #include <linux/of.h>
 
 #include "clk.h"
@@ -28,6 +29,20 @@ static DEFINE_MUTEX(clocks_mutex);
 
 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
 
+static struct clk *__of_clk_get_by_clkspec(struct of_phandle_args *clkspec,
+                                         const char *dev_id, const char *con_id)
+{
+        struct clk *clk;
+
+        if (!clkspec)
+                return ERR_PTR(-EINVAL);
+
+        of_clk_lock();
+        clk = __of_clk_get_from_provider(clkspec, dev_id, con_id);
+        of_clk_unlock();
+        return clk;
+}
+
 /**
  * of_clk_get_by_clkspec() - Lookup a clock form a clock provider
  * @clkspec: pointer to a clock specifier data structure
@@ -38,22 +53,11 @@ static DEFINE_MUTEX(clocks_mutex);
  */
 struct clk *of_clk_get_by_clkspec(struct of_phandle_args *clkspec)
 {
-        struct clk *clk;
-
-        if (!clkspec)
-                return ERR_PTR(-EINVAL);
-
-        of_clk_lock();
-        clk = __of_clk_get_from_provider(clkspec);
-
-        if (!IS_ERR(clk) && !__clk_get(clk))
-                clk = ERR_PTR(-ENOENT);
-
-        of_clk_unlock();
-        return clk;
+        return __of_clk_get_by_clkspec(clkspec, NULL, __func__);
 }
 
-struct clk *of_clk_get(struct device_node *np, int index)
+static struct clk *__of_clk_get(struct device_node *np, int index,
+                               const char *dev_id, const char *con_id)
 {
         struct of_phandle_args clkspec;
         struct clk *clk;
@@ -67,22 +71,21 @@ struct clk *of_clk_get(struct device_node *np, int index)
         if (rc)
                 return ERR_PTR(rc);
 
-        clk = of_clk_get_by_clkspec(&clkspec);
+        clk = __of_clk_get_by_clkspec(&clkspec, dev_id, con_id);
         of_node_put(clkspec.np);
+
         return clk;
 }
+
+struct clk *of_clk_get(struct device_node *np, int index)
+{
+        return __of_clk_get(np, index, np->full_name, NULL);
+}
 EXPORT_SYMBOL(of_clk_get);
 
-/**
- * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
- * @np: pointer to clock consumer node
- * @name: name of consumer's clock input, or NULL for the first clock reference
- *
- * This function parses the clocks and clock-names properties,
- * and uses them to look up the struct clk from the registered list of clock
- * providers.
- */
-struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
+static struct clk *__of_clk_get_by_name(struct device_node *np,
+                                        const char *dev_id,
+                                        const char *name)
 {
         struct clk *clk = ERR_PTR(-ENOENT);
 
@@ -97,10 +100,10 @@ struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
                  */
                 if (name)
                         index = of_property_match_string(np, "clock-names", name);
-                clk = of_clk_get(np, index);
-                if (!IS_ERR(clk))
+                clk = __of_clk_get(np, index, dev_id, name);
+                if (!IS_ERR(clk)) {
                         break;
-                else if (name && index >= 0) {
+                } else if (name && index >= 0) {
                         if (PTR_ERR(clk) != -EPROBE_DEFER)
                                 pr_err("ERROR: could not get clock %s:%s(%i)\n",
                                         np->full_name, name ? name : "", index);
@@ -119,7 +122,33 @@ struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
 
         return clk;
 }
+
+/**
+ * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
+ * @np: pointer to clock consumer node
+ * @name: name of consumer's clock input, or NULL for the first clock reference
+ *
+ * This function parses the clocks and clock-names properties,
+ * and uses them to look up the struct clk from the registered list of clock
+ * providers.
+ */
+struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
+{
+        if (!np)
+                return ERR_PTR(-ENOENT);
+
+        return __of_clk_get_by_name(np, np->full_name, name);
+}
 EXPORT_SYMBOL(of_clk_get_by_name);
+
+#else /* defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) */
+
+static struct clk *__of_clk_get_by_name(struct device_node *np,
+                                        const char *dev_id,
+                                        const char *name)
+{
+        return ERR_PTR(-ENOENT);
+}
 #endif
 
 /*
@@ -168,14 +197,28 @@ static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
 {
         struct clk_lookup *cl;
+        struct clk *clk = NULL;
 
         mutex_lock(&clocks_mutex);
+
         cl = clk_find(dev_id, con_id);
-        if (cl && !__clk_get(cl->clk))
+        if (!cl)
+                goto out;
+
+        clk = __clk_create_clk(__clk_get_hw(cl->clk), dev_id, con_id);
+        if (IS_ERR(clk))
+                goto out;
+
+        if (!__clk_get(clk)) {
+                __clk_free_clk(clk);
                 cl = NULL;
+                goto out;
+        }
+
+out:
         mutex_unlock(&clocks_mutex);
 
-        return cl ? cl->clk : ERR_PTR(-ENOENT);
+        return cl ? clk : ERR_PTR(-ENOENT);
 }
 EXPORT_SYMBOL(clk_get_sys);
 
@@ -185,10 +228,8 @@ struct clk *clk_get(struct device *dev, const char *con_id)
         struct clk *clk;
 
         if (dev) {
-                clk = of_clk_get_by_name(dev->of_node, con_id);
-                if (!IS_ERR(clk))
-                        return clk;
-                if (PTR_ERR(clk) == -EPROBE_DEFER)
+                clk = __of_clk_get_by_name(dev->of_node, dev_id, con_id);
+                if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)
                         return clk;
         }
 
@@ -331,6 +372,7 @@ int clk_register_clkdev(struct clk *clk, const char *con_id,
 
         return 0;
 }
+EXPORT_SYMBOL(clk_register_clkdev);
 
 /**
  * clk_register_clkdevs - register a set of clk_lookup for a struct clk
diff --git a/drivers/clk/hisilicon/clk-hi3620.c b/drivers/clk/hisilicon/clk-hi3620.c
index 007144f81f50..2e4f6d432beb 100644
--- a/drivers/clk/hisilicon/clk-hi3620.c
+++ b/drivers/clk/hisilicon/clk-hi3620.c
@@ -295,6 +295,8 @@ static unsigned long mmc_clk_recalc_rate(struct clk_hw *hw,
 }
 
 static long mmc_clk_determine_rate(struct clk_hw *hw, unsigned long rate,
+                              unsigned long min_rate,
+                              unsigned long max_rate,
                               unsigned long *best_parent_rate,
                               struct clk_hw **best_parent_p)
 {
diff --git a/drivers/clk/mmp/clk-mix.c b/drivers/clk/mmp/clk-mix.c
index 48fa53c7ce5e..de6a873175d2 100644
--- a/drivers/clk/mmp/clk-mix.c
+++ b/drivers/clk/mmp/clk-mix.c
@@ -202,6 +202,8 @@ error:
 }
 
 static long mmp_clk_mix_determine_rate(struct clk_hw *hw, unsigned long rate,
+                                        unsigned long min_rate,
+                                        unsigned long max_rate,
                                         unsigned long *best_parent_rate,
                                         struct clk_hw **best_parent_clk)
 {
diff --git a/drivers/clk/pxa/Makefile b/drivers/clk/pxa/Makefile
index 38e915344605..38e37bf6b821 100644
--- a/drivers/clk/pxa/Makefile
+++ b/drivers/clk/pxa/Makefile
@@ -1,3 +1,4 @@
 obj-y                           += clk-pxa.o
 obj-$(CONFIG_PXA25x)            += clk-pxa25x.o
 obj-$(CONFIG_PXA27x)            += clk-pxa27x.o
+obj-$(CONFIG_PXA3xx)            += clk-pxa3xx.o
diff --git a/drivers/clk/pxa/clk-pxa.c b/drivers/clk/pxa/clk-pxa.c
index 4e834753ab09..29cee9e8d4d9 100644
--- a/drivers/clk/pxa/clk-pxa.c
+++ b/drivers/clk/pxa/clk-pxa.c
@@ -46,7 +46,7 @@ static unsigned long cken_recalc_rate(struct clk_hw *hw,
                 fix = &pclk->lp;
         else
                 fix = &pclk->hp;
-        fix->hw.clk = hw->clk;
+        __clk_hw_set_clk(&fix->hw, hw);
         return clk_fixed_factor_ops.recalc_rate(&fix->hw, parent_rate);
 }
 
diff --git a/drivers/clk/pxa/clk-pxa3xx.c b/drivers/clk/pxa/clk-pxa3xx.c
new file mode 100644
index 000000000000..39f891bba09a
--- /dev/null
+++ b/drivers/clk/pxa/clk-pxa3xx.c
@@ -0,0 +1,364 @@
+/*
+ * Marvell PXA3xxx family clocks
+ *
+ * Copyright (C) 2014 Robert Jarzmik
+ *
+ * Heavily inspired from former arch/arm/mach-pxa/pxa3xx.c
+ *
+ * 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.
+ *
+ * For non-devicetree platforms. Once pxa is fully converted to devicetree, this
+ * should go away.
+ */
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/clkdev.h>
+#include <linux/of.h>
+#include <mach/smemc.h>
+#include <mach/pxa3xx-regs.h>
+
+#include <dt-bindings/clock/pxa-clock.h>
+#include "clk-pxa.h"
+
+#define KHz 1000
+#define MHz (1000 * 1000)
+
+enum {
+        PXA_CORE_60Mhz = 0,
+        PXA_CORE_RUN,
+        PXA_CORE_TURBO,
+};
+
+enum {
+        PXA_BUS_60Mhz = 0,
+        PXA_BUS_HSS,
+};
+
+/* crystal frequency to HSIO bus frequency multiplier (HSS) */
+static unsigned char hss_mult[4] = { 8, 12, 16, 24 };
+
+/* crystal frequency to static memory controller multiplier (SMCFS) */
+static unsigned int smcfs_mult[8] = { 6, 0, 8, 0, 0, 16, };
+static unsigned int df_clkdiv[4] = { 1, 2, 4, 1 };
+
+static const char * const get_freq_khz[] = {
+        "core", "ring_osc_60mhz", "run", "cpll", "system_bus"
+};
+
+/*
+ * Get the clock frequency as reflected by ACSR and the turbo flag.
+ * We assume these values have been applied via a fcs.
+ * If info is not 0 we also display the current settings.
+ */
+unsigned int pxa3xx_get_clk_frequency_khz(int info)
+{
+        struct clk *clk;
+        unsigned long clks[5];
+        int i;
+
+        for (i = 0; i < 5; i++) {
+                clk = clk_get(NULL, get_freq_khz[i]);
+                if (IS_ERR(clk)) {
+                        clks[i] = 0;
+                } else {
+                        clks[i] = clk_get_rate(clk);
+                        clk_put(clk);
+                }
+        }
+        if (info) {
+                pr_info("RO Mode clock: %ld.%02ldMHz\n",
+                        clks[1] / 1000000, (clks[0] % 1000000) / 10000);
+                pr_info("Run Mode clock: %ld.%02ldMHz\n",
+                        clks[2] / 1000000, (clks[1] % 1000000) / 10000);
+                pr_info("Turbo Mode clock: %ld.%02ldMHz\n",
+                        clks[3] / 1000000, (clks[2] % 1000000) / 10000);
+                pr_info("System bus clock: %ld.%02ldMHz\n",
+                        clks[4] / 1000000, (clks[4] % 1000000) / 10000);
+        }
+        return (unsigned int)clks[0];
+}
+
+static unsigned long clk_pxa3xx_ac97_get_rate(struct clk_hw *hw,
+                                             unsigned long parent_rate)
+{
+        unsigned long ac97_div, rate;
+
+        ac97_div = AC97_DIV;
+
+        /* This may loose precision for some rates but won't for the
+         * standard 24.576MHz.
+         */
+        rate = parent_rate / 2;
+        rate /= ((ac97_div >> 12) & 0x7fff);
+        rate *= (ac97_div & 0xfff);
+
+        return rate;
+}
+PARENTS(clk_pxa3xx_ac97) = { "spll_624mhz" };
+RATE_RO_OPS(clk_pxa3xx_ac97, "ac97");
+
+static unsigned long clk_pxa3xx_smemc_get_rate(struct clk_hw *hw,
+                                              unsigned long parent_rate)
+{
+        unsigned long acsr = ACSR;
+        unsigned long memclkcfg = __raw_readl(MEMCLKCFG);
+
+        return (parent_rate / 48)  * smcfs_mult[(acsr >> 23) & 0x7] /
+                df_clkdiv[(memclkcfg >> 16) & 0x3];
+}
+PARENTS(clk_pxa3xx_smemc) = { "spll_624mhz" };
+RATE_RO_OPS(clk_pxa3xx_smemc, "smemc");
+
+static bool pxa3xx_is_ring_osc_forced(void)
+{
+        unsigned long acsr = ACSR;
+
+        return acsr & ACCR_D0CS;
+}
+
+PARENTS(pxa3xx_pbus) = { "ring_osc_60mhz", "spll_624mhz" };
+PARENTS(pxa3xx_32Khz_bus) = { "osc_32_768khz", "osc_32_768khz" };
+PARENTS(pxa3xx_13MHz_bus) = { "osc_13mhz", "osc_13mhz" };
+PARENTS(pxa3xx_ac97_bus) = { "ring_osc_60mhz", "ac97" };
+PARENTS(pxa3xx_sbus) = { "ring_osc_60mhz", "system_bus" };
+PARENTS(pxa3xx_smemcbus) = { "ring_osc_60mhz", "smemc" };
+
+#define CKEN_AB(bit) ((CKEN_ ## bit > 31) ? &CKENA : &CKENB)
+#define PXA3XX_CKEN(dev_id, con_id, parents, mult_lp, div_lp, mult_hp,  \
+                    div_hp, bit, is_lp, flags)                          \
+        PXA_CKEN(dev_id, con_id, bit, parents, mult_lp, div_lp,         \
+                 mult_hp, div_hp, is_lp,  CKEN_AB(bit),                 \
+                 (CKEN_ ## bit % 32), flags)
+#define PXA3XX_PBUS_CKEN(dev_id, con_id, bit, mult_lp, div_lp,          \
+                         mult_hp, div_hp, delay)                        \
+        PXA3XX_CKEN(dev_id, con_id, pxa3xx_pbus_parents, mult_lp,       \
+                    div_lp, mult_hp, div_hp, bit, pxa3xx_is_ring_osc_forced, 0)
+#define PXA3XX_CKEN_1RATE(dev_id, con_id, bit, parents)                 \
+        PXA_CKEN_1RATE(dev_id, con_id, bit, parents,                    \
+                       CKEN_AB(bit), (CKEN_ ## bit % 32), 0)
+
+static struct desc_clk_cken pxa3xx_clocks[] __initdata = {
+        PXA3XX_PBUS_CKEN("pxa2xx-uart.0", NULL, FFUART, 1, 4, 1, 42, 1),
+        PXA3XX_PBUS_CKEN("pxa2xx-uart.1", NULL, BTUART, 1, 4, 1, 42, 1),
+        PXA3XX_PBUS_CKEN("pxa2xx-uart.2", NULL, STUART, 1, 4, 1, 42, 1),
+        PXA3XX_PBUS_CKEN("pxa2xx-i2c.0", NULL, I2C, 2, 5, 1, 19, 0),
+        PXA3XX_PBUS_CKEN("pxa27x-udc", NULL, UDC, 1, 4, 1, 13, 5),
+        PXA3XX_PBUS_CKEN("pxa27x-ohci", NULL, USBH, 1, 4, 1, 13, 0),
+        PXA3XX_PBUS_CKEN("pxa3xx-u2d", NULL, USB2, 1, 4, 1, 13, 0),
+        PXA3XX_PBUS_CKEN("pxa27x-pwm.0", NULL, PWM0, 1, 6, 1, 48, 0),
+        PXA3XX_PBUS_CKEN("pxa27x-pwm.1", NULL, PWM1, 1, 6, 1, 48, 0),
+        PXA3XX_PBUS_CKEN("pxa2xx-mci.0", NULL, MMC1, 1, 4, 1, 24, 0),
+        PXA3XX_PBUS_CKEN("pxa2xx-mci.1", NULL, MMC2, 1, 4, 1, 24, 0),
+        PXA3XX_PBUS_CKEN("pxa2xx-mci.2", NULL, MMC3, 1, 4, 1, 24, 0),
+
+        PXA3XX_CKEN_1RATE("pxa27x-keypad", NULL, KEYPAD,
+                          pxa3xx_32Khz_bus_parents),
+        PXA3XX_CKEN_1RATE("pxa3xx-ssp.0", NULL, SSP1, pxa3xx_13MHz_bus_parents),
+        PXA3XX_CKEN_1RATE("pxa3xx-ssp.1", NULL, SSP2, pxa3xx_13MHz_bus_parents),
+        PXA3XX_CKEN_1RATE("pxa3xx-ssp.2", NULL, SSP3, pxa3xx_13MHz_bus_parents),
+        PXA3XX_CKEN_1RATE("pxa3xx-ssp.3", NULL, SSP4, pxa3xx_13MHz_bus_parents),
+
+        PXA3XX_CKEN(NULL, "AC97CLK", pxa3xx_ac97_bus_parents, 1, 4, 1, 1, AC97,
+                    pxa3xx_is_ring_osc_forced, 0),
+        PXA3XX_CKEN(NULL, "CAMCLK", pxa3xx_sbus_parents, 1, 2, 1, 1, CAMERA,
+                    pxa3xx_is_ring_osc_forced, 0),
+        PXA3XX_CKEN("pxa2xx-fb", NULL, pxa3xx_sbus_parents, 1, 1, 1, 1, LCD,
+                    pxa3xx_is_ring_osc_forced, 0),
+        PXA3XX_CKEN("pxa2xx-pcmcia", NULL, pxa3xx_smemcbus_parents, 1, 4,
+                    1, 1, SMC, pxa3xx_is_ring_osc_forced, CLK_IGNORE_UNUSED),
+};
+
+static struct desc_clk_cken pxa300_310_clocks[] __initdata = {
+
+        PXA3XX_PBUS_CKEN("pxa3xx-gcu", NULL, PXA300_GCU, 1, 1, 1, 1, 0),
+        PXA3XX_PBUS_CKEN("pxa3xx-nand", NULL, NAND, 1, 2, 1, 4, 0),
+        PXA3XX_CKEN_1RATE("pxa3xx-gpio", NULL, GPIO, pxa3xx_13MHz_bus_parents),
+};
+
+static struct desc_clk_cken pxa320_clocks[] __initdata = {
+        PXA3XX_PBUS_CKEN("pxa3xx-nand", NULL, NAND, 1, 2, 1, 6, 0),
+        PXA3XX_PBUS_CKEN("pxa3xx-gcu", NULL, PXA320_GCU, 1, 1, 1, 1, 0),
+        PXA3XX_CKEN_1RATE("pxa3xx-gpio", NULL, GPIO, pxa3xx_13MHz_bus_parents),
+};
+
+static struct desc_clk_cken pxa93x_clocks[] __initdata = {
+
+        PXA3XX_PBUS_CKEN("pxa3xx-gcu", NULL, PXA300_GCU, 1, 1, 1, 1, 0),
+        PXA3XX_PBUS_CKEN("pxa3xx-nand", NULL, NAND, 1, 2, 1, 4, 0),
+        PXA3XX_CKEN_1RATE("pxa93x-gpio", NULL, GPIO, pxa3xx_13MHz_bus_parents),
+};
+
+static unsigned long clk_pxa3xx_system_bus_get_rate(struct clk_hw *hw,
+                                            unsigned long parent_rate)
+{
+        unsigned long acsr = ACSR;
+        unsigned int hss = (acsr >> 14) & 0x3;
+
+        if (pxa3xx_is_ring_osc_forced())
+                return parent_rate;
+        return parent_rate / 48 * hss_mult[hss];
+}
+
+static u8 clk_pxa3xx_system_bus_get_parent(struct clk_hw *hw)
+{
+        if (pxa3xx_is_ring_osc_forced())
+                return PXA_BUS_60Mhz;
+        else
+                return PXA_BUS_HSS;
+}
+
+PARENTS(clk_pxa3xx_system_bus) = { "ring_osc_60mhz", "spll_624mhz" };
+MUX_RO_RATE_RO_OPS(clk_pxa3xx_system_bus, "system_bus");
+
+static unsigned long clk_pxa3xx_core_get_rate(struct clk_hw *hw,
+                                              unsigned long parent_rate)
+{
+        return parent_rate;
+}
+
+static u8 clk_pxa3xx_core_get_parent(struct clk_hw *hw)
+{
+        unsigned long xclkcfg;
+        unsigned int t;
+
+        if (pxa3xx_is_ring_osc_forced())
+                return PXA_CORE_60Mhz;
+
+        /* Read XCLKCFG register turbo bit */
+        __asm__ __volatile__("mrc\tp14, 0, %0, c6, c0, 0" : "=r"(xclkcfg));
+        t = xclkcfg & 0x1;
+
+        if (t)
+                return PXA_CORE_TURBO;
+        return PXA_CORE_RUN;
+}
+PARENTS(clk_pxa3xx_core) = { "ring_osc_60mhz", "run", "cpll" };
+MUX_RO_RATE_RO_OPS(clk_pxa3xx_core, "core");
+
+static unsigned long clk_pxa3xx_run_get_rate(struct clk_hw *hw,
+                                             unsigned long parent_rate)
+{
+        unsigned long acsr = ACSR;
+        unsigned int xn = (acsr & ACCR_XN_MASK) >> 8;
+        unsigned int t, xclkcfg;
+
+        /* Read XCLKCFG register turbo bit */
+        __asm__ __volatile__("mrc\tp14, 0, %0, c6, c0, 0" : "=r"(xclkcfg));
+        t = xclkcfg & 0x1;
+
+        return t ? (parent_rate / xn) * 2 : parent_rate;
+}
+PARENTS(clk_pxa3xx_run) = { "cpll" };
+RATE_RO_OPS(clk_pxa3xx_run, "run");
+
+static unsigned long clk_pxa3xx_cpll_get_rate(struct clk_hw *hw,
+        unsigned long parent_rate)
+{
+        unsigned long acsr = ACSR;
+        unsigned int xn = (acsr & ACCR_XN_MASK) >> 8;
+        unsigned int xl = acsr & ACCR_XL_MASK;
+        unsigned int t, xclkcfg;
+
+        /* Read XCLKCFG register turbo bit */
+        __asm__ __volatile__("mrc\tp14, 0, %0, c6, c0, 0" : "=r"(xclkcfg));
+        t = xclkcfg & 0x1;
+
+        pr_info("RJK: parent_rate=%lu, xl=%u, xn=%u\n", parent_rate, xl, xn);
+        return t ? parent_rate * xl * xn : parent_rate * xl;
+}
+PARENTS(clk_pxa3xx_cpll) = { "osc_13mhz" };
+RATE_RO_OPS(clk_pxa3xx_cpll, "cpll");
+
+static void __init pxa3xx_register_core(void)
+{
+        clk_register_clk_pxa3xx_cpll();
+        clk_register_clk_pxa3xx_run();
+
+        clkdev_pxa_register(CLK_CORE, "core", NULL,
+                            clk_register_clk_pxa3xx_core());
+}
+
+static void __init pxa3xx_register_plls(void)
+{
+        clk_register_fixed_rate(NULL, "osc_13mhz", NULL,
+                                CLK_GET_RATE_NOCACHE | CLK_IS_ROOT,
+                                13 * MHz);
+        clk_register_fixed_rate(NULL, "osc_32_768khz", NULL,
+                                CLK_GET_RATE_NOCACHE | CLK_IS_ROOT,
+                                32768);
+        clk_register_fixed_rate(NULL, "ring_osc_120mhz", NULL,
+                                CLK_GET_RATE_NOCACHE | CLK_IS_ROOT,
+                                120 * MHz);
+        clk_register_fixed_rate(NULL, "clk_dummy", NULL, CLK_IS_ROOT, 0);
+        clk_register_fixed_factor(NULL, "spll_624mhz", "osc_13mhz", 0, 48, 1);
+        clk_register_fixed_factor(NULL, "ring_osc_60mhz", "ring_osc_120mhz",
+                                  0, 1, 2);
+}
+
+#define DUMMY_CLK(_con_id, _dev_id, _parent) \
+        { .con_id = _con_id, .dev_id = _dev_id, .parent = _parent }
+struct dummy_clk {
+        const char *con_id;
+        const char *dev_id;
+        const char *parent;
+};
+static struct dummy_clk dummy_clks[] __initdata = {
+        DUMMY_CLK(NULL, "pxa93x-gpio", "osc_13mhz"),
+        DUMMY_CLK(NULL, "sa1100-rtc", "osc_32_768khz"),
+        DUMMY_CLK("UARTCLK", "pxa2xx-ir", "STUART"),
+        DUMMY_CLK(NULL, "pxa3xx-pwri2c.1", "osc_13mhz"),
+};
+
+static void __init pxa3xx_dummy_clocks_init(void)
+{
+        struct clk *clk;
+        struct dummy_clk *d;
+        const char *name;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(dummy_clks); i++) {
+                d = &dummy_clks[i];
+                name = d->dev_id ? d->dev_id : d->con_id;
+                clk = clk_register_fixed_factor(NULL, name, d->parent, 0, 1, 1);
+                clk_register_clkdev(clk, d->con_id, d->dev_id);
+        }
+}
+
+static void __init pxa3xx_base_clocks_init(void)
+{
+        pxa3xx_register_plls();
+        pxa3xx_register_core();
+        clk_register_clk_pxa3xx_system_bus();
+        clk_register_clk_pxa3xx_ac97();
+        clk_register_clk_pxa3xx_smemc();
+        clk_register_gate(NULL, "CLK_POUT", "osc_13mhz", 0,
+                          (void __iomem *)&OSCC, 11, 0, NULL);
+}
+
+int __init pxa3xx_clocks_init(void)
+{
+        int ret;
+
+        pxa3xx_base_clocks_init();
+        pxa3xx_dummy_clocks_init();
+        ret = clk_pxa_cken_init(pxa3xx_clocks, ARRAY_SIZE(pxa3xx_clocks));
+        if (ret)
+                return ret;
+        if (cpu_is_pxa320())
+                return clk_pxa_cken_init(pxa320_clocks,
+                                         ARRAY_SIZE(pxa320_clocks));
+        if (cpu_is_pxa300() || cpu_is_pxa310())
+                return clk_pxa_cken_init(pxa300_310_clocks,
+                                         ARRAY_SIZE(pxa300_310_clocks));
+        return clk_pxa_cken_init(pxa93x_clocks, ARRAY_SIZE(pxa93x_clocks));
+}
+
+static void __init pxa3xx_dt_clocks_init(struct device_node *np)
+{
+        pxa3xx_clocks_init();
+        clk_pxa_dt_common_init(np);
+}
+CLK_OF_DECLARE(pxa_clks, "marvell,pxa300-clocks", pxa3xx_dt_clocks_init);
diff --git a/drivers/clk/qcom/Kconfig b/drivers/clk/qcom/Kconfig
index 1107351ed346..0d7ab52b7ab0 100644
--- a/drivers/clk/qcom/Kconfig
+++ b/drivers/clk/qcom/Kconfig
@@ -29,6 +29,15 @@ config IPQ_GCC_806X
           Say Y if you want to use peripheral devices such as UART, SPI,
           i2c, USB, SD/eMMC, etc.
 
+config IPQ_LCC_806X
+        tristate "IPQ806x LPASS Clock Controller"
+        select IPQ_GCC_806X
+        depends on COMMON_CLK_QCOM
+        help
+          Support for the LPASS clock controller on ipq806x devices.
+          Say Y if you want to use audio devices such as i2s, pcm,
+          S/PDIF, etc.
+
 config MSM_GCC_8660
         tristate "MSM8660 Global Clock Controller"
         depends on COMMON_CLK_QCOM
@@ -45,6 +54,15 @@ config MSM_GCC_8960
           Say Y if you want to use peripheral devices such as UART, SPI,
           i2c, USB, SD/eMMC, SATA, PCIe, etc.
 
+config MSM_LCC_8960
+        tristate "APQ8064/MSM8960 LPASS Clock Controller"
+        select MSM_GCC_8960
+        depends on COMMON_CLK_QCOM
+        help
+          Support for the LPASS clock controller on apq8064/msm8960 devices.
+          Say Y if you want to use audio devices such as i2s, pcm,
+          SLIMBus, etc.
+
 config MSM_MMCC_8960
         tristate "MSM8960 Multimedia Clock Controller"
         select MSM_GCC_8960
diff --git a/drivers/clk/qcom/Makefile b/drivers/clk/qcom/Makefile
index 783cfb24faa4..617826469595 100644
--- a/drivers/clk/qcom/Makefile
+++ b/drivers/clk/qcom/Makefile
@@ -6,13 +6,17 @@ clk-qcom-y += clk-pll.o
 clk-qcom-y += clk-rcg.o
 clk-qcom-y += clk-rcg2.o
 clk-qcom-y += clk-branch.o
+clk-qcom-y += clk-regmap-divider.o
+clk-qcom-y += clk-regmap-mux.o
 clk-qcom-y += reset.o
 
 obj-$(CONFIG_APQ_GCC_8084) += gcc-apq8084.o
 obj-$(CONFIG_APQ_MMCC_8084) += mmcc-apq8084.o
 obj-$(CONFIG_IPQ_GCC_806X) += gcc-ipq806x.o
+obj-$(CONFIG_IPQ_LCC_806X) += lcc-ipq806x.o
 obj-$(CONFIG_MSM_GCC_8660) += gcc-msm8660.o
 obj-$(CONFIG_MSM_GCC_8960) += gcc-msm8960.o
+obj-$(CONFIG_MSM_LCC_8960) += lcc-msm8960.o
 obj-$(CONFIG_MSM_GCC_8974) += gcc-msm8974.o
 obj-$(CONFIG_MSM_MMCC_8960) += mmcc-msm8960.o
 obj-$(CONFIG_MSM_MMCC_8974) += mmcc-msm8974.o
diff --git a/drivers/clk/qcom/clk-pll.c b/drivers/clk/qcom/clk-pll.c
index 60873a7f45d9..b4325f65a1bf 100644
--- a/drivers/clk/qcom/clk-pll.c
+++ b/drivers/clk/qcom/clk-pll.c
@@ -141,6 +141,7 @@ struct pll_freq_tbl *find_freq(const struct pll_freq_tbl *f, unsigned long rate)
 
 static long
 clk_pll_determine_rate(struct clk_hw *hw, unsigned long rate,
+                       unsigned long min_rate, unsigned long max_rate,
                        unsigned long *p_rate, struct clk_hw **p)
 {
         struct clk_pll *pll = to_clk_pll(hw);
diff --git a/drivers/clk/qcom/clk-rcg.c b/drivers/clk/qcom/clk-rcg.c
index 0b93972c8807..0039bd7d3965 100644
--- a/drivers/clk/qcom/clk-rcg.c
+++ b/drivers/clk/qcom/clk-rcg.c
@@ -368,6 +368,7 @@ clk_dyn_rcg_recalc_rate(struct clk_hw *hw, unsigned long parent_rate)
 
 static long _freq_tbl_determine_rate(struct clk_hw *hw,
                 const struct freq_tbl *f, unsigned long rate,
+                unsigned long min_rate, unsigned long max_rate,
                 unsigned long *p_rate, struct clk_hw **p_hw)
 {
         unsigned long clk_flags;
@@ -397,22 +398,27 @@ static long _freq_tbl_determine_rate(struct clk_hw *hw,
 }
 
 static long clk_rcg_determine_rate(struct clk_hw *hw, unsigned long rate,
+                unsigned long min_rate, unsigned long max_rate,
                 unsigned long *p_rate, struct clk_hw **p)
 {
         struct clk_rcg *rcg = to_clk_rcg(hw);
 
-        return _freq_tbl_determine_rate(hw, rcg->freq_tbl, rate, p_rate, p);
+        return _freq_tbl_determine_rate(hw, rcg->freq_tbl, rate, min_rate,
+                        max_rate, p_rate, p);
 }
 
 static long clk_dyn_rcg_determine_rate(struct clk_hw *hw, unsigned long rate,
+                unsigned long min_rate, unsigned long max_rate,
                 unsigned long *p_rate, struct clk_hw **p)
 {
         struct clk_dyn_rcg *rcg = to_clk_dyn_rcg(hw);
 
-        return _freq_tbl_determine_rate(hw, rcg->freq_tbl, rate, p_rate, p);
+        return _freq_tbl_determine_rate(hw, rcg->freq_tbl, rate, min_rate,
+                        max_rate, p_rate, p);
 }
 
 static long clk_rcg_bypass_determine_rate(struct clk_hw *hw, unsigned long rate,
+                unsigned long min_rate, unsigned long max_rate,
                 unsigned long *p_rate, struct clk_hw **p_hw)
 {
         struct clk_rcg *rcg = to_clk_rcg(hw);
diff --git a/drivers/clk/qcom/clk-rcg2.c b/drivers/clk/qcom/clk-rcg2.c
index 08b8b3729f53..742acfa18d63 100644
--- a/drivers/clk/qcom/clk-rcg2.c
+++ b/drivers/clk/qcom/clk-rcg2.c
@@ -208,6 +208,7 @@ static long _freq_tbl_determine_rate(struct clk_hw *hw,
 }
 
 static long clk_rcg2_determine_rate(struct clk_hw *hw, unsigned long rate,
+                unsigned long min_rate, unsigned long max_rate,
                 unsigned long *p_rate, struct clk_hw **p)
 {
         struct clk_rcg2 *rcg = to_clk_rcg2(hw);
@@ -361,6 +362,8 @@ static int clk_edp_pixel_set_rate_and_parent(struct clk_hw *hw,
 }
 
 static long clk_edp_pixel_determine_rate(struct clk_hw *hw, unsigned long rate,
+                                 unsigned long min_rate,
+                                 unsigned long max_rate,
                                  unsigned long *p_rate, struct clk_hw **p)
 {
         struct clk_rcg2 *rcg = to_clk_rcg2(hw);
@@ -412,6 +415,7 @@ const struct clk_ops clk_edp_pixel_ops = {
 EXPORT_SYMBOL_GPL(clk_edp_pixel_ops);
 
 static long clk_byte_determine_rate(struct clk_hw *hw, unsigned long rate,
+                         unsigned long min_rate, unsigned long max_rate,
                          unsigned long *p_rate, struct clk_hw **p_hw)
 {
         struct clk_rcg2 *rcg = to_clk_rcg2(hw);
@@ -476,6 +480,8 @@ static const struct frac_entry frac_table_pixel[] = {
 };
 
 static long clk_pixel_determine_rate(struct clk_hw *hw, unsigned long rate,
+                                 unsigned long min_rate,
+                                 unsigned long max_rate,
                                  unsigned long *p_rate, struct clk_hw **p)
 {
         struct clk_rcg2 *rcg = to_clk_rcg2(hw);
diff --git a/drivers/clk/qcom/clk-regmap-divider.c b/drivers/clk/qcom/clk-regmap-divider.c
new file mode 100644
index 000000000000..53484912301e
--- /dev/null
+++ b/drivers/clk/qcom/clk-regmap-divider.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/bitops.h>
+#include <linux/regmap.h>
+#include <linux/export.h>
+
+#include "clk-regmap-divider.h"
+
+static inline struct clk_regmap_div *to_clk_regmap_div(struct clk_hw *hw)
+{
+        return container_of(to_clk_regmap(hw), struct clk_regmap_div, clkr);
+}
+
+static long div_round_rate(struct clk_hw *hw, unsigned long rate,
+                           unsigned long *prate)
+{
+        struct clk_regmap_div *divider = to_clk_regmap_div(hw);
+
+        return divider_round_rate(hw, rate, prate, NULL, divider->width,
+                                  CLK_DIVIDER_ROUND_CLOSEST);
+}
+
+static int div_set_rate(struct clk_hw *hw, unsigned long rate,
+                        unsigned long parent_rate)
+{
+        struct clk_regmap_div *divider = to_clk_regmap_div(hw);
+        struct clk_regmap *clkr = &divider->clkr;
+        u32 div;
+
+        div = divider_get_val(rate, parent_rate, NULL, divider->width,
+                              CLK_DIVIDER_ROUND_CLOSEST);
+
+        return regmap_update_bits(clkr->regmap, divider->reg,
+                                  (BIT(divider->width) - 1) << divider->shift,
+                                  div << divider->shift);
+}
+
+static unsigned long div_recalc_rate(struct clk_hw *hw,
+                                     unsigned long parent_rate)
+{
+        struct clk_regmap_div *divider = to_clk_regmap_div(hw);
+        struct clk_regmap *clkr = &divider->clkr;
+        u32 div;
+
+        regmap_read(clkr->regmap, divider->reg, &div);
+        div >>= divider->shift;
+        div &= BIT(divider->width) - 1;
+
+        return divider_recalc_rate(hw, parent_rate, div, NULL,
+                                   CLK_DIVIDER_ROUND_CLOSEST);
+}
+
+const struct clk_ops clk_regmap_div_ops = {
+        .round_rate = div_round_rate,
+        .set_rate = div_set_rate,
+        .recalc_rate = div_recalc_rate,
+};
+EXPORT_SYMBOL_GPL(clk_regmap_div_ops);
diff --git a/drivers/clk/qcom/clk-regmap-divider.h b/drivers/clk/qcom/clk-regmap-divider.h
new file mode 100644
index 000000000000..fc4492e3a827
--- /dev/null
+++ b/drivers/clk/qcom/clk-regmap-divider.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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 __QCOM_CLK_REGMAP_DIVIDER_H__
+#define __QCOM_CLK_REGMAP_DIVIDER_H__
+
+#include <linux/clk-provider.h>
+#include "clk-regmap.h"
+
+struct clk_regmap_div {
+        u32                     reg;
+        u32                     shift;
+        u32                     width;
+        struct clk_regmap       clkr;
+};
+
+extern const struct clk_ops clk_regmap_div_ops;
+
+#endif
diff --git a/drivers/clk/qcom/clk-regmap-mux.c b/drivers/clk/qcom/clk-regmap-mux.c
new file mode 100644
index 000000000000..cae3071f384c
--- /dev/null
+++ b/drivers/clk/qcom/clk-regmap-mux.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/bitops.h>
+#include <linux/regmap.h>
+#include <linux/export.h>
+
+#include "clk-regmap-mux.h"
+
+static inline struct clk_regmap_mux *to_clk_regmap_mux(struct clk_hw *hw)
+{
+        return container_of(to_clk_regmap(hw), struct clk_regmap_mux, clkr);
+}
+
+static u8 mux_get_parent(struct clk_hw *hw)
+{
+        struct clk_regmap_mux *mux = to_clk_regmap_mux(hw);
+        struct clk_regmap *clkr = to_clk_regmap(hw);
+        unsigned int mask = GENMASK(mux->width - 1, 0);
+        unsigned int val;
+
+        regmap_read(clkr->regmap, mux->reg, &val);
+
+        val >>= mux->shift;
+        val &= mask;
+
+        return val;
+}
+
+static int mux_set_parent(struct clk_hw *hw, u8 index)
+{
+        struct clk_regmap_mux *mux = to_clk_regmap_mux(hw);
+        struct clk_regmap *clkr = to_clk_regmap(hw);
+        unsigned int mask = GENMASK(mux->width + mux->shift - 1, mux->shift);
+        unsigned int val;
+
+        val = index;
+        val <<= mux->shift;
+
+        return regmap_update_bits(clkr->regmap, mux->reg, mask, val);
+}
+
+const struct clk_ops clk_regmap_mux_closest_ops = {
+        .get_parent = mux_get_parent,
+        .set_parent = mux_set_parent,
+        .determine_rate = __clk_mux_determine_rate_closest,
+};
+EXPORT_SYMBOL_GPL(clk_regmap_mux_closest_ops);
diff --git a/drivers/clk/qcom/clk-regmap-mux.h b/drivers/clk/qcom/clk-regmap-mux.h
new file mode 100644
index 000000000000..5cec76154fda
--- /dev/null
+++ b/drivers/clk/qcom/clk-regmap-mux.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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 __QCOM_CLK_REGMAP_MUX_H__
+#define __QCOM_CLK_REGMAP_MUX_H__
+
+#include <linux/clk-provider.h>
+#include "clk-regmap.h"
+
+struct clk_regmap_mux {
+        u32                     reg;
+        u32                     shift;
+        u32                     width;
+        struct clk_regmap       clkr;
+};
+
+extern const struct clk_ops clk_regmap_mux_closest_ops;
+
+#endif
diff --git a/drivers/clk/qcom/gcc-ipq806x.c b/drivers/clk/qcom/gcc-ipq806x.c
index afed5eb0691e..cbdc31dea7f4 100644
--- a/drivers/clk/qcom/gcc-ipq806x.c
+++ b/drivers/clk/qcom/gcc-ipq806x.c
@@ -75,6 +75,17 @@ static struct clk_pll pll3 = {
         },
 };
 
+static struct clk_regmap pll4_vote = {
+        .enable_reg = 0x34c0,
+        .enable_mask = BIT(4),
+        .hw.init = &(struct clk_init_data){
+                .name = "pll4_vote",
+                .parent_names = (const char *[]){ "pll4" },
+                .num_parents = 1,
+                .ops = &clk_pll_vote_ops,
+        },
+};
+
 static struct clk_pll pll8 = {
         .l_reg = 0x3144,
         .m_reg = 0x3148,
@@ -2163,6 +2174,7 @@ static struct clk_regmap *gcc_ipq806x_clks[] = {
         [PLL0] = &pll0.clkr,
         [PLL0_VOTE] = &pll0_vote,
         [PLL3] = &pll3.clkr,
+        [PLL4_VOTE] = &pll4_vote,
         [PLL8] = &pll8.clkr,
         [PLL8_VOTE] = &pll8_vote,
         [PLL14] = &pll14.clkr,
diff --git a/drivers/clk/qcom/lcc-ipq806x.c b/drivers/clk/qcom/lcc-ipq806x.c
new file mode 100644
index 000000000000..121ffde25dc3
--- /dev/null
+++ b/drivers/clk/qcom/lcc-ipq806x.c
@@ -0,0 +1,473 @@
+/*
+ * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/bitops.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/clk-provider.h>
+#include <linux/regmap.h>
+
+#include <dt-bindings/clock/qcom,lcc-ipq806x.h>
+
+#include "common.h"
+#include "clk-regmap.h"
+#include "clk-pll.h"
+#include "clk-rcg.h"
+#include "clk-branch.h"
+#include "clk-regmap-divider.h"
+#include "clk-regmap-mux.h"
+
+static struct clk_pll pll4 = {
+        .l_reg = 0x4,
+        .m_reg = 0x8,
+        .n_reg = 0xc,
+        .config_reg = 0x14,
+        .mode_reg = 0x0,
+        .status_reg = 0x18,
+        .status_bit = 16,
+        .clkr.hw.init = &(struct clk_init_data){
+                .name = "pll4",
+                .parent_names = (const char *[]){ "pxo" },
+                .num_parents = 1,
+                .ops = &clk_pll_ops,
+        },
+};
+
+static const struct pll_config pll4_config = {
+        .l = 0xf,
+        .m = 0x91,
+        .n = 0xc7,
+        .vco_val = 0x0,
+        .vco_mask = BIT(17) | BIT(16),
+        .pre_div_val = 0x0,
+        .pre_div_mask = BIT(19),
+        .post_div_val = 0x0,
+        .post_div_mask = BIT(21) | BIT(20),
+        .mn_ena_mask = BIT(22),
+        .main_output_mask = BIT(23),
+};
+
+#define P_PXO   0
+#define P_PLL4  1
+
+static const u8 lcc_pxo_pll4_map[] = {
+        [P_PXO]         = 0,
+        [P_PLL4]        = 2,
+};
+
+static const char *lcc_pxo_pll4[] = {
+        "pxo",
+        "pll4_vote",
+};
+
+static struct freq_tbl clk_tbl_aif_mi2s[] = {
+        {  1024000, P_PLL4, 4,  1,  96 },
+        {  1411200, P_PLL4, 4,  2, 139 },
+        {  1536000, P_PLL4, 4,  1,  64 },
+        {  2048000, P_PLL4, 4,  1,  48 },
+        {  2116800, P_PLL4, 4,  2,  93 },
+        {  2304000, P_PLL4, 4,  2,  85 },
+        {  2822400, P_PLL4, 4,  6, 209 },
+        {  3072000, P_PLL4, 4,  1,  32 },
+        {  3175200, P_PLL4, 4,  1,  31 },
+        {  4096000, P_PLL4, 4,  1,  24 },
+        {  4233600, P_PLL4, 4,  9, 209 },
+        {  4608000, P_PLL4, 4,  3,  64 },
+        {  5644800, P_PLL4, 4, 12, 209 },
+        {  6144000, P_PLL4, 4,  1,  16 },
+        {  6350400, P_PLL4, 4,  2,  31 },
+        {  8192000, P_PLL4, 4,  1,  12 },
+        {  8467200, P_PLL4, 4, 18, 209 },
+        {  9216000, P_PLL4, 4,  3,  32 },
+        { 11289600, P_PLL4, 4, 24, 209 },
+        { 12288000, P_PLL4, 4,  1,   8 },
+        { 12700800, P_PLL4, 4, 27, 209 },
+        { 13824000, P_PLL4, 4,  9,  64 },
+        { 16384000, P_PLL4, 4,  1,   6 },
+        { 16934400, P_PLL4, 4, 41, 238 },
+        { 18432000, P_PLL4, 4,  3,  16 },
+        { 22579200, P_PLL4, 2, 24, 209 },
+        { 24576000, P_PLL4, 4,  1,   4 },
+        { 27648000, P_PLL4, 4,  9,  32 },
+        { 33868800, P_PLL4, 4, 41, 119 },
+        { 36864000, P_PLL4, 4,  3,   8 },
+        { 45158400, P_PLL4, 1, 24, 209 },
+        { 49152000, P_PLL4, 4,  1,   2 },
+        { 50803200, P_PLL4, 1, 27, 209 },
+        { }
+};
+
+static struct clk_rcg mi2s_osr_src = {
+        .ns_reg = 0x48,
+        .md_reg = 0x4c,
+        .mn = {
+                .mnctr_en_bit = 8,
+                .mnctr_reset_bit = 7,
+                .mnctr_mode_shift = 5,
+                .n_val_shift = 24,
+                .m_val_shift = 8,
+                .width = 8,
+        },
+        .p = {
+                .pre_div_shift = 3,
+                .pre_div_width = 2,
+        },
+        .s = {
+                .src_sel_shift = 0,
+                .parent_map = lcc_pxo_pll4_map,
+        },
+        .freq_tbl = clk_tbl_aif_mi2s,
+        .clkr = {
+                .enable_reg = 0x48,
+                .enable_mask = BIT(9),
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_osr_src",
+                        .parent_names = lcc_pxo_pll4,
+                        .num_parents = 2,
+                        .ops = &clk_rcg_ops,
+                        .flags = CLK_SET_RATE_GATE,
+                },
+        },
+};
+
+static const char *lcc_mi2s_parents[] = {
+        "mi2s_osr_src",
+};
+
+static struct clk_branch mi2s_osr_clk = {
+        .halt_reg = 0x50,
+        .halt_bit = 1,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0x48,
+                .enable_mask = BIT(17),
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_osr_clk",
+                        .parent_names = lcc_mi2s_parents,
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct clk_regmap_div mi2s_div_clk = {
+        .reg = 0x48,
+        .shift = 10,
+        .width = 4,
+        .clkr = {
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_div_clk",
+                        .parent_names = lcc_mi2s_parents,
+                        .num_parents = 1,
+                        .ops = &clk_regmap_div_ops,
+                },
+        },
+};
+
+static struct clk_branch mi2s_bit_div_clk = {
+        .halt_reg = 0x50,
+        .halt_bit = 0,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0x48,
+                .enable_mask = BIT(15),
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_bit_div_clk",
+                        .parent_names = (const char *[]){ "mi2s_div_clk" },
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+
+static struct clk_regmap_mux mi2s_bit_clk = {
+        .reg = 0x48,
+        .shift = 14,
+        .width = 1,
+        .clkr = {
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_bit_clk",
+                        .parent_names = (const char *[]){
+                                "mi2s_bit_div_clk",
+                                "mi2s_codec_clk",
+                        },
+                        .num_parents = 2,
+                        .ops = &clk_regmap_mux_closest_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct freq_tbl clk_tbl_pcm[] = {
+        {   64000, P_PLL4, 4, 1, 1536 },
+        {  128000, P_PLL4, 4, 1,  768 },
+        {  256000, P_PLL4, 4, 1,  384 },
+        {  512000, P_PLL4, 4, 1,  192 },
+        { 1024000, P_PLL4, 4, 1,   96 },
+        { 2048000, P_PLL4, 4, 1,   48 },
+        { },
+};
+
+static struct clk_rcg pcm_src = {
+        .ns_reg = 0x54,
+        .md_reg = 0x58,
+        .mn = {
+                .mnctr_en_bit = 8,
+                .mnctr_reset_bit = 7,
+                .mnctr_mode_shift = 5,
+                .n_val_shift = 16,
+                .m_val_shift = 16,
+                .width = 16,
+        },
+        .p = {
+                .pre_div_shift = 3,
+                .pre_div_width = 2,
+        },
+        .s = {
+                .src_sel_shift = 0,
+                .parent_map = lcc_pxo_pll4_map,
+        },
+        .freq_tbl = clk_tbl_pcm,
+        .clkr = {
+                .enable_reg = 0x54,
+                .enable_mask = BIT(9),
+                .hw.init = &(struct clk_init_data){
+                        .name = "pcm_src",
+                        .parent_names = lcc_pxo_pll4,
+                        .num_parents = 2,
+                        .ops = &clk_rcg_ops,
+                        .flags = CLK_SET_RATE_GATE,
+                },
+        },
+};
+
+static struct clk_branch pcm_clk_out = {
+        .halt_reg = 0x5c,
+        .halt_bit = 0,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0x54,
+                .enable_mask = BIT(11),
+                .hw.init = &(struct clk_init_data){
+                        .name = "pcm_clk_out",
+                        .parent_names = (const char *[]){ "pcm_src" },
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct clk_regmap_mux pcm_clk = {
+        .reg = 0x54,
+        .shift = 10,
+        .width = 1,
+        .clkr = {
+                .hw.init = &(struct clk_init_data){
+                        .name = "pcm_clk",
+                        .parent_names = (const char *[]){
+                                "pcm_clk_out",
+                                "pcm_codec_clk",
+                        },
+                        .num_parents = 2,
+                        .ops = &clk_regmap_mux_closest_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct freq_tbl clk_tbl_aif_osr[] = {
+        {  22050, P_PLL4, 1, 147, 20480 },
+        {  32000, P_PLL4, 1,   1,    96 },
+        {  44100, P_PLL4, 1, 147, 10240 },
+        {  48000, P_PLL4, 1,   1,    64 },
+        {  88200, P_PLL4, 1, 147,  5120 },
+        {  96000, P_PLL4, 1,   1,    32 },
+        { 176400, P_PLL4, 1, 147,  2560 },
+        { 192000, P_PLL4, 1,   1,    16 },
+        { },
+};
+
+static struct clk_rcg spdif_src = {
+        .ns_reg = 0xcc,
+        .md_reg = 0xd0,
+        .mn = {
+                .mnctr_en_bit = 8,
+                .mnctr_reset_bit = 7,
+                .mnctr_mode_shift = 5,
+                .n_val_shift = 16,
+                .m_val_shift = 16,
+                .width = 8,
+        },
+        .p = {
+                .pre_div_shift = 3,
+                .pre_div_width = 2,
+        },
+        .s = {
+                .src_sel_shift = 0,
+                .parent_map = lcc_pxo_pll4_map,
+        },
+        .freq_tbl = clk_tbl_aif_osr,
+        .clkr = {
+                .enable_reg = 0xcc,
+                .enable_mask = BIT(9),
+                .hw.init = &(struct clk_init_data){
+                        .name = "spdif_src",
+                        .parent_names = lcc_pxo_pll4,
+                        .num_parents = 2,
+                        .ops = &clk_rcg_ops,
+                        .flags = CLK_SET_RATE_GATE,
+                },
+        },
+};
+
+static const char *lcc_spdif_parents[] = {
+        "spdif_src",
+};
+
+static struct clk_branch spdif_clk = {
+        .halt_reg = 0xd4,
+        .halt_bit = 1,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0xcc,
+                .enable_mask = BIT(12),
+                .hw.init = &(struct clk_init_data){
+                        .name = "spdif_clk",
+                        .parent_names = lcc_spdif_parents,
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct freq_tbl clk_tbl_ahbix[] = {
+        { 131072, P_PLL4, 1, 1, 3 },
+        { },
+};
+
+static struct clk_rcg ahbix_clk = {
+        .ns_reg = 0x38,
+        .md_reg = 0x3c,
+        .mn = {
+                .mnctr_en_bit = 8,
+                .mnctr_reset_bit = 7,
+                .mnctr_mode_shift = 5,
+                .n_val_shift = 24,
+                .m_val_shift = 8,
+                .width = 8,
+        },
+        .p = {
+                .pre_div_shift = 3,
+                .pre_div_width = 2,
+        },
+        .s = {
+                .src_sel_shift = 0,
+                .parent_map = lcc_pxo_pll4_map,
+        },
+        .freq_tbl = clk_tbl_ahbix,
+        .clkr = {
+                .enable_reg = 0x38,
+                .enable_mask = BIT(10), /* toggle the gfmux to select mn/pxo */
+                .hw.init = &(struct clk_init_data){
+                        .name = "ahbix",
+                        .parent_names = lcc_pxo_pll4,
+                        .num_parents = 2,
+                        .ops = &clk_rcg_ops,
+                        .flags = CLK_SET_RATE_GATE,
+                },
+        },
+};
+
+static struct clk_regmap *lcc_ipq806x_clks[] = {
+        [PLL4] = &pll4.clkr,
+        [MI2S_OSR_SRC] = &mi2s_osr_src.clkr,
+        [MI2S_OSR_CLK] = &mi2s_osr_clk.clkr,
+        [MI2S_DIV_CLK] = &mi2s_div_clk.clkr,
+        [MI2S_BIT_DIV_CLK] = &mi2s_bit_div_clk.clkr,
+        [MI2S_BIT_CLK] = &mi2s_bit_clk.clkr,
+        [PCM_SRC] = &pcm_src.clkr,
+        [PCM_CLK_OUT] = &pcm_clk_out.clkr,
+        [PCM_CLK] = &pcm_clk.clkr,
+        [SPDIF_SRC] = &spdif_src.clkr,
+        [SPDIF_CLK] = &spdif_clk.clkr,
+        [AHBIX_CLK] = &ahbix_clk.clkr,
+};
+
+static const struct regmap_config lcc_ipq806x_regmap_config = {
+        .reg_bits       = 32,
+        .reg_stride     = 4,
+        .val_bits       = 32,
+        .max_register   = 0xfc,
+        .fast_io        = true,
+};
+
+static const struct qcom_cc_desc lcc_ipq806x_desc = {
+        .config = &lcc_ipq806x_regmap_config,
+        .clks = lcc_ipq806x_clks,
+        .num_clks = ARRAY_SIZE(lcc_ipq806x_clks),
+};
+
+static const struct of_device_id lcc_ipq806x_match_table[] = {
+        { .compatible = "qcom,lcc-ipq8064" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, lcc_ipq806x_match_table);
+
+static int lcc_ipq806x_probe(struct platform_device *pdev)
+{
+        u32 val;
+        struct regmap *regmap;
+
+        regmap = qcom_cc_map(pdev, &lcc_ipq806x_desc);
+        if (IS_ERR(regmap))
+                return PTR_ERR(regmap);
+
+        /* Configure the rate of PLL4 if the bootloader hasn't already */
+        val = regmap_read(regmap, 0x0, &val);
+        if (!val)
+                clk_pll_configure_sr(&pll4, regmap, &pll4_config, true);
+        /* Enable PLL4 source on the LPASS Primary PLL Mux */
+        regmap_write(regmap, 0xc4, 0x1);
+
+        return qcom_cc_really_probe(pdev, &lcc_ipq806x_desc, regmap);
+}
+
+static int lcc_ipq806x_remove(struct platform_device *pdev)
+{
+        qcom_cc_remove(pdev);
+        return 0;
+}
+
+static struct platform_driver lcc_ipq806x_driver = {
+        .probe          = lcc_ipq806x_probe,
+        .remove         = lcc_ipq806x_remove,
+        .driver         = {
+                .name   = "lcc-ipq806x",
+                .owner  = THIS_MODULE,
+                .of_match_table = lcc_ipq806x_match_table,
+        },
+};
+module_platform_driver(lcc_ipq806x_driver);
+
+MODULE_DESCRIPTION("QCOM LCC IPQ806x Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:lcc-ipq806x");
diff --git a/drivers/clk/qcom/lcc-msm8960.c b/drivers/clk/qcom/lcc-msm8960.c
new file mode 100644
index 000000000000..a75a408cfccd
--- /dev/null
+++ b/drivers/clk/qcom/lcc-msm8960.c
@@ -0,0 +1,585 @@
+/*
+ * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/bitops.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/clk-provider.h>
+#include <linux/regmap.h>
+
+#include <dt-bindings/clock/qcom,lcc-msm8960.h>
+
+#include "common.h"
+#include "clk-regmap.h"
+#include "clk-pll.h"
+#include "clk-rcg.h"
+#include "clk-branch.h"
+#include "clk-regmap-divider.h"
+#include "clk-regmap-mux.h"
+
+static struct clk_pll pll4 = {
+        .l_reg = 0x4,
+        .m_reg = 0x8,
+        .n_reg = 0xc,
+        .config_reg = 0x14,
+        .mode_reg = 0x0,
+        .status_reg = 0x18,
+        .status_bit = 16,
+        .clkr.hw.init = &(struct clk_init_data){
+                .name = "pll4",
+                .parent_names = (const char *[]){ "pxo" },
+                .num_parents = 1,
+                .ops = &clk_pll_ops,
+        },
+};
+
+#define P_PXO   0
+#define P_PLL4  1
+
+static const u8 lcc_pxo_pll4_map[] = {
+        [P_PXO]         = 0,
+        [P_PLL4]        = 2,
+};
+
+static const char *lcc_pxo_pll4[] = {
+        "pxo",
+        "pll4_vote",
+};
+
+static struct freq_tbl clk_tbl_aif_osr_492[] = {
+        {   512000, P_PLL4, 4, 1, 240 },
+        {   768000, P_PLL4, 4, 1, 160 },
+        {  1024000, P_PLL4, 4, 1, 120 },
+        {  1536000, P_PLL4, 4, 1,  80 },
+        {  2048000, P_PLL4, 4, 1,  60 },
+        {  3072000, P_PLL4, 4, 1,  40 },
+        {  4096000, P_PLL4, 4, 1,  30 },
+        {  6144000, P_PLL4, 4, 1,  20 },
+        {  8192000, P_PLL4, 4, 1,  15 },
+        { 12288000, P_PLL4, 4, 1,  10 },
+        { 24576000, P_PLL4, 4, 1,   5 },
+        { 27000000, P_PXO,  1, 0,   0 },
+        { }
+};
+
+static struct freq_tbl clk_tbl_aif_osr_393[] = {
+        {   512000, P_PLL4, 4, 1, 192 },
+        {   768000, P_PLL4, 4, 1, 128 },
+        {  1024000, P_PLL4, 4, 1,  96 },
+        {  1536000, P_PLL4, 4, 1,  64 },
+        {  2048000, P_PLL4, 4, 1,  48 },
+        {  3072000, P_PLL4, 4, 1,  32 },
+        {  4096000, P_PLL4, 4, 1,  24 },
+        {  6144000, P_PLL4, 4, 1,  16 },
+        {  8192000, P_PLL4, 4, 1,  12 },
+        { 12288000, P_PLL4, 4, 1,   8 },
+        { 24576000, P_PLL4, 4, 1,   4 },
+        { 27000000, P_PXO,  1, 0,   0 },
+        { }
+};
+
+static struct clk_rcg mi2s_osr_src = {
+        .ns_reg = 0x48,
+        .md_reg = 0x4c,
+        .mn = {
+                .mnctr_en_bit = 8,
+                .mnctr_reset_bit = 7,
+                .mnctr_mode_shift = 5,
+                .n_val_shift = 24,
+                .m_val_shift = 8,
+                .width = 8,
+        },
+        .p = {
+                .pre_div_shift = 3,
+                .pre_div_width = 2,
+        },
+        .s = {
+                .src_sel_shift = 0,
+                .parent_map = lcc_pxo_pll4_map,
+        },
+        .freq_tbl = clk_tbl_aif_osr_393,
+        .clkr = {
+                .enable_reg = 0x48,
+                .enable_mask = BIT(9),
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_osr_src",
+                        .parent_names = lcc_pxo_pll4,
+                        .num_parents = 2,
+                        .ops = &clk_rcg_ops,
+                        .flags = CLK_SET_RATE_GATE,
+                },
+        },
+};
+
+static const char *lcc_mi2s_parents[] = {
+        "mi2s_osr_src",
+};
+
+static struct clk_branch mi2s_osr_clk = {
+        .halt_reg = 0x50,
+        .halt_bit = 1,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0x48,
+                .enable_mask = BIT(17),
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_osr_clk",
+                        .parent_names = lcc_mi2s_parents,
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct clk_regmap_div mi2s_div_clk = {
+        .reg = 0x48,
+        .shift = 10,
+        .width = 4,
+        .clkr = {
+                .enable_reg = 0x48,
+                .enable_mask = BIT(15),
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_div_clk",
+                        .parent_names = lcc_mi2s_parents,
+                        .num_parents = 1,
+                        .ops = &clk_regmap_div_ops,
+                },
+        },
+};
+
+static struct clk_branch mi2s_bit_div_clk = {
+        .halt_reg = 0x50,
+        .halt_bit = 0,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0x48,
+                .enable_mask = BIT(15),
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_bit_div_clk",
+                        .parent_names = (const char *[]){ "mi2s_div_clk" },
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct clk_regmap_mux mi2s_bit_clk = {
+        .reg = 0x48,
+        .shift = 14,
+        .width = 1,
+        .clkr = {
+                .hw.init = &(struct clk_init_data){
+                        .name = "mi2s_bit_clk",
+                        .parent_names = (const char *[]){
+                                "mi2s_bit_div_clk",
+                                "mi2s_codec_clk",
+                        },
+                        .num_parents = 2,
+                        .ops = &clk_regmap_mux_closest_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+#define CLK_AIF_OSR_DIV(prefix, _ns, _md, hr)                   \
+static struct clk_rcg prefix##_osr_src = {                      \
+        .ns_reg = _ns,                                          \
+        .md_reg = _md,                                          \
+        .mn = {                                                 \
+                .mnctr_en_bit = 8,                              \
+                .mnctr_reset_bit = 7,                           \
+                .mnctr_mode_shift = 5,                          \
+                .n_val_shift = 24,                              \
+                .m_val_shift = 8,                               \
+                .width = 8,                                     \
+        },                                                      \
+        .p = {                                                  \
+                .pre_div_shift = 3,                             \
+                .pre_div_width = 2,                             \
+        },                                                      \
+        .s = {                                                  \
+                .src_sel_shift = 0,                             \
+                .parent_map = lcc_pxo_pll4_map,                 \
+        },                                                      \
+        .freq_tbl = clk_tbl_aif_osr_393,                        \
+        .clkr = {                                               \
+                .enable_reg = _ns,                              \
+                .enable_mask = BIT(9),                          \
+                .hw.init = &(struct clk_init_data){             \
+                        .name = #prefix "_osr_src",             \
+                        .parent_names = lcc_pxo_pll4,           \
+                        .num_parents = 2,                       \
+                        .ops = &clk_rcg_ops,                    \
+                        .flags = CLK_SET_RATE_GATE,             \
+                },                                              \
+        },                                                      \
+};                                                              \
+                                                                \
+static const char *lcc_##prefix##_parents[] = {                 \
+        #prefix "_osr_src",                                     \
+};                                                              \
+                                                                \
+static struct clk_branch prefix##_osr_clk = {                   \
+        .halt_reg = hr,                                         \
+        .halt_bit = 1,                                          \
+        .halt_check = BRANCH_HALT_ENABLE,                       \
+        .clkr = {                                               \
+                .enable_reg = _ns,                              \
+                .enable_mask = BIT(21),                         \
+                .hw.init = &(struct clk_init_data){             \
+                        .name = #prefix "_osr_clk",             \
+                        .parent_names = lcc_##prefix##_parents, \
+                        .num_parents = 1,                       \
+                        .ops = &clk_branch_ops,                 \
+                        .flags = CLK_SET_RATE_PARENT,           \
+                },                                              \
+        },                                                      \
+};                                                              \
+                                                                \
+static struct clk_regmap_div prefix##_div_clk = {               \
+        .reg = _ns,                                             \
+        .shift = 10,                                            \
+        .width = 8,                                             \
+        .clkr = {                                               \
+                .hw.init = &(struct clk_init_data){             \
+                        .name = #prefix "_div_clk",             \
+                        .parent_names = lcc_##prefix##_parents, \
+                        .num_parents = 1,                       \
+                        .ops = &clk_regmap_div_ops,             \
+                },                                              \
+        },                                                      \
+};                                                              \
+                                                                \
+static struct clk_branch prefix##_bit_div_clk = {               \
+        .halt_reg = hr,                                         \
+        .halt_bit = 0,                                          \
+        .halt_check = BRANCH_HALT_ENABLE,                       \
+        .clkr = {                                               \
+                .enable_reg = _ns,                              \
+                .enable_mask = BIT(19),                         \
+                .hw.init = &(struct clk_init_data){             \
+                        .name = #prefix "_bit_div_clk",         \
+                        .parent_names = (const char *[]){       \
+                                #prefix "_div_clk"              \
+                        },                                      \
+                        .num_parents = 1,                       \
+                        .ops = &clk_branch_ops,                 \
+                        .flags = CLK_SET_RATE_PARENT,           \
+                },                                              \
+        },                                                      \
+};                                                              \
+                                                                \
+static struct clk_regmap_mux prefix##_bit_clk = {               \
+        .reg = _ns,                                             \
+        .shift = 18,                                            \
+        .width = 1,                                             \
+        .clkr = {                                               \
+                .hw.init = &(struct clk_init_data){             \
+                        .name = #prefix "_bit_clk",             \
+                        .parent_names = (const char *[]){       \
+                                #prefix "_bit_div_clk",         \
+                                #prefix "_codec_clk",           \
+                        },                                      \
+                        .num_parents = 2,                       \
+                        .ops = &clk_regmap_mux_closest_ops,     \
+                        .flags = CLK_SET_RATE_PARENT,           \
+                },                                              \
+        },                                                      \
+}
+
+CLK_AIF_OSR_DIV(codec_i2s_mic, 0x60, 0x64, 0x68);
+CLK_AIF_OSR_DIV(spare_i2s_mic, 0x78, 0x7c, 0x80);
+CLK_AIF_OSR_DIV(codec_i2s_spkr, 0x6c, 0x70, 0x74);
+CLK_AIF_OSR_DIV(spare_i2s_spkr, 0x84, 0x88, 0x8c);
+
+static struct freq_tbl clk_tbl_pcm_492[] = {
+        {   256000, P_PLL4, 4, 1, 480 },
+        {   512000, P_PLL4, 4, 1, 240 },
+        {   768000, P_PLL4, 4, 1, 160 },
+        {  1024000, P_PLL4, 4, 1, 120 },
+        {  1536000, P_PLL4, 4, 1,  80 },
+        {  2048000, P_PLL4, 4, 1,  60 },
+        {  3072000, P_PLL4, 4, 1,  40 },
+        {  4096000, P_PLL4, 4, 1,  30 },
+        {  6144000, P_PLL4, 4, 1,  20 },
+        {  8192000, P_PLL4, 4, 1,  15 },
+        { 12288000, P_PLL4, 4, 1,  10 },
+        { 24576000, P_PLL4, 4, 1,   5 },
+        { 27000000, P_PXO,  1, 0,   0 },
+        { }
+};
+
+static struct freq_tbl clk_tbl_pcm_393[] = {
+        {   256000, P_PLL4, 4, 1, 384 },
+        {   512000, P_PLL4, 4, 1, 192 },
+        {   768000, P_PLL4, 4, 1, 128 },
+        {  1024000, P_PLL4, 4, 1,  96 },
+        {  1536000, P_PLL4, 4, 1,  64 },
+        {  2048000, P_PLL4, 4, 1,  48 },
+        {  3072000, P_PLL4, 4, 1,  32 },
+        {  4096000, P_PLL4, 4, 1,  24 },
+        {  6144000, P_PLL4, 4, 1,  16 },
+        {  8192000, P_PLL4, 4, 1,  12 },
+        { 12288000, P_PLL4, 4, 1,   8 },
+        { 24576000, P_PLL4, 4, 1,   4 },
+        { 27000000, P_PXO,  1, 0,   0 },
+        { }
+};
+
+static struct clk_rcg pcm_src = {
+        .ns_reg = 0x54,
+        .md_reg = 0x58,
+        .mn = {
+                .mnctr_en_bit = 8,
+                .mnctr_reset_bit = 7,
+                .mnctr_mode_shift = 5,
+                .n_val_shift = 16,
+                .m_val_shift = 16,
+                .width = 16,
+        },
+        .p = {
+                .pre_div_shift = 3,
+                .pre_div_width = 2,
+        },
+        .s = {
+                .src_sel_shift = 0,
+                .parent_map = lcc_pxo_pll4_map,
+        },
+        .freq_tbl = clk_tbl_pcm_393,
+        .clkr = {
+                .enable_reg = 0x54,
+                .enable_mask = BIT(9),
+                .hw.init = &(struct clk_init_data){
+                        .name = "pcm_src",
+                        .parent_names = lcc_pxo_pll4,
+                        .num_parents = 2,
+                        .ops = &clk_rcg_ops,
+                        .flags = CLK_SET_RATE_GATE,
+                },
+        },
+};
+
+static struct clk_branch pcm_clk_out = {
+        .halt_reg = 0x5c,
+        .halt_bit = 0,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0x54,
+                .enable_mask = BIT(11),
+                .hw.init = &(struct clk_init_data){
+                        .name = "pcm_clk_out",
+                        .parent_names = (const char *[]){ "pcm_src" },
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct clk_regmap_mux pcm_clk = {
+        .reg = 0x54,
+        .shift = 10,
+        .width = 1,
+        .clkr = {
+                .hw.init = &(struct clk_init_data){
+                        .name = "pcm_clk",
+                        .parent_names = (const char *[]){
+                                "pcm_clk_out",
+                                "pcm_codec_clk",
+                        },
+                        .num_parents = 2,
+                        .ops = &clk_regmap_mux_closest_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct clk_rcg slimbus_src = {
+        .ns_reg = 0xcc,
+        .md_reg = 0xd0,
+        .mn = {
+                .mnctr_en_bit = 8,
+                .mnctr_reset_bit = 7,
+                .mnctr_mode_shift = 5,
+                .n_val_shift = 16,
+                .m_val_shift = 16,
+                .width = 8,
+        },
+        .p = {
+                .pre_div_shift = 3,
+                .pre_div_width = 2,
+        },
+        .s = {
+                .src_sel_shift = 0,
+                .parent_map = lcc_pxo_pll4_map,
+        },
+        .freq_tbl = clk_tbl_aif_osr_393,
+        .clkr = {
+                .enable_reg = 0xcc,
+                .enable_mask = BIT(9),
+                .hw.init = &(struct clk_init_data){
+                        .name = "slimbus_src",
+                        .parent_names = lcc_pxo_pll4,
+                        .num_parents = 2,
+                        .ops = &clk_rcg_ops,
+                        .flags = CLK_SET_RATE_GATE,
+                },
+        },
+};
+
+static const char *lcc_slimbus_parents[] = {
+        "slimbus_src",
+};
+
+static struct clk_branch audio_slimbus_clk = {
+        .halt_reg = 0xd4,
+        .halt_bit = 0,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0xcc,
+                .enable_mask = BIT(10),
+                .hw.init = &(struct clk_init_data){
+                        .name = "audio_slimbus_clk",
+                        .parent_names = lcc_slimbus_parents,
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct clk_branch sps_slimbus_clk = {
+        .halt_reg = 0xd4,
+        .halt_bit = 1,
+        .halt_check = BRANCH_HALT_ENABLE,
+        .clkr = {
+                .enable_reg = 0xcc,
+                .enable_mask = BIT(12),
+                .hw.init = &(struct clk_init_data){
+                        .name = "sps_slimbus_clk",
+                        .parent_names = lcc_slimbus_parents,
+                        .num_parents = 1,
+                        .ops = &clk_branch_ops,
+                        .flags = CLK_SET_RATE_PARENT,
+                },
+        },
+};
+
+static struct clk_regmap *lcc_msm8960_clks[] = {
+        [PLL4] = &pll4.clkr,
+        [MI2S_OSR_SRC] = &mi2s_osr_src.clkr,
+        [MI2S_OSR_CLK] = &mi2s_osr_clk.clkr,
+        [MI2S_DIV_CLK] = &mi2s_div_clk.clkr,
+        [MI2S_BIT_DIV_CLK] = &mi2s_bit_div_clk.clkr,
+        [MI2S_BIT_CLK] = &mi2s_bit_clk.clkr,
+        [PCM_SRC] = &pcm_src.clkr,
+        [PCM_CLK_OUT] = &pcm_clk_out.clkr,
+        [PCM_CLK] = &pcm_clk.clkr,
+        [SLIMBUS_SRC] = &slimbus_src.clkr,
+        [AUDIO_SLIMBUS_CLK] = &audio_slimbus_clk.clkr,
+        [SPS_SLIMBUS_CLK] = &sps_slimbus_clk.clkr,
+        [CODEC_I2S_MIC_OSR_SRC] = &codec_i2s_mic_osr_src.clkr,
+        [CODEC_I2S_MIC_OSR_CLK] = &codec_i2s_mic_osr_clk.clkr,
+        [CODEC_I2S_MIC_DIV_CLK] = &codec_i2s_mic_div_clk.clkr,
+        [CODEC_I2S_MIC_BIT_DIV_CLK] = &codec_i2s_mic_bit_div_clk.clkr,
+        [CODEC_I2S_MIC_BIT_CLK] = &codec_i2s_mic_bit_clk.clkr,
+        [SPARE_I2S_MIC_OSR_SRC] = &spare_i2s_mic_osr_src.clkr,
+        [SPARE_I2S_MIC_OSR_CLK] = &spare_i2s_mic_osr_clk.clkr,
+        [SPARE_I2S_MIC_DIV_CLK] = &spare_i2s_mic_div_clk.clkr,
+        [SPARE_I2S_MIC_BIT_DIV_CLK] = &spare_i2s_mic_bit_div_clk.clkr,
+        [SPARE_I2S_MIC_BIT_CLK] = &spare_i2s_mic_bit_clk.clkr,
+        [CODEC_I2S_SPKR_OSR_SRC] = &codec_i2s_spkr_osr_src.clkr,
+        [CODEC_I2S_SPKR_OSR_CLK] = &codec_i2s_spkr_osr_clk.clkr,
+        [CODEC_I2S_SPKR_DIV_CLK] = &codec_i2s_spkr_div_clk.clkr,
+        [CODEC_I2S_SPKR_BIT_DIV_CLK] = &codec_i2s_spkr_bit_div_clk.clkr,
+        [CODEC_I2S_SPKR_BIT_CLK] = &codec_i2s_spkr_bit_clk.clkr,
+        [SPARE_I2S_SPKR_OSR_SRC] = &spare_i2s_spkr_osr_src.clkr,
+        [SPARE_I2S_SPKR_OSR_CLK] = &spare_i2s_spkr_osr_clk.clkr,
+        [SPARE_I2S_SPKR_DIV_CLK] = &spare_i2s_spkr_div_clk.clkr,
+        [SPARE_I2S_SPKR_BIT_DIV_CLK] = &spare_i2s_spkr_bit_div_clk.clkr,
+        [SPARE_I2S_SPKR_BIT_CLK] = &spare_i2s_spkr_bit_clk.clkr,
+};
+
+static const struct regmap_config lcc_msm8960_regmap_config = {
+        .reg_bits       = 32,
+        .reg_stride     = 4,
+        .val_bits       = 32,
+        .max_register   = 0xfc,
+        .fast_io        = true,
+};
+
+static const struct qcom_cc_desc lcc_msm8960_desc = {
+        .config = &lcc_msm8960_regmap_config,
+        .clks = lcc_msm8960_clks,
+        .num_clks = ARRAY_SIZE(lcc_msm8960_clks),
+};
+
+static const struct of_device_id lcc_msm8960_match_table[] = {
+        { .compatible = "qcom,lcc-msm8960" },
+        { .compatible = "qcom,lcc-apq8064" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, lcc_msm8960_match_table);
+
+static int lcc_msm8960_probe(struct platform_device *pdev)
+{
+        u32 val;
+        struct regmap *regmap;
+
+        regmap = qcom_cc_map(pdev, &lcc_msm8960_desc);
+        if (IS_ERR(regmap))
+                return PTR_ERR(regmap);
+
+        /* Use the correct frequency plan depending on speed of PLL4 */
+        val = regmap_read(regmap, 0x4, &val);
+        if (val == 0x12) {
+                slimbus_src.freq_tbl = clk_tbl_aif_osr_492;
+                mi2s_osr_src.freq_tbl = clk_tbl_aif_osr_492;
+                codec_i2s_mic_osr_src.freq_tbl = clk_tbl_aif_osr_492;
+                spare_i2s_mic_osr_src.freq_tbl = clk_tbl_aif_osr_492;
+                codec_i2s_spkr_osr_src.freq_tbl = clk_tbl_aif_osr_492;
+                spare_i2s_spkr_osr_src.freq_tbl = clk_tbl_aif_osr_492;
+                pcm_src.freq_tbl = clk_tbl_pcm_492;
+        }
+        /* Enable PLL4 source on the LPASS Primary PLL Mux */
+        regmap_write(regmap, 0xc4, 0x1);
+
+        return qcom_cc_really_probe(pdev, &lcc_msm8960_desc, regmap);
+}
+
+static int lcc_msm8960_remove(struct platform_device *pdev)
+{
+        qcom_cc_remove(pdev);
+        return 0;
+}
+
+static struct platform_driver lcc_msm8960_driver = {
+        .probe          = lcc_msm8960_probe,
+        .remove         = lcc_msm8960_remove,
+        .driver         = {
+                .name   = "lcc-msm8960",
+                .owner  = THIS_MODULE,
+                .of_match_table = lcc_msm8960_match_table,
+        },
+};
+module_platform_driver(lcc_msm8960_driver);
+
+MODULE_DESCRIPTION("QCOM LCC MSM8960 Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:lcc-msm8960");
diff --git a/drivers/clk/rockchip/clk-rk3288.c b/drivers/clk/rockchip/clk-rk3288.c
index cbcddcc02475..05d7a0bc0599 100644
--- a/drivers/clk/rockchip/clk-rk3288.c
+++ b/drivers/clk/rockchip/clk-rk3288.c
@@ -535,44 +535,44 @@ static struct rockchip_clk_branch rk3288_clk_branches[] __initdata = {
         COMPOSITE(0, "uart0_src", mux_pll_src_cpll_gll_usb_npll_p, 0,
                         RK3288_CLKSEL_CON(13), 13, 2, MFLAGS, 0, 7, DFLAGS,
                         RK3288_CLKGATE_CON(1), 8, GFLAGS),
-        COMPOSITE_FRAC(0, "uart0_frac", "uart0_src", 0,
+        COMPOSITE_FRAC(0, "uart0_frac", "uart0_src", CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(17), 0,
                         RK3288_CLKGATE_CON(1), 9, GFLAGS),
-        MUX(SCLK_UART0, "sclk_uart0", mux_uart0_p, 0,
+        MUX(SCLK_UART0, "sclk_uart0", mux_uart0_p, CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(13), 8, 2, MFLAGS),
         MUX(0, "uart_src", mux_pll_src_cpll_gpll_p, 0,
                         RK3288_CLKSEL_CON(13), 15, 1, MFLAGS),
         COMPOSITE_NOMUX(0, "uart1_src", "uart_src", 0,
                         RK3288_CLKSEL_CON(14), 0, 7, DFLAGS,
                         RK3288_CLKGATE_CON(1), 10, GFLAGS),
-        COMPOSITE_FRAC(0, "uart1_frac", "uart1_src", 0,
+        COMPOSITE_FRAC(0, "uart1_frac", "uart1_src", CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(18), 0,
                         RK3288_CLKGATE_CON(1), 11, GFLAGS),
-        MUX(SCLK_UART1, "sclk_uart1", mux_uart1_p, 0,
+        MUX(SCLK_UART1, "sclk_uart1", mux_uart1_p, CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(14), 8, 2, MFLAGS),
         COMPOSITE_NOMUX(0, "uart2_src", "uart_src", 0,
                         RK3288_CLKSEL_CON(15), 0, 7, DFLAGS,
                         RK3288_CLKGATE_CON(1), 12, GFLAGS),
-        COMPOSITE_FRAC(0, "uart2_frac", "uart2_src", 0,
+        COMPOSITE_FRAC(0, "uart2_frac", "uart2_src", CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(19), 0,
                         RK3288_CLKGATE_CON(1), 13, GFLAGS),
-        MUX(SCLK_UART2, "sclk_uart2", mux_uart2_p, 0,
+        MUX(SCLK_UART2, "sclk_uart2", mux_uart2_p, CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(15), 8, 2, MFLAGS),
         COMPOSITE_NOMUX(0, "uart3_src", "uart_src", 0,
                         RK3288_CLKSEL_CON(16), 0, 7, DFLAGS,
                         RK3288_CLKGATE_CON(1), 14, GFLAGS),
-        COMPOSITE_FRAC(0, "uart3_frac", "uart3_src", 0,
+        COMPOSITE_FRAC(0, "uart3_frac", "uart3_src", CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(20), 0,
                         RK3288_CLKGATE_CON(1), 15, GFLAGS),
-        MUX(SCLK_UART3, "sclk_uart3", mux_uart3_p, 0,
+        MUX(SCLK_UART3, "sclk_uart3", mux_uart3_p, CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(16), 8, 2, MFLAGS),
         COMPOSITE_NOMUX(0, "uart4_src", "uart_src", 0,
                         RK3288_CLKSEL_CON(3), 0, 7, DFLAGS,
                         RK3288_CLKGATE_CON(2), 12, GFLAGS),
-        COMPOSITE_FRAC(0, "uart4_frac", "uart4_src", 0,
+        COMPOSITE_FRAC(0, "uart4_frac", "uart4_src", CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(7), 0,
                         RK3288_CLKGATE_CON(2), 13, GFLAGS),
-        MUX(SCLK_UART4, "sclk_uart4", mux_uart4_p, 0,
+        MUX(SCLK_UART4, "sclk_uart4", mux_uart4_p, CLK_SET_RATE_PARENT,
                         RK3288_CLKSEL_CON(3), 8, 2, MFLAGS),
 
         COMPOSITE(0, "mac_pll_src", mux_pll_src_npll_cpll_gpll_p, 0,
@@ -598,7 +598,7 @@ static struct rockchip_clk_branch rk3288_clk_branches[] __initdata = {
         GATE(0, "jtag", "ext_jtag", 0,
                         RK3288_CLKGATE_CON(4), 14, GFLAGS),
 
-        COMPOSITE_NODIV(0, "usbphy480m_src", mux_usbphy480m_p, 0,
+        COMPOSITE_NODIV(SCLK_USBPHY480M_SRC, "usbphy480m_src", mux_usbphy480m_p, 0,
                         RK3288_CLKSEL_CON(13), 11, 2, MFLAGS,
                         RK3288_CLKGATE_CON(5), 14, GFLAGS),
         COMPOSITE_NODIV(SCLK_HSICPHY480M, "sclk_hsicphy480m", mux_hsicphy480m_p, 0,
@@ -704,8 +704,8 @@ static struct rockchip_clk_branch rk3288_clk_branches[] __initdata = {
 
         GATE(SCLK_LCDC_PWM0, "sclk_lcdc_pwm0", "xin24m", 0, RK3288_CLKGATE_CON(13), 10, GFLAGS),
         GATE(SCLK_LCDC_PWM1, "sclk_lcdc_pwm1", "xin24m", 0, RK3288_CLKGATE_CON(13), 11, GFLAGS),
-        GATE(0, "sclk_pvtm_core", "xin24m", 0, RK3288_CLKGATE_CON(5), 9, GFLAGS),
-        GATE(0, "sclk_pvtm_gpu", "xin24m", 0, RK3288_CLKGATE_CON(5), 10, GFLAGS),
+        GATE(SCLK_PVTM_CORE, "sclk_pvtm_core", "xin24m", 0, RK3288_CLKGATE_CON(5), 9, GFLAGS),
+        GATE(SCLK_PVTM_GPU, "sclk_pvtm_gpu", "xin24m", 0, RK3288_CLKGATE_CON(5), 10, GFLAGS),
         GATE(0, "sclk_mipidsi_24m", "xin24m", 0, RK3288_CLKGATE_CON(5), 15, GFLAGS),
 
         /* sclk_gpu gates */
@@ -805,6 +805,20 @@ static int rk3288_clk_suspend(void)
                 rk3288_saved_cru_regs[i] =
                                 readl_relaxed(rk3288_cru_base + reg_id);
         }
+
+        /*
+         * Switch PLLs other than DPLL (for SDRAM) to slow mode to
+         * avoid crashes on resume. The Mask ROM on the system will
+         * put APLL, CPLL, and GPLL into slow mode at resume time
+         * anyway (which is why we restore them), but we might not
+         * even make it to the Mask ROM if this isn't done at suspend
+         * time.
+         *
+         * NOTE: only APLL truly matters here, but we'll do them all.
+         */
+
+        writel_relaxed(0xf3030000, rk3288_cru_base + RK3288_MODE_CON);
+
         return 0;
 }
 
@@ -866,6 +880,14 @@ static void __init rk3288_clk_init(struct device_node *np)
                 pr_warn("%s: could not register clock hclk_vcodec_pre: %ld\n",
                         __func__, PTR_ERR(clk));
 
+        /* Watchdog pclk is controlled by RK3288_SGRF_SOC_CON0[1]. */
+        clk = clk_register_fixed_factor(NULL, "pclk_wdt", "pclk_pd_alive", 0, 1, 1);
+        if (IS_ERR(clk))
+                pr_warn("%s: could not register clock pclk_wdt: %ld\n",
+                        __func__, PTR_ERR(clk));
+        else
+                rockchip_clk_add_lookup(clk, PCLK_WDT);
+
         rockchip_clk_register_plls(rk3288_pll_clks,
                                    ARRAY_SIZE(rk3288_pll_clks),
                                    RK3288_GRF_SOC_STATUS1);
diff --git a/drivers/clk/samsung/clk-exynos-audss.c b/drivers/clk/samsung/clk-exynos-audss.c
index f2c2ccce49bb..454b02ae486a 100644
--- a/drivers/clk/samsung/clk-exynos-audss.c
+++ b/drivers/clk/samsung/clk-exynos-audss.c
@@ -82,6 +82,26 @@ static const struct of_device_id exynos_audss_clk_of_match[] = {
         {},
 };
 
+static void exynos_audss_clk_teardown(void)
+{
+        int i;
+
+        for (i = EXYNOS_MOUT_AUDSS; i < EXYNOS_DOUT_SRP; i++) {
+                if (!IS_ERR(clk_table[i]))
+                        clk_unregister_mux(clk_table[i]);
+        }
+
+        for (; i < EXYNOS_SRP_CLK; i++) {
+                if (!IS_ERR(clk_table[i]))
+                        clk_unregister_divider(clk_table[i]);
+        }
+
+        for (; i < clk_data.clk_num; i++) {
+                if (!IS_ERR(clk_table[i]))
+                        clk_unregister_gate(clk_table[i]);
+        }
+}
+
 /* register exynos_audss clocks */
 static int exynos_audss_clk_probe(struct platform_device *pdev)
 {
@@ -219,10 +239,7 @@ static int exynos_audss_clk_probe(struct platform_device *pdev)
         return 0;
 
 unregister:
-        for (i = 0; i < clk_data.clk_num; i++) {
-                if (!IS_ERR(clk_table[i]))
-                        clk_unregister(clk_table[i]);
-        }
+        exynos_audss_clk_teardown();
 
         if (!IS_ERR(epll))
                 clk_disable_unprepare(epll);
@@ -232,18 +249,13 @@ unregister:
 
 static int exynos_audss_clk_remove(struct platform_device *pdev)
 {
-        int i;
-
 #ifdef CONFIG_PM_SLEEP
         unregister_syscore_ops(&exynos_audss_clk_syscore_ops);
 #endif
 
         of_clk_del_provider(pdev->dev.of_node);
 
-        for (i = 0; i < clk_data.clk_num; i++) {
-                if (!IS_ERR(clk_table[i]))
-                        clk_unregister(clk_table[i]);
-        }
+        exynos_audss_clk_teardown();
 
         if (!IS_ERR(epll))
                 clk_disable_unprepare(epll);
diff --git a/drivers/clk/samsung/clk-exynos3250.c b/drivers/clk/samsung/clk-exynos3250.c
index 6e6cca392082..cc4c348d8a24 100644
--- a/drivers/clk/samsung/clk-exynos3250.c
+++ b/drivers/clk/samsung/clk-exynos3250.c
@@ -104,27 +104,6 @@
 #define PWR_CTRL1_USE_CORE1_WFI                 (1 << 1)
 #define PWR_CTRL1_USE_CORE0_WFI                 (1 << 0)
 
-/* list of PLLs to be registered */
-enum exynos3250_plls {
-        apll, mpll, vpll, upll,
-        nr_plls
-};
-
-/* list of PLLs in DMC block to be registered */
-enum exynos3250_dmc_plls {
-        bpll, epll,
-        nr_dmc_plls
-};
-
-static void __iomem *reg_base;
-static void __iomem *dmc_reg_base;
-
-/*
- * Support for CMU save/restore across system suspends
- */
-#ifdef CONFIG_PM_SLEEP
-static struct samsung_clk_reg_dump *exynos3250_clk_regs;
-
 static unsigned long exynos3250_cmu_clk_regs[] __initdata = {
         SRC_LEFTBUS,
         DIV_LEFTBUS,
@@ -195,43 +174,6 @@ static unsigned long exynos3250_cmu_clk_regs[] __initdata = {
         PWR_CTRL2,
 };
 
-static int exynos3250_clk_suspend(void)
-{
-        samsung_clk_save(reg_base, exynos3250_clk_regs,
-                                ARRAY_SIZE(exynos3250_cmu_clk_regs));
-        return 0;
-}
-
-static void exynos3250_clk_resume(void)
-{
-        samsung_clk_restore(reg_base, exynos3250_clk_regs,
-                                ARRAY_SIZE(exynos3250_cmu_clk_regs));
-}
-
-static struct syscore_ops exynos3250_clk_syscore_ops = {
-        .suspend = exynos3250_clk_suspend,
-        .resume = exynos3250_clk_resume,
-};
-
-static void exynos3250_clk_sleep_init(void)
-{
-        exynos3250_clk_regs =
-                samsung_clk_alloc_reg_dump(exynos3250_cmu_clk_regs,
-                                           ARRAY_SIZE(exynos3250_cmu_clk_regs));
-        if (!exynos3250_clk_regs) {
-                pr_warn("%s: Failed to allocate sleep save data\n", __func__);
-                goto err;
-        }
-
-        register_syscore_ops(&exynos3250_clk_syscore_ops);
-        return;
-err:
-        kfree(exynos3250_clk_regs);
-}
-#else
-static inline void exynos3250_clk_sleep_init(void) { }
-#endif
-
 /* list of all parent clock list */
 PNAME(mout_vpllsrc_p)           = { "fin_pll", };
 
@@ -782,18 +724,18 @@ static struct samsung_pll_rate_table exynos3250_vpll_rates[] = {
         { /* sentinel */ }
 };
 
-static struct samsung_pll_clock exynos3250_plls[nr_plls] __initdata = {
-        [apll] = PLL(pll_35xx, CLK_FOUT_APLL, "fout_apll", "fin_pll",
-                        APLL_LOCK, APLL_CON0, NULL),
-        [mpll] = PLL(pll_35xx, CLK_FOUT_MPLL, "fout_mpll", "fin_pll",
-                        MPLL_LOCK, MPLL_CON0, NULL),
-        [vpll] = PLL(pll_36xx, CLK_FOUT_VPLL, "fout_vpll", "fin_pll",
-                        VPLL_LOCK, VPLL_CON0, NULL),
-        [upll] = PLL(pll_35xx, CLK_FOUT_UPLL, "fout_upll", "fin_pll",
-                        UPLL_LOCK, UPLL_CON0, NULL),
+static struct samsung_pll_clock exynos3250_plls[] __initdata = {
+        PLL(pll_35xx, CLK_FOUT_APLL, "fout_apll", "fin_pll",
+                APLL_LOCK, APLL_CON0, exynos3250_pll_rates),
+        PLL(pll_35xx, CLK_FOUT_MPLL, "fout_mpll", "fin_pll",
+                        MPLL_LOCK, MPLL_CON0, exynos3250_pll_rates),
+        PLL(pll_36xx, CLK_FOUT_VPLL, "fout_vpll", "fin_pll",
+                        VPLL_LOCK, VPLL_CON0, exynos3250_vpll_rates),
+        PLL(pll_35xx, CLK_FOUT_UPLL, "fout_upll", "fin_pll",
+                        UPLL_LOCK, UPLL_CON0, exynos3250_pll_rates),
 };
 
-static void __init exynos3_core_down_clock(void)
+static void __init exynos3_core_down_clock(void __iomem *reg_base)
 {
         unsigned int tmp;
 
@@ -814,38 +756,31 @@ static void __init exynos3_core_down_clock(void)
         __raw_writel(0x0, reg_base + PWR_CTRL2);
 }
 
+static struct samsung_cmu_info cmu_info __initdata = {
+        .pll_clks               = exynos3250_plls,
+        .nr_pll_clks            = ARRAY_SIZE(exynos3250_plls),
+        .mux_clks               = mux_clks,
+        .nr_mux_clks            = ARRAY_SIZE(mux_clks),
+        .div_clks               = div_clks,
+        .nr_div_clks            = ARRAY_SIZE(div_clks),
+        .gate_clks              = gate_clks,
+        .nr_gate_clks           = ARRAY_SIZE(gate_clks),
+        .fixed_factor_clks      = fixed_factor_clks,
+        .nr_fixed_factor_clks   = ARRAY_SIZE(fixed_factor_clks),
+        .nr_clk_ids             = CLK_NR_CLKS,
+        .clk_regs               = exynos3250_cmu_clk_regs,
+        .nr_clk_regs            = ARRAY_SIZE(exynos3250_cmu_clk_regs),
+};
+
 static void __init exynos3250_cmu_init(struct device_node *np)
 {
         struct samsung_clk_provider *ctx;
 
-        reg_base = of_iomap(np, 0);
-        if (!reg_base)
-                panic("%s: failed to map registers\n", __func__);
-
-        ctx = samsung_clk_init(np, reg_base, CLK_NR_CLKS);
+        ctx = samsung_cmu_register_one(np, &cmu_info);
         if (!ctx)
-                panic("%s: unable to allocate context.\n", __func__);
-
-        samsung_clk_register_fixed_factor(ctx, fixed_factor_clks,
-                                          ARRAY_SIZE(fixed_factor_clks));
-
-        exynos3250_plls[apll].rate_table = exynos3250_pll_rates;
-        exynos3250_plls[mpll].rate_table = exynos3250_pll_rates;
-        exynos3250_plls[vpll].rate_table = exynos3250_vpll_rates;
-        exynos3250_plls[upll].rate_table = exynos3250_pll_rates;
-
-        samsung_clk_register_pll(ctx, exynos3250_plls,
-                                        ARRAY_SIZE(exynos3250_plls), reg_base);
-
-        samsung_clk_register_mux(ctx, mux_clks, ARRAY_SIZE(mux_clks));
-        samsung_clk_register_div(ctx, div_clks, ARRAY_SIZE(div_clks));
-        samsung_clk_register_gate(ctx, gate_clks, ARRAY_SIZE(gate_clks));
-
-        exynos3_core_down_clock();
+                return;
 
-        exynos3250_clk_sleep_init();
-
-        samsung_clk_of_add_provider(np, ctx);
+        exynos3_core_down_clock(ctx->reg_base);
 }
 CLK_OF_DECLARE(exynos3250_cmu, "samsung,exynos3250-cmu", exynos3250_cmu_init);
 
@@ -872,12 +807,6 @@ CLK_OF_DECLARE(exynos3250_cmu, "samsung,exynos3250-cmu", exynos3250_cmu_init);
 #define EPLL_CON2               0x111c
 #define SRC_EPLL                0x1120
 
-/*
- * Support for CMU save/restore across system suspends
- */
-#ifdef CONFIG_PM_SLEEP
-static struct samsung_clk_reg_dump *exynos3250_dmc_clk_regs;
-
 static unsigned long exynos3250_cmu_dmc_clk_regs[] __initdata = {
         BPLL_LOCK,
         BPLL_CON0,
@@ -899,43 +828,6 @@ static unsigned long exynos3250_cmu_dmc_clk_regs[] __initdata = {
         SRC_EPLL,
 };
 
-static int exynos3250_dmc_clk_suspend(void)
-{
-        samsung_clk_save(dmc_reg_base, exynos3250_dmc_clk_regs,
-                                ARRAY_SIZE(exynos3250_cmu_dmc_clk_regs));
-        return 0;
-}
-
-static void exynos3250_dmc_clk_resume(void)
-{
-        samsung_clk_restore(dmc_reg_base, exynos3250_dmc_clk_regs,
-                                ARRAY_SIZE(exynos3250_cmu_dmc_clk_regs));
-}
-
-static struct syscore_ops exynos3250_dmc_clk_syscore_ops = {
-        .suspend = exynos3250_dmc_clk_suspend,
-        .resume = exynos3250_dmc_clk_resume,
-};
-
-static void exynos3250_dmc_clk_sleep_init(void)
-{
-        exynos3250_dmc_clk_regs =
-                samsung_clk_alloc_reg_dump(exynos3250_cmu_dmc_clk_regs,
-                                   ARRAY_SIZE(exynos3250_cmu_dmc_clk_regs));
-        if (!exynos3250_dmc_clk_regs) {
-                pr_warn("%s: Failed to allocate sleep save data\n", __func__);
-                goto err;
-        }
-
-        register_syscore_ops(&exynos3250_dmc_clk_syscore_ops);
-        return;
-err:
-        kfree(exynos3250_dmc_clk_regs);
-}
-#else
-static inline void exynos3250_dmc_clk_sleep_init(void) { }
-#endif
-
 PNAME(mout_epll_p)      = { "fin_pll", "fout_epll", };
 PNAME(mout_bpll_p)      = { "fin_pll", "fout_bpll", };
 PNAME(mout_mpll_mif_p)  = { "fin_pll", "sclk_mpll_mif", };
@@ -977,43 +869,28 @@ static struct samsung_div_clock dmc_div_clks[] __initdata = {
         DIV(CLK_DIV_DMCD, "div_dmcd", "div_dmc", DIV_DMC1, 11, 3),
 };
 
-static struct samsung_pll_clock exynos3250_dmc_plls[nr_dmc_plls] __initdata = {
-        [bpll] = PLL(pll_35xx, CLK_FOUT_BPLL, "fout_bpll", "fin_pll",
-                        BPLL_LOCK, BPLL_CON0, NULL),
-        [epll] = PLL(pll_36xx, CLK_FOUT_EPLL, "fout_epll", "fin_pll",
-                        EPLL_LOCK, EPLL_CON0, NULL),
+static struct samsung_pll_clock exynos3250_dmc_plls[] __initdata = {
+        PLL(pll_35xx, CLK_FOUT_BPLL, "fout_bpll", "fin_pll",
+                BPLL_LOCK, BPLL_CON0, exynos3250_pll_rates),
+        PLL(pll_36xx, CLK_FOUT_EPLL, "fout_epll", "fin_pll",
+                EPLL_LOCK, EPLL_CON0, exynos3250_epll_rates),
+};
+
+static struct samsung_cmu_info dmc_cmu_info __initdata = {
+        .pll_clks               = exynos3250_dmc_plls,
+        .nr_pll_clks            = ARRAY_SIZE(exynos3250_dmc_plls),
+        .mux_clks               = dmc_mux_clks,
+        .nr_mux_clks            = ARRAY_SIZE(dmc_mux_clks),
+        .div_clks               = dmc_div_clks,
+        .nr_div_clks            = ARRAY_SIZE(dmc_div_clks),
+        .nr_clk_ids             = NR_CLKS_DMC,
+        .clk_regs               = exynos3250_cmu_dmc_clk_regs,
+        .nr_clk_regs            = ARRAY_SIZE(exynos3250_cmu_dmc_clk_regs),
 };
 
 static void __init exynos3250_cmu_dmc_init(struct device_node *np)
 {
-        struct samsung_clk_provider *ctx;
-
-        dmc_reg_base = of_iomap(np, 0);
-        if (!dmc_reg_base)
-                panic("%s: failed to map registers\n", __func__);
-
-        ctx = samsung_clk_init(np, dmc_reg_base, NR_CLKS_DMC);
-        if (!ctx)
-                panic("%s: unable to allocate context.\n", __func__);
-
-        exynos3250_dmc_plls[bpll].rate_table = exynos3250_pll_rates;
-        exynos3250_dmc_plls[epll].rate_table = exynos3250_epll_rates;
-
-        pr_err("CLK registering epll bpll: %d, %d, %d, %d\n",
-                        exynos3250_dmc_plls[bpll].rate_table[0].rate,
-                        exynos3250_dmc_plls[bpll].rate_table[0].mdiv,
-                        exynos3250_dmc_plls[bpll].rate_table[0].pdiv,
-                        exynos3250_dmc_plls[bpll].rate_table[0].sdiv
-              );
-        samsung_clk_register_pll(ctx, exynos3250_dmc_plls,
-                                ARRAY_SIZE(exynos3250_dmc_plls), dmc_reg_base);
-
-        samsung_clk_register_mux(ctx, dmc_mux_clks, ARRAY_SIZE(dmc_mux_clks));
-        samsung_clk_register_div(ctx, dmc_div_clks, ARRAY_SIZE(dmc_div_clks));
-
-        exynos3250_dmc_clk_sleep_init();
-
-        samsung_clk_of_add_provider(np, ctx);
+        samsung_cmu_register_one(np, &dmc_cmu_info);
 }
 CLK_OF_DECLARE(exynos3250_cmu_dmc, "samsung,exynos3250-cmu-dmc",
                 exynos3250_cmu_dmc_init);
diff --git a/drivers/clk/samsung/clk-exynos4.c b/drivers/clk/samsung/clk-exynos4.c
index 88e8c6bbd77f..51462e85675f 100644
--- a/drivers/clk/samsung/clk-exynos4.c
+++ b/drivers/clk/samsung/clk-exynos4.c
@@ -703,12 +703,12 @@ static struct samsung_mux_clock exynos4x12_mux_clks[] __initdata = {
 
 /* list of divider clocks supported in all exynos4 soc's */
 static struct samsung_div_clock exynos4_div_clks[] __initdata = {
-        DIV(0, "div_gdl", "mout_gdl", DIV_LEFTBUS, 0, 3),
+        DIV(CLK_DIV_GDL, "div_gdl", "mout_gdl", DIV_LEFTBUS, 0, 3),
         DIV(0, "div_gpl", "div_gdl", DIV_LEFTBUS, 4, 3),
         DIV(0, "div_clkout_leftbus", "mout_clkout_leftbus",
                         CLKOUT_CMU_LEFTBUS, 8, 6),
 
-        DIV(0, "div_gdr", "mout_gdr", DIV_RIGHTBUS, 0, 3),
+        DIV(CLK_DIV_GDR, "div_gdr", "mout_gdr", DIV_RIGHTBUS, 0, 3),
         DIV(0, "div_gpr", "div_gdr", DIV_RIGHTBUS, 4, 3),
         DIV(0, "div_clkout_rightbus", "mout_clkout_rightbus",
                         CLKOUT_CMU_RIGHTBUS, 8, 6),
@@ -781,10 +781,10 @@ static struct samsung_div_clock exynos4_div_clks[] __initdata = {
                         CLK_SET_RATE_PARENT, 0),
         DIV(0, "div_clkout_top", "mout_clkout_top", CLKOUT_CMU_TOP, 8, 6),
 
-        DIV(0, "div_acp", "mout_dmc_bus", DIV_DMC0, 0, 3),
+        DIV(CLK_DIV_ACP, "div_acp", "mout_dmc_bus", DIV_DMC0, 0, 3),
         DIV(0, "div_acp_pclk", "div_acp", DIV_DMC0, 4, 3),
         DIV(0, "div_dphy", "mout_dphy", DIV_DMC0, 8, 3),
-        DIV(0, "div_dmc", "mout_dmc_bus", DIV_DMC0, 12, 3),
+        DIV(CLK_DIV_DMC, "div_dmc", "mout_dmc_bus", DIV_DMC0, 12, 3),
         DIV(0, "div_dmcd", "div_dmc", DIV_DMC0, 16, 3),
         DIV(0, "div_dmcp", "div_dmcd", DIV_DMC0, 20, 3),
         DIV(0, "div_pwi", "mout_pwi", DIV_DMC1, 8, 4),
@@ -829,7 +829,7 @@ static struct samsung_div_clock exynos4x12_div_clks[] __initdata = {
         DIV_F(CLK_DIV_MCUISP1, "div_mcuisp1", "div_mcuisp0", E4X12_DIV_ISP1,
                                                 8, 3, CLK_GET_RATE_NOCACHE, 0),
         DIV(CLK_SCLK_FIMG2D, "sclk_fimg2d", "mout_g2d", DIV_DMC1, 0, 4),
-        DIV(0, "div_c2c", "mout_c2c", DIV_DMC1, 4, 3),
+        DIV(CLK_DIV_C2C, "div_c2c", "mout_c2c", DIV_DMC1, 4, 3),
         DIV(0, "div_c2c_aclk", "div_c2c", DIV_DMC1, 12, 3),
 };
 
diff --git a/drivers/clk/samsung/clk-exynos4415.c b/drivers/clk/samsung/clk-exynos4415.c
index 2123fc251e0f..6c78b09c829f 100644
--- a/drivers/clk/samsung/clk-exynos4415.c
+++ b/drivers/clk/samsung/clk-exynos4415.c
@@ -113,19 +113,6 @@
 #define DIV_CPU0                0x14500
 #define DIV_CPU1                0x14504
 
-enum exynos4415_plls {
-        apll, epll, g3d_pll, isp_pll, disp_pll,
-        nr_plls,
-};
-
-static struct samsung_clk_provider *exynos4415_ctx;
-
-/*
- * Support for CMU save/restore across system suspends
- */
-#ifdef CONFIG_PM_SLEEP
-static struct samsung_clk_reg_dump *exynos4415_clk_regs;
-
 static unsigned long exynos4415_cmu_clk_regs[] __initdata = {
         SRC_LEFTBUS,
         DIV_LEFTBUS,
@@ -219,41 +206,6 @@ static unsigned long exynos4415_cmu_clk_regs[] __initdata = {
         DIV_CPU1,
 };
 
-static int exynos4415_clk_suspend(void)
-{
-        samsung_clk_save(exynos4415_ctx->reg_base, exynos4415_clk_regs,
-                                ARRAY_SIZE(exynos4415_cmu_clk_regs));
-
-        return 0;
-}
-
-static void exynos4415_clk_resume(void)
-{
-        samsung_clk_restore(exynos4415_ctx->reg_base, exynos4415_clk_regs,
-                                ARRAY_SIZE(exynos4415_cmu_clk_regs));
-}
-
-static struct syscore_ops exynos4415_clk_syscore_ops = {
-        .suspend = exynos4415_clk_suspend,
-        .resume = exynos4415_clk_resume,
-};
-
-static void exynos4415_clk_sleep_init(void)
-{
-        exynos4415_clk_regs =
-                samsung_clk_alloc_reg_dump(exynos4415_cmu_clk_regs,
-                                        ARRAY_SIZE(exynos4415_cmu_clk_regs));
-        if (!exynos4415_clk_regs) {
-                pr_warn("%s: Failed to allocate sleep save data\n", __func__);
-                return;
-        }
-
-        register_syscore_ops(&exynos4415_clk_syscore_ops);
-}
-#else
-static inline void exynos4415_clk_sleep_init(void) { }
-#endif
-
 /* list of all parent clock list */
 PNAME(mout_g3d_pllsrc_p)        = { "fin_pll", };
 
@@ -959,56 +911,40 @@ static struct samsung_pll_rate_table exynos4415_epll_rates[] = {
         { /* sentinel */ }
 };
 
-static struct samsung_pll_clock exynos4415_plls[nr_plls] __initdata = {
-        [apll] = PLL(pll_35xx, CLK_FOUT_APLL, "fout_apll", "fin_pll",
-                        APLL_LOCK, APLL_CON0, NULL),
-        [epll] = PLL(pll_36xx, CLK_FOUT_EPLL, "fout_epll", "fin_pll",
-                        EPLL_LOCK, EPLL_CON0, NULL),
-        [g3d_pll] = PLL(pll_35xx, CLK_FOUT_G3D_PLL, "fout_g3d_pll",
-                        "mout_g3d_pllsrc", G3D_PLL_LOCK, G3D_PLL_CON0, NULL),
-        [isp_pll] = PLL(pll_35xx, CLK_FOUT_ISP_PLL, "fout_isp_pll", "fin_pll",
-                        ISP_PLL_LOCK, ISP_PLL_CON0, NULL),
-        [disp_pll] = PLL(pll_35xx, CLK_FOUT_DISP_PLL, "fout_disp_pll",
-                        "fin_pll", DISP_PLL_LOCK, DISP_PLL_CON0, NULL),
+static struct samsung_pll_clock exynos4415_plls[] __initdata = {
+        PLL(pll_35xx, CLK_FOUT_APLL, "fout_apll", "fin_pll",
+                APLL_LOCK, APLL_CON0, exynos4415_pll_rates),
+        PLL(pll_36xx, CLK_FOUT_EPLL, "fout_epll", "fin_pll",
+                EPLL_LOCK, EPLL_CON0, exynos4415_epll_rates),
+        PLL(pll_35xx, CLK_FOUT_G3D_PLL, "fout_g3d_pll", "mout_g3d_pllsrc",
+                G3D_PLL_LOCK, G3D_PLL_CON0, exynos4415_pll_rates),
+        PLL(pll_35xx, CLK_FOUT_ISP_PLL, "fout_isp_pll", "fin_pll",
+                ISP_PLL_LOCK, ISP_PLL_CON0, exynos4415_pll_rates),
+        PLL(pll_35xx, CLK_FOUT_DISP_PLL, "fout_disp_pll",
+                "fin_pll", DISP_PLL_LOCK, DISP_PLL_CON0, exynos4415_pll_rates),
+};
+
+static struct samsung_cmu_info cmu_info __initdata = {
+        .pll_clks               = exynos4415_plls,
+        .nr_pll_clks            = ARRAY_SIZE(exynos4415_plls),
+        .mux_clks               = exynos4415_mux_clks,
+        .nr_mux_clks            = ARRAY_SIZE(exynos4415_mux_clks),
+        .div_clks               = exynos4415_div_clks,
+        .nr_div_clks            = ARRAY_SIZE(exynos4415_div_clks),
+        .gate_clks              = exynos4415_gate_clks,
+        .nr_gate_clks           = ARRAY_SIZE(exynos4415_gate_clks),
+        .fixed_clks             = exynos4415_fixed_rate_clks,
+        .nr_fixed_clks          = ARRAY_SIZE(exynos4415_fixed_rate_clks),
+        .fixed_factor_clks      = exynos4415_fixed_factor_clks,
+        .nr_fixed_factor_clks   = ARRAY_SIZE(exynos4415_fixed_factor_clks),
+        .nr_clk_ids             = CLK_NR_CLKS,
+        .clk_regs               = exynos4415_cmu_clk_regs,
+        .nr_clk_regs            = ARRAY_SIZE(exynos4415_cmu_clk_regs),
 };
 
 static void __init exynos4415_cmu_init(struct device_node *np)
 {
-        void __iomem *reg_base;
-
-        reg_base = of_iomap(np, 0);
-        if (!reg_base)
-                panic("%s: failed to map registers\n", __func__);
-
-        exynos4415_ctx = samsung_clk_init(np, reg_base, CLK_NR_CLKS);
-        if (!exynos4415_ctx)
-                panic("%s: unable to allocate context.\n", __func__);
-
-        exynos4415_plls[apll].rate_table = exynos4415_pll_rates;
-        exynos4415_plls[epll].rate_table = exynos4415_epll_rates;
-        exynos4415_plls[g3d_pll].rate_table = exynos4415_pll_rates;
-        exynos4415_plls[isp_pll].rate_table = exynos4415_pll_rates;
-        exynos4415_plls[disp_pll].rate_table = exynos4415_pll_rates;
-
-        samsung_clk_register_fixed_factor(exynos4415_ctx,
-                                exynos4415_fixed_factor_clks,
-                                ARRAY_SIZE(exynos4415_fixed_factor_clks));
-        samsung_clk_register_fixed_rate(exynos4415_ctx,
-                                exynos4415_fixed_rate_clks,
-                                ARRAY_SIZE(exynos4415_fixed_rate_clks));
-
-        samsung_clk_register_pll(exynos4415_ctx, exynos4415_plls,
-                                ARRAY_SIZE(exynos4415_plls), reg_base);
-        samsung_clk_register_mux(exynos4415_ctx, exynos4415_mux_clks,
-                                ARRAY_SIZE(exynos4415_mux_clks));
-        samsung_clk_register_div(exynos4415_ctx, exynos4415_div_clks,
-                                ARRAY_SIZE(exynos4415_div_clks));
-        samsung_clk_register_gate(exynos4415_ctx, exynos4415_gate_clks,
-                                ARRAY_SIZE(exynos4415_gate_clks));
-
-        exynos4415_clk_sleep_init();
-
-        samsung_clk_of_add_provider(np, exynos4415_ctx);
+        samsung_cmu_register_one(np, &cmu_info);
 }
 CLK_OF_DECLARE(exynos4415_cmu, "samsung,exynos4415-cmu", exynos4415_cmu_init);
 
@@ -1027,16 +963,6 @@ CLK_OF_DECLARE(exynos4415_cmu, "samsung,exynos4415-cmu", exynos4415_cmu_init);
 #define SRC_DMC                 0x300
 #define DIV_DMC1                0x504
 
-enum exynos4415_dmc_plls {
-        mpll, bpll,
-        nr_dmc_plls,
-};
-
-static struct samsung_clk_provider *exynos4415_dmc_ctx;
-
-#ifdef CONFIG_PM_SLEEP
-static struct samsung_clk_reg_dump *exynos4415_dmc_clk_regs;
-
 static unsigned long exynos4415_cmu_dmc_clk_regs[] __initdata = {
         MPLL_LOCK,
         MPLL_CON0,
@@ -1050,42 +976,6 @@ static unsigned long exynos4415_cmu_dmc_clk_regs[] __initdata = {
         DIV_DMC1,
 };
 
-static int exynos4415_dmc_clk_suspend(void)
-{
-        samsung_clk_save(exynos4415_dmc_ctx->reg_base,
-                                exynos4415_dmc_clk_regs,
-                                ARRAY_SIZE(exynos4415_cmu_dmc_clk_regs));
-        return 0;
-}
-
-static void exynos4415_dmc_clk_resume(void)
-{
-        samsung_clk_restore(exynos4415_dmc_ctx->reg_base,
-                                exynos4415_dmc_clk_regs,
-                                ARRAY_SIZE(exynos4415_cmu_dmc_clk_regs));
-}
-
-static struct syscore_ops exynos4415_dmc_clk_syscore_ops = {
-        .suspend = exynos4415_dmc_clk_suspend,
-        .resume = exynos4415_dmc_clk_resume,
-};
-
-static void exynos4415_dmc_clk_sleep_init(void)
-{
-        exynos4415_dmc_clk_regs =
-                samsung_clk_alloc_reg_dump(exynos4415_cmu_dmc_clk_regs,
-                                ARRAY_SIZE(exynos4415_cmu_dmc_clk_regs));
-        if (!exynos4415_dmc_clk_regs) {
-                pr_warn("%s: Failed to allocate sleep save data\n", __func__);
-                return;
-        }
-
-        register_syscore_ops(&exynos4415_dmc_clk_syscore_ops);
-}
-#else
-static inline void exynos4415_dmc_clk_sleep_init(void) { }
-#endif /* CONFIG_PM_SLEEP */
-
 PNAME(mout_mpll_p)              = { "fin_pll", "fout_mpll", };
 PNAME(mout_bpll_p)              = { "fin_pll", "fout_bpll", };
 PNAME(mbpll_p)                  = { "mout_mpll", "mout_bpll", };
@@ -1107,38 +997,28 @@ static struct samsung_div_clock exynos4415_dmc_div_clks[] __initdata = {
         DIV(CLK_DMC_DIV_MPLL_PRE, "div_mpll_pre", "mout_mpll", DIV_DMC1, 8, 2),
 };
 
-static struct samsung_pll_clock exynos4415_dmc_plls[nr_dmc_plls] __initdata = {
-        [mpll] = PLL(pll_35xx, CLK_DMC_FOUT_MPLL, "fout_mpll", "fin_pll",
-                MPLL_LOCK, MPLL_CON0, NULL),
-        [bpll] = PLL(pll_35xx, CLK_DMC_FOUT_BPLL, "fout_bpll", "fin_pll",
-                BPLL_LOCK, BPLL_CON0, NULL),
+static struct samsung_pll_clock exynos4415_dmc_plls[] __initdata = {
+        PLL(pll_35xx, CLK_DMC_FOUT_MPLL, "fout_mpll", "fin_pll",
+                MPLL_LOCK, MPLL_CON0, exynos4415_pll_rates),
+        PLL(pll_35xx, CLK_DMC_FOUT_BPLL, "fout_bpll", "fin_pll",
+                BPLL_LOCK, BPLL_CON0, exynos4415_pll_rates),
+};
+
+static struct samsung_cmu_info cmu_dmc_info __initdata = {
+        .pll_clks               = exynos4415_dmc_plls,
+        .nr_pll_clks            = ARRAY_SIZE(exynos4415_dmc_plls),
+        .mux_clks               = exynos4415_dmc_mux_clks,
+        .nr_mux_clks            = ARRAY_SIZE(exynos4415_dmc_mux_clks),
+        .div_clks               = exynos4415_dmc_div_clks,
+        .nr_div_clks            = ARRAY_SIZE(exynos4415_dmc_div_clks),
+        .nr_clk_ids             = NR_CLKS_DMC,
+        .clk_regs               = exynos4415_cmu_dmc_clk_regs,
+        .nr_clk_regs            = ARRAY_SIZE(exynos4415_cmu_dmc_clk_regs),
 };
 
 static void __init exynos4415_cmu_dmc_init(struct device_node *np)
 {
-        void __iomem *reg_base;
-
-        reg_base = of_iomap(np, 0);
-        if (!reg_base)
-                panic("%s: failed to map registers\n", __func__);
-
-        exynos4415_dmc_ctx = samsung_clk_init(np, reg_base, NR_CLKS_DMC);
-        if (!exynos4415_dmc_ctx)
-                panic("%s: unable to allocate context.\n", __func__);
-
-        exynos4415_dmc_plls[mpll].rate_table = exynos4415_pll_rates;
-        exynos4415_dmc_plls[bpll].rate_table = exynos4415_pll_rates;
-
-        samsung_clk_register_pll(exynos4415_dmc_ctx, exynos4415_dmc_plls,
-                                ARRAY_SIZE(exynos4415_dmc_plls), reg_base);
-        samsung_clk_register_mux(exynos4415_dmc_ctx, exynos4415_dmc_mux_clks,
-                                ARRAY_SIZE(exynos4415_dmc_mux_clks));
-        samsung_clk_register_div(exynos4415_dmc_ctx, exynos4415_dmc_div_clks,
-                                ARRAY_SIZE(exynos4415_dmc_div_clks));
-
-        exynos4415_dmc_clk_sleep_init();
-
-        samsung_clk_of_add_provider(np, exynos4415_dmc_ctx);
+        samsung_cmu_register_one(np, &cmu_dmc_info);
 }
 CLK_OF_DECLARE(exynos4415_cmu_dmc, "samsung,exynos4415-cmu-dmc",
                 exynos4415_cmu_dmc_init);
diff --git a/drivers/clk/samsung/clk-exynos7.c b/drivers/clk/samsung/clk-exynos7.c
index ea4483b8d62e..03d36e847b78 100644
--- a/drivers/clk/samsung/clk-exynos7.c
+++ b/drivers/clk/samsung/clk-exynos7.c
@@ -34,6 +34,7 @@
 #define DIV_TOPC0               0x0600
 #define DIV_TOPC1               0x0604
 #define DIV_TOPC3               0x060C
+#define ENABLE_ACLK_TOPC1       0x0804
 
 static struct samsung_fixed_factor_clock topc_fixed_factor_clks[] __initdata = {
         FFACTOR(0, "ffac_topc_bus0_pll_div2", "mout_bus0_pll_ctrl", 1, 2, 0),
@@ -45,6 +46,7 @@ static struct samsung_fixed_factor_clock topc_fixed_factor_clks[] __initdata = {
 };
 
 /* List of parent clocks for Muxes in CMU_TOPC */
+PNAME(mout_aud_pll_ctrl_p)      = { "fin_pll", "fout_aud_pll" };
 PNAME(mout_bus0_pll_ctrl_p)     = { "fin_pll", "fout_bus0_pll" };
 PNAME(mout_bus1_pll_ctrl_p)     = { "fin_pll", "fout_bus1_pll" };
 PNAME(mout_cc_pll_ctrl_p)       = { "fin_pll", "fout_cc_pll" };
@@ -104,9 +106,11 @@ static struct samsung_mux_clock topc_mux_clks[] __initdata = {
 
         MUX(0, "mout_sclk_bus0_pll_out", mout_sclk_bus0_pll_out_p,
                 MUX_SEL_TOPC1, 16, 1),
+        MUX(0, "mout_aud_pll_ctrl", mout_aud_pll_ctrl_p, MUX_SEL_TOPC1, 0, 1),
 
         MUX(0, "mout_aclk_ccore_133", mout_topc_group2, MUX_SEL_TOPC2, 4, 2),
 
+        MUX(0, "mout_aclk_mscl_532", mout_topc_group2, MUX_SEL_TOPC3, 20, 2),
         MUX(0, "mout_aclk_peris_66", mout_topc_group2, MUX_SEL_TOPC3, 24, 2),
 };
 
@@ -114,6 +118,8 @@ static struct samsung_div_clock topc_div_clks[] __initdata = {
         DIV(DOUT_ACLK_CCORE_133, "dout_aclk_ccore_133", "mout_aclk_ccore_133",
                 DIV_TOPC0, 4, 4),
 
+        DIV(DOUT_ACLK_MSCL_532, "dout_aclk_mscl_532", "mout_aclk_mscl_532",
+                DIV_TOPC1, 20, 4),
         DIV(DOUT_ACLK_PERIS, "dout_aclk_peris_66", "mout_aclk_peris_66",
                 DIV_TOPC1, 24, 4),
 
@@ -125,6 +131,18 @@ static struct samsung_div_clock topc_div_clks[] __initdata = {
                 DIV_TOPC3, 12, 3),
         DIV(DOUT_SCLK_MFC_PLL, "dout_sclk_mfc_pll", "mout_mfc_pll_ctrl",
                 DIV_TOPC3, 16, 3),
+        DIV(DOUT_SCLK_AUD_PLL, "dout_sclk_aud_pll", "mout_aud_pll_ctrl",
+                DIV_TOPC3, 28, 3),
+};
+
+static struct samsung_pll_rate_table pll1460x_24mhz_tbl[] __initdata = {
+        PLL_36XX_RATE(491520000, 20, 1, 0, 31457),
+        {},
+};
+
+static struct samsung_gate_clock topc_gate_clks[] __initdata = {
+        GATE(ACLK_MSCL_532, "aclk_mscl_532", "dout_aclk_mscl_532",
+                ENABLE_ACLK_TOPC1, 20, 0, 0),
 };
 
 static struct samsung_pll_clock topc_pll_clks[] __initdata = {
@@ -136,8 +154,8 @@ static struct samsung_pll_clock topc_pll_clks[] __initdata = {
                 BUS1_DPLL_CON0, NULL),
         PLL(pll_1452x, 0, "fout_mfc_pll", "fin_pll", MFC_PLL_LOCK,
                 MFC_PLL_CON0, NULL),
-        PLL(pll_1460x, 0, "fout_aud_pll", "fin_pll", AUD_PLL_LOCK,
-                AUD_PLL_CON0, NULL),
+        PLL(pll_1460x, FOUT_AUD_PLL, "fout_aud_pll", "fin_pll", AUD_PLL_LOCK,
+                AUD_PLL_CON0, pll1460x_24mhz_tbl),
 };
 
 static struct samsung_cmu_info topc_cmu_info __initdata = {
@@ -147,6 +165,8 @@ static struct samsung_cmu_info topc_cmu_info __initdata = {
         .nr_mux_clks            = ARRAY_SIZE(topc_mux_clks),
         .div_clks               = topc_div_clks,
         .nr_div_clks            = ARRAY_SIZE(topc_div_clks),
+        .gate_clks              = topc_gate_clks,
+        .nr_gate_clks           = ARRAY_SIZE(topc_gate_clks),
         .fixed_factor_clks      = topc_fixed_factor_clks,
         .nr_fixed_factor_clks   = ARRAY_SIZE(topc_fixed_factor_clks),
         .nr_clk_ids             = TOPC_NR_CLK,
@@ -166,9 +186,18 @@ CLK_OF_DECLARE(exynos7_clk_topc, "samsung,exynos7-clock-topc",
 #define MUX_SEL_TOP00                   0x0200
 #define MUX_SEL_TOP01                   0x0204
 #define MUX_SEL_TOP03                   0x020C
+#define MUX_SEL_TOP0_PERIC0             0x0230
+#define MUX_SEL_TOP0_PERIC1             0x0234
+#define MUX_SEL_TOP0_PERIC2             0x0238
 #define MUX_SEL_TOP0_PERIC3             0x023C
 #define DIV_TOP03                       0x060C
+#define DIV_TOP0_PERIC0                 0x0630
+#define DIV_TOP0_PERIC1                 0x0634
+#define DIV_TOP0_PERIC2                 0x0638
 #define DIV_TOP0_PERIC3                 0x063C
+#define ENABLE_SCLK_TOP0_PERIC0         0x0A30
+#define ENABLE_SCLK_TOP0_PERIC1         0x0A34
+#define ENABLE_SCLK_TOP0_PERIC2         0x0A38
 #define ENABLE_SCLK_TOP0_PERIC3         0x0A3C
 
 /* List of parent clocks for Muxes in CMU_TOP0 */
@@ -176,6 +205,7 @@ PNAME(mout_bus0_pll_p)	= { "fin_pll", "dout_sclk_bus0_pll" };
 PNAME(mout_bus1_pll_p)  = { "fin_pll", "dout_sclk_bus1_pll" };
 PNAME(mout_cc_pll_p)    = { "fin_pll", "dout_sclk_cc_pll" };
 PNAME(mout_mfc_pll_p)   = { "fin_pll", "dout_sclk_mfc_pll" };
+PNAME(mout_aud_pll_p)   = { "fin_pll", "dout_sclk_aud_pll" };
 
 PNAME(mout_top0_half_bus0_pll_p) = {"mout_top0_bus0_pll",
         "ffac_top0_bus0_pll_div2"};
@@ -189,18 +219,34 @@ PNAME(mout_top0_half_mfc_pll_p) = {"mout_top0_mfc_pll",
 PNAME(mout_top0_group1) = {"mout_top0_half_bus0_pll",
         "mout_top0_half_bus1_pll", "mout_top0_half_cc_pll",
         "mout_top0_half_mfc_pll"};
+PNAME(mout_top0_group3) = {"ioclk_audiocdclk0",
+        "ioclk_audiocdclk1", "ioclk_spdif_extclk",
+        "mout_top0_aud_pll", "mout_top0_half_bus0_pll",
+        "mout_top0_half_bus1_pll"};
+PNAME(mout_top0_group4) = {"ioclk_audiocdclk1", "mout_top0_aud_pll",
+        "mout_top0_half_bus0_pll", "mout_top0_half_bus1_pll"};
 
 static unsigned long top0_clk_regs[] __initdata = {
         MUX_SEL_TOP00,
         MUX_SEL_TOP01,
         MUX_SEL_TOP03,
+        MUX_SEL_TOP0_PERIC0,
+        MUX_SEL_TOP0_PERIC1,
+        MUX_SEL_TOP0_PERIC2,
         MUX_SEL_TOP0_PERIC3,
         DIV_TOP03,
+        DIV_TOP0_PERIC0,
+        DIV_TOP0_PERIC1,
+        DIV_TOP0_PERIC2,
         DIV_TOP0_PERIC3,
+        ENABLE_SCLK_TOP0_PERIC0,
+        ENABLE_SCLK_TOP0_PERIC1,
+        ENABLE_SCLK_TOP0_PERIC2,
         ENABLE_SCLK_TOP0_PERIC3,
 };
 
 static struct samsung_mux_clock top0_mux_clks[] __initdata = {
+        MUX(0, "mout_top0_aud_pll", mout_aud_pll_p, MUX_SEL_TOP00, 0, 1),
         MUX(0, "mout_top0_mfc_pll", mout_mfc_pll_p, MUX_SEL_TOP00, 4, 1),
         MUX(0, "mout_top0_cc_pll", mout_cc_pll_p, MUX_SEL_TOP00, 8, 1),
         MUX(0, "mout_top0_bus1_pll", mout_bus1_pll_p, MUX_SEL_TOP00, 12, 1),
@@ -218,10 +264,20 @@ static struct samsung_mux_clock top0_mux_clks[] __initdata = {
         MUX(0, "mout_aclk_peric1_66", mout_top0_group1, MUX_SEL_TOP03, 12, 2),
         MUX(0, "mout_aclk_peric0_66", mout_top0_group1, MUX_SEL_TOP03, 20, 2),
 
+        MUX(0, "mout_sclk_spdif", mout_top0_group3, MUX_SEL_TOP0_PERIC0, 4, 3),
+        MUX(0, "mout_sclk_pcm1", mout_top0_group4, MUX_SEL_TOP0_PERIC0, 8, 2),
+        MUX(0, "mout_sclk_i2s1", mout_top0_group4, MUX_SEL_TOP0_PERIC0, 20, 2),
+
+        MUX(0, "mout_sclk_spi1", mout_top0_group1, MUX_SEL_TOP0_PERIC1, 8, 2),
+        MUX(0, "mout_sclk_spi0", mout_top0_group1, MUX_SEL_TOP0_PERIC1, 20, 2),
+
+        MUX(0, "mout_sclk_spi3", mout_top0_group1, MUX_SEL_TOP0_PERIC2, 8, 2),
+        MUX(0, "mout_sclk_spi2", mout_top0_group1, MUX_SEL_TOP0_PERIC2, 20, 2),
         MUX(0, "mout_sclk_uart3", mout_top0_group1, MUX_SEL_TOP0_PERIC3, 4, 2),
         MUX(0, "mout_sclk_uart2", mout_top0_group1, MUX_SEL_TOP0_PERIC3, 8, 2),
         MUX(0, "mout_sclk_uart1", mout_top0_group1, MUX_SEL_TOP0_PERIC3, 12, 2),
         MUX(0, "mout_sclk_uart0", mout_top0_group1, MUX_SEL_TOP0_PERIC3, 16, 2),
+        MUX(0, "mout_sclk_spi4", mout_top0_group1, MUX_SEL_TOP0_PERIC3, 20, 2),
 };
 
 static struct samsung_div_clock top0_div_clks[] __initdata = {
@@ -230,13 +286,40 @@ static struct samsung_div_clock top0_div_clks[] __initdata = {
         DIV(DOUT_ACLK_PERIC0, "dout_aclk_peric0_66", "mout_aclk_peric0_66",
                 DIV_TOP03, 20, 6),
 
+        DIV(0, "dout_sclk_spdif", "mout_sclk_spdif", DIV_TOP0_PERIC0, 4, 4),
+        DIV(0, "dout_sclk_pcm1", "mout_sclk_pcm1", DIV_TOP0_PERIC0, 8, 12),
+        DIV(0, "dout_sclk_i2s1", "mout_sclk_i2s1", DIV_TOP0_PERIC0, 20, 10),
+
+        DIV(0, "dout_sclk_spi1", "mout_sclk_spi1", DIV_TOP0_PERIC1, 8, 12),
+        DIV(0, "dout_sclk_spi0", "mout_sclk_spi0", DIV_TOP0_PERIC1, 20, 12),
+
+        DIV(0, "dout_sclk_spi3", "mout_sclk_spi3", DIV_TOP0_PERIC2, 8, 12),
+        DIV(0, "dout_sclk_spi2", "mout_sclk_spi2", DIV_TOP0_PERIC2, 20, 12),
+
         DIV(0, "dout_sclk_uart3", "mout_sclk_uart3", DIV_TOP0_PERIC3, 4, 4),
         DIV(0, "dout_sclk_uart2", "mout_sclk_uart2", DIV_TOP0_PERIC3, 8, 4),
         DIV(0, "dout_sclk_uart1", "mout_sclk_uart1", DIV_TOP0_PERIC3, 12, 4),
         DIV(0, "dout_sclk_uart0", "mout_sclk_uart0", DIV_TOP0_PERIC3, 16, 4),
+        DIV(0, "dout_sclk_spi4", "mout_sclk_spi4", DIV_TOP0_PERIC3, 20, 12),
 };
 
 static struct samsung_gate_clock top0_gate_clks[] __initdata = {
+        GATE(CLK_SCLK_SPDIF, "sclk_spdif", "dout_sclk_spdif",
+                ENABLE_SCLK_TOP0_PERIC0, 4, CLK_SET_RATE_PARENT, 0),
+        GATE(CLK_SCLK_PCM1, "sclk_pcm1", "dout_sclk_pcm1",
+                ENABLE_SCLK_TOP0_PERIC0, 8, CLK_SET_RATE_PARENT, 0),
+        GATE(CLK_SCLK_I2S1, "sclk_i2s1", "dout_sclk_i2s1",
+                ENABLE_SCLK_TOP0_PERIC0, 20, CLK_SET_RATE_PARENT, 0),
+
+        GATE(CLK_SCLK_SPI1, "sclk_spi1", "dout_sclk_spi1",
+                ENABLE_SCLK_TOP0_PERIC1, 8, CLK_SET_RATE_PARENT, 0),
+        GATE(CLK_SCLK_SPI0, "sclk_spi0", "dout_sclk_spi0",
+                ENABLE_SCLK_TOP0_PERIC1, 20, CLK_SET_RATE_PARENT, 0),
+
+        GATE(CLK_SCLK_SPI3, "sclk_spi3", "dout_sclk_spi3",
+                ENABLE_SCLK_TOP0_PERIC2, 8, CLK_SET_RATE_PARENT, 0),
+        GATE(CLK_SCLK_SPI2, "sclk_spi2", "dout_sclk_spi2",
+                ENABLE_SCLK_TOP0_PERIC2, 20, CLK_SET_RATE_PARENT, 0),
         GATE(CLK_SCLK_UART3, "sclk_uart3", "dout_sclk_uart3",
                 ENABLE_SCLK_TOP0_PERIC3, 4, 0, 0),
         GATE(CLK_SCLK_UART2, "sclk_uart2", "dout_sclk_uart2",
@@ -245,6 +328,8 @@ static struct samsung_gate_clock top0_gate_clks[] __initdata = {
                 ENABLE_SCLK_TOP0_PERIC3, 12, 0, 0),
         GATE(CLK_SCLK_UART0, "sclk_uart0", "dout_sclk_uart0",
                 ENABLE_SCLK_TOP0_PERIC3, 16, 0, 0),
+        GATE(CLK_SCLK_SPI4, "sclk_spi4", "dout_sclk_spi4",
+                ENABLE_SCLK_TOP0_PERIC3, 20, CLK_SET_RATE_PARENT, 0),
 };
 
 static struct samsung_fixed_factor_clock top0_fixed_factor_clks[] __initdata = {
@@ -343,6 +428,8 @@ static struct samsung_mux_clock top1_mux_clks[] __initdata = {
         MUX(0, "mout_aclk_fsys0_200", mout_top1_group1, MUX_SEL_TOP13, 28, 2),
 
         MUX(0, "mout_sclk_mmc2", mout_top1_group1, MUX_SEL_TOP1_FSYS0, 24, 2),
+        MUX(0, "mout_sclk_usbdrd300", mout_top1_group1,
+                MUX_SEL_TOP1_FSYS0, 28, 2),
 
         MUX(0, "mout_sclk_mmc1", mout_top1_group1, MUX_SEL_TOP1_FSYS1, 24, 2),
         MUX(0, "mout_sclk_mmc0", mout_top1_group1, MUX_SEL_TOP1_FSYS1, 28, 2),
@@ -356,6 +443,8 @@ static struct samsung_div_clock top1_div_clks[] __initdata = {
 
         DIV(DOUT_SCLK_MMC2, "dout_sclk_mmc2", "mout_sclk_mmc2",
                 DIV_TOP1_FSYS0, 24, 4),
+        DIV(0, "dout_sclk_usbdrd300", "mout_sclk_usbdrd300",
+                DIV_TOP1_FSYS0, 28, 4),
 
         DIV(DOUT_SCLK_MMC1, "dout_sclk_mmc1", "mout_sclk_mmc1",
                 DIV_TOP1_FSYS1, 24, 4),
@@ -366,6 +455,8 @@ static struct samsung_div_clock top1_div_clks[] __initdata = {
 static struct samsung_gate_clock top1_gate_clks[] __initdata = {
         GATE(CLK_SCLK_MMC2, "sclk_mmc2", "dout_sclk_mmc2",
                 ENABLE_SCLK_TOP1_FSYS0, 24, CLK_SET_RATE_PARENT, 0),
+        GATE(0, "sclk_usbdrd300", "dout_sclk_usbdrd300",
+                ENABLE_SCLK_TOP1_FSYS0, 28, 0, 0),
 
         GATE(CLK_SCLK_MMC1, "sclk_mmc1", "dout_sclk_mmc1",
                 ENABLE_SCLK_TOP1_FSYS1, 24, CLK_SET_RATE_PARENT, 0),
@@ -514,6 +605,7 @@ static void __init exynos7_clk_peric0_init(struct device_node *np)
 /* Register Offset definitions for CMU_PERIC1 (0x14C80000) */
 #define MUX_SEL_PERIC10                 0x0200
 #define MUX_SEL_PERIC11                 0x0204
+#define MUX_SEL_PERIC12                 0x0208
 #define ENABLE_PCLK_PERIC1              0x0900
 #define ENABLE_SCLK_PERIC10             0x0A00
 
@@ -525,10 +617,16 @@ PNAME(mout_aclk_peric1_66_p)	= { "fin_pll", "dout_aclk_peric1_66" };
 PNAME(mout_sclk_uart1_p)        = { "fin_pll", "sclk_uart1" };
 PNAME(mout_sclk_uart2_p)        = { "fin_pll", "sclk_uart2" };
 PNAME(mout_sclk_uart3_p)        = { "fin_pll", "sclk_uart3" };
+PNAME(mout_sclk_spi0_p)         = { "fin_pll", "sclk_spi0" };
+PNAME(mout_sclk_spi1_p)         = { "fin_pll", "sclk_spi1" };
+PNAME(mout_sclk_spi2_p)         = { "fin_pll", "sclk_spi2" };
+PNAME(mout_sclk_spi3_p)         = { "fin_pll", "sclk_spi3" };
+PNAME(mout_sclk_spi4_p)         = { "fin_pll", "sclk_spi4" };
 
 static unsigned long peric1_clk_regs[] __initdata = {
         MUX_SEL_PERIC10,
         MUX_SEL_PERIC11,
+        MUX_SEL_PERIC12,
         ENABLE_PCLK_PERIC1,
         ENABLE_SCLK_PERIC10,
 };
@@ -537,6 +635,16 @@ static struct samsung_mux_clock peric1_mux_clks[] __initdata = {
         MUX(0, "mout_aclk_peric1_66_user", mout_aclk_peric1_66_p,
                 MUX_SEL_PERIC10, 0, 1),
 
+        MUX_F(0, "mout_sclk_spi0_user", mout_sclk_spi0_p,
+                MUX_SEL_PERIC11, 0, 1, CLK_SET_RATE_PARENT, 0),
+        MUX_F(0, "mout_sclk_spi1_user", mout_sclk_spi1_p,
+                MUX_SEL_PERIC11, 4, 1, CLK_SET_RATE_PARENT, 0),
+        MUX_F(0, "mout_sclk_spi2_user", mout_sclk_spi2_p,
+                MUX_SEL_PERIC11, 8, 1, CLK_SET_RATE_PARENT, 0),
+        MUX_F(0, "mout_sclk_spi3_user", mout_sclk_spi3_p,
+                MUX_SEL_PERIC11, 12, 1, CLK_SET_RATE_PARENT, 0),
+        MUX_F(0, "mout_sclk_spi4_user", mout_sclk_spi4_p,
+                MUX_SEL_PERIC11, 16, 1, CLK_SET_RATE_PARENT, 0),
         MUX(0, "mout_sclk_uart1_user", mout_sclk_uart1_p,
                 MUX_SEL_PERIC11, 20, 1),
         MUX(0, "mout_sclk_uart2_user", mout_sclk_uart2_p,
@@ -562,6 +670,22 @@ static struct samsung_gate_clock peric1_gate_clks[] __initdata = {
                 ENABLE_PCLK_PERIC1, 10, 0, 0),
         GATE(PCLK_UART3, "pclk_uart3", "mout_aclk_peric1_66_user",
                 ENABLE_PCLK_PERIC1, 11, 0, 0),
+        GATE(PCLK_SPI0, "pclk_spi0", "mout_aclk_peric1_66_user",
+                ENABLE_PCLK_PERIC1, 12, 0, 0),
+        GATE(PCLK_SPI1, "pclk_spi1", "mout_aclk_peric1_66_user",
+                ENABLE_PCLK_PERIC1, 13, 0, 0),
+        GATE(PCLK_SPI2, "pclk_spi2", "mout_aclk_peric1_66_user",
+                ENABLE_PCLK_PERIC1, 14, 0, 0),
+        GATE(PCLK_SPI3, "pclk_spi3", "mout_aclk_peric1_66_user",
+                ENABLE_PCLK_PERIC1, 15, 0, 0),
+        GATE(PCLK_SPI4, "pclk_spi4", "mout_aclk_peric1_66_user",
+                ENABLE_PCLK_PERIC1, 16, 0, 0),
+        GATE(PCLK_I2S1, "pclk_i2s1", "mout_aclk_peric1_66_user",
+                ENABLE_PCLK_PERIC1, 17, CLK_SET_RATE_PARENT, 0),
+        GATE(PCLK_PCM1, "pclk_pcm1", "mout_aclk_peric1_66_user",
+                ENABLE_PCLK_PERIC1, 18, 0, 0),
+        GATE(PCLK_SPDIF, "pclk_spdif", "mout_aclk_peric1_66_user",
+                ENABLE_PCLK_PERIC1, 19, 0, 0),
 
         GATE(SCLK_UART1, "sclk_uart1_user", "mout_sclk_uart1_user",
                 ENABLE_SCLK_PERIC10, 9, 0, 0),
@@ -569,6 +693,22 @@ static struct samsung_gate_clock peric1_gate_clks[] __initdata = {
                 ENABLE_SCLK_PERIC10, 10, 0, 0),
         GATE(SCLK_UART3, "sclk_uart3_user", "mout_sclk_uart3_user",
                 ENABLE_SCLK_PERIC10, 11, 0, 0),
+        GATE(SCLK_SPI0, "sclk_spi0_user", "mout_sclk_spi0_user",
+                ENABLE_SCLK_PERIC10, 12, CLK_SET_RATE_PARENT, 0),
+        GATE(SCLK_SPI1, "sclk_spi1_user", "mout_sclk_spi1_user",
+                ENABLE_SCLK_PERIC10, 13, CLK_SET_RATE_PARENT, 0),
+        GATE(SCLK_SPI2, "sclk_spi2_user", "mout_sclk_spi2_user",
+                ENABLE_SCLK_PERIC10, 14, CLK_SET_RATE_PARENT, 0),
+        GATE(SCLK_SPI3, "sclk_spi3_user", "mout_sclk_spi3_user",
+                ENABLE_SCLK_PERIC10, 15, CLK_SET_RATE_PARENT, 0),
+        GATE(SCLK_SPI4, "sclk_spi4_user", "mout_sclk_spi4_user",
+                ENABLE_SCLK_PERIC10, 16, CLK_SET_RATE_PARENT, 0),
+        GATE(SCLK_I2S1, "sclk_i2s1_user", "sclk_i2s1",
+                ENABLE_SCLK_PERIC10, 17, CLK_SET_RATE_PARENT, 0),
+        GATE(SCLK_PCM1, "sclk_pcm1_user", "sclk_pcm1",
+                ENABLE_SCLK_PERIC10, 18, CLK_SET_RATE_PARENT, 0),
+        GATE(SCLK_SPDIF, "sclk_spdif_user", "sclk_spdif",
+                ENABLE_SCLK_PERIC10, 19, CLK_SET_RATE_PARENT, 0),
 };
 
 static struct samsung_cmu_info peric1_cmu_info __initdata = {
@@ -647,7 +787,12 @@ CLK_OF_DECLARE(exynos7_clk_peris, "samsung,exynos7-clock-peris",
 /* Register Offset definitions for CMU_FSYS0 (0x10E90000) */
 #define MUX_SEL_FSYS00                  0x0200
 #define MUX_SEL_FSYS01                  0x0204
+#define MUX_SEL_FSYS02                  0x0208
+#define ENABLE_ACLK_FSYS00              0x0800
 #define ENABLE_ACLK_FSYS01              0x0804
+#define ENABLE_SCLK_FSYS01              0x0A04
+#define ENABLE_SCLK_FSYS02              0x0A08
+#define ENABLE_SCLK_FSYS04              0x0A10
 
 /*
  * List of parent clocks for Muxes in CMU_FSYS0
@@ -655,10 +800,29 @@ CLK_OF_DECLARE(exynos7_clk_peris, "samsung,exynos7-clock-peris",
 PNAME(mout_aclk_fsys0_200_p)    = { "fin_pll", "dout_aclk_fsys0_200" };
 PNAME(mout_sclk_mmc2_p)         = { "fin_pll", "sclk_mmc2" };
 
+PNAME(mout_sclk_usbdrd300_p)    = { "fin_pll", "sclk_usbdrd300" };
+PNAME(mout_phyclk_usbdrd300_udrd30_phyclk_p)    = { "fin_pll",
+                                "phyclk_usbdrd300_udrd30_phyclock" };
+PNAME(mout_phyclk_usbdrd300_udrd30_pipe_pclk_p) = { "fin_pll",
+                                "phyclk_usbdrd300_udrd30_pipe_pclk" };
+
+/* fixed rate clocks used in the FSYS0 block */
+struct samsung_fixed_rate_clock fixed_rate_clks_fsys0[] __initdata = {
+        FRATE(0, "phyclk_usbdrd300_udrd30_phyclock", NULL,
+                CLK_IS_ROOT, 60000000),
+        FRATE(0, "phyclk_usbdrd300_udrd30_pipe_pclk", NULL,
+                CLK_IS_ROOT, 125000000),
+};
+
 static unsigned long fsys0_clk_regs[] __initdata = {
         MUX_SEL_FSYS00,
         MUX_SEL_FSYS01,
+        MUX_SEL_FSYS02,
+        ENABLE_ACLK_FSYS00,
         ENABLE_ACLK_FSYS01,
+        ENABLE_SCLK_FSYS01,
+        ENABLE_SCLK_FSYS02,
+        ENABLE_SCLK_FSYS04,
 };
 
 static struct samsung_mux_clock fsys0_mux_clks[] __initdata = {
@@ -666,11 +830,49 @@ static struct samsung_mux_clock fsys0_mux_clks[] __initdata = {
                 MUX_SEL_FSYS00, 24, 1),
 
         MUX(0, "mout_sclk_mmc2_user", mout_sclk_mmc2_p, MUX_SEL_FSYS01, 24, 1),
+        MUX(0, "mout_sclk_usbdrd300_user", mout_sclk_usbdrd300_p,
+                MUX_SEL_FSYS01, 28, 1),
+
+        MUX(0, "mout_phyclk_usbdrd300_udrd30_pipe_pclk_user",
+                mout_phyclk_usbdrd300_udrd30_pipe_pclk_p,
+                MUX_SEL_FSYS02, 24, 1),
+        MUX(0, "mout_phyclk_usbdrd300_udrd30_phyclk_user",
+                mout_phyclk_usbdrd300_udrd30_phyclk_p,
+                MUX_SEL_FSYS02, 28, 1),
 };
 
 static struct samsung_gate_clock fsys0_gate_clks[] __initdata = {
+        GATE(ACLK_AXIUS_USBDRD30X_FSYS0X, "aclk_axius_usbdrd30x_fsys0x",
+                "mout_aclk_fsys0_200_user",
+                ENABLE_ACLK_FSYS00, 19, 0, 0),
+        GATE(ACLK_PDMA1, "aclk_pdma1", "mout_aclk_fsys0_200_user",
+                        ENABLE_ACLK_FSYS00, 3, 0, 0),
+        GATE(ACLK_PDMA0, "aclk_pdma0", "mout_aclk_fsys0_200_user",
+                        ENABLE_ACLK_FSYS00, 4, 0, 0),
+
+        GATE(ACLK_USBDRD300, "aclk_usbdrd300", "mout_aclk_fsys0_200_user",
+                ENABLE_ACLK_FSYS01, 29, 0, 0),
         GATE(ACLK_MMC2, "aclk_mmc2", "mout_aclk_fsys0_200_user",
                 ENABLE_ACLK_FSYS01, 31, 0, 0),
+
+        GATE(SCLK_USBDRD300_SUSPENDCLK, "sclk_usbdrd300_suspendclk",
+                "mout_sclk_usbdrd300_user",
+                ENABLE_SCLK_FSYS01, 4, 0, 0),
+        GATE(SCLK_USBDRD300_REFCLK, "sclk_usbdrd300_refclk", "fin_pll",
+                ENABLE_SCLK_FSYS01, 8, 0, 0),
+
+        GATE(PHYCLK_USBDRD300_UDRD30_PIPE_PCLK_USER,
+                "phyclk_usbdrd300_udrd30_pipe_pclk_user",
+                "mout_phyclk_usbdrd300_udrd30_pipe_pclk_user",
+                ENABLE_SCLK_FSYS02, 24, 0, 0),
+        GATE(PHYCLK_USBDRD300_UDRD30_PHYCLK_USER,
+                "phyclk_usbdrd300_udrd30_phyclk_user",
+                "mout_phyclk_usbdrd300_udrd30_phyclk_user",
+                ENABLE_SCLK_FSYS02, 28, 0, 0),
+
+        GATE(OSCCLK_PHY_CLKOUT_USB30_PHY, "oscclk_phy_clkout_usb30_phy",
+                "fin_pll",
+                ENABLE_SCLK_FSYS04, 28, 0, 0),
 };
 
 static struct samsung_cmu_info fsys0_cmu_info __initdata = {
@@ -741,3 +943,205 @@ static void __init exynos7_clk_fsys1_init(struct device_node *np)
 
 CLK_OF_DECLARE(exynos7_clk_fsys1, "samsung,exynos7-clock-fsys1",
         exynos7_clk_fsys1_init);
+
+#define MUX_SEL_MSCL                    0x0200
+#define DIV_MSCL                        0x0600
+#define ENABLE_ACLK_MSCL                0x0800
+#define ENABLE_PCLK_MSCL                0x0900
+
+/* List of parent clocks for Muxes in CMU_MSCL */
+PNAME(mout_aclk_mscl_532_user_p)        = { "fin_pll", "aclk_mscl_532" };
+
+static unsigned long mscl_clk_regs[] __initdata = {
+        MUX_SEL_MSCL,
+        DIV_MSCL,
+        ENABLE_ACLK_MSCL,
+        ENABLE_PCLK_MSCL,
+};
+
+static struct samsung_mux_clock mscl_mux_clks[] __initdata = {
+        MUX(USERMUX_ACLK_MSCL_532, "usermux_aclk_mscl_532",
+                mout_aclk_mscl_532_user_p, MUX_SEL_MSCL, 0, 1),
+};
+static struct samsung_div_clock mscl_div_clks[] __initdata = {
+        DIV(DOUT_PCLK_MSCL, "dout_pclk_mscl", "usermux_aclk_mscl_532",
+                        DIV_MSCL, 0, 3),
+};
+static struct samsung_gate_clock mscl_gate_clks[] __initdata = {
+
+        GATE(ACLK_MSCL_0, "aclk_mscl_0", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 31, 0, 0),
+        GATE(ACLK_MSCL_1, "aclk_mscl_1", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 30, 0, 0),
+        GATE(ACLK_JPEG, "aclk_jpeg", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 29, 0, 0),
+        GATE(ACLK_G2D, "aclk_g2d", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 28, 0, 0),
+        GATE(ACLK_LH_ASYNC_SI_MSCL_0, "aclk_lh_async_si_mscl_0",
+                        "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 27, 0, 0),
+        GATE(ACLK_LH_ASYNC_SI_MSCL_1, "aclk_lh_async_si_mscl_1",
+                        "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 26, 0, 0),
+        GATE(ACLK_XIU_MSCLX_0, "aclk_xiu_msclx_0", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 25, 0, 0),
+        GATE(ACLK_XIU_MSCLX_1, "aclk_xiu_msclx_1", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 24, 0, 0),
+        GATE(ACLK_AXI2ACEL_BRIDGE, "aclk_axi2acel_bridge",
+                        "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 23, 0, 0),
+        GATE(ACLK_QE_MSCL_0, "aclk_qe_mscl_0", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 22, 0, 0),
+        GATE(ACLK_QE_MSCL_1, "aclk_qe_mscl_1", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 21, 0, 0),
+        GATE(ACLK_QE_JPEG, "aclk_qe_jpeg", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 20, 0, 0),
+        GATE(ACLK_QE_G2D, "aclk_qe_g2d", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 19, 0, 0),
+        GATE(ACLK_PPMU_MSCL_0, "aclk_ppmu_mscl_0", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 18, 0, 0),
+        GATE(ACLK_PPMU_MSCL_1, "aclk_ppmu_mscl_1", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 17, 0, 0),
+        GATE(ACLK_MSCLNP_133, "aclk_msclnp_133", "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 16, 0, 0),
+        GATE(ACLK_AHB2APB_MSCL0P, "aclk_ahb2apb_mscl0p",
+                        "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 15, 0, 0),
+        GATE(ACLK_AHB2APB_MSCL1P, "aclk_ahb2apb_mscl1p",
+                        "usermux_aclk_mscl_532",
+                        ENABLE_ACLK_MSCL, 14, 0, 0),
+
+        GATE(PCLK_MSCL_0, "pclk_mscl_0", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 31, 0, 0),
+        GATE(PCLK_MSCL_1, "pclk_mscl_1", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 30, 0, 0),
+        GATE(PCLK_JPEG, "pclk_jpeg", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 29, 0, 0),
+        GATE(PCLK_G2D, "pclk_g2d", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 28, 0, 0),
+        GATE(PCLK_QE_MSCL_0, "pclk_qe_mscl_0", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 27, 0, 0),
+        GATE(PCLK_QE_MSCL_1, "pclk_qe_mscl_1", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 26, 0, 0),
+        GATE(PCLK_QE_JPEG, "pclk_qe_jpeg", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 25, 0, 0),
+        GATE(PCLK_QE_G2D, "pclk_qe_g2d", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 24, 0, 0),
+        GATE(PCLK_PPMU_MSCL_0, "pclk_ppmu_mscl_0", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 23, 0, 0),
+        GATE(PCLK_PPMU_MSCL_1, "pclk_ppmu_mscl_1", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 22, 0, 0),
+        GATE(PCLK_AXI2ACEL_BRIDGE, "pclk_axi2acel_bridge", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 21, 0, 0),
+        GATE(PCLK_PMU_MSCL, "pclk_pmu_mscl", "dout_pclk_mscl",
+                        ENABLE_PCLK_MSCL, 20, 0, 0),
+};
+
+static struct samsung_cmu_info mscl_cmu_info __initdata = {
+        .mux_clks               = mscl_mux_clks,
+        .nr_mux_clks            = ARRAY_SIZE(mscl_mux_clks),
+        .div_clks               = mscl_div_clks,
+        .nr_div_clks            = ARRAY_SIZE(mscl_div_clks),
+        .gate_clks              = mscl_gate_clks,
+        .nr_gate_clks           = ARRAY_SIZE(mscl_gate_clks),
+        .nr_clk_ids             = MSCL_NR_CLK,
+        .clk_regs               = mscl_clk_regs,
+        .nr_clk_regs            = ARRAY_SIZE(mscl_clk_regs),
+};
+
+static void __init exynos7_clk_mscl_init(struct device_node *np)
+{
+        samsung_cmu_register_one(np, &mscl_cmu_info);
+}
+
+CLK_OF_DECLARE(exynos7_clk_mscl, "samsung,exynos7-clock-mscl",
+                exynos7_clk_mscl_init);
+
+/* Register Offset definitions for CMU_AUD (0x114C0000) */
+#define MUX_SEL_AUD                     0x0200
+#define DIV_AUD0                        0x0600
+#define DIV_AUD1                        0x0604
+#define ENABLE_ACLK_AUD                 0x0800
+#define ENABLE_PCLK_AUD                 0x0900
+#define ENABLE_SCLK_AUD                 0x0A00
+
+/*
+ * List of parent clocks for Muxes in CMU_AUD
+ */
+PNAME(mout_aud_pll_user_p) = { "fin_pll", "fout_aud_pll" };
+PNAME(mout_aud_group_p) = { "dout_aud_cdclk", "ioclk_audiocdclk0" };
+
+static unsigned long aud_clk_regs[] __initdata = {
+        MUX_SEL_AUD,
+        DIV_AUD0,
+        DIV_AUD1,
+        ENABLE_ACLK_AUD,
+        ENABLE_PCLK_AUD,
+        ENABLE_SCLK_AUD,
+};
+
+static struct samsung_mux_clock aud_mux_clks[] __initdata = {
+        MUX(0, "mout_sclk_i2s", mout_aud_group_p, MUX_SEL_AUD, 12, 1),
+        MUX(0, "mout_sclk_pcm", mout_aud_group_p, MUX_SEL_AUD, 16, 1),
+        MUX(0, "mout_aud_pll_user", mout_aud_pll_user_p, MUX_SEL_AUD, 20, 1),
+};
+
+static struct samsung_div_clock aud_div_clks[] __initdata = {
+        DIV(0, "dout_aud_ca5", "mout_aud_pll_user", DIV_AUD0, 0, 4),
+        DIV(0, "dout_aclk_aud", "dout_aud_ca5", DIV_AUD0, 4, 4),
+        DIV(0, "dout_aud_pclk_dbg", "dout_aud_ca5", DIV_AUD0, 8, 4),
+
+        DIV(0, "dout_sclk_i2s", "mout_sclk_i2s", DIV_AUD1, 0, 4),
+        DIV(0, "dout_sclk_pcm", "mout_sclk_pcm", DIV_AUD1, 4, 8),
+        DIV(0, "dout_sclk_uart", "dout_aud_cdclk", DIV_AUD1, 12, 4),
+        DIV(0, "dout_sclk_slimbus", "dout_aud_cdclk", DIV_AUD1, 16, 5),
+        DIV(0, "dout_aud_cdclk", "mout_aud_pll_user", DIV_AUD1, 24, 4),
+};
+
+static struct samsung_gate_clock aud_gate_clks[] __initdata = {
+        GATE(SCLK_PCM, "sclk_pcm", "dout_sclk_pcm",
+                        ENABLE_SCLK_AUD, 27, CLK_SET_RATE_PARENT, 0),
+        GATE(SCLK_I2S, "sclk_i2s", "dout_sclk_i2s",
+                        ENABLE_SCLK_AUD, 28, CLK_SET_RATE_PARENT, 0),
+        GATE(0, "sclk_uart", "dout_sclk_uart", ENABLE_SCLK_AUD, 29, 0, 0),
+        GATE(0, "sclk_slimbus", "dout_sclk_slimbus",
+                        ENABLE_SCLK_AUD, 30, 0, 0),
+
+        GATE(0, "pclk_dbg_aud", "dout_aud_pclk_dbg", ENABLE_PCLK_AUD, 19, 0, 0),
+        GATE(0, "pclk_gpio_aud", "dout_aclk_aud", ENABLE_PCLK_AUD, 20, 0, 0),
+        GATE(0, "pclk_wdt1", "dout_aclk_aud", ENABLE_PCLK_AUD, 22, 0, 0),
+        GATE(0, "pclk_wdt0", "dout_aclk_aud", ENABLE_PCLK_AUD, 23, 0, 0),
+        GATE(0, "pclk_slimbus", "dout_aclk_aud", ENABLE_PCLK_AUD, 24, 0, 0),
+        GATE(0, "pclk_uart", "dout_aclk_aud", ENABLE_PCLK_AUD, 25, 0, 0),
+        GATE(PCLK_PCM, "pclk_pcm", "dout_aclk_aud",
+                        ENABLE_PCLK_AUD, 26, CLK_SET_RATE_PARENT, 0),
+        GATE(PCLK_I2S, "pclk_i2s", "dout_aclk_aud",
+                        ENABLE_PCLK_AUD, 27, CLK_SET_RATE_PARENT, 0),
+        GATE(0, "pclk_timer", "dout_aclk_aud", ENABLE_PCLK_AUD, 28, 0, 0),
+        GATE(0, "pclk_smmu_aud", "dout_aclk_aud", ENABLE_PCLK_AUD, 31, 0, 0),
+
+        GATE(0, "aclk_smmu_aud", "dout_aclk_aud", ENABLE_ACLK_AUD, 27, 0, 0),
+        GATE(0, "aclk_acel_lh_async_si_top", "dout_aclk_aud",
+                         ENABLE_ACLK_AUD, 28, 0, 0),
+        GATE(ACLK_ADMA, "aclk_dmac", "dout_aclk_aud", ENABLE_ACLK_AUD, 31, 0, 0),
+};
+
+static struct samsung_cmu_info aud_cmu_info __initdata = {
+        .mux_clks               = aud_mux_clks,
+        .nr_mux_clks            = ARRAY_SIZE(aud_mux_clks),
+        .div_clks               = aud_div_clks,
+        .nr_div_clks            = ARRAY_SIZE(aud_div_clks),
+        .gate_clks              = aud_gate_clks,
+        .nr_gate_clks           = ARRAY_SIZE(aud_gate_clks),
+        .nr_clk_ids             = AUD_NR_CLK,
+        .clk_regs               = aud_clk_regs,
+        .nr_clk_regs            = ARRAY_SIZE(aud_clk_regs),
+};
+
+static void __init exynos7_clk_aud_init(struct device_node *np)
+{
+        samsung_cmu_register_one(np, &aud_cmu_info);
+}
+
+CLK_OF_DECLARE(exynos7_clk_aud, "samsung,exynos7-clock-aud",
+                exynos7_clk_aud_init);
diff --git a/drivers/clk/samsung/clk.c b/drivers/clk/samsung/clk.c
index 4bda54095a16..9e1f88c04fd4 100644
--- a/drivers/clk/samsung/clk.c
+++ b/drivers/clk/samsung/clk.c
@@ -374,19 +374,24 @@ static void samsung_clk_sleep_init(void __iomem *reg_base,
  * Common function which registers plls, muxes, dividers and gates
  * for each CMU. It also add CMU register list to register cache.
  */
-void __init samsung_cmu_register_one(struct device_node *np,
+struct samsung_clk_provider * __init samsung_cmu_register_one(
+                        struct device_node *np,
                         struct samsung_cmu_info *cmu)
 {
         void __iomem *reg_base;
         struct samsung_clk_provider *ctx;
 
         reg_base = of_iomap(np, 0);
-        if (!reg_base)
+        if (!reg_base) {
                 panic("%s: failed to map registers\n", __func__);
+                return NULL;
+        }
 
         ctx = samsung_clk_init(np, reg_base, cmu->nr_clk_ids);
-        if (!ctx)
+        if (!ctx) {
                 panic("%s: unable to alllocate ctx\n", __func__);
+                return ctx;
+        }
 
         if (cmu->pll_clks)
                 samsung_clk_register_pll(ctx, cmu->pll_clks, cmu->nr_pll_clks,
@@ -410,4 +415,6 @@ void __init samsung_cmu_register_one(struct device_node *np,
                         cmu->nr_clk_regs);
 
         samsung_clk_of_add_provider(np, ctx);
+
+        return ctx;
 }
diff --git a/drivers/clk/samsung/clk.h b/drivers/clk/samsung/clk.h
index 8acabe1f32c4..e4c75383cea7 100644
--- a/drivers/clk/samsung/clk.h
+++ b/drivers/clk/samsung/clk.h
@@ -392,7 +392,8 @@ extern void __init samsung_clk_register_pll(struct samsung_clk_provider *ctx,
                         struct samsung_pll_clock *pll_list,
                         unsigned int nr_clk, void __iomem *base);
 
-extern void __init samsung_cmu_register_one(struct device_node *,
+extern struct samsung_clk_provider __init *samsung_cmu_register_one(
+                        struct device_node *,
                         struct samsung_cmu_info *);
 
 extern unsigned long _get_rate(const char *clk_name);
diff --git a/drivers/clk/shmobile/Makefile b/drivers/clk/shmobile/Makefile
index f83980f2b956..0689d7fb2666 100644
--- a/drivers/clk/shmobile/Makefile
+++ b/drivers/clk/shmobile/Makefile
@@ -1,9 +1,11 @@
 obj-$(CONFIG_ARCH_EMEV2)                += clk-emev2.o
 obj-$(CONFIG_ARCH_R7S72100)             += clk-rz.o
+obj-$(CONFIG_ARCH_R8A73A4)              += clk-r8a73a4.o
 obj-$(CONFIG_ARCH_R8A7740)              += clk-r8a7740.o
 obj-$(CONFIG_ARCH_R8A7779)              += clk-r8a7779.o
 obj-$(CONFIG_ARCH_R8A7790)              += clk-rcar-gen2.o
 obj-$(CONFIG_ARCH_R8A7791)              += clk-rcar-gen2.o
+obj-$(CONFIG_ARCH_R8A7793)              += clk-rcar-gen2.o
 obj-$(CONFIG_ARCH_R8A7794)              += clk-rcar-gen2.o
 obj-$(CONFIG_ARCH_SH73A0)               += clk-sh73a0.o
 obj-$(CONFIG_ARCH_SHMOBILE_MULTI)       += clk-div6.o
diff --git a/drivers/clk/shmobile/clk-div6.c b/drivers/clk/shmobile/clk-div6.c
index 639241e31e03..036a692c7219 100644
--- a/drivers/clk/shmobile/clk-div6.c
+++ b/drivers/clk/shmobile/clk-div6.c
@@ -54,12 +54,19 @@ static int cpg_div6_clock_enable(struct clk_hw *hw)
 static void cpg_div6_clock_disable(struct clk_hw *hw)
 {
         struct div6_clock *clock = to_div6_clock(hw);
+        u32 val;
 
-        /* DIV6 clocks require the divisor field to be non-zero when stopping
-         * the clock.
+        val = clk_readl(clock->reg);
+        val |= CPG_DIV6_CKSTP;
+        /*
+         * DIV6 clocks require the divisor field to be non-zero when stopping
+         * the clock. However, some clocks (e.g. ZB on sh73a0) fail to be
+         * re-enabled later if the divisor field is changed when stopping the
+         * clock
          */
-        clk_writel(clk_readl(clock->reg) | CPG_DIV6_CKSTP | CPG_DIV6_DIV_MASK,
-                   clock->reg);
+        if (!(val & CPG_DIV6_DIV_MASK))
+                val |= CPG_DIV6_DIV_MASK;
+        clk_writel(val, clock->reg);
 }
 
 static int cpg_div6_clock_is_enabled(struct clk_hw *hw)
@@ -83,6 +90,9 @@ static unsigned int cpg_div6_clock_calc_div(unsigned long rate,
 {
         unsigned int div;
 
+        if (!rate)
+                rate = 1;
+
         div = DIV_ROUND_CLOSEST(parent_rate, rate);
         return clamp_t(unsigned int, div, 1, 64);
 }
diff --git a/drivers/clk/shmobile/clk-r8a73a4.c b/drivers/clk/shmobile/clk-r8a73a4.c
new file mode 100644
index 000000000000..29b9a0b0012a
--- /dev/null
+++ b/drivers/clk/shmobile/clk-r8a73a4.c
@@ -0,0 +1,241 @@
+/*
+ * r8a73a4 Core CPG Clocks
+ *
+ * Copyright (C) 2014  Ulrich Hecht
+ *
+ * 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.
+ */
+
+#include <linux/clk-provider.h>
+#include <linux/clkdev.h>
+#include <linux/clk/shmobile.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/spinlock.h>
+
+struct r8a73a4_cpg {
+        struct clk_onecell_data data;
+        spinlock_t lock;
+        void __iomem *reg;
+};
+
+#define CPG_CKSCR       0xc0
+#define CPG_FRQCRA      0x00
+#define CPG_FRQCRB      0x04
+#define CPG_FRQCRC      0xe0
+#define CPG_PLL0CR      0xd8
+#define CPG_PLL1CR      0x28
+#define CPG_PLL2CR      0x2c
+#define CPG_PLL2HCR     0xe4
+#define CPG_PLL2SCR     0xf4
+
+#define CLK_ENABLE_ON_INIT BIT(0)
+
+struct div4_clk {
+        const char *name;
+        unsigned int reg;
+        unsigned int shift;
+};
+
+static struct div4_clk div4_clks[] = {
+        { "i",  CPG_FRQCRA, 20 },
+        { "m3", CPG_FRQCRA, 12 },
+        { "b",  CPG_FRQCRA,  8 },
+        { "m1", CPG_FRQCRA,  4 },
+        { "m2", CPG_FRQCRA,  0 },
+        { "zx", CPG_FRQCRB, 12 },
+        { "zs", CPG_FRQCRB,  8 },
+        { "hp", CPG_FRQCRB,  4 },
+        { NULL, 0, 0 },
+};
+
+static const struct clk_div_table div4_div_table[] = {
+        { 0, 2 }, { 1, 3 }, { 2, 4 }, { 3, 6 }, { 4, 8 }, { 5, 12 },
+        { 6, 16 }, { 7, 18 }, { 8, 24 }, { 10, 36 }, { 11, 48 },
+        { 12, 10 }, { 0, 0 }
+};
+
+static struct clk * __init
+r8a73a4_cpg_register_clock(struct device_node *np, struct r8a73a4_cpg *cpg,
+                             const char *name)
+{
+        const struct clk_div_table *table = NULL;
+        const char *parent_name;
+        unsigned int shift, reg;
+        unsigned int mult = 1;
+        unsigned int div = 1;
+
+
+        if (!strcmp(name, "main")) {
+                u32 ckscr = clk_readl(cpg->reg + CPG_CKSCR);
+
+                switch ((ckscr >> 28) & 3) {
+                case 0: /* extal1 */
+                        parent_name = of_clk_get_parent_name(np, 0);
+                        break;
+                case 1: /* extal1 / 2 */
+                        parent_name = of_clk_get_parent_name(np, 0);
+                        div = 2;
+                        break;
+                case 2: /* extal2 */
+                        parent_name = of_clk_get_parent_name(np, 1);
+                        break;
+                case 3: /* extal2 / 2 */
+                        parent_name = of_clk_get_parent_name(np, 1);
+                        div = 2;
+                        break;
+                }
+        } else if (!strcmp(name, "pll0")) {
+                /* PLL0/1 are configurable multiplier clocks. Register them as
+                 * fixed factor clocks for now as there's no generic multiplier
+                 * clock implementation and we currently have no need to change
+                 * the multiplier value.
+                 */
+                u32 value = clk_readl(cpg->reg + CPG_PLL0CR);
+
+                parent_name = "main";
+                mult = ((value >> 24) & 0x7f) + 1;
+                if (value & BIT(20))
+                        div = 2;
+        } else if (!strcmp(name, "pll1")) {
+                u32 value = clk_readl(cpg->reg + CPG_PLL1CR);
+
+                parent_name = "main";
+                /* XXX: enable bit? */
+                mult = ((value >> 24) & 0x7f) + 1;
+                if (value & BIT(7))
+                        div = 2;
+        } else if (!strncmp(name, "pll2", 4)) {
+                u32 value, cr;
+
+                switch (name[4]) {
+                case 0:
+                        cr = CPG_PLL2CR;
+                        break;
+                case 's':
+                        cr = CPG_PLL2SCR;
+                        break;
+                case 'h':
+                        cr = CPG_PLL2HCR;
+                        break;
+                default:
+                        return ERR_PTR(-EINVAL);
+                }
+                value = clk_readl(cpg->reg + cr);
+                switch ((value >> 5) & 7) {
+                case 0:
+                        parent_name = "main";
+                        div = 2;
+                        break;
+                case 1:
+                        parent_name = "extal2";
+                        div = 2;
+                        break;
+                case 3:
+                        parent_name = "extal2";
+                        div = 4;
+                        break;
+                case 4:
+                        parent_name = "main";
+                        break;
+                case 5:
+                        parent_name = "extal2";
+                        break;
+                default:
+                        pr_warn("%s: unexpected parent of %s\n", __func__,
+                                name);
+                        return ERR_PTR(-EINVAL);
+                }
+                /* XXX: enable bit? */
+                mult = ((value >> 24) & 0x7f) + 1;
+        } else if (!strcmp(name, "z") || !strcmp(name, "z2")) {
+                u32 shift = 8;
+
+                parent_name = "pll0";
+                if (name[1] == '2') {
+                        div = 2;
+                        shift = 0;
+                }
+                div *= 32;
+                mult = 0x20 - ((clk_readl(cpg->reg + CPG_FRQCRC) >> shift)
+                       & 0x1f);
+        } else {
+                struct div4_clk *c;
+
+                for (c = div4_clks; c->name; c++) {
+                        if (!strcmp(name, c->name))
+                                break;
+                }
+                if (!c->name)
+                        return ERR_PTR(-EINVAL);
+
+                parent_name = "pll1";
+                table = div4_div_table;
+                reg = c->reg;
+                shift = c->shift;
+        }
+
+        if (!table) {
+                return clk_register_fixed_factor(NULL, name, parent_name, 0,
+                                                 mult, div);
+        } else {
+                return clk_register_divider_table(NULL, name, parent_name, 0,
+                                                  cpg->reg + reg, shift, 4, 0,
+                                                  table, &cpg->lock);
+        }
+}
+
+static void __init r8a73a4_cpg_clocks_init(struct device_node *np)
+{
+        struct r8a73a4_cpg *cpg;
+        struct clk **clks;
+        unsigned int i;
+        int num_clks;
+
+        num_clks = of_property_count_strings(np, "clock-output-names");
+        if (num_clks < 0) {
+                pr_err("%s: failed to count clocks\n", __func__);
+                return;
+        }
+
+        cpg = kzalloc(sizeof(*cpg), GFP_KERNEL);
+        clks = kcalloc(num_clks, sizeof(*clks), GFP_KERNEL);
+        if (cpg == NULL || clks == NULL) {
+                /* We're leaking memory on purpose, there's no point in cleaning
+                 * up as the system won't boot anyway.
+                 */
+                return;
+        }
+
+        spin_lock_init(&cpg->lock);
+
+        cpg->data.clks = clks;
+        cpg->data.clk_num = num_clks;
+
+        cpg->reg = of_iomap(np, 0);
+        if (WARN_ON(cpg->reg == NULL))
+                return;
+
+        for (i = 0; i < num_clks; ++i) {
+                const char *name;
+                struct clk *clk;
+
+                of_property_read_string_index(np, "clock-output-names", i,
+                                              &name);
+
+                clk = r8a73a4_cpg_register_clock(np, cpg, name);
+                if (IS_ERR(clk))
+                        pr_err("%s: failed to register %s %s clock (%ld)\n",
+                               __func__, np->name, name, PTR_ERR(clk));
+                else
+                        cpg->data.clks[i] = clk;
+        }
+
+        of_clk_add_provider(np, of_clk_src_onecell_get, &cpg->data);
+}
+CLK_OF_DECLARE(r8a73a4_cpg_clks, "renesas,r8a73a4-cpg-clocks",
+               r8a73a4_cpg_clocks_init);
diff --git a/drivers/clk/shmobile/clk-rcar-gen2.c b/drivers/clk/shmobile/clk-rcar-gen2.c
index e996425d06a9..acfb6d7dbd6b 100644
--- a/drivers/clk/shmobile/clk-rcar-gen2.c
+++ b/drivers/clk/shmobile/clk-rcar-gen2.c
@@ -33,6 +33,8 @@ struct rcar_gen2_cpg {
 #define CPG_FRQCRC                      0x000000e0
 #define CPG_FRQCRC_ZFC_MASK             (0x1f << 8)
 #define CPG_FRQCRC_ZFC_SHIFT            8
+#define CPG_ADSPCKCR                    0x0000025c
+#define CPG_RCANCKCR                    0x00000270
 
 /* -----------------------------------------------------------------------------
  * Z Clock
@@ -161,6 +163,88 @@ static struct clk * __init cpg_z_clk_register(struct rcar_gen2_cpg *cpg)
         return clk;
 }
 
+static struct clk * __init cpg_rcan_clk_register(struct rcar_gen2_cpg *cpg,
+                                                 struct device_node *np)
+{
+        const char *parent_name = of_clk_get_parent_name(np, 1);
+        struct clk_fixed_factor *fixed;
+        struct clk_gate *gate;
+        struct clk *clk;
+
+        fixed = kzalloc(sizeof(*fixed), GFP_KERNEL);
+        if (!fixed)
+                return ERR_PTR(-ENOMEM);
+
+        fixed->mult = 1;
+        fixed->div = 6;
+
+        gate = kzalloc(sizeof(*gate), GFP_KERNEL);
+        if (!gate) {
+                kfree(fixed);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        gate->reg = cpg->reg + CPG_RCANCKCR;
+        gate->bit_idx = 8;
+        gate->flags = CLK_GATE_SET_TO_DISABLE;
+        gate->lock = &cpg->lock;
+
+        clk = clk_register_composite(NULL, "rcan", &parent_name, 1, NULL, NULL,
+                                     &fixed->hw, &clk_fixed_factor_ops,
+                                     &gate->hw, &clk_gate_ops, 0);
+        if (IS_ERR(clk)) {
+                kfree(gate);
+                kfree(fixed);
+        }
+
+        return clk;
+}
+
+/* ADSP divisors */
+static const struct clk_div_table cpg_adsp_div_table[] = {
+        {  1,  3 }, {  2,  4 }, {  3,  6 }, {  4,  8 },
+        {  5, 12 }, {  6, 16 }, {  7, 18 }, {  8, 24 },
+        { 10, 36 }, { 11, 48 }, {  0,  0 },
+};
+
+static struct clk * __init cpg_adsp_clk_register(struct rcar_gen2_cpg *cpg)
+{
+        const char *parent_name = "pll1";
+        struct clk_divider *div;
+        struct clk_gate *gate;
+        struct clk *clk;
+
+        div = kzalloc(sizeof(*div), GFP_KERNEL);
+        if (!div)
+                return ERR_PTR(-ENOMEM);
+
+        div->reg = cpg->reg + CPG_ADSPCKCR;
+        div->width = 4;
+        div->table = cpg_adsp_div_table;
+        div->lock = &cpg->lock;
+
+        gate = kzalloc(sizeof(*gate), GFP_KERNEL);
+        if (!gate) {
+                kfree(div);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        gate->reg = cpg->reg + CPG_ADSPCKCR;
+        gate->bit_idx = 8;
+        gate->flags = CLK_GATE_SET_TO_DISABLE;
+        gate->lock = &cpg->lock;
+
+        clk = clk_register_composite(NULL, "adsp", &parent_name, 1, NULL, NULL,
+                                     &div->hw, &clk_divider_ops,
+                                     &gate->hw, &clk_gate_ops, 0);
+        if (IS_ERR(clk)) {
+                kfree(gate);
+                kfree(div);
+        }
+
+        return clk;
+}
+
 /* -----------------------------------------------------------------------------
  * CPG Clock Data
  */
@@ -263,6 +347,10 @@ rcar_gen2_cpg_register_clock(struct device_node *np, struct rcar_gen2_cpg *cpg,
                 shift = 0;
         } else if (!strcmp(name, "z")) {
                 return cpg_z_clk_register(cpg);
+        } else if (!strcmp(name, "rcan")) {
+                return cpg_rcan_clk_register(cpg, np);
+        } else if (!strcmp(name, "adsp")) {
+                return cpg_adsp_clk_register(cpg);
         } else {
                 return ERR_PTR(-EINVAL);
         }
diff --git a/drivers/clk/st/clk-flexgen.c b/drivers/clk/st/clk-flexgen.c
index 2282cef9f2ff..bf12a25eb3a2 100644
--- a/drivers/clk/st/clk-flexgen.c
+++ b/drivers/clk/st/clk-flexgen.c
@@ -37,8 +37,8 @@ static int flexgen_enable(struct clk_hw *hw)
         struct clk_hw *pgate_hw = &flexgen->pgate.hw;
         struct clk_hw *fgate_hw = &flexgen->fgate.hw;
 
-        pgate_hw->clk = hw->clk;
-        fgate_hw->clk = hw->clk;
+        __clk_hw_set_clk(pgate_hw, hw);
+        __clk_hw_set_clk(fgate_hw, hw);
 
         clk_gate_ops.enable(pgate_hw);
 
@@ -54,7 +54,7 @@ static void flexgen_disable(struct clk_hw *hw)
         struct clk_hw *fgate_hw = &flexgen->fgate.hw;
 
         /* disable only the final gate */
-        fgate_hw->clk = hw->clk;
+        __clk_hw_set_clk(fgate_hw, hw);
 
         clk_gate_ops.disable(fgate_hw);
 
@@ -66,7 +66,7 @@ static int flexgen_is_enabled(struct clk_hw *hw)
         struct flexgen *flexgen = to_flexgen(hw);
         struct clk_hw *fgate_hw = &flexgen->fgate.hw;
 
-        fgate_hw->clk = hw->clk;
+        __clk_hw_set_clk(fgate_hw, hw);
 
         if (!clk_gate_ops.is_enabled(fgate_hw))
                 return 0;
@@ -79,7 +79,7 @@ static u8 flexgen_get_parent(struct clk_hw *hw)
         struct flexgen *flexgen = to_flexgen(hw);
         struct clk_hw *mux_hw = &flexgen->mux.hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         return clk_mux_ops.get_parent(mux_hw);
 }
@@ -89,7 +89,7 @@ static int flexgen_set_parent(struct clk_hw *hw, u8 index)
         struct flexgen *flexgen = to_flexgen(hw);
         struct clk_hw *mux_hw = &flexgen->mux.hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         return clk_mux_ops.set_parent(mux_hw, index);
 }
@@ -124,8 +124,8 @@ unsigned long flexgen_recalc_rate(struct clk_hw *hw,
         struct clk_hw *fdiv_hw = &flexgen->fdiv.hw;
         unsigned long mid_rate;
 
-        pdiv_hw->clk = hw->clk;
-        fdiv_hw->clk = hw->clk;
+        __clk_hw_set_clk(pdiv_hw, hw);
+        __clk_hw_set_clk(fdiv_hw, hw);
 
         mid_rate = clk_divider_ops.recalc_rate(pdiv_hw, parent_rate);
 
@@ -138,16 +138,27 @@ static int flexgen_set_rate(struct clk_hw *hw, unsigned long rate,
         struct flexgen *flexgen = to_flexgen(hw);
         struct clk_hw *pdiv_hw = &flexgen->pdiv.hw;
         struct clk_hw *fdiv_hw = &flexgen->fdiv.hw;
-        unsigned long primary_div = 0;
+        unsigned long div = 0;
         int ret = 0;
 
-        pdiv_hw->clk = hw->clk;
-        fdiv_hw->clk = hw->clk;
+        __clk_hw_set_clk(pdiv_hw, hw);
+        __clk_hw_set_clk(fdiv_hw, hw);
 
-        primary_div = clk_best_div(parent_rate, rate);
+        div = clk_best_div(parent_rate, rate);
 
-        clk_divider_ops.set_rate(fdiv_hw, parent_rate, parent_rate);
-        ret = clk_divider_ops.set_rate(pdiv_hw, rate, rate * primary_div);
+        /*
+        * pdiv is mainly targeted for low freq results, while fdiv
+        * should be used for div <= 64. The other way round can
+        * lead to 'duty cycle' issues.
+        */
+
+        if (div <= 64) {
+                clk_divider_ops.set_rate(pdiv_hw, parent_rate, parent_rate);
+                ret = clk_divider_ops.set_rate(fdiv_hw, rate, rate * div);
+        } else {
+                clk_divider_ops.set_rate(fdiv_hw, parent_rate, parent_rate);
+                ret = clk_divider_ops.set_rate(pdiv_hw, rate, rate * div);
+        }
 
         return ret;
 }
diff --git a/drivers/clk/st/clkgen-mux.c b/drivers/clk/st/clkgen-mux.c
index 79dc40b5cc68..9a15ec344a85 100644
--- a/drivers/clk/st/clkgen-mux.c
+++ b/drivers/clk/st/clkgen-mux.c
@@ -94,7 +94,7 @@ static int clkgena_divmux_enable(struct clk_hw *hw)
         unsigned long timeout;
         int ret = 0;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         ret = clk_mux_ops.set_parent(mux_hw, genamux->muxsel);
         if (ret)
@@ -116,7 +116,7 @@ static void clkgena_divmux_disable(struct clk_hw *hw)
         struct clkgena_divmux *genamux = to_clkgena_divmux(hw);
         struct clk_hw *mux_hw = &genamux->mux.hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         clk_mux_ops.set_parent(mux_hw, CKGAX_CLKOPSRC_SWITCH_OFF);
 }
@@ -126,7 +126,7 @@ static int clkgena_divmux_is_enabled(struct clk_hw *hw)
         struct clkgena_divmux *genamux = to_clkgena_divmux(hw);
         struct clk_hw *mux_hw = &genamux->mux.hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         return (s8)clk_mux_ops.get_parent(mux_hw) > 0;
 }
@@ -136,7 +136,7 @@ u8 clkgena_divmux_get_parent(struct clk_hw *hw)
         struct clkgena_divmux *genamux = to_clkgena_divmux(hw);
         struct clk_hw *mux_hw = &genamux->mux.hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         genamux->muxsel = clk_mux_ops.get_parent(mux_hw);
         if ((s8)genamux->muxsel < 0) {
@@ -174,7 +174,7 @@ unsigned long clkgena_divmux_recalc_rate(struct clk_hw *hw,
         struct clkgena_divmux *genamux = to_clkgena_divmux(hw);
         struct clk_hw *div_hw = &genamux->div[genamux->muxsel].hw;
 
-        div_hw->clk = hw->clk;
+        __clk_hw_set_clk(div_hw, hw);
 
         return clk_divider_ops.recalc_rate(div_hw, parent_rate);
 }
@@ -185,7 +185,7 @@ static int clkgena_divmux_set_rate(struct clk_hw *hw, unsigned long rate,
         struct clkgena_divmux *genamux = to_clkgena_divmux(hw);
         struct clk_hw *div_hw = &genamux->div[genamux->muxsel].hw;
 
-        div_hw->clk = hw->clk;
+        __clk_hw_set_clk(div_hw, hw);
 
         return clk_divider_ops.set_rate(div_hw, rate, parent_rate);
 }
@@ -196,7 +196,7 @@ static long clkgena_divmux_round_rate(struct clk_hw *hw, unsigned long rate,
         struct clkgena_divmux *genamux = to_clkgena_divmux(hw);
         struct clk_hw *div_hw = &genamux->div[genamux->muxsel].hw;
 
-        div_hw->clk = hw->clk;
+        __clk_hw_set_clk(div_hw, hw);
 
         return clk_divider_ops.round_rate(div_hw, rate, prate);
 }
diff --git a/drivers/clk/sunxi/Makefile b/drivers/clk/sunxi/Makefile
index a66953c0f430..3a5292e3fcf8 100644
--- a/drivers/clk/sunxi/Makefile
+++ b/drivers/clk/sunxi/Makefile
@@ -8,6 +8,7 @@ obj-y += clk-a20-gmac.o
 obj-y += clk-mod0.o
 obj-y += clk-sun8i-mbus.o
 obj-y += clk-sun9i-core.o
+obj-y += clk-sun9i-mmc.o
 
 obj-$(CONFIG_MFD_SUN6I_PRCM) += \
         clk-sun6i-ar100.o clk-sun6i-apb0.o clk-sun6i-apb0-gates.o \
diff --git a/drivers/clk/sunxi/clk-factors.c b/drivers/clk/sunxi/clk-factors.c
index 62e08fb58554..8c20190a3e9f 100644
--- a/drivers/clk/sunxi/clk-factors.c
+++ b/drivers/clk/sunxi/clk-factors.c
@@ -80,6 +80,8 @@ static long clk_factors_round_rate(struct clk_hw *hw, unsigned long rate,
 }
 
 static long clk_factors_determine_rate(struct clk_hw *hw, unsigned long rate,
+                                       unsigned long min_rate,
+                                       unsigned long max_rate,
                                        unsigned long *best_parent_rate,
                                        struct clk_hw **best_parent_p)
 {
@@ -156,9 +158,10 @@ static const struct clk_ops clk_factors_ops = {
         .set_rate = clk_factors_set_rate,
 };
 
-struct clk * __init sunxi_factors_register(struct device_node *node,
-                                           const struct factors_data *data,
-                                           spinlock_t *lock)
+struct clk *sunxi_factors_register(struct device_node *node,
+                                   const struct factors_data *data,
+                                   spinlock_t *lock,
+                                   void __iomem *reg)
 {
         struct clk *clk;
         struct clk_factors *factors;
@@ -168,11 +171,8 @@ struct clk * __init sunxi_factors_register(struct device_node *node,
         struct clk_hw *mux_hw = NULL;
         const char *clk_name = node->name;
         const char *parents[FACTORS_MAX_PARENTS];
-        void __iomem *reg;
         int i = 0;
 
-        reg = of_iomap(node, 0);
-
         /* if we have a mux, we will have >1 parents */
         while (i < FACTORS_MAX_PARENTS &&
                (parents[i] = of_clk_get_parent_name(node, i)) != NULL)
diff --git a/drivers/clk/sunxi/clk-factors.h b/drivers/clk/sunxi/clk-factors.h
index 912238fde132..171085ab5513 100644
--- a/drivers/clk/sunxi/clk-factors.h
+++ b/drivers/clk/sunxi/clk-factors.h
@@ -36,8 +36,9 @@ struct clk_factors {
         spinlock_t *lock;
 };
 
-struct clk * __init sunxi_factors_register(struct device_node *node,
-                                           const struct factors_data *data,
-                                           spinlock_t *lock);
+struct clk *sunxi_factors_register(struct device_node *node,
+                                   const struct factors_data *data,
+                                   spinlock_t *lock,
+                                   void __iomem *reg);
 
 #endif
diff --git a/drivers/clk/sunxi/clk-mod0.c b/drivers/clk/sunxi/clk-mod0.c
index da0524eaee94..ec8f5a1fca09 100644
--- a/drivers/clk/sunxi/clk-mod0.c
+++ b/drivers/clk/sunxi/clk-mod0.c
@@ -17,6 +17,7 @@
 #include <linux/clk-provider.h>
 #include <linux/clkdev.h>
 #include <linux/of_address.h>
+#include <linux/platform_device.h>
 
 #include "clk-factors.h"
 
@@ -67,7 +68,7 @@ static struct clk_factors_config sun4i_a10_mod0_config = {
         .pwidth = 2,
 };
 
-static const struct factors_data sun4i_a10_mod0_data __initconst = {
+static const struct factors_data sun4i_a10_mod0_data = {
         .enable = 31,
         .mux = 24,
         .muxmask = BIT(1) | BIT(0),
@@ -79,15 +80,95 @@ static DEFINE_SPINLOCK(sun4i_a10_mod0_lock);
 
 static void __init sun4i_a10_mod0_setup(struct device_node *node)
 {
-        sunxi_factors_register(node, &sun4i_a10_mod0_data, &sun4i_a10_mod0_lock);
+        void __iomem *reg;
+
+        reg = of_iomap(node, 0);
+        if (!reg) {
+                /*
+                 * This happens with mod0 clk nodes instantiated through
+                 * mfd, as those do not have their resources assigned at
+                 * CLK_OF_DECLARE time yet, so do not print an error.
+                 */
+                return;
+        }
+
+        sunxi_factors_register(node, &sun4i_a10_mod0_data,
+                               &sun4i_a10_mod0_lock, reg);
 }
 CLK_OF_DECLARE(sun4i_a10_mod0, "allwinner,sun4i-a10-mod0-clk", sun4i_a10_mod0_setup);
 
+static int sun4i_a10_mod0_clk_probe(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct resource *r;
+        void __iomem *reg;
+
+        if (!np)
+                return -ENODEV;
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        reg = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(reg))
+                return PTR_ERR(reg);
+
+        sunxi_factors_register(np, &sun4i_a10_mod0_data,
+                               &sun4i_a10_mod0_lock, reg);
+        return 0;
+}
+
+static const struct of_device_id sun4i_a10_mod0_clk_dt_ids[] = {
+        { .compatible = "allwinner,sun4i-a10-mod0-clk" },
+        { /* sentinel */ }
+};
+
+static struct platform_driver sun4i_a10_mod0_clk_driver = {
+        .driver = {
+                .name = "sun4i-a10-mod0-clk",
+                .of_match_table = sun4i_a10_mod0_clk_dt_ids,
+        },
+        .probe = sun4i_a10_mod0_clk_probe,
+};
+module_platform_driver(sun4i_a10_mod0_clk_driver);
+
+static const struct factors_data sun9i_a80_mod0_data __initconst = {
+        .enable = 31,
+        .mux = 24,
+        .muxmask = BIT(3) | BIT(2) | BIT(1) | BIT(0),
+        .table = &sun4i_a10_mod0_config,
+        .getter = sun4i_a10_get_mod0_factors,
+};
+
+static void __init sun9i_a80_mod0_setup(struct device_node *node)
+{
+        void __iomem *reg;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+        if (IS_ERR(reg)) {
+                pr_err("Could not get registers for mod0-clk: %s\n",
+                       node->name);
+                return;
+        }
+
+        sunxi_factors_register(node, &sun9i_a80_mod0_data,
+                               &sun4i_a10_mod0_lock, reg);
+}
+CLK_OF_DECLARE(sun9i_a80_mod0, "allwinner,sun9i-a80-mod0-clk", sun9i_a80_mod0_setup);
+
 static DEFINE_SPINLOCK(sun5i_a13_mbus_lock);
 
 static void __init sun5i_a13_mbus_setup(struct device_node *node)
 {
-        struct clk *mbus = sunxi_factors_register(node, &sun4i_a10_mod0_data, &sun5i_a13_mbus_lock);
+        struct clk *mbus;
+        void __iomem *reg;
+
+        reg = of_iomap(node, 0);
+        if (!reg) {
+                pr_err("Could not get registers for a13-mbus-clk\n");
+                return;
+        }
+
+        mbus = sunxi_factors_register(node, &sun4i_a10_mod0_data,
+                                      &sun5i_a13_mbus_lock, reg);
 
         /* The MBUS clocks needs to be always enabled */
         __clk_get(mbus);
@@ -95,14 +176,10 @@ static void __init sun5i_a13_mbus_setup(struct device_node *node)
 }
 CLK_OF_DECLARE(sun5i_a13_mbus, "allwinner,sun5i-a13-mbus-clk", sun5i_a13_mbus_setup);
 
-struct mmc_phase_data {
-        u8      offset;
-};
-
 struct mmc_phase {
         struct clk_hw           hw;
+        u8                      offset;
         void __iomem            *reg;
-        struct mmc_phase_data   *data;
         spinlock_t              *lock;
 };
 
@@ -118,7 +195,7 @@ static int mmc_get_phase(struct clk_hw *hw)
         u8 delay;
 
         value = readl(phase->reg);
-        delay = (value >> phase->data->offset) & 0x3;
+        delay = (value >> phase->offset) & 0x3;
 
         if (!delay)
                 return 180;
@@ -206,8 +283,8 @@ static int mmc_set_phase(struct clk_hw *hw, int degrees)
 
         spin_lock_irqsave(phase->lock, flags);
         value = readl(phase->reg);
-        value &= ~GENMASK(phase->data->offset + 3, phase->data->offset);
-        value |= delay << phase->data->offset;
+        value &= ~GENMASK(phase->offset + 3, phase->offset);
+        value |= delay << phase->offset;
         writel(value, phase->reg);
         spin_unlock_irqrestore(phase->lock, flags);
 
@@ -219,66 +296,97 @@ static const struct clk_ops mmc_clk_ops = {
         .set_phase      = mmc_set_phase,
 };
 
-static void __init sun4i_a10_mmc_phase_setup(struct device_node *node,
-                                             struct mmc_phase_data *data)
+/*
+ * sunxi_mmc_setup - Common setup function for mmc module clocks
+ *
+ * The only difference between module clocks on different platforms is the
+ * width of the mux register bits and the valid values, which are passed in
+ * through struct factors_data. The phase clocks parts are identical.
+ */
+static void __init sunxi_mmc_setup(struct device_node *node,
+                                   const struct factors_data *data,
+                                   spinlock_t *lock)
 {
-        const char *parent_names[1] = { of_clk_get_parent_name(node, 0) };
-        struct clk_init_data init = {
-                .num_parents    = 1,
-                .parent_names   = parent_names,
-                .ops            = &mmc_clk_ops,
-        };
-
-        struct mmc_phase *phase;
-        struct clk *clk;
-
-        phase = kmalloc(sizeof(*phase), GFP_KERNEL);
-        if (!phase)
+        struct clk_onecell_data *clk_data;
+        const char *parent;
+        void __iomem *reg;
+        int i;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+        if (IS_ERR(reg)) {
+                pr_err("Couldn't map the %s clock registers\n", node->name);
                 return;
+        }
 
-        phase->hw.init = &init;
-
-        phase->reg = of_iomap(node, 0);
-        if (!phase->reg)
-                goto err_free;
-
-        phase->data = data;
-        phase->lock = &sun4i_a10_mod0_lock;
-
-        if (of_property_read_string(node, "clock-output-names", &init.name))
-                init.name = node->name;
+        clk_data = kmalloc(sizeof(*clk_data), GFP_KERNEL);
+        if (!clk_data)
+                return;
 
-        clk = clk_register(NULL, &phase->hw);
-        if (IS_ERR(clk))
-                goto err_unmap;
+        clk_data->clks = kcalloc(3, sizeof(*clk_data->clks), GFP_KERNEL);
+        if (!clk_data->clks)
+                goto err_free_data;
+
+        clk_data->clk_num = 3;
+        clk_data->clks[0] = sunxi_factors_register(node, data, lock, reg);
+        if (!clk_data->clks[0])
+                goto err_free_clks;
+
+        parent = __clk_get_name(clk_data->clks[0]);
+
+        for (i = 1; i < 3; i++) {
+                struct clk_init_data init = {
+                        .num_parents    = 1,
+                        .parent_names   = &parent,
+                        .ops            = &mmc_clk_ops,
+                };
+                struct mmc_phase *phase;
+
+                phase = kmalloc(sizeof(*phase), GFP_KERNEL);
+                if (!phase)
+                        continue;
+
+                phase->hw.init = &init;
+                phase->reg = reg;
+                phase->lock = lock;
+
+                if (i == 1)
+                        phase->offset = 8;
+                else
+                        phase->offset = 20;
+
+                if (of_property_read_string_index(node, "clock-output-names",
+                                                  i, &init.name))
+                        init.name = node->name;
+
+                clk_data->clks[i] = clk_register(NULL, &phase->hw);
+                if (IS_ERR(clk_data->clks[i])) {
+                        kfree(phase);
+                        continue;
+                }
+        }
 
-        of_clk_add_provider(node, of_clk_src_simple_get, clk);
+        of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
 
         return;
 
-err_unmap:
-        iounmap(phase->reg);
-err_free:
-        kfree(phase);
+err_free_clks:
+        kfree(clk_data->clks);
+err_free_data:
+        kfree(clk_data);
 }
 
+static DEFINE_SPINLOCK(sun4i_a10_mmc_lock);
 
-static struct mmc_phase_data mmc_output_clk = {
-        .offset = 8,
-};
-
-static struct mmc_phase_data mmc_sample_clk = {
-        .offset = 20,
-};
-
-static void __init sun4i_a10_mmc_output_setup(struct device_node *node)
+static void __init sun4i_a10_mmc_setup(struct device_node *node)
 {
-        sun4i_a10_mmc_phase_setup(node, &mmc_output_clk);
+        sunxi_mmc_setup(node, &sun4i_a10_mod0_data, &sun4i_a10_mmc_lock);
 }
-CLK_OF_DECLARE(sun4i_a10_mmc_output, "allwinner,sun4i-a10-mmc-output-clk", sun4i_a10_mmc_output_setup);
+CLK_OF_DECLARE(sun4i_a10_mmc, "allwinner,sun4i-a10-mmc-clk", sun4i_a10_mmc_setup);
+
+static DEFINE_SPINLOCK(sun9i_a80_mmc_lock);
 
-static void __init sun4i_a10_mmc_sample_setup(struct device_node *node)
+static void __init sun9i_a80_mmc_setup(struct device_node *node)
 {
-        sun4i_a10_mmc_phase_setup(node, &mmc_sample_clk);
+        sunxi_mmc_setup(node, &sun9i_a80_mod0_data, &sun9i_a80_mmc_lock);
 }
-CLK_OF_DECLARE(sun4i_a10_mmc_sample, "allwinner,sun4i-a10-mmc-sample-clk", sun4i_a10_mmc_sample_setup);
+CLK_OF_DECLARE(sun9i_a80_mmc, "allwinner,sun9i-a80-mmc-clk", sun9i_a80_mmc_setup);
diff --git a/drivers/clk/sunxi/clk-sun6i-ar100.c b/drivers/clk/sunxi/clk-sun6i-ar100.c
index 3d282fb8f85c..63cf149195ae 100644
--- a/drivers/clk/sunxi/clk-sun6i-ar100.c
+++ b/drivers/clk/sunxi/clk-sun6i-ar100.c
@@ -45,6 +45,8 @@ static unsigned long ar100_recalc_rate(struct clk_hw *hw,
 }
 
 static long ar100_determine_rate(struct clk_hw *hw, unsigned long rate,
+                                 unsigned long min_rate,
+                                 unsigned long max_rate,
                                  unsigned long *best_parent_rate,
                                  struct clk_hw **best_parent_clk)
 {
diff --git a/drivers/clk/sunxi/clk-sun8i-mbus.c b/drivers/clk/sunxi/clk-sun8i-mbus.c
index ef49786eefd3..14cd026064bf 100644
--- a/drivers/clk/sunxi/clk-sun8i-mbus.c
+++ b/drivers/clk/sunxi/clk-sun8i-mbus.c
@@ -69,8 +69,17 @@ static DEFINE_SPINLOCK(sun8i_a23_mbus_lock);
 
 static void __init sun8i_a23_mbus_setup(struct device_node *node)
 {
-        struct clk *mbus = sunxi_factors_register(node, &sun8i_a23_mbus_data,
-                                                  &sun8i_a23_mbus_lock);
+        struct clk *mbus;
+        void __iomem *reg;
+
+        reg = of_iomap(node, 0);
+        if (!reg) {
+                pr_err("Could not get registers for a23-mbus-clk\n");
+                return;
+        }
+
+        mbus = sunxi_factors_register(node, &sun8i_a23_mbus_data,
+                                      &sun8i_a23_mbus_lock, reg);
 
         /* The MBUS clocks needs to be always enabled */
         __clk_get(mbus);
diff --git a/drivers/clk/sunxi/clk-sun9i-core.c b/drivers/clk/sunxi/clk-sun9i-core.c
index 3cb9036d91bb..d8da77d72861 100644
--- a/drivers/clk/sunxi/clk-sun9i-core.c
+++ b/drivers/clk/sunxi/clk-sun9i-core.c
@@ -24,50 +24,51 @@
 
 
 /**
- * sun9i_a80_get_pll4_factors() - calculates n, p, m factors for PLL1
+ * sun9i_a80_get_pll4_factors() - calculates n, p, m factors for PLL4
  * PLL4 rate is calculated as follows
  * rate = (parent_rate * n >> p) / (m + 1);
- * parent_rate is always 24Mhz
+ * parent_rate is always 24MHz
  *
  * p and m are named div1 and div2 in Allwinner's SDK
  */
 
 static void sun9i_a80_get_pll4_factors(u32 *freq, u32 parent_rate,
-                                       u8 *n, u8 *k, u8 *m, u8 *p)
+                                       u8 *n_ret, u8 *k, u8 *m_ret, u8 *p_ret)
 {
-        int div;
+        int n;
+        int m = 1;
+        int p = 1;
 
-        /* Normalize value to a 6M multiple */
-        div = DIV_ROUND_UP(*freq, 6000000);
+        /* Normalize value to a 6 MHz multiple (24 MHz / 4) */
+        n = DIV_ROUND_UP(*freq, 6000000);
 
-        /* divs above 256 cannot be odd */
-        if (div > 256)
-                div = round_up(div, 2);
+        /* If n is too large switch to steps of 12 MHz */
+        if (n > 255) {
+                m = 0;
+                n = (n + 1) / 2;
+        }
+
+        /* If n is still too large switch to steps of 24 MHz */
+        if (n > 255) {
+                p = 0;
+                n = (n + 1) / 2;
+        }
 
-        /* divs above 512 must be a multiple of 4 */
-        if (div > 512)
-                div = round_up(div, 4);
+        /* n must be between 12 and 255 */
+        if (n > 255)
+                n = 255;
+        else if (n < 12)
+                n = 12;
 
-        *freq = 6000000 * div;
+        *freq = ((24000000 * n) >> p) / (m + 1);
 
         /* we were called to round the frequency, we can now return */
-        if (n == NULL)
+        if (n_ret == NULL)
                 return;
 
-        /* p will be 1 for divs under 512 */
-        if (div < 512)
-                *p = 1;
-        else
-                *p = 0;
-
-        /* m will be 1 if div is odd */
-        if (div & 1)
-                *m = 1;
-        else
-                *m = 0;
-
-        /* calculate a suitable n based on m and p */
-        *n = div / (*p + 1) / (*m + 1);
+        *n_ret = n;
+        *m_ret = m;
+        *p_ret = p;
 }
 
 static struct clk_factors_config sun9i_a80_pll4_config = {
@@ -89,7 +90,17 @@ static DEFINE_SPINLOCK(sun9i_a80_pll4_lock);
 
 static void __init sun9i_a80_pll4_setup(struct device_node *node)
 {
-        sunxi_factors_register(node, &sun9i_a80_pll4_data, &sun9i_a80_pll4_lock);
+        void __iomem *reg;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+        if (!reg) {
+                pr_err("Could not get registers for a80-pll4-clk: %s\n",
+                       node->name);
+                return;
+        }
+
+        sunxi_factors_register(node, &sun9i_a80_pll4_data,
+                               &sun9i_a80_pll4_lock, reg);
 }
 CLK_OF_DECLARE(sun9i_a80_pll4, "allwinner,sun9i-a80-pll4-clk", sun9i_a80_pll4_setup);
 
@@ -139,8 +150,18 @@ static DEFINE_SPINLOCK(sun9i_a80_gt_lock);
 
 static void __init sun9i_a80_gt_setup(struct device_node *node)
 {
-        struct clk *gt = sunxi_factors_register(node, &sun9i_a80_gt_data,
-                                                &sun9i_a80_gt_lock);
+        void __iomem *reg;
+        struct clk *gt;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+        if (!reg) {
+                pr_err("Could not get registers for a80-gt-clk: %s\n",
+                       node->name);
+                return;
+        }
+
+        gt = sunxi_factors_register(node, &sun9i_a80_gt_data,
+                                    &sun9i_a80_gt_lock, reg);
 
         /* The GT bus clock needs to be always enabled */
         __clk_get(gt);
@@ -194,7 +215,17 @@ static DEFINE_SPINLOCK(sun9i_a80_ahb_lock);
 
 static void __init sun9i_a80_ahb_setup(struct device_node *node)
 {
-        sunxi_factors_register(node, &sun9i_a80_ahb_data, &sun9i_a80_ahb_lock);
+        void __iomem *reg;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+        if (!reg) {
+                pr_err("Could not get registers for a80-ahb-clk: %s\n",
+                       node->name);
+                return;
+        }
+
+        sunxi_factors_register(node, &sun9i_a80_ahb_data,
+                               &sun9i_a80_ahb_lock, reg);
 }
 CLK_OF_DECLARE(sun9i_a80_ahb, "allwinner,sun9i-a80-ahb-clk", sun9i_a80_ahb_setup);
 
@@ -210,7 +241,17 @@ static DEFINE_SPINLOCK(sun9i_a80_apb0_lock);
 
 static void __init sun9i_a80_apb0_setup(struct device_node *node)
 {
-        sunxi_factors_register(node, &sun9i_a80_apb0_data, &sun9i_a80_apb0_lock);
+        void __iomem *reg;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+        if (!reg) {
+                pr_err("Could not get registers for a80-apb0-clk: %s\n",
+                       node->name);
+                return;
+        }
+
+        sunxi_factors_register(node, &sun9i_a80_apb0_data,
+                               &sun9i_a80_apb0_lock, reg);
 }
 CLK_OF_DECLARE(sun9i_a80_apb0, "allwinner,sun9i-a80-apb0-clk", sun9i_a80_apb0_setup);
 
@@ -266,6 +307,16 @@ static DEFINE_SPINLOCK(sun9i_a80_apb1_lock);
 
 static void __init sun9i_a80_apb1_setup(struct device_node *node)
 {
-        sunxi_factors_register(node, &sun9i_a80_apb1_data, &sun9i_a80_apb1_lock);
+        void __iomem *reg;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+        if (!reg) {
+                pr_err("Could not get registers for a80-apb1-clk: %s\n",
+                       node->name);
+                return;
+        }
+
+        sunxi_factors_register(node, &sun9i_a80_apb1_data,
+                               &sun9i_a80_apb1_lock, reg);
 }
 CLK_OF_DECLARE(sun9i_a80_apb1, "allwinner,sun9i-a80-apb1-clk", sun9i_a80_apb1_setup);
diff --git a/drivers/clk/sunxi/clk-sun9i-mmc.c b/drivers/clk/sunxi/clk-sun9i-mmc.c
new file mode 100644
index 000000000000..710c273648d7
--- /dev/null
+++ b/drivers/clk/sunxi/clk-sun9i-mmc.c
@@ -0,0 +1,219 @@
+/*
+ * Copyright 2015 Chen-Yu Tsai
+ *
+ * Chen-Yu Tsai <wens@csie.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.
+ */
+
+#include <linux/clk-provider.h>
+#include <linux/clkdev.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/reset.h>
+#include <linux/platform_device.h>
+#include <linux/reset-controller.h>
+#include <linux/spinlock.h>
+
+#define SUN9I_MMC_WIDTH         4
+
+#define SUN9I_MMC_GATE_BIT      16
+#define SUN9I_MMC_RESET_BIT     18
+
+struct sun9i_mmc_clk_data {
+        spinlock_t                      lock;
+        void __iomem                    *membase;
+        struct clk                      *clk;
+        struct reset_control            *reset;
+        struct clk_onecell_data         clk_data;
+        struct reset_controller_dev     rcdev;
+};
+
+static int sun9i_mmc_reset_assert(struct reset_controller_dev *rcdev,
+                              unsigned long id)
+{
+        struct sun9i_mmc_clk_data *data = container_of(rcdev,
+                                                       struct sun9i_mmc_clk_data,
+                                                       rcdev);
+        unsigned long flags;
+        void __iomem *reg = data->membase + SUN9I_MMC_WIDTH * id;
+        u32 val;
+
+        clk_prepare_enable(data->clk);
+        spin_lock_irqsave(&data->lock, flags);
+
+        val = readl(reg);
+        writel(val & ~BIT(SUN9I_MMC_RESET_BIT), reg);
+
+        spin_unlock_irqrestore(&data->lock, flags);
+        clk_disable_unprepare(data->clk);
+
+        return 0;
+}
+
+static int sun9i_mmc_reset_deassert(struct reset_controller_dev *rcdev,
+                                unsigned long id)
+{
+        struct sun9i_mmc_clk_data *data = container_of(rcdev,
+                                                       struct sun9i_mmc_clk_data,
+                                                       rcdev);
+        unsigned long flags;
+        void __iomem *reg = data->membase + SUN9I_MMC_WIDTH * id;
+        u32 val;
+
+        clk_prepare_enable(data->clk);
+        spin_lock_irqsave(&data->lock, flags);
+
+        val = readl(reg);
+        writel(val | BIT(SUN9I_MMC_RESET_BIT), reg);
+
+        spin_unlock_irqrestore(&data->lock, flags);
+        clk_disable_unprepare(data->clk);
+
+        return 0;
+}
+
+static struct reset_control_ops sun9i_mmc_reset_ops = {
+        .assert         = sun9i_mmc_reset_assert,
+        .deassert       = sun9i_mmc_reset_deassert,
+};
+
+static int sun9i_a80_mmc_config_clk_probe(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct sun9i_mmc_clk_data *data;
+        struct clk_onecell_data *clk_data;
+        const char *clk_name = np->name;
+        const char *clk_parent;
+        struct resource *r;
+        int count, i, ret;
+
+        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        spin_lock_init(&data->lock);
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        /* one clock/reset pair per word */
+        count = DIV_ROUND_UP((r->end - r->start + 1), SUN9I_MMC_WIDTH);
+        data->membase = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(data->membase))
+                return PTR_ERR(data->membase);
+
+        clk_data = &data->clk_data;
+        clk_data->clk_num = count;
+        clk_data->clks = devm_kcalloc(&pdev->dev, count, sizeof(struct clk *),
+                                      GFP_KERNEL);
+        if (!clk_data->clks)
+                return -ENOMEM;
+
+        data->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(data->clk)) {
+                dev_err(&pdev->dev, "Could not get clock\n");
+                return PTR_ERR(data->clk);
+        }
+
+        data->reset = devm_reset_control_get(&pdev->dev, NULL);
+        if (IS_ERR(data->reset)) {
+                dev_err(&pdev->dev, "Could not get reset control\n");
+                return PTR_ERR(data->reset);
+        }
+
+        ret = reset_control_deassert(data->reset);
+        if (ret) {
+                dev_err(&pdev->dev, "Reset deassert err %d\n", ret);
+                return ret;
+        }
+
+        clk_parent = __clk_get_name(data->clk);
+        for (i = 0; i < count; i++) {
+                of_property_read_string_index(np, "clock-output-names",
+                                              i, &clk_name);
+
+                clk_data->clks[i] = clk_register_gate(&pdev->dev, clk_name,
+                                                      clk_parent, 0,
+                                                      data->membase + SUN9I_MMC_WIDTH * i,
+                                                      SUN9I_MMC_GATE_BIT, 0,
+                                                      &data->lock);
+
+                if (IS_ERR(clk_data->clks[i])) {
+                        ret = PTR_ERR(clk_data->clks[i]);
+                        goto err_clk_register;
+                }
+        }
+
+        ret = of_clk_add_provider(np, of_clk_src_onecell_get, clk_data);
+        if (ret)
+                goto err_clk_provider;
+
+        data->rcdev.owner = THIS_MODULE;
+        data->rcdev.nr_resets = count;
+        data->rcdev.ops = &sun9i_mmc_reset_ops;
+        data->rcdev.of_node = pdev->dev.of_node;
+
+        ret = reset_controller_register(&data->rcdev);
+        if (ret)
+                goto err_rc_reg;
+
+        platform_set_drvdata(pdev, data);
+
+        return 0;
+
+err_rc_reg:
+        of_clk_del_provider(np);
+
+err_clk_provider:
+        for (i = 0; i < count; i++)
+                clk_unregister(clk_data->clks[i]);
+
+err_clk_register:
+        reset_control_assert(data->reset);
+
+        return ret;
+}
+
+static int sun9i_a80_mmc_config_clk_remove(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct sun9i_mmc_clk_data *data = platform_get_drvdata(pdev);
+        struct clk_onecell_data *clk_data = &data->clk_data;
+        int i;
+
+        reset_controller_unregister(&data->rcdev);
+        of_clk_del_provider(np);
+        for (i = 0; i < clk_data->clk_num; i++)
+                clk_unregister(clk_data->clks[i]);
+
+        reset_control_assert(data->reset);
+
+        return 0;
+}
+
+static const struct of_device_id sun9i_a80_mmc_config_clk_dt_ids[] = {
+        { .compatible = "allwinner,sun9i-a80-mmc-config-clk" },
+        { /* sentinel */ }
+};
+
+static struct platform_driver sun9i_a80_mmc_config_clk_driver = {
+        .driver = {
+                .name = "sun9i-a80-mmc-config-clk",
+                .of_match_table = sun9i_a80_mmc_config_clk_dt_ids,
+        },
+        .probe = sun9i_a80_mmc_config_clk_probe,
+        .remove = sun9i_a80_mmc_config_clk_remove,
+};
+module_platform_driver(sun9i_a80_mmc_config_clk_driver);
+
+MODULE_AUTHOR("Chen-Yu Tsai <wens@csie.org>");
+MODULE_DESCRIPTION("Allwinner A80 MMC clock/reset Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/clk/sunxi/clk-sunxi.c b/drivers/clk/sunxi/clk-sunxi.c
index 1818f404538d..379324eb5486 100644
--- a/drivers/clk/sunxi/clk-sunxi.c
+++ b/drivers/clk/sunxi/clk-sunxi.c
@@ -20,11 +20,221 @@
 #include <linux/of_address.h>
 #include <linux/reset-controller.h>
 #include <linux/spinlock.h>
+#include <linux/log2.h>
 
 #include "clk-factors.h"
 
 static DEFINE_SPINLOCK(clk_lock);
 
+/**
+ * sun6i_a31_ahb1_clk_setup() - Setup function for a31 ahb1 composite clk
+ */
+
+#define SUN6I_AHB1_MAX_PARENTS          4
+#define SUN6I_AHB1_MUX_PARENT_PLL6      3
+#define SUN6I_AHB1_MUX_SHIFT            12
+/* un-shifted mask is what mux_clk expects */
+#define SUN6I_AHB1_MUX_MASK             0x3
+#define SUN6I_AHB1_MUX_GET_PARENT(reg)  ((reg >> SUN6I_AHB1_MUX_SHIFT) & \
+                                         SUN6I_AHB1_MUX_MASK)
+
+#define SUN6I_AHB1_DIV_SHIFT            4
+#define SUN6I_AHB1_DIV_MASK             (0x3 << SUN6I_AHB1_DIV_SHIFT)
+#define SUN6I_AHB1_DIV_GET(reg)         ((reg & SUN6I_AHB1_DIV_MASK) >> \
+                                                SUN6I_AHB1_DIV_SHIFT)
+#define SUN6I_AHB1_DIV_SET(reg, div)    ((reg & ~SUN6I_AHB1_DIV_MASK) | \
+                                                (div << SUN6I_AHB1_DIV_SHIFT))
+#define SUN6I_AHB1_PLL6_DIV_SHIFT       6
+#define SUN6I_AHB1_PLL6_DIV_MASK        (0x3 << SUN6I_AHB1_PLL6_DIV_SHIFT)
+#define SUN6I_AHB1_PLL6_DIV_GET(reg)    ((reg & SUN6I_AHB1_PLL6_DIV_MASK) >> \
+                                                SUN6I_AHB1_PLL6_DIV_SHIFT)
+#define SUN6I_AHB1_PLL6_DIV_SET(reg, div) ((reg & ~SUN6I_AHB1_PLL6_DIV_MASK) | \
+                                                (div << SUN6I_AHB1_PLL6_DIV_SHIFT))
+
+struct sun6i_ahb1_clk {
+        struct clk_hw hw;
+        void __iomem *reg;
+};
+
+#define to_sun6i_ahb1_clk(_hw) container_of(_hw, struct sun6i_ahb1_clk, hw)
+
+static unsigned long sun6i_ahb1_clk_recalc_rate(struct clk_hw *hw,
+                                                unsigned long parent_rate)
+{
+        struct sun6i_ahb1_clk *ahb1 = to_sun6i_ahb1_clk(hw);
+        unsigned long rate;
+        u32 reg;
+
+        /* Fetch the register value */
+        reg = readl(ahb1->reg);
+
+        /* apply pre-divider first if parent is pll6 */
+        if (SUN6I_AHB1_MUX_GET_PARENT(reg) == SUN6I_AHB1_MUX_PARENT_PLL6)
+                parent_rate /= SUN6I_AHB1_PLL6_DIV_GET(reg) + 1;
+
+        /* clk divider */
+        rate = parent_rate >> SUN6I_AHB1_DIV_GET(reg);
+
+        return rate;
+}
+
+static long sun6i_ahb1_clk_round(unsigned long rate, u8 *divp, u8 *pre_divp,
+                                 u8 parent, unsigned long parent_rate)
+{
+        u8 div, calcp, calcm = 1;
+
+        /*
+         * clock can only divide, so we will never be able to achieve
+         * frequencies higher than the parent frequency
+         */
+        if (parent_rate && rate > parent_rate)
+                rate = parent_rate;
+
+        div = DIV_ROUND_UP(parent_rate, rate);
+
+        /* calculate pre-divider if parent is pll6 */
+        if (parent == SUN6I_AHB1_MUX_PARENT_PLL6) {
+                if (div < 4)
+                        calcp = 0;
+                else if (div / 2 < 4)
+                        calcp = 1;
+                else if (div / 4 < 4)
+                        calcp = 2;
+                else
+                        calcp = 3;
+
+                calcm = DIV_ROUND_UP(div, 1 << calcp);
+        } else {
+                calcp = __roundup_pow_of_two(div);
+                calcp = calcp > 3 ? 3 : calcp;
+        }
+
+        /* we were asked to pass back divider values */
+        if (divp) {
+                *divp = calcp;
+                *pre_divp = calcm - 1;
+        }
+
+        return (parent_rate / calcm) >> calcp;
+}
+
+static long sun6i_ahb1_clk_determine_rate(struct clk_hw *hw, unsigned long rate,
+                                          unsigned long min_rate,
+                                          unsigned long max_rate,
+                                          unsigned long *best_parent_rate,
+                                          struct clk_hw **best_parent_clk)
+{
+        struct clk *clk = hw->clk, *parent, *best_parent = NULL;
+        int i, num_parents;
+        unsigned long parent_rate, best = 0, child_rate, best_child_rate = 0;
+
+        /* find the parent that can help provide the fastest rate <= rate */
+        num_parents = __clk_get_num_parents(clk);
+        for (i = 0; i < num_parents; i++) {
+                parent = clk_get_parent_by_index(clk, i);
+                if (!parent)
+                        continue;
+                if (__clk_get_flags(clk) & CLK_SET_RATE_PARENT)
+                        parent_rate = __clk_round_rate(parent, rate);
+                else
+                        parent_rate = __clk_get_rate(parent);
+
+                child_rate = sun6i_ahb1_clk_round(rate, NULL, NULL, i,
+                                                  parent_rate);
+
+                if (child_rate <= rate && child_rate > best_child_rate) {
+                        best_parent = parent;
+                        best = parent_rate;
+                        best_child_rate = child_rate;
+                }
+        }
+
+        if (best_parent)
+                *best_parent_clk = __clk_get_hw(best_parent);
+        *best_parent_rate = best;
+
+        return best_child_rate;
+}
+
+static int sun6i_ahb1_clk_set_rate(struct clk_hw *hw, unsigned long rate,
+                                   unsigned long parent_rate)
+{
+        struct sun6i_ahb1_clk *ahb1 = to_sun6i_ahb1_clk(hw);
+        unsigned long flags;
+        u8 div, pre_div, parent;
+        u32 reg;
+
+        spin_lock_irqsave(&clk_lock, flags);
+
+        reg = readl(ahb1->reg);
+
+        /* need to know which parent is used to apply pre-divider */
+        parent = SUN6I_AHB1_MUX_GET_PARENT(reg);
+        sun6i_ahb1_clk_round(rate, &div, &pre_div, parent, parent_rate);
+
+        reg = SUN6I_AHB1_DIV_SET(reg, div);
+        reg = SUN6I_AHB1_PLL6_DIV_SET(reg, pre_div);
+        writel(reg, ahb1->reg);
+
+        spin_unlock_irqrestore(&clk_lock, flags);
+
+        return 0;
+}
+
+static const struct clk_ops sun6i_ahb1_clk_ops = {
+        .determine_rate = sun6i_ahb1_clk_determine_rate,
+        .recalc_rate    = sun6i_ahb1_clk_recalc_rate,
+        .set_rate       = sun6i_ahb1_clk_set_rate,
+};
+
+static void __init sun6i_ahb1_clk_setup(struct device_node *node)
+{
+        struct clk *clk;
+        struct sun6i_ahb1_clk *ahb1;
+        struct clk_mux *mux;
+        const char *clk_name = node->name;
+        const char *parents[SUN6I_AHB1_MAX_PARENTS];
+        void __iomem *reg;
+        int i = 0;
+
+        reg = of_io_request_and_map(node, 0, of_node_full_name(node));
+
+        /* we have a mux, we will have >1 parents */
+        while (i < SUN6I_AHB1_MAX_PARENTS &&
+               (parents[i] = of_clk_get_parent_name(node, i)) != NULL)
+                i++;
+
+        of_property_read_string(node, "clock-output-names", &clk_name);
+
+        ahb1 = kzalloc(sizeof(struct sun6i_ahb1_clk), GFP_KERNEL);
+        if (!ahb1)
+                return;
+
+        mux = kzalloc(sizeof(struct clk_mux), GFP_KERNEL);
+        if (!mux) {
+                kfree(ahb1);
+                return;
+        }
+
+        /* set up clock properties */
+        mux->reg = reg;
+        mux->shift = SUN6I_AHB1_MUX_SHIFT;
+        mux->mask = SUN6I_AHB1_MUX_MASK;
+        mux->lock = &clk_lock;
+        ahb1->reg = reg;
+
+        clk = clk_register_composite(NULL, clk_name, parents, i,
+                                     &mux->hw, &clk_mux_ops,
+                                     &ahb1->hw, &sun6i_ahb1_clk_ops,
+                                     NULL, NULL, 0);
+
+        if (!IS_ERR(clk)) {
+                of_clk_add_provider(node, of_clk_src_simple_get, clk);
+                clk_register_clkdev(clk, clk_name, NULL);
+        }
+}
+CLK_OF_DECLARE(sun6i_a31_ahb1, "allwinner,sun6i-a31-ahb1-clk", sun6i_ahb1_clk_setup);
+
 /* Maximum number of parents our clocks have */
 #define SUNXI_MAX_PARENTS       5
 
@@ -355,43 +565,6 @@ static void sun7i_a20_get_out_factors(u32 *freq, u32 parent_rate,
 }
 
 /**
- * clk_sunxi_mmc_phase_control() - configures MMC clock phase control
- */
-
-void clk_sunxi_mmc_phase_control(struct clk *clk, u8 sample, u8 output)
-{
-        #define to_clk_composite(_hw) container_of(_hw, struct clk_composite, hw)
-        #define to_clk_factors(_hw) container_of(_hw, struct clk_factors, hw)
-
-        struct clk_hw *hw = __clk_get_hw(clk);
-        struct clk_composite *composite = to_clk_composite(hw);
-        struct clk_hw *rate_hw = composite->rate_hw;
-        struct clk_factors *factors = to_clk_factors(rate_hw);
-        unsigned long flags = 0;
-        u32 reg;
-
-        if (factors->lock)
-                spin_lock_irqsave(factors->lock, flags);
-
-        reg = readl(factors->reg);
-
-        /* set sample clock phase control */
-        reg &= ~(0x7 << 20);
-        reg |= ((sample & 0x7) << 20);
-
-        /* set output clock phase control */
-        reg &= ~(0x7 << 8);
-        reg |= ((output & 0x7) << 8);
-
-        writel(reg, factors->reg);
-
-        if (factors->lock)
-                spin_unlock_irqrestore(factors->lock, flags);
-}
-EXPORT_SYMBOL(clk_sunxi_mmc_phase_control);
-
-
-/**
  * sunxi_factors_clk_setup() - Setup function for factor clocks
  */
 
@@ -413,6 +586,7 @@ static struct clk_factors_config sun6i_a31_pll1_config = {
         .kwidth = 2,
         .mshift = 0,
         .mwidth = 2,
+        .n_start = 1,
 };
 
 static struct clk_factors_config sun8i_a23_pll1_config = {
@@ -520,7 +694,16 @@ static const struct factors_data sun7i_a20_out_data __initconst = {
 static struct clk * __init sunxi_factors_clk_setup(struct device_node *node,
                                                    const struct factors_data *data)
 {
-        return sunxi_factors_register(node, data, &clk_lock);
+        void __iomem *reg;
+
+        reg = of_iomap(node, 0);
+        if (!reg) {
+                pr_err("Could not get registers for factors-clk: %s\n",
+                       node->name);
+                return NULL;
+        }
+
+        return sunxi_factors_register(node, data, &clk_lock, reg);
 }
 
 
@@ -561,7 +744,7 @@ static void __init sunxi_mux_clk_setup(struct device_node *node,
         of_property_read_string(node, "clock-output-names", &clk_name);
 
         clk = clk_register_mux(NULL, clk_name, parents, i,
-                               CLK_SET_RATE_NO_REPARENT, reg,
+                               CLK_SET_RATE_PARENT, reg,
                                data->shift, SUNXI_MUX_GATE_WIDTH,
                                0, &clk_lock);
 
@@ -1217,7 +1400,6 @@ CLK_OF_DECLARE(sun7i_a20_clk_init, "allwinner,sun7i-a20", sun5i_init_clocks);
 
 static const char *sun6i_critical_clocks[] __initdata = {
         "cpu",
-        "ahb1_sdram",
 };
 
 static void __init sun6i_init_clocks(struct device_node *node)
diff --git a/drivers/clk/tegra/Makefile b/drivers/clk/tegra/Makefile
index f7dfb72884a4..edb8358fa6ce 100644
--- a/drivers/clk/tegra/Makefile
+++ b/drivers/clk/tegra/Makefile
@@ -15,3 +15,4 @@ obj-$(CONFIG_ARCH_TEGRA_2x_SOC)         += clk-tegra20.o
 obj-$(CONFIG_ARCH_TEGRA_3x_SOC)         += clk-tegra30.o
 obj-$(CONFIG_ARCH_TEGRA_114_SOC)        += clk-tegra114.o
 obj-$(CONFIG_ARCH_TEGRA_124_SOC)        += clk-tegra124.o
+obj-$(CONFIG_ARCH_TEGRA_132_SOC)        += clk-tegra124.o
diff --git a/drivers/clk/tegra/clk-id.h b/drivers/clk/tegra/clk-id.h
index 0011d547a9f7..60738cc954cb 100644
--- a/drivers/clk/tegra/clk-id.h
+++ b/drivers/clk/tegra/clk-id.h
@@ -64,10 +64,8 @@ enum clk_id {
         tegra_clk_disp2,
         tegra_clk_dp2,
         tegra_clk_dpaux,
-        tegra_clk_dsia,
         tegra_clk_dsialp,
         tegra_clk_dsia_mux,
-        tegra_clk_dsib,
         tegra_clk_dsiblp,
         tegra_clk_dsib_mux,
         tegra_clk_dtv,
diff --git a/drivers/clk/tegra/clk-periph.c b/drivers/clk/tegra/clk-periph.c
index 9e899c18af86..d84ae49d0e05 100644
--- a/drivers/clk/tegra/clk-periph.c
+++ b/drivers/clk/tegra/clk-periph.c
@@ -28,7 +28,7 @@ static u8 clk_periph_get_parent(struct clk_hw *hw)
         const struct clk_ops *mux_ops = periph->mux_ops;
         struct clk_hw *mux_hw = &periph->mux.hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         return mux_ops->get_parent(mux_hw);
 }
@@ -39,7 +39,7 @@ static int clk_periph_set_parent(struct clk_hw *hw, u8 index)
         const struct clk_ops *mux_ops = periph->mux_ops;
         struct clk_hw *mux_hw = &periph->mux.hw;
 
-        mux_hw->clk = hw->clk;
+        __clk_hw_set_clk(mux_hw, hw);
 
         return mux_ops->set_parent(mux_hw, index);
 }
@@ -51,7 +51,7 @@ static unsigned long clk_periph_recalc_rate(struct clk_hw *hw,
         const struct clk_ops *div_ops = periph->div_ops;
         struct clk_hw *div_hw = &periph->divider.hw;
 
-        div_hw->clk = hw->clk;
+        __clk_hw_set_clk(div_hw, hw);
 
         return div_ops->recalc_rate(div_hw, parent_rate);
 }
@@ -63,7 +63,7 @@ static long clk_periph_round_rate(struct clk_hw *hw, unsigned long rate,
         const struct clk_ops *div_ops = periph->div_ops;
         struct clk_hw *div_hw = &periph->divider.hw;
 
-        div_hw->clk = hw->clk;
+        __clk_hw_set_clk(div_hw, hw);
 
         return div_ops->round_rate(div_hw, rate, prate);
 }
@@ -75,7 +75,7 @@ static int clk_periph_set_rate(struct clk_hw *hw, unsigned long rate,
         const struct clk_ops *div_ops = periph->div_ops;
         struct clk_hw *div_hw = &periph->divider.hw;
 
-        div_hw->clk = hw->clk;
+        __clk_hw_set_clk(div_hw, hw);
 
         return div_ops->set_rate(div_hw, rate, parent_rate);
 }
@@ -86,7 +86,7 @@ static int clk_periph_is_enabled(struct clk_hw *hw)
         const struct clk_ops *gate_ops = periph->gate_ops;
         struct clk_hw *gate_hw = &periph->gate.hw;
 
-        gate_hw->clk = hw->clk;
+        __clk_hw_set_clk(gate_hw, hw);
 
         return gate_ops->is_enabled(gate_hw);
 }
@@ -97,7 +97,7 @@ static int clk_periph_enable(struct clk_hw *hw)
         const struct clk_ops *gate_ops = periph->gate_ops;
         struct clk_hw *gate_hw = &periph->gate.hw;
 
-        gate_hw->clk = hw->clk;
+        __clk_hw_set_clk(gate_hw, hw);
 
         return gate_ops->enable(gate_hw);
 }
diff --git a/drivers/clk/tegra/clk-pll.c b/drivers/clk/tegra/clk-pll.c
index c7c6d8fb32fb..bfef9abdf232 100644
--- a/drivers/clk/tegra/clk-pll.c
+++ b/drivers/clk/tegra/clk-pll.c
@@ -816,7 +816,9 @@ const struct clk_ops tegra_clk_plle_ops = {
         .enable = clk_plle_enable,
 };
 
-#if defined(CONFIG_ARCH_TEGRA_114_SOC) || defined(CONFIG_ARCH_TEGRA_124_SOC)
+#if defined(CONFIG_ARCH_TEGRA_114_SOC) || \
+        defined(CONFIG_ARCH_TEGRA_124_SOC) || \
+        defined(CONFIG_ARCH_TEGRA_132_SOC)
 
 static int _pll_fixed_mdiv(struct tegra_clk_pll_params *pll_params,
                            unsigned long parent_rate)
@@ -1505,7 +1507,9 @@ struct clk *tegra_clk_register_plle(const char *name, const char *parent_name,
         return clk;
 }
 
-#if defined(CONFIG_ARCH_TEGRA_114_SOC) || defined(CONFIG_ARCH_TEGRA_124_SOC)
+#if defined(CONFIG_ARCH_TEGRA_114_SOC) || \
+        defined(CONFIG_ARCH_TEGRA_124_SOC) || \
+        defined(CONFIG_ARCH_TEGRA_132_SOC)
 static const struct clk_ops tegra_clk_pllxc_ops = {
         .is_enabled = clk_pll_is_enabled,
         .enable = clk_pll_iddq_enable,
@@ -1565,7 +1569,7 @@ struct clk *tegra_clk_register_pllxc(const char *name, const char *parent_name,
         parent = __clk_lookup(parent_name);
         if (!parent) {
                 WARN(1, "parent clk %s of %s must be registered first\n",
-                        name, parent_name);
+                        parent_name, name);
                 return ERR_PTR(-EINVAL);
         }
 
@@ -1665,7 +1669,7 @@ struct clk *tegra_clk_register_pllm(const char *name, const char *parent_name,
         parent = __clk_lookup(parent_name);
         if (!parent) {
                 WARN(1, "parent clk %s of %s must be registered first\n",
-                        name, parent_name);
+                        parent_name, name);
                 return ERR_PTR(-EINVAL);
         }
 
@@ -1706,7 +1710,7 @@ struct clk *tegra_clk_register_pllc(const char *name, const char *parent_name,
         parent = __clk_lookup(parent_name);
         if (!parent) {
                 WARN(1, "parent clk %s of %s must be registered first\n",
-                        name, parent_name);
+                        parent_name, name);
                 return ERR_PTR(-EINVAL);
         }
 
@@ -1802,7 +1806,7 @@ struct clk *tegra_clk_register_plle_tegra114(const char *name,
 }
 #endif
 
-#ifdef CONFIG_ARCH_TEGRA_124_SOC
+#if defined(CONFIG_ARCH_TEGRA_124_SOC) || defined(CONFIG_ARCH_TEGRA_132_SOC)
 static const struct clk_ops tegra_clk_pllss_ops = {
         .is_enabled = clk_pll_is_enabled,
         .enable = clk_pll_iddq_enable,
@@ -1830,7 +1834,7 @@ struct clk *tegra_clk_register_pllss(const char *name, const char *parent_name,
         parent = __clk_lookup(parent_name);
         if (!parent) {
                 WARN(1, "parent clk %s of %s must be registered first\n",
-                        name, parent_name);
+                        parent_name, name);
                 return ERR_PTR(-EINVAL);
         }
 
diff --git a/drivers/clk/tegra/clk-tegra-periph.c b/drivers/clk/tegra/clk-tegra-periph.c
index 37f32c49674e..cef0727b9eec 100644
--- a/drivers/clk/tegra/clk-tegra-periph.c
+++ b/drivers/clk/tegra/clk-tegra-periph.c
@@ -434,10 +434,10 @@ static struct tegra_periph_init_data periph_clks[] = {
         MUX("hda", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_HDA, 125, TEGRA_PERIPH_ON_APB, tegra_clk_hda),
         MUX("hda2codec_2x", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_HDA2CODEC_2X, 111, TEGRA_PERIPH_ON_APB, tegra_clk_hda2codec_2x),
         MUX("vfir", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_VFIR, 7, TEGRA_PERIPH_ON_APB, tegra_clk_vfir),
-        MUX("sdmmc1", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_SDMMC1, 14, 0, tegra_clk_sdmmc1),
-        MUX("sdmmc2", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_SDMMC2, 9, 0, tegra_clk_sdmmc2),
-        MUX("sdmmc3", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_SDMMC3, 69, 0, tegra_clk_sdmmc3),
-        MUX("sdmmc4", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_SDMMC4, 15, 0, tegra_clk_sdmmc4),
+        MUX("sdmmc1", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_SDMMC1, 14, TEGRA_PERIPH_ON_APB, tegra_clk_sdmmc1),
+        MUX("sdmmc2", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_SDMMC2, 9, TEGRA_PERIPH_ON_APB, tegra_clk_sdmmc2),
+        MUX("sdmmc3", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_SDMMC3, 69, TEGRA_PERIPH_ON_APB, tegra_clk_sdmmc3),
+        MUX("sdmmc4", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_SDMMC4, 15, TEGRA_PERIPH_ON_APB, tegra_clk_sdmmc4),
         MUX("la", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_LA, 76, TEGRA_PERIPH_ON_APB, tegra_clk_la),
         MUX("trace", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_TRACE, 77, TEGRA_PERIPH_ON_APB, tegra_clk_trace),
         MUX("owr", mux_pllp_pllc_pllm_clkm, CLK_SOURCE_OWR, 71, TEGRA_PERIPH_ON_APB, tegra_clk_owr),
@@ -470,10 +470,10 @@ static struct tegra_periph_init_data periph_clks[] = {
         MUX("adx1", mux_plla_pllc_pllp_clkm, CLK_SOURCE_ADX1, 180, TEGRA_PERIPH_ON_APB, tegra_clk_adx1),
         MUX("amx1", mux_plla_pllc_pllp_clkm, CLK_SOURCE_AMX1, 185, TEGRA_PERIPH_ON_APB, tegra_clk_amx1),
         MUX("vi_sensor2", mux_pllm_pllc2_c_c3_pllp_plla, CLK_SOURCE_VI_SENSOR2, 165, TEGRA_PERIPH_NO_RESET, tegra_clk_vi_sensor2),
-        MUX8("sdmmc1", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SDMMC1, 14, 0, tegra_clk_sdmmc1_8),
-        MUX8("sdmmc2", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SDMMC2, 9, 0, tegra_clk_sdmmc2_8),
-        MUX8("sdmmc3", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SDMMC3, 69, 0, tegra_clk_sdmmc3_8),
-        MUX8("sdmmc4", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SDMMC4, 15, 0, tegra_clk_sdmmc4_8),
+        MUX8("sdmmc1", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SDMMC1, 14, TEGRA_PERIPH_ON_APB, tegra_clk_sdmmc1_8),
+        MUX8("sdmmc2", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SDMMC2, 9, TEGRA_PERIPH_ON_APB, tegra_clk_sdmmc2_8),
+        MUX8("sdmmc3", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SDMMC3, 69, TEGRA_PERIPH_ON_APB, tegra_clk_sdmmc3_8),
+        MUX8("sdmmc4", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SDMMC4, 15, TEGRA_PERIPH_ON_APB, tegra_clk_sdmmc4_8),
         MUX8("sbc1", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SBC1, 41, TEGRA_PERIPH_ON_APB, tegra_clk_sbc1_8),
         MUX8("sbc2", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SBC2, 44, TEGRA_PERIPH_ON_APB, tegra_clk_sbc2_8),
         MUX8("sbc3", mux_pllp_pllc2_c_c3_pllm_clkm, CLK_SOURCE_SBC3, 46, TEGRA_PERIPH_ON_APB, tegra_clk_sbc3_8),
@@ -537,8 +537,6 @@ static struct tegra_periph_init_data gate_clks[] = {
         GATE("xusb_host", "xusb_host_src", 89, 0, tegra_clk_xusb_host, 0),
         GATE("xusb_ss", "xusb_ss_src", 156, 0, tegra_clk_xusb_ss, 0),
         GATE("xusb_dev", "xusb_dev_src", 95, 0, tegra_clk_xusb_dev, 0),
-        GATE("dsia", "dsia_mux", 48, 0, tegra_clk_dsia, 0),
-        GATE("dsib", "dsib_mux", 82, 0, tegra_clk_dsib, 0),
         GATE("emc", "emc_mux", 57, 0, tegra_clk_emc, CLK_IGNORE_UNUSED),
         GATE("sata_cold", "clk_m", 129, TEGRA_PERIPH_ON_APB, tegra_clk_sata_cold, 0),
         GATE("ispb", "clk_m", 3, 0, tegra_clk_ispb, 0),
diff --git a/drivers/clk/tegra/clk-tegra114.c b/drivers/clk/tegra/clk-tegra114.c
index 0b03d2cf7264..d0766423a5d6 100644
--- a/drivers/clk/tegra/clk-tegra114.c
+++ b/drivers/clk/tegra/clk-tegra114.c
@@ -715,7 +715,6 @@ static struct tegra_clk tegra114_clks[tegra_clk_max] __initdata = {
         [tegra_clk_sbc2_8] = { .dt_id = TEGRA114_CLK_SBC2, .present = true },
         [tegra_clk_sbc3_8] = { .dt_id = TEGRA114_CLK_SBC3, .present = true },
         [tegra_clk_i2c5] = { .dt_id = TEGRA114_CLK_I2C5, .present = true },
-        [tegra_clk_dsia] = { .dt_id = TEGRA114_CLK_DSIA, .present = true },
         [tegra_clk_mipi] = { .dt_id = TEGRA114_CLK_MIPI, .present = true },
         [tegra_clk_hdmi] = { .dt_id = TEGRA114_CLK_HDMI, .present = true },
         [tegra_clk_csi] = { .dt_id = TEGRA114_CLK_CSI, .present = true },
@@ -739,7 +738,6 @@ static struct tegra_clk tegra114_clks[tegra_clk_max] __initdata = {
         [tegra_clk_dtv] = { .dt_id = TEGRA114_CLK_DTV, .present = true },
         [tegra_clk_ndspeed] = { .dt_id = TEGRA114_CLK_NDSPEED, .present = true },
         [tegra_clk_i2cslow] = { .dt_id = TEGRA114_CLK_I2CSLOW, .present = true },
-        [tegra_clk_dsib] = { .dt_id = TEGRA114_CLK_DSIB, .present = true },
         [tegra_clk_tsec] = { .dt_id = TEGRA114_CLK_TSEC, .present = true },
         [tegra_clk_xusb_host] = { .dt_id = TEGRA114_CLK_XUSB_HOST, .present = true },
         [tegra_clk_msenc] = { .dt_id = TEGRA114_CLK_MSENC, .present = true },
@@ -1224,6 +1222,14 @@ static __init void tegra114_periph_clk_init(void __iomem *clk_base,
                                clk_base + PLLD2_BASE, 25, 1, 0, &pll_d2_lock);
         clks[TEGRA114_CLK_DSIB_MUX] = clk;
 
+        clk = tegra_clk_register_periph_gate("dsia", "dsia_mux", 0, clk_base,
+                                             0, 48, periph_clk_enb_refcnt);
+        clks[TEGRA114_CLK_DSIA] = clk;
+
+        clk = tegra_clk_register_periph_gate("dsib", "dsib_mux", 0, clk_base,
+                                             0, 82, periph_clk_enb_refcnt);
+        clks[TEGRA114_CLK_DSIB] = clk;
+
         /* emc mux */
         clk = clk_register_mux(NULL, "emc_mux", mux_pllmcp_clkm,
                                ARRAY_SIZE(mux_pllmcp_clkm),
diff --git a/drivers/clk/tegra/clk-tegra124.c b/drivers/clk/tegra/clk-tegra124.c
index f5f9baca7bb6..9a893f2fe8e9 100644
--- a/drivers/clk/tegra/clk-tegra124.c
+++ b/drivers/clk/tegra/clk-tegra124.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2013, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2012-2014 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,
@@ -28,6 +28,14 @@
 #include "clk.h"
 #include "clk-id.h"
 
+/*
+ * TEGRA124_CAR_BANK_COUNT: the number of peripheral clock register
+ * banks present in the Tegra124/132 CAR IP block.  The banks are
+ * identified by single letters, e.g.: L, H, U, V, W, X.  See
+ * periph_regs[] in drivers/clk/tegra/clk.c
+ */
+#define TEGRA124_CAR_BANK_COUNT                 6
+
 #define CLK_SOURCE_CSITE 0x1d4
 #define CLK_SOURCE_EMC 0x19c
 
@@ -128,7 +136,6 @@ static unsigned long osc_freq;
 static unsigned long pll_ref_freq;
 
 static DEFINE_SPINLOCK(pll_d_lock);
-static DEFINE_SPINLOCK(pll_d2_lock);
 static DEFINE_SPINLOCK(pll_e_lock);
 static DEFINE_SPINLOCK(pll_re_lock);
 static DEFINE_SPINLOCK(pll_u_lock);
@@ -145,11 +152,6 @@ static unsigned long tegra124_input_freq[] = {
         [12] = 260000000,
 };
 
-static const char *mux_plld_out0_plld2_out0[] = {
-        "pll_d_out0", "pll_d2_out0",
-};
-#define mux_plld_out0_plld2_out0_idx NULL
-
 static const char *mux_pllmcp_clkm[] = {
         "pll_m", "pll_c", "pll_p", "clk_m", "pll_m_ud", "pll_c2", "pll_c3",
 };
@@ -783,7 +785,6 @@ static struct tegra_clk tegra124_clks[tegra_clk_max] __initdata = {
         [tegra_clk_sbc2] = { .dt_id = TEGRA124_CLK_SBC2, .present = true },
         [tegra_clk_sbc3] = { .dt_id = TEGRA124_CLK_SBC3, .present = true },
         [tegra_clk_i2c5] = { .dt_id = TEGRA124_CLK_I2C5, .present = true },
-        [tegra_clk_dsia] = { .dt_id = TEGRA124_CLK_DSIA, .present = true },
         [tegra_clk_mipi] = { .dt_id = TEGRA124_CLK_MIPI, .present = true },
         [tegra_clk_hdmi] = { .dt_id = TEGRA124_CLK_HDMI, .present = true },
         [tegra_clk_csi] = { .dt_id = TEGRA124_CLK_CSI, .present = true },
@@ -809,7 +810,6 @@ static struct tegra_clk tegra124_clks[tegra_clk_max] __initdata = {
         [tegra_clk_soc_therm] = { .dt_id = TEGRA124_CLK_SOC_THERM, .present = true },
         [tegra_clk_dtv] = { .dt_id = TEGRA124_CLK_DTV, .present = true },
         [tegra_clk_i2cslow] = { .dt_id = TEGRA124_CLK_I2CSLOW, .present = true },
-        [tegra_clk_dsib] = { .dt_id = TEGRA124_CLK_DSIB, .present = true },
         [tegra_clk_tsec] = { .dt_id = TEGRA124_CLK_TSEC, .present = true },
         [tegra_clk_xusb_host] = { .dt_id = TEGRA124_CLK_XUSB_HOST, .present = true },
         [tegra_clk_msenc] = { .dt_id = TEGRA124_CLK_MSENC, .present = true },
@@ -949,8 +949,6 @@ static struct tegra_clk tegra124_clks[tegra_clk_max] __initdata = {
         [tegra_clk_clk_out_1_mux] = { .dt_id = TEGRA124_CLK_CLK_OUT_1_MUX, .present = true },
         [tegra_clk_clk_out_2_mux] = { .dt_id = TEGRA124_CLK_CLK_OUT_2_MUX, .present = true },
         [tegra_clk_clk_out_3_mux] = { .dt_id = TEGRA124_CLK_CLK_OUT_3_MUX, .present = true },
-        [tegra_clk_dsia_mux] = { .dt_id = TEGRA124_CLK_DSIA_MUX, .present = true },
-        [tegra_clk_dsib_mux] = { .dt_id = TEGRA124_CLK_DSIB_MUX, .present = true },
 };
 
 static struct tegra_devclk devclks[] __initdata = {
@@ -1112,17 +1110,17 @@ static __init void tegra124_periph_clk_init(void __iomem *clk_base,
                                         1, 2);
         clks[TEGRA124_CLK_XUSB_SS_DIV2] = clk;
 
-        /* dsia mux */
-        clk = clk_register_mux(NULL, "dsia_mux", mux_plld_out0_plld2_out0,
-                               ARRAY_SIZE(mux_plld_out0_plld2_out0), 0,
-                               clk_base + PLLD_BASE, 25, 1, 0, &pll_d_lock);
-        clks[TEGRA124_CLK_DSIA_MUX] = clk;
+        clk = clk_register_gate(NULL, "plld_dsi", "plld_out0", 0,
+                                clk_base + PLLD_MISC, 30, 0, &pll_d_lock);
+        clks[TEGRA124_CLK_PLLD_DSI] = clk;
+
+        clk = tegra_clk_register_periph_gate("dsia", "plld_dsi", 0, clk_base,
+                                             0, 48, periph_clk_enb_refcnt);
+        clks[TEGRA124_CLK_DSIA] = clk;
 
-        /* dsib mux */
-        clk = clk_register_mux(NULL, "dsib_mux", mux_plld_out0_plld2_out0,
-                               ARRAY_SIZE(mux_plld_out0_plld2_out0), 0,
-                               clk_base + PLLD2_BASE, 25, 1, 0, &pll_d2_lock);
-        clks[TEGRA124_CLK_DSIB_MUX] = clk;
+        clk = tegra_clk_register_periph_gate("dsib", "plld_dsi", 0, clk_base,
+                                             0, 82, periph_clk_enb_refcnt);
+        clks[TEGRA124_CLK_DSIB] = clk;
 
         /* emc mux */
         clk = clk_register_mux(NULL, "emc_mux", mux_pllmcp_clkm,
@@ -1351,7 +1349,7 @@ static const struct of_device_id pmc_match[] __initconst = {
         {},
 };
 
-static struct tegra_clk_init_table init_table[] __initdata = {
+static struct tegra_clk_init_table common_init_table[] __initdata = {
         {TEGRA124_CLK_UARTA, TEGRA124_CLK_PLL_P, 408000000, 0},
         {TEGRA124_CLK_UARTB, TEGRA124_CLK_PLL_P, 408000000, 0},
         {TEGRA124_CLK_UARTC, TEGRA124_CLK_PLL_P, 408000000, 0},
@@ -1368,6 +1366,8 @@ static struct tegra_clk_init_table init_table[] __initdata = {
         {TEGRA124_CLK_I2S4, TEGRA124_CLK_PLL_A_OUT0, 11289600, 0},
         {TEGRA124_CLK_VDE, TEGRA124_CLK_PLL_P, 0, 0},
         {TEGRA124_CLK_HOST1X, TEGRA124_CLK_PLL_P, 136000000, 1},
+        {TEGRA124_CLK_DSIALP, TEGRA124_CLK_PLL_P, 68000000, 0},
+        {TEGRA124_CLK_DSIBLP, TEGRA124_CLK_PLL_P, 68000000, 0},
         {TEGRA124_CLK_SCLK, TEGRA124_CLK_PLL_P_OUT2, 102000000, 1},
         {TEGRA124_CLK_DFLL_SOC, TEGRA124_CLK_PLL_P, 51000000, 1},
         {TEGRA124_CLK_DFLL_REF, TEGRA124_CLK_PLL_P, 51000000, 1},
@@ -1385,27 +1385,73 @@ static struct tegra_clk_init_table init_table[] __initdata = {
         {TEGRA124_CLK_SATA, TEGRA124_CLK_PLL_P, 104000000, 0},
         {TEGRA124_CLK_SATA_OOB, TEGRA124_CLK_PLL_P, 204000000, 0},
         {TEGRA124_CLK_EMC, TEGRA124_CLK_CLK_MAX, 0, 1},
-        {TEGRA124_CLK_CCLK_G, TEGRA124_CLK_CLK_MAX, 0, 1},
         {TEGRA124_CLK_MSELECT, TEGRA124_CLK_CLK_MAX, 0, 1},
         {TEGRA124_CLK_CSITE, TEGRA124_CLK_CLK_MAX, 0, 1},
         {TEGRA124_CLK_TSENSOR, TEGRA124_CLK_CLK_M, 400000, 0},
+        /* This MUST be the last entry. */
+        {TEGRA124_CLK_CLK_MAX, TEGRA124_CLK_CLK_MAX, 0, 0},
+};
+
+static struct tegra_clk_init_table tegra124_init_table[] __initdata = {
         {TEGRA124_CLK_SOC_THERM, TEGRA124_CLK_PLL_P, 51000000, 0},
+        {TEGRA124_CLK_CCLK_G, TEGRA124_CLK_CLK_MAX, 0, 1},
+        /* This MUST be the last entry. */
+        {TEGRA124_CLK_CLK_MAX, TEGRA124_CLK_CLK_MAX, 0, 0},
+};
+
+/* Tegra132 requires the SOC_THERM clock to remain active */
+static struct tegra_clk_init_table tegra132_init_table[] __initdata = {
+        {TEGRA124_CLK_SOC_THERM, TEGRA124_CLK_PLL_P, 51000000, 1},
         /* This MUST be the last entry. */
         {TEGRA124_CLK_CLK_MAX, TEGRA124_CLK_CLK_MAX, 0, 0},
 };
 
+/**
+ * tegra124_clock_apply_init_table - initialize clocks on Tegra124 SoCs
+ *
+ * Program an initial clock rate and enable or disable clocks needed
+ * by the rest of the kernel, for Tegra124 SoCs.  It is intended to be
+ * called by assigning a pointer to it to tegra_clk_apply_init_table -
+ * this will be called as an arch_initcall.  No return value.
+ */
 static void __init tegra124_clock_apply_init_table(void)
 {
-        tegra_init_from_table(init_table, clks, TEGRA124_CLK_CLK_MAX);
+        tegra_init_from_table(common_init_table, clks, TEGRA124_CLK_CLK_MAX);
+        tegra_init_from_table(tegra124_init_table, clks, TEGRA124_CLK_CLK_MAX);
 }
 
-static void __init tegra124_clock_init(struct device_node *np)
+/**
+ * tegra132_clock_apply_init_table - initialize clocks on Tegra132 SoCs
+ *
+ * Program an initial clock rate and enable or disable clocks needed
+ * by the rest of the kernel, for Tegra132 SoCs.  It is intended to be
+ * called by assigning a pointer to it to tegra_clk_apply_init_table -
+ * this will be called as an arch_initcall.  No return value.
+ */
+static void __init tegra132_clock_apply_init_table(void)
+{
+        tegra_init_from_table(common_init_table, clks, TEGRA124_CLK_CLK_MAX);
+        tegra_init_from_table(tegra132_init_table, clks, TEGRA124_CLK_CLK_MAX);
+}
+
+/**
+ * tegra124_132_clock_init_pre - clock initialization preamble for T124/T132
+ * @np: struct device_node * of the DT node for the SoC CAR IP block
+ *
+ * Register most of the clocks controlled by the CAR IP block, along
+ * with a few clocks controlled by the PMC IP block.  Everything in
+ * this function should be common to Tegra124 and Tegra132.  XXX The
+ * PMC clock initialization should probably be moved to PMC-specific
+ * driver code.  No return value.
+ */
+static void __init tegra124_132_clock_init_pre(struct device_node *np)
 {
         struct device_node *node;
+        u32 plld_base;
 
         clk_base = of_iomap(np, 0);
         if (!clk_base) {
-                pr_err("ioremap tegra124 CAR failed\n");
+                pr_err("ioremap tegra124/tegra132 CAR failed\n");
                 return;
         }
 
@@ -1423,7 +1469,8 @@ static void __init tegra124_clock_init(struct device_node *np)
                 return;
         }
 
-        clks = tegra_clk_init(clk_base, TEGRA124_CLK_CLK_MAX, 6);
+        clks = tegra_clk_init(clk_base, TEGRA124_CLK_CLK_MAX,
+                              TEGRA124_CAR_BANK_COUNT);
         if (!clks)
                 return;
 
@@ -1437,13 +1484,76 @@ static void __init tegra124_clock_init(struct device_node *np)
         tegra_audio_clk_init(clk_base, pmc_base, tegra124_clks, &pll_a_params);
         tegra_pmc_clk_init(pmc_base, tegra124_clks);
 
+        /* For Tegra124 & Tegra132, PLLD is the only source for DSIA & DSIB */
+        plld_base = clk_readl(clk_base + PLLD_BASE);
+        plld_base &= ~BIT(25);
+        clk_writel(plld_base, clk_base + PLLD_BASE);
+}
+
+/**
+ * tegra124_132_clock_init_post - clock initialization postamble for T124/T132
+ * @np: struct device_node * of the DT node for the SoC CAR IP block
+ *
+ * Register most of the along with a few clocks controlled by the PMC
+ * IP block.  Everything in this function should be common to Tegra124
+ * and Tegra132.  This function must be called after
+ * tegra124_132_clock_init_pre(), otherwise clk_base and pmc_base will
+ * not be set.  No return value.
+ */
+static void __init tegra124_132_clock_init_post(struct device_node *np)
+{
         tegra_super_clk_gen4_init(clk_base, pmc_base, tegra124_clks,
-                                        &pll_x_params);
+                                  &pll_x_params);
         tegra_add_of_provider(np);
         tegra_register_devclks(devclks, ARRAY_SIZE(devclks));
 
+        tegra_cpu_car_ops = &tegra124_cpu_car_ops;
+}
+
+/**
+ * tegra124_clock_init - Tegra124-specific clock initialization
+ * @np: struct device_node * of the DT node for the SoC CAR IP block
+ *
+ * Register most SoC clocks for the Tegra124 system-on-chip.  Most of
+ * this code is shared between the Tegra124 and Tegra132 SoCs,
+ * although some of the initial clock settings and CPU clocks differ.
+ * Intended to be called by the OF init code when a DT node with the
+ * "nvidia,tegra124-car" string is encountered, and declared with
+ * CLK_OF_DECLARE.  No return value.
+ */
+static void __init tegra124_clock_init(struct device_node *np)
+{
+        tegra124_132_clock_init_pre(np);
         tegra_clk_apply_init_table = tegra124_clock_apply_init_table;
+        tegra124_132_clock_init_post(np);
+}
 
-        tegra_cpu_car_ops = &tegra124_cpu_car_ops;
+/**
+ * tegra132_clock_init - Tegra132-specific clock initialization
+ * @np: struct device_node * of the DT node for the SoC CAR IP block
+ *
+ * Register most SoC clocks for the Tegra132 system-on-chip.  Most of
+ * this code is shared between the Tegra124 and Tegra132 SoCs,
+ * although some of the initial clock settings and CPU clocks differ.
+ * Intended to be called by the OF init code when a DT node with the
+ * "nvidia,tegra132-car" string is encountered, and declared with
+ * CLK_OF_DECLARE.  No return value.
+ */
+static void __init tegra132_clock_init(struct device_node *np)
+{
+        tegra124_132_clock_init_pre(np);
+
+        /*
+         * On Tegra132, these clocks are controlled by the
+         * CLUSTER_clocks IP block, located in the CPU complex
+         */
+        tegra124_clks[tegra_clk_cclk_g].present = false;
+        tegra124_clks[tegra_clk_cclk_lp].present = false;
+        tegra124_clks[tegra_clk_pll_x].present = false;
+        tegra124_clks[tegra_clk_pll_x_out0].present = false;
+
+        tegra_clk_apply_init_table = tegra132_clock_apply_init_table;
+        tegra124_132_clock_init_post(np);
 }
 CLK_OF_DECLARE(tegra124, "nvidia,tegra124-car", tegra124_clock_init);
+CLK_OF_DECLARE(tegra132, "nvidia,tegra132-car", tegra132_clock_init);
diff --git a/drivers/clk/tegra/clk.c b/drivers/clk/tegra/clk.c
index 97dc8595c3cd..9ddb7547cb43 100644
--- a/drivers/clk/tegra/clk.c
+++ b/drivers/clk/tegra/clk.c
@@ -302,10 +302,13 @@ struct clk ** __init tegra_lookup_dt_id(int clk_id,
 
 tegra_clk_apply_init_table_func tegra_clk_apply_init_table;
 
-void __init tegra_clocks_apply_init_table(void)
+static int __init tegra_clocks_apply_init_table(void)
 {
         if (!tegra_clk_apply_init_table)
-                return;
+                return 0;
 
         tegra_clk_apply_init_table();
+
+        return 0;
 }
+arch_initcall(tegra_clocks_apply_init_table);
diff --git a/drivers/clk/ti/Makefile b/drivers/clk/ti/Makefile
index ed4d0aaf8916..105ffd0f5e79 100644
--- a/drivers/clk/ti/Makefile
+++ b/drivers/clk/ti/Makefile
@@ -1,13 +1,17 @@
-ifneq ($(CONFIG_OF),)
 obj-y                                   += clk.o autoidle.o clockdomain.o
 clk-common                              = dpll.o composite.o divider.o gate.o \
                                           fixed-factor.o mux.o apll.o
 obj-$(CONFIG_SOC_AM33XX)                += $(clk-common) clk-33xx.o
+obj-$(CONFIG_SOC_TI81XX)                += $(clk-common) fapll.o clk-816x.o
 obj-$(CONFIG_ARCH_OMAP2)                += $(clk-common) interface.o clk-2xxx.o
-obj-$(CONFIG_ARCH_OMAP3)                += $(clk-common) interface.o clk-3xxx.o
+obj-$(CONFIG_ARCH_OMAP3)                += $(clk-common) interface.o \
+                                           clk-3xxx.o
 obj-$(CONFIG_ARCH_OMAP4)                += $(clk-common) clk-44xx.o
 obj-$(CONFIG_SOC_OMAP5)                 += $(clk-common) clk-54xx.o
 obj-$(CONFIG_SOC_DRA7XX)                += $(clk-common) clk-7xx.o \
                                            clk-dra7-atl.o
 obj-$(CONFIG_SOC_AM43XX)                += $(clk-common) clk-43xx.o
+
+ifdef CONFIG_ATAGS
+obj-$(CONFIG_ARCH_OMAP3)                += clk-3xxx-legacy.o
 endif
diff --git a/drivers/clk/ti/clk-3xxx-legacy.c b/drivers/clk/ti/clk-3xxx-legacy.c
new file mode 100644
index 000000000000..e0732a4c8f26
--- /dev/null
+++ b/drivers/clk/ti/clk-3xxx-legacy.c
@@ -0,0 +1,4653 @@
+/*
+ * OMAP3 Legacy clock data
+ *
+ * Copyright (C) 2014 Texas Instruments, Inc
+ *     Tero Kristo (t-kristo@ti.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 version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/clk-provider.h>
+#include <linux/clk/ti.h>
+
+#include "clock.h"
+
+static struct ti_clk_fixed virt_12m_ck_data = {
+        .frequency = 12000000,
+};
+
+static struct ti_clk virt_12m_ck = {
+        .name = "virt_12m_ck",
+        .type = TI_CLK_FIXED,
+        .data = &virt_12m_ck_data,
+};
+
+static struct ti_clk_fixed virt_13m_ck_data = {
+        .frequency = 13000000,
+};
+
+static struct ti_clk virt_13m_ck = {
+        .name = "virt_13m_ck",
+        .type = TI_CLK_FIXED,
+        .data = &virt_13m_ck_data,
+};
+
+static struct ti_clk_fixed virt_19200000_ck_data = {
+        .frequency = 19200000,
+};
+
+static struct ti_clk virt_19200000_ck = {
+        .name = "virt_19200000_ck",
+        .type = TI_CLK_FIXED,
+        .data = &virt_19200000_ck_data,
+};
+
+static struct ti_clk_fixed virt_26000000_ck_data = {
+        .frequency = 26000000,
+};
+
+static struct ti_clk virt_26000000_ck = {
+        .name = "virt_26000000_ck",
+        .type = TI_CLK_FIXED,
+        .data = &virt_26000000_ck_data,
+};
+
+static struct ti_clk_fixed virt_38_4m_ck_data = {
+        .frequency = 38400000,
+};
+
+static struct ti_clk virt_38_4m_ck = {
+        .name = "virt_38_4m_ck",
+        .type = TI_CLK_FIXED,
+        .data = &virt_38_4m_ck_data,
+};
+
+static struct ti_clk_fixed virt_16_8m_ck_data = {
+        .frequency = 16800000,
+};
+
+static struct ti_clk virt_16_8m_ck = {
+        .name = "virt_16_8m_ck",
+        .type = TI_CLK_FIXED,
+        .data = &virt_16_8m_ck_data,
+};
+
+static const char *osc_sys_ck_parents[] = {
+        "virt_12m_ck",
+        "virt_13m_ck",
+        "virt_19200000_ck",
+        "virt_26000000_ck",
+        "virt_38_4m_ck",
+        "virt_16_8m_ck",
+};
+
+static struct ti_clk_mux osc_sys_ck_data = {
+        .num_parents = ARRAY_SIZE(osc_sys_ck_parents),
+        .reg = 0xd40,
+        .module = TI_CLKM_PRM,
+        .parents = osc_sys_ck_parents,
+};
+
+static struct ti_clk osc_sys_ck = {
+        .name = "osc_sys_ck",
+        .type = TI_CLK_MUX,
+        .data = &osc_sys_ck_data,
+};
+
+static struct ti_clk_divider sys_ck_data = {
+        .parent = "osc_sys_ck",
+        .bit_shift = 6,
+        .max_div = 3,
+        .reg = 0x1270,
+        .module = TI_CLKM_PRM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk sys_ck = {
+        .name = "sys_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &sys_ck_data,
+};
+
+static const char *dpll3_ck_parents[] = {
+        "sys_ck",
+        "sys_ck",
+};
+
+static struct ti_clk_dpll dpll3_ck_data = {
+        .num_parents = ARRAY_SIZE(dpll3_ck_parents),
+        .control_reg = 0xd00,
+        .idlest_reg = 0xd20,
+        .mult_div1_reg = 0xd40,
+        .autoidle_reg = 0xd30,
+        .module = TI_CLKM_CM,
+        .parents = dpll3_ck_parents,
+        .flags = CLKF_CORE,
+        .freqsel_mask = 0xf0,
+        .div1_mask = 0x7f00,
+        .idlest_mask = 0x1,
+        .auto_recal_bit = 0x3,
+        .max_divider = 0x80,
+        .min_divider = 0x1,
+        .recal_en_bit = 0x5,
+        .max_multiplier = 0x7ff,
+        .enable_mask = 0x7,
+        .mult_mask = 0x7ff0000,
+        .recal_st_bit = 0x5,
+        .autoidle_mask = 0x7,
+};
+
+static struct ti_clk dpll3_ck = {
+        .name = "dpll3_ck",
+        .clkdm_name = "dpll3_clkdm",
+        .type = TI_CLK_DPLL,
+        .data = &dpll3_ck_data,
+};
+
+static struct ti_clk_divider dpll3_m2_ck_data = {
+        .parent = "dpll3_ck",
+        .bit_shift = 27,
+        .max_div = 31,
+        .reg = 0xd40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll3_m2_ck = {
+        .name = "dpll3_m2_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll3_m2_ck_data,
+};
+
+static struct ti_clk_fixed_factor core_ck_data = {
+        .parent = "dpll3_m2_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk core_ck = {
+        .name = "core_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_ck_data,
+};
+
+static struct ti_clk_divider l3_ick_data = {
+        .parent = "core_ck",
+        .max_div = 3,
+        .reg = 0xa40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk l3_ick = {
+        .name = "l3_ick",
+        .type = TI_CLK_DIVIDER,
+        .data = &l3_ick_data,
+};
+
+static struct ti_clk_fixed_factor security_l3_ick_data = {
+        .parent = "l3_ick",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk security_l3_ick = {
+        .name = "security_l3_ick",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &security_l3_ick_data,
+};
+
+static struct ti_clk_fixed_factor wkup_l4_ick_data = {
+        .parent = "sys_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk wkup_l4_ick = {
+        .name = "wkup_l4_ick",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &wkup_l4_ick_data,
+};
+
+static struct ti_clk_gate usim_ick_data = {
+        .parent = "wkup_l4_ick",
+        .bit_shift = 9,
+        .reg = 0xc10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk usim_ick = {
+        .name = "usim_ick",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &usim_ick_data,
+};
+
+static struct ti_clk_gate dss2_alwon_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 1,
+        .reg = 0xe00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk dss2_alwon_fck = {
+        .name = "dss2_alwon_fck",
+        .clkdm_name = "dss_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &dss2_alwon_fck_data,
+};
+
+static struct ti_clk_divider l4_ick_data = {
+        .parent = "l3_ick",
+        .bit_shift = 2,
+        .max_div = 3,
+        .reg = 0xa40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk l4_ick = {
+        .name = "l4_ick",
+        .type = TI_CLK_DIVIDER,
+        .data = &l4_ick_data,
+};
+
+static struct ti_clk_fixed_factor core_l4_ick_data = {
+        .parent = "l4_ick",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk core_l4_ick = {
+        .name = "core_l4_ick",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_l4_ick_data,
+};
+
+static struct ti_clk_gate mmchs2_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 25,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mmchs2_ick = {
+        .name = "mmchs2_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mmchs2_ick_data,
+};
+
+static const char *dpll4_ck_parents[] = {
+        "sys_ck",
+        "sys_ck",
+};
+
+static struct ti_clk_dpll dpll4_ck_data = {
+        .num_parents = ARRAY_SIZE(dpll4_ck_parents),
+        .control_reg = 0xd00,
+        .idlest_reg = 0xd20,
+        .mult_div1_reg = 0xd44,
+        .autoidle_reg = 0xd30,
+        .module = TI_CLKM_CM,
+        .parents = dpll4_ck_parents,
+        .flags = CLKF_PER,
+        .freqsel_mask = 0xf00000,
+        .modes = 0x82,
+        .div1_mask = 0x7f,
+        .idlest_mask = 0x2,
+        .auto_recal_bit = 0x13,
+        .max_divider = 0x80,
+        .min_divider = 0x1,
+        .recal_en_bit = 0x6,
+        .max_multiplier = 0x7ff,
+        .enable_mask = 0x70000,
+        .mult_mask = 0x7ff00,
+        .recal_st_bit = 0x6,
+        .autoidle_mask = 0x38,
+};
+
+static struct ti_clk dpll4_ck = {
+        .name = "dpll4_ck",
+        .clkdm_name = "dpll4_clkdm",
+        .type = TI_CLK_DPLL,
+        .data = &dpll4_ck_data,
+};
+
+static struct ti_clk_divider dpll4_m2_ck_data = {
+        .parent = "dpll4_ck",
+        .max_div = 63,
+        .reg = 0xd48,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll4_m2_ck = {
+        .name = "dpll4_m2_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll4_m2_ck_data,
+};
+
+static struct ti_clk_fixed_factor dpll4_m2x2_mul_ck_data = {
+        .parent = "dpll4_m2_ck",
+        .div = 1,
+        .mult = 2,
+};
+
+static struct ti_clk dpll4_m2x2_mul_ck = {
+        .name = "dpll4_m2x2_mul_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll4_m2x2_mul_ck_data,
+};
+
+static struct ti_clk_gate dpll4_m2x2_ck_data = {
+        .parent = "dpll4_m2x2_mul_ck",
+        .bit_shift = 0x1b,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m2x2_ck = {
+        .name = "dpll4_m2x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m2x2_ck_data,
+};
+
+static struct ti_clk_fixed_factor omap_96m_alwon_fck_data = {
+        .parent = "dpll4_m2x2_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk omap_96m_alwon_fck = {
+        .name = "omap_96m_alwon_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &omap_96m_alwon_fck_data,
+};
+
+static struct ti_clk_fixed_factor cm_96m_fck_data = {
+        .parent = "omap_96m_alwon_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk cm_96m_fck = {
+        .name = "cm_96m_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &cm_96m_fck_data,
+};
+
+static const char *omap_96m_fck_parents[] = {
+        "cm_96m_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux omap_96m_fck_data = {
+        .bit_shift = 6,
+        .num_parents = ARRAY_SIZE(omap_96m_fck_parents),
+        .reg = 0xd40,
+        .module = TI_CLKM_CM,
+        .parents = omap_96m_fck_parents,
+};
+
+static struct ti_clk omap_96m_fck = {
+        .name = "omap_96m_fck",
+        .type = TI_CLK_MUX,
+        .data = &omap_96m_fck_data,
+};
+
+static struct ti_clk_fixed_factor core_96m_fck_data = {
+        .parent = "omap_96m_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk core_96m_fck = {
+        .name = "core_96m_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_96m_fck_data,
+};
+
+static struct ti_clk_gate mspro_fck_data = {
+        .parent = "core_96m_fck",
+        .bit_shift = 23,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk mspro_fck = {
+        .name = "mspro_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mspro_fck_data,
+};
+
+static struct ti_clk_gate dss_ick_3430es2_data = {
+        .parent = "l4_ick",
+        .bit_shift = 0,
+        .reg = 0xe10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_DSS | CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk dss_ick_3430es2 = {
+        .name = "dss_ick",
+        .clkdm_name = "dss_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &dss_ick_3430es2_data,
+};
+
+static struct ti_clk_gate uart4_ick_am35xx_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 23,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk uart4_ick_am35xx = {
+        .name = "uart4_ick_am35xx",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart4_ick_am35xx_data,
+};
+
+static struct ti_clk_fixed_factor security_l4_ick2_data = {
+        .parent = "l4_ick",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk security_l4_ick2 = {
+        .name = "security_l4_ick2",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &security_l4_ick2_data,
+};
+
+static struct ti_clk_gate aes1_ick_data = {
+        .parent = "security_l4_ick2",
+        .bit_shift = 3,
+        .reg = 0xa14,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk aes1_ick = {
+        .name = "aes1_ick",
+        .type = TI_CLK_GATE,
+        .data = &aes1_ick_data,
+};
+
+static const char *dpll5_ck_parents[] = {
+        "sys_ck",
+        "sys_ck",
+};
+
+static struct ti_clk_dpll dpll5_ck_data = {
+        .num_parents = ARRAY_SIZE(dpll5_ck_parents),
+        .control_reg = 0xd04,
+        .idlest_reg = 0xd24,
+        .mult_div1_reg = 0xd4c,
+        .autoidle_reg = 0xd34,
+        .module = TI_CLKM_CM,
+        .parents = dpll5_ck_parents,
+        .freqsel_mask = 0xf0,
+        .modes = 0x82,
+        .div1_mask = 0x7f,
+        .idlest_mask = 0x1,
+        .auto_recal_bit = 0x3,
+        .max_divider = 0x80,
+        .min_divider = 0x1,
+        .recal_en_bit = 0x19,
+        .max_multiplier = 0x7ff,
+        .enable_mask = 0x7,
+        .mult_mask = 0x7ff00,
+        .recal_st_bit = 0x19,
+        .autoidle_mask = 0x7,
+};
+
+static struct ti_clk dpll5_ck = {
+        .name = "dpll5_ck",
+        .clkdm_name = "dpll5_clkdm",
+        .type = TI_CLK_DPLL,
+        .data = &dpll5_ck_data,
+};
+
+static struct ti_clk_divider dpll5_m2_ck_data = {
+        .parent = "dpll5_ck",
+        .max_div = 31,
+        .reg = 0xd50,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll5_m2_ck = {
+        .name = "dpll5_m2_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll5_m2_ck_data,
+};
+
+static struct ti_clk_gate usbhost_120m_fck_data = {
+        .parent = "dpll5_m2_ck",
+        .bit_shift = 1,
+        .reg = 0x1400,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk usbhost_120m_fck = {
+        .name = "usbhost_120m_fck",
+        .clkdm_name = "usbhost_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &usbhost_120m_fck_data,
+};
+
+static struct ti_clk_fixed_factor cm_96m_d2_fck_data = {
+        .parent = "cm_96m_fck",
+        .div = 2,
+        .mult = 1,
+};
+
+static struct ti_clk cm_96m_d2_fck = {
+        .name = "cm_96m_d2_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &cm_96m_d2_fck_data,
+};
+
+static struct ti_clk_fixed sys_altclk_data = {
+        .frequency = 0x0,
+};
+
+static struct ti_clk sys_altclk = {
+        .name = "sys_altclk",
+        .type = TI_CLK_FIXED,
+        .data = &sys_altclk_data,
+};
+
+static const char *omap_48m_fck_parents[] = {
+        "cm_96m_d2_fck",
+        "sys_altclk",
+};
+
+static struct ti_clk_mux omap_48m_fck_data = {
+        .bit_shift = 3,
+        .num_parents = ARRAY_SIZE(omap_48m_fck_parents),
+        .reg = 0xd40,
+        .module = TI_CLKM_CM,
+        .parents = omap_48m_fck_parents,
+};
+
+static struct ti_clk omap_48m_fck = {
+        .name = "omap_48m_fck",
+        .type = TI_CLK_MUX,
+        .data = &omap_48m_fck_data,
+};
+
+static struct ti_clk_fixed_factor core_48m_fck_data = {
+        .parent = "omap_48m_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk core_48m_fck = {
+        .name = "core_48m_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_48m_fck_data,
+};
+
+static struct ti_clk_fixed mcbsp_clks_data = {
+        .frequency = 0x0,
+};
+
+static struct ti_clk mcbsp_clks = {
+        .name = "mcbsp_clks",
+        .type = TI_CLK_FIXED,
+        .data = &mcbsp_clks_data,
+};
+
+static struct ti_clk_gate mcbsp2_gate_fck_data = {
+        .parent = "mcbsp_clks",
+        .bit_shift = 0,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_fixed_factor per_96m_fck_data = {
+        .parent = "omap_96m_alwon_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk per_96m_fck = {
+        .name = "per_96m_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &per_96m_fck_data,
+};
+
+static const char *mcbsp2_mux_fck_parents[] = {
+        "per_96m_fck",
+        "mcbsp_clks",
+};
+
+static struct ti_clk_mux mcbsp2_mux_fck_data = {
+        .bit_shift = 6,
+        .num_parents = ARRAY_SIZE(mcbsp2_mux_fck_parents),
+        .reg = 0x274,
+        .module = TI_CLKM_SCRM,
+        .parents = mcbsp2_mux_fck_parents,
+};
+
+static struct ti_clk_composite mcbsp2_fck_data = {
+        .mux = &mcbsp2_mux_fck_data,
+        .gate = &mcbsp2_gate_fck_data,
+};
+
+static struct ti_clk mcbsp2_fck = {
+        .name = "mcbsp2_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &mcbsp2_fck_data,
+};
+
+static struct ti_clk_fixed_factor dpll3_m2x2_ck_data = {
+        .parent = "dpll3_m2_ck",
+        .div = 1,
+        .mult = 2,
+};
+
+static struct ti_clk dpll3_m2x2_ck = {
+        .name = "dpll3_m2x2_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll3_m2x2_ck_data,
+};
+
+static struct ti_clk_fixed_factor corex2_fck_data = {
+        .parent = "dpll3_m2x2_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk corex2_fck = {
+        .name = "corex2_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &corex2_fck_data,
+};
+
+static struct ti_clk_gate ssi_ssr_gate_fck_3430es1_data = {
+        .parent = "corex2_fck",
+        .bit_shift = 0,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_NO_WAIT,
+};
+
+static int ssi_ssr_div_fck_3430es1_divs[] = {
+        0,
+        1,
+        2,
+        3,
+        4,
+        0,
+        6,
+        0,
+        8,
+};
+
+static struct ti_clk_divider ssi_ssr_div_fck_3430es1_data = {
+        .num_dividers = ARRAY_SIZE(ssi_ssr_div_fck_3430es1_divs),
+        .parent = "corex2_fck",
+        .bit_shift = 8,
+        .dividers = ssi_ssr_div_fck_3430es1_divs,
+        .reg = 0xa40,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_composite ssi_ssr_fck_3430es1_data = {
+        .gate = &ssi_ssr_gate_fck_3430es1_data,
+        .divider = &ssi_ssr_div_fck_3430es1_data,
+};
+
+static struct ti_clk ssi_ssr_fck_3430es1 = {
+        .name = "ssi_ssr_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &ssi_ssr_fck_3430es1_data,
+};
+
+static struct ti_clk_fixed_factor ssi_sst_fck_3430es1_data = {
+        .parent = "ssi_ssr_fck",
+        .div = 2,
+        .mult = 1,
+};
+
+static struct ti_clk ssi_sst_fck_3430es1 = {
+        .name = "ssi_sst_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &ssi_sst_fck_3430es1_data,
+};
+
+static struct ti_clk_fixed omap_32k_fck_data = {
+        .frequency = 32768,
+};
+
+static struct ti_clk omap_32k_fck = {
+        .name = "omap_32k_fck",
+        .type = TI_CLK_FIXED,
+        .data = &omap_32k_fck_data,
+};
+
+static struct ti_clk_fixed_factor per_32k_alwon_fck_data = {
+        .parent = "omap_32k_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk per_32k_alwon_fck = {
+        .name = "per_32k_alwon_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &per_32k_alwon_fck_data,
+};
+
+static struct ti_clk_gate gpio5_dbck_data = {
+        .parent = "per_32k_alwon_fck",
+        .bit_shift = 16,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk gpio5_dbck = {
+        .name = "gpio5_dbck",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio5_dbck_data,
+};
+
+static struct ti_clk_gate gpt1_ick_data = {
+        .parent = "wkup_l4_ick",
+        .bit_shift = 0,
+        .reg = 0xc10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt1_ick = {
+        .name = "gpt1_ick",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt1_ick_data,
+};
+
+static struct ti_clk_gate mcspi3_fck_data = {
+        .parent = "core_48m_fck",
+        .bit_shift = 20,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk mcspi3_fck = {
+        .name = "mcspi3_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcspi3_fck_data,
+};
+
+static struct ti_clk_gate gpt2_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 3,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static const char *gpt2_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt2_mux_fck_data = {
+        .num_parents = ARRAY_SIZE(gpt2_mux_fck_parents),
+        .reg = 0x1040,
+        .module = TI_CLKM_CM,
+        .parents = gpt2_mux_fck_parents,
+};
+
+static struct ti_clk_composite gpt2_fck_data = {
+        .mux = &gpt2_mux_fck_data,
+        .gate = &gpt2_gate_fck_data,
+};
+
+static struct ti_clk gpt2_fck = {
+        .name = "gpt2_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt2_fck_data,
+};
+
+static struct ti_clk_gate gpt10_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 11,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt10_ick = {
+        .name = "gpt10_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt10_ick_data,
+};
+
+static struct ti_clk_gate uart2_fck_data = {
+        .parent = "core_48m_fck",
+        .bit_shift = 14,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk uart2_fck = {
+        .name = "uart2_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart2_fck_data,
+};
+
+static struct ti_clk_fixed_factor sr_l4_ick_data = {
+        .parent = "l4_ick",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk sr_l4_ick = {
+        .name = "sr_l4_ick",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &sr_l4_ick_data,
+};
+
+static struct ti_clk_fixed_factor omap_96m_d8_fck_data = {
+        .parent = "omap_96m_fck",
+        .div = 8,
+        .mult = 1,
+};
+
+static struct ti_clk omap_96m_d8_fck = {
+        .name = "omap_96m_d8_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &omap_96m_d8_fck_data,
+};
+
+static struct ti_clk_divider dpll4_m5_ck_data = {
+        .parent = "dpll4_ck",
+        .max_div = 63,
+        .reg = 0xf40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll4_m5_ck = {
+        .name = "dpll4_m5_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll4_m5_ck_data,
+};
+
+static struct ti_clk_fixed_factor dpll4_m5x2_mul_ck_data = {
+        .parent = "dpll4_m5_ck",
+        .div = 1,
+        .mult = 2,
+        .flags = CLKF_SET_RATE_PARENT,
+};
+
+static struct ti_clk dpll4_m5x2_mul_ck = {
+        .name = "dpll4_m5x2_mul_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll4_m5x2_mul_ck_data,
+};
+
+static struct ti_clk_gate dpll4_m5x2_ck_data = {
+        .parent = "dpll4_m5x2_mul_ck",
+        .bit_shift = 0x1e,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m5x2_ck = {
+        .name = "dpll4_m5x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m5x2_ck_data,
+};
+
+static struct ti_clk_gate cam_mclk_data = {
+        .parent = "dpll4_m5x2_ck",
+        .bit_shift = 0,
+        .reg = 0xf00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SET_RATE_PARENT,
+};
+
+static struct ti_clk cam_mclk = {
+        .name = "cam_mclk",
+        .type = TI_CLK_GATE,
+        .data = &cam_mclk_data,
+};
+
+static struct ti_clk_gate mcbsp3_gate_fck_data = {
+        .parent = "mcbsp_clks",
+        .bit_shift = 1,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static const char *mcbsp3_mux_fck_parents[] = {
+        "per_96m_fck",
+        "mcbsp_clks",
+};
+
+static struct ti_clk_mux mcbsp3_mux_fck_data = {
+        .num_parents = ARRAY_SIZE(mcbsp3_mux_fck_parents),
+        .reg = 0x2d8,
+        .module = TI_CLKM_SCRM,
+        .parents = mcbsp3_mux_fck_parents,
+};
+
+static struct ti_clk_composite mcbsp3_fck_data = {
+        .mux = &mcbsp3_mux_fck_data,
+        .gate = &mcbsp3_gate_fck_data,
+};
+
+static struct ti_clk mcbsp3_fck = {
+        .name = "mcbsp3_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &mcbsp3_fck_data,
+};
+
+static struct ti_clk_gate csi2_96m_fck_data = {
+        .parent = "core_96m_fck",
+        .bit_shift = 1,
+        .reg = 0xf00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk csi2_96m_fck = {
+        .name = "csi2_96m_fck",
+        .clkdm_name = "cam_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &csi2_96m_fck_data,
+};
+
+static struct ti_clk_gate gpt9_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 10,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static const char *gpt9_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt9_mux_fck_data = {
+        .bit_shift = 7,
+        .num_parents = ARRAY_SIZE(gpt9_mux_fck_parents),
+        .reg = 0x1040,
+        .module = TI_CLKM_CM,
+        .parents = gpt9_mux_fck_parents,
+};
+
+static struct ti_clk_composite gpt9_fck_data = {
+        .mux = &gpt9_mux_fck_data,
+        .gate = &gpt9_gate_fck_data,
+};
+
+static struct ti_clk gpt9_fck = {
+        .name = "gpt9_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt9_fck_data,
+};
+
+static struct ti_clk_divider dpll3_m3_ck_data = {
+        .parent = "dpll3_ck",
+        .bit_shift = 16,
+        .max_div = 31,
+        .reg = 0x1140,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll3_m3_ck = {
+        .name = "dpll3_m3_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll3_m3_ck_data,
+};
+
+static struct ti_clk_fixed_factor dpll3_m3x2_mul_ck_data = {
+        .parent = "dpll3_m3_ck",
+        .div = 1,
+        .mult = 2,
+};
+
+static struct ti_clk dpll3_m3x2_mul_ck = {
+        .name = "dpll3_m3x2_mul_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll3_m3x2_mul_ck_data,
+};
+
+static struct ti_clk_gate sr2_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 7,
+        .reg = 0xc00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk sr2_fck = {
+        .name = "sr2_fck",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &sr2_fck_data,
+};
+
+static struct ti_clk_fixed pclk_ck_data = {
+        .frequency = 27000000,
+};
+
+static struct ti_clk pclk_ck = {
+        .name = "pclk_ck",
+        .type = TI_CLK_FIXED,
+        .data = &pclk_ck_data,
+};
+
+static struct ti_clk_gate wdt2_ick_data = {
+        .parent = "wkup_l4_ick",
+        .bit_shift = 5,
+        .reg = 0xc10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk wdt2_ick = {
+        .name = "wdt2_ick",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &wdt2_ick_data,
+};
+
+static struct ti_clk_fixed_factor core_l3_ick_data = {
+        .parent = "l3_ick",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk core_l3_ick = {
+        .name = "core_l3_ick",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_l3_ick_data,
+};
+
+static struct ti_clk_gate mcspi4_fck_data = {
+        .parent = "core_48m_fck",
+        .bit_shift = 21,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk mcspi4_fck = {
+        .name = "mcspi4_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcspi4_fck_data,
+};
+
+static struct ti_clk_fixed_factor per_48m_fck_data = {
+        .parent = "omap_48m_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk per_48m_fck = {
+        .name = "per_48m_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &per_48m_fck_data,
+};
+
+static struct ti_clk_gate uart4_fck_data = {
+        .parent = "per_48m_fck",
+        .bit_shift = 18,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk uart4_fck = {
+        .name = "uart4_fck",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart4_fck_data,
+};
+
+static struct ti_clk_fixed_factor omap_96m_d10_fck_data = {
+        .parent = "omap_96m_fck",
+        .div = 10,
+        .mult = 1,
+};
+
+static struct ti_clk omap_96m_d10_fck = {
+        .name = "omap_96m_d10_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &omap_96m_d10_fck_data,
+};
+
+static struct ti_clk_gate usim_gate_fck_data = {
+        .parent = "omap_96m_fck",
+        .bit_shift = 9,
+        .reg = 0xc00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_fixed_factor per_l4_ick_data = {
+        .parent = "l4_ick",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk per_l4_ick = {
+        .name = "per_l4_ick",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &per_l4_ick_data,
+};
+
+static struct ti_clk_gate gpt5_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 6,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt5_ick = {
+        .name = "gpt5_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt5_ick_data,
+};
+
+static struct ti_clk_gate mcspi2_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 19,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcspi2_ick = {
+        .name = "mcspi2_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcspi2_ick_data,
+};
+
+static struct ti_clk_fixed_factor ssi_l4_ick_data = {
+        .parent = "l4_ick",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk ssi_l4_ick = {
+        .name = "ssi_l4_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &ssi_l4_ick_data,
+};
+
+static struct ti_clk_gate ssi_ick_3430es1_data = {
+        .parent = "ssi_l4_ick",
+        .bit_shift = 0,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_NO_WAIT | CLKF_INTERFACE,
+};
+
+static struct ti_clk ssi_ick_3430es1 = {
+        .name = "ssi_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &ssi_ick_3430es1_data,
+};
+
+static struct ti_clk_gate i2c2_fck_data = {
+        .parent = "core_96m_fck",
+        .bit_shift = 16,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk i2c2_fck = {
+        .name = "i2c2_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &i2c2_fck_data,
+};
+
+static struct ti_clk_divider dpll1_fck_data = {
+        .parent = "core_ck",
+        .bit_shift = 19,
+        .max_div = 7,
+        .reg = 0x940,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll1_fck = {
+        .name = "dpll1_fck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll1_fck_data,
+};
+
+static const char *dpll1_ck_parents[] = {
+        "sys_ck",
+        "dpll1_fck",
+};
+
+static struct ti_clk_dpll dpll1_ck_data = {
+        .num_parents = ARRAY_SIZE(dpll1_ck_parents),
+        .control_reg = 0x904,
+        .idlest_reg = 0x924,
+        .mult_div1_reg = 0x940,
+        .autoidle_reg = 0x934,
+        .module = TI_CLKM_CM,
+        .parents = dpll1_ck_parents,
+        .freqsel_mask = 0xf0,
+        .modes = 0xa0,
+        .div1_mask = 0x7f,
+        .idlest_mask = 0x1,
+        .auto_recal_bit = 0x3,
+        .max_divider = 0x80,
+        .min_divider = 0x1,
+        .recal_en_bit = 0x7,
+        .max_multiplier = 0x7ff,
+        .enable_mask = 0x7,
+        .mult_mask = 0x7ff00,
+        .recal_st_bit = 0x7,
+        .autoidle_mask = 0x7,
+};
+
+static struct ti_clk dpll1_ck = {
+        .name = "dpll1_ck",
+        .clkdm_name = "dpll1_clkdm",
+        .type = TI_CLK_DPLL,
+        .data = &dpll1_ck_data,
+};
+
+static struct ti_clk_fixed secure_32k_fck_data = {
+        .frequency = 32768,
+};
+
+static struct ti_clk secure_32k_fck = {
+        .name = "secure_32k_fck",
+        .type = TI_CLK_FIXED,
+        .data = &secure_32k_fck_data,
+};
+
+static struct ti_clk_gate gpio5_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 16,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpio5_ick = {
+        .name = "gpio5_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio5_ick_data,
+};
+
+static struct ti_clk_divider dpll4_m4_ck_data = {
+        .parent = "dpll4_ck",
+        .max_div = 32,
+        .reg = 0xe40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll4_m4_ck = {
+        .name = "dpll4_m4_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll4_m4_ck_data,
+};
+
+static struct ti_clk_fixed_factor dpll4_m4x2_mul_ck_data = {
+        .parent = "dpll4_m4_ck",
+        .div = 1,
+        .mult = 2,
+        .flags = CLKF_SET_RATE_PARENT,
+};
+
+static struct ti_clk dpll4_m4x2_mul_ck = {
+        .name = "dpll4_m4x2_mul_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll4_m4x2_mul_ck_data,
+};
+
+static struct ti_clk_gate dpll4_m4x2_ck_data = {
+        .parent = "dpll4_m4x2_mul_ck",
+        .bit_shift = 0x1d,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SET_RATE_PARENT | CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m4x2_ck = {
+        .name = "dpll4_m4x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m4x2_ck_data,
+};
+
+static struct ti_clk_gate dss1_alwon_fck_3430es2_data = {
+        .parent = "dpll4_m4x2_ck",
+        .bit_shift = 0,
+        .reg = 0xe00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_DSS | CLKF_SET_RATE_PARENT,
+};
+
+static struct ti_clk dss1_alwon_fck_3430es2 = {
+        .name = "dss1_alwon_fck",
+        .clkdm_name = "dss_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &dss1_alwon_fck_3430es2_data,
+};
+
+static struct ti_clk_gate uart3_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 11,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk uart3_ick = {
+        .name = "uart3_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart3_ick_data,
+};
+
+static struct ti_clk_divider dpll4_m3_ck_data = {
+        .parent = "dpll4_ck",
+        .bit_shift = 8,
+        .max_div = 32,
+        .reg = 0xe40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll4_m3_ck = {
+        .name = "dpll4_m3_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll4_m3_ck_data,
+};
+
+static struct ti_clk_gate mcbsp3_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 1,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcbsp3_ick = {
+        .name = "mcbsp3_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcbsp3_ick_data,
+};
+
+static struct ti_clk_gate gpio3_dbck_data = {
+        .parent = "per_32k_alwon_fck",
+        .bit_shift = 14,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk gpio3_dbck = {
+        .name = "gpio3_dbck",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio3_dbck_data,
+};
+
+static struct ti_clk_gate fac_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 8,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk fac_ick = {
+        .name = "fac_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &fac_ick_data,
+};
+
+static struct ti_clk_gate clkout2_src_gate_ck_data = {
+        .parent = "core_ck",
+        .bit_shift = 7,
+        .reg = 0xd70,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_NO_WAIT,
+};
+
+static struct ti_clk_fixed_factor dpll4_m3x2_mul_ck_data = {
+        .parent = "dpll4_m3_ck",
+        .div = 1,
+        .mult = 2,
+};
+
+static struct ti_clk dpll4_m3x2_mul_ck = {
+        .name = "dpll4_m3x2_mul_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll4_m3x2_mul_ck_data,
+};
+
+static struct ti_clk_gate dpll4_m3x2_ck_data = {
+        .parent = "dpll4_m3x2_mul_ck",
+        .bit_shift = 0x1c,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m3x2_ck = {
+        .name = "dpll4_m3x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m3x2_ck_data,
+};
+
+static const char *omap_54m_fck_parents[] = {
+        "dpll4_m3x2_ck",
+        "sys_altclk",
+};
+
+static struct ti_clk_mux omap_54m_fck_data = {
+        .bit_shift = 5,
+        .num_parents = ARRAY_SIZE(omap_54m_fck_parents),
+        .reg = 0xd40,
+        .module = TI_CLKM_CM,
+        .parents = omap_54m_fck_parents,
+};
+
+static struct ti_clk omap_54m_fck = {
+        .name = "omap_54m_fck",
+        .type = TI_CLK_MUX,
+        .data = &omap_54m_fck_data,
+};
+
+static const char *clkout2_src_mux_ck_parents[] = {
+        "core_ck",
+        "sys_ck",
+        "cm_96m_fck",
+        "omap_54m_fck",
+};
+
+static struct ti_clk_mux clkout2_src_mux_ck_data = {
+        .num_parents = ARRAY_SIZE(clkout2_src_mux_ck_parents),
+        .reg = 0xd70,
+        .module = TI_CLKM_CM,
+        .parents = clkout2_src_mux_ck_parents,
+};
+
+static struct ti_clk_composite clkout2_src_ck_data = {
+        .mux = &clkout2_src_mux_ck_data,
+        .gate = &clkout2_src_gate_ck_data,
+};
+
+static struct ti_clk clkout2_src_ck = {
+        .name = "clkout2_src_ck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &clkout2_src_ck_data,
+};
+
+static struct ti_clk_gate i2c1_fck_data = {
+        .parent = "core_96m_fck",
+        .bit_shift = 15,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk i2c1_fck = {
+        .name = "i2c1_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &i2c1_fck_data,
+};
+
+static struct ti_clk_gate wdt3_fck_data = {
+        .parent = "per_32k_alwon_fck",
+        .bit_shift = 12,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk wdt3_fck = {
+        .name = "wdt3_fck",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &wdt3_fck_data,
+};
+
+static struct ti_clk_gate gpt7_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 8,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static const char *gpt7_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt7_mux_fck_data = {
+        .bit_shift = 5,
+        .num_parents = ARRAY_SIZE(gpt7_mux_fck_parents),
+        .reg = 0x1040,
+        .module = TI_CLKM_CM,
+        .parents = gpt7_mux_fck_parents,
+};
+
+static struct ti_clk_composite gpt7_fck_data = {
+        .mux = &gpt7_mux_fck_data,
+        .gate = &gpt7_gate_fck_data,
+};
+
+static struct ti_clk gpt7_fck = {
+        .name = "gpt7_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt7_fck_data,
+};
+
+static struct ti_clk_gate usb_l4_gate_ick_data = {
+        .parent = "l4_ick",
+        .bit_shift = 5,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INTERFACE,
+};
+
+static struct ti_clk_divider usb_l4_div_ick_data = {
+        .parent = "l4_ick",
+        .bit_shift = 4,
+        .max_div = 1,
+        .reg = 0xa40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk_composite usb_l4_ick_data = {
+        .gate = &usb_l4_gate_ick_data,
+        .divider = &usb_l4_div_ick_data,
+};
+
+static struct ti_clk usb_l4_ick = {
+        .name = "usb_l4_ick",
+        .type = TI_CLK_COMPOSITE,
+        .data = &usb_l4_ick_data,
+};
+
+static struct ti_clk_gate uart4_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 18,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk uart4_ick = {
+        .name = "uart4_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart4_ick_data,
+};
+
+static struct ti_clk_fixed dummy_ck_data = {
+        .frequency = 0,
+};
+
+static struct ti_clk dummy_ck = {
+        .name = "dummy_ck",
+        .type = TI_CLK_FIXED,
+        .data = &dummy_ck_data,
+};
+
+static const char *gpt3_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt3_mux_fck_data = {
+        .bit_shift = 1,
+        .num_parents = ARRAY_SIZE(gpt3_mux_fck_parents),
+        .reg = 0x1040,
+        .module = TI_CLKM_CM,
+        .parents = gpt3_mux_fck_parents,
+};
+
+static struct ti_clk_gate gpt9_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 10,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt9_ick = {
+        .name = "gpt9_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt9_ick_data,
+};
+
+static struct ti_clk_gate gpt10_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 11,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_gate dss_ick_3430es1_data = {
+        .parent = "l4_ick",
+        .bit_shift = 0,
+        .reg = 0xe10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_NO_WAIT | CLKF_INTERFACE,
+};
+
+static struct ti_clk dss_ick_3430es1 = {
+        .name = "dss_ick",
+        .clkdm_name = "dss_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &dss_ick_3430es1_data,
+};
+
+static struct ti_clk_gate gpt11_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 12,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt11_ick = {
+        .name = "gpt11_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt11_ick_data,
+};
+
+static struct ti_clk_divider dpll2_fck_data = {
+        .parent = "core_ck",
+        .bit_shift = 19,
+        .max_div = 7,
+        .reg = 0x40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll2_fck = {
+        .name = "dpll2_fck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll2_fck_data,
+};
+
+static struct ti_clk_gate uart1_fck_data = {
+        .parent = "core_48m_fck",
+        .bit_shift = 13,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk uart1_fck = {
+        .name = "uart1_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart1_fck_data,
+};
+
+static struct ti_clk_gate hsotgusb_ick_3430es1_data = {
+        .parent = "core_l3_ick",
+        .bit_shift = 4,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_NO_WAIT | CLKF_INTERFACE,
+};
+
+static struct ti_clk hsotgusb_ick_3430es1 = {
+        .name = "hsotgusb_ick_3430es1",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &hsotgusb_ick_3430es1_data,
+};
+
+static struct ti_clk_gate gpio2_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 13,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpio2_ick = {
+        .name = "gpio2_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio2_ick_data,
+};
+
+static struct ti_clk_gate mmchs1_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 24,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mmchs1_ick = {
+        .name = "mmchs1_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mmchs1_ick_data,
+};
+
+static struct ti_clk_gate modem_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 31,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk modem_fck = {
+        .name = "modem_fck",
+        .clkdm_name = "d2d_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &modem_fck_data,
+};
+
+static struct ti_clk_gate mcbsp4_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 2,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcbsp4_ick = {
+        .name = "mcbsp4_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcbsp4_ick_data,
+};
+
+static struct ti_clk_gate gpio1_ick_data = {
+        .parent = "wkup_l4_ick",
+        .bit_shift = 3,
+        .reg = 0xc10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpio1_ick = {
+        .name = "gpio1_ick",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio1_ick_data,
+};
+
+static const char *gpt6_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt6_mux_fck_data = {
+        .bit_shift = 4,
+        .num_parents = ARRAY_SIZE(gpt6_mux_fck_parents),
+        .reg = 0x1040,
+        .module = TI_CLKM_CM,
+        .parents = gpt6_mux_fck_parents,
+};
+
+static struct ti_clk_fixed_factor dpll1_x2_ck_data = {
+        .parent = "dpll1_ck",
+        .div = 1,
+        .mult = 2,
+};
+
+static struct ti_clk dpll1_x2_ck = {
+        .name = "dpll1_x2_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll1_x2_ck_data,
+};
+
+static struct ti_clk_divider dpll1_x2m2_ck_data = {
+        .parent = "dpll1_x2_ck",
+        .max_div = 31,
+        .reg = 0x944,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll1_x2m2_ck = {
+        .name = "dpll1_x2m2_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll1_x2m2_ck_data,
+};
+
+static struct ti_clk_fixed_factor mpu_ck_data = {
+        .parent = "dpll1_x2m2_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk mpu_ck = {
+        .name = "mpu_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &mpu_ck_data,
+};
+
+static struct ti_clk_divider arm_fck_data = {
+        .parent = "mpu_ck",
+        .max_div = 2,
+        .reg = 0x924,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk arm_fck = {
+        .name = "arm_fck",
+        .type = TI_CLK_DIVIDER,
+        .data = &arm_fck_data,
+};
+
+static struct ti_clk_fixed_factor core_d3_ck_data = {
+        .parent = "core_ck",
+        .div = 3,
+        .mult = 1,
+};
+
+static struct ti_clk core_d3_ck = {
+        .name = "core_d3_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_d3_ck_data,
+};
+
+static struct ti_clk_gate gpt11_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 12,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+};
+
+static const char *gpt11_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt11_mux_fck_data = {
+        .bit_shift = 7,
+        .num_parents = ARRAY_SIZE(gpt11_mux_fck_parents),
+        .reg = 0xa40,
+        .module = TI_CLKM_CM,
+        .parents = gpt11_mux_fck_parents,
+};
+
+static struct ti_clk_composite gpt11_fck_data = {
+        .mux = &gpt11_mux_fck_data,
+        .gate = &gpt11_gate_fck_data,
+};
+
+static struct ti_clk gpt11_fck = {
+        .name = "gpt11_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt11_fck_data,
+};
+
+static struct ti_clk_fixed_factor core_d6_ck_data = {
+        .parent = "core_ck",
+        .div = 6,
+        .mult = 1,
+};
+
+static struct ti_clk core_d6_ck = {
+        .name = "core_d6_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_d6_ck_data,
+};
+
+static struct ti_clk_gate uart4_fck_am35xx_data = {
+        .parent = "core_48m_fck",
+        .bit_shift = 23,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk uart4_fck_am35xx = {
+        .name = "uart4_fck_am35xx",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart4_fck_am35xx_data,
+};
+
+static struct ti_clk_gate dpll3_m3x2_ck_data = {
+        .parent = "dpll3_m3x2_mul_ck",
+        .bit_shift = 0xc,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll3_m3x2_ck = {
+        .name = "dpll3_m3x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll3_m3x2_ck_data,
+};
+
+static struct ti_clk_fixed_factor emu_core_alwon_ck_data = {
+        .parent = "dpll3_m3x2_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk emu_core_alwon_ck = {
+        .name = "emu_core_alwon_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &emu_core_alwon_ck_data,
+};
+
+static struct ti_clk_divider dpll4_m6_ck_data = {
+        .parent = "dpll4_ck",
+        .bit_shift = 24,
+        .max_div = 63,
+        .reg = 0x1140,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll4_m6_ck = {
+        .name = "dpll4_m6_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll4_m6_ck_data,
+};
+
+static struct ti_clk_fixed_factor dpll4_m6x2_mul_ck_data = {
+        .parent = "dpll4_m6_ck",
+        .div = 1,
+        .mult = 2,
+};
+
+static struct ti_clk dpll4_m6x2_mul_ck = {
+        .name = "dpll4_m6x2_mul_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll4_m6x2_mul_ck_data,
+};
+
+static struct ti_clk_gate dpll4_m6x2_ck_data = {
+        .parent = "dpll4_m6x2_mul_ck",
+        .bit_shift = 0x1f,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m6x2_ck = {
+        .name = "dpll4_m6x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m6x2_ck_data,
+};
+
+static struct ti_clk_fixed_factor emu_per_alwon_ck_data = {
+        .parent = "dpll4_m6x2_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk emu_per_alwon_ck = {
+        .name = "emu_per_alwon_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &emu_per_alwon_ck_data,
+};
+
+static struct ti_clk_fixed_factor emu_mpu_alwon_ck_data = {
+        .parent = "mpu_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk emu_mpu_alwon_ck = {
+        .name = "emu_mpu_alwon_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &emu_mpu_alwon_ck_data,
+};
+
+static const char *emu_src_mux_ck_parents[] = {
+        "sys_ck",
+        "emu_core_alwon_ck",
+        "emu_per_alwon_ck",
+        "emu_mpu_alwon_ck",
+};
+
+static struct ti_clk_mux emu_src_mux_ck_data = {
+        .num_parents = ARRAY_SIZE(emu_src_mux_ck_parents),
+        .reg = 0x1140,
+        .module = TI_CLKM_CM,
+        .parents = emu_src_mux_ck_parents,
+};
+
+static struct ti_clk emu_src_mux_ck = {
+        .name = "emu_src_mux_ck",
+        .type = TI_CLK_MUX,
+        .data = &emu_src_mux_ck_data,
+};
+
+static struct ti_clk_gate emu_src_ck_data = {
+        .parent = "emu_src_mux_ck",
+        .flags = CLKF_CLKDM,
+};
+
+static struct ti_clk emu_src_ck = {
+        .name = "emu_src_ck",
+        .clkdm_name = "emu_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &emu_src_ck_data,
+};
+
+static struct ti_clk_divider atclk_fck_data = {
+        .parent = "emu_src_ck",
+        .bit_shift = 4,
+        .max_div = 3,
+        .reg = 0x1140,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk atclk_fck = {
+        .name = "atclk_fck",
+        .type = TI_CLK_DIVIDER,
+        .data = &atclk_fck_data,
+};
+
+static struct ti_clk_gate ipss_ick_data = {
+        .parent = "core_l3_ick",
+        .bit_shift = 4,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_AM35XX | CLKF_INTERFACE,
+};
+
+static struct ti_clk ipss_ick = {
+        .name = "ipss_ick",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &ipss_ick_data,
+};
+
+static struct ti_clk_gate emac_ick_data = {
+        .parent = "ipss_ick",
+        .bit_shift = 1,
+        .reg = 0x59c,
+        .module = TI_CLKM_SCRM,
+        .flags = CLKF_AM35XX,
+};
+
+static struct ti_clk emac_ick = {
+        .name = "emac_ick",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &emac_ick_data,
+};
+
+static struct ti_clk_gate vpfe_ick_data = {
+        .parent = "ipss_ick",
+        .bit_shift = 2,
+        .reg = 0x59c,
+        .module = TI_CLKM_SCRM,
+        .flags = CLKF_AM35XX,
+};
+
+static struct ti_clk vpfe_ick = {
+        .name = "vpfe_ick",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &vpfe_ick_data,
+};
+
+static const char *dpll2_ck_parents[] = {
+        "sys_ck",
+        "dpll2_fck",
+};
+
+static struct ti_clk_dpll dpll2_ck_data = {
+        .num_parents = ARRAY_SIZE(dpll2_ck_parents),
+        .control_reg = 0x4,
+        .idlest_reg = 0x24,
+        .mult_div1_reg = 0x40,
+        .autoidle_reg = 0x34,
+        .module = TI_CLKM_CM,
+        .parents = dpll2_ck_parents,
+        .freqsel_mask = 0xf0,
+        .modes = 0xa2,
+        .div1_mask = 0x7f,
+        .idlest_mask = 0x1,
+        .auto_recal_bit = 0x3,
+        .max_divider = 0x80,
+        .min_divider = 0x1,
+        .recal_en_bit = 0x8,
+        .max_multiplier = 0x7ff,
+        .enable_mask = 0x7,
+        .mult_mask = 0x7ff00,
+        .recal_st_bit = 0x8,
+        .autoidle_mask = 0x7,
+};
+
+static struct ti_clk dpll2_ck = {
+        .name = "dpll2_ck",
+        .clkdm_name = "dpll2_clkdm",
+        .type = TI_CLK_DPLL,
+        .data = &dpll2_ck_data,
+};
+
+static struct ti_clk_divider dpll2_m2_ck_data = {
+        .parent = "dpll2_ck",
+        .max_div = 31,
+        .reg = 0x44,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk dpll2_m2_ck = {
+        .name = "dpll2_m2_ck",
+        .type = TI_CLK_DIVIDER,
+        .data = &dpll2_m2_ck_data,
+};
+
+static const char *mcbsp4_mux_fck_parents[] = {
+        "per_96m_fck",
+        "mcbsp_clks",
+};
+
+static struct ti_clk_mux mcbsp4_mux_fck_data = {
+        .bit_shift = 2,
+        .num_parents = ARRAY_SIZE(mcbsp4_mux_fck_parents),
+        .reg = 0x2d8,
+        .module = TI_CLKM_SCRM,
+        .parents = mcbsp4_mux_fck_parents,
+};
+
+static const char *mcbsp1_mux_fck_parents[] = {
+        "core_96m_fck",
+        "mcbsp_clks",
+};
+
+static struct ti_clk_mux mcbsp1_mux_fck_data = {
+        .bit_shift = 2,
+        .num_parents = ARRAY_SIZE(mcbsp1_mux_fck_parents),
+        .reg = 0x274,
+        .module = TI_CLKM_SCRM,
+        .parents = mcbsp1_mux_fck_parents,
+};
+
+static struct ti_clk_gate gpt8_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 9,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_gate gpt8_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 9,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt8_ick = {
+        .name = "gpt8_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt8_ick_data,
+};
+
+static const char *gpt10_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt10_mux_fck_data = {
+        .bit_shift = 6,
+        .num_parents = ARRAY_SIZE(gpt10_mux_fck_parents),
+        .reg = 0xa40,
+        .module = TI_CLKM_CM,
+        .parents = gpt10_mux_fck_parents,
+};
+
+static struct ti_clk_gate mmchs3_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 30,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mmchs3_ick = {
+        .name = "mmchs3_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mmchs3_ick_data,
+};
+
+static struct ti_clk_gate gpio3_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 14,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpio3_ick = {
+        .name = "gpio3_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio3_ick_data,
+};
+
+static const char *traceclk_src_fck_parents[] = {
+        "sys_ck",
+        "emu_core_alwon_ck",
+        "emu_per_alwon_ck",
+        "emu_mpu_alwon_ck",
+};
+
+static struct ti_clk_mux traceclk_src_fck_data = {
+        .bit_shift = 2,
+        .num_parents = ARRAY_SIZE(traceclk_src_fck_parents),
+        .reg = 0x1140,
+        .module = TI_CLKM_CM,
+        .parents = traceclk_src_fck_parents,
+};
+
+static struct ti_clk traceclk_src_fck = {
+        .name = "traceclk_src_fck",
+        .type = TI_CLK_MUX,
+        .data = &traceclk_src_fck_data,
+};
+
+static struct ti_clk_divider traceclk_fck_data = {
+        .parent = "traceclk_src_fck",
+        .bit_shift = 11,
+        .max_div = 7,
+        .reg = 0x1140,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk traceclk_fck = {
+        .name = "traceclk_fck",
+        .type = TI_CLK_DIVIDER,
+        .data = &traceclk_fck_data,
+};
+
+static struct ti_clk_gate mcbsp5_gate_fck_data = {
+        .parent = "mcbsp_clks",
+        .bit_shift = 10,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_gate sad2d_ick_data = {
+        .parent = "l3_ick",
+        .bit_shift = 3,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk sad2d_ick = {
+        .name = "sad2d_ick",
+        .clkdm_name = "d2d_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &sad2d_ick_data,
+};
+
+static const char *gpt1_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt1_mux_fck_data = {
+        .num_parents = ARRAY_SIZE(gpt1_mux_fck_parents),
+        .reg = 0xc40,
+        .module = TI_CLKM_CM,
+        .parents = gpt1_mux_fck_parents,
+};
+
+static struct ti_clk_gate hecc_ck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 3,
+        .reg = 0x59c,
+        .module = TI_CLKM_SCRM,
+        .flags = CLKF_AM35XX,
+};
+
+static struct ti_clk hecc_ck = {
+        .name = "hecc_ck",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &hecc_ck_data,
+};
+
+static struct ti_clk_gate gpt1_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 0,
+        .reg = 0xc00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_composite gpt1_fck_data = {
+        .mux = &gpt1_mux_fck_data,
+        .gate = &gpt1_gate_fck_data,
+};
+
+static struct ti_clk gpt1_fck = {
+        .name = "gpt1_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt1_fck_data,
+};
+
+static struct ti_clk_gate dpll4_m2x2_ck_omap36xx_data = {
+        .parent = "dpll4_m2x2_mul_ck",
+        .bit_shift = 0x1b,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_HSDIV | CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m2x2_ck_omap36xx = {
+        .name = "dpll4_m2x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m2x2_ck_omap36xx_data,
+        .patch = &dpll4_m2x2_ck,
+};
+
+static struct ti_clk_divider gfx_l3_fck_data = {
+        .parent = "l3_ick",
+        .max_div = 7,
+        .reg = 0xb40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk gfx_l3_fck = {
+        .name = "gfx_l3_fck",
+        .type = TI_CLK_DIVIDER,
+        .data = &gfx_l3_fck_data,
+};
+
+static struct ti_clk_gate gfx_cg1_ck_data = {
+        .parent = "gfx_l3_fck",
+        .bit_shift = 1,
+        .reg = 0xb00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk gfx_cg1_ck = {
+        .name = "gfx_cg1_ck",
+        .clkdm_name = "gfx_3430es1_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gfx_cg1_ck_data,
+};
+
+static struct ti_clk_gate mailboxes_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 7,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mailboxes_ick = {
+        .name = "mailboxes_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mailboxes_ick_data,
+};
+
+static struct ti_clk_gate sha11_ick_data = {
+        .parent = "security_l4_ick2",
+        .bit_shift = 1,
+        .reg = 0xa14,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk sha11_ick = {
+        .name = "sha11_ick",
+        .type = TI_CLK_GATE,
+        .data = &sha11_ick_data,
+};
+
+static struct ti_clk_gate hsotgusb_ick_am35xx_data = {
+        .parent = "ipss_ick",
+        .bit_shift = 0,
+        .reg = 0x59c,
+        .module = TI_CLKM_SCRM,
+        .flags = CLKF_AM35XX,
+};
+
+static struct ti_clk hsotgusb_ick_am35xx = {
+        .name = "hsotgusb_ick_am35xx",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &hsotgusb_ick_am35xx_data,
+};
+
+static struct ti_clk_gate mmchs3_fck_data = {
+        .parent = "core_96m_fck",
+        .bit_shift = 30,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk mmchs3_fck = {
+        .name = "mmchs3_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mmchs3_fck_data,
+};
+
+static struct ti_clk_divider pclk_fck_data = {
+        .parent = "emu_src_ck",
+        .bit_shift = 8,
+        .max_div = 7,
+        .reg = 0x1140,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk pclk_fck = {
+        .name = "pclk_fck",
+        .type = TI_CLK_DIVIDER,
+        .data = &pclk_fck_data,
+};
+
+static const char *dpll4_ck_omap36xx_parents[] = {
+        "sys_ck",
+        "sys_ck",
+};
+
+static struct ti_clk_dpll dpll4_ck_omap36xx_data = {
+        .num_parents = ARRAY_SIZE(dpll4_ck_omap36xx_parents),
+        .control_reg = 0xd00,
+        .idlest_reg = 0xd20,
+        .mult_div1_reg = 0xd44,
+        .autoidle_reg = 0xd30,
+        .module = TI_CLKM_CM,
+        .parents = dpll4_ck_omap36xx_parents,
+        .modes = 0x82,
+        .div1_mask = 0x7f,
+        .idlest_mask = 0x2,
+        .auto_recal_bit = 0x13,
+        .max_divider = 0x80,
+        .min_divider = 0x1,
+        .recal_en_bit = 0x6,
+        .max_multiplier = 0xfff,
+        .enable_mask = 0x70000,
+        .mult_mask = 0xfff00,
+        .recal_st_bit = 0x6,
+        .autoidle_mask = 0x38,
+        .sddiv_mask = 0xff000000,
+        .dco_mask = 0xe00000,
+        .flags = CLKF_PER | CLKF_J_TYPE,
+};
+
+static struct ti_clk dpll4_ck_omap36xx = {
+        .name = "dpll4_ck",
+        .type = TI_CLK_DPLL,
+        .data = &dpll4_ck_omap36xx_data,
+        .patch = &dpll4_ck,
+};
+
+static struct ti_clk_gate uart3_fck_data = {
+        .parent = "per_48m_fck",
+        .bit_shift = 11,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk uart3_fck = {
+        .name = "uart3_fck",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart3_fck_data,
+};
+
+static struct ti_clk_fixed_factor wkup_32k_fck_data = {
+        .parent = "omap_32k_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk wkup_32k_fck = {
+        .name = "wkup_32k_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &wkup_32k_fck_data,
+};
+
+static struct ti_clk_gate sys_clkout1_data = {
+        .parent = "osc_sys_ck",
+        .bit_shift = 7,
+        .reg = 0xd70,
+        .module = TI_CLKM_PRM,
+};
+
+static struct ti_clk sys_clkout1 = {
+        .name = "sys_clkout1",
+        .type = TI_CLK_GATE,
+        .data = &sys_clkout1_data,
+};
+
+static struct ti_clk_fixed_factor gpmc_fck_data = {
+        .parent = "core_l3_ick",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk gpmc_fck = {
+        .name = "gpmc_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &gpmc_fck_data,
+};
+
+static struct ti_clk_fixed_factor dpll5_m2_d20_ck_data = {
+        .parent = "dpll5_m2_ck",
+        .div = 20,
+        .mult = 1,
+};
+
+static struct ti_clk dpll5_m2_d20_ck = {
+        .name = "dpll5_m2_d20_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll5_m2_d20_ck_data,
+};
+
+static struct ti_clk_gate dpll4_m5x2_ck_omap36xx_data = {
+        .parent = "dpll4_m5x2_mul_ck",
+        .bit_shift = 0x1e,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_HSDIV | CLKF_SET_RATE_PARENT | CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m5x2_ck_omap36xx = {
+        .name = "dpll4_m5x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m5x2_ck_omap36xx_data,
+        .patch = &dpll4_m5x2_ck,
+};
+
+static struct ti_clk_gate ssi_ssr_gate_fck_3430es2_data = {
+        .parent = "corex2_fck",
+        .bit_shift = 0,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_NO_WAIT,
+};
+
+static struct ti_clk_gate uart1_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 13,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk uart1_ick = {
+        .name = "uart1_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart1_ick_data,
+};
+
+static struct ti_clk_gate iva2_ck_data = {
+        .parent = "dpll2_m2_ck",
+        .bit_shift = 0,
+        .reg = 0x0,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk iva2_ck = {
+        .name = "iva2_ck",
+        .clkdm_name = "iva2_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &iva2_ck_data,
+};
+
+static struct ti_clk_gate pka_ick_data = {
+        .parent = "security_l3_ick",
+        .bit_shift = 4,
+        .reg = 0xa14,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk pka_ick = {
+        .name = "pka_ick",
+        .type = TI_CLK_GATE,
+        .data = &pka_ick_data,
+};
+
+static struct ti_clk_gate gpt12_ick_data = {
+        .parent = "wkup_l4_ick",
+        .bit_shift = 1,
+        .reg = 0xc10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt12_ick = {
+        .name = "gpt12_ick",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt12_ick_data,
+};
+
+static const char *mcbsp5_mux_fck_parents[] = {
+        "core_96m_fck",
+        "mcbsp_clks",
+};
+
+static struct ti_clk_mux mcbsp5_mux_fck_data = {
+        .bit_shift = 4,
+        .num_parents = ARRAY_SIZE(mcbsp5_mux_fck_parents),
+        .reg = 0x2d8,
+        .module = TI_CLKM_SCRM,
+        .parents = mcbsp5_mux_fck_parents,
+};
+
+static struct ti_clk_composite mcbsp5_fck_data = {
+        .mux = &mcbsp5_mux_fck_data,
+        .gate = &mcbsp5_gate_fck_data,
+};
+
+static struct ti_clk mcbsp5_fck = {
+        .name = "mcbsp5_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &mcbsp5_fck_data,
+};
+
+static struct ti_clk_gate usbhost_48m_fck_data = {
+        .parent = "omap_48m_fck",
+        .bit_shift = 0,
+        .reg = 0x1400,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_DSS,
+};
+
+static struct ti_clk usbhost_48m_fck = {
+        .name = "usbhost_48m_fck",
+        .clkdm_name = "usbhost_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &usbhost_48m_fck_data,
+};
+
+static struct ti_clk_gate des1_ick_data = {
+        .parent = "security_l4_ick2",
+        .bit_shift = 0,
+        .reg = 0xa14,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk des1_ick = {
+        .name = "des1_ick",
+        .type = TI_CLK_GATE,
+        .data = &des1_ick_data,
+};
+
+static struct ti_clk_gate sgx_gate_fck_data = {
+        .parent = "core_ck",
+        .bit_shift = 1,
+        .reg = 0xb00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_fixed_factor core_d4_ck_data = {
+        .parent = "core_ck",
+        .div = 4,
+        .mult = 1,
+};
+
+static struct ti_clk core_d4_ck = {
+        .name = "core_d4_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_d4_ck_data,
+};
+
+static struct ti_clk_fixed_factor omap_192m_alwon_fck_data = {
+        .parent = "dpll4_m2x2_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk omap_192m_alwon_fck = {
+        .name = "omap_192m_alwon_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &omap_192m_alwon_fck_data,
+};
+
+static struct ti_clk_fixed_factor core_d2_ck_data = {
+        .parent = "core_ck",
+        .div = 2,
+        .mult = 1,
+};
+
+static struct ti_clk core_d2_ck = {
+        .name = "core_d2_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_d2_ck_data,
+};
+
+static struct ti_clk_fixed_factor corex2_d3_fck_data = {
+        .parent = "corex2_fck",
+        .div = 3,
+        .mult = 1,
+};
+
+static struct ti_clk corex2_d3_fck = {
+        .name = "corex2_d3_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &corex2_d3_fck_data,
+};
+
+static struct ti_clk_fixed_factor corex2_d5_fck_data = {
+        .parent = "corex2_fck",
+        .div = 5,
+        .mult = 1,
+};
+
+static struct ti_clk corex2_d5_fck = {
+        .name = "corex2_d5_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &corex2_d5_fck_data,
+};
+
+static const char *sgx_mux_fck_parents[] = {
+        "core_d3_ck",
+        "core_d4_ck",
+        "core_d6_ck",
+        "cm_96m_fck",
+        "omap_192m_alwon_fck",
+        "core_d2_ck",
+        "corex2_d3_fck",
+        "corex2_d5_fck",
+};
+
+static struct ti_clk_mux sgx_mux_fck_data = {
+        .num_parents = ARRAY_SIZE(sgx_mux_fck_parents),
+        .reg = 0xb40,
+        .module = TI_CLKM_CM,
+        .parents = sgx_mux_fck_parents,
+};
+
+static struct ti_clk_composite sgx_fck_data = {
+        .mux = &sgx_mux_fck_data,
+        .gate = &sgx_gate_fck_data,
+};
+
+static struct ti_clk sgx_fck = {
+        .name = "sgx_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &sgx_fck_data,
+};
+
+static struct ti_clk_gate mcspi1_fck_data = {
+        .parent = "core_48m_fck",
+        .bit_shift = 18,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk mcspi1_fck = {
+        .name = "mcspi1_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcspi1_fck_data,
+};
+
+static struct ti_clk_gate mmchs2_fck_data = {
+        .parent = "core_96m_fck",
+        .bit_shift = 25,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk mmchs2_fck = {
+        .name = "mmchs2_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mmchs2_fck_data,
+};
+
+static struct ti_clk_gate mcspi2_fck_data = {
+        .parent = "core_48m_fck",
+        .bit_shift = 19,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk mcspi2_fck = {
+        .name = "mcspi2_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcspi2_fck_data,
+};
+
+static struct ti_clk_gate vpfe_fck_data = {
+        .parent = "pclk_ck",
+        .bit_shift = 10,
+        .reg = 0x59c,
+        .module = TI_CLKM_SCRM,
+};
+
+static struct ti_clk vpfe_fck = {
+        .name = "vpfe_fck",
+        .type = TI_CLK_GATE,
+        .data = &vpfe_fck_data,
+};
+
+static struct ti_clk_gate gpt4_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 5,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_gate mcbsp1_gate_fck_data = {
+        .parent = "mcbsp_clks",
+        .bit_shift = 9,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_gate gpt5_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 6,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static const char *gpt5_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt5_mux_fck_data = {
+        .bit_shift = 3,
+        .num_parents = ARRAY_SIZE(gpt5_mux_fck_parents),
+        .reg = 0x1040,
+        .module = TI_CLKM_CM,
+        .parents = gpt5_mux_fck_parents,
+};
+
+static struct ti_clk_composite gpt5_fck_data = {
+        .mux = &gpt5_mux_fck_data,
+        .gate = &gpt5_gate_fck_data,
+};
+
+static struct ti_clk gpt5_fck = {
+        .name = "gpt5_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt5_fck_data,
+};
+
+static struct ti_clk_gate ts_fck_data = {
+        .parent = "omap_32k_fck",
+        .bit_shift = 1,
+        .reg = 0xa08,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk ts_fck = {
+        .name = "ts_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &ts_fck_data,
+};
+
+static struct ti_clk_fixed_factor wdt1_fck_data = {
+        .parent = "secure_32k_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk wdt1_fck = {
+        .name = "wdt1_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &wdt1_fck_data,
+};
+
+static struct ti_clk_gate dpll4_m6x2_ck_omap36xx_data = {
+        .parent = "dpll4_m6x2_mul_ck",
+        .bit_shift = 0x1f,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_HSDIV | CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m6x2_ck_omap36xx = {
+        .name = "dpll4_m6x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m6x2_ck_omap36xx_data,
+        .patch = &dpll4_m6x2_ck,
+};
+
+static const char *gpt4_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt4_mux_fck_data = {
+        .bit_shift = 2,
+        .num_parents = ARRAY_SIZE(gpt4_mux_fck_parents),
+        .reg = 0x1040,
+        .module = TI_CLKM_CM,
+        .parents = gpt4_mux_fck_parents,
+};
+
+static struct ti_clk_gate usbhost_ick_data = {
+        .parent = "l4_ick",
+        .bit_shift = 0,
+        .reg = 0x1410,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_DSS | CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk usbhost_ick = {
+        .name = "usbhost_ick",
+        .clkdm_name = "usbhost_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &usbhost_ick_data,
+};
+
+static struct ti_clk_gate mcbsp2_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 0,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcbsp2_ick = {
+        .name = "mcbsp2_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcbsp2_ick_data,
+};
+
+static struct ti_clk_gate omapctrl_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 6,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk omapctrl_ick = {
+        .name = "omapctrl_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &omapctrl_ick_data,
+};
+
+static struct ti_clk_fixed_factor omap_96m_d4_fck_data = {
+        .parent = "omap_96m_fck",
+        .div = 4,
+        .mult = 1,
+};
+
+static struct ti_clk omap_96m_d4_fck = {
+        .name = "omap_96m_d4_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &omap_96m_d4_fck_data,
+};
+
+static struct ti_clk_gate gpt6_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 7,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt6_ick = {
+        .name = "gpt6_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt6_ick_data,
+};
+
+static struct ti_clk_gate dpll3_m3x2_ck_omap36xx_data = {
+        .parent = "dpll3_m3x2_mul_ck",
+        .bit_shift = 0xc,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_HSDIV | CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll3_m3x2_ck_omap36xx = {
+        .name = "dpll3_m3x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll3_m3x2_ck_omap36xx_data,
+        .patch = &dpll3_m3x2_ck,
+};
+
+static struct ti_clk_gate i2c3_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 17,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk i2c3_ick = {
+        .name = "i2c3_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &i2c3_ick_data,
+};
+
+static struct ti_clk_gate gpio6_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 17,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpio6_ick = {
+        .name = "gpio6_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio6_ick_data,
+};
+
+static struct ti_clk_gate mspro_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 23,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mspro_ick = {
+        .name = "mspro_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mspro_ick_data,
+};
+
+static struct ti_clk_composite mcbsp1_fck_data = {
+        .mux = &mcbsp1_mux_fck_data,
+        .gate = &mcbsp1_gate_fck_data,
+};
+
+static struct ti_clk mcbsp1_fck = {
+        .name = "mcbsp1_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &mcbsp1_fck_data,
+};
+
+static struct ti_clk_gate gpt3_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 4,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_fixed rmii_ck_data = {
+        .frequency = 50000000,
+};
+
+static struct ti_clk rmii_ck = {
+        .name = "rmii_ck",
+        .type = TI_CLK_FIXED,
+        .data = &rmii_ck_data,
+};
+
+static struct ti_clk_gate gpt6_gate_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 7,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_composite gpt6_fck_data = {
+        .mux = &gpt6_mux_fck_data,
+        .gate = &gpt6_gate_fck_data,
+};
+
+static struct ti_clk gpt6_fck = {
+        .name = "gpt6_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt6_fck_data,
+};
+
+static struct ti_clk_fixed_factor dpll5_m2_d4_ck_data = {
+        .parent = "dpll5_m2_ck",
+        .div = 4,
+        .mult = 1,
+};
+
+static struct ti_clk dpll5_m2_d4_ck = {
+        .name = "dpll5_m2_d4_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll5_m2_d4_ck_data,
+};
+
+static struct ti_clk_fixed_factor sys_d2_ck_data = {
+        .parent = "sys_ck",
+        .div = 2,
+        .mult = 1,
+};
+
+static struct ti_clk sys_d2_ck = {
+        .name = "sys_d2_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &sys_d2_ck_data,
+};
+
+static struct ti_clk_fixed_factor omap_96m_d2_fck_data = {
+        .parent = "omap_96m_fck",
+        .div = 2,
+        .mult = 1,
+};
+
+static struct ti_clk omap_96m_d2_fck = {
+        .name = "omap_96m_d2_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &omap_96m_d2_fck_data,
+};
+
+static struct ti_clk_fixed_factor dpll5_m2_d8_ck_data = {
+        .parent = "dpll5_m2_ck",
+        .div = 8,
+        .mult = 1,
+};
+
+static struct ti_clk dpll5_m2_d8_ck = {
+        .name = "dpll5_m2_d8_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll5_m2_d8_ck_data,
+};
+
+static struct ti_clk_fixed_factor dpll5_m2_d16_ck_data = {
+        .parent = "dpll5_m2_ck",
+        .div = 16,
+        .mult = 1,
+};
+
+static struct ti_clk dpll5_m2_d16_ck = {
+        .name = "dpll5_m2_d16_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll5_m2_d16_ck_data,
+};
+
+static const char *usim_mux_fck_parents[] = {
+        "sys_ck",
+        "sys_d2_ck",
+        "omap_96m_d2_fck",
+        "omap_96m_d4_fck",
+        "omap_96m_d8_fck",
+        "omap_96m_d10_fck",
+        "dpll5_m2_d4_ck",
+        "dpll5_m2_d8_ck",
+        "dpll5_m2_d16_ck",
+        "dpll5_m2_d20_ck",
+};
+
+static struct ti_clk_mux usim_mux_fck_data = {
+        .bit_shift = 3,
+        .num_parents = ARRAY_SIZE(usim_mux_fck_parents),
+        .reg = 0xc40,
+        .module = TI_CLKM_CM,
+        .parents = usim_mux_fck_parents,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk_composite usim_fck_data = {
+        .mux = &usim_mux_fck_data,
+        .gate = &usim_gate_fck_data,
+};
+
+static struct ti_clk usim_fck = {
+        .name = "usim_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &usim_fck_data,
+};
+
+static int ssi_ssr_div_fck_3430es2_divs[] = {
+        0,
+        1,
+        2,
+        3,
+        4,
+        0,
+        6,
+        0,
+        8,
+};
+
+static struct ti_clk_divider ssi_ssr_div_fck_3430es2_data = {
+        .num_dividers = ARRAY_SIZE(ssi_ssr_div_fck_3430es2_divs),
+        .parent = "corex2_fck",
+        .bit_shift = 8,
+        .dividers = ssi_ssr_div_fck_3430es2_divs,
+        .reg = 0xa40,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_composite ssi_ssr_fck_3430es2_data = {
+        .gate = &ssi_ssr_gate_fck_3430es2_data,
+        .divider = &ssi_ssr_div_fck_3430es2_data,
+};
+
+static struct ti_clk ssi_ssr_fck_3430es2 = {
+        .name = "ssi_ssr_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &ssi_ssr_fck_3430es2_data,
+};
+
+static struct ti_clk_gate dss1_alwon_fck_3430es1_data = {
+        .parent = "dpll4_m4x2_ck",
+        .bit_shift = 0,
+        .reg = 0xe00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SET_RATE_PARENT,
+};
+
+static struct ti_clk dss1_alwon_fck_3430es1 = {
+        .name = "dss1_alwon_fck",
+        .clkdm_name = "dss_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &dss1_alwon_fck_3430es1_data,
+};
+
+static struct ti_clk_gate gpt3_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 4,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt3_ick = {
+        .name = "gpt3_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt3_ick_data,
+};
+
+static struct ti_clk_fixed_factor omap_12m_fck_data = {
+        .parent = "omap_48m_fck",
+        .div = 4,
+        .mult = 1,
+};
+
+static struct ti_clk omap_12m_fck = {
+        .name = "omap_12m_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &omap_12m_fck_data,
+};
+
+static struct ti_clk_fixed_factor core_12m_fck_data = {
+        .parent = "omap_12m_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk core_12m_fck = {
+        .name = "core_12m_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &core_12m_fck_data,
+};
+
+static struct ti_clk_gate hdq_fck_data = {
+        .parent = "core_12m_fck",
+        .bit_shift = 22,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk hdq_fck = {
+        .name = "hdq_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &hdq_fck_data,
+};
+
+static struct ti_clk_gate usbtll_fck_data = {
+        .parent = "dpll5_m2_ck",
+        .bit_shift = 2,
+        .reg = 0xa08,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk usbtll_fck = {
+        .name = "usbtll_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &usbtll_fck_data,
+};
+
+static struct ti_clk_gate hsotgusb_fck_am35xx_data = {
+        .parent = "sys_ck",
+        .bit_shift = 8,
+        .reg = 0x59c,
+        .module = TI_CLKM_SCRM,
+};
+
+static struct ti_clk hsotgusb_fck_am35xx = {
+        .name = "hsotgusb_fck_am35xx",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &hsotgusb_fck_am35xx_data,
+};
+
+static struct ti_clk_gate hsotgusb_ick_3430es2_data = {
+        .parent = "core_l3_ick",
+        .bit_shift = 4,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_HSOTGUSB | CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk hsotgusb_ick_3430es2 = {
+        .name = "hsotgusb_ick_3430es2",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &hsotgusb_ick_3430es2_data,
+};
+
+static struct ti_clk_gate gfx_l3_ck_data = {
+        .parent = "l3_ick",
+        .bit_shift = 0,
+        .reg = 0xb10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk gfx_l3_ck = {
+        .name = "gfx_l3_ck",
+        .clkdm_name = "gfx_3430es1_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gfx_l3_ck_data,
+};
+
+static struct ti_clk_fixed_factor gfx_l3_ick_data = {
+        .parent = "gfx_l3_ck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk gfx_l3_ick = {
+        .name = "gfx_l3_ick",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &gfx_l3_ick_data,
+};
+
+static struct ti_clk_gate mcbsp1_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 9,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcbsp1_ick = {
+        .name = "mcbsp1_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcbsp1_ick_data,
+};
+
+static struct ti_clk_fixed_factor gpt12_fck_data = {
+        .parent = "secure_32k_fck",
+        .div = 1,
+        .mult = 1,
+};
+
+static struct ti_clk gpt12_fck = {
+        .name = "gpt12_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &gpt12_fck_data,
+};
+
+static struct ti_clk_gate gfx_cg2_ck_data = {
+        .parent = "gfx_l3_fck",
+        .bit_shift = 2,
+        .reg = 0xb00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk gfx_cg2_ck = {
+        .name = "gfx_cg2_ck",
+        .clkdm_name = "gfx_3430es1_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gfx_cg2_ck_data,
+};
+
+static struct ti_clk_gate i2c2_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 16,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk i2c2_ick = {
+        .name = "i2c2_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &i2c2_ick_data,
+};
+
+static struct ti_clk_gate gpio4_dbck_data = {
+        .parent = "per_32k_alwon_fck",
+        .bit_shift = 15,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk gpio4_dbck = {
+        .name = "gpio4_dbck",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio4_dbck_data,
+};
+
+static struct ti_clk_gate i2c3_fck_data = {
+        .parent = "core_96m_fck",
+        .bit_shift = 17,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk i2c3_fck = {
+        .name = "i2c3_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &i2c3_fck_data,
+};
+
+static struct ti_clk_composite gpt3_fck_data = {
+        .mux = &gpt3_mux_fck_data,
+        .gate = &gpt3_gate_fck_data,
+};
+
+static struct ti_clk gpt3_fck = {
+        .name = "gpt3_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt3_fck_data,
+};
+
+static struct ti_clk_gate i2c1_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 15,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk i2c1_ick = {
+        .name = "i2c1_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &i2c1_ick_data,
+};
+
+static struct ti_clk_gate omap_32ksync_ick_data = {
+        .parent = "wkup_l4_ick",
+        .bit_shift = 2,
+        .reg = 0xc10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk omap_32ksync_ick = {
+        .name = "omap_32ksync_ick",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &omap_32ksync_ick_data,
+};
+
+static struct ti_clk_gate aes2_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 28,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk aes2_ick = {
+        .name = "aes2_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &aes2_ick_data,
+};
+
+static const char *gpt8_mux_fck_parents[] = {
+        "omap_32k_fck",
+        "sys_ck",
+};
+
+static struct ti_clk_mux gpt8_mux_fck_data = {
+        .bit_shift = 6,
+        .num_parents = ARRAY_SIZE(gpt8_mux_fck_parents),
+        .reg = 0x1040,
+        .module = TI_CLKM_CM,
+        .parents = gpt8_mux_fck_parents,
+};
+
+static struct ti_clk_composite gpt8_fck_data = {
+        .mux = &gpt8_mux_fck_data,
+        .gate = &gpt8_gate_fck_data,
+};
+
+static struct ti_clk gpt8_fck = {
+        .name = "gpt8_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt8_fck_data,
+};
+
+static struct ti_clk_gate mcbsp4_gate_fck_data = {
+        .parent = "mcbsp_clks",
+        .bit_shift = 2,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk_composite mcbsp4_fck_data = {
+        .mux = &mcbsp4_mux_fck_data,
+        .gate = &mcbsp4_gate_fck_data,
+};
+
+static struct ti_clk mcbsp4_fck = {
+        .name = "mcbsp4_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &mcbsp4_fck_data,
+};
+
+static struct ti_clk_gate gpio2_dbck_data = {
+        .parent = "per_32k_alwon_fck",
+        .bit_shift = 13,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk gpio2_dbck = {
+        .name = "gpio2_dbck",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio2_dbck_data,
+};
+
+static struct ti_clk_gate usbtll_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 2,
+        .reg = 0xa18,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk usbtll_ick = {
+        .name = "usbtll_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &usbtll_ick_data,
+};
+
+static struct ti_clk_gate mcspi4_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 21,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcspi4_ick = {
+        .name = "mcspi4_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcspi4_ick_data,
+};
+
+static struct ti_clk_gate dss_96m_fck_data = {
+        .parent = "omap_96m_fck",
+        .bit_shift = 2,
+        .reg = 0xe00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk dss_96m_fck = {
+        .name = "dss_96m_fck",
+        .clkdm_name = "dss_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &dss_96m_fck_data,
+};
+
+static struct ti_clk_divider rm_ick_data = {
+        .parent = "l4_ick",
+        .bit_shift = 1,
+        .max_div = 3,
+        .reg = 0xc40,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk rm_ick = {
+        .name = "rm_ick",
+        .type = TI_CLK_DIVIDER,
+        .data = &rm_ick_data,
+};
+
+static struct ti_clk_gate hdq_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 22,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk hdq_ick = {
+        .name = "hdq_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &hdq_ick_data,
+};
+
+static struct ti_clk_fixed_factor dpll3_x2_ck_data = {
+        .parent = "dpll3_ck",
+        .div = 1,
+        .mult = 2,
+};
+
+static struct ti_clk dpll3_x2_ck = {
+        .name = "dpll3_x2_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll3_x2_ck_data,
+};
+
+static struct ti_clk_gate mad2d_ick_data = {
+        .parent = "l3_ick",
+        .bit_shift = 3,
+        .reg = 0xa18,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mad2d_ick = {
+        .name = "mad2d_ick",
+        .clkdm_name = "d2d_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mad2d_ick_data,
+};
+
+static struct ti_clk_gate fshostusb_fck_data = {
+        .parent = "core_48m_fck",
+        .bit_shift = 5,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk fshostusb_fck = {
+        .name = "fshostusb_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &fshostusb_fck_data,
+};
+
+static struct ti_clk_gate sr1_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 6,
+        .reg = 0xc00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk sr1_fck = {
+        .name = "sr1_fck",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &sr1_fck_data,
+};
+
+static struct ti_clk_gate des2_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 26,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk des2_ick = {
+        .name = "des2_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &des2_ick_data,
+};
+
+static struct ti_clk_gate sdrc_ick_data = {
+        .parent = "core_l3_ick",
+        .bit_shift = 1,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk sdrc_ick = {
+        .name = "sdrc_ick",
+        .clkdm_name = "core_l3_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &sdrc_ick_data,
+};
+
+static struct ti_clk_composite gpt4_fck_data = {
+        .mux = &gpt4_mux_fck_data,
+        .gate = &gpt4_gate_fck_data,
+};
+
+static struct ti_clk gpt4_fck = {
+        .name = "gpt4_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt4_fck_data,
+};
+
+static struct ti_clk_gate dpll4_m3x2_ck_omap36xx_data = {
+        .parent = "dpll4_m3x2_mul_ck",
+        .bit_shift = 0x1c,
+        .reg = 0xd00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_HSDIV | CLKF_SET_BIT_TO_DISABLE,
+};
+
+static struct ti_clk dpll4_m3x2_ck_omap36xx = {
+        .name = "dpll4_m3x2_ck",
+        .type = TI_CLK_GATE,
+        .data = &dpll4_m3x2_ck_omap36xx_data,
+        .patch = &dpll4_m3x2_ck,
+};
+
+static struct ti_clk_gate cpefuse_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 0,
+        .reg = 0xa08,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk cpefuse_fck = {
+        .name = "cpefuse_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &cpefuse_fck_data,
+};
+
+static struct ti_clk_gate mcspi3_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 20,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcspi3_ick = {
+        .name = "mcspi3_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcspi3_ick_data,
+};
+
+static struct ti_clk_fixed_factor ssi_sst_fck_3430es2_data = {
+        .parent = "ssi_ssr_fck",
+        .div = 2,
+        .mult = 1,
+};
+
+static struct ti_clk ssi_sst_fck_3430es2 = {
+        .name = "ssi_sst_fck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &ssi_sst_fck_3430es2_data,
+};
+
+static struct ti_clk_gate gpio1_dbck_data = {
+        .parent = "wkup_32k_fck",
+        .bit_shift = 3,
+        .reg = 0xc00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk gpio1_dbck = {
+        .name = "gpio1_dbck",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio1_dbck_data,
+};
+
+static struct ti_clk_gate gpt4_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 5,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt4_ick = {
+        .name = "gpt4_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt4_ick_data,
+};
+
+static struct ti_clk_gate gpt2_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 3,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt2_ick = {
+        .name = "gpt2_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt2_ick_data,
+};
+
+static struct ti_clk_gate mmchs1_fck_data = {
+        .parent = "core_96m_fck",
+        .bit_shift = 24,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk mmchs1_fck = {
+        .name = "mmchs1_fck",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mmchs1_fck_data,
+};
+
+static struct ti_clk_fixed dummy_apb_pclk_data = {
+        .frequency = 0x0,
+};
+
+static struct ti_clk dummy_apb_pclk = {
+        .name = "dummy_apb_pclk",
+        .type = TI_CLK_FIXED,
+        .data = &dummy_apb_pclk_data,
+};
+
+static struct ti_clk_gate gpio6_dbck_data = {
+        .parent = "per_32k_alwon_fck",
+        .bit_shift = 17,
+        .reg = 0x1000,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk gpio6_dbck = {
+        .name = "gpio6_dbck",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio6_dbck_data,
+};
+
+static struct ti_clk_gate uart2_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 14,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk uart2_ick = {
+        .name = "uart2_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &uart2_ick_data,
+};
+
+static struct ti_clk_fixed_factor dpll4_x2_ck_data = {
+        .parent = "dpll4_ck",
+        .div = 1,
+        .mult = 2,
+};
+
+static struct ti_clk dpll4_x2_ck = {
+        .name = "dpll4_x2_ck",
+        .type = TI_CLK_FIXED_FACTOR,
+        .data = &dpll4_x2_ck_data,
+};
+
+static struct ti_clk_gate gpt7_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 8,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpt7_ick = {
+        .name = "gpt7_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpt7_ick_data,
+};
+
+static struct ti_clk_gate dss_tv_fck_data = {
+        .parent = "omap_54m_fck",
+        .bit_shift = 2,
+        .reg = 0xe00,
+        .module = TI_CLKM_CM,
+};
+
+static struct ti_clk dss_tv_fck = {
+        .name = "dss_tv_fck",
+        .clkdm_name = "dss_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &dss_tv_fck_data,
+};
+
+static struct ti_clk_gate mcbsp5_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 10,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcbsp5_ick = {
+        .name = "mcbsp5_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcbsp5_ick_data,
+};
+
+static struct ti_clk_gate mcspi1_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 18,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk mcspi1_ick = {
+        .name = "mcspi1_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &mcspi1_ick_data,
+};
+
+static struct ti_clk_gate d2d_26m_fck_data = {
+        .parent = "sys_ck",
+        .bit_shift = 3,
+        .reg = 0xa00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk d2d_26m_fck = {
+        .name = "d2d_26m_fck",
+        .clkdm_name = "d2d_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &d2d_26m_fck_data,
+};
+
+static struct ti_clk_gate wdt3_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 12,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk wdt3_ick = {
+        .name = "wdt3_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &wdt3_ick_data,
+};
+
+static struct ti_clk_divider pclkx2_fck_data = {
+        .parent = "emu_src_ck",
+        .bit_shift = 6,
+        .max_div = 3,
+        .reg = 0x1140,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_STARTS_AT_ONE,
+};
+
+static struct ti_clk pclkx2_fck = {
+        .name = "pclkx2_fck",
+        .type = TI_CLK_DIVIDER,
+        .data = &pclkx2_fck_data,
+};
+
+static struct ti_clk_gate sha12_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 27,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk sha12_ick = {
+        .name = "sha12_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &sha12_ick_data,
+};
+
+static struct ti_clk_gate emac_fck_data = {
+        .parent = "rmii_ck",
+        .bit_shift = 9,
+        .reg = 0x59c,
+        .module = TI_CLKM_SCRM,
+};
+
+static struct ti_clk emac_fck = {
+        .name = "emac_fck",
+        .type = TI_CLK_GATE,
+        .data = &emac_fck_data,
+};
+
+static struct ti_clk_composite gpt10_fck_data = {
+        .mux = &gpt10_mux_fck_data,
+        .gate = &gpt10_gate_fck_data,
+};
+
+static struct ti_clk gpt10_fck = {
+        .name = "gpt10_fck",
+        .type = TI_CLK_COMPOSITE,
+        .data = &gpt10_fck_data,
+};
+
+static struct ti_clk_gate wdt2_fck_data = {
+        .parent = "wkup_32k_fck",
+        .bit_shift = 5,
+        .reg = 0xc00,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk wdt2_fck = {
+        .name = "wdt2_fck",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &wdt2_fck_data,
+};
+
+static struct ti_clk_gate cam_ick_data = {
+        .parent = "l4_ick",
+        .bit_shift = 0,
+        .reg = 0xf10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_NO_WAIT | CLKF_INTERFACE,
+};
+
+static struct ti_clk cam_ick = {
+        .name = "cam_ick",
+        .clkdm_name = "cam_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &cam_ick_data,
+};
+
+static struct ti_clk_gate ssi_ick_3430es2_data = {
+        .parent = "ssi_l4_ick",
+        .bit_shift = 0,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_SSI | CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk ssi_ick_3430es2 = {
+        .name = "ssi_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &ssi_ick_3430es2_data,
+};
+
+static struct ti_clk_gate gpio4_ick_data = {
+        .parent = "per_l4_ick",
+        .bit_shift = 15,
+        .reg = 0x1010,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk gpio4_ick = {
+        .name = "gpio4_ick",
+        .clkdm_name = "per_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &gpio4_ick_data,
+};
+
+static struct ti_clk_gate wdt1_ick_data = {
+        .parent = "wkup_l4_ick",
+        .bit_shift = 4,
+        .reg = 0xc10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk wdt1_ick = {
+        .name = "wdt1_ick",
+        .clkdm_name = "wkup_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &wdt1_ick_data,
+};
+
+static struct ti_clk_gate rng_ick_data = {
+        .parent = "security_l4_ick2",
+        .bit_shift = 2,
+        .reg = 0xa14,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk rng_ick = {
+        .name = "rng_ick",
+        .type = TI_CLK_GATE,
+        .data = &rng_ick_data,
+};
+
+static struct ti_clk_gate icr_ick_data = {
+        .parent = "core_l4_ick",
+        .bit_shift = 29,
+        .reg = 0xa10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_OMAP3 | CLKF_INTERFACE,
+};
+
+static struct ti_clk icr_ick = {
+        .name = "icr_ick",
+        .clkdm_name = "core_l4_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &icr_ick_data,
+};
+
+static struct ti_clk_gate sgx_ick_data = {
+        .parent = "l3_ick",
+        .bit_shift = 0,
+        .reg = 0xb10,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_WAIT,
+};
+
+static struct ti_clk sgx_ick = {
+        .name = "sgx_ick",
+        .clkdm_name = "sgx_clkdm",
+        .type = TI_CLK_GATE,
+        .data = &sgx_ick_data,
+};
+
+static struct ti_clk_divider sys_clkout2_data = {
+        .parent = "clkout2_src_ck",
+        .bit_shift = 3,
+        .max_div = 64,
+        .reg = 0xd70,
+        .module = TI_CLKM_CM,
+        .flags = CLKF_INDEX_POWER_OF_TWO,
+};
+
+static struct ti_clk sys_clkout2 = {
+        .name = "sys_clkout2",
+        .type = TI_CLK_DIVIDER,
+        .data = &sys_clkout2_data,
+};
+
+static struct ti_clk_alias omap34xx_omap36xx_clks[] = {
+        CLK(NULL, "security_l4_ick2", &security_l4_ick2),
+        CLK(NULL, "aes1_ick", &aes1_ick),
+        CLK("omap_rng", "ick", &rng_ick),
+        CLK("omap3-rom-rng", "ick", &rng_ick),
+        CLK(NULL, "sha11_ick", &sha11_ick),
+        CLK(NULL, "des1_ick", &des1_ick),
+        CLK(NULL, "cam_mclk", &cam_mclk),
+        CLK(NULL, "cam_ick", &cam_ick),
+        CLK(NULL, "csi2_96m_fck", &csi2_96m_fck),
+        CLK(NULL, "security_l3_ick", &security_l3_ick),
+        CLK(NULL, "pka_ick", &pka_ick),
+        CLK(NULL, "icr_ick", &icr_ick),
+        CLK(NULL, "des2_ick", &des2_ick),
+        CLK(NULL, "mspro_ick", &mspro_ick),
+        CLK(NULL, "mailboxes_ick", &mailboxes_ick),
+        CLK(NULL, "ssi_l4_ick", &ssi_l4_ick),
+        CLK(NULL, "sr1_fck", &sr1_fck),
+        CLK(NULL, "sr2_fck", &sr2_fck),
+        CLK(NULL, "sr_l4_ick", &sr_l4_ick),
+        CLK(NULL, "dpll2_fck", &dpll2_fck),
+        CLK(NULL, "dpll2_ck", &dpll2_ck),
+        CLK(NULL, "dpll2_m2_ck", &dpll2_m2_ck),
+        CLK(NULL, "iva2_ck", &iva2_ck),
+        CLK(NULL, "modem_fck", &modem_fck),
+        CLK(NULL, "sad2d_ick", &sad2d_ick),
+        CLK(NULL, "mad2d_ick", &mad2d_ick),
+        CLK(NULL, "mspro_fck", &mspro_fck),
+        { NULL },
+};
+
+static struct ti_clk_alias omap36xx_omap3430es2plus_clks[] = {
+        CLK(NULL, "ssi_ssr_fck", &ssi_ssr_fck_3430es2),
+        CLK(NULL, "ssi_sst_fck", &ssi_sst_fck_3430es2),
+        CLK("musb-omap2430", "ick", &hsotgusb_ick_3430es2),
+        CLK(NULL, "hsotgusb_ick", &hsotgusb_ick_3430es2),
+        CLK(NULL, "ssi_ick", &ssi_ick_3430es2),
+        CLK(NULL, "sys_d2_ck", &sys_d2_ck),
+        CLK(NULL, "omap_96m_d2_fck", &omap_96m_d2_fck),
+        CLK(NULL, "omap_96m_d4_fck", &omap_96m_d4_fck),
+        CLK(NULL, "omap_96m_d8_fck", &omap_96m_d8_fck),
+        CLK(NULL, "omap_96m_d10_fck", &omap_96m_d10_fck),
+        CLK(NULL, "dpll5_m2_d4_ck", &dpll5_m2_d4_ck),
+        CLK(NULL, "dpll5_m2_d8_ck", &dpll5_m2_d8_ck),
+        CLK(NULL, "dpll5_m2_d16_ck", &dpll5_m2_d16_ck),
+        CLK(NULL, "dpll5_m2_d20_ck", &dpll5_m2_d20_ck),
+        CLK(NULL, "usim_fck", &usim_fck),
+        CLK(NULL, "usim_ick", &usim_ick),
+        { NULL },
+};
+
+static struct ti_clk_alias omap3xxx_clks[] = {
+        CLK(NULL, "apb_pclk", &dummy_apb_pclk),
+        CLK(NULL, "omap_32k_fck", &omap_32k_fck),
+        CLK(NULL, "virt_12m_ck", &virt_12m_ck),
+        CLK(NULL, "virt_13m_ck", &virt_13m_ck),
+        CLK(NULL, "virt_19200000_ck", &virt_19200000_ck),
+        CLK(NULL, "virt_26000000_ck", &virt_26000000_ck),
+        CLK(NULL, "virt_38_4m_ck", &virt_38_4m_ck),
+        CLK(NULL, "virt_16_8m_ck", &virt_16_8m_ck),
+        CLK(NULL, "osc_sys_ck", &osc_sys_ck),
+        CLK("twl", "fck", &osc_sys_ck),
+        CLK(NULL, "sys_ck", &sys_ck),
+        CLK(NULL, "timer_sys_ck", &sys_ck),
+        CLK(NULL, "dpll4_ck", &dpll4_ck),
+        CLK(NULL, "dpll4_m2_ck", &dpll4_m2_ck),
+        CLK(NULL, "dpll4_m2x2_mul_ck", &dpll4_m2x2_mul_ck),
+        CLK(NULL, "dpll4_m2x2_ck", &dpll4_m2x2_ck),
+        CLK(NULL, "omap_96m_alwon_fck", &omap_96m_alwon_fck),
+        CLK(NULL, "dpll3_ck", &dpll3_ck),
+        CLK(NULL, "dpll3_m3_ck", &dpll3_m3_ck),
+        CLK(NULL, "dpll3_m3x2_mul_ck", &dpll3_m3x2_mul_ck),
+        CLK(NULL, "dpll3_m3x2_ck", &dpll3_m3x2_ck),
+        CLK("etb", "emu_core_alwon_ck", &emu_core_alwon_ck),
+        CLK(NULL, "sys_altclk", &sys_altclk),
+        CLK(NULL, "mcbsp_clks", &mcbsp_clks),
+        CLK(NULL, "sys_clkout1", &sys_clkout1),
+        CLK(NULL, "dpll3_m2_ck", &dpll3_m2_ck),
+        CLK(NULL, "core_ck", &core_ck),
+        CLK(NULL, "dpll1_fck", &dpll1_fck),
+        CLK(NULL, "dpll1_ck", &dpll1_ck),
+        CLK(NULL, "cpufreq_ck", &dpll1_ck),
+        CLK(NULL, "dpll1_x2_ck", &dpll1_x2_ck),
+        CLK(NULL, "dpll1_x2m2_ck", &dpll1_x2m2_ck),
+        CLK(NULL, "dpll3_x2_ck", &dpll3_x2_ck),
+        CLK(NULL, "dpll3_m2x2_ck", &dpll3_m2x2_ck),
+        CLK(NULL, "dpll4_x2_ck", &dpll4_x2_ck),
+        CLK(NULL, "cm_96m_fck", &cm_96m_fck),
+        CLK(NULL, "omap_96m_fck", &omap_96m_fck),
+        CLK(NULL, "dpll4_m3_ck", &dpll4_m3_ck),
+        CLK(NULL, "dpll4_m3x2_mul_ck", &dpll4_m3x2_mul_ck),
+        CLK(NULL, "dpll4_m3x2_ck", &dpll4_m3x2_ck),
+        CLK(NULL, "omap_54m_fck", &omap_54m_fck),
+        CLK(NULL, "cm_96m_d2_fck", &cm_96m_d2_fck),
+        CLK(NULL, "omap_48m_fck", &omap_48m_fck),
+        CLK(NULL, "omap_12m_fck", &omap_12m_fck),
+        CLK(NULL, "dpll4_m4_ck", &dpll4_m4_ck),
+        CLK(NULL, "dpll4_m4x2_mul_ck", &dpll4_m4x2_mul_ck),
+        CLK(NULL, "dpll4_m4x2_ck", &dpll4_m4x2_ck),
+        CLK(NULL, "dpll4_m5_ck", &dpll4_m5_ck),
+        CLK(NULL, "dpll4_m5x2_mul_ck", &dpll4_m5x2_mul_ck),
+        CLK(NULL, "dpll4_m5x2_ck", &dpll4_m5x2_ck),
+        CLK(NULL, "dpll4_m6_ck", &dpll4_m6_ck),
+        CLK(NULL, "dpll4_m6x2_mul_ck", &dpll4_m6x2_mul_ck),
+        CLK(NULL, "dpll4_m6x2_ck", &dpll4_m6x2_ck),
+        CLK("etb", "emu_per_alwon_ck", &emu_per_alwon_ck),
+        CLK(NULL, "clkout2_src_ck", &clkout2_src_ck),
+        CLK(NULL, "sys_clkout2", &sys_clkout2),
+        CLK(NULL, "corex2_fck", &corex2_fck),
+        CLK(NULL, "mpu_ck", &mpu_ck),
+        CLK(NULL, "arm_fck", &arm_fck),
+        CLK("etb", "emu_mpu_alwon_ck", &emu_mpu_alwon_ck),
+        CLK(NULL, "l3_ick", &l3_ick),
+        CLK(NULL, "l4_ick", &l4_ick),
+        CLK(NULL, "rm_ick", &rm_ick),
+        CLK(NULL, "timer_32k_ck", &omap_32k_fck),
+        CLK(NULL, "gpt10_fck", &gpt10_fck),
+        CLK(NULL, "gpt11_fck", &gpt11_fck),
+        CLK(NULL, "core_96m_fck", &core_96m_fck),
+        CLK(NULL, "mmchs2_fck", &mmchs2_fck),
+        CLK(NULL, "mmchs1_fck", &mmchs1_fck),
+        CLK(NULL, "i2c3_fck", &i2c3_fck),
+        CLK(NULL, "i2c2_fck", &i2c2_fck),
+        CLK(NULL, "i2c1_fck", &i2c1_fck),
+        CLK(NULL, "mcbsp5_fck", &mcbsp5_fck),
+        CLK(NULL, "mcbsp1_fck", &mcbsp1_fck),
+        CLK(NULL, "core_48m_fck", &core_48m_fck),
+        CLK(NULL, "mcspi4_fck", &mcspi4_fck),
+        CLK(NULL, "mcspi3_fck", &mcspi3_fck),
+        CLK(NULL, "mcspi2_fck", &mcspi2_fck),
+        CLK(NULL, "mcspi1_fck", &mcspi1_fck),
+        CLK(NULL, "uart2_fck", &uart2_fck),
+        CLK(NULL, "uart1_fck", &uart1_fck),
+        CLK(NULL, "core_12m_fck", &core_12m_fck),
+        CLK("omap_hdq.0", "fck", &hdq_fck),
+        CLK(NULL, "hdq_fck", &hdq_fck),
+        CLK(NULL, "core_l3_ick", &core_l3_ick),
+        CLK(NULL, "sdrc_ick", &sdrc_ick),
+        CLK(NULL, "gpmc_fck", &gpmc_fck),
+        CLK(NULL, "core_l4_ick", &core_l4_ick),
+        CLK("omap_hsmmc.1", "ick", &mmchs2_ick),
+        CLK("omap_hsmmc.0", "ick", &mmchs1_ick),
+        CLK(NULL, "mmchs2_ick", &mmchs2_ick),
+        CLK(NULL, "mmchs1_ick", &mmchs1_ick),
+        CLK("omap_hdq.0", "ick", &hdq_ick),
+        CLK(NULL, "hdq_ick", &hdq_ick),
+        CLK("omap2_mcspi.4", "ick", &mcspi4_ick),
+        CLK("omap2_mcspi.3", "ick", &mcspi3_ick),
+        CLK("omap2_mcspi.2", "ick", &mcspi2_ick),
+        CLK("omap2_mcspi.1", "ick", &mcspi1_ick),
+        CLK(NULL, "mcspi4_ick", &mcspi4_ick),
+        CLK(NULL, "mcspi3_ick", &mcspi3_ick),
+        CLK(NULL, "mcspi2_ick", &mcspi2_ick),
+        CLK(NULL, "mcspi1_ick", &mcspi1_ick),
+        CLK("omap_i2c.3", "ick", &i2c3_ick),
+        CLK("omap_i2c.2", "ick", &i2c2_ick),
+        CLK("omap_i2c.1", "ick", &i2c1_ick),
+        CLK(NULL, "i2c3_ick", &i2c3_ick),
+        CLK(NULL, "i2c2_ick", &i2c2_ick),
+        CLK(NULL, "i2c1_ick", &i2c1_ick),
+        CLK(NULL, "uart2_ick", &uart2_ick),
+        CLK(NULL, "uart1_ick", &uart1_ick),
+        CLK(NULL, "gpt11_ick", &gpt11_ick),
+        CLK(NULL, "gpt10_ick", &gpt10_ick),
+        CLK("omap-mcbsp.5", "ick", &mcbsp5_ick),
+        CLK("omap-mcbsp.1", "ick", &mcbsp1_ick),
+        CLK(NULL, "mcbsp5_ick", &mcbsp5_ick),
+        CLK(NULL, "mcbsp1_ick", &mcbsp1_ick),
+        CLK(NULL, "omapctrl_ick", &omapctrl_ick),
+        CLK(NULL, "dss_tv_fck", &dss_tv_fck),
+        CLK(NULL, "dss_96m_fck", &dss_96m_fck),
+        CLK(NULL, "dss2_alwon_fck", &dss2_alwon_fck),
+        CLK(NULL, "init_60m_fclk", &dummy_ck),
+        CLK(NULL, "gpt1_fck", &gpt1_fck),
+        CLK(NULL, "aes2_ick", &aes2_ick),
+        CLK(NULL, "wkup_32k_fck", &wkup_32k_fck),
+        CLK(NULL, "gpio1_dbck", &gpio1_dbck),
+        CLK(NULL, "sha12_ick", &sha12_ick),
+        CLK(NULL, "wdt2_fck", &wdt2_fck),
+        CLK(NULL, "wkup_l4_ick", &wkup_l4_ick),
+        CLK("omap_wdt", "ick", &wdt2_ick),
+        CLK(NULL, "wdt2_ick", &wdt2_ick),
+        CLK(NULL, "wdt1_ick", &wdt1_ick),
+        CLK(NULL, "gpio1_ick", &gpio1_ick),
+        CLK(NULL, "omap_32ksync_ick", &omap_32ksync_ick),
+        CLK(NULL, "gpt12_ick", &gpt12_ick),
+        CLK(NULL, "gpt1_ick", &gpt1_ick),
+        CLK(NULL, "per_96m_fck", &per_96m_fck),
+        CLK(NULL, "per_48m_fck", &per_48m_fck),
+        CLK(NULL, "uart3_fck", &uart3_fck),
+        CLK(NULL, "gpt2_fck", &gpt2_fck),
+        CLK(NULL, "gpt3_fck", &gpt3_fck),
+        CLK(NULL, "gpt4_fck", &gpt4_fck),
+        CLK(NULL, "gpt5_fck", &gpt5_fck),
+        CLK(NULL, "gpt6_fck", &gpt6_fck),
+        CLK(NULL, "gpt7_fck", &gpt7_fck),
+        CLK(NULL, "gpt8_fck", &gpt8_fck),
+        CLK(NULL, "gpt9_fck", &gpt9_fck),
+        CLK(NULL, "per_32k_alwon_fck", &per_32k_alwon_fck),
+        CLK(NULL, "gpio6_dbck", &gpio6_dbck),
+        CLK(NULL, "gpio5_dbck", &gpio5_dbck),
+        CLK(NULL, "gpio4_dbck", &gpio4_dbck),
+        CLK(NULL, "gpio3_dbck", &gpio3_dbck),
+        CLK(NULL, "gpio2_dbck", &gpio2_dbck),
+        CLK(NULL, "wdt3_fck", &wdt3_fck),
+        CLK(NULL, "per_l4_ick", &per_l4_ick),
+        CLK(NULL, "gpio6_ick", &gpio6_ick),
+        CLK(NULL, "gpio5_ick", &gpio5_ick),
+        CLK(NULL, "gpio4_ick", &gpio4_ick),
+        CLK(NULL, "gpio3_ick", &gpio3_ick),
+        CLK(NULL, "gpio2_ick", &gpio2_ick),
+        CLK(NULL, "wdt3_ick", &wdt3_ick),
+        CLK(NULL, "uart3_ick", &uart3_ick),
+        CLK(NULL, "uart4_ick", &uart4_ick),
+        CLK(NULL, "gpt9_ick", &gpt9_ick),
+        CLK(NULL, "gpt8_ick", &gpt8_ick),
+        CLK(NULL, "gpt7_ick", &gpt7_ick),
+        CLK(NULL, "gpt6_ick", &gpt6_ick),
+        CLK(NULL, "gpt5_ick", &gpt5_ick),
+        CLK(NULL, "gpt4_ick", &gpt4_ick),
+        CLK(NULL, "gpt3_ick", &gpt3_ick),
+        CLK(NULL, "gpt2_ick", &gpt2_ick),
+        CLK("omap-mcbsp.2", "ick", &mcbsp2_ick),
+        CLK("omap-mcbsp.3", "ick", &mcbsp3_ick),
+        CLK("omap-mcbsp.4", "ick", &mcbsp4_ick),
+        CLK(NULL, "mcbsp4_ick", &mcbsp2_ick),
+        CLK(NULL, "mcbsp3_ick", &mcbsp3_ick),
+        CLK(NULL, "mcbsp2_ick", &mcbsp4_ick),
+        CLK(NULL, "mcbsp2_fck", &mcbsp2_fck),
+        CLK(NULL, "mcbsp3_fck", &mcbsp3_fck),
+        CLK(NULL, "mcbsp4_fck", &mcbsp4_fck),
+        CLK(NULL, "emu_src_mux_ck", &emu_src_mux_ck),
+        CLK("etb", "emu_src_ck", &emu_src_ck),
+        CLK(NULL, "emu_src_mux_ck", &emu_src_mux_ck),
+        CLK(NULL, "emu_src_ck", &emu_src_ck),
+        CLK(NULL, "pclk_fck", &pclk_fck),
+        CLK(NULL, "pclkx2_fck", &pclkx2_fck),
+        CLK(NULL, "atclk_fck", &atclk_fck),
+        CLK(NULL, "traceclk_src_fck", &traceclk_src_fck),
+        CLK(NULL, "traceclk_fck", &traceclk_fck),
+        CLK(NULL, "secure_32k_fck", &secure_32k_fck),
+        CLK(NULL, "gpt12_fck", &gpt12_fck),
+        CLK(NULL, "wdt1_fck", &wdt1_fck),
+        { NULL },
+};
+
+static struct ti_clk_alias omap36xx_am35xx_omap3430es2plus_clks[] = {
+        CLK(NULL, "dpll5_ck", &dpll5_ck),
+        CLK(NULL, "dpll5_m2_ck", &dpll5_m2_ck),
+        CLK(NULL, "core_d3_ck", &core_d3_ck),
+        CLK(NULL, "core_d4_ck", &core_d4_ck),
+        CLK(NULL, "core_d6_ck", &core_d6_ck),
+        CLK(NULL, "omap_192m_alwon_fck", &omap_192m_alwon_fck),
+        CLK(NULL, "core_d2_ck", &core_d2_ck),
+        CLK(NULL, "corex2_d3_fck", &corex2_d3_fck),
+        CLK(NULL, "corex2_d5_fck", &corex2_d5_fck),
+        CLK(NULL, "sgx_fck", &sgx_fck),
+        CLK(NULL, "sgx_ick", &sgx_ick),
+        CLK(NULL, "cpefuse_fck", &cpefuse_fck),
+        CLK(NULL, "ts_fck", &ts_fck),
+        CLK(NULL, "usbtll_fck", &usbtll_fck),
+        CLK(NULL, "usbtll_ick", &usbtll_ick),
+        CLK("omap_hsmmc.2", "ick", &mmchs3_ick),
+        CLK(NULL, "mmchs3_ick", &mmchs3_ick),
+        CLK(NULL, "mmchs3_fck", &mmchs3_fck),
+        CLK(NULL, "dss1_alwon_fck", &dss1_alwon_fck_3430es2),
+        CLK("omapdss_dss", "ick", &dss_ick_3430es2),
+        CLK(NULL, "dss_ick", &dss_ick_3430es2),
+        CLK(NULL, "usbhost_120m_fck", &usbhost_120m_fck),
+        CLK(NULL, "usbhost_48m_fck", &usbhost_48m_fck),
+        CLK(NULL, "usbhost_ick", &usbhost_ick),
+        { NULL },
+};
+
+static struct ti_clk_alias omap3430es1_clks[] = {
+        CLK(NULL, "gfx_l3_ck", &gfx_l3_ck),
+        CLK(NULL, "gfx_l3_fck", &gfx_l3_fck),
+        CLK(NULL, "gfx_l3_ick", &gfx_l3_ick),
+        CLK(NULL, "gfx_cg1_ck", &gfx_cg1_ck),
+        CLK(NULL, "gfx_cg2_ck", &gfx_cg2_ck),
+        CLK(NULL, "d2d_26m_fck", &d2d_26m_fck),
+        CLK(NULL, "fshostusb_fck", &fshostusb_fck),
+        CLK(NULL, "ssi_ssr_fck", &ssi_ssr_fck_3430es1),
+        CLK(NULL, "ssi_sst_fck", &ssi_sst_fck_3430es1),
+        CLK("musb-omap2430", "ick", &hsotgusb_ick_3430es1),
+        CLK(NULL, "hsotgusb_ick", &hsotgusb_ick_3430es1),
+        CLK(NULL, "fac_ick", &fac_ick),
+        CLK(NULL, "ssi_ick", &ssi_ick_3430es1),
+        CLK(NULL, "usb_l4_ick", &usb_l4_ick),
+        CLK(NULL, "dss1_alwon_fck", &dss1_alwon_fck_3430es1),
+        CLK("omapdss_dss", "ick", &dss_ick_3430es1),
+        CLK(NULL, "dss_ick", &dss_ick_3430es1),
+        { NULL },
+};
+
+static struct ti_clk_alias omap36xx_clks[] = {
+        CLK(NULL, "uart4_fck", &uart4_fck),
+        { NULL },
+};
+
+static struct ti_clk_alias am35xx_clks[] = {
+        CLK(NULL, "ipss_ick", &ipss_ick),
+        CLK(NULL, "rmii_ck", &rmii_ck),
+        CLK(NULL, "pclk_ck", &pclk_ck),
+        CLK(NULL, "emac_ick", &emac_ick),
+        CLK(NULL, "emac_fck", &emac_fck),
+        CLK("davinci_emac.0", NULL, &emac_ick),
+        CLK("davinci_mdio.0", NULL, &emac_fck),
+        CLK("vpfe-capture", "master", &vpfe_ick),
+        CLK("vpfe-capture", "slave", &vpfe_fck),
+        CLK(NULL, "hsotgusb_ick", &hsotgusb_ick_am35xx),
+        CLK(NULL, "hsotgusb_fck", &hsotgusb_fck_am35xx),
+        CLK(NULL, "hecc_ck", &hecc_ck),
+        CLK(NULL, "uart4_ick", &uart4_ick_am35xx),
+        CLK(NULL, "uart4_fck", &uart4_fck_am35xx),
+        { NULL },
+};
+
+static struct ti_clk *omap36xx_clk_patches[] = {
+        &dpll4_m3x2_ck_omap36xx,
+        &dpll3_m3x2_ck_omap36xx,
+        &dpll4_m6x2_ck_omap36xx,
+        &dpll4_m2x2_ck_omap36xx,
+        &dpll4_m5x2_ck_omap36xx,
+        &dpll4_ck_omap36xx,
+        NULL,
+};
+
+static const char *enable_init_clks[] = {
+        "sdrc_ick",
+        "gpmc_fck",
+        "omapctrl_ick",
+};
+
+static void __init omap3_clk_legacy_common_init(void)
+{
+        omap2_clk_disable_autoidle_all();
+
+        omap2_clk_enable_init_clocks(enable_init_clks,
+                                     ARRAY_SIZE(enable_init_clks));
+
+        pr_info("Clocking rate (Crystal/Core/MPU): %ld.%01ld/%ld/%ld MHz\n",
+                (clk_get_rate(osc_sys_ck.clk) / 1000000),
+                (clk_get_rate(osc_sys_ck.clk) / 100000) % 10,
+                (clk_get_rate(core_ck.clk) / 1000000),
+                (clk_get_rate(arm_fck.clk) / 1000000));
+}
+
+int __init omap3430es1_clk_legacy_init(void)
+{
+        int r;
+
+        r = ti_clk_register_legacy_clks(omap3430es1_clks);
+        r |= ti_clk_register_legacy_clks(omap34xx_omap36xx_clks);
+        r |= ti_clk_register_legacy_clks(omap3xxx_clks);
+
+        omap3_clk_legacy_common_init();
+
+        return r;
+}
+
+int __init omap3430_clk_legacy_init(void)
+{
+        int r;
+
+        r = ti_clk_register_legacy_clks(omap34xx_omap36xx_clks);
+        r |= ti_clk_register_legacy_clks(omap36xx_omap3430es2plus_clks);
+        r |= ti_clk_register_legacy_clks(omap36xx_am35xx_omap3430es2plus_clks);
+        r |= ti_clk_register_legacy_clks(omap3xxx_clks);
+
+        omap3_clk_legacy_common_init();
+        omap3_clk_lock_dpll5();
+
+        return r;
+}
+
+int __init omap36xx_clk_legacy_init(void)
+{
+        int r;
+
+        ti_clk_patch_legacy_clks(omap36xx_clk_patches);
+        r = ti_clk_register_legacy_clks(omap36xx_clks);
+        r |= ti_clk_register_legacy_clks(omap36xx_omap3430es2plus_clks);
+        r |= ti_clk_register_legacy_clks(omap34xx_omap36xx_clks);
+        r |= ti_clk_register_legacy_clks(omap36xx_am35xx_omap3430es2plus_clks);
+        r |= ti_clk_register_legacy_clks(omap3xxx_clks);
+
+        omap3_clk_legacy_common_init();
+        omap3_clk_lock_dpll5();
+
+        return r;
+}
+
+int __init am35xx_clk_legacy_init(void)
+{
+        int r;
+
+        r = ti_clk_register_legacy_clks(am35xx_clks);
+        r |= ti_clk_register_legacy_clks(omap36xx_am35xx_omap3430es2plus_clks);
+        r |= ti_clk_register_legacy_clks(omap3xxx_clks);
+
+        omap3_clk_legacy_common_init();
+        omap3_clk_lock_dpll5();
+
+        return r;
+}
diff --git a/drivers/clk/ti/clk-3xxx.c b/drivers/clk/ti/clk-3xxx.c
index 0d1750a8aea4..383a06e49b09 100644
--- a/drivers/clk/ti/clk-3xxx.c
+++ b/drivers/clk/ti/clk-3xxx.c
@@ -327,7 +327,6 @@ enum {
         OMAP3_SOC_OMAP3430_ES1,
         OMAP3_SOC_OMAP3430_ES2_PLUS,
         OMAP3_SOC_OMAP3630,
-        OMAP3_SOC_TI81XX,
 };
 
 static int __init omap3xxx_dt_clk_init(int soc_type)
@@ -370,7 +369,7 @@ static int __init omap3xxx_dt_clk_init(int soc_type)
                 (clk_get_rate(clk_get_sys(NULL, "core_ck")) / 1000000),
                 (clk_get_rate(clk_get_sys(NULL, "arm_fck")) / 1000000));
 
-        if (soc_type != OMAP3_SOC_TI81XX && soc_type != OMAP3_SOC_OMAP3430_ES1)
+        if (soc_type != OMAP3_SOC_OMAP3430_ES1)
                 omap3_clk_lock_dpll5();
 
         return 0;
@@ -390,8 +389,3 @@ int __init am35xx_dt_clk_init(void)
 {
         return omap3xxx_dt_clk_init(OMAP3_SOC_AM35XX);
 }
-
-int __init ti81xx_dt_clk_init(void)
-{
-        return omap3xxx_dt_clk_init(OMAP3_SOC_TI81XX);
-}
diff --git a/drivers/clk/ti/clk-44xx.c b/drivers/clk/ti/clk-44xx.c
index 02517a8206bd..4f4c87751db5 100644
--- a/drivers/clk/ti/clk-44xx.c
+++ b/drivers/clk/ti/clk-44xx.c
@@ -12,7 +12,7 @@
 
 #include <linux/kernel.h>
 #include <linux/list.h>
-#include <linux/clk-private.h>
+#include <linux/clk.h>
 #include <linux/clkdev.h>
 #include <linux/clk/ti.h>
 
diff --git a/drivers/clk/ti/clk-54xx.c b/drivers/clk/ti/clk-54xx.c
index 5e183993e3ec..14160b223548 100644
--- a/drivers/clk/ti/clk-54xx.c
+++ b/drivers/clk/ti/clk-54xx.c
@@ -12,7 +12,7 @@
 
 #include <linux/kernel.h>
 #include <linux/list.h>
-#include <linux/clk-private.h>
+#include <linux/clk.h>
 #include <linux/clkdev.h>
 #include <linux/io.h>
 #include <linux/clk/ti.h>
diff --git a/drivers/clk/ti/clk-7xx.c b/drivers/clk/ti/clk-7xx.c
index 62ac8f6e480c..ee32f4deebf4 100644
--- a/drivers/clk/ti/clk-7xx.c
+++ b/drivers/clk/ti/clk-7xx.c
@@ -12,7 +12,7 @@
 
 #include <linux/kernel.h>
 #include <linux/list.h>
-#include <linux/clk-private.h>
+#include <linux/clk.h>
 #include <linux/clkdev.h>
 #include <linux/clk/ti.h>
 
diff --git a/drivers/clk/ti/clk-816x.c b/drivers/clk/ti/clk-816x.c
new file mode 100644
index 000000000000..9451e651a1ff
--- /dev/null
+++ b/drivers/clk/ti/clk-816x.c
@@ -0,0 +1,53 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/clk-provider.h>
+#include <linux/clk/ti.h>
+
+static struct ti_dt_clk dm816x_clks[] = {
+        DT_CLK(NULL, "sys_clkin", "sys_clkin_ck"),
+        DT_CLK(NULL, "timer_sys_ck", "sys_clkin_ck"),
+        DT_CLK(NULL, "sys_32k_ck", "sys_32k_ck"),
+        DT_CLK(NULL, "mpu_ck", "mpu_ck"),
+        DT_CLK(NULL, "timer1_fck", "timer1_fck"),
+        DT_CLK(NULL, "timer2_fck", "timer2_fck"),
+        DT_CLK(NULL, "timer3_fck", "timer3_fck"),
+        DT_CLK(NULL, "timer4_fck", "timer4_fck"),
+        DT_CLK(NULL, "timer5_fck", "timer5_fck"),
+        DT_CLK(NULL, "timer6_fck", "timer6_fck"),
+        DT_CLK(NULL, "timer7_fck", "timer7_fck"),
+        DT_CLK(NULL, "sysclk4_ck", "sysclk4_ck"),
+        DT_CLK(NULL, "sysclk5_ck", "sysclk5_ck"),
+        DT_CLK(NULL, "sysclk6_ck", "sysclk6_ck"),
+        DT_CLK(NULL, "sysclk10_ck", "sysclk10_ck"),
+        DT_CLK(NULL, "sysclk18_ck", "sysclk18_ck"),
+        DT_CLK(NULL, "sysclk24_ck", "sysclk24_ck"),
+        DT_CLK("4a100000.ethernet", "sysclk24_ck", "sysclk24_ck"),
+        { .node_name = NULL },
+};
+
+static const char *enable_init_clks[] = {
+        "ddr_pll_clk1",
+        "ddr_pll_clk2",
+        "ddr_pll_clk3",
+};
+
+int __init ti81xx_dt_clk_init(void)
+{
+        ti_dt_clocks_register(dm816x_clks);
+        omap2_clk_disable_autoidle_all();
+        omap2_clk_enable_init_clocks(enable_init_clks,
+                                     ARRAY_SIZE(enable_init_clks));
+
+        return 0;
+}
diff --git a/drivers/clk/ti/clk.c b/drivers/clk/ti/clk.c
index 337abe5909e1..e22b95646e09 100644
--- a/drivers/clk/ti/clk.c
+++ b/drivers/clk/ti/clk.c
@@ -22,6 +22,8 @@
 #include <linux/of_address.h>
 #include <linux/list.h>
 
+#include "clock.h"
+
 #undef pr_fmt
 #define pr_fmt(fmt) "%s: " fmt, __func__
 
@@ -183,3 +185,128 @@ void ti_dt_clk_init_retry_clks(void)
                 retries--;
         }
 }
+
+#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_ATAGS)
+void __init ti_clk_patch_legacy_clks(struct ti_clk **patch)
+{
+        while (*patch) {
+                memcpy((*patch)->patch, *patch, sizeof(**patch));
+                patch++;
+        }
+}
+
+struct clk __init *ti_clk_register_clk(struct ti_clk *setup)
+{
+        struct clk *clk;
+        struct ti_clk_fixed *fixed;
+        struct ti_clk_fixed_factor *fixed_factor;
+        struct clk_hw *clk_hw;
+
+        if (setup->clk)
+                return setup->clk;
+
+        switch (setup->type) {
+        case TI_CLK_FIXED:
+                fixed = setup->data;
+
+                clk = clk_register_fixed_rate(NULL, setup->name, NULL,
+                                              CLK_IS_ROOT, fixed->frequency);
+                break;
+        case TI_CLK_MUX:
+                clk = ti_clk_register_mux(setup);
+                break;
+        case TI_CLK_DIVIDER:
+                clk = ti_clk_register_divider(setup);
+                break;
+        case TI_CLK_COMPOSITE:
+                clk = ti_clk_register_composite(setup);
+                break;
+        case TI_CLK_FIXED_FACTOR:
+                fixed_factor = setup->data;
+
+                clk = clk_register_fixed_factor(NULL, setup->name,
+                                                fixed_factor->parent,
+                                                0, fixed_factor->mult,
+                                                fixed_factor->div);
+                break;
+        case TI_CLK_GATE:
+                clk = ti_clk_register_gate(setup);
+                break;
+        case TI_CLK_DPLL:
+                clk = ti_clk_register_dpll(setup);
+                break;
+        default:
+                pr_err("bad type for %s!\n", setup->name);
+                clk = ERR_PTR(-EINVAL);
+        }
+
+        if (!IS_ERR(clk)) {
+                setup->clk = clk;
+                if (setup->clkdm_name) {
+                        if (__clk_get_flags(clk) & CLK_IS_BASIC) {
+                                pr_warn("can't setup clkdm for basic clk %s\n",
+                                        setup->name);
+                        } else {
+                                clk_hw = __clk_get_hw(clk);
+                                to_clk_hw_omap(clk_hw)->clkdm_name =
+                                        setup->clkdm_name;
+                                omap2_init_clk_clkdm(clk_hw);
+                        }
+                }
+        }
+
+        return clk;
+}
+
+int __init ti_clk_register_legacy_clks(struct ti_clk_alias *clks)
+{
+        struct clk *clk;
+        bool retry;
+        struct ti_clk_alias *retry_clk;
+        struct ti_clk_alias *tmp;
+
+        while (clks->clk) {
+                clk = ti_clk_register_clk(clks->clk);
+                if (IS_ERR(clk)) {
+                        if (PTR_ERR(clk) == -EAGAIN) {
+                                list_add(&clks->link, &retry_list);
+                        } else {
+                                pr_err("register for %s failed: %ld\n",
+                                       clks->clk->name, PTR_ERR(clk));
+                                return PTR_ERR(clk);
+                        }
+                } else {
+                        clks->lk.clk = clk;
+                        clkdev_add(&clks->lk);
+                }
+                clks++;
+        }
+
+        retry = true;
+
+        while (!list_empty(&retry_list) && retry) {
+                retry = false;
+                list_for_each_entry_safe(retry_clk, tmp, &retry_list, link) {
+                        pr_debug("retry-init: %s\n", retry_clk->clk->name);
+                        clk = ti_clk_register_clk(retry_clk->clk);
+                        if (IS_ERR(clk)) {
+                                if (PTR_ERR(clk) == -EAGAIN) {
+                                        continue;
+                                } else {
+                                        pr_err("register for %s failed: %ld\n",
+                                               retry_clk->clk->name,
+                                               PTR_ERR(clk));
+                                        return PTR_ERR(clk);
+                                }
+                        } else {
+                                retry = true;
+                                retry_clk->lk.clk = clk;
+                                clkdev_add(&retry_clk->lk);
+                                list_del(&retry_clk->link);
+                        }
+                }
+        }
+
+        return 0;
+}
+#endif
diff --git a/drivers/clk/ti/clock.h b/drivers/clk/ti/clock.h
new file mode 100644
index 000000000000..404158d2d7f8
--- /dev/null
+++ b/drivers/clk/ti/clock.h
@@ -0,0 +1,172 @@
+/*
+ * TI Clock driver internal definitions
+ *
+ * Copyright (C) 2014 Texas Instruments, Inc
+ *     Tero Kristo (t-kristo@ti.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 version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+#ifndef __DRIVERS_CLK_TI_CLOCK__
+#define __DRIVERS_CLK_TI_CLOCK__
+
+enum {
+        TI_CLK_FIXED,
+        TI_CLK_MUX,
+        TI_CLK_DIVIDER,
+        TI_CLK_COMPOSITE,
+        TI_CLK_FIXED_FACTOR,
+        TI_CLK_GATE,
+        TI_CLK_DPLL,
+};
+
+/* Global flags */
+#define CLKF_INDEX_POWER_OF_TWO         (1 << 0)
+#define CLKF_INDEX_STARTS_AT_ONE        (1 << 1)
+#define CLKF_SET_RATE_PARENT            (1 << 2)
+#define CLKF_OMAP3                      (1 << 3)
+#define CLKF_AM35XX                     (1 << 4)
+
+/* Gate flags */
+#define CLKF_SET_BIT_TO_DISABLE         (1 << 5)
+#define CLKF_INTERFACE                  (1 << 6)
+#define CLKF_SSI                        (1 << 7)
+#define CLKF_DSS                        (1 << 8)
+#define CLKF_HSOTGUSB                   (1 << 9)
+#define CLKF_WAIT                       (1 << 10)
+#define CLKF_NO_WAIT                    (1 << 11)
+#define CLKF_HSDIV                      (1 << 12)
+#define CLKF_CLKDM                      (1 << 13)
+
+/* DPLL flags */
+#define CLKF_LOW_POWER_STOP             (1 << 5)
+#define CLKF_LOCK                       (1 << 6)
+#define CLKF_LOW_POWER_BYPASS           (1 << 7)
+#define CLKF_PER                        (1 << 8)
+#define CLKF_CORE                       (1 << 9)
+#define CLKF_J_TYPE                     (1 << 10)
+
+#define CLK(dev, con, ck)               \
+        {                               \
+                .lk = {                 \
+                        .dev_id = dev,  \
+                        .con_id = con,  \
+                },                      \
+                .clk = ck,              \
+        }
+
+struct ti_clk {
+        const char *name;
+        const char *clkdm_name;
+        int type;
+        void *data;
+        struct ti_clk *patch;
+        struct clk *clk;
+};
+
+struct ti_clk_alias {
+        struct ti_clk *clk;
+        struct clk_lookup lk;
+        struct list_head link;
+};
+
+struct ti_clk_fixed {
+        u32 frequency;
+        u16 flags;
+};
+
+struct ti_clk_mux {
+        u8 bit_shift;
+        int num_parents;
+        u16 reg;
+        u8 module;
+        const char **parents;
+        u16 flags;
+};
+
+struct ti_clk_divider {
+        const char *parent;
+        u8 bit_shift;
+        u16 max_div;
+        u16 reg;
+        u8 module;
+        int *dividers;
+        int num_dividers;
+        u16 flags;
+};
+
+struct ti_clk_fixed_factor {
+        const char *parent;
+        u16 div;
+        u16 mult;
+        u16 flags;
+};
+
+struct ti_clk_gate {
+        const char *parent;
+        u8 bit_shift;
+        u16 reg;
+        u8 module;
+        u16 flags;
+};
+
+struct ti_clk_composite {
+        struct ti_clk_divider *divider;
+        struct ti_clk_mux *mux;
+        struct ti_clk_gate *gate;
+        u16 flags;
+};
+
+struct ti_clk_clkdm_gate {
+        const char *parent;
+        u16 flags;
+};
+
+struct ti_clk_dpll {
+        int num_parents;
+        u16 control_reg;
+        u16 idlest_reg;
+        u16 autoidle_reg;
+        u16 mult_div1_reg;
+        u8 module;
+        const char **parents;
+        u16 flags;
+        u8 modes;
+        u32 mult_mask;
+        u32 div1_mask;
+        u32 enable_mask;
+        u32 autoidle_mask;
+        u32 freqsel_mask;
+        u32 idlest_mask;
+        u32 dco_mask;
+        u32 sddiv_mask;
+        u16 max_multiplier;
+        u16 max_divider;
+        u8 min_divider;
+        u8 auto_recal_bit;
+        u8 recal_en_bit;
+        u8 recal_st_bit;
+};
+
+struct clk *ti_clk_register_gate(struct ti_clk *setup);
+struct clk *ti_clk_register_interface(struct ti_clk *setup);
+struct clk *ti_clk_register_mux(struct ti_clk *setup);
+struct clk *ti_clk_register_divider(struct ti_clk *setup);
+struct clk *ti_clk_register_composite(struct ti_clk *setup);
+struct clk *ti_clk_register_dpll(struct ti_clk *setup);
+
+struct clk_hw *ti_clk_build_component_div(struct ti_clk_divider *setup);
+struct clk_hw *ti_clk_build_component_gate(struct ti_clk_gate *setup);
+struct clk_hw *ti_clk_build_component_mux(struct ti_clk_mux *setup);
+
+void ti_clk_patch_legacy_clks(struct ti_clk **patch);
+struct clk *ti_clk_register_clk(struct ti_clk *setup);
+int ti_clk_register_legacy_clks(struct ti_clk_alias *clks);
+
+#endif
diff --git a/drivers/clk/ti/composite.c b/drivers/clk/ti/composite.c
index 19d8980ba458..3654f61912eb 100644
--- a/drivers/clk/ti/composite.c
+++ b/drivers/clk/ti/composite.c
@@ -23,6 +23,8 @@
 #include <linux/clk/ti.h>
 #include <linux/list.h>
 
+#include "clock.h"
+
 #undef pr_fmt
 #define pr_fmt(fmt) "%s: " fmt, __func__
 
@@ -116,8 +118,46 @@ static inline struct clk_hw *_get_hw(struct clk_hw_omap_comp *clk, int idx)
 
 #define to_clk_hw_comp(_hw) container_of(_hw, struct clk_hw_omap_comp, hw)
 
-static void __init ti_clk_register_composite(struct clk_hw *hw,
-                                             struct device_node *node)
+#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_ATAGS)
+struct clk *ti_clk_register_composite(struct ti_clk *setup)
+{
+        struct ti_clk_composite *comp;
+        struct clk_hw *gate;
+        struct clk_hw *mux;
+        struct clk_hw *div;
+        int num_parents = 1;
+        const char **parent_names = NULL;
+        struct clk *clk;
+
+        comp = setup->data;
+
+        div = ti_clk_build_component_div(comp->divider);
+        gate = ti_clk_build_component_gate(comp->gate);
+        mux = ti_clk_build_component_mux(comp->mux);
+
+        if (div)
+                parent_names = &comp->divider->parent;
+
+        if (gate)
+                parent_names = &comp->gate->parent;
+
+        if (mux) {
+                num_parents = comp->mux->num_parents;
+                parent_names = comp->mux->parents;
+        }
+
+        clk = clk_register_composite(NULL, setup->name,
+                                     parent_names, num_parents, mux,
+                                     &ti_clk_mux_ops, div,
+                                     &ti_composite_divider_ops, gate,
+                                     &ti_composite_gate_ops, 0);
+
+        return clk;
+}
+#endif
+
+static void __init _register_composite(struct clk_hw *hw,
+                                       struct device_node *node)
 {
         struct clk *clk;
         struct clk_hw_omap_comp *cclk = to_clk_hw_comp(hw);
@@ -136,7 +176,7 @@ static void __init ti_clk_register_composite(struct clk_hw *hw,
                         pr_debug("component %s not ready for %s, retry\n",
                                  cclk->comp_nodes[i]->name, node->name);
                         if (!ti_clk_retry_init(node, hw,
-                                               ti_clk_register_composite))
+                                               _register_composite))
                                 return;
 
                         goto cleanup;
@@ -216,7 +256,7 @@ static void __init of_ti_composite_clk_setup(struct device_node *node)
         for (i = 0; i < num_clks; i++)
                 cclk->comp_nodes[i] = _get_component_node(node, i);
 
-        ti_clk_register_composite(&cclk->hw, node);
+        _register_composite(&cclk->hw, node);
 }
 CLK_OF_DECLARE(ti_composite_clock, "ti,composite-clock",
                of_ti_composite_clk_setup);
diff --git a/drivers/clk/ti/divider.c b/drivers/clk/ti/divider.c
index bff2b5b8ff59..6211893c0980 100644
--- a/drivers/clk/ti/divider.c
+++ b/drivers/clk/ti/divider.c
@@ -21,6 +21,7 @@
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/clk/ti.h>
+#include "clock.h"
 
 #undef pr_fmt
 #define pr_fmt(fmt) "%s: " fmt, __func__
@@ -301,6 +302,134 @@ static struct clk *_register_divider(struct device *dev, const char *name,
 }
 
 static struct clk_div_table *
+_get_div_table_from_setup(struct ti_clk_divider *setup, u8 *width)
+{
+        int valid_div = 0;
+        struct clk_div_table *table;
+        int i;
+        int div;
+        u32 val;
+        u8 flags;
+
+        if (!setup->num_dividers) {
+                /* Clk divider table not provided, determine min/max divs */
+                flags = setup->flags;
+
+                if (flags & CLKF_INDEX_STARTS_AT_ONE)
+                        val = 1;
+                else
+                        val = 0;
+
+                div = 1;
+
+                while (div < setup->max_div) {
+                        if (flags & CLKF_INDEX_POWER_OF_TWO)
+                                div <<= 1;
+                        else
+                                div++;
+                        val++;
+                }
+
+                *width = fls(val);
+
+                return NULL;
+        }
+
+        for (i = 0; i < setup->num_dividers; i++)
+                if (setup->dividers[i])
+                        valid_div++;
+
+        table = kzalloc(sizeof(*table) * (valid_div + 1), GFP_KERNEL);
+        if (!table)
+                return ERR_PTR(-ENOMEM);
+
+        valid_div = 0;
+        *width = 0;
+
+        for (i = 0; i < setup->num_dividers; i++)
+                if (setup->dividers[i]) {
+                        table[valid_div].div = setup->dividers[i];
+                        table[valid_div].val = i;
+                        valid_div++;
+                        *width = i;
+                }
+
+        *width = fls(*width);
+
+        return table;
+}
+
+struct clk_hw *ti_clk_build_component_div(struct ti_clk_divider *setup)
+{
+        struct clk_divider *div;
+        struct clk_omap_reg *reg;
+
+        if (!setup)
+                return NULL;
+
+        div = kzalloc(sizeof(*div), GFP_KERNEL);
+        if (!div)
+                return ERR_PTR(-ENOMEM);
+
+        reg = (struct clk_omap_reg *)&div->reg;
+        reg->index = setup->module;
+        reg->offset = setup->reg;
+
+        if (setup->flags & CLKF_INDEX_STARTS_AT_ONE)
+                div->flags |= CLK_DIVIDER_ONE_BASED;
+
+        if (setup->flags & CLKF_INDEX_POWER_OF_TWO)
+                div->flags |= CLK_DIVIDER_POWER_OF_TWO;
+
+        div->table = _get_div_table_from_setup(setup, &div->width);
+
+        div->shift = setup->bit_shift;
+
+        return &div->hw;
+}
+
+struct clk *ti_clk_register_divider(struct ti_clk *setup)
+{
+        struct ti_clk_divider *div;
+        struct clk_omap_reg *reg_setup;
+        u32 reg;
+        u8 width;
+        u32 flags = 0;
+        u8 div_flags = 0;
+        struct clk_div_table *table;
+        struct clk *clk;
+
+        div = setup->data;
+
+        reg_setup = (struct clk_omap_reg *)&reg;
+
+        reg_setup->index = div->module;
+        reg_setup->offset = div->reg;
+
+        if (div->flags & CLKF_INDEX_STARTS_AT_ONE)
+                div_flags |= CLK_DIVIDER_ONE_BASED;
+
+        if (div->flags & CLKF_INDEX_POWER_OF_TWO)
+                div_flags |= CLK_DIVIDER_POWER_OF_TWO;
+
+        if (div->flags & CLKF_SET_RATE_PARENT)
+                flags |= CLK_SET_RATE_PARENT;
+
+        table = _get_div_table_from_setup(div, &width);
+        if (IS_ERR(table))
+                return (struct clk *)table;
+
+        clk = _register_divider(NULL, setup->name, div->parent,
+                                flags, (void __iomem *)reg, div->bit_shift,
+                                width, div_flags, table, NULL);
+
+        if (IS_ERR(clk))
+                kfree(table);
+
+        return clk;
+}
+
+static struct clk_div_table *
 __init ti_clk_get_div_table(struct device_node *node)
 {
         struct clk_div_table *table;
@@ -455,7 +584,8 @@ static void __init of_ti_divider_clk_setup(struct device_node *node)
                 goto cleanup;
 
         clk = _register_divider(NULL, node->name, parent_name, flags, reg,
-                                shift, width, clk_divider_flags, table, NULL);
+                                shift, width, clk_divider_flags, table,
+                                NULL);
 
         if (!IS_ERR(clk)) {
                 of_clk_add_provider(node, of_clk_src_simple_get, clk);
diff --git a/drivers/clk/ti/dpll.c b/drivers/clk/ti/dpll.c
index 85ac0dd501de..81dc4698dc41 100644
--- a/drivers/clk/ti/dpll.c
+++ b/drivers/clk/ti/dpll.c
@@ -21,6 +21,7 @@
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/clk/ti.h>
+#include "clock.h"
 
 #undef pr_fmt
 #define pr_fmt(fmt) "%s: " fmt, __func__
@@ -130,7 +131,7 @@ static const struct clk_ops dpll_x2_ck_ops = {
 };
 
 /**
- * ti_clk_register_dpll - low level registration of a DPLL clock
+ * _register_dpll - low level registration of a DPLL clock
  * @hw: hardware clock definition for the clock
  * @node: device node for the clock
  *
@@ -138,8 +139,8 @@ static const struct clk_ops dpll_x2_ck_ops = {
  * clk-bypass is missing), the clock is added to retry list and
  * the initialization is retried on later stage.
  */
-static void __init ti_clk_register_dpll(struct clk_hw *hw,
-                                        struct device_node *node)
+static void __init _register_dpll(struct clk_hw *hw,
+                                  struct device_node *node)
 {
         struct clk_hw_omap *clk_hw = to_clk_hw_omap(hw);
         struct dpll_data *dd = clk_hw->dpll_data;
@@ -151,7 +152,7 @@ static void __init ti_clk_register_dpll(struct clk_hw *hw,
         if (IS_ERR(dd->clk_ref) || IS_ERR(dd->clk_bypass)) {
                 pr_debug("clk-ref or clk-bypass missing for %s, retry later\n",
                          node->name);
-                if (!ti_clk_retry_init(node, hw, ti_clk_register_dpll))
+                if (!ti_clk_retry_init(node, hw, _register_dpll))
                         return;
 
                 goto cleanup;
@@ -175,20 +176,118 @@ cleanup:
         kfree(clk_hw);
 }
 
+#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_ATAGS)
+void __iomem *_get_reg(u8 module, u16 offset)
+{
+        u32 reg;
+        struct clk_omap_reg *reg_setup;
+
+        reg_setup = (struct clk_omap_reg *)&reg;
+
+        reg_setup->index = module;
+        reg_setup->offset = offset;
+
+        return (void __iomem *)reg;
+}
+
+struct clk *ti_clk_register_dpll(struct ti_clk *setup)
+{
+        struct clk_hw_omap *clk_hw;
+        struct clk_init_data init = { NULL };
+        struct dpll_data *dd;
+        struct clk *clk;
+        struct ti_clk_dpll *dpll;
+        const struct clk_ops *ops = &omap3_dpll_ck_ops;
+        struct clk *clk_ref;
+        struct clk *clk_bypass;
+
+        dpll = setup->data;
+
+        if (dpll->num_parents < 2)
+                return ERR_PTR(-EINVAL);
+
+        clk_ref = clk_get_sys(NULL, dpll->parents[0]);
+        clk_bypass = clk_get_sys(NULL, dpll->parents[1]);
+
+        if (IS_ERR_OR_NULL(clk_ref) || IS_ERR_OR_NULL(clk_bypass))
+                return ERR_PTR(-EAGAIN);
+
+        dd = kzalloc(sizeof(*dd), GFP_KERNEL);
+        clk_hw = kzalloc(sizeof(*clk_hw), GFP_KERNEL);
+        if (!dd || !clk_hw) {
+                clk = ERR_PTR(-ENOMEM);
+                goto cleanup;
+        }
+
+        clk_hw->dpll_data = dd;
+        clk_hw->ops = &clkhwops_omap3_dpll;
+        clk_hw->hw.init = &init;
+        clk_hw->flags = MEMMAP_ADDRESSING;
+
+        init.name = setup->name;
+        init.ops = ops;
+
+        init.num_parents = dpll->num_parents;
+        init.parent_names = dpll->parents;
+
+        dd->control_reg = _get_reg(dpll->module, dpll->control_reg);
+        dd->idlest_reg = _get_reg(dpll->module, dpll->idlest_reg);
+        dd->mult_div1_reg = _get_reg(dpll->module, dpll->mult_div1_reg);
+        dd->autoidle_reg = _get_reg(dpll->module, dpll->autoidle_reg);
+
+        dd->modes = dpll->modes;
+        dd->div1_mask = dpll->div1_mask;
+        dd->idlest_mask = dpll->idlest_mask;
+        dd->mult_mask = dpll->mult_mask;
+        dd->autoidle_mask = dpll->autoidle_mask;
+        dd->enable_mask = dpll->enable_mask;
+        dd->sddiv_mask = dpll->sddiv_mask;
+        dd->dco_mask = dpll->dco_mask;
+        dd->max_divider = dpll->max_divider;
+        dd->min_divider = dpll->min_divider;
+        dd->max_multiplier = dpll->max_multiplier;
+        dd->auto_recal_bit = dpll->auto_recal_bit;
+        dd->recal_en_bit = dpll->recal_en_bit;
+        dd->recal_st_bit = dpll->recal_st_bit;
+
+        dd->clk_ref = clk_ref;
+        dd->clk_bypass = clk_bypass;
+
+        if (dpll->flags & CLKF_CORE)
+                ops = &omap3_dpll_core_ck_ops;
+
+        if (dpll->flags & CLKF_PER)
+                ops = &omap3_dpll_per_ck_ops;
+
+        if (dpll->flags & CLKF_J_TYPE)
+                dd->flags |= DPLL_J_TYPE;
+
+        clk = clk_register(NULL, &clk_hw->hw);
+
+        if (!IS_ERR(clk))
+                return clk;
+
+cleanup:
+        kfree(dd);
+        kfree(clk_hw);
+        return clk;
+}
+#endif
+
 #if defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_SOC_OMAP5) || \
         defined(CONFIG_SOC_DRA7XX) || defined(CONFIG_SOC_AM33XX) || \
         defined(CONFIG_SOC_AM43XX)
 /**
- * ti_clk_register_dpll_x2 - Registers a DPLLx2 clock
+ * _register_dpll_x2 - Registers a DPLLx2 clock
  * @node: device node for this clock
  * @ops: clk_ops for this clock
  * @hw_ops: clk_hw_ops for this clock
  *
  * Initializes a DPLL x 2 clock from device tree data.
  */
-static void ti_clk_register_dpll_x2(struct device_node *node,
-                                    const struct clk_ops *ops,
-                                    const struct clk_hw_omap_ops *hw_ops)
+static void _register_dpll_x2(struct device_node *node,
+                              const struct clk_ops *ops,
+                              const struct clk_hw_omap_ops *hw_ops)
 {
         struct clk *clk;
         struct clk_init_data init = { NULL };
@@ -318,7 +417,7 @@ static void __init of_ti_dpll_setup(struct device_node *node,
         if (dpll_mode)
                 dd->modes = dpll_mode;
 
-        ti_clk_register_dpll(&clk_hw->hw, node);
+        _register_dpll(&clk_hw->hw, node);
         return;
 
 cleanup:
@@ -332,7 +431,7 @@ cleanup:
         defined(CONFIG_SOC_DRA7XX)
 static void __init of_ti_omap4_dpll_x2_setup(struct device_node *node)
 {
-        ti_clk_register_dpll_x2(node, &dpll_x2_ck_ops, &clkhwops_omap4_dpllmx);
+        _register_dpll_x2(node, &dpll_x2_ck_ops, &clkhwops_omap4_dpllmx);
 }
 CLK_OF_DECLARE(ti_omap4_dpll_x2_clock, "ti,omap4-dpll-x2-clock",
                of_ti_omap4_dpll_x2_setup);
@@ -341,7 +440,7 @@ CLK_OF_DECLARE(ti_omap4_dpll_x2_clock, "ti,omap4-dpll-x2-clock",
 #if defined(CONFIG_SOC_AM33XX) || defined(CONFIG_SOC_AM43XX)
 static void __init of_ti_am3_dpll_x2_setup(struct device_node *node)
 {
-        ti_clk_register_dpll_x2(node, &dpll_x2_ck_ops, NULL);
+        _register_dpll_x2(node, &dpll_x2_ck_ops, NULL);
 }
 CLK_OF_DECLARE(ti_am3_dpll_x2_clock, "ti,am3-dpll-x2-clock",
                of_ti_am3_dpll_x2_setup);
diff --git a/drivers/clk/ti/fapll.c b/drivers/clk/ti/fapll.c
new file mode 100644
index 000000000000..6ef89639a9f6
--- /dev/null
+++ b/drivers/clk/ti/fapll.c
@@ -0,0 +1,410 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/clk-provider.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/clk/ti.h>
+#include <asm/div64.h>
+
+/* FAPLL Control Register PLL_CTRL */
+#define FAPLL_MAIN_LOCK         BIT(7)
+#define FAPLL_MAIN_PLLEN        BIT(3)
+#define FAPLL_MAIN_BP           BIT(2)
+#define FAPLL_MAIN_LOC_CTL      BIT(0)
+
+/* FAPLL powerdown register PWD */
+#define FAPLL_PWD_OFFSET        4
+
+#define MAX_FAPLL_OUTPUTS       7
+#define FAPLL_MAX_RETRIES       1000
+
+#define to_fapll(_hw)           container_of(_hw, struct fapll_data, hw)
+#define to_synth(_hw)           container_of(_hw, struct fapll_synth, hw)
+
+/* The bypass bit is inverted on the ddr_pll.. */
+#define fapll_is_ddr_pll(va)    (((u32)(va) & 0xffff) == 0x0440)
+
+/*
+ * The audio_pll_clk1 input is hard wired to the 27MHz bypass clock,
+ * and the audio_pll_clk1 synthesizer is hardwared to 32KiHz output.
+ */
+#define is_ddr_pll_clk1(va)     (((u32)(va) & 0xffff) == 0x044c)
+#define is_audio_pll_clk1(va)   (((u32)(va) & 0xffff) == 0x04a8)
+
+/* Synthesizer divider register */
+#define SYNTH_LDMDIV1           BIT(8)
+
+/* Synthesizer frequency register */
+#define SYNTH_LDFREQ            BIT(31)
+
+struct fapll_data {
+        struct clk_hw hw;
+        void __iomem *base;
+        const char *name;
+        struct clk *clk_ref;
+        struct clk *clk_bypass;
+        struct clk_onecell_data outputs;
+        bool bypass_bit_inverted;
+};
+
+struct fapll_synth {
+        struct clk_hw hw;
+        struct fapll_data *fd;
+        int index;
+        void __iomem *freq;
+        void __iomem *div;
+        const char *name;
+        struct clk *clk_pll;
+};
+
+static bool ti_fapll_clock_is_bypass(struct fapll_data *fd)
+{
+        u32 v = readl_relaxed(fd->base);
+
+        if (fd->bypass_bit_inverted)
+                return !(v & FAPLL_MAIN_BP);
+        else
+                return !!(v & FAPLL_MAIN_BP);
+}
+
+static int ti_fapll_enable(struct clk_hw *hw)
+{
+        struct fapll_data *fd = to_fapll(hw);
+        u32 v = readl_relaxed(fd->base);
+
+        v |= (1 << FAPLL_MAIN_PLLEN);
+        writel_relaxed(v, fd->base);
+
+        return 0;
+}
+
+static void ti_fapll_disable(struct clk_hw *hw)
+{
+        struct fapll_data *fd = to_fapll(hw);
+        u32 v = readl_relaxed(fd->base);
+
+        v &= ~(1 << FAPLL_MAIN_PLLEN);
+        writel_relaxed(v, fd->base);
+}
+
+static int ti_fapll_is_enabled(struct clk_hw *hw)
+{
+        struct fapll_data *fd = to_fapll(hw);
+        u32 v = readl_relaxed(fd->base);
+
+        return v & (1 << FAPLL_MAIN_PLLEN);
+}
+
+static unsigned long ti_fapll_recalc_rate(struct clk_hw *hw,
+                                          unsigned long parent_rate)
+{
+        struct fapll_data *fd = to_fapll(hw);
+        u32 fapll_n, fapll_p, v;
+        long long rate;
+
+        if (ti_fapll_clock_is_bypass(fd))
+                return parent_rate;
+
+        rate = parent_rate;
+
+        /* PLL pre-divider is P and multiplier is N */
+        v = readl_relaxed(fd->base);
+        fapll_p = (v >> 8) & 0xff;
+        if (fapll_p)
+                do_div(rate, fapll_p);
+        fapll_n = v >> 16;
+        if (fapll_n)
+                rate *= fapll_n;
+
+        return rate;
+}
+
+static u8 ti_fapll_get_parent(struct clk_hw *hw)
+{
+        struct fapll_data *fd = to_fapll(hw);
+
+        if (ti_fapll_clock_is_bypass(fd))
+                return 1;
+
+        return 0;
+}
+
+static struct clk_ops ti_fapll_ops = {
+        .enable = ti_fapll_enable,
+        .disable = ti_fapll_disable,
+        .is_enabled = ti_fapll_is_enabled,
+        .recalc_rate = ti_fapll_recalc_rate,
+        .get_parent = ti_fapll_get_parent,
+};
+
+static int ti_fapll_synth_enable(struct clk_hw *hw)
+{
+        struct fapll_synth *synth = to_synth(hw);
+        u32 v = readl_relaxed(synth->fd->base + FAPLL_PWD_OFFSET);
+
+        v &= ~(1 << synth->index);
+        writel_relaxed(v, synth->fd->base + FAPLL_PWD_OFFSET);
+
+        return 0;
+}
+
+static void ti_fapll_synth_disable(struct clk_hw *hw)
+{
+        struct fapll_synth *synth = to_synth(hw);
+        u32 v = readl_relaxed(synth->fd->base + FAPLL_PWD_OFFSET);
+
+        v |= 1 << synth->index;
+        writel_relaxed(v, synth->fd->base + FAPLL_PWD_OFFSET);
+}
+
+static int ti_fapll_synth_is_enabled(struct clk_hw *hw)
+{
+        struct fapll_synth *synth = to_synth(hw);
+        u32 v = readl_relaxed(synth->fd->base + FAPLL_PWD_OFFSET);
+
+        return !(v & (1 << synth->index));
+}
+
+/*
+ * See dm816x TRM chapter 1.10.3 Flying Adder PLL fore more info
+ */
+static unsigned long ti_fapll_synth_recalc_rate(struct clk_hw *hw,
+                                                unsigned long parent_rate)
+{
+        struct fapll_synth *synth = to_synth(hw);
+        u32 synth_div_m;
+        long long rate;
+
+        /* The audio_pll_clk1 is hardwired to produce 32.768KiHz clock */
+        if (!synth->div)
+                return 32768;
+
+        /*
+         * PLL in bypass sets the synths in bypass mode too. The PLL rate
+         * can be also be set to 27MHz, so we can't use parent_rate to
+         * check for bypass mode.
+         */
+        if (ti_fapll_clock_is_bypass(synth->fd))
+                return parent_rate;
+
+        rate = parent_rate;
+
+        /*
+         * Synth frequency integer and fractional divider.
+         * Note that the phase output K is 8, so the result needs
+         * to be multiplied by 8.
+         */
+        if (synth->freq) {
+                u32 v, synth_int_div, synth_frac_div, synth_div_freq;
+
+                v = readl_relaxed(synth->freq);
+                synth_int_div = (v >> 24) & 0xf;
+                synth_frac_div = v & 0xffffff;
+                synth_div_freq = (synth_int_div * 10000000) + synth_frac_div;
+                rate *= 10000000;
+                do_div(rate, synth_div_freq);
+                rate *= 8;
+        }
+
+        /* Synth ost-divider M */
+        synth_div_m = readl_relaxed(synth->div) & 0xff;
+        do_div(rate, synth_div_m);
+
+        return rate;
+}
+
+static struct clk_ops ti_fapll_synt_ops = {
+        .enable = ti_fapll_synth_enable,
+        .disable = ti_fapll_synth_disable,
+        .is_enabled = ti_fapll_synth_is_enabled,
+        .recalc_rate = ti_fapll_synth_recalc_rate,
+};
+
+static struct clk * __init ti_fapll_synth_setup(struct fapll_data *fd,
+                                                void __iomem *freq,
+                                                void __iomem *div,
+                                                int index,
+                                                const char *name,
+                                                const char *parent,
+                                                struct clk *pll_clk)
+{
+        struct clk_init_data *init;
+        struct fapll_synth *synth;
+
+        init = kzalloc(sizeof(*init), GFP_KERNEL);
+        if (!init)
+                return ERR_PTR(-ENOMEM);
+
+        init->ops = &ti_fapll_synt_ops;
+        init->name = name;
+        init->parent_names = &parent;
+        init->num_parents = 1;
+
+        synth = kzalloc(sizeof(*synth), GFP_KERNEL);
+        if (!synth)
+                goto free;
+
+        synth->fd = fd;
+        synth->index = index;
+        synth->freq = freq;
+        synth->div = div;
+        synth->name = name;
+        synth->hw.init = init;
+        synth->clk_pll = pll_clk;
+
+        return clk_register(NULL, &synth->hw);
+
+free:
+        kfree(synth);
+        kfree(init);
+
+        return ERR_PTR(-ENOMEM);
+}
+
+static void __init ti_fapll_setup(struct device_node *node)
+{
+        struct fapll_data *fd;
+        struct clk_init_data *init = NULL;
+        const char *parent_name[2];
+        struct clk *pll_clk;
+        int i;
+
+        fd = kzalloc(sizeof(*fd), GFP_KERNEL);
+        if (!fd)
+                return;
+
+        fd->outputs.clks = kzalloc(sizeof(struct clk *) *
+                                   MAX_FAPLL_OUTPUTS + 1,
+                                   GFP_KERNEL);
+        if (!fd->outputs.clks)
+                goto free;
+
+        init = kzalloc(sizeof(*init), GFP_KERNEL);
+        if (!init)
+                goto free;
+
+        init->ops = &ti_fapll_ops;
+        init->name = node->name;
+
+        init->num_parents = of_clk_get_parent_count(node);
+        if (init->num_parents != 2) {
+                pr_err("%s must have two parents\n", node->name);
+                goto free;
+        }
+
+        parent_name[0] = of_clk_get_parent_name(node, 0);
+        parent_name[1] = of_clk_get_parent_name(node, 1);
+        init->parent_names = parent_name;
+
+        fd->clk_ref = of_clk_get(node, 0);
+        if (IS_ERR(fd->clk_ref)) {
+                pr_err("%s could not get clk_ref\n", node->name);
+                goto free;
+        }
+
+        fd->clk_bypass = of_clk_get(node, 1);
+        if (IS_ERR(fd->clk_bypass)) {
+                pr_err("%s could not get clk_bypass\n", node->name);
+                goto free;
+        }
+
+        fd->base = of_iomap(node, 0);
+        if (!fd->base) {
+                pr_err("%s could not get IO base\n", node->name);
+                goto free;
+        }
+
+        if (fapll_is_ddr_pll(fd->base))
+                fd->bypass_bit_inverted = true;
+
+        fd->name = node->name;
+        fd->hw.init = init;
+
+        /* Register the parent PLL */
+        pll_clk = clk_register(NULL, &fd->hw);
+        if (IS_ERR(pll_clk))
+                goto unmap;
+
+        fd->outputs.clks[0] = pll_clk;
+        fd->outputs.clk_num++;
+
+        /*
+         * Set up the child synthesizers starting at index 1 as the
+         * PLL output is at index 0. We need to check the clock-indices
+         * for numbering in case there are holes in the synth mapping,
+         * and then probe the synth register to see if it has a FREQ
+         * register available.
+         */
+        for (i = 0; i < MAX_FAPLL_OUTPUTS; i++) {
+                const char *output_name;
+                void __iomem *freq, *div;
+                struct clk *synth_clk;
+                int output_instance;
+                u32 v;
+
+                if (of_property_read_string_index(node, "clock-output-names",
+                                                  i, &output_name))
+                        continue;
+
+                if (of_property_read_u32_index(node, "clock-indices", i,
+                                               &output_instance))
+                        output_instance = i;
+
+                freq = fd->base + (output_instance * 8);
+                div = freq + 4;
+
+                /* Check for hardwired audio_pll_clk1 */
+                if (is_audio_pll_clk1(freq)) {
+                        freq = 0;
+                        div = 0;
+                } else {
+                        /* Does the synthesizer have a FREQ register? */
+                        v = readl_relaxed(freq);
+                        if (!v)
+                                freq = 0;
+                }
+                synth_clk = ti_fapll_synth_setup(fd, freq, div, output_instance,
+                                                 output_name, node->name,
+                                                 pll_clk);
+                if (IS_ERR(synth_clk))
+                        continue;
+
+                fd->outputs.clks[output_instance] = synth_clk;
+                fd->outputs.clk_num++;
+
+                clk_register_clkdev(synth_clk, output_name, NULL);
+        }
+
+        /* Register the child synthesizers as the FAPLL outputs */
+        of_clk_add_provider(node, of_clk_src_onecell_get, &fd->outputs);
+        /* Add clock alias for the outputs */
+
+        kfree(init);
+
+        return;
+
+unmap:
+        iounmap(fd->base);
+free:
+        if (fd->clk_bypass)
+                clk_put(fd->clk_bypass);
+        if (fd->clk_ref)
+                clk_put(fd->clk_ref);
+        kfree(fd->outputs.clks);
+        kfree(fd);
+        kfree(init);
+}
+
+CLK_OF_DECLARE(ti_fapll_clock, "ti,dm816-fapll-clock", ti_fapll_setup);
diff --git a/drivers/clk/ti/gate.c b/drivers/clk/ti/gate.c
index b326d2797feb..d493307b73f4 100644
--- a/drivers/clk/ti/gate.c
+++ b/drivers/clk/ti/gate.c
@@ -22,6 +22,8 @@
 #include <linux/of_address.h>
 #include <linux/clk/ti.h>
 
+#include "clock.h"
+
 #define to_clk_divider(_hw) container_of(_hw, struct clk_divider, hw)
 
 #undef pr_fmt
@@ -90,63 +92,164 @@ static int omap36xx_gate_clk_enable_with_hsdiv_restore(struct clk_hw *clk)
         return ret;
 }
 
-static void __init _of_ti_gate_clk_setup(struct device_node *node,
-                                         const struct clk_ops *ops,
-                                         const struct clk_hw_omap_ops *hw_ops)
+static struct clk *_register_gate(struct device *dev, const char *name,
+                                  const char *parent_name, unsigned long flags,
+                                  void __iomem *reg, u8 bit_idx,
+                                  u8 clk_gate_flags, const struct clk_ops *ops,
+                                  const struct clk_hw_omap_ops *hw_ops)
 {
-        struct clk *clk;
         struct clk_init_data init = { NULL };
         struct clk_hw_omap *clk_hw;
-        const char *clk_name = node->name;
-        const char *parent_name;
-        u32 val;
+        struct clk *clk;
 
         clk_hw = kzalloc(sizeof(*clk_hw), GFP_KERNEL);
         if (!clk_hw)
-                return;
+                return ERR_PTR(-ENOMEM);
 
         clk_hw->hw.init = &init;
 
-        init.name = clk_name;
+        init.name = name;
         init.ops = ops;
 
-        if (ops != &omap_gate_clkdm_clk_ops) {
-                clk_hw->enable_reg = ti_clk_get_reg_addr(node, 0);
-                if (!clk_hw->enable_reg)
-                        goto cleanup;
+        clk_hw->enable_reg = reg;
+        clk_hw->enable_bit = bit_idx;
+        clk_hw->ops = hw_ops;
 
-                if (!of_property_read_u32(node, "ti,bit-shift", &val))
-                        clk_hw->enable_bit = val;
+        clk_hw->flags = MEMMAP_ADDRESSING | clk_gate_flags;
+
+        init.parent_names = &parent_name;
+        init.num_parents = 1;
+
+        init.flags = flags;
+
+        clk = clk_register(NULL, &clk_hw->hw);
+
+        if (IS_ERR(clk))
+                kfree(clk_hw);
+
+        return clk;
+}
+
+#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_ATAGS)
+struct clk *ti_clk_register_gate(struct ti_clk *setup)
+{
+        const struct clk_ops *ops = &omap_gate_clk_ops;
+        const struct clk_hw_omap_ops *hw_ops = NULL;
+        u32 reg;
+        struct clk_omap_reg *reg_setup;
+        u32 flags = 0;
+        u8 clk_gate_flags = 0;
+        struct ti_clk_gate *gate;
+
+        gate = setup->data;
+
+        if (gate->flags & CLKF_INTERFACE)
+                return ti_clk_register_interface(setup);
+
+        reg_setup = (struct clk_omap_reg *)&reg;
+
+        if (gate->flags & CLKF_SET_RATE_PARENT)
+                flags |= CLK_SET_RATE_PARENT;
+
+        if (gate->flags & CLKF_SET_BIT_TO_DISABLE)
+                clk_gate_flags |= INVERT_ENABLE;
+
+        if (gate->flags & CLKF_HSDIV) {
+                ops = &omap_gate_clk_hsdiv_restore_ops;
+                hw_ops = &clkhwops_wait;
         }
 
-        clk_hw->ops = hw_ops;
+        if (gate->flags & CLKF_DSS)
+                hw_ops = &clkhwops_omap3430es2_dss_usbhost_wait;
+
+        if (gate->flags & CLKF_WAIT)
+                hw_ops = &clkhwops_wait;
+
+        if (gate->flags & CLKF_CLKDM)
+                ops = &omap_gate_clkdm_clk_ops;
+
+        if (gate->flags & CLKF_AM35XX)
+                hw_ops = &clkhwops_am35xx_ipss_module_wait;
 
-        clk_hw->flags = MEMMAP_ADDRESSING;
+        reg_setup->index = gate->module;
+        reg_setup->offset = gate->reg;
+
+        return _register_gate(NULL, setup->name, gate->parent, flags,
+                              (void __iomem *)reg, gate->bit_shift,
+                              clk_gate_flags, ops, hw_ops);
+}
+
+struct clk_hw *ti_clk_build_component_gate(struct ti_clk_gate *setup)
+{
+        struct clk_hw_omap *gate;
+        struct clk_omap_reg *reg;
+        const struct clk_hw_omap_ops *ops = &clkhwops_wait;
+
+        if (!setup)
+                return NULL;
+
+        gate = kzalloc(sizeof(*gate), GFP_KERNEL);
+        if (!gate)
+                return ERR_PTR(-ENOMEM);
+
+        reg = (struct clk_omap_reg *)&gate->enable_reg;
+        reg->index = setup->module;
+        reg->offset = setup->reg;
+
+        gate->enable_bit = setup->bit_shift;
+
+        if (setup->flags & CLKF_NO_WAIT)
+                ops = NULL;
+
+        if (setup->flags & CLKF_INTERFACE)
+                ops = &clkhwops_iclk_wait;
+
+        gate->ops = ops;
+        gate->flags = MEMMAP_ADDRESSING;
+
+        return &gate->hw;
+}
+#endif
+
+static void __init _of_ti_gate_clk_setup(struct device_node *node,
+                                         const struct clk_ops *ops,
+                                         const struct clk_hw_omap_ops *hw_ops)
+{
+        struct clk *clk;
+        const char *parent_name;
+        void __iomem *reg = NULL;
+        u8 enable_bit = 0;
+        u32 val;
+        u32 flags = 0;
+        u8 clk_gate_flags = 0;
+
+        if (ops != &omap_gate_clkdm_clk_ops) {
+                reg = ti_clk_get_reg_addr(node, 0);
+                if (!reg)
+                        return;
+
+                if (!of_property_read_u32(node, "ti,bit-shift", &val))
+                        enable_bit = val;
+        }
 
         if (of_clk_get_parent_count(node) != 1) {
-                pr_err("%s must have 1 parent\n", clk_name);
-                goto cleanup;
+                pr_err("%s must have 1 parent\n", node->name);
+                return;
         }
 
         parent_name = of_clk_get_parent_name(node, 0);
-        init.parent_names = &parent_name;
-        init.num_parents = 1;
 
         if (of_property_read_bool(node, "ti,set-rate-parent"))
-                init.flags |= CLK_SET_RATE_PARENT;
+                flags |= CLK_SET_RATE_PARENT;
 
         if (of_property_read_bool(node, "ti,set-bit-to-disable"))
-                clk_hw->flags |= INVERT_ENABLE;
+                clk_gate_flags |= INVERT_ENABLE;
 
-        clk = clk_register(NULL, &clk_hw->hw);
+        clk = _register_gate(NULL, node->name, parent_name, flags, reg,
+                             enable_bit, clk_gate_flags, ops, hw_ops);
 
-        if (!IS_ERR(clk)) {
+        if (!IS_ERR(clk))
                 of_clk_add_provider(node, of_clk_src_simple_get, clk);
-                return;
-        }
-
-cleanup:
-        kfree(clk_hw);
 }
 
 static void __init
diff --git a/drivers/clk/ti/interface.c b/drivers/clk/ti/interface.c
index 9c3e8c4aaa40..265d91f071c5 100644
--- a/drivers/clk/ti/interface.c
+++ b/drivers/clk/ti/interface.c
@@ -20,6 +20,7 @@
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/clk/ti.h>
+#include "clock.h"
 
 #undef pr_fmt
 #define pr_fmt(fmt) "%s: " fmt, __func__
@@ -31,53 +32,102 @@ static const struct clk_ops ti_interface_clk_ops = {
         .is_enabled     = &omap2_dflt_clk_is_enabled,
 };
 
-static void __init _of_ti_interface_clk_setup(struct device_node *node,
-                                              const struct clk_hw_omap_ops *ops)
+static struct clk *_register_interface(struct device *dev, const char *name,
+                                       const char *parent_name,
+                                       void __iomem *reg, u8 bit_idx,
+                                       const struct clk_hw_omap_ops *ops)
 {
-        struct clk *clk;
         struct clk_init_data init = { NULL };
         struct clk_hw_omap *clk_hw;
-        const char *parent_name;
-        u32 val;
+        struct clk *clk;
 
         clk_hw = kzalloc(sizeof(*clk_hw), GFP_KERNEL);
         if (!clk_hw)
-                return;
+                return ERR_PTR(-ENOMEM);
 
         clk_hw->hw.init = &init;
         clk_hw->ops = ops;
         clk_hw->flags = MEMMAP_ADDRESSING;
+        clk_hw->enable_reg = reg;
+        clk_hw->enable_bit = bit_idx;
 
-        clk_hw->enable_reg = ti_clk_get_reg_addr(node, 0);
-        if (!clk_hw->enable_reg)
-                goto cleanup;
-
-        if (!of_property_read_u32(node, "ti,bit-shift", &val))
-                clk_hw->enable_bit = val;
-
-        init.name = node->name;
+        init.name = name;
         init.ops = &ti_interface_clk_ops;
         init.flags = 0;
 
-        parent_name = of_clk_get_parent_name(node, 0);
-        if (!parent_name) {
-                pr_err("%s must have a parent\n", node->name);
-                goto cleanup;
-        }
-
         init.num_parents = 1;
         init.parent_names = &parent_name;
 
         clk = clk_register(NULL, &clk_hw->hw);
 
-        if (!IS_ERR(clk)) {
-                of_clk_add_provider(node, of_clk_src_simple_get, clk);
+        if (IS_ERR(clk))
+                kfree(clk_hw);
+        else
                 omap2_init_clk_hw_omap_clocks(clk);
+
+        return clk;
+}
+
+#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_ATAGS)
+struct clk *ti_clk_register_interface(struct ti_clk *setup)
+{
+        const struct clk_hw_omap_ops *ops = &clkhwops_iclk_wait;
+        u32 reg;
+        struct clk_omap_reg *reg_setup;
+        struct ti_clk_gate *gate;
+
+        gate = setup->data;
+        reg_setup = (struct clk_omap_reg *)&reg;
+        reg_setup->index = gate->module;
+        reg_setup->offset = gate->reg;
+
+        if (gate->flags & CLKF_NO_WAIT)
+                ops = &clkhwops_iclk;
+
+        if (gate->flags & CLKF_HSOTGUSB)
+                ops = &clkhwops_omap3430es2_iclk_hsotgusb_wait;
+
+        if (gate->flags & CLKF_DSS)
+                ops = &clkhwops_omap3430es2_iclk_dss_usbhost_wait;
+
+        if (gate->flags & CLKF_SSI)
+                ops = &clkhwops_omap3430es2_iclk_ssi_wait;
+
+        if (gate->flags & CLKF_AM35XX)
+                ops = &clkhwops_am35xx_ipss_wait;
+
+        return _register_interface(NULL, setup->name, gate->parent,
+                                   (void __iomem *)reg, gate->bit_shift, ops);
+}
+#endif
+
+static void __init _of_ti_interface_clk_setup(struct device_node *node,
+                                              const struct clk_hw_omap_ops *ops)
+{
+        struct clk *clk;
+        const char *parent_name;
+        void __iomem *reg;
+        u8 enable_bit = 0;
+        u32 val;
+
+        reg = ti_clk_get_reg_addr(node, 0);
+        if (!reg)
+                return;
+
+        if (!of_property_read_u32(node, "ti,bit-shift", &val))
+                enable_bit = val;
+
+        parent_name = of_clk_get_parent_name(node, 0);
+        if (!parent_name) {
+                pr_err("%s must have a parent\n", node->name);
                 return;
         }
 
-cleanup:
-        kfree(clk_hw);
+        clk = _register_interface(NULL, node->name, parent_name, reg,
+                                  enable_bit, ops);
+
+        if (!IS_ERR(clk))
+                of_clk_add_provider(node, of_clk_src_simple_get, clk);
 }
 
 static void __init of_ti_interface_clk_setup(struct device_node *node)
diff --git a/drivers/clk/ti/mux.c b/drivers/clk/ti/mux.c
index e9d650e51287..728e253606bc 100644
--- a/drivers/clk/ti/mux.c
+++ b/drivers/clk/ti/mux.c
@@ -21,6 +21,7 @@
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/clk/ti.h>
+#include "clock.h"
 
 #undef pr_fmt
 #define pr_fmt(fmt) "%s: " fmt, __func__
@@ -144,6 +145,39 @@ static struct clk *_register_mux(struct device *dev, const char *name,
         return clk;
 }
 
+struct clk *ti_clk_register_mux(struct ti_clk *setup)
+{
+        struct ti_clk_mux *mux;
+        u32 flags;
+        u8 mux_flags = 0;
+        struct clk_omap_reg *reg_setup;
+        u32 reg;
+        u32 mask;
+
+        reg_setup = (struct clk_omap_reg *)&reg;
+
+        mux = setup->data;
+        flags = CLK_SET_RATE_NO_REPARENT;
+
+        mask = mux->num_parents;
+        if (!(mux->flags & CLKF_INDEX_STARTS_AT_ONE))
+                mask--;
+
+        mask = (1 << fls(mask)) - 1;
+        reg_setup->index = mux->module;
+        reg_setup->offset = mux->reg;
+
+        if (mux->flags & CLKF_INDEX_STARTS_AT_ONE)
+                mux_flags |= CLK_MUX_INDEX_ONE;
+
+        if (mux->flags & CLKF_SET_RATE_PARENT)
+                flags |= CLK_SET_RATE_PARENT;
+
+        return _register_mux(NULL, setup->name, mux->parents, mux->num_parents,
+                             flags, (void __iomem *)reg, mux->bit_shift, mask,
+                             mux_flags, NULL, NULL);
+}
+
 /**
  * of_mux_clk_setup - Setup function for simple mux rate clock
  * @node: DT node for the clock
@@ -194,8 +228,9 @@ static void of_mux_clk_setup(struct device_node *node)
 
         mask = (1 << fls(mask)) - 1;
 
-        clk = _register_mux(NULL, node->name, parent_names, num_parents, flags,
-                            reg, shift, mask, clk_mux_flags, NULL, NULL);
+        clk = _register_mux(NULL, node->name, parent_names, num_parents,
+                            flags, reg, shift, mask, clk_mux_flags, NULL,
+                            NULL);
 
         if (!IS_ERR(clk))
                 of_clk_add_provider(node, of_clk_src_simple_get, clk);
@@ -205,6 +240,37 @@ cleanup:
 }
 CLK_OF_DECLARE(mux_clk, "ti,mux-clock", of_mux_clk_setup);
 
+struct clk_hw *ti_clk_build_component_mux(struct ti_clk_mux *setup)
+{
+        struct clk_mux *mux;
+        struct clk_omap_reg *reg;
+        int num_parents;
+
+        if (!setup)
+                return NULL;
+
+        mux = kzalloc(sizeof(*mux), GFP_KERNEL);
+        if (!mux)
+                return ERR_PTR(-ENOMEM);
+
+        reg = (struct clk_omap_reg *)&mux->reg;
+
+        mux->shift = setup->bit_shift;
+
+        reg->index = setup->module;
+        reg->offset = setup->reg;
+
+        if (setup->flags & CLKF_INDEX_STARTS_AT_ONE)
+                mux->flags |= CLK_MUX_INDEX_ONE;
+
+        num_parents = setup->num_parents;
+
+        mux->mask = num_parents - 1;
+        mux->mask = (1 << fls(mux->mask)) - 1;
+
+        return &mux->hw;
+}
+
 static void __init of_ti_composite_mux_clk_setup(struct device_node *node)
 {
         struct clk_mux *mux;
diff --git a/drivers/clk/ux500/clk-prcc.c b/drivers/clk/ux500/clk-prcc.c
index bd4769a84485..0e950769ed03 100644
--- a/drivers/clk/ux500/clk-prcc.c
+++ b/drivers/clk/ux500/clk-prcc.c
@@ -8,7 +8,6 @@
  */
 
 #include <linux/clk-provider.h>
-#include <linux/clk-private.h>
 #include <linux/slab.h>
 #include <linux/io.h>
 #include <linux/err.h>
diff --git a/drivers/clk/ux500/clk-prcmu.c b/drivers/clk/ux500/clk-prcmu.c
index e2d63bc47436..bf63c96acb1a 100644
--- a/drivers/clk/ux500/clk-prcmu.c
+++ b/drivers/clk/ux500/clk-prcmu.c
@@ -8,7 +8,6 @@
  */
 
 #include <linux/clk-provider.h>
-#include <linux/clk-private.h>
 #include <linux/mfd/dbx500-prcmu.h>
 #include <linux/slab.h>
 #include <linux/io.h>
diff --git a/drivers/clk/zynq/clkc.c b/drivers/clk/zynq/clkc.c
index 9037bebd69f7..f870aad57711 100644
--- a/drivers/clk/zynq/clkc.c
+++ b/drivers/clk/zynq/clkc.c
@@ -303,6 +303,7 @@ static void __init zynq_clk_setup(struct device_node *np)
         clks[cpu_2x] = clk_register_gate(NULL, clk_output_name[cpu_2x],
                         "cpu_2x_div", CLK_IGNORE_UNUSED, SLCR_ARM_CLK_CTRL,
                         26, 0, &armclk_lock);
+        clk_prepare_enable(clks[cpu_2x]);
 
         clk = clk_register_fixed_factor(NULL, "cpu_1x_div", "cpu_div", 0, 1,
                         4 + 2 * tmp);
diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig
index 1c2506f68122..68161f7a07d6 100644
--- a/drivers/clocksource/Kconfig
+++ b/drivers/clocksource/Kconfig
@@ -63,6 +63,11 @@ config VT8500_TIMER
 config CADENCE_TTC_TIMER
         bool
 
+config ASM9260_TIMER
+        bool
+        select CLKSRC_MMIO
+        select CLKSRC_OF
+
 config CLKSRC_NOMADIK_MTU
         bool
         depends on (ARCH_NOMADIK || ARCH_U8500)
@@ -245,15 +250,4 @@ config CLKSRC_PXA
         help
           This enables OST0 support available on PXA and SA-11x0
           platforms.
-
-config ASM9260_TIMER
-        bool "Alphascale ASM9260 timer driver"
-        depends on GENERIC_CLOCKEVENTS
-        select CLKSRC_MMIO
-        select CLKSRC_OF
-        default y if MACH_ASM9260
-        help
-          This enables build of a clocksource and clockevent driver for
-          the 32-bit System Timer hardware available on a Alphascale ASM9260.
-
 endmenu
diff --git a/drivers/clocksource/mtk_timer.c b/drivers/clocksource/mtk_timer.c
index 32a3d25795d3..68ab42356d0e 100644
--- a/drivers/clocksource/mtk_timer.c
+++ b/drivers/clocksource/mtk_timer.c
@@ -224,6 +224,8 @@ static void __init mtk_timer_init(struct device_node *node)
         }
         rate = clk_get_rate(clk);
 
+        mtk_timer_global_reset(evt);
+
         if (request_irq(evt->dev.irq, mtk_timer_interrupt,
                         IRQF_TIMER | IRQF_IRQPOLL, "mtk_timer", evt)) {
                 pr_warn("failed to setup irq %d\n", evt->dev.irq);
@@ -232,8 +234,6 @@ static void __init mtk_timer_init(struct device_node *node)
 
         evt->ticks_per_jiffy = DIV_ROUND_UP(rate, HZ);
 
-        mtk_timer_global_reset(evt);
-
         /* Configure clock source */
         mtk_timer_setup(evt, GPT_CLK_SRC, TIMER_CTRL_OP_FREERUN);
         clocksource_mmio_init(evt->gpt_base + TIMER_CNT_REG(GPT_CLK_SRC),
@@ -241,10 +241,11 @@ static void __init mtk_timer_init(struct device_node *node)
 
         /* Configure clock event */
         mtk_timer_setup(evt, GPT_CLK_EVT, TIMER_CTRL_OP_REPEAT);
-        mtk_timer_enable_irq(evt, GPT_CLK_EVT);
-
         clockevents_config_and_register(&evt->dev, rate, 0x3,
                                         0xffffffff);
+
+        mtk_timer_enable_irq(evt, GPT_CLK_EVT);
+
         return;
 
 err_clk_disable:
diff --git a/drivers/clocksource/pxa_timer.c b/drivers/clocksource/pxa_timer.c
index 941f3f344e08..d9438af2bbd6 100644
--- a/drivers/clocksource/pxa_timer.c
+++ b/drivers/clocksource/pxa_timer.c
@@ -163,7 +163,7 @@ static struct irqaction pxa_ost0_irq = {
         .dev_id         = &ckevt_pxa_osmr0,
 };
 
-static void pxa_timer_common_init(int irq, unsigned long clock_tick_rate)
+static void __init pxa_timer_common_init(int irq, unsigned long clock_tick_rate)
 {
         timer_writel(0, OIER);
         timer_writel(OSSR_M0 | OSSR_M1 | OSSR_M2 | OSSR_M3, OSSR);
diff --git a/drivers/connector/Kconfig b/drivers/connector/Kconfig
index 6e6730f9dfd1..3de5f3a9a104 100644
--- a/drivers/connector/Kconfig
+++ b/drivers/connector/Kconfig
@@ -12,7 +12,7 @@ menuconfig CONNECTOR
 if CONNECTOR
 
 config PROC_EVENTS
-        boolean "Report process events to userspace"
+        bool "Report process events to userspace"
         depends on CONNECTOR=y
         default y
         ---help---
diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm
index 0f9a2c3c0e0d..1b06fc4640e2 100644
--- a/drivers/cpufreq/Kconfig.arm
+++ b/drivers/cpufreq/Kconfig.arm
@@ -26,13 +26,21 @@ config ARM_VEXPRESS_SPC_CPUFREQ
 
 
 config ARM_EXYNOS_CPUFREQ
-        bool
+        tristate "SAMSUNG EXYNOS CPUfreq Driver"
+        depends on CPU_EXYNOS4210 || SOC_EXYNOS4212 || SOC_EXYNOS4412 || SOC_EXYNOS5250
+        depends on THERMAL
+        help
+          This adds the CPUFreq driver for Samsung EXYNOS platforms.
+          Supported SoC versions are:
+             Exynos4210, Exynos4212, Exynos4412, and Exynos5250.
+
+          If in doubt, say N.
 
 config ARM_EXYNOS4210_CPUFREQ
         bool "SAMSUNG EXYNOS4210"
         depends on CPU_EXYNOS4210
+        depends on ARM_EXYNOS_CPUFREQ
         default y
-        select ARM_EXYNOS_CPUFREQ
         help
           This adds the CPUFreq driver for Samsung EXYNOS4210
           SoC (S5PV310 or S5PC210).
@@ -42,8 +50,8 @@ config ARM_EXYNOS4210_CPUFREQ
 config ARM_EXYNOS4X12_CPUFREQ
         bool "SAMSUNG EXYNOS4x12"
         depends on SOC_EXYNOS4212 || SOC_EXYNOS4412
+        depends on ARM_EXYNOS_CPUFREQ
         default y
-        select ARM_EXYNOS_CPUFREQ
         help
           This adds the CPUFreq driver for Samsung EXYNOS4X12
           SoC (EXYNOS4212 or EXYNOS4412).
@@ -53,28 +61,14 @@ config ARM_EXYNOS4X12_CPUFREQ
 config ARM_EXYNOS5250_CPUFREQ
         bool "SAMSUNG EXYNOS5250"
         depends on SOC_EXYNOS5250
+        depends on ARM_EXYNOS_CPUFREQ
         default y
-        select ARM_EXYNOS_CPUFREQ
         help
           This adds the CPUFreq driver for Samsung EXYNOS5250
           SoC.
 
           If in doubt, say N.
 
-config ARM_EXYNOS5440_CPUFREQ
-        bool "SAMSUNG EXYNOS5440"
-        depends on SOC_EXYNOS5440
-        depends on HAVE_CLK && OF
-        select PM_OPP
-        default y
-        help
-          This adds the CPUFreq driver for Samsung EXYNOS5440
-          SoC. The nature of exynos5440 clock controller is
-          different than previous exynos controllers so not using
-          the common exynos framework.
-
-          If in doubt, say N.
-
 config ARM_EXYNOS_CPU_FREQ_BOOST_SW
         bool "EXYNOS Frequency Overclocking - Software"
         depends on ARM_EXYNOS_CPUFREQ && THERMAL
@@ -90,6 +84,20 @@ config ARM_EXYNOS_CPU_FREQ_BOOST_SW
 
           If in doubt, say N.
 
+config ARM_EXYNOS5440_CPUFREQ
+        tristate "SAMSUNG EXYNOS5440"
+        depends on SOC_EXYNOS5440
+        depends on HAVE_CLK && OF
+        select PM_OPP
+        default y
+        help
+          This adds the CPUFreq driver for Samsung EXYNOS5440
+          SoC. The nature of exynos5440 clock controller is
+          different than previous exynos controllers so not using
+          the common exynos framework.
+
+          If in doubt, say N.
+
 config ARM_HIGHBANK_CPUFREQ
         tristate "Calxeda Highbank-based"
         depends on ARCH_HIGHBANK && CPUFREQ_DT && REGULATOR
diff --git a/drivers/cpufreq/Kconfig.powerpc b/drivers/cpufreq/Kconfig.powerpc
index 72564b701b4a..7ea24413cee6 100644
--- a/drivers/cpufreq/Kconfig.powerpc
+++ b/drivers/cpufreq/Kconfig.powerpc
@@ -26,7 +26,7 @@ config CPU_FREQ_MAPLE
 config PPC_CORENET_CPUFREQ
         tristate "CPU frequency scaling driver for Freescale E500MC SoCs"
         depends on PPC_E500MC && OF && COMMON_CLK
-        select CLK_PPC_CORENET
+        select CLK_QORIQ
         help
           This adds the CPUFreq driver support for Freescale e500mc,
           e5500 and e6500 series SoCs which are capable of changing
diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile
index 8b4220ac888b..82a1821471fd 100644
--- a/drivers/cpufreq/Makefile
+++ b/drivers/cpufreq/Makefile
@@ -52,10 +52,11 @@ obj-$(CONFIG_ARM_DT_BL_CPUFREQ)		+= arm_big_little_dt.o
 
 obj-$(CONFIG_ARCH_DAVINCI)              += davinci-cpufreq.o
 obj-$(CONFIG_UX500_SOC_DB8500)          += dbx500-cpufreq.o
-obj-$(CONFIG_ARM_EXYNOS_CPUFREQ)        += exynos-cpufreq.o
-obj-$(CONFIG_ARM_EXYNOS4210_CPUFREQ)    += exynos4210-cpufreq.o
-obj-$(CONFIG_ARM_EXYNOS4X12_CPUFREQ)    += exynos4x12-cpufreq.o
-obj-$(CONFIG_ARM_EXYNOS5250_CPUFREQ)    += exynos5250-cpufreq.o
+obj-$(CONFIG_ARM_EXYNOS_CPUFREQ)        += arm-exynos-cpufreq.o
+arm-exynos-cpufreq-y                                    := exynos-cpufreq.o
+arm-exynos-cpufreq-$(CONFIG_ARM_EXYNOS4210_CPUFREQ)     += exynos4210-cpufreq.o
+arm-exynos-cpufreq-$(CONFIG_ARM_EXYNOS4X12_CPUFREQ)     += exynos4x12-cpufreq.o
+arm-exynos-cpufreq-$(CONFIG_ARM_EXYNOS5250_CPUFREQ)     += exynos5250-cpufreq.o
 obj-$(CONFIG_ARM_EXYNOS5440_CPUFREQ)    += exynos5440-cpufreq.o
 obj-$(CONFIG_ARM_HIGHBANK_CPUFREQ)      += highbank-cpufreq.o
 obj-$(CONFIG_ARM_IMX6Q_CPUFREQ)         += imx6q-cpufreq.o
diff --git a/drivers/cpufreq/exynos-cpufreq.c b/drivers/cpufreq/exynos-cpufreq.c
index f99a0b0b7c06..5e98c6b1f284 100644
--- a/drivers/cpufreq/exynos-cpufreq.c
+++ b/drivers/cpufreq/exynos-cpufreq.c
@@ -18,10 +18,13 @@
 #include <linux/cpufreq.h>
 #include <linux/platform_device.h>
 #include <linux/of.h>
+#include <linux/cpu_cooling.h>
+#include <linux/cpu.h>
 
 #include "exynos-cpufreq.h"
 
 static struct exynos_dvfs_info *exynos_info;
+static struct thermal_cooling_device *cdev;
 static struct regulator *arm_regulator;
 static unsigned int locking_frequency;
 
@@ -156,6 +159,7 @@ static struct cpufreq_driver exynos_driver = {
 
 static int exynos_cpufreq_probe(struct platform_device *pdev)
 {
+        struct device_node *cpus, *np;
         int ret = -EINVAL;
 
         exynos_info = kzalloc(sizeof(*exynos_info), GFP_KERNEL);
@@ -198,9 +202,36 @@ static int exynos_cpufreq_probe(struct platform_device *pdev)
         /* Done here as we want to capture boot frequency */
         locking_frequency = clk_get_rate(exynos_info->cpu_clk) / 1000;
 
-        if (!cpufreq_register_driver(&exynos_driver))
+        ret = cpufreq_register_driver(&exynos_driver);
+        if (ret)
+                goto err_cpufreq_reg;
+
+        cpus = of_find_node_by_path("/cpus");
+        if (!cpus) {
+                pr_err("failed to find cpus node\n");
+                return 0;
+        }
+
+        np = of_get_next_child(cpus, NULL);
+        if (!np) {
+                pr_err("failed to find cpus child node\n");
+                of_node_put(cpus);
                 return 0;
+        }
+
+        if (of_find_property(np, "#cooling-cells", NULL)) {
+                cdev = of_cpufreq_cooling_register(np,
+                                                   cpu_present_mask);
+                if (IS_ERR(cdev))
+                        pr_err("running cpufreq without cooling device: %ld\n",
+                               PTR_ERR(cdev));
+        }
+        of_node_put(np);
+        of_node_put(cpus);
+
+        return 0;
 
+err_cpufreq_reg:
         dev_err(&pdev->dev, "failed to register cpufreq driver\n");
         regulator_put(arm_regulator);
 err_vdd_arm:
diff --git a/drivers/cpufreq/s3c2416-cpufreq.c b/drivers/cpufreq/s3c2416-cpufreq.c
index 2fd53eaaec20..d6d425773fa4 100644
--- a/drivers/cpufreq/s3c2416-cpufreq.c
+++ b/drivers/cpufreq/s3c2416-cpufreq.c
@@ -263,7 +263,7 @@ out:
 }
 
 #ifdef CONFIG_ARM_S3C2416_CPUFREQ_VCORESCALE
-static void __init s3c2416_cpufreq_cfg_regulator(struct s3c2416_data *s3c_freq)
+static void s3c2416_cpufreq_cfg_regulator(struct s3c2416_data *s3c_freq)
 {
         int count, v, i, found;
         struct cpufreq_frequency_table *pos;
@@ -333,7 +333,7 @@ static struct notifier_block s3c2416_cpufreq_reboot_notifier = {
         .notifier_call = s3c2416_cpufreq_reboot_notifier_evt,
 };
 
-static int __init s3c2416_cpufreq_driver_init(struct cpufreq_policy *policy)
+static int s3c2416_cpufreq_driver_init(struct cpufreq_policy *policy)
 {
         struct s3c2416_data *s3c_freq = &s3c2416_cpufreq;
         struct cpufreq_frequency_table *pos;
diff --git a/drivers/cpufreq/s3c24xx-cpufreq.c b/drivers/cpufreq/s3c24xx-cpufreq.c
index d00f1cee4509..733aa5153e74 100644
--- a/drivers/cpufreq/s3c24xx-cpufreq.c
+++ b/drivers/cpufreq/s3c24xx-cpufreq.c
@@ -144,11 +144,6 @@ static void s3c_cpufreq_setfvco(struct s3c_cpufreq_config *cfg)
         (cfg->info->set_fvco)(cfg);
 }
 
-static inline void s3c_cpufreq_resume_clocks(void)
-{
-        cpu_cur.info->resume_clocks();
-}
-
 static inline void s3c_cpufreq_updateclk(struct clk *clk,
                                          unsigned int freq)
 {
@@ -417,9 +412,6 @@ static int s3c_cpufreq_resume(struct cpufreq_policy *policy)
 
         last_target = ~0;       /* invalidate last_target setting */
 
-        /* first, find out what speed we resumed at. */
-        s3c_cpufreq_resume_clocks();
-
         /* whilst we will be called later on, we try and re-set the
          * cpu frequencies as soon as possible so that we do not end
          * up resuming devices and then immediately having to re-set
@@ -454,7 +446,7 @@ static struct cpufreq_driver s3c24xx_driver = {
 };
 
 
-int __init s3c_cpufreq_register(struct s3c_cpufreq_info *info)
+int s3c_cpufreq_register(struct s3c_cpufreq_info *info)
 {
         if (!info || !info->name) {
                 printk(KERN_ERR "%s: failed to pass valid information\n",
diff --git a/drivers/cpuidle/cpuidle-powernv.c b/drivers/cpuidle/cpuidle-powernv.c
index aedec0957934..59372077ec7c 100644
--- a/drivers/cpuidle/cpuidle-powernv.c
+++ b/drivers/cpuidle/cpuidle-powernv.c
@@ -13,6 +13,7 @@
 #include <linux/notifier.h>
 #include <linux/clockchips.h>
 #include <linux/of.h>
+#include <linux/slab.h>
 
 #include <asm/machdep.h>
 #include <asm/firmware.h>
@@ -158,70 +159,83 @@ static int powernv_add_idle_states(void)
         struct device_node *power_mgt;
         int nr_idle_states = 1; /* Snooze */
         int dt_idle_states;
-        const __be32 *idle_state_flags;
-        const __be32 *idle_state_latency;
-        u32 len_flags, flags, latency_ns;
-        int i;
+        u32 *latency_ns, *residency_ns, *flags;
+        int i, rc;
 
         /* Currently we have snooze statically defined */
 
         power_mgt = of_find_node_by_path("/ibm,opal/power-mgt");
         if (!power_mgt) {
                 pr_warn("opal: PowerMgmt Node not found\n");
-                return nr_idle_states;
+                goto out;
         }
 
-        idle_state_flags = of_get_property(power_mgt, "ibm,cpu-idle-state-flags", &len_flags);
-        if (!idle_state_flags) {
-                pr_warn("DT-PowerMgmt: missing ibm,cpu-idle-state-flags\n");
-                return nr_idle_states;
+        /* Read values of any property to determine the num of idle states */
+        dt_idle_states = of_property_count_u32_elems(power_mgt, "ibm,cpu-idle-state-flags");
+        if (dt_idle_states < 0) {
+                pr_warn("cpuidle-powernv: no idle states found in the DT\n");
+                goto out;
         }
 
-        idle_state_latency = of_get_property(power_mgt,
-                        "ibm,cpu-idle-state-latencies-ns", NULL);
-        if (!idle_state_latency) {
-                pr_warn("DT-PowerMgmt: missing ibm,cpu-idle-state-latencies-ns\n");
-                return nr_idle_states;
+        flags = kzalloc(sizeof(*flags) * dt_idle_states, GFP_KERNEL);
+        if (of_property_read_u32_array(power_mgt,
+                        "ibm,cpu-idle-state-flags", flags, dt_idle_states)) {
+                pr_warn("cpuidle-powernv : missing ibm,cpu-idle-state-flags in DT\n");
+                goto out_free_flags;
         }
 
-        dt_idle_states = len_flags / sizeof(u32);
+        latency_ns = kzalloc(sizeof(*latency_ns) * dt_idle_states, GFP_KERNEL);
+        rc = of_property_read_u32_array(power_mgt,
+                "ibm,cpu-idle-state-latencies-ns", latency_ns, dt_idle_states);
+        if (rc) {
+                pr_warn("cpuidle-powernv: missing ibm,cpu-idle-state-latencies-ns in DT\n");
+                goto out_free_latency;
+        }
 
-        for (i = 0; i < dt_idle_states; i++) {
+        residency_ns = kzalloc(sizeof(*residency_ns) * dt_idle_states, GFP_KERNEL);
+        rc = of_property_read_u32_array(power_mgt,
+                "ibm,cpu-idle-state-residency-ns", residency_ns, dt_idle_states);
 
-                flags = be32_to_cpu(idle_state_flags[i]);
+        for (i = 0; i < dt_idle_states; i++) {
 
-                /* Cpuidle accepts exit_latency in us and we estimate
-                 * target residency to be 10x exit_latency
+                /*
+                 * Cpuidle accepts exit_latency and target_residency in us.
+                 * Use default target_residency values if f/w does not expose it.
                  */
-                latency_ns = be32_to_cpu(idle_state_latency[i]);
-                if (flags & OPAL_PM_NAP_ENABLED) {
+                if (flags[i] & OPAL_PM_NAP_ENABLED) {
                         /* 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 = 0;
-                        powernv_states[nr_idle_states].exit_latency =
-                                        ((unsigned int)latency_ns) / 1000;
-                        powernv_states[nr_idle_states].target_residency =
-                                        ((unsigned int)latency_ns / 100);
+                        powernv_states[nr_idle_states].target_residency = 100;
                         powernv_states[nr_idle_states].enter = &nap_loop;
-                        nr_idle_states++;
-                }
-
-                if (flags & OPAL_PM_SLEEP_ENABLED ||
-                        flags & OPAL_PM_SLEEP_ENABLED_ER1) {
+                } else if (flags[i] & OPAL_PM_SLEEP_ENABLED ||
+                        flags[i] & OPAL_PM_SLEEP_ENABLED_ER1) {
                         /* 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_TIMER_STOP;
-                        powernv_states[nr_idle_states].exit_latency =
-                                        ((unsigned int)latency_ns) / 1000;
-                        powernv_states[nr_idle_states].target_residency =
-                                        ((unsigned int)latency_ns / 100);
+                        powernv_states[nr_idle_states].target_residency = 300000;
                         powernv_states[nr_idle_states].enter = &fastsleep_loop;
-                        nr_idle_states++;
                 }
+
+                powernv_states[nr_idle_states].exit_latency =
+                                ((unsigned int)latency_ns[i]) / 1000;
+
+                if (!rc) {
+                        powernv_states[nr_idle_states].target_residency =
+                                ((unsigned int)residency_ns[i]) / 1000;
+                }
+
+                nr_idle_states++;
         }
 
+        kfree(residency_ns);
+out_free_latency:
+        kfree(latency_ns);
+out_free_flags:
+        kfree(flags);
+out:
         return nr_idle_states;
 }
 
diff --git a/drivers/crypto/ux500/cryp/cryp_core.c b/drivers/crypto/ux500/cryp/cryp_core.c
index d594ae962ed2..fded0a5cfcd7 100644
--- a/drivers/crypto/ux500/cryp/cryp_core.c
+++ b/drivers/crypto/ux500/cryp/cryp_core.c
@@ -606,12 +606,12 @@ static void cryp_dma_done(struct cryp_ctx *ctx)
         dev_dbg(ctx->device->dev, "[%s]: ", __func__);
 
         chan = ctx->device->dma.chan_mem2cryp;
-        dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
+        dmaengine_terminate_all(chan);
         dma_unmap_sg(chan->device->dev, ctx->device->dma.sg_src,
                      ctx->device->dma.sg_src_len, DMA_TO_DEVICE);
 
         chan = ctx->device->dma.chan_cryp2mem;
-        dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
+        dmaengine_terminate_all(chan);
         dma_unmap_sg(chan->device->dev, ctx->device->dma.sg_dst,
                      ctx->device->dma.sg_dst_len, DMA_FROM_DEVICE);
 }
diff --git a/drivers/crypto/ux500/hash/hash_core.c b/drivers/crypto/ux500/hash/hash_core.c
index 70a20871e998..187a8fd7eee7 100644
--- a/drivers/crypto/ux500/hash/hash_core.c
+++ b/drivers/crypto/ux500/hash/hash_core.c
@@ -202,7 +202,7 @@ static void hash_dma_done(struct hash_ctx *ctx)
         struct dma_chan *chan;
 
         chan = ctx->device->dma.chan_mem2hash;
-        dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
+        dmaengine_terminate_all(chan);
         dma_unmap_sg(chan->device->dev, ctx->device->dma.sg,
                      ctx->device->dma.sg_len, DMA_TO_DEVICE);
 }
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index faf30a4e642b..a874b6ec6650 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -416,6 +416,15 @@ config NBPFAXI_DMA
         help
           Support for "Type-AXI" NBPF DMA IPs from Renesas
 
+config IMG_MDC_DMA
+        tristate "IMG MDC support"
+        depends on MIPS || COMPILE_TEST
+        depends on MFD_SYSCON
+        select DMA_ENGINE
+        select DMA_VIRTUAL_CHANNELS
+        help
+          Enable support for the IMG multi-threaded DMA controller (MDC).
+
 config DMA_ENGINE
         bool
 
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index 2022b5451377..f915f61ec574 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -19,7 +19,7 @@ obj-$(CONFIG_AT_HDMAC) += at_hdmac.o
 obj-$(CONFIG_AT_XDMAC) += at_xdmac.o
 obj-$(CONFIG_MX3_IPU) += ipu/
 obj-$(CONFIG_TXX9_DMAC) += txx9dmac.o
-obj-$(CONFIG_SH_DMAE_BASE) += sh/
+obj-$(CONFIG_RENESAS_DMA) += sh/
 obj-$(CONFIG_COH901318) += coh901318.o coh901318_lli.o
 obj-$(CONFIG_AMCC_PPC440SPE_ADMA) += ppc4xx/
 obj-$(CONFIG_IMX_SDMA) += imx-sdma.o
@@ -50,3 +50,4 @@ obj-y += xilinx/
 obj-$(CONFIG_INTEL_MIC_X100_DMA) += mic_x100_dma.o
 obj-$(CONFIG_NBPFAXI_DMA) += nbpfaxi.o
 obj-$(CONFIG_DMA_SUN6I) += sun6i-dma.o
+obj-$(CONFIG_IMG_MDC_DMA) += img-mdc-dma.o
diff --git a/drivers/dma/amba-pl08x.c b/drivers/dma/amba-pl08x.c
index 1364d00881dd..4a5fd245014e 100644
--- a/drivers/dma/amba-pl08x.c
+++ b/drivers/dma/amba-pl08x.c
@@ -1386,32 +1386,6 @@ static u32 pl08x_get_cctl(struct pl08x_dma_chan *plchan,
         return pl08x_cctl(cctl);
 }
 
-static int dma_set_runtime_config(struct dma_chan *chan,
-                                  struct dma_slave_config *config)
-{
-        struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
-        struct pl08x_driver_data *pl08x = plchan->host;
-
-        if (!plchan->slave)
-                return -EINVAL;
-
-        /* Reject definitely invalid configurations */
-        if (config->src_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES ||
-            config->dst_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES)
-                return -EINVAL;
-
-        if (config->device_fc && pl08x->vd->pl080s) {
-                dev_err(&pl08x->adev->dev,
-                        "%s: PL080S does not support peripheral flow control\n",
-                        __func__);
-                return -EINVAL;
-        }
-
-        plchan->cfg = *config;
-
-        return 0;
-}
-
 /*
  * Slave transactions callback to the slave device to allow
  * synchronization of slave DMA signals with the DMAC enable
@@ -1693,20 +1667,71 @@ static struct dma_async_tx_descriptor *pl08x_prep_dma_cyclic(
         return vchan_tx_prep(&plchan->vc, &txd->vd, flags);
 }
 
-static int pl08x_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                         unsigned long arg)
+static int pl08x_config(struct dma_chan *chan,
+                        struct dma_slave_config *config)
+{
+        struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
+        struct pl08x_driver_data *pl08x = plchan->host;
+
+        if (!plchan->slave)
+                return -EINVAL;
+
+        /* Reject definitely invalid configurations */
+        if (config->src_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES ||
+            config->dst_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES)
+                return -EINVAL;
+
+        if (config->device_fc && pl08x->vd->pl080s) {
+                dev_err(&pl08x->adev->dev,
+                        "%s: PL080S does not support peripheral flow control\n",
+                        __func__);
+                return -EINVAL;
+        }
+
+        plchan->cfg = *config;
+
+        return 0;
+}
+
+static int pl08x_terminate_all(struct dma_chan *chan)
 {
         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
         struct pl08x_driver_data *pl08x = plchan->host;
         unsigned long flags;
-        int ret = 0;
 
-        /* Controls applicable to inactive channels */
-        if (cmd == DMA_SLAVE_CONFIG) {
-                return dma_set_runtime_config(chan,
-                                              (struct dma_slave_config *)arg);
+        spin_lock_irqsave(&plchan->vc.lock, flags);
+        if (!plchan->phychan && !plchan->at) {
+                spin_unlock_irqrestore(&plchan->vc.lock, flags);
+                return 0;
         }
 
+        plchan->state = PL08X_CHAN_IDLE;
+
+        if (plchan->phychan) {
+                /*
+                 * Mark physical channel as free and free any slave
+                 * signal
+                 */
+                pl08x_phy_free(plchan);
+        }
+        /* Dequeue jobs and free LLIs */
+        if (plchan->at) {
+                pl08x_desc_free(&plchan->at->vd);
+                plchan->at = NULL;
+        }
+        /* Dequeue jobs not yet fired as well */
+        pl08x_free_txd_list(pl08x, plchan);
+
+        spin_unlock_irqrestore(&plchan->vc.lock, flags);
+
+        return 0;
+}
+
+static int pl08x_pause(struct dma_chan *chan)
+{
+        struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
+        unsigned long flags;
+
         /*
          * Anything succeeds on channels with no physical allocation and
          * no queued transfers.
@@ -1717,42 +1742,35 @@ static int pl08x_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
                 return 0;
         }
 
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                plchan->state = PL08X_CHAN_IDLE;
+        pl08x_pause_phy_chan(plchan->phychan);
+        plchan->state = PL08X_CHAN_PAUSED;
 
-                if (plchan->phychan) {
-                        /*
-                         * Mark physical channel as free and free any slave
-                         * signal
-                         */
-                        pl08x_phy_free(plchan);
-                }
-                /* Dequeue jobs and free LLIs */
-                if (plchan->at) {
-                        pl08x_desc_free(&plchan->at->vd);
-                        plchan->at = NULL;
-                }
-                /* Dequeue jobs not yet fired as well */
-                pl08x_free_txd_list(pl08x, plchan);
-                break;
-        case DMA_PAUSE:
-                pl08x_pause_phy_chan(plchan->phychan);
-                plchan->state = PL08X_CHAN_PAUSED;
-                break;
-        case DMA_RESUME:
-                pl08x_resume_phy_chan(plchan->phychan);
-                plchan->state = PL08X_CHAN_RUNNING;
-                break;
-        default:
-                /* Unknown command */
-                ret = -ENXIO;
-                break;
+        spin_unlock_irqrestore(&plchan->vc.lock, flags);
+
+        return 0;
+}
+
+static int pl08x_resume(struct dma_chan *chan)
+{
+        struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
+        unsigned long flags;
+
+        /*
+         * Anything succeeds on channels with no physical allocation and
+         * no queued transfers.
+         */
+        spin_lock_irqsave(&plchan->vc.lock, flags);
+        if (!plchan->phychan && !plchan->at) {
+                spin_unlock_irqrestore(&plchan->vc.lock, flags);
+                return 0;
         }
 
+        pl08x_resume_phy_chan(plchan->phychan);
+        plchan->state = PL08X_CHAN_RUNNING;
+
         spin_unlock_irqrestore(&plchan->vc.lock, flags);
 
-        return ret;
+        return 0;
 }
 
 bool pl08x_filter_id(struct dma_chan *chan, void *chan_id)
@@ -2048,7 +2066,10 @@ static int pl08x_probe(struct amba_device *adev, const struct amba_id *id)
         pl08x->memcpy.device_prep_dma_interrupt = pl08x_prep_dma_interrupt;
         pl08x->memcpy.device_tx_status = pl08x_dma_tx_status;
         pl08x->memcpy.device_issue_pending = pl08x_issue_pending;
-        pl08x->memcpy.device_control = pl08x_control;
+        pl08x->memcpy.device_config = pl08x_config;
+        pl08x->memcpy.device_pause = pl08x_pause;
+        pl08x->memcpy.device_resume = pl08x_resume;
+        pl08x->memcpy.device_terminate_all = pl08x_terminate_all;
 
         /* Initialize slave engine */
         dma_cap_set(DMA_SLAVE, pl08x->slave.cap_mask);
@@ -2061,7 +2082,10 @@ static int pl08x_probe(struct amba_device *adev, const struct amba_id *id)
         pl08x->slave.device_issue_pending = pl08x_issue_pending;
         pl08x->slave.device_prep_slave_sg = pl08x_prep_slave_sg;
         pl08x->slave.device_prep_dma_cyclic = pl08x_prep_dma_cyclic;
-        pl08x->slave.device_control = pl08x_control;
+        pl08x->slave.device_config = pl08x_config;
+        pl08x->slave.device_pause = pl08x_pause;
+        pl08x->slave.device_resume = pl08x_resume;
+        pl08x->slave.device_terminate_all = pl08x_terminate_all;
 
         /* Get the platform data */
         pl08x->pd = dev_get_platdata(&adev->dev);
diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c
index ca9dd2613283..1e1a4c567542 100644
--- a/drivers/dma/at_hdmac.c
+++ b/drivers/dma/at_hdmac.c
@@ -42,6 +42,11 @@
 #define ATC_DEFAULT_CFG         (ATC_FIFOCFG_HALFFIFO)
 #define ATC_DEFAULT_CTRLB       (ATC_SIF(AT_DMA_MEM_IF) \
                                 |ATC_DIF(AT_DMA_MEM_IF))
+#define ATC_DMA_BUSWIDTHS\
+        (BIT(DMA_SLAVE_BUSWIDTH_UNDEFINED) |\
+        BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |\
+        BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) |\
+        BIT(DMA_SLAVE_BUSWIDTH_4_BYTES))
 
 /*
  * Initial number of descriptors to allocate for each channel. This could
@@ -972,11 +977,13 @@ err_out:
         return NULL;
 }
 
-static int set_runtime_config(struct dma_chan *chan,
-                              struct dma_slave_config *sconfig)
+static int atc_config(struct dma_chan *chan,
+                      struct dma_slave_config *sconfig)
 {
         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
 
+        dev_vdbg(chan2dev(chan), "%s\n", __func__);
+
         /* Check if it is chan is configured for slave transfers */
         if (!chan->private)
                 return -EINVAL;
@@ -989,9 +996,28 @@ static int set_runtime_config(struct dma_chan *chan,
         return 0;
 }
 
+static int atc_pause(struct dma_chan *chan)
+{
+        struct at_dma_chan      *atchan = to_at_dma_chan(chan);
+        struct at_dma           *atdma = to_at_dma(chan->device);
+        int                     chan_id = atchan->chan_common.chan_id;
+        unsigned long           flags;
 
-static int atc_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                       unsigned long arg)
+        LIST_HEAD(list);
+
+        dev_vdbg(chan2dev(chan), "%s\n", __func__);
+
+        spin_lock_irqsave(&atchan->lock, flags);
+
+        dma_writel(atdma, CHER, AT_DMA_SUSP(chan_id));
+        set_bit(ATC_IS_PAUSED, &atchan->status);
+
+        spin_unlock_irqrestore(&atchan->lock, flags);
+
+        return 0;
+}
+
+static int atc_resume(struct dma_chan *chan)
 {
         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
         struct at_dma           *atdma = to_at_dma(chan->device);
@@ -1000,60 +1026,61 @@ static int atc_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
 
         LIST_HEAD(list);
 
-        dev_vdbg(chan2dev(chan), "atc_control (%d)\n", cmd);
+        dev_vdbg(chan2dev(chan), "%s\n", __func__);
 
-        if (cmd == DMA_PAUSE) {
-                spin_lock_irqsave(&atchan->lock, flags);
+        if (!atc_chan_is_paused(atchan))
+                return 0;
 
-                dma_writel(atdma, CHER, AT_DMA_SUSP(chan_id));
-                set_bit(ATC_IS_PAUSED, &atchan->status);
+        spin_lock_irqsave(&atchan->lock, flags);
 
-                spin_unlock_irqrestore(&atchan->lock, flags);
-        } else if (cmd == DMA_RESUME) {
-                if (!atc_chan_is_paused(atchan))
-                        return 0;
+        dma_writel(atdma, CHDR, AT_DMA_RES(chan_id));
+        clear_bit(ATC_IS_PAUSED, &atchan->status);
 
-                spin_lock_irqsave(&atchan->lock, flags);
+        spin_unlock_irqrestore(&atchan->lock, flags);
 
-                dma_writel(atdma, CHDR, AT_DMA_RES(chan_id));
-                clear_bit(ATC_IS_PAUSED, &atchan->status);
+        return 0;
+}
 
-                spin_unlock_irqrestore(&atchan->lock, flags);
-        } else if (cmd == DMA_TERMINATE_ALL) {
-                struct at_desc  *desc, *_desc;
-                /*
-                 * This is only called when something went wrong elsewhere, so
-                 * we don't really care about the data. Just disable the
-                 * channel. We still have to poll the channel enable bit due
-                 * to AHB/HSB limitations.
-                 */
-                spin_lock_irqsave(&atchan->lock, flags);
+static int atc_terminate_all(struct dma_chan *chan)
+{
+        struct at_dma_chan      *atchan = to_at_dma_chan(chan);
+        struct at_dma           *atdma = to_at_dma(chan->device);
+        int                     chan_id = atchan->chan_common.chan_id;
+        struct at_desc          *desc, *_desc;
+        unsigned long           flags;
 
-                /* disabling channel: must also remove suspend state */
-                dma_writel(atdma, CHDR, AT_DMA_RES(chan_id) | atchan->mask);
+        LIST_HEAD(list);
 
-                /* confirm that this channel is disabled */
-                while (dma_readl(atdma, CHSR) & atchan->mask)
-                        cpu_relax();
+        dev_vdbg(chan2dev(chan), "%s\n", __func__);
 
-                /* active_list entries will end up before queued entries */
-                list_splice_init(&atchan->queue, &list);
-                list_splice_init(&atchan->active_list, &list);
+        /*
+         * This is only called when something went wrong elsewhere, so
+         * we don't really care about the data. Just disable the
+         * channel. We still have to poll the channel enable bit due
+         * to AHB/HSB limitations.
+         */
+        spin_lock_irqsave(&atchan->lock, flags);
 
-                /* Flush all pending and queued descriptors */
-                list_for_each_entry_safe(desc, _desc, &list, desc_node)
-                        atc_chain_complete(atchan, desc);
+        /* disabling channel: must also remove suspend state */
+        dma_writel(atdma, CHDR, AT_DMA_RES(chan_id) | atchan->mask);
 
-                clear_bit(ATC_IS_PAUSED, &atchan->status);
-                /* if channel dedicated to cyclic operations, free it */
-                clear_bit(ATC_IS_CYCLIC, &atchan->status);
+        /* confirm that this channel is disabled */
+        while (dma_readl(atdma, CHSR) & atchan->mask)
+                cpu_relax();
 
-                spin_unlock_irqrestore(&atchan->lock, flags);
-        } else if (cmd == DMA_SLAVE_CONFIG) {
-                return set_runtime_config(chan, (struct dma_slave_config *)arg);
-        } else {
-                return -ENXIO;
-        }
+        /* active_list entries will end up before queued entries */
+        list_splice_init(&atchan->queue, &list);
+        list_splice_init(&atchan->active_list, &list);
+
+        /* Flush all pending and queued descriptors */
+        list_for_each_entry_safe(desc, _desc, &list, desc_node)
+                atc_chain_complete(atchan, desc);
+
+        clear_bit(ATC_IS_PAUSED, &atchan->status);
+        /* if channel dedicated to cyclic operations, free it */
+        clear_bit(ATC_IS_CYCLIC, &atchan->status);
+
+        spin_unlock_irqrestore(&atchan->lock, flags);
 
         return 0;
 }
@@ -1505,7 +1532,14 @@ static int __init at_dma_probe(struct platform_device *pdev)
                 /* controller can do slave DMA: can trigger cyclic transfers */
                 dma_cap_set(DMA_CYCLIC, atdma->dma_common.cap_mask);
                 atdma->dma_common.device_prep_dma_cyclic = atc_prep_dma_cyclic;
-                atdma->dma_common.device_control = atc_control;
+                atdma->dma_common.device_config = atc_config;
+                atdma->dma_common.device_pause = atc_pause;
+                atdma->dma_common.device_resume = atc_resume;
+                atdma->dma_common.device_terminate_all = atc_terminate_all;
+                atdma->dma_common.src_addr_widths = ATC_DMA_BUSWIDTHS;
+                atdma->dma_common.dst_addr_widths = ATC_DMA_BUSWIDTHS;
+                atdma->dma_common.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+                atdma->dma_common.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
         }
 
         dma_writel(atdma, EN, AT_DMA_ENABLE);
@@ -1622,7 +1656,7 @@ static void atc_suspend_cyclic(struct at_dma_chan *atchan)
         if (!atc_chan_is_paused(atchan)) {
                 dev_warn(chan2dev(chan),
                 "cyclic channel not paused, should be done by channel user\n");
-                atc_control(chan, DMA_PAUSE, 0);
+                atc_pause(chan);
         }
 
         /* now preserve additional data for cyclic operations */
diff --git a/drivers/dma/at_hdmac_regs.h b/drivers/dma/at_hdmac_regs.h
index 2787aba60c6b..d6bba6c636c2 100644
--- a/drivers/dma/at_hdmac_regs.h
+++ b/drivers/dma/at_hdmac_regs.h
@@ -232,7 +232,8 @@ enum atc_status {
  * @save_dscr: for cyclic operations, preserve next descriptor address in
  *             the cyclic list on suspend/resume cycle
  * @remain_desc: to save remain desc length
- * @dma_sconfig: configuration for slave transfers, passed via DMA_SLAVE_CONFIG
+ * @dma_sconfig: configuration for slave transfers, passed via
+ * .device_config
  * @lock: serializes enqueue/dequeue operations to descriptors lists
  * @active_list: list of descriptors dmaengine is being running on
  * @queue: list of descriptors ready to be submitted to engine
diff --git a/drivers/dma/at_xdmac.c b/drivers/dma/at_xdmac.c
index b60d77a22df6..09e2825a547a 100644
--- a/drivers/dma/at_xdmac.c
+++ b/drivers/dma/at_xdmac.c
@@ -25,6 +25,7 @@
 #include <linux/dmapool.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
+#include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/of_dma.h>
@@ -174,6 +175,13 @@
 
 #define AT_XDMAC_MAX_CHAN       0x20
 
+#define AT_XDMAC_DMA_BUSWIDTHS\
+        (BIT(DMA_SLAVE_BUSWIDTH_UNDEFINED) |\
+        BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |\
+        BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) |\
+        BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) |\
+        BIT(DMA_SLAVE_BUSWIDTH_8_BYTES))
+
 enum atc_status {
         AT_XDMAC_CHAN_IS_CYCLIC = 0,
         AT_XDMAC_CHAN_IS_PAUSED,
@@ -184,15 +192,15 @@ struct at_xdmac_chan {
         struct dma_chan                 chan;
         void __iomem                    *ch_regs;
         u32                             mask;           /* Channel Mask */
-        u32                             cfg[3];         /* Channel Configuration Register */
-        #define AT_XDMAC_CUR_CFG        0               /* Current channel conf */
-        #define AT_XDMAC_DEV_TO_MEM_CFG 1               /* Predifined dev to mem channel conf */
-        #define AT_XDMAC_MEM_TO_DEV_CFG 2               /* Predifined mem to dev channel conf */
+        u32                             cfg[2];         /* Channel Configuration Register */
+        #define AT_XDMAC_DEV_TO_MEM_CFG 0               /* Predifined dev to mem channel conf */
+        #define AT_XDMAC_MEM_TO_DEV_CFG 1               /* Predifined mem to dev channel conf */
         u8                              perid;          /* Peripheral ID */
         u8                              perif;          /* Peripheral Interface */
         u8                              memif;          /* Memory Interface */
         u32                             per_src_addr;
         u32                             per_dst_addr;
+        u32                             save_cc;
         u32                             save_cim;
         u32                             save_cnda;
         u32                             save_cndc;
@@ -344,20 +352,13 @@ static void at_xdmac_start_xfer(struct at_xdmac_chan *atchan,
         at_xdmac_chan_write(atchan, AT_XDMAC_CNDA, reg);
 
         /*
-         * When doing memory to memory transfer we need to use the next
+         * When doing non cyclic transfer we need to use the next
          * descriptor view 2 since some fields of the configuration register
          * depend on transfer size and src/dest addresses.
          */
-        if (is_slave_direction(first->direction)) {
+        if (at_xdmac_chan_is_cyclic(atchan)) {
                 reg = AT_XDMAC_CNDC_NDVIEW_NDV1;
-                if (first->direction == DMA_MEM_TO_DEV)
-                        atchan->cfg[AT_XDMAC_CUR_CFG] =
-                                atchan->cfg[AT_XDMAC_MEM_TO_DEV_CFG];
-                else
-                        atchan->cfg[AT_XDMAC_CUR_CFG] =
-                                atchan->cfg[AT_XDMAC_DEV_TO_MEM_CFG];
-                at_xdmac_chan_write(atchan, AT_XDMAC_CC,
-                                    atchan->cfg[AT_XDMAC_CUR_CFG]);
+                at_xdmac_chan_write(atchan, AT_XDMAC_CC, first->lld.mbr_cfg);
         } else {
                 /*
                  * No need to write AT_XDMAC_CC reg, it will be done when the
@@ -561,7 +562,6 @@ at_xdmac_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         struct at_xdmac_desc    *first = NULL, *prev = NULL;
         struct scatterlist      *sg;
         int                     i;
-        u32                     cfg;
         unsigned int            xfer_size = 0;
 
         if (!sgl)
@@ -583,7 +583,7 @@ at_xdmac_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         /* Prepare descriptors. */
         for_each_sg(sgl, sg, sg_len, i) {
                 struct at_xdmac_desc    *desc = NULL;
-                u32                     len, mem;
+                u32                     len, mem, dwidth, fixed_dwidth;
 
                 len = sg_dma_len(sg);
                 mem = sg_dma_address(sg);
@@ -608,17 +608,21 @@ at_xdmac_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 if (direction == DMA_DEV_TO_MEM) {
                         desc->lld.mbr_sa = atchan->per_src_addr;
                         desc->lld.mbr_da = mem;
-                        cfg = atchan->cfg[AT_XDMAC_DEV_TO_MEM_CFG];
+                        desc->lld.mbr_cfg = atchan->cfg[AT_XDMAC_DEV_TO_MEM_CFG];
                 } else {
                         desc->lld.mbr_sa = mem;
                         desc->lld.mbr_da = atchan->per_dst_addr;
-                        cfg = atchan->cfg[AT_XDMAC_MEM_TO_DEV_CFG];
+                        desc->lld.mbr_cfg = atchan->cfg[AT_XDMAC_MEM_TO_DEV_CFG];
                 }
-                desc->lld.mbr_ubc = AT_XDMAC_MBR_UBC_NDV1               /* next descriptor view */
-                        | AT_XDMAC_MBR_UBC_NDEN                         /* next descriptor dst parameter update */
-                        | AT_XDMAC_MBR_UBC_NSEN                         /* next descriptor src parameter update */
-                        | (i == sg_len - 1 ? 0 : AT_XDMAC_MBR_UBC_NDE)  /* descriptor fetch */
-                        | len / (1 << at_xdmac_get_dwidth(cfg));        /* microblock length */
+                dwidth = at_xdmac_get_dwidth(desc->lld.mbr_cfg);
+                fixed_dwidth = IS_ALIGNED(len, 1 << dwidth)
+                               ? at_xdmac_get_dwidth(desc->lld.mbr_cfg)
+                               : AT_XDMAC_CC_DWIDTH_BYTE;
+                desc->lld.mbr_ubc = AT_XDMAC_MBR_UBC_NDV2                       /* next descriptor view */
+                        | AT_XDMAC_MBR_UBC_NDEN                                 /* next descriptor dst parameter update */
+                        | AT_XDMAC_MBR_UBC_NSEN                                 /* next descriptor src parameter update */
+                        | (i == sg_len - 1 ? 0 : AT_XDMAC_MBR_UBC_NDE)          /* descriptor fetch */
+                        | (len >> fixed_dwidth);                                /* microblock length */
                 dev_dbg(chan2dev(chan),
                          "%s: lld: mbr_sa=%pad, mbr_da=%pad, mbr_ubc=0x%08x\n",
                          __func__, &desc->lld.mbr_sa, &desc->lld.mbr_da, desc->lld.mbr_ubc);
@@ -882,7 +886,7 @@ at_xdmac_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
         enum dma_status         ret;
         int                     residue;
         u32                     cur_nda, mask, value;
-        u8                      dwidth = at_xdmac_get_dwidth(atchan->cfg[AT_XDMAC_CUR_CFG]);
+        u8                      dwidth = 0;
 
         ret = dma_cookie_status(chan, cookie, txstate);
         if (ret == DMA_COMPLETE)
@@ -912,7 +916,7 @@ at_xdmac_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
          */
         mask = AT_XDMAC_CC_TYPE | AT_XDMAC_CC_DSYNC;
         value = AT_XDMAC_CC_TYPE_PER_TRAN | AT_XDMAC_CC_DSYNC_PER2MEM;
-        if ((atchan->cfg[AT_XDMAC_CUR_CFG] & mask) == value) {
+        if ((desc->lld.mbr_cfg & mask) == value) {
                 at_xdmac_write(atxdmac, AT_XDMAC_GSWF, atchan->mask);
                 while (!(at_xdmac_chan_read(atchan, AT_XDMAC_CIS) & AT_XDMAC_CIS_FIS))
                         cpu_relax();
@@ -926,6 +930,7 @@ at_xdmac_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
          */
         descs_list = &desc->descs_list;
         list_for_each_entry_safe(desc, _desc, descs_list, desc_node) {
+                dwidth = at_xdmac_get_dwidth(desc->lld.mbr_cfg);
                 residue -= (desc->lld.mbr_ubc & 0xffffff) << dwidth;
                 if ((desc->lld.mbr_nda & 0xfffffffc) == cur_nda)
                         break;
@@ -1107,58 +1112,80 @@ static void at_xdmac_issue_pending(struct dma_chan *chan)
         return;
 }
 
-static int at_xdmac_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                            unsigned long arg)
+static int at_xdmac_device_config(struct dma_chan *chan,
+                                  struct dma_slave_config *config)
+{
+        struct at_xdmac_chan    *atchan = to_at_xdmac_chan(chan);
+        int ret;
+
+        dev_dbg(chan2dev(chan), "%s\n", __func__);
+
+        spin_lock_bh(&atchan->lock);
+        ret = at_xdmac_set_slave_config(chan, config);
+        spin_unlock_bh(&atchan->lock);
+
+        return ret;
+}
+
+static int at_xdmac_device_pause(struct dma_chan *chan)
 {
-        struct at_xdmac_desc    *desc, *_desc;
         struct at_xdmac_chan    *atchan = to_at_xdmac_chan(chan);
         struct at_xdmac         *atxdmac = to_at_xdmac(atchan->chan.device);
-        int                     ret = 0;
 
-        dev_dbg(chan2dev(chan), "%s: cmd=%d\n", __func__, cmd);
+        dev_dbg(chan2dev(chan), "%s\n", __func__);
+
+        if (test_and_set_bit(AT_XDMAC_CHAN_IS_PAUSED, &atchan->status))
+                return 0;
 
         spin_lock_bh(&atchan->lock);
+        at_xdmac_write(atxdmac, AT_XDMAC_GRWS, atchan->mask);
+        while (at_xdmac_chan_read(atchan, AT_XDMAC_CC)
+               & (AT_XDMAC_CC_WRIP | AT_XDMAC_CC_RDIP))
+                cpu_relax();
+        spin_unlock_bh(&atchan->lock);
 
-        switch (cmd) {
-        case DMA_PAUSE:
-                at_xdmac_write(atxdmac, AT_XDMAC_GRWS, atchan->mask);
-                set_bit(AT_XDMAC_CHAN_IS_PAUSED, &atchan->status);
-                break;
+        return 0;
+}
 
-        case DMA_RESUME:
-                if (!at_xdmac_chan_is_paused(atchan))
-                        break;
+static int at_xdmac_device_resume(struct dma_chan *chan)
+{
+        struct at_xdmac_chan    *atchan = to_at_xdmac_chan(chan);
+        struct at_xdmac         *atxdmac = to_at_xdmac(atchan->chan.device);
 
-                at_xdmac_write(atxdmac, AT_XDMAC_GRWR, atchan->mask);
-                clear_bit(AT_XDMAC_CHAN_IS_PAUSED, &atchan->status);
-                break;
+        dev_dbg(chan2dev(chan), "%s\n", __func__);
 
-        case DMA_TERMINATE_ALL:
-                at_xdmac_write(atxdmac, AT_XDMAC_GD, atchan->mask);
-                while (at_xdmac_read(atxdmac, AT_XDMAC_GS) & atchan->mask)
-                        cpu_relax();
+        spin_lock_bh(&atchan->lock);
+        if (!at_xdmac_chan_is_paused(atchan))
+                return 0;
+
+        at_xdmac_write(atxdmac, AT_XDMAC_GRWR, atchan->mask);
+        clear_bit(AT_XDMAC_CHAN_IS_PAUSED, &atchan->status);
+        spin_unlock_bh(&atchan->lock);
 
-                /* Cancel all pending transfers. */
-                list_for_each_entry_safe(desc, _desc, &atchan->xfers_list, xfer_node)
-                        at_xdmac_remove_xfer(atchan, desc);
+        return 0;
+}
+
+static int at_xdmac_device_terminate_all(struct dma_chan *chan)
+{
+        struct at_xdmac_desc    *desc, *_desc;
+        struct at_xdmac_chan    *atchan = to_at_xdmac_chan(chan);
+        struct at_xdmac         *atxdmac = to_at_xdmac(atchan->chan.device);
 
-                clear_bit(AT_XDMAC_CHAN_IS_CYCLIC, &atchan->status);
-                break;
+        dev_dbg(chan2dev(chan), "%s\n", __func__);
 
-        case DMA_SLAVE_CONFIG:
-                ret = at_xdmac_set_slave_config(chan,
-                                (struct dma_slave_config *)arg);
-                break;
+        spin_lock_bh(&atchan->lock);
+        at_xdmac_write(atxdmac, AT_XDMAC_GD, atchan->mask);
+        while (at_xdmac_read(atxdmac, AT_XDMAC_GS) & atchan->mask)
+                cpu_relax();
 
-        default:
-                dev_err(chan2dev(chan),
-                        "unmanaged or unknown dma control cmd: %d\n", cmd);
-                ret = -ENXIO;
-        }
+        /* Cancel all pending transfers. */
+        list_for_each_entry_safe(desc, _desc, &atchan->xfers_list, xfer_node)
+                at_xdmac_remove_xfer(atchan, desc);
 
+        clear_bit(AT_XDMAC_CHAN_IS_CYCLIC, &atchan->status);
         spin_unlock_bh(&atchan->lock);
 
-        return ret;
+        return 0;
 }
 
 static int at_xdmac_alloc_chan_resources(struct dma_chan *chan)
@@ -1217,27 +1244,6 @@ static void at_xdmac_free_chan_resources(struct dma_chan *chan)
         return;
 }
 
-#define AT_XDMAC_DMA_BUSWIDTHS\
-        (BIT(DMA_SLAVE_BUSWIDTH_UNDEFINED) |\
-        BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |\
-        BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) |\
-        BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) |\
-        BIT(DMA_SLAVE_BUSWIDTH_8_BYTES))
-
-static int at_xdmac_device_slave_caps(struct dma_chan *dchan,
-                                      struct dma_slave_caps *caps)
-{
-
-        caps->src_addr_widths = AT_XDMAC_DMA_BUSWIDTHS;
-        caps->dstn_addr_widths = AT_XDMAC_DMA_BUSWIDTHS;
-        caps->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
-        caps->cmd_pause = true;
-        caps->cmd_terminate = true;
-        caps->residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
-
-        return 0;
-}
-
 #ifdef CONFIG_PM
 static int atmel_xdmac_prepare(struct device *dev)
 {
@@ -1268,9 +1274,10 @@ static int atmel_xdmac_suspend(struct device *dev)
         list_for_each_entry_safe(chan, _chan, &atxdmac->dma.channels, device_node) {
                 struct at_xdmac_chan    *atchan = to_at_xdmac_chan(chan);
 
+                atchan->save_cc = at_xdmac_chan_read(atchan, AT_XDMAC_CC);
                 if (at_xdmac_chan_is_cyclic(atchan)) {
                         if (!at_xdmac_chan_is_paused(atchan))
-                                at_xdmac_control(chan, DMA_PAUSE, 0);
+                                at_xdmac_device_pause(chan);
                         atchan->save_cim = at_xdmac_chan_read(atchan, AT_XDMAC_CIM);
                         atchan->save_cnda = at_xdmac_chan_read(atchan, AT_XDMAC_CNDA);
                         atchan->save_cndc = at_xdmac_chan_read(atchan, AT_XDMAC_CNDC);
@@ -1290,7 +1297,6 @@ static int atmel_xdmac_resume(struct device *dev)
         struct at_xdmac_chan    *atchan;
         struct dma_chan         *chan, *_chan;
         int                     i;
-        u32                     cfg;
 
         clk_prepare_enable(atxdmac->clk);
 
@@ -1305,8 +1311,7 @@ static int atmel_xdmac_resume(struct device *dev)
         at_xdmac_write(atxdmac, AT_XDMAC_GE, atxdmac->save_gs);
         list_for_each_entry_safe(chan, _chan, &atxdmac->dma.channels, device_node) {
                 atchan = to_at_xdmac_chan(chan);
-                cfg = atchan->cfg[AT_XDMAC_CUR_CFG];
-                at_xdmac_chan_write(atchan, AT_XDMAC_CC, cfg);
+                at_xdmac_chan_write(atchan, AT_XDMAC_CC, atchan->save_cc);
                 if (at_xdmac_chan_is_cyclic(atchan)) {
                         at_xdmac_chan_write(atchan, AT_XDMAC_CNDA, atchan->save_cnda);
                         at_xdmac_chan_write(atchan, AT_XDMAC_CNDC, atchan->save_cndc);
@@ -1407,8 +1412,14 @@ static int at_xdmac_probe(struct platform_device *pdev)
         atxdmac->dma.device_prep_dma_cyclic             = at_xdmac_prep_dma_cyclic;
         atxdmac->dma.device_prep_dma_memcpy             = at_xdmac_prep_dma_memcpy;
         atxdmac->dma.device_prep_slave_sg               = at_xdmac_prep_slave_sg;
-        atxdmac->dma.device_control                     = at_xdmac_control;
-        atxdmac->dma.device_slave_caps                  = at_xdmac_device_slave_caps;
+        atxdmac->dma.device_config                      = at_xdmac_device_config;
+        atxdmac->dma.device_pause                       = at_xdmac_device_pause;
+        atxdmac->dma.device_resume                      = at_xdmac_device_resume;
+        atxdmac->dma.device_terminate_all               = at_xdmac_device_terminate_all;
+        atxdmac->dma.src_addr_widths = AT_XDMAC_DMA_BUSWIDTHS;
+        atxdmac->dma.dst_addr_widths = AT_XDMAC_DMA_BUSWIDTHS;
+        atxdmac->dma.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        atxdmac->dma.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
 
         /* Disable all chans and interrupts. */
         at_xdmac_off(atxdmac);
@@ -1507,7 +1518,6 @@ static struct platform_driver at_xdmac_driver = {
         .remove         = at_xdmac_remove,
         .driver = {
                 .name           = "at_xdmac",
-                .owner          = THIS_MODULE,
                 .of_match_table = of_match_ptr(atmel_xdmac_dt_ids),
                 .pm             = &atmel_xdmac_dev_pm_ops,
         }
diff --git a/drivers/dma/bcm2835-dma.c b/drivers/dma/bcm2835-dma.c
index 918b7b3f766f..0723096fb50a 100644
--- a/drivers/dma/bcm2835-dma.c
+++ b/drivers/dma/bcm2835-dma.c
@@ -436,9 +436,11 @@ static struct dma_async_tx_descriptor *bcm2835_dma_prep_dma_cyclic(
         return vchan_tx_prep(&c->vc, &d->vd, flags);
 }
 
-static int bcm2835_dma_slave_config(struct bcm2835_chan *c,
-                struct dma_slave_config *cfg)
+static int bcm2835_dma_slave_config(struct dma_chan *chan,
+                                    struct dma_slave_config *cfg)
 {
+        struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
+
         if ((cfg->direction == DMA_DEV_TO_MEM &&
              cfg->src_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES) ||
             (cfg->direction == DMA_MEM_TO_DEV &&
@@ -452,8 +454,9 @@ static int bcm2835_dma_slave_config(struct bcm2835_chan *c,
         return 0;
 }
 
-static int bcm2835_dma_terminate_all(struct bcm2835_chan *c)
+static int bcm2835_dma_terminate_all(struct dma_chan *chan)
 {
+        struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
         struct bcm2835_dmadev *d = to_bcm2835_dma_dev(c->vc.chan.device);
         unsigned long flags;
         int timeout = 10000;
@@ -495,24 +498,6 @@ static int bcm2835_dma_terminate_all(struct bcm2835_chan *c)
         return 0;
 }
 
-static int bcm2835_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-        unsigned long arg)
-{
-        struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
-
-        switch (cmd) {
-        case DMA_SLAVE_CONFIG:
-                return bcm2835_dma_slave_config(c,
-                                (struct dma_slave_config *)arg);
-
-        case DMA_TERMINATE_ALL:
-                return bcm2835_dma_terminate_all(c);
-
-        default:
-                return -ENXIO;
-        }
-}
-
 static int bcm2835_dma_chan_init(struct bcm2835_dmadev *d, int chan_id, int irq)
 {
         struct bcm2835_chan *c;
@@ -565,18 +550,6 @@ static struct dma_chan *bcm2835_dma_xlate(struct of_phandle_args *spec,
         return chan;
 }
 
-static int bcm2835_dma_device_slave_caps(struct dma_chan *dchan,
-        struct dma_slave_caps *caps)
-{
-        caps->src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
-        caps->dstn_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
-        caps->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
-        caps->cmd_pause = false;
-        caps->cmd_terminate = true;
-
-        return 0;
-}
-
 static int bcm2835_dma_probe(struct platform_device *pdev)
 {
         struct bcm2835_dmadev *od;
@@ -615,9 +588,12 @@ static int bcm2835_dma_probe(struct platform_device *pdev)
         od->ddev.device_free_chan_resources = bcm2835_dma_free_chan_resources;
         od->ddev.device_tx_status = bcm2835_dma_tx_status;
         od->ddev.device_issue_pending = bcm2835_dma_issue_pending;
-        od->ddev.device_slave_caps = bcm2835_dma_device_slave_caps;
         od->ddev.device_prep_dma_cyclic = bcm2835_dma_prep_dma_cyclic;
-        od->ddev.device_control = bcm2835_dma_control;
+        od->ddev.device_config = bcm2835_dma_slave_config;
+        od->ddev.device_terminate_all = bcm2835_dma_terminate_all;
+        od->ddev.src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
+        od->ddev.dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
+        od->ddev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
         od->ddev.dev = &pdev->dev;
         INIT_LIST_HEAD(&od->ddev.channels);
         spin_lock_init(&od->lock);
diff --git a/drivers/dma/coh901318.c b/drivers/dma/coh901318.c
index e88588d8ecd3..fd22dd36985f 100644
--- a/drivers/dma/coh901318.c
+++ b/drivers/dma/coh901318.c
@@ -1690,7 +1690,7 @@ static u32 coh901318_get_bytes_left(struct dma_chan *chan)
  * Pauses a transfer without losing data. Enables power save.
  * Use this function in conjunction with coh901318_resume.
  */
-static void coh901318_pause(struct dma_chan *chan)
+static int coh901318_pause(struct dma_chan *chan)
 {
         u32 val;
         unsigned long flags;
@@ -1730,12 +1730,13 @@ static void coh901318_pause(struct dma_chan *chan)
         enable_powersave(cohc);
 
         spin_unlock_irqrestore(&cohc->lock, flags);
+        return 0;
 }
 
 /* Resumes a transfer that has been stopped via 300_dma_stop(..).
    Power save is handled.
 */
-static void coh901318_resume(struct dma_chan *chan)
+static int coh901318_resume(struct dma_chan *chan)
 {
         u32 val;
         unsigned long flags;
@@ -1760,6 +1761,7 @@ static void coh901318_resume(struct dma_chan *chan)
         }
 
         spin_unlock_irqrestore(&cohc->lock, flags);
+        return 0;
 }
 
 bool coh901318_filter_id(struct dma_chan *chan, void *chan_id)
@@ -2114,6 +2116,57 @@ static irqreturn_t dma_irq_handler(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+static int coh901318_terminate_all(struct dma_chan *chan)
+{
+        unsigned long flags;
+        struct coh901318_chan *cohc = to_coh901318_chan(chan);
+        struct coh901318_desc *cohd;
+        void __iomem *virtbase = cohc->base->virtbase;
+
+        /* The remainder of this function terminates the transfer */
+        coh901318_pause(chan);
+        spin_lock_irqsave(&cohc->lock, flags);
+
+        /* Clear any pending BE or TC interrupt */
+        if (cohc->id < 32) {
+                writel(1 << cohc->id, virtbase + COH901318_BE_INT_CLEAR1);
+                writel(1 << cohc->id, virtbase + COH901318_TC_INT_CLEAR1);
+        } else {
+                writel(1 << (cohc->id - 32), virtbase +
+                       COH901318_BE_INT_CLEAR2);
+                writel(1 << (cohc->id - 32), virtbase +
+                       COH901318_TC_INT_CLEAR2);
+        }
+
+        enable_powersave(cohc);
+
+        while ((cohd = coh901318_first_active_get(cohc))) {
+                /* release the lli allocation*/
+                coh901318_lli_free(&cohc->base->pool, &cohd->lli);
+
+                /* return desc to free-list */
+                coh901318_desc_remove(cohd);
+                coh901318_desc_free(cohc, cohd);
+        }
+
+        while ((cohd = coh901318_first_queued(cohc))) {
+                /* release the lli allocation*/
+                coh901318_lli_free(&cohc->base->pool, &cohd->lli);
+
+                /* return desc to free-list */
+                coh901318_desc_remove(cohd);
+                coh901318_desc_free(cohc, cohd);
+        }
+
+
+        cohc->nbr_active_done = 0;
+        cohc->busy = 0;
+
+        spin_unlock_irqrestore(&cohc->lock, flags);
+
+        return 0;
+}
+
 static int coh901318_alloc_chan_resources(struct dma_chan *chan)
 {
         struct coh901318_chan   *cohc = to_coh901318_chan(chan);
@@ -2156,7 +2209,7 @@ coh901318_free_chan_resources(struct dma_chan *chan)
 
         spin_unlock_irqrestore(&cohc->lock, flags);
 
-        dmaengine_terminate_all(chan);
+        coh901318_terminate_all(chan);
 }
 
 
@@ -2461,8 +2514,8 @@ static const struct burst_table burst_sizes[] = {
         },
 };
 
-static void coh901318_dma_set_runtimeconfig(struct dma_chan *chan,
-                        struct dma_slave_config *config)
+static int coh901318_dma_set_runtimeconfig(struct dma_chan *chan,
+                                           struct dma_slave_config *config)
 {
         struct coh901318_chan *cohc = to_coh901318_chan(chan);
         dma_addr_t addr;
@@ -2482,7 +2535,7 @@ static void coh901318_dma_set_runtimeconfig(struct dma_chan *chan,
                 maxburst = config->dst_maxburst;
         } else {
                 dev_err(COHC_2_DEV(cohc), "illegal channel mode\n");
-                return;
+                return -EINVAL;
         }
 
         dev_dbg(COHC_2_DEV(cohc), "configure channel for %d byte transfers\n",
@@ -2528,7 +2581,7 @@ static void coh901318_dma_set_runtimeconfig(struct dma_chan *chan,
         default:
                 dev_err(COHC_2_DEV(cohc),
                         "bad runtimeconfig: alien address width\n");
-                return;
+                return -EINVAL;
         }
 
         ctrl |= burst_sizes[i].reg;
@@ -2538,84 +2591,12 @@ static void coh901318_dma_set_runtimeconfig(struct dma_chan *chan,
 
         cohc->addr = addr;
         cohc->ctrl = ctrl;
-}
-
-static int
-coh901318_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                  unsigned long arg)
-{
-        unsigned long flags;
-        struct coh901318_chan *cohc = to_coh901318_chan(chan);
-        struct coh901318_desc *cohd;
-        void __iomem *virtbase = cohc->base->virtbase;
-
-        if (cmd == DMA_SLAVE_CONFIG) {
-                struct dma_slave_config *config =
-                        (struct dma_slave_config *) arg;
-
-                coh901318_dma_set_runtimeconfig(chan, config);
-                return 0;
-          }
-
-        if (cmd == DMA_PAUSE) {
-                coh901318_pause(chan);
-                return 0;
-        }
-
-        if (cmd == DMA_RESUME) {
-                coh901318_resume(chan);
-                return 0;
-        }
-
-        if (cmd != DMA_TERMINATE_ALL)
-                return -ENXIO;
-
-        /* The remainder of this function terminates the transfer */
-        coh901318_pause(chan);
-        spin_lock_irqsave(&cohc->lock, flags);
-
-        /* Clear any pending BE or TC interrupt */
-        if (cohc->id < 32) {
-                writel(1 << cohc->id, virtbase + COH901318_BE_INT_CLEAR1);
-                writel(1 << cohc->id, virtbase + COH901318_TC_INT_CLEAR1);
-        } else {
-                writel(1 << (cohc->id - 32), virtbase +
-                       COH901318_BE_INT_CLEAR2);
-                writel(1 << (cohc->id - 32), virtbase +
-                       COH901318_TC_INT_CLEAR2);
-        }
-
-        enable_powersave(cohc);
-
-        while ((cohd = coh901318_first_active_get(cohc))) {
-                /* release the lli allocation*/
-                coh901318_lli_free(&cohc->base->pool, &cohd->lli);
-
-                /* return desc to free-list */
-                coh901318_desc_remove(cohd);
-                coh901318_desc_free(cohc, cohd);
-        }
-
-        while ((cohd = coh901318_first_queued(cohc))) {
-                /* release the lli allocation*/
-                coh901318_lli_free(&cohc->base->pool, &cohd->lli);
-
-                /* return desc to free-list */
-                coh901318_desc_remove(cohd);
-                coh901318_desc_free(cohc, cohd);
-        }
-
-
-        cohc->nbr_active_done = 0;
-        cohc->busy = 0;
-
-        spin_unlock_irqrestore(&cohc->lock, flags);
 
         return 0;
 }
 
-void coh901318_base_init(struct dma_device *dma, const int *pick_chans,
-                         struct coh901318_base *base)
+static void coh901318_base_init(struct dma_device *dma, const int *pick_chans,
+                                struct coh901318_base *base)
 {
         int chans_i;
         int i = 0;
@@ -2717,7 +2698,10 @@ static int __init coh901318_probe(struct platform_device *pdev)
         base->dma_slave.device_prep_slave_sg = coh901318_prep_slave_sg;
         base->dma_slave.device_tx_status = coh901318_tx_status;
         base->dma_slave.device_issue_pending = coh901318_issue_pending;
-        base->dma_slave.device_control = coh901318_control;
+        base->dma_slave.device_config = coh901318_dma_set_runtimeconfig;
+        base->dma_slave.device_pause = coh901318_pause;
+        base->dma_slave.device_resume = coh901318_resume;
+        base->dma_slave.device_terminate_all = coh901318_terminate_all;
         base->dma_slave.dev = &pdev->dev;
 
         err = dma_async_device_register(&base->dma_slave);
@@ -2737,7 +2721,10 @@ static int __init coh901318_probe(struct platform_device *pdev)
         base->dma_memcpy.device_prep_dma_memcpy = coh901318_prep_memcpy;
         base->dma_memcpy.device_tx_status = coh901318_tx_status;
         base->dma_memcpy.device_issue_pending = coh901318_issue_pending;
-        base->dma_memcpy.device_control = coh901318_control;
+        base->dma_memcpy.device_config = coh901318_dma_set_runtimeconfig;
+        base->dma_memcpy.device_pause = coh901318_pause;
+        base->dma_memcpy.device_resume = coh901318_resume;
+        base->dma_memcpy.device_terminate_all = coh901318_terminate_all;
         base->dma_memcpy.dev = &pdev->dev;
         /*
          * This controller can only access address at even 32bit boundaries,
diff --git a/drivers/dma/cppi41.c b/drivers/dma/cppi41.c
index b743adf56465..512cb8e2805e 100644
--- a/drivers/dma/cppi41.c
+++ b/drivers/dma/cppi41.c
@@ -525,12 +525,6 @@ static struct dma_async_tx_descriptor *cppi41_dma_prep_slave_sg(
         return &c->txd;
 }
 
-static int cpp41_cfg_chan(struct cppi41_channel *c,
-                struct dma_slave_config *cfg)
-{
-        return 0;
-}
-
 static void cppi41_compute_td_desc(struct cppi41_desc *d)
 {
         d->pd0 = DESC_TYPE_TEARD << DESC_TYPE;
@@ -647,28 +641,6 @@ static int cppi41_stop_chan(struct dma_chan *chan)
         return 0;
 }
 
-static int cppi41_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-        unsigned long arg)
-{
-        struct cppi41_channel *c = to_cpp41_chan(chan);
-        int ret;
-
-        switch (cmd) {
-        case DMA_SLAVE_CONFIG:
-                ret = cpp41_cfg_chan(c, (struct dma_slave_config *) arg);
-                break;
-
-        case DMA_TERMINATE_ALL:
-                ret = cppi41_stop_chan(chan);
-                break;
-
-        default:
-                ret = -ENXIO;
-                break;
-        }
-        return ret;
-}
-
 static void cleanup_chans(struct cppi41_dd *cdd)
 {
         while (!list_empty(&cdd->ddev.channels)) {
@@ -953,7 +925,7 @@ static int cppi41_dma_probe(struct platform_device *pdev)
         cdd->ddev.device_tx_status = cppi41_dma_tx_status;
         cdd->ddev.device_issue_pending = cppi41_dma_issue_pending;
         cdd->ddev.device_prep_slave_sg = cppi41_dma_prep_slave_sg;
-        cdd->ddev.device_control = cppi41_dma_control;
+        cdd->ddev.device_terminate_all = cppi41_stop_chan;
         cdd->ddev.dev = dev;
         INIT_LIST_HEAD(&cdd->ddev.channels);
         cpp41_dma_info.dma_cap = cdd->ddev.cap_mask;
diff --git a/drivers/dma/dma-jz4740.c b/drivers/dma/dma-jz4740.c
index bdeafeefa5f6..4527a3ebeac4 100644
--- a/drivers/dma/dma-jz4740.c
+++ b/drivers/dma/dma-jz4740.c
@@ -210,7 +210,7 @@ static enum jz4740_dma_transfer_size jz4740_dma_maxburst(u32 maxburst)
 }
 
 static int jz4740_dma_slave_config(struct dma_chan *c,
-        const struct dma_slave_config *config)
+                                   struct dma_slave_config *config)
 {
         struct jz4740_dmaengine_chan *chan = to_jz4740_dma_chan(c);
         struct jz4740_dma_dev *dmadev = jz4740_dma_chan_get_dev(chan);
@@ -290,21 +290,6 @@ static int jz4740_dma_terminate_all(struct dma_chan *c)
         return 0;
 }
 
-static int jz4740_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-        unsigned long arg)
-{
-        struct dma_slave_config *config = (struct dma_slave_config *)arg;
-
-        switch (cmd) {
-        case DMA_SLAVE_CONFIG:
-                return jz4740_dma_slave_config(chan, config);
-        case DMA_TERMINATE_ALL:
-                return jz4740_dma_terminate_all(chan);
-        default:
-                return -ENOSYS;
-        }
-}
-
 static int jz4740_dma_start_transfer(struct jz4740_dmaengine_chan *chan)
 {
         struct jz4740_dma_dev *dmadev = jz4740_dma_chan_get_dev(chan);
@@ -561,7 +546,8 @@ static int jz4740_dma_probe(struct platform_device *pdev)
         dd->device_issue_pending = jz4740_dma_issue_pending;
         dd->device_prep_slave_sg = jz4740_dma_prep_slave_sg;
         dd->device_prep_dma_cyclic = jz4740_dma_prep_dma_cyclic;
-        dd->device_control = jz4740_dma_control;
+        dd->device_config = jz4740_dma_slave_config;
+        dd->device_terminate_all = jz4740_dma_terminate_all;
         dd->dev = &pdev->dev;
         INIT_LIST_HEAD(&dd->channels);
 
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index e057935e3023..f15712f2fec6 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -222,31 +222,35 @@ static void balance_ref_count(struct dma_chan *chan)
  */
 static int dma_chan_get(struct dma_chan *chan)
 {
-        int err = -ENODEV;
         struct module *owner = dma_chan_to_owner(chan);
+        int ret;
 
+        /* The channel is already in use, update client count */
         if (chan->client_count) {
                 __module_get(owner);
-                err = 0;
-        } else if (try_module_get(owner))
-                err = 0;
+                goto out;
+        }
 
-        if (err == 0)
-                chan->client_count++;
+        if (!try_module_get(owner))
+                return -ENODEV;
 
         /* allocate upon first client reference */
-        if (chan->client_count == 1 && err == 0) {
-                int desc_cnt = chan->device->device_alloc_chan_resources(chan);
-
-                if (desc_cnt < 0) {
-                        err = desc_cnt;
-                        chan->client_count = 0;
-                        module_put(owner);
-                } else if (!dma_has_cap(DMA_PRIVATE, chan->device->cap_mask))
-                        balance_ref_count(chan);
+        if (chan->device->device_alloc_chan_resources) {
+                ret = chan->device->device_alloc_chan_resources(chan);
+                if (ret < 0)
+                        goto err_out;
         }
 
-        return err;
+        if (!dma_has_cap(DMA_PRIVATE, chan->device->cap_mask))
+                balance_ref_count(chan);
+
+out:
+        chan->client_count++;
+        return 0;
+
+err_out:
+        module_put(owner);
+        return ret;
 }
 
 /**
@@ -257,11 +261,15 @@ static int dma_chan_get(struct dma_chan *chan)
  */
 static void dma_chan_put(struct dma_chan *chan)
 {
+        /* This channel is not in use, bail out */
         if (!chan->client_count)
-                return; /* this channel failed alloc_chan_resources */
+                return;
+
         chan->client_count--;
         module_put(dma_chan_to_owner(chan));
-        if (chan->client_count == 0)
+
+        /* This channel is not in use anymore, free it */
+        if (!chan->client_count && chan->device->device_free_chan_resources)
                 chan->device->device_free_chan_resources(chan);
 }
 
@@ -471,6 +479,39 @@ static void dma_channel_rebalance(void)
                 }
 }
 
+int dma_get_slave_caps(struct dma_chan *chan, struct dma_slave_caps *caps)
+{
+        struct dma_device *device;
+
+        if (!chan || !caps)
+                return -EINVAL;
+
+        device = chan->device;
+
+        /* check if the channel supports slave transactions */
+        if (!test_bit(DMA_SLAVE, device->cap_mask.bits))
+                return -ENXIO;
+
+        /*
+         * Check whether it reports it uses the generic slave
+         * capabilities, if not, that means it doesn't support any
+         * kind of slave capabilities reporting.
+         */
+        if (!device->directions)
+                return -ENXIO;
+
+        caps->src_addr_widths = device->src_addr_widths;
+        caps->dst_addr_widths = device->dst_addr_widths;
+        caps->directions = device->directions;
+        caps->residue_granularity = device->residue_granularity;
+
+        caps->cmd_pause = !!device->device_pause;
+        caps->cmd_terminate = !!device->device_terminate_all;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(dma_get_slave_caps);
+
 static struct dma_chan *private_candidate(const dma_cap_mask_t *mask,
                                           struct dma_device *dev,
                                           dma_filter_fn fn, void *fn_param)
@@ -811,17 +852,16 @@ int dma_async_device_register(struct dma_device *device)
                 !device->device_prep_dma_sg);
         BUG_ON(dma_has_cap(DMA_CYCLIC, device->cap_mask) &&
                 !device->device_prep_dma_cyclic);
-        BUG_ON(dma_has_cap(DMA_SLAVE, device->cap_mask) &&
-                !device->device_control);
         BUG_ON(dma_has_cap(DMA_INTERLEAVE, device->cap_mask) &&
                 !device->device_prep_interleaved_dma);
 
-        BUG_ON(!device->device_alloc_chan_resources);
-        BUG_ON(!device->device_free_chan_resources);
         BUG_ON(!device->device_tx_status);
         BUG_ON(!device->device_issue_pending);
         BUG_ON(!device->dev);
 
+        WARN(dma_has_cap(DMA_SLAVE, device->cap_mask) && !device->directions,
+             "this driver doesn't support generic slave capabilities reporting\n");
+
         /* note: this only matters in the
          * CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH=n case
          */
diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c
index a8d7809e2f4c..220ee49633e4 100644
--- a/drivers/dma/dmatest.c
+++ b/drivers/dma/dmatest.c
@@ -349,14 +349,14 @@ static void dbg_result(const char *err, unsigned int n, unsigned int src_off,
                        unsigned long data)
 {
         pr_debug("%s: result #%u: '%s' with src_off=0x%x dst_off=0x%x len=0x%x (%lu)\n",
-                   current->comm, n, err, src_off, dst_off, len, data);
+                 current->comm, n, err, src_off, dst_off, len, data);
 }
 
-#define verbose_result(err, n, src_off, dst_off, len, data) ({ \
-        if (verbose) \
-                result(err, n, src_off, dst_off, len, data); \
-        else \
-                dbg_result(err, n, src_off, dst_off, len, data); \
+#define verbose_result(err, n, src_off, dst_off, len, data) ({  \
+        if (verbose)                                            \
+                result(err, n, src_off, dst_off, len, data);    \
+        else                                                    \
+                dbg_result(err, n, src_off, dst_off, len, data);\
 })
 
 static unsigned long long dmatest_persec(s64 runtime, unsigned int val)
@@ -405,7 +405,6 @@ static int dmatest_func(void *data)
         struct dmatest_params   *params;
         struct dma_chan         *chan;
         struct dma_device       *dev;
-        unsigned int            src_off, dst_off, len;
         unsigned int            error_count;
         unsigned int            failed_tests = 0;
         unsigned int            total_tests = 0;
@@ -484,6 +483,7 @@ static int dmatest_func(void *data)
                 struct dmaengine_unmap_data *um;
                 dma_addr_t srcs[src_cnt];
                 dma_addr_t *dsts;
+                unsigned int src_off, dst_off, len;
                 u8 align = 0;
 
                 total_tests++;
@@ -502,15 +502,21 @@ static int dmatest_func(void *data)
                         break;
                 }
 
-                if (params->noverify) {
+                if (params->noverify)
                         len = params->buf_size;
+                else
+                        len = dmatest_random() % params->buf_size + 1;
+
+                len = (len >> align) << align;
+                if (!len)
+                        len = 1 << align;
+
+                total_len += len;
+
+                if (params->noverify) {
                         src_off = 0;
                         dst_off = 0;
                 } else {
-                        len = dmatest_random() % params->buf_size + 1;
-                        len = (len >> align) << align;
-                        if (!len)
-                                len = 1 << align;
                         src_off = dmatest_random() % (params->buf_size - len + 1);
                         dst_off = dmatest_random() % (params->buf_size - len + 1);
 
@@ -523,11 +529,6 @@ static int dmatest_func(void *data)
                                           params->buf_size);
                 }
 
-                len = (len >> align) << align;
-                if (!len)
-                        len = 1 << align;
-                total_len += len;
-
                 um = dmaengine_get_unmap_data(dev->dev, src_cnt+dst_cnt,
                                               GFP_KERNEL);
                 if (!um) {
diff --git a/drivers/dma/dw/core.c b/drivers/dma/dw/core.c
index 5c062548957c..455b7a4f1e87 100644
--- a/drivers/dma/dw/core.c
+++ b/drivers/dma/dw/core.c
@@ -61,6 +61,13 @@
  */
 #define NR_DESCS_PER_CHANNEL    64
 
+/* The set of bus widths supported by the DMA controller */
+#define DW_DMA_BUSWIDTHS                          \
+        BIT(DMA_SLAVE_BUSWIDTH_UNDEFINED)       | \
+        BIT(DMA_SLAVE_BUSWIDTH_1_BYTE)          | \
+        BIT(DMA_SLAVE_BUSWIDTH_2_BYTES)         | \
+        BIT(DMA_SLAVE_BUSWIDTH_4_BYTES)
+
 /*----------------------------------------------------------------------*/
 
 static struct device *chan2dev(struct dma_chan *chan)
@@ -955,8 +962,7 @@ static inline void convert_burst(u32 *maxburst)
                 *maxburst = 0;
 }
 
-static int
-set_runtime_config(struct dma_chan *chan, struct dma_slave_config *sconfig)
+static int dwc_config(struct dma_chan *chan, struct dma_slave_config *sconfig)
 {
         struct dw_dma_chan *dwc = to_dw_dma_chan(chan);
 
@@ -973,16 +979,25 @@ set_runtime_config(struct dma_chan *chan, struct dma_slave_config *sconfig)
         return 0;
 }
 
-static inline void dwc_chan_pause(struct dw_dma_chan *dwc)
+static int dwc_pause(struct dma_chan *chan)
 {
-        u32 cfglo = channel_readl(dwc, CFG_LO);
-        unsigned int count = 20;        /* timeout iterations */
+        struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
+        unsigned long           flags;
+        unsigned int            count = 20;     /* timeout iterations */
+        u32                     cfglo;
+
+        spin_lock_irqsave(&dwc->lock, flags);
 
+        cfglo = channel_readl(dwc, CFG_LO);
         channel_writel(dwc, CFG_LO, cfglo | DWC_CFGL_CH_SUSP);
         while (!(channel_readl(dwc, CFG_LO) & DWC_CFGL_FIFO_EMPTY) && count--)
                 udelay(2);
 
         dwc->paused = true;
+
+        spin_unlock_irqrestore(&dwc->lock, flags);
+
+        return 0;
 }
 
 static inline void dwc_chan_resume(struct dw_dma_chan *dwc)
@@ -994,53 +1009,48 @@ static inline void dwc_chan_resume(struct dw_dma_chan *dwc)
         dwc->paused = false;
 }
 
-static int dwc_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                       unsigned long arg)
+static int dwc_resume(struct dma_chan *chan)
 {
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
-        struct dw_dma           *dw = to_dw_dma(chan->device);
-        struct dw_desc          *desc, *_desc;
         unsigned long           flags;
-        LIST_HEAD(list);
 
-        if (cmd == DMA_PAUSE) {
-                spin_lock_irqsave(&dwc->lock, flags);
+        if (!dwc->paused)
+                return 0;
 
-                dwc_chan_pause(dwc);
+        spin_lock_irqsave(&dwc->lock, flags);
 
-                spin_unlock_irqrestore(&dwc->lock, flags);
-        } else if (cmd == DMA_RESUME) {
-                if (!dwc->paused)
-                        return 0;
+        dwc_chan_resume(dwc);
 
-                spin_lock_irqsave(&dwc->lock, flags);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 
-                dwc_chan_resume(dwc);
+        return 0;
+}
 
-                spin_unlock_irqrestore(&dwc->lock, flags);
-        } else if (cmd == DMA_TERMINATE_ALL) {
-                spin_lock_irqsave(&dwc->lock, flags);
+static int dwc_terminate_all(struct dma_chan *chan)
+{
+        struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
+        struct dw_dma           *dw = to_dw_dma(chan->device);
+        struct dw_desc          *desc, *_desc;
+        unsigned long           flags;
+        LIST_HEAD(list);
 
-                clear_bit(DW_DMA_IS_SOFT_LLP, &dwc->flags);
+        spin_lock_irqsave(&dwc->lock, flags);
 
-                dwc_chan_disable(dw, dwc);
+        clear_bit(DW_DMA_IS_SOFT_LLP, &dwc->flags);
+
+        dwc_chan_disable(dw, dwc);
 
-                dwc_chan_resume(dwc);
+        dwc_chan_resume(dwc);
 
-                /* active_list entries will end up before queued entries */
-                list_splice_init(&dwc->queue, &list);
-                list_splice_init(&dwc->active_list, &list);
+        /* active_list entries will end up before queued entries */
+        list_splice_init(&dwc->queue, &list);
+        list_splice_init(&dwc->active_list, &list);
 
-                spin_unlock_irqrestore(&dwc->lock, flags);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 
-                /* Flush all pending and queued descriptors */
-                list_for_each_entry_safe(desc, _desc, &list, desc_node)
-                        dwc_descriptor_complete(dwc, desc, false);
-        } else if (cmd == DMA_SLAVE_CONFIG) {
-                return set_runtime_config(chan, (struct dma_slave_config *)arg);
-        } else {
-                return -ENXIO;
-        }
+        /* Flush all pending and queued descriptors */
+        list_for_each_entry_safe(desc, _desc, &list, desc_node)
+                dwc_descriptor_complete(dwc, desc, false);
 
         return 0;
 }
@@ -1551,7 +1561,8 @@ int dw_dma_probe(struct dw_dma_chip *chip, struct dw_dma_platform_data *pdata)
                 }
         } else {
                 dw->nr_masters = pdata->nr_masters;
-                memcpy(dw->data_width, pdata->data_width, 4);
+                for (i = 0; i < dw->nr_masters; i++)
+                        dw->data_width[i] = pdata->data_width[i];
         }
 
         /* Calculate all channel mask before DMA setup */
@@ -1656,13 +1667,23 @@ int dw_dma_probe(struct dw_dma_chip *chip, struct dw_dma_platform_data *pdata)
         dw->dma.device_free_chan_resources = dwc_free_chan_resources;
 
         dw->dma.device_prep_dma_memcpy = dwc_prep_dma_memcpy;
-
         dw->dma.device_prep_slave_sg = dwc_prep_slave_sg;
-        dw->dma.device_control = dwc_control;
+
+        dw->dma.device_config = dwc_config;
+        dw->dma.device_pause = dwc_pause;
+        dw->dma.device_resume = dwc_resume;
+        dw->dma.device_terminate_all = dwc_terminate_all;
 
         dw->dma.device_tx_status = dwc_tx_status;
         dw->dma.device_issue_pending = dwc_issue_pending;
 
+        /* DMA capabilities */
+        dw->dma.src_addr_widths = DW_DMA_BUSWIDTHS;
+        dw->dma.dst_addr_widths = DW_DMA_BUSWIDTHS;
+        dw->dma.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV) |
+                             BIT(DMA_MEM_TO_MEM);
+        dw->dma.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
+
         err = dma_async_device_register(&dw->dma);
         if (err)
                 goto err_dma_register;
diff --git a/drivers/dma/dw/platform.c b/drivers/dma/dw/platform.c
index 32ea1aca7a0e..6565a361e7e5 100644
--- a/drivers/dma/dw/platform.c
+++ b/drivers/dma/dw/platform.c
@@ -100,7 +100,7 @@ dw_dma_parse_dt(struct platform_device *pdev)
 {
         struct device_node *np = pdev->dev.of_node;
         struct dw_dma_platform_data *pdata;
-        u32 tmp, arr[4];
+        u32 tmp, arr[DW_DMA_MAX_NR_MASTERS];
 
         if (!np) {
                 dev_err(&pdev->dev, "Missing DT data\n");
@@ -127,7 +127,7 @@ dw_dma_parse_dt(struct platform_device *pdev)
                 pdata->block_size = tmp;
 
         if (!of_property_read_u32(np, "dma-masters", &tmp)) {
-                if (tmp > 4)
+                if (tmp > DW_DMA_MAX_NR_MASTERS)
                         return NULL;
 
                 pdata->nr_masters = tmp;
diff --git a/drivers/dma/dw/regs.h b/drivers/dma/dw/regs.h
index 848e232f7cc7..241ff2b1402b 100644
--- a/drivers/dma/dw/regs.h
+++ b/drivers/dma/dw/regs.h
@@ -252,7 +252,7 @@ struct dw_dma_chan {
         u8                      src_master;
         u8                      dst_master;
 
-        /* configuration passed via DMA_SLAVE_CONFIG */
+        /* configuration passed via .device_config */
         struct dma_slave_config dma_sconfig;
 };
 
@@ -285,7 +285,7 @@ struct dw_dma {
 
         /* hardware configuration */
         unsigned char           nr_masters;
-        unsigned char           data_width[4];
+        unsigned char           data_width[DW_DMA_MAX_NR_MASTERS];
 };
 
 static inline struct dw_dma_regs __iomem *__dw_regs(struct dw_dma *dw)
diff --git a/drivers/dma/edma.c b/drivers/dma/edma.c
index b969206439b7..276157f22612 100644
--- a/drivers/dma/edma.c
+++ b/drivers/dma/edma.c
@@ -15,6 +15,7 @@
 
 #include <linux/dmaengine.h>
 #include <linux/dma-mapping.h>
+#include <linux/edma.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
@@ -244,8 +245,9 @@ static void edma_execute(struct edma_chan *echan)
         }
 }
 
-static int edma_terminate_all(struct edma_chan *echan)
+static int edma_terminate_all(struct dma_chan *chan)
 {
+        struct edma_chan *echan = to_edma_chan(chan);
         unsigned long flags;
         LIST_HEAD(head);
 
@@ -273,9 +275,11 @@ static int edma_terminate_all(struct edma_chan *echan)
         return 0;
 }
 
-static int edma_slave_config(struct edma_chan *echan,
+static int edma_slave_config(struct dma_chan *chan,
         struct dma_slave_config *cfg)
 {
+        struct edma_chan *echan = to_edma_chan(chan);
+
         if (cfg->src_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES ||
             cfg->dst_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES)
                 return -EINVAL;
@@ -285,8 +289,10 @@ static int edma_slave_config(struct edma_chan *echan,
         return 0;
 }
 
-static int edma_dma_pause(struct edma_chan *echan)
+static int edma_dma_pause(struct dma_chan *chan)
 {
+        struct edma_chan *echan = to_edma_chan(chan);
+
         /* Pause/Resume only allowed with cyclic mode */
         if (!echan->edesc || !echan->edesc->cyclic)
                 return -EINVAL;
@@ -295,8 +301,10 @@ static int edma_dma_pause(struct edma_chan *echan)
         return 0;
 }
 
-static int edma_dma_resume(struct edma_chan *echan)
+static int edma_dma_resume(struct dma_chan *chan)
 {
+        struct edma_chan *echan = to_edma_chan(chan);
+
         /* Pause/Resume only allowed with cyclic mode */
         if (!echan->edesc->cyclic)
                 return -EINVAL;
@@ -305,36 +313,6 @@ static int edma_dma_resume(struct edma_chan *echan)
         return 0;
 }
 
-static int edma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                        unsigned long arg)
-{
-        int ret = 0;
-        struct dma_slave_config *config;
-        struct edma_chan *echan = to_edma_chan(chan);
-
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                edma_terminate_all(echan);
-                break;
-        case DMA_SLAVE_CONFIG:
-                config = (struct dma_slave_config *)arg;
-                ret = edma_slave_config(echan, config);
-                break;
-        case DMA_PAUSE:
-                ret = edma_dma_pause(echan);
-                break;
-
-        case DMA_RESUME:
-                ret = edma_dma_resume(echan);
-                break;
-
-        default:
-                ret = -ENOSYS;
-        }
-
-        return ret;
-}
-
 /*
  * A PaRAM set configuration abstraction used by other modes
  * @chan: Channel who's PaRAM set we're configuring
@@ -557,7 +535,7 @@ static struct dma_async_tx_descriptor *edma_prep_slave_sg(
         return vchan_tx_prep(&echan->vchan, &edesc->vdesc, tx_flags);
 }
 
-struct dma_async_tx_descriptor *edma_prep_dma_memcpy(
+static struct dma_async_tx_descriptor *edma_prep_dma_memcpy(
         struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
         size_t len, unsigned long tx_flags)
 {
@@ -994,19 +972,6 @@ static void __init edma_chan_init(struct edma_cc *ecc,
                                  BIT(DMA_SLAVE_BUSWIDTH_3_BYTES) | \
                                  BIT(DMA_SLAVE_BUSWIDTH_4_BYTES))
 
-static int edma_dma_device_slave_caps(struct dma_chan *dchan,
-                                      struct dma_slave_caps *caps)
-{
-        caps->src_addr_widths = EDMA_DMA_BUSWIDTHS;
-        caps->dstn_addr_widths = EDMA_DMA_BUSWIDTHS;
-        caps->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
-        caps->cmd_pause = true;
-        caps->cmd_terminate = true;
-        caps->residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
-
-        return 0;
-}
-
 static void edma_dma_init(struct edma_cc *ecc, struct dma_device *dma,
                           struct device *dev)
 {
@@ -1017,8 +982,16 @@ static void edma_dma_init(struct edma_cc *ecc, struct dma_device *dma,
         dma->device_free_chan_resources = edma_free_chan_resources;
         dma->device_issue_pending = edma_issue_pending;
         dma->device_tx_status = edma_tx_status;
-        dma->device_control = edma_control;
-        dma->device_slave_caps = edma_dma_device_slave_caps;
+        dma->device_config = edma_slave_config;
+        dma->device_pause = edma_dma_pause;
+        dma->device_resume = edma_dma_resume;
+        dma->device_terminate_all = edma_terminate_all;
+
+        dma->src_addr_widths = EDMA_DMA_BUSWIDTHS;
+        dma->dst_addr_widths = EDMA_DMA_BUSWIDTHS;
+        dma->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        dma->residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
+
         dma->dev = dev;
 
         /*
diff --git a/drivers/dma/ep93xx_dma.c b/drivers/dma/ep93xx_dma.c
index 7650470196c4..24e5290faa32 100644
--- a/drivers/dma/ep93xx_dma.c
+++ b/drivers/dma/ep93xx_dma.c
@@ -144,7 +144,7 @@ struct ep93xx_dma_desc {
  * @queue: pending descriptors which are handled next
  * @free_list: list of free descriptors which can be used
  * @runtime_addr: physical address currently used as dest/src (M2M only). This
- *                is set via %DMA_SLAVE_CONFIG before slave operation is
+ *                is set via .device_config before slave operation is
  *                prepared
  * @runtime_ctrl: M2M runtime values for the control register.
  *
@@ -1164,13 +1164,14 @@ fail:
 
 /**
  * ep93xx_dma_terminate_all - terminate all transactions
- * @edmac: channel
+ * @chan: channel
  *
  * Stops all DMA transactions. All descriptors are put back to the
  * @edmac->free_list and callbacks are _not_ called.
  */
-static int ep93xx_dma_terminate_all(struct ep93xx_dma_chan *edmac)
+static int ep93xx_dma_terminate_all(struct dma_chan *chan)
 {
+        struct ep93xx_dma_chan *edmac = to_ep93xx_dma_chan(chan);
         struct ep93xx_dma_desc *desc, *_d;
         unsigned long flags;
         LIST_HEAD(list);
@@ -1194,9 +1195,10 @@ static int ep93xx_dma_terminate_all(struct ep93xx_dma_chan *edmac)
         return 0;
 }
 
-static int ep93xx_dma_slave_config(struct ep93xx_dma_chan *edmac,
+static int ep93xx_dma_slave_config(struct dma_chan *chan,
                                    struct dma_slave_config *config)
 {
+        struct ep93xx_dma_chan *edmac = to_ep93xx_dma_chan(chan);
         enum dma_slave_buswidth width;
         unsigned long flags;
         u32 addr, ctrl;
@@ -1242,36 +1244,6 @@ static int ep93xx_dma_slave_config(struct ep93xx_dma_chan *edmac,
 }
 
 /**
- * ep93xx_dma_control - manipulate all pending operations on a channel
- * @chan: channel
- * @cmd: control command to perform
- * @arg: optional argument
- *
- * Controls the channel. Function returns %0 in case of success or negative
- * error in case of failure.
- */
-static int ep93xx_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                              unsigned long arg)
-{
-        struct ep93xx_dma_chan *edmac = to_ep93xx_dma_chan(chan);
-        struct dma_slave_config *config;
-
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                return ep93xx_dma_terminate_all(edmac);
-
-        case DMA_SLAVE_CONFIG:
-                config = (struct dma_slave_config *)arg;
-                return ep93xx_dma_slave_config(edmac, config);
-
-        default:
-                break;
-        }
-
-        return -ENOSYS;
-}
-
-/**
  * ep93xx_dma_tx_status - check if a transaction is completed
  * @chan: channel
  * @cookie: transaction specific cookie
@@ -1352,7 +1324,8 @@ static int __init ep93xx_dma_probe(struct platform_device *pdev)
         dma_dev->device_free_chan_resources = ep93xx_dma_free_chan_resources;
         dma_dev->device_prep_slave_sg = ep93xx_dma_prep_slave_sg;
         dma_dev->device_prep_dma_cyclic = ep93xx_dma_prep_dma_cyclic;
-        dma_dev->device_control = ep93xx_dma_control;
+        dma_dev->device_config = ep93xx_dma_slave_config;
+        dma_dev->device_terminate_all = ep93xx_dma_terminate_all;
         dma_dev->device_issue_pending = ep93xx_dma_issue_pending;
         dma_dev->device_tx_status = ep93xx_dma_tx_status;
 
diff --git a/drivers/dma/fsl-edma.c b/drivers/dma/fsl-edma.c
index e9ebb89e1711..09e2842d15ec 100644
--- a/drivers/dma/fsl-edma.c
+++ b/drivers/dma/fsl-edma.c
@@ -289,62 +289,69 @@ static void fsl_edma_free_desc(struct virt_dma_desc *vdesc)
         kfree(fsl_desc);
 }
 
-static int fsl_edma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                unsigned long arg)
+static int fsl_edma_terminate_all(struct dma_chan *chan)
 {
         struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
-        struct dma_slave_config *cfg = (void *)arg;
         unsigned long flags;
         LIST_HEAD(head);
 
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
+        spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
+        fsl_edma_disable_request(fsl_chan);
+        fsl_chan->edesc = NULL;
+        vchan_get_all_descriptors(&fsl_chan->vchan, &head);
+        spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
+        vchan_dma_desc_free_list(&fsl_chan->vchan, &head);
+        return 0;
+}
+
+static int fsl_edma_pause(struct dma_chan *chan)
+{
+        struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
+        if (fsl_chan->edesc) {
                 fsl_edma_disable_request(fsl_chan);
-                fsl_chan->edesc = NULL;
-                vchan_get_all_descriptors(&fsl_chan->vchan, &head);
-                spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
-                vchan_dma_desc_free_list(&fsl_chan->vchan, &head);
-                return 0;
-
-        case DMA_SLAVE_CONFIG:
-                fsl_chan->fsc.dir = cfg->direction;
-                if (cfg->direction == DMA_DEV_TO_MEM) {
-                        fsl_chan->fsc.dev_addr = cfg->src_addr;
-                        fsl_chan->fsc.addr_width = cfg->src_addr_width;
-                        fsl_chan->fsc.burst = cfg->src_maxburst;
-                        fsl_chan->fsc.attr = fsl_edma_get_tcd_attr(cfg->src_addr_width);
-                } else if (cfg->direction == DMA_MEM_TO_DEV) {
-                        fsl_chan->fsc.dev_addr = cfg->dst_addr;
-                        fsl_chan->fsc.addr_width = cfg->dst_addr_width;
-                        fsl_chan->fsc.burst = cfg->dst_maxburst;
-                        fsl_chan->fsc.attr = fsl_edma_get_tcd_attr(cfg->dst_addr_width);
-                } else {
-                        return -EINVAL;
-                }
-                return 0;
+                fsl_chan->status = DMA_PAUSED;
+        }
+        spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
+        return 0;
+}
 
-        case DMA_PAUSE:
-                spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
-                if (fsl_chan->edesc) {
-                        fsl_edma_disable_request(fsl_chan);
-                        fsl_chan->status = DMA_PAUSED;
-                }
-                spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
-                return 0;
-
-        case DMA_RESUME:
-                spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
-                if (fsl_chan->edesc) {
-                        fsl_edma_enable_request(fsl_chan);
-                        fsl_chan->status = DMA_IN_PROGRESS;
-                }
-                spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
-                return 0;
+static int fsl_edma_resume(struct dma_chan *chan)
+{
+        struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
+        unsigned long flags;
 
-        default:
-                return -ENXIO;
+        spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
+        if (fsl_chan->edesc) {
+                fsl_edma_enable_request(fsl_chan);
+                fsl_chan->status = DMA_IN_PROGRESS;
+        }
+        spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
+        return 0;
+}
+
+static int fsl_edma_slave_config(struct dma_chan *chan,
+                                 struct dma_slave_config *cfg)
+{
+        struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
+
+        fsl_chan->fsc.dir = cfg->direction;
+        if (cfg->direction == DMA_DEV_TO_MEM) {
+                fsl_chan->fsc.dev_addr = cfg->src_addr;
+                fsl_chan->fsc.addr_width = cfg->src_addr_width;
+                fsl_chan->fsc.burst = cfg->src_maxburst;
+                fsl_chan->fsc.attr = fsl_edma_get_tcd_attr(cfg->src_addr_width);
+        } else if (cfg->direction == DMA_MEM_TO_DEV) {
+                fsl_chan->fsc.dev_addr = cfg->dst_addr;
+                fsl_chan->fsc.addr_width = cfg->dst_addr_width;
+                fsl_chan->fsc.burst = cfg->dst_maxburst;
+                fsl_chan->fsc.attr = fsl_edma_get_tcd_attr(cfg->dst_addr_width);
+        } else {
+                        return -EINVAL;
         }
+        return 0;
 }
 
 static size_t fsl_edma_desc_residue(struct fsl_edma_chan *fsl_chan,
@@ -780,18 +787,6 @@ static void fsl_edma_free_chan_resources(struct dma_chan *chan)
         fsl_chan->tcd_pool = NULL;
 }
 
-static int fsl_dma_device_slave_caps(struct dma_chan *dchan,
-                struct dma_slave_caps *caps)
-{
-        caps->src_addr_widths = FSL_EDMA_BUSWIDTHS;
-        caps->dstn_addr_widths = FSL_EDMA_BUSWIDTHS;
-        caps->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
-        caps->cmd_pause = true;
-        caps->cmd_terminate = true;
-
-        return 0;
-}
-
 static int
 fsl_edma_irq_init(struct platform_device *pdev, struct fsl_edma_engine *fsl_edma)
 {
@@ -917,9 +912,15 @@ static int fsl_edma_probe(struct platform_device *pdev)
         fsl_edma->dma_dev.device_tx_status = fsl_edma_tx_status;
         fsl_edma->dma_dev.device_prep_slave_sg = fsl_edma_prep_slave_sg;
         fsl_edma->dma_dev.device_prep_dma_cyclic = fsl_edma_prep_dma_cyclic;
-        fsl_edma->dma_dev.device_control = fsl_edma_control;
+        fsl_edma->dma_dev.device_config = fsl_edma_slave_config;
+        fsl_edma->dma_dev.device_pause = fsl_edma_pause;
+        fsl_edma->dma_dev.device_resume = fsl_edma_resume;
+        fsl_edma->dma_dev.device_terminate_all = fsl_edma_terminate_all;
         fsl_edma->dma_dev.device_issue_pending = fsl_edma_issue_pending;
-        fsl_edma->dma_dev.device_slave_caps = fsl_dma_device_slave_caps;
+
+        fsl_edma->dma_dev.src_addr_widths = FSL_EDMA_BUSWIDTHS;
+        fsl_edma->dma_dev.dst_addr_widths = FSL_EDMA_BUSWIDTHS;
+        fsl_edma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
 
         platform_set_drvdata(pdev, fsl_edma);
 
diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index 38821cdf862b..300f821f1890 100644
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -941,84 +941,56 @@ fail:
         return NULL;
 }
 
-/**
- * fsl_dma_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
- * @chan: DMA channel
- * @sgl: scatterlist to transfer to/from
- * @sg_len: number of entries in @scatterlist
- * @direction: DMA direction
- * @flags: DMAEngine flags
- * @context: transaction context (ignored)
- *
- * Prepare a set of descriptors for a DMA_SLAVE transaction. Following the
- * DMA_SLAVE API, this gets the device-specific information from the
- * chan->private variable.
- */
-static struct dma_async_tx_descriptor *fsl_dma_prep_slave_sg(
-        struct dma_chan *dchan, struct scatterlist *sgl, unsigned int sg_len,
-        enum dma_transfer_direction direction, unsigned long flags,
-        void *context)
+static int fsl_dma_device_terminate_all(struct dma_chan *dchan)
 {
-        /*
-         * This operation is not supported on the Freescale DMA controller
-         *
-         * However, we need to provide the function pointer to allow the
-         * device_control() method to work.
-         */
-        return NULL;
-}
-
-static int fsl_dma_device_control(struct dma_chan *dchan,
-                                  enum dma_ctrl_cmd cmd, unsigned long arg)
-{
-        struct dma_slave_config *config;
         struct fsldma_chan *chan;
-        int size;
 
         if (!dchan)
                 return -EINVAL;
 
         chan = to_fsl_chan(dchan);
 
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                spin_lock_bh(&chan->desc_lock);
-
-                /* Halt the DMA engine */
-                dma_halt(chan);
+        spin_lock_bh(&chan->desc_lock);
 
-                /* Remove and free all of the descriptors in the LD queue */
-                fsldma_free_desc_list(chan, &chan->ld_pending);
-                fsldma_free_desc_list(chan, &chan->ld_running);
-                fsldma_free_desc_list(chan, &chan->ld_completed);
-                chan->idle = true;
+        /* Halt the DMA engine */
+        dma_halt(chan);
 
-                spin_unlock_bh(&chan->desc_lock);
-                return 0;
+        /* Remove and free all of the descriptors in the LD queue */
+        fsldma_free_desc_list(chan, &chan->ld_pending);
+        fsldma_free_desc_list(chan, &chan->ld_running);
+        fsldma_free_desc_list(chan, &chan->ld_completed);
+        chan->idle = true;
 
-        case DMA_SLAVE_CONFIG:
-                config = (struct dma_slave_config *)arg;
+        spin_unlock_bh(&chan->desc_lock);
+        return 0;
+}
 
-                /* make sure the channel supports setting burst size */
-                if (!chan->set_request_count)
-                        return -ENXIO;
+static int fsl_dma_device_config(struct dma_chan *dchan,
+                                 struct dma_slave_config *config)
+{
+        struct fsldma_chan *chan;
+        int size;
 
-                /* we set the controller burst size depending on direction */
-                if (config->direction == DMA_MEM_TO_DEV)
-                        size = config->dst_addr_width * config->dst_maxburst;
-                else
-                        size = config->src_addr_width * config->src_maxburst;
+        if (!dchan)
+                return -EINVAL;
 
-                chan->set_request_count(chan, size);
-                return 0;
+        chan = to_fsl_chan(dchan);
 
-        default:
+        /* make sure the channel supports setting burst size */
+        if (!chan->set_request_count)
                 return -ENXIO;
-        }
 
+        /* we set the controller burst size depending on direction */
+        if (config->direction == DMA_MEM_TO_DEV)
+                size = config->dst_addr_width * config->dst_maxburst;
+        else
+                size = config->src_addr_width * config->src_maxburst;
+
+        chan->set_request_count(chan, size);
         return 0;
 }
 
+
 /**
  * fsl_dma_memcpy_issue_pending - Issue the DMA start command
  * @chan : Freescale DMA channel
@@ -1395,10 +1367,15 @@ static int fsldma_of_probe(struct platform_device *op)
         fdev->common.device_prep_dma_sg = fsl_dma_prep_sg;
         fdev->common.device_tx_status = fsl_tx_status;
         fdev->common.device_issue_pending = fsl_dma_memcpy_issue_pending;
-        fdev->common.device_prep_slave_sg = fsl_dma_prep_slave_sg;
-        fdev->common.device_control = fsl_dma_device_control;
+        fdev->common.device_config = fsl_dma_device_config;
+        fdev->common.device_terminate_all = fsl_dma_device_terminate_all;
         fdev->common.dev = &op->dev;
 
+        fdev->common.src_addr_widths = FSL_DMA_BUSWIDTHS;
+        fdev->common.dst_addr_widths = FSL_DMA_BUSWIDTHS;
+        fdev->common.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        fdev->common.residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;
+
         dma_set_mask(&(op->dev), DMA_BIT_MASK(36));
 
         platform_set_drvdata(op, fdev);
diff --git a/drivers/dma/fsldma.h b/drivers/dma/fsldma.h
index 239c20c84382..31bffccdcc75 100644
--- a/drivers/dma/fsldma.h
+++ b/drivers/dma/fsldma.h
@@ -83,6 +83,10 @@
 #define FSL_DMA_DGSR_EOSI       0x02
 #define FSL_DMA_DGSR_EOLSI      0x01
 
+#define FSL_DMA_BUSWIDTHS       (BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) | \
+                                BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) | \
+                                BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | \
+                                BIT(DMA_SLAVE_BUSWIDTH_8_BYTES))
 typedef u64 __bitwise v64;
 typedef u32 __bitwise v32;
 
diff --git a/drivers/dma/img-mdc-dma.c b/drivers/dma/img-mdc-dma.c
new file mode 100644
index 000000000000..ed045a9ad634
--- /dev/null
+++ b/drivers/dma/img-mdc-dma.c
@@ -0,0 +1,1011 @@
+/*
+ * IMG Multi-threaded DMA Controller (MDC)
+ *
+ * Copyright (C) 2009,2012,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/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/dmapool.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_dma.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
+#include "dmaengine.h"
+#include "virt-dma.h"
+
+#define MDC_MAX_DMA_CHANNELS                    32
+
+#define MDC_GENERAL_CONFIG                      0x000
+#define MDC_GENERAL_CONFIG_LIST_IEN             BIT(31)
+#define MDC_GENERAL_CONFIG_IEN                  BIT(29)
+#define MDC_GENERAL_CONFIG_LEVEL_INT            BIT(28)
+#define MDC_GENERAL_CONFIG_INC_W                BIT(12)
+#define MDC_GENERAL_CONFIG_INC_R                BIT(8)
+#define MDC_GENERAL_CONFIG_PHYSICAL_W           BIT(7)
+#define MDC_GENERAL_CONFIG_WIDTH_W_SHIFT        4
+#define MDC_GENERAL_CONFIG_WIDTH_W_MASK         0x7
+#define MDC_GENERAL_CONFIG_PHYSICAL_R           BIT(3)
+#define MDC_GENERAL_CONFIG_WIDTH_R_SHIFT        0
+#define MDC_GENERAL_CONFIG_WIDTH_R_MASK         0x7
+
+#define MDC_READ_PORT_CONFIG                    0x004
+#define MDC_READ_PORT_CONFIG_STHREAD_SHIFT      28
+#define MDC_READ_PORT_CONFIG_STHREAD_MASK       0xf
+#define MDC_READ_PORT_CONFIG_RTHREAD_SHIFT      24
+#define MDC_READ_PORT_CONFIG_RTHREAD_MASK       0xf
+#define MDC_READ_PORT_CONFIG_WTHREAD_SHIFT      16
+#define MDC_READ_PORT_CONFIG_WTHREAD_MASK       0xf
+#define MDC_READ_PORT_CONFIG_BURST_SIZE_SHIFT   4
+#define MDC_READ_PORT_CONFIG_BURST_SIZE_MASK    0xff
+#define MDC_READ_PORT_CONFIG_DREQ_ENABLE        BIT(1)
+
+#define MDC_READ_ADDRESS                        0x008
+
+#define MDC_WRITE_ADDRESS                       0x00c
+
+#define MDC_TRANSFER_SIZE                       0x010
+#define MDC_TRANSFER_SIZE_MASK                  0xffffff
+
+#define MDC_LIST_NODE_ADDRESS                   0x014
+
+#define MDC_CMDS_PROCESSED                      0x018
+#define MDC_CMDS_PROCESSED_CMDS_PROCESSED_SHIFT 16
+#define MDC_CMDS_PROCESSED_CMDS_PROCESSED_MASK  0x3f
+#define MDC_CMDS_PROCESSED_INT_ACTIVE           BIT(8)
+#define MDC_CMDS_PROCESSED_CMDS_DONE_SHIFT      0
+#define MDC_CMDS_PROCESSED_CMDS_DONE_MASK       0x3f
+
+#define MDC_CONTROL_AND_STATUS                  0x01c
+#define MDC_CONTROL_AND_STATUS_CANCEL           BIT(20)
+#define MDC_CONTROL_AND_STATUS_LIST_EN          BIT(4)
+#define MDC_CONTROL_AND_STATUS_EN               BIT(0)
+
+#define MDC_ACTIVE_TRANSFER_SIZE                0x030
+
+#define MDC_GLOBAL_CONFIG_A                             0x900
+#define MDC_GLOBAL_CONFIG_A_THREAD_ID_WIDTH_SHIFT       16
+#define MDC_GLOBAL_CONFIG_A_THREAD_ID_WIDTH_MASK        0xff
+#define MDC_GLOBAL_CONFIG_A_DMA_CONTEXTS_SHIFT          8
+#define MDC_GLOBAL_CONFIG_A_DMA_CONTEXTS_MASK           0xff
+#define MDC_GLOBAL_CONFIG_A_SYS_DAT_WIDTH_SHIFT         0
+#define MDC_GLOBAL_CONFIG_A_SYS_DAT_WIDTH_MASK          0xff
+
+struct mdc_hw_list_desc {
+        u32 gen_conf;
+        u32 readport_conf;
+        u32 read_addr;
+        u32 write_addr;
+        u32 xfer_size;
+        u32 node_addr;
+        u32 cmds_done;
+        u32 ctrl_status;
+        /*
+         * Not part of the list descriptor, but instead used by the CPU to
+         * traverse the list.
+         */
+        struct mdc_hw_list_desc *next_desc;
+};
+
+struct mdc_tx_desc {
+        struct mdc_chan *chan;
+        struct virt_dma_desc vd;
+        dma_addr_t list_phys;
+        struct mdc_hw_list_desc *list;
+        bool cyclic;
+        bool cmd_loaded;
+        unsigned int list_len;
+        unsigned int list_period_len;
+        size_t list_xfer_size;
+        unsigned int list_cmds_done;
+};
+
+struct mdc_chan {
+        struct mdc_dma *mdma;
+        struct virt_dma_chan vc;
+        struct dma_slave_config config;
+        struct mdc_tx_desc *desc;
+        int irq;
+        unsigned int periph;
+        unsigned int thread;
+        unsigned int chan_nr;
+};
+
+struct mdc_dma_soc_data {
+        void (*enable_chan)(struct mdc_chan *mchan);
+        void (*disable_chan)(struct mdc_chan *mchan);
+};
+
+struct mdc_dma {
+        struct dma_device dma_dev;
+        void __iomem *regs;
+        struct clk *clk;
+        struct dma_pool *desc_pool;
+        struct regmap *periph_regs;
+        spinlock_t lock;
+        unsigned int nr_threads;
+        unsigned int nr_channels;
+        unsigned int bus_width;
+        unsigned int max_burst_mult;
+        unsigned int max_xfer_size;
+        const struct mdc_dma_soc_data *soc;
+        struct mdc_chan channels[MDC_MAX_DMA_CHANNELS];
+};
+
+static inline u32 mdc_readl(struct mdc_dma *mdma, u32 reg)
+{
+        return readl(mdma->regs + reg);
+}
+
+static inline void mdc_writel(struct mdc_dma *mdma, u32 val, u32 reg)
+{
+        writel(val, mdma->regs + reg);
+}
+
+static inline u32 mdc_chan_readl(struct mdc_chan *mchan, u32 reg)
+{
+        return mdc_readl(mchan->mdma, mchan->chan_nr * 0x040 + reg);
+}
+
+static inline void mdc_chan_writel(struct mdc_chan *mchan, u32 val, u32 reg)
+{
+        mdc_writel(mchan->mdma, val, mchan->chan_nr * 0x040 + reg);
+}
+
+static inline struct mdc_chan *to_mdc_chan(struct dma_chan *c)
+{
+        return container_of(to_virt_chan(c), struct mdc_chan, vc);
+}
+
+static inline struct mdc_tx_desc *to_mdc_desc(struct dma_async_tx_descriptor *t)
+{
+        struct virt_dma_desc *vdesc = container_of(t, struct virt_dma_desc, tx);
+
+        return container_of(vdesc, struct mdc_tx_desc, vd);
+}
+
+static inline struct device *mdma2dev(struct mdc_dma *mdma)
+{
+        return mdma->dma_dev.dev;
+}
+
+static inline unsigned int to_mdc_width(unsigned int bytes)
+{
+        return ffs(bytes) - 1;
+}
+
+static inline void mdc_set_read_width(struct mdc_hw_list_desc *ldesc,
+                                      unsigned int bytes)
+{
+        ldesc->gen_conf |= to_mdc_width(bytes) <<
+                MDC_GENERAL_CONFIG_WIDTH_R_SHIFT;
+}
+
+static inline void mdc_set_write_width(struct mdc_hw_list_desc *ldesc,
+                                       unsigned int bytes)
+{
+        ldesc->gen_conf |= to_mdc_width(bytes) <<
+                MDC_GENERAL_CONFIG_WIDTH_W_SHIFT;
+}
+
+static void mdc_list_desc_config(struct mdc_chan *mchan,
+                                 struct mdc_hw_list_desc *ldesc,
+                                 enum dma_transfer_direction dir,
+                                 dma_addr_t src, dma_addr_t dst, size_t len)
+{
+        struct mdc_dma *mdma = mchan->mdma;
+        unsigned int max_burst, burst_size;
+
+        ldesc->gen_conf = MDC_GENERAL_CONFIG_IEN | MDC_GENERAL_CONFIG_LIST_IEN |
+                MDC_GENERAL_CONFIG_LEVEL_INT | MDC_GENERAL_CONFIG_PHYSICAL_W |
+                MDC_GENERAL_CONFIG_PHYSICAL_R;
+        ldesc->readport_conf =
+                (mchan->thread << MDC_READ_PORT_CONFIG_STHREAD_SHIFT) |
+                (mchan->thread << MDC_READ_PORT_CONFIG_RTHREAD_SHIFT) |
+                (mchan->thread << MDC_READ_PORT_CONFIG_WTHREAD_SHIFT);
+        ldesc->read_addr = src;
+        ldesc->write_addr = dst;
+        ldesc->xfer_size = len - 1;
+        ldesc->node_addr = 0;
+        ldesc->cmds_done = 0;
+        ldesc->ctrl_status = MDC_CONTROL_AND_STATUS_LIST_EN |
+                MDC_CONTROL_AND_STATUS_EN;
+        ldesc->next_desc = NULL;
+
+        if (IS_ALIGNED(dst, mdma->bus_width) &&
+            IS_ALIGNED(src, mdma->bus_width))
+                max_burst = mdma->bus_width * mdma->max_burst_mult;
+        else
+                max_burst = mdma->bus_width * (mdma->max_burst_mult - 1);
+
+        if (dir == DMA_MEM_TO_DEV) {
+                ldesc->gen_conf |= MDC_GENERAL_CONFIG_INC_R;
+                ldesc->readport_conf |= MDC_READ_PORT_CONFIG_DREQ_ENABLE;
+                mdc_set_read_width(ldesc, mdma->bus_width);
+                mdc_set_write_width(ldesc, mchan->config.dst_addr_width);
+                burst_size = min(max_burst, mchan->config.dst_maxburst *
+                                 mchan->config.dst_addr_width);
+        } else if (dir == DMA_DEV_TO_MEM) {
+                ldesc->gen_conf |= MDC_GENERAL_CONFIG_INC_W;
+                ldesc->readport_conf |= MDC_READ_PORT_CONFIG_DREQ_ENABLE;
+                mdc_set_read_width(ldesc, mchan->config.src_addr_width);
+                mdc_set_write_width(ldesc, mdma->bus_width);
+                burst_size = min(max_burst, mchan->config.src_maxburst *
+                                 mchan->config.src_addr_width);
+        } else {
+                ldesc->gen_conf |= MDC_GENERAL_CONFIG_INC_R |
+                        MDC_GENERAL_CONFIG_INC_W;
+                mdc_set_read_width(ldesc, mdma->bus_width);
+                mdc_set_write_width(ldesc, mdma->bus_width);
+                burst_size = max_burst;
+        }
+        ldesc->readport_conf |= (burst_size - 1) <<
+                MDC_READ_PORT_CONFIG_BURST_SIZE_SHIFT;
+}
+
+static void mdc_list_desc_free(struct mdc_tx_desc *mdesc)
+{
+        struct mdc_dma *mdma = mdesc->chan->mdma;
+        struct mdc_hw_list_desc *curr, *next;
+        dma_addr_t curr_phys, next_phys;
+
+        curr = mdesc->list;
+        curr_phys = mdesc->list_phys;
+        while (curr) {
+                next = curr->next_desc;
+                next_phys = curr->node_addr;
+                dma_pool_free(mdma->desc_pool, curr, curr_phys);
+                curr = next;
+                curr_phys = next_phys;
+        }
+}
+
+static void mdc_desc_free(struct virt_dma_desc *vd)
+{
+        struct mdc_tx_desc *mdesc = to_mdc_desc(&vd->tx);
+
+        mdc_list_desc_free(mdesc);
+        kfree(mdesc);
+}
+
+static struct dma_async_tx_descriptor *mdc_prep_dma_memcpy(
+        struct dma_chan *chan, dma_addr_t dest, dma_addr_t src, size_t len,
+        unsigned long flags)
+{
+        struct mdc_chan *mchan = to_mdc_chan(chan);
+        struct mdc_dma *mdma = mchan->mdma;
+        struct mdc_tx_desc *mdesc;
+        struct mdc_hw_list_desc *curr, *prev = NULL;
+        dma_addr_t curr_phys, prev_phys;
+
+        if (!len)
+                return NULL;
+
+        mdesc = kzalloc(sizeof(*mdesc), GFP_NOWAIT);
+        if (!mdesc)
+                return NULL;
+        mdesc->chan = mchan;
+        mdesc->list_xfer_size = len;
+
+        while (len > 0) {
+                size_t xfer_size;
+
+                curr = dma_pool_alloc(mdma->desc_pool, GFP_NOWAIT, &curr_phys);
+                if (!curr)
+                        goto free_desc;
+
+                if (prev) {
+                        prev->node_addr = curr_phys;
+                        prev->next_desc = curr;
+                } else {
+                        mdesc->list_phys = curr_phys;
+                        mdesc->list = curr;
+                }
+
+                xfer_size = min_t(size_t, mdma->max_xfer_size, len);
+
+                mdc_list_desc_config(mchan, curr, DMA_MEM_TO_MEM, src, dest,
+                                     xfer_size);
+
+                prev = curr;
+                prev_phys = curr_phys;
+
+                mdesc->list_len++;
+                src += xfer_size;
+                dest += xfer_size;
+                len -= xfer_size;
+        }
+
+        return vchan_tx_prep(&mchan->vc, &mdesc->vd, flags);
+
+free_desc:
+        mdc_desc_free(&mdesc->vd);
+
+        return NULL;
+}
+
+static int mdc_check_slave_width(struct mdc_chan *mchan,
+                                 enum dma_transfer_direction dir)
+{
+        enum dma_slave_buswidth width;
+
+        if (dir == DMA_MEM_TO_DEV)
+                width = mchan->config.dst_addr_width;
+        else
+                width = mchan->config.src_addr_width;
+
+        switch (width) {
+        case DMA_SLAVE_BUSWIDTH_1_BYTE:
+        case DMA_SLAVE_BUSWIDTH_2_BYTES:
+        case DMA_SLAVE_BUSWIDTH_4_BYTES:
+        case DMA_SLAVE_BUSWIDTH_8_BYTES:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (width > mchan->mdma->bus_width)
+                return -EINVAL;
+
+        return 0;
+}
+
+static struct dma_async_tx_descriptor *mdc_prep_dma_cyclic(
+        struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
+        size_t period_len, enum dma_transfer_direction dir,
+        unsigned long flags)
+{
+        struct mdc_chan *mchan = to_mdc_chan(chan);
+        struct mdc_dma *mdma = mchan->mdma;
+        struct mdc_tx_desc *mdesc;
+        struct mdc_hw_list_desc *curr, *prev = NULL;
+        dma_addr_t curr_phys, prev_phys;
+
+        if (!buf_len && !period_len)
+                return NULL;
+
+        if (!is_slave_direction(dir))
+                return NULL;
+
+        if (mdc_check_slave_width(mchan, dir) < 0)
+                return NULL;
+
+        mdesc = kzalloc(sizeof(*mdesc), GFP_NOWAIT);
+        if (!mdesc)
+                return NULL;
+        mdesc->chan = mchan;
+        mdesc->cyclic = true;
+        mdesc->list_xfer_size = buf_len;
+        mdesc->list_period_len = DIV_ROUND_UP(period_len,
+                                              mdma->max_xfer_size);
+
+        while (buf_len > 0) {
+                size_t remainder = min(period_len, buf_len);
+
+                while (remainder > 0) {
+                        size_t xfer_size;
+
+                        curr = dma_pool_alloc(mdma->desc_pool, GFP_NOWAIT,
+                                              &curr_phys);
+                        if (!curr)
+                                goto free_desc;
+
+                        if (!prev) {
+                                mdesc->list_phys = curr_phys;
+                                mdesc->list = curr;
+                        } else {
+                                prev->node_addr = curr_phys;
+                                prev->next_desc = curr;
+                        }
+
+                        xfer_size = min_t(size_t, mdma->max_xfer_size,
+                                          remainder);
+
+                        if (dir == DMA_MEM_TO_DEV) {
+                                mdc_list_desc_config(mchan, curr, dir,
+                                                     buf_addr,
+                                                     mchan->config.dst_addr,
+                                                     xfer_size);
+                        } else {
+                                mdc_list_desc_config(mchan, curr, dir,
+                                                     mchan->config.src_addr,
+                                                     buf_addr,
+                                                     xfer_size);
+                        }
+
+                        prev = curr;
+                        prev_phys = curr_phys;
+
+                        mdesc->list_len++;
+                        buf_addr += xfer_size;
+                        buf_len -= xfer_size;
+                        remainder -= xfer_size;
+                }
+        }
+        prev->node_addr = mdesc->list_phys;
+
+        return vchan_tx_prep(&mchan->vc, &mdesc->vd, flags);
+
+free_desc:
+        mdc_desc_free(&mdesc->vd);
+
+        return NULL;
+}
+
+static struct dma_async_tx_descriptor *mdc_prep_slave_sg(
+        struct dma_chan *chan, struct scatterlist *sgl,
+        unsigned int sg_len, enum dma_transfer_direction dir,
+        unsigned long flags, void *context)
+{
+        struct mdc_chan *mchan = to_mdc_chan(chan);
+        struct mdc_dma *mdma = mchan->mdma;
+        struct mdc_tx_desc *mdesc;
+        struct scatterlist *sg;
+        struct mdc_hw_list_desc *curr, *prev = NULL;
+        dma_addr_t curr_phys, prev_phys;
+        unsigned int i;
+
+        if (!sgl)
+                return NULL;
+
+        if (!is_slave_direction(dir))
+                return NULL;
+
+        if (mdc_check_slave_width(mchan, dir) < 0)
+                return NULL;
+
+        mdesc = kzalloc(sizeof(*mdesc), GFP_NOWAIT);
+        if (!mdesc)
+                return NULL;
+        mdesc->chan = mchan;
+
+        for_each_sg(sgl, sg, sg_len, i) {
+                dma_addr_t buf = sg_dma_address(sg);
+                size_t buf_len = sg_dma_len(sg);
+
+                while (buf_len > 0) {
+                        size_t xfer_size;
+
+                        curr = dma_pool_alloc(mdma->desc_pool, GFP_NOWAIT,
+                                              &curr_phys);
+                        if (!curr)
+                                goto free_desc;
+
+                        if (!prev) {
+                                mdesc->list_phys = curr_phys;
+                                mdesc->list = curr;
+                        } else {
+                                prev->node_addr = curr_phys;
+                                prev->next_desc = curr;
+                        }
+
+                        xfer_size = min_t(size_t, mdma->max_xfer_size,
+                                          buf_len);
+
+                        if (dir == DMA_MEM_TO_DEV) {
+                                mdc_list_desc_config(mchan, curr, dir, buf,
+                                                     mchan->config.dst_addr,
+                                                     xfer_size);
+                        } else {
+                                mdc_list_desc_config(mchan, curr, dir,
+                                                     mchan->config.src_addr,
+                                                     buf, xfer_size);
+                        }
+
+                        prev = curr;
+                        prev_phys = curr_phys;
+
+                        mdesc->list_len++;
+                        mdesc->list_xfer_size += xfer_size;
+                        buf += xfer_size;
+                        buf_len -= xfer_size;
+                }
+        }
+
+        return vchan_tx_prep(&mchan->vc, &mdesc->vd, flags);
+
+free_desc:
+        mdc_desc_free(&mdesc->vd);
+
+        return NULL;
+}
+
+static void mdc_issue_desc(struct mdc_chan *mchan)
+{
+        struct mdc_dma *mdma = mchan->mdma;
+        struct virt_dma_desc *vd;
+        struct mdc_tx_desc *mdesc;
+        u32 val;
+
+        vd = vchan_next_desc(&mchan->vc);
+        if (!vd)
+                return;
+
+        list_del(&vd->node);
+
+        mdesc = to_mdc_desc(&vd->tx);
+        mchan->desc = mdesc;
+
+        dev_dbg(mdma2dev(mdma), "Issuing descriptor on channel %d\n",
+                mchan->chan_nr);
+
+        mdma->soc->enable_chan(mchan);
+
+        val = mdc_chan_readl(mchan, MDC_GENERAL_CONFIG);
+        val |= MDC_GENERAL_CONFIG_LIST_IEN | MDC_GENERAL_CONFIG_IEN |
+                MDC_GENERAL_CONFIG_LEVEL_INT | MDC_GENERAL_CONFIG_PHYSICAL_W |
+                MDC_GENERAL_CONFIG_PHYSICAL_R;
+        mdc_chan_writel(mchan, val, MDC_GENERAL_CONFIG);
+        val = (mchan->thread << MDC_READ_PORT_CONFIG_STHREAD_SHIFT) |
+                (mchan->thread << MDC_READ_PORT_CONFIG_RTHREAD_SHIFT) |
+                (mchan->thread << MDC_READ_PORT_CONFIG_WTHREAD_SHIFT);
+        mdc_chan_writel(mchan, val, MDC_READ_PORT_CONFIG);
+        mdc_chan_writel(mchan, mdesc->list_phys, MDC_LIST_NODE_ADDRESS);
+        val = mdc_chan_readl(mchan, MDC_CONTROL_AND_STATUS);
+        val |= MDC_CONTROL_AND_STATUS_LIST_EN;
+        mdc_chan_writel(mchan, val, MDC_CONTROL_AND_STATUS);
+}
+
+static void mdc_issue_pending(struct dma_chan *chan)
+{
+        struct mdc_chan *mchan = to_mdc_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&mchan->vc.lock, flags);
+        if (vchan_issue_pending(&mchan->vc) && !mchan->desc)
+                mdc_issue_desc(mchan);
+        spin_unlock_irqrestore(&mchan->vc.lock, flags);
+}
+
+static enum dma_status mdc_tx_status(struct dma_chan *chan,
+        dma_cookie_t cookie, struct dma_tx_state *txstate)
+{
+        struct mdc_chan *mchan = to_mdc_chan(chan);
+        struct mdc_tx_desc *mdesc;
+        struct virt_dma_desc *vd;
+        unsigned long flags;
+        size_t bytes = 0;
+        int ret;
+
+        ret = dma_cookie_status(chan, cookie, txstate);
+        if (ret == DMA_COMPLETE)
+                return ret;
+
+        if (!txstate)
+                return ret;
+
+        spin_lock_irqsave(&mchan->vc.lock, flags);
+        vd = vchan_find_desc(&mchan->vc, cookie);
+        if (vd) {
+                mdesc = to_mdc_desc(&vd->tx);
+                bytes = mdesc->list_xfer_size;
+        } else if (mchan->desc && mchan->desc->vd.tx.cookie == cookie) {
+                struct mdc_hw_list_desc *ldesc;
+                u32 val1, val2, done, processed, residue;
+                int i, cmds;
+
+                mdesc = mchan->desc;
+
+                /*
+                 * Determine the number of commands that haven't been
+                 * processed (handled by the IRQ handler) yet.
+                 */
+                do {
+                        val1 = mdc_chan_readl(mchan, MDC_CMDS_PROCESSED) &
+                                ~MDC_CMDS_PROCESSED_INT_ACTIVE;
+                        residue = mdc_chan_readl(mchan,
+                                                 MDC_ACTIVE_TRANSFER_SIZE);
+                        val2 = mdc_chan_readl(mchan, MDC_CMDS_PROCESSED) &
+                                ~MDC_CMDS_PROCESSED_INT_ACTIVE;
+                } while (val1 != val2);
+
+                done = (val1 >> MDC_CMDS_PROCESSED_CMDS_DONE_SHIFT) &
+                        MDC_CMDS_PROCESSED_CMDS_DONE_MASK;
+                processed = (val1 >> MDC_CMDS_PROCESSED_CMDS_PROCESSED_SHIFT) &
+                        MDC_CMDS_PROCESSED_CMDS_PROCESSED_MASK;
+                cmds = (done - processed) %
+                        (MDC_CMDS_PROCESSED_CMDS_DONE_MASK + 1);
+
+                /*
+                 * If the command loaded event hasn't been processed yet, then
+                 * the difference above includes an extra command.
+                 */
+                if (!mdesc->cmd_loaded)
+                        cmds--;
+                else
+                        cmds += mdesc->list_cmds_done;
+
+                bytes = mdesc->list_xfer_size;
+                ldesc = mdesc->list;
+                for (i = 0; i < cmds; i++) {
+                        bytes -= ldesc->xfer_size + 1;
+                        ldesc = ldesc->next_desc;
+                }
+                if (ldesc) {
+                        if (residue != MDC_TRANSFER_SIZE_MASK)
+                                bytes -= ldesc->xfer_size - residue;
+                        else
+                                bytes -= ldesc->xfer_size + 1;
+                }
+        }
+        spin_unlock_irqrestore(&mchan->vc.lock, flags);
+
+        dma_set_residue(txstate, bytes);
+
+        return ret;
+}
+
+static int mdc_terminate_all(struct dma_chan *chan)
+{
+        struct mdc_chan *mchan = to_mdc_chan(chan);
+        struct mdc_tx_desc *mdesc;
+        unsigned long flags;
+        LIST_HEAD(head);
+
+        spin_lock_irqsave(&mchan->vc.lock, flags);
+
+        mdc_chan_writel(mchan, MDC_CONTROL_AND_STATUS_CANCEL,
+                        MDC_CONTROL_AND_STATUS);
+
+        mdesc = mchan->desc;
+        mchan->desc = NULL;
+        vchan_get_all_descriptors(&mchan->vc, &head);
+
+        spin_unlock_irqrestore(&mchan->vc.lock, flags);
+
+        if (mdesc)
+                mdc_desc_free(&mdesc->vd);
+        vchan_dma_desc_free_list(&mchan->vc, &head);
+
+        return 0;
+}
+
+static int mdc_slave_config(struct dma_chan *chan,
+                            struct dma_slave_config *config)
+{
+        struct mdc_chan *mchan = to_mdc_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&mchan->vc.lock, flags);
+        mchan->config = *config;
+        spin_unlock_irqrestore(&mchan->vc.lock, flags);
+
+        return 0;
+}
+
+static int mdc_alloc_chan_resources(struct dma_chan *chan)
+{
+        return 0;
+}
+
+static void mdc_free_chan_resources(struct dma_chan *chan)
+{
+        struct mdc_chan *mchan = to_mdc_chan(chan);
+        struct mdc_dma *mdma = mchan->mdma;
+
+        mdc_terminate_all(chan);
+
+        mdma->soc->disable_chan(mchan);
+}
+
+static irqreturn_t mdc_chan_irq(int irq, void *dev_id)
+{
+        struct mdc_chan *mchan = (struct mdc_chan *)dev_id;
+        struct mdc_tx_desc *mdesc;
+        u32 val, processed, done1, done2;
+        unsigned int i;
+
+        spin_lock(&mchan->vc.lock);
+
+        val = mdc_chan_readl(mchan, MDC_CMDS_PROCESSED);
+        processed = (val >> MDC_CMDS_PROCESSED_CMDS_PROCESSED_SHIFT) &
+                MDC_CMDS_PROCESSED_CMDS_PROCESSED_MASK;
+        /*
+         * CMDS_DONE may have incremented between reading CMDS_PROCESSED
+         * and clearing INT_ACTIVE.  Re-read CMDS_PROCESSED to ensure we
+         * didn't miss a command completion.
+         */
+        do {
+                val = mdc_chan_readl(mchan, MDC_CMDS_PROCESSED);
+                done1 = (val >> MDC_CMDS_PROCESSED_CMDS_DONE_SHIFT) &
+                        MDC_CMDS_PROCESSED_CMDS_DONE_MASK;
+                val &= ~((MDC_CMDS_PROCESSED_CMDS_PROCESSED_MASK <<
+                          MDC_CMDS_PROCESSED_CMDS_PROCESSED_SHIFT) |
+                         MDC_CMDS_PROCESSED_INT_ACTIVE);
+                val |= done1 << MDC_CMDS_PROCESSED_CMDS_PROCESSED_SHIFT;
+                mdc_chan_writel(mchan, val, MDC_CMDS_PROCESSED);
+                val = mdc_chan_readl(mchan, MDC_CMDS_PROCESSED);
+                done2 = (val >> MDC_CMDS_PROCESSED_CMDS_DONE_SHIFT) &
+                        MDC_CMDS_PROCESSED_CMDS_DONE_MASK;
+        } while (done1 != done2);
+
+        dev_dbg(mdma2dev(mchan->mdma), "IRQ on channel %d\n", mchan->chan_nr);
+
+        mdesc = mchan->desc;
+        if (!mdesc) {
+                dev_warn(mdma2dev(mchan->mdma),
+                         "IRQ with no active descriptor on channel %d\n",
+                         mchan->chan_nr);
+                goto out;
+        }
+
+        for (i = processed; i != done1;
+             i = (i + 1) % (MDC_CMDS_PROCESSED_CMDS_PROCESSED_MASK + 1)) {
+                /*
+                 * The first interrupt in a transfer indicates that the
+                 * command list has been loaded, not that a command has
+                 * been completed.
+                 */
+                if (!mdesc->cmd_loaded) {
+                        mdesc->cmd_loaded = true;
+                        continue;
+                }
+
+                mdesc->list_cmds_done++;
+                if (mdesc->cyclic) {
+                        mdesc->list_cmds_done %= mdesc->list_len;
+                        if (mdesc->list_cmds_done % mdesc->list_period_len == 0)
+                                vchan_cyclic_callback(&mdesc->vd);
+                } else if (mdesc->list_cmds_done == mdesc->list_len) {
+                        mchan->desc = NULL;
+                        vchan_cookie_complete(&mdesc->vd);
+                        mdc_issue_desc(mchan);
+                        break;
+                }
+        }
+out:
+        spin_unlock(&mchan->vc.lock);
+
+        return IRQ_HANDLED;
+}
+
+static struct dma_chan *mdc_of_xlate(struct of_phandle_args *dma_spec,
+                                     struct of_dma *ofdma)
+{
+        struct mdc_dma *mdma = ofdma->of_dma_data;
+        struct dma_chan *chan;
+
+        if (dma_spec->args_count != 3)
+                return NULL;
+
+        list_for_each_entry(chan, &mdma->dma_dev.channels, device_node) {
+                struct mdc_chan *mchan = to_mdc_chan(chan);
+
+                if (!(dma_spec->args[1] & BIT(mchan->chan_nr)))
+                        continue;
+                if (dma_get_slave_channel(chan)) {
+                        mchan->periph = dma_spec->args[0];
+                        mchan->thread = dma_spec->args[2];
+                        return chan;
+                }
+        }
+
+        return NULL;
+}
+
+#define PISTACHIO_CR_PERIPH_DMA_ROUTE(ch)       (0x120 + 0x4 * ((ch) / 4))
+#define PISTACHIO_CR_PERIPH_DMA_ROUTE_SHIFT(ch) (8 * ((ch) % 4))
+#define PISTACHIO_CR_PERIPH_DMA_ROUTE_MASK      0x3f
+
+static void pistachio_mdc_enable_chan(struct mdc_chan *mchan)
+{
+        struct mdc_dma *mdma = mchan->mdma;
+
+        regmap_update_bits(mdma->periph_regs,
+                           PISTACHIO_CR_PERIPH_DMA_ROUTE(mchan->chan_nr),
+                           PISTACHIO_CR_PERIPH_DMA_ROUTE_MASK <<
+                           PISTACHIO_CR_PERIPH_DMA_ROUTE_SHIFT(mchan->chan_nr),
+                           mchan->periph <<
+                           PISTACHIO_CR_PERIPH_DMA_ROUTE_SHIFT(mchan->chan_nr));
+}
+
+static void pistachio_mdc_disable_chan(struct mdc_chan *mchan)
+{
+        struct mdc_dma *mdma = mchan->mdma;
+
+        regmap_update_bits(mdma->periph_regs,
+                           PISTACHIO_CR_PERIPH_DMA_ROUTE(mchan->chan_nr),
+                           PISTACHIO_CR_PERIPH_DMA_ROUTE_MASK <<
+                           PISTACHIO_CR_PERIPH_DMA_ROUTE_SHIFT(mchan->chan_nr),
+                           0);
+}
+
+static const struct mdc_dma_soc_data pistachio_mdc_data = {
+        .enable_chan = pistachio_mdc_enable_chan,
+        .disable_chan = pistachio_mdc_disable_chan,
+};
+
+static const struct of_device_id mdc_dma_of_match[] = {
+        { .compatible = "img,pistachio-mdc-dma", .data = &pistachio_mdc_data, },
+        { },
+};
+MODULE_DEVICE_TABLE(of, mdc_dma_of_match);
+
+static int mdc_dma_probe(struct platform_device *pdev)
+{
+        struct mdc_dma *mdma;
+        struct resource *res;
+        const struct of_device_id *match;
+        unsigned int i;
+        u32 val;
+        int ret;
+
+        mdma = devm_kzalloc(&pdev->dev, sizeof(*mdma), GFP_KERNEL);
+        if (!mdma)
+                return -ENOMEM;
+        platform_set_drvdata(pdev, mdma);
+
+        match = of_match_device(mdc_dma_of_match, &pdev->dev);
+        mdma->soc = match->data;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        mdma->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(mdma->regs))
+                return PTR_ERR(mdma->regs);
+
+        mdma->periph_regs = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
+                                                            "img,cr-periph");
+        if (IS_ERR(mdma->periph_regs))
+                return PTR_ERR(mdma->periph_regs);
+
+        mdma->clk = devm_clk_get(&pdev->dev, "sys");
+        if (IS_ERR(mdma->clk))
+                return PTR_ERR(mdma->clk);
+
+        ret = clk_prepare_enable(mdma->clk);
+        if (ret)
+                return ret;
+
+        dma_cap_zero(mdma->dma_dev.cap_mask);
+        dma_cap_set(DMA_SLAVE, mdma->dma_dev.cap_mask);
+        dma_cap_set(DMA_PRIVATE, mdma->dma_dev.cap_mask);
+        dma_cap_set(DMA_CYCLIC, mdma->dma_dev.cap_mask);
+        dma_cap_set(DMA_MEMCPY, mdma->dma_dev.cap_mask);
+
+        val = mdc_readl(mdma, MDC_GLOBAL_CONFIG_A);
+        mdma->nr_channels = (val >> MDC_GLOBAL_CONFIG_A_DMA_CONTEXTS_SHIFT) &
+                MDC_GLOBAL_CONFIG_A_DMA_CONTEXTS_MASK;
+        mdma->nr_threads =
+                1 << ((val >> MDC_GLOBAL_CONFIG_A_THREAD_ID_WIDTH_SHIFT) &
+                      MDC_GLOBAL_CONFIG_A_THREAD_ID_WIDTH_MASK);
+        mdma->bus_width =
+                (1 << ((val >> MDC_GLOBAL_CONFIG_A_SYS_DAT_WIDTH_SHIFT) &
+                       MDC_GLOBAL_CONFIG_A_SYS_DAT_WIDTH_MASK)) / 8;
+        /*
+         * Although transfer sizes of up to MDC_TRANSFER_SIZE_MASK + 1 bytes
+         * are supported, this makes it possible for the value reported in
+         * MDC_ACTIVE_TRANSFER_SIZE to be ambiguous - an active transfer size
+         * of MDC_TRANSFER_SIZE_MASK may indicate either that 0 bytes or
+         * MDC_TRANSFER_SIZE_MASK + 1 bytes are remaining.  To eliminate this
+         * ambiguity, restrict transfer sizes to one bus-width less than the
+         * actual maximum.
+         */
+        mdma->max_xfer_size = MDC_TRANSFER_SIZE_MASK + 1 - mdma->bus_width;
+
+        of_property_read_u32(pdev->dev.of_node, "dma-channels",
+                             &mdma->nr_channels);
+        ret = of_property_read_u32(pdev->dev.of_node,
+                                   "img,max-burst-multiplier",
+                                   &mdma->max_burst_mult);
+        if (ret)
+                goto disable_clk;
+
+        mdma->dma_dev.dev = &pdev->dev;
+        mdma->dma_dev.device_prep_slave_sg = mdc_prep_slave_sg;
+        mdma->dma_dev.device_prep_dma_cyclic = mdc_prep_dma_cyclic;
+        mdma->dma_dev.device_prep_dma_memcpy = mdc_prep_dma_memcpy;
+        mdma->dma_dev.device_alloc_chan_resources = mdc_alloc_chan_resources;
+        mdma->dma_dev.device_free_chan_resources = mdc_free_chan_resources;
+        mdma->dma_dev.device_tx_status = mdc_tx_status;
+        mdma->dma_dev.device_issue_pending = mdc_issue_pending;
+        mdma->dma_dev.device_terminate_all = mdc_terminate_all;
+        mdma->dma_dev.device_config = mdc_slave_config;
+
+        mdma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        mdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
+        for (i = 1; i <= mdma->bus_width; i <<= 1) {
+                mdma->dma_dev.src_addr_widths |= BIT(i);
+                mdma->dma_dev.dst_addr_widths |= BIT(i);
+        }
+
+        INIT_LIST_HEAD(&mdma->dma_dev.channels);
+        for (i = 0; i < mdma->nr_channels; i++) {
+                struct mdc_chan *mchan = &mdma->channels[i];
+
+                mchan->mdma = mdma;
+                mchan->chan_nr = i;
+                mchan->irq = platform_get_irq(pdev, i);
+                if (mchan->irq < 0) {
+                        ret = mchan->irq;
+                        goto disable_clk;
+                }
+                ret = devm_request_irq(&pdev->dev, mchan->irq, mdc_chan_irq,
+                                       IRQ_TYPE_LEVEL_HIGH,
+                                       dev_name(&pdev->dev), mchan);
+                if (ret < 0)
+                        goto disable_clk;
+
+                mchan->vc.desc_free = mdc_desc_free;
+                vchan_init(&mchan->vc, &mdma->dma_dev);
+        }
+
+        mdma->desc_pool = dmam_pool_create(dev_name(&pdev->dev), &pdev->dev,
+                                           sizeof(struct mdc_hw_list_desc),
+                                           4, 0);
+        if (!mdma->desc_pool) {
+                ret = -ENOMEM;
+                goto disable_clk;
+        }
+
+        ret = dma_async_device_register(&mdma->dma_dev);
+        if (ret)
+                goto disable_clk;
+
+        ret = of_dma_controller_register(pdev->dev.of_node, mdc_of_xlate, mdma);
+        if (ret)
+                goto unregister;
+
+        dev_info(&pdev->dev, "MDC with %u channels and %u threads\n",
+                 mdma->nr_channels, mdma->nr_threads);
+
+        return 0;
+
+unregister:
+        dma_async_device_unregister(&mdma->dma_dev);
+disable_clk:
+        clk_disable_unprepare(mdma->clk);
+        return ret;
+}
+
+static int mdc_dma_remove(struct platform_device *pdev)
+{
+        struct mdc_dma *mdma = platform_get_drvdata(pdev);
+        struct mdc_chan *mchan, *next;
+
+        of_dma_controller_free(pdev->dev.of_node);
+        dma_async_device_unregister(&mdma->dma_dev);
+
+        list_for_each_entry_safe(mchan, next, &mdma->dma_dev.channels,
+                                 vc.chan.device_node) {
+                list_del(&mchan->vc.chan.device_node);
+
+                synchronize_irq(mchan->irq);
+                devm_free_irq(&pdev->dev, mchan->irq, mchan);
+
+                tasklet_kill(&mchan->vc.task);
+        }
+
+        clk_disable_unprepare(mdma->clk);
+
+        return 0;
+}
+
+static struct platform_driver mdc_dma_driver = {
+        .driver = {
+                .name = "img-mdc-dma",
+                .of_match_table = of_match_ptr(mdc_dma_of_match),
+        },
+        .probe = mdc_dma_probe,
+        .remove = mdc_dma_remove,
+};
+module_platform_driver(mdc_dma_driver);
+
+MODULE_DESCRIPTION("IMG Multi-threaded DMA Controller (MDC) driver");
+MODULE_AUTHOR("Andrew Bresticker <abrestic@chromium.org>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/dma/imx-dma.c b/drivers/dma/imx-dma.c
index 10bbc0a675b0..eed405976ea9 100644
--- a/drivers/dma/imx-dma.c
+++ b/drivers/dma/imx-dma.c
@@ -230,11 +230,6 @@ static inline int is_imx1_dma(struct imxdma_engine *imxdma)
         return imxdma->devtype == IMX1_DMA;
 }
 
-static inline int is_imx21_dma(struct imxdma_engine *imxdma)
-{
-        return imxdma->devtype == IMX21_DMA;
-}
-
 static inline int is_imx27_dma(struct imxdma_engine *imxdma)
 {
         return imxdma->devtype == IMX27_DMA;
@@ -669,69 +664,67 @@ out:
 
 }
 
-static int imxdma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                unsigned long arg)
+static int imxdma_terminate_all(struct dma_chan *chan)
 {
         struct imxdma_channel *imxdmac = to_imxdma_chan(chan);
-        struct dma_slave_config *dmaengine_cfg = (void *)arg;
         struct imxdma_engine *imxdma = imxdmac->imxdma;
         unsigned long flags;
-        unsigned int mode = 0;
-
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                imxdma_disable_hw(imxdmac);
-
-                spin_lock_irqsave(&imxdma->lock, flags);
-                list_splice_tail_init(&imxdmac->ld_active, &imxdmac->ld_free);
-                list_splice_tail_init(&imxdmac->ld_queue, &imxdmac->ld_free);
-                spin_unlock_irqrestore(&imxdma->lock, flags);
-                return 0;
-        case DMA_SLAVE_CONFIG:
-                if (dmaengine_cfg->direction == DMA_DEV_TO_MEM) {
-                        imxdmac->per_address = dmaengine_cfg->src_addr;
-                        imxdmac->watermark_level = dmaengine_cfg->src_maxburst;
-                        imxdmac->word_size = dmaengine_cfg->src_addr_width;
-                } else {
-                        imxdmac->per_address = dmaengine_cfg->dst_addr;
-                        imxdmac->watermark_level = dmaengine_cfg->dst_maxburst;
-                        imxdmac->word_size = dmaengine_cfg->dst_addr_width;
-                }
 
-                switch (imxdmac->word_size) {
-                case DMA_SLAVE_BUSWIDTH_1_BYTE:
-                        mode = IMX_DMA_MEMSIZE_8;
-                        break;
-                case DMA_SLAVE_BUSWIDTH_2_BYTES:
-                        mode = IMX_DMA_MEMSIZE_16;
-                        break;
-                default:
-                case DMA_SLAVE_BUSWIDTH_4_BYTES:
-                        mode = IMX_DMA_MEMSIZE_32;
-                        break;
-                }
+        imxdma_disable_hw(imxdmac);
 
-                imxdmac->hw_chaining = 0;
+        spin_lock_irqsave(&imxdma->lock, flags);
+        list_splice_tail_init(&imxdmac->ld_active, &imxdmac->ld_free);
+        list_splice_tail_init(&imxdmac->ld_queue, &imxdmac->ld_free);
+        spin_unlock_irqrestore(&imxdma->lock, flags);
+        return 0;
+}
 
-                imxdmac->ccr_from_device = (mode | IMX_DMA_TYPE_FIFO) |
-                        ((IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR) << 2) |
-                        CCR_REN;
-                imxdmac->ccr_to_device =
-                        (IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR) |
-                        ((mode | IMX_DMA_TYPE_FIFO) << 2) | CCR_REN;
-                imx_dmav1_writel(imxdma, imxdmac->dma_request,
-                                 DMA_RSSR(imxdmac->channel));
+static int imxdma_config(struct dma_chan *chan,
+                         struct dma_slave_config *dmaengine_cfg)
+{
+        struct imxdma_channel *imxdmac = to_imxdma_chan(chan);
+        struct imxdma_engine *imxdma = imxdmac->imxdma;
+        unsigned int mode = 0;
 
-                /* Set burst length */
-                imx_dmav1_writel(imxdma, imxdmac->watermark_level *
-                                imxdmac->word_size, DMA_BLR(imxdmac->channel));
+        if (dmaengine_cfg->direction == DMA_DEV_TO_MEM) {
+                imxdmac->per_address = dmaengine_cfg->src_addr;
+                imxdmac->watermark_level = dmaengine_cfg->src_maxburst;
+                imxdmac->word_size = dmaengine_cfg->src_addr_width;
+        } else {
+                imxdmac->per_address = dmaengine_cfg->dst_addr;
+                imxdmac->watermark_level = dmaengine_cfg->dst_maxburst;
+                imxdmac->word_size = dmaengine_cfg->dst_addr_width;
+        }
 
-                return 0;
+        switch (imxdmac->word_size) {
+        case DMA_SLAVE_BUSWIDTH_1_BYTE:
+                mode = IMX_DMA_MEMSIZE_8;
+                break;
+        case DMA_SLAVE_BUSWIDTH_2_BYTES:
+                mode = IMX_DMA_MEMSIZE_16;
+                break;
         default:
-                return -ENOSYS;
+        case DMA_SLAVE_BUSWIDTH_4_BYTES:
+                mode = IMX_DMA_MEMSIZE_32;
+                break;
         }
 
-        return -EINVAL;
+        imxdmac->hw_chaining = 0;
+
+        imxdmac->ccr_from_device = (mode | IMX_DMA_TYPE_FIFO) |
+                ((IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR) << 2) |
+                CCR_REN;
+        imxdmac->ccr_to_device =
+                (IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR) |
+                ((mode | IMX_DMA_TYPE_FIFO) << 2) | CCR_REN;
+        imx_dmav1_writel(imxdma, imxdmac->dma_request,
+                         DMA_RSSR(imxdmac->channel));
+
+        /* Set burst length */
+        imx_dmav1_writel(imxdma, imxdmac->watermark_level *
+                         imxdmac->word_size, DMA_BLR(imxdmac->channel));
+
+        return 0;
 }
 
 static enum dma_status imxdma_tx_status(struct dma_chan *chan,
@@ -1184,7 +1177,8 @@ static int __init imxdma_probe(struct platform_device *pdev)
         imxdma->dma_device.device_prep_dma_cyclic = imxdma_prep_dma_cyclic;
         imxdma->dma_device.device_prep_dma_memcpy = imxdma_prep_dma_memcpy;
         imxdma->dma_device.device_prep_interleaved_dma = imxdma_prep_dma_interleaved;
-        imxdma->dma_device.device_control = imxdma_control;
+        imxdma->dma_device.device_config = imxdma_config;
+        imxdma->dma_device.device_terminate_all = imxdma_terminate_all;
         imxdma->dma_device.device_issue_pending = imxdma_issue_pending;
 
         platform_set_drvdata(pdev, imxdma);
diff --git a/drivers/dma/imx-sdma.c b/drivers/dma/imx-sdma.c
index d0df198f62e9..18c0a131e4e4 100644
--- a/drivers/dma/imx-sdma.c
+++ b/drivers/dma/imx-sdma.c
@@ -830,20 +830,29 @@ static int sdma_load_context(struct sdma_channel *sdmac)
         return ret;
 }
 
-static void sdma_disable_channel(struct sdma_channel *sdmac)
+static struct sdma_channel *to_sdma_chan(struct dma_chan *chan)
+{
+        return container_of(chan, struct sdma_channel, chan);
+}
+
+static int sdma_disable_channel(struct dma_chan *chan)
 {
+        struct sdma_channel *sdmac = to_sdma_chan(chan);
         struct sdma_engine *sdma = sdmac->sdma;
         int channel = sdmac->channel;
 
         writel_relaxed(BIT(channel), sdma->regs + SDMA_H_STATSTOP);
         sdmac->status = DMA_ERROR;
+
+        return 0;
 }
 
-static int sdma_config_channel(struct sdma_channel *sdmac)
+static int sdma_config_channel(struct dma_chan *chan)
 {
+        struct sdma_channel *sdmac = to_sdma_chan(chan);
         int ret;
 
-        sdma_disable_channel(sdmac);
+        sdma_disable_channel(chan);
 
         sdmac->event_mask[0] = 0;
         sdmac->event_mask[1] = 0;
@@ -935,11 +944,6 @@ out:
         return ret;
 }
 
-static struct sdma_channel *to_sdma_chan(struct dma_chan *chan)
-{
-        return container_of(chan, struct sdma_channel, chan);
-}
-
 static dma_cookie_t sdma_tx_submit(struct dma_async_tx_descriptor *tx)
 {
         unsigned long flags;
@@ -1004,7 +1008,7 @@ static void sdma_free_chan_resources(struct dma_chan *chan)
         struct sdma_channel *sdmac = to_sdma_chan(chan);
         struct sdma_engine *sdma = sdmac->sdma;
 
-        sdma_disable_channel(sdmac);
+        sdma_disable_channel(chan);
 
         if (sdmac->event_id0)
                 sdma_event_disable(sdmac, sdmac->event_id0);
@@ -1203,35 +1207,24 @@ err_out:
         return NULL;
 }
 
-static int sdma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                unsigned long arg)
+static int sdma_config(struct dma_chan *chan,
+                       struct dma_slave_config *dmaengine_cfg)
 {
         struct sdma_channel *sdmac = to_sdma_chan(chan);
-        struct dma_slave_config *dmaengine_cfg = (void *)arg;
-
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                sdma_disable_channel(sdmac);
-                return 0;
-        case DMA_SLAVE_CONFIG:
-                if (dmaengine_cfg->direction == DMA_DEV_TO_MEM) {
-                        sdmac->per_address = dmaengine_cfg->src_addr;
-                        sdmac->watermark_level = dmaengine_cfg->src_maxburst *
-                                                dmaengine_cfg->src_addr_width;
-                        sdmac->word_size = dmaengine_cfg->src_addr_width;
-                } else {
-                        sdmac->per_address = dmaengine_cfg->dst_addr;
-                        sdmac->watermark_level = dmaengine_cfg->dst_maxburst *
-                                                dmaengine_cfg->dst_addr_width;
-                        sdmac->word_size = dmaengine_cfg->dst_addr_width;
-                }
-                sdmac->direction = dmaengine_cfg->direction;
-                return sdma_config_channel(sdmac);
-        default:
-                return -ENOSYS;
-        }
 
-        return -EINVAL;
+        if (dmaengine_cfg->direction == DMA_DEV_TO_MEM) {
+                sdmac->per_address = dmaengine_cfg->src_addr;
+                sdmac->watermark_level = dmaengine_cfg->src_maxburst *
+                        dmaengine_cfg->src_addr_width;
+                sdmac->word_size = dmaengine_cfg->src_addr_width;
+        } else {
+                sdmac->per_address = dmaengine_cfg->dst_addr;
+                sdmac->watermark_level = dmaengine_cfg->dst_maxburst *
+                        dmaengine_cfg->dst_addr_width;
+                sdmac->word_size = dmaengine_cfg->dst_addr_width;
+        }
+        sdmac->direction = dmaengine_cfg->direction;
+        return sdma_config_channel(chan);
 }
 
 static enum dma_status sdma_tx_status(struct dma_chan *chan,
@@ -1303,15 +1296,15 @@ static void sdma_load_firmware(const struct firmware *fw, void *context)
         if (header->ram_code_start + header->ram_code_size > fw->size)
                 goto err_firmware;
         switch (header->version_major) {
-                case 1:
-                        sdma->script_number = SDMA_SCRIPT_ADDRS_ARRAY_SIZE_V1;
-                        break;
-                case 2:
-                        sdma->script_number = SDMA_SCRIPT_ADDRS_ARRAY_SIZE_V2;
-                        break;
-                default:
-                        dev_err(sdma->dev, "unknown firmware version\n");
-                        goto err_firmware;
+        case 1:
+                sdma->script_number = SDMA_SCRIPT_ADDRS_ARRAY_SIZE_V1;
+                break;
+        case 2:
+                sdma->script_number = SDMA_SCRIPT_ADDRS_ARRAY_SIZE_V2;
+                break;
+        default:
+                dev_err(sdma->dev, "unknown firmware version\n");
+                goto err_firmware;
         }
 
         addr = (void *)header + header->script_addrs_start;
@@ -1479,7 +1472,7 @@ static int sdma_probe(struct platform_device *pdev)
         if (ret)
                 return ret;
 
-        sdma = kzalloc(sizeof(*sdma), GFP_KERNEL);
+        sdma = devm_kzalloc(&pdev->dev, sizeof(*sdma), GFP_KERNEL);
         if (!sdma)
                 return -ENOMEM;
 
@@ -1488,48 +1481,34 @@ static int sdma_probe(struct platform_device *pdev)
         sdma->dev = &pdev->dev;
         sdma->drvdata = drvdata;
 
-        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
-        if (!iores || irq < 0) {
-                ret = -EINVAL;
-                goto err_irq;
-        }
+        if (irq < 0)
+                return irq;
 
-        if (!request_mem_region(iores->start, resource_size(iores), pdev->name)) {
-                ret = -EBUSY;
-                goto err_request_region;
-        }
+        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        sdma->regs = devm_ioremap_resource(&pdev->dev, iores);
+        if (IS_ERR(sdma->regs))
+                return PTR_ERR(sdma->regs);
 
         sdma->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
-        if (IS_ERR(sdma->clk_ipg)) {
-                ret = PTR_ERR(sdma->clk_ipg);
-                goto err_clk;
-        }
+        if (IS_ERR(sdma->clk_ipg))
+                return PTR_ERR(sdma->clk_ipg);
 
         sdma->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
-        if (IS_ERR(sdma->clk_ahb)) {
-                ret = PTR_ERR(sdma->clk_ahb);
-                goto err_clk;
-        }
+        if (IS_ERR(sdma->clk_ahb))
+                return PTR_ERR(sdma->clk_ahb);
 
         clk_prepare(sdma->clk_ipg);
         clk_prepare(sdma->clk_ahb);
 
-        sdma->regs = ioremap(iores->start, resource_size(iores));
-        if (!sdma->regs) {
-                ret = -ENOMEM;
-                goto err_ioremap;
-        }
-
-        ret = request_irq(irq, sdma_int_handler, 0, "sdma", sdma);
+        ret = devm_request_irq(&pdev->dev, irq, sdma_int_handler, 0, "sdma",
+                               sdma);
         if (ret)
-                goto err_request_irq;
+                return ret;
 
         sdma->script_addrs = kzalloc(sizeof(*sdma->script_addrs), GFP_KERNEL);
-        if (!sdma->script_addrs) {
-                ret = -ENOMEM;
-                goto err_alloc;
-        }
+        if (!sdma->script_addrs)
+                return -ENOMEM;
 
         /* initially no scripts available */
         saddr_arr = (s32 *)sdma->script_addrs;
@@ -1600,7 +1579,12 @@ static int sdma_probe(struct platform_device *pdev)
         sdma->dma_device.device_tx_status = sdma_tx_status;
         sdma->dma_device.device_prep_slave_sg = sdma_prep_slave_sg;
         sdma->dma_device.device_prep_dma_cyclic = sdma_prep_dma_cyclic;
-        sdma->dma_device.device_control = sdma_control;
+        sdma->dma_device.device_config = sdma_config;
+        sdma->dma_device.device_terminate_all = sdma_disable_channel;
+        sdma->dma_device.src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
+        sdma->dma_device.dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
+        sdma->dma_device.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        sdma->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
         sdma->dma_device.device_issue_pending = sdma_issue_pending;
         sdma->dma_device.dev->dma_parms = &sdma->dma_parms;
         dma_set_max_seg_size(sdma->dma_device.dev, 65535);
@@ -1629,38 +1613,22 @@ err_register:
         dma_async_device_unregister(&sdma->dma_device);
 err_init:
         kfree(sdma->script_addrs);
-err_alloc:
-        free_irq(irq, sdma);
-err_request_irq:
-        iounmap(sdma->regs);
-err_ioremap:
-err_clk:
-        release_mem_region(iores->start, resource_size(iores));
-err_request_region:
-err_irq:
-        kfree(sdma);
         return ret;
 }
 
 static int sdma_remove(struct platform_device *pdev)
 {
         struct sdma_engine *sdma = platform_get_drvdata(pdev);
-        struct resource *iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        int irq = platform_get_irq(pdev, 0);
         int i;
 
         dma_async_device_unregister(&sdma->dma_device);
         kfree(sdma->script_addrs);
-        free_irq(irq, sdma);
-        iounmap(sdma->regs);
-        release_mem_region(iores->start, resource_size(iores));
         /* Kill the tasklet */
         for (i = 0; i < MAX_DMA_CHANNELS; i++) {
                 struct sdma_channel *sdmac = &sdma->channel[i];
 
                 tasklet_kill(&sdmac->tasklet);
         }
-        kfree(sdma);
 
         platform_set_drvdata(pdev, NULL);
         dev_info(&pdev->dev, "Removed...\n");
diff --git a/drivers/dma/intel_mid_dma.c b/drivers/dma/intel_mid_dma.c
index 1aab8130efa1..5aaead9b56f7 100644
--- a/drivers/dma/intel_mid_dma.c
+++ b/drivers/dma/intel_mid_dma.c
@@ -492,10 +492,10 @@ static enum dma_status intel_mid_dma_tx_status(struct dma_chan *chan,
         return ret;
 }
 
-static int dma_slave_control(struct dma_chan *chan, unsigned long arg)
+static int intel_mid_dma_config(struct dma_chan *chan,
+                                struct dma_slave_config *slave)
 {
         struct intel_mid_dma_chan       *midc = to_intel_mid_dma_chan(chan);
-        struct dma_slave_config  *slave = (struct dma_slave_config *)arg;
         struct intel_mid_dma_slave *mid_slave;
 
         BUG_ON(!midc);
@@ -509,28 +509,14 @@ static int dma_slave_control(struct dma_chan *chan, unsigned long arg)
         midc->mid_slave = mid_slave;
         return 0;
 }
-/**
- * intel_mid_dma_device_control -       DMA device control
- * @chan: chan for DMA control
- * @cmd: control cmd
- * @arg: cmd arg value
- *
- * Perform DMA control command
- */
-static int intel_mid_dma_device_control(struct dma_chan *chan,
-                        enum dma_ctrl_cmd cmd, unsigned long arg)
+
+static int intel_mid_dma_terminate_all(struct dma_chan *chan)
 {
         struct intel_mid_dma_chan       *midc = to_intel_mid_dma_chan(chan);
         struct middma_device    *mid = to_middma_device(chan->device);
         struct intel_mid_dma_desc       *desc, *_desc;
         union intel_mid_dma_cfg_lo cfg_lo;
 
-        if (cmd == DMA_SLAVE_CONFIG)
-                return dma_slave_control(chan, arg);
-
-        if (cmd != DMA_TERMINATE_ALL)
-                return -ENXIO;
-
         spin_lock_bh(&midc->lock);
         if (midc->busy == false) {
                 spin_unlock_bh(&midc->lock);
@@ -1148,7 +1134,8 @@ static int mid_setup_dma(struct pci_dev *pdev)
         dma->common.device_prep_dma_memcpy = intel_mid_dma_prep_memcpy;
         dma->common.device_issue_pending = intel_mid_dma_issue_pending;
         dma->common.device_prep_slave_sg = intel_mid_dma_prep_slave_sg;
-        dma->common.device_control = intel_mid_dma_device_control;
+        dma->common.device_config = intel_mid_dma_config;
+        dma->common.device_terminate_all = intel_mid_dma_terminate_all;
 
         /*enable dma cntrl*/
         iowrite32(REG_BIT0, dma->dma_base + DMA_CFG);
diff --git a/drivers/dma/ioat/dma_v3.c b/drivers/dma/ioat/dma_v3.c
index 32eae38291e5..77a6dcf25b98 100644
--- a/drivers/dma/ioat/dma_v3.c
+++ b/drivers/dma/ioat/dma_v3.c
@@ -214,6 +214,11 @@ static bool is_bwd_ioat(struct pci_dev *pdev)
         case PCI_DEVICE_ID_INTEL_IOAT_BWD1:
         case PCI_DEVICE_ID_INTEL_IOAT_BWD2:
         case PCI_DEVICE_ID_INTEL_IOAT_BWD3:
+        /* even though not Atom, BDX-DE has same DMA silicon */
+        case PCI_DEVICE_ID_INTEL_IOAT_BDXDE0:
+        case PCI_DEVICE_ID_INTEL_IOAT_BDXDE1:
+        case PCI_DEVICE_ID_INTEL_IOAT_BDXDE2:
+        case PCI_DEVICE_ID_INTEL_IOAT_BDXDE3:
                 return true;
         default:
                 return false;
@@ -489,6 +494,7 @@ static void ioat3_eh(struct ioat2_dma_chan *ioat)
         struct ioat_chan_common *chan = &ioat->base;
         struct pci_dev *pdev = to_pdev(chan);
         struct ioat_dma_descriptor *hw;
+        struct dma_async_tx_descriptor *tx;
         u64 phys_complete;
         struct ioat_ring_ent *desc;
         u32 err_handled = 0;
@@ -534,6 +540,16 @@ static void ioat3_eh(struct ioat2_dma_chan *ioat)
                 dev_err(to_dev(chan), "%s: fatal error (%x:%x)\n",
                         __func__, chanerr, err_handled);
                 BUG();
+        } else { /* cleanup the faulty descriptor */
+                tx = &desc->txd;
+                if (tx->cookie) {
+                        dma_cookie_complete(tx);
+                        dma_descriptor_unmap(tx);
+                        if (tx->callback) {
+                                tx->callback(tx->callback_param);
+                                tx->callback = NULL;
+                        }
+                }
         }
 
         writel(chanerr, chan->reg_base + IOAT_CHANERR_OFFSET);
@@ -1300,7 +1316,8 @@ static int ioat_xor_val_self_test(struct ioatdma_device *device)
 
         tmo = wait_for_completion_timeout(&cmp, msecs_to_jiffies(3000));
 
-        if (dma->device_tx_status(dma_chan, cookie, NULL) != DMA_COMPLETE) {
+        if (tmo == 0 ||
+            dma->device_tx_status(dma_chan, cookie, NULL) != DMA_COMPLETE) {
                 dev_err(dev, "Self-test xor timed out\n");
                 err = -ENODEV;
                 goto dma_unmap;
@@ -1366,7 +1383,8 @@ static int ioat_xor_val_self_test(struct ioatdma_device *device)
 
         tmo = wait_for_completion_timeout(&cmp, msecs_to_jiffies(3000));
 
-        if (dma->device_tx_status(dma_chan, cookie, NULL) != DMA_COMPLETE) {
+        if (tmo == 0 ||
+            dma->device_tx_status(dma_chan, cookie, NULL) != DMA_COMPLETE) {
                 dev_err(dev, "Self-test validate timed out\n");
                 err = -ENODEV;
                 goto dma_unmap;
@@ -1418,7 +1436,8 @@ static int ioat_xor_val_self_test(struct ioatdma_device *device)
 
         tmo = wait_for_completion_timeout(&cmp, msecs_to_jiffies(3000));
 
-        if (dma->device_tx_status(dma_chan, cookie, NULL) != DMA_COMPLETE) {
+        if (tmo == 0 ||
+            dma->device_tx_status(dma_chan, cookie, NULL) != DMA_COMPLETE) {
                 dev_err(dev, "Self-test 2nd validate timed out\n");
                 err = -ENODEV;
                 goto dma_unmap;
diff --git a/drivers/dma/ioat/hw.h b/drivers/dma/ioat/hw.h
index 62f83e983d8d..02177ecf09f8 100644
--- a/drivers/dma/ioat/hw.h
+++ b/drivers/dma/ioat/hw.h
@@ -57,6 +57,11 @@
 #define PCI_DEVICE_ID_INTEL_IOAT_BWD2   0x0C52
 #define PCI_DEVICE_ID_INTEL_IOAT_BWD3   0x0C53
 
+#define PCI_DEVICE_ID_INTEL_IOAT_BDXDE0 0x6f50
+#define PCI_DEVICE_ID_INTEL_IOAT_BDXDE1 0x6f51
+#define PCI_DEVICE_ID_INTEL_IOAT_BDXDE2 0x6f52
+#define PCI_DEVICE_ID_INTEL_IOAT_BDXDE3 0x6f53
+
 #define IOAT_VER_1_2            0x12    /* Version 1.2 */
 #define IOAT_VER_2_0            0x20    /* Version 2.0 */
 #define IOAT_VER_3_0            0x30    /* Version 3.0 */
diff --git a/drivers/dma/ioat/pci.c b/drivers/dma/ioat/pci.c
index 1d051cd045db..5501eb072d69 100644
--- a/drivers/dma/ioat/pci.c
+++ b/drivers/dma/ioat/pci.c
@@ -111,6 +111,11 @@ static struct pci_device_id ioat_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_BWD2) },
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_BWD3) },
 
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_BDXDE0) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_BDXDE1) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_BDXDE2) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_BDXDE3) },
+
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, ioat_pci_tbl);
diff --git a/drivers/dma/ipu/ipu_idmac.c b/drivers/dma/ipu/ipu_idmac.c
index c2b017ad139d..b54f62de9232 100644
--- a/drivers/dma/ipu/ipu_idmac.c
+++ b/drivers/dma/ipu/ipu_idmac.c
@@ -1398,76 +1398,81 @@ static void idmac_issue_pending(struct dma_chan *chan)
          */
 }
 
-static int __idmac_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                           unsigned long arg)
+static int idmac_pause(struct dma_chan *chan)
 {
         struct idmac_channel *ichan = to_idmac_chan(chan);
         struct idmac *idmac = to_idmac(chan->device);
         struct ipu *ipu = to_ipu(idmac);
         struct list_head *list, *tmp;
         unsigned long flags;
-        int i;
 
-        switch (cmd) {
-        case DMA_PAUSE:
-                spin_lock_irqsave(&ipu->lock, flags);
-                ipu_ic_disable_task(ipu, chan->chan_id);
+        mutex_lock(&ichan->chan_mutex);
 
-                /* Return all descriptors into "prepared" state */
-                list_for_each_safe(list, tmp, &ichan->queue)
-                        list_del_init(list);
+        spin_lock_irqsave(&ipu->lock, flags);
+        ipu_ic_disable_task(ipu, chan->chan_id);
 
-                ichan->sg[0] = NULL;
-                ichan->sg[1] = NULL;
+        /* Return all descriptors into "prepared" state */
+        list_for_each_safe(list, tmp, &ichan->queue)
+                list_del_init(list);
 
-                spin_unlock_irqrestore(&ipu->lock, flags);
+        ichan->sg[0] = NULL;
+        ichan->sg[1] = NULL;
 
-                ichan->status = IPU_CHANNEL_INITIALIZED;
-                break;
-        case DMA_TERMINATE_ALL:
-                ipu_disable_channel(idmac, ichan,
-                                    ichan->status >= IPU_CHANNEL_ENABLED);
+        spin_unlock_irqrestore(&ipu->lock, flags);
 
-                tasklet_disable(&ipu->tasklet);
+        ichan->status = IPU_CHANNEL_INITIALIZED;
 
-                /* ichan->queue is modified in ISR, have to spinlock */
-                spin_lock_irqsave(&ichan->lock, flags);
-                list_splice_init(&ichan->queue, &ichan->free_list);
+        mutex_unlock(&ichan->chan_mutex);
 
-                if (ichan->desc)
-                        for (i = 0; i < ichan->n_tx_desc; i++) {
-                                struct idmac_tx_desc *desc = ichan->desc + i;
-                                if (list_empty(&desc->list))
-                                        /* Descriptor was prepared, but not submitted */
-                                        list_add(&desc->list, &ichan->free_list);
+        return 0;
+}
 
-                                async_tx_clear_ack(&desc->txd);
-                        }
+static int __idmac_terminate_all(struct dma_chan *chan)
+{
+        struct idmac_channel *ichan = to_idmac_chan(chan);
+        struct idmac *idmac = to_idmac(chan->device);
+        struct ipu *ipu = to_ipu(idmac);
+        unsigned long flags;
+        int i;
 
-                ichan->sg[0] = NULL;
-                ichan->sg[1] = NULL;
-                spin_unlock_irqrestore(&ichan->lock, flags);
+        ipu_disable_channel(idmac, ichan,
+                            ichan->status >= IPU_CHANNEL_ENABLED);
 
-                tasklet_enable(&ipu->tasklet);
+        tasklet_disable(&ipu->tasklet);
 
-                ichan->status = IPU_CHANNEL_INITIALIZED;
-                break;
-        default:
-                return -ENOSYS;
-        }
+        /* ichan->queue is modified in ISR, have to spinlock */
+        spin_lock_irqsave(&ichan->lock, flags);
+        list_splice_init(&ichan->queue, &ichan->free_list);
+
+        if (ichan->desc)
+                for (i = 0; i < ichan->n_tx_desc; i++) {
+                        struct idmac_tx_desc *desc = ichan->desc + i;
+                        if (list_empty(&desc->list))
+                                /* Descriptor was prepared, but not submitted */
+                                list_add(&desc->list, &ichan->free_list);
+
+                        async_tx_clear_ack(&desc->txd);
+                }
+
+        ichan->sg[0] = NULL;
+        ichan->sg[1] = NULL;
+        spin_unlock_irqrestore(&ichan->lock, flags);
+
+        tasklet_enable(&ipu->tasklet);
+
+        ichan->status = IPU_CHANNEL_INITIALIZED;
 
         return 0;
 }
 
-static int idmac_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                         unsigned long arg)
+static int idmac_terminate_all(struct dma_chan *chan)
 {
         struct idmac_channel *ichan = to_idmac_chan(chan);
         int ret;
 
         mutex_lock(&ichan->chan_mutex);
 
-        ret = __idmac_control(chan, cmd, arg);
+        ret = __idmac_terminate_all(chan);
 
         mutex_unlock(&ichan->chan_mutex);
 
@@ -1568,7 +1573,7 @@ static void idmac_free_chan_resources(struct dma_chan *chan)
 
         mutex_lock(&ichan->chan_mutex);
 
-        __idmac_control(chan, DMA_TERMINATE_ALL, 0);
+        __idmac_terminate_all(chan);
 
         if (ichan->status > IPU_CHANNEL_FREE) {
 #ifdef DEBUG
@@ -1622,7 +1627,8 @@ static int __init ipu_idmac_init(struct ipu *ipu)
 
         /* Compulsory for DMA_SLAVE fields */
         dma->device_prep_slave_sg               = idmac_prep_slave_sg;
-        dma->device_control                     = idmac_control;
+        dma->device_pause                       = idmac_pause;
+        dma->device_terminate_all               = idmac_terminate_all;
 
         INIT_LIST_HEAD(&dma->channels);
         for (i = 0; i < IPU_CHANNELS_NUM; i++) {
@@ -1655,7 +1661,7 @@ static void ipu_idmac_exit(struct ipu *ipu)
         for (i = 0; i < IPU_CHANNELS_NUM; i++) {
                 struct idmac_channel *ichan = ipu->channel + i;
 
-                idmac_control(&ichan->dma_chan, DMA_TERMINATE_ALL, 0);
+                idmac_terminate_all(&ichan->dma_chan);
         }
 
         dma_async_device_unregister(&idmac->dma);
diff --git a/drivers/dma/k3dma.c b/drivers/dma/k3dma.c
index a1de14ab2c51..6f7f43529ccb 100644
--- a/drivers/dma/k3dma.c
+++ b/drivers/dma/k3dma.c
@@ -441,7 +441,7 @@ static struct dma_async_tx_descriptor *k3_dma_prep_memcpy(
         num = 0;
 
         if (!c->ccfg) {
-                /* default is memtomem, without calling device_control */
+                /* default is memtomem, without calling device_config */
                 c->ccfg = CX_CFG_SRCINCR | CX_CFG_DSTINCR | CX_CFG_EN;
                 c->ccfg |= (0xf << 20) | (0xf << 24);   /* burst = 16 */
                 c->ccfg |= (0x3 << 12) | (0x3 << 16);   /* width = 64 bit */
@@ -523,112 +523,126 @@ static struct dma_async_tx_descriptor *k3_dma_prep_slave_sg(
         return vchan_tx_prep(&c->vc, &ds->vd, flags);
 }
 
-static int k3_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-        unsigned long arg)
+static int k3_dma_config(struct dma_chan *chan,
+                         struct dma_slave_config *cfg)
+{
+        struct k3_dma_chan *c = to_k3_chan(chan);
+        u32 maxburst = 0, val = 0;
+        enum dma_slave_buswidth width = DMA_SLAVE_BUSWIDTH_UNDEFINED;
+
+        if (cfg == NULL)
+                return -EINVAL;
+        c->dir = cfg->direction;
+        if (c->dir == DMA_DEV_TO_MEM) {
+                c->ccfg = CX_CFG_DSTINCR;
+                c->dev_addr = cfg->src_addr;
+                maxburst = cfg->src_maxburst;
+                width = cfg->src_addr_width;
+        } else if (c->dir == DMA_MEM_TO_DEV) {
+                c->ccfg = CX_CFG_SRCINCR;
+                c->dev_addr = cfg->dst_addr;
+                maxburst = cfg->dst_maxburst;
+                width = cfg->dst_addr_width;
+        }
+        switch (width) {
+        case DMA_SLAVE_BUSWIDTH_1_BYTE:
+        case DMA_SLAVE_BUSWIDTH_2_BYTES:
+        case DMA_SLAVE_BUSWIDTH_4_BYTES:
+        case DMA_SLAVE_BUSWIDTH_8_BYTES:
+                val =  __ffs(width);
+                break;
+        default:
+                val = 3;
+                break;
+        }
+        c->ccfg |= (val << 12) | (val << 16);
+
+        if ((maxburst == 0) || (maxburst > 16))
+                val = 16;
+        else
+                val = maxburst - 1;
+        c->ccfg |= (val << 20) | (val << 24);
+        c->ccfg |= CX_CFG_MEM2PER | CX_CFG_EN;
+
+        /* specific request line */
+        c->ccfg |= c->vc.chan.chan_id << 4;
+
+        return 0;
+}
+
+static int k3_dma_terminate_all(struct dma_chan *chan)
 {
         struct k3_dma_chan *c = to_k3_chan(chan);
         struct k3_dma_dev *d = to_k3_dma(chan->device);
-        struct dma_slave_config *cfg = (void *)arg;
         struct k3_dma_phy *p = c->phy;
         unsigned long flags;
-        u32 maxburst = 0, val = 0;
-        enum dma_slave_buswidth width = DMA_SLAVE_BUSWIDTH_UNDEFINED;
         LIST_HEAD(head);
 
-        switch (cmd) {
-        case DMA_SLAVE_CONFIG:
-                if (cfg == NULL)
-                        return -EINVAL;
-                c->dir = cfg->direction;
-                if (c->dir == DMA_DEV_TO_MEM) {
-                        c->ccfg = CX_CFG_DSTINCR;
-                        c->dev_addr = cfg->src_addr;
-                        maxburst = cfg->src_maxburst;
-                        width = cfg->src_addr_width;
-                } else if (c->dir == DMA_MEM_TO_DEV) {
-                        c->ccfg = CX_CFG_SRCINCR;
-                        c->dev_addr = cfg->dst_addr;
-                        maxburst = cfg->dst_maxburst;
-                        width = cfg->dst_addr_width;
-                }
-                switch (width) {
-                case DMA_SLAVE_BUSWIDTH_1_BYTE:
-                case DMA_SLAVE_BUSWIDTH_2_BYTES:
-                case DMA_SLAVE_BUSWIDTH_4_BYTES:
-                case DMA_SLAVE_BUSWIDTH_8_BYTES:
-                        val =  __ffs(width);
-                        break;
-                default:
-                        val = 3;
-                        break;
-                }
-                c->ccfg |= (val << 12) | (val << 16);
+        dev_dbg(d->slave.dev, "vchan %p: terminate all\n", &c->vc);
 
-                if ((maxburst == 0) || (maxburst > 16))
-                        val = 16;
-                else
-                        val = maxburst - 1;
-                c->ccfg |= (val << 20) | (val << 24);
-                c->ccfg |= CX_CFG_MEM2PER | CX_CFG_EN;
+        /* Prevent this channel being scheduled */
+        spin_lock(&d->lock);
+        list_del_init(&c->node);
+        spin_unlock(&d->lock);
 
-                /* specific request line */
-                c->ccfg |= c->vc.chan.chan_id << 4;
-                break;
+        /* Clear the tx descriptor lists */
+        spin_lock_irqsave(&c->vc.lock, flags);
+        vchan_get_all_descriptors(&c->vc, &head);
+        if (p) {
+                /* vchan is assigned to a pchan - stop the channel */
+                k3_dma_terminate_chan(p, d);
+                c->phy = NULL;
+                p->vchan = NULL;
+                p->ds_run = p->ds_done = NULL;
+        }
+        spin_unlock_irqrestore(&c->vc.lock, flags);
+        vchan_dma_desc_free_list(&c->vc, &head);
 
-        case DMA_TERMINATE_ALL:
-                dev_dbg(d->slave.dev, "vchan %p: terminate all\n", &c->vc);
+        return 0;
+}
 
-                /* Prevent this channel being scheduled */
-                spin_lock(&d->lock);
-                list_del_init(&c->node);
-                spin_unlock(&d->lock);
+static int k3_dma_transfer_pause(struct dma_chan *chan)
+{
+        struct k3_dma_chan *c = to_k3_chan(chan);
+        struct k3_dma_dev *d = to_k3_dma(chan->device);
+        struct k3_dma_phy *p = c->phy;
 
-                /* Clear the tx descriptor lists */
-                spin_lock_irqsave(&c->vc.lock, flags);
-                vchan_get_all_descriptors(&c->vc, &head);
+        dev_dbg(d->slave.dev, "vchan %p: pause\n", &c->vc);
+        if (c->status == DMA_IN_PROGRESS) {
+                c->status = DMA_PAUSED;
                 if (p) {
-                        /* vchan is assigned to a pchan - stop the channel */
-                        k3_dma_terminate_chan(p, d);
-                        c->phy = NULL;
-                        p->vchan = NULL;
-                        p->ds_run = p->ds_done = NULL;
+                        k3_dma_pause_dma(p, false);
+                } else {
+                        spin_lock(&d->lock);
+                        list_del_init(&c->node);
+                        spin_unlock(&d->lock);
                 }
-                spin_unlock_irqrestore(&c->vc.lock, flags);
-                vchan_dma_desc_free_list(&c->vc, &head);
-                break;
+        }
 
-        case DMA_PAUSE:
-                dev_dbg(d->slave.dev, "vchan %p: pause\n", &c->vc);
-                if (c->status == DMA_IN_PROGRESS) {
-                        c->status = DMA_PAUSED;
-                        if (p) {
-                                k3_dma_pause_dma(p, false);
-                        } else {
-                                spin_lock(&d->lock);
-                                list_del_init(&c->node);
-                                spin_unlock(&d->lock);
-                        }
-                }
-                break;
+        return 0;
+}
 
-        case DMA_RESUME:
-                dev_dbg(d->slave.dev, "vchan %p: resume\n", &c->vc);
-                spin_lock_irqsave(&c->vc.lock, flags);
-                if (c->status == DMA_PAUSED) {
-                        c->status = DMA_IN_PROGRESS;
-                        if (p) {
-                                k3_dma_pause_dma(p, true);
-                        } else if (!list_empty(&c->vc.desc_issued)) {
-                                spin_lock(&d->lock);
-                                list_add_tail(&c->node, &d->chan_pending);
-                                spin_unlock(&d->lock);
-                        }
+static int k3_dma_transfer_resume(struct dma_chan *chan)
+{
+        struct k3_dma_chan *c = to_k3_chan(chan);
+        struct k3_dma_dev *d = to_k3_dma(chan->device);
+        struct k3_dma_phy *p = c->phy;
+        unsigned long flags;
+
+        dev_dbg(d->slave.dev, "vchan %p: resume\n", &c->vc);
+        spin_lock_irqsave(&c->vc.lock, flags);
+        if (c->status == DMA_PAUSED) {
+                c->status = DMA_IN_PROGRESS;
+                if (p) {
+                        k3_dma_pause_dma(p, true);
+                } else if (!list_empty(&c->vc.desc_issued)) {
+                        spin_lock(&d->lock);
+                        list_add_tail(&c->node, &d->chan_pending);
+                        spin_unlock(&d->lock);
                 }
-                spin_unlock_irqrestore(&c->vc.lock, flags);
-                break;
-        default:
-                return -ENXIO;
         }
+        spin_unlock_irqrestore(&c->vc.lock, flags);
+
         return 0;
 }
 
@@ -720,7 +734,10 @@ static int k3_dma_probe(struct platform_device *op)
         d->slave.device_prep_dma_memcpy = k3_dma_prep_memcpy;
         d->slave.device_prep_slave_sg = k3_dma_prep_slave_sg;
         d->slave.device_issue_pending = k3_dma_issue_pending;
-        d->slave.device_control = k3_dma_control;
+        d->slave.device_config = k3_dma_config;
+        d->slave.device_pause = k3_dma_transfer_pause;
+        d->slave.device_resume = k3_dma_transfer_resume;
+        d->slave.device_terminate_all = k3_dma_terminate_all;
         d->slave.copy_align = DMA_ALIGN;
 
         /* init virtual channel */
@@ -787,7 +804,7 @@ static int k3_dma_remove(struct platform_device *op)
 }
 
 #ifdef CONFIG_PM_SLEEP
-static int k3_dma_suspend(struct device *dev)
+static int k3_dma_suspend_dev(struct device *dev)
 {
         struct k3_dma_dev *d = dev_get_drvdata(dev);
         u32 stat = 0;
@@ -803,7 +820,7 @@ static int k3_dma_suspend(struct device *dev)
         return 0;
 }
 
-static int k3_dma_resume(struct device *dev)
+static int k3_dma_resume_dev(struct device *dev)
 {
         struct k3_dma_dev *d = dev_get_drvdata(dev);
         int ret = 0;
@@ -818,7 +835,7 @@ static int k3_dma_resume(struct device *dev)
 }
 #endif
 
-static SIMPLE_DEV_PM_OPS(k3_dma_pmops, k3_dma_suspend, k3_dma_resume);
+static SIMPLE_DEV_PM_OPS(k3_dma_pmops, k3_dma_suspend_dev, k3_dma_resume_dev);
 
 static struct platform_driver k3_pdma_driver = {
         .driver         = {
diff --git a/drivers/dma/mmp_pdma.c b/drivers/dma/mmp_pdma.c
index 8b8952f35e6c..8926f271904e 100644
--- a/drivers/dma/mmp_pdma.c
+++ b/drivers/dma/mmp_pdma.c
@@ -683,68 +683,70 @@ fail:
         return NULL;
 }
 
-static int mmp_pdma_control(struct dma_chan *dchan, enum dma_ctrl_cmd cmd,
-                            unsigned long arg)
+static int mmp_pdma_config(struct dma_chan *dchan,
+                           struct dma_slave_config *cfg)
 {
         struct mmp_pdma_chan *chan = to_mmp_pdma_chan(dchan);
-        struct dma_slave_config *cfg = (void *)arg;
-        unsigned long flags;
         u32 maxburst = 0, addr = 0;
         enum dma_slave_buswidth width = DMA_SLAVE_BUSWIDTH_UNDEFINED;
 
         if (!dchan)
                 return -EINVAL;
 
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                disable_chan(chan->phy);
-                mmp_pdma_free_phy(chan);
-                spin_lock_irqsave(&chan->desc_lock, flags);
-                mmp_pdma_free_desc_list(chan, &chan->chain_pending);
-                mmp_pdma_free_desc_list(chan, &chan->chain_running);
-                spin_unlock_irqrestore(&chan->desc_lock, flags);
-                chan->idle = true;
-                break;
-        case DMA_SLAVE_CONFIG:
-                if (cfg->direction == DMA_DEV_TO_MEM) {
-                        chan->dcmd = DCMD_INCTRGADDR | DCMD_FLOWSRC;
-                        maxburst = cfg->src_maxburst;
-                        width = cfg->src_addr_width;
-                        addr = cfg->src_addr;
-                } else if (cfg->direction == DMA_MEM_TO_DEV) {
-                        chan->dcmd = DCMD_INCSRCADDR | DCMD_FLOWTRG;
-                        maxburst = cfg->dst_maxburst;
-                        width = cfg->dst_addr_width;
-                        addr = cfg->dst_addr;
-                }
-
-                if (width == DMA_SLAVE_BUSWIDTH_1_BYTE)
-                        chan->dcmd |= DCMD_WIDTH1;
-                else if (width == DMA_SLAVE_BUSWIDTH_2_BYTES)
-                        chan->dcmd |= DCMD_WIDTH2;
-                else if (width == DMA_SLAVE_BUSWIDTH_4_BYTES)
-                        chan->dcmd |= DCMD_WIDTH4;
-
-                if (maxburst == 8)
-                        chan->dcmd |= DCMD_BURST8;
-                else if (maxburst == 16)
-                        chan->dcmd |= DCMD_BURST16;
-                else if (maxburst == 32)
-                        chan->dcmd |= DCMD_BURST32;
-
-                chan->dir = cfg->direction;
-                chan->dev_addr = addr;
-                /* FIXME: drivers should be ported over to use the filter
-                 * function. Once that's done, the following two lines can
-                 * be removed.
-                 */
-                if (cfg->slave_id)
-                        chan->drcmr = cfg->slave_id;
-                break;
-        default:
-                return -ENOSYS;
+        if (cfg->direction == DMA_DEV_TO_MEM) {
+                chan->dcmd = DCMD_INCTRGADDR | DCMD_FLOWSRC;
+                maxburst = cfg->src_maxburst;
+                width = cfg->src_addr_width;
+                addr = cfg->src_addr;
+        } else if (cfg->direction == DMA_MEM_TO_DEV) {
+                chan->dcmd = DCMD_INCSRCADDR | DCMD_FLOWTRG;
+                maxburst = cfg->dst_maxburst;
+                width = cfg->dst_addr_width;
+                addr = cfg->dst_addr;
         }
 
+        if (width == DMA_SLAVE_BUSWIDTH_1_BYTE)
+                chan->dcmd |= DCMD_WIDTH1;
+        else if (width == DMA_SLAVE_BUSWIDTH_2_BYTES)
+                chan->dcmd |= DCMD_WIDTH2;
+        else if (width == DMA_SLAVE_BUSWIDTH_4_BYTES)
+                chan->dcmd |= DCMD_WIDTH4;
+
+        if (maxburst == 8)
+                chan->dcmd |= DCMD_BURST8;
+        else if (maxburst == 16)
+                chan->dcmd |= DCMD_BURST16;
+        else if (maxburst == 32)
+                chan->dcmd |= DCMD_BURST32;
+
+        chan->dir = cfg->direction;
+        chan->dev_addr = addr;
+        /* FIXME: drivers should be ported over to use the filter
+         * function. Once that's done, the following two lines can
+         * be removed.
+         */
+        if (cfg->slave_id)
+                chan->drcmr = cfg->slave_id;
+
+        return 0;
+}
+
+static int mmp_pdma_terminate_all(struct dma_chan *dchan)
+{
+        struct mmp_pdma_chan *chan = to_mmp_pdma_chan(dchan);
+        unsigned long flags;
+
+        if (!dchan)
+                return -EINVAL;
+
+        disable_chan(chan->phy);
+        mmp_pdma_free_phy(chan);
+        spin_lock_irqsave(&chan->desc_lock, flags);
+        mmp_pdma_free_desc_list(chan, &chan->chain_pending);
+        mmp_pdma_free_desc_list(chan, &chan->chain_running);
+        spin_unlock_irqrestore(&chan->desc_lock, flags);
+        chan->idle = true;
+
         return 0;
 }
 
@@ -1061,7 +1063,8 @@ static int mmp_pdma_probe(struct platform_device *op)
         pdev->device.device_prep_slave_sg = mmp_pdma_prep_slave_sg;
         pdev->device.device_prep_dma_cyclic = mmp_pdma_prep_dma_cyclic;
         pdev->device.device_issue_pending = mmp_pdma_issue_pending;
-        pdev->device.device_control = mmp_pdma_control;
+        pdev->device.device_config = mmp_pdma_config;
+        pdev->device.device_terminate_all = mmp_pdma_terminate_all;
         pdev->device.copy_align = PDMA_ALIGNMENT;
 
         if (pdev->dev->coherent_dma_mask)
diff --git a/drivers/dma/mmp_tdma.c b/drivers/dma/mmp_tdma.c
index bfb46957c3dc..70c2fa9963cd 100644
--- a/drivers/dma/mmp_tdma.c
+++ b/drivers/dma/mmp_tdma.c
@@ -19,7 +19,6 @@
 #include <linux/dmaengine.h>
 #include <linux/platform_device.h>
 #include <linux/device.h>
-#include <mach/regs-icu.h>
 #include <linux/platform_data/dma-mmp_tdma.h>
 #include <linux/of_device.h>
 #include <linux/of_dma.h>
@@ -164,33 +163,46 @@ static void mmp_tdma_enable_chan(struct mmp_tdma_chan *tdmac)
         tdmac->status = DMA_IN_PROGRESS;
 }
 
-static void mmp_tdma_disable_chan(struct mmp_tdma_chan *tdmac)
+static int mmp_tdma_disable_chan(struct dma_chan *chan)
 {
+        struct mmp_tdma_chan *tdmac = to_mmp_tdma_chan(chan);
+
         writel(readl(tdmac->reg_base + TDCR) & ~TDCR_CHANEN,
                                         tdmac->reg_base + TDCR);
 
         tdmac->status = DMA_COMPLETE;
+
+        return 0;
 }
 
-static void mmp_tdma_resume_chan(struct mmp_tdma_chan *tdmac)
+static int mmp_tdma_resume_chan(struct dma_chan *chan)
 {
+        struct mmp_tdma_chan *tdmac = to_mmp_tdma_chan(chan);
+
         writel(readl(tdmac->reg_base + TDCR) | TDCR_CHANEN,
                                         tdmac->reg_base + TDCR);
         tdmac->status = DMA_IN_PROGRESS;
+
+        return 0;
 }
 
-static void mmp_tdma_pause_chan(struct mmp_tdma_chan *tdmac)
+static int mmp_tdma_pause_chan(struct dma_chan *chan)
 {
+        struct mmp_tdma_chan *tdmac = to_mmp_tdma_chan(chan);
+
         writel(readl(tdmac->reg_base + TDCR) & ~TDCR_CHANEN,
                                         tdmac->reg_base + TDCR);
         tdmac->status = DMA_PAUSED;
+
+        return 0;
 }
 
-static int mmp_tdma_config_chan(struct mmp_tdma_chan *tdmac)
+static int mmp_tdma_config_chan(struct dma_chan *chan)
 {
+        struct mmp_tdma_chan *tdmac = to_mmp_tdma_chan(chan);
         unsigned int tdcr = 0;
 
-        mmp_tdma_disable_chan(tdmac);
+        mmp_tdma_disable_chan(chan);
 
         if (tdmac->dir == DMA_MEM_TO_DEV)
                 tdcr = TDCR_DSTDIR_ADDR_HOLD | TDCR_SRCDIR_ADDR_INC;
@@ -452,42 +464,34 @@ err_out:
         return NULL;
 }
 
-static int mmp_tdma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                unsigned long arg)
+static int mmp_tdma_terminate_all(struct dma_chan *chan)
 {
         struct mmp_tdma_chan *tdmac = to_mmp_tdma_chan(chan);
-        struct dma_slave_config *dmaengine_cfg = (void *)arg;
-        int ret = 0;
-
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                mmp_tdma_disable_chan(tdmac);
-                /* disable interrupt */
-                mmp_tdma_enable_irq(tdmac, false);
-                break;
-        case DMA_PAUSE:
-                mmp_tdma_pause_chan(tdmac);
-                break;
-        case DMA_RESUME:
-                mmp_tdma_resume_chan(tdmac);
-                break;
-        case DMA_SLAVE_CONFIG:
-                if (dmaengine_cfg->direction == DMA_DEV_TO_MEM) {
-                        tdmac->dev_addr = dmaengine_cfg->src_addr;
-                        tdmac->burst_sz = dmaengine_cfg->src_maxburst;
-                        tdmac->buswidth = dmaengine_cfg->src_addr_width;
-                } else {
-                        tdmac->dev_addr = dmaengine_cfg->dst_addr;
-                        tdmac->burst_sz = dmaengine_cfg->dst_maxburst;
-                        tdmac->buswidth = dmaengine_cfg->dst_addr_width;
-                }
-                tdmac->dir = dmaengine_cfg->direction;
-                return mmp_tdma_config_chan(tdmac);
-        default:
-                ret = -ENOSYS;
+
+        mmp_tdma_disable_chan(chan);
+        /* disable interrupt */
+        mmp_tdma_enable_irq(tdmac, false);
+
+        return 0;
+}
+
+static int mmp_tdma_config(struct dma_chan *chan,
+                           struct dma_slave_config *dmaengine_cfg)
+{
+        struct mmp_tdma_chan *tdmac = to_mmp_tdma_chan(chan);
+
+        if (dmaengine_cfg->direction == DMA_DEV_TO_MEM) {
+                tdmac->dev_addr = dmaengine_cfg->src_addr;
+                tdmac->burst_sz = dmaengine_cfg->src_maxburst;
+                tdmac->buswidth = dmaengine_cfg->src_addr_width;
+        } else {
+                tdmac->dev_addr = dmaengine_cfg->dst_addr;
+                tdmac->burst_sz = dmaengine_cfg->dst_maxburst;
+                tdmac->buswidth = dmaengine_cfg->dst_addr_width;
         }
+        tdmac->dir = dmaengine_cfg->direction;
 
-        return ret;
+        return mmp_tdma_config_chan(chan);
 }
 
 static enum dma_status mmp_tdma_tx_status(struct dma_chan *chan,
@@ -668,7 +672,10 @@ static int mmp_tdma_probe(struct platform_device *pdev)
         tdev->device.device_prep_dma_cyclic = mmp_tdma_prep_dma_cyclic;
         tdev->device.device_tx_status = mmp_tdma_tx_status;
         tdev->device.device_issue_pending = mmp_tdma_issue_pending;
-        tdev->device.device_control = mmp_tdma_control;
+        tdev->device.device_config = mmp_tdma_config;
+        tdev->device.device_pause = mmp_tdma_pause_chan;
+        tdev->device.device_resume = mmp_tdma_resume_chan;
+        tdev->device.device_terminate_all = mmp_tdma_terminate_all;
         tdev->device.copy_align = TDMA_ALIGNMENT;
 
         dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
diff --git a/drivers/dma/moxart-dma.c b/drivers/dma/moxart-dma.c
index 53032bac06e0..15cab7d79525 100644
--- a/drivers/dma/moxart-dma.c
+++ b/drivers/dma/moxart-dma.c
@@ -263,28 +263,6 @@ static int moxart_slave_config(struct dma_chan *chan,
         return 0;
 }
 
-static int moxart_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                          unsigned long arg)
-{
-        int ret = 0;
-
-        switch (cmd) {
-        case DMA_PAUSE:
-        case DMA_RESUME:
-                return -EINVAL;
-        case DMA_TERMINATE_ALL:
-                moxart_terminate_all(chan);
-                break;
-        case DMA_SLAVE_CONFIG:
-                ret = moxart_slave_config(chan, (struct dma_slave_config *)arg);
-                break;
-        default:
-                ret = -ENOSYS;
-        }
-
-        return ret;
-}
-
 static struct dma_async_tx_descriptor *moxart_prep_slave_sg(
         struct dma_chan *chan, struct scatterlist *sgl,
         unsigned int sg_len, enum dma_transfer_direction dir,
@@ -531,7 +509,8 @@ static void moxart_dma_init(struct dma_device *dma, struct device *dev)
         dma->device_free_chan_resources         = moxart_free_chan_resources;
         dma->device_issue_pending               = moxart_issue_pending;
         dma->device_tx_status                   = moxart_tx_status;
-        dma->device_control                     = moxart_control;
+        dma->device_config                      = moxart_slave_config;
+        dma->device_terminate_all               = moxart_terminate_all;
         dma->dev                                = dev;
 
         INIT_LIST_HEAD(&dma->channels);
diff --git a/drivers/dma/mpc512x_dma.c b/drivers/dma/mpc512x_dma.c
index 01bec4023de2..57d2457545f3 100644
--- a/drivers/dma/mpc512x_dma.c
+++ b/drivers/dma/mpc512x_dma.c
@@ -800,79 +800,69 @@ err_prep:
         return NULL;
 }
 
-static int mpc_dma_device_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                                                        unsigned long arg)
+static int mpc_dma_device_config(struct dma_chan *chan,
+                                 struct dma_slave_config *cfg)
 {
-        struct mpc_dma_chan *mchan;
-        struct mpc_dma *mdma;
-        struct dma_slave_config *cfg;
+        struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
         unsigned long flags;
 
-        mchan = dma_chan_to_mpc_dma_chan(chan);
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                /* Disable channel requests */
-                mdma = dma_chan_to_mpc_dma(chan);
-
-                spin_lock_irqsave(&mchan->lock, flags);
-
-                out_8(&mdma->regs->dmacerq, chan->chan_id);
-                list_splice_tail_init(&mchan->prepared, &mchan->free);
-                list_splice_tail_init(&mchan->queued, &mchan->free);
-                list_splice_tail_init(&mchan->active, &mchan->free);
-
-                spin_unlock_irqrestore(&mchan->lock, flags);
+        /*
+         * Software constraints:
+         *  - only transfers between a peripheral device and
+         *     memory are supported;
+         *  - only peripheral devices with 4-byte FIFO access register
+         *     are supported;
+         *  - minimal transfer chunk is 4 bytes and consequently
+         *     source and destination addresses must be 4-byte aligned
+         *     and transfer size must be aligned on (4 * maxburst)
+         *     boundary;
+         *  - during the transfer RAM address is being incremented by
+         *     the size of minimal transfer chunk;
+         *  - peripheral port's address is constant during the transfer.
+         */
 
-                return 0;
+        if (cfg->src_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES ||
+            cfg->dst_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES ||
+            !IS_ALIGNED(cfg->src_addr, 4) ||
+            !IS_ALIGNED(cfg->dst_addr, 4)) {
+                return -EINVAL;
+        }
 
-        case DMA_SLAVE_CONFIG:
-                /*
-                 * Software constraints:
-                 *  - only transfers between a peripheral device and
-                 *     memory are supported;
-                 *  - only peripheral devices with 4-byte FIFO access register
-                 *     are supported;
-                 *  - minimal transfer chunk is 4 bytes and consequently
-                 *     source and destination addresses must be 4-byte aligned
-                 *     and transfer size must be aligned on (4 * maxburst)
-                 *     boundary;
-                 *  - during the transfer RAM address is being incremented by
-                 *     the size of minimal transfer chunk;
-                 *  - peripheral port's address is constant during the transfer.
-                 */
+        spin_lock_irqsave(&mchan->lock, flags);
 
-                cfg = (void *)arg;
+        mchan->src_per_paddr = cfg->src_addr;
+        mchan->src_tcd_nunits = cfg->src_maxburst;
+        mchan->dst_per_paddr = cfg->dst_addr;
+        mchan->dst_tcd_nunits = cfg->dst_maxburst;
 
-                if (cfg->src_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES ||
-                    cfg->dst_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES ||
-                    !IS_ALIGNED(cfg->src_addr, 4) ||
-                    !IS_ALIGNED(cfg->dst_addr, 4)) {
-                        return -EINVAL;
-                }
+        /* Apply defaults */
+        if (mchan->src_tcd_nunits == 0)
+                mchan->src_tcd_nunits = 1;
+        if (mchan->dst_tcd_nunits == 0)
+                mchan->dst_tcd_nunits = 1;
 
-                spin_lock_irqsave(&mchan->lock, flags);
+        spin_unlock_irqrestore(&mchan->lock, flags);
 
-                mchan->src_per_paddr = cfg->src_addr;
-                mchan->src_tcd_nunits = cfg->src_maxburst;
-                mchan->dst_per_paddr = cfg->dst_addr;
-                mchan->dst_tcd_nunits = cfg->dst_maxburst;
+        return 0;
+}
 
-                /* Apply defaults */
-                if (mchan->src_tcd_nunits == 0)
-                        mchan->src_tcd_nunits = 1;
-                if (mchan->dst_tcd_nunits == 0)
-                        mchan->dst_tcd_nunits = 1;
+static int mpc_dma_device_terminate_all(struct dma_chan *chan)
+{
+        struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
+        struct mpc_dma *mdma = dma_chan_to_mpc_dma(chan);
+        unsigned long flags;
 
-                spin_unlock_irqrestore(&mchan->lock, flags);
+        /* Disable channel requests */
+        spin_lock_irqsave(&mchan->lock, flags);
 
-                return 0;
+        out_8(&mdma->regs->dmacerq, chan->chan_id);
+        list_splice_tail_init(&mchan->prepared, &mchan->free);
+        list_splice_tail_init(&mchan->queued, &mchan->free);
+        list_splice_tail_init(&mchan->active, &mchan->free);
 
-        default:
-                /* Unknown command */
-                break;
-        }
+        spin_unlock_irqrestore(&mchan->lock, flags);
 
-        return -ENXIO;
+        return 0;
 }
 
 static int mpc_dma_probe(struct platform_device *op)
@@ -963,7 +953,8 @@ static int mpc_dma_probe(struct platform_device *op)
         dma->device_tx_status = mpc_dma_tx_status;
         dma->device_prep_dma_memcpy = mpc_dma_prep_memcpy;
         dma->device_prep_slave_sg = mpc_dma_prep_slave_sg;
-        dma->device_control = mpc_dma_device_control;
+        dma->device_config = mpc_dma_device_config;
+        dma->device_terminate_all = mpc_dma_device_terminate_all;
 
         INIT_LIST_HEAD(&dma->channels);
         dma_cap_set(DMA_MEMCPY, dma->cap_mask);
diff --git a/drivers/dma/mv_xor.c b/drivers/dma/mv_xor.c
index d7ac558c2c1c..b03e8137b918 100644
--- a/drivers/dma/mv_xor.c
+++ b/drivers/dma/mv_xor.c
@@ -928,14 +928,6 @@ out:
         return err;
 }
 
-/* This driver does not implement any of the optional DMA operations. */
-static int
-mv_xor_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-               unsigned long arg)
-{
-        return -ENOSYS;
-}
-
 static int mv_xor_channel_remove(struct mv_xor_chan *mv_chan)
 {
         struct dma_chan *chan, *_chan;
@@ -1008,7 +1000,6 @@ mv_xor_channel_add(struct mv_xor_device *xordev,
         dma_dev->device_free_chan_resources = mv_xor_free_chan_resources;
         dma_dev->device_tx_status = mv_xor_status;
         dma_dev->device_issue_pending = mv_xor_issue_pending;
-        dma_dev->device_control = mv_xor_control;
         dma_dev->dev = &pdev->dev;
 
         /* set prep routines based on capability */
diff --git a/drivers/dma/mxs-dma.c b/drivers/dma/mxs-dma.c
index 5ea61201dbf0..829ec686dac3 100644
--- a/drivers/dma/mxs-dma.c
+++ b/drivers/dma/mxs-dma.c
@@ -202,8 +202,9 @@ static struct mxs_dma_chan *to_mxs_dma_chan(struct dma_chan *chan)
         return container_of(chan, struct mxs_dma_chan, chan);
 }
 
-static void mxs_dma_reset_chan(struct mxs_dma_chan *mxs_chan)
+static void mxs_dma_reset_chan(struct dma_chan *chan)
 {
+        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
         struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
         int chan_id = mxs_chan->chan.chan_id;
 
@@ -250,8 +251,9 @@ static void mxs_dma_reset_chan(struct mxs_dma_chan *mxs_chan)
         mxs_chan->status = DMA_COMPLETE;
 }
 
-static void mxs_dma_enable_chan(struct mxs_dma_chan *mxs_chan)
+static void mxs_dma_enable_chan(struct dma_chan *chan)
 {
+        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
         struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
         int chan_id = mxs_chan->chan.chan_id;
 
@@ -272,13 +274,16 @@ static void mxs_dma_enable_chan(struct mxs_dma_chan *mxs_chan)
         mxs_chan->reset = false;
 }
 
-static void mxs_dma_disable_chan(struct mxs_dma_chan *mxs_chan)
+static void mxs_dma_disable_chan(struct dma_chan *chan)
 {
+        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
+
         mxs_chan->status = DMA_COMPLETE;
 }
 
-static void mxs_dma_pause_chan(struct mxs_dma_chan *mxs_chan)
+static int mxs_dma_pause_chan(struct dma_chan *chan)
 {
+        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
         struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
         int chan_id = mxs_chan->chan.chan_id;
 
@@ -291,10 +296,12 @@ static void mxs_dma_pause_chan(struct mxs_dma_chan *mxs_chan)
                         mxs_dma->base + HW_APBHX_CHANNEL_CTRL + STMP_OFFSET_REG_SET);
 
         mxs_chan->status = DMA_PAUSED;
+        return 0;
 }
 
-static void mxs_dma_resume_chan(struct mxs_dma_chan *mxs_chan)
+static int mxs_dma_resume_chan(struct dma_chan *chan)
 {
+        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
         struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
         int chan_id = mxs_chan->chan.chan_id;
 
@@ -307,6 +314,7 @@ static void mxs_dma_resume_chan(struct mxs_dma_chan *mxs_chan)
                         mxs_dma->base + HW_APBHX_CHANNEL_CTRL + STMP_OFFSET_REG_CLR);
 
         mxs_chan->status = DMA_IN_PROGRESS;
+        return 0;
 }
 
 static dma_cookie_t mxs_dma_tx_submit(struct dma_async_tx_descriptor *tx)
@@ -383,7 +391,7 @@ static irqreturn_t mxs_dma_int_handler(int irq, void *dev_id)
                         "%s: error in channel %d\n", __func__,
                         chan);
                 mxs_chan->status = DMA_ERROR;
-                mxs_dma_reset_chan(mxs_chan);
+                mxs_dma_reset_chan(&mxs_chan->chan);
         } else if (mxs_chan->status != DMA_COMPLETE) {
                 if (mxs_chan->flags & MXS_DMA_SG_LOOP) {
                         mxs_chan->status = DMA_IN_PROGRESS;
@@ -432,7 +440,7 @@ static int mxs_dma_alloc_chan_resources(struct dma_chan *chan)
         if (ret)
                 goto err_clk;
 
-        mxs_dma_reset_chan(mxs_chan);
+        mxs_dma_reset_chan(chan);
 
         dma_async_tx_descriptor_init(&mxs_chan->desc, chan);
         mxs_chan->desc.tx_submit = mxs_dma_tx_submit;
@@ -456,7 +464,7 @@ static void mxs_dma_free_chan_resources(struct dma_chan *chan)
         struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
         struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
 
-        mxs_dma_disable_chan(mxs_chan);
+        mxs_dma_disable_chan(chan);
 
         free_irq(mxs_chan->chan_irq, mxs_dma);
 
@@ -651,28 +659,12 @@ err_out:
         return NULL;
 }
 
-static int mxs_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                unsigned long arg)
+static int mxs_dma_terminate_all(struct dma_chan *chan)
 {
-        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
-        int ret = 0;
-
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                mxs_dma_reset_chan(mxs_chan);
-                mxs_dma_disable_chan(mxs_chan);
-                break;
-        case DMA_PAUSE:
-                mxs_dma_pause_chan(mxs_chan);
-                break;
-        case DMA_RESUME:
-                mxs_dma_resume_chan(mxs_chan);
-                break;
-        default:
-                ret = -ENOSYS;
-        }
+        mxs_dma_reset_chan(chan);
+        mxs_dma_disable_chan(chan);
 
-        return ret;
+        return 0;
 }
 
 static enum dma_status mxs_dma_tx_status(struct dma_chan *chan,
@@ -701,13 +693,6 @@ static enum dma_status mxs_dma_tx_status(struct dma_chan *chan,
         return mxs_chan->status;
 }
 
-static void mxs_dma_issue_pending(struct dma_chan *chan)
-{
-        struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan);
-
-        mxs_dma_enable_chan(mxs_chan);
-}
-
 static int __init mxs_dma_init(struct mxs_dma_engine *mxs_dma)
 {
         int ret;
@@ -860,8 +845,14 @@ static int __init mxs_dma_probe(struct platform_device *pdev)
         mxs_dma->dma_device.device_tx_status = mxs_dma_tx_status;
         mxs_dma->dma_device.device_prep_slave_sg = mxs_dma_prep_slave_sg;
         mxs_dma->dma_device.device_prep_dma_cyclic = mxs_dma_prep_dma_cyclic;
-        mxs_dma->dma_device.device_control = mxs_dma_control;
-        mxs_dma->dma_device.device_issue_pending = mxs_dma_issue_pending;
+        mxs_dma->dma_device.device_pause = mxs_dma_pause_chan;
+        mxs_dma->dma_device.device_resume = mxs_dma_resume_chan;
+        mxs_dma->dma_device.device_terminate_all = mxs_dma_terminate_all;
+        mxs_dma->dma_device.src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
+        mxs_dma->dma_device.dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
+        mxs_dma->dma_device.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        mxs_dma->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
+        mxs_dma->dma_device.device_issue_pending = mxs_dma_enable_chan;
 
         ret = dma_async_device_register(&mxs_dma->dma_device);
         if (ret) {
diff --git a/drivers/dma/nbpfaxi.c b/drivers/dma/nbpfaxi.c
index d7d61e1a01c3..88b77c98365d 100644
--- a/drivers/dma/nbpfaxi.c
+++ b/drivers/dma/nbpfaxi.c
@@ -504,7 +504,7 @@ static int nbpf_prep_one(struct nbpf_link_desc *ldesc,
          * pauses DMA and reads out data received via DMA as well as those left
          * in the Rx FIFO. For this to work with the RAM side using burst
          * transfers we enable the SBE bit and terminate the transfer in our
-         * DMA_PAUSE handler.
+         * .device_pause handler.
          */
         mem_xfer = nbpf_xfer_ds(chan->nbpf, size);
 
@@ -565,13 +565,6 @@ static void nbpf_configure(struct nbpf_device *nbpf)
         nbpf_write(nbpf, NBPF_CTRL, NBPF_CTRL_LVINT);
 }
 
-static void nbpf_pause(struct nbpf_channel *chan)
-{
-        nbpf_chan_write(chan, NBPF_CHAN_CTRL, NBPF_CHAN_CTRL_SETSUS);
-        /* See comment in nbpf_prep_one() */
-        nbpf_chan_write(chan, NBPF_CHAN_CTRL, NBPF_CHAN_CTRL_CLREN);
-}
-
 /*              Generic part                    */
 
 /* DMA ENGINE functions */
@@ -837,54 +830,58 @@ static void nbpf_chan_idle(struct nbpf_channel *chan)
         }
 }
 
-static int nbpf_control(struct dma_chan *dchan, enum dma_ctrl_cmd cmd,
-                        unsigned long arg)
+static int nbpf_pause(struct dma_chan *dchan)
 {
         struct nbpf_channel *chan = nbpf_to_chan(dchan);
-        struct dma_slave_config *config;
 
-        dev_dbg(dchan->device->dev, "Entry %s(%d)\n", __func__, cmd);
+        dev_dbg(dchan->device->dev, "Entry %s\n", __func__);
 
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                dev_dbg(dchan->device->dev, "Terminating\n");
-                nbpf_chan_halt(chan);
-                nbpf_chan_idle(chan);
-                break;
+        chan->paused = true;
+        nbpf_chan_write(chan, NBPF_CHAN_CTRL, NBPF_CHAN_CTRL_SETSUS);
+        /* See comment in nbpf_prep_one() */
+        nbpf_chan_write(chan, NBPF_CHAN_CTRL, NBPF_CHAN_CTRL_CLREN);
 
-        case DMA_SLAVE_CONFIG:
-                if (!arg)
-                        return -EINVAL;
-                config = (struct dma_slave_config *)arg;
+        return 0;
+}
 
-                /*
-                 * We could check config->slave_id to match chan->terminal here,
-                 * but with DT they would be coming from the same source, so
-                 * such a check would be superflous
-                 */
+static int nbpf_terminate_all(struct dma_chan *dchan)
+{
+        struct nbpf_channel *chan = nbpf_to_chan(dchan);
 
-                chan->slave_dst_addr = config->dst_addr;
-                chan->slave_dst_width = nbpf_xfer_size(chan->nbpf,
-                                                       config->dst_addr_width, 1);
-                chan->slave_dst_burst = nbpf_xfer_size(chan->nbpf,
-                                                       config->dst_addr_width,
-                                                       config->dst_maxburst);
-                chan->slave_src_addr = config->src_addr;
-                chan->slave_src_width = nbpf_xfer_size(chan->nbpf,
-                                                       config->src_addr_width, 1);
-                chan->slave_src_burst = nbpf_xfer_size(chan->nbpf,
-                                                       config->src_addr_width,
-                                                       config->src_maxburst);
-                break;
+        dev_dbg(dchan->device->dev, "Entry %s\n", __func__);
+        dev_dbg(dchan->device->dev, "Terminating\n");
 
-        case DMA_PAUSE:
-                chan->paused = true;
-                nbpf_pause(chan);
-                break;
+        nbpf_chan_halt(chan);
+        nbpf_chan_idle(chan);
 
-        default:
-                return -ENXIO;
-        }
+        return 0;
+}
+
+static int nbpf_config(struct dma_chan *dchan,
+                       struct dma_slave_config *config)
+{
+        struct nbpf_channel *chan = nbpf_to_chan(dchan);
+
+        dev_dbg(dchan->device->dev, "Entry %s\n", __func__);
+
+        /*
+         * We could check config->slave_id to match chan->terminal here,
+         * but with DT they would be coming from the same source, so
+         * such a check would be superflous
+         */
+
+        chan->slave_dst_addr = config->dst_addr;
+        chan->slave_dst_width = nbpf_xfer_size(chan->nbpf,
+                                               config->dst_addr_width, 1);
+        chan->slave_dst_burst = nbpf_xfer_size(chan->nbpf,
+                                               config->dst_addr_width,
+                                               config->dst_maxburst);
+        chan->slave_src_addr = config->src_addr;
+        chan->slave_src_width = nbpf_xfer_size(chan->nbpf,
+                                               config->src_addr_width, 1);
+        chan->slave_src_burst = nbpf_xfer_size(chan->nbpf,
+                                               config->src_addr_width,
+                                               config->src_maxburst);
 
         return 0;
 }
@@ -1072,18 +1069,6 @@ static void nbpf_free_chan_resources(struct dma_chan *dchan)
         }
 }
 
-static int nbpf_slave_caps(struct dma_chan *dchan,
-                           struct dma_slave_caps *caps)
-{
-        caps->src_addr_widths = NBPF_DMA_BUSWIDTHS;
-        caps->dstn_addr_widths = NBPF_DMA_BUSWIDTHS;
-        caps->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
-        caps->cmd_pause = false;
-        caps->cmd_terminate = true;
-
-        return 0;
-}
-
 static struct dma_chan *nbpf_of_xlate(struct of_phandle_args *dma_spec,
                                       struct of_dma *ofdma)
 {
@@ -1414,7 +1399,6 @@ static int nbpf_probe(struct platform_device *pdev)
         dma_dev->device_prep_dma_memcpy = nbpf_prep_memcpy;
         dma_dev->device_tx_status = nbpf_tx_status;
         dma_dev->device_issue_pending = nbpf_issue_pending;
-        dma_dev->device_slave_caps = nbpf_slave_caps;
 
         /*
          * If we drop support for unaligned MEMCPY buffer addresses and / or
@@ -1426,7 +1410,13 @@ static int nbpf_probe(struct platform_device *pdev)
 
         /* Compulsory for DMA_SLAVE fields */
         dma_dev->device_prep_slave_sg = nbpf_prep_slave_sg;
-        dma_dev->device_control = nbpf_control;
+        dma_dev->device_config = nbpf_config;
+        dma_dev->device_pause = nbpf_pause;
+        dma_dev->device_terminate_all = nbpf_terminate_all;
+
+        dma_dev->src_addr_widths = NBPF_DMA_BUSWIDTHS;
+        dma_dev->dst_addr_widths = NBPF_DMA_BUSWIDTHS;
+        dma_dev->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
 
         platform_set_drvdata(pdev, nbpf);
 
diff --git a/drivers/dma/of-dma.c b/drivers/dma/of-dma.c
index d5fbeaa1e7ba..ca31f1b45366 100644
--- a/drivers/dma/of-dma.c
+++ b/drivers/dma/of-dma.c
@@ -159,6 +159,10 @@ struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
                 return ERR_PTR(-ENODEV);
         }
 
+        /* Silently fail if there is not even the "dmas" property */
+        if (!of_find_property(np, "dmas", NULL))
+                return ERR_PTR(-ENODEV);
+
         count = of_property_count_strings(np, "dma-names");
         if (count < 0) {
                 pr_err("%s: dma-names property of node '%s' missing or empty\n",
diff --git a/drivers/dma/omap-dma.c b/drivers/dma/omap-dma.c
index c0016a68b446..7dd6dd121681 100644
--- a/drivers/dma/omap-dma.c
+++ b/drivers/dma/omap-dma.c
@@ -948,8 +948,10 @@ static struct dma_async_tx_descriptor *omap_dma_prep_dma_cyclic(
         return vchan_tx_prep(&c->vc, &d->vd, flags);
 }
 
-static int omap_dma_slave_config(struct omap_chan *c, struct dma_slave_config *cfg)
+static int omap_dma_slave_config(struct dma_chan *chan, struct dma_slave_config *cfg)
 {
+        struct omap_chan *c = to_omap_dma_chan(chan);
+
         if (cfg->src_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES ||
             cfg->dst_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES)
                 return -EINVAL;
@@ -959,8 +961,9 @@ static int omap_dma_slave_config(struct omap_chan *c, struct dma_slave_config *c
         return 0;
 }
 
-static int omap_dma_terminate_all(struct omap_chan *c)
+static int omap_dma_terminate_all(struct dma_chan *chan)
 {
+        struct omap_chan *c = to_omap_dma_chan(chan);
         struct omap_dmadev *d = to_omap_dma_dev(c->vc.chan.device);
         unsigned long flags;
         LIST_HEAD(head);
@@ -996,8 +999,10 @@ static int omap_dma_terminate_all(struct omap_chan *c)
         return 0;
 }
 
-static int omap_dma_pause(struct omap_chan *c)
+static int omap_dma_pause(struct dma_chan *chan)
 {
+        struct omap_chan *c = to_omap_dma_chan(chan);
+
         /* Pause/Resume only allowed with cyclic mode */
         if (!c->cyclic)
                 return -EINVAL;
@@ -1010,8 +1015,10 @@ static int omap_dma_pause(struct omap_chan *c)
         return 0;
 }
 
-static int omap_dma_resume(struct omap_chan *c)
+static int omap_dma_resume(struct dma_chan *chan)
 {
+        struct omap_chan *c = to_omap_dma_chan(chan);
+
         /* Pause/Resume only allowed with cyclic mode */
         if (!c->cyclic)
                 return -EINVAL;
@@ -1029,37 +1036,6 @@ static int omap_dma_resume(struct omap_chan *c)
         return 0;
 }
 
-static int omap_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-        unsigned long arg)
-{
-        struct omap_chan *c = to_omap_dma_chan(chan);
-        int ret;
-
-        switch (cmd) {
-        case DMA_SLAVE_CONFIG:
-                ret = omap_dma_slave_config(c, (struct dma_slave_config *)arg);
-                break;
-
-        case DMA_TERMINATE_ALL:
-                ret = omap_dma_terminate_all(c);
-                break;
-
-        case DMA_PAUSE:
-                ret = omap_dma_pause(c);
-                break;
-
-        case DMA_RESUME:
-                ret = omap_dma_resume(c);
-                break;
-
-        default:
-                ret = -ENXIO;
-                break;
-        }
-
-        return ret;
-}
-
 static int omap_dma_chan_init(struct omap_dmadev *od, int dma_sig)
 {
         struct omap_chan *c;
@@ -1094,19 +1070,6 @@ static void omap_dma_free(struct omap_dmadev *od)
                                  BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) | \
                                  BIT(DMA_SLAVE_BUSWIDTH_4_BYTES))
 
-static int omap_dma_device_slave_caps(struct dma_chan *dchan,
-                                      struct dma_slave_caps *caps)
-{
-        caps->src_addr_widths = OMAP_DMA_BUSWIDTHS;
-        caps->dstn_addr_widths = OMAP_DMA_BUSWIDTHS;
-        caps->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
-        caps->cmd_pause = true;
-        caps->cmd_terminate = true;
-        caps->residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
-
-        return 0;
-}
-
 static int omap_dma_probe(struct platform_device *pdev)
 {
         struct omap_dmadev *od;
@@ -1136,8 +1099,14 @@ static int omap_dma_probe(struct platform_device *pdev)
         od->ddev.device_issue_pending = omap_dma_issue_pending;
         od->ddev.device_prep_slave_sg = omap_dma_prep_slave_sg;
         od->ddev.device_prep_dma_cyclic = omap_dma_prep_dma_cyclic;
-        od->ddev.device_control = omap_dma_control;
-        od->ddev.device_slave_caps = omap_dma_device_slave_caps;
+        od->ddev.device_config = omap_dma_slave_config;
+        od->ddev.device_pause = omap_dma_pause;
+        od->ddev.device_resume = omap_dma_resume;
+        od->ddev.device_terminate_all = omap_dma_terminate_all;
+        od->ddev.src_addr_widths = OMAP_DMA_BUSWIDTHS;
+        od->ddev.dst_addr_widths = OMAP_DMA_BUSWIDTHS;
+        od->ddev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        od->ddev.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
         od->ddev.dev = &pdev->dev;
         INIT_LIST_HEAD(&od->ddev.channels);
         INIT_LIST_HEAD(&od->pending);
diff --git a/drivers/dma/pch_dma.c b/drivers/dma/pch_dma.c
index 6e0e47d76b23..35c143cb88da 100644
--- a/drivers/dma/pch_dma.c
+++ b/drivers/dma/pch_dma.c
@@ -665,16 +665,12 @@ err_desc_get:
         return NULL;
 }
 
-static int pd_device_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                             unsigned long arg)
+static int pd_device_terminate_all(struct dma_chan *chan)
 {
         struct pch_dma_chan *pd_chan = to_pd_chan(chan);
         struct pch_dma_desc *desc, *_d;
         LIST_HEAD(list);
 
-        if (cmd != DMA_TERMINATE_ALL)
-                return -ENXIO;
-
         spin_lock_irq(&pd_chan->lock);
 
         pdc_set_mode(&pd_chan->chan, DMA_CTL0_DISABLE);
@@ -932,7 +928,7 @@ static int pch_dma_probe(struct pci_dev *pdev,
         pd->dma.device_tx_status = pd_tx_status;
         pd->dma.device_issue_pending = pd_issue_pending;
         pd->dma.device_prep_slave_sg = pd_prep_slave_sg;
-        pd->dma.device_control = pd_device_control;
+        pd->dma.device_terminate_all = pd_device_terminate_all;
 
         err = dma_async_device_register(&pd->dma);
         if (err) {
diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
index bdf40b530032..0e1f56772855 100644
--- a/drivers/dma/pl330.c
+++ b/drivers/dma/pl330.c
@@ -504,6 +504,9 @@ struct dma_pl330_desc {
 
         enum desc_status status;
 
+        int bytes_requested;
+        bool last;
+
         /* The channel which currently holds this desc */
         struct dma_pl330_chan *pchan;
 
@@ -1048,6 +1051,10 @@ static bool _trigger(struct pl330_thread *thrd)
         if (!req)
                 return true;
 
+        /* Return if req is running */
+        if (idx == thrd->req_running)
+                return true;
+
         desc = req->desc;
 
         ns = desc->rqcfg.nonsecure ? 1 : 0;
@@ -1587,6 +1594,8 @@ static int pl330_update(struct pl330_dmac *pl330)
                         descdone = thrd->req[active].desc;
                         thrd->req[active].desc = NULL;
 
+                        thrd->req_running = -1;
+
                         /* Get going again ASAP */
                         _start(thrd);
 
@@ -2086,77 +2095,89 @@ static int pl330_alloc_chan_resources(struct dma_chan *chan)
         return 1;
 }
 
-static int pl330_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd, unsigned long arg)
+static int pl330_config(struct dma_chan *chan,
+                        struct dma_slave_config *slave_config)
+{
+        struct dma_pl330_chan *pch = to_pchan(chan);
+
+        if (slave_config->direction == DMA_MEM_TO_DEV) {
+                if (slave_config->dst_addr)
+                        pch->fifo_addr = slave_config->dst_addr;
+                if (slave_config->dst_addr_width)
+                        pch->burst_sz = __ffs(slave_config->dst_addr_width);
+                if (slave_config->dst_maxburst)
+                        pch->burst_len = slave_config->dst_maxburst;
+        } else if (slave_config->direction == DMA_DEV_TO_MEM) {
+                if (slave_config->src_addr)
+                        pch->fifo_addr = slave_config->src_addr;
+                if (slave_config->src_addr_width)
+                        pch->burst_sz = __ffs(slave_config->src_addr_width);
+                if (slave_config->src_maxburst)
+                        pch->burst_len = slave_config->src_maxburst;
+        }
+
+        return 0;
+}
+
+static int pl330_terminate_all(struct dma_chan *chan)
 {
         struct dma_pl330_chan *pch = to_pchan(chan);
         struct dma_pl330_desc *desc;
         unsigned long flags;
         struct pl330_dmac *pl330 = pch->dmac;
-        struct dma_slave_config *slave_config;
         LIST_HEAD(list);
 
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                pm_runtime_get_sync(pl330->ddma.dev);
-                spin_lock_irqsave(&pch->lock, flags);
+        spin_lock_irqsave(&pch->lock, flags);
+        spin_lock(&pl330->lock);
+        _stop(pch->thread);
+        spin_unlock(&pl330->lock);
+
+        pch->thread->req[0].desc = NULL;
+        pch->thread->req[1].desc = NULL;
+        pch->thread->req_running = -1;
+
+        /* Mark all desc done */
+        list_for_each_entry(desc, &pch->submitted_list, node) {
+                desc->status = FREE;
+                dma_cookie_complete(&desc->txd);
+        }
 
-                spin_lock(&pl330->lock);
-                _stop(pch->thread);
-                spin_unlock(&pl330->lock);
+        list_for_each_entry(desc, &pch->work_list , node) {
+                desc->status = FREE;
+                dma_cookie_complete(&desc->txd);
+        }
 
-                pch->thread->req[0].desc = NULL;
-                pch->thread->req[1].desc = NULL;
-                pch->thread->req_running = -1;
+        list_splice_tail_init(&pch->submitted_list, &pl330->desc_pool);
+        list_splice_tail_init(&pch->work_list, &pl330->desc_pool);
+        list_splice_tail_init(&pch->completed_list, &pl330->desc_pool);
+        spin_unlock_irqrestore(&pch->lock, flags);
 
-                /* Mark all desc done */
-                list_for_each_entry(desc, &pch->submitted_list, node) {
-                        desc->status = FREE;
-                        dma_cookie_complete(&desc->txd);
-                }
+        return 0;
+}
 
-                list_for_each_entry(desc, &pch->work_list , node) {
-                        desc->status = FREE;
-                        dma_cookie_complete(&desc->txd);
-                }
+/*
+ * We don't support DMA_RESUME command because of hardware
+ * limitations, so after pausing the channel we cannot restore
+ * it to active state. We have to terminate channel and setup
+ * DMA transfer again. This pause feature was implemented to
+ * allow safely read residue before channel termination.
+ */
+int pl330_pause(struct dma_chan *chan)
+{
+        struct dma_pl330_chan *pch = to_pchan(chan);
+        struct pl330_dmac *pl330 = pch->dmac;
+        unsigned long flags;
 
-                list_for_each_entry(desc, &pch->completed_list , node) {
-                        desc->status = FREE;
-                        dma_cookie_complete(&desc->txd);
-                }
+        pm_runtime_get_sync(pl330->ddma.dev);
+        spin_lock_irqsave(&pch->lock, flags);
 
-                if (!list_empty(&pch->work_list))
-                        pm_runtime_put(pl330->ddma.dev);
+        spin_lock(&pl330->lock);
+        _stop(pch->thread);
+        spin_unlock(&pl330->lock);
 
-                list_splice_tail_init(&pch->submitted_list, &pl330->desc_pool);
-                list_splice_tail_init(&pch->work_list, &pl330->desc_pool);
-                list_splice_tail_init(&pch->completed_list, &pl330->desc_pool);
-                spin_unlock_irqrestore(&pch->lock, flags);
-                pm_runtime_mark_last_busy(pl330->ddma.dev);
-                pm_runtime_put_autosuspend(pl330->ddma.dev);
-                break;
-        case DMA_SLAVE_CONFIG:
-                slave_config = (struct dma_slave_config *)arg;
-
-                if (slave_config->direction == DMA_MEM_TO_DEV) {
-                        if (slave_config->dst_addr)
-                                pch->fifo_addr = slave_config->dst_addr;
-                        if (slave_config->dst_addr_width)
-                                pch->burst_sz = __ffs(slave_config->dst_addr_width);
-                        if (slave_config->dst_maxburst)
-                                pch->burst_len = slave_config->dst_maxburst;
-                } else if (slave_config->direction == DMA_DEV_TO_MEM) {
-                        if (slave_config->src_addr)
-                                pch->fifo_addr = slave_config->src_addr;
-                        if (slave_config->src_addr_width)
-                                pch->burst_sz = __ffs(slave_config->src_addr_width);
-                        if (slave_config->src_maxburst)
-                                pch->burst_len = slave_config->src_maxburst;
-                }
-                break;
-        default:
-                dev_err(pch->dmac->ddma.dev, "Not supported command.\n");
-                return -ENXIO;
-        }
+        spin_unlock_irqrestore(&pch->lock, flags);
+        pm_runtime_mark_last_busy(pl330->ddma.dev);
+        pm_runtime_put_autosuspend(pl330->ddma.dev);
 
         return 0;
 }
@@ -2182,11 +2203,74 @@ static void pl330_free_chan_resources(struct dma_chan *chan)
         pm_runtime_put_autosuspend(pch->dmac->ddma.dev);
 }
 
+int pl330_get_current_xferred_count(struct dma_pl330_chan *pch,
+                struct dma_pl330_desc *desc)
+{
+        struct pl330_thread *thrd = pch->thread;
+        struct pl330_dmac *pl330 = pch->dmac;
+        void __iomem *regs = thrd->dmac->base;
+        u32 val, addr;
+
+        pm_runtime_get_sync(pl330->ddma.dev);
+        val = addr = 0;
+        if (desc->rqcfg.src_inc) {
+                val = readl(regs + SA(thrd->id));
+                addr = desc->px.src_addr;
+        } else {
+                val = readl(regs + DA(thrd->id));
+                addr = desc->px.dst_addr;
+        }
+        pm_runtime_mark_last_busy(pch->dmac->ddma.dev);
+        pm_runtime_put_autosuspend(pl330->ddma.dev);
+        return val - addr;
+}
+
 static enum dma_status
 pl330_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
                  struct dma_tx_state *txstate)
 {
-        return dma_cookie_status(chan, cookie, txstate);
+        enum dma_status ret;
+        unsigned long flags;
+        struct dma_pl330_desc *desc, *running = NULL;
+        struct dma_pl330_chan *pch = to_pchan(chan);
+        unsigned int transferred, residual = 0;
+
+        ret = dma_cookie_status(chan, cookie, txstate);
+
+        if (!txstate)
+                return ret;
+
+        if (ret == DMA_COMPLETE)
+                goto out;
+
+        spin_lock_irqsave(&pch->lock, flags);
+
+        if (pch->thread->req_running != -1)
+                running = pch->thread->req[pch->thread->req_running].desc;
+
+        /* Check in pending list */
+        list_for_each_entry(desc, &pch->work_list, node) {
+                if (desc->status == DONE)
+                        transferred = desc->bytes_requested;
+                else if (running && desc == running)
+                        transferred =
+                                pl330_get_current_xferred_count(pch, desc);
+                else
+                        transferred = 0;
+                residual += desc->bytes_requested - transferred;
+                if (desc->txd.cookie == cookie) {
+                        ret = desc->status;
+                        break;
+                }
+                if (desc->last)
+                        residual = 0;
+        }
+        spin_unlock_irqrestore(&pch->lock, flags);
+
+out:
+        dma_set_residue(txstate, residual);
+
+        return ret;
 }
 
 static void pl330_issue_pending(struct dma_chan *chan)
@@ -2231,12 +2315,14 @@ static dma_cookie_t pl330_tx_submit(struct dma_async_tx_descriptor *tx)
                         desc->txd.callback = last->txd.callback;
                         desc->txd.callback_param = last->txd.callback_param;
                 }
+                last->last = false;
 
                 dma_cookie_assign(&desc->txd);
 
                 list_move_tail(&desc->node, &pch->submitted_list);
         }
 
+        last->last = true;
         cookie = dma_cookie_assign(&last->txd);
         list_add_tail(&last->node, &pch->submitted_list);
         spin_unlock_irqrestore(&pch->lock, flags);
@@ -2459,6 +2545,7 @@ static struct dma_async_tx_descriptor *pl330_prep_dma_cyclic(
                 desc->rqtype = direction;
                 desc->rqcfg.brst_size = pch->burst_sz;
                 desc->rqcfg.brst_len = 1;
+                desc->bytes_requested = period_len;
                 fill_px(&desc->px, dst, src, period_len);
 
                 if (!first)
@@ -2601,6 +2688,7 @@ pl330_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 desc->rqcfg.brst_size = pch->burst_sz;
                 desc->rqcfg.brst_len = 1;
                 desc->rqtype = direction;
+                desc->bytes_requested = sg_dma_len(sg);
         }
 
         /* Return the last desc in the chain */
@@ -2623,19 +2711,6 @@ static irqreturn_t pl330_irq_handler(int irq, void *data)
         BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | \
         BIT(DMA_SLAVE_BUSWIDTH_8_BYTES)
 
-static int pl330_dma_device_slave_caps(struct dma_chan *dchan,
-        struct dma_slave_caps *caps)
-{
-        caps->src_addr_widths = PL330_DMA_BUSWIDTHS;
-        caps->dstn_addr_widths = PL330_DMA_BUSWIDTHS;
-        caps->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
-        caps->cmd_pause = false;
-        caps->cmd_terminate = true;
-        caps->residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;
-
-        return 0;
-}
-
 /*
  * Runtime PM callbacks are provided by amba/bus.c driver.
  *
@@ -2793,9 +2868,14 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
         pd->device_prep_dma_cyclic = pl330_prep_dma_cyclic;
         pd->device_tx_status = pl330_tx_status;
         pd->device_prep_slave_sg = pl330_prep_slave_sg;
-        pd->device_control = pl330_control;
+        pd->device_config = pl330_config;
+        pd->device_pause = pl330_pause;
+        pd->device_terminate_all = pl330_terminate_all;
         pd->device_issue_pending = pl330_issue_pending;
-        pd->device_slave_caps = pl330_dma_device_slave_caps;
+        pd->src_addr_widths = PL330_DMA_BUSWIDTHS;
+        pd->dst_addr_widths = PL330_DMA_BUSWIDTHS;
+        pd->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        pd->residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT;
 
         ret = dma_async_device_register(pd);
         if (ret) {
@@ -2847,7 +2927,7 @@ probe_err3:
 
                 /* Flush the channel */
                 if (pch->thread) {
-                        pl330_control(&pch->chan, DMA_TERMINATE_ALL, 0);
+                        pl330_terminate_all(&pch->chan);
                         pl330_free_chan_resources(&pch->chan);
                 }
         }
@@ -2878,7 +2958,7 @@ static int pl330_remove(struct amba_device *adev)
 
                 /* Flush the channel */
                 if (pch->thread) {
-                        pl330_control(&pch->chan, DMA_TERMINATE_ALL, 0);
+                        pl330_terminate_all(&pch->chan);
                         pl330_free_chan_resources(&pch->chan);
                 }
         }
diff --git a/drivers/dma/qcom_bam_dma.c b/drivers/dma/qcom_bam_dma.c
index 3122a99ec06b..d7a33b3ac466 100644
--- a/drivers/dma/qcom_bam_dma.c
+++ b/drivers/dma/qcom_bam_dma.c
@@ -530,11 +530,18 @@ static void bam_free_chan(struct dma_chan *chan)
  * Sets slave configuration for channel
  *
  */
-static void bam_slave_config(struct bam_chan *bchan,
-                struct dma_slave_config *cfg)
+static int bam_slave_config(struct dma_chan *chan,
+                            struct dma_slave_config *cfg)
 {
+        struct bam_chan *bchan = to_bam_chan(chan);
+        unsigned long flag;
+
+        spin_lock_irqsave(&bchan->vc.lock, flag);
         memcpy(&bchan->slave, cfg, sizeof(*cfg));
         bchan->reconfigure = 1;
+        spin_unlock_irqrestore(&bchan->vc.lock, flag);
+
+        return 0;
 }
 
 /**
@@ -627,8 +634,9 @@ err_out:
  * No callbacks are done
  *
  */
-static void bam_dma_terminate_all(struct bam_chan *bchan)
+static int bam_dma_terminate_all(struct dma_chan *chan)
 {
+        struct bam_chan *bchan = to_bam_chan(chan);
         unsigned long flag;
         LIST_HEAD(head);
 
@@ -643,56 +651,46 @@ static void bam_dma_terminate_all(struct bam_chan *bchan)
         spin_unlock_irqrestore(&bchan->vc.lock, flag);
 
         vchan_dma_desc_free_list(&bchan->vc, &head);
+
+        return 0;
 }
 
 /**
- * bam_control - DMA device control
+ * bam_pause - Pause DMA channel
  * @chan: dma channel
- * @cmd: control cmd
- * @arg: cmd argument
  *
- * Perform DMA control command
+ */
+static int bam_pause(struct dma_chan *chan)
+{
+        struct bam_chan *bchan = to_bam_chan(chan);
+        struct bam_device *bdev = bchan->bdev;
+        unsigned long flag;
+
+        spin_lock_irqsave(&bchan->vc.lock, flag);
+        writel_relaxed(1, bam_addr(bdev, bchan->id, BAM_P_HALT));
+        bchan->paused = 1;
+        spin_unlock_irqrestore(&bchan->vc.lock, flag);
+
+        return 0;
+}
+
+/**
+ * bam_resume - Resume DMA channel operations
+ * @chan: dma channel
  *
  */
-static int bam_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-        unsigned long arg)
+static int bam_resume(struct dma_chan *chan)
 {
         struct bam_chan *bchan = to_bam_chan(chan);
         struct bam_device *bdev = bchan->bdev;
-        int ret = 0;
         unsigned long flag;
 
-        switch (cmd) {
-        case DMA_PAUSE:
-                spin_lock_irqsave(&bchan->vc.lock, flag);
-                writel_relaxed(1, bam_addr(bdev, bchan->id, BAM_P_HALT));
-                bchan->paused = 1;
-                spin_unlock_irqrestore(&bchan->vc.lock, flag);
-                break;
-
-        case DMA_RESUME:
-                spin_lock_irqsave(&bchan->vc.lock, flag);
-                writel_relaxed(0, bam_addr(bdev, bchan->id, BAM_P_HALT));
-                bchan->paused = 0;
-                spin_unlock_irqrestore(&bchan->vc.lock, flag);
-                break;
-
-        case DMA_TERMINATE_ALL:
-                bam_dma_terminate_all(bchan);
-                break;
-
-        case DMA_SLAVE_CONFIG:
-                spin_lock_irqsave(&bchan->vc.lock, flag);
-                bam_slave_config(bchan, (struct dma_slave_config *)arg);
-                spin_unlock_irqrestore(&bchan->vc.lock, flag);
-                break;
-
-        default:
-                ret = -ENXIO;
-                break;
-        }
+        spin_lock_irqsave(&bchan->vc.lock, flag);
+        writel_relaxed(0, bam_addr(bdev, bchan->id, BAM_P_HALT));
+        bchan->paused = 0;
+        spin_unlock_irqrestore(&bchan->vc.lock, flag);
 
-        return ret;
+        return 0;
 }
 
 /**
@@ -1148,7 +1146,10 @@ static int bam_dma_probe(struct platform_device *pdev)
         bdev->common.device_alloc_chan_resources = bam_alloc_chan;
         bdev->common.device_free_chan_resources = bam_free_chan;
         bdev->common.device_prep_slave_sg = bam_prep_slave_sg;
-        bdev->common.device_control = bam_control;
+        bdev->common.device_config = bam_slave_config;
+        bdev->common.device_pause = bam_pause;
+        bdev->common.device_resume = bam_resume;
+        bdev->common.device_terminate_all = bam_dma_terminate_all;
         bdev->common.device_issue_pending = bam_issue_pending;
         bdev->common.device_tx_status = bam_tx_status;
         bdev->common.dev = bdev->dev;
@@ -1187,7 +1188,7 @@ static int bam_dma_remove(struct platform_device *pdev)
         devm_free_irq(bdev->dev, bdev->irq, bdev);
 
         for (i = 0; i < bdev->num_channels; i++) {
-                bam_dma_terminate_all(&bdev->channels[i]);
+                bam_dma_terminate_all(&bdev->channels[i].vc.chan);
                 tasklet_kill(&bdev->channels[i].vc.task);
 
                 dma_free_writecombine(bdev->dev, BAM_DESC_FIFO_SIZE,
diff --git a/drivers/dma/s3c24xx-dma.c b/drivers/dma/s3c24xx-dma.c
index 6941a77521c3..2f91da3db836 100644
--- a/drivers/dma/s3c24xx-dma.c
+++ b/drivers/dma/s3c24xx-dma.c
@@ -384,20 +384,30 @@ static u32 s3c24xx_dma_getbytes_chan(struct s3c24xx_dma_chan *s3cchan)
         return tc * txd->width;
 }
 
-static int s3c24xx_dma_set_runtime_config(struct s3c24xx_dma_chan *s3cchan,
+static int s3c24xx_dma_set_runtime_config(struct dma_chan *chan,
                                   struct dma_slave_config *config)
 {
-        if (!s3cchan->slave)
-                return -EINVAL;
+        struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
+        unsigned long flags;
+        int ret = 0;
 
         /* Reject definitely invalid configurations */
         if (config->src_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES ||
             config->dst_addr_width == DMA_SLAVE_BUSWIDTH_8_BYTES)
                 return -EINVAL;
 
+        spin_lock_irqsave(&s3cchan->vc.lock, flags);
+
+        if (!s3cchan->slave) {
+                ret = -EINVAL;
+                goto out;
+        }
+
         s3cchan->cfg = *config;
 
-        return 0;
+out:
+        spin_unlock_irqrestore(&s3cchan->vc.lock, flags);
+        return ret;
 }
 
 /*
@@ -703,8 +713,7 @@ static irqreturn_t s3c24xx_dma_irq(int irq, void *data)
  * The DMA ENGINE API
  */
 
-static int s3c24xx_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                         unsigned long arg)
+static int s3c24xx_dma_terminate_all(struct dma_chan *chan)
 {
         struct s3c24xx_dma_chan *s3cchan = to_s3c24xx_dma_chan(chan);
         struct s3c24xx_dma_engine *s3cdma = s3cchan->host;
@@ -713,40 +722,28 @@ static int s3c24xx_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
 
         spin_lock_irqsave(&s3cchan->vc.lock, flags);
 
-        switch (cmd) {
-        case DMA_SLAVE_CONFIG:
-                ret = s3c24xx_dma_set_runtime_config(s3cchan,
-                                              (struct dma_slave_config *)arg);
-                break;
-        case DMA_TERMINATE_ALL:
-                if (!s3cchan->phy && !s3cchan->at) {
-                        dev_err(&s3cdma->pdev->dev, "trying to terminate already stopped channel %d\n",
-                                s3cchan->id);
-                        ret = -EINVAL;
-                        break;
-                }
+        if (!s3cchan->phy && !s3cchan->at) {
+                dev_err(&s3cdma->pdev->dev, "trying to terminate already stopped channel %d\n",
+                        s3cchan->id);
+                ret = -EINVAL;
+                goto unlock;
+        }
 
-                s3cchan->state = S3C24XX_DMA_CHAN_IDLE;
+        s3cchan->state = S3C24XX_DMA_CHAN_IDLE;
 
-                 /* Mark physical channel as free */
-                if (s3cchan->phy)
-                        s3c24xx_dma_phy_free(s3cchan);
+        /* Mark physical channel as free */
+        if (s3cchan->phy)
+                s3c24xx_dma_phy_free(s3cchan);
 
-                /* Dequeue current job */
-                if (s3cchan->at) {
-                        s3c24xx_dma_desc_free(&s3cchan->at->vd);
-                        s3cchan->at = NULL;
-                }
-
-                /* Dequeue jobs not yet fired as well */
-                s3c24xx_dma_free_txd_list(s3cdma, s3cchan);
-                break;
-        default:
-                /* Unknown command */
-                ret = -ENXIO;
-                break;
+        /* Dequeue current job */
+        if (s3cchan->at) {
+                s3c24xx_dma_desc_free(&s3cchan->at->vd);
+                s3cchan->at = NULL;
         }
 
+        /* Dequeue jobs not yet fired as well */
+        s3c24xx_dma_free_txd_list(s3cdma, s3cchan);
+unlock:
         spin_unlock_irqrestore(&s3cchan->vc.lock, flags);
 
         return ret;
@@ -1300,7 +1297,8 @@ static int s3c24xx_dma_probe(struct platform_device *pdev)
         s3cdma->memcpy.device_prep_dma_memcpy = s3c24xx_dma_prep_memcpy;
         s3cdma->memcpy.device_tx_status = s3c24xx_dma_tx_status;
         s3cdma->memcpy.device_issue_pending = s3c24xx_dma_issue_pending;
-        s3cdma->memcpy.device_control = s3c24xx_dma_control;
+        s3cdma->memcpy.device_config = s3c24xx_dma_set_runtime_config;
+        s3cdma->memcpy.device_terminate_all = s3c24xx_dma_terminate_all;
 
         /* Initialize slave engine for SoC internal dedicated peripherals */
         dma_cap_set(DMA_SLAVE, s3cdma->slave.cap_mask);
@@ -1315,7 +1313,8 @@ static int s3c24xx_dma_probe(struct platform_device *pdev)
         s3cdma->slave.device_issue_pending = s3c24xx_dma_issue_pending;
         s3cdma->slave.device_prep_slave_sg = s3c24xx_dma_prep_slave_sg;
         s3cdma->slave.device_prep_dma_cyclic = s3c24xx_dma_prep_dma_cyclic;
-        s3cdma->slave.device_control = s3c24xx_dma_control;
+        s3cdma->slave.device_config = s3c24xx_dma_set_runtime_config;
+        s3cdma->slave.device_terminate_all = s3c24xx_dma_terminate_all;
 
         /* Register as many memcpy channels as there are physical channels */
         ret = s3c24xx_dma_init_virtual_channels(s3cdma, &s3cdma->memcpy,
diff --git a/drivers/dma/sa11x0-dma.c b/drivers/dma/sa11x0-dma.c
index 96bb62c39c41..5adf5407a8cb 100644
--- a/drivers/dma/sa11x0-dma.c
+++ b/drivers/dma/sa11x0-dma.c
@@ -669,8 +669,10 @@ static struct dma_async_tx_descriptor *sa11x0_dma_prep_dma_cyclic(
         return vchan_tx_prep(&c->vc, &txd->vd, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 }
 
-static int sa11x0_dma_slave_config(struct sa11x0_dma_chan *c, struct dma_slave_config *cfg)
+static int sa11x0_dma_device_config(struct dma_chan *chan,
+                                    struct dma_slave_config *cfg)
 {
+        struct sa11x0_dma_chan *c = to_sa11x0_dma_chan(chan);
         u32 ddar = c->ddar & ((0xf << 4) | DDAR_RW);
         dma_addr_t addr;
         enum dma_slave_buswidth width;
@@ -704,99 +706,101 @@ static int sa11x0_dma_slave_config(struct sa11x0_dma_chan *c, struct dma_slave_c
         return 0;
 }
 
-static int sa11x0_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-        unsigned long arg)
+static int sa11x0_dma_device_pause(struct dma_chan *chan)
 {
         struct sa11x0_dma_chan *c = to_sa11x0_dma_chan(chan);
         struct sa11x0_dma_dev *d = to_sa11x0_dma(chan->device);
         struct sa11x0_dma_phy *p;
         LIST_HEAD(head);
         unsigned long flags;
-        int ret;
 
-        switch (cmd) {
-        case DMA_SLAVE_CONFIG:
-                return sa11x0_dma_slave_config(c, (struct dma_slave_config *)arg);
-
-        case DMA_TERMINATE_ALL:
-                dev_dbg(d->slave.dev, "vchan %p: terminate all\n", &c->vc);
-                /* Clear the tx descriptor lists */
-                spin_lock_irqsave(&c->vc.lock, flags);
-                vchan_get_all_descriptors(&c->vc, &head);
+        dev_dbg(d->slave.dev, "vchan %p: pause\n", &c->vc);
+        spin_lock_irqsave(&c->vc.lock, flags);
+        if (c->status == DMA_IN_PROGRESS) {
+                c->status = DMA_PAUSED;
 
                 p = c->phy;
                 if (p) {
-                        dev_dbg(d->slave.dev, "pchan %u: terminating\n", p->num);
-                        /* vchan is assigned to a pchan - stop the channel */
-                        writel(DCSR_RUN | DCSR_IE |
-                                DCSR_STRTA | DCSR_DONEA |
-                                DCSR_STRTB | DCSR_DONEB,
-                                p->base + DMA_DCSR_C);
-
-                        if (p->txd_load) {
-                                if (p->txd_load != p->txd_done)
-                                        list_add_tail(&p->txd_load->vd.node, &head);
-                                p->txd_load = NULL;
-                        }
-                        if (p->txd_done) {
-                                list_add_tail(&p->txd_done->vd.node, &head);
-                                p->txd_done = NULL;
-                        }
-                        c->phy = NULL;
+                        writel(DCSR_RUN | DCSR_IE, p->base + DMA_DCSR_C);
+                } else {
                         spin_lock(&d->lock);
-                        p->vchan = NULL;
+                        list_del_init(&c->node);
                         spin_unlock(&d->lock);
-                        tasklet_schedule(&d->task);
                 }
-                spin_unlock_irqrestore(&c->vc.lock, flags);
-                vchan_dma_desc_free_list(&c->vc, &head);
-                ret = 0;
-                break;
+        }
+        spin_unlock_irqrestore(&c->vc.lock, flags);
 
-        case DMA_PAUSE:
-                dev_dbg(d->slave.dev, "vchan %p: pause\n", &c->vc);
-                spin_lock_irqsave(&c->vc.lock, flags);
-                if (c->status == DMA_IN_PROGRESS) {
-                        c->status = DMA_PAUSED;
+        return 0;
+}
 
-                        p = c->phy;
-                        if (p) {
-                                writel(DCSR_RUN | DCSR_IE, p->base + DMA_DCSR_C);
-                        } else {
-                                spin_lock(&d->lock);
-                                list_del_init(&c->node);
-                                spin_unlock(&d->lock);
-                        }
-                }
-                spin_unlock_irqrestore(&c->vc.lock, flags);
-                ret = 0;
-                break;
+static int sa11x0_dma_device_resume(struct dma_chan *chan)
+{
+        struct sa11x0_dma_chan *c = to_sa11x0_dma_chan(chan);
+        struct sa11x0_dma_dev *d = to_sa11x0_dma(chan->device);
+        struct sa11x0_dma_phy *p;
+        LIST_HEAD(head);
+        unsigned long flags;
 
-        case DMA_RESUME:
-                dev_dbg(d->slave.dev, "vchan %p: resume\n", &c->vc);
-                spin_lock_irqsave(&c->vc.lock, flags);
-                if (c->status == DMA_PAUSED) {
-                        c->status = DMA_IN_PROGRESS;
-
-                        p = c->phy;
-                        if (p) {
-                                writel(DCSR_RUN | DCSR_IE, p->base + DMA_DCSR_S);
-                        } else if (!list_empty(&c->vc.desc_issued)) {
-                                spin_lock(&d->lock);
-                                list_add_tail(&c->node, &d->chan_pending);
-                                spin_unlock(&d->lock);
-                        }
+        dev_dbg(d->slave.dev, "vchan %p: resume\n", &c->vc);
+        spin_lock_irqsave(&c->vc.lock, flags);
+        if (c->status == DMA_PAUSED) {
+                c->status = DMA_IN_PROGRESS;
+
+                p = c->phy;
+                if (p) {
+                        writel(DCSR_RUN | DCSR_IE, p->base + DMA_DCSR_S);
+                } else if (!list_empty(&c->vc.desc_issued)) {
+                        spin_lock(&d->lock);
+                        list_add_tail(&c->node, &d->chan_pending);
+                        spin_unlock(&d->lock);
                 }
-                spin_unlock_irqrestore(&c->vc.lock, flags);
-                ret = 0;
-                break;
+        }
+        spin_unlock_irqrestore(&c->vc.lock, flags);
 
-        default:
-                ret = -ENXIO;
-                break;
+        return 0;
+}
+
+static int sa11x0_dma_device_terminate_all(struct dma_chan *chan)
+{
+        struct sa11x0_dma_chan *c = to_sa11x0_dma_chan(chan);
+        struct sa11x0_dma_dev *d = to_sa11x0_dma(chan->device);
+        struct sa11x0_dma_phy *p;
+        LIST_HEAD(head);
+        unsigned long flags;
+
+        dev_dbg(d->slave.dev, "vchan %p: terminate all\n", &c->vc);
+        /* Clear the tx descriptor lists */
+        spin_lock_irqsave(&c->vc.lock, flags);
+        vchan_get_all_descriptors(&c->vc, &head);
+
+        p = c->phy;
+        if (p) {
+                dev_dbg(d->slave.dev, "pchan %u: terminating\n", p->num);
+                /* vchan is assigned to a pchan - stop the channel */
+                writel(DCSR_RUN | DCSR_IE |
+                       DCSR_STRTA | DCSR_DONEA |
+                       DCSR_STRTB | DCSR_DONEB,
+                       p->base + DMA_DCSR_C);
+
+                if (p->txd_load) {
+                        if (p->txd_load != p->txd_done)
+                                list_add_tail(&p->txd_load->vd.node, &head);
+                        p->txd_load = NULL;
+                }
+                if (p->txd_done) {
+                        list_add_tail(&p->txd_done->vd.node, &head);
+                        p->txd_done = NULL;
+                }
+                c->phy = NULL;
+                spin_lock(&d->lock);
+                p->vchan = NULL;
+                spin_unlock(&d->lock);
+                tasklet_schedule(&d->task);
         }
+        spin_unlock_irqrestore(&c->vc.lock, flags);
+        vchan_dma_desc_free_list(&c->vc, &head);
 
-        return ret;
+        return 0;
 }
 
 struct sa11x0_dma_channel_desc {
@@ -833,7 +837,10 @@ static int sa11x0_dma_init_dmadev(struct dma_device *dmadev,
         dmadev->dev = dev;
         dmadev->device_alloc_chan_resources = sa11x0_dma_alloc_chan_resources;
         dmadev->device_free_chan_resources = sa11x0_dma_free_chan_resources;
-        dmadev->device_control = sa11x0_dma_control;
+        dmadev->device_config = sa11x0_dma_device_config;
+        dmadev->device_pause = sa11x0_dma_device_pause;
+        dmadev->device_resume = sa11x0_dma_device_resume;
+        dmadev->device_terminate_all = sa11x0_dma_device_terminate_all;
         dmadev->device_tx_status = sa11x0_dma_tx_status;
         dmadev->device_issue_pending = sa11x0_dma_issue_pending;
 
diff --git a/drivers/dma/sh/Kconfig b/drivers/dma/sh/Kconfig
index 0349125a2e20..8190ad225a1b 100644
--- a/drivers/dma/sh/Kconfig
+++ b/drivers/dma/sh/Kconfig
@@ -2,6 +2,10 @@
 # DMA engine configuration for sh
 #
 
+config RENESAS_DMA
+        bool
+        select DMA_ENGINE
+
 #
 # DMA Engine Helpers
 #
@@ -12,7 +16,7 @@ config SH_DMAE_BASE
         depends on !SUPERH || SH_DMA
         depends on !SH_DMA_API
         default y
-        select DMA_ENGINE
+        select RENESAS_DMA
         help
           Enable support for the Renesas SuperH DMA controllers.
 
@@ -52,3 +56,11 @@ config RCAR_AUDMAC_PP
         depends on SH_DMAE_BASE
         help
           Enable support for the Renesas R-Car Audio DMAC Peripheral Peripheral controllers.
+
+config RCAR_DMAC
+        tristate "Renesas R-Car Gen2 DMA Controller"
+        depends on ARCH_SHMOBILE || COMPILE_TEST
+        select RENESAS_DMA
+        help
+          This driver supports the general purpose DMA controller found in the
+          Renesas R-Car second generation SoCs.
diff --git a/drivers/dma/sh/Makefile b/drivers/dma/sh/Makefile
index 0a5cfdb76e45..2852f9db61a4 100644
--- a/drivers/dma/sh/Makefile
+++ b/drivers/dma/sh/Makefile
@@ -16,3 +16,4 @@ obj-$(CONFIG_SH_DMAE) += shdma.o
 obj-$(CONFIG_SUDMAC) += sudmac.o
 obj-$(CONFIG_RCAR_HPB_DMAE) += rcar-hpbdma.o
 obj-$(CONFIG_RCAR_AUDMAC_PP) += rcar-audmapp.o
+obj-$(CONFIG_RCAR_DMAC) += rcar-dmac.o
diff --git a/drivers/dma/sh/rcar-dmac.c b/drivers/dma/sh/rcar-dmac.c
new file mode 100644
index 000000000000..a18d16cc4795
--- /dev/null
+++ b/drivers/dma/sh/rcar-dmac.c
@@ -0,0 +1,1770 @@
+/*
+ * Renesas R-Car Gen2 DMA Controller Driver
+ *
+ * Copyright (C) 2014 Renesas Electronics Inc.
+ *
+ * Author: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/of_dma.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
+#include "../dmaengine.h"
+
+/*
+ * struct rcar_dmac_xfer_chunk - Descriptor for a hardware transfer
+ * @node: entry in the parent's chunks list
+ * @src_addr: device source address
+ * @dst_addr: device destination address
+ * @size: transfer size in bytes
+ */
+struct rcar_dmac_xfer_chunk {
+        struct list_head node;
+
+        dma_addr_t src_addr;
+        dma_addr_t dst_addr;
+        u32 size;
+};
+
+/*
+ * struct rcar_dmac_hw_desc - Hardware descriptor for a transfer chunk
+ * @sar: value of the SAR register (source address)
+ * @dar: value of the DAR register (destination address)
+ * @tcr: value of the TCR register (transfer count)
+ */
+struct rcar_dmac_hw_desc {
+        u32 sar;
+        u32 dar;
+        u32 tcr;
+        u32 reserved;
+} __attribute__((__packed__));
+
+/*
+ * struct rcar_dmac_desc - R-Car Gen2 DMA Transfer Descriptor
+ * @async_tx: base DMA asynchronous transaction descriptor
+ * @direction: direction of the DMA transfer
+ * @xfer_shift: log2 of the transfer size
+ * @chcr: value of the channel configuration register for this transfer
+ * @node: entry in the channel's descriptors lists
+ * @chunks: list of transfer chunks for this transfer
+ * @running: the transfer chunk being currently processed
+ * @nchunks: number of transfer chunks for this transfer
+ * @hwdescs.use: whether the transfer descriptor uses hardware descriptors
+ * @hwdescs.mem: hardware descriptors memory for the transfer
+ * @hwdescs.dma: device address of the hardware descriptors memory
+ * @hwdescs.size: size of the hardware descriptors in bytes
+ * @size: transfer size in bytes
+ * @cyclic: when set indicates that the DMA transfer is cyclic
+ */
+struct rcar_dmac_desc {
+        struct dma_async_tx_descriptor async_tx;
+        enum dma_transfer_direction direction;
+        unsigned int xfer_shift;
+        u32 chcr;
+
+        struct list_head node;
+        struct list_head chunks;
+        struct rcar_dmac_xfer_chunk *running;
+        unsigned int nchunks;
+
+        struct {
+                bool use;
+                struct rcar_dmac_hw_desc *mem;
+                dma_addr_t dma;
+                size_t size;
+        } hwdescs;
+
+        unsigned int size;
+        bool cyclic;
+};
+
+#define to_rcar_dmac_desc(d)    container_of(d, struct rcar_dmac_desc, async_tx)
+
+/*
+ * struct rcar_dmac_desc_page - One page worth of descriptors
+ * @node: entry in the channel's pages list
+ * @descs: array of DMA descriptors
+ * @chunks: array of transfer chunk descriptors
+ */
+struct rcar_dmac_desc_page {
+        struct list_head node;
+
+        union {
+                struct rcar_dmac_desc descs[0];
+                struct rcar_dmac_xfer_chunk chunks[0];
+        };
+};
+
+#define RCAR_DMAC_DESCS_PER_PAGE                                        \
+        ((PAGE_SIZE - offsetof(struct rcar_dmac_desc_page, descs)) /    \
+        sizeof(struct rcar_dmac_desc))
+#define RCAR_DMAC_XFER_CHUNKS_PER_PAGE                                  \
+        ((PAGE_SIZE - offsetof(struct rcar_dmac_desc_page, chunks)) /   \
+        sizeof(struct rcar_dmac_xfer_chunk))
+
+/*
+ * struct rcar_dmac_chan - R-Car Gen2 DMA Controller Channel
+ * @chan: base DMA channel object
+ * @iomem: channel I/O memory base
+ * @index: index of this channel in the controller
+ * @src_xfer_size: size (in bytes) of hardware transfers on the source side
+ * @dst_xfer_size: size (in bytes) of hardware transfers on the destination side
+ * @src_slave_addr: slave source memory address
+ * @dst_slave_addr: slave destination memory address
+ * @mid_rid: hardware MID/RID for the DMA client using this channel
+ * @lock: protects the channel CHCR register and the desc members
+ * @desc.free: list of free descriptors
+ * @desc.pending: list of pending descriptors (submitted with tx_submit)
+ * @desc.active: list of active descriptors (activated with issue_pending)
+ * @desc.done: list of completed descriptors
+ * @desc.wait: list of descriptors waiting for an ack
+ * @desc.running: the descriptor being processed (a member of the active list)
+ * @desc.chunks_free: list of free transfer chunk descriptors
+ * @desc.pages: list of pages used by allocated descriptors
+ */
+struct rcar_dmac_chan {
+        struct dma_chan chan;
+        void __iomem *iomem;
+        unsigned int index;
+
+        unsigned int src_xfer_size;
+        unsigned int dst_xfer_size;
+        dma_addr_t src_slave_addr;
+        dma_addr_t dst_slave_addr;
+        int mid_rid;
+
+        spinlock_t lock;
+
+        struct {
+                struct list_head free;
+                struct list_head pending;
+                struct list_head active;
+                struct list_head done;
+                struct list_head wait;
+                struct rcar_dmac_desc *running;
+
+                struct list_head chunks_free;
+
+                struct list_head pages;
+        } desc;
+};
+
+#define to_rcar_dmac_chan(c)    container_of(c, struct rcar_dmac_chan, chan)
+
+/*
+ * struct rcar_dmac - R-Car Gen2 DMA Controller
+ * @engine: base DMA engine object
+ * @dev: the hardware device
+ * @iomem: remapped I/O memory base
+ * @n_channels: number of available channels
+ * @channels: array of DMAC channels
+ * @modules: bitmask of client modules in use
+ */
+struct rcar_dmac {
+        struct dma_device engine;
+        struct device *dev;
+        void __iomem *iomem;
+
+        unsigned int n_channels;
+        struct rcar_dmac_chan *channels;
+
+        unsigned long modules[256 / BITS_PER_LONG];
+};
+
+#define to_rcar_dmac(d)         container_of(d, struct rcar_dmac, engine)
+
+/* -----------------------------------------------------------------------------
+ * Registers
+ */
+
+#define RCAR_DMAC_CHAN_OFFSET(i)        (0x8000 + 0x80 * (i))
+
+#define RCAR_DMAISTA                    0x0020
+#define RCAR_DMASEC                     0x0030
+#define RCAR_DMAOR                      0x0060
+#define RCAR_DMAOR_PRI_FIXED            (0 << 8)
+#define RCAR_DMAOR_PRI_ROUND_ROBIN      (3 << 8)
+#define RCAR_DMAOR_AE                   (1 << 2)
+#define RCAR_DMAOR_DME                  (1 << 0)
+#define RCAR_DMACHCLR                   0x0080
+#define RCAR_DMADPSEC                   0x00a0
+
+#define RCAR_DMASAR                     0x0000
+#define RCAR_DMADAR                     0x0004
+#define RCAR_DMATCR                     0x0008
+#define RCAR_DMATCR_MASK                0x00ffffff
+#define RCAR_DMATSR                     0x0028
+#define RCAR_DMACHCR                    0x000c
+#define RCAR_DMACHCR_CAE                (1 << 31)
+#define RCAR_DMACHCR_CAIE               (1 << 30)
+#define RCAR_DMACHCR_DPM_DISABLED       (0 << 28)
+#define RCAR_DMACHCR_DPM_ENABLED        (1 << 28)
+#define RCAR_DMACHCR_DPM_REPEAT         (2 << 28)
+#define RCAR_DMACHCR_DPM_INFINITE       (3 << 28)
+#define RCAR_DMACHCR_RPT_SAR            (1 << 27)
+#define RCAR_DMACHCR_RPT_DAR            (1 << 26)
+#define RCAR_DMACHCR_RPT_TCR            (1 << 25)
+#define RCAR_DMACHCR_DPB                (1 << 22)
+#define RCAR_DMACHCR_DSE                (1 << 19)
+#define RCAR_DMACHCR_DSIE               (1 << 18)
+#define RCAR_DMACHCR_TS_1B              ((0 << 20) | (0 << 3))
+#define RCAR_DMACHCR_TS_2B              ((0 << 20) | (1 << 3))
+#define RCAR_DMACHCR_TS_4B              ((0 << 20) | (2 << 3))
+#define RCAR_DMACHCR_TS_16B             ((0 << 20) | (3 << 3))
+#define RCAR_DMACHCR_TS_32B             ((1 << 20) | (0 << 3))
+#define RCAR_DMACHCR_TS_64B             ((1 << 20) | (1 << 3))
+#define RCAR_DMACHCR_TS_8B              ((1 << 20) | (3 << 3))
+#define RCAR_DMACHCR_DM_FIXED           (0 << 14)
+#define RCAR_DMACHCR_DM_INC             (1 << 14)
+#define RCAR_DMACHCR_DM_DEC             (2 << 14)
+#define RCAR_DMACHCR_SM_FIXED           (0 << 12)
+#define RCAR_DMACHCR_SM_INC             (1 << 12)
+#define RCAR_DMACHCR_SM_DEC             (2 << 12)
+#define RCAR_DMACHCR_RS_AUTO            (4 << 8)
+#define RCAR_DMACHCR_RS_DMARS           (8 << 8)
+#define RCAR_DMACHCR_IE                 (1 << 2)
+#define RCAR_DMACHCR_TE                 (1 << 1)
+#define RCAR_DMACHCR_DE                 (1 << 0)
+#define RCAR_DMATCRB                    0x0018
+#define RCAR_DMATSRB                    0x0038
+#define RCAR_DMACHCRB                   0x001c
+#define RCAR_DMACHCRB_DCNT(n)           ((n) << 24)
+#define RCAR_DMACHCRB_DPTR_MASK         (0xff << 16)
+#define RCAR_DMACHCRB_DPTR_SHIFT        16
+#define RCAR_DMACHCRB_DRST              (1 << 15)
+#define RCAR_DMACHCRB_DTS               (1 << 8)
+#define RCAR_DMACHCRB_SLM_NORMAL        (0 << 4)
+#define RCAR_DMACHCRB_SLM_CLK(n)        ((8 | (n)) << 4)
+#define RCAR_DMACHCRB_PRI(n)            ((n) << 0)
+#define RCAR_DMARS                      0x0040
+#define RCAR_DMABUFCR                   0x0048
+#define RCAR_DMABUFCR_MBU(n)            ((n) << 16)
+#define RCAR_DMABUFCR_ULB(n)            ((n) << 0)
+#define RCAR_DMADPBASE                  0x0050
+#define RCAR_DMADPBASE_MASK             0xfffffff0
+#define RCAR_DMADPBASE_SEL              (1 << 0)
+#define RCAR_DMADPCR                    0x0054
+#define RCAR_DMADPCR_DIPT(n)            ((n) << 24)
+#define RCAR_DMAFIXSAR                  0x0010
+#define RCAR_DMAFIXDAR                  0x0014
+#define RCAR_DMAFIXDPBASE               0x0060
+
+/* Hardcode the MEMCPY transfer size to 4 bytes. */
+#define RCAR_DMAC_MEMCPY_XFER_SIZE      4
+
+/* -----------------------------------------------------------------------------
+ * Device access
+ */
+
+static void rcar_dmac_write(struct rcar_dmac *dmac, u32 reg, u32 data)
+{
+        if (reg == RCAR_DMAOR)
+                writew(data, dmac->iomem + reg);
+        else
+                writel(data, dmac->iomem + reg);
+}
+
+static u32 rcar_dmac_read(struct rcar_dmac *dmac, u32 reg)
+{
+        if (reg == RCAR_DMAOR)
+                return readw(dmac->iomem + reg);
+        else
+                return readl(dmac->iomem + reg);
+}
+
+static u32 rcar_dmac_chan_read(struct rcar_dmac_chan *chan, u32 reg)
+{
+        if (reg == RCAR_DMARS)
+                return readw(chan->iomem + reg);
+        else
+                return readl(chan->iomem + reg);
+}
+
+static void rcar_dmac_chan_write(struct rcar_dmac_chan *chan, u32 reg, u32 data)
+{
+        if (reg == RCAR_DMARS)
+                writew(data, chan->iomem + reg);
+        else
+                writel(data, chan->iomem + reg);
+}
+
+/* -----------------------------------------------------------------------------
+ * Initialization and configuration
+ */
+
+static bool rcar_dmac_chan_is_busy(struct rcar_dmac_chan *chan)
+{
+        u32 chcr = rcar_dmac_chan_read(chan, RCAR_DMACHCR);
+
+        return (chcr & (RCAR_DMACHCR_DE | RCAR_DMACHCR_TE)) == RCAR_DMACHCR_DE;
+}
+
+static void rcar_dmac_chan_start_xfer(struct rcar_dmac_chan *chan)
+{
+        struct rcar_dmac_desc *desc = chan->desc.running;
+        u32 chcr = desc->chcr;
+
+        WARN_ON_ONCE(rcar_dmac_chan_is_busy(chan));
+
+        if (chan->mid_rid >= 0)
+                rcar_dmac_chan_write(chan, RCAR_DMARS, chan->mid_rid);
+
+        if (desc->hwdescs.use) {
+                struct rcar_dmac_xfer_chunk *chunk;
+
+                dev_dbg(chan->chan.device->dev,
+                        "chan%u: queue desc %p: %u@%pad\n",
+                        chan->index, desc, desc->nchunks, &desc->hwdescs.dma);
+
+#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
+                rcar_dmac_chan_write(chan, RCAR_DMAFIXDPBASE,
+                                     desc->hwdescs.dma >> 32);
+#endif
+                rcar_dmac_chan_write(chan, RCAR_DMADPBASE,
+                                     (desc->hwdescs.dma & 0xfffffff0) |
+                                     RCAR_DMADPBASE_SEL);
+                rcar_dmac_chan_write(chan, RCAR_DMACHCRB,
+                                     RCAR_DMACHCRB_DCNT(desc->nchunks - 1) |
+                                     RCAR_DMACHCRB_DRST);
+
+                /*
+                 * Errata: When descriptor memory is accessed through an IOMMU
+                 * the DMADAR register isn't initialized automatically from the
+                 * first descriptor at beginning of transfer by the DMAC like it
+                 * should. Initialize it manually with the destination address
+                 * of the first chunk.
+                 */
+                chunk = list_first_entry(&desc->chunks,
+                                         struct rcar_dmac_xfer_chunk, node);
+                rcar_dmac_chan_write(chan, RCAR_DMADAR,
+                                     chunk->dst_addr & 0xffffffff);
+
+                /*
+                 * Program the descriptor stage interrupt to occur after the end
+                 * of the first stage.
+                 */
+                rcar_dmac_chan_write(chan, RCAR_DMADPCR, RCAR_DMADPCR_DIPT(1));
+
+                chcr |= RCAR_DMACHCR_RPT_SAR | RCAR_DMACHCR_RPT_DAR
+                     |  RCAR_DMACHCR_RPT_TCR | RCAR_DMACHCR_DPB;
+
+                /*
+                 * If the descriptor isn't cyclic enable normal descriptor mode
+                 * and the transfer completion interrupt.
+                 */
+                if (!desc->cyclic)
+                        chcr |= RCAR_DMACHCR_DPM_ENABLED | RCAR_DMACHCR_IE;
+                /*
+                 * If the descriptor is cyclic and has a callback enable the
+                 * descriptor stage interrupt in infinite repeat mode.
+                 */
+                else if (desc->async_tx.callback)
+                        chcr |= RCAR_DMACHCR_DPM_INFINITE | RCAR_DMACHCR_DSIE;
+                /*
+                 * Otherwise just select infinite repeat mode without any
+                 * interrupt.
+                 */
+                else
+                        chcr |= RCAR_DMACHCR_DPM_INFINITE;
+        } else {
+                struct rcar_dmac_xfer_chunk *chunk = desc->running;
+
+                dev_dbg(chan->chan.device->dev,
+                        "chan%u: queue chunk %p: %u@%pad -> %pad\n",
+                        chan->index, chunk, chunk->size, &chunk->src_addr,
+                        &chunk->dst_addr);
+
+#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
+                rcar_dmac_chan_write(chan, RCAR_DMAFIXSAR,
+                                     chunk->src_addr >> 32);
+                rcar_dmac_chan_write(chan, RCAR_DMAFIXDAR,
+                                     chunk->dst_addr >> 32);
+#endif
+                rcar_dmac_chan_write(chan, RCAR_DMASAR,
+                                     chunk->src_addr & 0xffffffff);
+                rcar_dmac_chan_write(chan, RCAR_DMADAR,
+                                     chunk->dst_addr & 0xffffffff);
+                rcar_dmac_chan_write(chan, RCAR_DMATCR,
+                                     chunk->size >> desc->xfer_shift);
+
+                chcr |= RCAR_DMACHCR_DPM_DISABLED | RCAR_DMACHCR_IE;
+        }
+
+        rcar_dmac_chan_write(chan, RCAR_DMACHCR, chcr | RCAR_DMACHCR_DE);
+}
+
+static int rcar_dmac_init(struct rcar_dmac *dmac)
+{
+        u16 dmaor;
+
+        /* Clear all channels and enable the DMAC globally. */
+        rcar_dmac_write(dmac, RCAR_DMACHCLR, 0x7fff);
+        rcar_dmac_write(dmac, RCAR_DMAOR,
+                        RCAR_DMAOR_PRI_FIXED | RCAR_DMAOR_DME);
+
+        dmaor = rcar_dmac_read(dmac, RCAR_DMAOR);
+        if ((dmaor & (RCAR_DMAOR_AE | RCAR_DMAOR_DME)) != RCAR_DMAOR_DME) {
+                dev_warn(dmac->dev, "DMAOR initialization failed.\n");
+                return -EIO;
+        }
+
+        return 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * Descriptors submission
+ */
+
+static dma_cookie_t rcar_dmac_tx_submit(struct dma_async_tx_descriptor *tx)
+{
+        struct rcar_dmac_chan *chan = to_rcar_dmac_chan(tx->chan);
+        struct rcar_dmac_desc *desc = to_rcar_dmac_desc(tx);
+        unsigned long flags;
+        dma_cookie_t cookie;
+
+        spin_lock_irqsave(&chan->lock, flags);
+
+        cookie = dma_cookie_assign(tx);
+
+        dev_dbg(chan->chan.device->dev, "chan%u: submit #%d@%p\n",
+                chan->index, tx->cookie, desc);
+
+        list_add_tail(&desc->node, &chan->desc.pending);
+        desc->running = list_first_entry(&desc->chunks,
+                                         struct rcar_dmac_xfer_chunk, node);
+
+        spin_unlock_irqrestore(&chan->lock, flags);
+
+        return cookie;
+}
+
+/* -----------------------------------------------------------------------------
+ * Descriptors allocation and free
+ */
+
+/*
+ * rcar_dmac_desc_alloc - Allocate a page worth of DMA descriptors
+ * @chan: the DMA channel
+ * @gfp: allocation flags
+ */
+static int rcar_dmac_desc_alloc(struct rcar_dmac_chan *chan, gfp_t gfp)
+{
+        struct rcar_dmac_desc_page *page;
+        LIST_HEAD(list);
+        unsigned int i;
+
+        page = (void *)get_zeroed_page(gfp);
+        if (!page)
+                return -ENOMEM;
+
+        for (i = 0; i < RCAR_DMAC_DESCS_PER_PAGE; ++i) {
+                struct rcar_dmac_desc *desc = &page->descs[i];
+
+                dma_async_tx_descriptor_init(&desc->async_tx, &chan->chan);
+                desc->async_tx.tx_submit = rcar_dmac_tx_submit;
+                INIT_LIST_HEAD(&desc->chunks);
+
+                list_add_tail(&desc->node, &list);
+        }
+
+        spin_lock_irq(&chan->lock);
+        list_splice_tail(&list, &chan->desc.free);
+        list_add_tail(&page->node, &chan->desc.pages);
+        spin_unlock_irq(&chan->lock);
+
+        return 0;
+}
+
+/*
+ * rcar_dmac_desc_put - Release a DMA transfer descriptor
+ * @chan: the DMA channel
+ * @desc: the descriptor
+ *
+ * Put the descriptor and its transfer chunk descriptors back in the channel's
+ * free descriptors lists. The descriptor's chunks list will be reinitialized to
+ * an empty list as a result.
+ *
+ * The descriptor must have been removed from the channel's lists before calling
+ * this function.
+ */
+static void rcar_dmac_desc_put(struct rcar_dmac_chan *chan,
+                               struct rcar_dmac_desc *desc)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&chan->lock, flags);
+        list_splice_tail_init(&desc->chunks, &chan->desc.chunks_free);
+        list_add_tail(&desc->node, &chan->desc.free);
+        spin_unlock_irqrestore(&chan->lock, flags);
+}
+
+static void rcar_dmac_desc_recycle_acked(struct rcar_dmac_chan *chan)
+{
+        struct rcar_dmac_desc *desc, *_desc;
+        LIST_HEAD(list);
+
+        /*
+         * We have to temporarily move all descriptors from the wait list to a
+         * local list as iterating over the wait list, even with
+         * list_for_each_entry_safe, isn't safe if we release the channel lock
+         * around the rcar_dmac_desc_put() call.
+         */
+        spin_lock_irq(&chan->lock);
+        list_splice_init(&chan->desc.wait, &list);
+        spin_unlock_irq(&chan->lock);
+
+        list_for_each_entry_safe(desc, _desc, &list, node) {
+                if (async_tx_test_ack(&desc->async_tx)) {
+                        list_del(&desc->node);
+                        rcar_dmac_desc_put(chan, desc);
+                }
+        }
+
+        if (list_empty(&list))
+                return;
+
+        /* Put the remaining descriptors back in the wait list. */
+        spin_lock_irq(&chan->lock);
+        list_splice(&list, &chan->desc.wait);
+        spin_unlock_irq(&chan->lock);
+}
+
+/*
+ * rcar_dmac_desc_get - Allocate a descriptor for a DMA transfer
+ * @chan: the DMA channel
+ *
+ * Locking: This function must be called in a non-atomic context.
+ *
+ * Return: A pointer to the allocated descriptor or NULL if no descriptor can
+ * be allocated.
+ */
+static struct rcar_dmac_desc *rcar_dmac_desc_get(struct rcar_dmac_chan *chan)
+{
+        struct rcar_dmac_desc *desc;
+        int ret;
+
+        /* Recycle acked descriptors before attempting allocation. */
+        rcar_dmac_desc_recycle_acked(chan);
+
+        spin_lock_irq(&chan->lock);
+
+        while (list_empty(&chan->desc.free)) {
+                /*
+                 * No free descriptors, allocate a page worth of them and try
+                 * again, as someone else could race us to get the newly
+                 * allocated descriptors. If the allocation fails return an
+                 * error.
+                 */
+                spin_unlock_irq(&chan->lock);
+                ret = rcar_dmac_desc_alloc(chan, GFP_NOWAIT);
+                if (ret < 0)
+                        return NULL;
+                spin_lock_irq(&chan->lock);
+        }
+
+        desc = list_first_entry(&chan->desc.free, struct rcar_dmac_desc, node);
+        list_del(&desc->node);
+
+        spin_unlock_irq(&chan->lock);
+
+        return desc;
+}
+
+/*
+ * rcar_dmac_xfer_chunk_alloc - Allocate a page worth of transfer chunks
+ * @chan: the DMA channel
+ * @gfp: allocation flags
+ */
+static int rcar_dmac_xfer_chunk_alloc(struct rcar_dmac_chan *chan, gfp_t gfp)
+{
+        struct rcar_dmac_desc_page *page;
+        LIST_HEAD(list);
+        unsigned int i;
+
+        page = (void *)get_zeroed_page(gfp);
+        if (!page)
+                return -ENOMEM;
+
+        for (i = 0; i < RCAR_DMAC_XFER_CHUNKS_PER_PAGE; ++i) {
+                struct rcar_dmac_xfer_chunk *chunk = &page->chunks[i];
+
+                list_add_tail(&chunk->node, &list);
+        }
+
+        spin_lock_irq(&chan->lock);
+        list_splice_tail(&list, &chan->desc.chunks_free);
+        list_add_tail(&page->node, &chan->desc.pages);
+        spin_unlock_irq(&chan->lock);
+
+        return 0;
+}
+
+/*
+ * rcar_dmac_xfer_chunk_get - Allocate a transfer chunk for a DMA transfer
+ * @chan: the DMA channel
+ *
+ * Locking: This function must be called in a non-atomic context.
+ *
+ * Return: A pointer to the allocated transfer chunk descriptor or NULL if no
+ * descriptor can be allocated.
+ */
+static struct rcar_dmac_xfer_chunk *
+rcar_dmac_xfer_chunk_get(struct rcar_dmac_chan *chan)
+{
+        struct rcar_dmac_xfer_chunk *chunk;
+        int ret;
+
+        spin_lock_irq(&chan->lock);
+
+        while (list_empty(&chan->desc.chunks_free)) {
+                /*
+                 * No free descriptors, allocate a page worth of them and try
+                 * again, as someone else could race us to get the newly
+                 * allocated descriptors. If the allocation fails return an
+                 * error.
+                 */
+                spin_unlock_irq(&chan->lock);
+                ret = rcar_dmac_xfer_chunk_alloc(chan, GFP_NOWAIT);
+                if (ret < 0)
+                        return NULL;
+                spin_lock_irq(&chan->lock);
+        }
+
+        chunk = list_first_entry(&chan->desc.chunks_free,
+                                 struct rcar_dmac_xfer_chunk, node);
+        list_del(&chunk->node);
+
+        spin_unlock_irq(&chan->lock);
+
+        return chunk;
+}
+
+static void rcar_dmac_realloc_hwdesc(struct rcar_dmac_chan *chan,
+                                     struct rcar_dmac_desc *desc, size_t size)
+{
+        /*
+         * dma_alloc_coherent() allocates memory in page size increments. To
+         * avoid reallocating the hardware descriptors when the allocated size
+         * wouldn't change align the requested size to a multiple of the page
+         * size.
+         */
+        size = PAGE_ALIGN(size);
+
+        if (desc->hwdescs.size == size)
+                return;
+
+        if (desc->hwdescs.mem) {
+                dma_free_coherent(chan->chan.device->dev, desc->hwdescs.size,
+                                  desc->hwdescs.mem, desc->hwdescs.dma);
+                desc->hwdescs.mem = NULL;
+                desc->hwdescs.size = 0;
+        }
+
+        if (!size)
+                return;
+
+        desc->hwdescs.mem = dma_alloc_coherent(chan->chan.device->dev, size,
+                                               &desc->hwdescs.dma, GFP_NOWAIT);
+        if (!desc->hwdescs.mem)
+                return;
+
+        desc->hwdescs.size = size;
+}
+
+static int rcar_dmac_fill_hwdesc(struct rcar_dmac_chan *chan,
+                                 struct rcar_dmac_desc *desc)
+{
+        struct rcar_dmac_xfer_chunk *chunk;
+        struct rcar_dmac_hw_desc *hwdesc;
+
+        rcar_dmac_realloc_hwdesc(chan, desc, desc->nchunks * sizeof(*hwdesc));
+
+        hwdesc = desc->hwdescs.mem;
+        if (!hwdesc)
+                return -ENOMEM;
+
+        list_for_each_entry(chunk, &desc->chunks, node) {
+                hwdesc->sar = chunk->src_addr;
+                hwdesc->dar = chunk->dst_addr;
+                hwdesc->tcr = chunk->size >> desc->xfer_shift;
+                hwdesc++;
+        }
+
+        return 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * Stop and reset
+ */
+
+static void rcar_dmac_chan_halt(struct rcar_dmac_chan *chan)
+{
+        u32 chcr = rcar_dmac_chan_read(chan, RCAR_DMACHCR);
+
+        chcr &= ~(RCAR_DMACHCR_DSE | RCAR_DMACHCR_DSIE | RCAR_DMACHCR_IE |
+                  RCAR_DMACHCR_TE | RCAR_DMACHCR_DE);
+        rcar_dmac_chan_write(chan, RCAR_DMACHCR, chcr);
+}
+
+static void rcar_dmac_chan_reinit(struct rcar_dmac_chan *chan)
+{
+        struct rcar_dmac_desc *desc, *_desc;
+        unsigned long flags;
+        LIST_HEAD(descs);
+
+        spin_lock_irqsave(&chan->lock, flags);
+
+        /* Move all non-free descriptors to the local lists. */
+        list_splice_init(&chan->desc.pending, &descs);
+        list_splice_init(&chan->desc.active, &descs);
+        list_splice_init(&chan->desc.done, &descs);
+        list_splice_init(&chan->desc.wait, &descs);
+
+        chan->desc.running = NULL;
+
+        spin_unlock_irqrestore(&chan->lock, flags);
+
+        list_for_each_entry_safe(desc, _desc, &descs, node) {
+                list_del(&desc->node);
+                rcar_dmac_desc_put(chan, desc);
+        }
+}
+
+static void rcar_dmac_stop(struct rcar_dmac *dmac)
+{
+        rcar_dmac_write(dmac, RCAR_DMAOR, 0);
+}
+
+static void rcar_dmac_abort(struct rcar_dmac *dmac)
+{
+        unsigned int i;
+
+        /* Stop all channels. */
+        for (i = 0; i < dmac->n_channels; ++i) {
+                struct rcar_dmac_chan *chan = &dmac->channels[i];
+
+                /* Stop and reinitialize the channel. */
+                spin_lock(&chan->lock);
+                rcar_dmac_chan_halt(chan);
+                spin_unlock(&chan->lock);
+
+                rcar_dmac_chan_reinit(chan);
+        }
+}
+
+/* -----------------------------------------------------------------------------
+ * Descriptors preparation
+ */
+
+static void rcar_dmac_chan_configure_desc(struct rcar_dmac_chan *chan,
+                                          struct rcar_dmac_desc *desc)
+{
+        static const u32 chcr_ts[] = {
+                RCAR_DMACHCR_TS_1B, RCAR_DMACHCR_TS_2B,
+                RCAR_DMACHCR_TS_4B, RCAR_DMACHCR_TS_8B,
+                RCAR_DMACHCR_TS_16B, RCAR_DMACHCR_TS_32B,
+                RCAR_DMACHCR_TS_64B,
+        };
+
+        unsigned int xfer_size;
+        u32 chcr;
+
+        switch (desc->direction) {
+        case DMA_DEV_TO_MEM:
+                chcr = RCAR_DMACHCR_DM_INC | RCAR_DMACHCR_SM_FIXED
+                     | RCAR_DMACHCR_RS_DMARS;
+                xfer_size = chan->src_xfer_size;
+                break;
+
+        case DMA_MEM_TO_DEV:
+                chcr = RCAR_DMACHCR_DM_FIXED | RCAR_DMACHCR_SM_INC
+                     | RCAR_DMACHCR_RS_DMARS;
+                xfer_size = chan->dst_xfer_size;
+                break;
+
+        case DMA_MEM_TO_MEM:
+        default:
+                chcr = RCAR_DMACHCR_DM_INC | RCAR_DMACHCR_SM_INC
+                     | RCAR_DMACHCR_RS_AUTO;
+                xfer_size = RCAR_DMAC_MEMCPY_XFER_SIZE;
+                break;
+        }
+
+        desc->xfer_shift = ilog2(xfer_size);
+        desc->chcr = chcr | chcr_ts[desc->xfer_shift];
+}
+
+/*
+ * rcar_dmac_chan_prep_sg - prepare transfer descriptors from an SG list
+ *
+ * Common routine for public (MEMCPY) and slave DMA. The MEMCPY case is also
+ * converted to scatter-gather to guarantee consistent locking and a correct
+ * list manipulation. For slave DMA direction carries the usual meaning, and,
+ * logically, the SG list is RAM and the addr variable contains slave address,
+ * e.g., the FIFO I/O register. For MEMCPY direction equals DMA_MEM_TO_MEM
+ * and the SG list contains only one element and points at the source buffer.
+ */
+static struct dma_async_tx_descriptor *
+rcar_dmac_chan_prep_sg(struct rcar_dmac_chan *chan, struct scatterlist *sgl,
+                       unsigned int sg_len, dma_addr_t dev_addr,
+                       enum dma_transfer_direction dir, unsigned long dma_flags,
+                       bool cyclic)
+{
+        struct rcar_dmac_xfer_chunk *chunk;
+        struct rcar_dmac_desc *desc;
+        struct scatterlist *sg;
+        unsigned int nchunks = 0;
+        unsigned int max_chunk_size;
+        unsigned int full_size = 0;
+        bool highmem = false;
+        unsigned int i;
+
+        desc = rcar_dmac_desc_get(chan);
+        if (!desc)
+                return NULL;
+
+        desc->async_tx.flags = dma_flags;
+        desc->async_tx.cookie = -EBUSY;
+
+        desc->cyclic = cyclic;
+        desc->direction = dir;
+
+        rcar_dmac_chan_configure_desc(chan, desc);
+
+        max_chunk_size = (RCAR_DMATCR_MASK + 1) << desc->xfer_shift;
+
+        /*
+         * Allocate and fill the transfer chunk descriptors. We own the only
+         * reference to the DMA descriptor, there's no need for locking.
+         */
+        for_each_sg(sgl, sg, sg_len, i) {
+                dma_addr_t mem_addr = sg_dma_address(sg);
+                unsigned int len = sg_dma_len(sg);
+
+                full_size += len;
+
+                while (len) {
+                        unsigned int size = min(len, max_chunk_size);
+
+#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
+                        /*
+                         * Prevent individual transfers from crossing 4GB
+                         * boundaries.
+                         */
+                        if (dev_addr >> 32 != (dev_addr + size - 1) >> 32)
+                                size = ALIGN(dev_addr, 1ULL << 32) - dev_addr;
+                        if (mem_addr >> 32 != (mem_addr + size - 1) >> 32)
+                                size = ALIGN(mem_addr, 1ULL << 32) - mem_addr;
+
+                        /*
+                         * Check if either of the source or destination address
+                         * can't be expressed in 32 bits. If so we can't use
+                         * hardware descriptor lists.
+                         */
+                        if (dev_addr >> 32 || mem_addr >> 32)
+                                highmem = true;
+#endif
+
+                        chunk = rcar_dmac_xfer_chunk_get(chan);
+                        if (!chunk) {
+                                rcar_dmac_desc_put(chan, desc);
+                                return NULL;
+                        }
+
+                        if (dir == DMA_DEV_TO_MEM) {
+                                chunk->src_addr = dev_addr;
+                                chunk->dst_addr = mem_addr;
+                        } else {
+                                chunk->src_addr = mem_addr;
+                                chunk->dst_addr = dev_addr;
+                        }
+
+                        chunk->size = size;
+
+                        dev_dbg(chan->chan.device->dev,
+                                "chan%u: chunk %p/%p sgl %u@%p, %u/%u %pad -> %pad\n",
+                                chan->index, chunk, desc, i, sg, size, len,
+                                &chunk->src_addr, &chunk->dst_addr);
+
+                        mem_addr += size;
+                        if (dir == DMA_MEM_TO_MEM)
+                                dev_addr += size;
+
+                        len -= size;
+
+                        list_add_tail(&chunk->node, &desc->chunks);
+                        nchunks++;
+                }
+        }
+
+        desc->nchunks = nchunks;
+        desc->size = full_size;
+
+        /*
+         * Use hardware descriptor lists if possible when more than one chunk
+         * needs to be transferred (otherwise they don't make much sense).
+         *
+         * The highmem check currently covers the whole transfer. As an
+         * optimization we could use descriptor lists for consecutive lowmem
+         * chunks and direct manual mode for highmem chunks. Whether the
+         * performance improvement would be significant enough compared to the
+         * additional complexity remains to be investigated.
+         */
+        desc->hwdescs.use = !highmem && nchunks > 1;
+        if (desc->hwdescs.use) {
+                if (rcar_dmac_fill_hwdesc(chan, desc) < 0)
+                        desc->hwdescs.use = false;
+        }
+
+        return &desc->async_tx;
+}
+
+/* -----------------------------------------------------------------------------
+ * DMA engine operations
+ */
+
+static int rcar_dmac_alloc_chan_resources(struct dma_chan *chan)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+        int ret;
+
+        INIT_LIST_HEAD(&rchan->desc.chunks_free);
+        INIT_LIST_HEAD(&rchan->desc.pages);
+
+        /* Preallocate descriptors. */
+        ret = rcar_dmac_xfer_chunk_alloc(rchan, GFP_KERNEL);
+        if (ret < 0)
+                return -ENOMEM;
+
+        ret = rcar_dmac_desc_alloc(rchan, GFP_KERNEL);
+        if (ret < 0)
+                return -ENOMEM;
+
+        return pm_runtime_get_sync(chan->device->dev);
+}
+
+static void rcar_dmac_free_chan_resources(struct dma_chan *chan)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+        struct rcar_dmac *dmac = to_rcar_dmac(chan->device);
+        struct rcar_dmac_desc_page *page, *_page;
+        struct rcar_dmac_desc *desc;
+        LIST_HEAD(list);
+
+        /* Protect against ISR */
+        spin_lock_irq(&rchan->lock);
+        rcar_dmac_chan_halt(rchan);
+        spin_unlock_irq(&rchan->lock);
+
+        /* Now no new interrupts will occur */
+
+        if (rchan->mid_rid >= 0) {
+                /* The caller is holding dma_list_mutex */
+                clear_bit(rchan->mid_rid, dmac->modules);
+                rchan->mid_rid = -EINVAL;
+        }
+
+        list_splice_init(&rchan->desc.free, &list);
+        list_splice_init(&rchan->desc.pending, &list);
+        list_splice_init(&rchan->desc.active, &list);
+        list_splice_init(&rchan->desc.done, &list);
+        list_splice_init(&rchan->desc.wait, &list);
+
+        list_for_each_entry(desc, &list, node)
+                rcar_dmac_realloc_hwdesc(rchan, desc, 0);
+
+        list_for_each_entry_safe(page, _page, &rchan->desc.pages, node) {
+                list_del(&page->node);
+                free_page((unsigned long)page);
+        }
+
+        pm_runtime_put(chan->device->dev);
+}
+
+static struct dma_async_tx_descriptor *
+rcar_dmac_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dma_dest,
+                          dma_addr_t dma_src, size_t len, unsigned long flags)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+        struct scatterlist sgl;
+
+        if (!len)
+                return NULL;
+
+        sg_init_table(&sgl, 1);
+        sg_set_page(&sgl, pfn_to_page(PFN_DOWN(dma_src)), len,
+                    offset_in_page(dma_src));
+        sg_dma_address(&sgl) = dma_src;
+        sg_dma_len(&sgl) = len;
+
+        return rcar_dmac_chan_prep_sg(rchan, &sgl, 1, dma_dest,
+                                      DMA_MEM_TO_MEM, flags, false);
+}
+
+static struct dma_async_tx_descriptor *
+rcar_dmac_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
+                        unsigned int sg_len, enum dma_transfer_direction dir,
+                        unsigned long flags, void *context)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+        dma_addr_t dev_addr;
+
+        /* Someone calling slave DMA on a generic channel? */
+        if (rchan->mid_rid < 0 || !sg_len) {
+                dev_warn(chan->device->dev,
+                         "%s: bad parameter: len=%d, id=%d\n",
+                         __func__, sg_len, rchan->mid_rid);
+                return NULL;
+        }
+
+        dev_addr = dir == DMA_DEV_TO_MEM
+                 ? rchan->src_slave_addr : rchan->dst_slave_addr;
+        return rcar_dmac_chan_prep_sg(rchan, sgl, sg_len, dev_addr,
+                                      dir, flags, false);
+}
+
+#define RCAR_DMAC_MAX_SG_LEN    32
+
+static struct dma_async_tx_descriptor *
+rcar_dmac_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr,
+                          size_t buf_len, size_t period_len,
+                          enum dma_transfer_direction dir, unsigned long flags)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+        struct dma_async_tx_descriptor *desc;
+        struct scatterlist *sgl;
+        dma_addr_t dev_addr;
+        unsigned int sg_len;
+        unsigned int i;
+
+        /* Someone calling slave DMA on a generic channel? */
+        if (rchan->mid_rid < 0 || buf_len < period_len) {
+                dev_warn(chan->device->dev,
+                        "%s: bad parameter: buf_len=%zu, period_len=%zu, id=%d\n",
+                        __func__, buf_len, period_len, rchan->mid_rid);
+                return NULL;
+        }
+
+        sg_len = buf_len / period_len;
+        if (sg_len > RCAR_DMAC_MAX_SG_LEN) {
+                dev_err(chan->device->dev,
+                        "chan%u: sg length %d exceds limit %d",
+                        rchan->index, sg_len, RCAR_DMAC_MAX_SG_LEN);
+                return NULL;
+        }
+
+        /*
+         * Allocate the sg list dynamically as it would consume too much stack
+         * space.
+         */
+        sgl = kcalloc(sg_len, sizeof(*sgl), GFP_NOWAIT);
+        if (!sgl)
+                return NULL;
+
+        sg_init_table(sgl, sg_len);
+
+        for (i = 0; i < sg_len; ++i) {
+                dma_addr_t src = buf_addr + (period_len * i);
+
+                sg_set_page(&sgl[i], pfn_to_page(PFN_DOWN(src)), period_len,
+                            offset_in_page(src));
+                sg_dma_address(&sgl[i]) = src;
+                sg_dma_len(&sgl[i]) = period_len;
+        }
+
+        dev_addr = dir == DMA_DEV_TO_MEM
+                 ? rchan->src_slave_addr : rchan->dst_slave_addr;
+        desc = rcar_dmac_chan_prep_sg(rchan, sgl, sg_len, dev_addr,
+                                      dir, flags, true);
+
+        kfree(sgl);
+        return desc;
+}
+
+static int rcar_dmac_device_config(struct dma_chan *chan,
+                                   struct dma_slave_config *cfg)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+
+        /*
+         * We could lock this, but you shouldn't be configuring the
+         * channel, while using it...
+         */
+        rchan->src_slave_addr = cfg->src_addr;
+        rchan->dst_slave_addr = cfg->dst_addr;
+        rchan->src_xfer_size = cfg->src_addr_width;
+        rchan->dst_xfer_size = cfg->dst_addr_width;
+
+        return 0;
+}
+
+static int rcar_dmac_chan_terminate_all(struct dma_chan *chan)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&rchan->lock, flags);
+        rcar_dmac_chan_halt(rchan);
+        spin_unlock_irqrestore(&rchan->lock, flags);
+
+        /*
+         * FIXME: No new interrupt can occur now, but the IRQ thread might still
+         * be running.
+         */
+
+        rcar_dmac_chan_reinit(rchan);
+
+        return 0;
+}
+
+static unsigned int rcar_dmac_chan_get_residue(struct rcar_dmac_chan *chan,
+                                               dma_cookie_t cookie)
+{
+        struct rcar_dmac_desc *desc = chan->desc.running;
+        struct rcar_dmac_xfer_chunk *running = NULL;
+        struct rcar_dmac_xfer_chunk *chunk;
+        unsigned int residue = 0;
+        unsigned int dptr = 0;
+
+        if (!desc)
+                return 0;
+
+        /*
+         * If the cookie doesn't correspond to the currently running transfer
+         * then the descriptor hasn't been processed yet, and the residue is
+         * equal to the full descriptor size.
+         */
+        if (cookie != desc->async_tx.cookie)
+                return desc->size;
+
+        /*
+         * In descriptor mode the descriptor running pointer is not maintained
+         * by the interrupt handler, find the running descriptor from the
+         * descriptor pointer field in the CHCRB register. In non-descriptor
+         * mode just use the running descriptor pointer.
+         */
+        if (desc->hwdescs.use) {
+                dptr = (rcar_dmac_chan_read(chan, RCAR_DMACHCRB) &
+                        RCAR_DMACHCRB_DPTR_MASK) >> RCAR_DMACHCRB_DPTR_SHIFT;
+                WARN_ON(dptr >= desc->nchunks);
+        } else {
+                running = desc->running;
+        }
+
+        /* Compute the size of all chunks still to be transferred. */
+        list_for_each_entry_reverse(chunk, &desc->chunks, node) {
+                if (chunk == running || ++dptr == desc->nchunks)
+                        break;
+
+                residue += chunk->size;
+        }
+
+        /* Add the residue for the current chunk. */
+        residue += rcar_dmac_chan_read(chan, RCAR_DMATCR) << desc->xfer_shift;
+
+        return residue;
+}
+
+static enum dma_status rcar_dmac_tx_status(struct dma_chan *chan,
+                                           dma_cookie_t cookie,
+                                           struct dma_tx_state *txstate)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+        enum dma_status status;
+        unsigned long flags;
+        unsigned int residue;
+
+        status = dma_cookie_status(chan, cookie, txstate);
+        if (status == DMA_COMPLETE || !txstate)
+                return status;
+
+        spin_lock_irqsave(&rchan->lock, flags);
+        residue = rcar_dmac_chan_get_residue(rchan, cookie);
+        spin_unlock_irqrestore(&rchan->lock, flags);
+
+        dma_set_residue(txstate, residue);
+
+        return status;
+}
+
+static void rcar_dmac_issue_pending(struct dma_chan *chan)
+{
+        struct rcar_dmac_chan *rchan = to_rcar_dmac_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&rchan->lock, flags);
+
+        if (list_empty(&rchan->desc.pending))
+                goto done;
+
+        /* Append the pending list to the active list. */
+        list_splice_tail_init(&rchan->desc.pending, &rchan->desc.active);
+
+        /*
+         * If no transfer is running pick the first descriptor from the active
+         * list and start the transfer.
+         */
+        if (!rchan->desc.running) {
+                struct rcar_dmac_desc *desc;
+
+                desc = list_first_entry(&rchan->desc.active,
+                                        struct rcar_dmac_desc, node);
+                rchan->desc.running = desc;
+
+                rcar_dmac_chan_start_xfer(rchan);
+        }
+
+done:
+        spin_unlock_irqrestore(&rchan->lock, flags);
+}
+
+/* -----------------------------------------------------------------------------
+ * IRQ handling
+ */
+
+static irqreturn_t rcar_dmac_isr_desc_stage_end(struct rcar_dmac_chan *chan)
+{
+        struct rcar_dmac_desc *desc = chan->desc.running;
+        unsigned int stage;
+
+        if (WARN_ON(!desc || !desc->cyclic)) {
+                /*
+                 * This should never happen, there should always be a running
+                 * cyclic descriptor when a descriptor stage end interrupt is
+                 * triggered. Warn and return.
+                 */
+                return IRQ_NONE;
+        }
+
+        /* Program the interrupt pointer to the next stage. */
+        stage = (rcar_dmac_chan_read(chan, RCAR_DMACHCRB) &
+                 RCAR_DMACHCRB_DPTR_MASK) >> RCAR_DMACHCRB_DPTR_SHIFT;
+        rcar_dmac_chan_write(chan, RCAR_DMADPCR, RCAR_DMADPCR_DIPT(stage));
+
+        return IRQ_WAKE_THREAD;
+}
+
+static irqreturn_t rcar_dmac_isr_transfer_end(struct rcar_dmac_chan *chan)
+{
+        struct rcar_dmac_desc *desc = chan->desc.running;
+        irqreturn_t ret = IRQ_WAKE_THREAD;
+
+        if (WARN_ON_ONCE(!desc)) {
+                /*
+                 * This should never happen, there should always be a running
+                 * descriptor when a transfer end interrupt is triggered. Warn
+                 * and return.
+                 */
+                return IRQ_NONE;
+        }
+
+        /*
+         * The transfer end interrupt isn't generated for each chunk when using
+         * descriptor mode. Only update the running chunk pointer in
+         * non-descriptor mode.
+         */
+        if (!desc->hwdescs.use) {
+                /*
+                 * If we haven't completed the last transfer chunk simply move
+                 * to the next one. Only wake the IRQ thread if the transfer is
+                 * cyclic.
+                 */
+                if (!list_is_last(&desc->running->node, &desc->chunks)) {
+                        desc->running = list_next_entry(desc->running, node);
+                        if (!desc->cyclic)
+                                ret = IRQ_HANDLED;
+                        goto done;
+                }
+
+                /*
+                 * We've completed the last transfer chunk. If the transfer is
+                 * cyclic, move back to the first one.
+                 */
+                if (desc->cyclic) {
+                        desc->running =
+                                list_first_entry(&desc->chunks,
+                                                 struct rcar_dmac_xfer_chunk,
+                                                 node);
+                        goto done;
+                }
+        }
+
+        /* The descriptor is complete, move it to the done list. */
+        list_move_tail(&desc->node, &chan->desc.done);
+
+        /* Queue the next descriptor, if any. */
+        if (!list_empty(&chan->desc.active))
+                chan->desc.running = list_first_entry(&chan->desc.active,
+                                                      struct rcar_dmac_desc,
+                                                      node);
+        else
+                chan->desc.running = NULL;
+
+done:
+        if (chan->desc.running)
+                rcar_dmac_chan_start_xfer(chan);
+
+        return ret;
+}
+
+static irqreturn_t rcar_dmac_isr_channel(int irq, void *dev)
+{
+        u32 mask = RCAR_DMACHCR_DSE | RCAR_DMACHCR_TE;
+        struct rcar_dmac_chan *chan = dev;
+        irqreturn_t ret = IRQ_NONE;
+        u32 chcr;
+
+        spin_lock(&chan->lock);
+
+        chcr = rcar_dmac_chan_read(chan, RCAR_DMACHCR);
+        if (chcr & RCAR_DMACHCR_TE)
+                mask |= RCAR_DMACHCR_DE;
+        rcar_dmac_chan_write(chan, RCAR_DMACHCR, chcr & ~mask);
+
+        if (chcr & RCAR_DMACHCR_DSE)
+                ret |= rcar_dmac_isr_desc_stage_end(chan);
+
+        if (chcr & RCAR_DMACHCR_TE)
+                ret |= rcar_dmac_isr_transfer_end(chan);
+
+        spin_unlock(&chan->lock);
+
+        return ret;
+}
+
+static irqreturn_t rcar_dmac_isr_channel_thread(int irq, void *dev)
+{
+        struct rcar_dmac_chan *chan = dev;
+        struct rcar_dmac_desc *desc;
+
+        spin_lock_irq(&chan->lock);
+
+        /* For cyclic transfers notify the user after every chunk. */
+        if (chan->desc.running && chan->desc.running->cyclic) {
+                dma_async_tx_callback callback;
+                void *callback_param;
+
+                desc = chan->desc.running;
+                callback = desc->async_tx.callback;
+                callback_param = desc->async_tx.callback_param;
+
+                if (callback) {
+                        spin_unlock_irq(&chan->lock);
+                        callback(callback_param);
+                        spin_lock_irq(&chan->lock);
+                }
+        }
+
+        /*
+         * Call the callback function for all descriptors on the done list and
+         * move them to the ack wait list.
+         */
+        while (!list_empty(&chan->desc.done)) {
+                desc = list_first_entry(&chan->desc.done, struct rcar_dmac_desc,
+                                        node);
+                dma_cookie_complete(&desc->async_tx);
+                list_del(&desc->node);
+
+                if (desc->async_tx.callback) {
+                        spin_unlock_irq(&chan->lock);
+                        /*
+                         * We own the only reference to this descriptor, we can
+                         * safely dereference it without holding the channel
+                         * lock.
+                         */
+                        desc->async_tx.callback(desc->async_tx.callback_param);
+                        spin_lock_irq(&chan->lock);
+                }
+
+                list_add_tail(&desc->node, &chan->desc.wait);
+        }
+
+        spin_unlock_irq(&chan->lock);
+
+        /* Recycle all acked descriptors. */
+        rcar_dmac_desc_recycle_acked(chan);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t rcar_dmac_isr_error(int irq, void *data)
+{
+        struct rcar_dmac *dmac = data;
+
+        if (!(rcar_dmac_read(dmac, RCAR_DMAOR) & RCAR_DMAOR_AE))
+                return IRQ_NONE;
+
+        /*
+         * An unrecoverable error occurred on an unknown channel. Halt the DMAC,
+         * abort transfers on all channels, and reinitialize the DMAC.
+         */
+        rcar_dmac_stop(dmac);
+        rcar_dmac_abort(dmac);
+        rcar_dmac_init(dmac);
+
+        return IRQ_HANDLED;
+}
+
+/* -----------------------------------------------------------------------------
+ * OF xlate and channel filter
+ */
+
+static bool rcar_dmac_chan_filter(struct dma_chan *chan, void *arg)
+{
+        struct rcar_dmac *dmac = to_rcar_dmac(chan->device);
+        struct of_phandle_args *dma_spec = arg;
+
+        /*
+         * FIXME: Using a filter on OF platforms is a nonsense. The OF xlate
+         * function knows from which device it wants to allocate a channel from,
+         * and would be perfectly capable of selecting the channel it wants.
+         * Forcing it to call dma_request_channel() and iterate through all
+         * channels from all controllers is just pointless.
+         */
+        if (chan->device->device_config != rcar_dmac_device_config ||
+            dma_spec->np != chan->device->dev->of_node)
+                return false;
+
+        return !test_and_set_bit(dma_spec->args[0], dmac->modules);
+}
+
+static struct dma_chan *rcar_dmac_of_xlate(struct of_phandle_args *dma_spec,
+                                           struct of_dma *ofdma)
+{
+        struct rcar_dmac_chan *rchan;
+        struct dma_chan *chan;
+        dma_cap_mask_t mask;
+
+        if (dma_spec->args_count != 1)
+                return NULL;
+
+        /* Only slave DMA channels can be allocated via DT */
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        chan = dma_request_channel(mask, rcar_dmac_chan_filter, dma_spec);
+        if (!chan)
+                return NULL;
+
+        rchan = to_rcar_dmac_chan(chan);
+        rchan->mid_rid = dma_spec->args[0];
+
+        return chan;
+}
+
+/* -----------------------------------------------------------------------------
+ * Power management
+ */
+
+#ifdef CONFIG_PM_SLEEP
+static int rcar_dmac_sleep_suspend(struct device *dev)
+{
+        /*
+         * TODO: Wait for the current transfer to complete and stop the device.
+         */
+        return 0;
+}
+
+static int rcar_dmac_sleep_resume(struct device *dev)
+{
+        /* TODO: Resume transfers, if any. */
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_PM
+static int rcar_dmac_runtime_suspend(struct device *dev)
+{
+        return 0;
+}
+
+static int rcar_dmac_runtime_resume(struct device *dev)
+{
+        struct rcar_dmac *dmac = dev_get_drvdata(dev);
+
+        return rcar_dmac_init(dmac);
+}
+#endif
+
+static const struct dev_pm_ops rcar_dmac_pm = {
+        SET_SYSTEM_SLEEP_PM_OPS(rcar_dmac_sleep_suspend, rcar_dmac_sleep_resume)
+        SET_RUNTIME_PM_OPS(rcar_dmac_runtime_suspend, rcar_dmac_runtime_resume,
+                           NULL)
+};
+
+/* -----------------------------------------------------------------------------
+ * Probe and remove
+ */
+
+static int rcar_dmac_chan_probe(struct rcar_dmac *dmac,
+                                struct rcar_dmac_chan *rchan,
+                                unsigned int index)
+{
+        struct platform_device *pdev = to_platform_device(dmac->dev);
+        struct dma_chan *chan = &rchan->chan;
+        char pdev_irqname[5];
+        char *irqname;
+        int irq;
+        int ret;
+
+        rchan->index = index;
+        rchan->iomem = dmac->iomem + RCAR_DMAC_CHAN_OFFSET(index);
+        rchan->mid_rid = -EINVAL;
+
+        spin_lock_init(&rchan->lock);
+
+        INIT_LIST_HEAD(&rchan->desc.free);
+        INIT_LIST_HEAD(&rchan->desc.pending);
+        INIT_LIST_HEAD(&rchan->desc.active);
+        INIT_LIST_HEAD(&rchan->desc.done);
+        INIT_LIST_HEAD(&rchan->desc.wait);
+
+        /* Request the channel interrupt. */
+        sprintf(pdev_irqname, "ch%u", index);
+        irq = platform_get_irq_byname(pdev, pdev_irqname);
+        if (irq < 0) {
+                dev_err(dmac->dev, "no IRQ specified for channel %u\n", index);
+                return -ENODEV;
+        }
+
+        irqname = devm_kasprintf(dmac->dev, GFP_KERNEL, "%s:%u",
+                                 dev_name(dmac->dev), index);
+        if (!irqname)
+                return -ENOMEM;
+
+        ret = devm_request_threaded_irq(dmac->dev, irq, rcar_dmac_isr_channel,
+                                        rcar_dmac_isr_channel_thread, 0,
+                                        irqname, rchan);
+        if (ret) {
+                dev_err(dmac->dev, "failed to request IRQ %u (%d)\n", irq, ret);
+                return ret;
+        }
+
+        /*
+         * Initialize the DMA engine channel and add it to the DMA engine
+         * channels list.
+         */
+        chan->device = &dmac->engine;
+        dma_cookie_init(chan);
+
+        list_add_tail(&chan->device_node, &dmac->engine.channels);
+
+        return 0;
+}
+
+static int rcar_dmac_parse_of(struct device *dev, struct rcar_dmac *dmac)
+{
+        struct device_node *np = dev->of_node;
+        int ret;
+
+        ret = of_property_read_u32(np, "dma-channels", &dmac->n_channels);
+        if (ret < 0) {
+                dev_err(dev, "unable to read dma-channels property\n");
+                return ret;
+        }
+
+        if (dmac->n_channels <= 0 || dmac->n_channels >= 100) {
+                dev_err(dev, "invalid number of channels %u\n",
+                        dmac->n_channels);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int rcar_dmac_probe(struct platform_device *pdev)
+{
+        const enum dma_slave_buswidth widths = DMA_SLAVE_BUSWIDTH_1_BYTE |
+                DMA_SLAVE_BUSWIDTH_2_BYTES | DMA_SLAVE_BUSWIDTH_4_BYTES |
+                DMA_SLAVE_BUSWIDTH_8_BYTES | DMA_SLAVE_BUSWIDTH_16_BYTES |
+                DMA_SLAVE_BUSWIDTH_32_BYTES | DMA_SLAVE_BUSWIDTH_64_BYTES;
+        unsigned int channels_offset = 0;
+        struct dma_device *engine;
+        struct rcar_dmac *dmac;
+        struct resource *mem;
+        unsigned int i;
+        char *irqname;
+        int irq;
+        int ret;
+
+        dmac = devm_kzalloc(&pdev->dev, sizeof(*dmac), GFP_KERNEL);
+        if (!dmac)
+                return -ENOMEM;
+
+        dmac->dev = &pdev->dev;
+        platform_set_drvdata(pdev, dmac);
+
+        ret = rcar_dmac_parse_of(&pdev->dev, dmac);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * A still unconfirmed hardware bug prevents the IPMMU microTLB 0 to be
+         * flushed correctly, resulting in memory corruption. DMAC 0 channel 0
+         * is connected to microTLB 0 on currently supported platforms, so we
+         * can't use it with the IPMMU. As the IOMMU API operates at the device
+         * level we can't disable it selectively, so ignore channel 0 for now if
+         * the device is part of an IOMMU group.
+         */
+        if (pdev->dev.iommu_group) {
+                dmac->n_channels--;
+                channels_offset = 1;
+        }
+
+        dmac->channels = devm_kcalloc(&pdev->dev, dmac->n_channels,
+                                      sizeof(*dmac->channels), GFP_KERNEL);
+        if (!dmac->channels)
+                return -ENOMEM;
+
+        /* Request resources. */
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        dmac->iomem = devm_ioremap_resource(&pdev->dev, mem);
+        if (IS_ERR(dmac->iomem))
+                return PTR_ERR(dmac->iomem);
+
+        irq = platform_get_irq_byname(pdev, "error");
+        if (irq < 0) {
+                dev_err(&pdev->dev, "no error IRQ specified\n");
+                return -ENODEV;
+        }
+
+        irqname = devm_kasprintf(dmac->dev, GFP_KERNEL, "%s:error",
+                                 dev_name(dmac->dev));
+        if (!irqname)
+                return -ENOMEM;
+
+        ret = devm_request_irq(&pdev->dev, irq, rcar_dmac_isr_error, 0,
+                               irqname, dmac);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to request IRQ %u (%d)\n",
+                        irq, ret);
+                return ret;
+        }
+
+        /* Enable runtime PM and initialize the device. */
+        pm_runtime_enable(&pdev->dev);
+        ret = pm_runtime_get_sync(&pdev->dev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "runtime PM get sync failed (%d)\n", ret);
+                return ret;
+        }
+
+        ret = rcar_dmac_init(dmac);
+        pm_runtime_put(&pdev->dev);
+
+        if (ret) {
+                dev_err(&pdev->dev, "failed to reset device\n");
+                goto error;
+        }
+
+        /* Initialize the channels. */
+        INIT_LIST_HEAD(&dmac->engine.channels);
+
+        for (i = 0; i < dmac->n_channels; ++i) {
+                ret = rcar_dmac_chan_probe(dmac, &dmac->channels[i],
+                                           i + channels_offset);
+                if (ret < 0)
+                        goto error;
+        }
+
+        /* Register the DMAC as a DMA provider for DT. */
+        ret = of_dma_controller_register(pdev->dev.of_node, rcar_dmac_of_xlate,
+                                         NULL);
+        if (ret < 0)
+                goto error;
+
+        /*
+         * Register the DMA engine device.
+         *
+         * Default transfer size of 32 bytes requires 32-byte alignment.
+         */
+        engine = &dmac->engine;
+        dma_cap_set(DMA_MEMCPY, engine->cap_mask);
+        dma_cap_set(DMA_SLAVE, engine->cap_mask);
+
+        engine->dev = &pdev->dev;
+        engine->copy_align = ilog2(RCAR_DMAC_MEMCPY_XFER_SIZE);
+
+        engine->src_addr_widths = widths;
+        engine->dst_addr_widths = widths;
+        engine->directions = BIT(DMA_MEM_TO_DEV) | BIT(DMA_DEV_TO_MEM);
+        engine->residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
+
+        engine->device_alloc_chan_resources = rcar_dmac_alloc_chan_resources;
+        engine->device_free_chan_resources = rcar_dmac_free_chan_resources;
+        engine->device_prep_dma_memcpy = rcar_dmac_prep_dma_memcpy;
+        engine->device_prep_slave_sg = rcar_dmac_prep_slave_sg;
+        engine->device_prep_dma_cyclic = rcar_dmac_prep_dma_cyclic;
+        engine->device_config = rcar_dmac_device_config;
+        engine->device_terminate_all = rcar_dmac_chan_terminate_all;
+        engine->device_tx_status = rcar_dmac_tx_status;
+        engine->device_issue_pending = rcar_dmac_issue_pending;
+
+        ret = dma_async_device_register(engine);
+        if (ret < 0)
+                goto error;
+
+        return 0;
+
+error:
+        of_dma_controller_free(pdev->dev.of_node);
+        pm_runtime_disable(&pdev->dev);
+        return ret;
+}
+
+static int rcar_dmac_remove(struct platform_device *pdev)
+{
+        struct rcar_dmac *dmac = platform_get_drvdata(pdev);
+
+        of_dma_controller_free(pdev->dev.of_node);
+        dma_async_device_unregister(&dmac->engine);
+
+        pm_runtime_disable(&pdev->dev);
+
+        return 0;
+}
+
+static void rcar_dmac_shutdown(struct platform_device *pdev)
+{
+        struct rcar_dmac *dmac = platform_get_drvdata(pdev);
+
+        rcar_dmac_stop(dmac);
+}
+
+static const struct of_device_id rcar_dmac_of_ids[] = {
+        { .compatible = "renesas,rcar-dmac", },
+        { /* Sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, rcar_dmac_of_ids);
+
+static struct platform_driver rcar_dmac_driver = {
+        .driver         = {
+                .pm     = &rcar_dmac_pm,
+                .name   = "rcar-dmac",
+                .of_match_table = rcar_dmac_of_ids,
+        },
+        .probe          = rcar_dmac_probe,
+        .remove         = rcar_dmac_remove,
+        .shutdown       = rcar_dmac_shutdown,
+};
+
+module_platform_driver(rcar_dmac_driver);
+
+MODULE_DESCRIPTION("R-Car Gen2 DMA Controller Driver");
+MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/dma/sh/rcar-hpbdma.c b/drivers/dma/sh/rcar-hpbdma.c
index 20a6f6f2a018..749f26ecd3b3 100644
--- a/drivers/dma/sh/rcar-hpbdma.c
+++ b/drivers/dma/sh/rcar-hpbdma.c
@@ -534,6 +534,8 @@ static int hpb_dmae_chan_probe(struct hpb_dmae_device *hpbdev, int id)
 
 static int hpb_dmae_probe(struct platform_device *pdev)
 {
+        const enum dma_slave_buswidth widths = DMA_SLAVE_BUSWIDTH_1_BYTE |
+                DMA_SLAVE_BUSWIDTH_2_BYTES | DMA_SLAVE_BUSWIDTH_4_BYTES;
         struct hpb_dmae_pdata *pdata = pdev->dev.platform_data;
         struct hpb_dmae_device *hpbdev;
         struct dma_device *dma_dev;
@@ -595,6 +597,10 @@ static int hpb_dmae_probe(struct platform_device *pdev)
 
         dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);
         dma_cap_set(DMA_SLAVE, dma_dev->cap_mask);
+        dma_dev->src_addr_widths = widths;
+        dma_dev->dst_addr_widths = widths;
+        dma_dev->directions = BIT(DMA_MEM_TO_DEV) | BIT(DMA_DEV_TO_MEM);
+        dma_dev->residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;
 
         hpbdev->shdma_dev.ops = &hpb_dmae_ops;
         hpbdev->shdma_dev.desc_size = sizeof(struct hpb_desc);
diff --git a/drivers/dma/sh/shdma-base.c b/drivers/dma/sh/shdma-base.c
index 3a2adb131d46..8ee383d339a5 100644
--- a/drivers/dma/sh/shdma-base.c
+++ b/drivers/dma/sh/shdma-base.c
@@ -729,57 +729,50 @@ static struct dma_async_tx_descriptor *shdma_prep_dma_cyclic(
         return desc;
 }
 
-static int shdma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                          unsigned long arg)
+static int shdma_terminate_all(struct dma_chan *chan)
 {
         struct shdma_chan *schan = to_shdma_chan(chan);
         struct shdma_dev *sdev = to_shdma_dev(chan->device);
         const struct shdma_ops *ops = sdev->ops;
-        struct dma_slave_config *config;
         unsigned long flags;
-        int ret;
 
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                spin_lock_irqsave(&schan->chan_lock, flags);
-                ops->halt_channel(schan);
+        spin_lock_irqsave(&schan->chan_lock, flags);
+        ops->halt_channel(schan);
 
-                if (ops->get_partial && !list_empty(&schan->ld_queue)) {
-                        /* Record partial transfer */
-                        struct shdma_desc *desc = list_first_entry(&schan->ld_queue,
-                                                struct shdma_desc, node);
-                        desc->partial = ops->get_partial(schan, desc);
-                }
+        if (ops->get_partial && !list_empty(&schan->ld_queue)) {
+                /* Record partial transfer */
+                struct shdma_desc *desc = list_first_entry(&schan->ld_queue,
+                                                           struct shdma_desc, node);
+                desc->partial = ops->get_partial(schan, desc);
+        }
 
-                spin_unlock_irqrestore(&schan->chan_lock, flags);
+        spin_unlock_irqrestore(&schan->chan_lock, flags);
 
-                shdma_chan_ld_cleanup(schan, true);
-                break;
-        case DMA_SLAVE_CONFIG:
-                /*
-                 * So far only .slave_id is used, but the slave drivers are
-                 * encouraged to also set a transfer direction and an address.
-                 */
-                if (!arg)
-                        return -EINVAL;
-                /*
-                 * We could lock this, but you shouldn't be configuring the
-                 * channel, while using it...
-                 */
-                config = (struct dma_slave_config *)arg;
-                ret = shdma_setup_slave(schan, config->slave_id,
-                                        config->direction == DMA_DEV_TO_MEM ?
-                                        config->src_addr : config->dst_addr);
-                if (ret < 0)
-                        return ret;
-                break;
-        default:
-                return -ENXIO;
-        }
+        shdma_chan_ld_cleanup(schan, true);
 
         return 0;
 }
 
+static int shdma_config(struct dma_chan *chan,
+                        struct dma_slave_config *config)
+{
+        struct shdma_chan *schan = to_shdma_chan(chan);
+
+        /*
+         * So far only .slave_id is used, but the slave drivers are
+         * encouraged to also set a transfer direction and an address.
+         */
+        if (!config)
+                return -EINVAL;
+        /*
+         * We could lock this, but you shouldn't be configuring the
+         * channel, while using it...
+         */
+        return shdma_setup_slave(schan, config->slave_id,
+                                 config->direction == DMA_DEV_TO_MEM ?
+                                 config->src_addr : config->dst_addr);
+}
+
 static void shdma_issue_pending(struct dma_chan *chan)
 {
         struct shdma_chan *schan = to_shdma_chan(chan);
@@ -1002,7 +995,8 @@ int shdma_init(struct device *dev, struct shdma_dev *sdev,
         /* Compulsory for DMA_SLAVE fields */
         dma_dev->device_prep_slave_sg = shdma_prep_slave_sg;
         dma_dev->device_prep_dma_cyclic = shdma_prep_dma_cyclic;
-        dma_dev->device_control = shdma_control;
+        dma_dev->device_config = shdma_config;
+        dma_dev->device_terminate_all = shdma_terminate_all;
 
         dma_dev->dev = dev;
 
diff --git a/drivers/dma/sh/shdmac.c b/drivers/dma/sh/shdmac.c
index aec8a84784a4..b2431aa30033 100644
--- a/drivers/dma/sh/shdmac.c
+++ b/drivers/dma/sh/shdmac.c
@@ -588,6 +588,7 @@ static void sh_dmae_shutdown(struct platform_device *pdev)
         sh_dmae_ctl_stop(shdev);
 }
 
+#ifdef CONFIG_PM
 static int sh_dmae_runtime_suspend(struct device *dev)
 {
         return 0;
@@ -599,8 +600,9 @@ static int sh_dmae_runtime_resume(struct device *dev)
 
         return sh_dmae_rst(shdev);
 }
+#endif
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int sh_dmae_suspend(struct device *dev)
 {
         return 0;
@@ -632,16 +634,12 @@ static int sh_dmae_resume(struct device *dev)
 
         return 0;
 }
-#else
-#define sh_dmae_suspend NULL
-#define sh_dmae_resume NULL
 #endif
 
 static const struct dev_pm_ops sh_dmae_pm = {
-        .suspend                = sh_dmae_suspend,
-        .resume                 = sh_dmae_resume,
-        .runtime_suspend        = sh_dmae_runtime_suspend,
-        .runtime_resume         = sh_dmae_runtime_resume,
+        SET_SYSTEM_SLEEP_PM_OPS(sh_dmae_suspend, sh_dmae_resume)
+        SET_RUNTIME_PM_OPS(sh_dmae_runtime_suspend, sh_dmae_runtime_resume,
+                           NULL)
 };
 
 static dma_addr_t sh_dmae_slave_addr(struct shdma_chan *schan)
@@ -684,6 +682,10 @@ MODULE_DEVICE_TABLE(of, sh_dmae_of_match);
 
 static int sh_dmae_probe(struct platform_device *pdev)
 {
+        const enum dma_slave_buswidth widths =
+                DMA_SLAVE_BUSWIDTH_1_BYTE   | DMA_SLAVE_BUSWIDTH_2_BYTES |
+                DMA_SLAVE_BUSWIDTH_4_BYTES  | DMA_SLAVE_BUSWIDTH_8_BYTES |
+                DMA_SLAVE_BUSWIDTH_16_BYTES | DMA_SLAVE_BUSWIDTH_32_BYTES;
         const struct sh_dmae_pdata *pdata;
         unsigned long chan_flag[SH_DMAE_MAX_CHANNELS] = {};
         int chan_irq[SH_DMAE_MAX_CHANNELS];
@@ -746,6 +748,11 @@ static int sh_dmae_probe(struct platform_device *pdev)
                         return PTR_ERR(shdev->dmars);
         }
 
+        dma_dev->src_addr_widths = widths;
+        dma_dev->dst_addr_widths = widths;
+        dma_dev->directions = BIT(DMA_MEM_TO_DEV) | BIT(DMA_DEV_TO_MEM);
+        dma_dev->residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;
+
         if (!pdata->slave_only)
                 dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);
         if (pdata->slave && pdata->slave_num)
diff --git a/drivers/dma/sirf-dma.c b/drivers/dma/sirf-dma.c
index 3492a5f91d31..d0086e9f2082 100644
--- a/drivers/dma/sirf-dma.c
+++ b/drivers/dma/sirf-dma.c
@@ -281,9 +281,10 @@ static dma_cookie_t sirfsoc_dma_tx_submit(struct dma_async_tx_descriptor *txd)
         return cookie;
 }
 
-static int sirfsoc_dma_slave_config(struct sirfsoc_dma_chan *schan,
-        struct dma_slave_config *config)
+static int sirfsoc_dma_slave_config(struct dma_chan *chan,
+                                    struct dma_slave_config *config)
 {
+        struct sirfsoc_dma_chan *schan = dma_chan_to_sirfsoc_dma_chan(chan);
         unsigned long flags;
 
         if ((config->src_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES) ||
@@ -297,8 +298,9 @@ static int sirfsoc_dma_slave_config(struct sirfsoc_dma_chan *schan,
         return 0;
 }
 
-static int sirfsoc_dma_terminate_all(struct sirfsoc_dma_chan *schan)
+static int sirfsoc_dma_terminate_all(struct dma_chan *chan)
 {
+        struct sirfsoc_dma_chan *schan = dma_chan_to_sirfsoc_dma_chan(chan);
         struct sirfsoc_dma *sdma = dma_chan_to_sirfsoc_dma(&schan->chan);
         int cid = schan->chan.chan_id;
         unsigned long flags;
@@ -327,8 +329,9 @@ static int sirfsoc_dma_terminate_all(struct sirfsoc_dma_chan *schan)
         return 0;
 }
 
-static int sirfsoc_dma_pause_chan(struct sirfsoc_dma_chan *schan)
+static int sirfsoc_dma_pause_chan(struct dma_chan *chan)
 {
+        struct sirfsoc_dma_chan *schan = dma_chan_to_sirfsoc_dma_chan(chan);
         struct sirfsoc_dma *sdma = dma_chan_to_sirfsoc_dma(&schan->chan);
         int cid = schan->chan.chan_id;
         unsigned long flags;
@@ -348,8 +351,9 @@ static int sirfsoc_dma_pause_chan(struct sirfsoc_dma_chan *schan)
         return 0;
 }
 
-static int sirfsoc_dma_resume_chan(struct sirfsoc_dma_chan *schan)
+static int sirfsoc_dma_resume_chan(struct dma_chan *chan)
 {
+        struct sirfsoc_dma_chan *schan = dma_chan_to_sirfsoc_dma_chan(chan);
         struct sirfsoc_dma *sdma = dma_chan_to_sirfsoc_dma(&schan->chan);
         int cid = schan->chan.chan_id;
         unsigned long flags;
@@ -369,30 +373,6 @@ static int sirfsoc_dma_resume_chan(struct sirfsoc_dma_chan *schan)
         return 0;
 }
 
-static int sirfsoc_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-        unsigned long arg)
-{
-        struct dma_slave_config *config;
-        struct sirfsoc_dma_chan *schan = dma_chan_to_sirfsoc_dma_chan(chan);
-
-        switch (cmd) {
-        case DMA_PAUSE:
-                return sirfsoc_dma_pause_chan(schan);
-        case DMA_RESUME:
-                return sirfsoc_dma_resume_chan(schan);
-        case DMA_TERMINATE_ALL:
-                return sirfsoc_dma_terminate_all(schan);
-        case DMA_SLAVE_CONFIG:
-                config = (struct dma_slave_config *)arg;
-                return sirfsoc_dma_slave_config(schan, config);
-
-        default:
-                break;
-        }
-
-        return -ENOSYS;
-}
-
 /* Alloc channel resources */
 static int sirfsoc_dma_alloc_chan_resources(struct dma_chan *chan)
 {
@@ -648,18 +628,6 @@ EXPORT_SYMBOL(sirfsoc_dma_filter_id);
         BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | \
         BIT(DMA_SLAVE_BUSWIDTH_8_BYTES))
 
-static int sirfsoc_dma_device_slave_caps(struct dma_chan *dchan,
-        struct dma_slave_caps *caps)
-{
-        caps->src_addr_widths = SIRFSOC_DMA_BUSWIDTHS;
-        caps->dstn_addr_widths = SIRFSOC_DMA_BUSWIDTHS;
-        caps->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
-        caps->cmd_pause = true;
-        caps->cmd_terminate = true;
-
-        return 0;
-}
-
 static struct dma_chan *of_dma_sirfsoc_xlate(struct of_phandle_args *dma_spec,
         struct of_dma *ofdma)
 {
@@ -739,11 +707,16 @@ static int sirfsoc_dma_probe(struct platform_device *op)
         dma->device_alloc_chan_resources = sirfsoc_dma_alloc_chan_resources;
         dma->device_free_chan_resources = sirfsoc_dma_free_chan_resources;
         dma->device_issue_pending = sirfsoc_dma_issue_pending;
-        dma->device_control = sirfsoc_dma_control;
+        dma->device_config = sirfsoc_dma_slave_config;
+        dma->device_pause = sirfsoc_dma_pause_chan;
+        dma->device_resume = sirfsoc_dma_resume_chan;
+        dma->device_terminate_all = sirfsoc_dma_terminate_all;
         dma->device_tx_status = sirfsoc_dma_tx_status;
         dma->device_prep_interleaved_dma = sirfsoc_dma_prep_interleaved;
         dma->device_prep_dma_cyclic = sirfsoc_dma_prep_cyclic;
-        dma->device_slave_caps = sirfsoc_dma_device_slave_caps;
+        dma->src_addr_widths = SIRFSOC_DMA_BUSWIDTHS;
+        dma->dst_addr_widths = SIRFSOC_DMA_BUSWIDTHS;
+        dma->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
 
         INIT_LIST_HEAD(&dma->channels);
         dma_cap_set(DMA_SLAVE, dma->cap_mask);
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index 15d49461c0d2..68aca3334a17 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -1429,11 +1429,17 @@ static bool d40_tx_is_linked(struct d40_chan *d40c)
         return is_link;
 }
 
-static int d40_pause(struct d40_chan *d40c)
+static int d40_pause(struct dma_chan *chan)
 {
+        struct d40_chan *d40c = container_of(chan, struct d40_chan, chan);
         int res = 0;
         unsigned long flags;
 
+        if (d40c->phy_chan == NULL) {
+                chan_err(d40c, "Channel is not allocated!\n");
+                return -EINVAL;
+        }
+
         if (!d40c->busy)
                 return 0;
 
@@ -1448,11 +1454,17 @@ static int d40_pause(struct d40_chan *d40c)
         return res;
 }
 
-static int d40_resume(struct d40_chan *d40c)
+static int d40_resume(struct dma_chan *chan)
 {
+        struct d40_chan *d40c = container_of(chan, struct d40_chan, chan);
         int res = 0;
         unsigned long flags;
 
+        if (d40c->phy_chan == NULL) {
+                chan_err(d40c, "Channel is not allocated!\n");
+                return -EINVAL;
+        }
+
         if (!d40c->busy)
                 return 0;
 
@@ -2604,12 +2616,17 @@ static void d40_issue_pending(struct dma_chan *chan)
         spin_unlock_irqrestore(&d40c->lock, flags);
 }
 
-static void d40_terminate_all(struct dma_chan *chan)
+static int d40_terminate_all(struct dma_chan *chan)
 {
         unsigned long flags;
         struct d40_chan *d40c = container_of(chan, struct d40_chan, chan);
         int ret;
 
+        if (d40c->phy_chan == NULL) {
+                chan_err(d40c, "Channel is not allocated!\n");
+                return -EINVAL;
+        }
+
         spin_lock_irqsave(&d40c->lock, flags);
 
         pm_runtime_get_sync(d40c->base->dev);
@@ -2627,6 +2644,7 @@ static void d40_terminate_all(struct dma_chan *chan)
         d40c->busy = false;
 
         spin_unlock_irqrestore(&d40c->lock, flags);
+        return 0;
 }
 
 static int
@@ -2673,6 +2691,11 @@ static int d40_set_runtime_config(struct dma_chan *chan,
         u32 src_maxburst, dst_maxburst;
         int ret;
 
+        if (d40c->phy_chan == NULL) {
+                chan_err(d40c, "Channel is not allocated!\n");
+                return -EINVAL;
+        }
+
         src_addr_width = config->src_addr_width;
         src_maxburst = config->src_maxburst;
         dst_addr_width = config->dst_addr_width;
@@ -2781,35 +2804,6 @@ static int d40_set_runtime_config(struct dma_chan *chan,
         return 0;
 }
 
-static int d40_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                       unsigned long arg)
-{
-        struct d40_chan *d40c = container_of(chan, struct d40_chan, chan);
-
-        if (d40c->phy_chan == NULL) {
-                chan_err(d40c, "Channel is not allocated!\n");
-                return -EINVAL;
-        }
-
-        switch (cmd) {
-        case DMA_TERMINATE_ALL:
-                d40_terminate_all(chan);
-                return 0;
-        case DMA_PAUSE:
-                return d40_pause(d40c);
-        case DMA_RESUME:
-                return d40_resume(d40c);
-        case DMA_SLAVE_CONFIG:
-                return d40_set_runtime_config(chan,
-                        (struct dma_slave_config *) arg);
-        default:
-                break;
-        }
-
-        /* Other commands are unimplemented */
-        return -ENXIO;
-}
-
 /* Initialization functions */
 
 static void __init d40_chan_init(struct d40_base *base, struct dma_device *dma,
@@ -2870,7 +2864,10 @@ static void d40_ops_init(struct d40_base *base, struct dma_device *dev)
         dev->device_free_chan_resources = d40_free_chan_resources;
         dev->device_issue_pending = d40_issue_pending;
         dev->device_tx_status = d40_tx_status;
-        dev->device_control = d40_control;
+        dev->device_config = d40_set_runtime_config;
+        dev->device_pause = d40_pause;
+        dev->device_resume = d40_resume;
+        dev->device_terminate_all = d40_terminate_all;
         dev->dev = base->dev;
 }
 
diff --git a/drivers/dma/sun6i-dma.c b/drivers/dma/sun6i-dma.c
index 159f1736a16f..7ebcf9bec698 100644
--- a/drivers/dma/sun6i-dma.c
+++ b/drivers/dma/sun6i-dma.c
@@ -355,38 +355,6 @@ static void sun6i_dma_free_desc(struct virt_dma_desc *vd)
         kfree(txd);
 }
 
-static int sun6i_dma_terminate_all(struct sun6i_vchan *vchan)
-{
-        struct sun6i_dma_dev *sdev = to_sun6i_dma_dev(vchan->vc.chan.device);
-        struct sun6i_pchan *pchan = vchan->phy;
-        unsigned long flags;
-        LIST_HEAD(head);
-
-        spin_lock(&sdev->lock);
-        list_del_init(&vchan->node);
-        spin_unlock(&sdev->lock);
-
-        spin_lock_irqsave(&vchan->vc.lock, flags);
-
-        vchan_get_all_descriptors(&vchan->vc, &head);
-
-        if (pchan) {
-                writel(DMA_CHAN_ENABLE_STOP, pchan->base + DMA_CHAN_ENABLE);
-                writel(DMA_CHAN_PAUSE_RESUME, pchan->base + DMA_CHAN_PAUSE);
-
-                vchan->phy = NULL;
-                pchan->vchan = NULL;
-                pchan->desc = NULL;
-                pchan->done = NULL;
-        }
-
-        spin_unlock_irqrestore(&vchan->vc.lock, flags);
-
-        vchan_dma_desc_free_list(&vchan->vc, &head);
-
-        return 0;
-}
-
 static int sun6i_dma_start_desc(struct sun6i_vchan *vchan)
 {
         struct sun6i_dma_dev *sdev = to_sun6i_dma_dev(vchan->vc.chan.device);
@@ -675,57 +643,92 @@ err_lli_free:
         return NULL;
 }
 
-static int sun6i_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                       unsigned long arg)
+static int sun6i_dma_config(struct dma_chan *chan,
+                            struct dma_slave_config *config)
+{
+        struct sun6i_vchan *vchan = to_sun6i_vchan(chan);
+
+        memcpy(&vchan->cfg, config, sizeof(*config));
+
+        return 0;
+}
+
+static int sun6i_dma_pause(struct dma_chan *chan)
+{
+        struct sun6i_dma_dev *sdev = to_sun6i_dma_dev(chan->device);
+        struct sun6i_vchan *vchan = to_sun6i_vchan(chan);
+        struct sun6i_pchan *pchan = vchan->phy;
+
+        dev_dbg(chan2dev(chan), "vchan %p: pause\n", &vchan->vc);
+
+        if (pchan) {
+                writel(DMA_CHAN_PAUSE_PAUSE,
+                       pchan->base + DMA_CHAN_PAUSE);
+        } else {
+                spin_lock(&sdev->lock);
+                list_del_init(&vchan->node);
+                spin_unlock(&sdev->lock);
+        }
+
+        return 0;
+}
+
+static int sun6i_dma_resume(struct dma_chan *chan)
 {
         struct sun6i_dma_dev *sdev = to_sun6i_dma_dev(chan->device);
         struct sun6i_vchan *vchan = to_sun6i_vchan(chan);
         struct sun6i_pchan *pchan = vchan->phy;
         unsigned long flags;
-        int ret = 0;
 
-        switch (cmd) {
-        case DMA_RESUME:
-                dev_dbg(chan2dev(chan), "vchan %p: resume\n", &vchan->vc);
+        dev_dbg(chan2dev(chan), "vchan %p: resume\n", &vchan->vc);
 
-                spin_lock_irqsave(&vchan->vc.lock, flags);
+        spin_lock_irqsave(&vchan->vc.lock, flags);
 
-                if (pchan) {
-                        writel(DMA_CHAN_PAUSE_RESUME,
-                               pchan->base + DMA_CHAN_PAUSE);
-                } else if (!list_empty(&vchan->vc.desc_issued)) {
-                        spin_lock(&sdev->lock);
-                        list_add_tail(&vchan->node, &sdev->pending);
-                        spin_unlock(&sdev->lock);
-                }
+        if (pchan) {
+                writel(DMA_CHAN_PAUSE_RESUME,
+                       pchan->base + DMA_CHAN_PAUSE);
+        } else if (!list_empty(&vchan->vc.desc_issued)) {
+                spin_lock(&sdev->lock);
+                list_add_tail(&vchan->node, &sdev->pending);
+                spin_unlock(&sdev->lock);
+        }
 
-                spin_unlock_irqrestore(&vchan->vc.lock, flags);
-                break;
+        spin_unlock_irqrestore(&vchan->vc.lock, flags);
 
-        case DMA_PAUSE:
-                dev_dbg(chan2dev(chan), "vchan %p: pause\n", &vchan->vc);
+        return 0;
+}
 
-                if (pchan) {
-                        writel(DMA_CHAN_PAUSE_PAUSE,
-                               pchan->base + DMA_CHAN_PAUSE);
-                } else {
-                        spin_lock(&sdev->lock);
-                        list_del_init(&vchan->node);
-                        spin_unlock(&sdev->lock);
-                }
-                break;
-
-        case DMA_TERMINATE_ALL:
-                ret = sun6i_dma_terminate_all(vchan);
-                break;
-        case DMA_SLAVE_CONFIG:
-                memcpy(&vchan->cfg, (void *)arg, sizeof(struct dma_slave_config));
-                break;
-        default:
-                ret = -ENXIO;
-                break;
+static int sun6i_dma_terminate_all(struct dma_chan *chan)
+{
+        struct sun6i_dma_dev *sdev = to_sun6i_dma_dev(chan->device);
+        struct sun6i_vchan *vchan = to_sun6i_vchan(chan);
+        struct sun6i_pchan *pchan = vchan->phy;
+        unsigned long flags;
+        LIST_HEAD(head);
+
+        spin_lock(&sdev->lock);
+        list_del_init(&vchan->node);
+        spin_unlock(&sdev->lock);
+
+        spin_lock_irqsave(&vchan->vc.lock, flags);
+
+        vchan_get_all_descriptors(&vchan->vc, &head);
+
+        if (pchan) {
+                writel(DMA_CHAN_ENABLE_STOP, pchan->base + DMA_CHAN_ENABLE);
+                writel(DMA_CHAN_PAUSE_RESUME, pchan->base + DMA_CHAN_PAUSE);
+
+                vchan->phy = NULL;
+                pchan->vchan = NULL;
+                pchan->desc = NULL;
+                pchan->done = NULL;
         }
-        return ret;
+
+        spin_unlock_irqrestore(&vchan->vc.lock, flags);
+
+        vchan_dma_desc_free_list(&vchan->vc, &head);
+
+        return 0;
 }
 
 static enum dma_status sun6i_dma_tx_status(struct dma_chan *chan,
@@ -960,9 +963,20 @@ static int sun6i_dma_probe(struct platform_device *pdev)
         sdc->slave.device_issue_pending         = sun6i_dma_issue_pending;
         sdc->slave.device_prep_slave_sg         = sun6i_dma_prep_slave_sg;
         sdc->slave.device_prep_dma_memcpy       = sun6i_dma_prep_dma_memcpy;
-        sdc->slave.device_control               = sun6i_dma_control;
         sdc->slave.copy_align                   = 4;
-
+        sdc->slave.device_config                = sun6i_dma_config;
+        sdc->slave.device_pause                 = sun6i_dma_pause;
+        sdc->slave.device_resume                = sun6i_dma_resume;
+        sdc->slave.device_terminate_all         = sun6i_dma_terminate_all;
+        sdc->slave.src_addr_widths              = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |
+                                                  BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) |
+                                                  BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
+        sdc->slave.dst_addr_widths              = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |
+                                                  BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) |
+                                                  BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
+        sdc->slave.directions                   = BIT(DMA_DEV_TO_MEM) |
+                                                  BIT(DMA_MEM_TO_DEV);
+        sdc->slave.residue_granularity          = DMA_RESIDUE_GRANULARITY_BURST;
         sdc->slave.dev = &pdev->dev;
 
         sdc->pchans = devm_kcalloc(&pdev->dev, sdc->cfg->nr_max_channels,
diff --git a/drivers/dma/tegra20-apb-dma.c b/drivers/dma/tegra20-apb-dma.c
index d8450c3f35f0..eaf585e8286b 100644
--- a/drivers/dma/tegra20-apb-dma.c
+++ b/drivers/dma/tegra20-apb-dma.c
@@ -723,7 +723,7 @@ end:
         return;
 }
 
-static void tegra_dma_terminate_all(struct dma_chan *dc)
+static int tegra_dma_terminate_all(struct dma_chan *dc)
 {
         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
         struct tegra_dma_sg_req *sgreq;
@@ -736,7 +736,7 @@ static void tegra_dma_terminate_all(struct dma_chan *dc)
         spin_lock_irqsave(&tdc->lock, flags);
         if (list_empty(&tdc->pending_sg_req)) {
                 spin_unlock_irqrestore(&tdc->lock, flags);
-                return;
+                return 0;
         }
 
         if (!tdc->busy)
@@ -777,6 +777,7 @@ skip_dma_stop:
                 dma_desc->cb_count = 0;
         }
         spin_unlock_irqrestore(&tdc->lock, flags);
+        return 0;
 }
 
 static enum dma_status tegra_dma_tx_status(struct dma_chan *dc,
@@ -827,25 +828,6 @@ static enum dma_status tegra_dma_tx_status(struct dma_chan *dc,
         return ret;
 }
 
-static int tegra_dma_device_control(struct dma_chan *dc, enum dma_ctrl_cmd cmd,
-                        unsigned long arg)
-{
-        switch (cmd) {
-        case DMA_SLAVE_CONFIG:
-                return tegra_dma_slave_config(dc,
-                                (struct dma_slave_config *)arg);
-
-        case DMA_TERMINATE_ALL:
-                tegra_dma_terminate_all(dc);
-                return 0;
-
-        default:
-                break;
-        }
-
-        return -ENXIO;
-}
-
 static inline int get_bus_width(struct tegra_dma_channel *tdc,
                 enum dma_slave_buswidth slave_bw)
 {
@@ -1443,7 +1425,23 @@ static int tegra_dma_probe(struct platform_device *pdev)
                                         tegra_dma_free_chan_resources;
         tdma->dma_dev.device_prep_slave_sg = tegra_dma_prep_slave_sg;
         tdma->dma_dev.device_prep_dma_cyclic = tegra_dma_prep_dma_cyclic;
-        tdma->dma_dev.device_control = tegra_dma_device_control;
+        tdma->dma_dev.src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |
+                BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) |
+                BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) |
+                BIT(DMA_SLAVE_BUSWIDTH_8_BYTES);
+        tdma->dma_dev.dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |
+                BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) |
+                BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) |
+                BIT(DMA_SLAVE_BUSWIDTH_8_BYTES);
+        tdma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        /*
+         * XXX The hardware appears to support
+         * DMA_RESIDUE_GRANULARITY_BURST-level reporting, but it's
+         * only used by this driver during tegra_dma_terminate_all()
+         */
+        tdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT;
+        tdma->dma_dev.device_config = tegra_dma_slave_config;
+        tdma->dma_dev.device_terminate_all = tegra_dma_terminate_all;
         tdma->dma_dev.device_tx_status = tegra_dma_tx_status;
         tdma->dma_dev.device_issue_pending = tegra_dma_issue_pending;
 
diff --git a/drivers/dma/timb_dma.c b/drivers/dma/timb_dma.c
index 2407ccf1a64b..c4c3d93fdd1b 100644
--- a/drivers/dma/timb_dma.c
+++ b/drivers/dma/timb_dma.c
@@ -561,8 +561,7 @@ static struct dma_async_tx_descriptor *td_prep_slave_sg(struct dma_chan *chan,
         return &td_desc->txd;
 }
 
-static int td_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                      unsigned long arg)
+static int td_terminate_all(struct dma_chan *chan)
 {
         struct timb_dma_chan *td_chan =
                 container_of(chan, struct timb_dma_chan, chan);
@@ -570,9 +569,6 @@ static int td_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
 
         dev_dbg(chan2dev(chan), "%s: Entry\n", __func__);
 
-        if (cmd != DMA_TERMINATE_ALL)
-                return -ENXIO;
-
         /* first the easy part, put the queue into the free list */
         spin_lock_bh(&td_chan->lock);
         list_for_each_entry_safe(td_desc, _td_desc, &td_chan->queue,
@@ -697,7 +693,7 @@ static int td_probe(struct platform_device *pdev)
         dma_cap_set(DMA_SLAVE, td->dma.cap_mask);
         dma_cap_set(DMA_PRIVATE, td->dma.cap_mask);
         td->dma.device_prep_slave_sg = td_prep_slave_sg;
-        td->dma.device_control = td_control;
+        td->dma.device_terminate_all = td_terminate_all;
 
         td->dma.dev = &pdev->dev;
 
diff --git a/drivers/dma/txx9dmac.c b/drivers/dma/txx9dmac.c
index 0659ec9c4488..8849318b32b7 100644
--- a/drivers/dma/txx9dmac.c
+++ b/drivers/dma/txx9dmac.c
@@ -901,17 +901,12 @@ txx9dmac_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         return &first->txd;
 }
 
-static int txx9dmac_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
-                            unsigned long arg)
+static int txx9dmac_terminate_all(struct dma_chan *chan)
 {
         struct txx9dmac_chan *dc = to_txx9dmac_chan(chan);
         struct txx9dmac_desc *desc, *_desc;
         LIST_HEAD(list);
 
-        /* Only supports DMA_TERMINATE_ALL */
-        if (cmd != DMA_TERMINATE_ALL)
-                return -EINVAL;
-
         dev_vdbg(chan2dev(chan), "terminate_all\n");
         spin_lock_bh(&dc->lock);
 
@@ -1109,7 +1104,7 @@ static int __init txx9dmac_chan_probe(struct platform_device *pdev)
         dc->dma.dev = &pdev->dev;
         dc->dma.device_alloc_chan_resources = txx9dmac_alloc_chan_resources;
         dc->dma.device_free_chan_resources = txx9dmac_free_chan_resources;
-        dc->dma.device_control = txx9dmac_control;
+        dc->dma.device_terminate_all = txx9dmac_terminate_all;
         dc->dma.device_tx_status = txx9dmac_tx_status;
         dc->dma.device_issue_pending = txx9dmac_issue_pending;
         if (pdata && pdata->memcpy_chan == ch) {
diff --git a/drivers/dma/xilinx/xilinx_vdma.c b/drivers/dma/xilinx/xilinx_vdma.c
index 4a3a8f3137b3..bdd2a5dd7220 100644
--- a/drivers/dma/xilinx/xilinx_vdma.c
+++ b/drivers/dma/xilinx/xilinx_vdma.c
@@ -1001,13 +1001,17 @@ error:
  * xilinx_vdma_terminate_all - Halt the channel and free descriptors
  * @chan: Driver specific VDMA Channel pointer
  */
-static void xilinx_vdma_terminate_all(struct xilinx_vdma_chan *chan)
+static int xilinx_vdma_terminate_all(struct dma_chan *dchan)
 {
+        struct xilinx_vdma_chan *chan = to_xilinx_chan(dchan);
+
         /* Halt the DMA engine */
         xilinx_vdma_halt(chan);
 
         /* Remove and free all of the descriptors in the lists */
         xilinx_vdma_free_descriptors(chan);
+
+        return 0;
 }
 
 /**
@@ -1075,27 +1079,6 @@ int xilinx_vdma_channel_set_config(struct dma_chan *dchan,
 }
 EXPORT_SYMBOL(xilinx_vdma_channel_set_config);
 
-/**
- * xilinx_vdma_device_control - Configure DMA channel of the device
- * @dchan: DMA Channel pointer
- * @cmd: DMA control command
- * @arg: Channel configuration
- *
- * Return: '0' on success and failure value on error
- */
-static int xilinx_vdma_device_control(struct dma_chan *dchan,
-                                      enum dma_ctrl_cmd cmd, unsigned long arg)
-{
-        struct xilinx_vdma_chan *chan = to_xilinx_chan(dchan);
-
-        if (cmd != DMA_TERMINATE_ALL)
-                return -ENXIO;
-
-        xilinx_vdma_terminate_all(chan);
-
-        return 0;
-}
-
 /* -----------------------------------------------------------------------------
  * Probe and remove
  */
@@ -1300,7 +1283,7 @@ static int xilinx_vdma_probe(struct platform_device *pdev)
                                 xilinx_vdma_free_chan_resources;
         xdev->common.device_prep_interleaved_dma =
                                 xilinx_vdma_dma_prep_interleaved;
-        xdev->common.device_control = xilinx_vdma_device_control;
+        xdev->common.device_terminate_all = xilinx_vdma_terminate_all;
         xdev->common.device_tx_status = xilinx_vdma_tx_status;
         xdev->common.device_issue_pending = xilinx_vdma_issue_pending;
 
diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c
index 17638d7cf5c2..5907c1718f8c 100644
--- a/drivers/edac/amd64_edac.c
+++ b/drivers/edac/amd64_edac.c
@@ -2174,14 +2174,20 @@ static void __log_bus_error(struct mem_ctl_info *mci, struct err_info *err,
 
 static inline void decode_bus_error(int node_id, struct mce *m)
 {
-        struct mem_ctl_info *mci = mcis[node_id];
-        struct amd64_pvt *pvt = mci->pvt_info;
+        struct mem_ctl_info *mci;
+        struct amd64_pvt *pvt;
         u8 ecc_type = (m->status >> 45) & 0x3;
         u8 xec = XEC(m->status, 0x1f);
         u16 ec = EC(m->status);
         u64 sys_addr;
         struct err_info err;
 
+        mci = edac_mc_find(node_id);
+        if (!mci)
+                return;
+
+        pvt = mci->pvt_info;
+
         /* Bail out early if this was an 'observed' error */
         if (PP(ec) == NBSL_PP_OBS)
                 return;
diff --git a/drivers/edac/sb_edac.c b/drivers/edac/sb_edac.c
index 63aa6730e89e..1acf57ba4c86 100644
--- a/drivers/edac/sb_edac.c
+++ b/drivers/edac/sb_edac.c
@@ -2447,7 +2447,7 @@ static int sbridge_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 rc = sbridge_get_all_devices(&num_mc, pci_dev_descr_ibridge_table);
                 type = IVY_BRIDGE;
                 break;
-        case PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_TA:
+        case PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_HA0:
                 rc = sbridge_get_all_devices(&num_mc, pci_dev_descr_sbridge_table);
                 type = SANDY_BRIDGE;
                 break;
@@ -2460,8 +2460,11 @@ static int sbridge_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 type = BROADWELL;
                 break;
         }
-        if (unlikely(rc < 0))
+        if (unlikely(rc < 0)) {
+                edac_dbg(0, "couldn't get all devices for 0x%x\n", pdev->device);
                 goto fail0;
+        }
+
         mc = 0;
 
         list_for_each_entry(sbridge_dev, &sbridge_edac_list, list) {
@@ -2474,7 +2477,7 @@ static int sbridge_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                         goto fail1;
         }
 
-        sbridge_printk(KERN_INFO, "Driver loaded.\n");
+        sbridge_printk(KERN_INFO, "%s\n", SBRIDGE_REVISION);
 
         mutex_unlock(&sbridge_edac_lock);
         return 0;
diff --git a/drivers/firewire/core-transaction.c b/drivers/firewire/core-transaction.c
index eb6935c8ad94..d6a09b9cd8cc 100644
--- a/drivers/firewire/core-transaction.c
+++ b/drivers/firewire/core-transaction.c
@@ -1246,14 +1246,14 @@ static const u32 model_textual_descriptor[] = {
 
 static struct fw_descriptor vendor_id_descriptor = {
         .length = ARRAY_SIZE(vendor_textual_descriptor),
-        .immediate = 0x03d00d1e,
+        .immediate = 0x03001f11,
         .key = 0x81000000,
         .data = vendor_textual_descriptor,
 };
 
 static struct fw_descriptor model_id_descriptor = {
         .length = ARRAY_SIZE(model_textual_descriptor),
-        .immediate = 0x17000001,
+        .immediate = 0x17023901,
         .key = 0x81000000,
         .data = model_textual_descriptor,
 };
diff --git a/drivers/firewire/ohci.c b/drivers/firewire/ohci.c
index aff9018d0658..f51d376d10ba 100644
--- a/drivers/firewire/ohci.c
+++ b/drivers/firewire/ohci.c
@@ -718,11 +718,6 @@ static inline unsigned int ar_next_buffer_index(unsigned int index)
         return (index + 1) % AR_BUFFERS;
 }
 
-static inline unsigned int ar_prev_buffer_index(unsigned int index)
-{
-        return (index - 1 + AR_BUFFERS) % AR_BUFFERS;
-}
-
 static inline unsigned int ar_first_buffer_index(struct ar_context *ctx)
 {
         return ar_next_buffer_index(ctx->last_buffer_index);
diff --git a/drivers/firewire/sbp2.c b/drivers/firewire/sbp2.c
index 64ac8f8f5098..c22606fe3d44 100644
--- a/drivers/firewire/sbp2.c
+++ b/drivers/firewire/sbp2.c
@@ -1463,17 +1463,6 @@ static int sbp2_scsi_queuecommand(struct Scsi_Host *shost,
         struct sbp2_command_orb *orb;
         int generation, retval = SCSI_MLQUEUE_HOST_BUSY;
 
-        /*
-         * Bidirectional commands are not yet implemented, and unknown
-         * transfer direction not handled.
-         */
-        if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
-                dev_err(lu_dev(lu), "cannot handle bidirectional command\n");
-                cmd->result = DID_ERROR << 16;
-                cmd->scsi_done(cmd);
-                return 0;
-        }
-
         orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
         if (orb == NULL)
                 return SCSI_MLQUEUE_HOST_BUSY;
diff --git a/drivers/firmware/efi/libstub/efi-stub-helper.c b/drivers/firmware/efi/libstub/efi-stub-helper.c
index af5d63c7cc53..2fe195002021 100644
--- a/drivers/firmware/efi/libstub/efi-stub-helper.c
+++ b/drivers/firmware/efi/libstub/efi-stub-helper.c
@@ -75,29 +75,25 @@ efi_status_t efi_get_memory_map(efi_system_table_t *sys_table_arg,
         unsigned long key;
         u32 desc_version;
 
-        *map_size = 0;
-        *desc_size = 0;
-        key = 0;
-        status = efi_call_early(get_memory_map, map_size, NULL,
-                                &key, desc_size, &desc_version);
-        if (status != EFI_BUFFER_TOO_SMALL)
-                return EFI_LOAD_ERROR;
-
+        *map_size = sizeof(*m) * 32;
+again:
         /*
          * Add an additional efi_memory_desc_t because we're doing an
          * allocation which may be in a new descriptor region.
          */
-        *map_size += *desc_size;
+        *map_size += sizeof(*m);
         status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
                                 *map_size, (void **)&m);
         if (status != EFI_SUCCESS)
                 goto fail;
 
+        *desc_size = 0;
+        key = 0;
         status = efi_call_early(get_memory_map, map_size, m,
                                 &key, desc_size, &desc_version);
         if (status == EFI_BUFFER_TOO_SMALL) {
                 efi_call_early(free_pool, m);
-                return EFI_LOAD_ERROR;
+                goto again;
         }
 
         if (status != EFI_SUCCESS)
diff --git a/drivers/gpio/gpio-tps65912.c b/drivers/gpio/gpio-tps65912.c
index 472fb5b8779f..9cdbc0c9cb2d 100644
--- a/drivers/gpio/gpio-tps65912.c
+++ b/drivers/gpio/gpio-tps65912.c
@@ -26,9 +26,12 @@ struct tps65912_gpio_data {
         struct gpio_chip gpio_chip;
 };
 
+#define to_tgd(gc) container_of(gc, struct tps65912_gpio_data, gpio_chip)
+
 static int tps65912_gpio_get(struct gpio_chip *gc, unsigned offset)
 {
-        struct tps65912 *tps65912 = container_of(gc, struct tps65912, gpio);
+        struct tps65912_gpio_data *tps65912_gpio = to_tgd(gc);
+        struct tps65912 *tps65912 = tps65912_gpio->tps65912;
         int val;
 
         val = tps65912_reg_read(tps65912, TPS65912_GPIO1 + offset);
@@ -42,7 +45,8 @@ static int tps65912_gpio_get(struct gpio_chip *gc, unsigned offset)
 static void tps65912_gpio_set(struct gpio_chip *gc, unsigned offset,
                               int value)
 {
-        struct tps65912 *tps65912 = container_of(gc, struct tps65912, gpio);
+        struct tps65912_gpio_data *tps65912_gpio = to_tgd(gc);
+        struct tps65912 *tps65912 = tps65912_gpio->tps65912;
 
         if (value)
                 tps65912_set_bits(tps65912, TPS65912_GPIO1 + offset,
@@ -55,7 +59,8 @@ static void tps65912_gpio_set(struct gpio_chip *gc, unsigned offset,
 static int tps65912_gpio_output(struct gpio_chip *gc, unsigned offset,
                                 int value)
 {
-        struct tps65912 *tps65912 = container_of(gc, struct tps65912, gpio);
+        struct tps65912_gpio_data *tps65912_gpio = to_tgd(gc);
+        struct tps65912 *tps65912 = tps65912_gpio->tps65912;
 
         /* Set the initial value */
         tps65912_gpio_set(gc, offset, value);
@@ -66,7 +71,8 @@ static int tps65912_gpio_output(struct gpio_chip *gc, unsigned offset,
 
 static int tps65912_gpio_input(struct gpio_chip *gc, unsigned offset)
 {
-        struct tps65912 *tps65912 = container_of(gc, struct tps65912, gpio);
+        struct tps65912_gpio_data *tps65912_gpio = to_tgd(gc);
+        struct tps65912 *tps65912 = tps65912_gpio->tps65912;
 
         return tps65912_clear_bits(tps65912, TPS65912_GPIO1 + offset,
                                                                 GPIO_CFG_MASK);
diff --git a/drivers/gpio/gpiolib-of.c b/drivers/gpio/gpiolib-of.c
index 8cad8e400b44..4650bf830d6b 100644
--- a/drivers/gpio/gpiolib-of.c
+++ b/drivers/gpio/gpiolib-of.c
@@ -46,12 +46,13 @@ static int of_gpiochip_find_and_xlate(struct gpio_chip *gc, void *data)
 
         ret = gc->of_xlate(gc, &gg_data->gpiospec, gg_data->flags);
         if (ret < 0) {
-                /* We've found the gpio chip, but the translation failed.
-                 * Return true to stop looking and return the translation
-                 * error via out_gpio
+                /* We've found a gpio chip, but the translation failed.
+                 * Store translation error in out_gpio.
+                 * Return false to keep looking, as more than one gpio chip
+                 * could be registered per of-node.
                  */
                 gg_data->out_gpio = ERR_PTR(ret);
-                return true;
+                return false;
          }
 
         gg_data->out_gpio = gpiochip_get_desc(gc, ret);
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c
index b3589d0e39b9..910ff8ab9c9c 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c
@@ -62,12 +62,18 @@ enum KFD_MQD_TYPE get_mqd_type_from_queue_type(enum kfd_queue_type type)
         return KFD_MQD_TYPE_CP;
 }
 
-static inline unsigned int get_first_pipe(struct device_queue_manager *dqm)
+unsigned int get_first_pipe(struct device_queue_manager *dqm)
 {
-        BUG_ON(!dqm);
+        BUG_ON(!dqm || !dqm->dev);
         return dqm->dev->shared_resources.first_compute_pipe;
 }
 
+unsigned int get_pipes_num(struct device_queue_manager *dqm)
+{
+        BUG_ON(!dqm || !dqm->dev);
+        return dqm->dev->shared_resources.compute_pipe_count;
+}
+
 static inline unsigned int get_pipes_num_cpsch(void)
 {
         return PIPE_PER_ME_CP_SCHEDULING;
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h
index d64f86cda34f..488f51d19427 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h
@@ -163,6 +163,8 @@ void program_sh_mem_settings(struct device_queue_manager *dqm,
                                         struct qcm_process_device *qpd);
 int init_pipelines(struct device_queue_manager *dqm,
                 unsigned int pipes_num, unsigned int first_pipe);
+unsigned int get_first_pipe(struct device_queue_manager *dqm);
+unsigned int get_pipes_num(struct device_queue_manager *dqm);
 
 extern inline unsigned int get_sh_mem_bases_32(struct kfd_process_device *pdd)
 {
@@ -175,10 +177,4 @@ get_sh_mem_bases_nybble_64(struct kfd_process_device *pdd)
         return (pdd->lds_base >> 60) & 0x0E;
 }
 
-extern inline unsigned int get_pipes_num(struct device_queue_manager *dqm)
-{
-        BUG_ON(!dqm || !dqm->dev);
-        return dqm->dev->shared_resources.compute_pipe_count;
-}
-
 #endif /* KFD_DEVICE_QUEUE_MANAGER_H_ */
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_cik.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_cik.c
index 6b072466e2a6..5469efe0523e 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_cik.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_cik.c
@@ -131,5 +131,5 @@ static int register_process_cik(struct device_queue_manager *dqm,
 
 static int initialize_cpsch_cik(struct device_queue_manager *dqm)
 {
-        return init_pipelines(dqm, get_pipes_num(dqm), 0);
+        return init_pipelines(dqm, get_pipes_num(dqm), get_first_pipe(dqm));
 }
diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c
index 0409b907de5d..b3e3068c6ec0 100644
--- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c
+++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c
@@ -153,7 +153,7 @@ static int atmel_hlcdc_crtc_mode_set(struct drm_crtc *c,
                      (adj->crtc_hdisplay - 1) |
                      ((adj->crtc_vdisplay - 1) << 16));
 
-        cfg = ATMEL_HLCDC_CLKPOL;
+        cfg = 0;
 
         prate = clk_get_rate(crtc->dc->hlcdc->sys_clk);
         mode_rate = mode->crtc_clock * 1000;
diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
index 7320a6c6613f..c1cb17493e0d 100644
--- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
+++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
@@ -311,8 +311,6 @@ static int atmel_hlcdc_dc_load(struct drm_device *dev)
 
         pm_runtime_enable(dev->dev);
 
-        pm_runtime_put_sync(dev->dev);
-
         ret = atmel_hlcdc_dc_modeset_init(dev);
         if (ret < 0) {
                 dev_err(dev->dev, "failed to initialize mode setting\n");
diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_layer.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_layer.c
index 063d2a7b941f..e79bd9ba474b 100644
--- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_layer.c
+++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_layer.c
@@ -311,7 +311,8 @@ int atmel_hlcdc_layer_disable(struct atmel_hlcdc_layer *layer)
 
         /* Disable the layer */
         regmap_write(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_CHDR,
-                     ATMEL_HLCDC_LAYER_RST);
+                     ATMEL_HLCDC_LAYER_RST | ATMEL_HLCDC_LAYER_A2Q |
+                     ATMEL_HLCDC_LAYER_UPDATE);
 
         /* Clear all pending interrupts */
         regmap_read(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_ISR, &isr);
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 6b00173d1be4..6b6b07ff720b 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -2127,7 +2127,6 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
         DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
 
         mutex_lock(&dev->mode_config.mutex);
-        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 
         connector = drm_connector_find(dev, out_resp->connector_id);
         if (!connector) {
@@ -2157,6 +2156,8 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
         out_resp->mm_height = connector->display_info.height_mm;
         out_resp->subpixel = connector->display_info.subpixel_order;
         out_resp->connection = connector->status;
+
+        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
         encoder = drm_connector_get_encoder(connector);
         if (encoder)
                 out_resp->encoder_id = encoder->base.id;
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index f2a825e39646..8727086cf48c 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -2114,6 +2114,9 @@ void i915_gem_track_fb(struct drm_i915_gem_object *old,
  * number comparisons on buffer last_read|write_seqno. It also allows an
  * emission time to be associated with the request for tracking how far ahead
  * of the GPU the submission is.
+ *
+ * The requests are reference counted, so upon creation they should have an
+ * initial reference taken using kref_init
  */
 struct drm_i915_gem_request {
         struct kref ref;
@@ -2137,7 +2140,16 @@ struct drm_i915_gem_request {
         /** Position in the ringbuffer of the end of the whole request */
         u32 tail;
 
-        /** Context related to this request */
+        /**
+         * Context related to this request
+         * Contexts are refcounted, so when this request is associated with a
+         * context, we must increment the context's refcount, to guarantee that
+         * it persists while any request is linked to it. Requests themselves
+         * are also refcounted, so the request will only be freed when the last
+         * reference to it is dismissed, and the code in
+         * i915_gem_request_free() will then decrement the refcount on the
+         * context.
+         */
         struct intel_context *ctx;
 
         /** Batch buffer related to this request if any */
@@ -2374,6 +2386,7 @@ struct drm_i915_cmd_table {
                                  (INTEL_DEVID(dev) & 0xFF00) == 0x0C00)
 #define IS_BDW_ULT(dev)         (IS_BROADWELL(dev) && \
                                  ((INTEL_DEVID(dev) & 0xf) == 0x6 ||    \
+                                 (INTEL_DEVID(dev) & 0xf) == 0xb ||     \
                                  (INTEL_DEVID(dev) & 0xf) == 0xe))
 #define IS_BDW_GT3(dev)         (IS_BROADWELL(dev) && \
                                  (INTEL_DEVID(dev) & 0x00F0) == 0x0020)
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index c26d36cc4b31..e5daad5f75fb 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -2659,8 +2659,7 @@ static void i915_gem_reset_ring_cleanup(struct drm_i915_private *dev_priv,
                 if (submit_req->ctx != ring->default_context)
                         intel_lr_context_unpin(ring, submit_req->ctx);
 
-                i915_gem_context_unreference(submit_req->ctx);
-                kfree(submit_req);
+                i915_gem_request_unreference(submit_req);
         }
 
         /*
diff --git a/drivers/gpu/drm/i915/i915_gem_stolen.c b/drivers/gpu/drm/i915/i915_gem_stolen.c
index a2045848bd1a..9c6f93ec886b 100644
--- a/drivers/gpu/drm/i915/i915_gem_stolen.c
+++ b/drivers/gpu/drm/i915/i915_gem_stolen.c
@@ -485,10 +485,8 @@ i915_gem_object_create_stolen_for_preallocated(struct drm_device *dev,
                         stolen_offset, gtt_offset, size);
 
         /* KISS and expect everything to be page-aligned */
-        BUG_ON(stolen_offset & 4095);
-        BUG_ON(size & 4095);
-
-        if (WARN_ON(size == 0))
+        if (WARN_ON(size == 0) || WARN_ON(size & 4095) ||
+            WARN_ON(stolen_offset & 4095))
                 return NULL;
 
         stolen = kzalloc(sizeof(*stolen), GFP_KERNEL);
diff --git a/drivers/gpu/drm/i915/i915_gem_tiling.c b/drivers/gpu/drm/i915/i915_gem_tiling.c
index 7a24bd1a51f6..6377b22269ad 100644
--- a/drivers/gpu/drm/i915/i915_gem_tiling.c
+++ b/drivers/gpu/drm/i915/i915_gem_tiling.c
@@ -335,9 +335,10 @@ i915_gem_set_tiling(struct drm_device *dev, void *data,
                 return -EINVAL;
         }
 
+        mutex_lock(&dev->struct_mutex);
         if (i915_gem_obj_is_pinned(obj) || obj->framebuffer_references) {
-                drm_gem_object_unreference_unlocked(&obj->base);
-                return -EBUSY;
+                ret = -EBUSY;
+                goto err;
         }
 
         if (args->tiling_mode == I915_TILING_NONE) {
@@ -369,7 +370,6 @@ i915_gem_set_tiling(struct drm_device *dev, void *data,
                 }
         }
 
-        mutex_lock(&dev->struct_mutex);
         if (args->tiling_mode != obj->tiling_mode ||
             args->stride != obj->stride) {
                 /* We need to rebind the object if its current allocation
@@ -424,6 +424,7 @@ i915_gem_set_tiling(struct drm_device *dev, void *data,
                 obj->bit_17 = NULL;
         }
 
+err:
         drm_gem_object_unreference(&obj->base);
         mutex_unlock(&dev->struct_mutex);
 
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 4145d95902f5..ede5bbbd8a08 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -1892,6 +1892,9 @@ static irqreturn_t valleyview_irq_handler(int irq, void *arg)
         u32 iir, gt_iir, pm_iir;
         irqreturn_t ret = IRQ_NONE;
 
+        if (!intel_irqs_enabled(dev_priv))
+                return IRQ_NONE;
+
         while (true) {
                 /* Find, clear, then process each source of interrupt */
 
@@ -1936,6 +1939,9 @@ static irqreturn_t cherryview_irq_handler(int irq, void *arg)
         u32 master_ctl, iir;
         irqreturn_t ret = IRQ_NONE;
 
+        if (!intel_irqs_enabled(dev_priv))
+                return IRQ_NONE;
+
         for (;;) {
                 master_ctl = I915_READ(GEN8_MASTER_IRQ) & ~GEN8_MASTER_IRQ_CONTROL;
                 iir = I915_READ(VLV_IIR);
@@ -2208,6 +2214,9 @@ static irqreturn_t ironlake_irq_handler(int irq, void *arg)
         u32 de_iir, gt_iir, de_ier, sde_ier = 0;
         irqreturn_t ret = IRQ_NONE;
 
+        if (!intel_irqs_enabled(dev_priv))
+                return IRQ_NONE;
+
         /* We get interrupts on unclaimed registers, so check for this before we
          * do any I915_{READ,WRITE}. */
         intel_uncore_check_errors(dev);
@@ -2279,6 +2288,9 @@ static irqreturn_t gen8_irq_handler(int irq, void *arg)
         enum pipe pipe;
         u32 aux_mask = GEN8_AUX_CHANNEL_A;
 
+        if (!intel_irqs_enabled(dev_priv))
+                return IRQ_NONE;
+
         if (IS_GEN9(dev))
                 aux_mask |=  GEN9_AUX_CHANNEL_B | GEN9_AUX_CHANNEL_C |
                         GEN9_AUX_CHANNEL_D;
@@ -3771,6 +3783,9 @@ static irqreturn_t i8xx_irq_handler(int irq, void *arg)
                 I915_DISPLAY_PLANE_A_FLIP_PENDING_INTERRUPT |
                 I915_DISPLAY_PLANE_B_FLIP_PENDING_INTERRUPT;
 
+        if (!intel_irqs_enabled(dev_priv))
+                return IRQ_NONE;
+
         iir = I915_READ16(IIR);
         if (iir == 0)
                 return IRQ_NONE;
@@ -3951,6 +3966,9 @@ static irqreturn_t i915_irq_handler(int irq, void *arg)
                 I915_DISPLAY_PLANE_B_FLIP_PENDING_INTERRUPT;
         int pipe, ret = IRQ_NONE;
 
+        if (!intel_irqs_enabled(dev_priv))
+                return IRQ_NONE;
+
         iir = I915_READ(IIR);
         do {
                 bool irq_received = (iir & ~flip_mask) != 0;
@@ -4171,6 +4189,9 @@ static irqreturn_t i965_irq_handler(int irq, void *arg)
                 I915_DISPLAY_PLANE_A_FLIP_PENDING_INTERRUPT |
                 I915_DISPLAY_PLANE_B_FLIP_PENDING_INTERRUPT;
 
+        if (!intel_irqs_enabled(dev_priv))
+                return IRQ_NONE;
+
         iir = I915_READ(IIR);
 
         for (;;) {
@@ -4520,6 +4541,7 @@ void intel_runtime_pm_disable_interrupts(struct drm_i915_private *dev_priv)
 {
         dev_priv->dev->driver->irq_uninstall(dev_priv->dev);
         dev_priv->pm.irqs_enabled = false;
+        synchronize_irq(dev_priv->dev->irq);
 }
 
 /**
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 3d220a67f865..e730789b53b7 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -2371,13 +2371,19 @@ intel_alloc_plane_obj(struct intel_crtc *crtc,
         struct drm_device *dev = crtc->base.dev;
         struct drm_i915_gem_object *obj = NULL;
         struct drm_mode_fb_cmd2 mode_cmd = { 0 };
-        u32 base = plane_config->base;
+        u32 base_aligned = round_down(plane_config->base, PAGE_SIZE);
+        u32 size_aligned = round_up(plane_config->base + plane_config->size,
+                                    PAGE_SIZE);
+
+        size_aligned -= base_aligned;
 
         if (plane_config->size == 0)
                 return false;
 
-        obj = i915_gem_object_create_stolen_for_preallocated(dev, base, base,
-                                                             plane_config->size);
+        obj = i915_gem_object_create_stolen_for_preallocated(dev,
+                                                             base_aligned,
+                                                             base_aligned,
+                                                             size_aligned);
         if (!obj)
                 return false;
 
@@ -2725,10 +2731,19 @@ static void skylake_update_primary_plane(struct drm_crtc *crtc,
         case DRM_FORMAT_XRGB8888:
                 plane_ctl |= PLANE_CTL_FORMAT_XRGB_8888;
                 break;
+        case DRM_FORMAT_ARGB8888:
+                plane_ctl |= PLANE_CTL_FORMAT_XRGB_8888;
+                plane_ctl |= PLANE_CTL_ALPHA_SW_PREMULTIPLY;
+                break;
         case DRM_FORMAT_XBGR8888:
                 plane_ctl |= PLANE_CTL_ORDER_RGBX;
                 plane_ctl |= PLANE_CTL_FORMAT_XRGB_8888;
                 break;
+        case DRM_FORMAT_ABGR8888:
+                plane_ctl |= PLANE_CTL_ORDER_RGBX;
+                plane_ctl |= PLANE_CTL_FORMAT_XRGB_8888;
+                plane_ctl |= PLANE_CTL_ALPHA_SW_PREMULTIPLY;
+                break;
         case DRM_FORMAT_XRGB2101010:
                 plane_ctl |= PLANE_CTL_FORMAT_XRGB_2101010;
                 break;
@@ -6627,7 +6642,7 @@ i9xx_get_initial_plane_config(struct intel_crtc *crtc,
         aligned_height = intel_fb_align_height(dev, fb->height,
                                                plane_config->tiling);
 
-        plane_config->size = PAGE_ALIGN(fb->pitches[0] * aligned_height);
+        plane_config->size = fb->pitches[0] * aligned_height;
 
         DRM_DEBUG_KMS("pipe/plane %c/%d with fb: size=%dx%d@%d, offset=%x, pitch %d, size 0x%x\n",
                       pipe_name(pipe), plane, fb->width, fb->height,
@@ -7664,7 +7679,7 @@ skylake_get_initial_plane_config(struct intel_crtc *crtc,
         aligned_height = intel_fb_align_height(dev, fb->height,
                                                plane_config->tiling);
 
-        plane_config->size = ALIGN(fb->pitches[0] * aligned_height, PAGE_SIZE);
+        plane_config->size = fb->pitches[0] * aligned_height;
 
         DRM_DEBUG_KMS("pipe %c with fb: size=%dx%d@%d, offset=%x, pitch %d, size 0x%x\n",
                       pipe_name(pipe), fb->width, fb->height,
@@ -7755,7 +7770,7 @@ ironlake_get_initial_plane_config(struct intel_crtc *crtc,
         aligned_height = intel_fb_align_height(dev, fb->height,
                                                plane_config->tiling);
 
-        plane_config->size = PAGE_ALIGN(fb->pitches[0] * aligned_height);
+        plane_config->size = fb->pitches[0] * aligned_height;
 
         DRM_DEBUG_KMS("pipe %c with fb: size=%dx%d@%d, offset=%x, pitch %d, size 0x%x\n",
                       pipe_name(pipe), fb->width, fb->height,
@@ -8698,6 +8713,7 @@ retry:
                         old->release_fb->funcs->destroy(old->release_fb);
                 goto fail;
         }
+        crtc->primary->crtc = crtc;
 
         /* let the connector get through one full cycle before testing */
         intel_wait_for_vblank(dev, intel_crtc->pipe);
@@ -12182,9 +12198,6 @@ intel_check_cursor_plane(struct drm_plane *plane,
                 return -ENOMEM;
         }
 
-        if (fb == crtc->cursor->fb)
-                return 0;
-
         /* we only need to pin inside GTT if cursor is non-phy */
         mutex_lock(&dev->struct_mutex);
         if (!INTEL_INFO(dev)->cursor_needs_physical && obj->tiling_mode) {
@@ -13096,6 +13109,9 @@ static struct intel_quirk intel_quirks[] = {
 
         /* HP Chromebook 14 (Celeron 2955U) */
         { 0x0a06, 0x103c, 0x21ed, quirk_backlight_present },
+
+        /* Dell Chromebook 11 */
+        { 0x0a06, 0x1028, 0x0a35, quirk_backlight_present },
 };
 
 static void intel_init_quirks(struct drm_device *dev)
diff --git a/drivers/gpu/drm/i915/intel_lrc.c b/drivers/gpu/drm/i915/intel_lrc.c
index 0f358c5999ec..e8d3da9f3373 100644
--- a/drivers/gpu/drm/i915/intel_lrc.c
+++ b/drivers/gpu/drm/i915/intel_lrc.c
@@ -503,18 +503,19 @@ static int execlists_context_queue(struct intel_engine_cs *ring,
                  * If there isn't a request associated with this submission,
                  * create one as a temporary holder.
                  */
-                WARN(1, "execlist context submission without request");
                 request = kzalloc(sizeof(*request), GFP_KERNEL);
                 if (request == NULL)
                         return -ENOMEM;
                 request->ring = ring;
                 request->ctx = to;
+                kref_init(&request->ref);
+                request->uniq = dev_priv->request_uniq++;
+                i915_gem_context_reference(request->ctx);
         } else {
+                i915_gem_request_reference(request);
                 WARN_ON(to != request->ctx);
         }
         request->tail = tail;
-        i915_gem_request_reference(request);
-        i915_gem_context_reference(request->ctx);
 
         intel_runtime_pm_get(dev_priv);
 
@@ -731,7 +732,6 @@ void intel_execlists_retire_requests(struct intel_engine_cs *ring)
                 if (ctx_obj && (ctx != ring->default_context))
                         intel_lr_context_unpin(ring, ctx);
                 intel_runtime_pm_put(dev_priv);
-                i915_gem_context_unreference(ctx);
                 list_del(&req->execlist_link);
                 i915_gem_request_unreference(req);
         }
diff --git a/drivers/gpu/drm/radeon/atombios_dp.c b/drivers/gpu/drm/radeon/atombios_dp.c
index 5bf825dfaa09..8d74de82456e 100644
--- a/drivers/gpu/drm/radeon/atombios_dp.c
+++ b/drivers/gpu/drm/radeon/atombios_dp.c
@@ -178,6 +178,13 @@ radeon_dp_aux_transfer(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
         switch (msg->request & ~DP_AUX_I2C_MOT) {
         case DP_AUX_NATIVE_WRITE:
         case DP_AUX_I2C_WRITE:
+                /* The atom implementation only supports writes with a max payload of
+                 * 12 bytes since it uses 4 bits for the total count (header + payload)
+                 * in the parameter space.  The atom interface supports 16 byte
+                 * payloads for reads. The hw itself supports up to 16 bytes of payload.
+                 */
+                if (WARN_ON_ONCE(msg->size > 12))
+                        return -E2BIG;
                 /* tx_size needs to be 4 even for bare address packets since the atom
                  * table needs the info in tx_buf[3].
                  */
diff --git a/drivers/gpu/drm/radeon/atombios_encoders.c b/drivers/gpu/drm/radeon/atombios_encoders.c
index 7c9df1eac065..7fe7b749e182 100644
--- a/drivers/gpu/drm/radeon/atombios_encoders.c
+++ b/drivers/gpu/drm/radeon/atombios_encoders.c
@@ -731,7 +731,9 @@ atombios_get_encoder_mode(struct drm_encoder *encoder)
                 dig_connector = radeon_connector->con_priv;
                 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
                     (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
-                        if (radeon_audio != 0 && ASIC_IS_DCE4(rdev) && !ASIC_IS_DCE5(rdev))
+                        if (radeon_audio != 0 &&
+                            drm_detect_monitor_audio(radeon_connector_edid(connector)) &&
+                            ASIC_IS_DCE4(rdev) && !ASIC_IS_DCE5(rdev))
                                 return ATOM_ENCODER_MODE_DP_AUDIO;
                         return ATOM_ENCODER_MODE_DP;
                 } else if (radeon_audio != 0) {
@@ -747,7 +749,9 @@ atombios_get_encoder_mode(struct drm_encoder *encoder)
                 }
                 break;
         case DRM_MODE_CONNECTOR_eDP:
-                if (radeon_audio != 0 && ASIC_IS_DCE4(rdev) && !ASIC_IS_DCE5(rdev))
+                if (radeon_audio != 0 &&
+                    drm_detect_monitor_audio(radeon_connector_edid(connector)) &&
+                    ASIC_IS_DCE4(rdev) && !ASIC_IS_DCE5(rdev))
                         return ATOM_ENCODER_MODE_DP_AUDIO;
                 return ATOM_ENCODER_MODE_DP;
         case DRM_MODE_CONNECTOR_DVIA:
@@ -1720,8 +1724,10 @@ radeon_atom_encoder_dpms_dig(struct drm_encoder *encoder, int mode)
         }
 
         encoder_mode = atombios_get_encoder_mode(encoder);
-        if (radeon_audio != 0 &&
-                (encoder_mode == ATOM_ENCODER_MODE_HDMI || ENCODER_MODE_IS_DP(encoder_mode)))
+        if (connector && (radeon_audio != 0) &&
+            ((encoder_mode == ATOM_ENCODER_MODE_HDMI) ||
+             (ENCODER_MODE_IS_DP(encoder_mode) &&
+              drm_detect_monitor_audio(radeon_connector_edid(connector)))))
                 radeon_audio_dpms(encoder, mode);
 }
 
@@ -2136,6 +2142,7 @@ radeon_atom_encoder_mode_set(struct drm_encoder *encoder,
         struct drm_device *dev = encoder->dev;
         struct radeon_device *rdev = dev->dev_private;
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
         int encoder_mode;
 
         radeon_encoder->pixel_clock = adjusted_mode->clock;
@@ -2164,8 +2171,10 @@ radeon_atom_encoder_mode_set(struct drm_encoder *encoder,
         case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
                 /* handled in dpms */
                 encoder_mode = atombios_get_encoder_mode(encoder);
-                if (radeon_audio != 0 &&
-                        (encoder_mode == ATOM_ENCODER_MODE_HDMI || ENCODER_MODE_IS_DP(encoder_mode)))
+                if (connector && (radeon_audio != 0) &&
+                    ((encoder_mode == ATOM_ENCODER_MODE_HDMI) ||
+                     (ENCODER_MODE_IS_DP(encoder_mode) &&
+                      drm_detect_monitor_audio(radeon_connector_edid(connector)))))
                         radeon_audio_mode_set(encoder, adjusted_mode);
                 break;
         case ENCODER_OBJECT_ID_INTERNAL_DDI:
diff --git a/drivers/gpu/drm/radeon/cik.c b/drivers/gpu/drm/radeon/cik.c
index e6a4ba236c70..0c993da9c8fb 100644
--- a/drivers/gpu/drm/radeon/cik.c
+++ b/drivers/gpu/drm/radeon/cik.c
@@ -3613,6 +3613,8 @@ static void cik_gpu_init(struct radeon_device *rdev)
         }
 
         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
+        WREG32(SRBM_INT_CNTL, 0x1);
+        WREG32(SRBM_INT_ACK, 0x1);
 
         WREG32(BIF_FB_EN, FB_READ_EN | FB_WRITE_EN);
 
@@ -7230,6 +7232,8 @@ static void cik_disable_interrupt_state(struct radeon_device *rdev)
         WREG32(CP_ME2_PIPE3_INT_CNTL, 0);
         /* grbm */
         WREG32(GRBM_INT_CNTL, 0);
+        /* SRBM */
+        WREG32(SRBM_INT_CNTL, 0);
         /* vline/vblank, etc. */
         WREG32(LB_INTERRUPT_MASK + EVERGREEN_CRTC0_REGISTER_OFFSET, 0);
         WREG32(LB_INTERRUPT_MASK + EVERGREEN_CRTC1_REGISTER_OFFSET, 0);
@@ -8046,6 +8050,10 @@ restart_ih:
                                 break;
                         }
                         break;
+                case 96:
+                        DRM_ERROR("SRBM_READ_ERROR: 0x%x\n", RREG32(SRBM_READ_ERROR));
+                        WREG32(SRBM_INT_ACK, 0x1);
+                        break;
                 case 124: /* UVD */
                         DRM_DEBUG("IH: UVD int: 0x%08x\n", src_data);
                         radeon_fence_process(rdev, R600_RING_TYPE_UVD_INDEX);
diff --git a/drivers/gpu/drm/radeon/cikd.h b/drivers/gpu/drm/radeon/cikd.h
index 03003f8a6de6..c648e1996dab 100644
--- a/drivers/gpu/drm/radeon/cikd.h
+++ b/drivers/gpu/drm/radeon/cikd.h
@@ -482,6 +482,10 @@
 #define         SOFT_RESET_ORB                          (1 << 23)
 #define         SOFT_RESET_VCE                          (1 << 24)
 
+#define SRBM_READ_ERROR                                 0xE98
+#define SRBM_INT_CNTL                                   0xEA0
+#define SRBM_INT_ACK                                    0xEA8
+
 #define VM_L2_CNTL                                      0x1400
 #define         ENABLE_L2_CACHE                                 (1 << 0)
 #define         ENABLE_L2_FRAGMENT_PROCESSING                   (1 << 1)
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 78600f534c80..4c0e24b3bb90 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -3253,6 +3253,8 @@ static void evergreen_gpu_init(struct radeon_device *rdev)
         }
 
         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
+        WREG32(SRBM_INT_CNTL, 0x1);
+        WREG32(SRBM_INT_ACK, 0x1);
 
         evergreen_fix_pci_max_read_req_size(rdev);
 
@@ -4324,6 +4326,7 @@ void evergreen_disable_interrupt_state(struct radeon_device *rdev)
         tmp = RREG32(DMA_CNTL) & ~TRAP_ENABLE;
         WREG32(DMA_CNTL, tmp);
         WREG32(GRBM_INT_CNTL, 0);
+        WREG32(SRBM_INT_CNTL, 0);
         WREG32(INT_MASK + EVERGREEN_CRTC0_REGISTER_OFFSET, 0);
         WREG32(INT_MASK + EVERGREEN_CRTC1_REGISTER_OFFSET, 0);
         if (rdev->num_crtc >= 4) {
@@ -5066,6 +5069,10 @@ restart_ih:
                                 DRM_ERROR("Unhandled interrupt: %d %d\n", src_id, src_data);
                                 break;
                         }
+                case 96:
+                        DRM_ERROR("SRBM_READ_ERROR: 0x%x\n", RREG32(SRBM_READ_ERROR));
+                        WREG32(SRBM_INT_ACK, 0x1);
+                        break;
                 case 124: /* UVD */
                         DRM_DEBUG("IH: UVD int: 0x%08x\n", src_data);
                         radeon_fence_process(rdev, R600_RING_TYPE_UVD_INDEX);
diff --git a/drivers/gpu/drm/radeon/evergreend.h b/drivers/gpu/drm/radeon/evergreend.h
index ee83d2a88750..a8d1d5240fcb 100644
--- a/drivers/gpu/drm/radeon/evergreend.h
+++ b/drivers/gpu/drm/radeon/evergreend.h
@@ -1191,6 +1191,10 @@
 #define         SOFT_RESET_REGBB                        (1 << 22)
 #define         SOFT_RESET_ORB                          (1 << 23)
 
+#define SRBM_READ_ERROR                                 0xE98
+#define SRBM_INT_CNTL                                   0xEA0
+#define SRBM_INT_ACK                                    0xEA8
+
 /* display watermarks */
 #define DC_LB_MEMORY_SPLIT                                0x6b0c
 #define PRIORITY_A_CNT                                    0x6b18
diff --git a/drivers/gpu/drm/radeon/ni.c b/drivers/gpu/drm/radeon/ni.c
index 24242a7f0ac3..dab00812abaa 100644
--- a/drivers/gpu/drm/radeon/ni.c
+++ b/drivers/gpu/drm/radeon/ni.c
@@ -962,6 +962,8 @@ static void cayman_gpu_init(struct radeon_device *rdev)
         }
 
         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
+        WREG32(SRBM_INT_CNTL, 0x1);
+        WREG32(SRBM_INT_ACK, 0x1);
 
         evergreen_fix_pci_max_read_req_size(rdev);
 
@@ -1086,12 +1088,12 @@ static void cayman_gpu_init(struct radeon_device *rdev)
 
         if ((rdev->config.cayman.max_backends_per_se == 1) &&
             (rdev->flags & RADEON_IS_IGP)) {
-                if ((disabled_rb_mask & 3) == 1) {
-                        /* RB0 disabled, RB1 enabled */
-                        tmp = 0x11111111;
-                } else {
+                if ((disabled_rb_mask & 3) == 2) {
                         /* RB1 disabled, RB0 enabled */
                         tmp = 0x00000000;
+                } else {
+                        /* RB0 disabled, RB1 enabled */
+                        tmp = 0x11111111;
                 }
         } else {
                 tmp = gb_addr_config & NUM_PIPES_MASK;
diff --git a/drivers/gpu/drm/radeon/nid.h b/drivers/gpu/drm/radeon/nid.h
index ad7125486894..6b44580440d0 100644
--- a/drivers/gpu/drm/radeon/nid.h
+++ b/drivers/gpu/drm/radeon/nid.h
@@ -82,6 +82,10 @@
 #define         SOFT_RESET_REGBB                        (1 << 22)
 #define         SOFT_RESET_ORB                          (1 << 23)
 
+#define SRBM_READ_ERROR                                 0xE98
+#define SRBM_INT_CNTL                                   0xEA0
+#define SRBM_INT_ACK                                    0xEA8
+
 #define SRBM_STATUS2                                    0x0EC4
 #define         DMA_BUSY                                (1 << 5)
 #define         DMA1_BUSY                               (1 << 6)
diff --git a/drivers/gpu/drm/radeon/r600_dpm.c b/drivers/gpu/drm/radeon/r600_dpm.c
index 843b65f46ece..fa2154493cf1 100644
--- a/drivers/gpu/drm/radeon/r600_dpm.c
+++ b/drivers/gpu/drm/radeon/r600_dpm.c
@@ -188,7 +188,7 @@ u32 r600_dpm_get_vrefresh(struct radeon_device *rdev)
                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
                         radeon_crtc = to_radeon_crtc(crtc);
                         if (crtc->enabled && radeon_crtc->enabled && radeon_crtc->hw_mode.clock) {
-                                vrefresh = radeon_crtc->hw_mode.vrefresh;
+                                vrefresh = drm_mode_vrefresh(&radeon_crtc->hw_mode);
                                 break;
                         }
                 }
diff --git a/drivers/gpu/drm/radeon/radeon_cs.c b/drivers/gpu/drm/radeon/radeon_cs.c
index c830863bc98a..a579ed379f20 100644
--- a/drivers/gpu/drm/radeon/radeon_cs.c
+++ b/drivers/gpu/drm/radeon/radeon_cs.c
@@ -715,6 +715,7 @@ int radeon_cs_packet_parse(struct radeon_cs_parser *p,
         struct radeon_cs_chunk *ib_chunk = p->chunk_ib;
         struct radeon_device *rdev = p->rdev;
         uint32_t header;
+        int ret = 0, i;
 
         if (idx >= ib_chunk->length_dw) {
                 DRM_ERROR("Can not parse packet at %d after CS end %d !\n",
@@ -743,14 +744,25 @@ int radeon_cs_packet_parse(struct radeon_cs_parser *p,
                 break;
         default:
                 DRM_ERROR("Unknown packet type %d at %d !\n", pkt->type, idx);
-                return -EINVAL;
+                ret = -EINVAL;
+                goto dump_ib;
         }
         if ((pkt->count + 1 + pkt->idx) >= ib_chunk->length_dw) {
                 DRM_ERROR("Packet (%d:%d:%d) end after CS buffer (%d) !\n",
                           pkt->idx, pkt->type, pkt->count, ib_chunk->length_dw);
-                return -EINVAL;
+                ret = -EINVAL;
+                goto dump_ib;
         }
         return 0;
+
+dump_ib:
+        for (i = 0; i < ib_chunk->length_dw; i++) {
+                if (i == idx)
+                        printk("\t0x%08x <---\n", radeon_get_ib_value(p, i));
+                else
+                        printk("\t0x%08x\n", radeon_get_ib_value(p, i));
+        }
+        return ret;
 }
 
 /**
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c
index 6b670b0bc47b..3a297037cc17 100644
--- a/drivers/gpu/drm/radeon/radeon_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_encoders.c
@@ -179,9 +179,12 @@ static void radeon_encoder_add_backlight(struct radeon_encoder *radeon_encoder,
                     (rdev->pdev->subsystem_vendor == 0x1734) &&
                     (rdev->pdev->subsystem_device == 0x1107))
                         use_bl = false;
+/* Older PPC macs use on-GPU backlight controller */
+#ifndef CONFIG_PPC_PMAC
                 /* disable native backlight control on older asics */
                 else if (rdev->family < CHIP_R600)
                         use_bl = false;
+#endif
                 else
                         use_bl = true;
         }
diff --git a/drivers/gpu/drm/radeon/radeon_pm.c b/drivers/gpu/drm/radeon/radeon_pm.c
index 9f758d39420d..33cf4108386d 100644
--- a/drivers/gpu/drm/radeon/radeon_pm.c
+++ b/drivers/gpu/drm/radeon/radeon_pm.c
@@ -852,6 +852,12 @@ static struct radeon_ps *radeon_dpm_pick_power_state(struct radeon_device *rdev,
                         single_display = false;
         }
 
+        /* 120hz tends to be problematic even if they are under the
+         * vblank limit.
+         */
+        if (single_display && (r600_dpm_get_vrefresh(rdev) >= 120))
+                single_display = false;
+
         /* certain older asics have a separare 3D performance state,
          * so try that first if the user selected performance
          */
diff --git a/drivers/gpu/drm/radeon/si.c b/drivers/gpu/drm/radeon/si.c
index 73107fe9e46f..bcf516a8a2f1 100644
--- a/drivers/gpu/drm/radeon/si.c
+++ b/drivers/gpu/drm/radeon/si.c
@@ -3162,6 +3162,8 @@ static void si_gpu_init(struct radeon_device *rdev)
         }
 
         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
+        WREG32(SRBM_INT_CNTL, 1);
+        WREG32(SRBM_INT_ACK, 1);
 
         evergreen_fix_pci_max_read_req_size(rdev);
 
@@ -4699,12 +4701,6 @@ int si_ib_parse(struct radeon_device *rdev, struct radeon_ib *ib)
                 switch (pkt.type) {
                 case RADEON_PACKET_TYPE0:
                         dev_err(rdev->dev, "Packet0 not allowed!\n");
-                        for (i = 0; i < ib->length_dw; i++) {
-                                if (i == idx)
-                                        printk("\t0x%08x <---\n", ib->ptr[i]);
-                                else
-                                        printk("\t0x%08x\n", ib->ptr[i]);
-                        }
                         ret = -EINVAL;
                         break;
                 case RADEON_PACKET_TYPE2:
@@ -4736,8 +4732,15 @@ int si_ib_parse(struct radeon_device *rdev, struct radeon_ib *ib)
                         ret = -EINVAL;
                         break;
                 }
-                if (ret)
+                if (ret) {
+                        for (i = 0; i < ib->length_dw; i++) {
+                                if (i == idx)
+                                        printk("\t0x%08x <---\n", ib->ptr[i]);
+                                else
+                                        printk("\t0x%08x\n", ib->ptr[i]);
+                        }
                         break;
+                }
         } while (idx < ib->length_dw);
 
         return ret;
@@ -5910,6 +5913,7 @@ static void si_disable_interrupt_state(struct radeon_device *rdev)
         tmp = RREG32(DMA_CNTL + DMA1_REGISTER_OFFSET) & ~TRAP_ENABLE;
         WREG32(DMA_CNTL + DMA1_REGISTER_OFFSET, tmp);
         WREG32(GRBM_INT_CNTL, 0);
+        WREG32(SRBM_INT_CNTL, 0);
         if (rdev->num_crtc >= 2) {
                 WREG32(INT_MASK + EVERGREEN_CRTC0_REGISTER_OFFSET, 0);
                 WREG32(INT_MASK + EVERGREEN_CRTC1_REGISTER_OFFSET, 0);
@@ -6609,6 +6613,10 @@ restart_ih:
                                 break;
                         }
                         break;
+                case 96:
+                        DRM_ERROR("SRBM_READ_ERROR: 0x%x\n", RREG32(SRBM_READ_ERROR));
+                        WREG32(SRBM_INT_ACK, 0x1);
+                        break;
                 case 124: /* UVD */
                         DRM_DEBUG("IH: UVD int: 0x%08x\n", src_data);
                         radeon_fence_process(rdev, R600_RING_TYPE_UVD_INDEX);
diff --git a/drivers/gpu/drm/radeon/sid.h b/drivers/gpu/drm/radeon/sid.h
index cbd91d226f3c..c27118cab16a 100644
--- a/drivers/gpu/drm/radeon/sid.h
+++ b/drivers/gpu/drm/radeon/sid.h
@@ -358,6 +358,10 @@
 #define CC_SYS_RB_BACKEND_DISABLE                       0xe80
 #define GC_USER_SYS_RB_BACKEND_DISABLE                  0xe84
 
+#define SRBM_READ_ERROR                                 0xE98
+#define SRBM_INT_CNTL                                   0xEA0
+#define SRBM_INT_ACK                                    0xEA8
+
 #define SRBM_STATUS2                                    0x0EC4
 #define         DMA_BUSY                                (1 << 5)
 #define         DMA1_BUSY                               (1 << 6)
diff --git a/drivers/gpu/drm/tegra/dc.c b/drivers/gpu/drm/tegra/dc.c
index 3aaa84ae2681..1a52522f5da7 100644
--- a/drivers/gpu/drm/tegra/dc.c
+++ b/drivers/gpu/drm/tegra/dc.c
@@ -997,8 +997,10 @@ static void tegra_crtc_reset(struct drm_crtc *crtc)
         crtc->state = NULL;
 
         state = kzalloc(sizeof(*state), GFP_KERNEL);
-        if (state)
+        if (state) {
                 crtc->state = &state->base;
+                crtc->state->crtc = crtc;
+        }
 }
 
 static struct drm_crtc_state *
@@ -1012,6 +1014,7 @@ tegra_crtc_atomic_duplicate_state(struct drm_crtc *crtc)
                 return NULL;
 
         copy->base.mode_changed = false;
+        copy->base.active_changed = false;
         copy->base.planes_changed = false;
         copy->base.event = NULL;
 
@@ -1227,9 +1230,6 @@ static void tegra_crtc_mode_set_nofb(struct drm_crtc *crtc)
         /* program display mode */
         tegra_dc_set_timings(dc, mode);
 
-        if (dc->soc->supports_border_color)
-                tegra_dc_writel(dc, 0, DC_DISP_BORDER_COLOR);
-
         /* interlacing isn't supported yet, so disable it */
         if (dc->soc->supports_interlacing) {
                 value = tegra_dc_readl(dc, DC_DISP_INTERLACE_CONTROL);
@@ -1252,42 +1252,7 @@ static void tegra_crtc_mode_set_nofb(struct drm_crtc *crtc)
 
 static void tegra_crtc_prepare(struct drm_crtc *crtc)
 {
-        struct tegra_dc *dc = to_tegra_dc(crtc);
-        unsigned int syncpt;
-        unsigned long value;
-
         drm_crtc_vblank_off(crtc);
-
-        if (dc->pipe)
-                syncpt = SYNCPT_VBLANK1;
-        else
-                syncpt = SYNCPT_VBLANK0;
-
-        /* initialize display controller */
-        tegra_dc_writel(dc, 0x00000100, DC_CMD_GENERAL_INCR_SYNCPT_CNTRL);
-        tegra_dc_writel(dc, 0x100 | syncpt, DC_CMD_CONT_SYNCPT_VSYNC);
-
-        value = WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT | WIN_A_OF_INT;
-        tegra_dc_writel(dc, value, DC_CMD_INT_TYPE);
-
-        value = WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT |
-                WIN_A_OF_INT | WIN_B_OF_INT | WIN_C_OF_INT;
-        tegra_dc_writel(dc, value, DC_CMD_INT_POLARITY);
-
-        /* initialize timer */
-        value = CURSOR_THRESHOLD(0) | WINDOW_A_THRESHOLD(0x20) |
-                WINDOW_B_THRESHOLD(0x20) | WINDOW_C_THRESHOLD(0x20);
-        tegra_dc_writel(dc, value, DC_DISP_DISP_MEM_HIGH_PRIORITY);
-
-        value = CURSOR_THRESHOLD(0) | WINDOW_A_THRESHOLD(1) |
-                WINDOW_B_THRESHOLD(1) | WINDOW_C_THRESHOLD(1);
-        tegra_dc_writel(dc, value, DC_DISP_DISP_MEM_HIGH_PRIORITY_TIMER);
-
-        value = VBLANK_INT | WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT;
-        tegra_dc_writel(dc, value, DC_CMD_INT_ENABLE);
-
-        value = WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT;
-        tegra_dc_writel(dc, value, DC_CMD_INT_MASK);
 }
 
 static void tegra_crtc_commit(struct drm_crtc *crtc)
@@ -1664,6 +1629,8 @@ static int tegra_dc_init(struct host1x_client *client)
         struct tegra_drm *tegra = drm->dev_private;
         struct drm_plane *primary = NULL;
         struct drm_plane *cursor = NULL;
+        unsigned int syncpt;
+        u32 value;
         int err;
 
         if (tegra->domain) {
@@ -1730,6 +1697,40 @@ static int tegra_dc_init(struct host1x_client *client)
                 goto cleanup;
         }
 
+        /* initialize display controller */
+        if (dc->pipe)
+                syncpt = SYNCPT_VBLANK1;
+        else
+                syncpt = SYNCPT_VBLANK0;
+
+        tegra_dc_writel(dc, 0x00000100, DC_CMD_GENERAL_INCR_SYNCPT_CNTRL);
+        tegra_dc_writel(dc, 0x100 | syncpt, DC_CMD_CONT_SYNCPT_VSYNC);
+
+        value = WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT | WIN_A_OF_INT;
+        tegra_dc_writel(dc, value, DC_CMD_INT_TYPE);
+
+        value = WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT |
+                WIN_A_OF_INT | WIN_B_OF_INT | WIN_C_OF_INT;
+        tegra_dc_writel(dc, value, DC_CMD_INT_POLARITY);
+
+        /* initialize timer */
+        value = CURSOR_THRESHOLD(0) | WINDOW_A_THRESHOLD(0x20) |
+                WINDOW_B_THRESHOLD(0x20) | WINDOW_C_THRESHOLD(0x20);
+        tegra_dc_writel(dc, value, DC_DISP_DISP_MEM_HIGH_PRIORITY);
+
+        value = CURSOR_THRESHOLD(0) | WINDOW_A_THRESHOLD(1) |
+                WINDOW_B_THRESHOLD(1) | WINDOW_C_THRESHOLD(1);
+        tegra_dc_writel(dc, value, DC_DISP_DISP_MEM_HIGH_PRIORITY_TIMER);
+
+        value = VBLANK_INT | WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT;
+        tegra_dc_writel(dc, value, DC_CMD_INT_ENABLE);
+
+        value = WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT;
+        tegra_dc_writel(dc, value, DC_CMD_INT_MASK);
+
+        if (dc->soc->supports_border_color)
+                tegra_dc_writel(dc, 0, DC_DISP_BORDER_COLOR);
+
         return 0;
 
 cleanup:
diff --git a/drivers/gpu/drm/tegra/hdmi.c b/drivers/gpu/drm/tegra/hdmi.c
index 7e06657ae58b..7eaaee74a039 100644
--- a/drivers/gpu/drm/tegra/hdmi.c
+++ b/drivers/gpu/drm/tegra/hdmi.c
@@ -851,6 +851,14 @@ static void tegra_hdmi_encoder_mode_set(struct drm_encoder *encoder,
         h_back_porch = mode->htotal - mode->hsync_end;
         h_front_porch = mode->hsync_start - mode->hdisplay;
 
+        err = clk_set_rate(hdmi->clk, pclk);
+        if (err < 0) {
+                dev_err(hdmi->dev, "failed to set HDMI clock frequency: %d\n",
+                        err);
+        }
+
+        DRM_DEBUG_KMS("HDMI clock rate: %lu Hz\n", clk_get_rate(hdmi->clk));
+
         /* power up sequence */
         value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_SOR_PLL0);
         value &= ~SOR_PLL_PDBG;
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index db4fb6e1cc5b..7c669c328c4c 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1872,6 +1872,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE7K) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K) },
@@ -1926,6 +1927,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
 #endif
 #if IS_ENABLED(CONFIG_HID_SAITEK)
         { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7_OLD) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT9) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 46edb4d3ed28..204312bfab2c 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -654,6 +654,7 @@
 #define USB_DEVICE_ID_MS_LK6K           0x00f9
 #define USB_DEVICE_ID_MS_PRESENTER_8K_BT        0x0701
 #define USB_DEVICE_ID_MS_PRESENTER_8K_USB       0x0713
+#define USB_DEVICE_ID_MS_NE7K           0x071d
 #define USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K       0x0730
 #define USB_DEVICE_ID_MS_COMFORT_MOUSE_4500     0x076c
 #define USB_DEVICE_ID_MS_SURFACE_PRO_2   0x0799
@@ -802,6 +803,7 @@
 #define USB_VENDOR_ID_SAITEK            0x06a3
 #define USB_DEVICE_ID_SAITEK_RUMBLEPAD  0xff17
 #define USB_DEVICE_ID_SAITEK_PS1000     0x0621
+#define USB_DEVICE_ID_SAITEK_RAT7_OLD   0x0ccb
 #define USB_DEVICE_ID_SAITEK_RAT7       0x0cd7
 #define USB_DEVICE_ID_SAITEK_MMO7       0x0cd0
 
diff --git a/drivers/hid/hid-microsoft.c b/drivers/hid/hid-microsoft.c
index fbaea6eb882e..af935eb198c9 100644
--- a/drivers/hid/hid-microsoft.c
+++ b/drivers/hid/hid-microsoft.c
@@ -264,6 +264,8 @@ static const struct hid_device_id ms_devices[] = {
                 .driver_data = MS_ERGONOMY },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP),
                 .driver_data = MS_ERGONOMY },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE7K),
+                .driver_data = MS_ERGONOMY },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K),
                 .driver_data = MS_ERGONOMY | MS_RDESC },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB),
diff --git a/drivers/hid/hid-saitek.c b/drivers/hid/hid-saitek.c
index 5632c54eadf0..a014f21275d8 100644
--- a/drivers/hid/hid-saitek.c
+++ b/drivers/hid/hid-saitek.c
@@ -177,6 +177,8 @@ static int saitek_event(struct hid_device *hdev, struct hid_field *field,
 static const struct hid_device_id saitek_devices[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000),
                 .driver_data = SAITEK_FIX_PS1000 },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7_OLD),
+                .driver_data = SAITEK_RELEASE_MODE_RAT7 },
         { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7),
                 .driver_data = SAITEK_RELEASE_MODE_RAT7 },
         { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT9),
diff --git a/drivers/hid/hid-sensor-hub.c b/drivers/hid/hid-sensor-hub.c
index 6a58b6c723aa..e54ce1097e2c 100644
--- a/drivers/hid/hid-sensor-hub.c
+++ b/drivers/hid/hid-sensor-hub.c
@@ -135,8 +135,9 @@ static struct hid_sensor_hub_callbacks *sensor_hub_get_callback(
 {
         struct hid_sensor_hub_callbacks_list *callback;
         struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
+        unsigned long flags;
 
-        spin_lock(&pdata->dyn_callback_lock);
+        spin_lock_irqsave(&pdata->dyn_callback_lock, flags);
         list_for_each_entry(callback, &pdata->dyn_callback_list, list)
                 if (callback->usage_id == usage_id &&
                         (collection_index >=
@@ -145,10 +146,11 @@ static struct hid_sensor_hub_callbacks *sensor_hub_get_callback(
                                 callback->hsdev->end_collection_index)) {
                         *priv = callback->priv;
                         *hsdev = callback->hsdev;
-                        spin_unlock(&pdata->dyn_callback_lock);
+                        spin_unlock_irqrestore(&pdata->dyn_callback_lock,
+                                               flags);
                         return callback->usage_callback;
                 }
-        spin_unlock(&pdata->dyn_callback_lock);
+        spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
 
         return NULL;
 }
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
index 31e9d2561106..1896c019e302 100644
--- a/drivers/hid/hid-sony.c
+++ b/drivers/hid/hid-sony.c
@@ -804,7 +804,7 @@ union sixaxis_output_report_01 {
 #define DS4_REPORT_0x81_SIZE 7
 #define SIXAXIS_REPORT_0xF2_SIZE 18
 
-static spinlock_t sony_dev_list_lock;
+static DEFINE_SPINLOCK(sony_dev_list_lock);
 static LIST_HEAD(sony_device_list);
 static DEFINE_IDA(sony_device_id_allocator);
 
@@ -1944,6 +1944,8 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
                 return -ENOMEM;
         }
 
+        spin_lock_init(&sc->lock);
+
         sc->quirks = quirks;
         hid_set_drvdata(hdev, sc);
         sc->hdev = hdev;
@@ -2147,8 +2149,8 @@ static void __exit sony_exit(void)
 {
         dbg_hid("Sony:%s\n", __func__);
 
-        ida_destroy(&sony_device_id_allocator);
         hid_unregister_driver(&sony_driver);
+        ida_destroy(&sony_device_id_allocator);
 }
 module_init(sony_init);
 module_exit(sony_exit);
diff --git a/drivers/hid/i2c-hid/i2c-hid.c b/drivers/hid/i2c-hid/i2c-hid.c
index d43e967e7533..36053f33d6d9 100644
--- a/drivers/hid/i2c-hid/i2c-hid.c
+++ b/drivers/hid/i2c-hid/i2c-hid.c
@@ -370,7 +370,10 @@ static int i2c_hid_hwreset(struct i2c_client *client)
 static void i2c_hid_get_input(struct i2c_hid *ihid)
 {
         int ret, ret_size;
-        int size = ihid->bufsize;
+        int size = le16_to_cpu(ihid->hdesc.wMaxInputLength);
+
+        if (size > ihid->bufsize)
+                size = ihid->bufsize;
 
         ret = i2c_master_recv(ihid->client, ihid->inbuf, size);
         if (ret != size) {
@@ -785,7 +788,7 @@ static int i2c_hid_init_irq(struct i2c_client *client)
         dev_dbg(&client->dev, "Requesting IRQ: %d\n", client->irq);
 
         ret = request_threaded_irq(client->irq, NULL, i2c_hid_irq,
-                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                        IRQF_TRIGGER_LOW | IRQF_ONESHOT,
                         client->name, ihid);
         if (ret < 0) {
                 dev_warn(&client->dev,
diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c
index 1a6507999a65..046351cf17f3 100644
--- a/drivers/hid/wacom_wac.c
+++ b/drivers/hid/wacom_wac.c
@@ -778,6 +778,11 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
                         input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[4]));
                         input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[6]));
                         input_report_abs(input, ABS_Z, be16_to_cpup((__be16 *)&data[8]));
+                        if ((data[2] & 0x07) | data[4] | data[5] | data[6] | data[7] | data[8] | data[9]) {
+                                input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
+                        } else {
+                                input_report_abs(input, ABS_MISC, 0);
+                        }
                 } else if (features->type == CINTIQ_HYBRID) {
                         /*
                          * Do not send hardware buttons under Android. They
@@ -2725,9 +2730,9 @@ static const struct wacom_features wacom_features_0xF6 =
           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
 static const struct wacom_features wacom_features_0x32A =
-        { "Wacom Cintiq 27QHD", 119740, 67520, 2047,
-          63, WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
-          WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
+        { "Wacom Cintiq 27QHD", 119740, 67520, 2047, 63,
+          WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
+          WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
 static const struct wacom_features wacom_features_0x32B =
         { "Wacom Cintiq 27QHD touch", 119740, 67520, 2047, 63,
           WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index d931cbbed240..110fade9cb74 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -1606,7 +1606,7 @@ config SENSORS_W83795
           will be called w83795.
 
 config SENSORS_W83795_FANCTRL
-        boolean "Include automatic fan control support (DANGEROUS)"
+        bool "Include automatic fan control support (DANGEROUS)"
         depends on SENSORS_W83795
         default n
         help
diff --git a/drivers/hwmon/ads7828.c b/drivers/hwmon/ads7828.c
index bce4e9ff21bf..6c99ee7bafa3 100644
--- a/drivers/hwmon/ads7828.c
+++ b/drivers/hwmon/ads7828.c
@@ -147,6 +147,9 @@ static int ads7828_probe(struct i2c_client *client,
                                                     &ads2830_regmap_config);
         }
 
+        if (IS_ERR(data->regmap))
+                return PTR_ERR(data->regmap);
+
         data->cmd_byte = ext_vref ? ADS7828_CMD_PD1 : ADS7828_CMD_PD3;
         if (!diff_input)
                 data->cmd_byte |= ADS7828_CMD_SD_SE;
diff --git a/drivers/hwmon/pmbus/Kconfig b/drivers/hwmon/pmbus/Kconfig
index a674cd83a4e2..9f7dbd189c97 100644
--- a/drivers/hwmon/pmbus/Kconfig
+++ b/drivers/hwmon/pmbus/Kconfig
@@ -57,7 +57,7 @@ config SENSORS_LTC2978
           be called ltc2978.
 
 config SENSORS_LTC2978_REGULATOR
-        boolean "Regulator support for LTC2978 and compatibles"
+        bool "Regulator support for LTC2978 and compatibles"
         depends on SENSORS_LTC2978 && REGULATOR
         help
           If you say yes here you get regulator support for Linear
diff --git a/drivers/i2c/Kconfig b/drivers/i2c/Kconfig
index 8c9e619f3026..78fbee463628 100644
--- a/drivers/i2c/Kconfig
+++ b/drivers/i2c/Kconfig
@@ -35,11 +35,11 @@ config ACPI_I2C_OPREGION
 if I2C
 
 config I2C_BOARDINFO
-        boolean
+        bool
         default y
 
 config I2C_COMPAT
-        boolean "Enable compatibility bits for old user-space"
+        bool "Enable compatibility bits for old user-space"
         default y
         help
           Say Y here if you intend to run lm-sensors 3.1.1 or older, or any
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index ab838d9e28b6..22da9c2ffa22 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -79,7 +79,7 @@ config I2C_AMD8111
 
 config I2C_HIX5HD2
         tristate "Hix5hd2 high-speed I2C driver"
-        depends on ARCH_HIX5HD2
+        depends on ARCH_HIX5HD2 || COMPILE_TEST
         help
           Say Y here to include support for high-speed I2C controller in the
           Hisilicon based hix5hd2 SoCs.
@@ -372,6 +372,16 @@ config I2C_BCM2835
           This support is also available as a module.  If so, the module
           will be called i2c-bcm2835.
 
+config I2C_BCM_IPROC
+        tristate "Broadcom iProc I2C controller"
+        depends on ARCH_BCM_IPROC || COMPILE_TEST
+        default ARCH_BCM_IPROC
+        help
+          If you say yes to this option, support will be included for the
+          Broadcom iProc I2C controller.
+
+          If you don't know what to do here, say N.
+
 config I2C_BCM_KONA
         tristate "BCM Kona I2C adapter"
         depends on ARCH_BCM_MOBILE
@@ -465,6 +475,16 @@ config I2C_DESIGNWARE_PCI
           This driver can also be built as a module.  If so, the module
           will be called i2c-designware-pci.
 
+config I2C_DESIGNWARE_BAYTRAIL
+        bool "Intel Baytrail I2C semaphore support"
+        depends on I2C_DESIGNWARE_PLATFORM && IOSF_MBI=y && ACPI
+        help
+          This driver enables managed host access to the PMIC I2C bus on select
+          Intel BayTrail platforms using the X-Powers AXP288 PMIC. It allows
+          the host to request uninterrupted access to the PMIC's I2C bus from
+          the platform firmware controlling it. You should say Y if running on
+          a BayTrail system using the AXP288.
+
 config I2C_EFM32
         tristate "EFM32 I2C controller"
         depends on ARCH_EFM32 || COMPILE_TEST
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index 56388f658d2f..3638feb6677e 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -33,6 +33,7 @@ obj-$(CONFIG_I2C_AT91)		+= i2c-at91.o
 obj-$(CONFIG_I2C_AU1550)        += i2c-au1550.o
 obj-$(CONFIG_I2C_AXXIA)         += i2c-axxia.o
 obj-$(CONFIG_I2C_BCM2835)       += i2c-bcm2835.o
+obj-$(CONFIG_I2C_BCM_IPROC)     += i2c-bcm-iproc.o
 obj-$(CONFIG_I2C_BLACKFIN_TWI)  += i2c-bfin-twi.o
 obj-$(CONFIG_I2C_CADENCE)       += i2c-cadence.o
 obj-$(CONFIG_I2C_CBUS_GPIO)     += i2c-cbus-gpio.o
@@ -41,6 +42,7 @@ obj-$(CONFIG_I2C_DAVINCI)	+= i2c-davinci.o
 obj-$(CONFIG_I2C_DESIGNWARE_CORE)       += i2c-designware-core.o
 obj-$(CONFIG_I2C_DESIGNWARE_PLATFORM)   += i2c-designware-platform.o
 i2c-designware-platform-objs := i2c-designware-platdrv.o
+i2c-designware-platform-$(CONFIG_I2C_DESIGNWARE_BAYTRAIL) += i2c-designware-baytrail.o
 obj-$(CONFIG_I2C_DESIGNWARE_PCI)        += i2c-designware-pci.o
 i2c-designware-pci-objs := i2c-designware-pcidrv.o
 obj-$(CONFIG_I2C_EFM32)         += i2c-efm32.o
diff --git a/drivers/i2c/busses/i2c-bcm-iproc.c b/drivers/i2c/busses/i2c-bcm-iproc.c
new file mode 100644
index 000000000000..d3c89157b337
--- /dev/null
+++ b/drivers/i2c/busses/i2c-bcm-iproc.c
@@ -0,0 +1,461 @@
+/*
+ * Copyright (C) 2014 Broadcom 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.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#define CFG_OFFSET                   0x00
+#define CFG_RESET_SHIFT              31
+#define CFG_EN_SHIFT                 30
+#define CFG_M_RETRY_CNT_SHIFT        16
+#define CFG_M_RETRY_CNT_MASK         0x0f
+
+#define TIM_CFG_OFFSET               0x04
+#define TIM_CFG_MODE_400_SHIFT       31
+
+#define M_FIFO_CTRL_OFFSET           0x0c
+#define M_FIFO_RX_FLUSH_SHIFT        31
+#define M_FIFO_TX_FLUSH_SHIFT        30
+#define M_FIFO_RX_CNT_SHIFT          16
+#define M_FIFO_RX_CNT_MASK           0x7f
+#define M_FIFO_RX_THLD_SHIFT         8
+#define M_FIFO_RX_THLD_MASK          0x3f
+
+#define M_CMD_OFFSET                 0x30
+#define M_CMD_START_BUSY_SHIFT       31
+#define M_CMD_STATUS_SHIFT           25
+#define M_CMD_STATUS_MASK            0x07
+#define M_CMD_STATUS_SUCCESS         0x0
+#define M_CMD_STATUS_LOST_ARB        0x1
+#define M_CMD_STATUS_NACK_ADDR       0x2
+#define M_CMD_STATUS_NACK_DATA       0x3
+#define M_CMD_STATUS_TIMEOUT         0x4
+#define M_CMD_PROTOCOL_SHIFT         9
+#define M_CMD_PROTOCOL_MASK          0xf
+#define M_CMD_PROTOCOL_BLK_WR        0x7
+#define M_CMD_PROTOCOL_BLK_RD        0x8
+#define M_CMD_PEC_SHIFT              8
+#define M_CMD_RD_CNT_SHIFT           0
+#define M_CMD_RD_CNT_MASK            0xff
+
+#define IE_OFFSET                    0x38
+#define IE_M_RX_FIFO_FULL_SHIFT      31
+#define IE_M_RX_THLD_SHIFT           30
+#define IE_M_START_BUSY_SHIFT        28
+
+#define IS_OFFSET                    0x3c
+#define IS_M_RX_FIFO_FULL_SHIFT      31
+#define IS_M_RX_THLD_SHIFT           30
+#define IS_M_START_BUSY_SHIFT        28
+
+#define M_TX_OFFSET                  0x40
+#define M_TX_WR_STATUS_SHIFT         31
+#define M_TX_DATA_SHIFT              0
+#define M_TX_DATA_MASK               0xff
+
+#define M_RX_OFFSET                  0x44
+#define M_RX_STATUS_SHIFT            30
+#define M_RX_STATUS_MASK             0x03
+#define M_RX_PEC_ERR_SHIFT           29
+#define M_RX_DATA_SHIFT              0
+#define M_RX_DATA_MASK               0xff
+
+#define I2C_TIMEOUT_MESC             100
+#define M_TX_RX_FIFO_SIZE            64
+
+enum bus_speed_index {
+        I2C_SPD_100K = 0,
+        I2C_SPD_400K,
+};
+
+struct bcm_iproc_i2c_dev {
+        struct device *device;
+        int irq;
+
+        void __iomem *base;
+
+        struct i2c_adapter adapter;
+
+        struct completion done;
+        int xfer_is_done;
+};
+
+/*
+ * Can be expanded in the future if more interrupt status bits are utilized
+ */
+#define ISR_MASK (1 << IS_M_START_BUSY_SHIFT)
+
+static irqreturn_t bcm_iproc_i2c_isr(int irq, void *data)
+{
+        struct bcm_iproc_i2c_dev *iproc_i2c = data;
+        u32 status = readl(iproc_i2c->base + IS_OFFSET);
+
+        status &= ISR_MASK;
+
+        if (!status)
+                return IRQ_NONE;
+
+        writel(status, iproc_i2c->base + IS_OFFSET);
+        iproc_i2c->xfer_is_done = 1;
+        complete_all(&iproc_i2c->done);
+
+        return IRQ_HANDLED;
+}
+
+static int bcm_iproc_i2c_check_status(struct bcm_iproc_i2c_dev *iproc_i2c,
+                                      struct i2c_msg *msg)
+{
+        u32 val;
+
+        val = readl(iproc_i2c->base + M_CMD_OFFSET);
+        val = (val >> M_CMD_STATUS_SHIFT) & M_CMD_STATUS_MASK;
+
+        switch (val) {
+        case M_CMD_STATUS_SUCCESS:
+                return 0;
+
+        case M_CMD_STATUS_LOST_ARB:
+                dev_dbg(iproc_i2c->device, "lost bus arbitration\n");
+                return -EAGAIN;
+
+        case M_CMD_STATUS_NACK_ADDR:
+                dev_dbg(iproc_i2c->device, "NAK addr:0x%02x\n", msg->addr);
+                return -ENXIO;
+
+        case M_CMD_STATUS_NACK_DATA:
+                dev_dbg(iproc_i2c->device, "NAK data\n");
+                return -ENXIO;
+
+        case M_CMD_STATUS_TIMEOUT:
+                dev_dbg(iproc_i2c->device, "bus timeout\n");
+                return -ETIMEDOUT;
+
+        default:
+                dev_dbg(iproc_i2c->device, "unknown error code=%d\n", val);
+                return -EIO;
+        }
+}
+
+static int bcm_iproc_i2c_xfer_single_msg(struct bcm_iproc_i2c_dev *iproc_i2c,
+                                         struct i2c_msg *msg)
+{
+        int ret, i;
+        u8 addr;
+        u32 val;
+        unsigned long time_left = msecs_to_jiffies(I2C_TIMEOUT_MESC);
+
+        /* need to reserve one byte in the FIFO for the slave address */
+        if (msg->len > M_TX_RX_FIFO_SIZE - 1) {
+                dev_err(iproc_i2c->device,
+                        "only support data length up to %u bytes\n",
+                        M_TX_RX_FIFO_SIZE - 1);
+                return -EOPNOTSUPP;
+        }
+
+        /* check if bus is busy */
+        if (!!(readl(iproc_i2c->base + M_CMD_OFFSET) &
+               BIT(M_CMD_START_BUSY_SHIFT))) {
+                dev_warn(iproc_i2c->device, "bus is busy\n");
+                return -EBUSY;
+        }
+
+        /* format and load slave address into the TX FIFO */
+        addr = msg->addr << 1 | (msg->flags & I2C_M_RD ? 1 : 0);
+        writel(addr, iproc_i2c->base + M_TX_OFFSET);
+
+        /* for a write transaction, load data into the TX FIFO */
+        if (!(msg->flags & I2C_M_RD)) {
+                for (i = 0; i < msg->len; i++) {
+                        val = msg->buf[i];
+
+                        /* mark the last byte */
+                        if (i == msg->len - 1)
+                                val |= 1 << M_TX_WR_STATUS_SHIFT;
+
+                        writel(val, iproc_i2c->base + M_TX_OFFSET);
+                }
+        }
+
+        /* mark as incomplete before starting the transaction */
+        reinit_completion(&iproc_i2c->done);
+        iproc_i2c->xfer_is_done = 0;
+
+        /*
+         * Enable the "start busy" interrupt, which will be triggered after the
+         * transaction is done, i.e., the internal start_busy bit, transitions
+         * from 1 to 0.
+         */
+        writel(1 << IE_M_START_BUSY_SHIFT, iproc_i2c->base + IE_OFFSET);
+
+        /*
+         * Now we can activate the transfer. For a read operation, specify the
+         * number of bytes to read
+         */
+        val = 1 << M_CMD_START_BUSY_SHIFT;
+        if (msg->flags & I2C_M_RD) {
+                val |= (M_CMD_PROTOCOL_BLK_RD << M_CMD_PROTOCOL_SHIFT) |
+                       (msg->len << M_CMD_RD_CNT_SHIFT);
+        } else {
+                val |= (M_CMD_PROTOCOL_BLK_WR << M_CMD_PROTOCOL_SHIFT);
+        }
+        writel(val, iproc_i2c->base + M_CMD_OFFSET);
+
+        time_left = wait_for_completion_timeout(&iproc_i2c->done, time_left);
+
+        /* disable all interrupts */
+        writel(0, iproc_i2c->base + IE_OFFSET);
+        /* read it back to flush the write */
+        readl(iproc_i2c->base + IE_OFFSET);
+
+        /* make sure the interrupt handler isn't running */
+        synchronize_irq(iproc_i2c->irq);
+
+        if (!time_left && !iproc_i2c->xfer_is_done) {
+                dev_err(iproc_i2c->device, "transaction timed out\n");
+
+                /* flush FIFOs */
+                val = (1 << M_FIFO_RX_FLUSH_SHIFT) |
+                      (1 << M_FIFO_TX_FLUSH_SHIFT);
+                writel(val, iproc_i2c->base + M_FIFO_CTRL_OFFSET);
+                return -ETIMEDOUT;
+        }
+
+        ret = bcm_iproc_i2c_check_status(iproc_i2c, msg);
+        if (ret) {
+                /* flush both TX/RX FIFOs */
+                val = (1 << M_FIFO_RX_FLUSH_SHIFT) |
+                      (1 << M_FIFO_TX_FLUSH_SHIFT);
+                writel(val, iproc_i2c->base + M_FIFO_CTRL_OFFSET);
+                return ret;
+        }
+
+        /*
+         * For a read operation, we now need to load the data from FIFO
+         * into the memory buffer
+         */
+        if (msg->flags & I2C_M_RD) {
+                for (i = 0; i < msg->len; i++) {
+                        msg->buf[i] = (readl(iproc_i2c->base + M_RX_OFFSET) >>
+                                      M_RX_DATA_SHIFT) & M_RX_DATA_MASK;
+                }
+        }
+
+        return 0;
+}
+
+static int bcm_iproc_i2c_xfer(struct i2c_adapter *adapter,
+                              struct i2c_msg msgs[], int num)
+{
+        struct bcm_iproc_i2c_dev *iproc_i2c = i2c_get_adapdata(adapter);
+        int ret, i;
+
+        /* go through all messages */
+        for (i = 0; i < num; i++) {
+                ret = bcm_iproc_i2c_xfer_single_msg(iproc_i2c, &msgs[i]);
+                if (ret) {
+                        dev_dbg(iproc_i2c->device, "xfer failed\n");
+                        return ret;
+                }
+        }
+
+        return num;
+}
+
+static uint32_t bcm_iproc_i2c_functionality(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
+}
+
+static const struct i2c_algorithm bcm_iproc_algo = {
+        .master_xfer = bcm_iproc_i2c_xfer,
+        .functionality = bcm_iproc_i2c_functionality,
+};
+
+static int bcm_iproc_i2c_cfg_speed(struct bcm_iproc_i2c_dev *iproc_i2c)
+{
+        unsigned int bus_speed;
+        u32 val;
+        int ret = of_property_read_u32(iproc_i2c->device->of_node,
+                                       "clock-frequency", &bus_speed);
+        if (ret < 0) {
+                dev_info(iproc_i2c->device,
+                        "unable to interpret clock-frequency DT property\n");
+                bus_speed = 100000;
+        }
+
+        if (bus_speed < 100000) {
+                dev_err(iproc_i2c->device, "%d Hz bus speed not supported\n",
+                        bus_speed);
+                dev_err(iproc_i2c->device,
+                        "valid speeds are 100khz and 400khz\n");
+                return -EINVAL;
+        } else if (bus_speed < 400000) {
+                bus_speed = 100000;
+        } else {
+                bus_speed = 400000;
+        }
+
+        val = readl(iproc_i2c->base + TIM_CFG_OFFSET);
+        val &= ~(1 << TIM_CFG_MODE_400_SHIFT);
+        val |= (bus_speed == 400000) << TIM_CFG_MODE_400_SHIFT;
+        writel(val, iproc_i2c->base + TIM_CFG_OFFSET);
+
+        dev_info(iproc_i2c->device, "bus set to %u Hz\n", bus_speed);
+
+        return 0;
+}
+
+static int bcm_iproc_i2c_init(struct bcm_iproc_i2c_dev *iproc_i2c)
+{
+        u32 val;
+
+        /* put controller in reset */
+        val = readl(iproc_i2c->base + CFG_OFFSET);
+        val |= 1 << CFG_RESET_SHIFT;
+        val &= ~(1 << CFG_EN_SHIFT);
+        writel(val, iproc_i2c->base + CFG_OFFSET);
+
+        /* wait 100 usec per spec */
+        udelay(100);
+
+        /* bring controller out of reset */
+        val &= ~(1 << CFG_RESET_SHIFT);
+        writel(val, iproc_i2c->base + CFG_OFFSET);
+
+        /* flush TX/RX FIFOs and set RX FIFO threshold to zero */
+        val = (1 << M_FIFO_RX_FLUSH_SHIFT) | (1 << M_FIFO_TX_FLUSH_SHIFT);
+        writel(val, iproc_i2c->base + M_FIFO_CTRL_OFFSET);
+
+        /* disable all interrupts */
+        writel(0, iproc_i2c->base + IE_OFFSET);
+
+        /* clear all pending interrupts */
+        writel(0xffffffff, iproc_i2c->base + IS_OFFSET);
+
+        return 0;
+}
+
+static void bcm_iproc_i2c_enable_disable(struct bcm_iproc_i2c_dev *iproc_i2c,
+                                         bool enable)
+{
+        u32 val;
+
+        val = readl(iproc_i2c->base + CFG_OFFSET);
+        if (enable)
+                val |= BIT(CFG_EN_SHIFT);
+        else
+                val &= ~BIT(CFG_EN_SHIFT);
+        writel(val, iproc_i2c->base + CFG_OFFSET);
+}
+
+static int bcm_iproc_i2c_probe(struct platform_device *pdev)
+{
+        int irq, ret = 0;
+        struct bcm_iproc_i2c_dev *iproc_i2c;
+        struct i2c_adapter *adap;
+        struct resource *res;
+
+        iproc_i2c = devm_kzalloc(&pdev->dev, sizeof(*iproc_i2c),
+                                 GFP_KERNEL);
+        if (!iproc_i2c)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, iproc_i2c);
+        iproc_i2c->device = &pdev->dev;
+        init_completion(&iproc_i2c->done);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        iproc_i2c->base = devm_ioremap_resource(iproc_i2c->device, res);
+        if (IS_ERR(iproc_i2c->base))
+                return PTR_ERR(iproc_i2c->base);
+
+        ret = bcm_iproc_i2c_init(iproc_i2c);
+        if (ret)
+                return ret;
+
+        ret = bcm_iproc_i2c_cfg_speed(iproc_i2c);
+        if (ret)
+                return ret;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0) {
+                dev_err(iproc_i2c->device, "no irq resource\n");
+                return irq;
+        }
+        iproc_i2c->irq = irq;
+
+        ret = devm_request_irq(iproc_i2c->device, irq, bcm_iproc_i2c_isr, 0,
+                               pdev->name, iproc_i2c);
+        if (ret < 0) {
+                dev_err(iproc_i2c->device, "unable to request irq %i\n", irq);
+                return ret;
+        }
+
+        bcm_iproc_i2c_enable_disable(iproc_i2c, true);
+
+        adap = &iproc_i2c->adapter;
+        i2c_set_adapdata(adap, iproc_i2c);
+        strlcpy(adap->name, "Broadcom iProc I2C adapter", sizeof(adap->name));
+        adap->algo = &bcm_iproc_algo;
+        adap->dev.parent = &pdev->dev;
+        adap->dev.of_node = pdev->dev.of_node;
+
+        ret = i2c_add_adapter(adap);
+        if (ret) {
+                dev_err(iproc_i2c->device, "failed to add adapter\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static int bcm_iproc_i2c_remove(struct platform_device *pdev)
+{
+        struct bcm_iproc_i2c_dev *iproc_i2c = platform_get_drvdata(pdev);
+
+        /* make sure there's no pending interrupt when we remove the adapter */
+        writel(0, iproc_i2c->base + IE_OFFSET);
+        readl(iproc_i2c->base + IE_OFFSET);
+        synchronize_irq(iproc_i2c->irq);
+
+        i2c_del_adapter(&iproc_i2c->adapter);
+        bcm_iproc_i2c_enable_disable(iproc_i2c, false);
+
+        return 0;
+}
+
+static const struct of_device_id bcm_iproc_i2c_of_match[] = {
+        { .compatible = "brcm,iproc-i2c" },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, bcm_iproc_i2c_of_match);
+
+static struct platform_driver bcm_iproc_i2c_driver = {
+        .driver = {
+                .name = "bcm-iproc-i2c",
+                .of_match_table = bcm_iproc_i2c_of_match,
+        },
+        .probe = bcm_iproc_i2c_probe,
+        .remove = bcm_iproc_i2c_remove,
+};
+module_platform_driver(bcm_iproc_i2c_driver);
+
+MODULE_AUTHOR("Ray Jui <rjui@broadcom.com>");
+MODULE_DESCRIPTION("Broadcom iProc I2C Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/i2c/busses/i2c-cadence.c b/drivers/i2c/busses/i2c-cadence.c
index 626f74ecd4be..7d7a14cdadfb 100644
--- a/drivers/i2c/busses/i2c-cadence.c
+++ b/drivers/i2c/busses/i2c-cadence.c
@@ -128,6 +128,7 @@
  * @suspended:          Flag holding the device's PM status
  * @send_count:         Number of bytes still expected to send
  * @recv_count:         Number of bytes still expected to receive
+ * @curr_recv_count:    Number of bytes to be received in current transfer
  * @irq:                IRQ number
  * @input_clk:          Input clock to I2C controller
  * @i2c_clk:            Maximum I2C clock speed
@@ -146,6 +147,7 @@ struct cdns_i2c {
         u8 suspended;
         unsigned int send_count;
         unsigned int recv_count;
+        unsigned int curr_recv_count;
         int irq;
         unsigned long input_clk;
         unsigned int i2c_clk;
@@ -182,14 +184,15 @@ static void cdns_i2c_clear_bus_hold(struct cdns_i2c *id)
  */
 static irqreturn_t cdns_i2c_isr(int irq, void *ptr)
 {
-        unsigned int isr_status, avail_bytes;
-        unsigned int bytes_to_recv, bytes_to_send;
+        unsigned int isr_status, avail_bytes, updatetx;
+        unsigned int bytes_to_send;
         struct cdns_i2c *id = ptr;
         /* Signal completion only after everything is updated */
         int done_flag = 0;
         irqreturn_t status = IRQ_NONE;
 
         isr_status = cdns_i2c_readreg(CDNS_I2C_ISR_OFFSET);
+        cdns_i2c_writereg(isr_status, CDNS_I2C_ISR_OFFSET);
 
         /* Handling nack and arbitration lost interrupt */
         if (isr_status & (CDNS_I2C_IXR_NACK | CDNS_I2C_IXR_ARB_LOST)) {
@@ -197,89 +200,112 @@ static irqreturn_t cdns_i2c_isr(int irq, void *ptr)
                 status = IRQ_HANDLED;
         }
 
-        /* Handling Data interrupt */
-        if ((isr_status & CDNS_I2C_IXR_DATA) &&
-                        (id->recv_count >= CDNS_I2C_DATA_INTR_DEPTH)) {
-                /* Always read data interrupt threshold bytes */
-                bytes_to_recv = CDNS_I2C_DATA_INTR_DEPTH;
-                id->recv_count -= CDNS_I2C_DATA_INTR_DEPTH;
-                avail_bytes = cdns_i2c_readreg(CDNS_I2C_XFER_SIZE_OFFSET);
-
-                /*
-                 * if the tranfer size register value is zero, then
-                 * check for the remaining bytes and update the
-                 * transfer size register.
-                 */
-                if (!avail_bytes) {
-                        if (id->recv_count > CDNS_I2C_TRANSFER_SIZE)
-                                cdns_i2c_writereg(CDNS_I2C_TRANSFER_SIZE,
-                                                CDNS_I2C_XFER_SIZE_OFFSET);
-                        else
-                                cdns_i2c_writereg(id->recv_count,
-                                                CDNS_I2C_XFER_SIZE_OFFSET);
-                }
+        /*
+         * Check if transfer size register needs to be updated again for a
+         * large data receive operation.
+         */
+        updatetx = 0;
+        if (id->recv_count > id->curr_recv_count)
+                updatetx = 1;
+
+        /* When receiving, handle data interrupt and completion interrupt */
+        if (id->p_recv_buf &&
+            ((isr_status & CDNS_I2C_IXR_COMP) ||
+             (isr_status & CDNS_I2C_IXR_DATA))) {
+                /* Read data if receive data valid is set */
+                while (cdns_i2c_readreg(CDNS_I2C_SR_OFFSET) &
+                       CDNS_I2C_SR_RXDV) {
+                        /*
+                         * Clear hold bit that was set for FIFO control if
+                         * RX data left is less than FIFO depth, unless
+                         * repeated start is selected.
+                         */
+                        if ((id->recv_count < CDNS_I2C_FIFO_DEPTH) &&
+                            !id->bus_hold_flag)
+                                cdns_i2c_clear_bus_hold(id);
 
-                /* Process the data received */
-                while (bytes_to_recv--)
                         *(id->p_recv_buf)++ =
                                 cdns_i2c_readreg(CDNS_I2C_DATA_OFFSET);
+                        id->recv_count--;
+                        id->curr_recv_count--;
 
-                if (!id->bus_hold_flag &&
-                                (id->recv_count <= CDNS_I2C_FIFO_DEPTH))
-                        cdns_i2c_clear_bus_hold(id);
+                        if (updatetx &&
+                            (id->curr_recv_count == CDNS_I2C_FIFO_DEPTH + 1))
+                                break;
+                }
 
-                status = IRQ_HANDLED;
-        }
+                /*
+                 * The controller sends NACK to the slave when transfer size
+                 * register reaches zero without considering the HOLD bit.
+                 * This workaround is implemented for large data transfers to
+                 * maintain transfer size non-zero while performing a large
+                 * receive operation.
+                 */
+                if (updatetx &&
+                    (id->curr_recv_count == CDNS_I2C_FIFO_DEPTH + 1)) {
+                        /* wait while fifo is full */
+                        while (cdns_i2c_readreg(CDNS_I2C_XFER_SIZE_OFFSET) !=
+                               (id->curr_recv_count - CDNS_I2C_FIFO_DEPTH))
+                                ;
 
-        /* Handling Transfer Complete interrupt */
-        if (isr_status & CDNS_I2C_IXR_COMP) {
-                if (!id->p_recv_buf) {
                         /*
-                         * If the device is sending data If there is further
-                         * data to be sent. Calculate the available space
-                         * in FIFO and fill the FIFO with that many bytes.
+                         * Check number of bytes to be received against maximum
+                         * transfer size and update register accordingly.
                          */
-                        if (id->send_count) {
-                                avail_bytes = CDNS_I2C_FIFO_DEPTH -
-                                    cdns_i2c_readreg(CDNS_I2C_XFER_SIZE_OFFSET);
-                                if (id->send_count > avail_bytes)
-                                        bytes_to_send = avail_bytes;
-                                else
-                                        bytes_to_send = id->send_count;
-
-                                while (bytes_to_send--) {
-                                        cdns_i2c_writereg(
-                                                (*(id->p_send_buf)++),
-                                                 CDNS_I2C_DATA_OFFSET);
-                                        id->send_count--;
-                                }
+                        if (((int)(id->recv_count) - CDNS_I2C_FIFO_DEPTH) >
+                            CDNS_I2C_TRANSFER_SIZE) {
+                                cdns_i2c_writereg(CDNS_I2C_TRANSFER_SIZE,
+                                                  CDNS_I2C_XFER_SIZE_OFFSET);
+                                id->curr_recv_count = CDNS_I2C_TRANSFER_SIZE +
+                                                      CDNS_I2C_FIFO_DEPTH;
                         } else {
-                                /*
-                                 * Signal the completion of transaction and
-                                 * clear the hold bus bit if there are no
-                                 * further messages to be processed.
-                                 */
-                                done_flag = 1;
+                                cdns_i2c_writereg(id->recv_count -
+                                                  CDNS_I2C_FIFO_DEPTH,
+                                                  CDNS_I2C_XFER_SIZE_OFFSET);
+                                id->curr_recv_count = id->recv_count;
                         }
-                        if (!id->send_count && !id->bus_hold_flag)
-                                cdns_i2c_clear_bus_hold(id);
-                } else {
+                }
+
+                /* Clear hold (if not repeated start) and signal completion */
+                if ((isr_status & CDNS_I2C_IXR_COMP) && !id->recv_count) {
                         if (!id->bus_hold_flag)
                                 cdns_i2c_clear_bus_hold(id);
+                        done_flag = 1;
+                }
+
+                status = IRQ_HANDLED;
+        }
+
+        /* When sending, handle transfer complete interrupt */
+        if ((isr_status & CDNS_I2C_IXR_COMP) && !id->p_recv_buf) {
+                /*
+                 * If there is more data to be sent, calculate the
+                 * space available in FIFO and fill with that many bytes.
+                 */
+                if (id->send_count) {
+                        avail_bytes = CDNS_I2C_FIFO_DEPTH -
+                            cdns_i2c_readreg(CDNS_I2C_XFER_SIZE_OFFSET);
+                        if (id->send_count > avail_bytes)
+                                bytes_to_send = avail_bytes;
+                        else
+                                bytes_to_send = id->send_count;
+
+                        while (bytes_to_send--) {
+                                cdns_i2c_writereg(
+                                        (*(id->p_send_buf)++),
+                                         CDNS_I2C_DATA_OFFSET);
+                                id->send_count--;
+                        }
+                } else {
                         /*
-                         * If the device is receiving data, then signal
-                         * the completion of transaction and read the data
-                         * present in the FIFO. Signal the completion of
-                         * transaction.
+                         * Signal the completion of transaction and
+                         * clear the hold bus bit if there are no
+                         * further messages to be processed.
                          */
-                        while (cdns_i2c_readreg(CDNS_I2C_SR_OFFSET) &
-                                        CDNS_I2C_SR_RXDV) {
-                                *(id->p_recv_buf)++ =
-                                        cdns_i2c_readreg(CDNS_I2C_DATA_OFFSET);
-                                id->recv_count--;
-                        }
                         done_flag = 1;
                 }
+                if (!id->send_count && !id->bus_hold_flag)
+                        cdns_i2c_clear_bus_hold(id);
 
                 status = IRQ_HANDLED;
         }
@@ -289,8 +315,6 @@ static irqreturn_t cdns_i2c_isr(int irq, void *ptr)
         if (id->err_status)
                 status = IRQ_HANDLED;
 
-        cdns_i2c_writereg(isr_status, CDNS_I2C_ISR_OFFSET);
-
         if (done_flag)
                 complete(&id->xfer_done);
 
@@ -316,6 +340,8 @@ static void cdns_i2c_mrecv(struct cdns_i2c *id)
         if (id->p_msg->flags & I2C_M_RECV_LEN)
                 id->recv_count = I2C_SMBUS_BLOCK_MAX + 1;
 
+        id->curr_recv_count = id->recv_count;
+
         /*
          * Check for the message size against FIFO depth and set the
          * 'hold bus' bit if it is greater than FIFO depth.
@@ -335,11 +361,14 @@ static void cdns_i2c_mrecv(struct cdns_i2c *id)
          * receive if it is less than transfer size and transfer size if
          * it is more. Enable the interrupts.
          */
-        if (id->recv_count > CDNS_I2C_TRANSFER_SIZE)
+        if (id->recv_count > CDNS_I2C_TRANSFER_SIZE) {
                 cdns_i2c_writereg(CDNS_I2C_TRANSFER_SIZE,
                                   CDNS_I2C_XFER_SIZE_OFFSET);
-        else
+                id->curr_recv_count = CDNS_I2C_TRANSFER_SIZE;
+        } else {
                 cdns_i2c_writereg(id->recv_count, CDNS_I2C_XFER_SIZE_OFFSET);
+        }
+
         /* Clear the bus hold flag if bytes to receive is less than FIFO size */
         if (!id->bus_hold_flag &&
                 ((id->p_msg->flags & I2C_M_RECV_LEN) != I2C_M_RECV_LEN) &&
@@ -516,6 +545,20 @@ static int cdns_i2c_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
          * processed with a repeated start.
          */
         if (num > 1) {
+                /*
+                 * This controller does not give completion interrupt after a
+                 * master receive message if HOLD bit is set (repeated start),
+                 * resulting in SW timeout. Hence, if a receive message is
+                 * followed by any other message, an error is returned
+                 * indicating that this sequence is not supported.
+                 */
+                for (count = 0; count < num - 1; count++) {
+                        if (msgs[count].flags & I2C_M_RD) {
+                                dev_warn(adap->dev.parent,
+                                         "Can't do repeated start after a receive message\n");
+                                return -EOPNOTSUPP;
+                        }
+                }
                 id->bus_hold_flag = 1;
                 reg = cdns_i2c_readreg(CDNS_I2C_CR_OFFSET);
                 reg |= CDNS_I2C_CR_HOLD;
diff --git a/drivers/i2c/busses/i2c-designware-baytrail.c b/drivers/i2c/busses/i2c-designware-baytrail.c
new file mode 100644
index 000000000000..5f1ff4cc5c34
--- /dev/null
+++ b/drivers/i2c/busses/i2c-designware-baytrail.c
@@ -0,0 +1,160 @@
+/*
+ * Intel BayTrail PMIC I2C bus semaphore implementaion
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * 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.
+ */
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/acpi.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <asm/iosf_mbi.h>
+#include "i2c-designware-core.h"
+
+#define SEMAPHORE_TIMEOUT       100
+#define PUNIT_SEMAPHORE         0x7
+
+static unsigned long acquired;
+
+static int get_sem(struct device *dev, u32 *sem)
+{
+        u32 reg_val;
+        int ret;
+
+        ret = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ, PUNIT_SEMAPHORE,
+                            &reg_val);
+        if (ret) {
+                dev_err(dev, "iosf failed to read punit semaphore\n");
+                return ret;
+        }
+
+        *sem = reg_val & 0x1;
+
+        return 0;
+}
+
+static void reset_semaphore(struct device *dev)
+{
+        u32 data;
+
+        if (iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
+                                PUNIT_SEMAPHORE, &data)) {
+                dev_err(dev, "iosf failed to reset punit semaphore during read\n");
+                return;
+        }
+
+        data = data & 0xfffffffe;
+        if (iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
+                                 PUNIT_SEMAPHORE, data))
+                dev_err(dev, "iosf failed to reset punit semaphore during write\n");
+}
+
+int baytrail_i2c_acquire(struct dw_i2c_dev *dev)
+{
+        u32 sem = 0;
+        int ret;
+        unsigned long start, end;
+
+        if (!dev || !dev->dev)
+                return -ENODEV;
+
+        if (!dev->acquire_lock)
+                return 0;
+
+        /* host driver writes 0x2 to side band semaphore register */
+        ret = iosf_mbi_write(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_WRITE,
+                                 PUNIT_SEMAPHORE, 0x2);
+        if (ret) {
+                dev_err(dev->dev, "iosf punit semaphore request failed\n");
+                return ret;
+        }
+
+        /* host driver waits for bit 0 to be set in semaphore register */
+        start = jiffies;
+        end = start + msecs_to_jiffies(SEMAPHORE_TIMEOUT);
+        while (!time_after(jiffies, end)) {
+                ret = get_sem(dev->dev, &sem);
+                if (!ret && sem) {
+                        acquired = jiffies;
+                        dev_dbg(dev->dev, "punit semaphore acquired after %ums\n",
+                                jiffies_to_msecs(jiffies - start));
+                        return 0;
+                }
+
+                usleep_range(1000, 2000);
+        }
+
+        dev_err(dev->dev, "punit semaphore timed out, resetting\n");
+        reset_semaphore(dev->dev);
+
+        ret = iosf_mbi_read(BT_MBI_UNIT_PMC, BT_MBI_BUNIT_READ,
+                PUNIT_SEMAPHORE, &sem);
+        if (!ret)
+                dev_err(dev->dev, "iosf failed to read punit semaphore\n");
+        else
+                dev_err(dev->dev, "PUNIT SEM: %d\n", sem);
+
+        WARN_ON(1);
+
+        return -ETIMEDOUT;
+}
+EXPORT_SYMBOL(baytrail_i2c_acquire);
+
+void baytrail_i2c_release(struct dw_i2c_dev *dev)
+{
+        if (!dev || !dev->dev)
+                return;
+
+        if (!dev->acquire_lock)
+                return;
+
+        reset_semaphore(dev->dev);
+        dev_dbg(dev->dev, "punit semaphore held for %ums\n",
+                jiffies_to_msecs(jiffies - acquired));
+}
+EXPORT_SYMBOL(baytrail_i2c_release);
+
+int i2c_dw_eval_lock_support(struct dw_i2c_dev *dev)
+{
+        acpi_status status;
+        unsigned long long shared_host = 0;
+        acpi_handle handle;
+
+        if (!dev || !dev->dev)
+                return 0;
+
+        handle = ACPI_HANDLE(dev->dev);
+        if (!handle)
+                return 0;
+
+        status = acpi_evaluate_integer(handle, "_SEM", NULL, &shared_host);
+
+        if (ACPI_FAILURE(status))
+                return 0;
+
+        if (shared_host) {
+                dev_info(dev->dev, "I2C bus managed by PUNIT\n");
+                dev->acquire_lock = baytrail_i2c_acquire;
+                dev->release_lock = baytrail_i2c_release;
+                dev->pm_runtime_disabled = true;
+        }
+
+        if (!iosf_mbi_available())
+                return -EPROBE_DEFER;
+
+        return 0;
+}
+EXPORT_SYMBOL(i2c_dw_eval_lock_support);
+
+MODULE_AUTHOR("David E. Box <david.e.box@linux.intel.com>");
+MODULE_DESCRIPTION("Baytrail I2C Semaphore driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/i2c/busses/i2c-designware-core.c b/drivers/i2c/busses/i2c-designware-core.c
index 23628b7bfb8d..6e25c010e690 100644
--- a/drivers/i2c/busses/i2c-designware-core.c
+++ b/drivers/i2c/busses/i2c-designware-core.c
@@ -170,10 +170,10 @@ u32 dw_readl(struct dw_i2c_dev *dev, int offset)
         u32 value;
 
         if (dev->accessor_flags & ACCESS_16BIT)
-                value = readw(dev->base + offset) |
-                        (readw(dev->base + offset + 2) << 16);
+                value = readw_relaxed(dev->base + offset) |
+                        (readw_relaxed(dev->base + offset + 2) << 16);
         else
-                value = readl(dev->base + offset);
+                value = readl_relaxed(dev->base + offset);
 
         if (dev->accessor_flags & ACCESS_SWAP)
                 return swab32(value);
@@ -187,10 +187,10 @@ void dw_writel(struct dw_i2c_dev *dev, u32 b, int offset)
                 b = swab32(b);
 
         if (dev->accessor_flags & ACCESS_16BIT) {
-                writew((u16)b, dev->base + offset);
-                writew((u16)(b >> 16), dev->base + offset + 2);
+                writew_relaxed((u16)b, dev->base + offset);
+                writew_relaxed((u16)(b >> 16), dev->base + offset + 2);
         } else {
-                writel(b, dev->base + offset);
+                writel_relaxed(b, dev->base + offset);
         }
 }
 
@@ -285,6 +285,15 @@ int i2c_dw_init(struct dw_i2c_dev *dev)
         u32 hcnt, lcnt;
         u32 reg;
         u32 sda_falling_time, scl_falling_time;
+        int ret;
+
+        if (dev->acquire_lock) {
+                ret = dev->acquire_lock(dev);
+                if (ret) {
+                        dev_err(dev->dev, "couldn't acquire bus ownership\n");
+                        return ret;
+                }
+        }
 
         input_clock_khz = dev->get_clk_rate_khz(dev);
 
@@ -298,6 +307,8 @@ int i2c_dw_init(struct dw_i2c_dev *dev)
         } else if (reg != DW_IC_COMP_TYPE_VALUE) {
                 dev_err(dev->dev, "Unknown Synopsys component type: "
                         "0x%08x\n", reg);
+                if (dev->release_lock)
+                        dev->release_lock(dev);
                 return -ENODEV;
         }
 
@@ -309,40 +320,39 @@ int i2c_dw_init(struct dw_i2c_dev *dev)
         sda_falling_time = dev->sda_falling_time ?: 300; /* ns */
         scl_falling_time = dev->scl_falling_time ?: 300; /* ns */
 
-        /* Standard-mode */
-        hcnt = i2c_dw_scl_hcnt(input_clock_khz,
-                                4000,   /* tHD;STA = tHIGH = 4.0 us */
-                                sda_falling_time,
-                                0,      /* 0: DW default, 1: Ideal */
-                                0);     /* No offset */
-        lcnt = i2c_dw_scl_lcnt(input_clock_khz,
-                                4700,   /* tLOW = 4.7 us */
-                                scl_falling_time,
-                                0);     /* No offset */
-
-        /* Allow platforms to specify the ideal HCNT and LCNT values */
+        /* Set SCL timing parameters for standard-mode */
         if (dev->ss_hcnt && dev->ss_lcnt) {
                 hcnt = dev->ss_hcnt;
                 lcnt = dev->ss_lcnt;
+        } else {
+                hcnt = i2c_dw_scl_hcnt(input_clock_khz,
+                                        4000,   /* tHD;STA = tHIGH = 4.0 us */
+                                        sda_falling_time,
+                                        0,      /* 0: DW default, 1: Ideal */
+                                        0);     /* No offset */
+                lcnt = i2c_dw_scl_lcnt(input_clock_khz,
+                                        4700,   /* tLOW = 4.7 us */
+                                        scl_falling_time,
+                                        0);     /* No offset */
         }
         dw_writel(dev, hcnt, DW_IC_SS_SCL_HCNT);
         dw_writel(dev, lcnt, DW_IC_SS_SCL_LCNT);
         dev_dbg(dev->dev, "Standard-mode HCNT:LCNT = %d:%d\n", hcnt, lcnt);
 
-        /* Fast-mode */
-        hcnt = i2c_dw_scl_hcnt(input_clock_khz,
-                                600,    /* tHD;STA = tHIGH = 0.6 us */
-                                sda_falling_time,
-                                0,      /* 0: DW default, 1: Ideal */
-                                0);     /* No offset */
-        lcnt = i2c_dw_scl_lcnt(input_clock_khz,
-                                1300,   /* tLOW = 1.3 us */
-                                scl_falling_time,
-                                0);     /* No offset */
-
+        /* Set SCL timing parameters for fast-mode */
         if (dev->fs_hcnt && dev->fs_lcnt) {
                 hcnt = dev->fs_hcnt;
                 lcnt = dev->fs_lcnt;
+        } else {
+                hcnt = i2c_dw_scl_hcnt(input_clock_khz,
+                                        600,    /* tHD;STA = tHIGH = 0.6 us */
+                                        sda_falling_time,
+                                        0,      /* 0: DW default, 1: Ideal */
+                                        0);     /* No offset */
+                lcnt = i2c_dw_scl_lcnt(input_clock_khz,
+                                        1300,   /* tLOW = 1.3 us */
+                                        scl_falling_time,
+                                        0);     /* No offset */
         }
         dw_writel(dev, hcnt, DW_IC_FS_SCL_HCNT);
         dw_writel(dev, lcnt, DW_IC_FS_SCL_LCNT);
@@ -364,6 +374,9 @@ int i2c_dw_init(struct dw_i2c_dev *dev)
 
         /* configure the i2c master */
         dw_writel(dev, dev->master_cfg , DW_IC_CON);
+
+        if (dev->release_lock)
+                dev->release_lock(dev);
         return 0;
 }
 EXPORT_SYMBOL_GPL(i2c_dw_init);
@@ -627,6 +640,14 @@ i2c_dw_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
         dev->abort_source = 0;
         dev->rx_outstanding = 0;
 
+        if (dev->acquire_lock) {
+                ret = dev->acquire_lock(dev);
+                if (ret) {
+                        dev_err(dev->dev, "couldn't acquire bus ownership\n");
+                        goto done_nolock;
+                }
+        }
+
         ret = i2c_dw_wait_bus_not_busy(dev);
         if (ret < 0)
                 goto done;
@@ -672,6 +693,10 @@ i2c_dw_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
         ret = -EIO;
 
 done:
+        if (dev->release_lock)
+                dev->release_lock(dev);
+
+done_nolock:
         pm_runtime_mark_last_busy(dev->dev);
         pm_runtime_put_autosuspend(dev->dev);
         mutex_unlock(&dev->lock);
diff --git a/drivers/i2c/busses/i2c-designware-core.h b/drivers/i2c/busses/i2c-designware-core.h
index 5a410ef17abd..9630222abf32 100644
--- a/drivers/i2c/busses/i2c-designware-core.h
+++ b/drivers/i2c/busses/i2c-designware-core.h
@@ -61,6 +61,9 @@
  * @ss_lcnt: standard speed LCNT value
  * @fs_hcnt: fast speed HCNT value
  * @fs_lcnt: fast speed LCNT value
+ * @acquire_lock: function to acquire a hardware lock on the bus
+ * @release_lock: function to release a hardware lock on the bus
+ * @pm_runtime_disabled: true if pm runtime is disabled
  *
  * HCNT and LCNT parameters can be used if the platform knows more accurate
  * values than the one computed based only on the input clock frequency.
@@ -101,6 +104,9 @@ struct dw_i2c_dev {
         u16                     ss_lcnt;
         u16                     fs_hcnt;
         u16                     fs_lcnt;
+        int                     (*acquire_lock)(struct dw_i2c_dev *dev);
+        void                    (*release_lock)(struct dw_i2c_dev *dev);
+        bool                    pm_runtime_disabled;
 };
 
 #define ACCESS_SWAP             0x00000001
@@ -119,3 +125,9 @@ extern void i2c_dw_disable(struct dw_i2c_dev *dev);
 extern void i2c_dw_clear_int(struct dw_i2c_dev *dev);
 extern void i2c_dw_disable_int(struct dw_i2c_dev *dev);
 extern u32 i2c_dw_read_comp_param(struct dw_i2c_dev *dev);
+
+#if IS_ENABLED(CONFIG_I2C_DESIGNWARE_BAYTRAIL)
+extern int i2c_dw_eval_lock_support(struct dw_i2c_dev *dev);
+#else
+static inline int i2c_dw_eval_lock_support(struct dw_i2c_dev *dev) { return 0; }
+#endif
diff --git a/drivers/i2c/busses/i2c-designware-pcidrv.c b/drivers/i2c/busses/i2c-designware-pcidrv.c
index acb40f95db78..6643d2dc0b25 100644
--- a/drivers/i2c/busses/i2c-designware-pcidrv.c
+++ b/drivers/i2c/busses/i2c-designware-pcidrv.c
@@ -6,7 +6,7 @@
  * Copyright (C) 2006 Texas Instruments.
  * Copyright (C) 2007 MontaVista Software Inc.
  * Copyright (C) 2009 Provigent Ltd.
- * Copyright (C) 2011 Intel corporation.
+ * Copyright (C) 2011, 2015 Intel Corporation.
  *
  * ----------------------------------------------------------------------------
  *
@@ -40,10 +40,6 @@
 #define DRIVER_NAME "i2c-designware-pci"
 
 enum dw_pci_ctl_id_t {
-        moorestown_0,
-        moorestown_1,
-        moorestown_2,
-
         medfield_0,
         medfield_1,
         medfield_2,
@@ -101,28 +97,7 @@ static struct dw_scl_sda_cfg hsw_config = {
         .sda_hold = 0x9,
 };
 
-static struct  dw_pci_controller  dw_pci_controllers[] = {
-        [moorestown_0] = {
-                .bus_num     = 0,
-                .bus_cfg   = INTEL_MID_STD_CFG | DW_IC_CON_SPEED_FAST,
-                .tx_fifo_depth = 32,
-                .rx_fifo_depth = 32,
-                .clk_khz      = 25000,
-        },
-        [moorestown_1] = {
-                .bus_num     = 1,
-                .bus_cfg   = INTEL_MID_STD_CFG | DW_IC_CON_SPEED_FAST,
-                .tx_fifo_depth = 32,
-                .rx_fifo_depth = 32,
-                .clk_khz      = 25000,
-        },
-        [moorestown_2] = {
-                .bus_num     = 2,
-                .bus_cfg   = INTEL_MID_STD_CFG | DW_IC_CON_SPEED_FAST,
-                .tx_fifo_depth = 32,
-                .rx_fifo_depth = 32,
-                .clk_khz      = 25000,
-        },
+static struct dw_pci_controller dw_pci_controllers[] = {
         [medfield_0] = {
                 .bus_num     = 0,
                 .bus_cfg   = INTEL_MID_STD_CFG | DW_IC_CON_SPEED_FAST,
@@ -170,7 +145,6 @@ static struct  dw_pci_controller  dw_pci_controllers[] = {
                 .bus_cfg = INTEL_MID_STD_CFG | DW_IC_CON_SPEED_FAST,
                 .tx_fifo_depth = 32,
                 .rx_fifo_depth = 32,
-                .clk_khz = 100000,
                 .functionality = I2C_FUNC_10BIT_ADDR,
                 .scl_sda_cfg = &byt_config,
         },
@@ -179,7 +153,6 @@ static struct  dw_pci_controller  dw_pci_controllers[] = {
                 .bus_cfg = INTEL_MID_STD_CFG | DW_IC_CON_SPEED_FAST,
                 .tx_fifo_depth = 32,
                 .rx_fifo_depth = 32,
-                .clk_khz = 100000,
                 .functionality = I2C_FUNC_10BIT_ADDR,
                 .scl_sda_cfg = &hsw_config,
         },
@@ -259,7 +232,7 @@ static int i2c_dw_pci_probe(struct pci_dev *pdev,
         dev->functionality = controller->functionality |
                                 DW_DEFAULT_FUNCTIONALITY;
 
-        dev->master_cfg =  controller->bus_cfg;
+        dev->master_cfg = controller->bus_cfg;
         if (controller->scl_sda_cfg) {
                 cfg = controller->scl_sda_cfg;
                 dev->ss_hcnt = cfg->ss_hcnt;
@@ -325,12 +298,8 @@ static void i2c_dw_pci_remove(struct pci_dev *pdev)
 MODULE_ALIAS("i2c_designware-pci");
 
 static const struct pci_device_id i2_designware_pci_ids[] = {
-        /* Moorestown */
-        { PCI_VDEVICE(INTEL, 0x0802), moorestown_0 },
-        { PCI_VDEVICE(INTEL, 0x0803), moorestown_1 },
-        { PCI_VDEVICE(INTEL, 0x0804), moorestown_2 },
         /* Medfield */
-        { PCI_VDEVICE(INTEL, 0x0817), medfield_3,},
+        { PCI_VDEVICE(INTEL, 0x0817), medfield_3 },
         { PCI_VDEVICE(INTEL, 0x0818), medfield_4 },
         { PCI_VDEVICE(INTEL, 0x0819), medfield_5 },
         { PCI_VDEVICE(INTEL, 0x082C), medfield_0 },
@@ -348,7 +317,7 @@ static const struct pci_device_id i2_designware_pci_ids[] = {
         { PCI_VDEVICE(INTEL, 0x9c61), haswell },
         { PCI_VDEVICE(INTEL, 0x9c62), haswell },
         /* Braswell / Cherrytrail */
-        { PCI_VDEVICE(INTEL, 0x22C1), baytrail,},
+        { PCI_VDEVICE(INTEL, 0x22C1), baytrail },
         { PCI_VDEVICE(INTEL, 0x22C2), baytrail },
         { PCI_VDEVICE(INTEL, 0x22C3), baytrail },
         { PCI_VDEVICE(INTEL, 0x22C4), baytrail },
diff --git a/drivers/i2c/busses/i2c-designware-platdrv.c b/drivers/i2c/busses/i2c-designware-platdrv.c
index 2b463c313e4e..c270f5f9a8f9 100644
--- a/drivers/i2c/busses/i2c-designware-platdrv.c
+++ b/drivers/i2c/busses/i2c-designware-platdrv.c
@@ -195,6 +195,10 @@ static int dw_i2c_probe(struct platform_device *pdev)
                         clk_freq = pdata->i2c_scl_freq;
         }
 
+        r = i2c_dw_eval_lock_support(dev);
+        if (r)
+                return r;
+
         dev->functionality =
                 I2C_FUNC_I2C |
                 I2C_FUNC_10BIT_ADDR |
@@ -257,10 +261,14 @@ static int dw_i2c_probe(struct platform_device *pdev)
                 return r;
         }
 
-        pm_runtime_set_autosuspend_delay(&pdev->dev, 1000);
-        pm_runtime_use_autosuspend(&pdev->dev);
-        pm_runtime_set_active(&pdev->dev);
-        pm_runtime_enable(&pdev->dev);
+        if (dev->pm_runtime_disabled) {
+                pm_runtime_forbid(&pdev->dev);
+        } else {
+                pm_runtime_set_autosuspend_delay(&pdev->dev, 1000);
+                pm_runtime_use_autosuspend(&pdev->dev);
+                pm_runtime_set_active(&pdev->dev);
+                pm_runtime_enable(&pdev->dev);
+        }
 
         return 0;
 }
@@ -310,7 +318,9 @@ static int dw_i2c_resume(struct device *dev)
         struct dw_i2c_dev *i_dev = platform_get_drvdata(pdev);
 
         clk_prepare_enable(i_dev->clk);
-        i2c_dw_init(i_dev);
+
+        if (!i_dev->pm_runtime_disabled)
+                i2c_dw_init(i_dev);
 
         return 0;
 }
diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c
index 7f3a9fe9bf4e..d7b26fc6f432 100644
--- a/drivers/i2c/busses/i2c-imx.c
+++ b/drivers/i2c/busses/i2c-imx.c
@@ -201,7 +201,7 @@ struct imx_i2c_struct {
         void __iomem            *base;
         wait_queue_head_t       queue;
         unsigned long           i2csr;
-        unsigned int            disable_delay;
+        unsigned int            disable_delay;
         int                     stopped;
         unsigned int            ifdr; /* IMX_I2C_IFDR */
         unsigned int            cur_clk;
@@ -295,7 +295,6 @@ static void i2c_imx_dma_request(struct imx_i2c_struct *i2c_imx,
         dma->chan_tx = dma_request_slave_channel(dev, "tx");
         if (!dma->chan_tx) {
                 dev_dbg(dev, "can't request DMA tx channel\n");
-                ret = -ENODEV;
                 goto fail_al;
         }
 
@@ -313,7 +312,6 @@ static void i2c_imx_dma_request(struct imx_i2c_struct *i2c_imx,
         dma->chan_rx = dma_request_slave_channel(dev, "rx");
         if (!dma->chan_rx) {
                 dev_dbg(dev, "can't request DMA rx channel\n");
-                ret = -ENODEV;
                 goto fail_tx;
         }
 
@@ -481,8 +479,8 @@ static void i2c_imx_set_clk(struct imx_i2c_struct *i2c_imx)
         i2c_clk_rate = clk_get_rate(i2c_imx->clk);
         if (i2c_imx->cur_clk == i2c_clk_rate)
                 return;
-        else
-                i2c_imx->cur_clk = i2c_clk_rate;
+
+        i2c_imx->cur_clk = i2c_clk_rate;
 
         div = (i2c_clk_rate + i2c_imx->bitrate - 1) / i2c_imx->bitrate;
         if (div < i2c_clk_div[0].div)
@@ -490,7 +488,8 @@ static void i2c_imx_set_clk(struct imx_i2c_struct *i2c_imx)
         else if (div > i2c_clk_div[i2c_imx->hwdata->ndivs - 1].div)
                 i = i2c_imx->hwdata->ndivs - 1;
         else
-                for (i = 0; i2c_clk_div[i].div < div; i++);
+                for (i = 0; i2c_clk_div[i].div < div; i++)
+                        ;
 
         /* Store divider value */
         i2c_imx->ifdr = i2c_clk_div[i].val;
@@ -628,9 +627,9 @@ static int i2c_imx_dma_write(struct imx_i2c_struct *i2c_imx,
         result = wait_for_completion_timeout(
                                 &i2c_imx->dma->cmd_complete,
                                 msecs_to_jiffies(DMA_TIMEOUT));
-        if (result <= 0) {
+        if (result == 0) {
                 dmaengine_terminate_all(dma->chan_using);
-                return result ?: -ETIMEDOUT;
+                return -ETIMEDOUT;
         }
 
         /* Waiting for transfer complete. */
@@ -686,9 +685,9 @@ static int i2c_imx_dma_read(struct imx_i2c_struct *i2c_imx,
         result = wait_for_completion_timeout(
                                 &i2c_imx->dma->cmd_complete,
                                 msecs_to_jiffies(DMA_TIMEOUT));
-        if (result <= 0) {
+        if (result == 0) {
                 dmaengine_terminate_all(dma->chan_using);
-                return result ?: -ETIMEDOUT;
+                return -ETIMEDOUT;
         }
 
         /* waiting for transfer complete. */
@@ -822,6 +821,7 @@ static int i2c_imx_read(struct imx_i2c_struct *i2c_imx, struct i2c_msg *msgs, bo
         /* read data */
         for (i = 0; i < msgs->len; i++) {
                 u8 len = 0;
+
                 result = i2c_imx_trx_complete(i2c_imx);
                 if (result)
                         return result;
@@ -917,15 +917,16 @@ static int i2c_imx_xfer(struct i2c_adapter *adapter,
                 /* write/read data */
 #ifdef CONFIG_I2C_DEBUG_BUS
                 temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
-                dev_dbg(&i2c_imx->adapter.dev, "<%s> CONTROL: IEN=%d, IIEN=%d, "
-                        "MSTA=%d, MTX=%d, TXAK=%d, RSTA=%d\n", __func__,
+                dev_dbg(&i2c_imx->adapter.dev,
+                        "<%s> CONTROL: IEN=%d, IIEN=%d, MSTA=%d, MTX=%d, TXAK=%d, RSTA=%d\n",
+                        __func__,
                         (temp & I2CR_IEN ? 1 : 0), (temp & I2CR_IIEN ? 1 : 0),
                         (temp & I2CR_MSTA ? 1 : 0), (temp & I2CR_MTX ? 1 : 0),
                         (temp & I2CR_TXAK ? 1 : 0), (temp & I2CR_RSTA ? 1 : 0));
                 temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
                 dev_dbg(&i2c_imx->adapter.dev,
-                        "<%s> STATUS: ICF=%d, IAAS=%d, IBB=%d, "
-                        "IAL=%d, SRW=%d, IIF=%d, RXAK=%d\n", __func__,
+                        "<%s> STATUS: ICF=%d, IAAS=%d, IBB=%d, IAL=%d, SRW=%d, IIF=%d, RXAK=%d\n",
+                        __func__,
                         (temp & I2SR_ICF ? 1 : 0), (temp & I2SR_IAAS ? 1 : 0),
                         (temp & I2SR_IBB ? 1 : 0), (temp & I2SR_IAL ? 1 : 0),
                         (temp & I2SR_SRW ? 1 : 0), (temp & I2SR_IIF ? 1 : 0),
@@ -1004,7 +1005,7 @@ static int i2c_imx_probe(struct platform_device *pdev)
         i2c_imx->adapter.owner          = THIS_MODULE;
         i2c_imx->adapter.algo           = &i2c_imx_algo;
         i2c_imx->adapter.dev.parent     = &pdev->dev;
-        i2c_imx->adapter.nr             = pdev->id;
+        i2c_imx->adapter.nr             = pdev->id;
         i2c_imx->adapter.dev.of_node    = pdev->dev.of_node;
         i2c_imx->base                   = base;
 
@@ -1063,7 +1064,7 @@ static int i2c_imx_probe(struct platform_device *pdev)
                 i2c_imx->adapter.name);
         dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n");
 
-        /* Init DMA config if support*/
+        /* Init DMA config if supported */
         i2c_imx_dma_request(i2c_imx, phy_addr);
 
         return 0;   /* Return OK */
diff --git a/drivers/i2c/busses/i2c-ocores.c b/drivers/i2c/busses/i2c-ocores.c
index 7249b5b1e5d0..abf5db7e441e 100644
--- a/drivers/i2c/busses/i2c-ocores.c
+++ b/drivers/i2c/busses/i2c-ocores.c
@@ -12,6 +12,7 @@
  * kind, whether express or implied.
  */
 
+#include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -35,7 +36,9 @@ struct ocores_i2c {
         int pos;
         int nmsgs;
         int state; /* see STATE_ */
-        int clock_khz;
+        struct clk *clk;
+        int ip_clock_khz;
+        int bus_clock_khz;
         void (*setreg)(struct ocores_i2c *i2c, int reg, u8 value);
         u8 (*getreg)(struct ocores_i2c *i2c, int reg);
 };
@@ -215,21 +218,34 @@ static int ocores_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
                 return -ETIMEDOUT;
 }
 
-static void ocores_init(struct ocores_i2c *i2c)
+static int ocores_init(struct device *dev, struct ocores_i2c *i2c)
 {
         int prescale;
+        int diff;
         u8 ctrl = oc_getreg(i2c, OCI2C_CONTROL);
 
         /* make sure the device is disabled */
         oc_setreg(i2c, OCI2C_CONTROL, ctrl & ~(OCI2C_CTRL_EN|OCI2C_CTRL_IEN));
 
-        prescale = (i2c->clock_khz / (5*100)) - 1;
+        prescale = (i2c->ip_clock_khz / (5 * i2c->bus_clock_khz)) - 1;
+        prescale = clamp(prescale, 0, 0xffff);
+
+        diff = i2c->ip_clock_khz / (5 * (prescale + 1)) - i2c->bus_clock_khz;
+        if (abs(diff) > i2c->bus_clock_khz / 10) {
+                dev_err(dev,
+                        "Unsupported clock settings: core: %d KHz, bus: %d KHz\n",
+                        i2c->ip_clock_khz, i2c->bus_clock_khz);
+                return -EINVAL;
+        }
+
         oc_setreg(i2c, OCI2C_PRELOW, prescale & 0xff);
         oc_setreg(i2c, OCI2C_PREHIGH, prescale >> 8);
 
         /* Init the device */
         oc_setreg(i2c, OCI2C_CMD, OCI2C_CMD_IACK);
         oc_setreg(i2c, OCI2C_CONTROL, ctrl | OCI2C_CTRL_IEN | OCI2C_CTRL_EN);
+
+        return 0;
 }
 
 
@@ -304,6 +320,8 @@ static int ocores_i2c_of_probe(struct platform_device *pdev,
         struct device_node *np = pdev->dev.of_node;
         const struct of_device_id *match;
         u32 val;
+        u32 clock_frequency;
+        bool clock_frequency_present;
 
         if (of_property_read_u32(np, "reg-shift", &i2c->reg_shift)) {
                 /* no 'reg-shift', check for deprecated 'regstep' */
@@ -319,12 +337,42 @@ static int ocores_i2c_of_probe(struct platform_device *pdev,
                 }
         }
 
-        if (of_property_read_u32(np, "clock-frequency", &val)) {
-                dev_err(&pdev->dev,
-                        "Missing required parameter 'clock-frequency'\n");
-                return -ENODEV;
+        clock_frequency_present = !of_property_read_u32(np, "clock-frequency",
+                                                        &clock_frequency);
+        i2c->bus_clock_khz = 100;
+
+        i2c->clk = devm_clk_get(&pdev->dev, NULL);
+
+        if (!IS_ERR(i2c->clk)) {
+                int ret = clk_prepare_enable(i2c->clk);
+
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "clk_prepare_enable failed: %d\n", ret);
+                        return ret;
+                }
+                i2c->ip_clock_khz = clk_get_rate(i2c->clk) / 1000;
+                if (clock_frequency_present)
+                        i2c->bus_clock_khz = clock_frequency / 1000;
+        }
+
+        if (i2c->ip_clock_khz == 0) {
+                if (of_property_read_u32(np, "opencores,ip-clock-frequency",
+                                                &val)) {
+                        if (!clock_frequency_present) {
+                                dev_err(&pdev->dev,
+                                        "Missing required parameter 'opencores,ip-clock-frequency'\n");
+                                return -ENODEV;
+                        }
+                        i2c->ip_clock_khz = clock_frequency / 1000;
+                        dev_warn(&pdev->dev,
+                                 "Deprecated usage of the 'clock-frequency' property, please update to 'opencores,ip-clock-frequency'\n");
+                } else {
+                        i2c->ip_clock_khz = val / 1000;
+                        if (clock_frequency_present)
+                                i2c->bus_clock_khz = clock_frequency / 1000;
+                }
         }
-        i2c->clock_khz = val / 1000;
 
         of_property_read_u32(pdev->dev.of_node, "reg-io-width",
                                 &i2c->reg_io_width);
@@ -368,7 +416,8 @@ static int ocores_i2c_probe(struct platform_device *pdev)
         if (pdata) {
                 i2c->reg_shift = pdata->reg_shift;
                 i2c->reg_io_width = pdata->reg_io_width;
-                i2c->clock_khz = pdata->clock_khz;
+                i2c->ip_clock_khz = pdata->clock_khz;
+                i2c->bus_clock_khz = 100;
         } else {
                 ret = ocores_i2c_of_probe(pdev, i2c);
                 if (ret)
@@ -402,7 +451,9 @@ static int ocores_i2c_probe(struct platform_device *pdev)
                 }
         }
 
-        ocores_init(i2c);
+        ret = ocores_init(&pdev->dev, i2c);
+        if (ret)
+                return ret;
 
         init_waitqueue_head(&i2c->wait);
         ret = devm_request_irq(&pdev->dev, irq, ocores_isr, 0,
@@ -446,6 +497,9 @@ static int ocores_i2c_remove(struct platform_device *pdev)
         /* remove adapter & data */
         i2c_del_adapter(&i2c->adap);
 
+        if (!IS_ERR(i2c->clk))
+                clk_disable_unprepare(i2c->clk);
+
         return 0;
 }
 
@@ -458,6 +512,8 @@ static int ocores_i2c_suspend(struct device *dev)
         /* make sure the device is disabled */
         oc_setreg(i2c, OCI2C_CONTROL, ctrl & ~(OCI2C_CTRL_EN|OCI2C_CTRL_IEN));
 
+        if (!IS_ERR(i2c->clk))
+                clk_disable_unprepare(i2c->clk);
         return 0;
 }
 
@@ -465,9 +521,20 @@ static int ocores_i2c_resume(struct device *dev)
 {
         struct ocores_i2c *i2c = dev_get_drvdata(dev);
 
-        ocores_init(i2c);
+        if (!IS_ERR(i2c->clk)) {
+                unsigned long rate;
+                int ret = clk_prepare_enable(i2c->clk);
 
-        return 0;
+                if (ret) {
+                        dev_err(dev,
+                                "clk_prepare_enable failed: %d\n", ret);
+                        return ret;
+                }
+                rate = clk_get_rate(i2c->clk) / 1000;
+                if (rate)
+                        i2c->ip_clock_khz = rate;
+        }
+        return ocores_init(dev, i2c);
 }
 
 static SIMPLE_DEV_PM_OPS(ocores_i2c_pm, ocores_i2c_suspend, ocores_i2c_resume);
diff --git a/drivers/i2c/busses/i2c-pmcmsp.c b/drivers/i2c/busses/i2c-pmcmsp.c
index 44f03eed00dd..d37d9db6681e 100644
--- a/drivers/i2c/busses/i2c-pmcmsp.c
+++ b/drivers/i2c/busses/i2c-pmcmsp.c
@@ -148,13 +148,6 @@ static inline u32 pmcmsptwi_clock_to_reg(
         return ((clock->filter & 0xf) << 12) | (clock->clock & 0x03ff);
 }
 
-static inline void pmcmsptwi_reg_to_clock(
-                        u32 reg, struct pmcmsptwi_clock *clock)
-{
-        clock->filter = (reg >> 12) & 0xf;
-        clock->clock = reg & 0x03ff;
-}
-
 static inline u32 pmcmsptwi_cfg_to_reg(const struct pmcmsptwi_cfg *cfg)
 {
         return ((cfg->arbf & 0xf) << 12) |
diff --git a/drivers/i2c/busses/i2c-rk3x.c b/drivers/i2c/busses/i2c-rk3x.c
index 92462843db66..5f96b1b3e3a5 100644
--- a/drivers/i2c/busses/i2c-rk3x.c
+++ b/drivers/i2c/busses/i2c-rk3x.c
@@ -102,6 +102,9 @@ struct rk3x_i2c {
 
         /* Settings */
         unsigned int scl_frequency;
+        unsigned int scl_rise_ns;
+        unsigned int scl_fall_ns;
+        unsigned int sda_fall_ns;
 
         /* Synchronization & notification */
         spinlock_t lock;
@@ -435,6 +438,9 @@ out:
  *
  * @clk_rate: I2C input clock rate
  * @scl_rate: Desired SCL rate
+ * @scl_rise_ns: How many ns it takes for SCL to rise.
+ * @scl_fall_ns: How many ns it takes for SCL to fall.
+ * @sda_fall_ns: How many ns it takes for SDA to fall.
  * @div_low: Divider output for low
  * @div_high: Divider output for high
  *
@@ -443,11 +449,16 @@ out:
  * too high, we silently use the highest possible rate.
  */
 static int rk3x_i2c_calc_divs(unsigned long clk_rate, unsigned long scl_rate,
+                              unsigned long scl_rise_ns,
+                              unsigned long scl_fall_ns,
+                              unsigned long sda_fall_ns,
                               unsigned long *div_low, unsigned long *div_high)
 {
-        unsigned long min_low_ns, min_high_ns;
-        unsigned long max_data_hold_ns;
+        unsigned long spec_min_low_ns, spec_min_high_ns;
+        unsigned long spec_setup_start, spec_max_data_hold_ns;
         unsigned long data_hold_buffer_ns;
+
+        unsigned long min_low_ns, min_high_ns;
         unsigned long max_low_ns, min_total_ns;
 
         unsigned long clk_rate_khz, scl_rate_khz;
@@ -469,29 +480,50 @@ static int rk3x_i2c_calc_divs(unsigned long clk_rate, unsigned long scl_rate,
                 scl_rate = 1000;
 
         /*
-         * min_low_ns:  The minimum number of ns we need to hold low
-         *              to meet i2c spec
-         * min_high_ns: The minimum number of ns we need to hold high
-         *              to meet i2c spec
-         * max_low_ns:  The maximum number of ns we can hold low
-         *              to meet i2c spec
+         * min_low_ns:  The minimum number of ns we need to hold low to
+         *              meet I2C specification, should include fall time.
+         * min_high_ns: The minimum number of ns we need to hold high to
+         *              meet I2C specification, should include rise time.
+         * max_low_ns:  The maximum number of ns we can hold low to meet
+         *              I2C specification.
          *
-         * Note: max_low_ns should be (max data hold time * 2 - buffer)
+         * Note: max_low_ns should be (maximum data hold time * 2 - buffer)
          *       This is because the i2c host on Rockchip holds the data line
          *       for half the low time.
          */
         if (scl_rate <= 100000) {
-                min_low_ns = 4700;
-                min_high_ns = 4000;
-                max_data_hold_ns = 3450;
+                /* Standard-mode */
+                spec_min_low_ns = 4700;
+                spec_setup_start = 4700;
+                spec_min_high_ns = 4000;
+                spec_max_data_hold_ns = 3450;
                 data_hold_buffer_ns = 50;
         } else {
-                min_low_ns = 1300;
-                min_high_ns = 600;
-                max_data_hold_ns = 900;
+                /* Fast-mode */
+                spec_min_low_ns = 1300;
+                spec_setup_start = 600;
+                spec_min_high_ns = 600;
+                spec_max_data_hold_ns = 900;
                 data_hold_buffer_ns = 50;
         }
-        max_low_ns = max_data_hold_ns * 2 - data_hold_buffer_ns;
+        min_high_ns = scl_rise_ns + spec_min_high_ns;
+
+        /*
+         * Timings for repeated start:
+         * - controller appears to drop SDA at .875x (7/8) programmed clk high.
+         * - controller appears to keep SCL high for 2x programmed clk high.
+         *
+         * We need to account for those rules in picking our "high" time so
+         * we meet tSU;STA and tHD;STA times.
+         */
+        min_high_ns = max(min_high_ns,
+                DIV_ROUND_UP((scl_rise_ns + spec_setup_start) * 1000, 875));
+        min_high_ns = max(min_high_ns,
+                DIV_ROUND_UP((scl_rise_ns + spec_setup_start +
+                              sda_fall_ns + spec_min_high_ns), 2));
+
+        min_low_ns = scl_fall_ns + spec_min_low_ns;
+        max_low_ns = spec_max_data_hold_ns * 2 - data_hold_buffer_ns;
         min_total_ns = min_low_ns + min_high_ns;
 
         /* Adjust to avoid overflow */
@@ -510,8 +542,8 @@ static int rk3x_i2c_calc_divs(unsigned long clk_rate, unsigned long scl_rate,
         min_div_for_hold = (min_low_div + min_high_div);
 
         /*
-         * This is the maximum divider so we don't go over the max.
-         * We don't round up here (we round down) since this is a max.
+         * This is the maximum divider so we don't go over the maximum.
+         * We don't round up here (we round down) since this is a maximum.
          */
         max_low_div = clk_rate_khz * max_low_ns / (8 * 1000000);
 
@@ -544,7 +576,7 @@ static int rk3x_i2c_calc_divs(unsigned long clk_rate, unsigned long scl_rate,
                 ideal_low_div = DIV_ROUND_UP(clk_rate_khz * min_low_ns,
                                              scl_rate_khz * 8 * min_total_ns);
 
-                /* Don't allow it to go over the max */
+                /* Don't allow it to go over the maximum */
                 if (ideal_low_div > max_low_div)
                         ideal_low_div = max_low_div;
 
@@ -588,9 +620,9 @@ static void rk3x_i2c_adapt_div(struct rk3x_i2c *i2c, unsigned long clk_rate)
         u64 t_low_ns, t_high_ns;
         int ret;
 
-        ret = rk3x_i2c_calc_divs(clk_rate, i2c->scl_frequency, &div_low,
-                                 &div_high);
-
+        ret = rk3x_i2c_calc_divs(clk_rate, i2c->scl_frequency, i2c->scl_rise_ns,
+                                 i2c->scl_fall_ns, i2c->sda_fall_ns,
+                                 &div_low, &div_high);
         WARN_ONCE(ret != 0, "Could not reach SCL freq %u", i2c->scl_frequency);
 
         clk_enable(i2c->clk);
@@ -633,9 +665,10 @@ static int rk3x_i2c_clk_notifier_cb(struct notifier_block *nb, unsigned long
         switch (event) {
         case PRE_RATE_CHANGE:
                 if (rk3x_i2c_calc_divs(ndata->new_rate, i2c->scl_frequency,
-                                      &div_low, &div_high) != 0) {
+                                       i2c->scl_rise_ns, i2c->scl_fall_ns,
+                                       i2c->sda_fall_ns,
+                                       &div_low, &div_high) != 0)
                         return NOTIFY_STOP;
-                }
 
                 /* scale up */
                 if (ndata->new_rate > ndata->old_rate)
@@ -859,6 +892,24 @@ static int rk3x_i2c_probe(struct platform_device *pdev)
                 i2c->scl_frequency = DEFAULT_SCL_RATE;
         }
 
+        /*
+         * Read rise and fall time from device tree. If not available use
+         * the default maximum timing from the specification.
+         */
+        if (of_property_read_u32(pdev->dev.of_node, "i2c-scl-rising-time-ns",
+                                 &i2c->scl_rise_ns)) {
+                if (i2c->scl_frequency <= 100000)
+                        i2c->scl_rise_ns = 1000;
+                else
+                        i2c->scl_rise_ns = 300;
+        }
+        if (of_property_read_u32(pdev->dev.of_node, "i2c-scl-falling-time-ns",
+                                 &i2c->scl_fall_ns))
+                i2c->scl_fall_ns = 300;
+        if (of_property_read_u32(pdev->dev.of_node, "i2c-sda-falling-time-ns",
+                                 &i2c->scl_fall_ns))
+                i2c->sda_fall_ns = i2c->scl_fall_ns;
+
         strlcpy(i2c->adap.name, "rk3x-i2c", sizeof(i2c->adap.name));
         i2c->adap.owner = THIS_MODULE;
         i2c->adap.algo = &rk3x_i2c_algorithm;
diff --git a/drivers/i2c/busses/i2c-tegra.c b/drivers/i2c/busses/i2c-tegra.c
index 28b87e683503..29f14331dd9d 100644
--- a/drivers/i2c/busses/i2c-tegra.c
+++ b/drivers/i2c/busses/i2c-tegra.c
@@ -286,6 +286,7 @@ static int tegra_i2c_empty_rx_fifo(struct tegra_i2c_dev *i2c_dev)
         if (rx_fifo_avail > 0 && buf_remaining > 0) {
                 BUG_ON(buf_remaining > 3);
                 val = i2c_readl(i2c_dev, I2C_RX_FIFO);
+                val = cpu_to_le32(val);
                 memcpy(buf, &val, buf_remaining);
                 buf_remaining = 0;
                 rx_fifo_avail--;
@@ -344,6 +345,7 @@ static int tegra_i2c_fill_tx_fifo(struct tegra_i2c_dev *i2c_dev)
         if (tx_fifo_avail > 0 && buf_remaining > 0) {
                 BUG_ON(buf_remaining > 3);
                 memcpy(&val, buf, buf_remaining);
+                val = le32_to_cpu(val);
 
                 /* Again update before writing to FIFO to make sure isr sees. */
                 i2c_dev->msg_buf_remaining = 0;
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index e9eae57a2b50..210cf4874cb7 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -102,7 +102,7 @@ static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
                 struct acpi_resource_i2c_serialbus *sb;
 
                 sb = &ares->data.i2c_serial_bus;
-                if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
+                if (!info->addr && sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
                         info->addr = sb->slave_address;
                         if (sb->access_mode == ACPI_I2C_10BIT_MODE)
                                 info->flags |= I2C_CLIENT_TEN;
@@ -698,101 +698,6 @@ static void i2c_device_shutdown(struct device *dev)
                 driver->shutdown(client);
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
-{
-        struct i2c_client *client = i2c_verify_client(dev);
-        struct i2c_driver *driver;
-
-        if (!client || !dev->driver)
-                return 0;
-        driver = to_i2c_driver(dev->driver);
-        if (!driver->suspend)
-                return 0;
-        return driver->suspend(client, mesg);
-}
-
-static int i2c_legacy_resume(struct device *dev)
-{
-        struct i2c_client *client = i2c_verify_client(dev);
-        struct i2c_driver *driver;
-
-        if (!client || !dev->driver)
-                return 0;
-        driver = to_i2c_driver(dev->driver);
-        if (!driver->resume)
-                return 0;
-        return driver->resume(client);
-}
-
-static int i2c_device_pm_suspend(struct device *dev)
-{
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-
-        if (pm)
-                return pm_generic_suspend(dev);
-        else
-                return i2c_legacy_suspend(dev, PMSG_SUSPEND);
-}
-
-static int i2c_device_pm_resume(struct device *dev)
-{
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-
-        if (pm)
-                return pm_generic_resume(dev);
-        else
-                return i2c_legacy_resume(dev);
-}
-
-static int i2c_device_pm_freeze(struct device *dev)
-{
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-
-        if (pm)
-                return pm_generic_freeze(dev);
-        else
-                return i2c_legacy_suspend(dev, PMSG_FREEZE);
-}
-
-static int i2c_device_pm_thaw(struct device *dev)
-{
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-
-        if (pm)
-                return pm_generic_thaw(dev);
-        else
-                return i2c_legacy_resume(dev);
-}
-
-static int i2c_device_pm_poweroff(struct device *dev)
-{
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-
-        if (pm)
-                return pm_generic_poweroff(dev);
-        else
-                return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
-}
-
-static int i2c_device_pm_restore(struct device *dev)
-{
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-
-        if (pm)
-                return pm_generic_restore(dev);
-        else
-                return i2c_legacy_resume(dev);
-}
-#else /* !CONFIG_PM_SLEEP */
-#define i2c_device_pm_suspend   NULL
-#define i2c_device_pm_resume    NULL
-#define i2c_device_pm_freeze    NULL
-#define i2c_device_pm_thaw      NULL
-#define i2c_device_pm_poweroff  NULL
-#define i2c_device_pm_restore   NULL
-#endif /* !CONFIG_PM_SLEEP */
-
 static void i2c_client_dev_release(struct device *dev)
 {
         kfree(to_i2c_client(dev));
@@ -804,6 +709,7 @@ show_name(struct device *dev, struct device_attribute *attr, char *buf)
         return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
                        to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
 }
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 
 static ssize_t
 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
@@ -817,8 +723,6 @@ show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 
         return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
 }
-
-static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 
 static struct attribute *i2c_dev_attrs[] = {
@@ -827,29 +731,7 @@ static struct attribute *i2c_dev_attrs[] = {
         &dev_attr_modalias.attr,
         NULL
 };
-
-static struct attribute_group i2c_dev_attr_group = {
-        .attrs          = i2c_dev_attrs,
-};
-
-static const struct attribute_group *i2c_dev_attr_groups[] = {
-        &i2c_dev_attr_group,
-        NULL
-};
-
-static const struct dev_pm_ops i2c_device_pm_ops = {
-        .suspend = i2c_device_pm_suspend,
-        .resume = i2c_device_pm_resume,
-        .freeze = i2c_device_pm_freeze,
-        .thaw = i2c_device_pm_thaw,
-        .poweroff = i2c_device_pm_poweroff,
-        .restore = i2c_device_pm_restore,
-        SET_RUNTIME_PM_OPS(
-                pm_generic_runtime_suspend,
-                pm_generic_runtime_resume,
-                NULL
-        )
-};
+ATTRIBUTE_GROUPS(i2c_dev);
 
 struct bus_type i2c_bus_type = {
         .name           = "i2c",
@@ -857,12 +739,11 @@ struct bus_type i2c_bus_type = {
         .probe          = i2c_device_probe,
         .remove         = i2c_device_remove,
         .shutdown       = i2c_device_shutdown,
-        .pm             = &i2c_device_pm_ops,
 };
 EXPORT_SYMBOL_GPL(i2c_bus_type);
 
 static struct device_type i2c_client_type = {
-        .groups         = i2c_dev_attr_groups,
+        .groups         = i2c_dev_groups,
         .uevent         = i2c_device_uevent,
         .release        = i2c_client_dev_release,
 };
@@ -1261,6 +1142,7 @@ i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
 
         return count;
 }
+static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
 
 /*
  * And of course let the users delete the devices they instantiated, if
@@ -1315,8 +1197,6 @@ i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
                         "delete_device");
         return res;
 }
-
-static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
                                    i2c_sysfs_delete_device);
 
@@ -1326,18 +1206,10 @@ static struct attribute *i2c_adapter_attrs[] = {
         &dev_attr_delete_device.attr,
         NULL
 };
-
-static struct attribute_group i2c_adapter_attr_group = {
-        .attrs          = i2c_adapter_attrs,
-};
-
-static const struct attribute_group *i2c_adapter_attr_groups[] = {
-        &i2c_adapter_attr_group,
-        NULL
-};
+ATTRIBUTE_GROUPS(i2c_adapter);
 
 struct device_type i2c_adapter_type = {
-        .groups         = i2c_adapter_attr_groups,
+        .groups         = i2c_adapter_groups,
         .release        = i2c_adapter_dev_release,
 };
 EXPORT_SYMBOL_GPL(i2c_adapter_type);
@@ -1419,8 +1291,6 @@ static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
         if (of_get_property(node, "wakeup-source", NULL))
                 info.flags |= I2C_CLIENT_WAKE;
 
-        request_module("%s%s", I2C_MODULE_PREFIX, info.type);
-
         result = i2c_new_device(adap, &info);
         if (result == NULL) {
                 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
@@ -1796,11 +1666,15 @@ void i2c_del_adapter(struct i2c_adapter *adap)
         /* device name is gone after device_unregister */
         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
 
-        /* clean up the sysfs representation */
+        /* wait until all references to the device are gone
+         *
+         * FIXME: This is old code and should ideally be replaced by an
+         * alternative which results in decoupling the lifetime of the struct
+         * device from the i2c_adapter, like spi or netdev do. Any solution
+         * should be throughly tested with DEBUG_KOBJECT_RELEASE enabled!
+         */
         init_completion(&adap->dev_released);
         device_unregister(&adap->dev);
-
-        /* wait for sysfs to drop all references */
         wait_for_completion(&adap->dev_released);
 
         /* free bus id */
@@ -1859,14 +1733,6 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
         if (res)
                 return res;
 
-        /* Drivers should switch to dev_pm_ops instead. */
-        if (driver->suspend)
-                pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
-                        driver->driver.name);
-        if (driver->resume)
-                pr_warn("i2c-core: driver [%s] using legacy resume method\n",
-                        driver->driver.name);
-
         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
 
         INIT_LIST_HEAD(&driver->clients);
diff --git a/drivers/i2c/muxes/i2c-mux-pca954x.c b/drivers/i2c/muxes/i2c-mux-pca954x.c
index ec11b404b433..3d8f4fe2e47e 100644
--- a/drivers/i2c/muxes/i2c-mux-pca954x.c
+++ b/drivers/i2c/muxes/i2c-mux-pca954x.c
@@ -41,6 +41,7 @@
 #include <linux/i2c-mux.h>
 #include <linux/i2c/pca954x.h>
 #include <linux/module.h>
+#include <linux/of.h>
 #include <linux/pm.h>
 #include <linux/slab.h>
 
@@ -186,6 +187,8 @@ static int pca954x_probe(struct i2c_client *client,
 {
         struct i2c_adapter *adap = to_i2c_adapter(client->dev.parent);
         struct pca954x_platform_data *pdata = dev_get_platdata(&client->dev);
+        struct device_node *of_node = client->dev.of_node;
+        bool idle_disconnect_dt;
         struct gpio_desc *gpio;
         int num, force, class;
         struct pca954x *data;
@@ -217,8 +220,13 @@ static int pca954x_probe(struct i2c_client *client,
         data->type = id->driver_data;
         data->last_chan = 0;               /* force the first selection */
 
+        idle_disconnect_dt = of_node &&
+                of_property_read_bool(of_node, "i2c-mux-idle-disconnect");
+
         /* Now create an adapter for each channel */
         for (num = 0; num < chips[data->type].nchans; num++) {
+                bool idle_disconnect_pd = false;
+
                 force = 0;                        /* dynamic adap number */
                 class = 0;                        /* no class by default */
                 if (pdata) {
@@ -229,12 +237,13 @@ static int pca954x_probe(struct i2c_client *client,
                         } else
                                 /* discard unconfigured channels */
                                 break;
+                        idle_disconnect_pd = pdata->modes[num].deselect_on_exit;
                 }
 
                 data->virt_adaps[num] =
                         i2c_add_mux_adapter(adap, &client->dev, client,
                                 force, num, class, pca954x_select_chan,
-                                (pdata && pdata->modes[num].deselect_on_exit)
+                                (idle_disconnect_pd || idle_disconnect_dt)
                                         ? pca954x_deselect_mux : NULL);
 
                 if (data->virt_adaps[num] == NULL) {
diff --git a/drivers/iio/Kconfig b/drivers/iio/Kconfig
index 4132935dc929..4011effe4c05 100644
--- a/drivers/iio/Kconfig
+++ b/drivers/iio/Kconfig
@@ -21,7 +21,7 @@ config IIO_BUFFER
 if IIO_BUFFER
 
 config IIO_BUFFER_CB
-boolean "IIO callback buffer used for push in-kernel interfaces"
+        bool "IIO callback buffer used for push in-kernel interfaces"
         help
           Should be selected by any drivers that do in-kernel push
           usage.  That is, those where the data is pushed to the consumer.
@@ -43,7 +43,7 @@ config IIO_TRIGGERED_BUFFER
 endif # IIO_BUFFER
 
 config IIO_TRIGGER
-        boolean "Enable triggered sampling support"
+        bool "Enable triggered sampling support"
         help
           Provides IIO core support for triggers.  Currently these
           are used to initialize capture of samples to push into
diff --git a/drivers/infiniband/core/ucma.c b/drivers/infiniband/core/ucma.c
index 56a4b7ca7ee3..45d67e9228d7 100644
--- a/drivers/infiniband/core/ucma.c
+++ b/drivers/infiniband/core/ucma.c
@@ -1124,6 +1124,9 @@ static int ucma_set_ib_path(struct ucma_context *ctx,
         if (!optlen)
                 return -EINVAL;
 
+        memset(&sa_path, 0, sizeof(sa_path));
+        sa_path.vlan_id = 0xffff;
+
         ib_sa_unpack_path(path_data->path_rec, &sa_path);
         ret = rdma_set_ib_paths(ctx->cm_id, &sa_path, 1);
         if (ret)
diff --git a/drivers/infiniband/core/umem_odp.c b/drivers/infiniband/core/umem_odp.c
index 6095872549e7..8b8cc6fa0ab0 100644
--- a/drivers/infiniband/core/umem_odp.c
+++ b/drivers/infiniband/core/umem_odp.c
@@ -294,7 +294,8 @@ int ib_umem_odp_get(struct ib_ucontext *context, struct ib_umem *umem)
         if (likely(ib_umem_start(umem) != ib_umem_end(umem)))
                 rbt_ib_umem_insert(&umem->odp_data->interval_tree,
                                    &context->umem_tree);
-        if (likely(!atomic_read(&context->notifier_count)))
+        if (likely(!atomic_read(&context->notifier_count)) ||
+            context->odp_mrs_count == 1)
                 umem->odp_data->mn_counters_active = true;
         else
                 list_add(&umem->odp_data->no_private_counters,
diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h
index 643c08a025a5..b716b0815644 100644
--- a/drivers/infiniband/core/uverbs.h
+++ b/drivers/infiniband/core/uverbs.h
@@ -258,5 +258,6 @@ IB_UVERBS_DECLARE_CMD(close_xrcd);
 
 IB_UVERBS_DECLARE_EX_CMD(create_flow);
 IB_UVERBS_DECLARE_EX_CMD(destroy_flow);
+IB_UVERBS_DECLARE_EX_CMD(query_device);
 
 #endif /* UVERBS_H */
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index b7943ff16ed3..a9f048990dfc 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -400,6 +400,52 @@ err:
         return ret;
 }
 
+static void copy_query_dev_fields(struct ib_uverbs_file *file,
+                                  struct ib_uverbs_query_device_resp *resp,
+                                  struct ib_device_attr *attr)
+{
+        resp->fw_ver            = attr->fw_ver;
+        resp->node_guid         = file->device->ib_dev->node_guid;
+        resp->sys_image_guid    = attr->sys_image_guid;
+        resp->max_mr_size       = attr->max_mr_size;
+        resp->page_size_cap     = attr->page_size_cap;
+        resp->vendor_id         = attr->vendor_id;
+        resp->vendor_part_id    = attr->vendor_part_id;
+        resp->hw_ver            = attr->hw_ver;
+        resp->max_qp            = attr->max_qp;
+        resp->max_qp_wr         = attr->max_qp_wr;
+        resp->device_cap_flags  = attr->device_cap_flags;
+        resp->max_sge           = attr->max_sge;
+        resp->max_sge_rd        = attr->max_sge_rd;
+        resp->max_cq            = attr->max_cq;
+        resp->max_cqe           = attr->max_cqe;
+        resp->max_mr            = attr->max_mr;
+        resp->max_pd            = attr->max_pd;
+        resp->max_qp_rd_atom    = attr->max_qp_rd_atom;
+        resp->max_ee_rd_atom    = attr->max_ee_rd_atom;
+        resp->max_res_rd_atom   = attr->max_res_rd_atom;
+        resp->max_qp_init_rd_atom       = attr->max_qp_init_rd_atom;
+        resp->max_ee_init_rd_atom       = attr->max_ee_init_rd_atom;
+        resp->atomic_cap                = attr->atomic_cap;
+        resp->max_ee                    = attr->max_ee;
+        resp->max_rdd                   = attr->max_rdd;
+        resp->max_mw                    = attr->max_mw;
+        resp->max_raw_ipv6_qp           = attr->max_raw_ipv6_qp;
+        resp->max_raw_ethy_qp           = attr->max_raw_ethy_qp;
+        resp->max_mcast_grp             = attr->max_mcast_grp;
+        resp->max_mcast_qp_attach       = attr->max_mcast_qp_attach;
+        resp->max_total_mcast_qp_attach = attr->max_total_mcast_qp_attach;
+        resp->max_ah                    = attr->max_ah;
+        resp->max_fmr                   = attr->max_fmr;
+        resp->max_map_per_fmr           = attr->max_map_per_fmr;
+        resp->max_srq                   = attr->max_srq;
+        resp->max_srq_wr                = attr->max_srq_wr;
+        resp->max_srq_sge               = attr->max_srq_sge;
+        resp->max_pkeys                 = attr->max_pkeys;
+        resp->local_ca_ack_delay        = attr->local_ca_ack_delay;
+        resp->phys_port_cnt             = file->device->ib_dev->phys_port_cnt;
+}
+
 ssize_t ib_uverbs_query_device(struct ib_uverbs_file *file,
                                const char __user *buf,
                                int in_len, int out_len)
@@ -420,47 +466,7 @@ ssize_t ib_uverbs_query_device(struct ib_uverbs_file *file,
                 return ret;
 
         memset(&resp, 0, sizeof resp);
-
-        resp.fw_ver                    = attr.fw_ver;
-        resp.node_guid                 = file->device->ib_dev->node_guid;
-        resp.sys_image_guid            = attr.sys_image_guid;
-        resp.max_mr_size               = attr.max_mr_size;
-        resp.page_size_cap             = attr.page_size_cap;
-        resp.vendor_id                 = attr.vendor_id;
-        resp.vendor_part_id            = attr.vendor_part_id;
-        resp.hw_ver                    = attr.hw_ver;
-        resp.max_qp                    = attr.max_qp;
-        resp.max_qp_wr                 = attr.max_qp_wr;
-        resp.device_cap_flags          = attr.device_cap_flags;
-        resp.max_sge                   = attr.max_sge;
-        resp.max_sge_rd                = attr.max_sge_rd;
-        resp.max_cq                    = attr.max_cq;
-        resp.max_cqe                   = attr.max_cqe;
-        resp.max_mr                    = attr.max_mr;
-        resp.max_pd                    = attr.max_pd;
-        resp.max_qp_rd_atom            = attr.max_qp_rd_atom;
-        resp.max_ee_rd_atom            = attr.max_ee_rd_atom;
-        resp.max_res_rd_atom           = attr.max_res_rd_atom;
-        resp.max_qp_init_rd_atom       = attr.max_qp_init_rd_atom;
-        resp.max_ee_init_rd_atom       = attr.max_ee_init_rd_atom;
-        resp.atomic_cap                = attr.atomic_cap;
-        resp.max_ee                    = attr.max_ee;
-        resp.max_rdd                   = attr.max_rdd;
-        resp.max_mw                    = attr.max_mw;
-        resp.max_raw_ipv6_qp           = attr.max_raw_ipv6_qp;
-        resp.max_raw_ethy_qp           = attr.max_raw_ethy_qp;
-        resp.max_mcast_grp             = attr.max_mcast_grp;
-        resp.max_mcast_qp_attach       = attr.max_mcast_qp_attach;
-        resp.max_total_mcast_qp_attach = attr.max_total_mcast_qp_attach;
-        resp.max_ah                    = attr.max_ah;
-        resp.max_fmr                   = attr.max_fmr;
-        resp.max_map_per_fmr           = attr.max_map_per_fmr;
-        resp.max_srq                   = attr.max_srq;
-        resp.max_srq_wr                = attr.max_srq_wr;
-        resp.max_srq_sge               = attr.max_srq_sge;
-        resp.max_pkeys                 = attr.max_pkeys;
-        resp.local_ca_ack_delay        = attr.local_ca_ack_delay;
-        resp.phys_port_cnt             = file->device->ib_dev->phys_port_cnt;
+        copy_query_dev_fields(file, &resp, &attr);
 
         if (copy_to_user((void __user *) (unsigned long) cmd.response,
                          &resp, sizeof resp))
@@ -2091,20 +2097,21 @@ ssize_t ib_uverbs_modify_qp(struct ib_uverbs_file *file,
         if (qp->real_qp == qp) {
                 ret = ib_resolve_eth_l2_attrs(qp, attr, &cmd.attr_mask);
                 if (ret)
-                        goto out;
+                        goto release_qp;
                 ret = qp->device->modify_qp(qp, attr,
                         modify_qp_mask(qp->qp_type, cmd.attr_mask), &udata);
         } else {
                 ret = ib_modify_qp(qp, attr, modify_qp_mask(qp->qp_type, cmd.attr_mask));
         }
 
-        put_qp_read(qp);
-
         if (ret)
-                goto out;
+                goto release_qp;
 
         ret = in_len;
 
+release_qp:
+        put_qp_read(qp);
+
 out:
         kfree(attr);
 
@@ -3287,3 +3294,64 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
 
         return ret ? ret : in_len;
 }
+
+int ib_uverbs_ex_query_device(struct ib_uverbs_file *file,
+                              struct ib_udata *ucore,
+                              struct ib_udata *uhw)
+{
+        struct ib_uverbs_ex_query_device_resp resp;
+        struct ib_uverbs_ex_query_device  cmd;
+        struct ib_device_attr attr;
+        struct ib_device *device;
+        int err;
+
+        device = file->device->ib_dev;
+        if (ucore->inlen < sizeof(cmd))
+                return -EINVAL;
+
+        err = ib_copy_from_udata(&cmd, ucore, sizeof(cmd));
+        if (err)
+                return err;
+
+        if (cmd.comp_mask)
+                return -EINVAL;
+
+        if (cmd.reserved)
+                return -EINVAL;
+
+        resp.response_length = offsetof(typeof(resp), odp_caps);
+
+        if (ucore->outlen < resp.response_length)
+                return -ENOSPC;
+
+        err = device->query_device(device, &attr);
+        if (err)
+                return err;
+
+        copy_query_dev_fields(file, &resp.base, &attr);
+        resp.comp_mask = 0;
+
+        if (ucore->outlen < resp.response_length + sizeof(resp.odp_caps))
+                goto end;
+
+#ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
+        resp.odp_caps.general_caps = attr.odp_caps.general_caps;
+        resp.odp_caps.per_transport_caps.rc_odp_caps =
+                attr.odp_caps.per_transport_caps.rc_odp_caps;
+        resp.odp_caps.per_transport_caps.uc_odp_caps =
+                attr.odp_caps.per_transport_caps.uc_odp_caps;
+        resp.odp_caps.per_transport_caps.ud_odp_caps =
+                attr.odp_caps.per_transport_caps.ud_odp_caps;
+        resp.odp_caps.reserved = 0;
+#else
+        memset(&resp.odp_caps, 0, sizeof(resp.odp_caps));
+#endif
+        resp.response_length += sizeof(resp.odp_caps);
+
+end:
+        err = ib_copy_to_udata(ucore, &resp, resp.response_length);
+        if (err)
+                return err;
+
+        return 0;
+}
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 5db1a8cc388d..259dcc7779f5 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -123,6 +123,7 @@ static int (*uverbs_ex_cmd_table[])(struct ib_uverbs_file *file,
                                     struct ib_udata *uhw) = {
         [IB_USER_VERBS_EX_CMD_CREATE_FLOW]      = ib_uverbs_ex_create_flow,
         [IB_USER_VERBS_EX_CMD_DESTROY_FLOW]     = ib_uverbs_ex_destroy_flow,
+        [IB_USER_VERBS_EX_CMD_QUERY_DEVICE]     = ib_uverbs_ex_query_device,
 };
 
 static void ib_uverbs_add_one(struct ib_device *device);
diff --git a/drivers/infiniband/hw/cxgb4/ev.c b/drivers/infiniband/hw/cxgb4/ev.c
index 794555dc86a5..bdfac2ccb704 100644
--- a/drivers/infiniband/hw/cxgb4/ev.c
+++ b/drivers/infiniband/hw/cxgb4/ev.c
@@ -225,13 +225,20 @@ int c4iw_ev_handler(struct c4iw_dev *dev, u32 qid)
         struct c4iw_cq *chp;
         unsigned long flag;
 
+        spin_lock_irqsave(&dev->lock, flag);
         chp = get_chp(dev, qid);
         if (chp) {
+                atomic_inc(&chp->refcnt);
+                spin_unlock_irqrestore(&dev->lock, flag);
                 t4_clear_cq_armed(&chp->cq);
                 spin_lock_irqsave(&chp->comp_handler_lock, flag);
                 (*chp->ibcq.comp_handler)(&chp->ibcq, chp->ibcq.cq_context);
                 spin_unlock_irqrestore(&chp->comp_handler_lock, flag);
-        } else
+                if (atomic_dec_and_test(&chp->refcnt))
+                        wake_up(&chp->wait);
+        } else {
                 PDBG("%s unknown cqid 0x%x\n", __func__, qid);
+                spin_unlock_irqrestore(&dev->lock, flag);
+        }
         return 0;
 }
diff --git a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
index b5678ac97393..d87e1650f643 100644
--- a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
+++ b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
@@ -196,7 +196,7 @@ static inline int c4iw_num_stags(struct c4iw_rdev *rdev)
         return (int)(rdev->lldi.vr->stag.size >> 5);
 }
 
-#define C4IW_WR_TO (30*HZ)
+#define C4IW_WR_TO (60*HZ)
 
 struct c4iw_wr_wait {
         struct completion completion;
@@ -220,22 +220,21 @@ static inline int c4iw_wait_for_reply(struct c4iw_rdev *rdev,
                                  u32 hwtid, u32 qpid,
                                  const char *func)
 {
-        unsigned to = C4IW_WR_TO;
         int ret;
 
-        do {
-                ret = wait_for_completion_timeout(&wr_waitp->completion, to);
-                if (!ret) {
-                        printk(KERN_ERR MOD "%s - Device %s not responding - "
-                               "tid %u qpid %u\n", func,
-                               pci_name(rdev->lldi.pdev), hwtid, qpid);
-                        if (c4iw_fatal_error(rdev)) {
-                                wr_waitp->ret = -EIO;
-                                break;
-                        }
-                        to = to << 2;
-                }
-        } while (!ret);
+        if (c4iw_fatal_error(rdev)) {
+                wr_waitp->ret = -EIO;
+                goto out;
+        }
+
+        ret = wait_for_completion_timeout(&wr_waitp->completion, C4IW_WR_TO);
+        if (!ret) {
+                PDBG("%s - Device %s not responding (disabling device) - tid %u qpid %u\n",
+                     func, pci_name(rdev->lldi.pdev), hwtid, qpid);
+                rdev->flags |= T4_FATAL_ERROR;
+                wr_waitp->ret = -EIO;
+        }
+out:
         if (wr_waitp->ret)
                 PDBG("%s: FW reply %d tid %u qpid %u\n",
                      pci_name(rdev->lldi.pdev), wr_waitp->ret, hwtid, qpid);
diff --git a/drivers/infiniband/hw/ipath/ipath_fs.c b/drivers/infiniband/hw/ipath/ipath_fs.c
index 4977082e081f..33c45dfcbd88 100644
--- a/drivers/infiniband/hw/ipath/ipath_fs.c
+++ b/drivers/infiniband/hw/ipath/ipath_fs.c
@@ -277,7 +277,7 @@ static int remove_file(struct dentry *parent, char *name)
         }
 
         spin_lock(&tmp->d_lock);
-        if (!(d_unhashed(tmp) && tmp->d_inode)) {
+        if (!d_unhashed(tmp) && tmp->d_inode) {
                 dget_dlock(tmp);
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
diff --git a/drivers/infiniband/hw/ipath/ipath_kernel.h b/drivers/infiniband/hw/ipath/ipath_kernel.h
index 6559af60bffd..e08db7020cd4 100644
--- a/drivers/infiniband/hw/ipath/ipath_kernel.h
+++ b/drivers/infiniband/hw/ipath/ipath_kernel.h
@@ -908,9 +908,6 @@ void ipath_chip_cleanup(struct ipath_devdata *);
 /* clean up any chip type-specific stuff */
 void ipath_chip_done(void);
 
-/* check to see if we have to force ordering for write combining */
-int ipath_unordered_wc(void);
-
 void ipath_disarm_piobufs(struct ipath_devdata *, unsigned first,
                           unsigned cnt);
 void ipath_cancel_sends(struct ipath_devdata *, int);
diff --git a/drivers/infiniband/hw/ipath/ipath_wc_ppc64.c b/drivers/infiniband/hw/ipath/ipath_wc_ppc64.c
index 1d7bd82a1fb1..1a7e20a75149 100644
--- a/drivers/infiniband/hw/ipath/ipath_wc_ppc64.c
+++ b/drivers/infiniband/hw/ipath/ipath_wc_ppc64.c
@@ -47,16 +47,3 @@ int ipath_enable_wc(struct ipath_devdata *dd)
 {
         return 0;
 }
-
-/**
- * ipath_unordered_wc - indicate whether write combining is unordered
- *
- * Because our performance depends on our ability to do write
- * combining mmio writes in the most efficient way, we need to
- * know if we are on a processor that may reorder stores when
- * write combining.
- */
-int ipath_unordered_wc(void)
-{
-        return 1;
-}
diff --git a/drivers/infiniband/hw/ipath/ipath_wc_x86_64.c b/drivers/infiniband/hw/ipath/ipath_wc_x86_64.c
index 3428acb0868c..4ad0b932df1f 100644
--- a/drivers/infiniband/hw/ipath/ipath_wc_x86_64.c
+++ b/drivers/infiniband/hw/ipath/ipath_wc_x86_64.c
@@ -167,18 +167,3 @@ void ipath_disable_wc(struct ipath_devdata *dd)
                 dd->ipath_wc_cookie = 0; /* even on failure */
         }
 }
-
-/**
- * ipath_unordered_wc - indicate whether write combining is ordered
- *
- * Because our performance depends on our ability to do write combining mmio
- * writes in the most efficient way, we need to know if we are on an Intel
- * or AMD x86_64 processor.  AMD x86_64 processors flush WC buffers out in
- * the order completed, and so no special flushing is required to get
- * correct ordering.  Intel processors, however, will flush write buffers
- * out in "random" orders, and so explicit ordering is needed at times.
- */
-int ipath_unordered_wc(void)
-{
-        return boot_cpu_data.x86_vendor != X86_VENDOR_AMD;
-}
diff --git a/drivers/infiniband/hw/mlx4/cm.c b/drivers/infiniband/hw/mlx4/cm.c
index 56a593e0ae5d..39a488889fc7 100644
--- a/drivers/infiniband/hw/mlx4/cm.c
+++ b/drivers/infiniband/hw/mlx4/cm.c
@@ -372,7 +372,7 @@ int mlx4_ib_demux_cm_handler(struct ib_device *ibdev, int port, int *slave,
                 *slave = mlx4_ib_find_real_gid(ibdev, port, gid.global.interface_id);
                 if (*slave < 0) {
                         mlx4_ib_warn(ibdev, "failed matching slave_id by gid (0x%llx)\n",
-                                        gid.global.interface_id);
+                                     be64_to_cpu(gid.global.interface_id));
                         return -ENOENT;
                 }
                 return 0;
diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index 543ecdd8667b..0176caa5792c 100644
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -369,8 +369,7 @@ int mlx4_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
         int err;
 
         mutex_lock(&cq->resize_mutex);
-
-        if (entries < 1) {
+        if (entries < 1 || entries > dev->dev->caps.max_cqes) {
                 err = -EINVAL;
                 goto out;
         }
@@ -381,7 +380,7 @@ int mlx4_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
                 goto out;
         }
 
-        if (entries > dev->dev->caps.max_cqes) {
+        if (entries > dev->dev->caps.max_cqes + 1) {
                 err = -EINVAL;
                 goto out;
         }
@@ -394,7 +393,7 @@ int mlx4_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
                 /* Can't be smaller than the number of outstanding CQEs */
                 outst_cqe = mlx4_ib_get_outstanding_cqes(cq);
                 if (entries < outst_cqe + 1) {
-                        err = 0;
+                        err = -EINVAL;
                         goto out;
                 }
 
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index eb8e215f1613..ac6e2b710ea6 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -1269,8 +1269,7 @@ static int mlx4_ib_mcg_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
         struct mlx4_dev *dev = mdev->dev;
         struct mlx4_ib_qp *mqp = to_mqp(ibqp);
         struct mlx4_ib_steering *ib_steering = NULL;
-        enum mlx4_protocol prot = (gid->raw[1] == 0x0e) ?
-                MLX4_PROT_IB_IPV4 : MLX4_PROT_IB_IPV6;
+        enum mlx4_protocol prot = MLX4_PROT_IB_IPV6;
         struct mlx4_flow_reg_id reg_id;
 
         if (mdev->dev->caps.steering_mode ==
@@ -1284,8 +1283,10 @@ static int mlx4_ib_mcg_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
                                     !!(mqp->flags &
                                        MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK),
                                     prot, &reg_id.id);
-        if (err)
+        if (err) {
+                pr_err("multicast attach op failed, err %d\n", err);
                 goto err_malloc;
+        }
 
         reg_id.mirror = 0;
         if (mlx4_is_bonded(dev)) {
@@ -1348,9 +1349,7 @@ static int mlx4_ib_mcg_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
         struct net_device *ndev;
         struct mlx4_ib_gid_entry *ge;
         struct mlx4_flow_reg_id reg_id = {0, 0};
-
-        enum mlx4_protocol prot = (gid->raw[1] == 0x0e) ?
-                MLX4_PROT_IB_IPV4 : MLX4_PROT_IB_IPV6;
+        enum mlx4_protocol prot =  MLX4_PROT_IB_IPV6;
 
         if (mdev->dev->caps.steering_mode ==
             MLX4_STEERING_MODE_DEVICE_MANAGED) {
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index dfc6ca128a7e..ed2bd6701f9b 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -1696,8 +1696,10 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
                             qp->mlx4_ib_qp_type == MLX4_IB_QPT_PROXY_GSI ||
                             qp->mlx4_ib_qp_type == MLX4_IB_QPT_TUN_GSI) {
                                 err = handle_eth_ud_smac_index(dev, qp, (u8 *)attr->smac, context);
-                                if (err)
-                                        return -EINVAL;
+                                if (err) {
+                                        err = -EINVAL;
+                                        goto out;
+                                }
                                 if (qp->mlx4_ib_qp_type == MLX4_IB_QPT_PROXY_GSI)
                                         dev->qp1_proxy[qp->port - 1] = qp;
                         }
diff --git a/drivers/infiniband/hw/mlx5/main.c b/drivers/infiniband/hw/mlx5/main.c
index 03bf81211a54..cc4ac1e583b2 100644
--- a/drivers/infiniband/hw/mlx5/main.c
+++ b/drivers/infiniband/hw/mlx5/main.c
@@ -997,7 +997,7 @@ static int get_port_caps(struct mlx5_ib_dev *dev)
         struct ib_device_attr *dprops = NULL;
         struct ib_port_attr *pprops = NULL;
         struct mlx5_general_caps *gen;
-        int err = 0;
+        int err = -ENOMEM;
         int port;
 
         gen = &dev->mdev->caps.gen;
@@ -1331,6 +1331,8 @@ static void *mlx5_ib_add(struct mlx5_core_dev *mdev)
                 (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ)         |
                 (1ull << IB_USER_VERBS_CMD_CREATE_XSRQ)         |
                 (1ull << IB_USER_VERBS_CMD_OPEN_QP);
+        dev->ib_dev.uverbs_ex_cmd_mask =
+                (1ull << IB_USER_VERBS_EX_CMD_QUERY_DEVICE);
 
         dev->ib_dev.query_device        = mlx5_ib_query_device;
         dev->ib_dev.query_port          = mlx5_ib_query_port;
diff --git a/drivers/infiniband/hw/mlx5/mr.c b/drivers/infiniband/hw/mlx5/mr.c
index 32a28bd50b20..cd9822eeacae 100644
--- a/drivers/infiniband/hw/mlx5/mr.c
+++ b/drivers/infiniband/hw/mlx5/mr.c
@@ -1012,6 +1012,7 @@ static struct mlx5_ib_mr *reg_create(struct ib_pd *pd, u64 virt_addr,
                 goto err_2;
         }
         mr->umem = umem;
+        mr->dev = dev;
         mr->live = 1;
         kvfree(in);
 
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma.h b/drivers/infiniband/hw/ocrdma/ocrdma.h
index b43456ae124b..c9780d919769 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma.h
@@ -40,7 +40,7 @@
 #include <be_roce.h>
 #include "ocrdma_sli.h"
 
-#define OCRDMA_ROCE_DRV_VERSION "10.2.287.0u"
+#define OCRDMA_ROCE_DRV_VERSION "10.4.205.0u"
 
 #define OCRDMA_ROCE_DRV_DESC "Emulex OneConnect RoCE Driver"
 #define OCRDMA_NODE_DESC "Emulex OneConnect RoCE HCA"
@@ -55,12 +55,19 @@
 #define OCRDMA_UVERBS(CMD_NAME) (1ull << IB_USER_VERBS_CMD_##CMD_NAME)
 
 #define convert_to_64bit(lo, hi) ((u64)hi << 32 | (u64)lo)
+#define EQ_INTR_PER_SEC_THRSH_HI 150000
+#define EQ_INTR_PER_SEC_THRSH_LOW 100000
+#define EQ_AIC_MAX_EQD 20
+#define EQ_AIC_MIN_EQD 0
+
+void ocrdma_eqd_set_task(struct work_struct *work);
 
 struct ocrdma_dev_attr {
         u8 fw_ver[32];
         u32 vendor_id;
         u32 device_id;
         u16 max_pd;
+        u16 max_dpp_pds;
         u16 max_cq;
         u16 max_cqe;
         u16 max_qp;
@@ -116,12 +123,19 @@ struct ocrdma_queue_info {
         bool created;
 };
 
+struct ocrdma_aic_obj {         /* Adaptive interrupt coalescing (AIC) info */
+        u32 prev_eqd;
+        u64 eq_intr_cnt;
+        u64 prev_eq_intr_cnt;
+};
+
 struct ocrdma_eq {
         struct ocrdma_queue_info q;
         u32 vector;
         int cq_cnt;
         struct ocrdma_dev *dev;
         char irq_name[32];
+        struct ocrdma_aic_obj aic_obj;
 };
 
 struct ocrdma_mq {
@@ -171,6 +185,21 @@ struct ocrdma_stats {
         struct ocrdma_dev *dev;
 };
 
+struct ocrdma_pd_resource_mgr {
+        u32 pd_norm_start;
+        u16 pd_norm_count;
+        u16 pd_norm_thrsh;
+        u16 max_normal_pd;
+        u32 pd_dpp_start;
+        u16 pd_dpp_count;
+        u16 pd_dpp_thrsh;
+        u16 max_dpp_pd;
+        u16 dpp_page_index;
+        unsigned long *pd_norm_bitmap;
+        unsigned long *pd_dpp_bitmap;
+        bool pd_prealloc_valid;
+};
+
 struct stats_mem {
         struct ocrdma_mqe mqe;
         void *va;
@@ -198,6 +227,7 @@ struct ocrdma_dev {
 
         struct ocrdma_eq *eq_tbl;
         int eq_cnt;
+        struct delayed_work eqd_work;
         u16 base_eqid;
         u16 max_eq;
 
@@ -255,7 +285,12 @@ struct ocrdma_dev {
         struct ocrdma_stats rx_qp_err_stats;
         struct ocrdma_stats tx_dbg_stats;
         struct ocrdma_stats rx_dbg_stats;
+        struct ocrdma_stats driver_stats;
+        struct ocrdma_stats reset_stats;
         struct dentry *dir;
+        atomic_t async_err_stats[OCRDMA_MAX_ASYNC_ERRORS];
+        atomic_t cqe_err_stats[OCRDMA_MAX_CQE_ERR];
+        struct ocrdma_pd_resource_mgr *pd_mgr;
 };
 
 struct ocrdma_cq {
@@ -335,7 +370,6 @@ struct ocrdma_srq {
 
 struct ocrdma_qp {
         struct ib_qp ibqp;
-        struct ocrdma_dev *dev;
 
         u8 __iomem *sq_db;
         struct ocrdma_qp_hwq_info sq;
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_ah.c b/drivers/infiniband/hw/ocrdma/ocrdma_ah.c
index f3cc8c9e65ae..d812904f3984 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_ah.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_ah.c
@@ -29,19 +29,22 @@
 #include <net/netevent.h>
 
 #include <rdma/ib_addr.h>
+#include <rdma/ib_mad.h>
 
 #include "ocrdma.h"
 #include "ocrdma_verbs.h"
 #include "ocrdma_ah.h"
 #include "ocrdma_hw.h"
+#include "ocrdma_stats.h"
 
 #define OCRDMA_VID_PCP_SHIFT    0xD
 
 static inline int set_av_attr(struct ocrdma_dev *dev, struct ocrdma_ah *ah,
-                        struct ib_ah_attr *attr, union ib_gid *sgid, int pdid)
+                        struct ib_ah_attr *attr, union ib_gid *sgid,
+                        int pdid, bool *isvlan)
 {
         int status = 0;
-        u16 vlan_tag; bool vlan_enabled = false;
+        u16 vlan_tag;
         struct ocrdma_eth_vlan eth;
         struct ocrdma_grh grh;
         int eth_sz;
@@ -59,7 +62,7 @@ static inline int set_av_attr(struct ocrdma_dev *dev, struct ocrdma_ah *ah,
                 vlan_tag |= (dev->sl & 0x07) << OCRDMA_VID_PCP_SHIFT;
                 eth.vlan_tag = cpu_to_be16(vlan_tag);
                 eth_sz = sizeof(struct ocrdma_eth_vlan);
-                vlan_enabled = true;
+                *isvlan = true;
         } else {
                 eth.eth_type = cpu_to_be16(OCRDMA_ROCE_ETH_TYPE);
                 eth_sz = sizeof(struct ocrdma_eth_basic);
@@ -82,7 +85,7 @@ static inline int set_av_attr(struct ocrdma_dev *dev, struct ocrdma_ah *ah,
         /* Eth HDR */
         memcpy(&ah->av->eth_hdr, &eth, eth_sz);
         memcpy((u8 *)ah->av + eth_sz, &grh, sizeof(struct ocrdma_grh));
-        if (vlan_enabled)
+        if (*isvlan)
                 ah->av->valid |= OCRDMA_AV_VLAN_VALID;
         ah->av->valid = cpu_to_le32(ah->av->valid);
         return status;
@@ -91,6 +94,7 @@ static inline int set_av_attr(struct ocrdma_dev *dev, struct ocrdma_ah *ah,
 struct ib_ah *ocrdma_create_ah(struct ib_pd *ibpd, struct ib_ah_attr *attr)
 {
         u32 *ahid_addr;
+        bool isvlan = false;
         int status;
         struct ocrdma_ah *ah;
         struct ocrdma_pd *pd = get_ocrdma_pd(ibpd);
@@ -127,15 +131,20 @@ struct ib_ah *ocrdma_create_ah(struct ib_pd *ibpd, struct ib_ah_attr *attr)
                 }
         }
 
-        status = set_av_attr(dev, ah, attr, &sgid, pd->id);
+        status = set_av_attr(dev, ah, attr, &sgid, pd->id, &isvlan);
         if (status)
                 goto av_conf_err;
 
         /* if pd is for the user process, pass the ah_id to user space */
         if ((pd->uctx) && (pd->uctx->ah_tbl.va)) {
                 ahid_addr = pd->uctx->ah_tbl.va + attr->dlid;
-                *ahid_addr = ah->id;
+                *ahid_addr = 0;
+                *ahid_addr |= ah->id & OCRDMA_AH_ID_MASK;
+                if (isvlan)
+                        *ahid_addr |= (OCRDMA_AH_VLAN_VALID_MASK <<
+                                       OCRDMA_AH_VLAN_VALID_SHIFT);
         }
+
         return &ah->ibah;
 
 av_conf_err:
@@ -191,5 +200,20 @@ int ocrdma_process_mad(struct ib_device *ibdev,
                        struct ib_grh *in_grh,
                        struct ib_mad *in_mad, struct ib_mad *out_mad)
 {
-        return IB_MAD_RESULT_SUCCESS;
+        int status;
+        struct ocrdma_dev *dev;
+
+        switch (in_mad->mad_hdr.mgmt_class) {
+        case IB_MGMT_CLASS_PERF_MGMT:
+                dev = get_ocrdma_dev(ibdev);
+                if (!ocrdma_pma_counters(dev, out_mad))
+                        status = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY;
+                else
+                        status = IB_MAD_RESULT_SUCCESS;
+                break;
+        default:
+                status = IB_MAD_RESULT_SUCCESS;
+                break;
+        }
+        return status;
 }
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_ah.h b/drivers/infiniband/hw/ocrdma/ocrdma_ah.h
index 8ac49e7f96d1..726a87cf22dc 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_ah.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_ah.h
@@ -28,6 +28,12 @@
 #ifndef __OCRDMA_AH_H__
 #define __OCRDMA_AH_H__
 
+enum {
+        OCRDMA_AH_ID_MASK               = 0x3FF,
+        OCRDMA_AH_VLAN_VALID_MASK       = 0x01,
+        OCRDMA_AH_VLAN_VALID_SHIFT      = 0x1F
+};
+
 struct ib_ah *ocrdma_create_ah(struct ib_pd *, struct ib_ah_attr *);
 int ocrdma_destroy_ah(struct ib_ah *);
 int ocrdma_query_ah(struct ib_ah *, struct ib_ah_attr *);
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_hw.c b/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
index 638bff1ffc6c..0c9e95909a64 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
@@ -734,6 +734,9 @@ static void ocrdma_dispatch_ibevent(struct ocrdma_dev *dev,
                 break;
         }
 
+        if (type < OCRDMA_MAX_ASYNC_ERRORS)
+                atomic_inc(&dev->async_err_stats[type]);
+
         if (qp_event) {
                 if (qp->ibqp.event_handler)
                         qp->ibqp.event_handler(&ib_evt, qp->ibqp.qp_context);
@@ -831,20 +834,20 @@ static int ocrdma_mq_cq_handler(struct ocrdma_dev *dev, u16 cq_id)
         return 0;
 }
 
-static void ocrdma_qp_buddy_cq_handler(struct ocrdma_dev *dev,
-                                       struct ocrdma_cq *cq)
+static struct ocrdma_cq *_ocrdma_qp_buddy_cq_handler(struct ocrdma_dev *dev,
+                                struct ocrdma_cq *cq, bool sq)
 {
-        unsigned long flags;
         struct ocrdma_qp *qp;
-        bool buddy_cq_found = false;
-        /* Go through list of QPs in error state which are using this CQ
-         * and invoke its callback handler to trigger CQE processing for
-         * error/flushed CQE. It is rare to find more than few entries in
-         * this list as most consumers stops after getting error CQE.
-         * List is traversed only once when a matching buddy cq found for a QP.
-         */
-        spin_lock_irqsave(&dev->flush_q_lock, flags);
-        list_for_each_entry(qp, &cq->sq_head, sq_entry) {
+        struct list_head *cur;
+        struct ocrdma_cq *bcq = NULL;
+        struct list_head *head = sq?(&cq->sq_head):(&cq->rq_head);
+
+        list_for_each(cur, head) {
+                if (sq)
+                        qp = list_entry(cur, struct ocrdma_qp, sq_entry);
+                else
+                        qp = list_entry(cur, struct ocrdma_qp, rq_entry);
+
                 if (qp->srq)
                         continue;
                 /* if wq and rq share the same cq, than comp_handler
@@ -856,19 +859,41 @@ static void ocrdma_qp_buddy_cq_handler(struct ocrdma_dev *dev,
                  * if completion came on rq, sq's cq is buddy cq.
                  */
                 if (qp->sq_cq == cq)
-                        cq = qp->rq_cq;
+                        bcq = qp->rq_cq;
                 else
-                        cq = qp->sq_cq;
-                buddy_cq_found = true;
-                break;
+                        bcq = qp->sq_cq;
+                return bcq;
         }
+        return NULL;
+}
+
+static void ocrdma_qp_buddy_cq_handler(struct ocrdma_dev *dev,
+                                       struct ocrdma_cq *cq)
+{
+        unsigned long flags;
+        struct ocrdma_cq *bcq = NULL;
+
+        /* Go through list of QPs in error state which are using this CQ
+         * and invoke its callback handler to trigger CQE processing for
+         * error/flushed CQE. It is rare to find more than few entries in
+         * this list as most consumers stops after getting error CQE.
+         * List is traversed only once when a matching buddy cq found for a QP.
+         */
+        spin_lock_irqsave(&dev->flush_q_lock, flags);
+        /* Check if buddy CQ is present.
+         * true - Check for  SQ CQ
+         * false - Check for RQ CQ
+         */
+        bcq = _ocrdma_qp_buddy_cq_handler(dev, cq, true);
+        if (bcq == NULL)
+                bcq = _ocrdma_qp_buddy_cq_handler(dev, cq, false);
         spin_unlock_irqrestore(&dev->flush_q_lock, flags);
-        if (buddy_cq_found == false)
-                return;
-        if (cq->ibcq.comp_handler) {
-                spin_lock_irqsave(&cq->comp_handler_lock, flags);
-                (*cq->ibcq.comp_handler) (&cq->ibcq, cq->ibcq.cq_context);
-                spin_unlock_irqrestore(&cq->comp_handler_lock, flags);
+
+        /* if there is valid buddy cq, look for its completion handler */
+        if (bcq && bcq->ibcq.comp_handler) {
+                spin_lock_irqsave(&bcq->comp_handler_lock, flags);
+                (*bcq->ibcq.comp_handler) (&bcq->ibcq, bcq->ibcq.cq_context);
+                spin_unlock_irqrestore(&bcq->comp_handler_lock, flags);
         }
 }
 
@@ -935,6 +960,7 @@ static irqreturn_t ocrdma_irq_handler(int irq, void *handle)
 
         } while (budget);
 
+        eq->aic_obj.eq_intr_cnt++;
         ocrdma_ring_eq_db(dev, eq->q.id, true, true, 0);
         return IRQ_HANDLED;
 }
@@ -1050,6 +1076,9 @@ static void ocrdma_get_attr(struct ocrdma_dev *dev,
         attr->max_pd =
             (rsp->max_pd_ca_ack_delay & OCRDMA_MBX_QUERY_CFG_MAX_PD_MASK) >>
             OCRDMA_MBX_QUERY_CFG_MAX_PD_SHIFT;
+        attr->max_dpp_pds =
+           (rsp->max_dpp_pds_credits & OCRDMA_MBX_QUERY_CFG_MAX_DPP_PDS_MASK) >>
+            OCRDMA_MBX_QUERY_CFG_MAX_DPP_PDS_OFFSET;
         attr->max_qp =
             (rsp->qp_srq_cq_ird_ord & OCRDMA_MBX_QUERY_CFG_MAX_QP_MASK) >>
             OCRDMA_MBX_QUERY_CFG_MAX_QP_SHIFT;
@@ -1396,6 +1425,122 @@ int ocrdma_mbx_dealloc_pd(struct ocrdma_dev *dev, struct ocrdma_pd *pd)
         return status;
 }
 
+
+static int ocrdma_mbx_alloc_pd_range(struct ocrdma_dev *dev)
+{
+        int status = -ENOMEM;
+        size_t pd_bitmap_size;
+        struct ocrdma_alloc_pd_range *cmd;
+        struct ocrdma_alloc_pd_range_rsp *rsp;
+
+        /* Pre allocate the DPP PDs */
+        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_ALLOC_PD_RANGE, sizeof(*cmd));
+        if (!cmd)
+                return -ENOMEM;
+        cmd->pd_count = dev->attr.max_dpp_pds;
+        cmd->enable_dpp_rsvd |= OCRDMA_ALLOC_PD_ENABLE_DPP;
+        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
+        if (status)
+                goto mbx_err;
+        rsp = (struct ocrdma_alloc_pd_range_rsp *)cmd;
+
+        if ((rsp->dpp_page_pdid & OCRDMA_ALLOC_PD_RSP_DPP) && rsp->pd_count) {
+                dev->pd_mgr->dpp_page_index = rsp->dpp_page_pdid >>
+                                OCRDMA_ALLOC_PD_RSP_DPP_PAGE_SHIFT;
+                dev->pd_mgr->pd_dpp_start = rsp->dpp_page_pdid &
+                                OCRDMA_ALLOC_PD_RNG_RSP_START_PDID_MASK;
+                dev->pd_mgr->max_dpp_pd = rsp->pd_count;
+                pd_bitmap_size = BITS_TO_LONGS(rsp->pd_count) * sizeof(long);
+                dev->pd_mgr->pd_dpp_bitmap = kzalloc(pd_bitmap_size,
+                                                     GFP_KERNEL);
+        }
+        kfree(cmd);
+
+        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_ALLOC_PD_RANGE, sizeof(*cmd));
+        if (!cmd)
+                return -ENOMEM;
+
+        cmd->pd_count = dev->attr.max_pd - dev->attr.max_dpp_pds;
+        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
+        if (status)
+                goto mbx_err;
+        rsp = (struct ocrdma_alloc_pd_range_rsp *)cmd;
+        if (rsp->pd_count) {
+                dev->pd_mgr->pd_norm_start = rsp->dpp_page_pdid &
+                                        OCRDMA_ALLOC_PD_RNG_RSP_START_PDID_MASK;
+                dev->pd_mgr->max_normal_pd = rsp->pd_count;
+                pd_bitmap_size = BITS_TO_LONGS(rsp->pd_count) * sizeof(long);
+                dev->pd_mgr->pd_norm_bitmap = kzalloc(pd_bitmap_size,
+                                                      GFP_KERNEL);
+        }
+
+        if (dev->pd_mgr->pd_norm_bitmap || dev->pd_mgr->pd_dpp_bitmap) {
+                /* Enable PD resource manager */
+                dev->pd_mgr->pd_prealloc_valid = true;
+        } else {
+                return -ENOMEM;
+        }
+mbx_err:
+        kfree(cmd);
+        return status;
+}
+
+static void ocrdma_mbx_dealloc_pd_range(struct ocrdma_dev *dev)
+{
+        struct ocrdma_dealloc_pd_range *cmd;
+
+        /* return normal PDs to firmware */
+        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_DEALLOC_PD_RANGE, sizeof(*cmd));
+        if (!cmd)
+                goto mbx_err;
+
+        if (dev->pd_mgr->max_normal_pd) {
+                cmd->start_pd_id = dev->pd_mgr->pd_norm_start;
+                cmd->pd_count = dev->pd_mgr->max_normal_pd;
+                ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
+        }
+
+        if (dev->pd_mgr->max_dpp_pd) {
+                kfree(cmd);
+                /* return DPP PDs to firmware */
+                cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_DEALLOC_PD_RANGE,
+                                          sizeof(*cmd));
+                if (!cmd)
+                        goto mbx_err;
+
+                cmd->start_pd_id = dev->pd_mgr->pd_dpp_start;
+                cmd->pd_count = dev->pd_mgr->max_dpp_pd;
+                ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
+        }
+mbx_err:
+        kfree(cmd);
+}
+
+void ocrdma_alloc_pd_pool(struct ocrdma_dev *dev)
+{
+        int status;
+
+        dev->pd_mgr = kzalloc(sizeof(struct ocrdma_pd_resource_mgr),
+                              GFP_KERNEL);
+        if (!dev->pd_mgr) {
+                pr_err("%s(%d)Memory allocation failure.\n", __func__, dev->id);
+                return;
+        }
+        status = ocrdma_mbx_alloc_pd_range(dev);
+        if (status) {
+                pr_err("%s(%d) Unable to initialize PD pool, using default.\n",
+                         __func__, dev->id);
+        }
+}
+
+static void ocrdma_free_pd_pool(struct ocrdma_dev *dev)
+{
+        ocrdma_mbx_dealloc_pd_range(dev);
+        kfree(dev->pd_mgr->pd_norm_bitmap);
+        kfree(dev->pd_mgr->pd_dpp_bitmap);
+        kfree(dev->pd_mgr);
+}
+
 static int ocrdma_build_q_conf(u32 *num_entries, int entry_size,
                                int *num_pages, int *page_size)
 {
@@ -1896,8 +2041,9 @@ void ocrdma_flush_qp(struct ocrdma_qp *qp)
 {
         bool found;
         unsigned long flags;
+        struct ocrdma_dev *dev = get_ocrdma_dev(qp->ibqp.device);
 
-        spin_lock_irqsave(&qp->dev->flush_q_lock, flags);
+        spin_lock_irqsave(&dev->flush_q_lock, flags);
         found = ocrdma_is_qp_in_sq_flushlist(qp->sq_cq, qp);
         if (!found)
                 list_add_tail(&qp->sq_entry, &qp->sq_cq->sq_head);
@@ -1906,7 +2052,7 @@ void ocrdma_flush_qp(struct ocrdma_qp *qp)
                 if (!found)
                         list_add_tail(&qp->rq_entry, &qp->rq_cq->rq_head);
         }
-        spin_unlock_irqrestore(&qp->dev->flush_q_lock, flags);
+        spin_unlock_irqrestore(&dev->flush_q_lock, flags);
 }
 
 static void ocrdma_init_hwq_ptr(struct ocrdma_qp *qp)
@@ -1972,7 +2118,8 @@ static int ocrdma_set_create_qp_sq_cmd(struct ocrdma_create_qp_req *cmd,
         int status;
         u32 len, hw_pages, hw_page_size;
         dma_addr_t pa;
-        struct ocrdma_dev *dev = qp->dev;
+        struct ocrdma_pd *pd = qp->pd;
+        struct ocrdma_dev *dev = get_ocrdma_dev(pd->ibpd.device);
         struct pci_dev *pdev = dev->nic_info.pdev;
         u32 max_wqe_allocated;
         u32 max_sges = attrs->cap.max_send_sge;
@@ -2027,7 +2174,8 @@ static int ocrdma_set_create_qp_rq_cmd(struct ocrdma_create_qp_req *cmd,
         int status;
         u32 len, hw_pages, hw_page_size;
         dma_addr_t pa = 0;
-        struct ocrdma_dev *dev = qp->dev;
+        struct ocrdma_pd *pd = qp->pd;
+        struct ocrdma_dev *dev = get_ocrdma_dev(pd->ibpd.device);
         struct pci_dev *pdev = dev->nic_info.pdev;
         u32 max_rqe_allocated = attrs->cap.max_recv_wr + 1;
 
@@ -2086,7 +2234,8 @@ static void ocrdma_set_create_qp_dpp_cmd(struct ocrdma_create_qp_req *cmd,
 static int ocrdma_set_create_qp_ird_cmd(struct ocrdma_create_qp_req *cmd,
                                         struct ocrdma_qp *qp)
 {
-        struct ocrdma_dev *dev = qp->dev;
+        struct ocrdma_pd *pd = qp->pd;
+        struct ocrdma_dev *dev = get_ocrdma_dev(pd->ibpd.device);
         struct pci_dev *pdev = dev->nic_info.pdev;
         dma_addr_t pa = 0;
         int ird_page_size = dev->attr.ird_page_size;
@@ -2157,8 +2306,8 @@ int ocrdma_mbx_create_qp(struct ocrdma_qp *qp, struct ib_qp_init_attr *attrs,
 {
         int status = -ENOMEM;
         u32 flags = 0;
-        struct ocrdma_dev *dev = qp->dev;
         struct ocrdma_pd *pd = qp->pd;
+        struct ocrdma_dev *dev = get_ocrdma_dev(pd->ibpd.device);
         struct pci_dev *pdev = dev->nic_info.pdev;
         struct ocrdma_cq *cq;
         struct ocrdma_create_qp_req *cmd;
@@ -2281,11 +2430,12 @@ static int ocrdma_set_av_params(struct ocrdma_qp *qp,
         union ib_gid sgid, zgid;
         u32 vlan_id;
         u8 mac_addr[6];
+        struct ocrdma_dev *dev = get_ocrdma_dev(qp->ibqp.device);
 
         if ((ah_attr->ah_flags & IB_AH_GRH) == 0)
                 return -EINVAL;
-        if (atomic_cmpxchg(&qp->dev->update_sl, 1, 0))
-                ocrdma_init_service_level(qp->dev);
+        if (atomic_cmpxchg(&dev->update_sl, 1, 0))
+                ocrdma_init_service_level(dev);
         cmd->params.tclass_sq_psn |=
             (ah_attr->grh.traffic_class << OCRDMA_QP_PARAMS_TCLASS_SHIFT);
         cmd->params.rnt_rc_sl_fl |=
@@ -2296,7 +2446,7 @@ static int ocrdma_set_av_params(struct ocrdma_qp *qp,
         cmd->flags |= OCRDMA_QP_PARA_FLOW_LBL_VALID;
         memcpy(&cmd->params.dgid[0], &ah_attr->grh.dgid.raw[0],
                sizeof(cmd->params.dgid));
-        status = ocrdma_query_gid(&qp->dev->ibdev, 1,
+        status = ocrdma_query_gid(&dev->ibdev, 1,
                         ah_attr->grh.sgid_index, &sgid);
         if (status)
                 return status;
@@ -2307,7 +2457,9 @@ static int ocrdma_set_av_params(struct ocrdma_qp *qp,
 
         qp->sgid_idx = ah_attr->grh.sgid_index;
         memcpy(&cmd->params.sgid[0], &sgid.raw[0], sizeof(cmd->params.sgid));
-        ocrdma_resolve_dmac(qp->dev, ah_attr, &mac_addr[0]);
+        status = ocrdma_resolve_dmac(dev, ah_attr, &mac_addr[0]);
+        if (status)
+                return status;
         cmd->params.dmac_b0_to_b3 = mac_addr[0] | (mac_addr[1] << 8) |
                                 (mac_addr[2] << 16) | (mac_addr[3] << 24);
         /* convert them to LE format. */
@@ -2320,7 +2472,7 @@ static int ocrdma_set_av_params(struct ocrdma_qp *qp,
                     vlan_id << OCRDMA_QP_PARAMS_VLAN_SHIFT;
                 cmd->flags |= OCRDMA_QP_PARA_VLAN_EN_VALID;
                 cmd->params.rnt_rc_sl_fl |=
-                        (qp->dev->sl & 0x07) << OCRDMA_QP_PARAMS_SL_SHIFT;
+                        (dev->sl & 0x07) << OCRDMA_QP_PARAMS_SL_SHIFT;
         }
         return 0;
 }
@@ -2330,6 +2482,7 @@ static int ocrdma_set_qp_params(struct ocrdma_qp *qp,
                                 struct ib_qp_attr *attrs, int attr_mask)
 {
         int status = 0;
+        struct ocrdma_dev *dev = get_ocrdma_dev(qp->ibqp.device);
 
         if (attr_mask & IB_QP_PKEY_INDEX) {
                 cmd->params.path_mtu_pkey_indx |= (attrs->pkey_index &
@@ -2347,12 +2500,12 @@ static int ocrdma_set_qp_params(struct ocrdma_qp *qp,
                         return status;
         } else if (qp->qp_type == IB_QPT_GSI || qp->qp_type == IB_QPT_UD) {
                 /* set the default mac address for UD, GSI QPs */
-                cmd->params.dmac_b0_to_b3 = qp->dev->nic_info.mac_addr[0] |
-                        (qp->dev->nic_info.mac_addr[1] << 8) |
-                        (qp->dev->nic_info.mac_addr[2] << 16) |
-                        (qp->dev->nic_info.mac_addr[3] << 24);
-                cmd->params.vlan_dmac_b4_to_b5 = qp->dev->nic_info.mac_addr[4] |
-                                        (qp->dev->nic_info.mac_addr[5] << 8);
+                cmd->params.dmac_b0_to_b3 = dev->nic_info.mac_addr[0] |
+                        (dev->nic_info.mac_addr[1] << 8) |
+                        (dev->nic_info.mac_addr[2] << 16) |
+                        (dev->nic_info.mac_addr[3] << 24);
+                cmd->params.vlan_dmac_b4_to_b5 = dev->nic_info.mac_addr[4] |
+                                        (dev->nic_info.mac_addr[5] << 8);
         }
         if ((attr_mask & IB_QP_EN_SQD_ASYNC_NOTIFY) &&
             attrs->en_sqd_async_notify) {
@@ -2409,7 +2562,7 @@ static int ocrdma_set_qp_params(struct ocrdma_qp *qp,
                 cmd->flags |= OCRDMA_QP_PARA_RQPSN_VALID;
         }
         if (attr_mask & IB_QP_MAX_QP_RD_ATOMIC) {
-                if (attrs->max_rd_atomic > qp->dev->attr.max_ord_per_qp) {
+                if (attrs->max_rd_atomic > dev->attr.max_ord_per_qp) {
                         status = -EINVAL;
                         goto pmtu_err;
                 }
@@ -2417,7 +2570,7 @@ static int ocrdma_set_qp_params(struct ocrdma_qp *qp,
                 cmd->flags |= OCRDMA_QP_PARA_MAX_ORD_VALID;
         }
         if (attr_mask & IB_QP_MAX_DEST_RD_ATOMIC) {
-                if (attrs->max_dest_rd_atomic > qp->dev->attr.max_ird_per_qp) {
+                if (attrs->max_dest_rd_atomic > dev->attr.max_ird_per_qp) {
                         status = -EINVAL;
                         goto pmtu_err;
                 }
@@ -2870,6 +3023,82 @@ done:
         return status;
 }
 
+static int ocrdma_mbx_modify_eqd(struct ocrdma_dev *dev, struct ocrdma_eq *eq,
+                                 int num)
+{
+        int i, status = -ENOMEM;
+        struct ocrdma_modify_eqd_req *cmd;
+
+        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_MODIFY_EQ_DELAY, sizeof(*cmd));
+        if (!cmd)
+                return status;
+
+        ocrdma_init_mch(&cmd->cmd.req, OCRDMA_CMD_MODIFY_EQ_DELAY,
+                        OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
+
+        cmd->cmd.num_eq = num;
+        for (i = 0; i < num; i++) {
+                cmd->cmd.set_eqd[i].eq_id = eq[i].q.id;
+                cmd->cmd.set_eqd[i].phase = 0;
+                cmd->cmd.set_eqd[i].delay_multiplier =
+                                (eq[i].aic_obj.prev_eqd * 65)/100;
+        }
+        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
+        if (status)
+                goto mbx_err;
+mbx_err:
+        kfree(cmd);
+        return status;
+}
+
+static int ocrdma_modify_eqd(struct ocrdma_dev *dev, struct ocrdma_eq *eq,
+                             int num)
+{
+        int num_eqs, i = 0;
+        if (num > 8) {
+                while (num) {
+                        num_eqs = min(num, 8);
+                        ocrdma_mbx_modify_eqd(dev, &eq[i], num_eqs);
+                        i += num_eqs;
+                        num -= num_eqs;
+                }
+        } else {
+                ocrdma_mbx_modify_eqd(dev, eq, num);
+        }
+        return 0;
+}
+
+void ocrdma_eqd_set_task(struct work_struct *work)
+{
+        struct ocrdma_dev *dev =
+                container_of(work, struct ocrdma_dev, eqd_work.work);
+        struct ocrdma_eq *eq = 0;
+        int i, num = 0, status = -EINVAL;
+        u64 eq_intr;
+
+        for (i = 0; i < dev->eq_cnt; i++) {
+                eq = &dev->eq_tbl[i];
+                if (eq->aic_obj.eq_intr_cnt > eq->aic_obj.prev_eq_intr_cnt) {
+                        eq_intr = eq->aic_obj.eq_intr_cnt -
+                                  eq->aic_obj.prev_eq_intr_cnt;
+                        if ((eq_intr > EQ_INTR_PER_SEC_THRSH_HI) &&
+                            (eq->aic_obj.prev_eqd == EQ_AIC_MIN_EQD)) {
+                                eq->aic_obj.prev_eqd = EQ_AIC_MAX_EQD;
+                                num++;
+                        } else if ((eq_intr < EQ_INTR_PER_SEC_THRSH_LOW) &&
+                                   (eq->aic_obj.prev_eqd == EQ_AIC_MAX_EQD)) {
+                                eq->aic_obj.prev_eqd = EQ_AIC_MIN_EQD;
+                                num++;
+                        }
+                }
+                eq->aic_obj.prev_eq_intr_cnt = eq->aic_obj.eq_intr_cnt;
+        }
+
+        if (num)
+                status = ocrdma_modify_eqd(dev, &dev->eq_tbl[0], num);
+        schedule_delayed_work(&dev->eqd_work, msecs_to_jiffies(1000));
+}
+
 int ocrdma_init_hw(struct ocrdma_dev *dev)
 {
         int status;
@@ -2915,6 +3144,7 @@ qpeq_err:
 
 void ocrdma_cleanup_hw(struct ocrdma_dev *dev)
 {
+        ocrdma_free_pd_pool(dev);
         ocrdma_mbx_delete_ah_tbl(dev);
 
         /* cleanup the eqs */
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_hw.h b/drivers/infiniband/hw/ocrdma/ocrdma_hw.h
index 6eed8f191322..e905972fceb7 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_hw.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_hw.h
@@ -136,5 +136,7 @@ int ocrdma_get_irq(struct ocrdma_dev *dev, struct ocrdma_eq *eq);
 int ocrdma_mbx_rdma_stats(struct ocrdma_dev *, bool reset);
 char *port_speed_string(struct ocrdma_dev *dev);
 void ocrdma_init_service_level(struct ocrdma_dev *);
+void ocrdma_alloc_pd_pool(struct ocrdma_dev *dev);
+void ocrdma_free_pd_range(struct ocrdma_dev *dev);
 
 #endif                          /* __OCRDMA_HW_H__ */
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_main.c b/drivers/infiniband/hw/ocrdma/ocrdma_main.c
index b0b2257b8e04..7a2b59aca004 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_main.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_main.c
@@ -239,7 +239,7 @@ static int ocrdma_register_device(struct ocrdma_dev *dev)
 
         dev->ibdev.node_type = RDMA_NODE_IB_CA;
         dev->ibdev.phys_port_cnt = 1;
-        dev->ibdev.num_comp_vectors = 1;
+        dev->ibdev.num_comp_vectors = dev->eq_cnt;
 
         /* mandatory verbs. */
         dev->ibdev.query_device = ocrdma_query_device;
@@ -329,6 +329,8 @@ static int ocrdma_alloc_resources(struct ocrdma_dev *dev)
         if (dev->stag_arr == NULL)
                 goto alloc_err;
 
+        ocrdma_alloc_pd_pool(dev);
+
         spin_lock_init(&dev->av_tbl.lock);
         spin_lock_init(&dev->flush_q_lock);
         return 0;
@@ -491,6 +493,9 @@ static struct ocrdma_dev *ocrdma_add(struct be_dev_info *dev_info)
         spin_unlock(&ocrdma_devlist_lock);
         /* Init stats */
         ocrdma_add_port_stats(dev);
+        /* Interrupt Moderation */
+        INIT_DELAYED_WORK(&dev->eqd_work, ocrdma_eqd_set_task);
+        schedule_delayed_work(&dev->eqd_work, msecs_to_jiffies(1000));
 
         pr_info("%s %s: %s \"%s\" port %d\n",
                 dev_name(&dev->nic_info.pdev->dev), hca_name(dev),
@@ -528,11 +533,12 @@ static void ocrdma_remove(struct ocrdma_dev *dev)
         /* first unregister with stack to stop all the active traffic
          * of the registered clients.
          */
-        ocrdma_rem_port_stats(dev);
+        cancel_delayed_work_sync(&dev->eqd_work);
         ocrdma_remove_sysfiles(dev);
-
         ib_unregister_device(&dev->ibdev);
 
+        ocrdma_rem_port_stats(dev);
+
         spin_lock(&ocrdma_devlist_lock);
         list_del_rcu(&dev->entry);
         spin_unlock(&ocrdma_devlist_lock);
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_sli.h b/drivers/infiniband/hw/ocrdma/ocrdma_sli.h
index 4e036480c1a8..243c87c8bd65 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_sli.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_sli.h
@@ -75,6 +75,8 @@ enum {
         OCRDMA_CMD_DESTROY_RBQ = 26,
 
         OCRDMA_CMD_GET_RDMA_STATS = 27,
+        OCRDMA_CMD_ALLOC_PD_RANGE = 28,
+        OCRDMA_CMD_DEALLOC_PD_RANGE = 29,
 
         OCRDMA_CMD_MAX
 };
@@ -87,6 +89,7 @@ enum {
         OCRDMA_CMD_CREATE_MQ            = 21,
         OCRDMA_CMD_GET_CTRL_ATTRIBUTES  = 32,
         OCRDMA_CMD_GET_FW_VER           = 35,
+        OCRDMA_CMD_MODIFY_EQ_DELAY      = 41,
         OCRDMA_CMD_DELETE_MQ            = 53,
         OCRDMA_CMD_DELETE_CQ            = 54,
         OCRDMA_CMD_DELETE_EQ            = 55,
@@ -101,7 +104,7 @@ enum {
         QTYPE_MCCQ      = 3
 };
 
-#define OCRDMA_MAX_SGID         8
+#define OCRDMA_MAX_SGID         16
 
 #define OCRDMA_MAX_QP    2048
 #define OCRDMA_MAX_CQ    2048
@@ -314,6 +317,29 @@ struct ocrdma_create_eq_rsp {
 
 #define OCRDMA_EQ_MINOR_OTHER   0x1
 
+struct ocrmda_set_eqd {
+        u32 eq_id;
+        u32 phase;
+        u32 delay_multiplier;
+};
+
+struct ocrdma_modify_eqd_cmd {
+        struct ocrdma_mbx_hdr req;
+        u32 num_eq;
+        struct ocrmda_set_eqd set_eqd[8];
+} __packed;
+
+struct ocrdma_modify_eqd_req {
+        struct ocrdma_mqe_hdr hdr;
+        struct ocrdma_modify_eqd_cmd cmd;
+};
+
+
+struct ocrdma_modify_eq_delay_rsp {
+        struct ocrdma_mbx_rsp hdr;
+        u32 rsvd0;
+} __packed;
+
 enum {
         OCRDMA_MCQE_STATUS_SHIFT        = 0,
         OCRDMA_MCQE_STATUS_MASK         = 0xFFFF,
@@ -441,7 +467,9 @@ enum OCRDMA_ASYNC_EVENT_TYPE {
         OCRDMA_DEVICE_FATAL_EVENT       = 0x08,
         OCRDMA_SRQCAT_ERROR             = 0x0E,
         OCRDMA_SRQ_LIMIT_EVENT          = 0x0F,
-        OCRDMA_QP_LAST_WQE_EVENT        = 0x10
+        OCRDMA_QP_LAST_WQE_EVENT        = 0x10,
+
+        OCRDMA_MAX_ASYNC_ERRORS
 };
 
 /* mailbox command request and responses */
@@ -1297,6 +1325,37 @@ struct ocrdma_dealloc_pd_rsp {
         struct ocrdma_mbx_rsp rsp;
 };
 
+struct ocrdma_alloc_pd_range {
+        struct ocrdma_mqe_hdr hdr;
+        struct ocrdma_mbx_hdr req;
+        u32 enable_dpp_rsvd;
+        u32 pd_count;
+};
+
+struct ocrdma_alloc_pd_range_rsp {
+        struct ocrdma_mqe_hdr hdr;
+        struct ocrdma_mbx_rsp rsp;
+        u32 dpp_page_pdid;
+        u32 pd_count;
+};
+
+enum {
+        OCRDMA_ALLOC_PD_RNG_RSP_START_PDID_MASK = 0xFFFF,
+};
+
+struct ocrdma_dealloc_pd_range {
+        struct ocrdma_mqe_hdr hdr;
+        struct ocrdma_mbx_hdr req;
+        u32 start_pd_id;
+        u32 pd_count;
+};
+
+struct ocrdma_dealloc_pd_range_rsp {
+        struct ocrdma_mqe_hdr hdr;
+        struct ocrdma_mbx_hdr req;
+        u32 rsvd;
+};
+
 enum {
         OCRDMA_ADDR_CHECK_ENABLE        = 1,
         OCRDMA_ADDR_CHECK_DISABLE       = 0
@@ -1597,7 +1656,9 @@ enum OCRDMA_CQE_STATUS {
         OCRDMA_CQE_INV_EEC_STATE_ERR,
         OCRDMA_CQE_FATAL_ERR,
         OCRDMA_CQE_RESP_TIMEOUT_ERR,
-        OCRDMA_CQE_GENERAL_ERR
+        OCRDMA_CQE_GENERAL_ERR,
+
+        OCRDMA_MAX_CQE_ERR
 };
 
 enum {
@@ -1673,6 +1734,7 @@ enum {
         OCRDMA_FLAG_FENCE_R     = 0x8,
         OCRDMA_FLAG_SOLICIT     = 0x10,
         OCRDMA_FLAG_IMM         = 0x20,
+        OCRDMA_FLAG_AH_VLAN_PR  = 0x40,
 
         /* Stag flags */
         OCRDMA_LKEY_FLAG_LOCAL_WR       = 0x1,
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_stats.c b/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
index 41a9aec9998d..48d7ef51aa0c 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
@@ -26,6 +26,7 @@
  *******************************************************************/
 
 #include <rdma/ib_addr.h>
+#include <rdma/ib_pma.h>
 #include "ocrdma_stats.h"
 
 static struct dentry *ocrdma_dbgfs_dir;
@@ -249,6 +250,27 @@ static char *ocrdma_rx_stats(struct ocrdma_dev *dev)
         return stats;
 }
 
+static u64 ocrdma_sysfs_rcv_pkts(struct ocrdma_dev *dev)
+{
+        struct ocrdma_rdma_stats_resp *rdma_stats =
+                (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va;
+        struct ocrdma_rx_stats *rx_stats = &rdma_stats->rx_stats;
+
+        return convert_to_64bit(rx_stats->roce_frames_lo,
+                rx_stats->roce_frames_hi) + (u64)rx_stats->roce_frame_icrc_drops
+                + (u64)rx_stats->roce_frame_payload_len_drops;
+}
+
+static u64 ocrdma_sysfs_rcv_data(struct ocrdma_dev *dev)
+{
+        struct ocrdma_rdma_stats_resp *rdma_stats =
+                (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va;
+        struct ocrdma_rx_stats *rx_stats = &rdma_stats->rx_stats;
+
+        return (convert_to_64bit(rx_stats->roce_frame_bytes_lo,
+                rx_stats->roce_frame_bytes_hi))/4;
+}
+
 static char *ocrdma_tx_stats(struct ocrdma_dev *dev)
 {
         char *stats = dev->stats_mem.debugfs_mem, *pcur;
@@ -292,6 +314,37 @@ static char *ocrdma_tx_stats(struct ocrdma_dev *dev)
         return stats;
 }
 
+static u64 ocrdma_sysfs_xmit_pkts(struct ocrdma_dev *dev)
+{
+        struct ocrdma_rdma_stats_resp *rdma_stats =
+                (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va;
+        struct ocrdma_tx_stats *tx_stats = &rdma_stats->tx_stats;
+
+        return (convert_to_64bit(tx_stats->send_pkts_lo,
+                                 tx_stats->send_pkts_hi) +
+        convert_to_64bit(tx_stats->write_pkts_lo, tx_stats->write_pkts_hi) +
+        convert_to_64bit(tx_stats->read_pkts_lo, tx_stats->read_pkts_hi) +
+        convert_to_64bit(tx_stats->read_rsp_pkts_lo,
+                         tx_stats->read_rsp_pkts_hi) +
+        convert_to_64bit(tx_stats->ack_pkts_lo, tx_stats->ack_pkts_hi));
+}
+
+static u64 ocrdma_sysfs_xmit_data(struct ocrdma_dev *dev)
+{
+        struct ocrdma_rdma_stats_resp *rdma_stats =
+                (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va;
+        struct ocrdma_tx_stats *tx_stats = &rdma_stats->tx_stats;
+
+        return (convert_to_64bit(tx_stats->send_bytes_lo,
+                                 tx_stats->send_bytes_hi) +
+                convert_to_64bit(tx_stats->write_bytes_lo,
+                                 tx_stats->write_bytes_hi) +
+                convert_to_64bit(tx_stats->read_req_bytes_lo,
+                                 tx_stats->read_req_bytes_hi) +
+                convert_to_64bit(tx_stats->read_rsp_bytes_lo,
+                                 tx_stats->read_rsp_bytes_hi))/4;
+}
+
 static char *ocrdma_wqe_stats(struct ocrdma_dev *dev)
 {
         char *stats = dev->stats_mem.debugfs_mem, *pcur;
@@ -432,10 +485,118 @@ static char *ocrdma_rx_dbg_stats(struct ocrdma_dev *dev)
         return dev->stats_mem.debugfs_mem;
 }
 
+static char *ocrdma_driver_dbg_stats(struct ocrdma_dev *dev)
+{
+        char *stats = dev->stats_mem.debugfs_mem, *pcur;
+
+
+        memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM));
+
+        pcur = stats;
+        pcur += ocrdma_add_stat(stats, pcur, "async_cq_err",
+                                (u64)(dev->async_err_stats
+                                [OCRDMA_CQ_ERROR].counter));
+        pcur += ocrdma_add_stat(stats, pcur, "async_cq_overrun_err",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_CQ_OVERRUN_ERROR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "async_cq_qpcat_err",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_CQ_QPCAT_ERROR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "async_qp_access_err",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_QP_ACCESS_ERROR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "async_qp_commm_est_evt",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_QP_COMM_EST_EVENT].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "async_sq_drained_evt",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_SQ_DRAINED_EVENT].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "async_dev_fatal_evt",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_DEVICE_FATAL_EVENT].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "async_srqcat_err",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_SRQCAT_ERROR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "async_srq_limit_evt",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_SRQ_LIMIT_EVENT].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "async_qp_last_wqe_evt",
+                                (u64)dev->async_err_stats
+                                [OCRDMA_QP_LAST_WQE_EVENT].counter);
+
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_len_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_LOC_LEN_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_qp_op_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_LOC_QP_OP_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_eec_op_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_LOC_EEC_OP_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_prot_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_LOC_PROT_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_wr_flush_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_WR_FLUSH_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_mw_bind_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_MW_BIND_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_bad_resp_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_BAD_RESP_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_access_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_LOC_ACCESS_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_inv_req_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_REM_INV_REQ_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_access_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_REM_ACCESS_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_op_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_REM_OP_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_retry_exc_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_RETRY_EXC_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_rnr_retry_exc_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_RNR_RETRY_EXC_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_rdd_viol_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_LOC_RDD_VIOL_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_inv_rd_req_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_REM_INV_RD_REQ_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_abort_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_REM_ABORT_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_inv_eecn_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_INV_EECN_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_inv_eec_state_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_INV_EEC_STATE_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_fatal_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_FATAL_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_resp_timeout_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_RESP_TIMEOUT_ERR].counter);
+        pcur += ocrdma_add_stat(stats, pcur, "cqe_general_err",
+                                (u64)dev->cqe_err_stats
+                                [OCRDMA_CQE_GENERAL_ERR].counter);
+        return stats;
+}
+
 static void ocrdma_update_stats(struct ocrdma_dev *dev)
 {
         ulong now = jiffies, secs;
         int status = 0;
+        struct ocrdma_rdma_stats_resp *rdma_stats =
+                      (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va;
+        struct ocrdma_rsrc_stats *rsrc_stats = &rdma_stats->act_rsrc_stats;
 
         secs = jiffies_to_msecs(now - dev->last_stats_time) / 1000U;
         if (secs) {
@@ -444,10 +605,74 @@ static void ocrdma_update_stats(struct ocrdma_dev *dev)
                 if (status)
                         pr_err("%s: stats mbox failed with status = %d\n",
                                __func__, status);
+                /* Update PD counters from PD resource manager */
+                if (dev->pd_mgr->pd_prealloc_valid) {
+                        rsrc_stats->dpp_pds = dev->pd_mgr->pd_dpp_count;
+                        rsrc_stats->non_dpp_pds = dev->pd_mgr->pd_norm_count;
+                        /* Threshold stata*/
+                        rsrc_stats = &rdma_stats->th_rsrc_stats;
+                        rsrc_stats->dpp_pds = dev->pd_mgr->pd_dpp_thrsh;
+                        rsrc_stats->non_dpp_pds = dev->pd_mgr->pd_norm_thrsh;
+                }
                 dev->last_stats_time = jiffies;
         }
 }
 
+static ssize_t ocrdma_dbgfs_ops_write(struct file *filp,
+                                        const char __user *buffer,
+                                        size_t count, loff_t *ppos)
+{
+        char tmp_str[32];
+        long reset;
+        int status = 0;
+        struct ocrdma_stats *pstats = filp->private_data;
+        struct ocrdma_dev *dev = pstats->dev;
+
+        if (count > 32)
+                goto err;
+
+        if (copy_from_user(tmp_str, buffer, count))
+                goto err;
+
+        tmp_str[count-1] = '\0';
+        if (kstrtol(tmp_str, 10, &reset))
+                goto err;
+
+        switch (pstats->type) {
+        case OCRDMA_RESET_STATS:
+                if (reset) {
+                        status = ocrdma_mbx_rdma_stats(dev, true);
+                        if (status) {
+                                pr_err("Failed to reset stats = %d", status);
+                                goto err;
+                        }
+                }
+                break;
+        default:
+                goto err;
+        }
+
+        return count;
+err:
+        return -EFAULT;
+}
+
+int ocrdma_pma_counters(struct ocrdma_dev *dev,
+                        struct ib_mad *out_mad)
+{
+        struct ib_pma_portcounters *pma_cnt;
+
+        memset(out_mad->data, 0, sizeof out_mad->data);
+        pma_cnt = (void *)(out_mad->data + 40);
+        ocrdma_update_stats(dev);
+
+        pma_cnt->port_xmit_data    = cpu_to_be32(ocrdma_sysfs_xmit_data(dev));
+        pma_cnt->port_rcv_data     = cpu_to_be32(ocrdma_sysfs_rcv_data(dev));
+        pma_cnt->port_xmit_packets = cpu_to_be32(ocrdma_sysfs_xmit_pkts(dev));
+        pma_cnt->port_rcv_packets  = cpu_to_be32(ocrdma_sysfs_rcv_pkts(dev));
+        return 0;
+}
+
 static ssize_t ocrdma_dbgfs_ops_read(struct file *filp, char __user *buffer,
                                         size_t usr_buf_len, loff_t *ppos)
 {
@@ -492,6 +717,9 @@ static ssize_t ocrdma_dbgfs_ops_read(struct file *filp, char __user *buffer,
         case OCRDMA_RX_DBG_STATS:
                 data = ocrdma_rx_dbg_stats(dev);
                 break;
+        case OCRDMA_DRV_STATS:
+                data = ocrdma_driver_dbg_stats(dev);
+                break;
 
         default:
                 status = -EFAULT;
@@ -514,6 +742,7 @@ static const struct file_operations ocrdma_dbg_ops = {
         .owner = THIS_MODULE,
         .open = simple_open,
         .read = ocrdma_dbgfs_ops_read,
+        .write = ocrdma_dbgfs_ops_write,
 };
 
 void ocrdma_add_port_stats(struct ocrdma_dev *dev)
@@ -582,6 +811,18 @@ void ocrdma_add_port_stats(struct ocrdma_dev *dev)
                                  &dev->rx_dbg_stats, &ocrdma_dbg_ops))
                 goto err;
 
+        dev->driver_stats.type = OCRDMA_DRV_STATS;
+        dev->driver_stats.dev = dev;
+        if (!debugfs_create_file("driver_dbg_stats", S_IRUSR, dev->dir,
+                                        &dev->driver_stats, &ocrdma_dbg_ops))
+                goto err;
+
+        dev->reset_stats.type = OCRDMA_RESET_STATS;
+        dev->reset_stats.dev = dev;
+        if (!debugfs_create_file("reset_stats", S_IRUSR, dev->dir,
+                                &dev->reset_stats, &ocrdma_dbg_ops))
+                goto err;
+
         /* Now create dma_mem for stats mbx command */
         if (!ocrdma_alloc_stats_mem(dev))
                 goto err;
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_stats.h b/drivers/infiniband/hw/ocrdma/ocrdma_stats.h
index 5f5e20c46d7c..091edd68a8a3 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_stats.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_stats.h
@@ -43,12 +43,16 @@ enum OCRDMA_STATS_TYPE {
         OCRDMA_RXQP_ERRSTATS,
         OCRDMA_TXQP_ERRSTATS,
         OCRDMA_TX_DBG_STATS,
-        OCRDMA_RX_DBG_STATS
+        OCRDMA_RX_DBG_STATS,
+        OCRDMA_DRV_STATS,
+        OCRDMA_RESET_STATS
 };
 
 void ocrdma_rem_debugfs(void);
 void ocrdma_init_debugfs(void);
 void ocrdma_rem_port_stats(struct ocrdma_dev *dev);
 void ocrdma_add_port_stats(struct ocrdma_dev *dev);
+int ocrdma_pma_counters(struct ocrdma_dev *dev,
+                        struct ib_mad *out_mad);
 
 #endif  /* __OCRDMA_STATS_H__ */
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
index fb8d8c4dfbb9..877175563634 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
@@ -53,7 +53,7 @@ int ocrdma_query_gid(struct ib_device *ibdev, u8 port,
 
         dev = get_ocrdma_dev(ibdev);
         memset(sgid, 0, sizeof(*sgid));
-        if (index > OCRDMA_MAX_SGID)
+        if (index >= OCRDMA_MAX_SGID)
                 return -EINVAL;
 
         memcpy(sgid, &dev->sgid_tbl[index], sizeof(*sgid));
@@ -253,6 +253,107 @@ static bool ocrdma_search_mmap(struct ocrdma_ucontext *uctx, u64 phy_addr,
         return found;
 }
 
+
+static u16 _ocrdma_pd_mgr_get_bitmap(struct ocrdma_dev *dev, bool dpp_pool)
+{
+        u16 pd_bitmap_idx = 0;
+        const unsigned long *pd_bitmap;
+
+        if (dpp_pool) {
+                pd_bitmap = dev->pd_mgr->pd_dpp_bitmap;
+                pd_bitmap_idx = find_first_zero_bit(pd_bitmap,
+                                                    dev->pd_mgr->max_dpp_pd);
+                __set_bit(pd_bitmap_idx, dev->pd_mgr->pd_dpp_bitmap);
+                dev->pd_mgr->pd_dpp_count++;
+                if (dev->pd_mgr->pd_dpp_count > dev->pd_mgr->pd_dpp_thrsh)
+                        dev->pd_mgr->pd_dpp_thrsh = dev->pd_mgr->pd_dpp_count;
+        } else {
+                pd_bitmap = dev->pd_mgr->pd_norm_bitmap;
+                pd_bitmap_idx = find_first_zero_bit(pd_bitmap,
+                                                    dev->pd_mgr->max_normal_pd);
+                __set_bit(pd_bitmap_idx, dev->pd_mgr->pd_norm_bitmap);
+                dev->pd_mgr->pd_norm_count++;
+                if (dev->pd_mgr->pd_norm_count > dev->pd_mgr->pd_norm_thrsh)
+                        dev->pd_mgr->pd_norm_thrsh = dev->pd_mgr->pd_norm_count;
+        }
+        return pd_bitmap_idx;
+}
+
+static int _ocrdma_pd_mgr_put_bitmap(struct ocrdma_dev *dev, u16 pd_id,
+                                        bool dpp_pool)
+{
+        u16 pd_count;
+        u16 pd_bit_index;
+
+        pd_count = dpp_pool ? dev->pd_mgr->pd_dpp_count :
+                              dev->pd_mgr->pd_norm_count;
+        if (pd_count == 0)
+                return -EINVAL;
+
+        if (dpp_pool) {
+                pd_bit_index = pd_id - dev->pd_mgr->pd_dpp_start;
+                if (pd_bit_index >= dev->pd_mgr->max_dpp_pd) {
+                        return -EINVAL;
+                } else {
+                        __clear_bit(pd_bit_index, dev->pd_mgr->pd_dpp_bitmap);
+                        dev->pd_mgr->pd_dpp_count--;
+                }
+        } else {
+                pd_bit_index = pd_id - dev->pd_mgr->pd_norm_start;
+                if (pd_bit_index >= dev->pd_mgr->max_normal_pd) {
+                        return -EINVAL;
+                } else {
+                        __clear_bit(pd_bit_index, dev->pd_mgr->pd_norm_bitmap);
+                        dev->pd_mgr->pd_norm_count--;
+                }
+        }
+
+        return 0;
+}
+
+static u8 ocrdma_put_pd_num(struct ocrdma_dev *dev, u16 pd_id,
+                                   bool dpp_pool)
+{
+        int status;
+
+        mutex_lock(&dev->dev_lock);
+        status = _ocrdma_pd_mgr_put_bitmap(dev, pd_id, dpp_pool);
+        mutex_unlock(&dev->dev_lock);
+        return status;
+}
+
+static int ocrdma_get_pd_num(struct ocrdma_dev *dev, struct ocrdma_pd *pd)
+{
+        u16 pd_idx = 0;
+        int status = 0;
+
+        mutex_lock(&dev->dev_lock);
+        if (pd->dpp_enabled) {
+                /* try allocating DPP PD, if not available then normal PD */
+                if (dev->pd_mgr->pd_dpp_count < dev->pd_mgr->max_dpp_pd) {
+                        pd_idx = _ocrdma_pd_mgr_get_bitmap(dev, true);
+                        pd->id = dev->pd_mgr->pd_dpp_start + pd_idx;
+                        pd->dpp_page = dev->pd_mgr->dpp_page_index + pd_idx;
+                } else if (dev->pd_mgr->pd_norm_count <
+                           dev->pd_mgr->max_normal_pd) {
+                        pd_idx = _ocrdma_pd_mgr_get_bitmap(dev, false);
+                        pd->id = dev->pd_mgr->pd_norm_start + pd_idx;
+                        pd->dpp_enabled = false;
+                } else {
+                        status = -EINVAL;
+                }
+        } else {
+                if (dev->pd_mgr->pd_norm_count < dev->pd_mgr->max_normal_pd) {
+                        pd_idx = _ocrdma_pd_mgr_get_bitmap(dev, false);
+                        pd->id = dev->pd_mgr->pd_norm_start + pd_idx;
+                } else {
+                        status = -EINVAL;
+                }
+        }
+        mutex_unlock(&dev->dev_lock);
+        return status;
+}
+
 static struct ocrdma_pd *_ocrdma_alloc_pd(struct ocrdma_dev *dev,
                                           struct ocrdma_ucontext *uctx,
                                           struct ib_udata *udata)
@@ -272,6 +373,11 @@ static struct ocrdma_pd *_ocrdma_alloc_pd(struct ocrdma_dev *dev,
                                            dev->attr.wqe_size) : 0;
         }
 
+        if (dev->pd_mgr->pd_prealloc_valid) {
+                status = ocrdma_get_pd_num(dev, pd);
+                return (status == 0) ? pd : ERR_PTR(status);
+        }
+
 retry:
         status = ocrdma_mbx_alloc_pd(dev, pd);
         if (status) {
@@ -299,7 +405,11 @@ static int _ocrdma_dealloc_pd(struct ocrdma_dev *dev,
 {
         int status = 0;
 
-        status = ocrdma_mbx_dealloc_pd(dev, pd);
+        if (dev->pd_mgr->pd_prealloc_valid)
+                status = ocrdma_put_pd_num(dev, pd->id, pd->dpp_enabled);
+        else
+                status = ocrdma_mbx_dealloc_pd(dev, pd);
+
         kfree(pd);
         return status;
 }
@@ -325,7 +435,6 @@ err:
 
 static int ocrdma_dealloc_ucontext_pd(struct ocrdma_ucontext *uctx)
 {
-        int status = 0;
         struct ocrdma_pd *pd = uctx->cntxt_pd;
         struct ocrdma_dev *dev = get_ocrdma_dev(pd->ibpd.device);
 
@@ -334,8 +443,8 @@ static int ocrdma_dealloc_ucontext_pd(struct ocrdma_ucontext *uctx)
                        __func__, dev->id, pd->id);
         }
         uctx->cntxt_pd = NULL;
-        status = _ocrdma_dealloc_pd(dev, pd);
-        return status;
+        (void)_ocrdma_dealloc_pd(dev, pd);
+        return 0;
 }
 
 static struct ocrdma_pd *ocrdma_get_ucontext_pd(struct ocrdma_ucontext *uctx)
@@ -569,7 +678,7 @@ err:
         if (is_uctx_pd) {
                 ocrdma_release_ucontext_pd(uctx);
         } else {
-                status = ocrdma_mbx_dealloc_pd(dev, pd);
+                status = _ocrdma_dealloc_pd(dev, pd);
                 kfree(pd);
         }
 exit:
@@ -837,9 +946,8 @@ int ocrdma_dereg_mr(struct ib_mr *ib_mr)
 {
         struct ocrdma_mr *mr = get_ocrdma_mr(ib_mr);
         struct ocrdma_dev *dev = get_ocrdma_dev(ib_mr->device);
-        int status;
 
-        status = ocrdma_mbx_dealloc_lkey(dev, mr->hwmr.fr_mr, mr->hwmr.lkey);
+        (void) ocrdma_mbx_dealloc_lkey(dev, mr->hwmr.fr_mr, mr->hwmr.lkey);
 
         ocrdma_free_mr_pbl_tbl(dev, &mr->hwmr);
 
@@ -850,11 +958,10 @@ int ocrdma_dereg_mr(struct ib_mr *ib_mr)
 
         /* Don't stop cleanup, in case FW is unresponsive */
         if (dev->mqe_ctx.fw_error_state) {
-                status = 0;
                 pr_err("%s(%d) fw not responding.\n",
                        __func__, dev->id);
         }
-        return status;
+        return 0;
 }
 
 static int ocrdma_copy_cq_uresp(struct ocrdma_dev *dev, struct ocrdma_cq *cq,
@@ -986,7 +1093,6 @@ static void ocrdma_flush_cq(struct ocrdma_cq *cq)
 
 int ocrdma_destroy_cq(struct ib_cq *ibcq)
 {
-        int status;
         struct ocrdma_cq *cq = get_ocrdma_cq(ibcq);
         struct ocrdma_eq *eq = NULL;
         struct ocrdma_dev *dev = get_ocrdma_dev(ibcq->device);
@@ -1003,7 +1109,7 @@ int ocrdma_destroy_cq(struct ib_cq *ibcq)
         synchronize_irq(irq);
         ocrdma_flush_cq(cq);
 
-        status = ocrdma_mbx_destroy_cq(dev, cq);
+        (void)ocrdma_mbx_destroy_cq(dev, cq);
         if (cq->ucontext) {
                 pdid = cq->ucontext->cntxt_pd->id;
                 ocrdma_del_mmap(cq->ucontext, (u64) cq->pa,
@@ -1014,7 +1120,7 @@ int ocrdma_destroy_cq(struct ib_cq *ibcq)
         }
 
         kfree(cq);
-        return status;
+        return 0;
 }
 
 static int ocrdma_add_qpn_map(struct ocrdma_dev *dev, struct ocrdma_qp *qp)
@@ -1113,8 +1219,8 @@ static int ocrdma_copy_qp_uresp(struct ocrdma_qp *qp,
         int status = 0;
         u64 usr_db;
         struct ocrdma_create_qp_uresp uresp;
-        struct ocrdma_dev *dev = qp->dev;
         struct ocrdma_pd *pd = qp->pd;
+        struct ocrdma_dev *dev = get_ocrdma_dev(pd->ibpd.device);
 
         memset(&uresp, 0, sizeof(uresp));
         usr_db = dev->nic_info.unmapped_db +
@@ -1253,7 +1359,6 @@ struct ib_qp *ocrdma_create_qp(struct ib_pd *ibpd,
                 status = -ENOMEM;
                 goto gen_err;
         }
-        qp->dev = dev;
         ocrdma_set_qp_init_params(qp, pd, attrs);
         if (udata == NULL)
                 qp->cap_flags |= (OCRDMA_QP_MW_BIND | OCRDMA_QP_LKEY0 |
@@ -1312,7 +1417,7 @@ int _ocrdma_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
         enum ib_qp_state old_qps;
 
         qp = get_ocrdma_qp(ibqp);
-        dev = qp->dev;
+        dev = get_ocrdma_dev(ibqp->device);
         if (attr_mask & IB_QP_STATE)
                 status = ocrdma_qp_state_change(qp, attr->qp_state, &old_qps);
         /* if new and previous states are same hw doesn't need to
@@ -1335,7 +1440,7 @@ int ocrdma_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
         enum ib_qp_state old_qps, new_qps;
 
         qp = get_ocrdma_qp(ibqp);
-        dev = qp->dev;
+        dev = get_ocrdma_dev(ibqp->device);
 
         /* syncronize with multiple context trying to change, retrive qps */
         mutex_lock(&dev->dev_lock);
@@ -1402,7 +1507,7 @@ int ocrdma_query_qp(struct ib_qp *ibqp,
         u32 qp_state;
         struct ocrdma_qp_params params;
         struct ocrdma_qp *qp = get_ocrdma_qp(ibqp);
-        struct ocrdma_dev *dev = qp->dev;
+        struct ocrdma_dev *dev = get_ocrdma_dev(ibqp->device);
 
         memset(&params, 0, sizeof(params));
         mutex_lock(&dev->dev_lock);
@@ -1412,8 +1517,6 @@ int ocrdma_query_qp(struct ib_qp *ibqp,
                 goto mbx_err;
         if (qp->qp_type == IB_QPT_UD)
                 qp_attr->qkey = params.qkey;
-        qp_attr->qp_state = get_ibqp_state(IB_QPS_INIT);
-        qp_attr->cur_qp_state = get_ibqp_state(IB_QPS_INIT);
         qp_attr->path_mtu =
                 ocrdma_mtu_int_to_enum(params.path_mtu_pkey_indx &
                                 OCRDMA_QP_PARAMS_PATH_MTU_MASK) >>
@@ -1468,6 +1571,8 @@ int ocrdma_query_qp(struct ib_qp *ibqp,
         memset(&qp_attr->alt_ah_attr, 0, sizeof(qp_attr->alt_ah_attr));
         qp_state = (params.max_sge_recv_flags & OCRDMA_QP_PARAMS_STATE_MASK) >>
                     OCRDMA_QP_PARAMS_STATE_SHIFT;
+        qp_attr->qp_state = get_ibqp_state(qp_state);
+        qp_attr->cur_qp_state = qp_attr->qp_state;
         qp_attr->sq_draining = (qp_state == OCRDMA_QPS_SQ_DRAINING) ? 1 : 0;
         qp_attr->max_dest_rd_atomic =
             params.max_ord_ird >> OCRDMA_QP_PARAMS_MAX_ORD_SHIFT;
@@ -1475,19 +1580,18 @@ int ocrdma_query_qp(struct ib_qp *ibqp,
             params.max_ord_ird & OCRDMA_QP_PARAMS_MAX_IRD_MASK;
         qp_attr->en_sqd_async_notify = (params.max_sge_recv_flags &
                                 OCRDMA_QP_PARAMS_FLAGS_SQD_ASYNC) ? 1 : 0;
+        /* Sync driver QP state with FW */
+        ocrdma_qp_state_change(qp, qp_attr->qp_state, NULL);
 mbx_err:
         return status;
 }
 
-static void ocrdma_srq_toggle_bit(struct ocrdma_srq *srq, int idx)
+static void ocrdma_srq_toggle_bit(struct ocrdma_srq *srq, unsigned int idx)
 {
-        int i = idx / 32;
-        unsigned int mask = (1 << (idx % 32));
+        unsigned int i = idx / 32;
+        u32 mask = (1U << (idx % 32));
 
-        if (srq->idx_bit_fields[i] & mask)
-                srq->idx_bit_fields[i] &= ~mask;
-        else
-                srq->idx_bit_fields[i] |= mask;
+        srq->idx_bit_fields[i] ^= mask;
 }
 
 static int ocrdma_hwq_free_cnt(struct ocrdma_qp_hwq_info *q)
@@ -1596,7 +1700,7 @@ void ocrdma_del_flush_qp(struct ocrdma_qp *qp)
 {
         int found = false;
         unsigned long flags;
-        struct ocrdma_dev *dev = qp->dev;
+        struct ocrdma_dev *dev = get_ocrdma_dev(qp->ibqp.device);
         /* sync with any active CQ poll */
 
         spin_lock_irqsave(&dev->flush_q_lock, flags);
@@ -1613,7 +1717,6 @@ void ocrdma_del_flush_qp(struct ocrdma_qp *qp)
 
 int ocrdma_destroy_qp(struct ib_qp *ibqp)
 {
-        int status;
         struct ocrdma_pd *pd;
         struct ocrdma_qp *qp;
         struct ocrdma_dev *dev;
@@ -1622,7 +1725,7 @@ int ocrdma_destroy_qp(struct ib_qp *ibqp)
         unsigned long flags;
 
         qp = get_ocrdma_qp(ibqp);
-        dev = qp->dev;
+        dev = get_ocrdma_dev(ibqp->device);
 
         attrs.qp_state = IB_QPS_ERR;
         pd = qp->pd;
@@ -1635,7 +1738,7 @@ int ocrdma_destroy_qp(struct ib_qp *ibqp)
          * discarded until the old CQEs are discarded.
          */
         mutex_lock(&dev->dev_lock);
-        status = ocrdma_mbx_destroy_qp(dev, qp);
+        (void) ocrdma_mbx_destroy_qp(dev, qp);
 
         /*
          * acquire CQ lock while destroy is in progress, in order to
@@ -1670,7 +1773,7 @@ int ocrdma_destroy_qp(struct ib_qp *ibqp)
         kfree(qp->wqe_wr_id_tbl);
         kfree(qp->rqe_wr_id_tbl);
         kfree(qp);
-        return status;
+        return 0;
 }
 
 static int ocrdma_copy_srq_uresp(struct ocrdma_dev *dev, struct ocrdma_srq *srq,
@@ -1831,6 +1934,8 @@ static void ocrdma_build_ud_hdr(struct ocrdma_qp *qp,
         else
                 ud_hdr->qkey = wr->wr.ud.remote_qkey;
         ud_hdr->rsvd_ahid = ah->id;
+        if (ah->av->valid & OCRDMA_AV_VLAN_VALID)
+                hdr->cw |= (OCRDMA_FLAG_AH_VLAN_PR << OCRDMA_WQE_FLAGS_SHIFT);
 }
 
 static void ocrdma_build_sges(struct ocrdma_hdr_wqe *hdr,
@@ -2007,11 +2112,12 @@ static int ocrdma_build_fr(struct ocrdma_qp *qp, struct ocrdma_hdr_wqe *hdr,
         u64 fbo;
         struct ocrdma_ewqe_fr *fast_reg = (struct ocrdma_ewqe_fr *)(hdr + 1);
         struct ocrdma_mr *mr;
+        struct ocrdma_dev *dev = get_ocrdma_dev(qp->ibqp.device);
         u32 wqe_size = sizeof(*fast_reg) + sizeof(*hdr);
 
         wqe_size = roundup(wqe_size, OCRDMA_WQE_ALIGN_BYTES);
 
-        if (wr->wr.fast_reg.page_list_len > qp->dev->attr.max_pages_per_frmr)
+        if (wr->wr.fast_reg.page_list_len > dev->attr.max_pages_per_frmr)
                 return -EINVAL;
 
         hdr->cw |= (OCRDMA_FR_MR << OCRDMA_WQE_OPCODE_SHIFT);
@@ -2039,7 +2145,7 @@ static int ocrdma_build_fr(struct ocrdma_qp *qp, struct ocrdma_hdr_wqe *hdr,
         fast_reg->size_sge =
                 get_encoded_page_size(1 << wr->wr.fast_reg.page_shift);
         mr = (struct ocrdma_mr *) (unsigned long)
-                qp->dev->stag_arr[(hdr->lkey >> 8) & (OCRDMA_MAX_STAG - 1)];
+                dev->stag_arr[(hdr->lkey >> 8) & (OCRDMA_MAX_STAG - 1)];
         build_frmr_pbes(wr, mr->hwmr.pbl_table, &mr->hwmr);
         return 0;
 }
@@ -2112,8 +2218,6 @@ int ocrdma_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                         hdr->cw |= (OCRDMA_WRITE << OCRDMA_WQE_OPCODE_SHIFT);
                         status = ocrdma_build_write(qp, hdr, wr);
                         break;
-                case IB_WR_RDMA_READ_WITH_INV:
-                        hdr->cw |= (OCRDMA_FLAG_INV << OCRDMA_WQE_FLAGS_SHIFT);
                 case IB_WR_RDMA_READ:
                         ocrdma_build_read(qp, hdr, wr);
                         break;
@@ -2484,8 +2588,11 @@ static bool ocrdma_poll_err_scqe(struct ocrdma_qp *qp,
                                  bool *polled, bool *stop)
 {
         bool expand;
+        struct ocrdma_dev *dev = get_ocrdma_dev(qp->ibqp.device);
         int status = (le32_to_cpu(cqe->flags_status_srcqpn) &
                 OCRDMA_CQE_STATUS_MASK) >> OCRDMA_CQE_STATUS_SHIFT;
+        if (status < OCRDMA_MAX_CQE_ERR)
+                atomic_inc(&dev->cqe_err_stats[status]);
 
         /* when hw sq is empty, but rq is not empty, so we continue
          * to keep the cqe in order to get the cq event again.
@@ -2604,6 +2711,10 @@ static bool ocrdma_poll_err_rcqe(struct ocrdma_qp *qp, struct ocrdma_cqe *cqe,
                                 int status)
 {
         bool expand;
+        struct ocrdma_dev *dev = get_ocrdma_dev(qp->ibqp.device);
+
+        if (status < OCRDMA_MAX_CQE_ERR)
+                atomic_inc(&dev->cqe_err_stats[status]);
 
         /* when hw_rq is empty, but wq is not empty, so continue
          * to keep the cqe to get the cq event again.
diff --git a/drivers/infiniband/hw/qib/qib.h b/drivers/infiniband/hw/qib/qib.h
index c00ae093b6f8..ffd48bfc4923 100644
--- a/drivers/infiniband/hw/qib/qib.h
+++ b/drivers/infiniband/hw/qib/qib.h
@@ -1082,12 +1082,6 @@ struct qib_devdata {
         /* control high-level access to EEPROM */
         struct mutex eep_lock;
         uint64_t traffic_wds;
-        /* active time is kept in seconds, but logged in hours */
-        atomic_t active_time;
-        /* Below are nominal shadow of EEPROM, new since last EEPROM update */
-        uint8_t eep_st_errs[QIB_EEP_LOG_CNT];
-        uint8_t eep_st_new_errs[QIB_EEP_LOG_CNT];
-        uint16_t eep_hrs;
         /*
          * masks for which bits of errs, hwerrs that cause
          * each of the counters to increment.
@@ -1309,8 +1303,7 @@ int qib_twsi_blk_rd(struct qib_devdata *dd, int dev, int addr, void *buffer,
 int qib_twsi_blk_wr(struct qib_devdata *dd, int dev, int addr,
                     const void *buffer, int len);
 void qib_get_eeprom_info(struct qib_devdata *);
-int qib_update_eeprom_log(struct qib_devdata *dd);
-void qib_inc_eeprom_err(struct qib_devdata *dd, u32 eidx, u32 incr);
+#define qib_inc_eeprom_err(dd, eidx, incr)
 void qib_dump_lookup_output_queue(struct qib_devdata *);
 void qib_force_pio_avail_update(struct qib_devdata *);
 void qib_clear_symerror_on_linkup(unsigned long opaque);
@@ -1467,11 +1460,14 @@ const char *qib_get_unit_name(int unit);
  * Flush write combining store buffers (if present) and perform a write
  * barrier.
  */
+static inline void qib_flush_wc(void)
+{
 #if defined(CONFIG_X86_64)
-#define qib_flush_wc() asm volatile("sfence" : : : "memory")
+        asm volatile("sfence" : : : "memory");
 #else
-#define qib_flush_wc() wmb() /* no reorder around wc flush */
+        wmb(); /* no reorder around wc flush */
 #endif
+}
 
 /* global module parameter variables */
 extern unsigned qib_ibmtu;
diff --git a/drivers/infiniband/hw/qib/qib_common.h b/drivers/infiniband/hw/qib/qib_common.h
index 5670ace27c63..4fb78abd8ba1 100644
--- a/drivers/infiniband/hw/qib/qib_common.h
+++ b/drivers/infiniband/hw/qib/qib_common.h
@@ -257,7 +257,7 @@ struct qib_base_info {
 
         /* shared memory page for send buffer disarm status */
         __u64 spi_sendbuf_status;
-} __attribute__ ((aligned(8)));
+} __aligned(8);
 
 /*
  * This version number is given to the driver by the user code during
@@ -361,7 +361,7 @@ struct qib_user_info {
          */
         __u64 spu_base_info;
 
-} __attribute__ ((aligned(8)));
+} __aligned(8);
 
 /* User commands. */
 
diff --git a/drivers/infiniband/hw/qib/qib_debugfs.c b/drivers/infiniband/hw/qib/qib_debugfs.c
index 6abd3ed3cd51..5e75b43c596b 100644
--- a/drivers/infiniband/hw/qib/qib_debugfs.c
+++ b/drivers/infiniband/hw/qib/qib_debugfs.c
@@ -255,7 +255,6 @@ void qib_dbg_ibdev_init(struct qib_ibdev *ibd)
         DEBUGFS_FILE_CREATE(opcode_stats);
         DEBUGFS_FILE_CREATE(ctx_stats);
         DEBUGFS_FILE_CREATE(qp_stats);
-        return;
 }
 
 void qib_dbg_ibdev_exit(struct qib_ibdev *ibd)
diff --git a/drivers/infiniband/hw/qib/qib_diag.c b/drivers/infiniband/hw/qib/qib_diag.c
index 5dfda4c5cc9c..8c34b23e5bf6 100644
--- a/drivers/infiniband/hw/qib/qib_diag.c
+++ b/drivers/infiniband/hw/qib/qib_diag.c
@@ -85,7 +85,7 @@ static struct qib_diag_client *get_client(struct qib_devdata *dd)
                 client_pool = dc->next;
         else
                 /* None in pool, alloc and init */
-                dc = kmalloc(sizeof *dc, GFP_KERNEL);
+                dc = kmalloc(sizeof(*dc), GFP_KERNEL);
 
         if (dc) {
                 dc->next = NULL;
@@ -257,6 +257,7 @@ static u32 __iomem *qib_remap_ioaddr32(struct qib_devdata *dd, u32 offset,
         if (dd->userbase) {
                 /* If user regs mapped, they are after send, so set limit. */
                 u32 ulim = (dd->cfgctxts * dd->ureg_align) + dd->uregbase;
+
                 if (!dd->piovl15base)
                         snd_lim = dd->uregbase;
                 krb32 = (u32 __iomem *)dd->userbase;
@@ -280,6 +281,7 @@ static u32 __iomem *qib_remap_ioaddr32(struct qib_devdata *dd, u32 offset,
         snd_bottom = dd->pio2k_bufbase;
         if (snd_lim == 0) {
                 u32 tot2k = dd->piobcnt2k * ALIGN(dd->piosize2k, dd->palign);
+
                 snd_lim = snd_bottom + tot2k;
         }
         /* If 4k buffers exist, account for them by bumping
@@ -398,6 +400,7 @@ static int qib_write_umem64(struct qib_devdata *dd, u32 regoffs,
         /* not very efficient, but it works for now */
         while (reg_addr < reg_end) {
                 u64 data;
+
                 if (copy_from_user(&data, uaddr, sizeof(data))) {
                         ret = -EFAULT;
                         goto bail;
@@ -698,7 +701,7 @@ int qib_register_observer(struct qib_devdata *dd,
 
         if (!dd || !op)
                 return -EINVAL;
-        olp = vmalloc(sizeof *olp);
+        olp = vmalloc(sizeof(*olp));
         if (!olp) {
                 pr_err("vmalloc for observer failed\n");
                 return -ENOMEM;
@@ -796,6 +799,7 @@ static ssize_t qib_diag_read(struct file *fp, char __user *data,
                 op = diag_get_observer(dd, *off);
                 if (op) {
                         u32 offset = *off;
+
                         ret = op->hook(dd, op, offset, &data64, 0, use_32);
                 }
                 /*
@@ -873,6 +877,7 @@ static ssize_t qib_diag_write(struct file *fp, const char __user *data,
                 if (count == 4 || count == 8) {
                         u64 data64;
                         u32 offset = *off;
+
                         ret = copy_from_user(&data64, data, count);
                         if (ret) {
                                 ret = -EFAULT;
diff --git a/drivers/infiniband/hw/qib/qib_driver.c b/drivers/infiniband/hw/qib/qib_driver.c
index 5bee08f16d74..f58fdc3d25a2 100644
--- a/drivers/infiniband/hw/qib/qib_driver.c
+++ b/drivers/infiniband/hw/qib/qib_driver.c
@@ -86,7 +86,7 @@ const char *qib_get_unit_name(int unit)
 {
         static char iname[16];
 
-        snprintf(iname, sizeof iname, "infinipath%u", unit);
+        snprintf(iname, sizeof(iname), "infinipath%u", unit);
         return iname;
 }
 
@@ -349,6 +349,7 @@ static u32 qib_rcv_hdrerr(struct qib_ctxtdata *rcd, struct qib_pportdata *ppd,
                 qp_num = be32_to_cpu(ohdr->bth[1]) & QIB_QPN_MASK;
                 if (qp_num != QIB_MULTICAST_QPN) {
                         int ruc_res;
+
                         qp = qib_lookup_qpn(ibp, qp_num);
                         if (!qp)
                                 goto drop;
@@ -461,6 +462,7 @@ u32 qib_kreceive(struct qib_ctxtdata *rcd, u32 *llic, u32 *npkts)
         rhf_addr = (__le32 *) rcd->rcvhdrq + l + dd->rhf_offset;
         if (dd->flags & QIB_NODMA_RTAIL) {
                 u32 seq = qib_hdrget_seq(rhf_addr);
+
                 if (seq != rcd->seq_cnt)
                         goto bail;
                 hdrqtail = 0;
@@ -651,6 +653,7 @@ bail:
 int qib_set_lid(struct qib_pportdata *ppd, u32 lid, u8 lmc)
 {
         struct qib_devdata *dd = ppd->dd;
+
         ppd->lid = lid;
         ppd->lmc = lmc;
 
diff --git a/drivers/infiniband/hw/qib/qib_eeprom.c b/drivers/infiniband/hw/qib/qib_eeprom.c
index 4d5d71aaa2b4..311ee6c3dd5e 100644
--- a/drivers/infiniband/hw/qib/qib_eeprom.c
+++ b/drivers/infiniband/hw/qib/qib_eeprom.c
@@ -153,6 +153,7 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
 
         if (t && dd0->nguid > 1 && t <= dd0->nguid) {
                 u8 oguid;
+
                 dd->base_guid = dd0->base_guid;
                 bguid = (u8 *) &dd->base_guid;
 
@@ -251,206 +252,25 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
                  * This board has a Serial-prefix, which is stored
                  * elsewhere for backward-compatibility.
                  */
-                memcpy(snp, ifp->if_sprefix, sizeof ifp->if_sprefix);
-                snp[sizeof ifp->if_sprefix] = '\0';
+                memcpy(snp, ifp->if_sprefix, sizeof(ifp->if_sprefix));
+                snp[sizeof(ifp->if_sprefix)] = '\0';
                 len = strlen(snp);
                 snp += len;
-                len = (sizeof dd->serial) - len;
-                if (len > sizeof ifp->if_serial)
-                        len = sizeof ifp->if_serial;
+                len = sizeof(dd->serial) - len;
+                if (len > sizeof(ifp->if_serial))
+                        len = sizeof(ifp->if_serial);
                 memcpy(snp, ifp->if_serial, len);
-        } else
-                memcpy(dd->serial, ifp->if_serial,
-                       sizeof ifp->if_serial);
+        } else {
+                memcpy(dd->serial, ifp->if_serial, sizeof(ifp->if_serial));
+        }
         if (!strstr(ifp->if_comment, "Tested successfully"))
                 qib_dev_err(dd,
                         "Board SN %s did not pass functional test: %s\n",
                         dd->serial, ifp->if_comment);
 
-        memcpy(&dd->eep_st_errs, &ifp->if_errcntp, QIB_EEP_LOG_CNT);
-        /*
-         * Power-on (actually "active") hours are kept as little-endian value
-         * in EEPROM, but as seconds in a (possibly as small as 24-bit)
-         * atomic_t while running.
-         */
-        atomic_set(&dd->active_time, 0);
-        dd->eep_hrs = ifp->if_powerhour[0] | (ifp->if_powerhour[1] << 8);
-
 done:
         vfree(buf);
 
 bail:;
 }
 
-/**
- * qib_update_eeprom_log - copy active-time and error counters to eeprom
- * @dd: the qlogic_ib device
- *
- * Although the time is kept as seconds in the qib_devdata struct, it is
- * rounded to hours for re-write, as we have only 16 bits in EEPROM.
- * First-cut code reads whole (expected) struct qib_flash, modifies,
- * re-writes. Future direction: read/write only what we need, assuming
- * that the EEPROM had to have been "good enough" for driver init, and
- * if not, we aren't making it worse.
- *
- */
-int qib_update_eeprom_log(struct qib_devdata *dd)
-{
-        void *buf;
-        struct qib_flash *ifp;
-        int len, hi_water;
-        uint32_t new_time, new_hrs;
-        u8 csum;
-        int ret, idx;
-        unsigned long flags;
-
-        /* first, check if we actually need to do anything. */
-        ret = 0;
-        for (idx = 0; idx < QIB_EEP_LOG_CNT; ++idx) {
-                if (dd->eep_st_new_errs[idx]) {
-                        ret = 1;
-                        break;
-                }
-        }
-        new_time = atomic_read(&dd->active_time);
-
-        if (ret == 0 && new_time < 3600)
-                goto bail;
-
-        /*
-         * The quick-check above determined that there is something worthy
-         * of logging, so get current contents and do a more detailed idea.
-         * read full flash, not just currently used part, since it may have
-         * been written with a newer definition
-         */
-        len = sizeof(struct qib_flash);
-        buf = vmalloc(len);
-        ret = 1;
-        if (!buf) {
-                qib_dev_err(dd,
-                        "Couldn't allocate memory to read %u bytes from eeprom for logging\n",
-                        len);
-                goto bail;
-        }
-
-        /* Grab semaphore and read current EEPROM. If we get an
-         * error, let go, but if not, keep it until we finish write.
-         */
-        ret = mutex_lock_interruptible(&dd->eep_lock);
-        if (ret) {
-                qib_dev_err(dd, "Unable to acquire EEPROM for logging\n");
-                goto free_bail;
-        }
-        ret = qib_twsi_blk_rd(dd, dd->twsi_eeprom_dev, 0, buf, len);
-        if (ret) {
-                mutex_unlock(&dd->eep_lock);
-                qib_dev_err(dd, "Unable read EEPROM for logging\n");
-                goto free_bail;
-        }
-        ifp = (struct qib_flash *)buf;
-
-        csum = flash_csum(ifp, 0);
-        if (csum != ifp->if_csum) {
-                mutex_unlock(&dd->eep_lock);
-                qib_dev_err(dd, "EEPROM cks err (0x%02X, S/B 0x%02X)\n",
-                            csum, ifp->if_csum);
-                ret = 1;
-                goto free_bail;
-        }
-        hi_water = 0;
-        spin_lock_irqsave(&dd->eep_st_lock, flags);
-        for (idx = 0; idx < QIB_EEP_LOG_CNT; ++idx) {
-                int new_val = dd->eep_st_new_errs[idx];
-                if (new_val) {
-                        /*
-                         * If we have seen any errors, add to EEPROM values
-                         * We need to saturate at 0xFF (255) and we also
-                         * would need to adjust the checksum if we were
-                         * trying to minimize EEPROM traffic
-                         * Note that we add to actual current count in EEPROM,
-                         * in case it was altered while we were running.
-                         */
-                        new_val += ifp->if_errcntp[idx];
-                        if (new_val > 0xFF)
-                                new_val = 0xFF;
-                        if (ifp->if_errcntp[idx] != new_val) {
-                                ifp->if_errcntp[idx] = new_val;
-                                hi_water = offsetof(struct qib_flash,
-                                                    if_errcntp) + idx;
-                        }
-                        /*
-                         * update our shadow (used to minimize EEPROM
-                         * traffic), to match what we are about to write.
-                         */
-                        dd->eep_st_errs[idx] = new_val;
-                        dd->eep_st_new_errs[idx] = 0;
-                }
-        }
-        /*
-         * Now update active-time. We would like to round to the nearest hour
-         * but unless atomic_t are sure to be proper signed ints we cannot,
-         * because we need to account for what we "transfer" to EEPROM and
-         * if we log an hour at 31 minutes, then we would need to set
-         * active_time to -29 to accurately count the _next_ hour.
-         */
-        if (new_time >= 3600) {
-                new_hrs = new_time / 3600;
-                atomic_sub((new_hrs * 3600), &dd->active_time);
-                new_hrs += dd->eep_hrs;
-                if (new_hrs > 0xFFFF)
-                        new_hrs = 0xFFFF;
-                dd->eep_hrs = new_hrs;
-                if ((new_hrs & 0xFF) != ifp->if_powerhour[0]) {
-                        ifp->if_powerhour[0] = new_hrs & 0xFF;
-                        hi_water = offsetof(struct qib_flash, if_powerhour);
-                }
-                if ((new_hrs >> 8) != ifp->if_powerhour[1]) {
-                        ifp->if_powerhour[1] = new_hrs >> 8;
-                        hi_water = offsetof(struct qib_flash, if_powerhour) + 1;
-                }
-        }
-        /*
-         * There is a tiny possibility that we could somehow fail to write
-         * the EEPROM after updating our shadows, but problems from holding
-         * the spinlock too long are a much bigger issue.
-         */
-        spin_unlock_irqrestore(&dd->eep_st_lock, flags);
-        if (hi_water) {
-                /* we made some change to the data, uopdate cksum and write */
-                csum = flash_csum(ifp, 1);
-                ret = eeprom_write_with_enable(dd, 0, buf, hi_water + 1);
-        }
-        mutex_unlock(&dd->eep_lock);
-        if (ret)
-                qib_dev_err(dd, "Failed updating EEPROM\n");
-
-free_bail:
-        vfree(buf);
-bail:
-        return ret;
-}
-
-/**
- * qib_inc_eeprom_err - increment one of the four error counters
- * that are logged to EEPROM.
- * @dd: the qlogic_ib device
- * @eidx: 0..3, the counter to increment
- * @incr: how much to add
- *
- * Each counter is 8-bits, and saturates at 255 (0xFF). They
- * are copied to the EEPROM (aka flash) whenever qib_update_eeprom_log()
- * is called, but it can only be called in a context that allows sleep.
- * This function can be called even at interrupt level.
- */
-void qib_inc_eeprom_err(struct qib_devdata *dd, u32 eidx, u32 incr)
-{
-        uint new_val;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dd->eep_st_lock, flags);
-        new_val = dd->eep_st_new_errs[eidx] + incr;
-        if (new_val > 255)
-                new_val = 255;
-        dd->eep_st_new_errs[eidx] = new_val;
-        spin_unlock_irqrestore(&dd->eep_st_lock, flags);
-}
diff --git a/drivers/infiniband/hw/qib/qib_file_ops.c b/drivers/infiniband/hw/qib/qib_file_ops.c
index b15e34eeef68..41937c6f888a 100644
--- a/drivers/infiniband/hw/qib/qib_file_ops.c
+++ b/drivers/infiniband/hw/qib/qib_file_ops.c
@@ -351,9 +351,10 @@ static int qib_tid_update(struct qib_ctxtdata *rcd, struct file *fp,
                  * unless perhaps the user has mpin'ed the pages
                  * themselves.
                  */
-                qib_devinfo(dd->pcidev,
-                         "Failed to lock addr %p, %u pages: "
-                         "errno %d\n", (void *) vaddr, cnt, -ret);
+                qib_devinfo(
+                        dd->pcidev,
+                        "Failed to lock addr %p, %u pages: errno %d\n",
+                        (void *) vaddr, cnt, -ret);
                 goto done;
         }
         for (i = 0; i < cnt; i++, vaddr += PAGE_SIZE) {
@@ -437,7 +438,7 @@ cleanup:
                         goto cleanup;
                 }
                 if (copy_to_user((void __user *) (unsigned long) ti->tidmap,
-                                 tidmap, sizeof tidmap)) {
+                                 tidmap, sizeof(tidmap))) {
                         ret = -EFAULT;
                         goto cleanup;
                 }
@@ -484,7 +485,7 @@ static int qib_tid_free(struct qib_ctxtdata *rcd, unsigned subctxt,
         }
 
         if (copy_from_user(tidmap, (void __user *)(unsigned long)ti->tidmap,
-                           sizeof tidmap)) {
+                           sizeof(tidmap))) {
                 ret = -EFAULT;
                 goto done;
         }
@@ -951,8 +952,8 @@ static int mmap_kvaddr(struct vm_area_struct *vma, u64 pgaddr,
                 /* rcvegrbufs are read-only on the slave */
                 if (vma->vm_flags & VM_WRITE) {
                         qib_devinfo(dd->pcidev,
-                                 "Can't map eager buffers as "
-                                 "writable (flags=%lx)\n", vma->vm_flags);
+                                 "Can't map eager buffers as writable (flags=%lx)\n",
+                                 vma->vm_flags);
                         ret = -EPERM;
                         goto bail;
                 }
@@ -1185,6 +1186,7 @@ static void assign_ctxt_affinity(struct file *fp, struct qib_devdata *dd)
          */
         if (weight >= qib_cpulist_count) {
                 int cpu;
+
                 cpu = find_first_zero_bit(qib_cpulist,
                                           qib_cpulist_count);
                 if (cpu == qib_cpulist_count)
@@ -1247,10 +1249,7 @@ static int init_subctxts(struct qib_devdata *dd,
         if (!qib_compatible_subctxts(uinfo->spu_userversion >> 16,
                 uinfo->spu_userversion & 0xffff)) {
                 qib_devinfo(dd->pcidev,
-                         "Mismatched user version (%d.%d) and driver "
-                         "version (%d.%d) while context sharing. Ensure "
-                         "that driver and library are from the same "
-                         "release.\n",
+                         "Mismatched user version (%d.%d) and driver version (%d.%d) while context sharing. Ensure that driver and library are from the same release.\n",
                          (int) (uinfo->spu_userversion >> 16),
                          (int) (uinfo->spu_userversion & 0xffff),
                          QIB_USER_SWMAJOR, QIB_USER_SWMINOR);
@@ -1391,6 +1390,7 @@ static int choose_port_ctxt(struct file *fp, struct qib_devdata *dd, u32 port,
         }
         if (!ppd) {
                 u32 pidx = ctxt % dd->num_pports;
+
                 if (usable(dd->pport + pidx))
                         ppd = dd->pport + pidx;
                 else {
@@ -1438,10 +1438,12 @@ static int get_a_ctxt(struct file *fp, const struct qib_user_info *uinfo,
 
         if (alg == QIB_PORT_ALG_ACROSS) {
                 unsigned inuse = ~0U;
+
                 /* find device (with ACTIVE ports) with fewest ctxts in use */
                 for (ndev = 0; ndev < devmax; ndev++) {
                         struct qib_devdata *dd = qib_lookup(ndev);
                         unsigned cused = 0, cfree = 0, pusable = 0;
+
                         if (!dd)
                                 continue;
                         if (port && port <= dd->num_pports &&
@@ -1471,6 +1473,7 @@ static int get_a_ctxt(struct file *fp, const struct qib_user_info *uinfo,
         } else {
                 for (ndev = 0; ndev < devmax; ndev++) {
                         struct qib_devdata *dd = qib_lookup(ndev);
+
                         if (dd) {
                                 ret = choose_port_ctxt(fp, dd, port, uinfo);
                                 if (!ret)
@@ -1556,6 +1559,7 @@ static int find_hca(unsigned int cpu, int *unit)
         }
         for (ndev = 0; ndev < devmax; ndev++) {
                 struct qib_devdata *dd = qib_lookup(ndev);
+
                 if (dd) {
                         if (pcibus_to_node(dd->pcidev->bus) < 0) {
                                 ret = -EINVAL;
diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index 81854586c081..650897a8591e 100644
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -106,7 +106,7 @@ static ssize_t driver_stats_read(struct file *file, char __user *buf,
 {
         qib_stats.sps_ints = qib_sps_ints();
         return simple_read_from_buffer(buf, count, ppos, &qib_stats,
-                                       sizeof qib_stats);
+                                       sizeof(qib_stats));
 }
 
 /*
@@ -133,7 +133,7 @@ static ssize_t driver_names_read(struct file *file, char __user *buf,
                                  size_t count, loff_t *ppos)
 {
         return simple_read_from_buffer(buf, count, ppos, qib_statnames,
-                sizeof qib_statnames - 1); /* no null */
+                sizeof(qib_statnames) - 1); /* no null */
 }
 
 static const struct file_operations driver_ops[] = {
@@ -379,7 +379,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
         int ret, i;
 
         /* create the per-unit directory */
-        snprintf(unit, sizeof unit, "%u", dd->unit);
+        snprintf(unit, sizeof(unit), "%u", dd->unit);
         ret = create_file(unit, S_IFDIR|S_IRUGO|S_IXUGO, sb->s_root, &dir,
                           &simple_dir_operations, dd);
         if (ret) {
@@ -455,7 +455,7 @@ static int remove_file(struct dentry *parent, char *name)
         }
 
         spin_lock(&tmp->d_lock);
-        if (!(d_unhashed(tmp) && tmp->d_inode)) {
+        if (!d_unhashed(tmp) && tmp->d_inode) {
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
                 simple_unlink(parent->d_inode, tmp);
@@ -482,7 +482,7 @@ static int remove_device_files(struct super_block *sb,
 
         root = dget(sb->s_root);
         mutex_lock(&root->d_inode->i_mutex);
-        snprintf(unit, sizeof unit, "%u", dd->unit);
+        snprintf(unit, sizeof(unit), "%u", dd->unit);
         dir = lookup_one_len(unit, root, strlen(unit));
 
         if (IS_ERR(dir)) {
@@ -560,6 +560,7 @@ static struct dentry *qibfs_mount(struct file_system_type *fs_type, int flags,
                         const char *dev_name, void *data)
 {
         struct dentry *ret;
+
         ret = mount_single(fs_type, flags, data, qibfs_fill_super);
         if (!IS_ERR(ret))
                 qib_super = ret->d_sb;
diff --git a/drivers/infiniband/hw/qib/qib_iba6120.c b/drivers/infiniband/hw/qib/qib_iba6120.c
index d68266ac7619..0d2ba59af30a 100644
--- a/drivers/infiniband/hw/qib/qib_iba6120.c
+++ b/drivers/infiniband/hw/qib/qib_iba6120.c
@@ -333,6 +333,7 @@ static inline void qib_write_ureg(const struct qib_devdata *dd,
                                   enum qib_ureg regno, u64 value, int ctxt)
 {
         u64 __iomem *ubase;
+
         if (dd->userbase)
                 ubase = (u64 __iomem *)
                         ((char __iomem *) dd->userbase +
@@ -834,14 +835,14 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
                 bits = (u32) ((hwerrs >>
                                QLOGIC_IB_HWE_PCIEMEMPARITYERR_SHIFT) &
                               QLOGIC_IB_HWE_PCIEMEMPARITYERR_MASK);
-                snprintf(bitsmsg, sizeof dd->cspec->bitsmsgbuf,
+                snprintf(bitsmsg, sizeof(dd->cspec->bitsmsgbuf),
                          "[PCIe Mem Parity Errs %x] ", bits);
                 strlcat(msg, bitsmsg, msgl);
         }
 
         if (hwerrs & _QIB_PLL_FAIL) {
                 isfatal = 1;
-                snprintf(bitsmsg, sizeof dd->cspec->bitsmsgbuf,
+                snprintf(bitsmsg, sizeof(dd->cspec->bitsmsgbuf),
                          "[PLL failed (%llx), InfiniPath hardware unusable]",
                          (unsigned long long) hwerrs & _QIB_PLL_FAIL);
                 strlcat(msg, bitsmsg, msgl);
@@ -1014,7 +1015,7 @@ static void handle_6120_errors(struct qib_devdata *dd, u64 errs)
 
         /* do these first, they are most important */
         if (errs & ERR_MASK(HardwareErr))
-                qib_handle_6120_hwerrors(dd, msg, sizeof dd->cspec->emsgbuf);
+                qib_handle_6120_hwerrors(dd, msg, sizeof(dd->cspec->emsgbuf));
         else
                 for (log_idx = 0; log_idx < QIB_EEP_LOG_CNT; ++log_idx)
                         if (errs & dd->eep_st_masks[log_idx].errs_to_log)
@@ -1062,7 +1063,7 @@ static void handle_6120_errors(struct qib_devdata *dd, u64 errs)
          */
         mask = ERR_MASK(IBStatusChanged) | ERR_MASK(RcvEgrFullErr) |
                 ERR_MASK(RcvHdrFullErr) | ERR_MASK(HardwareErr);
-        qib_decode_6120_err(dd, msg, sizeof dd->cspec->emsgbuf, errs & ~mask);
+        qib_decode_6120_err(dd, msg, sizeof(dd->cspec->emsgbuf), errs & ~mask);
 
         if (errs & E_SUM_PKTERRS)
                 qib_stats.sps_rcverrs++;
@@ -1670,6 +1671,7 @@ static irqreturn_t qib_6120intr(int irq, void *data)
                 }
                 if (crcs) {
                         u32 cntr = dd->cspec->lli_counter;
+
                         cntr += crcs;
                         if (cntr) {
                                 if (cntr > dd->cspec->lli_thresh) {
@@ -1722,6 +1724,7 @@ static void qib_setup_6120_interrupt(struct qib_devdata *dd)
                         "irq is 0, BIOS error?  Interrupts won't work\n");
         else {
                 int ret;
+
                 ret = request_irq(dd->cspec->irq, qib_6120intr, 0,
                                   QIB_DRV_NAME, dd);
                 if (ret)
@@ -2681,8 +2684,6 @@ static void qib_get_6120_faststats(unsigned long opaque)
         spin_lock_irqsave(&dd->eep_st_lock, flags);
         traffic_wds -= dd->traffic_wds;
         dd->traffic_wds += traffic_wds;
-        if (traffic_wds  >= QIB_TRAFFIC_ACTIVE_THRESHOLD)
-                atomic_add(5, &dd->active_time); /* S/B #define */
         spin_unlock_irqrestore(&dd->eep_st_lock, flags);
 
         qib_chk_6120_errormask(dd);
@@ -2929,6 +2930,7 @@ bail:
 static int qib_6120_set_loopback(struct qib_pportdata *ppd, const char *what)
 {
         int ret = 0;
+
         if (!strncmp(what, "ibc", 3)) {
                 ppd->dd->cspec->ibcctrl |= SYM_MASK(IBCCtrl, Loopback);
                 qib_devinfo(ppd->dd->pcidev, "Enabling IB%u:%u IBC loopback\n",
@@ -3170,6 +3172,7 @@ static void get_6120_chip_params(struct qib_devdata *dd)
 static void set_6120_baseaddrs(struct qib_devdata *dd)
 {
         u32 cregbase;
+
         cregbase = qib_read_kreg32(dd, kr_counterregbase);
         dd->cspec->cregbase = (u64 __iomem *)
                 ((char __iomem *) dd->kregbase + cregbase);
diff --git a/drivers/infiniband/hw/qib/qib_iba7220.c b/drivers/infiniband/hw/qib/qib_iba7220.c
index 7dec89fdc124..22affda8af88 100644
--- a/drivers/infiniband/hw/qib/qib_iba7220.c
+++ b/drivers/infiniband/hw/qib/qib_iba7220.c
@@ -902,7 +902,8 @@ static void sdma_7220_errors(struct qib_pportdata *ppd, u64 errs)
         errs &= QLOGIC_IB_E_SDMAERRS;
 
         msg = dd->cspec->sdmamsgbuf;
-        qib_decode_7220_sdma_errs(ppd, errs, msg, sizeof dd->cspec->sdmamsgbuf);
+        qib_decode_7220_sdma_errs(ppd, errs, msg,
+                sizeof(dd->cspec->sdmamsgbuf));
         spin_lock_irqsave(&ppd->sdma_lock, flags);
 
         if (errs & ERR_MASK(SendBufMisuseErr)) {
@@ -1043,6 +1044,7 @@ done:
 static void reenable_7220_chase(unsigned long opaque)
 {
         struct qib_pportdata *ppd = (struct qib_pportdata *)opaque;
+
         ppd->cpspec->chase_timer.expires = 0;
         qib_set_ib_7220_lstate(ppd, QLOGIC_IB_IBCC_LINKCMD_DOWN,
                 QLOGIC_IB_IBCC_LINKINITCMD_POLL);
@@ -1101,7 +1103,7 @@ static void handle_7220_errors(struct qib_devdata *dd, u64 errs)
 
         /* do these first, they are most important */
         if (errs & ERR_MASK(HardwareErr))
-                qib_7220_handle_hwerrors(dd, msg, sizeof dd->cspec->emsgbuf);
+                qib_7220_handle_hwerrors(dd, msg, sizeof(dd->cspec->emsgbuf));
         else
                 for (log_idx = 0; log_idx < QIB_EEP_LOG_CNT; ++log_idx)
                         if (errs & dd->eep_st_masks[log_idx].errs_to_log)
@@ -1155,7 +1157,7 @@ static void handle_7220_errors(struct qib_devdata *dd, u64 errs)
                 ERR_MASK(RcvEgrFullErr) | ERR_MASK(RcvHdrFullErr) |
                 ERR_MASK(HardwareErr) | ERR_MASK(SDmaDisabledErr);
 
-        qib_decode_7220_err(dd, msg, sizeof dd->cspec->emsgbuf, errs & ~mask);
+        qib_decode_7220_err(dd, msg, sizeof(dd->cspec->emsgbuf), errs & ~mask);
 
         if (errs & E_SUM_PKTERRS)
                 qib_stats.sps_rcverrs++;
@@ -1380,7 +1382,7 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
                 bits = (u32) ((hwerrs >>
                                QLOGIC_IB_HWE_PCIEMEMPARITYERR_SHIFT) &
                               QLOGIC_IB_HWE_PCIEMEMPARITYERR_MASK);
-                snprintf(bitsmsg, sizeof dd->cspec->bitsmsgbuf,
+                snprintf(bitsmsg, sizeof(dd->cspec->bitsmsgbuf),
                          "[PCIe Mem Parity Errs %x] ", bits);
                 strlcat(msg, bitsmsg, msgl);
         }
@@ -1390,7 +1392,7 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
 
         if (hwerrs & _QIB_PLL_FAIL) {
                 isfatal = 1;
-                snprintf(bitsmsg, sizeof dd->cspec->bitsmsgbuf,
+                snprintf(bitsmsg, sizeof(dd->cspec->bitsmsgbuf),
                          "[PLL failed (%llx), InfiniPath hardware unusable]",
                          (unsigned long long) hwerrs & _QIB_PLL_FAIL);
                 strlcat(msg, bitsmsg, msgl);
@@ -3297,8 +3299,6 @@ static void qib_get_7220_faststats(unsigned long opaque)
         spin_lock_irqsave(&dd->eep_st_lock, flags);
         traffic_wds -= dd->traffic_wds;
         dd->traffic_wds += traffic_wds;
-        if (traffic_wds  >= QIB_TRAFFIC_ACTIVE_THRESHOLD)
-                atomic_add(5, &dd->active_time); /* S/B #define */
         spin_unlock_irqrestore(&dd->eep_st_lock, flags);
 done:
         mod_timer(&dd->stats_timer, jiffies + HZ * ACTIVITY_TIMER);
diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c
index a7eb32517a04..ef97b71c8f7d 100644
--- a/drivers/infiniband/hw/qib/qib_iba7322.c
+++ b/drivers/infiniband/hw/qib/qib_iba7322.c
@@ -117,7 +117,7 @@ MODULE_PARM_DESC(chase, "Enable state chase handling");
 
 static ushort qib_long_atten = 10; /* 10 dB ~= 5m length */
 module_param_named(long_attenuation, qib_long_atten, ushort, S_IRUGO);
-MODULE_PARM_DESC(long_attenuation, \
+MODULE_PARM_DESC(long_attenuation,
                  "attenuation cutoff (dB) for long copper cable setup");
 
 static ushort qib_singleport;
@@ -153,11 +153,12 @@ static struct kparam_string kp_txselect = {
 static int  setup_txselect(const char *, struct kernel_param *);
 module_param_call(txselect, setup_txselect, param_get_string,
                   &kp_txselect, S_IWUSR | S_IRUGO);
-MODULE_PARM_DESC(txselect, \
+MODULE_PARM_DESC(txselect,
                  "Tx serdes indices (for no QSFP or invalid QSFP data)");
 
 #define BOARD_QME7342 5
 #define BOARD_QMH7342 6
+#define BOARD_QMH7360 9
 #define IS_QMH(dd) (SYM_FIELD((dd)->revision, Revision, BoardID) == \
                     BOARD_QMH7342)
 #define IS_QME(dd) (SYM_FIELD((dd)->revision, Revision, BoardID) == \
@@ -817,6 +818,7 @@ static inline void qib_write_ureg(const struct qib_devdata *dd,
                                   enum qib_ureg regno, u64 value, int ctxt)
 {
         u64 __iomem *ubase;
+
         if (dd->userbase)
                 ubase = (u64 __iomem *)
                         ((char __iomem *) dd->userbase +
@@ -1677,7 +1679,7 @@ static noinline void handle_7322_errors(struct qib_devdata *dd)
         /* do these first, they are most important */
         if (errs & QIB_E_HARDWARE) {
                 *msg = '\0';
-                qib_7322_handle_hwerrors(dd, msg, sizeof dd->cspec->emsgbuf);
+                qib_7322_handle_hwerrors(dd, msg, sizeof(dd->cspec->emsgbuf));
         } else
                 for (log_idx = 0; log_idx < QIB_EEP_LOG_CNT; ++log_idx)
                         if (errs & dd->eep_st_masks[log_idx].errs_to_log)
@@ -1702,7 +1704,7 @@ static noinline void handle_7322_errors(struct qib_devdata *dd)
         mask = QIB_E_HARDWARE;
         *msg = '\0';
 
-        err_decode(msg, sizeof dd->cspec->emsgbuf, errs & ~mask,
+        err_decode(msg, sizeof(dd->cspec->emsgbuf), errs & ~mask,
                    qib_7322error_msgs);
 
         /*
@@ -1889,10 +1891,10 @@ static noinline void handle_7322_p_errors(struct qib_pportdata *ppd)
         *msg = '\0';
 
         if (errs & ~QIB_E_P_BITSEXTANT) {
-                err_decode(msg, sizeof ppd->cpspec->epmsgbuf,
+                err_decode(msg, sizeof(ppd->cpspec->epmsgbuf),
                            errs & ~QIB_E_P_BITSEXTANT, qib_7322p_error_msgs);
                 if (!*msg)
-                        snprintf(msg, sizeof ppd->cpspec->epmsgbuf,
+                        snprintf(msg, sizeof(ppd->cpspec->epmsgbuf),
                                  "no others");
                 qib_dev_porterr(dd, ppd->port,
                         "error interrupt with unknown errors 0x%016Lx set (and %s)\n",
@@ -1906,7 +1908,7 @@ static noinline void handle_7322_p_errors(struct qib_pportdata *ppd)
                 /* determine cause, then write to clear */
                 symptom = qib_read_kreg_port(ppd, krp_sendhdrsymptom);
                 qib_write_kreg_port(ppd, krp_sendhdrsymptom, 0);
-                err_decode(msg, sizeof ppd->cpspec->epmsgbuf, symptom,
+                err_decode(msg, sizeof(ppd->cpspec->epmsgbuf), symptom,
                            hdrchk_msgs);
                 *msg = '\0';
                 /* senderrbuf cleared in SPKTERRS below */
@@ -1922,7 +1924,7 @@ static noinline void handle_7322_p_errors(struct qib_pportdata *ppd)
                          * isn't valid.  We don't want to confuse people, so
                          * we just don't print them, except at debug
                          */
-                        err_decode(msg, sizeof ppd->cpspec->epmsgbuf,
+                        err_decode(msg, sizeof(ppd->cpspec->epmsgbuf),
                                    (errs & QIB_E_P_LINK_PKTERRS),
                                    qib_7322p_error_msgs);
                         *msg = '\0';
@@ -1938,7 +1940,7 @@ static noinline void handle_7322_p_errors(struct qib_pportdata *ppd)
                  * valid.  We don't want to confuse people, so we just
                  * don't print them, except at debug
                  */
-                err_decode(msg, sizeof ppd->cpspec->epmsgbuf, errs,
+                err_decode(msg, sizeof(ppd->cpspec->epmsgbuf), errs,
                            qib_7322p_error_msgs);
                 ignore_this_time = errs & QIB_E_P_LINK_PKTERRS;
                 *msg = '\0';
@@ -2031,6 +2033,7 @@ static void qib_7322_set_intr_state(struct qib_devdata *dd, u32 enable)
                 if (dd->cspec->num_msix_entries) {
                         /* and same for MSIx */
                         u64 val = qib_read_kreg64(dd, kr_intgranted);
+
                         if (val)
                                 qib_write_kreg(dd, kr_intgranted, val);
                 }
@@ -2176,6 +2179,7 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
                 int err;
                 unsigned long flags;
                 struct qib_pportdata *ppd = dd->pport;
+
                 for (; pidx < dd->num_pports; ++pidx, ppd++) {
                         err = 0;
                         if (pidx == 0 && (hwerrs &
@@ -2801,9 +2805,11 @@ static void qib_irq_notifier_notify(struct irq_affinity_notify *notify,
 
         if (n->rcv) {
                 struct qib_ctxtdata *rcd = (struct qib_ctxtdata *)n->arg;
+
                 qib_update_rhdrq_dca(rcd, cpu);
         } else {
                 struct qib_pportdata *ppd = (struct qib_pportdata *)n->arg;
+
                 qib_update_sdma_dca(ppd, cpu);
         }
 }
@@ -2816,9 +2822,11 @@ static void qib_irq_notifier_release(struct kref *ref)
 
         if (n->rcv) {
                 struct qib_ctxtdata *rcd = (struct qib_ctxtdata *)n->arg;
+
                 dd = rcd->dd;
         } else {
                 struct qib_pportdata *ppd = (struct qib_pportdata *)n->arg;
+
                 dd = ppd->dd;
         }
         qib_devinfo(dd->pcidev,
@@ -2994,6 +3002,7 @@ static noinline void unknown_7322_gpio_intr(struct qib_devdata *dd)
                 struct qib_pportdata *ppd;
                 struct qib_qsfp_data *qd;
                 u32 mask;
+
                 if (!dd->pport[pidx].link_speed_supported)
                         continue;
                 mask = QSFP_GPIO_MOD_PRS_N;
@@ -3001,6 +3010,7 @@ static noinline void unknown_7322_gpio_intr(struct qib_devdata *dd)
                 mask <<= (QSFP_GPIO_PORT2_SHIFT * ppd->hw_pidx);
                 if (gpiostatus & dd->cspec->gpio_mask & mask) {
                         u64 pins;
+
                         qd = &ppd->cpspec->qsfp_data;
                         gpiostatus &= ~mask;
                         pins = qib_read_kreg64(dd, kr_extstatus);
@@ -3442,7 +3452,7 @@ try_intx:
         }
 
         /* Try to get MSIx interrupts */
-        memset(redirect, 0, sizeof redirect);
+        memset(redirect, 0, sizeof(redirect));
         mask = ~0ULL;
         msixnum = 0;
         local_mask = cpumask_of_pcibus(dd->pcidev->bus);
@@ -3617,6 +3627,10 @@ static unsigned qib_7322_boardname(struct qib_devdata *dd)
                 n = "InfiniPath_QME7362";
                 dd->flags |= QIB_HAS_QSFP;
                 break;
+        case BOARD_QMH7360:
+                n = "Intel IB QDR 1P FLR-QSFP Adptr";
+                dd->flags |= QIB_HAS_QSFP;
+                break;
         case 15:
                 n = "InfiniPath_QLE7342_TEST";
                 dd->flags |= QIB_HAS_QSFP;
@@ -3694,6 +3708,7 @@ static int qib_do_7322_reset(struct qib_devdata *dd)
          */
         for (i = 0; i < msix_entries; i++) {
                 u64 vecaddr, vecdata;
+
                 vecaddr = qib_read_kreg64(dd, 2 * i +
                                   (QIB_7322_MsixTable_OFFS / sizeof(u64)));
                 vecdata = qib_read_kreg64(dd, 1 + 2 * i +
@@ -5178,8 +5193,6 @@ static void qib_get_7322_faststats(unsigned long opaque)
                 spin_lock_irqsave(&ppd->dd->eep_st_lock, flags);
                 traffic_wds -= ppd->dd->traffic_wds;
                 ppd->dd->traffic_wds += traffic_wds;
-                if (traffic_wds >= QIB_TRAFFIC_ACTIVE_THRESHOLD)
-                        atomic_add(ACTIVITY_TIMER, &ppd->dd->active_time);
                 spin_unlock_irqrestore(&ppd->dd->eep_st_lock, flags);
                 if (ppd->cpspec->qdr_dfe_on && (ppd->link_speed_active &
                                                 QIB_IB_QDR) &&
@@ -5357,6 +5370,7 @@ static void qib_autoneg_7322_send(struct qib_pportdata *ppd, int which)
 static void set_7322_ibspeed_fast(struct qib_pportdata *ppd, u32 speed)
 {
         u64 newctrlb;
+
         newctrlb = ppd->cpspec->ibcctrl_b & ~(IBA7322_IBC_SPEED_MASK |
                                     IBA7322_IBC_IBTA_1_2_MASK |
                                     IBA7322_IBC_MAX_SPEED_MASK);
@@ -5843,6 +5857,7 @@ static void get_7322_chip_params(struct qib_devdata *dd)
 static void qib_7322_set_baseaddrs(struct qib_devdata *dd)
 {
         u32 cregbase;
+
         cregbase = qib_read_kreg32(dd, kr_counterregbase);
 
         dd->cspec->cregbase = (u64 __iomem *)(cregbase +
@@ -6183,6 +6198,7 @@ static int setup_txselect(const char *str, struct kernel_param *kp)
         struct qib_devdata *dd;
         unsigned long val;
         char *n;
+
         if (strlen(str) >= MAX_ATTEN_LEN) {
                 pr_info("txselect_values string too long\n");
                 return -ENOSPC;
@@ -6393,6 +6409,7 @@ static void write_7322_initregs(struct qib_devdata *dd)
         val = TIDFLOW_ERRBITS; /* these are W1C */
         for (i = 0; i < dd->cfgctxts; i++) {
                 int flow;
+
                 for (flow = 0; flow < NUM_TIDFLOWS_CTXT; flow++)
                         qib_write_ureg(dd, ur_rcvflowtable+flow, val, i);
         }
@@ -6503,6 +6520,7 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
 
         for (pidx = 0; pidx < NUM_IB_PORTS; ++pidx) {
                 struct qib_chippport_specific *cp = ppd->cpspec;
+
                 ppd->link_speed_supported = features & PORT_SPD_CAP;
                 features >>=  PORT_SPD_CAP_SHIFT;
                 if (!ppd->link_speed_supported) {
@@ -6581,8 +6599,7 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
                                 ppd->vls_supported = IB_VL_VL0_7;
                         else {
                                 qib_devinfo(dd->pcidev,
-                                            "Invalid num_vls %u for MTU %d "
-                                            ", using 4 VLs\n",
+                                            "Invalid num_vls %u for MTU %d , using 4 VLs\n",
                                             qib_num_cfg_vls, mtu);
                                 ppd->vls_supported = IB_VL_VL0_3;
                                 qib_num_cfg_vls = 4;
@@ -7890,6 +7907,7 @@ static void serdes_7322_los_enable(struct qib_pportdata *ppd, int enable)
 static int serdes_7322_init(struct qib_pportdata *ppd)
 {
         int ret = 0;
+
         if (ppd->dd->cspec->r1)
                 ret = serdes_7322_init_old(ppd);
         else
@@ -8305,8 +8323,8 @@ static void force_h1(struct qib_pportdata *ppd)
 
 static int qib_r_grab(struct qib_devdata *dd)
 {
-        u64 val;
-        val = SJA_EN;
+        u64 val = SJA_EN;
+
         qib_write_kreg(dd, kr_r_access, val);
         qib_read_kreg32(dd, kr_scratch);
         return 0;
@@ -8319,6 +8337,7 @@ static int qib_r_wait_for_rdy(struct qib_devdata *dd)
 {
         u64 val;
         int timeout;
+
         for (timeout = 0; timeout < 100 ; ++timeout) {
                 val = qib_read_kreg32(dd, kr_r_access);
                 if (val & R_RDY)
@@ -8346,6 +8365,7 @@ static int qib_r_shift(struct qib_devdata *dd, int bisten,
                 }
                 if (inp) {
                         int tdi = inp[pos >> 3] >> (pos & 7);
+
                         val |= ((tdi & 1) << R_TDI_LSB);
                 }
                 qib_write_kreg(dd, kr_r_access, val);
diff --git a/drivers/infiniband/hw/qib/qib_init.c b/drivers/infiniband/hw/qib/qib_init.c
index 729da39c49ed..2ee36953e234 100644
--- a/drivers/infiniband/hw/qib/qib_init.c
+++ b/drivers/infiniband/hw/qib/qib_init.c
@@ -140,7 +140,7 @@ int qib_create_ctxts(struct qib_devdata *dd)
          * Allocate full ctxtcnt array, rather than just cfgctxts, because
          * cleanup iterates across all possible ctxts.
          */
-        dd->rcd = kzalloc(sizeof(*dd->rcd) * dd->ctxtcnt, GFP_KERNEL);
+        dd->rcd = kcalloc(dd->ctxtcnt, sizeof(*dd->rcd), GFP_KERNEL);
         if (!dd->rcd) {
                 qib_dev_err(dd,
                         "Unable to allocate ctxtdata array, failing\n");
@@ -234,6 +234,7 @@ int qib_init_pportdata(struct qib_pportdata *ppd, struct qib_devdata *dd,
                         u8 hw_pidx, u8 port)
 {
         int size;
+
         ppd->dd = dd;
         ppd->hw_pidx = hw_pidx;
         ppd->port = port; /* IB port number, not index */
@@ -613,6 +614,7 @@ static int qib_create_workqueues(struct qib_devdata *dd)
                 ppd = dd->pport + pidx;
                 if (!ppd->qib_wq) {
                         char wq_name[8]; /* 3 + 2 + 1 + 1 + 1 */
+
                         snprintf(wq_name, sizeof(wq_name), "qib%d_%d",
                                 dd->unit, pidx);
                         ppd->qib_wq =
@@ -714,6 +716,7 @@ int qib_init(struct qib_devdata *dd, int reinit)
 
         for (pidx = 0; pidx < dd->num_pports; ++pidx) {
                 int mtu;
+
                 if (lastfail)
                         ret = lastfail;
                 ppd = dd->pport + pidx;
@@ -931,7 +934,6 @@ static void qib_shutdown_device(struct qib_devdata *dd)
                 qib_free_pportdata(ppd);
         }
 
-        qib_update_eeprom_log(dd);
 }
 
 /**
@@ -1026,8 +1028,7 @@ static void qib_verify_pioperf(struct qib_devdata *dd)
         addr = vmalloc(cnt);
         if (!addr) {
                 qib_devinfo(dd->pcidev,
-                         "Couldn't get memory for checking PIO perf,"
-                         " skipping\n");
+                         "Couldn't get memory for checking PIO perf, skipping\n");
                 goto done;
         }
 
@@ -1163,6 +1164,7 @@ struct qib_devdata *qib_alloc_devdata(struct pci_dev *pdev, size_t extra)
 
         if (!qib_cpulist_count) {
                 u32 count = num_online_cpus();
+
                 qib_cpulist = kzalloc(BITS_TO_LONGS(count) *
                                       sizeof(long), GFP_KERNEL);
                 if (qib_cpulist)
@@ -1179,7 +1181,7 @@ bail:
         if (!list_empty(&dd->list))
                 list_del_init(&dd->list);
         ib_dealloc_device(&dd->verbs_dev.ibdev);
-        return ERR_PTR(ret);;
+        return ERR_PTR(ret);
 }
 
 /*
diff --git a/drivers/infiniband/hw/qib/qib_intr.c b/drivers/infiniband/hw/qib/qib_intr.c
index f4918f2165ec..086616d071b9 100644
--- a/drivers/infiniband/hw/qib/qib_intr.c
+++ b/drivers/infiniband/hw/qib/qib_intr.c
@@ -168,7 +168,6 @@ skip_ibchange:
         ppd->lastibcstat = ibcs;
         if (ev)
                 signal_ib_event(ppd, ev);
-        return;
 }
 
 void qib_clear_symerror_on_linkup(unsigned long opaque)
diff --git a/drivers/infiniband/hw/qib/qib_keys.c b/drivers/infiniband/hw/qib/qib_keys.c
index 3b9afccaaade..ad843c786e72 100644
--- a/drivers/infiniband/hw/qib/qib_keys.c
+++ b/drivers/infiniband/hw/qib/qib_keys.c
@@ -122,10 +122,10 @@ void qib_free_lkey(struct qib_mregion *mr)
         if (!mr->lkey_published)
                 goto out;
         if (lkey == 0)
-                rcu_assign_pointer(dev->dma_mr, NULL);
+                RCU_INIT_POINTER(dev->dma_mr, NULL);
         else {
                 r = lkey >> (32 - ib_qib_lkey_table_size);
-                rcu_assign_pointer(rkt->table[r], NULL);
+                RCU_INIT_POINTER(rkt->table[r], NULL);
         }
         qib_put_mr(mr);
         mr->lkey_published = 0;
diff --git a/drivers/infiniband/hw/qib/qib_mad.c b/drivers/infiniband/hw/qib/qib_mad.c
index 636be117b578..395f4046dba2 100644
--- a/drivers/infiniband/hw/qib/qib_mad.c
+++ b/drivers/infiniband/hw/qib/qib_mad.c
@@ -152,14 +152,14 @@ void qib_bad_pqkey(struct qib_ibport *ibp, __be16 trap_num, u32 key, u32 sl,
         data.trap_num = trap_num;
         data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
         data.toggle_count = 0;
-        memset(&data.details, 0, sizeof data.details);
+        memset(&data.details, 0, sizeof(data.details));
         data.details.ntc_257_258.lid1 = lid1;
         data.details.ntc_257_258.lid2 = lid2;
         data.details.ntc_257_258.key = cpu_to_be32(key);
         data.details.ntc_257_258.sl_qp1 = cpu_to_be32((sl << 28) | qp1);
         data.details.ntc_257_258.qp2 = cpu_to_be32(qp2);
 
-        qib_send_trap(ibp, &data, sizeof data);
+        qib_send_trap(ibp, &data, sizeof(data));
 }
 
 /*
@@ -176,7 +176,7 @@ static void qib_bad_mkey(struct qib_ibport *ibp, struct ib_smp *smp)
         data.trap_num = IB_NOTICE_TRAP_BAD_MKEY;
         data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
         data.toggle_count = 0;
-        memset(&data.details, 0, sizeof data.details);
+        memset(&data.details, 0, sizeof(data.details));
         data.details.ntc_256.lid = data.issuer_lid;
         data.details.ntc_256.method = smp->method;
         data.details.ntc_256.attr_id = smp->attr_id;
@@ -198,7 +198,7 @@ static void qib_bad_mkey(struct qib_ibport *ibp, struct ib_smp *smp)
                        hop_cnt);
         }
 
-        qib_send_trap(ibp, &data, sizeof data);
+        qib_send_trap(ibp, &data, sizeof(data));
 }
 
 /*
@@ -214,11 +214,11 @@ void qib_cap_mask_chg(struct qib_ibport *ibp)
         data.trap_num = IB_NOTICE_TRAP_CAP_MASK_CHG;
         data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
         data.toggle_count = 0;
-        memset(&data.details, 0, sizeof data.details);
+        memset(&data.details, 0, sizeof(data.details));
         data.details.ntc_144.lid = data.issuer_lid;
         data.details.ntc_144.new_cap_mask = cpu_to_be32(ibp->port_cap_flags);
 
-        qib_send_trap(ibp, &data, sizeof data);
+        qib_send_trap(ibp, &data, sizeof(data));
 }
 
 /*
@@ -234,11 +234,11 @@ void qib_sys_guid_chg(struct qib_ibport *ibp)
         data.trap_num = IB_NOTICE_TRAP_SYS_GUID_CHG;
         data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
         data.toggle_count = 0;
-        memset(&data.details, 0, sizeof data.details);
+        memset(&data.details, 0, sizeof(data.details));
         data.details.ntc_145.lid = data.issuer_lid;
         data.details.ntc_145.new_sys_guid = ib_qib_sys_image_guid;
 
-        qib_send_trap(ibp, &data, sizeof data);
+        qib_send_trap(ibp, &data, sizeof(data));
 }
 
 /*
@@ -254,12 +254,12 @@ void qib_node_desc_chg(struct qib_ibport *ibp)
         data.trap_num = IB_NOTICE_TRAP_CAP_MASK_CHG;
         data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
         data.toggle_count = 0;
-        memset(&data.details, 0, sizeof data.details);
+        memset(&data.details, 0, sizeof(data.details));
         data.details.ntc_144.lid = data.issuer_lid;
         data.details.ntc_144.local_changes = 1;
         data.details.ntc_144.change_flags = IB_NOTICE_TRAP_NODE_DESC_CHG;
 
-        qib_send_trap(ibp, &data, sizeof data);
+        qib_send_trap(ibp, &data, sizeof(data));
 }
 
 static int subn_get_nodedescription(struct ib_smp *smp,
diff --git a/drivers/infiniband/hw/qib/qib_mmap.c b/drivers/infiniband/hw/qib/qib_mmap.c
index 8b73a11d571c..146cf29a2e1d 100644
--- a/drivers/infiniband/hw/qib/qib_mmap.c
+++ b/drivers/infiniband/hw/qib/qib_mmap.c
@@ -134,7 +134,7 @@ struct qib_mmap_info *qib_create_mmap_info(struct qib_ibdev *dev,
                                            void *obj) {
         struct qib_mmap_info *ip;
 
-        ip = kmalloc(sizeof *ip, GFP_KERNEL);
+        ip = kmalloc(sizeof(*ip), GFP_KERNEL);
         if (!ip)
                 goto bail;
 
diff --git a/drivers/infiniband/hw/qib/qib_mr.c b/drivers/infiniband/hw/qib/qib_mr.c
index a77fb4fb14e4..c4473db46699 100644
--- a/drivers/infiniband/hw/qib/qib_mr.c
+++ b/drivers/infiniband/hw/qib/qib_mr.c
@@ -55,7 +55,7 @@ static int init_qib_mregion(struct qib_mregion *mr, struct ib_pd *pd,
 
         m = (count + QIB_SEGSZ - 1) / QIB_SEGSZ;
         for (; i < m; i++) {
-                mr->map[i] = kzalloc(sizeof *mr->map[0], GFP_KERNEL);
+                mr->map[i] = kzalloc(sizeof(*mr->map[0]), GFP_KERNEL);
                 if (!mr->map[i])
                         goto bail;
         }
@@ -104,7 +104,7 @@ struct ib_mr *qib_get_dma_mr(struct ib_pd *pd, int acc)
                 goto bail;
         }
 
-        mr = kzalloc(sizeof *mr, GFP_KERNEL);
+        mr = kzalloc(sizeof(*mr), GFP_KERNEL);
         if (!mr) {
                 ret = ERR_PTR(-ENOMEM);
                 goto bail;
@@ -143,7 +143,7 @@ static struct qib_mr *alloc_mr(int count, struct ib_pd *pd)
 
         /* Allocate struct plus pointers to first level page tables. */
         m = (count + QIB_SEGSZ - 1) / QIB_SEGSZ;
-        mr = kzalloc(sizeof *mr + m * sizeof mr->mr.map[0], GFP_KERNEL);
+        mr = kzalloc(sizeof(*mr) + m * sizeof(mr->mr.map[0]), GFP_KERNEL);
         if (!mr)
                 goto bail;
 
@@ -347,7 +347,7 @@ qib_alloc_fast_reg_page_list(struct ib_device *ibdev, int page_list_len)
         if (size > PAGE_SIZE)
                 return ERR_PTR(-EINVAL);
 
-        pl = kzalloc(sizeof *pl, GFP_KERNEL);
+        pl = kzalloc(sizeof(*pl), GFP_KERNEL);
         if (!pl)
                 return ERR_PTR(-ENOMEM);
 
@@ -386,7 +386,7 @@ struct ib_fmr *qib_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
 
         /* Allocate struct plus pointers to first level page tables. */
         m = (fmr_attr->max_pages + QIB_SEGSZ - 1) / QIB_SEGSZ;
-        fmr = kzalloc(sizeof *fmr + m * sizeof fmr->mr.map[0], GFP_KERNEL);
+        fmr = kzalloc(sizeof(*fmr) + m * sizeof(fmr->mr.map[0]), GFP_KERNEL);
         if (!fmr)
                 goto bail;
 
diff --git a/drivers/infiniband/hw/qib/qib_pcie.c b/drivers/infiniband/hw/qib/qib_pcie.c
index 61a0046efb76..4758a3801ae8 100644
--- a/drivers/infiniband/hw/qib/qib_pcie.c
+++ b/drivers/infiniband/hw/qib/qib_pcie.c
@@ -210,7 +210,7 @@ static void qib_msix_setup(struct qib_devdata *dd, int pos, u32 *msixcnt,
         /* We can't pass qib_msix_entry array to qib_msix_setup
          * so use a dummy msix_entry array and copy the allocated
          * irq back to the qib_msix_entry array. */
-        msix_entry = kmalloc(nvec * sizeof(*msix_entry), GFP_KERNEL);
+        msix_entry = kcalloc(nvec, sizeof(*msix_entry), GFP_KERNEL);
         if (!msix_entry)
                 goto do_intx;
 
@@ -234,8 +234,10 @@ free_msix_entry:
         kfree(msix_entry);
 
 do_intx:
-        qib_dev_err(dd, "pci_enable_msix_range %d vectors failed: %d, "
-                        "falling back to INTx\n", nvec, ret);
+        qib_dev_err(
+                dd,
+                "pci_enable_msix_range %d vectors failed: %d, falling back to INTx\n",
+                nvec, ret);
         *msixcnt = 0;
         qib_enable_intx(dd->pcidev);
 }
@@ -459,6 +461,7 @@ void qib_pcie_getcmd(struct qib_devdata *dd, u16 *cmd, u8 *iline, u8 *cline)
 void qib_pcie_reenable(struct qib_devdata *dd, u16 cmd, u8 iline, u8 cline)
 {
         int r;
+
         r = pci_write_config_dword(dd->pcidev, PCI_BASE_ADDRESS_0,
                                    dd->pcibar0);
         if (r)
@@ -696,6 +699,7 @@ static void
 qib_pci_resume(struct pci_dev *pdev)
 {
         struct qib_devdata *dd = pci_get_drvdata(pdev);
+
         qib_devinfo(pdev, "QIB resume function called\n");
         pci_cleanup_aer_uncorrect_error_status(pdev);
         /*
diff --git a/drivers/infiniband/hw/qib/qib_qp.c b/drivers/infiniband/hw/qib/qib_qp.c
index 6ddc0264aad2..4fa88ba2963e 100644
--- a/drivers/infiniband/hw/qib/qib_qp.c
+++ b/drivers/infiniband/hw/qib/qib_qp.c
@@ -255,10 +255,10 @@ static void remove_qp(struct qib_ibdev *dev, struct qib_qp *qp)
 
         if (rcu_dereference_protected(ibp->qp0,
                         lockdep_is_held(&dev->qpt_lock)) == qp) {
-                rcu_assign_pointer(ibp->qp0, NULL);
+                RCU_INIT_POINTER(ibp->qp0, NULL);
         } else if (rcu_dereference_protected(ibp->qp1,
                         lockdep_is_held(&dev->qpt_lock)) == qp) {
-                rcu_assign_pointer(ibp->qp1, NULL);
+                RCU_INIT_POINTER(ibp->qp1, NULL);
         } else {
                 struct qib_qp *q;
                 struct qib_qp __rcu **qpp;
@@ -269,7 +269,7 @@ static void remove_qp(struct qib_ibdev *dev, struct qib_qp *qp)
                                 lockdep_is_held(&dev->qpt_lock))) != NULL;
                                 qpp = &q->next)
                         if (q == qp) {
-                                rcu_assign_pointer(*qpp,
+                                RCU_INIT_POINTER(*qpp,
                                         rcu_dereference_protected(qp->next,
                                          lockdep_is_held(&dev->qpt_lock)));
                                 removed = 1;
@@ -315,7 +315,7 @@ unsigned qib_free_all_qps(struct qib_devdata *dd)
         for (n = 0; n < dev->qp_table_size; n++) {
                 qp = rcu_dereference_protected(dev->qp_table[n],
                         lockdep_is_held(&dev->qpt_lock));
-                rcu_assign_pointer(dev->qp_table[n], NULL);
+                RCU_INIT_POINTER(dev->qp_table[n], NULL);
 
                 for (; qp; qp = rcu_dereference_protected(qp->next,
                                         lockdep_is_held(&dev->qpt_lock)))
diff --git a/drivers/infiniband/hw/qib/qib_qsfp.c b/drivers/infiniband/hw/qib/qib_qsfp.c
index fa71b1e666c5..5e27f76805e2 100644
--- a/drivers/infiniband/hw/qib/qib_qsfp.c
+++ b/drivers/infiniband/hw/qib/qib_qsfp.c
@@ -81,7 +81,7 @@ static int qsfp_read(struct qib_pportdata *ppd, int addr, void *bp, int len)
          * Module could take up to 2 Msec to respond to MOD_SEL, and there
          * is no way to tell if it is ready, so we must wait.
          */
-        msleep(2);
+        msleep(20);
 
         /* Make sure TWSI bus is in sane state. */
         ret = qib_twsi_reset(dd);
@@ -99,6 +99,7 @@ static int qsfp_read(struct qib_pportdata *ppd, int addr, void *bp, int len)
         while (cnt < len) {
                 unsigned in_page;
                 int wlen = len - cnt;
+
                 in_page = addr % QSFP_PAGESIZE;
                 if ((in_page + wlen) > QSFP_PAGESIZE)
                         wlen = QSFP_PAGESIZE - in_page;
@@ -139,7 +140,7 @@ deselect:
         else if (pass)
                 qib_dev_porterr(dd, ppd->port, "QSFP retries: %d\n", pass);
 
-        msleep(2);
+        msleep(20);
 
 bail:
         mutex_unlock(&dd->eep_lock);
@@ -189,7 +190,7 @@ static int qib_qsfp_write(struct qib_pportdata *ppd, int addr, void *bp,
          * Module could take up to 2 Msec to respond to MOD_SEL,
          * and there is no way to tell if it is ready, so we must wait.
          */
-        msleep(2);
+        msleep(20);
 
         /* Make sure TWSI bus is in sane state. */
         ret = qib_twsi_reset(dd);
@@ -206,6 +207,7 @@ static int qib_qsfp_write(struct qib_pportdata *ppd, int addr, void *bp,
         while (cnt < len) {
                 unsigned in_page;
                 int wlen = len - cnt;
+
                 in_page = addr % QSFP_PAGESIZE;
                 if ((in_page + wlen) > QSFP_PAGESIZE)
                         wlen = QSFP_PAGESIZE - in_page;
@@ -234,7 +236,7 @@ deselect:
          * going away, and there is no way to tell if it is ready.
          * so we must wait.
          */
-        msleep(2);
+        msleep(20);
 
 bail:
         mutex_unlock(&dd->eep_lock);
@@ -296,6 +298,7 @@ int qib_refresh_qsfp_cache(struct qib_pportdata *ppd, struct qib_qsfp_cache *cp)
                  * set the page to zero, Even if it already appears to be zero.
                  */
                 u8 poke = 0;
+
                 ret = qib_qsfp_write(ppd, 127, &poke, 1);
                 udelay(50);
                 if (ret != 1) {
@@ -480,7 +483,6 @@ void qib_qsfp_init(struct qib_qsfp_data *qd,
         udelay(20); /* Generous RST dwell */
 
         dd->f_gpio_mod(dd, mask, mask, mask);
-        return;
 }
 
 void qib_qsfp_deinit(struct qib_qsfp_data *qd)
@@ -540,6 +542,7 @@ int qib_qsfp_dump(struct qib_pportdata *ppd, char *buf, int len)
 
         while (bidx < QSFP_DEFAULT_HDR_CNT) {
                 int iidx;
+
                 ret = qsfp_read(ppd, bidx, bin_buff, QSFP_DUMP_CHUNK);
                 if (ret < 0)
                         goto bail;
diff --git a/drivers/infiniband/hw/qib/qib_rc.c b/drivers/infiniband/hw/qib/qib_rc.c
index 2f2501890c4e..4544d6f88ad7 100644
--- a/drivers/infiniband/hw/qib/qib_rc.c
+++ b/drivers/infiniband/hw/qib/qib_rc.c
@@ -1017,7 +1017,7 @@ void qib_rc_send_complete(struct qib_qp *qp, struct qib_ib_header *hdr)
                 /* Post a send completion queue entry if requested. */
                 if (!(qp->s_flags & QIB_S_SIGNAL_REQ_WR) ||
                     (wqe->wr.send_flags & IB_SEND_SIGNALED)) {
-                        memset(&wc, 0, sizeof wc);
+                        memset(&wc, 0, sizeof(wc));
                         wc.wr_id = wqe->wr.wr_id;
                         wc.status = IB_WC_SUCCESS;
                         wc.opcode = ib_qib_wc_opcode[wqe->wr.opcode];
@@ -1073,7 +1073,7 @@ static struct qib_swqe *do_rc_completion(struct qib_qp *qp,
                 /* Post a send completion queue entry if requested. */
                 if (!(qp->s_flags & QIB_S_SIGNAL_REQ_WR) ||
                     (wqe->wr.send_flags & IB_SEND_SIGNALED)) {
-                        memset(&wc, 0, sizeof wc);
+                        memset(&wc, 0, sizeof(wc));
                         wc.wr_id = wqe->wr.wr_id;
                         wc.status = IB_WC_SUCCESS;
                         wc.opcode = ib_qib_wc_opcode[wqe->wr.opcode];
diff --git a/drivers/infiniband/hw/qib/qib_ruc.c b/drivers/infiniband/hw/qib/qib_ruc.c
index 4c07a8b34ffe..f42bd0f47577 100644
--- a/drivers/infiniband/hw/qib/qib_ruc.c
+++ b/drivers/infiniband/hw/qib/qib_ruc.c
@@ -247,8 +247,8 @@ static __be64 get_sguid(struct qib_ibport *ibp, unsigned index)
                 struct qib_pportdata *ppd = ppd_from_ibp(ibp);
 
                 return ppd->guid;
-        } else
-                return ibp->guids[index - 1];
+        }
+        return ibp->guids[index - 1];
 }
 
 static int gid_ok(union ib_gid *gid, __be64 gid_prefix, __be64 id)
@@ -420,7 +420,7 @@ again:
                 goto serr;
         }
 
-        memset(&wc, 0, sizeof wc);
+        memset(&wc, 0, sizeof(wc));
         send_status = IB_WC_SUCCESS;
 
         release = 1;
@@ -792,7 +792,7 @@ void qib_send_complete(struct qib_qp *qp, struct qib_swqe *wqe,
             status != IB_WC_SUCCESS) {
                 struct ib_wc wc;
 
-                memset(&wc, 0, sizeof wc);
+                memset(&wc, 0, sizeof(wc));
                 wc.wr_id = wqe->wr.wr_id;
                 wc.status = status;
                 wc.opcode = ib_qib_wc_opcode[wqe->wr.opcode];
diff --git a/drivers/infiniband/hw/qib/qib_sd7220.c b/drivers/infiniband/hw/qib/qib_sd7220.c
index 911205d3d5a0..c72775f27212 100644
--- a/drivers/infiniband/hw/qib/qib_sd7220.c
+++ b/drivers/infiniband/hw/qib/qib_sd7220.c
@@ -259,6 +259,7 @@ static int qib_ibsd_reset(struct qib_devdata *dd, int assert_rst)
                  * it again during startup.
                  */
                 u64 val;
+
                 rst_val &= ~(1ULL);
                 qib_write_kreg(dd, kr_hwerrmask,
                                dd->cspec->hwerrmask &
@@ -590,6 +591,7 @@ static int epb_access(struct qib_devdata *dd, int sdnum, int claim)
                  * Both should be clear
                  */
                 u64 newval = 0;
+
                 qib_write_kreg(dd, acc, newval);
                 /* First read after write is not trustworthy */
                 pollval = qib_read_kreg32(dd, acc);
@@ -601,6 +603,7 @@ static int epb_access(struct qib_devdata *dd, int sdnum, int claim)
                 /* Need to claim */
                 u64 pollval;
                 u64 newval = EPB_ACC_REQ | oct_sel;
+
                 qib_write_kreg(dd, acc, newval);
                 /* First read after write is not trustworthy */
                 pollval = qib_read_kreg32(dd, acc);
@@ -812,6 +815,7 @@ static int qib_sd7220_ram_xfer(struct qib_devdata *dd, int sdnum, u32 loc,
                         if (!sofar) {
                                 /* Only set address at start of chunk */
                                 int addrbyte = (addr + sofar) >> 8;
+
                                 transval = csbit | EPB_MADDRH | addrbyte;
                                 tries = epb_trans(dd, trans, transval,
                                                   &transval);
@@ -922,7 +926,7 @@ qib_sd7220_ib_vfy(struct qib_devdata *dd, const struct firmware *fw)
  * IRQ not set up at this point in init, so we poll.
  */
 #define IB_SERDES_TRIM_DONE (1ULL << 11)
-#define TRIM_TMO (30)
+#define TRIM_TMO (15)
 
 static int qib_sd_trimdone_poll(struct qib_devdata *dd)
 {
@@ -940,7 +944,7 @@ static int qib_sd_trimdone_poll(struct qib_devdata *dd)
                         ret = 1;
                         break;
                 }
-                msleep(10);
+                msleep(20);
         }
         if (trim_tmo >= TRIM_TMO) {
                 qib_dev_err(dd, "No TRIMDONE in %d tries\n", trim_tmo);
@@ -1071,6 +1075,7 @@ static int qib_sd_setvals(struct qib_devdata *dd)
                 dds_reg_map >>= 4;
                 for (midx = 0; midx < DDS_ROWS; ++midx) {
                         u64 __iomem *daddr = taddr + ((midx << 4) + idx);
+
                         data = dds_init_vals[midx].reg_vals[idx];
                         writeq(data, daddr);
                         mmiowb();
diff --git a/drivers/infiniband/hw/qib/qib_sysfs.c b/drivers/infiniband/hw/qib/qib_sysfs.c
index 3c8e4e3caca6..81f56cdff2bc 100644
--- a/drivers/infiniband/hw/qib/qib_sysfs.c
+++ b/drivers/infiniband/hw/qib/qib_sysfs.c
@@ -586,8 +586,8 @@ static ssize_t show_serial(struct device *device,
                 container_of(device, struct qib_ibdev, ibdev.dev);
         struct qib_devdata *dd = dd_from_dev(dev);
 
-        buf[sizeof dd->serial] = '\0';
-        memcpy(buf, dd->serial, sizeof dd->serial);
+        buf[sizeof(dd->serial)] = '\0';
+        memcpy(buf, dd->serial, sizeof(dd->serial));
         strcat(buf, "\n");
         return strlen(buf);
 }
@@ -611,28 +611,6 @@ bail:
         return ret < 0 ? ret : count;
 }
 
-static ssize_t show_logged_errs(struct device *device,
-                                struct device_attribute *attr, char *buf)
-{
-        struct qib_ibdev *dev =
-                container_of(device, struct qib_ibdev, ibdev.dev);
-        struct qib_devdata *dd = dd_from_dev(dev);
-        int idx, count;
-
-        /* force consistency with actual EEPROM */
-        if (qib_update_eeprom_log(dd) != 0)
-                return -ENXIO;
-
-        count = 0;
-        for (idx = 0; idx < QIB_EEP_LOG_CNT; ++idx) {
-                count += scnprintf(buf + count, PAGE_SIZE - count, "%d%c",
-                                   dd->eep_st_errs[idx],
-                                   idx == (QIB_EEP_LOG_CNT - 1) ? '\n' : ' ');
-        }
-
-        return count;
-}
-
 /*
  * Dump tempsense regs. in decimal, to ease shell-scripts.
  */
@@ -679,7 +657,6 @@ static DEVICE_ATTR(nctxts, S_IRUGO, show_nctxts, NULL);
 static DEVICE_ATTR(nfreectxts, S_IRUGO, show_nfreectxts, NULL);
 static DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL);
 static DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL);
-static DEVICE_ATTR(logged_errors, S_IRUGO, show_logged_errs, NULL);
 static DEVICE_ATTR(tempsense, S_IRUGO, show_tempsense, NULL);
 static DEVICE_ATTR(localbus_info, S_IRUGO, show_localbus_info, NULL);
 static DEVICE_ATTR(chip_reset, S_IWUSR, NULL, store_chip_reset);
@@ -693,7 +670,6 @@ static struct device_attribute *qib_attributes[] = {
         &dev_attr_nfreectxts,
         &dev_attr_serial,
         &dev_attr_boardversion,
-        &dev_attr_logged_errors,
         &dev_attr_tempsense,
         &dev_attr_localbus_info,
         &dev_attr_chip_reset,
diff --git a/drivers/infiniband/hw/qib/qib_twsi.c b/drivers/infiniband/hw/qib/qib_twsi.c
index 647f7beb1b0a..f5698664419b 100644
--- a/drivers/infiniband/hw/qib/qib_twsi.c
+++ b/drivers/infiniband/hw/qib/qib_twsi.c
@@ -105,6 +105,7 @@ static void scl_out(struct qib_devdata *dd, u8 bit)
                 udelay(2);
         else {
                 int rise_usec;
+
                 for (rise_usec = SCL_WAIT_USEC; rise_usec > 0; rise_usec -= 2) {
                         if (mask & dd->f_gpio_mod(dd, 0, 0, 0))
                                 break;
@@ -326,6 +327,7 @@ int qib_twsi_reset(struct qib_devdata *dd)
 static int qib_twsi_wr(struct qib_devdata *dd, int data, int flags)
 {
         int ret = 1;
+
         if (flags & QIB_TWSI_START)
                 start_seq(dd);
 
@@ -435,8 +437,7 @@ int qib_twsi_blk_wr(struct qib_devdata *dd, int dev, int addr,
         int sub_len;
         const u8 *bp = buffer;
         int max_wait_time, i;
-        int ret;
-        ret = 1;
+        int ret = 1;
 
         while (len > 0) {
                 if (dev == QIB_TWSI_NO_DEV) {
diff --git a/drivers/infiniband/hw/qib/qib_tx.c b/drivers/infiniband/hw/qib/qib_tx.c
index 31d3561400a4..eface3b3dacf 100644
--- a/drivers/infiniband/hw/qib/qib_tx.c
+++ b/drivers/infiniband/hw/qib/qib_tx.c
@@ -180,6 +180,7 @@ void qib_disarm_piobufs_set(struct qib_devdata *dd, unsigned long *mask,
 
         for (i = 0; i < cnt; i++) {
                 int which;
+
                 if (!test_bit(i, mask))
                         continue;
                 /*
diff --git a/drivers/infiniband/hw/qib/qib_ud.c b/drivers/infiniband/hw/qib/qib_ud.c
index aaf7039f8ed2..26243b722b5e 100644
--- a/drivers/infiniband/hw/qib/qib_ud.c
+++ b/drivers/infiniband/hw/qib/qib_ud.c
@@ -127,7 +127,7 @@ static void qib_ud_loopback(struct qib_qp *sqp, struct qib_swqe *swqe)
          * present on the wire.
          */
         length = swqe->length;
-        memset(&wc, 0, sizeof wc);
+        memset(&wc, 0, sizeof(wc));
         wc.byte_len = length + sizeof(struct ib_grh);
 
         if (swqe->wr.opcode == IB_WR_SEND_WITH_IMM) {
diff --git a/drivers/infiniband/hw/qib/qib_user_sdma.c b/drivers/infiniband/hw/qib/qib_user_sdma.c
index d2806cae234c..3e0677c51276 100644
--- a/drivers/infiniband/hw/qib/qib_user_sdma.c
+++ b/drivers/infiniband/hw/qib/qib_user_sdma.c
@@ -50,7 +50,7 @@
 /* expected size of headers (for dma_pool) */
 #define QIB_USER_SDMA_EXP_HEADER_LENGTH 64
 /* attempt to drain the queue for 5secs */
-#define QIB_USER_SDMA_DRAIN_TIMEOUT 500
+#define QIB_USER_SDMA_DRAIN_TIMEOUT 250
 
 /*
  * track how many times a process open this driver.
@@ -226,6 +226,7 @@ qib_user_sdma_queue_create(struct device *dev, int unit, int ctxt, int sctxt)
                 sdma_rb_node->refcount++;
         } else {
                 int ret;
+
                 sdma_rb_node = kmalloc(sizeof(
                         struct qib_user_sdma_rb_node), GFP_KERNEL);
                 if (!sdma_rb_node)
@@ -936,6 +937,7 @@ static int qib_user_sdma_queue_pkts(const struct qib_devdata *dd,
 
                         if (tiddma) {
                                 char *tidsm = (char *)pkt + pktsize;
+
                                 cfur = copy_from_user(tidsm,
                                         iov[idx].iov_base, tidsmsize);
                                 if (cfur) {
@@ -1142,7 +1144,7 @@ void qib_user_sdma_queue_drain(struct qib_pportdata *ppd,
                 qib_user_sdma_hwqueue_clean(ppd);
                 qib_user_sdma_queue_clean(ppd, pq);
                 mutex_unlock(&pq->lock);
-                msleep(10);
+                msleep(20);
         }
 
         if (pq->num_pending || pq->num_sending) {
@@ -1316,8 +1318,6 @@ retry:
 
         if (nfree && !list_empty(pktlist))
                 goto retry;
-
-        return;
 }
 
 /* pq->lock must be held, get packets on the wire... */
diff --git a/drivers/infiniband/hw/qib/qib_verbs.c b/drivers/infiniband/hw/qib/qib_verbs.c
index 9bcfbd842980..4a3599890ea5 100644
--- a/drivers/infiniband/hw/qib/qib_verbs.c
+++ b/drivers/infiniband/hw/qib/qib_verbs.c
@@ -1342,6 +1342,7 @@ static int qib_verbs_send_pio(struct qib_qp *qp, struct qib_ib_header *ibhdr,
 done:
         if (dd->flags & QIB_USE_SPCL_TRIG) {
                 u32 spcl_off = (pbufn >= dd->piobcnt2k) ? 2047 : 1023;
+
                 qib_flush_wc();
                 __raw_writel(0xaebecede, piobuf_orig + spcl_off);
         }
@@ -1744,7 +1745,7 @@ static struct ib_pd *qib_alloc_pd(struct ib_device *ibdev,
          * we allow allocations of more than we report for this value.
          */
 
-        pd = kmalloc(sizeof *pd, GFP_KERNEL);
+        pd = kmalloc(sizeof(*pd), GFP_KERNEL);
         if (!pd) {
                 ret = ERR_PTR(-ENOMEM);
                 goto bail;
@@ -1829,7 +1830,7 @@ static struct ib_ah *qib_create_ah(struct ib_pd *pd,
                 goto bail;
         }
 
-        ah = kmalloc(sizeof *ah, GFP_ATOMIC);
+        ah = kmalloc(sizeof(*ah), GFP_ATOMIC);
         if (!ah) {
                 ret = ERR_PTR(-ENOMEM);
                 goto bail;
@@ -1862,7 +1863,7 @@ struct ib_ah *qib_create_qp0_ah(struct qib_ibport *ibp, u16 dlid)
         struct ib_ah *ah = ERR_PTR(-EINVAL);
         struct qib_qp *qp0;
 
-        memset(&attr, 0, sizeof attr);
+        memset(&attr, 0, sizeof(attr));
         attr.dlid = dlid;
         attr.port_num = ppd_from_ibp(ibp)->port;
         rcu_read_lock();
@@ -1977,7 +1978,7 @@ static struct ib_ucontext *qib_alloc_ucontext(struct ib_device *ibdev,
         struct qib_ucontext *context;
         struct ib_ucontext *ret;
 
-        context = kmalloc(sizeof *context, GFP_KERNEL);
+        context = kmalloc(sizeof(*context), GFP_KERNEL);
         if (!context) {
                 ret = ERR_PTR(-ENOMEM);
                 goto bail;
@@ -2054,7 +2055,9 @@ int qib_register_ib_device(struct qib_devdata *dd)
 
         dev->qp_table_size = ib_qib_qp_table_size;
         get_random_bytes(&dev->qp_rnd, sizeof(dev->qp_rnd));
-        dev->qp_table = kmalloc(dev->qp_table_size * sizeof *dev->qp_table,
+        dev->qp_table = kmalloc_array(
+                                dev->qp_table_size,
+                                sizeof(*dev->qp_table),
                                 GFP_KERNEL);
         if (!dev->qp_table) {
                 ret = -ENOMEM;
@@ -2122,7 +2125,7 @@ int qib_register_ib_device(struct qib_devdata *dd)
         for (i = 0; i < ppd->sdma_descq_cnt; i++) {
                 struct qib_verbs_txreq *tx;
 
-                tx = kzalloc(sizeof *tx, GFP_KERNEL);
+                tx = kzalloc(sizeof(*tx), GFP_KERNEL);
                 if (!tx) {
                         ret = -ENOMEM;
                         goto err_tx;
diff --git a/drivers/infiniband/hw/qib/qib_verbs_mcast.c b/drivers/infiniband/hw/qib/qib_verbs_mcast.c
index dabb697b1c2a..f8ea069a3eaf 100644
--- a/drivers/infiniband/hw/qib/qib_verbs_mcast.c
+++ b/drivers/infiniband/hw/qib/qib_verbs_mcast.c
@@ -43,7 +43,7 @@ static struct qib_mcast_qp *qib_mcast_qp_alloc(struct qib_qp *qp)
 {
         struct qib_mcast_qp *mqp;
 
-        mqp = kmalloc(sizeof *mqp, GFP_KERNEL);
+        mqp = kmalloc(sizeof(*mqp), GFP_KERNEL);
         if (!mqp)
                 goto bail;
 
@@ -75,7 +75,7 @@ static struct qib_mcast *qib_mcast_alloc(union ib_gid *mgid)
 {
         struct qib_mcast *mcast;
 
-        mcast = kmalloc(sizeof *mcast, GFP_KERNEL);
+        mcast = kmalloc(sizeof(*mcast), GFP_KERNEL);
         if (!mcast)
                 goto bail;
 
diff --git a/drivers/infiniband/hw/qib/qib_wc_x86_64.c b/drivers/infiniband/hw/qib/qib_wc_x86_64.c
index 1d7281c5a02e..81b225f2300a 100644
--- a/drivers/infiniband/hw/qib/qib_wc_x86_64.c
+++ b/drivers/infiniband/hw/qib/qib_wc_x86_64.c
@@ -72,6 +72,7 @@ int qib_enable_wc(struct qib_devdata *dd)
         if (dd->piobcnt2k && dd->piobcnt4k) {
                 /* 2 sizes for chip */
                 unsigned long pio2kbase, pio4kbase;
+
                 pio2kbase = dd->piobufbase & 0xffffffffUL;
                 pio4kbase = (dd->piobufbase >> 32) & 0xffffffffUL;
                 if (pio2kbase < pio4kbase) {
@@ -91,7 +92,7 @@ int qib_enable_wc(struct qib_devdata *dd)
         }
 
         for (bits = 0; !(piolen & (1ULL << bits)); bits++)
-                /* do nothing */ ;
+                ; /* do nothing */
 
         if (piolen != (1ULL << bits)) {
                 piolen >>= bits;
@@ -100,8 +101,8 @@ int qib_enable_wc(struct qib_devdata *dd)
                 piolen = 1ULL << (bits + 1);
         }
         if (pioaddr & (piolen - 1)) {
-                u64 atmp;
-                atmp = pioaddr & ~(piolen - 1);
+                u64 atmp = pioaddr & ~(piolen - 1);
+
                 if (atmp < addr || (atmp + piolen) > (addr + len)) {
                         qib_dev_err(dd,
                                 "No way to align address/size (%llx/%llx), no WC mtrr\n",
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.h b/drivers/infiniband/ulp/iser/iscsi_iser.h
index 5ce26817e7e1..b47aea1094b2 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.h
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.h
@@ -654,7 +654,9 @@ int iser_dma_map_task_data(struct iscsi_iser_task *iser_task,
                            enum dma_data_direction dma_dir);
 
 void iser_dma_unmap_task_data(struct iscsi_iser_task *iser_task,
-                              struct iser_data_buf *data);
+                              struct iser_data_buf *data,
+                              enum dma_data_direction dir);
+
 int  iser_initialize_task_headers(struct iscsi_task *task,
                         struct iser_tx_desc *tx_desc);
 int iser_alloc_rx_descriptors(struct iser_conn *iser_conn,
diff --git a/drivers/infiniband/ulp/iser/iser_initiator.c b/drivers/infiniband/ulp/iser/iser_initiator.c
index 3821633f1065..20e859a6f1a6 100644
--- a/drivers/infiniband/ulp/iser/iser_initiator.c
+++ b/drivers/infiniband/ulp/iser/iser_initiator.c
@@ -320,9 +320,6 @@ void iser_free_rx_descriptors(struct iser_conn *iser_conn)
         struct ib_conn *ib_conn = &iser_conn->ib_conn;
         struct iser_device *device = ib_conn->device;
 
-        if (!iser_conn->rx_descs)
-                goto free_login_buf;
-
         if (device->iser_free_rdma_reg_res)
                 device->iser_free_rdma_reg_res(ib_conn);
 
@@ -334,7 +331,6 @@ void iser_free_rx_descriptors(struct iser_conn *iser_conn)
         /* make sure we never redo any unmapping */
         iser_conn->rx_descs = NULL;
 
-free_login_buf:
         iser_free_login_buf(iser_conn);
 }
 
@@ -714,19 +710,23 @@ void iser_task_rdma_finalize(struct iscsi_iser_task *iser_task)
                 device->iser_unreg_rdma_mem(iser_task, ISER_DIR_IN);
                 if (is_rdma_data_aligned)
                         iser_dma_unmap_task_data(iser_task,
-                                                 &iser_task->data[ISER_DIR_IN]);
+                                                 &iser_task->data[ISER_DIR_IN],
+                                                 DMA_FROM_DEVICE);
                 if (prot_count && is_rdma_prot_aligned)
                         iser_dma_unmap_task_data(iser_task,
-                                                 &iser_task->prot[ISER_DIR_IN]);
+                                                 &iser_task->prot[ISER_DIR_IN],
+                                                 DMA_FROM_DEVICE);
         }
 
         if (iser_task->dir[ISER_DIR_OUT]) {
                 device->iser_unreg_rdma_mem(iser_task, ISER_DIR_OUT);
                 if (is_rdma_data_aligned)
                         iser_dma_unmap_task_data(iser_task,
-                                                 &iser_task->data[ISER_DIR_OUT]);
+                                                 &iser_task->data[ISER_DIR_OUT],
+                                                 DMA_TO_DEVICE);
                 if (prot_count && is_rdma_prot_aligned)
                         iser_dma_unmap_task_data(iser_task,
-                                                 &iser_task->prot[ISER_DIR_OUT]);
+                                                 &iser_task->prot[ISER_DIR_OUT],
+                                                 DMA_TO_DEVICE);
         }
 }
diff --git a/drivers/infiniband/ulp/iser/iser_memory.c b/drivers/infiniband/ulp/iser/iser_memory.c
index abce9339333f..341040bf0984 100644
--- a/drivers/infiniband/ulp/iser/iser_memory.c
+++ b/drivers/infiniband/ulp/iser/iser_memory.c
@@ -332,12 +332,13 @@ int iser_dma_map_task_data(struct iscsi_iser_task *iser_task,
 }
 
 void iser_dma_unmap_task_data(struct iscsi_iser_task *iser_task,
-                              struct iser_data_buf *data)
+                              struct iser_data_buf *data,
+                              enum dma_data_direction dir)
 {
         struct ib_device *dev;
 
         dev = iser_task->iser_conn->ib_conn.device->ib_device;
-        ib_dma_unmap_sg(dev, data->buf, data->size, DMA_FROM_DEVICE);
+        ib_dma_unmap_sg(dev, data->buf, data->size, dir);
 }
 
 static int fall_to_bounce_buf(struct iscsi_iser_task *iser_task,
@@ -357,7 +358,9 @@ static int fall_to_bounce_buf(struct iscsi_iser_task *iser_task,
                 iser_data_buf_dump(mem, ibdev);
 
         /* unmap the command data before accessing it */
-        iser_dma_unmap_task_data(iser_task, mem);
+        iser_dma_unmap_task_data(iser_task, mem,
+                                 (cmd_dir == ISER_DIR_OUT) ?
+                                 DMA_TO_DEVICE : DMA_FROM_DEVICE);
 
         /* allocate copy buf, if we are writing, copy the */
         /* unaligned scatterlist, dma map the copy        */
diff --git a/drivers/infiniband/ulp/iser/iser_verbs.c b/drivers/infiniband/ulp/iser/iser_verbs.c
index 695a2704bd43..4065abe28829 100644
--- a/drivers/infiniband/ulp/iser/iser_verbs.c
+++ b/drivers/infiniband/ulp/iser/iser_verbs.c
@@ -600,16 +600,16 @@ void iser_release_work(struct work_struct *work)
 /**
  * iser_free_ib_conn_res - release IB related resources
  * @iser_conn: iser connection struct
- * @destroy_device: indicator if we need to try to release
- *     the iser device (only iscsi shutdown and DEVICE_REMOVAL
- *     will use this.
+ * @destroy: indicator if we need to try to release the
+ *     iser device and memory regoins pool (only iscsi
+ *     shutdown and DEVICE_REMOVAL will use this).
  *
  * This routine is called with the iser state mutex held
  * so the cm_id removal is out of here. It is Safe to
  * be invoked multiple times.
  */
 static void iser_free_ib_conn_res(struct iser_conn *iser_conn,
-                                  bool destroy_device)
+                                  bool destroy)
 {
         struct ib_conn *ib_conn = &iser_conn->ib_conn;
         struct iser_device *device = ib_conn->device;
@@ -617,17 +617,20 @@ static void iser_free_ib_conn_res(struct iser_conn *iser_conn,
         iser_info("freeing conn %p cma_id %p qp %p\n",
                   iser_conn, ib_conn->cma_id, ib_conn->qp);
 
-        iser_free_rx_descriptors(iser_conn);
-
         if (ib_conn->qp != NULL) {
                 ib_conn->comp->active_qps--;
                 rdma_destroy_qp(ib_conn->cma_id);
                 ib_conn->qp = NULL;
         }
 
-        if (destroy_device && device != NULL) {
-                iser_device_try_release(device);
-                ib_conn->device = NULL;
+        if (destroy) {
+                if (iser_conn->rx_descs)
+                        iser_free_rx_descriptors(iser_conn);
+
+                if (device != NULL) {
+                        iser_device_try_release(device);
+                        ib_conn->device = NULL;
+                }
         }
 }
 
@@ -643,9 +646,11 @@ void iser_conn_release(struct iser_conn *iser_conn)
         mutex_unlock(&ig.connlist_mutex);
 
         mutex_lock(&iser_conn->state_mutex);
+        /* In case we endup here without ep_disconnect being invoked. */
         if (iser_conn->state != ISER_CONN_DOWN) {
                 iser_warn("iser conn %p state %d, expected state down.\n",
                           iser_conn, iser_conn->state);
+                iscsi_destroy_endpoint(iser_conn->ep);
                 iser_conn->state = ISER_CONN_DOWN;
         }
         /*
@@ -840,7 +845,7 @@ static void iser_disconnected_handler(struct rdma_cm_id *cma_id)
 }
 
 static void iser_cleanup_handler(struct rdma_cm_id *cma_id,
-                                 bool destroy_device)
+                                 bool destroy)
 {
         struct iser_conn *iser_conn = (struct iser_conn *)cma_id->context;
 
@@ -850,7 +855,7 @@ static void iser_cleanup_handler(struct rdma_cm_id *cma_id,
          * and flush errors.
          */
         iser_disconnected_handler(cma_id);
-        iser_free_ib_conn_res(iser_conn, destroy_device);
+        iser_free_ib_conn_res(iser_conn, destroy);
         complete(&iser_conn->ib_completion);
 };
 
diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
index dafb3c531f96..075b19cc78e8 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.c
+++ b/drivers/infiniband/ulp/isert/ib_isert.c
@@ -38,7 +38,7 @@
 #define ISER_MAX_CQ_LEN         (ISER_MAX_RX_CQ_LEN + ISER_MAX_TX_CQ_LEN + \
                                  ISERT_MAX_CONN)
 
-int isert_debug_level = 0;
+static int isert_debug_level;
 module_param_named(debug_level, isert_debug_level, int, 0644);
 MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0 (default:0)");
 
@@ -949,7 +949,7 @@ isert_post_recv(struct isert_conn *isert_conn, u32 count)
                 isert_err("ib_post_recv() failed with ret: %d\n", ret);
                 isert_conn->post_recv_buf_count -= count;
         } else {
-                isert_dbg("isert_post_recv(): Posted %d RX buffers\n", count);
+                isert_dbg("Posted %d RX buffers\n", count);
                 isert_conn->conn_rx_desc_head = rx_head;
         }
         return ret;
@@ -1351,17 +1351,19 @@ isert_handle_text_cmd(struct isert_conn *isert_conn, struct isert_cmd *isert_cmd
         struct iscsi_conn *conn = isert_conn->conn;
         u32 payload_length = ntoh24(hdr->dlength);
         int rc;
-        unsigned char *text_in;
+        unsigned char *text_in = NULL;
 
         rc = iscsit_setup_text_cmd(conn, cmd, hdr);
         if (rc < 0)
                 return rc;
 
-        text_in = kzalloc(payload_length, GFP_KERNEL);
-        if (!text_in) {
-                isert_err("Unable to allocate text_in of payload_length: %u\n",
-                          payload_length);
-                return -ENOMEM;
+        if (payload_length) {
+                text_in = kzalloc(payload_length, GFP_KERNEL);
+                if (!text_in) {
+                        isert_err("Unable to allocate text_in of payload_length: %u\n",
+                                  payload_length);
+                        return -ENOMEM;
+                }
         }
         cmd->text_in_ptr = text_in;
 
@@ -1434,9 +1436,15 @@ isert_rx_opcode(struct isert_conn *isert_conn, struct iser_rx_desc *rx_desc,
                 ret = iscsit_handle_logout_cmd(conn, cmd, (unsigned char *)hdr);
                 break;
         case ISCSI_OP_TEXT:
-                cmd = isert_allocate_cmd(conn);
-                if (!cmd)
-                        break;
+                if (be32_to_cpu(hdr->ttt) != 0xFFFFFFFF) {
+                        cmd = iscsit_find_cmd_from_itt(conn, hdr->itt);
+                        if (!cmd)
+                                break;
+                } else {
+                        cmd = isert_allocate_cmd(conn);
+                        if (!cmd)
+                                break;
+                }
 
                 isert_cmd = iscsit_priv_cmd(cmd);
                 ret = isert_handle_text_cmd(isert_conn, isert_cmd, cmd,
@@ -1658,6 +1666,7 @@ isert_put_cmd(struct isert_cmd *isert_cmd, bool comp_err)
         struct isert_conn *isert_conn = isert_cmd->conn;
         struct iscsi_conn *conn = isert_conn->conn;
         struct isert_device *device = isert_conn->conn_device;
+        struct iscsi_text_rsp *hdr;
 
         isert_dbg("Cmd %p\n", isert_cmd);
 
@@ -1698,6 +1707,11 @@ isert_put_cmd(struct isert_cmd *isert_cmd, bool comp_err)
         case ISCSI_OP_REJECT:
         case ISCSI_OP_NOOP_OUT:
         case ISCSI_OP_TEXT:
+                hdr = (struct iscsi_text_rsp *)&isert_cmd->tx_desc.iscsi_header;
+                /* If the continue bit is on, keep the command alive */
+                if (hdr->flags & ISCSI_FLAG_TEXT_CONTINUE)
+                        break;
+
                 spin_lock_bh(&conn->cmd_lock);
                 if (!list_empty(&cmd->i_conn_node))
                         list_del_init(&cmd->i_conn_node);
@@ -1709,8 +1723,7 @@ isert_put_cmd(struct isert_cmd *isert_cmd, bool comp_err)
                  * associated cmd->se_cmd needs to be released.
                  */
                 if (cmd->se_cmd.se_tfo != NULL) {
-                        isert_dbg("Calling transport_generic_free_cmd from"
-                                 " isert_put_cmd for 0x%02x\n",
+                        isert_dbg("Calling transport_generic_free_cmd for 0x%02x\n",
                                  cmd->iscsi_opcode);
                         transport_generic_free_cmd(&cmd->se_cmd, 0);
                         break;
@@ -2275,7 +2288,7 @@ isert_put_text_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
         }
         isert_init_send_wr(isert_conn, isert_cmd, send_wr);
 
-        isert_dbg("conn %p Text Reject\n", isert_conn);
+        isert_dbg("conn %p Text Response\n", isert_conn);
 
         return isert_post_response(isert_conn, isert_cmd);
 }
@@ -3136,7 +3149,7 @@ accept_wait:
         spin_lock_bh(&np->np_thread_lock);
         if (np->np_thread_state >= ISCSI_NP_THREAD_RESET) {
                 spin_unlock_bh(&np->np_thread_lock);
-                isert_dbg("np_thread_state %d for isert_accept_np\n",
+                isert_dbg("np_thread_state %d\n",
                          np->np_thread_state);
                 /**
                  * No point in stalling here when np_thread
@@ -3320,7 +3333,8 @@ static int __init isert_init(void)
 {
         int ret;
 
-        isert_comp_wq = alloc_workqueue("isert_comp_wq", 0, 0);
+        isert_comp_wq = alloc_workqueue("isert_comp_wq",
+                                        WQ_UNBOUND | WQ_HIGHPRI, 0);
         if (!isert_comp_wq) {
                 isert_err("Unable to allocate isert_comp_wq\n");
                 ret = -ENOMEM;
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index eb694ddad79f..6e0a477681e9 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -3518,7 +3518,7 @@ static void srpt_close_session(struct se_session *se_sess)
         DECLARE_COMPLETION_ONSTACK(release_done);
         struct srpt_rdma_ch *ch;
         struct srpt_device *sdev;
-        int res;
+        unsigned long res;
 
         ch = se_sess->fabric_sess_ptr;
         WARN_ON(ch->sess != se_sess);
@@ -3533,7 +3533,7 @@ static void srpt_close_session(struct se_session *se_sess)
         spin_unlock_irq(&sdev->spinlock);
 
         res = wait_for_completion_timeout(&release_done, 60 * HZ);
-        WARN_ON(res <= 0);
+        WARN_ON(res == 0);
 }
 
 /**
diff --git a/drivers/input/joystick/adi.c b/drivers/input/joystick/adi.c
index b78425765d3e..d09cefa37931 100644
--- a/drivers/input/joystick/adi.c
+++ b/drivers/input/joystick/adi.c
@@ -535,8 +535,7 @@ static int adi_connect(struct gameport *gameport, struct gameport_driver *drv)
                 }
         }
  fail2: for (i = 0; i < 2; i++)
-                if (port->adi[i].dev)
-                        input_free_device(port->adi[i].dev);
+                input_free_device(port->adi[i].dev);
         gameport_close(gameport);
  fail1: gameport_set_drvdata(gameport, NULL);
         kfree(port);
diff --git a/drivers/input/keyboard/pxa27x_keypad.c b/drivers/input/keyboard/pxa27x_keypad.c
index a89488aa1aa4..fcef5d1365e2 100644
--- a/drivers/input/keyboard/pxa27x_keypad.c
+++ b/drivers/input/keyboard/pxa27x_keypad.c
@@ -345,13 +345,11 @@ static int pxa27x_keypad_build_keycode(struct pxa27x_keypad *keypad)
 {
         const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
         struct input_dev *input_dev = keypad->input_dev;
-        const struct matrix_keymap_data *keymap_data =
-                                pdata ? pdata->matrix_keymap_data : NULL;
         unsigned short keycode;
         int i;
         int error;
 
-        error = matrix_keypad_build_keymap(keymap_data, NULL,
+        error = matrix_keypad_build_keymap(pdata->matrix_keymap_data, NULL,
                                            pdata->matrix_key_rows,
                                            pdata->matrix_key_cols,
                                            keypad->keycodes, input_dev);
diff --git a/drivers/input/misc/bfin_rotary.c b/drivers/input/misc/bfin_rotary.c
index 3f4351579372..a0fc18fdfc0c 100644
--- a/drivers/input/misc/bfin_rotary.c
+++ b/drivers/input/misc/bfin_rotary.c
@@ -7,29 +7,37 @@
 
 #include <linux/module.h>
 #include <linux/interrupt.h>
+#include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/slab.h>
+#include <linux/platform_data/bfin_rotary.h>
 
 #include <asm/portmux.h>
-#include <asm/bfin_rotary.h>
 
-static const u16 per_cnt[] = {
-        P_CNT_CUD,
-        P_CNT_CDG,
-        P_CNT_CZM,
-        0
-};
+#define CNT_CONFIG_OFF          0       /* CNT Config Offset */
+#define CNT_IMASK_OFF           4       /* CNT Interrupt Mask Offset */
+#define CNT_STATUS_OFF          8       /* CNT Status Offset */
+#define CNT_COMMAND_OFF         12      /* CNT Command Offset */
+#define CNT_DEBOUNCE_OFF        16      /* CNT Debounce Offset */
+#define CNT_COUNTER_OFF         20      /* CNT Counter Offset */
+#define CNT_MAX_OFF             24      /* CNT Maximum Count Offset */
+#define CNT_MIN_OFF             28      /* CNT Minimum Count Offset */
 
 struct bfin_rot {
         struct input_dev *input;
+        void __iomem *base;
         int irq;
         unsigned int up_key;
         unsigned int down_key;
         unsigned int button_key;
         unsigned int rel_code;
+
+        unsigned short mode;
+        unsigned short debounce;
+
         unsigned short cnt_config;
         unsigned short cnt_imask;
         unsigned short cnt_debounce;
@@ -59,18 +67,17 @@ static void report_rotary_event(struct bfin_rot *rotary, int delta)
 
 static irqreturn_t bfin_rotary_isr(int irq, void *dev_id)
 {
-        struct platform_device *pdev = dev_id;
-        struct bfin_rot *rotary = platform_get_drvdata(pdev);
+        struct bfin_rot *rotary = dev_id;
         int delta;
 
-        switch (bfin_read_CNT_STATUS()) {
+        switch (readw(rotary->base + CNT_STATUS_OFF)) {
 
         case ICII:
                 break;
 
         case UCII:
         case DCII:
-                delta = bfin_read_CNT_COUNTER();
+                delta = readl(rotary->base + CNT_COUNTER_OFF);
                 if (delta)
                         report_rotary_event(rotary, delta);
                 break;
@@ -83,16 +90,52 @@ static irqreturn_t bfin_rotary_isr(int irq, void *dev_id)
                 break;
         }
 
-        bfin_write_CNT_COMMAND(W1LCNT_ZERO);    /* Clear COUNTER */
-        bfin_write_CNT_STATUS(-1);      /* Clear STATUS */
+        writew(W1LCNT_ZERO, rotary->base + CNT_COMMAND_OFF); /* Clear COUNTER */
+        writew(-1, rotary->base + CNT_STATUS_OFF); /* Clear STATUS */
 
         return IRQ_HANDLED;
 }
 
+static int bfin_rotary_open(struct input_dev *input)
+{
+        struct bfin_rot *rotary = input_get_drvdata(input);
+        unsigned short val;
+
+        if (rotary->mode & ROT_DEBE)
+                writew(rotary->debounce & DPRESCALE,
+                        rotary->base + CNT_DEBOUNCE_OFF);
+
+        writew(rotary->mode & ~CNTE, rotary->base + CNT_CONFIG_OFF);
+
+        val = UCIE | DCIE;
+        if (rotary->button_key)
+                val |= CZMIE;
+        writew(val, rotary->base + CNT_IMASK_OFF);
+
+        writew(rotary->mode | CNTE, rotary->base + CNT_CONFIG_OFF);
+
+        return 0;
+}
+
+static void bfin_rotary_close(struct input_dev *input)
+{
+        struct bfin_rot *rotary = input_get_drvdata(input);
+
+        writew(0, rotary->base + CNT_CONFIG_OFF);
+        writew(0, rotary->base + CNT_IMASK_OFF);
+}
+
+static void bfin_rotary_free_action(void *data)
+{
+        peripheral_free_list(data);
+}
+
 static int bfin_rotary_probe(struct platform_device *pdev)
 {
-        struct bfin_rotary_platform_data *pdata = dev_get_platdata(&pdev->dev);
+        struct device *dev = &pdev->dev;
+        const struct bfin_rotary_platform_data *pdata = dev_get_platdata(dev);
         struct bfin_rot *rotary;
+        struct resource *res;
         struct input_dev *input;
         int error;
 
@@ -102,18 +145,37 @@ static int bfin_rotary_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        error = peripheral_request_list(per_cnt, dev_name(&pdev->dev));
-        if (error) {
-                dev_err(&pdev->dev, "requesting peripherals failed\n");
-                return error;
+        if (pdata->pin_list) {
+                error = peripheral_request_list(pdata->pin_list,
+                                                dev_name(&pdev->dev));
+                if (error) {
+                        dev_err(dev, "requesting peripherals failed: %d\n",
+                                error);
+                        return error;
+                }
+
+                error = devm_add_action(dev, bfin_rotary_free_action,
+                                        pdata->pin_list);
+                if (error) {
+                        dev_err(dev, "setting cleanup action failed: %d\n",
+                                error);
+                        peripheral_free_list(pdata->pin_list);
+                        return error;
+                }
         }
 
-        rotary = kzalloc(sizeof(struct bfin_rot), GFP_KERNEL);
-        input = input_allocate_device();
-        if (!rotary || !input) {
-                error = -ENOMEM;
-                goto out1;
-        }
+        rotary = devm_kzalloc(dev, sizeof(struct bfin_rot), GFP_KERNEL);
+        if (!rotary)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        rotary->base = devm_ioremap_resource(dev, res);
+        if (IS_ERR(rotary->base))
+                return PTR_ERR(rotary->base);
+
+        input = devm_input_allocate_device(dev);
+        if (!input)
+                return -ENOMEM;
 
         rotary->input = input;
 
@@ -122,9 +184,8 @@ static int bfin_rotary_probe(struct platform_device *pdev)
         rotary->button_key = pdata->rotary_button_key;
         rotary->rel_code = pdata->rotary_rel_code;
 
-        error = rotary->irq = platform_get_irq(pdev, 0);
-        if (error < 0)
-                goto out1;
+        rotary->mode = pdata->mode;
+        rotary->debounce = pdata->debounce;
 
         input->name = pdev->name;
         input->phys = "bfin-rotary/input0";
@@ -137,6 +198,9 @@ static int bfin_rotary_probe(struct platform_device *pdev)
         input->id.product = 0x0001;
         input->id.version = 0x0100;
 
+        input->open = bfin_rotary_open;
+        input->close = bfin_rotary_close;
+
         if (rotary->up_key) {
                 __set_bit(EV_KEY, input->evbit);
                 __set_bit(rotary->up_key, input->keybit);
@@ -151,75 +215,43 @@ static int bfin_rotary_probe(struct platform_device *pdev)
                 __set_bit(rotary->button_key, input->keybit);
         }
 
-        error = request_irq(rotary->irq, bfin_rotary_isr,
-                            0, dev_name(&pdev->dev), pdev);
+        /* Quiesce the device before requesting irq */
+        bfin_rotary_close(input);
+
+        rotary->irq = platform_get_irq(pdev, 0);
+        if (rotary->irq < 0) {
+                dev_err(dev, "No rotary IRQ specified\n");
+                return -ENOENT;
+        }
+
+        error = devm_request_irq(dev, rotary->irq, bfin_rotary_isr,
+                                 0, dev_name(dev), rotary);
         if (error) {
-                dev_err(&pdev->dev,
-                        "unable to claim irq %d; error %d\n",
+                dev_err(dev, "unable to claim irq %d; error %d\n",
                         rotary->irq, error);
-                goto out1;
+                return error;
         }
 
         error = input_register_device(input);
         if (error) {
-                dev_err(&pdev->dev,
-                        "unable to register input device (%d)\n", error);
-                goto out2;
+                dev_err(dev, "unable to register input device (%d)\n", error);
+                return error;
         }
 
-        if (pdata->rotary_button_key)
-                bfin_write_CNT_IMASK(CZMIE);
-
-        if (pdata->mode & ROT_DEBE)
-                bfin_write_CNT_DEBOUNCE(pdata->debounce & DPRESCALE);
-
-        if (pdata->mode)
-                bfin_write_CNT_CONFIG(bfin_read_CNT_CONFIG() |
-                                        (pdata->mode & ~CNTE));
-
-        bfin_write_CNT_IMASK(bfin_read_CNT_IMASK() | UCIE | DCIE);
-        bfin_write_CNT_CONFIG(bfin_read_CNT_CONFIG() | CNTE);
-
         platform_set_drvdata(pdev, rotary);
         device_init_wakeup(&pdev->dev, 1);
 
         return 0;
-
-out2:
-        free_irq(rotary->irq, pdev);
-out1:
-        input_free_device(input);
-        kfree(rotary);
-        peripheral_free_list(per_cnt);
-
-        return error;
 }
 
-static int bfin_rotary_remove(struct platform_device *pdev)
-{
-        struct bfin_rot *rotary = platform_get_drvdata(pdev);
-
-        bfin_write_CNT_CONFIG(0);
-        bfin_write_CNT_IMASK(0);
-
-        free_irq(rotary->irq, pdev);
-        input_unregister_device(rotary->input);
-        peripheral_free_list(per_cnt);
-
-        kfree(rotary);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int bfin_rotary_suspend(struct device *dev)
+static int __maybe_unused bfin_rotary_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct bfin_rot *rotary = platform_get_drvdata(pdev);
 
-        rotary->cnt_config = bfin_read_CNT_CONFIG();
-        rotary->cnt_imask = bfin_read_CNT_IMASK();
-        rotary->cnt_debounce = bfin_read_CNT_DEBOUNCE();
+        rotary->cnt_config = readw(rotary->base + CNT_CONFIG_OFF);
+        rotary->cnt_imask = readw(rotary->base + CNT_IMASK_OFF);
+        rotary->cnt_debounce = readw(rotary->base + CNT_DEBOUNCE_OFF);
 
         if (device_may_wakeup(&pdev->dev))
                 enable_irq_wake(rotary->irq);
@@ -227,38 +259,32 @@ static int bfin_rotary_suspend(struct device *dev)
         return 0;
 }
 
-static int bfin_rotary_resume(struct device *dev)
+static int __maybe_unused bfin_rotary_resume(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct bfin_rot *rotary = platform_get_drvdata(pdev);
 
-        bfin_write_CNT_DEBOUNCE(rotary->cnt_debounce);
-        bfin_write_CNT_IMASK(rotary->cnt_imask);
-        bfin_write_CNT_CONFIG(rotary->cnt_config & ~CNTE);
+        writew(rotary->cnt_debounce, rotary->base + CNT_DEBOUNCE_OFF);
+        writew(rotary->cnt_imask, rotary->base + CNT_IMASK_OFF);
+        writew(rotary->cnt_config & ~CNTE, rotary->base + CNT_CONFIG_OFF);
 
         if (device_may_wakeup(&pdev->dev))
                 disable_irq_wake(rotary->irq);
 
         if (rotary->cnt_config & CNTE)
-                bfin_write_CNT_CONFIG(rotary->cnt_config);
+                writew(rotary->cnt_config, rotary->base + CNT_CONFIG_OFF);
 
         return 0;
 }
 
-static const struct dev_pm_ops bfin_rotary_pm_ops = {
-        .suspend        = bfin_rotary_suspend,
-        .resume         = bfin_rotary_resume,
-};
-#endif
+static SIMPLE_DEV_PM_OPS(bfin_rotary_pm_ops,
+                         bfin_rotary_suspend, bfin_rotary_resume);
 
 static struct platform_driver bfin_rotary_device_driver = {
         .probe          = bfin_rotary_probe,
-        .remove         = bfin_rotary_remove,
         .driver         = {
                 .name   = "bfin-rotary",
-#ifdef CONFIG_PM
                 .pm     = &bfin_rotary_pm_ops,
-#endif
         },
 };
 module_platform_driver(bfin_rotary_device_driver);
diff --git a/drivers/input/misc/soc_button_array.c b/drivers/input/misc/soc_button_array.c
index 79cc0f79896f..e8e010a85484 100644
--- a/drivers/input/misc/soc_button_array.c
+++ b/drivers/input/misc/soc_button_array.c
@@ -195,7 +195,7 @@ static int soc_button_probe(struct platform_device *pdev)
 
 static struct soc_button_info soc_button_PNP0C40[] = {
         { "power", 0, EV_KEY, KEY_POWER, false, true },
-        { "home", 1, EV_KEY, KEY_HOME, false, true },
+        { "home", 1, EV_KEY, KEY_LEFTMETA, false, true },
         { "volume_up", 2, EV_KEY, KEY_VOLUMEUP, true, false },
         { "volume_down", 3, EV_KEY, KEY_VOLUMEDOWN, true, false },
         { "rotation_lock", 4, EV_SW, SW_ROTATE_LOCK, false, false },
diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index f205b8be2ce4..d28726a0ef85 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -99,36 +99,58 @@ static const struct alps_nibble_commands alps_v6_nibble_commands[] = {
 #define ALPS_FOUR_BUTTONS       0x40    /* 4 direction button present */
 #define ALPS_PS2_INTERLEAVED    0x80    /* 3-byte PS/2 packet interleaved with
                                            6-byte ALPS packet */
-#define ALPS_IS_RUSHMORE        0x100   /* device is a rushmore */
 #define ALPS_BUTTONPAD          0x200   /* device is a clickpad */
 
 static const struct alps_model_info alps_model_data[] = {
-        { { 0x32, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },  /* Toshiba Salellite Pro M10 */
-        { { 0x33, 0x02, 0x0a }, 0x00, ALPS_PROTO_V1, 0x88, 0xf8, 0 },                           /* UMAX-530T */
-        { { 0x53, 0x02, 0x0a }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
-        { { 0x53, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
-        { { 0x60, 0x03, 0xc8 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },                           /* HP ze1115 */
-        { { 0x63, 0x02, 0x0a }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
-        { { 0x63, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
-        { { 0x63, 0x02, 0x28 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_FW_BK_2 },                /* Fujitsu Siemens S6010 */
-        { { 0x63, 0x02, 0x3c }, 0x00, ALPS_PROTO_V2, 0x8f, 0x8f, ALPS_WHEEL },                  /* Toshiba Satellite S2400-103 */
-        { { 0x63, 0x02, 0x50 }, 0x00, ALPS_PROTO_V2, 0xef, 0xef, ALPS_FW_BK_1 },                /* NEC Versa L320 */
-        { { 0x63, 0x02, 0x64 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
-        { { 0x63, 0x03, 0xc8 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },  /* Dell Latitude D800 */
-        { { 0x73, 0x00, 0x0a }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_DUALPOINT },              /* ThinkPad R61 8918-5QG */
-        { { 0x73, 0x02, 0x0a }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
-        { { 0x73, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_FW_BK_2 },                /* Ahtec Laptop */
-        { { 0x20, 0x02, 0x0e }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },  /* XXX */
-        { { 0x22, 0x02, 0x0a }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },
-        { { 0x22, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xff, 0xff, ALPS_PASS | ALPS_DUALPOINT },  /* Dell Latitude D600 */
+        { { 0x32, 0x02, 0x14 }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT } },      /* Toshiba Salellite Pro M10 */
+        { { 0x33, 0x02, 0x0a }, 0x00, { ALPS_PROTO_V1, 0x88, 0xf8, 0 } },                               /* UMAX-530T */
+        { { 0x53, 0x02, 0x0a }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, 0 } },
+        { { 0x53, 0x02, 0x14 }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, 0 } },
+        { { 0x60, 0x03, 0xc8 }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, 0 } },                               /* HP ze1115 */
+        { { 0x63, 0x02, 0x0a }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, 0 } },
+        { { 0x63, 0x02, 0x14 }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, 0 } },
+        { { 0x63, 0x02, 0x28 }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_FW_BK_2 } },            /* Fujitsu Siemens S6010 */
+        { { 0x63, 0x02, 0x3c }, 0x00, { ALPS_PROTO_V2, 0x8f, 0x8f, ALPS_WHEEL } },              /* Toshiba Satellite S2400-103 */
+        { { 0x63, 0x02, 0x50 }, 0x00, { ALPS_PROTO_V2, 0xef, 0xef, ALPS_FW_BK_1 } },            /* NEC Versa L320 */
+        { { 0x63, 0x02, 0x64 }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, 0 } },
+        { { 0x63, 0x03, 0xc8 }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT } },      /* Dell Latitude D800 */
+        { { 0x73, 0x00, 0x0a }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_DUALPOINT } },          /* ThinkPad R61 8918-5QG */
+        { { 0x73, 0x02, 0x0a }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, 0 } },
+        { { 0x73, 0x02, 0x14 }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_FW_BK_2 } },            /* Ahtec Laptop */
+
+        /*
+         * XXX This entry is suspicious. First byte has zero lower nibble,
+         * which is what a normal mouse would report. Also, the value 0x0e
+         * isn't valid per PS/2 spec.
+         */
+        { { 0x20, 0x02, 0x0e }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT } },
+
+        { { 0x22, 0x02, 0x0a }, 0x00, { ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT } },
+        { { 0x22, 0x02, 0x14 }, 0x00, { ALPS_PROTO_V2, 0xff, 0xff, ALPS_PASS | ALPS_DUALPOINT } },      /* Dell Latitude D600 */
         /* Dell Latitude E5500, E6400, E6500, Precision M4400 */
-        { { 0x62, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xcf, 0xcf,
-                ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED },
-        { { 0x73, 0x00, 0x14 }, 0x00, ALPS_PROTO_V6, 0xff, 0xff, ALPS_DUALPOINT },              /* Dell XT2 */
-        { { 0x73, 0x02, 0x50 }, 0x00, ALPS_PROTO_V2, 0xcf, 0xcf, ALPS_FOUR_BUTTONS },           /* Dell Vostro 1400 */
-        { { 0x52, 0x01, 0x14 }, 0x00, ALPS_PROTO_V2, 0xff, 0xff,
-                ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED },                            /* Toshiba Tecra A11-11L */
-        { { 0x73, 0x02, 0x64 }, 0x8a, ALPS_PROTO_V4, 0x8f, 0x8f, 0 },
+        { { 0x62, 0x02, 0x14 }, 0x00, { ALPS_PROTO_V2, 0xcf, 0xcf,
+                ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED } },
+        { { 0x73, 0x00, 0x14 }, 0x00, { ALPS_PROTO_V6, 0xff, 0xff, ALPS_DUALPOINT } },          /* Dell XT2 */
+        { { 0x73, 0x02, 0x50 }, 0x00, { ALPS_PROTO_V2, 0xcf, 0xcf, ALPS_FOUR_BUTTONS } },       /* Dell Vostro 1400 */
+        { { 0x52, 0x01, 0x14 }, 0x00, { ALPS_PROTO_V2, 0xff, 0xff,
+                ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED } },                          /* Toshiba Tecra A11-11L */
+        { { 0x73, 0x02, 0x64 }, 0x8a, { ALPS_PROTO_V4, 0x8f, 0x8f, 0 } },
+};
+
+static const struct alps_protocol_info alps_v3_protocol_data = {
+        ALPS_PROTO_V3, 0x8f, 0x8f, ALPS_DUALPOINT
+};
+
+static const struct alps_protocol_info alps_v3_rushmore_data = {
+        ALPS_PROTO_V3_RUSHMORE, 0x8f, 0x8f, ALPS_DUALPOINT
+};
+
+static const struct alps_protocol_info alps_v5_protocol_data = {
+        ALPS_PROTO_V5, 0xc8, 0xd8, 0
+};
+
+static const struct alps_protocol_info alps_v7_protocol_data = {
+        ALPS_PROTO_V7, 0x48, 0x48, ALPS_DUALPOINT
 };
 
 static void alps_set_abs_params_st(struct alps_data *priv,
@@ -136,12 +158,6 @@ static void alps_set_abs_params_st(struct alps_data *priv,
 static void alps_set_abs_params_mt(struct alps_data *priv,
                                    struct input_dev *dev1);
 
-/*
- * XXX - this entry is suspicious. First byte has zero lower nibble,
- * which is what a normal mouse would report. Also, the value 0x0e
- * isn't valid per PS/2 spec.
- */
-
 /* Packet formats are described in Documentation/input/alps.txt */
 
 static bool alps_is_valid_first_byte(struct alps_data *priv,
@@ -150,8 +166,7 @@ static bool alps_is_valid_first_byte(struct alps_data *priv,
         return (data & priv->mask0) == priv->byte0;
 }
 
-static void alps_report_buttons(struct psmouse *psmouse,
-                                struct input_dev *dev1, struct input_dev *dev2,
+static void alps_report_buttons(struct input_dev *dev1, struct input_dev *dev2,
                                 int left, int right, int middle)
 {
         struct input_dev *dev;
@@ -161,20 +176,21 @@ static void alps_report_buttons(struct psmouse *psmouse,
          * other device (dev2) then this event should be also
          * sent through that device.
          */
-        dev = test_bit(BTN_LEFT, dev2->key) ? dev2 : dev1;
+        dev = (dev2 && test_bit(BTN_LEFT, dev2->key)) ? dev2 : dev1;
         input_report_key(dev, BTN_LEFT, left);
 
-        dev = test_bit(BTN_RIGHT, dev2->key) ? dev2 : dev1;
+        dev = (dev2 && test_bit(BTN_RIGHT, dev2->key)) ? dev2 : dev1;
         input_report_key(dev, BTN_RIGHT, right);
 
-        dev = test_bit(BTN_MIDDLE, dev2->key) ? dev2 : dev1;
+        dev = (dev2 && test_bit(BTN_MIDDLE, dev2->key)) ? dev2 : dev1;
         input_report_key(dev, BTN_MIDDLE, middle);
 
         /*
          * Sync the _other_ device now, we'll do the first
          * device later once we report the rest of the events.
          */
-        input_sync(dev2);
+        if (dev2)
+                input_sync(dev2);
 }
 
 static void alps_process_packet_v1_v2(struct psmouse *psmouse)
@@ -221,13 +237,13 @@ static void alps_process_packet_v1_v2(struct psmouse *psmouse)
                 input_report_rel(dev2, REL_X,  (x > 383 ? (x - 768) : x));
                 input_report_rel(dev2, REL_Y, -(y > 255 ? (y - 512) : y));
 
-                alps_report_buttons(psmouse, dev2, dev, left, right, middle);
+                alps_report_buttons(dev2, dev, left, right, middle);
 
                 input_sync(dev2);
                 return;
         }
 
-        alps_report_buttons(psmouse, dev, dev2, left, right, middle);
+        alps_report_buttons(dev, dev2, left, right, middle);
 
         /* Convert hardware tap to a reasonable Z value */
         if (ges && !fin)
@@ -412,7 +428,7 @@ static int alps_process_bitmap(struct alps_data *priv,
                 (2 * (priv->y_bits - 1));
 
         /* y-bitmap order is reversed, except on rushmore */
-        if (!(priv->flags & ALPS_IS_RUSHMORE)) {
+        if (priv->proto_version != ALPS_PROTO_V3_RUSHMORE) {
                 fields->mt[0].y = priv->y_max - fields->mt[0].y;
                 fields->mt[1].y = priv->y_max - fields->mt[1].y;
         }
@@ -648,7 +664,8 @@ static void alps_process_touchpad_packet_v3_v5(struct psmouse *psmouse)
                  */
                 if (f->is_mp) {
                         fingers = f->fingers;
-                        if (priv->proto_version == ALPS_PROTO_V3) {
+                        if (priv->proto_version == ALPS_PROTO_V3 ||
+                            priv->proto_version == ALPS_PROTO_V3_RUSHMORE) {
                                 if (alps_process_bitmap(priv, f) == 0)
                                         fingers = 0; /* Use st data */
 
@@ -892,34 +909,6 @@ static void alps_get_finger_coordinate_v7(struct input_mt_pos *mt,
                                           unsigned char *pkt,
                                           unsigned char pkt_id)
 {
-        /*
-         *       packet-fmt    b7   b6    b5   b4   b3   b2   b1   b0
-         * Byte0 TWO & MULTI    L    1     R    M    1 Y0-2 Y0-1 Y0-0
-         * Byte0 NEW            L    1  X1-5    1    1 Y0-2 Y0-1 Y0-0
-         * Byte1            Y0-10 Y0-9  Y0-8 Y0-7 Y0-6 Y0-5 Y0-4 Y0-3
-         * Byte2            X0-11    1 X0-10 X0-9 X0-8 X0-7 X0-6 X0-5
-         * Byte3            X1-11    1  X0-4 X0-3    1 X0-2 X0-1 X0-0
-         * Byte4 TWO        X1-10  TWO  X1-9 X1-8 X1-7 X1-6 X1-5 X1-4
-         * Byte4 MULTI      X1-10  TWO  X1-9 X1-8 X1-7 X1-6 Y1-5    1
-         * Byte4 NEW        X1-10  TWO  X1-9 X1-8 X1-7 X1-6    0    0
-         * Byte5 TWO & NEW  Y1-10    0  Y1-9 Y1-8 Y1-7 Y1-6 Y1-5 Y1-4
-         * Byte5 MULTI      Y1-10    0  Y1-9 Y1-8 Y1-7 Y1-6  F-1  F-0
-         * L:         Left button
-         * R / M:     Non-clickpads: Right / Middle button
-         *            Clickpads: When > 2 fingers are down, and some fingers
-         *            are in the button area, then the 2 coordinates reported
-         *            are for fingers outside the button area and these report
-         *            extra fingers being present in the right / left button
-         *            area. Note these fingers are not added to the F field!
-         *            so if a TWO packet is received and R = 1 then there are
-         *            3 fingers down, etc.
-         * TWO:       1: Two touches present, byte 0/4/5 are in TWO fmt
-         *            0: If byte 4 bit 0 is 1, then byte 0/4/5 are in MULTI fmt
-         *               otherwise byte 0 bit 4 must be set and byte 0/4/5 are
-         *               in NEW fmt
-         * F:         Number of fingers - 3, 0 means 3 fingers, 1 means 4 ...
-         */
-
         mt[0].x = ((pkt[2] & 0x80) << 4);
         mt[0].x |= ((pkt[2] & 0x3F) << 5);
         mt[0].x |= ((pkt[3] & 0x30) >> 1);
@@ -1044,17 +1033,6 @@ static void alps_process_trackstick_packet_v7(struct psmouse *psmouse)
                 return;
         }
 
-        /*
-         *        b7 b6 b5 b4 b3 b2 b1 b0
-         * Byte0   0  1  0  0  1  0  0  0
-         * Byte1   1  1  *  *  1  M  R  L
-         * Byte2  X7  1 X5 X4 X3 X2 X1 X0
-         * Byte3  Z6  1 Y6 X6  1 Y2 Y1 Y0
-         * Byte4  Y7  0 Y5 Y4 Y3  1  1  0
-         * Byte5 T&P  0 Z5 Z4 Z3 Z2 Z1 Z0
-         * M / R / L: Middle / Right / Left button
-         */
-
         x = ((packet[2] & 0xbf)) | ((packet[3] & 0x10) << 2);
         y = (packet[3] & 0x07) | (packet[4] & 0xb8) |
             ((packet[3] & 0x20) << 1);
@@ -1107,23 +1085,89 @@ static void alps_process_packet_v7(struct psmouse *psmouse)
                 alps_process_touchpad_packet_v7(psmouse);
 }
 
-static void alps_report_bare_ps2_packet(struct psmouse *psmouse,
+static DEFINE_MUTEX(alps_mutex);
+
+static void alps_register_bare_ps2_mouse(struct work_struct *work)
+{
+        struct alps_data *priv =
+                container_of(work, struct alps_data, dev3_register_work.work);
+        struct psmouse *psmouse = priv->psmouse;
+        struct input_dev *dev3;
+        int error = 0;
+
+        mutex_lock(&alps_mutex);
+
+        if (priv->dev3)
+                goto out;
+
+        dev3 = input_allocate_device();
+        if (!dev3) {
+                psmouse_err(psmouse, "failed to allocate secondary device\n");
+                error = -ENOMEM;
+                goto out;
+        }
+
+        snprintf(priv->phys3, sizeof(priv->phys3), "%s/%s",
+                 psmouse->ps2dev.serio->phys,
+                 (priv->dev2 ? "input2" : "input1"));
+        dev3->phys = priv->phys3;
+
+        /*
+         * format of input device name is: "protocol vendor name"
+         * see function psmouse_switch_protocol() in psmouse-base.c
+         */
+        dev3->name = "PS/2 ALPS Mouse";
+
+        dev3->id.bustype = BUS_I8042;
+        dev3->id.vendor  = 0x0002;
+        dev3->id.product = PSMOUSE_PS2;
+        dev3->id.version = 0x0000;
+        dev3->dev.parent = &psmouse->ps2dev.serio->dev;
+
+        input_set_capability(dev3, EV_REL, REL_X);
+        input_set_capability(dev3, EV_REL, REL_Y);
+        input_set_capability(dev3, EV_KEY, BTN_LEFT);
+        input_set_capability(dev3, EV_KEY, BTN_RIGHT);
+        input_set_capability(dev3, EV_KEY, BTN_MIDDLE);
+
+        __set_bit(INPUT_PROP_POINTER, dev3->propbit);
+
+        error = input_register_device(dev3);
+        if (error) {
+                psmouse_err(psmouse,
+                            "failed to register secondary device: %d\n",
+                            error);
+                input_free_device(dev3);
+                goto out;
+        }
+
+        priv->dev3 = dev3;
+
+out:
+        /*
+         * Save the error code so that we can detect that we
+         * already tried to create the device.
+         */
+        if (error)
+                priv->dev3 = ERR_PTR(error);
+
+        mutex_unlock(&alps_mutex);
+}
+
+static void alps_report_bare_ps2_packet(struct input_dev *dev,
                                         unsigned char packet[],
                                         bool report_buttons)
 {
-        struct alps_data *priv = psmouse->private;
-        struct input_dev *dev2 = priv->dev2;
-
         if (report_buttons)
-                alps_report_buttons(psmouse, dev2, psmouse->dev,
+                alps_report_buttons(dev, NULL,
                                 packet[0] & 1, packet[0] & 2, packet[0] & 4);
 
-        input_report_rel(dev2, REL_X,
+        input_report_rel(dev, REL_X,
                 packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0);
-        input_report_rel(dev2, REL_Y,
+        input_report_rel(dev, REL_Y,
                 packet[2] ? ((packet[0] << 3) & 0x100) - packet[2] : 0);
 
-        input_sync(dev2);
+        input_sync(dev);
 }
 
 static psmouse_ret_t alps_handle_interleaved_ps2(struct psmouse *psmouse)
@@ -1188,8 +1232,8 @@ static psmouse_ret_t alps_handle_interleaved_ps2(struct psmouse *psmouse)
                  * de-synchronization.
                  */
 
-                alps_report_bare_ps2_packet(psmouse, &psmouse->packet[3],
-                                            false);
+                alps_report_bare_ps2_packet(priv->dev2,
+                                            &psmouse->packet[3], false);
 
                 /*
                  * Continue with the standard ALPS protocol handling,
@@ -1245,9 +1289,18 @@ static psmouse_ret_t alps_process_byte(struct psmouse *psmouse)
          * properly we only do this if the device is fully synchronized.
          */
         if (!psmouse->out_of_sync_cnt && (psmouse->packet[0] & 0xc8) == 0x08) {
+
+                /* Register dev3 mouse if we received PS/2 packet first time */
+                if (unlikely(!priv->dev3))
+                        psmouse_queue_work(psmouse,
+                                           &priv->dev3_register_work, 0);
+
                 if (psmouse->pktcnt == 3) {
-                        alps_report_bare_ps2_packet(psmouse, psmouse->packet,
-                                                    true);
+                        /* Once dev3 mouse device is registered report data */
+                        if (likely(!IS_ERR_OR_NULL(priv->dev3)))
+                                alps_report_bare_ps2_packet(priv->dev3,
+                                                            psmouse->packet,
+                                                            true);
                         return PSMOUSE_FULL_PACKET;
                 }
                 return PSMOUSE_GOOD_DATA;
@@ -1275,7 +1328,7 @@ static psmouse_ret_t alps_process_byte(struct psmouse *psmouse)
                             psmouse->pktcnt - 1,
                             psmouse->packet[psmouse->pktcnt - 1]);
 
-                if (priv->proto_version == ALPS_PROTO_V3 &&
+                if (priv->proto_version == ALPS_PROTO_V3_RUSHMORE &&
                     psmouse->pktcnt == psmouse->pktsize) {
                         /*
                          * Some Dell boxes, such as Latitude E6440 or E7440
@@ -1780,7 +1833,7 @@ static int alps_setup_trackstick_v3(struct psmouse *psmouse, int reg_base)
          * all.
          */
         if (alps_rpt_cmd(psmouse, 0, PSMOUSE_CMD_SETSCALE21, param)) {
-                psmouse_warn(psmouse, "trackstick E7 report failed\n");
+                psmouse_warn(psmouse, "Failed to initialize trackstick (E7 report failed)\n");
                 ret = -ENODEV;
         } else {
                 psmouse_dbg(psmouse, "trackstick E7 report: %3ph\n", param);
@@ -1945,8 +1998,6 @@ static int alps_hw_init_rushmore_v3(struct psmouse *psmouse)
                                                    ALPS_REG_BASE_RUSHMORE);
                 if (reg_val == -EIO)
                         goto error;
-                if (reg_val == -ENODEV)
-                        priv->flags &= ~ALPS_DUALPOINT;
         }
 
         if (alps_enter_command_mode(psmouse) ||
@@ -2162,11 +2213,18 @@ error:
         return ret;
 }
 
-static void alps_set_defaults(struct alps_data *priv)
+static int alps_set_protocol(struct psmouse *psmouse,
+                             struct alps_data *priv,
+                             const struct alps_protocol_info *protocol)
 {
-        priv->byte0 = 0x8f;
-        priv->mask0 = 0x8f;
-        priv->flags = ALPS_DUALPOINT;
+        psmouse->private = priv;
+
+        setup_timer(&priv->timer, alps_flush_packet, (unsigned long)psmouse);
+
+        priv->proto_version = protocol->version;
+        priv->byte0 = protocol->byte0;
+        priv->mask0 = protocol->mask0;
+        priv->flags = protocol->flags;
 
         priv->x_max = 2000;
         priv->y_max = 1400;
@@ -2182,6 +2240,7 @@ static void alps_set_defaults(struct alps_data *priv)
                 priv->x_max = 1023;
                 priv->y_max = 767;
                 break;
+
         case ALPS_PROTO_V3:
                 priv->hw_init = alps_hw_init_v3;
                 priv->process_packet = alps_process_packet_v3;
@@ -2190,6 +2249,23 @@ static void alps_set_defaults(struct alps_data *priv)
                 priv->nibble_commands = alps_v3_nibble_commands;
                 priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
                 break;
+
+        case ALPS_PROTO_V3_RUSHMORE:
+                priv->hw_init = alps_hw_init_rushmore_v3;
+                priv->process_packet = alps_process_packet_v3;
+                priv->set_abs_params = alps_set_abs_params_mt;
+                priv->decode_fields = alps_decode_rushmore;
+                priv->nibble_commands = alps_v3_nibble_commands;
+                priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
+                priv->x_bits = 16;
+                priv->y_bits = 12;
+
+                if (alps_probe_trackstick_v3(psmouse,
+                                             ALPS_REG_BASE_RUSHMORE) < 0)
+                        priv->flags &= ~ALPS_DUALPOINT;
+
+                break;
+
         case ALPS_PROTO_V4:
                 priv->hw_init = alps_hw_init_v4;
                 priv->process_packet = alps_process_packet_v4;
@@ -2197,6 +2273,7 @@ static void alps_set_defaults(struct alps_data *priv)
                 priv->nibble_commands = alps_v4_nibble_commands;
                 priv->addr_command = PSMOUSE_CMD_DISABLE;
                 break;
+
         case ALPS_PROTO_V5:
                 priv->hw_init = alps_hw_init_dolphin_v1;
                 priv->process_packet = alps_process_touchpad_packet_v3_v5;
@@ -2204,14 +2281,12 @@ static void alps_set_defaults(struct alps_data *priv)
                 priv->set_abs_params = alps_set_abs_params_mt;
                 priv->nibble_commands = alps_v3_nibble_commands;
                 priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
-                priv->byte0 = 0xc8;
-                priv->mask0 = 0xd8;
-                priv->flags = 0;
                 priv->x_max = 1360;
                 priv->y_max = 660;
                 priv->x_bits = 23;
                 priv->y_bits = 12;
                 break;
+
         case ALPS_PROTO_V6:
                 priv->hw_init = alps_hw_init_v6;
                 priv->process_packet = alps_process_packet_v6;
@@ -2220,6 +2295,7 @@ static void alps_set_defaults(struct alps_data *priv)
                 priv->x_max = 2047;
                 priv->y_max = 1535;
                 break;
+
         case ALPS_PROTO_V7:
                 priv->hw_init = alps_hw_init_v7;
                 priv->process_packet = alps_process_packet_v7;
@@ -2227,19 +2303,21 @@ static void alps_set_defaults(struct alps_data *priv)
                 priv->set_abs_params = alps_set_abs_params_mt;
                 priv->nibble_commands = alps_v3_nibble_commands;
                 priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
-                priv->x_max = 0xfff;
-                priv->y_max = 0x7ff;
-                priv->byte0 = 0x48;
-                priv->mask0 = 0x48;
+
+                if (alps_dolphin_get_device_area(psmouse, priv))
+                        return -EIO;
 
                 if (priv->fw_ver[1] != 0xba)
                         priv->flags |= ALPS_BUTTONPAD;
+
                 break;
         }
+
+        return 0;
 }
 
-static int alps_match_table(struct psmouse *psmouse, struct alps_data *priv,
-                            unsigned char *e7, unsigned char *ec)
+static const struct alps_protocol_info *alps_match_table(unsigned char *e7,
+                                                         unsigned char *ec)
 {
         const struct alps_model_info *model;
         int i;
@@ -2251,23 +2329,18 @@ static int alps_match_table(struct psmouse *psmouse, struct alps_data *priv,
                     (!model->command_mode_resp ||
                      model->command_mode_resp == ec[2])) {
 
-                        priv->proto_version = model->proto_version;
-                        alps_set_defaults(priv);
-
-                        priv->flags = model->flags;
-                        priv->byte0 = model->byte0;
-                        priv->mask0 = model->mask0;
-
-                        return 0;
+                        return &model->protocol_info;
                 }
         }
 
-        return -EINVAL;
+        return NULL;
 }
 
 static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
 {
+        const struct alps_protocol_info *protocol;
         unsigned char e6[4], e7[4], ec[4];
+        int error;
 
         /*
          * First try "E6 report".
@@ -2293,54 +2366,35 @@ static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
             alps_exit_command_mode(psmouse))
                 return -EIO;
 
-        /* Save the Firmware version */
-        memcpy(priv->fw_ver, ec, 3);
-
-        if (alps_match_table(psmouse, priv, e7, ec) == 0) {
-                return 0;
-        } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0x50 &&
-                   ec[0] == 0x73 && (ec[1] == 0x01 || ec[1] == 0x02)) {
-                priv->proto_version = ALPS_PROTO_V5;
-                alps_set_defaults(priv);
-                if (alps_dolphin_get_device_area(psmouse, priv))
-                        return -EIO;
-                else
-                        return 0;
-        } else if (ec[0] == 0x88 &&
-                   ((ec[1] & 0xf0) == 0xb0 || (ec[1] & 0xf0) == 0xc0)) {
-                priv->proto_version = ALPS_PROTO_V7;
-                alps_set_defaults(priv);
-
-                return 0;
-        } else if (ec[0] == 0x88 && ec[1] == 0x08) {
-                priv->proto_version = ALPS_PROTO_V3;
-                alps_set_defaults(priv);
-
-                priv->hw_init = alps_hw_init_rushmore_v3;
-                priv->decode_fields = alps_decode_rushmore;
-                priv->x_bits = 16;
-                priv->y_bits = 12;
-                priv->flags |= ALPS_IS_RUSHMORE;
-
-                /* hack to make addr_command, nibble_command available */
-                psmouse->private = priv;
-
-                if (alps_probe_trackstick_v3(psmouse, ALPS_REG_BASE_RUSHMORE))
-                        priv->flags &= ~ALPS_DUALPOINT;
-
-                return 0;
-        } else if (ec[0] == 0x88 && ec[1] == 0x07 &&
-                   ec[2] >= 0x90 && ec[2] <= 0x9d) {
-                priv->proto_version = ALPS_PROTO_V3;
-                alps_set_defaults(priv);
-
-                return 0;
+        protocol = alps_match_table(e7, ec);
+        if (!protocol) {
+                if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0x50 &&
+                           ec[0] == 0x73 && (ec[1] == 0x01 || ec[1] == 0x02)) {
+                        protocol = &alps_v5_protocol_data;
+                } else if (ec[0] == 0x88 &&
+                           ((ec[1] & 0xf0) == 0xb0 || (ec[1] & 0xf0) == 0xc0)) {
+                        protocol = &alps_v7_protocol_data;
+                } else if (ec[0] == 0x88 && ec[1] == 0x08) {
+                        protocol = &alps_v3_rushmore_data;
+                } else if (ec[0] == 0x88 && ec[1] == 0x07 &&
+                           ec[2] >= 0x90 && ec[2] <= 0x9d) {
+                        protocol = &alps_v3_protocol_data;
+                } else {
+                        psmouse_dbg(psmouse,
+                                    "Likely not an ALPS touchpad: E7=%3ph, EC=%3ph\n", e7, ec);
+                        return -EINVAL;
+                }
         }
 
-        psmouse_dbg(psmouse,
-                    "Likely not an ALPS touchpad: E7=%3ph, EC=%3ph\n", e7, ec);
+        if (priv) {
+                /* Save the Firmware version */
+                memcpy(priv->fw_ver, ec, 3);
+                error = alps_set_protocol(psmouse, priv, protocol);
+                if (error)
+                        return error;
+        }
 
-        return -EINVAL;
+        return 0;
 }
 
 static int alps_reconnect(struct psmouse *psmouse)
@@ -2361,7 +2415,10 @@ static void alps_disconnect(struct psmouse *psmouse)
 
         psmouse_reset(psmouse);
         del_timer_sync(&priv->timer);
-        input_unregister_device(priv->dev2);
+        if (priv->dev2)
+                input_unregister_device(priv->dev2);
+        if (!IS_ERR_OR_NULL(priv->dev3))
+                input_unregister_device(priv->dev3);
         kfree(priv);
 }
 
@@ -2394,25 +2451,12 @@ static void alps_set_abs_params_mt(struct alps_data *priv,
 
 int alps_init(struct psmouse *psmouse)
 {
-        struct alps_data *priv;
-        struct input_dev *dev1 = psmouse->dev, *dev2;
-
-        priv = kzalloc(sizeof(struct alps_data), GFP_KERNEL);
-        dev2 = input_allocate_device();
-        if (!priv || !dev2)
-                goto init_fail;
-
-        priv->dev2 = dev2;
-        setup_timer(&priv->timer, alps_flush_packet, (unsigned long)psmouse);
-
-        psmouse->private = priv;
-
-        psmouse_reset(psmouse);
-
-        if (alps_identify(psmouse, priv) < 0)
-                goto init_fail;
+        struct alps_data *priv = psmouse->private;
+        struct input_dev *dev1 = psmouse->dev;
+        int error;
 
-        if (priv->hw_init(psmouse))
+        error = priv->hw_init(psmouse);
+        if (error)
                 goto init_fail;
 
         /*
@@ -2462,36 +2506,57 @@ int alps_init(struct psmouse *psmouse)
         }
 
         if (priv->flags & ALPS_DUALPOINT) {
+                struct input_dev *dev2;
+
+                dev2 = input_allocate_device();
+                if (!dev2) {
+                        psmouse_err(psmouse,
+                                    "failed to allocate trackstick device\n");
+                        error = -ENOMEM;
+                        goto init_fail;
+                }
+
+                snprintf(priv->phys2, sizeof(priv->phys2), "%s/input1",
+                         psmouse->ps2dev.serio->phys);
+                dev2->phys = priv->phys2;
+
                 /*
                  * format of input device name is: "protocol vendor name"
                  * see function psmouse_switch_protocol() in psmouse-base.c
                  */
                 dev2->name = "AlpsPS/2 ALPS DualPoint Stick";
+
+                dev2->id.bustype = BUS_I8042;
+                dev2->id.vendor  = 0x0002;
                 dev2->id.product = PSMOUSE_ALPS;
                 dev2->id.version = priv->proto_version;
-        } else {
-                dev2->name = "PS/2 ALPS Mouse";
-                dev2->id.product = PSMOUSE_PS2;
-                dev2->id.version = 0x0000;
-        }
+                dev2->dev.parent = &psmouse->ps2dev.serio->dev;
 
-        snprintf(priv->phys, sizeof(priv->phys), "%s/input1", psmouse->ps2dev.serio->phys);
-        dev2->phys = priv->phys;
-        dev2->id.bustype = BUS_I8042;
-        dev2->id.vendor  = 0x0002;
-        dev2->dev.parent = &psmouse->ps2dev.serio->dev;
+                input_set_capability(dev2, EV_REL, REL_X);
+                input_set_capability(dev2, EV_REL, REL_Y);
+                input_set_capability(dev2, EV_KEY, BTN_LEFT);
+                input_set_capability(dev2, EV_KEY, BTN_RIGHT);
+                input_set_capability(dev2, EV_KEY, BTN_MIDDLE);
 
-        dev2->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
-        dev2->relbit[BIT_WORD(REL_X)] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
-        dev2->keybit[BIT_WORD(BTN_LEFT)] =
-                BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
-
-        __set_bit(INPUT_PROP_POINTER, dev2->propbit);
-        if (priv->flags & ALPS_DUALPOINT)
+                __set_bit(INPUT_PROP_POINTER, dev2->propbit);
                 __set_bit(INPUT_PROP_POINTING_STICK, dev2->propbit);
 
-        if (input_register_device(priv->dev2))
-                goto init_fail;
+                error = input_register_device(dev2);
+                if (error) {
+                        psmouse_err(psmouse,
+                                    "failed to register trackstick device: %d\n",
+                                    error);
+                        input_free_device(dev2);
+                        goto init_fail;
+                }
+
+                priv->dev2 = dev2;
+        }
+
+        priv->psmouse = psmouse;
+
+        INIT_DELAYED_WORK(&priv->dev3_register_work,
+                          alps_register_bare_ps2_mouse);
 
         psmouse->protocol_handler = alps_process_byte;
         psmouse->poll = alps_poll;
@@ -2509,25 +2574,56 @@ int alps_init(struct psmouse *psmouse)
 
 init_fail:
         psmouse_reset(psmouse);
-        input_free_device(dev2);
-        kfree(priv);
+        /*
+         * Even though we did not allocate psmouse->private we do free
+         * it here.
+         */
+        kfree(psmouse->private);
         psmouse->private = NULL;
-        return -1;
+        return error;
 }
 
 int alps_detect(struct psmouse *psmouse, bool set_properties)
 {
-        struct alps_data dummy;
+        struct alps_data *priv;
+        int error;
 
-        if (alps_identify(psmouse, &dummy) < 0)
-                return -1;
+        error = alps_identify(psmouse, NULL);
+        if (error)
+                return error;
+
+        /*
+         * Reset the device to make sure it is fully operational:
+         * on some laptops, like certain Dell Latitudes, we may
+         * fail to properly detect presence of trackstick if device
+         * has not been reset.
+         */
+        psmouse_reset(psmouse);
+
+        priv = kzalloc(sizeof(struct alps_data), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        error = alps_identify(psmouse, priv);
+        if (error)
+                return error;
 
         if (set_properties) {
                 psmouse->vendor = "ALPS";
-                psmouse->name = dummy.flags & ALPS_DUALPOINT ?
+                psmouse->name = priv->flags & ALPS_DUALPOINT ?
                                 "DualPoint TouchPad" : "GlidePoint";
-                psmouse->model = dummy.proto_version << 8;
+                psmouse->model = priv->proto_version;
+        } else {
+                /*
+                 * Destroy alps_data structure we allocated earlier since
+                 * this was just a "trial run". Otherwise we'll keep it
+                 * to be used by alps_init() which has to be called if
+                 * we succeed and set_properties is true.
+                 */
+                kfree(priv);
+                psmouse->private = NULL;
         }
+
         return 0;
 }
 
diff --git a/drivers/input/mouse/alps.h b/drivers/input/mouse/alps.h
index 66240b47819a..02513c0502fc 100644
--- a/drivers/input/mouse/alps.h
+++ b/drivers/input/mouse/alps.h
@@ -14,13 +14,14 @@
 
 #include <linux/input/mt.h>
 
-#define ALPS_PROTO_V1   1
-#define ALPS_PROTO_V2   2
-#define ALPS_PROTO_V3   3
-#define ALPS_PROTO_V4   4
-#define ALPS_PROTO_V5   5
-#define ALPS_PROTO_V6   6
-#define ALPS_PROTO_V7   7       /* t3btl t4s */
+#define ALPS_PROTO_V1           0x100
+#define ALPS_PROTO_V2           0x200
+#define ALPS_PROTO_V3           0x300
+#define ALPS_PROTO_V3_RUSHMORE  0x310
+#define ALPS_PROTO_V4           0x400
+#define ALPS_PROTO_V5           0x500
+#define ALPS_PROTO_V6           0x600
+#define ALPS_PROTO_V7           0x700   /* t3btl t4s */
 
 #define MAX_TOUCHES     2
 
@@ -46,29 +47,37 @@ enum V7_PACKET_ID {
 };
 
 /**
+ * struct alps_protocol_info - information about protocol used by a device
+ * @version: Indicates V1/V2/V3/...
+ * @byte0: Helps figure out whether a position report packet matches the
+ *   known format for this model.  The first byte of the report, ANDed with
+ *   mask0, should match byte0.
+ * @mask0: The mask used to check the first byte of the report.
+ * @flags: Additional device capabilities (passthrough port, trackstick, etc.).
+ */
+struct alps_protocol_info {
+        u16 version;
+        u8 byte0, mask0;
+        unsigned int flags;
+};
+
+/**
  * struct alps_model_info - touchpad ID table
  * @signature: E7 response string to match.
  * @command_mode_resp: For V3/V4 touchpads, the final byte of the EC response
  *   (aka command mode response) identifies the firmware minor version.  This
  *   can be used to distinguish different hardware models which are not
  *   uniquely identifiable through their E7 responses.
- * @proto_version: Indicates V1/V2/V3/...
- * @byte0: Helps figure out whether a position report packet matches the
- *   known format for this model.  The first byte of the report, ANDed with
- *   mask0, should match byte0.
- * @mask0: The mask used to check the first byte of the report.
- * @flags: Additional device capabilities (passthrough port, trackstick, etc.).
+ * @protocol_info: information about protcol used by the device.
  *
  * Many (but not all) ALPS touchpads can be identified by looking at the
  * values returned in the "E7 report" and/or the "EC report."  This table
  * lists a number of such touchpads.
  */
 struct alps_model_info {
-        unsigned char signature[3];
-        unsigned char command_mode_resp;
-        unsigned char proto_version;
-        unsigned char byte0, mask0;
-        int flags;
+        u8 signature[3];
+        u8 command_mode_resp;
+        struct alps_protocol_info protocol_info;
 };
 
 /**
@@ -132,8 +141,12 @@ struct alps_fields {
 
 /**
  * struct alps_data - private data structure for the ALPS driver
- * @dev2: "Relative" device used to report trackstick or mouse activity.
- * @phys: Physical path for the relative device.
+ * @psmouse: Pointer to parent psmouse device
+ * @dev2: Trackstick device (can be NULL).
+ * @dev3: Generic PS/2 mouse (can be NULL, delayed registering).
+ * @phys2: Physical path for the trackstick device.
+ * @phys3: Physical path for the generic PS/2 mouse.
+ * @dev3_register_work: Delayed work for registering PS/2 mouse.
  * @nibble_commands: Command mapping used for touchpad register accesses.
  * @addr_command: Command used to tell the touchpad that a register address
  *   follows.
@@ -160,15 +173,19 @@ struct alps_fields {
  * @timer: Timer for flushing out the final report packet in the stream.
  */
 struct alps_data {
+        struct psmouse *psmouse;
         struct input_dev *dev2;
-        char phys[32];
+        struct input_dev *dev3;
+        char phys2[32];
+        char phys3[32];
+        struct delayed_work dev3_register_work;
 
         /* these are autodetected when the device is identified */
         const struct alps_nibble_commands *nibble_commands;
         int addr_command;
-        unsigned char proto_version;
-        unsigned char byte0, mask0;
-        unsigned char fw_ver[3];
+        u16 proto_version;
+        u8 byte0, mask0;
+        u8 fw_ver[3];
         int flags;
         int x_max;
         int y_max;
diff --git a/drivers/input/mouse/cypress_ps2.c b/drivers/input/mouse/cypress_ps2.c
index 9118a1861a45..28dcfc822bf6 100644
--- a/drivers/input/mouse/cypress_ps2.c
+++ b/drivers/input/mouse/cypress_ps2.c
@@ -710,8 +710,3 @@ err_exit:
 
         return -1;
 }
-
-bool cypress_supported(void)
-{
-        return true;
-}
diff --git a/drivers/input/mouse/cypress_ps2.h b/drivers/input/mouse/cypress_ps2.h
index 4720f21d2d70..81f68aaed7c8 100644
--- a/drivers/input/mouse/cypress_ps2.h
+++ b/drivers/input/mouse/cypress_ps2.h
@@ -172,7 +172,6 @@ struct cytp_data {
 #ifdef CONFIG_MOUSE_PS2_CYPRESS
 int cypress_detect(struct psmouse *psmouse, bool set_properties);
 int cypress_init(struct psmouse *psmouse);
-bool cypress_supported(void);
 #else
 inline int cypress_detect(struct psmouse *psmouse, bool set_properties)
 {
@@ -182,10 +181,6 @@ inline int cypress_init(struct psmouse *psmouse)
 {
         return -ENOSYS;
 }
-inline bool cypress_supported(void)
-{
-        return 0;
-}
 #endif /* CONFIG_MOUSE_PS2_CYPRESS */
 
 #endif  /* _CYPRESS_PS2_H */
diff --git a/drivers/input/mouse/focaltech.c b/drivers/input/mouse/focaltech.c
index fca38ba63bbe..757f78a94aec 100644
--- a/drivers/input/mouse/focaltech.c
+++ b/drivers/input/mouse/focaltech.c
@@ -424,11 +424,6 @@ fail:
         return error;
 }
 
-bool focaltech_supported(void)
-{
-        return true;
-}
-
 #else /* CONFIG_MOUSE_PS2_FOCALTECH */
 
 int focaltech_init(struct psmouse *psmouse)
@@ -438,9 +433,4 @@ int focaltech_init(struct psmouse *psmouse)
         return 0;
 }
 
-bool focaltech_supported(void)
-{
-        return false;
-}
-
 #endif /* CONFIG_MOUSE_PS2_FOCALTECH */
diff --git a/drivers/input/mouse/focaltech.h b/drivers/input/mouse/focaltech.h
index 71870a9b548a..ca61ebff373e 100644
--- a/drivers/input/mouse/focaltech.h
+++ b/drivers/input/mouse/focaltech.h
@@ -19,6 +19,5 @@
 
 int focaltech_detect(struct psmouse *psmouse, bool set_properties);
 int focaltech_init(struct psmouse *psmouse);
-bool focaltech_supported(void);
 
 #endif
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index 68469feda470..4ccd01d7a48d 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -727,7 +727,7 @@ static int psmouse_extensions(struct psmouse *psmouse,
         if (psmouse_do_detect(focaltech_detect, psmouse, set_properties) == 0) {
                 if (max_proto > PSMOUSE_IMEX) {
                         if (!set_properties || focaltech_init(psmouse) == 0) {
-                                if (focaltech_supported())
+                                if (IS_ENABLED(CONFIG_MOUSE_PS2_FOCALTECH))
                                         return PSMOUSE_FOCALTECH;
                                 /*
                                  * Note that we need to also restrict
@@ -776,7 +776,7 @@ static int psmouse_extensions(struct psmouse *psmouse,
  * Try activating protocol, but check if support is enabled first, since
  * we try detecting Synaptics even when protocol is disabled.
  */
-                        if (synaptics_supported() &&
+                        if (IS_ENABLED(CONFIG_MOUSE_PS2_SYNAPTICS) &&
                             (!set_properties || synaptics_init(psmouse) == 0)) {
                                 return PSMOUSE_SYNAPTICS;
                         }
@@ -801,7 +801,7 @@ static int psmouse_extensions(struct psmouse *psmouse,
  */
         if (max_proto > PSMOUSE_IMEX &&
                         cypress_detect(psmouse, set_properties) == 0) {
-                if (cypress_supported()) {
+                if (IS_ENABLED(CONFIG_MOUSE_PS2_CYPRESS)) {
                         if (cypress_init(psmouse) == 0)
                                 return PSMOUSE_CYPRESS;
 
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index 7e705ee90b86..f2cceb6493a0 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -1454,11 +1454,6 @@ int synaptics_init_relative(struct psmouse *psmouse)
         return __synaptics_init(psmouse, false);
 }
 
-bool synaptics_supported(void)
-{
-        return true;
-}
-
 #else /* CONFIG_MOUSE_PS2_SYNAPTICS */
 
 void __init synaptics_module_init(void)
@@ -1470,9 +1465,4 @@ int synaptics_init(struct psmouse *psmouse)
         return -ENOSYS;
 }
 
-bool synaptics_supported(void)
-{
-        return false;
-}
-
 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS */
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index 6faf9bb7c117..aedc3299b14e 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -175,6 +175,5 @@ int synaptics_detect(struct psmouse *psmouse, bool set_properties);
 int synaptics_init(struct psmouse *psmouse);
 int synaptics_init_relative(struct psmouse *psmouse);
 void synaptics_reset(struct psmouse *psmouse);
-bool synaptics_supported(void);
 
 #endif /* _SYNAPTICS_H */
diff --git a/drivers/irqchip/irq-mips-gic.c b/drivers/irqchip/irq-mips-gic.c
index 1daa7ca04577..9acdc080e7ec 100644
--- a/drivers/irqchip/irq-mips-gic.c
+++ b/drivers/irqchip/irq-mips-gic.c
@@ -192,14 +192,6 @@ static bool gic_local_irq_is_routable(int intr)
         }
 }
 
-unsigned int gic_get_timer_pending(void)
-{
-        unsigned int vpe_pending;
-
-        vpe_pending = gic_read(GIC_REG(VPE_LOCAL, GIC_VPE_PEND));
-        return vpe_pending & GIC_VPE_PEND_TIMER_MSK;
-}
-
 static void gic_bind_eic_interrupt(int irq, int set)
 {
         /* Convert irq vector # to hw int # */
diff --git a/drivers/isdn/hardware/mISDN/Kconfig b/drivers/isdn/hardware/mISDN/Kconfig
index b8611e3e5e74..09df54fc1fef 100644
--- a/drivers/isdn/hardware/mISDN/Kconfig
+++ b/drivers/isdn/hardware/mISDN/Kconfig
@@ -24,7 +24,7 @@ config MISDN_HFCMULTI
            * HFC-E1 (E1 interface for 2Mbit ISDN)
 
 config MISDN_HFCMULTI_8xx
-        boolean "Support for XHFC embedded board in HFC multiport driver"
+        bool "Support for XHFC embedded board in HFC multiport driver"
         depends on MISDN
         depends on MISDN_HFCMULTI
         depends on 8xx
diff --git a/drivers/isdn/hardware/mISDN/hfcpci.c b/drivers/isdn/hardware/mISDN/hfcpci.c
index 3c92780bda09..ff48da61c94c 100644
--- a/drivers/isdn/hardware/mISDN/hfcpci.c
+++ b/drivers/isdn/hardware/mISDN/hfcpci.c
@@ -1755,7 +1755,7 @@ init_card(struct hfc_pci *hc)
                 enable_hwirq(hc);
                 spin_unlock_irqrestore(&hc->lock, flags);
                 /* Timeout 80ms */
-                current->state = TASK_UNINTERRUPTIBLE;
+                set_current_state(TASK_UNINTERRUPTIBLE);
                 schedule_timeout((80 * HZ) / 1000);
                 printk(KERN_INFO "HFC PCI: IRQ %d count %d\n",
                        hc->irq, hc->irqcnt);
diff --git a/drivers/lguest/Makefile b/drivers/lguest/Makefile
index c4197503900e..16f52ee73994 100644
--- a/drivers/lguest/Makefile
+++ b/drivers/lguest/Makefile
@@ -1,6 +1,3 @@
-# Guest requires the device configuration and probing code.
-obj-$(CONFIG_LGUEST_GUEST) += lguest_device.o
-
 # Host requires the other files, which can be a module.
 obj-$(CONFIG_LGUEST)    += lg.o
 lg-y = core.o hypercalls.o page_tables.o interrupts_and_traps.o \
diff --git a/drivers/lguest/core.c b/drivers/lguest/core.c
index 6590558d1d31..7dc93aa004c8 100644
--- a/drivers/lguest/core.c
+++ b/drivers/lguest/core.c
@@ -208,6 +208,14 @@ void __lgwrite(struct lg_cpu *cpu, unsigned long addr, const void *b,
  */
 int run_guest(struct lg_cpu *cpu, unsigned long __user *user)
 {
+        /* If the launcher asked for a register with LHREQ_GETREG */
+        if (cpu->reg_read) {
+                if (put_user(*cpu->reg_read, user))
+                        return -EFAULT;
+                cpu->reg_read = NULL;
+                return sizeof(*cpu->reg_read);
+        }
+
         /* We stop running once the Guest is dead. */
         while (!cpu->lg->dead) {
                 unsigned int irq;
@@ -217,21 +225,12 @@ int run_guest(struct lg_cpu *cpu, unsigned long __user *user)
                 if (cpu->hcall)
                         do_hypercalls(cpu);
 
-                /*
-                 * It's possible the Guest did a NOTIFY hypercall to the
-                 * Launcher.
-                 */
-                if (cpu->pending_notify) {
-                        /*
-                         * Does it just needs to write to a registered
-                         * eventfd (ie. the appropriate virtqueue thread)?
-                         */
-                        if (!send_notify_to_eventfd(cpu)) {
-                                /* OK, we tell the main Launcher. */
-                                if (put_user(cpu->pending_notify, user))
-                                        return -EFAULT;
-                                return sizeof(cpu->pending_notify);
-                        }
+                /* Do we have to tell the Launcher about a trap? */
+                if (cpu->pending.trap) {
+                        if (copy_to_user(user, &cpu->pending,
+                                         sizeof(cpu->pending)))
+                                return -EFAULT;
+                        return sizeof(cpu->pending);
                 }
 
                 /*
diff --git a/drivers/lguest/hypercalls.c b/drivers/lguest/hypercalls.c
index 83511eb0923d..1219af493c0f 100644
--- a/drivers/lguest/hypercalls.c
+++ b/drivers/lguest/hypercalls.c
@@ -117,9 +117,6 @@ static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args)
                 /* Similarly, this sets the halted flag for run_guest(). */
                 cpu->halted = 1;
                 break;
-        case LHCALL_NOTIFY:
-                cpu->pending_notify = args->arg1;
-                break;
         default:
                 /* It should be an architecture-specific hypercall. */
                 if (lguest_arch_do_hcall(cpu, args))
@@ -189,7 +186,7 @@ static void do_async_hcalls(struct lg_cpu *cpu)
                  * Stop doing hypercalls if they want to notify the Launcher:
                  * it needs to service this first.
                  */
-                if (cpu->pending_notify)
+                if (cpu->pending.trap)
                         break;
         }
 }
@@ -280,7 +277,7 @@ void do_hypercalls(struct lg_cpu *cpu)
          * NOTIFY to the Launcher, we want to return now.  Otherwise we do
          * the hypercall.
          */
-        if (!cpu->pending_notify) {
+        if (!cpu->pending.trap) {
                 do_hcall(cpu, cpu->hcall);
                 /*
                  * Tricky point: we reset the hcall pointer to mark the
diff --git a/drivers/lguest/lg.h b/drivers/lguest/lg.h
index 2eef40be4c04..307e8b39e7d1 100644
--- a/drivers/lguest/lg.h
+++ b/drivers/lguest/lg.h
@@ -50,7 +50,10 @@ struct lg_cpu {
         /* Bitmap of what has changed: see CHANGED_* above. */
         int changed;
 
-        unsigned long pending_notify; /* pfn from LHCALL_NOTIFY */
+        /* Pending operation. */
+        struct lguest_pending pending;
+
+        unsigned long *reg_read; /* register from LHREQ_GETREG */
 
         /* At end of a page shared mapped over lguest_pages in guest. */
         unsigned long regs_page;
@@ -78,24 +81,18 @@ struct lg_cpu {
         struct lg_cpu_arch arch;
 };
 
-struct lg_eventfd {
-        unsigned long addr;
-        struct eventfd_ctx *event;
-};
-
-struct lg_eventfd_map {
-        unsigned int num;
-        struct lg_eventfd map[];
-};
-
 /* The private info the thread maintains about the guest. */
 struct lguest {
         struct lguest_data __user *lguest_data;
         struct lg_cpu cpus[NR_CPUS];
         unsigned int nr_cpus;
 
+        /* Valid guest memory pages must be < this. */
         u32 pfn_limit;
 
+        /* Device memory is >= pfn_limit and < device_limit. */
+        u32 device_limit;
+
         /*
          * This provides the offset to the base of guest-physical memory in the
          * Launcher.
@@ -110,8 +107,6 @@ struct lguest {
         unsigned int stack_pages;
         u32 tsc_khz;
 
-        struct lg_eventfd_map *eventfds;
-
         /* Dead? */
         const char *dead;
 };
@@ -197,8 +192,10 @@ void guest_pagetable_flush_user(struct lg_cpu *cpu);
 void guest_set_pte(struct lg_cpu *cpu, unsigned long gpgdir,
                    unsigned long vaddr, pte_t val);
 void map_switcher_in_guest(struct lg_cpu *cpu, struct lguest_pages *pages);
-bool demand_page(struct lg_cpu *cpu, unsigned long cr2, int errcode);
+bool demand_page(struct lg_cpu *cpu, unsigned long cr2, int errcode,
+                 unsigned long *iomem);
 void pin_page(struct lg_cpu *cpu, unsigned long vaddr);
+bool __guest_pa(struct lg_cpu *cpu, unsigned long vaddr, unsigned long *paddr);
 unsigned long guest_pa(struct lg_cpu *cpu, unsigned long vaddr);
 void page_table_guest_data_init(struct lg_cpu *cpu);
 
@@ -210,6 +207,7 @@ void lguest_arch_handle_trap(struct lg_cpu *cpu);
 int lguest_arch_init_hypercalls(struct lg_cpu *cpu);
 int lguest_arch_do_hcall(struct lg_cpu *cpu, struct hcall_args *args);
 void lguest_arch_setup_regs(struct lg_cpu *cpu, unsigned long start);
+unsigned long *lguest_arch_regptr(struct lg_cpu *cpu, size_t reg_off, bool any);
 
 /* <arch>/switcher.S: */
 extern char start_switcher_text[], end_switcher_text[], switch_to_guest[];
diff --git a/drivers/lguest/lguest_device.c b/drivers/lguest/lguest_device.c
deleted file mode 100644
index 89088d6538fd..000000000000
--- a/drivers/lguest/lguest_device.c
+++ /dev/null
@@ -1,540 +0,0 @@
-/*P:050
- * Lguest guests use a very simple method to describe devices.  It's a
- * series of device descriptors contained just above the top of normal Guest
- * memory.
- *
- * We use the standard "virtio" device infrastructure, which provides us with a
- * console, a network and a block driver.  Each one expects some configuration
- * information and a "virtqueue" or two to send and receive data.
-:*/
-#include <linux/init.h>
-#include <linux/bootmem.h>
-#include <linux/lguest_launcher.h>
-#include <linux/virtio.h>
-#include <linux/virtio_config.h>
-#include <linux/interrupt.h>
-#include <linux/virtio_ring.h>
-#include <linux/err.h>
-#include <linux/export.h>
-#include <linux/slab.h>
-#include <asm/io.h>
-#include <asm/paravirt.h>
-#include <asm/lguest_hcall.h>
-
-/* The pointer to our (page) of device descriptions. */
-static void *lguest_devices;
-
-/*
- * For Guests, device memory can be used as normal memory, so we cast away the
- * __iomem to quieten sparse.
- */
-static inline void *lguest_map(unsigned long phys_addr, unsigned long pages)
-{
-        return (__force void *)ioremap_cache(phys_addr, PAGE_SIZE*pages);
-}
-
-static inline void lguest_unmap(void *addr)
-{
-        iounmap((__force void __iomem *)addr);
-}
-
-/*D:100
- * Each lguest device is just a virtio device plus a pointer to its entry
- * in the lguest_devices page.
- */
-struct lguest_device {
-        struct virtio_device vdev;
-
-        /* The entry in the lguest_devices page for this device. */
-        struct lguest_device_desc *desc;
-};
-
-/*
- * Since the virtio infrastructure hands us a pointer to the virtio_device all
- * the time, it helps to have a curt macro to get a pointer to the struct
- * lguest_device it's enclosed in.
- */
-#define to_lgdev(vd) container_of(vd, struct lguest_device, vdev)
-
-/*D:130
- * Device configurations
- *
- * The configuration information for a device consists of one or more
- * virtqueues, a feature bitmap, and some configuration bytes.  The
- * configuration bytes don't really matter to us: the Launcher sets them up, and
- * the driver will look at them during setup.
- *
- * A convenient routine to return the device's virtqueue config array:
- * immediately after the descriptor.
- */
-static struct lguest_vqconfig *lg_vq(const struct lguest_device_desc *desc)
-{
-        return (void *)(desc + 1);
-}
-
-/* The features come immediately after the virtqueues. */
-static u8 *lg_features(const struct lguest_device_desc *desc)
-{
-        return (void *)(lg_vq(desc) + desc->num_vq);
-}
-
-/* The config space comes after the two feature bitmasks. */
-static u8 *lg_config(const struct lguest_device_desc *desc)
-{
-        return lg_features(desc) + desc->feature_len * 2;
-}
-
-/* The total size of the config page used by this device (incl. desc) */
-static unsigned desc_size(const struct lguest_device_desc *desc)
-{
-        return sizeof(*desc)
-                + desc->num_vq * sizeof(struct lguest_vqconfig)
-                + desc->feature_len * 2
-                + desc->config_len;
-}
-
-/* This gets the device's feature bits. */
-static u64 lg_get_features(struct virtio_device *vdev)
-{
-        unsigned int i;
-        u32 features = 0;
-        struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
-        u8 *in_features = lg_features(desc);
-
-        /* We do this the slow but generic way. */
-        for (i = 0; i < min(desc->feature_len * 8, 32); i++)
-                if (in_features[i / 8] & (1 << (i % 8)))
-                        features |= (1 << i);
-
-        return features;
-}
-
-/*
- * To notify on reset or feature finalization, we (ab)use the NOTIFY
- * hypercall, with the descriptor address of the device.
- */
-static void status_notify(struct virtio_device *vdev)
-{
-        unsigned long offset = (void *)to_lgdev(vdev)->desc - lguest_devices;
-
-        hcall(LHCALL_NOTIFY, (max_pfn << PAGE_SHIFT) + offset, 0, 0, 0);
-}
-
-/*
- * The virtio core takes the features the Host offers, and copies the ones
- * supported by the driver into the vdev->features array.  Once that's all
- * sorted out, this routine is called so we can tell the Host which features we
- * understand and accept.
- */
-static int lg_finalize_features(struct virtio_device *vdev)
-{
-        unsigned int i, bits;
-        struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
-        /* Second half of bitmap is features we accept. */
-        u8 *out_features = lg_features(desc) + desc->feature_len;
-
-        /* 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);
-
-        /*
-         * 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 (__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. */
-static void lg_get(struct virtio_device *vdev, unsigned int offset,
-                   void *buf, unsigned len)
-{
-        struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
-
-        /* Check they didn't ask for more than the length of the config! */
-        BUG_ON(offset + len > desc->config_len);
-        memcpy(buf, lg_config(desc) + offset, len);
-}
-
-/* Setting the contents is also trivial. */
-static void lg_set(struct virtio_device *vdev, unsigned int offset,
-                   const void *buf, unsigned len)
-{
-        struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
-
-        /* Check they didn't ask for more than the length of the config! */
-        BUG_ON(offset + len > desc->config_len);
-        memcpy(lg_config(desc) + offset, buf, len);
-}
-
-/*
- * The operations to get and set the status word just access the status field
- * of the device descriptor.
- */
-static u8 lg_get_status(struct virtio_device *vdev)
-{
-        return to_lgdev(vdev)->desc->status;
-}
-
-static void lg_set_status(struct virtio_device *vdev, u8 status)
-{
-        BUG_ON(!status);
-        to_lgdev(vdev)->desc->status = status;
-
-        /* Tell Host immediately if we failed. */
-        if (status & VIRTIO_CONFIG_S_FAILED)
-                status_notify(vdev);
-}
-
-static void lg_reset(struct virtio_device *vdev)
-{
-        /* 0 status means "reset" */
-        to_lgdev(vdev)->desc->status = 0;
-        status_notify(vdev);
-}
-
-/*
- * Virtqueues
- *
- * The other piece of infrastructure virtio needs is a "virtqueue": a way of
- * the Guest device registering buffers for the other side to read from or
- * write into (ie. send and receive buffers).  Each device can have multiple
- * virtqueues: for example the console driver uses one queue for sending and
- * another for receiving.
- *
- * Fortunately for us, a very fast shared-memory-plus-descriptors virtqueue
- * already exists in virtio_ring.c.  We just need to connect it up.
- *
- * We start with the information we need to keep about each virtqueue.
- */
-
-/*D:140 This is the information we remember about each virtqueue. */
-struct lguest_vq_info {
-        /* A copy of the information contained in the device config. */
-        struct lguest_vqconfig config;
-
-        /* The address where we mapped the virtio ring, so we can unmap it. */
-        void *pages;
-};
-
-/*
- * When the virtio_ring code wants to prod the Host, it calls us here and we
- * make a hypercall.  We hand the physical address of the virtqueue so the Host
- * knows which virtqueue we're talking about.
- */
-static bool lg_notify(struct virtqueue *vq)
-{
-        /*
-         * We store our virtqueue information in the "priv" pointer of the
-         * virtqueue structure.
-         */
-        struct lguest_vq_info *lvq = vq->priv;
-
-        hcall(LHCALL_NOTIFY, lvq->config.pfn << PAGE_SHIFT, 0, 0, 0);
-        return true;
-}
-
-/* An extern declaration inside a C file is bad form.  Don't do it. */
-extern int lguest_setup_irq(unsigned int irq);
-
-/*
- * This routine finds the Nth virtqueue described in the configuration of
- * this device and sets it up.
- *
- * This is kind of an ugly duckling.  It'd be nicer to have a standard
- * representation of a virtqueue in the configuration space, but it seems that
- * everyone wants to do it differently.  The KVM coders want the Guest to
- * allocate its own pages and tell the Host where they are, but for lguest it's
- * simpler for the Host to simply tell us where the pages are.
- */
-static struct virtqueue *lg_find_vq(struct virtio_device *vdev,
-                                    unsigned index,
-                                    void (*callback)(struct virtqueue *vq),
-                                    const char *name)
-{
-        struct lguest_device *ldev = to_lgdev(vdev);
-        struct lguest_vq_info *lvq;
-        struct virtqueue *vq;
-        int err;
-
-        if (!name)
-                return NULL;
-
-        /* We must have this many virtqueues. */
-        if (index >= ldev->desc->num_vq)
-                return ERR_PTR(-ENOENT);
-
-        lvq = kmalloc(sizeof(*lvq), GFP_KERNEL);
-        if (!lvq)
-                return ERR_PTR(-ENOMEM);
-
-        /*
-         * Make a copy of the "struct lguest_vqconfig" entry, which sits after
-         * the descriptor.  We need a copy because the config space might not
-         * be aligned correctly.
-         */
-        memcpy(&lvq->config, lg_vq(ldev->desc)+index, sizeof(lvq->config));
-
-        printk("Mapping virtqueue %i addr %lx\n", index,
-               (unsigned long)lvq->config.pfn << PAGE_SHIFT);
-        /* Figure out how many pages the ring will take, and map that memory */
-        lvq->pages = lguest_map((unsigned long)lvq->config.pfn << PAGE_SHIFT,
-                                DIV_ROUND_UP(vring_size(lvq->config.num,
-                                                        LGUEST_VRING_ALIGN),
-                                             PAGE_SIZE));
-        if (!lvq->pages) {
-                err = -ENOMEM;
-                goto free_lvq;
-        }
-
-        /*
-         * OK, tell virtio_ring.c to set up a virtqueue now we know its size
-         * and we've got a pointer to its pages.  Note that we set weak_barriers
-         * to 'true': the host just a(nother) SMP CPU, so we only need inter-cpu
-         * barriers.
-         */
-        vq = vring_new_virtqueue(index, lvq->config.num, LGUEST_VRING_ALIGN, vdev,
-                                 true, lvq->pages, lg_notify, callback, name);
-        if (!vq) {
-                err = -ENOMEM;
-                goto unmap;
-        }
-
-        /* Make sure the interrupt is allocated. */
-        err = lguest_setup_irq(lvq->config.irq);
-        if (err)
-                goto destroy_vring;
-
-        /*
-         * Tell the interrupt for this virtqueue to go to the virtio_ring
-         * interrupt handler.
-         *
-         * FIXME: We used to have a flag for the Host to tell us we could use
-         * the interrupt as a source of randomness: it'd be nice to have that
-         * back.
-         */
-        err = request_irq(lvq->config.irq, vring_interrupt, IRQF_SHARED,
-                          dev_name(&vdev->dev), vq);
-        if (err)
-                goto free_desc;
-
-        /*
-         * Last of all we hook up our 'struct lguest_vq_info" to the
-         * virtqueue's priv pointer.
-         */
-        vq->priv = lvq;
-        return vq;
-
-free_desc:
-        irq_free_desc(lvq->config.irq);
-destroy_vring:
-        vring_del_virtqueue(vq);
-unmap:
-        lguest_unmap(lvq->pages);
-free_lvq:
-        kfree(lvq);
-        return ERR_PTR(err);
-}
-/*:*/
-
-/* Cleaning up a virtqueue is easy */
-static void lg_del_vq(struct virtqueue *vq)
-{
-        struct lguest_vq_info *lvq = vq->priv;
-
-        /* Release the interrupt */
-        free_irq(lvq->config.irq, vq);
-        /* Tell virtio_ring.c to free the virtqueue. */
-        vring_del_virtqueue(vq);
-        /* Unmap the pages containing the ring. */
-        lguest_unmap(lvq->pages);
-        /* Free our own queue information. */
-        kfree(lvq);
-}
-
-static void lg_del_vqs(struct virtio_device *vdev)
-{
-        struct virtqueue *vq, *n;
-
-        list_for_each_entry_safe(vq, n, &vdev->vqs, list)
-                lg_del_vq(vq);
-}
-
-static int lg_find_vqs(struct virtio_device *vdev, unsigned nvqs,
-                       struct virtqueue *vqs[],
-                       vq_callback_t *callbacks[],
-                       const char *names[])
-{
-        struct lguest_device *ldev = to_lgdev(vdev);
-        int i;
-
-        /* We must have this many virtqueues. */
-        if (nvqs > ldev->desc->num_vq)
-                return -ENOENT;
-
-        for (i = 0; i < nvqs; ++i) {
-                vqs[i] = lg_find_vq(vdev, i, callbacks[i], names[i]);
-                if (IS_ERR(vqs[i]))
-                        goto error;
-        }
-        return 0;
-
-error:
-        lg_del_vqs(vdev);
-        return PTR_ERR(vqs[i]);
-}
-
-static const char *lg_bus_name(struct virtio_device *vdev)
-{
-        return "";
-}
-
-/* The ops structure which hooks everything together. */
-static const struct virtio_config_ops lguest_config_ops = {
-        .get_features = lg_get_features,
-        .finalize_features = lg_finalize_features,
-        .get = lg_get,
-        .set = lg_set,
-        .get_status = lg_get_status,
-        .set_status = lg_set_status,
-        .reset = lg_reset,
-        .find_vqs = lg_find_vqs,
-        .del_vqs = lg_del_vqs,
-        .bus_name = lg_bus_name,
-};
-
-/*
- * The root device for the lguest virtio devices.  This makes them appear as
- * /sys/devices/lguest/0,1,2 not /sys/devices/0,1,2.
- */
-static struct device *lguest_root;
-
-/*D:120
- * This is the core of the lguest bus: actually adding a new device.
- * It's a separate function because it's neater that way, and because an
- * earlier version of the code supported hotplug and unplug.  They were removed
- * early on because they were never used.
- *
- * As Andrew Tridgell says, "Untested code is buggy code".
- *
- * It's worth reading this carefully: we start with a pointer to the new device
- * descriptor in the "lguest_devices" page, and the offset into the device
- * descriptor page so we can uniquely identify it if things go badly wrong.
- */
-static void add_lguest_device(struct lguest_device_desc *d,
-                              unsigned int offset)
-{
-        struct lguest_device *ldev;
-
-        /* Start with zeroed memory; Linux's device layer counts on it. */
-        ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
-        if (!ldev) {
-                printk(KERN_EMERG "Cannot allocate lguest dev %u type %u\n",
-                       offset, d->type);
-                return;
-        }
-
-        /* This devices' parent is the lguest/ dir. */
-        ldev->vdev.dev.parent = lguest_root;
-        /*
-         * The device type comes straight from the descriptor.  There's also a
-         * device vendor field in the virtio_device struct, which we leave as
-         * 0.
-         */
-        ldev->vdev.id.device = d->type;
-        /*
-         * We have a simple set of routines for querying the device's
-         * configuration information and setting its status.
-         */
-        ldev->vdev.config = &lguest_config_ops;
-        /* And we remember the device's descriptor for lguest_config_ops. */
-        ldev->desc = d;
-
-        /*
-         * register_virtio_device() sets up the generic fields for the struct
-         * virtio_device and calls device_register().  This makes the bus
-         * infrastructure look for a matching driver.
-         */
-        if (register_virtio_device(&ldev->vdev) != 0) {
-                printk(KERN_ERR "Failed to register lguest dev %u type %u\n",
-                       offset, d->type);
-                kfree(ldev);
-        }
-}
-
-/*D:110
- * scan_devices() simply iterates through the device page.  The type 0 is
- * reserved to mean "end of devices".
- */
-static void scan_devices(void)
-{
-        unsigned int i;
-        struct lguest_device_desc *d;
-
-        /* We start at the page beginning, and skip over each entry. */
-        for (i = 0; i < PAGE_SIZE; i += desc_size(d)) {
-                d = lguest_devices + i;
-
-                /* Once we hit a zero, stop. */
-                if (d->type == 0)
-                        break;
-
-                printk("Device at %i has size %u\n", i, desc_size(d));
-                add_lguest_device(d, i);
-        }
-}
-
-/*D:105
- * Fairly early in boot, lguest_devices_init() is called to set up the
- * lguest device infrastructure.  We check that we are a Guest by checking
- * pv_info.name: there are other ways of checking, but this seems most
- * obvious to me.
- *
- * So we can access the "struct lguest_device_desc"s easily, we map that memory
- * and store the pointer in the global "lguest_devices".  Then we register a
- * root device from which all our devices will hang (this seems to be the
- * correct sysfs incantation).
- *
- * Finally we call scan_devices() which adds all the devices found in the
- * lguest_devices page.
- */
-static int __init lguest_devices_init(void)
-{
-        if (strcmp(pv_info.name, "lguest") != 0)
-                return 0;
-
-        lguest_root = root_device_register("lguest");
-        if (IS_ERR(lguest_root))
-                panic("Could not register lguest root");
-
-        /* Devices are in a single page above top of "normal" mem */
-        lguest_devices = lguest_map(max_pfn<<PAGE_SHIFT, 1);
-
-        scan_devices();
-        return 0;
-}
-/* We do this after core stuff, but before the drivers. */
-postcore_initcall(lguest_devices_init);
-
-/*D:150
- * At this point in the journey we used to now wade through the lguest
- * devices themselves: net, block and console.  Since they're all now virtio
- * devices rather than lguest-specific, I've decided to ignore them.  Mostly,
- * they're kind of boring.  But this does mean you'll never experience the
- * thrill of reading the forbidden love scene buried deep in the block driver.
- *
- * "make Launcher" beckons, where we answer questions like "Where do Guests
- * come from?", and "What do you do when someone asks for optimization?".
- */
diff --git a/drivers/lguest/lguest_user.c b/drivers/lguest/lguest_user.c
index 4263f4cc8c55..c4c6113eb9a6 100644
--- a/drivers/lguest/lguest_user.c
+++ b/drivers/lguest/lguest_user.c
@@ -2,175 +2,62 @@
  * launcher controls and communicates with the Guest.  For example,
  * the first write will tell us the Guest's memory layout and entry
  * point.  A read will run the Guest until something happens, such as
- * a signal or the Guest doing a NOTIFY out to the Launcher.  There is
- * also a way for the Launcher to attach eventfds to particular NOTIFY
- * values instead of returning from the read() call.
+ * a signal or the Guest accessing a device.
 :*/
 #include <linux/uaccess.h>
 #include <linux/miscdevice.h>
 #include <linux/fs.h>
 #include <linux/sched.h>
-#include <linux/eventfd.h>
 #include <linux/file.h>
 #include <linux/slab.h>
 #include <linux/export.h>
 #include "lg.h"
 
-/*L:056
- * Before we move on, let's jump ahead and look at what the kernel does when
- * it needs to look up the eventfds.  That will complete our picture of how we
- * use RCU.
- *
- * The notification value is in cpu->pending_notify: we return true if it went
- * to an eventfd.
- */
-bool send_notify_to_eventfd(struct lg_cpu *cpu)
-{
-        unsigned int i;
-        struct lg_eventfd_map *map;
-
-        /*
-         * This "rcu_read_lock()" helps track when someone is still looking at
-         * the (RCU-using) eventfds array.  It's not actually a lock at all;
-         * indeed it's a noop in many configurations.  (You didn't expect me to
-         * explain all the RCU secrets here, did you?)
-         */
-        rcu_read_lock();
-        /*
-         * rcu_dereference is the counter-side of rcu_assign_pointer(); it
-         * makes sure we don't access the memory pointed to by
-         * cpu->lg->eventfds before cpu->lg->eventfds is set.  Sounds crazy,
-         * but Alpha allows this!  Paul McKenney points out that a really
-         * aggressive compiler could have the same effect:
-         *   http://lists.ozlabs.org/pipermail/lguest/2009-July/001560.html
-         *
-         * So play safe, use rcu_dereference to get the rcu-protected pointer:
-         */
-        map = rcu_dereference(cpu->lg->eventfds);
-        /*
-         * Simple array search: even if they add an eventfd while we do this,
-         * we'll continue to use the old array and just won't see the new one.
-         */
-        for (i = 0; i < map->num; i++) {
-                if (map->map[i].addr == cpu->pending_notify) {
-                        eventfd_signal(map->map[i].event, 1);
-                        cpu->pending_notify = 0;
-                        break;
-                }
-        }
-        /* We're done with the rcu-protected variable cpu->lg->eventfds. */
-        rcu_read_unlock();
-
-        /* If we cleared the notification, it's because we found a match. */
-        return cpu->pending_notify == 0;
-}
-
-/*L:055
- * One of the more tricksy tricks in the Linux Kernel is a technique called
- * Read Copy Update.  Since one point of lguest is to teach lguest journeyers
- * about kernel coding, I use it here.  (In case you're curious, other purposes
- * include learning about virtualization and instilling a deep appreciation for
- * simplicity and puppies).
- *
- * We keep a simple array which maps LHCALL_NOTIFY values to eventfds, but we
- * add new eventfds without ever blocking readers from accessing the array.
- * The current Launcher only does this during boot, so that never happens.  But
- * Read Copy Update is cool, and adding a lock risks damaging even more puppies
- * than this code does.
- *
- * We allocate a brand new one-larger array, copy the old one and add our new
- * element.  Then we make the lg eventfd pointer point to the new array.
- * That's the easy part: now we need to free the old one, but we need to make
- * sure no slow CPU somewhere is still looking at it.  That's what
- * synchronize_rcu does for us: waits until every CPU has indicated that it has
- * moved on to know it's no longer using the old one.
- *
- * If that's unclear, see http://en.wikipedia.org/wiki/Read-copy-update.
- */
-static int add_eventfd(struct lguest *lg, unsigned long addr, int fd)
+/*L:052
+  The Launcher can get the registers, and also set some of them.
+*/
+static int getreg_setup(struct lg_cpu *cpu, const unsigned long __user *input)
 {
-        struct lg_eventfd_map *new, *old = lg->eventfds;
-
-        /*
-         * We don't allow notifications on value 0 anyway (pending_notify of
-         * 0 means "nothing pending").
-         */
-        if (!addr)
-                return -EINVAL;
-
-        /*
-         * Replace the old array with the new one, carefully: others can
-         * be accessing it at the same time.
-         */
-        new = kmalloc(sizeof(*new) + sizeof(new->map[0]) * (old->num + 1),
-                      GFP_KERNEL);
-        if (!new)
-                return -ENOMEM;
+        unsigned long which;
 
-        /* First make identical copy. */
-        memcpy(new->map, old->map, sizeof(old->map[0]) * old->num);
-        new->num = old->num;
-
-        /* Now append new entry. */
-        new->map[new->num].addr = addr;
-        new->map[new->num].event = eventfd_ctx_fdget(fd);
-        if (IS_ERR(new->map[new->num].event)) {
-                int err =  PTR_ERR(new->map[new->num].event);
-                kfree(new);
-                return err;
-        }
-        new->num++;
+        /* We re-use the ptrace structure to specify which register to read. */
+        if (get_user(which, input) != 0)
+                return -EFAULT;
 
         /*
-         * Now put new one in place: rcu_assign_pointer() is a fancy way of
-         * doing "lg->eventfds = new", but it uses memory barriers to make
-         * absolutely sure that the contents of "new" written above is nailed
-         * down before we actually do the assignment.
+         * We set up the cpu register pointer, and their next read will
+         * actually get the value (instead of running the guest).
          *
-         * We have to think about these kinds of things when we're operating on
-         * live data without locks.
+         * The last argument 'true' says we can access any register.
          */
-        rcu_assign_pointer(lg->eventfds, new);
+        cpu->reg_read = lguest_arch_regptr(cpu, which, true);
+        if (!cpu->reg_read)
+                return -ENOENT;
 
-        /*
-         * We're not in a big hurry.  Wait until no one's looking at old
-         * version, then free it.
-         */
-        synchronize_rcu();
-        kfree(old);
-
-        return 0;
+        /* And because this is a write() call, we return the length used. */
+        return sizeof(unsigned long) * 2;
 }
 
-/*L:052
- * Receiving notifications from the Guest is usually done by attaching a
- * particular LHCALL_NOTIFY value to an event filedescriptor.  The eventfd will
- * become readable when the Guest does an LHCALL_NOTIFY with that value.
- *
- * This is really convenient for processing each virtqueue in a separate
- * thread.
- */
-static int attach_eventfd(struct lguest *lg, const unsigned long __user *input)
+static int setreg(struct lg_cpu *cpu, const unsigned long __user *input)
 {
-        unsigned long addr, fd;
-        int err;
+        unsigned long which, value, *reg;
 
-        if (get_user(addr, input) != 0)
+        /* We re-use the ptrace structure to specify which register to read. */
+        if (get_user(which, input) != 0)
                 return -EFAULT;
         input++;
-        if (get_user(fd, input) != 0)
+        if (get_user(value, input) != 0)
                 return -EFAULT;
 
-        /*
-         * Just make sure two callers don't add eventfds at once.  We really
-         * only need to lock against callers adding to the same Guest, so using
-         * the Big Lguest Lock is overkill.  But this is setup, not a fast path.
-         */
-        mutex_lock(&lguest_lock);
-        err = add_eventfd(lg, addr, fd);
-        mutex_unlock(&lguest_lock);
+        /* The last argument 'false' means we can't access all registers. */
+        reg = lguest_arch_regptr(cpu, which, false);
+        if (!reg)
+                return -ENOENT;
 
-        return err;
+        *reg = value;
+
+        /* And because this is a write() call, we return the length used. */
+        return sizeof(unsigned long) * 3;
 }
 
 /*L:050
@@ -194,6 +81,23 @@ static int user_send_irq(struct lg_cpu *cpu, const unsigned long __user *input)
         return 0;
 }
 
+/*L:053
+ * Deliver a trap: this is used by the Launcher if it can't emulate
+ * an instruction.
+ */
+static int trap(struct lg_cpu *cpu, const unsigned long __user *input)
+{
+        unsigned long trapnum;
+
+        if (get_user(trapnum, input) != 0)
+                return -EFAULT;
+
+        if (!deliver_trap(cpu, trapnum))
+                return -EINVAL;
+
+        return 0;
+}
+
 /*L:040
  * Once our Guest is initialized, the Launcher makes it run by reading
  * from /dev/lguest.
@@ -237,8 +141,8 @@ static ssize_t read(struct file *file, char __user *user, size_t size,loff_t*o)
          * If we returned from read() last time because the Guest sent I/O,
          * clear the flag.
          */
-        if (cpu->pending_notify)
-                cpu->pending_notify = 0;
+        if (cpu->pending.trap)
+                cpu->pending.trap = 0;
 
         /* Run the Guest until something interesting happens. */
         return run_guest(cpu, (unsigned long __user *)user);
@@ -319,7 +223,7 @@ static int initialize(struct file *file, const unsigned long __user *input)
         /* "struct lguest" contains all we (the Host) know about a Guest. */
         struct lguest *lg;
         int err;
-        unsigned long args[3];
+        unsigned long args[4];
 
         /*
          * We grab the Big Lguest lock, which protects against multiple
@@ -343,21 +247,15 @@ static int initialize(struct file *file, const unsigned long __user *input)
                 goto unlock;
         }
 
-        lg->eventfds = kmalloc(sizeof(*lg->eventfds), GFP_KERNEL);
-        if (!lg->eventfds) {
-                err = -ENOMEM;
-                goto free_lg;
-        }
-        lg->eventfds->num = 0;
-
         /* Populate the easy fields of our "struct lguest" */
         lg->mem_base = (void __user *)args[0];
         lg->pfn_limit = args[1];
+        lg->device_limit = args[3];
 
         /* This is the first cpu (cpu 0) and it will start booting at args[2] */
         err = lg_cpu_start(&lg->cpus[0], 0, args[2]);
         if (err)
-                goto free_eventfds;
+                goto free_lg;
 
         /*
          * Initialize the Guest's shadow page tables.  This allocates
@@ -378,8 +276,6 @@ static int initialize(struct file *file, const unsigned long __user *input)
 free_regs:
         /* FIXME: This should be in free_vcpu */
         free_page(lg->cpus[0].regs_page);
-free_eventfds:
-        kfree(lg->eventfds);
 free_lg:
         kfree(lg);
 unlock:
@@ -432,8 +328,12 @@ static ssize_t write(struct file *file, const char __user *in,
                 return initialize(file, input);
         case LHREQ_IRQ:
                 return user_send_irq(cpu, input);
-        case LHREQ_EVENTFD:
-                return attach_eventfd(lg, input);
+        case LHREQ_GETREG:
+                return getreg_setup(cpu, input);
+        case LHREQ_SETREG:
+                return setreg(cpu, input);
+        case LHREQ_TRAP:
+                return trap(cpu, input);
         default:
                 return -EINVAL;
         }
@@ -478,11 +378,6 @@ static int close(struct inode *inode, struct file *file)
                 mmput(lg->cpus[i].mm);
         }
 
-        /* Release any eventfds they registered. */
-        for (i = 0; i < lg->eventfds->num; i++)
-                eventfd_ctx_put(lg->eventfds->map[i].event);
-        kfree(lg->eventfds);
-
         /*
          * If lg->dead doesn't contain an error code it will be NULL or a
          * kmalloc()ed string, either of which is ok to hand to kfree().
diff --git a/drivers/lguest/page_tables.c b/drivers/lguest/page_tables.c
index e8b55c3a6170..e3abebc912c0 100644
--- a/drivers/lguest/page_tables.c
+++ b/drivers/lguest/page_tables.c
@@ -250,6 +250,16 @@ static void release_pte(pte_t pte)
 }
 /*:*/
 
+static bool gpte_in_iomem(struct lg_cpu *cpu, pte_t gpte)
+{
+        /* We don't handle large pages. */
+        if (pte_flags(gpte) & _PAGE_PSE)
+                return false;
+
+        return (pte_pfn(gpte) >= cpu->lg->pfn_limit
+                && pte_pfn(gpte) < cpu->lg->device_limit);
+}
+
 static bool check_gpte(struct lg_cpu *cpu, pte_t gpte)
 {
         if ((pte_flags(gpte) & _PAGE_PSE) ||
@@ -374,8 +384,14 @@ static pte_t *find_spte(struct lg_cpu *cpu, unsigned long vaddr, bool allocate,
  *
  * If we fixed up the fault (ie. we mapped the address), this routine returns
  * true.  Otherwise, it was a real fault and we need to tell the Guest.
+ *
+ * There's a corner case: they're trying to access memory between
+ * pfn_limit and device_limit, which is I/O memory.  In this case, we
+ * return false and set @iomem to the physical address, so the the
+ * Launcher can handle the instruction manually.
  */
-bool demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode)
+bool demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode,
+                 unsigned long *iomem)
 {
         unsigned long gpte_ptr;
         pte_t gpte;
@@ -383,6 +399,8 @@ bool demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode)
         pmd_t gpmd;
         pgd_t gpgd;
 
+        *iomem = 0;
+
         /* We never demand page the Switcher, so trying is a mistake. */
         if (vaddr >= switcher_addr)
                 return false;
@@ -459,6 +477,12 @@ bool demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode)
         if ((errcode & 4) && !(pte_flags(gpte) & _PAGE_USER))
                 return false;
 
+        /* If they're accessing io memory, we expect a fault. */
+        if (gpte_in_iomem(cpu, gpte)) {
+                *iomem = (pte_pfn(gpte) << PAGE_SHIFT) | (vaddr & ~PAGE_MASK);
+                return false;
+        }
+
         /*
          * Check that the Guest PTE flags are OK, and the page number is below
          * the pfn_limit (ie. not mapping the Launcher binary).
@@ -553,7 +577,9 @@ static bool page_writable(struct lg_cpu *cpu, unsigned long vaddr)
  */
 void pin_page(struct lg_cpu *cpu, unsigned long vaddr)
 {
-        if (!page_writable(cpu, vaddr) && !demand_page(cpu, vaddr, 2))
+        unsigned long iomem;
+
+        if (!page_writable(cpu, vaddr) && !demand_page(cpu, vaddr, 2, &iomem))
                 kill_guest(cpu, "bad stack page %#lx", vaddr);
 }
 /*:*/
@@ -647,7 +673,7 @@ void guest_pagetable_flush_user(struct lg_cpu *cpu)
 /*:*/
 
 /* We walk down the guest page tables to get a guest-physical address */
-unsigned long guest_pa(struct lg_cpu *cpu, unsigned long vaddr)
+bool __guest_pa(struct lg_cpu *cpu, unsigned long vaddr, unsigned long *paddr)
 {
         pgd_t gpgd;
         pte_t gpte;
@@ -656,31 +682,47 @@ unsigned long guest_pa(struct lg_cpu *cpu, unsigned long vaddr)
 #endif
 
         /* Still not set up?  Just map 1:1. */
-        if (unlikely(cpu->linear_pages))
-                return vaddr;
+        if (unlikely(cpu->linear_pages)) {
+                *paddr = vaddr;
+                return true;
+        }
 
         /* First step: get the top-level Guest page table entry. */
         gpgd = lgread(cpu, gpgd_addr(cpu, vaddr), pgd_t);
         /* Toplevel not present?  We can't map it in. */
-        if (!(pgd_flags(gpgd) & _PAGE_PRESENT)) {
-                kill_guest(cpu, "Bad address %#lx", vaddr);
-                return -1UL;
-        }
+        if (!(pgd_flags(gpgd) & _PAGE_PRESENT))
+                goto fail;
 
 #ifdef CONFIG_X86_PAE
         gpmd = lgread(cpu, gpmd_addr(gpgd, vaddr), pmd_t);
-        if (!(pmd_flags(gpmd) & _PAGE_PRESENT)) {
-                kill_guest(cpu, "Bad address %#lx", vaddr);
-                return -1UL;
-        }
+        if (!(pmd_flags(gpmd) & _PAGE_PRESENT))
+                goto fail;
         gpte = lgread(cpu, gpte_addr(cpu, gpmd, vaddr), pte_t);
 #else
         gpte = lgread(cpu, gpte_addr(cpu, gpgd, vaddr), pte_t);
 #endif
         if (!(pte_flags(gpte) & _PAGE_PRESENT))
-                kill_guest(cpu, "Bad address %#lx", vaddr);
+                goto fail;
+
+        *paddr = pte_pfn(gpte) * PAGE_SIZE | (vaddr & ~PAGE_MASK);
+        return true;
+
+fail:
+        *paddr = -1UL;
+        return false;
+}
 
-        return pte_pfn(gpte) * PAGE_SIZE | (vaddr & ~PAGE_MASK);
+/*
+ * This is the version we normally use: kills the Guest if it uses a
+ * bad address
+ */
+unsigned long guest_pa(struct lg_cpu *cpu, unsigned long vaddr)
+{
+        unsigned long paddr;
+
+        if (!__guest_pa(cpu, vaddr, &paddr))
+                kill_guest(cpu, "Bad address %#lx", vaddr);
+        return paddr;
 }
 
 /*
@@ -912,7 +954,8 @@ static void __guest_set_pte(struct lg_cpu *cpu, int idx,
                          * now.  This shaves 10% off a copy-on-write
                          * micro-benchmark.
                          */
-                        if (pte_flags(gpte) & (_PAGE_DIRTY | _PAGE_ACCESSED)) {
+                        if ((pte_flags(gpte) & (_PAGE_DIRTY | _PAGE_ACCESSED))
+                            && !gpte_in_iomem(cpu, gpte)) {
                                 if (!check_gpte(cpu, gpte))
                                         return;
                                 set_pte(spte,
diff --git a/drivers/lguest/x86/core.c b/drivers/lguest/x86/core.c
index 6adfd7ba4c97..30f2aef69d78 100644
--- a/drivers/lguest/x86/core.c
+++ b/drivers/lguest/x86/core.c
@@ -182,6 +182,52 @@ static void run_guest_once(struct lg_cpu *cpu, struct lguest_pages *pages)
 }
 /*:*/
 
+unsigned long *lguest_arch_regptr(struct lg_cpu *cpu, size_t reg_off, bool any)
+{
+        switch (reg_off) {
+        case offsetof(struct pt_regs, bx):
+                return &cpu->regs->ebx;
+        case offsetof(struct pt_regs, cx):
+                return &cpu->regs->ecx;
+        case offsetof(struct pt_regs, dx):
+                return &cpu->regs->edx;
+        case offsetof(struct pt_regs, si):
+                return &cpu->regs->esi;
+        case offsetof(struct pt_regs, di):
+                return &cpu->regs->edi;
+        case offsetof(struct pt_regs, bp):
+                return &cpu->regs->ebp;
+        case offsetof(struct pt_regs, ax):
+                return &cpu->regs->eax;
+        case offsetof(struct pt_regs, ip):
+                return &cpu->regs->eip;
+        case offsetof(struct pt_regs, sp):
+                return &cpu->regs->esp;
+        }
+
+        /* Launcher can read these, but we don't allow any setting. */
+        if (any) {
+                switch (reg_off) {
+                case offsetof(struct pt_regs, ds):
+                        return &cpu->regs->ds;
+                case offsetof(struct pt_regs, es):
+                        return &cpu->regs->es;
+                case offsetof(struct pt_regs, fs):
+                        return &cpu->regs->fs;
+                case offsetof(struct pt_regs, gs):
+                        return &cpu->regs->gs;
+                case offsetof(struct pt_regs, cs):
+                        return &cpu->regs->cs;
+                case offsetof(struct pt_regs, flags):
+                        return &cpu->regs->eflags;
+                case offsetof(struct pt_regs, ss):
+                        return &cpu->regs->ss;
+                }
+        }
+
+        return NULL;
+}
+
 /*M:002
  * There are hooks in the scheduler which we can register to tell when we
  * get kicked off the CPU (preempt_notifier_register()).  This would allow us
@@ -269,110 +315,73 @@ void lguest_arch_run_guest(struct lg_cpu *cpu)
  * usually attached to a PC.
  *
  * When the Guest uses one of these instructions, we get a trap (General
- * Protection Fault) and come here.  We see if it's one of those troublesome
- * instructions and skip over it.  We return true if we did.
+ * Protection Fault) and come here.  We queue this to be sent out to the
+ * Launcher to handle.
  */
-static int emulate_insn(struct lg_cpu *cpu)
-{
-        u8 insn;
-        unsigned int insnlen = 0, in = 0, small_operand = 0;
-        /*
-         * The eip contains the *virtual* address of the Guest's instruction:
-         * walk the Guest's page tables to find the "physical" address.
-         */
-        unsigned long physaddr = guest_pa(cpu, cpu->regs->eip);
-
-        /*
-         * This must be the Guest kernel trying to do something, not userspace!
-         * The bottom two bits of the CS segment register are the privilege
-         * level.
-         */
-        if ((cpu->regs->cs & 3) != GUEST_PL)
-                return 0;
-
-        /* Decoding x86 instructions is icky. */
-        insn = lgread(cpu, physaddr, u8);
 
-        /*
-         * Around 2.6.33, the kernel started using an emulation for the
-         * cmpxchg8b instruction in early boot on many configurations.  This
-         * code isn't paravirtualized, and it tries to disable interrupts.
-         * Ignore it, which will Mostly Work.
-         */
-        if (insn == 0xfa) {
-                /* "cli", or Clear Interrupt Enable instruction.  Skip it. */
-                cpu->regs->eip++;
-                return 1;
+/*
+ * The eip contains the *virtual* address of the Guest's instruction:
+ * we copy the instruction here so the Launcher doesn't have to walk
+ * the page tables to decode it.  We handle the case (eg. in a kernel
+ * module) where the instruction is over two pages, and the pages are
+ * virtually but not physically contiguous.
+ *
+ * The longest possible x86 instruction is 15 bytes, but we don't handle
+ * anything that strange.
+ */
+static void copy_from_guest(struct lg_cpu *cpu,
+                            void *dst, unsigned long vaddr, size_t len)
+{
+        size_t to_page_end = PAGE_SIZE - (vaddr % PAGE_SIZE);
+        unsigned long paddr;
+
+        BUG_ON(len > PAGE_SIZE);
+
+        /* If it goes over a page, copy in two parts. */
+        if (len > to_page_end) {
+                /* But make sure the next page is mapped! */
+                if (__guest_pa(cpu, vaddr + to_page_end, &paddr))
+                        copy_from_guest(cpu, dst + to_page_end,
+                                        vaddr + to_page_end,
+                                        len - to_page_end);
+                else
+                        /* Otherwise fill with zeroes. */
+                        memset(dst + to_page_end, 0, len - to_page_end);
+                len = to_page_end;
         }
 
-        /*
-         * 0x66 is an "operand prefix".  It means a 16, not 32 bit in/out.
-         */
-        if (insn == 0x66) {
-                small_operand = 1;
-                /* The instruction is 1 byte so far, read the next byte. */
-                insnlen = 1;
-                insn = lgread(cpu, physaddr + insnlen, u8);
-        }
+        /* This will kill the guest if it isn't mapped, but that
+         * shouldn't happen. */
+        __lgread(cpu, dst, guest_pa(cpu, vaddr), len);
+}
 
-        /*
-         * We can ignore the lower bit for the moment and decode the 4 opcodes
-         * we need to emulate.
-         */
-        switch (insn & 0xFE) {
-        case 0xE4: /* in     <next byte>,%al */
-                insnlen += 2;
-                in = 1;
-                break;
-        case 0xEC: /* in     (%dx),%al */
-                insnlen += 1;
-                in = 1;
-                break;
-        case 0xE6: /* out    %al,<next byte> */
-                insnlen += 2;
-                break;
-        case 0xEE: /* out    %al,(%dx) */
-                insnlen += 1;
-                break;
-        default:
-                /* OK, we don't know what this is, can't emulate. */
-                return 0;
-        }
 
-        /*
-         * If it was an "IN" instruction, they expect the result to be read
-         * into %eax, so we change %eax.  We always return all-ones, which
-         * traditionally means "there's nothing there".
-         */
-        if (in) {
-                /* Lower bit tells means it's a 32/16 bit access */
-                if (insn & 0x1) {
-                        if (small_operand)
-                                cpu->regs->eax |= 0xFFFF;
-                        else
-                                cpu->regs->eax = 0xFFFFFFFF;
-                } else
-                        cpu->regs->eax |= 0xFF;
-        }
-        /* Finally, we've "done" the instruction, so move past it. */
-        cpu->regs->eip += insnlen;
-        /* Success! */
-        return 1;
+static void setup_emulate_insn(struct lg_cpu *cpu)
+{
+        cpu->pending.trap = 13;
+        copy_from_guest(cpu, cpu->pending.insn, cpu->regs->eip,
+                        sizeof(cpu->pending.insn));
+}
+
+static void setup_iomem_insn(struct lg_cpu *cpu, unsigned long iomem_addr)
+{
+        cpu->pending.trap = 14;
+        cpu->pending.addr = iomem_addr;
+        copy_from_guest(cpu, cpu->pending.insn, cpu->regs->eip,
+                        sizeof(cpu->pending.insn));
 }
 
 /*H:050 Once we've re-enabled interrupts, we look at why the Guest exited. */
 void lguest_arch_handle_trap(struct lg_cpu *cpu)
 {
+        unsigned long iomem_addr;
+
         switch (cpu->regs->trapnum) {
         case 13: /* We've intercepted a General Protection Fault. */
-                /*
-                 * Check if this was one of those annoying IN or OUT
-                 * instructions which we need to emulate.  If so, we just go
-                 * back into the Guest after we've done it.
-                 */
+                /* Hand to Launcher to emulate those pesky IN and OUT insns */
                 if (cpu->regs->errcode == 0) {
-                        if (emulate_insn(cpu))
-                                return;
+                        setup_emulate_insn(cpu);
+                        return;
                 }
                 break;
         case 14: /* We've intercepted a Page Fault. */
@@ -387,9 +396,16 @@ void lguest_arch_handle_trap(struct lg_cpu *cpu)
                  * whether kernel or userspace code.
                  */
                 if (demand_page(cpu, cpu->arch.last_pagefault,
-                                cpu->regs->errcode))
+                                cpu->regs->errcode, &iomem_addr))
                         return;
 
+                /* Was this an access to memory mapped IO? */
+                if (iomem_addr) {
+                        /* Tell Launcher, let it handle it. */
+                        setup_iomem_insn(cpu, iomem_addr);
+                        return;
+                }
+
                 /*
                  * OK, it's really not there (or not OK): the Guest needs to
                  * know.  We write out the cr2 value so it knows where the
diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index c39644478aa4..63e05e32b462 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -178,7 +178,7 @@ config MD_FAULTY
 source "drivers/md/bcache/Kconfig"
 
 config BLK_DEV_DM_BUILTIN
-        boolean
+        bool
 
 config BLK_DEV_DM
         tristate "Device mapper support"
@@ -197,7 +197,7 @@ config BLK_DEV_DM
           If unsure, say N.
 
 config DM_DEBUG
-        boolean "Device mapper debugging support"
+        bool "Device mapper debugging support"
         depends on BLK_DEV_DM
         ---help---
           Enable this for messages that may help debug device-mapper problems.
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 08981be7baa1..713a96237a80 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -18,9 +18,11 @@
 #include <linux/slab.h>
 #include <linux/crypto.h>
 #include <linux/workqueue.h>
+#include <linux/kthread.h>
 #include <linux/backing-dev.h>
 #include <linux/atomic.h>
 #include <linux/scatterlist.h>
+#include <linux/rbtree.h>
 #include <asm/page.h>
 #include <asm/unaligned.h>
 #include <crypto/hash.h>
@@ -58,7 +60,8 @@ struct dm_crypt_io {
         atomic_t io_pending;
         int error;
         sector_t sector;
-        struct dm_crypt_io *base_io;
+
+        struct rb_node rb_node;
 } CRYPTO_MINALIGN_ATTR;
 
 struct dm_crypt_request {
@@ -108,7 +111,8 @@ struct iv_tcw_private {
  * Crypt: maps a linear range of a block device
  * and encrypts / decrypts at the same time.
  */
-enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID };
+enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID,
+             DM_CRYPT_SAME_CPU, DM_CRYPT_NO_OFFLOAD };
 
 /*
  * The fields in here must be read only after initialization.
@@ -121,14 +125,18 @@ struct crypt_config {
          * pool for per bio private data, crypto requests and
          * encryption requeusts/buffer pages
          */
-        mempool_t *io_pool;
         mempool_t *req_pool;
         mempool_t *page_pool;
         struct bio_set *bs;
+        struct mutex bio_alloc_lock;
 
         struct workqueue_struct *io_queue;
         struct workqueue_struct *crypt_queue;
 
+        struct task_struct *write_thread;
+        wait_queue_head_t write_thread_wait;
+        struct rb_root write_tree;
+
         char *cipher;
         char *cipher_string;
 
@@ -172,9 +180,6 @@ struct crypt_config {
 };
 
 #define MIN_IOS        16
-#define MIN_POOL_PAGES 32
-
-static struct kmem_cache *_crypt_io_pool;
 
 static void clone_init(struct dm_crypt_io *, struct bio *);
 static void kcryptd_queue_crypt(struct dm_crypt_io *io);
@@ -946,57 +951,70 @@ static int crypt_convert(struct crypt_config *cc,
         return 0;
 }
 
+static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone);
+
 /*
  * Generate a new unfragmented bio with the given size
  * This should never violate the device limitations
- * May return a smaller bio when running out of pages, indicated by
- * *out_of_pages set to 1.
+ *
+ * This function may be called concurrently. If we allocate from the mempool
+ * concurrently, there is a possibility of deadlock. For example, if we have
+ * mempool of 256 pages, two processes, each wanting 256, pages allocate from
+ * the mempool concurrently, it may deadlock in a situation where both processes
+ * have allocated 128 pages and the mempool is exhausted.
+ *
+ * In order to avoid this scenario we allocate the pages under a mutex.
+ *
+ * In order to not degrade performance with excessive locking, we try
+ * non-blocking allocations without a mutex first but on failure we fallback
+ * to blocking allocations with a mutex.
  */
-static struct bio *crypt_alloc_buffer(struct dm_crypt_io *io, unsigned size,
-                                      unsigned *out_of_pages)
+static struct bio *crypt_alloc_buffer(struct dm_crypt_io *io, unsigned size)
 {
         struct crypt_config *cc = io->cc;
         struct bio *clone;
         unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
-        gfp_t gfp_mask = GFP_NOIO | __GFP_HIGHMEM;
-        unsigned i, len;
+        gfp_t gfp_mask = GFP_NOWAIT | __GFP_HIGHMEM;
+        unsigned i, len, remaining_size;
         struct page *page;
+        struct bio_vec *bvec;
+
+retry:
+        if (unlikely(gfp_mask & __GFP_WAIT))
+                mutex_lock(&cc->bio_alloc_lock);
 
         clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
         if (!clone)
-                return NULL;
+                goto return_clone;
 
         clone_init(io, clone);
-        *out_of_pages = 0;
+
+        remaining_size = size;
 
         for (i = 0; i < nr_iovecs; i++) {
                 page = mempool_alloc(cc->page_pool, gfp_mask);
                 if (!page) {
-                        *out_of_pages = 1;
-                        break;
+                        crypt_free_buffer_pages(cc, clone);
+                        bio_put(clone);
+                        gfp_mask |= __GFP_WAIT;
+                        goto retry;
                 }
 
-                /*
-                 * If additional pages cannot be allocated without waiting,
-                 * return a partially-allocated bio.  The caller will then try
-                 * to allocate more bios while submitting this partial bio.
-                 */
-                gfp_mask = (gfp_mask | __GFP_NOWARN) & ~__GFP_WAIT;
+                len = (remaining_size > PAGE_SIZE) ? PAGE_SIZE : remaining_size;
 
-                len = (size > PAGE_SIZE) ? PAGE_SIZE : size;
+                bvec = &clone->bi_io_vec[clone->bi_vcnt++];
+                bvec->bv_page = page;
+                bvec->bv_len = len;
+                bvec->bv_offset = 0;
 
-                if (!bio_add_page(clone, page, len, 0)) {
-                        mempool_free(page, cc->page_pool);
-                        break;
-                }
+                clone->bi_iter.bi_size += len;
 
-                size -= len;
+                remaining_size -= len;
         }
 
-        if (!clone->bi_iter.bi_size) {
-                bio_put(clone);
-                return NULL;
-        }
+return_clone:
+        if (unlikely(gfp_mask & __GFP_WAIT))
+                mutex_unlock(&cc->bio_alloc_lock);
 
         return clone;
 }
@@ -1020,7 +1038,6 @@ static void crypt_io_init(struct dm_crypt_io *io, struct crypt_config *cc,
         io->base_bio = bio;
         io->sector = sector;
         io->error = 0;
-        io->base_io = NULL;
         io->ctx.req = NULL;
         atomic_set(&io->io_pending, 0);
 }
@@ -1033,13 +1050,11 @@ static void crypt_inc_pending(struct dm_crypt_io *io)
 /*
  * One of the bios was finished. Check for completion of
  * the whole request and correctly clean up the buffer.
- * If base_io is set, wait for the last fragment to complete.
  */
 static void crypt_dec_pending(struct dm_crypt_io *io)
 {
         struct crypt_config *cc = io->cc;
         struct bio *base_bio = io->base_bio;
-        struct dm_crypt_io *base_io = io->base_io;
         int error = io->error;
 
         if (!atomic_dec_and_test(&io->io_pending))
@@ -1047,16 +1062,8 @@ static void crypt_dec_pending(struct dm_crypt_io *io)
 
         if (io->ctx.req)
                 crypt_free_req(cc, io->ctx.req, base_bio);
-        if (io != dm_per_bio_data(base_bio, cc->per_bio_data_size))
-                mempool_free(io, cc->io_pool);
-
-        if (likely(!base_io))
-                bio_endio(base_bio, error);
-        else {
-                if (error && !base_io->error)
-                        base_io->error = error;
-                crypt_dec_pending(base_io);
-        }
+
+        bio_endio(base_bio, error);
 }
 
 /*
@@ -1138,37 +1145,97 @@ static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
         return 0;
 }
 
+static void kcryptd_io_read_work(struct work_struct *work)
+{
+        struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
+
+        crypt_inc_pending(io);
+        if (kcryptd_io_read(io, GFP_NOIO))
+                io->error = -ENOMEM;
+        crypt_dec_pending(io);
+}
+
+static void kcryptd_queue_read(struct dm_crypt_io *io)
+{
+        struct crypt_config *cc = io->cc;
+
+        INIT_WORK(&io->work, kcryptd_io_read_work);
+        queue_work(cc->io_queue, &io->work);
+}
+
 static void kcryptd_io_write(struct dm_crypt_io *io)
 {
         struct bio *clone = io->ctx.bio_out;
+
         generic_make_request(clone);
 }
 
-static void kcryptd_io(struct work_struct *work)
+#define crypt_io_from_node(node) rb_entry((node), struct dm_crypt_io, rb_node)
+
+static int dmcrypt_write(void *data)
 {
-        struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
+        struct crypt_config *cc = data;
+        struct dm_crypt_io *io;
 
-        if (bio_data_dir(io->base_bio) == READ) {
-                crypt_inc_pending(io);
-                if (kcryptd_io_read(io, GFP_NOIO))
-                        io->error = -ENOMEM;
-                crypt_dec_pending(io);
-        } else
-                kcryptd_io_write(io);
-}
+        while (1) {
+                struct rb_root write_tree;
+                struct blk_plug plug;
 
-static void kcryptd_queue_io(struct dm_crypt_io *io)
-{
-        struct crypt_config *cc = io->cc;
+                DECLARE_WAITQUEUE(wait, current);
 
-        INIT_WORK(&io->work, kcryptd_io);
-        queue_work(cc->io_queue, &io->work);
+                spin_lock_irq(&cc->write_thread_wait.lock);
+continue_locked:
+
+                if (!RB_EMPTY_ROOT(&cc->write_tree))
+                        goto pop_from_list;
+
+                __set_current_state(TASK_INTERRUPTIBLE);
+                __add_wait_queue(&cc->write_thread_wait, &wait);
+
+                spin_unlock_irq(&cc->write_thread_wait.lock);
+
+                if (unlikely(kthread_should_stop())) {
+                        set_task_state(current, TASK_RUNNING);
+                        remove_wait_queue(&cc->write_thread_wait, &wait);
+                        break;
+                }
+
+                schedule();
+
+                set_task_state(current, TASK_RUNNING);
+                spin_lock_irq(&cc->write_thread_wait.lock);
+                __remove_wait_queue(&cc->write_thread_wait, &wait);
+                goto continue_locked;
+
+pop_from_list:
+                write_tree = cc->write_tree;
+                cc->write_tree = RB_ROOT;
+                spin_unlock_irq(&cc->write_thread_wait.lock);
+
+                BUG_ON(rb_parent(write_tree.rb_node));
+
+                /*
+                 * Note: we cannot walk the tree here with rb_next because
+                 * the structures may be freed when kcryptd_io_write is called.
+                 */
+                blk_start_plug(&plug);
+                do {
+                        io = crypt_io_from_node(rb_first(&write_tree));
+                        rb_erase(&io->rb_node, &write_tree);
+                        kcryptd_io_write(io);
+                } while (!RB_EMPTY_ROOT(&write_tree));
+                blk_finish_plug(&plug);
+        }
+        return 0;
 }
 
 static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int async)
 {
         struct bio *clone = io->ctx.bio_out;
         struct crypt_config *cc = io->cc;
+        unsigned long flags;
+        sector_t sector;
+        struct rb_node **rbp, *parent;
 
         if (unlikely(io->error < 0)) {
                 crypt_free_buffer_pages(cc, clone);
@@ -1182,20 +1249,34 @@ static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int async)
 
         clone->bi_iter.bi_sector = cc->start + io->sector;
 
-        if (async)
-                kcryptd_queue_io(io);
-        else
+        if (likely(!async) && test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags)) {
                 generic_make_request(clone);
+                return;
+        }
+
+        spin_lock_irqsave(&cc->write_thread_wait.lock, flags);
+        rbp = &cc->write_tree.rb_node;
+        parent = NULL;
+        sector = io->sector;
+        while (*rbp) {
+                parent = *rbp;
+                if (sector < crypt_io_from_node(parent)->sector)
+                        rbp = &(*rbp)->rb_left;
+                else
+                        rbp = &(*rbp)->rb_right;
+        }
+        rb_link_node(&io->rb_node, parent, rbp);
+        rb_insert_color(&io->rb_node, &cc->write_tree);
+
+        wake_up_locked(&cc->write_thread_wait);
+        spin_unlock_irqrestore(&cc->write_thread_wait.lock, flags);
 }
 
 static void kcryptd_crypt_write_convert(struct dm_crypt_io *io)
 {
         struct crypt_config *cc = io->cc;
         struct bio *clone;
-        struct dm_crypt_io *new_io;
         int crypt_finished;
-        unsigned out_of_pages = 0;
-        unsigned remaining = io->base_bio->bi_iter.bi_size;
         sector_t sector = io->sector;
         int r;
 
@@ -1205,80 +1286,30 @@ static void kcryptd_crypt_write_convert(struct dm_crypt_io *io)
         crypt_inc_pending(io);
         crypt_convert_init(cc, &io->ctx, NULL, io->base_bio, sector);
 
-        /*
-         * The allocated buffers can be smaller than the whole bio,
-         * so repeat the whole process until all the data can be handled.
-         */
-        while (remaining) {
-                clone = crypt_alloc_buffer(io, remaining, &out_of_pages);
-                if (unlikely(!clone)) {
-                        io->error = -ENOMEM;
-                        break;
-                }
-
-                io->ctx.bio_out = clone;
-                io->ctx.iter_out = clone->bi_iter;
-
-                remaining -= clone->bi_iter.bi_size;
-                sector += bio_sectors(clone);
-
-                crypt_inc_pending(io);
-
-                r = crypt_convert(cc, &io->ctx);
-                if (r < 0)
-                        io->error = -EIO;
-
-                crypt_finished = atomic_dec_and_test(&io->ctx.cc_pending);
-
-                /* Encryption was already finished, submit io now */
-                if (crypt_finished) {
-                        kcryptd_crypt_write_io_submit(io, 0);
-
-                        /*
-                         * If there was an error, do not try next fragments.
-                         * For async, error is processed in async handler.
-                         */
-                        if (unlikely(r < 0))
-                                break;
+        clone = crypt_alloc_buffer(io, io->base_bio->bi_iter.bi_size);
+        if (unlikely(!clone)) {
+                io->error = -EIO;
+                goto dec;
+        }
 
-                        io->sector = sector;
-                }
+        io->ctx.bio_out = clone;
+        io->ctx.iter_out = clone->bi_iter;
 
-                /*
-                 * Out of memory -> run queues
-                 * But don't wait if split was due to the io size restriction
-                 */
-                if (unlikely(out_of_pages))
-                        congestion_wait(BLK_RW_ASYNC, HZ/100);
+        sector += bio_sectors(clone);
 
-                /*
-                 * With async crypto it is unsafe to share the crypto context
-                 * between fragments, so switch to a new dm_crypt_io structure.
-                 */
-                if (unlikely(!crypt_finished && remaining)) {
-                        new_io = mempool_alloc(cc->io_pool, GFP_NOIO);
-                        crypt_io_init(new_io, io->cc, io->base_bio, sector);
-                        crypt_inc_pending(new_io);
-                        crypt_convert_init(cc, &new_io->ctx, NULL,
-                                           io->base_bio, sector);
-                        new_io->ctx.iter_in = io->ctx.iter_in;
-
-                        /*
-                         * Fragments after the first use the base_io
-                         * pending count.
-                         */
-                        if (!io->base_io)
-                                new_io->base_io = io;
-                        else {
-                                new_io->base_io = io->base_io;
-                                crypt_inc_pending(io->base_io);
-                                crypt_dec_pending(io);
-                        }
+        crypt_inc_pending(io);
+        r = crypt_convert(cc, &io->ctx);
+        if (r)
+                io->error = -EIO;
+        crypt_finished = atomic_dec_and_test(&io->ctx.cc_pending);
 
-                        io = new_io;
-                }
+        /* Encryption was already finished, submit io now */
+        if (crypt_finished) {
+                kcryptd_crypt_write_io_submit(io, 0);
+                io->sector = sector;
         }
 
+dec:
         crypt_dec_pending(io);
 }
 
@@ -1481,6 +1512,9 @@ static void crypt_dtr(struct dm_target *ti)
         if (!cc)
                 return;
 
+        if (cc->write_thread)
+                kthread_stop(cc->write_thread);
+
         if (cc->io_queue)
                 destroy_workqueue(cc->io_queue);
         if (cc->crypt_queue)
@@ -1495,8 +1529,6 @@ static void crypt_dtr(struct dm_target *ti)
                 mempool_destroy(cc->page_pool);
         if (cc->req_pool)
                 mempool_destroy(cc->req_pool);
-        if (cc->io_pool)
-                mempool_destroy(cc->io_pool);
 
         if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
                 cc->iv_gen_ops->dtr(cc);
@@ -1688,7 +1720,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         char dummy;
 
         static struct dm_arg _args[] = {
-                {0, 1, "Invalid number of feature args"},
+                {0, 3, "Invalid number of feature args"},
         };
 
         if (argc < 5) {
@@ -1710,13 +1742,6 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         if (ret < 0)
                 goto bad;
 
-        ret = -ENOMEM;
-        cc->io_pool = mempool_create_slab_pool(MIN_IOS, _crypt_io_pool);
-        if (!cc->io_pool) {
-                ti->error = "Cannot allocate crypt io mempool";
-                goto bad;
-        }
-
         cc->dmreq_start = sizeof(struct ablkcipher_request);
         cc->dmreq_start += crypto_ablkcipher_reqsize(any_tfm(cc));
         cc->dmreq_start = ALIGN(cc->dmreq_start, __alignof__(struct dm_crypt_request));
@@ -1734,6 +1759,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 iv_size_padding = crypto_ablkcipher_alignmask(any_tfm(cc));
         }
 
+        ret = -ENOMEM;
         cc->req_pool = mempool_create_kmalloc_pool(MIN_IOS, cc->dmreq_start +
                         sizeof(struct dm_crypt_request) + iv_size_padding + cc->iv_size);
         if (!cc->req_pool) {
@@ -1746,7 +1772,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                       sizeof(struct dm_crypt_request) + iv_size_padding + cc->iv_size,
                       ARCH_KMALLOC_MINALIGN);
 
-        cc->page_pool = mempool_create_page_pool(MIN_POOL_PAGES, 0);
+        cc->page_pool = mempool_create_page_pool(BIO_MAX_PAGES, 0);
         if (!cc->page_pool) {
                 ti->error = "Cannot allocate page mempool";
                 goto bad;
@@ -1758,6 +1784,8 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad;
         }
 
+        mutex_init(&cc->bio_alloc_lock);
+
         ret = -EINVAL;
         if (sscanf(argv[2], "%llu%c", &tmpll, &dummy) != 1) {
                 ti->error = "Invalid iv_offset sector";
@@ -1788,15 +1816,26 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 if (ret)
                         goto bad;
 
-                opt_string = dm_shift_arg(&as);
+                while (opt_params--) {
+                        opt_string = dm_shift_arg(&as);
+                        if (!opt_string) {
+                                ti->error = "Not enough feature arguments";
+                                goto bad;
+                        }
 
-                if (opt_params == 1 && opt_string &&
-                    !strcasecmp(opt_string, "allow_discards"))
-                        ti->num_discard_bios = 1;
-                else if (opt_params) {
-                        ret = -EINVAL;
-                        ti->error = "Invalid feature arguments";
-                        goto bad;
+                        if (!strcasecmp(opt_string, "allow_discards"))
+                                ti->num_discard_bios = 1;
+
+                        else if (!strcasecmp(opt_string, "same_cpu_crypt"))
+                                set_bit(DM_CRYPT_SAME_CPU, &cc->flags);
+
+                        else if (!strcasecmp(opt_string, "submit_from_crypt_cpus"))
+                                set_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags);
+
+                        else {
+                                ti->error = "Invalid feature arguments";
+                                goto bad;
+                        }
                 }
         }
 
@@ -1807,13 +1846,28 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad;
         }
 
-        cc->crypt_queue = alloc_workqueue("kcryptd",
-                                          WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM, 1);
+        if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags))
+                cc->crypt_queue = alloc_workqueue("kcryptd", WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM, 1);
+        else
+                cc->crypt_queue = alloc_workqueue("kcryptd", WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM | WQ_UNBOUND,
+                                                  num_online_cpus());
         if (!cc->crypt_queue) {
                 ti->error = "Couldn't create kcryptd queue";
                 goto bad;
         }
 
+        init_waitqueue_head(&cc->write_thread_wait);
+        cc->write_tree = RB_ROOT;
+
+        cc->write_thread = kthread_create(dmcrypt_write, cc, "dmcrypt_write");
+        if (IS_ERR(cc->write_thread)) {
+                ret = PTR_ERR(cc->write_thread);
+                cc->write_thread = NULL;
+                ti->error = "Couldn't spawn write thread";
+                goto bad;
+        }
+        wake_up_process(cc->write_thread);
+
         ti->num_flush_bios = 1;
         ti->discard_zeroes_data_unsupported = true;
 
@@ -1848,7 +1902,7 @@ static int crypt_map(struct dm_target *ti, struct bio *bio)
 
         if (bio_data_dir(io->base_bio) == READ) {
                 if (kcryptd_io_read(io, GFP_NOWAIT))
-                        kcryptd_queue_io(io);
+                        kcryptd_queue_read(io);
         } else
                 kcryptd_queue_crypt(io);
 
@@ -1860,6 +1914,7 @@ static void crypt_status(struct dm_target *ti, status_type_t type,
 {
         struct crypt_config *cc = ti->private;
         unsigned i, sz = 0;
+        int num_feature_args = 0;
 
         switch (type) {
         case STATUSTYPE_INFO:
@@ -1878,8 +1933,18 @@ static void crypt_status(struct dm_target *ti, status_type_t type,
                 DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
                                 cc->dev->name, (unsigned long long)cc->start);
 
-                if (ti->num_discard_bios)
-                        DMEMIT(" 1 allow_discards");
+                num_feature_args += !!ti->num_discard_bios;
+                num_feature_args += test_bit(DM_CRYPT_SAME_CPU, &cc->flags);
+                num_feature_args += test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags);
+                if (num_feature_args) {
+                        DMEMIT(" %d", num_feature_args);
+                        if (ti->num_discard_bios)
+                                DMEMIT(" allow_discards");
+                        if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags))
+                                DMEMIT(" same_cpu_crypt");
+                        if (test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags))
+                                DMEMIT(" submit_from_crypt_cpus");
+                }
 
                 break;
         }
@@ -1976,7 +2041,7 @@ static int crypt_iterate_devices(struct dm_target *ti,
 
 static struct target_type crypt_target = {
         .name   = "crypt",
-        .version = {1, 13, 0},
+        .version = {1, 14, 0},
         .module = THIS_MODULE,
         .ctr    = crypt_ctr,
         .dtr    = crypt_dtr,
@@ -1994,15 +2059,9 @@ static int __init dm_crypt_init(void)
 {
         int r;
 
-        _crypt_io_pool = KMEM_CACHE(dm_crypt_io, 0);
-        if (!_crypt_io_pool)
-                return -ENOMEM;
-
         r = dm_register_target(&crypt_target);
-        if (r < 0) {
+        if (r < 0)
                 DMERR("register failed %d", r);
-                kmem_cache_destroy(_crypt_io_pool);
-        }
 
         return r;
 }
@@ -2010,7 +2069,6 @@ static int __init dm_crypt_init(void)
 static void __exit dm_crypt_exit(void)
 {
         dm_unregister_target(&crypt_target);
-        kmem_cache_destroy(_crypt_io_pool);
 }
 
 module_init(dm_crypt_init);
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index c09359db3a90..37de0173b6d2 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -290,6 +290,12 @@ static void do_region(int rw, unsigned region, struct dm_io_region *where,
         unsigned short logical_block_size = queue_logical_block_size(q);
         sector_t num_sectors;
 
+        /* Reject unsupported discard requests */
+        if ((rw & REQ_DISCARD) && !blk_queue_discard(q)) {
+                dec_count(io, region, -EOPNOTSUPP);
+                return;
+        }
+
         /*
          * where->count may be zero if rw holds a flush and we need to
          * send a zero-sized flush.
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 7dfdb5c746d6..089d62751f7f 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -604,6 +604,15 @@ static void write_callback(unsigned long error, void *context)
                 return;
         }
 
+        /*
+         * If the bio is discard, return an error, but do not
+         * degrade the array.
+         */
+        if (bio->bi_rw & REQ_DISCARD) {
+                bio_endio(bio, -EOPNOTSUPP);
+                return;
+        }
+
         for (i = 0; i < ms->nr_mirrors; i++)
                 if (test_bit(i, &error))
                         fail_mirror(ms->mirror + i, DM_RAID1_WRITE_ERROR);
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 864b03f47727..8b204ae216ab 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -1432,8 +1432,6 @@ out:
                 full_bio->bi_private = pe->full_bio_private;
                 atomic_inc(&full_bio->bi_remaining);
         }
-        free_pending_exception(pe);
-
         increment_pending_exceptions_done_count();
 
         up_write(&s->lock);
@@ -1450,6 +1448,8 @@ out:
         }
 
         retry_origin_bios(s, origin_bios);
+
+        free_pending_exception(pe);
 }
 
 static void commit_callback(void *context, int success)
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index ec1444f49de1..73f28802dc7a 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -2571,7 +2571,7 @@ int dm_setup_md_queue(struct mapped_device *md)
         return 0;
 }
 
-static struct mapped_device *dm_find_md(dev_t dev)
+struct mapped_device *dm_get_md(dev_t dev)
 {
         struct mapped_device *md;
         unsigned minor = MINOR(dev);
@@ -2582,12 +2582,15 @@ static struct mapped_device *dm_find_md(dev_t dev)
         spin_lock(&_minor_lock);
 
         md = idr_find(&_minor_idr, minor);
-        if (md && (md == MINOR_ALLOCED ||
-                   (MINOR(disk_devt(dm_disk(md))) != minor) ||
-                   dm_deleting_md(md) ||
-                   test_bit(DMF_FREEING, &md->flags))) {
-                md = NULL;
-                goto out;
+        if (md) {
+                if ((md == MINOR_ALLOCED ||
+                     (MINOR(disk_devt(dm_disk(md))) != minor) ||
+                     dm_deleting_md(md) ||
+                     test_bit(DMF_FREEING, &md->flags))) {
+                        md = NULL;
+                        goto out;
+                }
+                dm_get(md);
         }
 
 out:
@@ -2595,16 +2598,6 @@ out:
 
         return md;
 }
-
-struct mapped_device *dm_get_md(dev_t dev)
-{
-        struct mapped_device *md = dm_find_md(dev);
-
-        if (md)
-                dm_get(md);
-
-        return md;
-}
 EXPORT_SYMBOL_GPL(dm_get_md);
 
 void *dm_get_mdptr(struct mapped_device *md)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index c8d2bac4e28b..cadf9cc02b25 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2555,7 +2555,7 @@ state_store(struct md_rdev *rdev, const char *buf, size_t len)
         return err ? err : len;
 }
 static struct rdev_sysfs_entry rdev_state =
-__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
+__ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
 
 static ssize_t
 errors_show(struct md_rdev *rdev, char *page)
@@ -3638,7 +3638,8 @@ resync_start_store(struct mddev *mddev, const char *buf, size_t len)
         return err ?: len;
 }
 static struct md_sysfs_entry md_resync_start =
-__ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
+__ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
+                resync_start_show, resync_start_store);
 
 /*
  * The array state can be:
@@ -3851,7 +3852,7 @@ array_state_store(struct mddev *mddev, const char *buf, size_t len)
         return err ?: len;
 }
 static struct md_sysfs_entry md_array_state =
-__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
+__ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
 
 static ssize_t
 max_corrected_read_errors_show(struct mddev *mddev, char *page) {
@@ -4101,7 +4102,7 @@ out_unlock:
 }
 
 static struct md_sysfs_entry md_metadata =
-__ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
+__ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
 
 static ssize_t
 action_show(struct mddev *mddev, char *page)
@@ -4189,7 +4190,7 @@ action_store(struct mddev *mddev, const char *page, size_t len)
 }
 
 static struct md_sysfs_entry md_scan_mode =
-__ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
+__ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
 
 static ssize_t
 last_sync_action_show(struct mddev *mddev, char *page)
@@ -4335,7 +4336,8 @@ sync_completed_show(struct mddev *mddev, char *page)
         return sprintf(page, "%llu / %llu\n", resync, max_sectors);
 }
 
-static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
+static struct md_sysfs_entry md_sync_completed =
+        __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
 
 static ssize_t
 min_sync_show(struct mddev *mddev, char *page)
diff --git a/drivers/md/persistent-data/Kconfig b/drivers/md/persistent-data/Kconfig
index 0c2dec7aec20..78c74bb71ba4 100644
--- a/drivers/md/persistent-data/Kconfig
+++ b/drivers/md/persistent-data/Kconfig
@@ -8,7 +8,7 @@ config DM_PERSISTENT_DATA
          device-mapper targets such as the thin provisioning target.
 
 config DM_DEBUG_BLOCK_STACK_TRACING
-       boolean "Keep stack trace of persistent data block lock holders"
+       bool "Keep stack trace of persistent data block lock holders"
        depends on STACKTRACE_SUPPORT && DM_PERSISTENT_DATA
        select STACKTRACE
        ---help---
diff --git a/drivers/md/persistent-data/dm-space-map-disk.c b/drivers/md/persistent-data/dm-space-map-disk.c
index cfbf9617e465..ebb280a14325 100644
--- a/drivers/md/persistent-data/dm-space-map-disk.c
+++ b/drivers/md/persistent-data/dm-space-map-disk.c
@@ -78,7 +78,9 @@ static int sm_disk_count_is_more_than_one(struct dm_space_map *sm, dm_block_t b,
         if (r)
                 return r;
 
-        return count > 1;
+        *result = count > 1;
+
+        return 0;
 }
 
 static int sm_disk_set_count(struct dm_space_map *sm, dm_block_t b,
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 4153da5d4011..d34e238afa54 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -560,7 +560,7 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect
                 if (test_bit(WriteMostly, &rdev->flags)) {
                         /* Don't balance among write-mostly, just
                          * use the first as a last resort */
-                        if (best_disk < 0) {
+                        if (best_dist_disk < 0) {
                                 if (is_badblock(rdev, this_sector, sectors,
                                                 &first_bad, &bad_sectors)) {
                                         if (first_bad < this_sector)
@@ -569,7 +569,8 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect
                                         best_good_sectors = first_bad - this_sector;
                                 } else
                                         best_good_sectors = sectors;
-                                best_disk = disk;
+                                best_dist_disk = disk;
+                                best_pending_disk = disk;
                         }
                         continue;
                 }
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index e75d48c0421a..cd2f96b2c572 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -5121,12 +5121,17 @@ static inline sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int
                 schedule_timeout_uninterruptible(1);
         }
         /* Need to check if array will still be degraded after recovery/resync
-         * We don't need to check the 'failed' flag as when that gets set,
-         * recovery aborts.
+         * Note in case of > 1 drive failures it's possible we're rebuilding
+         * one drive while leaving another faulty drive in array.
          */
-        for (i = 0; i < conf->raid_disks; i++)
-                if (conf->disks[i].rdev == NULL)
+        rcu_read_lock();
+        for (i = 0; i < conf->raid_disks; i++) {
+                struct md_rdev *rdev = ACCESS_ONCE(conf->disks[i].rdev);
+
+                if (rdev == NULL || test_bit(Faulty, &rdev->flags))
                         still_degraded = 1;
+        }
+        rcu_read_unlock();
 
         bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, still_degraded);
 
diff --git a/drivers/mfd/88pm860x-core.c b/drivers/mfd/88pm860x-core.c
index 3a2604580164..d2a85cde68da 100644
--- a/drivers/mfd/88pm860x-core.c
+++ b/drivers/mfd/88pm860x-core.c
@@ -1111,7 +1111,7 @@ static int verify_addr(struct i2c_client *i2c)
         return 0;
 }
 
-static struct regmap_config pm860x_regmap_config = {
+static const struct regmap_config pm860x_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 };
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 2e6b7311fabc..38356e39adba 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -195,6 +195,18 @@ config MFD_DA9063
           Additional drivers must be enabled in order to use the functionality
           of the device.
 
+config MFD_DA9150
+        tristate "Dialog Semiconductor DA9150 Charger Fuel-Gauge chip"
+        depends on I2C=y
+        select MFD_CORE
+        select REGMAP_I2C
+        select REGMAP_IRQ
+        help
+          This adds support for the DA9150 integrated charger and fuel-gauge
+          chip. This driver provides common support for accessing the device.
+          Additional drivers must be enabled in order to use the specific
+          features of the device.
+
 config MFD_DLN2
         tristate "Diolan DLN2 support"
         select MFD_CORE
@@ -417,6 +429,7 @@ config MFD_MAX14577
 config MFD_MAX77686
         bool "Maxim Semiconductor MAX77686/802 PMIC Support"
         depends on I2C=y
+        depends on OF
         select MFD_CORE
         select REGMAP_I2C
         select REGMAP_IRQ
@@ -589,6 +602,20 @@ config MFD_PM8921_CORE
           Say M here if you want to include support for PM8921 chip as a module.
           This will build a module called "pm8921-core".
 
+config MFD_QCOM_RPM
+        tristate "Qualcomm Resource Power Manager (RPM)"
+        depends on ARCH_QCOM && OF
+        help
+          If you say yes to this option, support will be included for the
+          Resource Power Manager system found in the Qualcomm 8660, 8960 and
+          8064 based devices.
+
+          This is required to access many regulators, clocks and bus
+          frequencies controlled by the RPM on these devices.
+
+          Say M here if you want to include support for the Qualcomm RPM as a
+          module. This will build a module called "qcom_rpm".
+
 config MFD_SPMI_PMIC
         tristate "Qualcomm SPMI PMICs"
         depends on ARCH_QCOM || COMPILE_TEST
@@ -623,6 +650,18 @@ config MFD_RTSX_PCI
           types of memory cards, such as Memory Stick, Memory Stick Pro,
           Secure Digital and MultiMediaCard.
 
+config MFD_RT5033
+        tristate "Richtek RT5033 Power Management IC"
+        depends on I2C=y
+        select MFD_CORE
+        select REGMAP_I2C
+        help
+          This driver provides for the Richtek RT5033 Power Management IC,
+          which includes the I2C driver and the Core APIs. This driver provides
+          common support for accessing the device. The device supports multiple
+          sub-devices like charger, fuel gauge, flash LED, current source,
+          LDO and Buck.
+
 config MFD_RTSX_USB
         tristate "Realtek USB card reader"
         depends on USB
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 53467e211381..19f3d744e3bd 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -113,7 +113,7 @@ obj-$(CONFIG_MFD_DA9055)	+= da9055.o
 
 da9063-objs                     := da9063-core.o da9063-irq.o da9063-i2c.o
 obj-$(CONFIG_MFD_DA9063)        += da9063.o
-
+obj-$(CONFIG_MFD_DA9150)        += da9150-core.o
 obj-$(CONFIG_MFD_MAX14577)      += max14577.o
 obj-$(CONFIG_MFD_MAX77686)      += max77686.o
 obj-$(CONFIG_MFD_MAX77693)      += max77693.o
@@ -153,6 +153,7 @@ obj-$(CONFIG_MFD_SI476X_CORE)	+= si476x-core.o
 obj-$(CONFIG_MFD_CS5535)        += cs5535-mfd.o
 obj-$(CONFIG_MFD_OMAP_USB_HOST) += omap-usb-host.o omap-usb-tll.o
 obj-$(CONFIG_MFD_PM8921_CORE)   += pm8921-core.o ssbi.o
+obj-$(CONFIG_MFD_QCOM_RPM)      += qcom_rpm.o
 obj-$(CONFIG_MFD_SPMI_PMIC)     += qcom-spmi-pmic.o
 obj-$(CONFIG_TPS65911_COMPARATOR)       += tps65911-comparator.o
 obj-$(CONFIG_MFD_TPS65090)      += tps65090.o
@@ -176,6 +177,7 @@ 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
+obj-$(CONFIG_MFD_RT5033)        += rt5033.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/da9063-core.c b/drivers/mfd/da9063-core.c
index f38bc98a3c57..facd3610ac77 100644
--- a/drivers/mfd/da9063-core.c
+++ b/drivers/mfd/da9063-core.c
@@ -86,6 +86,7 @@ static const struct mfd_cell da9063_devs[] = {
         },
         {
                 .name           = DA9063_DRVNAME_WATCHDOG,
+                .of_compatible  = "dlg,da9063-watchdog",
         },
         {
                 .name           = DA9063_DRVNAME_HWMON,
@@ -101,6 +102,7 @@ static const struct mfd_cell da9063_devs[] = {
                 .name           = DA9063_DRVNAME_RTC,
                 .num_resources  = ARRAY_SIZE(da9063_rtc_resources),
                 .resources      = da9063_rtc_resources,
+                .of_compatible  = "dlg,da9063-rtc",
         },
         {
                 .name           = DA9063_DRVNAME_VIBRATION,
diff --git a/drivers/mfd/da9063-i2c.c b/drivers/mfd/da9063-i2c.c
index 21fd8d9a217b..6f3a7c0001f9 100644
--- a/drivers/mfd/da9063-i2c.c
+++ b/drivers/mfd/da9063-i2c.c
@@ -25,6 +25,9 @@
 #include <linux/mfd/da9063/pdata.h>
 #include <linux/mfd/da9063/registers.h>
 
+#include <linux/of.h>
+#include <linux/regulator/of_regulator.h>
+
 static const struct regmap_range da9063_ad_readable_ranges[] = {
         {
                 .range_min = DA9063_REG_PAGE_CON,
@@ -203,6 +206,11 @@ static struct regmap_config da9063_regmap_config = {
         .cache_type = REGCACHE_RBTREE,
 };
 
+static const struct of_device_id da9063_dt_ids[] = {
+        { .compatible = "dlg,da9063", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, da9063_dt_ids);
 static int da9063_i2c_probe(struct i2c_client *i2c,
         const struct i2c_device_id *id)
 {
@@ -257,6 +265,7 @@ static struct i2c_driver da9063_i2c_driver = {
         .driver = {
                 .name = "da9063",
                 .owner = THIS_MODULE,
+                .of_match_table = of_match_ptr(da9063_dt_ids),
         },
         .probe    = da9063_i2c_probe,
         .remove   = da9063_i2c_remove,
diff --git a/drivers/mfd/da9150-core.c b/drivers/mfd/da9150-core.c
new file mode 100644
index 000000000000..4d757b97ef9a
--- /dev/null
+++ b/drivers/mfd/da9150-core.c
@@ -0,0 +1,413 @@
+/*
+ * DA9150 Core MFD Driver
+ *
+ * Copyright (c) 2014 Dialog Semiconductor
+ *
+ * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.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/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/da9150/core.h>
+#include <linux/mfd/da9150/registers.h>
+
+static bool da9150_volatile_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case DA9150_PAGE_CON:
+        case DA9150_STATUS_A:
+        case DA9150_STATUS_B:
+        case DA9150_STATUS_C:
+        case DA9150_STATUS_D:
+        case DA9150_STATUS_E:
+        case DA9150_STATUS_F:
+        case DA9150_STATUS_G:
+        case DA9150_STATUS_H:
+        case DA9150_STATUS_I:
+        case DA9150_STATUS_J:
+        case DA9150_STATUS_K:
+        case DA9150_STATUS_L:
+        case DA9150_STATUS_N:
+        case DA9150_FAULT_LOG_A:
+        case DA9150_FAULT_LOG_B:
+        case DA9150_EVENT_E:
+        case DA9150_EVENT_F:
+        case DA9150_EVENT_G:
+        case DA9150_EVENT_H:
+        case DA9150_CONTROL_B:
+        case DA9150_CONTROL_C:
+        case DA9150_GPADC_MAN:
+        case DA9150_GPADC_RES_A:
+        case DA9150_GPADC_RES_B:
+        case DA9150_ADETVB_CFG_C:
+        case DA9150_ADETD_STAT:
+        case DA9150_ADET_CMPSTAT:
+        case DA9150_ADET_CTRL_A:
+        case DA9150_PPR_TCTR_B:
+        case DA9150_COREBTLD_STAT_A:
+        case DA9150_CORE_DATA_A:
+        case DA9150_CORE_DATA_B:
+        case DA9150_CORE_DATA_C:
+        case DA9150_CORE_DATA_D:
+        case DA9150_CORE2WIRE_STAT_A:
+        case DA9150_FW_CTRL_C:
+        case DA9150_FG_CTRL_B:
+        case DA9150_FW_CTRL_B:
+        case DA9150_GPADC_CMAN:
+        case DA9150_GPADC_CRES_A:
+        case DA9150_GPADC_CRES_B:
+        case DA9150_CC_ICHG_RES_A:
+        case DA9150_CC_ICHG_RES_B:
+        case DA9150_CC_IAVG_RES_A:
+        case DA9150_CC_IAVG_RES_B:
+        case DA9150_TAUX_CTRL_A:
+        case DA9150_TAUX_VALUE_H:
+        case DA9150_TAUX_VALUE_L:
+        case DA9150_TBAT_RES_A:
+        case DA9150_TBAT_RES_B:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static const struct regmap_range_cfg da9150_range_cfg[] = {
+        {
+                .range_min = DA9150_PAGE_CON,
+                .range_max = DA9150_TBAT_RES_B,
+                .selector_reg = DA9150_PAGE_CON,
+                .selector_mask = DA9150_I2C_PAGE_MASK,
+                .selector_shift = DA9150_I2C_PAGE_SHIFT,
+                .window_start = 0,
+                .window_len = 256,
+        },
+};
+
+static struct regmap_config da9150_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .ranges = da9150_range_cfg,
+        .num_ranges = ARRAY_SIZE(da9150_range_cfg),
+        .max_register = DA9150_TBAT_RES_B,
+
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = da9150_volatile_reg,
+};
+
+u8 da9150_reg_read(struct da9150 *da9150, u16 reg)
+{
+        int val, ret;
+
+        ret = regmap_read(da9150->regmap, reg, &val);
+        if (ret)
+                dev_err(da9150->dev, "Failed to read from reg 0x%x: %d\n",
+                        reg, ret);
+
+        return (u8) val;
+}
+EXPORT_SYMBOL_GPL(da9150_reg_read);
+
+void da9150_reg_write(struct da9150 *da9150, u16 reg, u8 val)
+{
+        int ret;
+
+        ret = regmap_write(da9150->regmap, reg, val);
+        if (ret)
+                dev_err(da9150->dev, "Failed to write to reg 0x%x: %d\n",
+                        reg, ret);
+}
+EXPORT_SYMBOL_GPL(da9150_reg_write);
+
+void da9150_set_bits(struct da9150 *da9150, u16 reg, u8 mask, u8 val)
+{
+        int ret;
+
+        ret = regmap_update_bits(da9150->regmap, reg, mask, val);
+        if (ret)
+                dev_err(da9150->dev, "Failed to set bits in reg 0x%x: %d\n",
+                        reg, ret);
+}
+EXPORT_SYMBOL_GPL(da9150_set_bits);
+
+void da9150_bulk_read(struct da9150 *da9150, u16 reg, int count, u8 *buf)
+{
+        int ret;
+
+        ret = regmap_bulk_read(da9150->regmap, reg, buf, count);
+        if (ret)
+                dev_err(da9150->dev, "Failed to bulk read from reg 0x%x: %d\n",
+                        reg, ret);
+}
+EXPORT_SYMBOL_GPL(da9150_bulk_read);
+
+void da9150_bulk_write(struct da9150 *da9150, u16 reg, int count, const u8 *buf)
+{
+        int ret;
+
+        ret = regmap_raw_write(da9150->regmap, reg, buf, count);
+        if (ret)
+                dev_err(da9150->dev, "Failed to bulk write to reg 0x%x %d\n",
+                        reg, ret);
+}
+EXPORT_SYMBOL_GPL(da9150_bulk_write);
+
+static struct regmap_irq da9150_irqs[] = {
+        [DA9150_IRQ_VBUS] = {
+                .reg_offset = 0,
+                .mask = DA9150_E_VBUS_MASK,
+        },
+        [DA9150_IRQ_CHG] = {
+                .reg_offset = 0,
+                .mask = DA9150_E_CHG_MASK,
+        },
+        [DA9150_IRQ_TCLASS] = {
+                .reg_offset = 0,
+                .mask = DA9150_E_TCLASS_MASK,
+        },
+        [DA9150_IRQ_TJUNC] = {
+                .reg_offset = 0,
+                .mask = DA9150_E_TJUNC_MASK,
+        },
+        [DA9150_IRQ_VFAULT] = {
+                .reg_offset = 0,
+                .mask = DA9150_E_VFAULT_MASK,
+        },
+        [DA9150_IRQ_CONF] = {
+                .reg_offset = 1,
+                .mask = DA9150_E_CONF_MASK,
+        },
+        [DA9150_IRQ_DAT] = {
+                .reg_offset = 1,
+                .mask = DA9150_E_DAT_MASK,
+        },
+        [DA9150_IRQ_DTYPE] = {
+                .reg_offset = 1,
+                .mask = DA9150_E_DTYPE_MASK,
+        },
+        [DA9150_IRQ_ID] = {
+                .reg_offset = 1,
+                .mask = DA9150_E_ID_MASK,
+        },
+        [DA9150_IRQ_ADP] = {
+                .reg_offset = 1,
+                .mask = DA9150_E_ADP_MASK,
+        },
+        [DA9150_IRQ_SESS_END] = {
+                .reg_offset = 1,
+                .mask = DA9150_E_SESS_END_MASK,
+        },
+        [DA9150_IRQ_SESS_VLD] = {
+                .reg_offset = 1,
+                .mask = DA9150_E_SESS_VLD_MASK,
+        },
+        [DA9150_IRQ_FG] = {
+                .reg_offset = 2,
+                .mask = DA9150_E_FG_MASK,
+        },
+        [DA9150_IRQ_GP] = {
+                .reg_offset = 2,
+                .mask = DA9150_E_GP_MASK,
+        },
+        [DA9150_IRQ_TBAT] = {
+                .reg_offset = 2,
+                .mask = DA9150_E_TBAT_MASK,
+        },
+        [DA9150_IRQ_GPIOA] = {
+                .reg_offset = 2,
+                .mask = DA9150_E_GPIOA_MASK,
+        },
+        [DA9150_IRQ_GPIOB] = {
+                .reg_offset = 2,
+                .mask = DA9150_E_GPIOB_MASK,
+        },
+        [DA9150_IRQ_GPIOC] = {
+                .reg_offset = 2,
+                .mask = DA9150_E_GPIOC_MASK,
+        },
+        [DA9150_IRQ_GPIOD] = {
+                .reg_offset = 2,
+                .mask = DA9150_E_GPIOD_MASK,
+        },
+        [DA9150_IRQ_GPADC] = {
+                .reg_offset = 2,
+                .mask = DA9150_E_GPADC_MASK,
+        },
+        [DA9150_IRQ_WKUP] = {
+                .reg_offset = 3,
+                .mask = DA9150_E_WKUP_MASK,
+        },
+};
+
+static struct regmap_irq_chip da9150_regmap_irq_chip = {
+        .name = "da9150_irq",
+        .status_base = DA9150_EVENT_E,
+        .mask_base = DA9150_IRQ_MASK_E,
+        .ack_base = DA9150_EVENT_E,
+        .num_regs = DA9150_NUM_IRQ_REGS,
+        .irqs = da9150_irqs,
+        .num_irqs = ARRAY_SIZE(da9150_irqs),
+};
+
+static struct resource da9150_gpadc_resources[] = {
+        {
+                .name = "GPADC",
+                .start = DA9150_IRQ_GPADC,
+                .end = DA9150_IRQ_GPADC,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource da9150_charger_resources[] = {
+        {
+                .name = "CHG_STATUS",
+                .start = DA9150_IRQ_CHG,
+                .end = DA9150_IRQ_CHG,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "CHG_TJUNC",
+                .start = DA9150_IRQ_TJUNC,
+                .end = DA9150_IRQ_TJUNC,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "CHG_VFAULT",
+                .start = DA9150_IRQ_VFAULT,
+                .end = DA9150_IRQ_VFAULT,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "CHG_VBUS",
+                .start = DA9150_IRQ_VBUS,
+                .end = DA9150_IRQ_VBUS,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct mfd_cell da9150_devs[] = {
+        {
+                .name = "da9150-gpadc",
+                .of_compatible = "dlg,da9150-gpadc",
+                .resources = da9150_gpadc_resources,
+                .num_resources = ARRAY_SIZE(da9150_gpadc_resources),
+        },
+        {
+                .name = "da9150-charger",
+                .of_compatible = "dlg,da9150-charger",
+                .resources = da9150_charger_resources,
+                .num_resources = ARRAY_SIZE(da9150_charger_resources),
+        },
+};
+
+static int da9150_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct da9150 *da9150;
+        struct da9150_pdata *pdata = dev_get_platdata(&client->dev);
+        int ret;
+
+        da9150 = devm_kzalloc(&client->dev, sizeof(*da9150), GFP_KERNEL);
+        if (!da9150)
+                return -ENOMEM;
+
+        da9150->dev = &client->dev;
+        da9150->irq = client->irq;
+        i2c_set_clientdata(client, da9150);
+
+        da9150->regmap = devm_regmap_init_i2c(client, &da9150_regmap_config);
+        if (IS_ERR(da9150->regmap)) {
+                ret = PTR_ERR(da9150->regmap);
+                dev_err(da9150->dev, "Failed to allocate register map: %d\n",
+                        ret);
+                return ret;
+        }
+
+        da9150->irq_base = pdata ? pdata->irq_base : -1;
+
+        ret = regmap_add_irq_chip(da9150->regmap, da9150->irq,
+                                  IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                  da9150->irq_base, &da9150_regmap_irq_chip,
+                                  &da9150->regmap_irq_data);
+        if (ret)
+                return ret;
+
+        da9150->irq_base = regmap_irq_chip_get_base(da9150->regmap_irq_data);
+        enable_irq_wake(da9150->irq);
+
+        ret = mfd_add_devices(da9150->dev, -1, da9150_devs,
+                              ARRAY_SIZE(da9150_devs), NULL,
+                              da9150->irq_base, NULL);
+        if (ret) {
+                dev_err(da9150->dev, "Failed to add child devices: %d\n", ret);
+                regmap_del_irq_chip(da9150->irq, da9150->regmap_irq_data);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int da9150_remove(struct i2c_client *client)
+{
+        struct da9150 *da9150 = i2c_get_clientdata(client);
+
+        regmap_del_irq_chip(da9150->irq, da9150->regmap_irq_data);
+        mfd_remove_devices(da9150->dev);
+
+        return 0;
+}
+
+static void da9150_shutdown(struct i2c_client *client)
+{
+        struct da9150 *da9150 = i2c_get_clientdata(client);
+
+        /* Make sure we have a wakup source for the device */
+        da9150_set_bits(da9150, DA9150_CONFIG_D,
+                        DA9150_WKUP_PM_EN_MASK,
+                        DA9150_WKUP_PM_EN_MASK);
+
+        /* Set device to DISABLED mode */
+        da9150_set_bits(da9150, DA9150_CONTROL_C,
+                        DA9150_DISABLE_MASK, DA9150_DISABLE_MASK);
+}
+
+static const struct i2c_device_id da9150_i2c_id[] = {
+        { "da9150", },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, da9150_i2c_id);
+
+static const struct of_device_id da9150_of_match[] = {
+        { .compatible = "dlg,da9150", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, da9150_of_match);
+
+static struct i2c_driver da9150_driver = {
+        .driver = {
+                .name   = "da9150",
+                .of_match_table = of_match_ptr(da9150_of_match),
+        },
+        .probe          = da9150_probe,
+        .remove         = da9150_remove,
+        .shutdown       = da9150_shutdown,
+        .id_table       = da9150_i2c_id,
+};
+
+module_i2c_driver(da9150_driver);
+
+MODULE_DESCRIPTION("MFD Core Driver for DA9150");
+MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/davinci_voicecodec.c b/drivers/mfd/davinci_voicecodec.c
index c835e85539b2..9bbc642a7b9d 100644
--- a/drivers/mfd/davinci_voicecodec.c
+++ b/drivers/mfd/davinci_voicecodec.c
@@ -33,7 +33,7 @@
 
 #include <linux/mfd/davinci_voicecodec.h>
 
-static struct regmap_config davinci_vc_regmap = {
+static const struct regmap_config davinci_vc_regmap = {
         .reg_bits = 32,
         .val_bits = 32,
 };
diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index 16162bf43656..cc1a404328c2 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -675,15 +675,6 @@ bool prcmu_has_arm_maxopp(void)
 }
 
 /**
- * prcmu_get_boot_status - PRCMU boot status checking
- * Returns: the current PRCMU boot status
- */
-int prcmu_get_boot_status(void)
-{
-        return readb(tcdm_base + PRCM_BOOT_STATUS);
-}
-
-/**
  * prcmu_set_rc_a2p - This function is used to run few power state sequences
  * @val: Value to be set, i.e. transition requested
  * Returns: 0 on success, -EINVAL on invalid argument
diff --git a/drivers/mfd/dln2.c b/drivers/mfd/dln2.c
index 6d49685d4ee4..1be9bd1c046d 100644
--- a/drivers/mfd/dln2.c
+++ b/drivers/mfd/dln2.c
@@ -587,12 +587,19 @@ 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_stop_rx_urbs(struct dln2_dev *dln2)
+{
+        int i;
+
+        for (i = 0; i < DLN2_MAX_URBS; i++)
+                usb_kill_urb(dln2->rx_urb[i]);
+}
+
 static void dln2_free(struct dln2_dev *dln2)
 {
         dln2_free_rx_urbs(dln2);
@@ -604,9 +611,7 @@ 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);
@@ -620,8 +625,19 @@ static int dln2_setup_rx_urbs(struct dln2_dev *dln2,
                 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);
+        return 0;
+}
+
+static int dln2_start_rx_urbs(struct dln2_dev *dln2, gfp_t gfp)
+{
+        struct device *dev = &dln2->interface->dev;
+        int ret;
+        int i;
+
+        for (i = 0; i < DLN2_MAX_URBS; i++) {
+                ret = usb_submit_urb(dln2->rx_urb[i], gfp);
                 if (ret < 0) {
                         dev_err(dev, "failed to submit RX URB: %d\n", ret);
                         return ret;
@@ -665,9 +681,8 @@ static const struct mfd_cell dln2_devs[] = {
         },
 };
 
-static void dln2_disconnect(struct usb_interface *interface)
+static void dln2_stop(struct dln2_dev *dln2)
 {
-        struct dln2_dev *dln2 = usb_get_intfdata(interface);
         int i, j;
 
         /* don't allow starting new transfers */
@@ -696,6 +711,15 @@ static void dln2_disconnect(struct usb_interface *interface)
         /* wait for transfers to end */
         wait_event(dln2->disconnect_wq, !dln2->active_transfers);
 
+        dln2_stop_rx_urbs(dln2);
+}
+
+static void dln2_disconnect(struct usb_interface *interface)
+{
+        struct dln2_dev *dln2 = usb_get_intfdata(interface);
+
+        dln2_stop(dln2);
+
         mfd_remove_devices(&interface->dev);
 
         dln2_free(dln2);
@@ -738,28 +762,53 @@ static int dln2_probe(struct usb_interface *interface,
 
         ret = dln2_setup_rx_urbs(dln2, hostif);
         if (ret)
-                goto out_cleanup;
+                goto out_free;
+
+        ret = dln2_start_rx_urbs(dln2, GFP_KERNEL);
+        if (ret)
+                goto out_stop_rx;
 
         ret = dln2_hw_init(dln2);
         if (ret < 0) {
                 dev_err(dev, "failed to initialize hardware\n");
-                goto out_cleanup;
+                goto out_stop_rx;
         }
 
         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;
+                goto out_stop_rx;
         }
 
         return 0;
 
-out_cleanup:
+out_stop_rx:
+        dln2_stop_rx_urbs(dln2);
+
+out_free:
         dln2_free(dln2);
 
         return ret;
 }
 
+static int dln2_suspend(struct usb_interface *iface, pm_message_t message)
+{
+        struct dln2_dev *dln2 = usb_get_intfdata(iface);
+
+        dln2_stop(dln2);
+
+        return 0;
+}
+
+static int dln2_resume(struct usb_interface *iface)
+{
+        struct dln2_dev *dln2 = usb_get_intfdata(iface);
+
+        dln2->disconnect = false;
+
+        return dln2_start_rx_urbs(dln2, GFP_NOIO);
+}
+
 static const struct usb_device_id dln2_table[] = {
         { USB_DEVICE(0xa257, 0x2013) },
         { }
@@ -772,6 +821,8 @@ static struct usb_driver dln2_driver = {
         .probe = dln2_probe,
         .disconnect = dln2_disconnect,
         .id_table = dln2_table,
+        .suspend = dln2_suspend,
+        .resume = dln2_resume,
 };
 
 module_usb_driver(dln2_driver);
diff --git a/drivers/mfd/hi6421-pmic-core.c b/drivers/mfd/hi6421-pmic-core.c
index 321a2656fd00..7210ae28bf81 100644
--- a/drivers/mfd/hi6421-pmic-core.c
+++ b/drivers/mfd/hi6421-pmic-core.c
@@ -35,7 +35,7 @@ static const struct mfd_cell hi6421_devs[] = {
         { .name = "hi6421-regulator", },
 };
 
-static struct regmap_config hi6421_regmap_config = {
+static const struct regmap_config hi6421_regmap_config = {
         .reg_bits = 32,
         .reg_stride = 4,
         .val_bits = 8,
diff --git a/drivers/mfd/intel_soc_pmic_core.c b/drivers/mfd/intel_soc_pmic_core.c
index df7b0642a5b4..80cef048b904 100644
--- a/drivers/mfd/intel_soc_pmic_core.c
+++ b/drivers/mfd/intel_soc_pmic_core.c
@@ -64,6 +64,9 @@ static int intel_soc_pmic_i2c_probe(struct i2c_client *i2c,
         config = (struct intel_soc_pmic_config *)id->driver_data;
 
         pmic = devm_kzalloc(dev, sizeof(*pmic), GFP_KERNEL);
+        if (!pmic)
+                return -ENOMEM;
+
         dev_set_drvdata(dev, pmic);
 
         pmic->regmap = devm_regmap_init_i2c(i2c, config->regmap_config);
diff --git a/drivers/mfd/intel_soc_pmic_core.h b/drivers/mfd/intel_soc_pmic_core.h
index 33aacd9baddc..9498d6719847 100644
--- a/drivers/mfd/intel_soc_pmic_core.h
+++ b/drivers/mfd/intel_soc_pmic_core.h
@@ -23,7 +23,7 @@ struct intel_soc_pmic_config {
         unsigned long irq_flags;
         struct mfd_cell *cell_dev;
         int n_cell_devs;
-        struct regmap_config *regmap_config;
+        const struct regmap_config *regmap_config;
         struct regmap_irq_chip *irq_chip;
 };
 
diff --git a/drivers/mfd/intel_soc_pmic_crc.c b/drivers/mfd/intel_soc_pmic_crc.c
index c85e2ecb868a..4cc1b324e971 100644
--- a/drivers/mfd/intel_soc_pmic_crc.c
+++ b/drivers/mfd/intel_soc_pmic_crc.c
@@ -111,7 +111,7 @@ static struct mfd_cell crystal_cove_dev[] = {
         },
 };
 
-static struct regmap_config crystal_cove_regmap_config = {
+static const struct regmap_config crystal_cove_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/drivers/mfd/lm3533-core.c b/drivers/mfd/lm3533-core.c
index 8c29f7b27324..d42fbb667d8c 100644
--- a/drivers/mfd/lm3533-core.c
+++ b/drivers/mfd/lm3533-core.c
@@ -583,7 +583,7 @@ static bool lm3533_precious_register(struct device *dev, unsigned int reg)
         }
 }
 
-static struct regmap_config regmap_config = {
+static const struct regmap_config regmap_config = {
         .reg_bits       = 8,
         .val_bits       = 8,
         .max_register   = LM3533_REG_MAX,
diff --git a/drivers/mfd/lpc_sch.c b/drivers/mfd/lpc_sch.c
index 5c38df35a84d..a56e4ba5227b 100644
--- a/drivers/mfd/lpc_sch.c
+++ b/drivers/mfd/lpc_sch.c
@@ -75,6 +75,7 @@ static struct lpc_sch_info sch_chipset_info[] = {
         [LPC_QUARK_X1000] = {
                 .io_size_gpio = GPIO_IO_SIZE,
                 .irq_gpio = GPIO_IRQ_QUARK_X1000,
+                .io_size_wdt = WDT_IO_SIZE,
         },
 };
 
diff --git a/drivers/mfd/max77686.c b/drivers/mfd/max77686.c
index 929795eae9fc..760d08d7923d 100644
--- a/drivers/mfd/max77686.c
+++ b/drivers/mfd/max77686.c
@@ -111,17 +111,17 @@ static bool max77802_is_volatile_reg(struct device *dev, unsigned int reg)
                 max77802_rtc_is_volatile_reg(dev, reg));
 }
 
-static struct regmap_config max77686_regmap_config = {
+static const struct regmap_config max77686_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 };
 
-static struct regmap_config max77686_rtc_regmap_config = {
+static const struct regmap_config max77686_rtc_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 };
 
-static struct regmap_config max77802_regmap_config = {
+static const struct regmap_config max77802_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
         .writeable_reg = max77802_is_accessible_reg,
@@ -205,24 +205,10 @@ static const struct of_device_id max77686_pmic_dt_match[] = {
         { },
 };
 
-static struct max77686_platform_data *max77686_i2c_parse_dt_pdata(struct device
-                                                                  *dev)
-{
-        struct max77686_platform_data *pd;
-
-        pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL);
-        if (!pd)
-                return NULL;
-
-        dev->platform_data = pd;
-        return pd;
-}
-
 static int max77686_i2c_probe(struct i2c_client *i2c,
                               const struct i2c_device_id *id)
 {
         struct max77686_dev *max77686 = NULL;
-        struct max77686_platform_data *pdata = dev_get_platdata(&i2c->dev);
         const struct of_device_id *match;
         unsigned int data;
         int ret = 0;
@@ -233,14 +219,6 @@ static int max77686_i2c_probe(struct i2c_client *i2c,
         const struct mfd_cell *cells;
         int n_devs;
 
-        if (IS_ENABLED(CONFIG_OF) && i2c->dev.of_node && !pdata)
-                pdata = max77686_i2c_parse_dt_pdata(&i2c->dev);
-
-        if (!pdata) {
-                dev_err(&i2c->dev, "No platform data found.\n");
-                return -EINVAL;
-        }
-
         max77686 = devm_kzalloc(&i2c->dev,
                                 sizeof(struct max77686_dev), GFP_KERNEL);
         if (!max77686)
@@ -259,7 +237,6 @@ static int max77686_i2c_probe(struct i2c_client *i2c,
         max77686->dev = &i2c->dev;
         max77686->i2c = i2c;
 
-        max77686->wakeup = pdata->wakeup;
         max77686->irq = i2c->irq;
 
         if (max77686->type == TYPE_MAX77686) {
diff --git a/drivers/mfd/mc13xxx-i2c.c b/drivers/mfd/mc13xxx-i2c.c
index ae3addb153a2..68b844811566 100644
--- a/drivers/mfd/mc13xxx-i2c.c
+++ b/drivers/mfd/mc13xxx-i2c.c
@@ -46,7 +46,7 @@ static const struct of_device_id mc13xxx_dt_ids[] = {
 };
 MODULE_DEVICE_TABLE(of, mc13xxx_dt_ids);
 
-static struct regmap_config mc13xxx_regmap_i2c_config = {
+static const struct regmap_config mc13xxx_regmap_i2c_config = {
         .reg_bits = 8,
         .val_bits = 24,
 
diff --git a/drivers/mfd/mc13xxx-spi.c b/drivers/mfd/mc13xxx-spi.c
index 702925e242c9..58a170e45d88 100644
--- a/drivers/mfd/mc13xxx-spi.c
+++ b/drivers/mfd/mc13xxx-spi.c
@@ -48,7 +48,7 @@ static const struct of_device_id mc13xxx_dt_ids[] = {
 };
 MODULE_DEVICE_TABLE(of, mc13xxx_dt_ids);
 
-static struct regmap_config mc13xxx_regmap_spi_config = {
+static const struct regmap_config mc13xxx_regmap_spi_config = {
         .reg_bits = 7,
         .pad_bits = 1,
         .val_bits = 24,
diff --git a/drivers/mfd/omap-usb-host.c b/drivers/mfd/omap-usb-host.c
index 04cd54dd507c..1d924d1533c0 100644
--- a/drivers/mfd/omap-usb-host.c
+++ b/drivers/mfd/omap-usb-host.c
@@ -129,16 +129,6 @@ static inline u32 usbhs_read(void __iomem *base, u32 reg)
         return readl_relaxed(base + reg);
 }
 
-static inline void usbhs_writeb(void __iomem *base, u8 reg, u8 val)
-{
-        writeb_relaxed(val, base + reg);
-}
-
-static inline u8 usbhs_readb(void __iomem *base, u8 reg)
-{
-        return readb_relaxed(base + reg);
-}
-
 /*-------------------------------------------------------------------------*/
 
 /**
diff --git a/drivers/mfd/pcf50633-core.c b/drivers/mfd/pcf50633-core.c
index 43664eb69c93..6155d123a84e 100644
--- a/drivers/mfd/pcf50633-core.c
+++ b/drivers/mfd/pcf50633-core.c
@@ -183,7 +183,7 @@ static int pcf50633_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(pcf50633_pm, pcf50633_suspend, pcf50633_resume);
 
-static struct regmap_config pcf50633_regmap_config = {
+static const struct regmap_config pcf50633_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 };
diff --git a/drivers/mfd/qcom_rpm.c b/drivers/mfd/qcom_rpm.c
new file mode 100644
index 000000000000..f696328c2933
--- /dev/null
+++ b/drivers/mfd/qcom_rpm.c
@@ -0,0 +1,581 @@
+/*
+ * Copyright (c) 2014, Sony Mobile Communications AB.
+ * Copyright (c) 2013, The Linux Foundation. All rights reserved.
+ * Author: Bjorn Andersson <bjorn.andersson@sonymobile.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 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/module.h>
+#include <linux/platform_device.h>
+#include <linux/of_platform.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/qcom_rpm.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
+
+#include <dt-bindings/mfd/qcom-rpm.h>
+
+struct qcom_rpm_resource {
+        unsigned target_id;
+        unsigned status_id;
+        unsigned select_id;
+        unsigned size;
+};
+
+struct qcom_rpm_data {
+        u32 version;
+        const struct qcom_rpm_resource *resource_table;
+        unsigned n_resources;
+};
+
+struct qcom_rpm {
+        struct device *dev;
+        struct regmap *ipc_regmap;
+        unsigned ipc_offset;
+        unsigned ipc_bit;
+
+        struct completion ack;
+        struct mutex lock;
+
+        void __iomem *status_regs;
+        void __iomem *ctrl_regs;
+        void __iomem *req_regs;
+
+        u32 ack_status;
+
+        const struct qcom_rpm_data *data;
+};
+
+#define RPM_STATUS_REG(rpm, i)  ((rpm)->status_regs + (i) * 4)
+#define RPM_CTRL_REG(rpm, i)    ((rpm)->ctrl_regs + (i) * 4)
+#define RPM_REQ_REG(rpm, i)     ((rpm)->req_regs + (i) * 4)
+
+#define RPM_REQUEST_TIMEOUT     (5 * HZ)
+
+#define RPM_REQUEST_CONTEXT     3
+#define RPM_REQ_SELECT          11
+#define RPM_ACK_CONTEXT         15
+#define RPM_ACK_SELECTOR        23
+#define RPM_SELECT_SIZE         7
+
+#define RPM_NOTIFICATION        BIT(30)
+#define RPM_REJECTED            BIT(31)
+
+#define RPM_SIGNAL              BIT(2)
+
+static const struct qcom_rpm_resource apq8064_rpm_resource_table[] = {
+        [QCOM_RPM_CXO_CLK] =                    { 25, 9, 5, 1 },
+        [QCOM_RPM_PXO_CLK] =                    { 26, 10, 6, 1 },
+        [QCOM_RPM_APPS_FABRIC_CLK] =            { 27, 11, 8, 1 },
+        [QCOM_RPM_SYS_FABRIC_CLK] =             { 28, 12, 9, 1 },
+        [QCOM_RPM_MM_FABRIC_CLK] =              { 29, 13, 10, 1 },
+        [QCOM_RPM_DAYTONA_FABRIC_CLK] =         { 30, 14, 11, 1 },
+        [QCOM_RPM_SFPB_CLK] =                   { 31, 15, 12, 1 },
+        [QCOM_RPM_CFPB_CLK] =                   { 32, 16, 13, 1 },
+        [QCOM_RPM_MMFPB_CLK] =                  { 33, 17, 14, 1 },
+        [QCOM_RPM_EBI1_CLK] =                   { 34, 18, 16, 1 },
+        [QCOM_RPM_APPS_FABRIC_HALT] =           { 35, 19, 18, 1 },
+        [QCOM_RPM_APPS_FABRIC_MODE] =           { 37, 20, 19, 1 },
+        [QCOM_RPM_APPS_FABRIC_IOCTL] =          { 40, 21, 20, 1 },
+        [QCOM_RPM_APPS_FABRIC_ARB] =            { 41, 22, 21, 12 },
+        [QCOM_RPM_SYS_FABRIC_HALT] =            { 53, 23, 22, 1 },
+        [QCOM_RPM_SYS_FABRIC_MODE] =            { 55, 24, 23, 1 },
+        [QCOM_RPM_SYS_FABRIC_IOCTL] =           { 58, 25, 24, 1 },
+        [QCOM_RPM_SYS_FABRIC_ARB] =             { 59, 26, 25, 30 },
+        [QCOM_RPM_MM_FABRIC_HALT] =             { 89, 27, 26, 1 },
+        [QCOM_RPM_MM_FABRIC_MODE] =             { 91, 28, 27, 1 },
+        [QCOM_RPM_MM_FABRIC_IOCTL] =            { 94, 29, 28, 1 },
+        [QCOM_RPM_MM_FABRIC_ARB] =              { 95, 30, 29, 21 },
+        [QCOM_RPM_PM8921_SMPS1] =               { 116, 31, 30, 2 },
+        [QCOM_RPM_PM8921_SMPS2] =               { 118, 33, 31, 2 },
+        [QCOM_RPM_PM8921_SMPS3] =               { 120, 35, 32, 2 },
+        [QCOM_RPM_PM8921_SMPS4] =               { 122, 37, 33, 2 },
+        [QCOM_RPM_PM8921_SMPS5] =               { 124, 39, 34, 2 },
+        [QCOM_RPM_PM8921_SMPS6] =               { 126, 41, 35, 2 },
+        [QCOM_RPM_PM8921_SMPS7] =               { 128, 43, 36, 2 },
+        [QCOM_RPM_PM8921_SMPS8] =               { 130, 45, 37, 2 },
+        [QCOM_RPM_PM8921_LDO1] =                { 132, 47, 38, 2 },
+        [QCOM_RPM_PM8921_LDO2] =                { 134, 49, 39, 2 },
+        [QCOM_RPM_PM8921_LDO3] =                { 136, 51, 40, 2 },
+        [QCOM_RPM_PM8921_LDO4] =                { 138, 53, 41, 2 },
+        [QCOM_RPM_PM8921_LDO5] =                { 140, 55, 42, 2 },
+        [QCOM_RPM_PM8921_LDO6] =                { 142, 57, 43, 2 },
+        [QCOM_RPM_PM8921_LDO7] =                { 144, 59, 44, 2 },
+        [QCOM_RPM_PM8921_LDO8] =                { 146, 61, 45, 2 },
+        [QCOM_RPM_PM8921_LDO9] =                { 148, 63, 46, 2 },
+        [QCOM_RPM_PM8921_LDO10] =               { 150, 65, 47, 2 },
+        [QCOM_RPM_PM8921_LDO11] =               { 152, 67, 48, 2 },
+        [QCOM_RPM_PM8921_LDO12] =               { 154, 69, 49, 2 },
+        [QCOM_RPM_PM8921_LDO13] =               { 156, 71, 50, 2 },
+        [QCOM_RPM_PM8921_LDO14] =               { 158, 73, 51, 2 },
+        [QCOM_RPM_PM8921_LDO15] =               { 160, 75, 52, 2 },
+        [QCOM_RPM_PM8921_LDO16] =               { 162, 77, 53, 2 },
+        [QCOM_RPM_PM8921_LDO17] =               { 164, 79, 54, 2 },
+        [QCOM_RPM_PM8921_LDO18] =               { 166, 81, 55, 2 },
+        [QCOM_RPM_PM8921_LDO19] =               { 168, 83, 56, 2 },
+        [QCOM_RPM_PM8921_LDO20] =               { 170, 85, 57, 2 },
+        [QCOM_RPM_PM8921_LDO21] =               { 172, 87, 58, 2 },
+        [QCOM_RPM_PM8921_LDO22] =               { 174, 89, 59, 2 },
+        [QCOM_RPM_PM8921_LDO23] =               { 176, 91, 60, 2 },
+        [QCOM_RPM_PM8921_LDO24] =               { 178, 93, 61, 2 },
+        [QCOM_RPM_PM8921_LDO25] =               { 180, 95, 62, 2 },
+        [QCOM_RPM_PM8921_LDO26] =               { 182, 97, 63, 2 },
+        [QCOM_RPM_PM8921_LDO27] =               { 184, 99, 64, 2 },
+        [QCOM_RPM_PM8921_LDO28] =               { 186, 101, 65, 2 },
+        [QCOM_RPM_PM8921_LDO29] =               { 188, 103, 66, 2 },
+        [QCOM_RPM_PM8921_CLK1] =                { 190, 105, 67, 2 },
+        [QCOM_RPM_PM8921_CLK2] =                { 192, 107, 68, 2 },
+        [QCOM_RPM_PM8921_LVS1] =                { 194, 109, 69, 1 },
+        [QCOM_RPM_PM8921_LVS2] =                { 195, 110, 70, 1 },
+        [QCOM_RPM_PM8921_LVS3] =                { 196, 111, 71, 1 },
+        [QCOM_RPM_PM8921_LVS4] =                { 197, 112, 72, 1 },
+        [QCOM_RPM_PM8921_LVS5] =                { 198, 113, 73, 1 },
+        [QCOM_RPM_PM8921_LVS6] =                { 199, 114, 74, 1 },
+        [QCOM_RPM_PM8921_LVS7] =                { 200, 115, 75, 1 },
+        [QCOM_RPM_PM8821_SMPS1] =               { 201, 116, 76, 2 },
+        [QCOM_RPM_PM8821_SMPS2] =               { 203, 118, 77, 2 },
+        [QCOM_RPM_PM8821_LDO1] =                { 205, 120, 78, 2 },
+        [QCOM_RPM_PM8921_NCP] =                 { 207, 122, 80, 2 },
+        [QCOM_RPM_CXO_BUFFERS] =                { 209, 124, 81, 1 },
+        [QCOM_RPM_USB_OTG_SWITCH] =             { 210, 125, 82, 1 },
+        [QCOM_RPM_HDMI_SWITCH] =                { 211, 126, 83, 1 },
+        [QCOM_RPM_DDR_DMM] =                    { 212, 127, 84, 2 },
+        [QCOM_RPM_VDDMIN_GPIO] =                { 215, 131, 89, 1 },
+};
+
+static const struct qcom_rpm_data apq8064_template = {
+        .version = 3,
+        .resource_table = apq8064_rpm_resource_table,
+        .n_resources = ARRAY_SIZE(apq8064_rpm_resource_table),
+};
+
+static const struct qcom_rpm_resource msm8660_rpm_resource_table[] = {
+        [QCOM_RPM_CXO_CLK] =                    { 32, 12, 5, 1 },
+        [QCOM_RPM_PXO_CLK] =                    { 33, 13, 6, 1 },
+        [QCOM_RPM_PLL_4] =                      { 34, 14, 7, 1 },
+        [QCOM_RPM_APPS_FABRIC_CLK] =            { 35, 15, 8, 1 },
+        [QCOM_RPM_SYS_FABRIC_CLK] =             { 36, 16, 9, 1 },
+        [QCOM_RPM_MM_FABRIC_CLK] =              { 37, 17, 10, 1 },
+        [QCOM_RPM_DAYTONA_FABRIC_CLK] =         { 38, 18, 11, 1 },
+        [QCOM_RPM_SFPB_CLK] =                   { 39, 19, 12, 1 },
+        [QCOM_RPM_CFPB_CLK] =                   { 40, 20, 13, 1 },
+        [QCOM_RPM_MMFPB_CLK] =                  { 41, 21, 14, 1 },
+        [QCOM_RPM_SMI_CLK] =                    { 42, 22, 15, 1 },
+        [QCOM_RPM_EBI1_CLK] =                   { 43, 23, 16, 1 },
+        [QCOM_RPM_APPS_L2_CACHE_CTL] =          { 44, 24, 17, 1 },
+        [QCOM_RPM_APPS_FABRIC_HALT] =           { 45, 25, 18, 2 },
+        [QCOM_RPM_APPS_FABRIC_MODE] =           { 47, 26, 19, 3 },
+        [QCOM_RPM_APPS_FABRIC_ARB] =            { 51, 28, 21, 6 },
+        [QCOM_RPM_SYS_FABRIC_HALT] =            { 63, 29, 22, 2 },
+        [QCOM_RPM_SYS_FABRIC_MODE] =            { 65, 30, 23, 3 },
+        [QCOM_RPM_SYS_FABRIC_ARB] =             { 69, 32, 25, 22 },
+        [QCOM_RPM_MM_FABRIC_HALT] =             { 105, 33, 26, 2 },
+        [QCOM_RPM_MM_FABRIC_MODE] =             { 107, 34, 27, 3 },
+        [QCOM_RPM_MM_FABRIC_ARB] =              { 111, 36, 29, 23 },
+        [QCOM_RPM_PM8901_SMPS0] =               { 134, 37, 30, 2 },
+        [QCOM_RPM_PM8901_SMPS1] =               { 136, 39, 31, 2 },
+        [QCOM_RPM_PM8901_SMPS2] =               { 138, 41, 32, 2 },
+        [QCOM_RPM_PM8901_SMPS3] =               { 140, 43, 33, 2 },
+        [QCOM_RPM_PM8901_SMPS4] =               { 142, 45, 34, 2 },
+        [QCOM_RPM_PM8901_LDO0] =                { 144, 47, 35, 2 },
+        [QCOM_RPM_PM8901_LDO1] =                { 146, 49, 36, 2 },
+        [QCOM_RPM_PM8901_LDO2] =                { 148, 51, 37, 2 },
+        [QCOM_RPM_PM8901_LDO3] =                { 150, 53, 38, 2 },
+        [QCOM_RPM_PM8901_LDO4] =                { 152, 55, 39, 2 },
+        [QCOM_RPM_PM8901_LDO5] =                { 154, 57, 40, 2 },
+        [QCOM_RPM_PM8901_LDO6] =                { 156, 59, 41, 2 },
+        [QCOM_RPM_PM8901_LVS0] =                { 158, 61, 42, 1 },
+        [QCOM_RPM_PM8901_LVS1] =                { 159, 62, 43, 1 },
+        [QCOM_RPM_PM8901_LVS2] =                { 160, 63, 44, 1 },
+        [QCOM_RPM_PM8901_LVS3] =                { 161, 64, 45, 1 },
+        [QCOM_RPM_PM8901_MVS] =                 { 162, 65, 46, 1 },
+        [QCOM_RPM_PM8058_SMPS0] =               { 163, 66, 47, 2 },
+        [QCOM_RPM_PM8058_SMPS1] =               { 165, 68, 48, 2 },
+        [QCOM_RPM_PM8058_SMPS2] =               { 167, 70, 49, 2 },
+        [QCOM_RPM_PM8058_SMPS3] =               { 169, 72, 50, 2 },
+        [QCOM_RPM_PM8058_SMPS4] =               { 171, 74, 51, 2 },
+        [QCOM_RPM_PM8058_LDO0] =                { 173, 76, 52, 2 },
+        [QCOM_RPM_PM8058_LDO1] =                { 175, 78, 53, 2 },
+        [QCOM_RPM_PM8058_LDO2] =                { 177, 80, 54, 2 },
+        [QCOM_RPM_PM8058_LDO3] =                { 179, 82, 55, 2 },
+        [QCOM_RPM_PM8058_LDO4] =                { 181, 84, 56, 2 },
+        [QCOM_RPM_PM8058_LDO5] =                { 183, 86, 57, 2 },
+        [QCOM_RPM_PM8058_LDO6] =                { 185, 88, 58, 2 },
+        [QCOM_RPM_PM8058_LDO7] =                { 187, 90, 59, 2 },
+        [QCOM_RPM_PM8058_LDO8] =                { 189, 92, 60, 2 },
+        [QCOM_RPM_PM8058_LDO9] =                { 191, 94, 61, 2 },
+        [QCOM_RPM_PM8058_LDO10] =               { 193, 96, 62, 2 },
+        [QCOM_RPM_PM8058_LDO11] =               { 195, 98, 63, 2 },
+        [QCOM_RPM_PM8058_LDO12] =               { 197, 100, 64, 2 },
+        [QCOM_RPM_PM8058_LDO13] =               { 199, 102, 65, 2 },
+        [QCOM_RPM_PM8058_LDO14] =               { 201, 104, 66, 2 },
+        [QCOM_RPM_PM8058_LDO15] =               { 203, 106, 67, 2 },
+        [QCOM_RPM_PM8058_LDO16] =               { 205, 108, 68, 2 },
+        [QCOM_RPM_PM8058_LDO17] =               { 207, 110, 69, 2 },
+        [QCOM_RPM_PM8058_LDO18] =               { 209, 112, 70, 2 },
+        [QCOM_RPM_PM8058_LDO19] =               { 211, 114, 71, 2 },
+        [QCOM_RPM_PM8058_LDO20] =               { 213, 116, 72, 2 },
+        [QCOM_RPM_PM8058_LDO21] =               { 215, 118, 73, 2 },
+        [QCOM_RPM_PM8058_LDO22] =               { 217, 120, 74, 2 },
+        [QCOM_RPM_PM8058_LDO23] =               { 219, 122, 75, 2 },
+        [QCOM_RPM_PM8058_LDO24] =               { 221, 124, 76, 2 },
+        [QCOM_RPM_PM8058_LDO25] =               { 223, 126, 77, 2 },
+        [QCOM_RPM_PM8058_LVS0] =                { 225, 128, 78, 1 },
+        [QCOM_RPM_PM8058_LVS1] =                { 226, 129, 79, 1 },
+        [QCOM_RPM_PM8058_NCP] =                 { 227, 130, 80, 2 },
+        [QCOM_RPM_CXO_BUFFERS] =                { 229, 132, 81, 1 },
+};
+
+static const struct qcom_rpm_data msm8660_template = {
+        .version = 2,
+        .resource_table = msm8660_rpm_resource_table,
+        .n_resources = ARRAY_SIZE(msm8660_rpm_resource_table),
+};
+
+static const struct qcom_rpm_resource msm8960_rpm_resource_table[] = {
+        [QCOM_RPM_CXO_CLK] =                    { 25, 9, 5, 1 },
+        [QCOM_RPM_PXO_CLK] =                    { 26, 10, 6, 1 },
+        [QCOM_RPM_APPS_FABRIC_CLK] =            { 27, 11, 8, 1 },
+        [QCOM_RPM_SYS_FABRIC_CLK] =             { 28, 12, 9, 1 },
+        [QCOM_RPM_MM_FABRIC_CLK] =              { 29, 13, 10, 1 },
+        [QCOM_RPM_DAYTONA_FABRIC_CLK] =         { 30, 14, 11, 1 },
+        [QCOM_RPM_SFPB_CLK] =                   { 31, 15, 12, 1 },
+        [QCOM_RPM_CFPB_CLK] =                   { 32, 16, 13, 1 },
+        [QCOM_RPM_MMFPB_CLK] =                  { 33, 17, 14, 1 },
+        [QCOM_RPM_EBI1_CLK] =                   { 34, 18, 16, 1 },
+        [QCOM_RPM_APPS_FABRIC_HALT] =           { 35, 19, 18, 1 },
+        [QCOM_RPM_APPS_FABRIC_MODE] =           { 37, 20, 19, 1 },
+        [QCOM_RPM_APPS_FABRIC_IOCTL] =          { 40, 21, 20, 1 },
+        [QCOM_RPM_APPS_FABRIC_ARB] =            { 41, 22, 21, 12 },
+        [QCOM_RPM_SYS_FABRIC_HALT] =            { 53, 23, 22, 1 },
+        [QCOM_RPM_SYS_FABRIC_MODE] =            { 55, 24, 23, 1 },
+        [QCOM_RPM_SYS_FABRIC_IOCTL] =           { 58, 25, 24, 1 },
+        [QCOM_RPM_SYS_FABRIC_ARB] =             { 59, 26, 25, 29 },
+        [QCOM_RPM_MM_FABRIC_HALT] =             { 88, 27, 26, 1 },
+        [QCOM_RPM_MM_FABRIC_MODE] =             { 90, 28, 27, 1 },
+        [QCOM_RPM_MM_FABRIC_IOCTL] =            { 93, 29, 28, 1 },
+        [QCOM_RPM_MM_FABRIC_ARB] =              { 94, 30, 29, 23 },
+        [QCOM_RPM_PM8921_SMPS1] =               { 117, 31, 30, 2 },
+        [QCOM_RPM_PM8921_SMPS2] =               { 119, 33, 31, 2 },
+        [QCOM_RPM_PM8921_SMPS3] =               { 121, 35, 32, 2 },
+        [QCOM_RPM_PM8921_SMPS4] =               { 123, 37, 33, 2 },
+        [QCOM_RPM_PM8921_SMPS5] =               { 125, 39, 34, 2 },
+        [QCOM_RPM_PM8921_SMPS6] =               { 127, 41, 35, 2 },
+        [QCOM_RPM_PM8921_SMPS7] =               { 129, 43, 36, 2 },
+        [QCOM_RPM_PM8921_SMPS8] =               { 131, 45, 37, 2 },
+        [QCOM_RPM_PM8921_LDO1] =                { 133, 47, 38, 2 },
+        [QCOM_RPM_PM8921_LDO2] =                { 135, 49, 39, 2 },
+        [QCOM_RPM_PM8921_LDO3] =                { 137, 51, 40, 2 },
+        [QCOM_RPM_PM8921_LDO4] =                { 139, 53, 41, 2 },
+        [QCOM_RPM_PM8921_LDO5] =                { 141, 55, 42, 2 },
+        [QCOM_RPM_PM8921_LDO6] =                { 143, 57, 43, 2 },
+        [QCOM_RPM_PM8921_LDO7] =                { 145, 59, 44, 2 },
+        [QCOM_RPM_PM8921_LDO8] =                { 147, 61, 45, 2 },
+        [QCOM_RPM_PM8921_LDO9] =                { 149, 63, 46, 2 },
+        [QCOM_RPM_PM8921_LDO10] =               { 151, 65, 47, 2 },
+        [QCOM_RPM_PM8921_LDO11] =               { 153, 67, 48, 2 },
+        [QCOM_RPM_PM8921_LDO12] =               { 155, 69, 49, 2 },
+        [QCOM_RPM_PM8921_LDO13] =               { 157, 71, 50, 2 },
+        [QCOM_RPM_PM8921_LDO14] =               { 159, 73, 51, 2 },
+        [QCOM_RPM_PM8921_LDO15] =               { 161, 75, 52, 2 },
+        [QCOM_RPM_PM8921_LDO16] =               { 163, 77, 53, 2 },
+        [QCOM_RPM_PM8921_LDO17] =               { 165, 79, 54, 2 },
+        [QCOM_RPM_PM8921_LDO18] =               { 167, 81, 55, 2 },
+        [QCOM_RPM_PM8921_LDO19] =               { 169, 83, 56, 2 },
+        [QCOM_RPM_PM8921_LDO20] =               { 171, 85, 57, 2 },
+        [QCOM_RPM_PM8921_LDO21] =               { 173, 87, 58, 2 },
+        [QCOM_RPM_PM8921_LDO22] =               { 175, 89, 59, 2 },
+        [QCOM_RPM_PM8921_LDO23] =               { 177, 91, 60, 2 },
+        [QCOM_RPM_PM8921_LDO24] =               { 179, 93, 61, 2 },
+        [QCOM_RPM_PM8921_LDO25] =               { 181, 95, 62, 2 },
+        [QCOM_RPM_PM8921_LDO26] =               { 183, 97, 63, 2 },
+        [QCOM_RPM_PM8921_LDO27] =               { 185, 99, 64, 2 },
+        [QCOM_RPM_PM8921_LDO28] =               { 187, 101, 65, 2 },
+        [QCOM_RPM_PM8921_LDO29] =               { 189, 103, 66, 2 },
+        [QCOM_RPM_PM8921_CLK1] =                { 191, 105, 67, 2 },
+        [QCOM_RPM_PM8921_CLK2] =                { 193, 107, 68, 2 },
+        [QCOM_RPM_PM8921_LVS1] =                { 195, 109, 69, 1 },
+        [QCOM_RPM_PM8921_LVS2] =                { 196, 110, 70, 1 },
+        [QCOM_RPM_PM8921_LVS3] =                { 197, 111, 71, 1 },
+        [QCOM_RPM_PM8921_LVS4] =                { 198, 112, 72, 1 },
+        [QCOM_RPM_PM8921_LVS5] =                { 199, 113, 73, 1 },
+        [QCOM_RPM_PM8921_LVS6] =                { 200, 114, 74, 1 },
+        [QCOM_RPM_PM8921_LVS7] =                { 201, 115, 75, 1 },
+        [QCOM_RPM_PM8921_NCP] =                 { 202, 116, 80, 2 },
+        [QCOM_RPM_CXO_BUFFERS] =                { 204, 118, 81, 1 },
+        [QCOM_RPM_USB_OTG_SWITCH] =             { 205, 119, 82, 1 },
+        [QCOM_RPM_HDMI_SWITCH] =                { 206, 120, 83, 1 },
+        [QCOM_RPM_DDR_DMM] =                    { 207, 121, 84, 2 },
+};
+
+static const struct qcom_rpm_data msm8960_template = {
+        .version = 3,
+        .resource_table = msm8960_rpm_resource_table,
+        .n_resources = ARRAY_SIZE(msm8960_rpm_resource_table),
+};
+
+static const struct of_device_id qcom_rpm_of_match[] = {
+        { .compatible = "qcom,rpm-apq8064", .data = &apq8064_template },
+        { .compatible = "qcom,rpm-msm8660", .data = &msm8660_template },
+        { .compatible = "qcom,rpm-msm8960", .data = &msm8960_template },
+        { }
+};
+MODULE_DEVICE_TABLE(of, qcom_rpm_of_match);
+
+int qcom_rpm_write(struct qcom_rpm *rpm,
+                   int state,
+                   int resource,
+                   u32 *buf, size_t count)
+{
+        const struct qcom_rpm_resource *res;
+        const struct qcom_rpm_data *data = rpm->data;
+        u32 sel_mask[RPM_SELECT_SIZE] = { 0 };
+        int left;
+        int ret = 0;
+        int i;
+
+        if (WARN_ON(resource < 0 || resource >= data->n_resources))
+                return -EINVAL;
+
+        res = &data->resource_table[resource];
+        if (WARN_ON(res->size != count))
+                return -EINVAL;
+
+        mutex_lock(&rpm->lock);
+
+        for (i = 0; i < res->size; i++)
+                writel_relaxed(buf[i], RPM_REQ_REG(rpm, res->target_id + i));
+
+        bitmap_set((unsigned long *)sel_mask, res->select_id, 1);
+        for (i = 0; i < ARRAY_SIZE(sel_mask); i++) {
+                writel_relaxed(sel_mask[i],
+                               RPM_CTRL_REG(rpm, RPM_REQ_SELECT + i));
+        }
+
+        writel_relaxed(BIT(state), RPM_CTRL_REG(rpm, RPM_REQUEST_CONTEXT));
+
+        reinit_completion(&rpm->ack);
+        regmap_write(rpm->ipc_regmap, rpm->ipc_offset, BIT(rpm->ipc_bit));
+
+        left = wait_for_completion_timeout(&rpm->ack, RPM_REQUEST_TIMEOUT);
+        if (!left)
+                ret = -ETIMEDOUT;
+        else if (rpm->ack_status & RPM_REJECTED)
+                ret = -EIO;
+
+        mutex_unlock(&rpm->lock);
+
+        return ret;
+}
+EXPORT_SYMBOL(qcom_rpm_write);
+
+static irqreturn_t qcom_rpm_ack_interrupt(int irq, void *dev)
+{
+        struct qcom_rpm *rpm = dev;
+        u32 ack;
+        int i;
+
+        ack = readl_relaxed(RPM_CTRL_REG(rpm, RPM_ACK_CONTEXT));
+        for (i = 0; i < RPM_SELECT_SIZE; i++)
+                writel_relaxed(0, RPM_CTRL_REG(rpm, RPM_ACK_SELECTOR + i));
+        writel(0, RPM_CTRL_REG(rpm, RPM_ACK_CONTEXT));
+
+        if (ack & RPM_NOTIFICATION) {
+                dev_warn(rpm->dev, "ignoring notification!\n");
+        } else {
+                rpm->ack_status = ack;
+                complete(&rpm->ack);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t qcom_rpm_err_interrupt(int irq, void *dev)
+{
+        struct qcom_rpm *rpm = dev;
+
+        regmap_write(rpm->ipc_regmap, rpm->ipc_offset, BIT(rpm->ipc_bit));
+        dev_err(rpm->dev, "RPM triggered fatal error\n");
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t qcom_rpm_wakeup_interrupt(int irq, void *dev)
+{
+        return IRQ_HANDLED;
+}
+
+static int qcom_rpm_probe(struct platform_device *pdev)
+{
+        const struct of_device_id *match;
+        struct device_node *syscon_np;
+        struct resource *res;
+        struct qcom_rpm *rpm;
+        u32 fw_version[3];
+        int irq_wakeup;
+        int irq_ack;
+        int irq_err;
+        int ret;
+
+        rpm = devm_kzalloc(&pdev->dev, sizeof(*rpm), GFP_KERNEL);
+        if (!rpm)
+                return -ENOMEM;
+
+        rpm->dev = &pdev->dev;
+        mutex_init(&rpm->lock);
+        init_completion(&rpm->ack);
+
+        irq_ack = platform_get_irq_byname(pdev, "ack");
+        if (irq_ack < 0) {
+                dev_err(&pdev->dev, "required ack interrupt missing\n");
+                return irq_ack;
+        }
+
+        irq_err = platform_get_irq_byname(pdev, "err");
+        if (irq_err < 0) {
+                dev_err(&pdev->dev, "required err interrupt missing\n");
+                return irq_err;
+        }
+
+        irq_wakeup = platform_get_irq_byname(pdev, "wakeup");
+        if (irq_wakeup < 0) {
+                dev_err(&pdev->dev, "required wakeup interrupt missing\n");
+                return irq_wakeup;
+        }
+
+        match = of_match_device(qcom_rpm_of_match, &pdev->dev);
+        rpm->data = match->data;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        rpm->status_regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(rpm->status_regs))
+                return PTR_ERR(rpm->status_regs);
+        rpm->ctrl_regs = rpm->status_regs + 0x400;
+        rpm->req_regs = rpm->status_regs + 0x600;
+
+        syscon_np = of_parse_phandle(pdev->dev.of_node, "qcom,ipc", 0);
+        if (!syscon_np) {
+                dev_err(&pdev->dev, "no qcom,ipc node\n");
+                return -ENODEV;
+        }
+
+        rpm->ipc_regmap = syscon_node_to_regmap(syscon_np);
+        if (IS_ERR(rpm->ipc_regmap))
+                return PTR_ERR(rpm->ipc_regmap);
+
+        ret = of_property_read_u32_index(pdev->dev.of_node, "qcom,ipc", 1,
+                                         &rpm->ipc_offset);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "no offset in qcom,ipc\n");
+                return -EINVAL;
+        }
+
+        ret = of_property_read_u32_index(pdev->dev.of_node, "qcom,ipc", 2,
+                                         &rpm->ipc_bit);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "no bit in qcom,ipc\n");
+                return -EINVAL;
+        }
+
+        dev_set_drvdata(&pdev->dev, rpm);
+
+        fw_version[0] = readl(RPM_STATUS_REG(rpm, 0));
+        fw_version[1] = readl(RPM_STATUS_REG(rpm, 1));
+        fw_version[2] = readl(RPM_STATUS_REG(rpm, 2));
+        if (fw_version[0] != rpm->data->version) {
+                dev_err(&pdev->dev,
+                        "RPM version %u.%u.%u incompatible with driver version %u",
+                        fw_version[0],
+                        fw_version[1],
+                        fw_version[2],
+                        rpm->data->version);
+                return -EFAULT;
+        }
+
+        dev_info(&pdev->dev, "RPM firmware %u.%u.%u\n", fw_version[0],
+                                                        fw_version[1],
+                                                        fw_version[2]);
+
+        ret = devm_request_irq(&pdev->dev,
+                               irq_ack,
+                               qcom_rpm_ack_interrupt,
+                               IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND,
+                               "qcom_rpm_ack",
+                               rpm);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to request ack interrupt\n");
+                return ret;
+        }
+
+        ret = irq_set_irq_wake(irq_ack, 1);
+        if (ret)
+                dev_warn(&pdev->dev, "failed to mark ack irq as wakeup\n");
+
+        ret = devm_request_irq(&pdev->dev,
+                               irq_err,
+                               qcom_rpm_err_interrupt,
+                               IRQF_TRIGGER_RISING,
+                               "qcom_rpm_err",
+                               rpm);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to request err interrupt\n");
+                return ret;
+        }
+
+        ret = devm_request_irq(&pdev->dev,
+                               irq_wakeup,
+                               qcom_rpm_wakeup_interrupt,
+                               IRQF_TRIGGER_RISING,
+                               "qcom_rpm_wakeup",
+                               rpm);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to request wakeup interrupt\n");
+                return ret;
+        }
+
+        ret = irq_set_irq_wake(irq_wakeup, 1);
+        if (ret)
+                dev_warn(&pdev->dev, "failed to mark wakeup irq as wakeup\n");
+
+        return of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev);
+}
+
+static int qcom_rpm_remove(struct platform_device *pdev)
+{
+        of_platform_depopulate(&pdev->dev);
+        return 0;
+}
+
+static struct platform_driver qcom_rpm_driver = {
+        .probe = qcom_rpm_probe,
+        .remove = qcom_rpm_remove,
+        .driver  = {
+                .name  = "qcom_rpm",
+                .of_match_table = qcom_rpm_of_match,
+        },
+};
+
+static int __init qcom_rpm_init(void)
+{
+        return platform_driver_register(&qcom_rpm_driver);
+}
+arch_initcall(qcom_rpm_init);
+
+static void __exit qcom_rpm_exit(void)
+{
+        platform_driver_unregister(&qcom_rpm_driver);
+}
+module_exit(qcom_rpm_exit)
+
+MODULE_DESCRIPTION("Qualcomm Resource Power Manager driver");
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
diff --git a/drivers/mfd/retu-mfd.c b/drivers/mfd/retu-mfd.c
index 663f8a37aa6b..2d64430c719b 100644
--- a/drivers/mfd/retu-mfd.c
+++ b/drivers/mfd/retu-mfd.c
@@ -222,7 +222,7 @@ static struct regmap_bus retu_bus = {
         .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
 };
 
-static struct regmap_config retu_config = {
+static const struct regmap_config retu_config = {
         .reg_bits = 8,
         .val_bits = 16,
 };
diff --git a/drivers/mfd/rt5033.c b/drivers/mfd/rt5033.c
new file mode 100644
index 000000000000..db395a6c52bc
--- /dev/null
+++ b/drivers/mfd/rt5033.c
@@ -0,0 +1,142 @@
+/*
+ * MFD core driver for the Richtek RT5033.
+ *
+ * RT5033 comprises multiple sub-devices switcing charger, fuel gauge,
+ * flash LED, current source, LDO and BUCK regulators.
+ *
+ * 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/err.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/of_device.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/rt5033.h>
+#include <linux/mfd/rt5033-private.h>
+
+static const struct regmap_irq rt5033_irqs[] = {
+        { .mask = RT5033_PMIC_IRQ_BUCKOCP, },
+        { .mask = RT5033_PMIC_IRQ_BUCKLV, },
+        { .mask = RT5033_PMIC_IRQ_SAFELDOLV, },
+        { .mask = RT5033_PMIC_IRQ_LDOLV, },
+        { .mask = RT5033_PMIC_IRQ_OT, },
+        { .mask = RT5033_PMIC_IRQ_VDDA_UV, },
+};
+
+static const struct regmap_irq_chip rt5033_irq_chip = {
+        .name           = "rt5033",
+        .status_base    = RT5033_REG_PMIC_IRQ_STAT,
+        .mask_base      = RT5033_REG_PMIC_IRQ_CTRL,
+        .mask_invert    = true,
+        .num_regs       = 1,
+        .irqs           = rt5033_irqs,
+        .num_irqs       = ARRAY_SIZE(rt5033_irqs),
+};
+
+static const struct mfd_cell rt5033_devs[] = {
+        { .name = "rt5033-regulator", },
+        {
+                .name = "rt5033-charger",
+                .of_compatible = "richtek,rt5033-charger",
+        }, {
+                .name = "rt5033-battery",
+                .of_compatible = "richtek,rt5033-battery",
+        },
+};
+
+static const struct regmap_config rt5033_regmap_config = {
+        .reg_bits       = 8,
+        .val_bits       = 8,
+        .max_register   = RT5033_REG_END,
+};
+
+static int rt5033_i2c_probe(struct i2c_client *i2c,
+                                const struct i2c_device_id *id)
+{
+        struct rt5033_dev *rt5033;
+        unsigned int dev_id;
+        int ret;
+
+        rt5033 = devm_kzalloc(&i2c->dev, sizeof(*rt5033), GFP_KERNEL);
+        if (!rt5033)
+                return -ENOMEM;
+
+        i2c_set_clientdata(i2c, rt5033);
+        rt5033->dev = &i2c->dev;
+        rt5033->irq = i2c->irq;
+        rt5033->wakeup = true;
+
+        rt5033->regmap = devm_regmap_init_i2c(i2c, &rt5033_regmap_config);
+        if (IS_ERR(rt5033->regmap)) {
+                dev_err(&i2c->dev, "Failed to allocate register map.\n");
+                return PTR_ERR(rt5033->regmap);
+        }
+
+        ret = regmap_read(rt5033->regmap, RT5033_REG_DEVICE_ID, &dev_id);
+        if (ret) {
+                dev_err(&i2c->dev, "Device not found\n");
+                return -ENODEV;
+        }
+        dev_info(&i2c->dev, "Device found Device ID: %04x\n", dev_id);
+
+        ret = regmap_add_irq_chip(rt5033->regmap, rt5033->irq,
+                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                        0, &rt5033_irq_chip, &rt5033->irq_data);
+        if (ret) {
+                dev_err(&i2c->dev, "Failed to request IRQ %d: %d\n",
+                                                        rt5033->irq, ret);
+                return ret;
+        }
+
+        ret = mfd_add_devices(rt5033->dev, -1, rt5033_devs,
+                        ARRAY_SIZE(rt5033_devs), NULL, 0,
+                        regmap_irq_get_domain(rt5033->irq_data));
+        if (ret < 0) {
+                dev_err(&i2c->dev, "Failed to add RT5033 child devices.\n");
+                return ret;
+        }
+
+        device_init_wakeup(rt5033->dev, rt5033->wakeup);
+
+        return 0;
+}
+
+static int rt5033_i2c_remove(struct i2c_client *i2c)
+{
+        mfd_remove_devices(&i2c->dev);
+
+        return 0;
+}
+
+static const struct i2c_device_id rt5033_i2c_id[] = {
+        { "rt5033", },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, rt5033_i2c_id);
+
+static const struct of_device_id rt5033_dt_match[] = {
+        { .compatible = "richtek,rt5033", },
+        { }
+};
+
+static struct i2c_driver rt5033_driver = {
+        .driver = {
+                .name = "rt5033",
+                .of_match_table = of_match_ptr(rt5033_dt_match),
+        },
+        .probe = rt5033_i2c_probe,
+        .remove = rt5033_i2c_remove,
+        .id_table = rt5033_i2c_id,
+};
+module_i2c_driver(rt5033_driver);
+
+MODULE_ALIAS("i2c:rt5033");
+MODULE_DESCRIPTION("Richtek RT5033 multi-function core driver");
+MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/rtsx_usb.c b/drivers/mfd/rtsx_usb.c
index 210d1f85679e..ede50244f265 100644
--- a/drivers/mfd/rtsx_usb.c
+++ b/drivers/mfd/rtsx_usb.c
@@ -681,9 +681,27 @@ static void rtsx_usb_disconnect(struct usb_interface *intf)
 #ifdef CONFIG_PM
 static int rtsx_usb_suspend(struct usb_interface *intf, pm_message_t message)
 {
+        struct rtsx_ucr *ucr =
+                (struct rtsx_ucr *)usb_get_intfdata(intf);
+        u16 val = 0;
+
         dev_dbg(&intf->dev, "%s called with pm message 0x%04x\n",
                         __func__, message.event);
 
+        if (PMSG_IS_AUTO(message)) {
+                if (mutex_trylock(&ucr->dev_mutex)) {
+                        rtsx_usb_get_card_status(ucr, &val);
+                        mutex_unlock(&ucr->dev_mutex);
+
+                        /* Defer the autosuspend if card exists */
+                        if (val & (SD_CD | MS_CD))
+                                return -EAGAIN;
+                } else {
+                        /* There is an ongoing operation*/
+                        return -EAGAIN;
+                }
+        }
+
         return 0;
 }
 
diff --git a/drivers/mfd/smsc-ece1099.c b/drivers/mfd/smsc-ece1099.c
index 90112d4cc905..03246880d484 100644
--- a/drivers/mfd/smsc-ece1099.c
+++ b/drivers/mfd/smsc-ece1099.c
@@ -24,7 +24,7 @@
 #include <linux/mfd/smsc.h>
 #include <linux/of_platform.h>
 
-static struct regmap_config smsc_regmap_config = {
+static const struct regmap_config smsc_regmap_config = {
                 .reg_bits = 8,
                 .val_bits = 8,
                 .max_register = SMSC_VEN_ID_H,
diff --git a/drivers/mfd/sun6i-prcm.c b/drivers/mfd/sun6i-prcm.c
index 2f2e9f062571..191173166d65 100644
--- a/drivers/mfd/sun6i-prcm.c
+++ b/drivers/mfd/sun6i-prcm.c
@@ -41,6 +41,14 @@ static const struct resource sun6i_a31_apb0_gates_clk_res[] = {
         },
 };
 
+static const struct resource sun6i_a31_ir_clk_res[] = {
+        {
+                .start = 0x54,
+                .end = 0x57,
+                .flags = IORESOURCE_MEM,
+        },
+};
+
 static const struct resource sun6i_a31_apb0_rstc_res[] = {
         {
                 .start = 0xb0,
@@ -69,6 +77,12 @@ static const struct mfd_cell sun6i_a31_prcm_subdevs[] = {
                 .resources = sun6i_a31_apb0_gates_clk_res,
         },
         {
+                .name = "sun6i-a31-ir-clk",
+                .of_compatible = "allwinner,sun4i-a10-mod0-clk",
+                .num_resources = ARRAY_SIZE(sun6i_a31_ir_clk_res),
+                .resources = sun6i_a31_ir_clk_res,
+        },
+        {
                 .name = "sun6i-a31-apb0-clock-reset",
                 .of_compatible = "allwinner,sun6i-a31-clock-reset",
                 .num_resources = ARRAY_SIZE(sun6i_a31_apb0_rstc_res),
diff --git a/drivers/mfd/tps65217.c b/drivers/mfd/tps65217.c
index 80a919a8ca97..7d1cfc1d3ce0 100644
--- a/drivers/mfd/tps65217.c
+++ b/drivers/mfd/tps65217.c
@@ -145,7 +145,7 @@ int tps65217_clear_bits(struct tps65217 *tps, unsigned int reg,
 }
 EXPORT_SYMBOL_GPL(tps65217_clear_bits);
 
-static struct regmap_config tps65217_regmap_config = {
+static const struct regmap_config tps65217_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/drivers/mfd/tps65218.c b/drivers/mfd/tps65218.c
index d6b764349f9d..7af11a8b9753 100644
--- a/drivers/mfd/tps65218.c
+++ b/drivers/mfd/tps65218.c
@@ -135,7 +135,7 @@ static const struct regmap_access_table tps65218_volatile_table = {
         .n_yes_ranges = ARRAY_SIZE(tps65218_yes_ranges),
 };
 
-static struct regmap_config tps65218_regmap_config = {
+static const struct regmap_config tps65218_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
         .cache_type = REGCACHE_RBTREE,
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index db11b4f40611..489674a2497e 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -207,7 +207,7 @@ static struct twl_mapping twl4030_map[] = {
         { 2, TWL5031_BASEADD_INTERRUPTS },
 };
 
-static struct reg_default twl4030_49_defaults[] = {
+static const struct reg_default twl4030_49_defaults[] = {
         /* Audio Registers */
         { 0x01, 0x00}, /* CODEC_MODE    */
         { 0x02, 0x00}, /* OPTION        */
@@ -306,7 +306,7 @@ static const struct regmap_access_table twl4030_49_volatile_table = {
         .n_yes_ranges = ARRAY_SIZE(twl4030_49_volatile_ranges),
 };
 
-static struct regmap_config twl4030_regmap_config[4] = {
+static const struct regmap_config twl4030_regmap_config[4] = {
         {
                 /* Address 0x48 */
                 .reg_bits = 8,
@@ -369,7 +369,7 @@ static struct twl_mapping twl6030_map[] = {
         { 1, TWL6030_BASEADD_GASGAUGE },
 };
 
-static struct regmap_config twl6030_regmap_config[3] = {
+static const struct regmap_config twl6030_regmap_config[3] = {
         {
                 /* Address 0x48 */
                 .reg_bits = 8,
@@ -1087,7 +1087,7 @@ twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
         struct twl4030_platform_data    *pdata = dev_get_platdata(&client->dev);
         struct device_node              *node = client->dev.of_node;
         struct platform_device          *pdev;
-        struct regmap_config            *twl_regmap_config;
+        const struct regmap_config      *twl_regmap_config;
         int                             irq_base = 0;
         int                             status;
         unsigned                        i, num_slaves;
diff --git a/drivers/mfd/twl6040.c b/drivers/mfd/twl6040.c
index 9687645162ae..f71ee3dbc2a2 100644
--- a/drivers/mfd/twl6040.c
+++ b/drivers/mfd/twl6040.c
@@ -44,7 +44,7 @@
 #define VIBRACTRL_MEMBER(reg) ((reg == TWL6040_REG_VIBCTLL) ? 0 : 1)
 #define TWL6040_NUM_SUPPLIES    (2)
 
-static struct reg_default twl6040_defaults[] = {
+static const struct reg_default twl6040_defaults[] = {
         { 0x01, 0x4B }, /* REG_ASICID   (ro) */
         { 0x02, 0x00 }, /* REG_ASICREV  (ro) */
         { 0x03, 0x00 }, /* REG_INTID    */
@@ -580,7 +580,7 @@ static bool twl6040_writeable_reg(struct device *dev, unsigned int reg)
         }
 }
 
-static struct regmap_config twl6040_regmap_config = {
+static const struct regmap_config twl6040_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/drivers/mfd/wm8994-core.c b/drivers/mfd/wm8994-core.c
index 6ca9d25cc3f0..53ae5af5d6e4 100644
--- a/drivers/mfd/wm8994-core.c
+++ b/drivers/mfd/wm8994-core.c
@@ -36,12 +36,12 @@
 static const struct mfd_cell wm8994_regulator_devs[] = {
         {
                 .name = "wm8994-ldo",
-                .id = 1,
+                .id = 0,
                 .pm_runtime_no_callbacks = true,
         },
         {
                 .name = "wm8994-ldo",
-                .id = 2,
+                .id = 1,
                 .pm_runtime_no_callbacks = true,
         },
 };
@@ -344,7 +344,7 @@ static int wm8994_device_init(struct wm8994 *wm8994, int irq)
         dev_set_drvdata(wm8994->dev, wm8994);
 
         /* Add the on-chip regulators first for bootstrapping */
-        ret = mfd_add_devices(wm8994->dev, -1,
+        ret = mfd_add_devices(wm8994->dev, 0,
                               wm8994_regulator_devs,
                               ARRAY_SIZE(wm8994_regulator_devs),
                               NULL, 0, NULL);
diff --git a/drivers/mmc/host/sunxi-mmc.c b/drivers/mmc/host/sunxi-mmc.c
index 6af0a28ba37d..e8a4218b5726 100644
--- a/drivers/mmc/host/sunxi-mmc.c
+++ b/drivers/mmc/host/sunxi-mmc.c
@@ -21,8 +21,6 @@
 #include <linux/err.h>
 
 #include <linux/clk.h>
-#include <linux/clk/sunxi.h>
-
 #include <linux/gpio.h>
 #include <linux/platform_device.h>
 #include <linux/spinlock.h>
@@ -229,6 +227,8 @@ struct sunxi_mmc_host {
         /* clock management */
         struct clk      *clk_ahb;
         struct clk      *clk_mmc;
+        struct clk      *clk_sample;
+        struct clk      *clk_output;
 
         /* irq */
         spinlock_t      lock;
@@ -653,26 +653,31 @@ static int sunxi_mmc_clk_set_rate(struct sunxi_mmc_host *host,
 
         /* determine delays */
         if (rate <= 400000) {
-                oclk_dly = 0;
-                sclk_dly = 7;
+                oclk_dly = 180;
+                sclk_dly = 42;
         } else if (rate <= 25000000) {
-                oclk_dly = 0;
-                sclk_dly = 5;
+                oclk_dly = 180;
+                sclk_dly = 75;
         } else if (rate <= 50000000) {
                 if (ios->timing == MMC_TIMING_UHS_DDR50) {
-                        oclk_dly = 2;
-                        sclk_dly = 4;
+                        oclk_dly = 60;
+                        sclk_dly = 120;
                 } else {
-                        oclk_dly = 3;
-                        sclk_dly = 5;
+                        oclk_dly = 90;
+                        sclk_dly = 150;
                 }
+        } else if (rate <= 100000000) {
+                oclk_dly = 6;
+                sclk_dly = 24;
+        } else if (rate <= 200000000) {
+                oclk_dly = 3;
+                sclk_dly = 12;
         } else {
-                /* rate > 50000000 */
-                oclk_dly = 2;
-                sclk_dly = 4;
+                return -EINVAL;
         }
 
-        clk_sunxi_mmc_phase_control(host->clk_mmc, sclk_dly, oclk_dly);
+        clk_set_phase(host->clk_sample, sclk_dly);
+        clk_set_phase(host->clk_output, oclk_dly);
 
         return sunxi_mmc_oclk_onoff(host, 1);
 }
@@ -913,6 +918,18 @@ static int sunxi_mmc_resource_request(struct sunxi_mmc_host *host,
                 return PTR_ERR(host->clk_mmc);
         }
 
+        host->clk_output = devm_clk_get(&pdev->dev, "output");
+        if (IS_ERR(host->clk_output)) {
+                dev_err(&pdev->dev, "Could not get output clock\n");
+                return PTR_ERR(host->clk_output);
+        }
+
+        host->clk_sample = devm_clk_get(&pdev->dev, "sample");
+        if (IS_ERR(host->clk_sample)) {
+                dev_err(&pdev->dev, "Could not get sample clock\n");
+                return PTR_ERR(host->clk_sample);
+        }
+
         host->reset = devm_reset_control_get(&pdev->dev, "ahb");
 
         ret = clk_prepare_enable(host->clk_ahb);
@@ -927,11 +944,23 @@ static int sunxi_mmc_resource_request(struct sunxi_mmc_host *host,
                 goto error_disable_clk_ahb;
         }
 
+        ret = clk_prepare_enable(host->clk_output);
+        if (ret) {
+                dev_err(&pdev->dev, "Enable output clk err %d\n", ret);
+                goto error_disable_clk_mmc;
+        }
+
+        ret = clk_prepare_enable(host->clk_sample);
+        if (ret) {
+                dev_err(&pdev->dev, "Enable sample clk err %d\n", ret);
+                goto error_disable_clk_output;
+        }
+
         if (!IS_ERR(host->reset)) {
                 ret = reset_control_deassert(host->reset);
                 if (ret) {
                         dev_err(&pdev->dev, "reset err %d\n", ret);
-                        goto error_disable_clk_mmc;
+                        goto error_disable_clk_sample;
                 }
         }
 
@@ -950,6 +979,10 @@ static int sunxi_mmc_resource_request(struct sunxi_mmc_host *host,
 error_assert_reset:
         if (!IS_ERR(host->reset))
                 reset_control_assert(host->reset);
+error_disable_clk_sample:
+        clk_disable_unprepare(host->clk_sample);
+error_disable_clk_output:
+        clk_disable_unprepare(host->clk_output);
 error_disable_clk_mmc:
         clk_disable_unprepare(host->clk_mmc);
 error_disable_clk_ahb:
diff --git a/drivers/mtd/bcm47xxpart.c b/drivers/mtd/bcm47xxpart.c
index cc13ea5ce4d5..c0720c1ee4c9 100644
--- a/drivers/mtd/bcm47xxpart.c
+++ b/drivers/mtd/bcm47xxpart.c
@@ -15,6 +15,8 @@
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
 
+#include <uapi/linux/magic.h>
+
 /*
  * NAND flash on Netgear R6250 was verified to contain 15 partitions.
  * This will result in allocating too big array for some old devices, but the
@@ -39,7 +41,8 @@
 #define ML_MAGIC1                       0x39685a42
 #define ML_MAGIC2                       0x26594131
 #define TRX_MAGIC                       0x30524448
-#define SQSH_MAGIC                      0x71736873      /* shsq */
+#define SHSQ_MAGIC                      0x71736873      /* shsq (weird ZTE H218N endianness) */
+#define UBI_EC_MAGIC                    0x23494255      /* UBI# */
 
 struct trx_header {
         uint32_t magic;
@@ -50,7 +53,7 @@ struct trx_header {
         uint32_t offset[3];
 } __packed;
 
-static void bcm47xxpart_add_part(struct mtd_partition *part, char *name,
+static void bcm47xxpart_add_part(struct mtd_partition *part, const char *name,
                                  u64 offset, uint32_t mask_flags)
 {
         part->name = name;
@@ -58,6 +61,26 @@ static void bcm47xxpart_add_part(struct mtd_partition *part, char *name,
         part->mask_flags = mask_flags;
 }
 
+static const char *bcm47xxpart_trx_data_part_name(struct mtd_info *master,
+                                                  size_t offset)
+{
+        uint32_t buf;
+        size_t bytes_read;
+
+        if (mtd_read(master, offset, sizeof(buf), &bytes_read,
+                     (uint8_t *)&buf) < 0) {
+                pr_err("mtd_read error while parsing (offset: 0x%X)!\n",
+                        offset);
+                goto out_default;
+        }
+
+        if (buf == UBI_EC_MAGIC)
+                return "ubi";
+
+out_default:
+        return "rootfs";
+}
+
 static int bcm47xxpart_parse(struct mtd_info *master,
                              struct mtd_partition **pparts,
                              struct mtd_part_parser_data *data)
@@ -73,8 +96,12 @@ static int bcm47xxpart_parse(struct mtd_info *master,
         int last_trx_part = -1;
         int possible_nvram_sizes[] = { 0x8000, 0xF000, 0x10000, };
 
-        if (blocksize <= 0x10000)
-                blocksize = 0x10000;
+        /*
+         * Some really old flashes (like AT45DB*) had smaller erasesize-s, but
+         * partitions were aligned to at least 0x1000 anyway.
+         */
+        if (blocksize < 0x1000)
+                blocksize = 0x1000;
 
         /* Alloc */
         parts = kzalloc(sizeof(struct mtd_partition) * BCM47XXPART_MAX_PARTS,
@@ -186,8 +213,11 @@ static int bcm47xxpart_parse(struct mtd_info *master,
                          * we want to have jffs2 (overlay) in the same mtd.
                          */
                         if (trx->offset[i]) {
+                                const char *name;
+
+                                name = bcm47xxpart_trx_data_part_name(master, offset + trx->offset[i]);
                                 bcm47xxpart_add_part(&parts[curr_part++],
-                                                     "rootfs",
+                                                     name,
                                                      offset + trx->offset[i],
                                                      0);
                                 i++;
@@ -205,7 +235,8 @@ static int bcm47xxpart_parse(struct mtd_info *master,
                 }
 
                 /* Squashfs on devices not using TRX */
-                if (buf[0x000 / 4] == SQSH_MAGIC) {
+                if (le32_to_cpu(buf[0x000 / 4]) == SQUASHFS_MAGIC ||
+                    buf[0x000 / 4] == SHSQ_MAGIC) {
                         bcm47xxpart_add_part(&parts[curr_part++], "rootfs",
                                              offset, 0);
                         continue;
diff --git a/drivers/mtd/chips/map_ram.c b/drivers/mtd/chips/map_ram.c
index 991c2a1c05d3..afb43d5e1782 100644
--- a/drivers/mtd/chips/map_ram.c
+++ b/drivers/mtd/chips/map_ram.c
@@ -68,6 +68,7 @@ static struct mtd_info *map_ram_probe(struct map_info *map)
         mtd->_get_unmapped_area = mapram_unmapped_area;
         mtd->_read = mapram_read;
         mtd->_write = mapram_write;
+        mtd->_panic_write = mapram_write;
         mtd->_sync = mapram_nop;
         mtd->flags = MTD_CAP_RAM;
         mtd->writesize = 1;
diff --git a/drivers/mtd/chips/map_rom.c b/drivers/mtd/chips/map_rom.c
index 47a43cf7e5c6..e67f73ab44c9 100644
--- a/drivers/mtd/chips/map_rom.c
+++ b/drivers/mtd/chips/map_rom.c
@@ -11,6 +11,7 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/init.h>
+#include <linux/of.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 
@@ -28,6 +29,15 @@ static struct mtd_chip_driver maprom_chipdrv = {
         .module = THIS_MODULE
 };
 
+static unsigned int default_erasesize(struct map_info *map)
+{
+        const __be32 *erase_size = NULL;
+
+        erase_size = of_get_property(map->device_node, "erase-size", NULL);
+
+        return !erase_size ? map->size : be32_to_cpu(*erase_size);
+}
+
 static struct mtd_info *map_rom_probe(struct map_info *map)
 {
         struct mtd_info *mtd;
@@ -47,8 +57,9 @@ static struct mtd_info *map_rom_probe(struct map_info *map)
         mtd->_sync = maprom_nop;
         mtd->_erase = maprom_erase;
         mtd->flags = MTD_CAP_ROM;
-        mtd->erasesize = map->size;
+        mtd->erasesize = default_erasesize(map);
         mtd->writesize = 1;
+        mtd->writebufsize = 1;
 
         __module_get(THIS_MODULE);
         return mtd;
diff --git a/drivers/mtd/devices/st_spi_fsm.c b/drivers/mtd/devices/st_spi_fsm.c
index 54ffe5223e64..3060025c8af4 100644
--- a/drivers/mtd/devices/st_spi_fsm.c
+++ b/drivers/mtd/devices/st_spi_fsm.c
@@ -24,6 +24,7 @@
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/of.h>
+#include <linux/clk.h>
 
 #include "serial_flash_cmds.h"
 
@@ -262,6 +263,7 @@ struct stfsm {
         struct mtd_info         mtd;
         struct mutex            lock;
         struct flash_info       *info;
+        struct clk              *clk;
 
         uint32_t                configuration;
         uint32_t                fifo_dir_delay;
@@ -663,6 +665,23 @@ static struct stfsm_seq stfsm_seq_write_status = {
                     SEQ_CFG_STARTSEQ),
 };
 
+/* Dummy sequence to read one byte of data from flash into the FIFO */
+static const struct stfsm_seq stfsm_seq_load_fifo_byte = {
+        .data_size = TRANSFER_SIZE(1),
+        .seq_opc[0] = (SEQ_OPC_PADS_1 |
+                       SEQ_OPC_CYCLES(8) |
+                       SEQ_OPC_OPCODE(SPINOR_OP_RDID)),
+        .seq = {
+                STFSM_INST_CMD1,
+                STFSM_INST_DATA_READ,
+                STFSM_INST_STOP,
+        },
+        .seq_cfg = (SEQ_CFG_PADS_1 |
+                    SEQ_CFG_READNOTWRITE |
+                    SEQ_CFG_CSDEASSERT |
+                    SEQ_CFG_STARTSEQ),
+};
+
 static int stfsm_n25q_en_32bit_addr_seq(struct stfsm_seq *seq)
 {
         seq->seq_opc[0] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
@@ -695,22 +714,6 @@ static inline uint32_t stfsm_fifo_available(struct stfsm *fsm)
         return (readl(fsm->base + SPI_FAST_SEQ_STA) >> 5) & 0x7f;
 }
 
-static void stfsm_clear_fifo(struct stfsm *fsm)
-{
-        uint32_t avail;
-
-        for (;;) {
-                avail = stfsm_fifo_available(fsm);
-                if (!avail)
-                        break;
-
-                while (avail) {
-                        readl(fsm->base + SPI_FAST_SEQ_DATA_REG);
-                        avail--;
-                }
-        }
-}
-
 static inline void stfsm_load_seq(struct stfsm *fsm,
                                   const struct stfsm_seq *seq)
 {
@@ -772,6 +775,68 @@ static void stfsm_read_fifo(struct stfsm *fsm, uint32_t *buf, uint32_t size)
         }
 }
 
+/*
+ * Clear the data FIFO
+ *
+ * Typically, this is only required during driver initialisation, where no
+ * assumptions can be made regarding the state of the FIFO.
+ *
+ * The process of clearing the FIFO is complicated by fact that while it is
+ * possible for the FIFO to contain an arbitrary number of bytes [1], the
+ * SPI_FAST_SEQ_STA register only reports the number of complete 32-bit words
+ * present.  Furthermore, data can only be drained from the FIFO by reading
+ * complete 32-bit words.
+ *
+ * With this in mind, a two stage process is used to the clear the FIFO:
+ *
+ *     1. Read any complete 32-bit words from the FIFO, as reported by the
+ *        SPI_FAST_SEQ_STA register.
+ *
+ *     2. Mop up any remaining bytes.  At this point, it is not known if there
+ *        are 0, 1, 2, or 3 bytes in the FIFO.  To handle all cases, a dummy FSM
+ *        sequence is used to load one byte at a time, until a complete 32-bit
+ *        word is formed; at most, 4 bytes will need to be loaded.
+ *
+ * [1] It is theoretically possible for the FIFO to contain an arbitrary number
+ *     of bits.  However, since there are no known use-cases that leave
+ *     incomplete bytes in the FIFO, only words and bytes are considered here.
+ */
+static void stfsm_clear_fifo(struct stfsm *fsm)
+{
+        const struct stfsm_seq *seq = &stfsm_seq_load_fifo_byte;
+        uint32_t words, i;
+
+        /* 1. Clear any 32-bit words */
+        words = stfsm_fifo_available(fsm);
+        if (words) {
+                for (i = 0; i < words; i++)
+                        readl(fsm->base + SPI_FAST_SEQ_DATA_REG);
+                dev_dbg(fsm->dev, "cleared %d words from FIFO\n", words);
+        }
+
+        /*
+         * 2. Clear any remaining bytes
+         *    - Load the FIFO, one byte at a time, until a complete 32-bit word
+         *      is available.
+         */
+        for (i = 0, words = 0; i < 4 && !words; i++) {
+                stfsm_load_seq(fsm, seq);
+                stfsm_wait_seq(fsm);
+                words = stfsm_fifo_available(fsm);
+        }
+
+        /*    - A single word must be available now */
+        if (words != 1) {
+                dev_err(fsm->dev, "failed to clear bytes from the data FIFO\n");
+                return;
+        }
+
+        /*    - Read the 32-bit word */
+        readl(fsm->base + SPI_FAST_SEQ_DATA_REG);
+
+        dev_dbg(fsm->dev, "cleared %d byte(s) from the data FIFO\n", 4 - i);
+}
+
 static int stfsm_write_fifo(struct stfsm *fsm, const uint32_t *buf,
                             uint32_t size)
 {
@@ -1521,11 +1586,11 @@ static int stfsm_write(struct stfsm *fsm, const uint8_t *buf,
         uint32_t size_lb;
         uint32_t size_mop;
         uint32_t tmp[4];
+        uint32_t i;
         uint32_t page_buf[FLASH_PAGESIZE_32];
         uint8_t *t = (uint8_t *)&tmp;
         const uint8_t *p;
         int ret;
-        int i;
 
         dev_dbg(fsm->dev, "writing %d bytes to 0x%08x\n", size, offset);
 
@@ -1843,8 +1908,7 @@ static void stfsm_set_freq(struct stfsm *fsm, uint32_t spi_freq)
         uint32_t emi_freq;
         uint32_t clk_div;
 
-        /* TODO: Make this dynamic */
-        emi_freq = STFSM_DEFAULT_EMI_FREQ;
+        emi_freq = clk_get_rate(fsm->clk);
 
         /*
          * Calculate clk_div - values between 2 and 128
@@ -1994,6 +2058,18 @@ static int stfsm_probe(struct platform_device *pdev)
                 return PTR_ERR(fsm->base);
         }
 
+        fsm->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(fsm->clk)) {
+                dev_err(fsm->dev, "Couldn't find EMI clock.\n");
+                return PTR_ERR(fsm->clk);
+        }
+
+        ret = clk_prepare_enable(fsm->clk);
+        if (ret) {
+                dev_err(fsm->dev, "Failed to enable EMI clock.\n");
+                return ret;
+        }
+
         mutex_init(&fsm->lock);
 
         ret = stfsm_init(fsm);
@@ -2058,6 +2134,28 @@ static int stfsm_remove(struct platform_device *pdev)
         return mtd_device_unregister(&fsm->mtd);
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int stfsmfsm_suspend(struct device *dev)
+{
+        struct stfsm *fsm = dev_get_drvdata(dev);
+
+        clk_disable_unprepare(fsm->clk);
+
+        return 0;
+}
+
+static int stfsmfsm_resume(struct device *dev)
+{
+        struct stfsm *fsm = dev_get_drvdata(dev);
+
+        clk_prepare_enable(fsm->clk);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(stfsm_pm_ops, stfsmfsm_suspend, stfsmfsm_resume);
+
 static const struct of_device_id stfsm_match[] = {
         { .compatible = "st,spi-fsm", },
         {},
@@ -2070,6 +2168,7 @@ static struct platform_driver stfsm_driver = {
         .driver         = {
                 .name   = "st-spi-fsm",
                 .of_match_table = stfsm_match,
+                .pm     = &stfsm_pm_ops,
         },
 };
 module_platform_driver(stfsm_driver);
diff --git a/drivers/mtd/maps/physmap_of.c b/drivers/mtd/maps/physmap_of.c
index f35cd2081314..ff26e979b1a1 100644
--- a/drivers/mtd/maps/physmap_of.c
+++ b/drivers/mtd/maps/physmap_of.c
@@ -269,6 +269,16 @@ static int of_flash_probe(struct platform_device *dev)
                         info->list[i].mtd = obsolete_probe(dev,
                                                            &info->list[i].map);
                 }
+
+                /* Fall back to mapping region as ROM */
+                if (!info->list[i].mtd) {
+                        dev_warn(&dev->dev,
+                                "do_map_probe() failed for type %s\n",
+                                 probe_type);
+
+                        info->list[i].mtd = do_map_probe("map_rom",
+                                                         &info->list[i].map);
+                }
                 mtd_list[i] = info->list[i].mtd;
 
                 err = -ENXIO;
diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index 485ea751c7f9..bb4c14f83c75 100644
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -45,8 +45,6 @@ struct mtdblk_dev {
         enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state;
 };
 
-static DEFINE_MUTEX(mtdblks_lock);
-
 /*
  * Cache stuff...
  *
@@ -286,10 +284,8 @@ static int mtdblock_open(struct mtd_blktrans_dev *mbd)
 
         pr_debug("mtdblock_open\n");
 
-        mutex_lock(&mtdblks_lock);
         if (mtdblk->count) {
                 mtdblk->count++;
-                mutex_unlock(&mtdblks_lock);
                 return 0;
         }
 
@@ -302,8 +298,6 @@ static int mtdblock_open(struct mtd_blktrans_dev *mbd)
                 mtdblk->cache_data = NULL;
         }
 
-        mutex_unlock(&mtdblks_lock);
-
         pr_debug("ok\n");
 
         return 0;
@@ -315,8 +309,6 @@ static void mtdblock_release(struct mtd_blktrans_dev *mbd)
 
         pr_debug("mtdblock_release\n");
 
-        mutex_lock(&mtdblks_lock);
-
         mutex_lock(&mtdblk->cache_mutex);
         write_cached_data(mtdblk);
         mutex_unlock(&mtdblk->cache_mutex);
@@ -331,8 +323,6 @@ static void mtdblock_release(struct mtd_blktrans_dev *mbd)
                 vfree(mtdblk->cache_data);
         }
 
-        mutex_unlock(&mtdblks_lock);
-
         pr_debug("ok\n");
 }
 
diff --git a/drivers/mtd/mtdconcat.c b/drivers/mtd/mtdconcat.c
index eacc3aac7327..239a8c806b67 100644
--- a/drivers/mtd/mtdconcat.c
+++ b/drivers/mtd/mtdconcat.c
@@ -311,7 +311,8 @@ concat_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
                         devops.len = subdev->size - to;
 
                 err = mtd_write_oob(subdev, to, &devops);
-                ops->retlen += devops.oobretlen;
+                ops->retlen += devops.retlen;
+                ops->oobretlen += devops.oobretlen;
                 if (err)
                         return err;
 
diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
index 0ec4d6ea1e4b..11883bd26d9d 100644
--- a/drivers/mtd/mtdcore.c
+++ b/drivers/mtd/mtdcore.c
@@ -37,6 +37,7 @@
 #include <linux/backing-dev.h>
 #include <linux/gfp.h>
 #include <linux/slab.h>
+#include <linux/reboot.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
@@ -356,6 +357,17 @@ unsigned mtd_mmap_capabilities(struct mtd_info *mtd)
 EXPORT_SYMBOL_GPL(mtd_mmap_capabilities);
 #endif
 
+static int mtd_reboot_notifier(struct notifier_block *n, unsigned long state,
+                               void *cmd)
+{
+        struct mtd_info *mtd;
+
+        mtd = container_of(n, struct mtd_info, reboot_notifier);
+        mtd->_reboot(mtd);
+
+        return NOTIFY_DONE;
+}
+
 /**
  *      add_mtd_device - register an MTD device
  *      @mtd: pointer to new MTD device info structure
@@ -544,6 +556,19 @@ int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
                         err = -ENODEV;
         }
 
+        /*
+         * FIXME: some drivers unfortunately call this function more than once.
+         * So we have to check if we've already assigned the reboot notifier.
+         *
+         * Generally, we can make multiple calls work for most cases, but it
+         * does cause problems with parse_mtd_partitions() above (e.g.,
+         * cmdlineparts will register partitions more than once).
+         */
+        if (mtd->_reboot && !mtd->reboot_notifier.notifier_call) {
+                mtd->reboot_notifier.notifier_call = mtd_reboot_notifier;
+                register_reboot_notifier(&mtd->reboot_notifier);
+        }
+
         return err;
 }
 EXPORT_SYMBOL_GPL(mtd_device_parse_register);
@@ -558,6 +583,9 @@ int mtd_device_unregister(struct mtd_info *master)
 {
         int err;
 
+        if (master->_reboot)
+                unregister_reboot_notifier(&master->reboot_notifier);
+
         err = del_mtd_partitions(master);
         if (err)
                 return err;
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index 7d0150d20432..5b76a173cd95 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -421,7 +421,7 @@ config MTD_NAND_ORION
 
 config MTD_NAND_FSL_ELBC
         tristate "NAND support for Freescale eLBC controllers"
-        depends on PPC_OF
+        depends on PPC
         select FSL_LBC
         help
           Various Freescale chips, including the 8313, include a NAND Flash
@@ -524,4 +524,9 @@ config MTD_NAND_SUNXI
         help
           Enables support for NAND Flash chips on Allwinner SoCs.
 
+config MTD_NAND_HISI504
+        tristate "Support for NAND controller on Hisilicon SoC Hip04"
+        help
+          Enables support for NAND controller on Hisilicon SoC Hip04.
+
 endif # MTD_NAND
diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
index bd38f21d2e28..582bbd05aff7 100644
--- a/drivers/mtd/nand/Makefile
+++ b/drivers/mtd/nand/Makefile
@@ -51,5 +51,6 @@ obj-$(CONFIG_MTD_NAND_GPMI_NAND)	+= gpmi-nand/
 obj-$(CONFIG_MTD_NAND_XWAY)             += xway_nand.o
 obj-$(CONFIG_MTD_NAND_BCM47XXNFLASH)    += bcm47xxnflash/
 obj-$(CONFIG_MTD_NAND_SUNXI)            += sunxi_nand.o
+obj-$(CONFIG_MTD_NAND_HISI504)          += hisi504_nand.o
 
 nand-objs := nand_base.o nand_bbt.o nand_timings.o
diff --git a/drivers/mtd/nand/ams-delta.c b/drivers/mtd/nand/ams-delta.c
index f1d555cfb332..842f8fe91b56 100644
--- a/drivers/mtd/nand/ams-delta.c
+++ b/drivers/mtd/nand/ams-delta.c
@@ -183,7 +183,7 @@ static int ams_delta_init(struct platform_device *pdev)
                 return -ENXIO;
 
         /* Allocate memory for MTD device structure and private data */
-        ams_delta_mtd = kmalloc(sizeof(struct mtd_info) +
+        ams_delta_mtd = kzalloc(sizeof(struct mtd_info) +
                                 sizeof(struct nand_chip), GFP_KERNEL);
         if (!ams_delta_mtd) {
                 printk (KERN_WARNING "Unable to allocate E3 NAND MTD device structure.\n");
@@ -196,10 +196,6 @@ static int ams_delta_init(struct platform_device *pdev)
         /* Get pointer to private data */
         this = (struct nand_chip *) (&ams_delta_mtd[1]);
 
-        /* Initialize structures */
-        memset(ams_delta_mtd, 0, sizeof(struct mtd_info));
-        memset(this, 0, sizeof(struct nand_chip));
-
         /* Link the private data with the MTD structure */
         ams_delta_mtd->priv = this;
 
diff --git a/drivers/mtd/nand/atmel_nand.c b/drivers/mtd/nand/atmel_nand.c
index a345e7b2463a..d93c849b70b5 100644
--- a/drivers/mtd/nand/atmel_nand.c
+++ b/drivers/mtd/nand/atmel_nand.c
@@ -63,6 +63,10 @@ module_param(on_flash_bbt, int, 0);
 #include "atmel_nand_ecc.h"     /* Hardware ECC registers */
 #include "atmel_nand_nfc.h"     /* Nand Flash Controller definition */
 
+struct atmel_nand_caps {
+        bool pmecc_correct_erase_page;
+};
+
 /* oob layout for large page size
  * bad block info is on bytes 0 and 1
  * the bytes have to be consecutives to avoid
@@ -124,6 +128,7 @@ struct atmel_nand_host {
 
         struct atmel_nfc        *nfc;
 
+        struct atmel_nand_caps  *caps;
         bool                    has_pmecc;
         u8                      pmecc_corr_cap;
         u16                     pmecc_sector_size;
@@ -847,7 +852,11 @@ static int pmecc_correction(struct mtd_info *mtd, u32 pmecc_stat, uint8_t *buf,
         struct atmel_nand_host *host = nand_chip->priv;
         int i, err_nbr;
         uint8_t *buf_pos;
-        int total_err = 0;
+        int max_bitflips = 0;
+
+        /* If can correct bitfilps from erased page, do the normal check */
+        if (host->caps->pmecc_correct_erase_page)
+                goto normal_check;
 
         for (i = 0; i < nand_chip->ecc.total; i++)
                 if (ecc[i] != 0xff)
@@ -874,13 +883,13 @@ normal_check:
                                 pmecc_correct_data(mtd, buf_pos, ecc, i,
                                         nand_chip->ecc.bytes, err_nbr);
                                 mtd->ecc_stats.corrected += err_nbr;
-                                total_err += err_nbr;
+                                max_bitflips = max_t(int, max_bitflips, err_nbr);
                         }
                 }
                 pmecc_stat >>= 1;
         }
 
-        return total_err;
+        return max_bitflips;
 }
 
 static void pmecc_enable(struct atmel_nand_host *host, int ecc_op)
@@ -1474,6 +1483,8 @@ static void atmel_nand_hwctl(struct mtd_info *mtd, int mode)
                 ecc_writel(host->ecc, CR, ATMEL_ECC_RST);
 }
 
+static const struct of_device_id atmel_nand_dt_ids[];
+
 static int atmel_of_init_port(struct atmel_nand_host *host,
                               struct device_node *np)
 {
@@ -1483,6 +1494,9 @@ static int atmel_of_init_port(struct atmel_nand_host *host,
         struct atmel_nand_data *board = &host->board;
         enum of_gpio_flags flags = 0;
 
+        host->caps = (struct atmel_nand_caps *)
+                of_match_device(atmel_nand_dt_ids, host->dev)->data;
+
         if (of_property_read_u32(np, "atmel,nand-addr-offset", &val) == 0) {
                 if (val >= 32) {
                         dev_err(host->dev, "invalid addr-offset %u\n", val);
@@ -2288,8 +2302,17 @@ static int atmel_nand_remove(struct platform_device *pdev)
         return 0;
 }
 
+static struct atmel_nand_caps at91rm9200_caps = {
+        .pmecc_correct_erase_page = false,
+};
+
+static struct atmel_nand_caps sama5d4_caps = {
+        .pmecc_correct_erase_page = true,
+};
+
 static const struct of_device_id atmel_nand_dt_ids[] = {
-        { .compatible = "atmel,at91rm9200-nand" },
+        { .compatible = "atmel,at91rm9200-nand", .data = &at91rm9200_caps },
+        { .compatible = "atmel,sama5d4-nand", .data = &sama5d4_caps },
         { /* sentinel */ }
 };
 
diff --git a/drivers/mtd/nand/denali.c b/drivers/mtd/nand/denali.c
index b3b7ca1bafb8..f44c6061536a 100644
--- a/drivers/mtd/nand/denali.c
+++ b/drivers/mtd/nand/denali.c
@@ -1041,7 +1041,7 @@ static void denali_setup_dma(struct denali_nand_info *denali, int op)
         index_addr(denali, mode | ((addr >> 16) << 8), 0x2200);
 
         /* 3. set memory low address bits 23:8 */
-        index_addr(denali, mode | ((addr & 0xff) << 8), 0x2300);
+        index_addr(denali, mode | ((addr & 0xffff) << 8), 0x2300);
 
         /* 4. interrupt when complete, burst len = 64 bytes */
         index_addr(denali, mode | 0x14000, 0x2400);
@@ -1328,35 +1328,6 @@ static void denali_cmdfunc(struct mtd_info *mtd, unsigned int cmd, int col,
                 break;
         }
 }
-
-/* stubs for ECC functions not used by the NAND core */
-static int denali_ecc_calculate(struct mtd_info *mtd, const uint8_t *data,
-                                uint8_t *ecc_code)
-{
-        struct denali_nand_info *denali = mtd_to_denali(mtd);
-
-        dev_err(denali->dev, "denali_ecc_calculate called unexpectedly\n");
-        BUG();
-        return -EIO;
-}
-
-static int denali_ecc_correct(struct mtd_info *mtd, uint8_t *data,
-                                uint8_t *read_ecc, uint8_t *calc_ecc)
-{
-        struct denali_nand_info *denali = mtd_to_denali(mtd);
-
-        dev_err(denali->dev, "denali_ecc_correct called unexpectedly\n");
-        BUG();
-        return -EIO;
-}
-
-static void denali_ecc_hwctl(struct mtd_info *mtd, int mode)
-{
-        struct denali_nand_info *denali = mtd_to_denali(mtd);
-
-        dev_err(denali->dev, "denali_ecc_hwctl called unexpectedly\n");
-        BUG();
-}
 /* end NAND core entry points */
 
 /* Initialization code to bring the device up to a known good state */
@@ -1609,15 +1580,6 @@ int denali_init(struct denali_nand_info *denali)
         denali->totalblks = denali->mtd.size >> denali->nand.phys_erase_shift;
         denali->blksperchip = denali->totalblks / denali->nand.numchips;
 
-        /*
-         * These functions are required by the NAND core framework, otherwise,
-         * the NAND core will assert. However, we don't need them, so we'll stub
-         * them out.
-         */
-        denali->nand.ecc.calculate = denali_ecc_calculate;
-        denali->nand.ecc.correct = denali_ecc_correct;
-        denali->nand.ecc.hwctl = denali_ecc_hwctl;
-
         /* override the default read operations */
         denali->nand.ecc.size = ECC_SECTOR_SIZE * denali->devnum;
         denali->nand.ecc.read_page = denali_read_page;
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
index 4f3851a24bb2..33f3c3c54dbc 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
@@ -1294,14 +1294,6 @@ exit_auxiliary:
  * ecc.read_page or ecc.read_page_raw function. Thus, the fact that MTD wants an
  * ECC-based or raw view of the page is implicit in which function it calls
  * (there is a similar pair of ECC-based/raw functions for writing).
- *
- * FIXME: The following paragraph is incorrect, now that there exist
- * ecc.read_oob_raw and ecc.write_oob_raw functions.
- *
- * Since MTD assumes the OOB is not covered by ECC, there is no pair of
- * ECC-based/raw functions for reading or or writing the OOB. The fact that the
- * caller wants an ECC-based or raw view of the page is not propagated down to
- * this driver.
  */
 static int gpmi_ecc_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
                                 int page)
@@ -2029,7 +2021,6 @@ static int gpmi_nand_probe(struct platform_device *pdev)
 exit_nfc_init:
         release_resources(this);
 exit_acquire_resources:
-        dev_err(this->dev, "driver registration failed: %d\n", ret);
 
         return ret;
 }
diff --git a/drivers/mtd/nand/hisi504_nand.c b/drivers/mtd/nand/hisi504_nand.c
new file mode 100644
index 000000000000..289ad3ac3e80
--- /dev/null
+++ b/drivers/mtd/nand/hisi504_nand.c
@@ -0,0 +1,891 @@
+/*
+ * Hisilicon NAND Flash controller driver
+ *
+ * Copyright © 2012-2014 HiSilicon Technologies Co., Ltd.
+ *              http://www.hisilicon.com
+ *
+ * Author: Zhou Wang <wangzhou.bry@gmail.com>
+ * The initial developer of the original code is Zhiyong Cai
+ * <caizhiyong@huawei.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 <linux/of.h>
+#include <linux/of_mtd.h>
+#include <linux/mtd/mtd.h>
+#include <linux/sizes.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/mtd/nand.h>
+#include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
+#include <linux/mtd/partitions.h>
+
+#define HINFC504_MAX_CHIP                               (4)
+#define HINFC504_W_LATCH                                (5)
+#define HINFC504_R_LATCH                                (7)
+#define HINFC504_RW_LATCH                               (3)
+
+#define HINFC504_NFC_TIMEOUT                            (2 * HZ)
+#define HINFC504_NFC_PM_TIMEOUT                         (1 * HZ)
+#define HINFC504_NFC_DMA_TIMEOUT                        (5 * HZ)
+#define HINFC504_CHIP_DELAY                             (25)
+
+#define HINFC504_REG_BASE_ADDRESS_LEN                   (0x100)
+#define HINFC504_BUFFER_BASE_ADDRESS_LEN                (2048 + 128)
+
+#define HINFC504_ADDR_CYCLE_MASK                        0x4
+
+#define HINFC504_CON                                    0x00
+#define HINFC504_CON_OP_MODE_NORMAL                     BIT(0)
+#define HINFC504_CON_PAGEISZE_SHIFT                     (1)
+#define HINFC504_CON_PAGESIZE_MASK                      (0x07)
+#define HINFC504_CON_BUS_WIDTH                          BIT(4)
+#define HINFC504_CON_READY_BUSY_SEL                     BIT(8)
+#define HINFC504_CON_ECCTYPE_SHIFT                      (9)
+#define HINFC504_CON_ECCTYPE_MASK                       (0x07)
+
+#define HINFC504_PWIDTH                                 0x04
+#define SET_HINFC504_PWIDTH(_w_lcnt, _r_lcnt, _rw_hcnt) \
+        ((_w_lcnt) | (((_r_lcnt) & 0x0F) << 4) | (((_rw_hcnt) & 0x0F) << 8))
+
+#define HINFC504_CMD                                    0x0C
+#define HINFC504_ADDRL                                  0x10
+#define HINFC504_ADDRH                                  0x14
+#define HINFC504_DATA_NUM                               0x18
+
+#define HINFC504_OP                                     0x1C
+#define HINFC504_OP_READ_DATA_EN                        BIT(1)
+#define HINFC504_OP_WAIT_READY_EN                       BIT(2)
+#define HINFC504_OP_CMD2_EN                             BIT(3)
+#define HINFC504_OP_WRITE_DATA_EN                       BIT(4)
+#define HINFC504_OP_ADDR_EN                             BIT(5)
+#define HINFC504_OP_CMD1_EN                             BIT(6)
+#define HINFC504_OP_NF_CS_SHIFT                         (7)
+#define HINFC504_OP_NF_CS_MASK                          (3)
+#define HINFC504_OP_ADDR_CYCLE_SHIFT                    (9)
+#define HINFC504_OP_ADDR_CYCLE_MASK                     (7)
+
+#define HINFC504_STATUS                                 0x20
+#define HINFC504_READY                                  BIT(0)
+
+#define HINFC504_INTEN                                  0x24
+#define HINFC504_INTEN_DMA                              BIT(9)
+#define HINFC504_INTEN_UE                               BIT(6)
+#define HINFC504_INTEN_CE                               BIT(5)
+
+#define HINFC504_INTS                                   0x28
+#define HINFC504_INTS_DMA                               BIT(9)
+#define HINFC504_INTS_UE                                BIT(6)
+#define HINFC504_INTS_CE                                BIT(5)
+
+#define HINFC504_INTCLR                                 0x2C
+#define HINFC504_INTCLR_DMA                             BIT(9)
+#define HINFC504_INTCLR_UE                              BIT(6)
+#define HINFC504_INTCLR_CE                              BIT(5)
+
+#define HINFC504_ECC_STATUS                             0x5C
+#define HINFC504_ECC_16_BIT_SHIFT                       12
+
+#define HINFC504_DMA_CTRL                               0x60
+#define HINFC504_DMA_CTRL_DMA_START                     BIT(0)
+#define HINFC504_DMA_CTRL_WE                            BIT(1)
+#define HINFC504_DMA_CTRL_DATA_AREA_EN                  BIT(2)
+#define HINFC504_DMA_CTRL_OOB_AREA_EN                   BIT(3)
+#define HINFC504_DMA_CTRL_BURST4_EN                     BIT(4)
+#define HINFC504_DMA_CTRL_BURST8_EN                     BIT(5)
+#define HINFC504_DMA_CTRL_BURST16_EN                    BIT(6)
+#define HINFC504_DMA_CTRL_ADDR_NUM_SHIFT                (7)
+#define HINFC504_DMA_CTRL_ADDR_NUM_MASK                 (1)
+#define HINFC504_DMA_CTRL_CS_SHIFT                      (8)
+#define HINFC504_DMA_CTRL_CS_MASK                       (0x03)
+
+#define HINFC504_DMA_ADDR_DATA                          0x64
+#define HINFC504_DMA_ADDR_OOB                           0x68
+
+#define HINFC504_DMA_LEN                                0x6C
+#define HINFC504_DMA_LEN_OOB_SHIFT                      (16)
+#define HINFC504_DMA_LEN_OOB_MASK                       (0xFFF)
+
+#define HINFC504_DMA_PARA                               0x70
+#define HINFC504_DMA_PARA_DATA_RW_EN                    BIT(0)
+#define HINFC504_DMA_PARA_OOB_RW_EN                     BIT(1)
+#define HINFC504_DMA_PARA_DATA_EDC_EN                   BIT(2)
+#define HINFC504_DMA_PARA_OOB_EDC_EN                    BIT(3)
+#define HINFC504_DMA_PARA_DATA_ECC_EN                   BIT(4)
+#define HINFC504_DMA_PARA_OOB_ECC_EN                    BIT(5)
+
+#define HINFC_VERSION                                   0x74
+#define HINFC504_LOG_READ_ADDR                          0x7C
+#define HINFC504_LOG_READ_LEN                           0x80
+
+#define HINFC504_NANDINFO_LEN                           0x10
+
+struct hinfc_host {
+        struct nand_chip        chip;
+        struct mtd_info         mtd;
+        struct device           *dev;
+        void __iomem            *iobase;
+        void __iomem            *mmio;
+        struct completion       cmd_complete;
+        unsigned int            offset;
+        unsigned int            command;
+        int                     chipselect;
+        unsigned int            addr_cycle;
+        u32                     addr_value[2];
+        u32                     cache_addr_value[2];
+        char                    *buffer;
+        dma_addr_t              dma_buffer;
+        dma_addr_t              dma_oob;
+        int                     version;
+        unsigned int            irq_status; /* interrupt status */
+};
+
+static inline unsigned int hinfc_read(struct hinfc_host *host, unsigned int reg)
+{
+        return readl(host->iobase + reg);
+}
+
+static inline void hinfc_write(struct hinfc_host *host, unsigned int value,
+                               unsigned int reg)
+{
+        writel(value, host->iobase + reg);
+}
+
+static void wait_controller_finished(struct hinfc_host *host)
+{
+        unsigned long timeout = jiffies + HINFC504_NFC_TIMEOUT;
+        int val;
+
+        while (time_before(jiffies, timeout)) {
+                val = hinfc_read(host, HINFC504_STATUS);
+                if (host->command == NAND_CMD_ERASE2) {
+                        /* nfc is ready */
+                        while (!(val & HINFC504_READY)) {
+                                usleep_range(500, 1000);
+                                val = hinfc_read(host, HINFC504_STATUS);
+                        }
+                        return;
+                }
+
+                if (val & HINFC504_READY)
+                        return;
+        }
+
+        /* wait cmd timeout */
+        dev_err(host->dev, "Wait NAND controller exec cmd timeout.\n");
+}
+
+static void hisi_nfc_dma_transfer(struct hinfc_host *host, int todev)
+{
+        struct mtd_info *mtd = &host->mtd;
+        struct nand_chip *chip = mtd->priv;
+        unsigned long val;
+        int ret;
+
+        hinfc_write(host, host->dma_buffer, HINFC504_DMA_ADDR_DATA);
+        hinfc_write(host, host->dma_oob, HINFC504_DMA_ADDR_OOB);
+
+        if (chip->ecc.mode == NAND_ECC_NONE) {
+                hinfc_write(host, ((mtd->oobsize & HINFC504_DMA_LEN_OOB_MASK)
+                        << HINFC504_DMA_LEN_OOB_SHIFT), HINFC504_DMA_LEN);
+
+                hinfc_write(host, HINFC504_DMA_PARA_DATA_RW_EN
+                        | HINFC504_DMA_PARA_OOB_RW_EN, HINFC504_DMA_PARA);
+        } else {
+                if (host->command == NAND_CMD_READOOB)
+                        hinfc_write(host, HINFC504_DMA_PARA_OOB_RW_EN
+                        | HINFC504_DMA_PARA_OOB_EDC_EN
+                        | HINFC504_DMA_PARA_OOB_ECC_EN, HINFC504_DMA_PARA);
+                else
+                        hinfc_write(host, HINFC504_DMA_PARA_DATA_RW_EN
+                        | HINFC504_DMA_PARA_OOB_RW_EN
+                        | HINFC504_DMA_PARA_DATA_EDC_EN
+                        | HINFC504_DMA_PARA_OOB_EDC_EN
+                        | HINFC504_DMA_PARA_DATA_ECC_EN
+                        | HINFC504_DMA_PARA_OOB_ECC_EN, HINFC504_DMA_PARA);
+
+        }
+
+        val = (HINFC504_DMA_CTRL_DMA_START | HINFC504_DMA_CTRL_BURST4_EN
+                | HINFC504_DMA_CTRL_BURST8_EN | HINFC504_DMA_CTRL_BURST16_EN
+                | HINFC504_DMA_CTRL_DATA_AREA_EN | HINFC504_DMA_CTRL_OOB_AREA_EN
+                | ((host->addr_cycle == 4 ? 1 : 0)
+                        << HINFC504_DMA_CTRL_ADDR_NUM_SHIFT)
+                | ((host->chipselect & HINFC504_DMA_CTRL_CS_MASK)
+                        << HINFC504_DMA_CTRL_CS_SHIFT));
+
+        if (todev)
+                val |= HINFC504_DMA_CTRL_WE;
+
+        init_completion(&host->cmd_complete);
+
+        hinfc_write(host, val, HINFC504_DMA_CTRL);
+        ret = wait_for_completion_timeout(&host->cmd_complete,
+                        HINFC504_NFC_DMA_TIMEOUT);
+
+        if (!ret) {
+                dev_err(host->dev, "DMA operation(irq) timeout!\n");
+                /* sanity check */
+                val = hinfc_read(host, HINFC504_DMA_CTRL);
+                if (!(val & HINFC504_DMA_CTRL_DMA_START))
+                        dev_err(host->dev, "DMA is already done but without irq ACK!\n");
+                else
+                        dev_err(host->dev, "DMA is really timeout!\n");
+        }
+}
+
+static int hisi_nfc_send_cmd_pageprog(struct hinfc_host *host)
+{
+        host->addr_value[0] &= 0xffff0000;
+
+        hinfc_write(host, host->addr_value[0], HINFC504_ADDRL);
+        hinfc_write(host, host->addr_value[1], HINFC504_ADDRH);
+        hinfc_write(host, NAND_CMD_PAGEPROG << 8 | NAND_CMD_SEQIN,
+                    HINFC504_CMD);
+
+        hisi_nfc_dma_transfer(host, 1);
+
+        return 0;
+}
+
+static int hisi_nfc_send_cmd_readstart(struct hinfc_host *host)
+{
+        struct mtd_info *mtd = &host->mtd;
+
+        if ((host->addr_value[0] == host->cache_addr_value[0]) &&
+            (host->addr_value[1] == host->cache_addr_value[1]))
+                return 0;
+
+        host->addr_value[0] &= 0xffff0000;
+
+        hinfc_write(host, host->addr_value[0], HINFC504_ADDRL);
+        hinfc_write(host, host->addr_value[1], HINFC504_ADDRH);
+        hinfc_write(host, NAND_CMD_READSTART << 8 | NAND_CMD_READ0,
+                    HINFC504_CMD);
+
+        hinfc_write(host, 0, HINFC504_LOG_READ_ADDR);
+        hinfc_write(host, mtd->writesize + mtd->oobsize,
+                    HINFC504_LOG_READ_LEN);
+
+        hisi_nfc_dma_transfer(host, 0);
+
+        host->cache_addr_value[0] = host->addr_value[0];
+        host->cache_addr_value[1] = host->addr_value[1];
+
+        return 0;
+}
+
+static int hisi_nfc_send_cmd_erase(struct hinfc_host *host)
+{
+        hinfc_write(host, host->addr_value[0], HINFC504_ADDRL);
+        hinfc_write(host, (NAND_CMD_ERASE2 << 8) | NAND_CMD_ERASE1,
+                    HINFC504_CMD);
+
+        hinfc_write(host, HINFC504_OP_WAIT_READY_EN
+                | HINFC504_OP_CMD2_EN
+                | HINFC504_OP_CMD1_EN
+                | HINFC504_OP_ADDR_EN
+                | ((host->chipselect & HINFC504_OP_NF_CS_MASK)
+                        << HINFC504_OP_NF_CS_SHIFT)
+                | ((host->addr_cycle & HINFC504_OP_ADDR_CYCLE_MASK)
+                        << HINFC504_OP_ADDR_CYCLE_SHIFT),
+                HINFC504_OP);
+
+        wait_controller_finished(host);
+
+        return 0;
+}
+
+static int hisi_nfc_send_cmd_readid(struct hinfc_host *host)
+{
+        hinfc_write(host, HINFC504_NANDINFO_LEN, HINFC504_DATA_NUM);
+        hinfc_write(host, NAND_CMD_READID, HINFC504_CMD);
+        hinfc_write(host, 0, HINFC504_ADDRL);
+
+        hinfc_write(host, HINFC504_OP_CMD1_EN | HINFC504_OP_ADDR_EN
+                | HINFC504_OP_READ_DATA_EN
+                | ((host->chipselect & HINFC504_OP_NF_CS_MASK)
+                        << HINFC504_OP_NF_CS_SHIFT)
+                | 1 << HINFC504_OP_ADDR_CYCLE_SHIFT, HINFC504_OP);
+
+        wait_controller_finished(host);
+
+        return 0;
+}
+
+static int hisi_nfc_send_cmd_status(struct hinfc_host *host)
+{
+        hinfc_write(host, HINFC504_NANDINFO_LEN, HINFC504_DATA_NUM);
+        hinfc_write(host, NAND_CMD_STATUS, HINFC504_CMD);
+        hinfc_write(host, HINFC504_OP_CMD1_EN
+                | HINFC504_OP_READ_DATA_EN
+                | ((host->chipselect & HINFC504_OP_NF_CS_MASK)
+                        << HINFC504_OP_NF_CS_SHIFT),
+                HINFC504_OP);
+
+        wait_controller_finished(host);
+
+        return 0;
+}
+
+static int hisi_nfc_send_cmd_reset(struct hinfc_host *host, int chipselect)
+{
+        hinfc_write(host, NAND_CMD_RESET, HINFC504_CMD);
+
+        hinfc_write(host, HINFC504_OP_CMD1_EN
+                | ((chipselect & HINFC504_OP_NF_CS_MASK)
+                        << HINFC504_OP_NF_CS_SHIFT)
+                | HINFC504_OP_WAIT_READY_EN,
+                HINFC504_OP);
+
+        wait_controller_finished(host);
+
+        return 0;
+}
+
+static void hisi_nfc_select_chip(struct mtd_info *mtd, int chipselect)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct hinfc_host *host = chip->priv;
+
+        if (chipselect < 0)
+                return;
+
+        host->chipselect = chipselect;
+}
+
+static uint8_t hisi_nfc_read_byte(struct mtd_info *mtd)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct hinfc_host *host = chip->priv;
+
+        if (host->command == NAND_CMD_STATUS)
+                return *(uint8_t *)(host->mmio);
+
+        host->offset++;
+
+        if (host->command == NAND_CMD_READID)
+                return *(uint8_t *)(host->mmio + host->offset - 1);
+
+        return *(uint8_t *)(host->buffer + host->offset - 1);
+}
+
+static u16 hisi_nfc_read_word(struct mtd_info *mtd)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct hinfc_host *host = chip->priv;
+
+        host->offset += 2;
+        return *(u16 *)(host->buffer + host->offset - 2);
+}
+
+static void
+hisi_nfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct hinfc_host *host = chip->priv;
+
+        memcpy(host->buffer + host->offset, buf, len);
+        host->offset += len;
+}
+
+static void hisi_nfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct hinfc_host *host = chip->priv;
+
+        memcpy(buf, host->buffer + host->offset, len);
+        host->offset += len;
+}
+
+static void set_addr(struct mtd_info *mtd, int column, int page_addr)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct hinfc_host *host = chip->priv;
+        unsigned int command = host->command;
+
+        host->addr_cycle    = 0;
+        host->addr_value[0] = 0;
+        host->addr_value[1] = 0;
+
+        /* Serially input address */
+        if (column != -1) {
+                /* Adjust columns for 16 bit buswidth */
+                if (chip->options & NAND_BUSWIDTH_16 &&
+                                !nand_opcode_8bits(command))
+                        column >>= 1;
+
+                host->addr_value[0] = column & 0xffff;
+                host->addr_cycle    = 2;
+        }
+        if (page_addr != -1) {
+                host->addr_value[0] |= (page_addr & 0xffff)
+                        << (host->addr_cycle * 8);
+                host->addr_cycle    += 2;
+                /* One more address cycle for devices > 128MiB */
+                if (chip->chipsize > (128 << 20)) {
+                        host->addr_cycle += 1;
+                        if (host->command == NAND_CMD_ERASE1)
+                                host->addr_value[0] |= ((page_addr >> 16) & 0xff) << 16;
+                        else
+                                host->addr_value[1] |= ((page_addr >> 16) & 0xff);
+                }
+        }
+}
+
+static void hisi_nfc_cmdfunc(struct mtd_info *mtd, unsigned command, int column,
+                int page_addr)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct hinfc_host *host = chip->priv;
+        int is_cache_invalid = 1;
+        unsigned int flag = 0;
+
+        host->command =  command;
+
+        switch (command) {
+        case NAND_CMD_READ0:
+        case NAND_CMD_READOOB:
+                if (command == NAND_CMD_READ0)
+                        host->offset = column;
+                else
+                        host->offset = column + mtd->writesize;
+
+                is_cache_invalid = 0;
+                set_addr(mtd, column, page_addr);
+                hisi_nfc_send_cmd_readstart(host);
+                break;
+
+        case NAND_CMD_SEQIN:
+                host->offset = column;
+                set_addr(mtd, column, page_addr);
+                break;
+
+        case NAND_CMD_ERASE1:
+                set_addr(mtd, column, page_addr);
+                break;
+
+        case NAND_CMD_PAGEPROG:
+                hisi_nfc_send_cmd_pageprog(host);
+                break;
+
+        case NAND_CMD_ERASE2:
+                hisi_nfc_send_cmd_erase(host);
+                break;
+
+        case NAND_CMD_READID:
+                host->offset = column;
+                memset(host->mmio, 0, 0x10);
+                hisi_nfc_send_cmd_readid(host);
+                break;
+
+        case NAND_CMD_STATUS:
+                flag = hinfc_read(host, HINFC504_CON);
+                if (chip->ecc.mode == NAND_ECC_HW)
+                        hinfc_write(host,
+                                    flag & ~(HINFC504_CON_ECCTYPE_MASK <<
+                                    HINFC504_CON_ECCTYPE_SHIFT), HINFC504_CON);
+
+                host->offset = 0;
+                memset(host->mmio, 0, 0x10);
+                hisi_nfc_send_cmd_status(host);
+                hinfc_write(host, flag, HINFC504_CON);
+                break;
+
+        case NAND_CMD_RESET:
+                hisi_nfc_send_cmd_reset(host, host->chipselect);
+                break;
+
+        default:
+                dev_err(host->dev, "Error: unsupported cmd(cmd=%x, col=%x, page=%x)\n",
+                        command, column, page_addr);
+        }
+
+        if (is_cache_invalid) {
+                host->cache_addr_value[0] = ~0;
+                host->cache_addr_value[1] = ~0;
+        }
+}
+
+static irqreturn_t hinfc_irq_handle(int irq, void *devid)
+{
+        struct hinfc_host *host = devid;
+        unsigned int flag;
+
+        flag = hinfc_read(host, HINFC504_INTS);
+        /* store interrupts state */
+        host->irq_status |= flag;
+
+        if (flag & HINFC504_INTS_DMA) {
+                hinfc_write(host, HINFC504_INTCLR_DMA, HINFC504_INTCLR);
+                complete(&host->cmd_complete);
+        } else if (flag & HINFC504_INTS_CE) {
+                hinfc_write(host, HINFC504_INTCLR_CE, HINFC504_INTCLR);
+        } else if (flag & HINFC504_INTS_UE) {
+                hinfc_write(host, HINFC504_INTCLR_UE, HINFC504_INTCLR);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int hisi_nand_read_page_hwecc(struct mtd_info *mtd,
+        struct nand_chip *chip, uint8_t *buf, int oob_required, int page)
+{
+        struct hinfc_host *host = chip->priv;
+        int max_bitflips = 0, stat = 0, stat_max = 0, status_ecc;
+        int stat_1, stat_2;
+
+        chip->read_buf(mtd, buf, mtd->writesize);
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        /* errors which can not be corrected by ECC */
+        if (host->irq_status & HINFC504_INTS_UE) {
+                mtd->ecc_stats.failed++;
+        } else if (host->irq_status & HINFC504_INTS_CE) {
+                /* TODO: need add other ECC modes! */
+                switch (chip->ecc.strength) {
+                case 16:
+                        status_ecc = hinfc_read(host, HINFC504_ECC_STATUS) >>
+                                        HINFC504_ECC_16_BIT_SHIFT & 0x0fff;
+                        stat_2 = status_ecc & 0x3f;
+                        stat_1 = status_ecc >> 6 & 0x3f;
+                        stat = stat_1 + stat_2;
+                        stat_max = max_t(int, stat_1, stat_2);
+                }
+                mtd->ecc_stats.corrected += stat;
+                max_bitflips = max_t(int, max_bitflips, stat_max);
+        }
+        host->irq_status = 0;
+
+        return max_bitflips;
+}
+
+static int hisi_nand_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
+                                int page)
+{
+        struct hinfc_host *host = chip->priv;
+
+        chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        if (host->irq_status & HINFC504_INTS_UE) {
+                host->irq_status = 0;
+                return -EBADMSG;
+        }
+
+        host->irq_status = 0;
+        return 0;
+}
+
+static int hisi_nand_write_page_hwecc(struct mtd_info *mtd,
+                struct nand_chip *chip, const uint8_t *buf, int oob_required)
+{
+        chip->write_buf(mtd, buf, mtd->writesize);
+        if (oob_required)
+                chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
+}
+
+static void hisi_nfc_host_init(struct hinfc_host *host)
+{
+        struct nand_chip *chip = &host->chip;
+        unsigned int flag = 0;
+
+        host->version = hinfc_read(host, HINFC_VERSION);
+        host->addr_cycle                = 0;
+        host->addr_value[0]             = 0;
+        host->addr_value[1]             = 0;
+        host->cache_addr_value[0]       = ~0;
+        host->cache_addr_value[1]       = ~0;
+        host->chipselect                = 0;
+
+        /* default page size: 2K, ecc_none. need modify */
+        flag = HINFC504_CON_OP_MODE_NORMAL | HINFC504_CON_READY_BUSY_SEL
+                | ((0x001 & HINFC504_CON_PAGESIZE_MASK)
+                        << HINFC504_CON_PAGEISZE_SHIFT)
+                | ((0x0 & HINFC504_CON_ECCTYPE_MASK)
+                        << HINFC504_CON_ECCTYPE_SHIFT)
+                | ((chip->options & NAND_BUSWIDTH_16) ?
+                        HINFC504_CON_BUS_WIDTH : 0);
+        hinfc_write(host, flag, HINFC504_CON);
+
+        memset(host->mmio, 0xff, HINFC504_BUFFER_BASE_ADDRESS_LEN);
+
+        hinfc_write(host, SET_HINFC504_PWIDTH(HINFC504_W_LATCH,
+                    HINFC504_R_LATCH, HINFC504_RW_LATCH), HINFC504_PWIDTH);
+
+        /* enable DMA irq */
+        hinfc_write(host, HINFC504_INTEN_DMA, HINFC504_INTEN);
+}
+
+static struct nand_ecclayout nand_ecc_2K_16bits = {
+        .oobavail = 6,
+        .oobfree = { {2, 6} },
+};
+
+static int hisi_nfc_ecc_probe(struct hinfc_host *host)
+{
+        unsigned int flag;
+        int size, strength, ecc_bits;
+        struct device *dev = host->dev;
+        struct nand_chip *chip = &host->chip;
+        struct mtd_info *mtd = &host->mtd;
+        struct device_node *np = host->dev->of_node;
+
+        size = of_get_nand_ecc_step_size(np);
+        strength = of_get_nand_ecc_strength(np);
+        if (size != 1024) {
+                dev_err(dev, "error ecc size: %d\n", size);
+                return -EINVAL;
+        }
+
+        if ((size == 1024) && ((strength != 8) && (strength != 16) &&
+                                (strength != 24) && (strength != 40))) {
+                dev_err(dev, "ecc size and strength do not match\n");
+                return -EINVAL;
+        }
+
+        chip->ecc.size = size;
+        chip->ecc.strength = strength;
+
+        chip->ecc.read_page = hisi_nand_read_page_hwecc;
+        chip->ecc.read_oob = hisi_nand_read_oob;
+        chip->ecc.write_page = hisi_nand_write_page_hwecc;
+
+        switch (chip->ecc.strength) {
+        case 16:
+                ecc_bits = 6;
+                if (mtd->writesize == 2048)
+                        chip->ecc.layout = &nand_ecc_2K_16bits;
+
+                /* TODO: add more page size support */
+                break;
+
+        /* TODO: add more ecc strength support */
+        default:
+                dev_err(dev, "not support strength: %d\n", chip->ecc.strength);
+                return -EINVAL;
+        }
+
+        flag = hinfc_read(host, HINFC504_CON);
+        /* add ecc type configure */
+        flag |= ((ecc_bits & HINFC504_CON_ECCTYPE_MASK)
+                                                << HINFC504_CON_ECCTYPE_SHIFT);
+        hinfc_write(host, flag, HINFC504_CON);
+
+        /* enable ecc irq */
+        flag = hinfc_read(host, HINFC504_INTEN) & 0xfff;
+        hinfc_write(host, flag | HINFC504_INTEN_UE | HINFC504_INTEN_CE,
+                    HINFC504_INTEN);
+
+        return 0;
+}
+
+static int hisi_nfc_probe(struct platform_device *pdev)
+{
+        int ret = 0, irq, buswidth, flag, max_chips = HINFC504_MAX_CHIP;
+        struct device *dev = &pdev->dev;
+        struct hinfc_host *host;
+        struct nand_chip  *chip;
+        struct mtd_info   *mtd;
+        struct resource   *res;
+        struct device_node *np = dev->of_node;
+        struct mtd_part_parser_data ppdata;
+
+        host = devm_kzalloc(dev, sizeof(*host), GFP_KERNEL);
+        if (!host)
+                return -ENOMEM;
+        host->dev = dev;
+
+        platform_set_drvdata(pdev, host);
+        chip = &host->chip;
+        mtd  = &host->mtd;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(dev, "no IRQ resource defined\n");
+                ret = -ENXIO;
+                goto err_res;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        host->iobase = devm_ioremap_resource(dev, res);
+        if (IS_ERR(host->iobase)) {
+                ret = PTR_ERR(host->iobase);
+                goto err_res;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        host->mmio = devm_ioremap_resource(dev, res);
+        if (IS_ERR(host->mmio)) {
+                ret = PTR_ERR(host->mmio);
+                dev_err(dev, "devm_ioremap_resource[1] fail\n");
+                goto err_res;
+        }
+
+        mtd->priv               = chip;
+        mtd->owner              = THIS_MODULE;
+        mtd->name               = "hisi_nand";
+        mtd->dev.parent         = &pdev->dev;
+
+        chip->priv              = host;
+        chip->cmdfunc           = hisi_nfc_cmdfunc;
+        chip->select_chip       = hisi_nfc_select_chip;
+        chip->read_byte         = hisi_nfc_read_byte;
+        chip->read_word         = hisi_nfc_read_word;
+        chip->write_buf         = hisi_nfc_write_buf;
+        chip->read_buf          = hisi_nfc_read_buf;
+        chip->chip_delay        = HINFC504_CHIP_DELAY;
+
+        chip->ecc.mode = of_get_nand_ecc_mode(np);
+
+        buswidth = of_get_nand_bus_width(np);
+        if (buswidth == 16)
+                chip->options |= NAND_BUSWIDTH_16;
+
+        hisi_nfc_host_init(host);
+
+        ret = devm_request_irq(dev, irq, hinfc_irq_handle, IRQF_DISABLED,
+                                "nandc", host);
+        if (ret) {
+                dev_err(dev, "failed to request IRQ\n");
+                goto err_res;
+        }
+
+        ret = nand_scan_ident(mtd, max_chips, NULL);
+        if (ret) {
+                ret = -ENODEV;
+                goto err_res;
+        }
+
+        host->buffer = dmam_alloc_coherent(dev, mtd->writesize + mtd->oobsize,
+                &host->dma_buffer, GFP_KERNEL);
+        if (!host->buffer) {
+                ret = -ENOMEM;
+                goto err_res;
+        }
+
+        host->dma_oob = host->dma_buffer + mtd->writesize;
+        memset(host->buffer, 0xff, mtd->writesize + mtd->oobsize);
+
+        flag = hinfc_read(host, HINFC504_CON);
+        flag &= ~(HINFC504_CON_PAGESIZE_MASK << HINFC504_CON_PAGEISZE_SHIFT);
+        switch (mtd->writesize) {
+        case 2048:
+                flag |= (0x001 << HINFC504_CON_PAGEISZE_SHIFT); break;
+        /*
+         * TODO: add more pagesize support,
+         * default pagesize has been set in hisi_nfc_host_init
+         */
+        default:
+                dev_err(dev, "NON-2KB page size nand flash\n");
+                ret = -EINVAL;
+                goto err_res;
+        }
+        hinfc_write(host, flag, HINFC504_CON);
+
+        if (chip->ecc.mode == NAND_ECC_HW)
+                hisi_nfc_ecc_probe(host);
+
+        ret = nand_scan_tail(mtd);
+        if (ret) {
+                dev_err(dev, "nand_scan_tail failed: %d\n", ret);
+                goto err_res;
+        }
+
+        ppdata.of_node = np;
+        ret = mtd_device_parse_register(mtd, NULL, &ppdata, NULL, 0);
+        if (ret) {
+                dev_err(dev, "Err MTD partition=%d\n", ret);
+                goto err_mtd;
+        }
+
+        return 0;
+
+err_mtd:
+        nand_release(mtd);
+err_res:
+        return ret;
+}
+
+static int hisi_nfc_remove(struct platform_device *pdev)
+{
+        struct hinfc_host *host = platform_get_drvdata(pdev);
+        struct mtd_info *mtd = &host->mtd;
+
+        nand_release(mtd);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int hisi_nfc_suspend(struct device *dev)
+{
+        struct hinfc_host *host = dev_get_drvdata(dev);
+        unsigned long timeout = jiffies + HINFC504_NFC_PM_TIMEOUT;
+
+        while (time_before(jiffies, timeout)) {
+                if (((hinfc_read(host, HINFC504_STATUS) & 0x1) == 0x0) &&
+                    (hinfc_read(host, HINFC504_DMA_CTRL) &
+                     HINFC504_DMA_CTRL_DMA_START)) {
+                        cond_resched();
+                        return 0;
+                }
+        }
+
+        dev_err(host->dev, "nand controller suspend timeout.\n");
+
+        return -EAGAIN;
+}
+
+static int hisi_nfc_resume(struct device *dev)
+{
+        int cs;
+        struct hinfc_host *host = dev_get_drvdata(dev);
+        struct nand_chip *chip = &host->chip;
+
+        for (cs = 0; cs < chip->numchips; cs++)
+                hisi_nfc_send_cmd_reset(host, cs);
+        hinfc_write(host, SET_HINFC504_PWIDTH(HINFC504_W_LATCH,
+                    HINFC504_R_LATCH, HINFC504_RW_LATCH), HINFC504_PWIDTH);
+
+        return 0;
+}
+#endif
+static SIMPLE_DEV_PM_OPS(hisi_nfc_pm_ops, hisi_nfc_suspend, hisi_nfc_resume);
+
+static const struct of_device_id nfc_id_table[] = {
+        { .compatible = "hisilicon,504-nfc" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, nfc_id_table);
+
+static struct platform_driver hisi_nfc_driver = {
+        .driver = {
+                .name  = "hisi_nand",
+                .of_match_table = nfc_id_table,
+                .pm = &hisi_nfc_pm_ops,
+        },
+        .probe          = hisi_nfc_probe,
+        .remove         = hisi_nfc_remove,
+};
+
+module_platform_driver(hisi_nfc_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Zhou Wang");
+MODULE_AUTHOR("Zhiyong Cai");
+MODULE_DESCRIPTION("Hisilicon Nand Flash Controller Driver");
diff --git a/drivers/mtd/nand/jz4740_nand.c b/drivers/mtd/nand/jz4740_nand.c
index 1633ec9c5108..ebf2cce04cba 100644
--- a/drivers/mtd/nand/jz4740_nand.c
+++ b/drivers/mtd/nand/jz4740_nand.c
@@ -69,7 +69,7 @@ struct jz_nand {
 
         int selected_bank;
 
-        struct jz_nand_platform_data *pdata;
+        struct gpio_desc *busy_gpio;
         bool is_reading;
 };
 
@@ -131,7 +131,7 @@ static void jz_nand_cmd_ctrl(struct mtd_info *mtd, int dat, unsigned int ctrl)
 static int jz_nand_dev_ready(struct mtd_info *mtd)
 {
         struct jz_nand *nand = mtd_to_jz_nand(mtd);
-        return gpio_get_value_cansleep(nand->pdata->busy_gpio);
+        return gpiod_get_value_cansleep(nand->busy_gpio);
 }
 
 static void jz_nand_hwctl(struct mtd_info *mtd, int mode)
@@ -423,14 +423,12 @@ static int jz_nand_probe(struct platform_device *pdev)
         if (ret)
                 goto err_free;
 
-        if (pdata && gpio_is_valid(pdata->busy_gpio)) {
-                ret = gpio_request(pdata->busy_gpio, "NAND busy pin");
-                if (ret) {
-                        dev_err(&pdev->dev,
-                                "Failed to request busy gpio %d: %d\n",
-                                pdata->busy_gpio, ret);
-                        goto err_iounmap_mmio;
-                }
+        nand->busy_gpio = devm_gpiod_get_optional(&pdev->dev, "busy", GPIOD_IN);
+        if (IS_ERR(nand->busy_gpio)) {
+                ret = PTR_ERR(nand->busy_gpio);
+                dev_err(&pdev->dev, "Failed to request busy gpio %d\n",
+                    ret);
+                goto err_iounmap_mmio;
         }
 
         mtd             = &nand->mtd;
@@ -454,10 +452,9 @@ static int jz_nand_probe(struct platform_device *pdev)
         chip->cmd_ctrl = jz_nand_cmd_ctrl;
         chip->select_chip = jz_nand_select_chip;
 
-        if (pdata && gpio_is_valid(pdata->busy_gpio))
+        if (nand->busy_gpio)
                 chip->dev_ready = jz_nand_dev_ready;
 
-        nand->pdata = pdata;
         platform_set_drvdata(pdev, nand);
 
         /* We are going to autodetect NAND chips in the banks specified in the
@@ -496,7 +493,7 @@ static int jz_nand_probe(struct platform_device *pdev)
         }
         if (chipnr == 0) {
                 dev_err(&pdev->dev, "No NAND chips found\n");
-                goto err_gpio_busy;
+                goto err_iounmap_mmio;
         }
 
         if (pdata && pdata->ident_callback) {
@@ -533,9 +530,6 @@ err_unclaim_banks:
                                          nand->bank_base[bank - 1]);
         }
         writel(0, nand->base + JZ_REG_NAND_CTRL);
-err_gpio_busy:
-        if (pdata && gpio_is_valid(pdata->busy_gpio))
-                gpio_free(pdata->busy_gpio);
 err_iounmap_mmio:
         jz_nand_iounmap_resource(nand->mem, nand->base);
 err_free:
@@ -546,7 +540,6 @@ err_free:
 static int jz_nand_remove(struct platform_device *pdev)
 {
         struct jz_nand *nand = platform_get_drvdata(pdev);
-        struct jz_nand_platform_data *pdata = dev_get_platdata(&pdev->dev);
         size_t i;
 
         nand_release(&nand->mtd);
@@ -562,8 +555,6 @@ static int jz_nand_remove(struct platform_device *pdev)
                         gpio_free(JZ_GPIO_MEM_CS0 + bank - 1);
                 }
         }
-        if (pdata && gpio_is_valid(pdata->busy_gpio))
-                gpio_free(pdata->busy_gpio);
 
         jz_nand_iounmap_resource(nand->mem, nand->base);
 
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index 41585dfb206f..df7eb4ff07d1 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -157,7 +157,6 @@ static uint8_t nand_read_byte(struct mtd_info *mtd)
 
 /**
  * nand_read_byte16 - [DEFAULT] read one byte endianness aware from the chip
- * nand_read_byte16 - [DEFAULT] read one byte endianness aware from the chip
  * @mtd: MTD device structure
  *
  * Default read function for 16bit buswidth with endianness conversion.
@@ -1751,11 +1750,10 @@ static int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
 static int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
                                   int page)
 {
-        uint8_t *buf = chip->oob_poi;
         int length = mtd->oobsize;
         int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
         int eccsize = chip->ecc.size;
-        uint8_t *bufpoi = buf;
+        uint8_t *bufpoi = chip->oob_poi;
         int i, toread, sndrnd = 0, pos;
 
         chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page);
@@ -2944,6 +2942,16 @@ static void nand_resume(struct mtd_info *mtd)
                         __func__);
 }
 
+/**
+ * nand_shutdown - [MTD Interface] Finish the current NAND operation and
+ *                 prevent further operations
+ * @mtd: MTD device structure
+ */
+static void nand_shutdown(struct mtd_info *mtd)
+{
+        nand_get_device(mtd, FL_SHUTDOWN);
+}
+
 /* Set default functions */
 static void nand_set_defaults(struct nand_chip *chip, int busw)
 {
@@ -4028,22 +4036,24 @@ int nand_scan_tail(struct mtd_info *mtd)
                 ecc->read_oob = nand_read_oob_std;
                 ecc->write_oob = nand_write_oob_std;
                 /*
-                 * Board driver should supply ecc.size and ecc.bytes values to
-                 * select how many bits are correctable; see nand_bch_init()
-                 * for details. Otherwise, default to 4 bits for large page
-                 * devices.
+                 * Board driver should supply ecc.size and ecc.strength values
+                 * to select how many bits are correctable. Otherwise, default
+                 * to 4 bits for large page devices.
                  */
                 if (!ecc->size && (mtd->oobsize >= 64)) {
                         ecc->size = 512;
-                        ecc->bytes = DIV_ROUND_UP(13 * ecc->strength, 8);
+                        ecc->strength = 4;
                 }
+
+                /* See nand_bch_init() for details. */
+                ecc->bytes = DIV_ROUND_UP(
+                                ecc->strength * fls(8 * ecc->size), 8);
                 ecc->priv = nand_bch_init(mtd, ecc->size, ecc->bytes,
                                                &ecc->layout);
                 if (!ecc->priv) {
                         pr_warn("BCH ECC initialization failed!\n");
                         BUG();
                 }
-                ecc->strength = ecc->bytes * 8 / fls(8 * ecc->size);
                 break;
 
         case NAND_ECC_NONE:
@@ -4146,6 +4156,7 @@ int nand_scan_tail(struct mtd_info *mtd)
         mtd->_unlock = NULL;
         mtd->_suspend = nand_suspend;
         mtd->_resume = nand_resume;
+        mtd->_reboot = nand_shutdown;
         mtd->_block_isreserved = nand_block_isreserved;
         mtd->_block_isbad = nand_block_isbad;
         mtd->_block_markbad = nand_block_markbad;
@@ -4161,7 +4172,7 @@ int nand_scan_tail(struct mtd_info *mtd)
          * properly set.
          */
         if (!mtd->bitflip_threshold)
-                mtd->bitflip_threshold = mtd->ecc_strength;
+                mtd->bitflip_threshold = DIV_ROUND_UP(mtd->ecc_strength * 3, 4);
 
         /* Check, if we should skip the bad block table scan */
         if (chip->options & NAND_SKIP_BBTSCAN)
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index ab5bbf567439..f2324271b94e 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -245,7 +245,6 @@ MODULE_PARM_DESC(bch,		 "Enable BCH ecc and set how many bits should "
 #define STATE_DATAOUT          0x00001000 /* waiting for page data output */
 #define STATE_DATAOUT_ID       0x00002000 /* waiting for ID bytes output */
 #define STATE_DATAOUT_STATUS   0x00003000 /* waiting for status output */
-#define STATE_DATAOUT_STATUS_M 0x00004000 /* waiting for multi-plane status output */
 #define STATE_DATAOUT_MASK     0x00007000 /* data output states mask */
 
 /* Previous operation is done, ready to accept new requests */
@@ -269,7 +268,6 @@ MODULE_PARM_DESC(bch,		 "Enable BCH ecc and set how many bits should "
 #define OPT_ANY          0xFFFFFFFF /* any chip supports this operation */
 #define OPT_PAGE512      0x00000002 /* 512-byte  page chips */
 #define OPT_PAGE2048     0x00000008 /* 2048-byte page chips */
-#define OPT_SMARTMEDIA   0x00000010 /* SmartMedia technology chips */
 #define OPT_PAGE512_8BIT 0x00000040 /* 512-byte page chips with 8-bit bus width */
 #define OPT_PAGE4096     0x00000080 /* 4096-byte page chips */
 #define OPT_LARGEPAGE    (OPT_PAGE2048 | OPT_PAGE4096) /* 2048 & 4096-byte page chips */
@@ -1096,8 +1094,6 @@ static char *get_state_name(uint32_t state)
                         return "STATE_DATAOUT_ID";
                 case STATE_DATAOUT_STATUS:
                         return "STATE_DATAOUT_STATUS";
-                case STATE_DATAOUT_STATUS_M:
-                        return "STATE_DATAOUT_STATUS_M";
                 case STATE_READY:
                         return "STATE_READY";
                 case STATE_UNKNOWN:
@@ -1865,7 +1861,6 @@ static void switch_state(struct nandsim *ns)
                                 break;
 
                         case STATE_DATAOUT_STATUS:
-                        case STATE_DATAOUT_STATUS_M:
                                 ns->regs.count = ns->regs.num = 0;
                                 break;
 
@@ -2005,7 +2000,6 @@ static void ns_nand_write_byte(struct mtd_info *mtd, u_char byte)
                 }
 
                 if (NS_STATE(ns->state) == STATE_DATAOUT_STATUS
-                        || NS_STATE(ns->state) == STATE_DATAOUT_STATUS_M
                         || NS_STATE(ns->state) == STATE_DATAOUT) {
                         int row = ns->regs.row;
 
@@ -2343,6 +2337,7 @@ static int __init ns_init_module(void)
                 }
                 chip->ecc.mode = NAND_ECC_SOFT_BCH;
                 chip->ecc.size = 512;
+                chip->ecc.strength = bch;
                 chip->ecc.bytes = eccbytes;
                 NS_INFO("using %u-bit/%u bytes BCH ECC\n", bch, chip->ecc.size);
         }
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index 63f858e6bf39..60fa89939c24 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -1048,10 +1048,9 @@ static int omap_dev_ready(struct mtd_info *mtd)
  * @mtd: MTD device structure
  * @mode: Read/Write mode
  *
- * When using BCH, sector size is hardcoded to 512 bytes.
- * Using wrapping mode 6 both for reading and writing if ELM module not uses
- * for error correction.
- * On writing,
+ * When using BCH with SW correction (i.e. no ELM), sector size is set
+ * to 512 bytes and we use BCH_WRAPMODE_6 wrapping mode
+ * for both reading and writing with:
  * eccsize0 = 0  (no additional protected byte in spare area)
  * eccsize1 = 32 (skip 32 nibbles = 16 bytes per sector in spare area)
  */
@@ -1071,15 +1070,9 @@ static void __maybe_unused omap_enable_hwecc_bch(struct mtd_info *mtd, int mode)
         case OMAP_ECC_BCH4_CODE_HW_DETECTION_SW:
                 bch_type = 0;
                 nsectors = 1;
-                if (mode == NAND_ECC_READ) {
-                        wr_mode   = BCH_WRAPMODE_6;
-                        ecc_size0 = BCH_ECC_SIZE0;
-                        ecc_size1 = BCH_ECC_SIZE1;
-                } else {
-                        wr_mode   = BCH_WRAPMODE_6;
-                        ecc_size0 = BCH_ECC_SIZE0;
-                        ecc_size1 = BCH_ECC_SIZE1;
-                }
+                wr_mode   = BCH_WRAPMODE_6;
+                ecc_size0 = BCH_ECC_SIZE0;
+                ecc_size1 = BCH_ECC_SIZE1;
                 break;
         case OMAP_ECC_BCH4_CODE_HW:
                 bch_type = 0;
@@ -1097,15 +1090,9 @@ static void __maybe_unused omap_enable_hwecc_bch(struct mtd_info *mtd, int mode)
         case OMAP_ECC_BCH8_CODE_HW_DETECTION_SW:
                 bch_type = 1;
                 nsectors = 1;
-                if (mode == NAND_ECC_READ) {
-                        wr_mode   = BCH_WRAPMODE_6;
-                        ecc_size0 = BCH_ECC_SIZE0;
-                        ecc_size1 = BCH_ECC_SIZE1;
-                } else {
-                        wr_mode   = BCH_WRAPMODE_6;
-                        ecc_size0 = BCH_ECC_SIZE0;
-                        ecc_size1 = BCH_ECC_SIZE1;
-                }
+                wr_mode   = BCH_WRAPMODE_6;
+                ecc_size0 = BCH_ECC_SIZE0;
+                ecc_size1 = BCH_ECC_SIZE1;
                 break;
         case OMAP_ECC_BCH8_CODE_HW:
                 bch_type = 1;
diff --git a/drivers/mtd/nand/sunxi_nand.c b/drivers/mtd/nand/sunxi_nand.c
index ccaa8e283388..6f93b2990d25 100644
--- a/drivers/mtd/nand/sunxi_nand.c
+++ b/drivers/mtd/nand/sunxi_nand.c
@@ -1110,8 +1110,6 @@ static int sunxi_nand_ecc_init(struct mtd_info *mtd, struct nand_ecc_ctrl *ecc,
 
         switch (ecc->mode) {
         case NAND_ECC_SOFT_BCH:
-                ecc->bytes = DIV_ROUND_UP(ecc->strength * fls(8 * ecc->size),
-                                          8);
                 break;
         case NAND_ECC_HW:
                 ret = sunxi_nand_hw_ecc_ctrl_init(mtd, ecc, np);
diff --git a/drivers/mtd/nftlmount.c b/drivers/mtd/nftlmount.c
index 51b9d6af307f..a5dfbfbebfca 100644
--- a/drivers/mtd/nftlmount.c
+++ b/drivers/mtd/nftlmount.c
@@ -89,9 +89,10 @@ static int find_boot_record(struct NFTLrecord *nftl)
                 }
 
                 /* To be safer with BIOS, also use erase mark as discriminant */
-                if ((ret = nftl_read_oob(mtd, block * nftl->EraseSize +
+                ret = nftl_read_oob(mtd, block * nftl->EraseSize +
                                          SECTORSIZE + 8, 8, &retlen,
-                                         (char *)&h1) < 0)) {
+                                         (char *)&h1);
+                if (ret < 0) {
                         printk(KERN_WARNING "ANAND header found at 0x%x in mtd%d, but OOB data read failed (err %d)\n",
                                block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
                         continue;
@@ -109,8 +110,9 @@ static int find_boot_record(struct NFTLrecord *nftl)
                 }
 
                 /* Finally reread to check ECC */
-                if ((ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
-                                     &retlen, buf) < 0)) {
+                ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
+                                &retlen, buf);
+                if (ret < 0) {
                         printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but ECC read failed (err %d)\n",
                                block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
                         continue;
@@ -228,9 +230,11 @@ device is already correct.
 The new DiskOnChip driver already scanned the bad block table.  Just query it.
                         if ((i & (SECTORSIZE - 1)) == 0) {
                                 /* read one sector for every SECTORSIZE of blocks */
-                                if ((ret = mtd->read(nftl->mbd.mtd, block * nftl->EraseSize +
-                                                     i + SECTORSIZE, SECTORSIZE, &retlen,
-                                                     buf)) < 0) {
+                                ret = mtd->read(nftl->mbd.mtd,
+                                                block * nftl->EraseSize + i +
+                                                SECTORSIZE, SECTORSIZE,
+                                                &retlen, buf);
+                                if (ret < 0) {
                                         printk(KERN_NOTICE "Read of bad sector table failed (err %d)\n",
                                                ret);
                                         kfree(nftl->ReplUnitTable);
diff --git a/drivers/mtd/spi-nor/fsl-quadspi.c b/drivers/mtd/spi-nor/fsl-quadspi.c
index 39763b94f67d..1c7308c2c77d 100644
--- a/drivers/mtd/spi-nor/fsl-quadspi.c
+++ b/drivers/mtd/spi-nor/fsl-quadspi.c
@@ -57,7 +57,9 @@
 
 #define QUADSPI_BUF3CR                  0x1c
 #define QUADSPI_BUF3CR_ALLMST_SHIFT     31
-#define QUADSPI_BUF3CR_ALLMST           (1 << QUADSPI_BUF3CR_ALLMST_SHIFT)
+#define QUADSPI_BUF3CR_ALLMST_MASK      (1 << QUADSPI_BUF3CR_ALLMST_SHIFT)
+#define QUADSPI_BUF3CR_ADATSZ_SHIFT             8
+#define QUADSPI_BUF3CR_ADATSZ_MASK      (0xFF << QUADSPI_BUF3CR_ADATSZ_SHIFT)
 
 #define QUADSPI_BFGENCR                 0x20
 #define QUADSPI_BFGENCR_PAR_EN_SHIFT    16
@@ -198,18 +200,21 @@ struct fsl_qspi_devtype_data {
         enum fsl_qspi_devtype devtype;
         int rxfifo;
         int txfifo;
+        int ahb_buf_size;
 };
 
 static struct fsl_qspi_devtype_data vybrid_data = {
         .devtype = FSL_QUADSPI_VYBRID,
         .rxfifo = 128,
-        .txfifo = 64
+        .txfifo = 64,
+        .ahb_buf_size = 1024
 };
 
 static struct fsl_qspi_devtype_data imx6sx_data = {
         .devtype = FSL_QUADSPI_IMX6SX,
         .rxfifo = 128,
-        .txfifo = 512
+        .txfifo = 512,
+        .ahb_buf_size = 1024
 };
 
 #define FSL_QSPI_MAX_CHIP       4
@@ -227,6 +232,7 @@ struct fsl_qspi {
         u32 nor_num;
         u32 clk_rate;
         unsigned int chip_base_addr; /* We may support two chips. */
+        bool has_second_chip;
 };
 
 static inline int is_vybrid_qspi(struct fsl_qspi *q)
@@ -583,7 +589,12 @@ static void fsl_qspi_init_abh_read(struct fsl_qspi *q)
         writel(QUADSPI_BUFXCR_INVALID_MSTRID, base + QUADSPI_BUF0CR);
         writel(QUADSPI_BUFXCR_INVALID_MSTRID, base + QUADSPI_BUF1CR);
         writel(QUADSPI_BUFXCR_INVALID_MSTRID, base + QUADSPI_BUF2CR);
-        writel(QUADSPI_BUF3CR_ALLMST, base + QUADSPI_BUF3CR);
+        /*
+         * Set ADATSZ with the maximum AHB buffer size to improve the
+         * read performance.
+         */
+        writel(QUADSPI_BUF3CR_ALLMST_MASK | ((q->devtype_data->ahb_buf_size / 8)
+                        << QUADSPI_BUF3CR_ADATSZ_SHIFT), base + QUADSPI_BUF3CR);
 
         /* We only use the buffer3 */
         writel(0, base + QUADSPI_BUF0IND);
@@ -783,7 +794,6 @@ static int fsl_qspi_probe(struct platform_device *pdev)
         struct spi_nor *nor;
         struct mtd_info *mtd;
         int ret, i = 0;
-        bool has_second_chip = false;
         const struct of_device_id *of_id =
                         of_match_device(fsl_qspi_dt_ids, &pdev->dev);
 
@@ -798,37 +808,30 @@ static int fsl_qspi_probe(struct platform_device *pdev)
         /* find the resources */
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "QuadSPI");
         q->iobase = devm_ioremap_resource(dev, res);
-        if (IS_ERR(q->iobase)) {
-                ret = PTR_ERR(q->iobase);
-                goto map_failed;
-        }
+        if (IS_ERR(q->iobase))
+                return PTR_ERR(q->iobase);
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
                                         "QuadSPI-memory");
         q->ahb_base = devm_ioremap_resource(dev, res);
-        if (IS_ERR(q->ahb_base)) {
-                ret = PTR_ERR(q->ahb_base);
-                goto map_failed;
-        }
+        if (IS_ERR(q->ahb_base))
+                return PTR_ERR(q->ahb_base);
+
         q->memmap_phy = res->start;
 
         /* find the clocks */
         q->clk_en = devm_clk_get(dev, "qspi_en");
-        if (IS_ERR(q->clk_en)) {
-                ret = PTR_ERR(q->clk_en);
-                goto map_failed;
-        }
+        if (IS_ERR(q->clk_en))
+                return PTR_ERR(q->clk_en);
 
         q->clk = devm_clk_get(dev, "qspi");
-        if (IS_ERR(q->clk)) {
-                ret = PTR_ERR(q->clk);
-                goto map_failed;
-        }
+        if (IS_ERR(q->clk))
+                return PTR_ERR(q->clk);
 
         ret = clk_prepare_enable(q->clk_en);
         if (ret) {
                 dev_err(dev, "can not enable the qspi_en clock\n");
-                goto map_failed;
+                return ret;
         }
 
         ret = clk_prepare_enable(q->clk);
@@ -860,14 +863,14 @@ static int fsl_qspi_probe(struct platform_device *pdev)
                 goto irq_failed;
 
         if (of_get_property(np, "fsl,qspi-has-second-chip", NULL))
-                has_second_chip = true;
+                q->has_second_chip = true;
 
         /* iterate the subnodes. */
         for_each_available_child_of_node(dev->of_node, np) {
                 char modalias[40];
 
                 /* skip the holes */
-                if (!has_second_chip)
+                if (!q->has_second_chip)
                         i *= 2;
 
                 nor = &q->nor[i];
@@ -890,24 +893,24 @@ static int fsl_qspi_probe(struct platform_device *pdev)
 
                 ret = of_modalias_node(np, modalias, sizeof(modalias));
                 if (ret < 0)
-                        goto map_failed;
+                        goto irq_failed;
 
                 ret = of_property_read_u32(np, "spi-max-frequency",
                                 &q->clk_rate);
                 if (ret < 0)
-                        goto map_failed;
+                        goto irq_failed;
 
                 /* set the chip address for READID */
                 fsl_qspi_set_base_addr(q, nor);
 
                 ret = spi_nor_scan(nor, modalias, SPI_NOR_QUAD);
                 if (ret)
-                        goto map_failed;
+                        goto irq_failed;
 
                 ppdata.of_node = np;
                 ret = mtd_device_parse_register(mtd, NULL, &ppdata, NULL, 0);
                 if (ret)
-                        goto map_failed;
+                        goto irq_failed;
 
                 /* Set the correct NOR size now. */
                 if (q->nor_size == 0) {
@@ -939,19 +942,19 @@ static int fsl_qspi_probe(struct platform_device *pdev)
 
         clk_disable(q->clk);
         clk_disable(q->clk_en);
-        dev_info(dev, "QuadSPI SPI NOR flash driver\n");
         return 0;
 
 last_init_failed:
-        for (i = 0; i < q->nor_num; i++)
+        for (i = 0; i < q->nor_num; i++) {
+                /* skip the holes */
+                if (!q->has_second_chip)
+                        i *= 2;
                 mtd_device_unregister(&q->mtd[i]);
-
+        }
 irq_failed:
         clk_disable_unprepare(q->clk);
 clk_failed:
         clk_disable_unprepare(q->clk_en);
-map_failed:
-        dev_err(dev, "Freescale QuadSPI probe failed\n");
         return ret;
 }
 
@@ -960,8 +963,12 @@ static int fsl_qspi_remove(struct platform_device *pdev)
         struct fsl_qspi *q = platform_get_drvdata(pdev);
         int i;
 
-        for (i = 0; i < q->nor_num; i++)
+        for (i = 0; i < q->nor_num; i++) {
+                /* skip the holes */
+                if (!q->has_second_chip)
+                        i *= 2;
                 mtd_device_unregister(&q->mtd[i]);
+        }
 
         /* disable the hardware */
         writel(QUADSPI_MCR_MDIS_MASK, q->iobase + QUADSPI_MCR);
@@ -972,6 +979,22 @@ static int fsl_qspi_remove(struct platform_device *pdev)
         return 0;
 }
 
+static int fsl_qspi_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        return 0;
+}
+
+static int fsl_qspi_resume(struct platform_device *pdev)
+{
+        struct fsl_qspi *q = platform_get_drvdata(pdev);
+
+        fsl_qspi_nor_setup(q);
+        fsl_qspi_set_map_addr(q);
+        fsl_qspi_nor_setup_last(q);
+
+        return 0;
+}
+
 static struct platform_driver fsl_qspi_driver = {
         .driver = {
                 .name   = "fsl-quadspi",
@@ -980,6 +1003,8 @@ static struct platform_driver fsl_qspi_driver = {
         },
         .probe          = fsl_qspi_probe,
         .remove         = fsl_qspi_remove,
+        .suspend        = fsl_qspi_suspend,
+        .resume         = fsl_qspi_resume,
 };
 module_platform_driver(fsl_qspi_driver);
 
diff --git a/drivers/mtd/spi-nor/spi-nor.c b/drivers/mtd/spi-nor/spi-nor.c
index 0f8ec3c2d015..b6a5a0c269e1 100644
--- a/drivers/mtd/spi-nor/spi-nor.c
+++ b/drivers/mtd/spi-nor/spi-nor.c
@@ -538,6 +538,7 @@ static const struct spi_device_id spi_nor_ids[] = {
         /* GigaDevice */
         { "gd25q32", INFO(0xc84016, 0, 64 * 1024,  64, SECT_4K) },
         { "gd25q64", INFO(0xc84017, 0, 64 * 1024, 128, SECT_4K) },
+        { "gd25q128", INFO(0xc84018, 0, 64 * 1024, 256, SECT_4K) },
 
         /* Intel/Numonyx -- xxxs33b */
         { "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, 0) },
@@ -560,14 +561,14 @@ static const struct spi_device_id spi_nor_ids[] = {
         { "mx66l1g55g",  INFO(0xc2261b, 0, 64 * 1024, 2048, SPI_NOR_QUAD_READ) },
 
         /* Micron */
-        { "n25q032",     INFO(0x20ba16, 0, 64 * 1024,   64, 0) },
-        { "n25q064",     INFO(0x20ba17, 0, 64 * 1024,  128, 0) },
-        { "n25q128a11",  INFO(0x20bb18, 0, 64 * 1024,  256, 0) },
-        { "n25q128a13",  INFO(0x20ba18, 0, 64 * 1024,  256, 0) },
-        { "n25q256a",    INFO(0x20ba19, 0, 64 * 1024,  512, SECT_4K) },
-        { "n25q512a",    INFO(0x20bb20, 0, 64 * 1024, 1024, SECT_4K) },
-        { "n25q512ax3",  INFO(0x20ba20, 0, 64 * 1024, 1024, USE_FSR) },
-        { "n25q00",      INFO(0x20ba21, 0, 64 * 1024, 2048, USE_FSR) },
+        { "n25q032",     INFO(0x20ba16, 0, 64 * 1024,   64, SPI_NOR_QUAD_READ) },
+        { "n25q064",     INFO(0x20ba17, 0, 64 * 1024,  128, SPI_NOR_QUAD_READ) },
+        { "n25q128a11",  INFO(0x20bb18, 0, 64 * 1024,  256, SPI_NOR_QUAD_READ) },
+        { "n25q128a13",  INFO(0x20ba18, 0, 64 * 1024,  256, SPI_NOR_QUAD_READ) },
+        { "n25q256a",    INFO(0x20ba19, 0, 64 * 1024,  512, SECT_4K | SPI_NOR_QUAD_READ) },
+        { "n25q512a",    INFO(0x20bb20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
+        { "n25q512ax3",  INFO(0x20ba20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
+        { "n25q00",      INFO(0x20ba21, 0, 64 * 1024, 2048, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
 
         /* PMC */
         { "pm25lv512",   INFO(0,        0, 32 * 1024,    2, SECT_4K_PMC) },
@@ -891,6 +892,45 @@ static int spansion_quad_enable(struct spi_nor *nor)
         return 0;
 }
 
+static int micron_quad_enable(struct spi_nor *nor)
+{
+        int ret;
+        u8 val;
+
+        ret = nor->read_reg(nor, SPINOR_OP_RD_EVCR, &val, 1);
+        if (ret < 0) {
+                dev_err(nor->dev, "error %d reading EVCR\n", ret);
+                return ret;
+        }
+
+        write_enable(nor);
+
+        /* set EVCR, enable quad I/O */
+        nor->cmd_buf[0] = val & ~EVCR_QUAD_EN_MICRON;
+        ret = nor->write_reg(nor, SPINOR_OP_WD_EVCR, nor->cmd_buf, 1, 0);
+        if (ret < 0) {
+                dev_err(nor->dev, "error while writing EVCR register\n");
+                return ret;
+        }
+
+        ret = spi_nor_wait_till_ready(nor);
+        if (ret)
+                return ret;
+
+        /* read EVCR and check it */
+        ret = nor->read_reg(nor, SPINOR_OP_RD_EVCR, &val, 1);
+        if (ret < 0) {
+                dev_err(nor->dev, "error %d reading EVCR\n", ret);
+                return ret;
+        }
+        if (val & EVCR_QUAD_EN_MICRON) {
+                dev_err(nor->dev, "Micron EVCR Quad bit not clear\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static int set_quad_mode(struct spi_nor *nor, struct flash_info *info)
 {
         int status;
@@ -903,6 +943,13 @@ static int set_quad_mode(struct spi_nor *nor, struct flash_info *info)
                         return -EINVAL;
                 }
                 return status;
+        case CFI_MFR_ST:
+                status = micron_quad_enable(nor);
+                if (status) {
+                        dev_err(nor->dev, "Micron quad-read not enabled\n");
+                        return -EINVAL;
+                }
+                return status;
         default:
                 status = spansion_quad_enable(nor);
                 if (status) {
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 84673ebcf428..df51d6025a90 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -157,7 +157,7 @@ config IPVLAN
       making it transparent to the connected L2 switch.
 
       Ipvlan devices can be added using the "ip" command from the
-      iproute2 package starting with the iproute2-X.Y.ZZ release:
+      iproute2 package starting with the iproute2-3.19 release:
 
       "ip link add link <main-dev> [ NAME ] type ipvlan"
 
diff --git a/drivers/net/appletalk/Kconfig b/drivers/net/appletalk/Kconfig
index 4ce6ca5f3d36..dc6b78e5342f 100644
--- a/drivers/net/appletalk/Kconfig
+++ b/drivers/net/appletalk/Kconfig
@@ -40,7 +40,7 @@ config DEV_APPLETALK
 
 config LTPC
         tristate "Apple/Farallon LocalTalk PC support"
-        depends on DEV_APPLETALK && (ISA || EISA) && ISA_DMA_API
+        depends on DEV_APPLETALK && (ISA || EISA) && ISA_DMA_API && VIRT_TO_BUS
         help
           This allows you to use the AppleTalk PC card to connect to LocalTalk
           networks. The card is also known as the Farallon PhoneNet PC card.
diff --git a/drivers/net/dsa/bcm_sf2.h b/drivers/net/dsa/bcm_sf2.h
index 0f217e99904f..22e2ebf31333 100644
--- a/drivers/net/dsa/bcm_sf2.h
+++ b/drivers/net/dsa/bcm_sf2.h
@@ -107,8 +107,8 @@ static inline u64 name##_readq(struct bcm_sf2_priv *priv, u32 off)	\
 {                                                                       \
         u32 indir, dir;                                                 \
         spin_lock(&priv->indir_lock);                                   \
-        indir = reg_readl(priv, REG_DIR_DATA_READ);                     \
         dir = __raw_readl(priv->name + off);                            \
+        indir = reg_readl(priv, REG_DIR_DATA_READ);                     \
         spin_unlock(&priv->indir_lock);                                 \
         return (u64)indir << 32 | dir;                                  \
 }                                                                       \
diff --git a/drivers/net/ethernet/8390/axnet_cs.c b/drivers/net/ethernet/8390/axnet_cs.c
index 7769c05543f1..ec6eac1f8c95 100644
--- a/drivers/net/ethernet/8390/axnet_cs.c
+++ b/drivers/net/ethernet/8390/axnet_cs.c
@@ -484,11 +484,8 @@ static int axnet_open(struct net_device *dev)
     link->open++;
 
     info->link_status = 0x00;
-    init_timer(&info->watchdog);
-    info->watchdog.function = ei_watchdog;
-    info->watchdog.data = (u_long)dev;
-    info->watchdog.expires = jiffies + HZ;
-    add_timer(&info->watchdog);
+    setup_timer(&info->watchdog, ei_watchdog, (u_long)dev);
+    mod_timer(&info->watchdog, jiffies + HZ);
 
     return ax_open(dev);
 } /* axnet_open */
diff --git a/drivers/net/ethernet/8390/pcnet_cs.c b/drivers/net/ethernet/8390/pcnet_cs.c
index 9fb7b9d4fd6c..2777289a26c0 100644
--- a/drivers/net/ethernet/8390/pcnet_cs.c
+++ b/drivers/net/ethernet/8390/pcnet_cs.c
@@ -918,11 +918,8 @@ static int pcnet_open(struct net_device *dev)
 
     info->phy_id = info->eth_phy;
     info->link_status = 0x00;
-    init_timer(&info->watchdog);
-    info->watchdog.function = ei_watchdog;
-    info->watchdog.data = (u_long)dev;
-    info->watchdog.expires = jiffies + HZ;
-    add_timer(&info->watchdog);
+    setup_timer(&info->watchdog, ei_watchdog, (u_long)dev);
+    mod_timer(&info->watchdog, jiffies + HZ);
 
     return ei_open(dev);
 } /* pcnet_open */
diff --git a/drivers/net/ethernet/altera/altera_tse_main.c b/drivers/net/ethernet/altera/altera_tse_main.c
index a1ee261bff5c..fd9296a5014d 100644
--- a/drivers/net/ethernet/altera/altera_tse_main.c
+++ b/drivers/net/ethernet/altera/altera_tse_main.c
@@ -376,7 +376,8 @@ static int tse_rx(struct altera_tse_private *priv, int limit)
         u16 pktlength;
         u16 pktstatus;
 
-        while ((rxstatus = priv->dmaops->get_rx_status(priv)) != 0) {
+        while (((rxstatus = priv->dmaops->get_rx_status(priv)) != 0) &&
+               (count < limit))  {
                 pktstatus = rxstatus >> 16;
                 pktlength = rxstatus & 0xffff;
 
@@ -491,28 +492,27 @@ static int tse_poll(struct napi_struct *napi, int budget)
         struct altera_tse_private *priv =
                         container_of(napi, struct altera_tse_private, napi);
         int rxcomplete = 0;
-        int txcomplete = 0;
         unsigned long int flags;
 
-        txcomplete = tse_tx_complete(priv);
+        tse_tx_complete(priv);
 
         rxcomplete = tse_rx(priv, budget);
 
-        if (rxcomplete >= budget || txcomplete > 0)
-                return rxcomplete;
+        if (rxcomplete < budget) {
 
-        napi_gro_flush(napi, false);
-        __napi_complete(napi);
+                napi_gro_flush(napi, false);
+                __napi_complete(napi);
 
-        netdev_dbg(priv->dev,
-                   "NAPI Complete, did %d packets with budget %d\n",
-                   txcomplete+rxcomplete, budget);
+                netdev_dbg(priv->dev,
+                           "NAPI Complete, did %d packets with budget %d\n",
+                           rxcomplete, budget);
 
-        spin_lock_irqsave(&priv->rxdma_irq_lock, flags);
-        priv->dmaops->enable_rxirq(priv);
-        priv->dmaops->enable_txirq(priv);
-        spin_unlock_irqrestore(&priv->rxdma_irq_lock, flags);
-        return rxcomplete + txcomplete;
+                spin_lock_irqsave(&priv->rxdma_irq_lock, flags);
+                priv->dmaops->enable_rxirq(priv);
+                priv->dmaops->enable_txirq(priv);
+                spin_unlock_irqrestore(&priv->rxdma_irq_lock, flags);
+        }
+        return rxcomplete;
 }
 
 /* DMA TX & RX FIFO interrupt routing
@@ -521,7 +521,6 @@ static irqreturn_t altera_isr(int irq, void *dev_id)
 {
         struct net_device *dev = dev_id;
         struct altera_tse_private *priv;
-        unsigned long int flags;
 
         if (unlikely(!dev)) {
                 pr_err("%s: invalid dev pointer\n", __func__);
@@ -529,20 +528,20 @@ static irqreturn_t altera_isr(int irq, void *dev_id)
         }
         priv = netdev_priv(dev);
 
-        /* turn off desc irqs and enable napi rx */
-        spin_lock_irqsave(&priv->rxdma_irq_lock, flags);
+        spin_lock(&priv->rxdma_irq_lock);
+        /* reset IRQs */
+        priv->dmaops->clear_rxirq(priv);
+        priv->dmaops->clear_txirq(priv);
+        spin_unlock(&priv->rxdma_irq_lock);
 
         if (likely(napi_schedule_prep(&priv->napi))) {
+                spin_lock(&priv->rxdma_irq_lock);
                 priv->dmaops->disable_rxirq(priv);
                 priv->dmaops->disable_txirq(priv);
+                spin_unlock(&priv->rxdma_irq_lock);
                 __napi_schedule(&priv->napi);
         }
 
-        /* reset IRQs */
-        priv->dmaops->clear_rxirq(priv);
-        priv->dmaops->clear_txirq(priv);
-
-        spin_unlock_irqrestore(&priv->rxdma_irq_lock, flags);
 
         return IRQ_HANDLED;
 }
@@ -1407,7 +1406,7 @@ static int altera_tse_probe(struct platform_device *pdev)
         }
 
         if (of_property_read_u32(pdev->dev.of_node, "tx-fifo-depth",
-                                 &priv->rx_fifo_depth)) {
+                                 &priv->tx_fifo_depth)) {
                 dev_err(&pdev->dev, "cannot obtain tx-fifo-depth\n");
                 ret = -ENXIO;
                 goto err_free_netdev;
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
index b93d4404d975..885b02b5be07 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
@@ -609,6 +609,68 @@ static void xgbe_napi_disable(struct xgbe_prv_data *pdata, unsigned int del)
         }
 }
 
+static int xgbe_request_irqs(struct xgbe_prv_data *pdata)
+{
+        struct xgbe_channel *channel;
+        struct net_device *netdev = pdata->netdev;
+        unsigned int i;
+        int ret;
+
+        ret = devm_request_irq(pdata->dev, pdata->dev_irq, xgbe_isr, 0,
+                               netdev->name, pdata);
+        if (ret) {
+                netdev_alert(netdev, "error requesting irq %d\n",
+                             pdata->dev_irq);
+                return ret;
+        }
+
+        if (!pdata->per_channel_irq)
+                return 0;
+
+        channel = pdata->channel;
+        for (i = 0; i < pdata->channel_count; i++, channel++) {
+                snprintf(channel->dma_irq_name,
+                         sizeof(channel->dma_irq_name) - 1,
+                         "%s-TxRx-%u", netdev_name(netdev),
+                         channel->queue_index);
+
+                ret = devm_request_irq(pdata->dev, channel->dma_irq,
+                                       xgbe_dma_isr, 0,
+                                       channel->dma_irq_name, channel);
+                if (ret) {
+                        netdev_alert(netdev, "error requesting irq %d\n",
+                                     channel->dma_irq);
+                        goto err_irq;
+                }
+        }
+
+        return 0;
+
+err_irq:
+        /* Using an unsigned int, 'i' will go to UINT_MAX and exit */
+        for (i--, channel--; i < pdata->channel_count; i--, channel--)
+                devm_free_irq(pdata->dev, channel->dma_irq, channel);
+
+        devm_free_irq(pdata->dev, pdata->dev_irq, pdata);
+
+        return ret;
+}
+
+static void xgbe_free_irqs(struct xgbe_prv_data *pdata)
+{
+        struct xgbe_channel *channel;
+        unsigned int i;
+
+        devm_free_irq(pdata->dev, pdata->dev_irq, pdata);
+
+        if (!pdata->per_channel_irq)
+                return;
+
+        channel = pdata->channel;
+        for (i = 0; i < pdata->channel_count; i++, channel++)
+                devm_free_irq(pdata->dev, channel->dma_irq, channel);
+}
+
 void xgbe_init_tx_coalesce(struct xgbe_prv_data *pdata)
 {
         struct xgbe_hw_if *hw_if = &pdata->hw_if;
@@ -810,20 +872,20 @@ int xgbe_powerdown(struct net_device *netdev, unsigned int caller)
                 return -EINVAL;
         }
 
-        phy_stop(pdata->phydev);
-
         spin_lock_irqsave(&pdata->lock, flags);
 
         if (caller == XGMAC_DRIVER_CONTEXT)
                 netif_device_detach(netdev);
 
         netif_tx_stop_all_queues(netdev);
-        xgbe_napi_disable(pdata, 0);
 
-        /* Powerdown Tx/Rx */
         hw_if->powerdown_tx(pdata);
         hw_if->powerdown_rx(pdata);
 
+        xgbe_napi_disable(pdata, 0);
+
+        phy_stop(pdata->phydev);
+
         pdata->power_down = 1;
 
         spin_unlock_irqrestore(&pdata->lock, flags);
@@ -854,14 +916,14 @@ int xgbe_powerup(struct net_device *netdev, unsigned int caller)
 
         phy_start(pdata->phydev);
 
-        /* Enable Tx/Rx */
+        xgbe_napi_enable(pdata, 0);
+
         hw_if->powerup_tx(pdata);
         hw_if->powerup_rx(pdata);
 
         if (caller == XGMAC_DRIVER_CONTEXT)
                 netif_device_attach(netdev);
 
-        xgbe_napi_enable(pdata, 0);
         netif_tx_start_all_queues(netdev);
 
         spin_unlock_irqrestore(&pdata->lock, flags);
@@ -875,6 +937,7 @@ static int xgbe_start(struct xgbe_prv_data *pdata)
 {
         struct xgbe_hw_if *hw_if = &pdata->hw_if;
         struct net_device *netdev = pdata->netdev;
+        int ret;
 
         DBGPR("-->xgbe_start\n");
 
@@ -884,17 +947,31 @@ static int xgbe_start(struct xgbe_prv_data *pdata)
 
         phy_start(pdata->phydev);
 
+        xgbe_napi_enable(pdata, 1);
+
+        ret = xgbe_request_irqs(pdata);
+        if (ret)
+                goto err_napi;
+
         hw_if->enable_tx(pdata);
         hw_if->enable_rx(pdata);
 
         xgbe_init_tx_timers(pdata);
 
-        xgbe_napi_enable(pdata, 1);
         netif_tx_start_all_queues(netdev);
 
         DBGPR("<--xgbe_start\n");
 
         return 0;
+
+err_napi:
+        xgbe_napi_disable(pdata, 1);
+
+        phy_stop(pdata->phydev);
+
+        hw_if->exit(pdata);
+
+        return ret;
 }
 
 static void xgbe_stop(struct xgbe_prv_data *pdata)
@@ -907,16 +984,21 @@ static void xgbe_stop(struct xgbe_prv_data *pdata)
 
         DBGPR("-->xgbe_stop\n");
 
-        phy_stop(pdata->phydev);
-
         netif_tx_stop_all_queues(netdev);
-        xgbe_napi_disable(pdata, 1);
 
         xgbe_stop_tx_timers(pdata);
 
         hw_if->disable_tx(pdata);
         hw_if->disable_rx(pdata);
 
+        xgbe_free_irqs(pdata);
+
+        xgbe_napi_disable(pdata, 1);
+
+        phy_stop(pdata->phydev);
+
+        hw_if->exit(pdata);
+
         channel = pdata->channel;
         for (i = 0; i < pdata->channel_count; i++, channel++) {
                 if (!channel->tx_ring)
@@ -931,10 +1013,6 @@ static void xgbe_stop(struct xgbe_prv_data *pdata)
 
 static void xgbe_restart_dev(struct xgbe_prv_data *pdata)
 {
-        struct xgbe_channel *channel;
-        struct xgbe_hw_if *hw_if = &pdata->hw_if;
-        unsigned int i;
-
         DBGPR("-->xgbe_restart_dev\n");
 
         /* If not running, "restart" will happen on open */
@@ -942,19 +1020,10 @@ static void xgbe_restart_dev(struct xgbe_prv_data *pdata)
                 return;
 
         xgbe_stop(pdata);
-        synchronize_irq(pdata->dev_irq);
-        if (pdata->per_channel_irq) {
-                channel = pdata->channel;
-                for (i = 0; i < pdata->channel_count; i++, channel++)
-                        synchronize_irq(channel->dma_irq);
-        }
 
         xgbe_free_tx_data(pdata);
         xgbe_free_rx_data(pdata);
 
-        /* Issue software reset to device */
-        hw_if->exit(pdata);
-
         xgbe_start(pdata);
 
         DBGPR("<--xgbe_restart_dev\n");
@@ -1283,10 +1352,7 @@ static void xgbe_packet_info(struct xgbe_prv_data *pdata,
 static int xgbe_open(struct net_device *netdev)
 {
         struct xgbe_prv_data *pdata = netdev_priv(netdev);
-        struct xgbe_hw_if *hw_if = &pdata->hw_if;
         struct xgbe_desc_if *desc_if = &pdata->desc_if;
-        struct xgbe_channel *channel = NULL;
-        unsigned int i = 0;
         int ret;
 
         DBGPR("-->xgbe_open\n");
@@ -1329,55 +1395,14 @@ static int xgbe_open(struct net_device *netdev)
         INIT_WORK(&pdata->restart_work, xgbe_restart);
         INIT_WORK(&pdata->tx_tstamp_work, xgbe_tx_tstamp);
 
-        /* Request interrupts */
-        ret = devm_request_irq(pdata->dev, pdata->dev_irq, xgbe_isr, 0,
-                               netdev->name, pdata);
-        if (ret) {
-                netdev_alert(netdev, "error requesting irq %d\n",
-                             pdata->dev_irq);
-                goto err_rings;
-        }
-
-        if (pdata->per_channel_irq) {
-                channel = pdata->channel;
-                for (i = 0; i < pdata->channel_count; i++, channel++) {
-                        snprintf(channel->dma_irq_name,
-                                 sizeof(channel->dma_irq_name) - 1,
-                                 "%s-TxRx-%u", netdev_name(netdev),
-                                 channel->queue_index);
-
-                        ret = devm_request_irq(pdata->dev, channel->dma_irq,
-                                               xgbe_dma_isr, 0,
-                                               channel->dma_irq_name, channel);
-                        if (ret) {
-                                netdev_alert(netdev,
-                                             "error requesting irq %d\n",
-                                             channel->dma_irq);
-                                goto err_irq;
-                        }
-                }
-        }
-
         ret = xgbe_start(pdata);
         if (ret)
-                goto err_start;
+                goto err_rings;
 
         DBGPR("<--xgbe_open\n");
 
         return 0;
 
-err_start:
-        hw_if->exit(pdata);
-
-err_irq:
-        if (pdata->per_channel_irq) {
-                /* Using an unsigned int, 'i' will go to UINT_MAX and exit */
-                for (i--, channel--; i < pdata->channel_count; i--, channel--)
-                        devm_free_irq(pdata->dev, channel->dma_irq, channel);
-        }
-
-        devm_free_irq(pdata->dev, pdata->dev_irq, pdata);
-
 err_rings:
         desc_if->free_ring_resources(pdata);
 
@@ -1399,30 +1424,16 @@ err_phy_init:
 static int xgbe_close(struct net_device *netdev)
 {
         struct xgbe_prv_data *pdata = netdev_priv(netdev);
-        struct xgbe_hw_if *hw_if = &pdata->hw_if;
         struct xgbe_desc_if *desc_if = &pdata->desc_if;
-        struct xgbe_channel *channel;
-        unsigned int i;
 
         DBGPR("-->xgbe_close\n");
 
         /* Stop the device */
         xgbe_stop(pdata);
 
-        /* Issue software reset to device */
-        hw_if->exit(pdata);
-
         /* Free the ring descriptors and buffers */
         desc_if->free_ring_resources(pdata);
 
-        /* Release the interrupts */
-        devm_free_irq(pdata->dev, pdata->dev_irq, pdata);
-        if (pdata->per_channel_irq) {
-                channel = pdata->channel;
-                for (i = 0; i < pdata->channel_count; i++, channel++)
-                        devm_free_irq(pdata->dev, channel->dma_irq, channel);
-        }
-
         /* Free the channel and ring structures */
         xgbe_free_channels(pdata);
 
diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c
index 5b308a4a4d0e..783543ad1fcf 100644
--- a/drivers/net/ethernet/broadcom/bcmsysport.c
+++ b/drivers/net/ethernet/broadcom/bcmsysport.c
@@ -274,9 +274,9 @@ static const struct bcm_sysport_stats bcm_sysport_gstrings_stats[] = {
         /* RBUF misc statistics */
         STAT_RBUF("rbuf_ovflow_cnt", mib.rbuf_ovflow_cnt, RBUF_OVFL_DISC_CNTR),
         STAT_RBUF("rbuf_err_cnt", mib.rbuf_err_cnt, RBUF_ERR_PKT_CNTR),
-        STAT_MIB_RX("alloc_rx_buff_failed", mib.alloc_rx_buff_failed),
-        STAT_MIB_RX("rx_dma_failed", mib.rx_dma_failed),
-        STAT_MIB_TX("tx_dma_failed", mib.tx_dma_failed),
+        STAT_MIB_SOFT("alloc_rx_buff_failed", mib.alloc_rx_buff_failed),
+        STAT_MIB_SOFT("rx_dma_failed", mib.rx_dma_failed),
+        STAT_MIB_SOFT("tx_dma_failed", mib.tx_dma_failed),
 };
 
 #define BCM_SYSPORT_STATS_LEN   ARRAY_SIZE(bcm_sysport_gstrings_stats)
@@ -345,6 +345,7 @@ static void bcm_sysport_update_mib_counters(struct bcm_sysport_priv *priv)
                 s = &bcm_sysport_gstrings_stats[i];
                 switch (s->type) {
                 case BCM_SYSPORT_STAT_NETDEV:
+                case BCM_SYSPORT_STAT_SOFT:
                         continue;
                 case BCM_SYSPORT_STAT_MIB_RX:
                 case BCM_SYSPORT_STAT_MIB_TX:
diff --git a/drivers/net/ethernet/broadcom/bcmsysport.h b/drivers/net/ethernet/broadcom/bcmsysport.h
index fc19417d82a5..7e3d87a88c76 100644
--- a/drivers/net/ethernet/broadcom/bcmsysport.h
+++ b/drivers/net/ethernet/broadcom/bcmsysport.h
@@ -570,6 +570,7 @@ enum bcm_sysport_stat_type {
         BCM_SYSPORT_STAT_RUNT,
         BCM_SYSPORT_STAT_RXCHK,
         BCM_SYSPORT_STAT_RBUF,
+        BCM_SYSPORT_STAT_SOFT,
 };
 
 /* Macros to help define ethtool statistics */
@@ -590,6 +591,7 @@ enum bcm_sysport_stat_type {
 #define STAT_MIB_RX(str, m) STAT_MIB(str, m, BCM_SYSPORT_STAT_MIB_RX)
 #define STAT_MIB_TX(str, m) STAT_MIB(str, m, BCM_SYSPORT_STAT_MIB_TX)
 #define STAT_RUNT(str, m) STAT_MIB(str, m, BCM_SYSPORT_STAT_RUNT)
+#define STAT_MIB_SOFT(str, m) STAT_MIB(str, m, BCM_SYSPORT_STAT_SOFT)
 
 #define STAT_RXCHK(str, m, ofs) { \
         .stat_string = str, \
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.c b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
index 51300532ec26..84feb241d60b 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.c
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
@@ -487,6 +487,7 @@ enum bcmgenet_stat_type {
         BCMGENET_STAT_MIB_TX,
         BCMGENET_STAT_RUNT,
         BCMGENET_STAT_MISC,
+        BCMGENET_STAT_SOFT,
 };
 
 struct bcmgenet_stats {
@@ -515,6 +516,7 @@ struct bcmgenet_stats {
 #define STAT_GENET_MIB_RX(str, m) STAT_GENET_MIB(str, m, BCMGENET_STAT_MIB_RX)
 #define STAT_GENET_MIB_TX(str, m) STAT_GENET_MIB(str, m, BCMGENET_STAT_MIB_TX)
 #define STAT_GENET_RUNT(str, m) STAT_GENET_MIB(str, m, BCMGENET_STAT_RUNT)
+#define STAT_GENET_SOFT_MIB(str, m) STAT_GENET_MIB(str, m, BCMGENET_STAT_SOFT)
 
 #define STAT_GENET_MISC(str, m, offset) { \
         .stat_string = str, \
@@ -614,9 +616,9 @@ static const struct bcmgenet_stats bcmgenet_gstrings_stats[] = {
                         UMAC_RBUF_OVFL_CNT),
         STAT_GENET_MISC("rbuf_err_cnt", mib.rbuf_err_cnt, UMAC_RBUF_ERR_CNT),
         STAT_GENET_MISC("mdf_err_cnt", mib.mdf_err_cnt, UMAC_MDF_ERR_CNT),
-        STAT_GENET_MIB_RX("alloc_rx_buff_failed", mib.alloc_rx_buff_failed),
-        STAT_GENET_MIB_RX("rx_dma_failed", mib.rx_dma_failed),
-        STAT_GENET_MIB_TX("tx_dma_failed", mib.tx_dma_failed),
+        STAT_GENET_SOFT_MIB("alloc_rx_buff_failed", mib.alloc_rx_buff_failed),
+        STAT_GENET_SOFT_MIB("rx_dma_failed", mib.rx_dma_failed),
+        STAT_GENET_SOFT_MIB("tx_dma_failed", mib.tx_dma_failed),
 };
 
 #define BCMGENET_STATS_LEN      ARRAY_SIZE(bcmgenet_gstrings_stats)
@@ -668,6 +670,7 @@ static void bcmgenet_update_mib_counters(struct bcmgenet_priv *priv)
                 s = &bcmgenet_gstrings_stats[i];
                 switch (s->type) {
                 case BCMGENET_STAT_NETDEV:
+                case BCMGENET_STAT_SOFT:
                         continue;
                 case BCMGENET_STAT_MIB_RX:
                 case BCMGENET_STAT_MIB_TX:
@@ -971,13 +974,14 @@ static inline void bcmgenet_tx_ring_int_disable(struct bcmgenet_priv *priv,
 }
 
 /* Unlocked version of the reclaim routine */
-static void __bcmgenet_tx_reclaim(struct net_device *dev,
-                                  struct bcmgenet_tx_ring *ring)
+static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
+                                          struct bcmgenet_tx_ring *ring)
 {
         struct bcmgenet_priv *priv = netdev_priv(dev);
         int last_tx_cn, last_c_index, num_tx_bds;
         struct enet_cb *tx_cb_ptr;
         struct netdev_queue *txq;
+        unsigned int pkts_compl = 0;
         unsigned int bds_compl;
         unsigned int c_index;
 
@@ -1005,6 +1009,7 @@ static void __bcmgenet_tx_reclaim(struct net_device *dev,
                 tx_cb_ptr = ring->cbs + last_c_index;
                 bds_compl = 0;
                 if (tx_cb_ptr->skb) {
+                        pkts_compl++;
                         bds_compl = skb_shinfo(tx_cb_ptr->skb)->nr_frags + 1;
                         dev->stats.tx_bytes += tx_cb_ptr->skb->len;
                         dma_unmap_single(&dev->dev,
@@ -1028,23 +1033,45 @@ static void __bcmgenet_tx_reclaim(struct net_device *dev,
                 last_c_index &= (num_tx_bds - 1);
         }
 
-        if (ring->free_bds > (MAX_SKB_FRAGS + 1))
-                ring->int_disable(priv, ring);
-
-        if (netif_tx_queue_stopped(txq))
-                netif_tx_wake_queue(txq);
+        if (ring->free_bds > (MAX_SKB_FRAGS + 1)) {
+                if (netif_tx_queue_stopped(txq))
+                        netif_tx_wake_queue(txq);
+        }
 
         ring->c_index = c_index;
+
+        return pkts_compl;
 }
 
-static void bcmgenet_tx_reclaim(struct net_device *dev,
+static unsigned int bcmgenet_tx_reclaim(struct net_device *dev,
                                 struct bcmgenet_tx_ring *ring)
 {
+        unsigned int released;
         unsigned long flags;
 
         spin_lock_irqsave(&ring->lock, flags);
-        __bcmgenet_tx_reclaim(dev, ring);
+        released = __bcmgenet_tx_reclaim(dev, ring);
         spin_unlock_irqrestore(&ring->lock, flags);
+
+        return released;
+}
+
+static int bcmgenet_tx_poll(struct napi_struct *napi, int budget)
+{
+        struct bcmgenet_tx_ring *ring =
+                container_of(napi, struct bcmgenet_tx_ring, napi);
+        unsigned int work_done = 0;
+
+        work_done = bcmgenet_tx_reclaim(ring->priv->dev, ring);
+
+        if (work_done == 0) {
+                napi_complete(napi);
+                ring->int_enable(ring->priv, ring);
+
+                return 0;
+        }
+
+        return budget;
 }
 
 static void bcmgenet_tx_reclaim_all(struct net_device *dev)
@@ -1302,10 +1329,8 @@ static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
         bcmgenet_tdma_ring_writel(priv, ring->index,
                                   ring->prod_index, TDMA_PROD_INDEX);
 
-        if (ring->free_bds <= (MAX_SKB_FRAGS + 1)) {
+        if (ring->free_bds <= (MAX_SKB_FRAGS + 1))
                 netif_tx_stop_queue(txq);
-                ring->int_enable(priv, ring);
-        }
 
 out:
         spin_unlock_irqrestore(&ring->lock, flags);
@@ -1621,6 +1646,7 @@ static int init_umac(struct bcmgenet_priv *priv)
         struct device *kdev = &priv->pdev->dev;
         int ret;
         u32 reg, cpu_mask_clear;
+        int index;
 
         dev_dbg(&priv->pdev->dev, "bcmgenet: init_umac\n");
 
@@ -1647,7 +1673,7 @@ static int init_umac(struct bcmgenet_priv *priv)
 
         bcmgenet_intr_disable(priv);
 
-        cpu_mask_clear = UMAC_IRQ_RXDMA_BDONE;
+        cpu_mask_clear = UMAC_IRQ_RXDMA_BDONE | UMAC_IRQ_TXDMA_BDONE;
 
         dev_dbg(kdev, "%s:Enabling RXDMA_BDONE interrupt\n", __func__);
 
@@ -1674,6 +1700,10 @@ static int init_umac(struct bcmgenet_priv *priv)
 
         bcmgenet_intrl2_0_writel(priv, cpu_mask_clear, INTRL2_CPU_MASK_CLEAR);
 
+        for (index = 0; index < priv->hw_params->tx_queues; index++)
+                bcmgenet_intrl2_1_writel(priv, (1 << index),
+                                         INTRL2_CPU_MASK_CLEAR);
+
         /* Enable rx/tx engine.*/
         dev_dbg(kdev, "done init umac\n");
 
@@ -1690,6 +1720,8 @@ static void bcmgenet_init_tx_ring(struct bcmgenet_priv *priv,
         u32 flow_period_val = 0;
 
         spin_lock_init(&ring->lock);
+        ring->priv = priv;
+        netif_napi_add(priv->dev, &ring->napi, bcmgenet_tx_poll, 64);
         ring->index = index;
         if (index == DESC_INDEX) {
                 ring->queue = 0;
@@ -1732,6 +1764,17 @@ static void bcmgenet_init_tx_ring(struct bcmgenet_priv *priv,
                                   TDMA_WRITE_PTR);
         bcmgenet_tdma_ring_writel(priv, index, end_ptr * words_per_bd - 1,
                                   DMA_END_ADDR);
+
+        napi_enable(&ring->napi);
+}
+
+static void bcmgenet_fini_tx_ring(struct bcmgenet_priv *priv,
+                                  unsigned int index)
+{
+        struct bcmgenet_tx_ring *ring = &priv->tx_rings[index];
+
+        napi_disable(&ring->napi);
+        netif_napi_del(&ring->napi);
 }
 
 /* Initialize a RDMA ring */
@@ -1896,7 +1939,7 @@ static int bcmgenet_dma_teardown(struct bcmgenet_priv *priv)
         return ret;
 }
 
-static void bcmgenet_fini_dma(struct bcmgenet_priv *priv)
+static void __bcmgenet_fini_dma(struct bcmgenet_priv *priv)
 {
         int i;
 
@@ -1915,6 +1958,18 @@ static void bcmgenet_fini_dma(struct bcmgenet_priv *priv)
         kfree(priv->tx_cbs);
 }
 
+static void bcmgenet_fini_dma(struct bcmgenet_priv *priv)
+{
+        int i;
+
+        bcmgenet_fini_tx_ring(priv, DESC_INDEX);
+
+        for (i = 0; i < priv->hw_params->tx_queues; i++)
+                bcmgenet_fini_tx_ring(priv, i);
+
+        __bcmgenet_fini_dma(priv);
+}
+
 /* init_edma: Initialize DMA control register */
 static int bcmgenet_init_dma(struct bcmgenet_priv *priv)
 {
@@ -1943,7 +1998,7 @@ static int bcmgenet_init_dma(struct bcmgenet_priv *priv)
         priv->tx_cbs = kcalloc(priv->num_tx_bds, sizeof(struct enet_cb),
                                GFP_KERNEL);
         if (!priv->tx_cbs) {
-                bcmgenet_fini_dma(priv);
+                __bcmgenet_fini_dma(priv);
                 return -ENOMEM;
         }
 
@@ -1965,9 +2020,6 @@ static int bcmgenet_poll(struct napi_struct *napi, int budget)
                         struct bcmgenet_priv, napi);
         unsigned int work_done;
 
-        /* tx reclaim */
-        bcmgenet_tx_reclaim(priv->dev, &priv->tx_rings[DESC_INDEX]);
-
         work_done = bcmgenet_desc_rx(priv, budget);
 
         /* Advancing our consumer index*/
@@ -2012,28 +2064,34 @@ static void bcmgenet_irq_task(struct work_struct *work)
 static irqreturn_t bcmgenet_isr1(int irq, void *dev_id)
 {
         struct bcmgenet_priv *priv = dev_id;
+        struct bcmgenet_tx_ring *ring;
         unsigned int index;
 
         /* Save irq status for bottom-half processing. */
         priv->irq1_stat =
                 bcmgenet_intrl2_1_readl(priv, INTRL2_CPU_STAT) &
-                ~priv->int1_mask;
+                ~bcmgenet_intrl2_1_readl(priv, INTRL2_CPU_MASK_STATUS);
         /* clear interrupts */
         bcmgenet_intrl2_1_writel(priv, priv->irq1_stat, INTRL2_CPU_CLEAR);
 
         netif_dbg(priv, intr, priv->dev,
                   "%s: IRQ=0x%x\n", __func__, priv->irq1_stat);
+
         /* Check the MBDONE interrupts.
          * packet is done, reclaim descriptors
          */
-        if (priv->irq1_stat & 0x0000ffff) {
-                index = 0;
-                for (index = 0; index < 16; index++) {
-                        if (priv->irq1_stat & (1 << index))
-                                bcmgenet_tx_reclaim(priv->dev,
-                                                    &priv->tx_rings[index]);
+        for (index = 0; index < priv->hw_params->tx_queues; index++) {
+                if (!(priv->irq1_stat & BIT(index)))
+                        continue;
+
+                ring = &priv->tx_rings[index];
+
+                if (likely(napi_schedule_prep(&ring->napi))) {
+                        ring->int_disable(priv, ring);
+                        __napi_schedule(&ring->napi);
                 }
         }
+
         return IRQ_HANDLED;
 }
 
@@ -2065,8 +2123,12 @@ static irqreturn_t bcmgenet_isr0(int irq, void *dev_id)
         }
         if (priv->irq0_stat &
                         (UMAC_IRQ_TXDMA_BDONE | UMAC_IRQ_TXDMA_PDONE)) {
-                /* Tx reclaim */
-                bcmgenet_tx_reclaim(priv->dev, &priv->tx_rings[DESC_INDEX]);
+                struct bcmgenet_tx_ring *ring = &priv->tx_rings[DESC_INDEX];
+
+                if (likely(napi_schedule_prep(&ring->napi))) {
+                        ring->int_disable(priv, ring);
+                        __napi_schedule(&ring->napi);
+                }
         }
         if (priv->irq0_stat & (UMAC_IRQ_PHY_DET_R |
                                 UMAC_IRQ_PHY_DET_F |
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.h b/drivers/net/ethernet/broadcom/genet/bcmgenet.h
index 3a8a90f95365..016bd12bf493 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.h
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.h
@@ -520,6 +520,7 @@ struct bcmgenet_hw_params {
 
 struct bcmgenet_tx_ring {
         spinlock_t      lock;           /* ring lock */
+        struct napi_struct napi;        /* NAPI per tx queue */
         unsigned int    index;          /* ring index */
         unsigned int    queue;          /* queue index */
         struct enet_cb  *cbs;           /* tx ring buffer control block*/
@@ -534,6 +535,7 @@ struct bcmgenet_tx_ring {
                            struct bcmgenet_tx_ring *);
         void (*int_disable)(struct bcmgenet_priv *priv,
                             struct bcmgenet_tx_ring *);
+        struct bcmgenet_priv *priv;
 };
 
 /* device context */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.c b/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.c
index 9062a8434246..c308429dd9c7 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.c
@@ -35,10 +35,10 @@ static inline unsigned int ipv6_clip_hash(struct clip_tbl *d, const u32 *key)
 }
 
 static unsigned int clip_addr_hash(struct clip_tbl *ctbl, const u32 *addr,
-                                   int addr_len)
+                                   u8 v6)
 {
-        return addr_len == 4 ? ipv4_clip_hash(ctbl, addr) :
-                                ipv6_clip_hash(ctbl, addr);
+        return v6 ? ipv6_clip_hash(ctbl, addr) :
+                        ipv4_clip_hash(ctbl, addr);
 }
 
 static int clip6_get_mbox(const struct net_device *dev,
@@ -78,23 +78,22 @@ int cxgb4_clip_get(const struct net_device *dev, const u32 *lip, u8 v6)
         struct clip_entry *ce, *cte;
         u32 *addr = (u32 *)lip;
         int hash;
-        int addr_len;
-        int ret = 0;
+        int ret = -1;
 
         if (!ctbl)
                 return 0;
 
-        if (v6)
-                addr_len = 16;
-        else
-                addr_len = 4;
-
-        hash = clip_addr_hash(ctbl, addr, addr_len);
+        hash = clip_addr_hash(ctbl, addr, v6);
 
         read_lock_bh(&ctbl->lock);
         list_for_each_entry(cte, &ctbl->hash_list[hash], list) {
-                if (addr_len == cte->addr_len &&
-                    memcmp(lip, cte->addr, cte->addr_len) == 0) {
+                if (cte->addr6.sin6_family == AF_INET6 && v6)
+                        ret = memcmp(lip, cte->addr6.sin6_addr.s6_addr,
+                                     sizeof(struct in6_addr));
+                else if (cte->addr.sin_family == AF_INET && !v6)
+                        ret = memcmp(lip, (char *)(&cte->addr.sin_addr),
+                                     sizeof(struct in_addr));
+                if (!ret) {
                         ce = cte;
                         read_unlock_bh(&ctbl->lock);
                         goto found;
@@ -111,15 +110,20 @@ int cxgb4_clip_get(const struct net_device *dev, const u32 *lip, u8 v6)
                 spin_lock_init(&ce->lock);
                 atomic_set(&ce->refcnt, 0);
                 atomic_dec(&ctbl->nfree);
-                ce->addr_len = addr_len;
-                memcpy(ce->addr, lip, addr_len);
                 list_add_tail(&ce->list, &ctbl->hash_list[hash]);
                 if (v6) {
+                        ce->addr6.sin6_family = AF_INET6;
+                        memcpy(ce->addr6.sin6_addr.s6_addr,
+                               lip, sizeof(struct in6_addr));
                         ret = clip6_get_mbox(dev, (const struct in6_addr *)lip);
                         if (ret) {
                                 write_unlock_bh(&ctbl->lock);
                                 return ret;
                         }
+                } else {
+                        ce->addr.sin_family = AF_INET;
+                        memcpy((char *)(&ce->addr.sin_addr), lip,
+                               sizeof(struct in_addr));
                 }
         } else {
                 write_unlock_bh(&ctbl->lock);
@@ -140,19 +144,19 @@ void cxgb4_clip_release(const struct net_device *dev, const u32 *lip, u8 v6)
         struct clip_entry *ce, *cte;
         u32 *addr = (u32 *)lip;
         int hash;
-        int addr_len;
-
-        if (v6)
-                addr_len = 16;
-        else
-                addr_len = 4;
+        int ret = -1;
 
-        hash = clip_addr_hash(ctbl, addr, addr_len);
+        hash = clip_addr_hash(ctbl, addr, v6);
 
         read_lock_bh(&ctbl->lock);
         list_for_each_entry(cte, &ctbl->hash_list[hash], list) {
-                if (addr_len == cte->addr_len &&
-                    memcmp(lip, cte->addr, cte->addr_len) == 0) {
+                if (cte->addr6.sin6_family == AF_INET6 && v6)
+                        ret = memcmp(lip, cte->addr6.sin6_addr.s6_addr,
+                                     sizeof(struct in6_addr));
+                else if (cte->addr.sin_family == AF_INET && !v6)
+                        ret = memcmp(lip, (char *)(&cte->addr.sin_addr),
+                                     sizeof(struct in_addr));
+                if (!ret) {
                         ce = cte;
                         read_unlock_bh(&ctbl->lock);
                         goto found;
@@ -249,10 +253,7 @@ int clip_tbl_show(struct seq_file *seq, void *v)
         for (i = 0 ; i < ctbl->clipt_size;  ++i) {
                 list_for_each_entry(ce, &ctbl->hash_list[i], list) {
                         ip[0] = '\0';
-                        if (ce->addr_len == 16)
-                                sprintf(ip, "%pI6c", ce->addr);
-                        else
-                                sprintf(ip, "%pI4c", ce->addr);
+                        sprintf(ip, "%pISc", &ce->addr);
                         seq_printf(seq, "%-25s   %u\n", ip,
                                    atomic_read(&ce->refcnt));
                 }
diff --git a/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.h b/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.h
index 2eaba0161cf8..35eb43c6bcbb 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/clip_tbl.h
@@ -14,8 +14,10 @@ struct clip_entry {
         spinlock_t lock;        /* Hold while modifying clip reference */
         atomic_t refcnt;
         struct list_head list;
-        u32 addr[4];
-        int addr_len;
+        union {
+                struct sockaddr_in addr;
+                struct sockaddr_in6 addr6;
+        };
 };
 
 struct clip_tbl {
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
index d6cda17efe6e..97842d03675b 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
@@ -1103,7 +1103,7 @@ int t4_restart_aneg(struct adapter *adap, unsigned int mbox, unsigned int port);
 #define T4_MEMORY_WRITE 0
 #define T4_MEMORY_READ  1
 int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr, u32 len,
-                 __be32 *buf, int dir);
+                 void *buf, int dir);
 static inline int t4_memory_write(struct adapter *adap, int mtype, u32 addr,
                                   u32 len, __be32 *buf)
 {
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
index 4d643b65265e..853c38997c82 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
@@ -449,7 +449,7 @@ int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
  *      @mtype: memory type: MEM_EDC0, MEM_EDC1 or MEM_MC
  *      @addr: address within indicated memory type
  *      @len: amount of memory to transfer
- *      @buf: host memory buffer
+ *      @hbuf: host memory buffer
  *      @dir: direction of transfer T4_MEMORY_READ (1) or T4_MEMORY_WRITE (0)
  *
  *      Reads/writes an [almost] arbitrary memory region in the firmware: the
@@ -460,15 +460,17 @@ int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
  *      caller's responsibility to perform appropriate byte order conversions.
  */
 int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr,
-                 u32 len, __be32 *buf, int dir)
+                 u32 len, void *hbuf, int dir)
 {
         u32 pos, offset, resid, memoffset;
         u32 edc_size, mc_size, win_pf, mem_reg, mem_aperture, mem_base;
+        u32 *buf;
 
         /* Argument sanity checks ...
          */
-        if (addr & 0x3)
+        if (addr & 0x3 || (uintptr_t)hbuf & 0x3)
                 return -EINVAL;
+        buf = (u32 *)hbuf;
 
         /* It's convenient to be able to handle lengths which aren't a
          * multiple of 32-bits because we often end up transferring files to
@@ -532,14 +534,45 @@ int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr,
 
         /* Transfer data to/from the adapter as long as there's an integral
          * number of 32-bit transfers to complete.
+         *
+         * A note on Endianness issues:
+         *
+         * The "register" reads and writes below from/to the PCI-E Memory
+         * Window invoke the standard adapter Big-Endian to PCI-E Link
+         * Little-Endian "swizzel."  As a result, if we have the following
+         * data in adapter memory:
+         *
+         *     Memory:  ... | b0 | b1 | b2 | b3 | ...
+         *     Address:      i+0  i+1  i+2  i+3
+         *
+         * Then a read of the adapter memory via the PCI-E Memory Window
+         * will yield:
+         *
+         *     x = readl(i)
+         *         31                  0
+         *         [ b3 | b2 | b1 | b0 ]
+         *
+         * If this value is stored into local memory on a Little-Endian system
+         * it will show up correctly in local memory as:
+         *
+         *     ( ..., b0, b1, b2, b3, ... )
+         *
+         * But on a Big-Endian system, the store will show up in memory
+         * incorrectly swizzled as:
+         *
+         *     ( ..., b3, b2, b1, b0, ... )
+         *
+         * So we need to account for this in the reads and writes to the
+         * PCI-E Memory Window below by undoing the register read/write
+         * swizzels.
          */
         while (len > 0) {
                 if (dir == T4_MEMORY_READ)
-                        *buf++ = (__force __be32) t4_read_reg(adap,
-                                                        mem_base + offset);
+                        *buf++ = le32_to_cpu((__force __le32)t4_read_reg(adap,
+                                                mem_base + offset));
                 else
                         t4_write_reg(adap, mem_base + offset,
-                                     (__force u32) *buf++);
+                                     (__force u32)cpu_to_le32(*buf++));
                 offset += sizeof(__be32);
                 len -= sizeof(__be32);
 
@@ -568,15 +601,16 @@ int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr,
          */
         if (resid) {
                 union {
-                        __be32 word;
+                        u32 word;
                         char byte[4];
                 } last;
                 unsigned char *bp;
                 int i;
 
                 if (dir == T4_MEMORY_READ) {
-                        last.word = (__force __be32) t4_read_reg(adap,
-                                                        mem_base + offset);
+                        last.word = le32_to_cpu(
+                                        (__force __le32)t4_read_reg(adap,
+                                                mem_base + offset));
                         for (bp = (unsigned char *)buf, i = resid; i < 4; i++)
                                 bp[i] = last.byte[i];
                 } else {
@@ -584,7 +618,7 @@ int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr,
                         for (i = resid; i < 4; i++)
                                 last.byte[i] = 0;
                         t4_write_reg(adap, mem_base + offset,
-                                     (__force u32) last.word);
+                                     (__force u32)cpu_to_le32(last.word));
                 }
         }
 
diff --git a/drivers/net/ethernet/cisco/enic/enic_main.c b/drivers/net/ethernet/cisco/enic/enic_main.c
index a368c0a96ec7..204bd182473b 100644
--- a/drivers/net/ethernet/cisco/enic/enic_main.c
+++ b/drivers/net/ethernet/cisco/enic/enic_main.c
@@ -272,8 +272,8 @@ static irqreturn_t enic_isr_legacy(int irq, void *data)
         }
 
         if (ENIC_TEST_INTR(pba, notify_intr)) {
-                vnic_intr_return_all_credits(&enic->intr[notify_intr]);
                 enic_notify_check(enic);
+                vnic_intr_return_all_credits(&enic->intr[notify_intr]);
         }
 
         if (ENIC_TEST_INTR(pba, err_intr)) {
@@ -346,8 +346,8 @@ static irqreturn_t enic_isr_msix_notify(int irq, void *data)
         struct enic *enic = data;
         unsigned int intr = enic_msix_notify_intr(enic);
 
-        vnic_intr_return_all_credits(&enic->intr[intr]);
         enic_notify_check(enic);
+        vnic_intr_return_all_credits(&enic->intr[intr]);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index 43df78882e48..178e54028d10 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -3162,8 +3162,8 @@ static void adjust_link(struct net_device *dev)
         struct phy_device *phydev = priv->phydev;
 
         if (unlikely(phydev->link != priv->oldlink ||
-                     phydev->duplex != priv->oldduplex ||
-                     phydev->speed != priv->oldspeed))
+                     (phydev->link && (phydev->duplex != priv->oldduplex ||
+                                       phydev->speed != priv->oldspeed))))
                 gfar_update_link_state(priv);
 }
 
diff --git a/drivers/net/ethernet/ibm/ehea/ehea_main.c b/drivers/net/ethernet/ibm/ehea/ehea_main.c
index e8a1adb7a962..c05e50759621 100644
--- a/drivers/net/ethernet/ibm/ehea/ehea_main.c
+++ b/drivers/net/ethernet/ibm/ehea/ehea_main.c
@@ -3262,6 +3262,139 @@ static void ehea_remove_device_sysfs(struct platform_device *dev)
         device_remove_file(&dev->dev, &dev_attr_remove_port);
 }
 
+static int ehea_reboot_notifier(struct notifier_block *nb,
+                                unsigned long action, void *unused)
+{
+        if (action == SYS_RESTART) {
+                pr_info("Reboot: freeing all eHEA resources\n");
+                ibmebus_unregister_driver(&ehea_driver);
+        }
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block ehea_reboot_nb = {
+        .notifier_call = ehea_reboot_notifier,
+};
+
+static int ehea_mem_notifier(struct notifier_block *nb,
+                             unsigned long action, void *data)
+{
+        int ret = NOTIFY_BAD;
+        struct memory_notify *arg = data;
+
+        mutex_lock(&dlpar_mem_lock);
+
+        switch (action) {
+        case MEM_CANCEL_OFFLINE:
+                pr_info("memory offlining canceled");
+                /* Fall through: re-add canceled memory block */
+
+        case MEM_ONLINE:
+                pr_info("memory is going online");
+                set_bit(__EHEA_STOP_XFER, &ehea_driver_flags);
+                if (ehea_add_sect_bmap(arg->start_pfn, arg->nr_pages))
+                        goto out_unlock;
+                ehea_rereg_mrs();
+                break;
+
+        case MEM_GOING_OFFLINE:
+                pr_info("memory is going offline");
+                set_bit(__EHEA_STOP_XFER, &ehea_driver_flags);
+                if (ehea_rem_sect_bmap(arg->start_pfn, arg->nr_pages))
+                        goto out_unlock;
+                ehea_rereg_mrs();
+                break;
+
+        default:
+                break;
+        }
+
+        ehea_update_firmware_handles();
+        ret = NOTIFY_OK;
+
+out_unlock:
+        mutex_unlock(&dlpar_mem_lock);
+        return ret;
+}
+
+static struct notifier_block ehea_mem_nb = {
+        .notifier_call = ehea_mem_notifier,
+};
+
+static void ehea_crash_handler(void)
+{
+        int i;
+
+        if (ehea_fw_handles.arr)
+                for (i = 0; i < ehea_fw_handles.num_entries; i++)
+                        ehea_h_free_resource(ehea_fw_handles.arr[i].adh,
+                                             ehea_fw_handles.arr[i].fwh,
+                                             FORCE_FREE);
+
+        if (ehea_bcmc_regs.arr)
+                for (i = 0; i < ehea_bcmc_regs.num_entries; i++)
+                        ehea_h_reg_dereg_bcmc(ehea_bcmc_regs.arr[i].adh,
+                                              ehea_bcmc_regs.arr[i].port_id,
+                                              ehea_bcmc_regs.arr[i].reg_type,
+                                              ehea_bcmc_regs.arr[i].macaddr,
+                                              0, H_DEREG_BCMC);
+}
+
+static atomic_t ehea_memory_hooks_registered;
+
+/* Register memory hooks on probe of first adapter */
+static int ehea_register_memory_hooks(void)
+{
+        int ret = 0;
+
+        if (atomic_inc_and_test(&ehea_memory_hooks_registered))
+                return 0;
+
+        ret = ehea_create_busmap();
+        if (ret) {
+                pr_info("ehea_create_busmap failed\n");
+                goto out;
+        }
+
+        ret = register_reboot_notifier(&ehea_reboot_nb);
+        if (ret) {
+                pr_info("register_reboot_notifier failed\n");
+                goto out;
+        }
+
+        ret = register_memory_notifier(&ehea_mem_nb);
+        if (ret) {
+                pr_info("register_memory_notifier failed\n");
+                goto out2;
+        }
+
+        ret = crash_shutdown_register(ehea_crash_handler);
+        if (ret) {
+                pr_info("crash_shutdown_register failed\n");
+                goto out3;
+        }
+
+        return 0;
+
+out3:
+        unregister_memory_notifier(&ehea_mem_nb);
+out2:
+        unregister_reboot_notifier(&ehea_reboot_nb);
+out:
+        return ret;
+}
+
+static void ehea_unregister_memory_hooks(void)
+{
+        if (atomic_read(&ehea_memory_hooks_registered))
+                return;
+
+        unregister_reboot_notifier(&ehea_reboot_nb);
+        if (crash_shutdown_unregister(ehea_crash_handler))
+                pr_info("failed unregistering crash handler\n");
+        unregister_memory_notifier(&ehea_mem_nb);
+}
+
 static int ehea_probe_adapter(struct platform_device *dev)
 {
         struct ehea_adapter *adapter;
@@ -3269,6 +3402,10 @@ static int ehea_probe_adapter(struct platform_device *dev)
         int ret;
         int i;
 
+        ret = ehea_register_memory_hooks();
+        if (ret)
+                return ret;
+
         if (!dev || !dev->dev.of_node) {
                 pr_err("Invalid ibmebus device probed\n");
                 return -EINVAL;
@@ -3392,81 +3529,6 @@ static int ehea_remove(struct platform_device *dev)
         return 0;
 }
 
-static void ehea_crash_handler(void)
-{
-        int i;
-
-        if (ehea_fw_handles.arr)
-                for (i = 0; i < ehea_fw_handles.num_entries; i++)
-                        ehea_h_free_resource(ehea_fw_handles.arr[i].adh,
-                                             ehea_fw_handles.arr[i].fwh,
-                                             FORCE_FREE);
-
-        if (ehea_bcmc_regs.arr)
-                for (i = 0; i < ehea_bcmc_regs.num_entries; i++)
-                        ehea_h_reg_dereg_bcmc(ehea_bcmc_regs.arr[i].adh,
-                                              ehea_bcmc_regs.arr[i].port_id,
-                                              ehea_bcmc_regs.arr[i].reg_type,
-                                              ehea_bcmc_regs.arr[i].macaddr,
-                                              0, H_DEREG_BCMC);
-}
-
-static int ehea_mem_notifier(struct notifier_block *nb,
-                             unsigned long action, void *data)
-{
-        int ret = NOTIFY_BAD;
-        struct memory_notify *arg = data;
-
-        mutex_lock(&dlpar_mem_lock);
-
-        switch (action) {
-        case MEM_CANCEL_OFFLINE:
-                pr_info("memory offlining canceled");
-                /* Readd canceled memory block */
-        case MEM_ONLINE:
-                pr_info("memory is going online");
-                set_bit(__EHEA_STOP_XFER, &ehea_driver_flags);
-                if (ehea_add_sect_bmap(arg->start_pfn, arg->nr_pages))
-                        goto out_unlock;
-                ehea_rereg_mrs();
-                break;
-        case MEM_GOING_OFFLINE:
-                pr_info("memory is going offline");
-                set_bit(__EHEA_STOP_XFER, &ehea_driver_flags);
-                if (ehea_rem_sect_bmap(arg->start_pfn, arg->nr_pages))
-                        goto out_unlock;
-                ehea_rereg_mrs();
-                break;
-        default:
-                break;
-        }
-
-        ehea_update_firmware_handles();
-        ret = NOTIFY_OK;
-
-out_unlock:
-        mutex_unlock(&dlpar_mem_lock);
-        return ret;
-}
-
-static struct notifier_block ehea_mem_nb = {
-        .notifier_call = ehea_mem_notifier,
-};
-
-static int ehea_reboot_notifier(struct notifier_block *nb,
-                                unsigned long action, void *unused)
-{
-        if (action == SYS_RESTART) {
-                pr_info("Reboot: freeing all eHEA resources\n");
-                ibmebus_unregister_driver(&ehea_driver);
-        }
-        return NOTIFY_DONE;
-}
-
-static struct notifier_block ehea_reboot_nb = {
-        .notifier_call = ehea_reboot_notifier,
-};
-
 static int check_module_parm(void)
 {
         int ret = 0;
@@ -3520,26 +3582,10 @@ static int __init ehea_module_init(void)
         if (ret)
                 goto out;
 
-        ret = ehea_create_busmap();
-        if (ret)
-                goto out;
-
-        ret = register_reboot_notifier(&ehea_reboot_nb);
-        if (ret)
-                pr_info("failed registering reboot notifier\n");
-
-        ret = register_memory_notifier(&ehea_mem_nb);
-        if (ret)
-                pr_info("failed registering memory remove notifier\n");
-
-        ret = crash_shutdown_register(ehea_crash_handler);
-        if (ret)
-                pr_info("failed registering crash handler\n");
-
         ret = ibmebus_register_driver(&ehea_driver);
         if (ret) {
                 pr_err("failed registering eHEA device driver on ebus\n");
-                goto out2;
+                goto out;
         }
 
         ret = driver_create_file(&ehea_driver.driver,
@@ -3547,32 +3593,22 @@ static int __init ehea_module_init(void)
         if (ret) {
                 pr_err("failed to register capabilities attribute, ret=%d\n",
                        ret);
-                goto out3;
+                goto out2;
         }
 
         return ret;
 
-out3:
-        ibmebus_unregister_driver(&ehea_driver);
 out2:
-        unregister_memory_notifier(&ehea_mem_nb);
-        unregister_reboot_notifier(&ehea_reboot_nb);
-        crash_shutdown_unregister(ehea_crash_handler);
+        ibmebus_unregister_driver(&ehea_driver);
 out:
         return ret;
 }
 
 static void __exit ehea_module_exit(void)
 {
-        int ret;
-
         driver_remove_file(&ehea_driver.driver, &driver_attr_capabilities);
         ibmebus_unregister_driver(&ehea_driver);
-        unregister_reboot_notifier(&ehea_reboot_nb);
-        ret = crash_shutdown_unregister(ehea_crash_handler);
-        if (ret)
-                pr_info("failed unregistering crash handler\n");
-        unregister_memory_notifier(&ehea_mem_nb);
+        ehea_unregister_memory_hooks();
         kfree(ehea_fw_handles.arr);
         kfree(ehea_bcmc_regs.arr);
         ehea_destroy_busmap();
diff --git a/drivers/net/ethernet/ibm/ibmveth.c b/drivers/net/ethernet/ibm/ibmveth.c
index 21978cc019e7..072426a72745 100644
--- a/drivers/net/ethernet/ibm/ibmveth.c
+++ b/drivers/net/ethernet/ibm/ibmveth.c
@@ -1327,6 +1327,28 @@ static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev)
         return ret;
 }
 
+static int ibmveth_set_mac_addr(struct net_device *dev, void *p)
+{
+        struct ibmveth_adapter *adapter = netdev_priv(dev);
+        struct sockaddr *addr = p;
+        u64 mac_address;
+        int rc;
+
+        if (!is_valid_ether_addr(addr->sa_data))
+                return -EADDRNOTAVAIL;
+
+        mac_address = ibmveth_encode_mac_addr(addr->sa_data);
+        rc = h_change_logical_lan_mac(adapter->vdev->unit_address, mac_address);
+        if (rc) {
+                netdev_err(adapter->netdev, "h_change_logical_lan_mac failed with rc=%d\n", rc);
+                return rc;
+        }
+
+        ether_addr_copy(dev->dev_addr, addr->sa_data);
+
+        return 0;
+}
+
 static const struct net_device_ops ibmveth_netdev_ops = {
         .ndo_open               = ibmveth_open,
         .ndo_stop               = ibmveth_close,
@@ -1337,7 +1359,7 @@ static const struct net_device_ops ibmveth_netdev_ops = {
         .ndo_fix_features       = ibmveth_fix_features,
         .ndo_set_features       = ibmveth_set_features,
         .ndo_validate_addr      = eth_validate_addr,
-        .ndo_set_mac_address    = eth_mac_addr,
+        .ndo_set_mac_address    = ibmveth_set_mac_addr,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ibmveth_poll_controller,
 #endif
diff --git a/drivers/net/ethernet/intel/i40e/i40e_common.c b/drivers/net/ethernet/intel/i40e/i40e_common.c
index cb19c377e0cc..1da7d05abd38 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_common.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_common.c
@@ -875,8 +875,9 @@ i40e_status i40e_pf_reset(struct i40e_hw *hw)
          * The grst delay value is in 100ms units, and we'll wait a
          * couple counts longer to be sure we don't just miss the end.
          */
-        grst_del = rd32(hw, I40E_GLGEN_RSTCTL) & I40E_GLGEN_RSTCTL_GRSTDEL_MASK
-                        >> I40E_GLGEN_RSTCTL_GRSTDEL_SHIFT;
+        grst_del = (rd32(hw, I40E_GLGEN_RSTCTL) &
+                    I40E_GLGEN_RSTCTL_GRSTDEL_MASK) >>
+                    I40E_GLGEN_RSTCTL_GRSTDEL_SHIFT;
         for (cnt = 0; cnt < grst_del + 2; cnt++) {
                 reg = rd32(hw, I40E_GLGEN_RSTAT);
                 if (!(reg & I40E_GLGEN_RSTAT_DEVSTATE_MASK))
@@ -2828,7 +2829,7 @@ i40e_status i40e_aq_add_udp_tunnel(struct i40e_hw *hw,
 
         status = i40e_asq_send_command(hw, &desc, NULL, 0, cmd_details);
 
-        if (!status)
+        if (!status && filter_index)
                 *filter_index = resp->index;
 
         return status;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_dcb_nl.c b/drivers/net/ethernet/intel/i40e/i40e_dcb_nl.c
index b0665509eae6..2f583554a260 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_dcb_nl.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_dcb_nl.c
@@ -40,7 +40,7 @@ static void i40e_get_pfc_delay(struct i40e_hw *hw, u16 *delay)
         u32 val;
 
         val = rd32(hw, I40E_PRTDCB_GENC);
-        *delay = (u16)(val & I40E_PRTDCB_GENC_PFCLDA_MASK >>
+        *delay = (u16)((val & I40E_PRTDCB_GENC_PFCLDA_MASK) >>
                        I40E_PRTDCB_GENC_PFCLDA_SHIFT);
 }
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_debugfs.c b/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
index 30cf0be7d1b2..e802b6bc067d 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
@@ -990,8 +990,10 @@ static ssize_t i40e_dbg_command_write(struct file *filp,
         if (!cmd_buf)
                 return count;
         bytes_not_copied = copy_from_user(cmd_buf, buffer, count);
-        if (bytes_not_copied < 0)
+        if (bytes_not_copied < 0) {
+                kfree(cmd_buf);
                 return bytes_not_copied;
+        }
         if (bytes_not_copied > 0)
                 count -= bytes_not_copied;
         cmd_buf[count] = '\0';
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index c3858e7f0e66..56bdaff9f27e 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -1507,7 +1507,12 @@ static void i40e_vsi_setup_queue_map(struct i40e_vsi *vsi,
         vsi->tc_config.numtc = numtc;
         vsi->tc_config.enabled_tc = enabled_tc ? enabled_tc : 1;
         /* Number of queues per enabled TC */
-        num_tc_qps = vsi->alloc_queue_pairs/numtc;
+        /* In MFP case we can have a much lower count of MSIx
+         * vectors available and so we need to lower the used
+         * q count.
+         */
+        qcount = min_t(int, vsi->alloc_queue_pairs, pf->num_lan_msix);
+        num_tc_qps = qcount / numtc;
         num_tc_qps = min_t(int, num_tc_qps, I40E_MAX_QUEUES_PER_TC);
 
         /* Setup queue offset/count for all TCs for given VSI */
@@ -2690,8 +2695,15 @@ static void i40e_vsi_config_dcb_rings(struct i40e_vsi *vsi)
         u16 qoffset, qcount;
         int i, n;
 
-        if (!(vsi->back->flags & I40E_FLAG_DCB_ENABLED))
-                return;
+        if (!(vsi->back->flags & I40E_FLAG_DCB_ENABLED)) {
+                /* Reset the TC information */
+                for (i = 0; i < vsi->num_queue_pairs; i++) {
+                        rx_ring = vsi->rx_rings[i];
+                        tx_ring = vsi->tx_rings[i];
+                        rx_ring->dcb_tc = 0;
+                        tx_ring->dcb_tc = 0;
+                }
+        }
 
         for (n = 0; n < I40E_MAX_TRAFFIC_CLASS; n++) {
                 if (!(vsi->tc_config.enabled_tc & (1 << n)))
@@ -3836,6 +3848,12 @@ static void i40e_clear_interrupt_scheme(struct i40e_pf *pf)
 {
         int i;
 
+        i40e_stop_misc_vector(pf);
+        if (pf->flags & I40E_FLAG_MSIX_ENABLED) {
+                synchronize_irq(pf->msix_entries[0].vector);
+                free_irq(pf->msix_entries[0].vector, pf);
+        }
+
         i40e_put_lump(pf->irq_pile, 0, I40E_PILE_VALID_BIT-1);
         for (i = 0; i < pf->num_alloc_vsi; i++)
                 if (pf->vsi[i])
@@ -5246,8 +5264,14 @@ static int i40e_handle_lldp_event(struct i40e_pf *pf,
 
         /* Wait for the PF's Tx queues to be disabled */
         ret = i40e_pf_wait_txq_disabled(pf);
-        if (!ret)
+        if (ret) {
+                /* Schedule PF reset to recover */
+                set_bit(__I40E_PF_RESET_REQUESTED, &pf->state);
+                i40e_service_event_schedule(pf);
+        } else {
                 i40e_pf_unquiesce_all_vsi(pf);
+        }
+
 exit:
         return ret;
 }
@@ -5579,7 +5603,8 @@ static void i40e_check_hang_subtask(struct i40e_pf *pf)
         int i, v;
 
         /* If we're down or resetting, just bail */
-        if (test_bit(__I40E_CONFIG_BUSY, &pf->state))
+        if (test_bit(__I40E_DOWN, &pf->state) ||
+            test_bit(__I40E_CONFIG_BUSY, &pf->state))
                 return;
 
         /* for each VSI/netdev
@@ -9849,6 +9874,7 @@ static void i40e_remove(struct pci_dev *pdev)
         set_bit(__I40E_DOWN, &pf->state);
         del_timer_sync(&pf->service_timer);
         cancel_work_sync(&pf->service_task);
+        i40e_fdir_teardown(pf);
 
         if (pf->flags & I40E_FLAG_SRIOV_ENABLED) {
                 i40e_free_vfs(pf);
@@ -9875,12 +9901,6 @@ static void i40e_remove(struct pci_dev *pdev)
         if (pf->vsi[pf->lan_vsi])
                 i40e_vsi_release(pf->vsi[pf->lan_vsi]);
 
-        i40e_stop_misc_vector(pf);
-        if (pf->flags & I40E_FLAG_MSIX_ENABLED) {
-                synchronize_irq(pf->msix_entries[0].vector);
-                free_irq(pf->msix_entries[0].vector, pf);
-        }
-
         /* shutdown and destroy the HMC */
         if (pf->hw.hmc.hmc_obj) {
                 ret_code = i40e_shutdown_lan_hmc(&pf->hw);
@@ -10034,6 +10054,8 @@ static void i40e_shutdown(struct pci_dev *pdev)
         wr32(hw, I40E_PFPM_APM, (pf->wol_en ? I40E_PFPM_APM_APME_MASK : 0));
         wr32(hw, I40E_PFPM_WUFC, (pf->wol_en ? I40E_PFPM_WUFC_MAG_MASK : 0));
 
+        i40e_clear_interrupt_scheme(pf);
+
         if (system_state == SYSTEM_POWER_OFF) {
                 pci_wake_from_d3(pdev, pf->wol_en);
                 pci_set_power_state(pdev, PCI_D3hot);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_nvm.c b/drivers/net/ethernet/intel/i40e/i40e_nvm.c
index 28429c8fbc98..039018abad4a 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_nvm.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_nvm.c
@@ -725,9 +725,11 @@ static i40e_status i40e_nvmupd_state_writing(struct i40e_hw *hw,
 {
         i40e_status status;
         enum i40e_nvmupd_cmd upd_cmd;
+        bool retry_attempt = false;
 
         upd_cmd = i40e_nvmupd_validate_command(hw, cmd, errno);
 
+retry:
         switch (upd_cmd) {
         case I40E_NVMUPD_WRITE_CON:
                 status = i40e_nvmupd_nvm_write(hw, cmd, bytes, errno);
@@ -771,6 +773,39 @@ static i40e_status i40e_nvmupd_state_writing(struct i40e_hw *hw,
                 *errno = -ESRCH;
                 break;
         }
+
+        /* In some circumstances, a multi-write transaction takes longer
+         * than the default 3 minute timeout on the write semaphore.  If
+         * the write failed with an EBUSY status, this is likely the problem,
+         * so here we try to reacquire the semaphore then retry the write.
+         * We only do one retry, then give up.
+         */
+        if (status && (hw->aq.asq_last_status == I40E_AQ_RC_EBUSY) &&
+            !retry_attempt) {
+                i40e_status old_status = status;
+                u32 old_asq_status = hw->aq.asq_last_status;
+                u32 gtime;
+
+                gtime = rd32(hw, I40E_GLVFGEN_TIMER);
+                if (gtime >= hw->nvm.hw_semaphore_timeout) {
+                        i40e_debug(hw, I40E_DEBUG_ALL,
+                                   "NVMUPD: write semaphore expired (%d >= %lld), retrying\n",
+                                   gtime, hw->nvm.hw_semaphore_timeout);
+                        i40e_release_nvm(hw);
+                        status = i40e_acquire_nvm(hw, I40E_RESOURCE_WRITE);
+                        if (status) {
+                                i40e_debug(hw, I40E_DEBUG_ALL,
+                                           "NVMUPD: write semaphore reacquire failed aq_err = %d\n",
+                                           hw->aq.asq_last_status);
+                                status = old_status;
+                                hw->aq.asq_last_status = old_asq_status;
+                        } else {
+                                retry_attempt = true;
+                                goto retry;
+                        }
+                }
+        }
+
         return status;
 }
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
index af350626843e..d4b4aa7c204e 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
@@ -587,6 +587,20 @@ void i40e_free_tx_resources(struct i40e_ring *tx_ring)
 }
 
 /**
+ * i40e_get_head - Retrieve head from head writeback
+ * @tx_ring:  tx ring to fetch head of
+ *
+ * Returns value of Tx ring head based on value stored
+ * in head write-back location
+ **/
+static inline u32 i40e_get_head(struct i40e_ring *tx_ring)
+{
+        void *head = (struct i40e_tx_desc *)tx_ring->desc + tx_ring->count;
+
+        return le32_to_cpu(*(volatile __le32 *)head);
+}
+
+/**
  * i40e_get_tx_pending - how many tx descriptors not processed
  * @tx_ring: the ring of descriptors
  *
@@ -595,10 +609,16 @@ void i40e_free_tx_resources(struct i40e_ring *tx_ring)
  **/
 static u32 i40e_get_tx_pending(struct i40e_ring *ring)
 {
-        u32 ntu = ((ring->next_to_clean <= ring->next_to_use)
-                        ? ring->next_to_use
-                        : ring->next_to_use + ring->count);
-        return ntu - ring->next_to_clean;
+        u32 head, tail;
+
+        head = i40e_get_head(ring);
+        tail = readl(ring->tail);
+
+        if (head != tail)
+                return (head < tail) ?
+                        tail - head : (tail + ring->count - head);
+
+        return 0;
 }
 
 /**
@@ -607,6 +627,8 @@ static u32 i40e_get_tx_pending(struct i40e_ring *ring)
  **/
 static bool i40e_check_tx_hang(struct i40e_ring *tx_ring)
 {
+        u32 tx_done = tx_ring->stats.packets;
+        u32 tx_done_old = tx_ring->tx_stats.tx_done_old;
         u32 tx_pending = i40e_get_tx_pending(tx_ring);
         struct i40e_pf *pf = tx_ring->vsi->back;
         bool ret = false;
@@ -624,41 +646,25 @@ static bool i40e_check_tx_hang(struct i40e_ring *tx_ring)
          * run the check_tx_hang logic with a transmit completion
          * pending but without time to complete it yet.
          */
-        if ((tx_ring->tx_stats.tx_done_old == tx_ring->stats.packets) &&
-            (tx_pending >= I40E_MIN_DESC_PENDING)) {
+        if ((tx_done_old == tx_done) && tx_pending) {
                 /* make sure it is true for two checks in a row */
                 ret = test_and_set_bit(__I40E_HANG_CHECK_ARMED,
                                        &tx_ring->state);
-        } else if ((tx_ring->tx_stats.tx_done_old == tx_ring->stats.packets) &&
-                   (tx_pending < I40E_MIN_DESC_PENDING) &&
-                   (tx_pending > 0)) {
+        } else if (tx_done_old == tx_done &&
+                   (tx_pending < I40E_MIN_DESC_PENDING) && (tx_pending > 0)) {
                 if (I40E_DEBUG_FLOW & pf->hw.debug_mask)
                         dev_info(tx_ring->dev, "HW needs some more descs to do a cacheline flush. tx_pending %d, queue %d",
                                  tx_pending, tx_ring->queue_index);
                 pf->tx_sluggish_count++;
         } else {
                 /* update completed stats and disarm the hang check */
-                tx_ring->tx_stats.tx_done_old = tx_ring->stats.packets;
+                tx_ring->tx_stats.tx_done_old = tx_done;
                 clear_bit(__I40E_HANG_CHECK_ARMED, &tx_ring->state);
         }
 
         return ret;
 }
 
-/**
- * i40e_get_head - Retrieve head from head writeback
- * @tx_ring:  tx ring to fetch head of
- *
- * Returns value of Tx ring head based on value stored
- * in head write-back location
- **/
-static inline u32 i40e_get_head(struct i40e_ring *tx_ring)
-{
-        void *head = (struct i40e_tx_desc *)tx_ring->desc + tx_ring->count;
-
-        return le32_to_cpu(*(volatile __le32 *)head);
-}
-
 #define WB_STRIDE 0x3
 
 /**
@@ -2356,6 +2362,67 @@ static int i40e_maybe_stop_tx(struct i40e_ring *tx_ring, int size)
 }
 
 /**
+ * i40e_chk_linearize - Check if there are more than 8 fragments per packet
+ * @skb:      send buffer
+ * @tx_flags: collected send information
+ * @hdr_len:  size of the packet header
+ *
+ * Note: Our HW can't scatter-gather more than 8 fragments to build
+ * a packet on the wire and so we need to figure out the cases where we
+ * need to linearize the skb.
+ **/
+static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags,
+                               const u8 hdr_len)
+{
+        struct skb_frag_struct *frag;
+        bool linearize = false;
+        unsigned int size = 0;
+        u16 num_frags;
+        u16 gso_segs;
+
+        num_frags = skb_shinfo(skb)->nr_frags;
+        gso_segs = skb_shinfo(skb)->gso_segs;
+
+        if (tx_flags & (I40E_TX_FLAGS_TSO | I40E_TX_FLAGS_FSO)) {
+                u16 j = 1;
+
+                if (num_frags < (I40E_MAX_BUFFER_TXD))
+                        goto linearize_chk_done;
+                /* try the simple math, if we have too many frags per segment */
+                if (DIV_ROUND_UP((num_frags + gso_segs), gso_segs) >
+                    I40E_MAX_BUFFER_TXD) {
+                        linearize = true;
+                        goto linearize_chk_done;
+                }
+                frag = &skb_shinfo(skb)->frags[0];
+                size = hdr_len;
+                /* we might still have more fragments per segment */
+                do {
+                        size += skb_frag_size(frag);
+                        frag++; j++;
+                        if (j == I40E_MAX_BUFFER_TXD) {
+                                if (size < skb_shinfo(skb)->gso_size) {
+                                        linearize = true;
+                                        break;
+                                }
+                                j = 1;
+                                size -= skb_shinfo(skb)->gso_size;
+                                if (size)
+                                        j++;
+                                size += hdr_len;
+                        }
+                        num_frags--;
+                } while (num_frags);
+        } else {
+                if (num_frags >= I40E_MAX_BUFFER_TXD)
+                        linearize = true;
+        }
+
+linearize_chk_done:
+        return linearize;
+}
+
+/**
  * i40e_tx_map - Build the Tx descriptor
  * @tx_ring:  ring to send buffer on
  * @skb:      send buffer
@@ -2612,6 +2679,10 @@ static netdev_tx_t i40e_xmit_frame_ring(struct sk_buff *skb,
         if (tsyn)
                 tx_flags |= I40E_TX_FLAGS_TSYN;
 
+        if (i40e_chk_linearize(skb, tx_flags, hdr_len))
+                if (skb_linearize(skb))
+                        goto out_drop;
+
         skb_tx_timestamp(skb);
 
         /* always enable CRC insertion offload */
diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.h b/drivers/net/ethernet/intel/i40e/i40e_txrx.h
index 38449b230d60..4b0b8102cdc3 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.h
@@ -120,6 +120,7 @@ enum i40e_dyn_idx_t {
 
 #define i40e_rx_desc i40e_32byte_rx_desc
 
+#define I40E_MAX_BUFFER_TXD     8
 #define I40E_MIN_TX_LEN         17
 #define I40E_MAX_DATA_PER_TXD   8192
 
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
index d2ff862f0726..fe13ad2def46 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
@@ -127,6 +127,20 @@ void i40evf_free_tx_resources(struct i40e_ring *tx_ring)
 }
 
 /**
+ * i40e_get_head - Retrieve head from head writeback
+ * @tx_ring:  tx ring to fetch head of
+ *
+ * Returns value of Tx ring head based on value stored
+ * in head write-back location
+ **/
+static inline u32 i40e_get_head(struct i40e_ring *tx_ring)
+{
+        void *head = (struct i40e_tx_desc *)tx_ring->desc + tx_ring->count;
+
+        return le32_to_cpu(*(volatile __le32 *)head);
+}
+
+/**
  * i40e_get_tx_pending - how many tx descriptors not processed
  * @tx_ring: the ring of descriptors
  *
@@ -135,10 +149,16 @@ void i40evf_free_tx_resources(struct i40e_ring *tx_ring)
  **/
 static u32 i40e_get_tx_pending(struct i40e_ring *ring)
 {
-        u32 ntu = ((ring->next_to_clean <= ring->next_to_use)
-                        ? ring->next_to_use
-                        : ring->next_to_use + ring->count);
-        return ntu - ring->next_to_clean;
+        u32 head, tail;
+
+        head = i40e_get_head(ring);
+        tail = readl(ring->tail);
+
+        if (head != tail)
+                return (head < tail) ?
+                        tail - head : (tail + ring->count - head);
+
+        return 0;
 }
 
 /**
@@ -147,6 +167,8 @@ static u32 i40e_get_tx_pending(struct i40e_ring *ring)
  **/
 static bool i40e_check_tx_hang(struct i40e_ring *tx_ring)
 {
+        u32 tx_done = tx_ring->stats.packets;
+        u32 tx_done_old = tx_ring->tx_stats.tx_done_old;
         u32 tx_pending = i40e_get_tx_pending(tx_ring);
         bool ret = false;
 
@@ -163,36 +185,20 @@ static bool i40e_check_tx_hang(struct i40e_ring *tx_ring)
          * run the check_tx_hang logic with a transmit completion
          * pending but without time to complete it yet.
          */
-        if ((tx_ring->tx_stats.tx_done_old == tx_ring->stats.packets) &&
-            (tx_pending >= I40E_MIN_DESC_PENDING)) {
+        if ((tx_done_old == tx_done) && tx_pending) {
                 /* make sure it is true for two checks in a row */
                 ret = test_and_set_bit(__I40E_HANG_CHECK_ARMED,
                                        &tx_ring->state);
-        } else if (!(tx_ring->tx_stats.tx_done_old == tx_ring->stats.packets) ||
-                   !(tx_pending < I40E_MIN_DESC_PENDING) ||
-                   !(tx_pending > 0)) {
+        } else if (tx_done_old == tx_done &&
+                   (tx_pending < I40E_MIN_DESC_PENDING) && (tx_pending > 0)) {
                 /* update completed stats and disarm the hang check */
-                tx_ring->tx_stats.tx_done_old = tx_ring->stats.packets;
+                tx_ring->tx_stats.tx_done_old = tx_done;
                 clear_bit(__I40E_HANG_CHECK_ARMED, &tx_ring->state);
         }
 
         return ret;
 }
 
-/**
- * i40e_get_head - Retrieve head from head writeback
- * @tx_ring:  tx ring to fetch head of
- *
- * Returns value of Tx ring head based on value stored
- * in head write-back location
- **/
-static inline u32 i40e_get_head(struct i40e_ring *tx_ring)
-{
-        void *head = (struct i40e_tx_desc *)tx_ring->desc + tx_ring->count;
-
-        return le32_to_cpu(*(volatile __le32 *)head);
-}
-
 #define WB_STRIDE 0x3
 
 /**
@@ -1405,17 +1411,16 @@ static int i40e_tso(struct i40e_ring *tx_ring, struct sk_buff *skb,
         if (err < 0)
                 return err;
 
-        if (protocol == htons(ETH_P_IP)) {
-                iph = skb->encapsulation ? inner_ip_hdr(skb) : ip_hdr(skb);
+        iph = skb->encapsulation ? inner_ip_hdr(skb) : ip_hdr(skb);
+        ipv6h = skb->encapsulation ? inner_ipv6_hdr(skb) : ipv6_hdr(skb);
+
+        if (iph->version == 4) {
                 tcph = skb->encapsulation ? inner_tcp_hdr(skb) : tcp_hdr(skb);
                 iph->tot_len = 0;
                 iph->check = 0;
                 tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
                                                  0, IPPROTO_TCP, 0);
-        } else if (skb_is_gso_v6(skb)) {
-
-                ipv6h = skb->encapsulation ? inner_ipv6_hdr(skb)
-                                           : ipv6_hdr(skb);
+        } else if (ipv6h->version == 6) {
                 tcph = skb->encapsulation ? inner_tcp_hdr(skb) : tcp_hdr(skb);
                 ipv6h->payload_len = 0;
                 tcph->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr,
@@ -1473,13 +1478,9 @@ static void i40e_tx_enable_csum(struct sk_buff *skb, u32 tx_flags,
                                          I40E_TX_CTX_EXT_IP_IPV4_NO_CSUM;
                         }
                 } else if (tx_flags & I40E_TX_FLAGS_IPV6) {
-                        if (tx_flags & I40E_TX_FLAGS_TSO) {
-                                *cd_tunneling |= I40E_TX_CTX_EXT_IP_IPV6;
+                        *cd_tunneling |= I40E_TX_CTX_EXT_IP_IPV6;
+                        if (tx_flags & I40E_TX_FLAGS_TSO)
                                 ip_hdr(skb)->check = 0;
-                        } else {
-                                *cd_tunneling |=
-                                         I40E_TX_CTX_EXT_IP_IPV4_NO_CSUM;
-                        }
                 }
 
                 /* Now set the ctx descriptor fields */
@@ -1489,6 +1490,11 @@ static void i40e_tx_enable_csum(struct sk_buff *skb, u32 tx_flags,
                                    ((skb_inner_network_offset(skb) -
                                         skb_transport_offset(skb)) >> 1) <<
                                    I40E_TXD_CTX_QW0_NATLEN_SHIFT;
+                if (this_ip_hdr->version == 6) {
+                        tx_flags &= ~I40E_TX_FLAGS_IPV4;
+                        tx_flags |= I40E_TX_FLAGS_IPV6;
+                }
+
 
         } else {
                 network_hdr_len = skb_network_header_len(skb);
@@ -1579,6 +1585,67 @@ static void i40e_create_tx_ctx(struct i40e_ring *tx_ring,
         context_desc->type_cmd_tso_mss = cpu_to_le64(cd_type_cmd_tso_mss);
 }
 
+ /**
+ * i40e_chk_linearize - Check if there are more than 8 fragments per packet
+ * @skb:      send buffer
+ * @tx_flags: collected send information
+ * @hdr_len:  size of the packet header
+ *
+ * Note: Our HW can't scatter-gather more than 8 fragments to build
+ * a packet on the wire and so we need to figure out the cases where we
+ * need to linearize the skb.
+ **/
+static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags,
+                               const u8 hdr_len)
+{
+        struct skb_frag_struct *frag;
+        bool linearize = false;
+        unsigned int size = 0;
+        u16 num_frags;
+        u16 gso_segs;
+
+        num_frags = skb_shinfo(skb)->nr_frags;
+        gso_segs = skb_shinfo(skb)->gso_segs;
+
+        if (tx_flags & (I40E_TX_FLAGS_TSO | I40E_TX_FLAGS_FSO)) {
+                u16 j = 1;
+
+                if (num_frags < (I40E_MAX_BUFFER_TXD))
+                        goto linearize_chk_done;
+                /* try the simple math, if we have too many frags per segment */
+                if (DIV_ROUND_UP((num_frags + gso_segs), gso_segs) >
+                    I40E_MAX_BUFFER_TXD) {
+                        linearize = true;
+                        goto linearize_chk_done;
+                }
+                frag = &skb_shinfo(skb)->frags[0];
+                size = hdr_len;
+                /* we might still have more fragments per segment */
+                do {
+                        size += skb_frag_size(frag);
+                        frag++; j++;
+                        if (j == I40E_MAX_BUFFER_TXD) {
+                                if (size < skb_shinfo(skb)->gso_size) {
+                                        linearize = true;
+                                        break;
+                                }
+                                j = 1;
+                                size -= skb_shinfo(skb)->gso_size;
+                                if (size)
+                                        j++;
+                                size += hdr_len;
+                        }
+                        num_frags--;
+                } while (num_frags);
+        } else {
+                if (num_frags >= I40E_MAX_BUFFER_TXD)
+                        linearize = true;
+        }
+
+linearize_chk_done:
+        return linearize;
+}
+
 /**
  * i40e_tx_map - Build the Tx descriptor
  * @tx_ring:  ring to send buffer on
@@ -1853,6 +1920,10 @@ static netdev_tx_t i40e_xmit_frame_ring(struct sk_buff *skb,
         else if (tso)
                 tx_flags |= I40E_TX_FLAGS_TSO;
 
+        if (i40e_chk_linearize(skb, tx_flags, hdr_len))
+                if (skb_linearize(skb))
+                        goto out_drop;
+
         skb_tx_timestamp(skb);
 
         /* always enable CRC insertion offload */
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.h b/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
index ffdda716813e..1e49bb1fbac1 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
@@ -120,6 +120,7 @@ enum i40e_dyn_idx_t {
 
 #define i40e_rx_desc i40e_32byte_rx_desc
 
+#define I40E_MAX_BUFFER_TXD     8
 #define I40E_MIN_TX_LEN         17
 #define I40E_MAX_DATA_PER_TXD   8192
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_selftest.c b/drivers/net/ethernet/mellanox/mlx4/en_selftest.c
index 4e789479f00f..b66e03d9711f 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_selftest.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_selftest.c
@@ -81,12 +81,14 @@ static int mlx4_en_test_loopback(struct mlx4_en_priv *priv)
 {
         u32 loopback_ok = 0;
         int i;
-
+        bool gro_enabled;
 
         priv->loopback_ok = 0;
         priv->validate_loopback = 1;
+        gro_enabled = priv->dev->features & NETIF_F_GRO;
 
         mlx4_en_update_loopback_state(priv->dev, priv->dev->features);
+        priv->dev->features &= ~NETIF_F_GRO;
 
         /* xmit */
         if (mlx4_en_test_loopback_xmit(priv)) {
@@ -108,6 +110,10 @@ static int mlx4_en_test_loopback(struct mlx4_en_priv *priv)
 mlx4_en_test_loopback_exit:
 
         priv->validate_loopback = 0;
+
+        if (gro_enabled)
+                priv->dev->features |= NETIF_F_GRO;
+
         mlx4_en_update_loopback_state(priv->dev, priv->dev->features);
         return !loopback_ok;
 }
diff --git a/drivers/net/ethernet/mellanox/mlx4/qp.c b/drivers/net/ethernet/mellanox/mlx4/qp.c
index 2bb8553bd905..eda29dbbfcd2 100644
--- a/drivers/net/ethernet/mellanox/mlx4/qp.c
+++ b/drivers/net/ethernet/mellanox/mlx4/qp.c
@@ -412,7 +412,6 @@ err_icm:
 
 EXPORT_SYMBOL_GPL(mlx4_qp_alloc);
 
-#define MLX4_UPDATE_QP_SUPPORTED_ATTRS MLX4_UPDATE_QP_SMAC
 int mlx4_update_qp(struct mlx4_dev *dev, u32 qpn,
                    enum mlx4_update_qp_attr attr,
                    struct mlx4_update_qp_params *params)
diff --git a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
index 486e3d26cd4a..d97ca88c55b5 100644
--- a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
+++ b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
@@ -713,7 +713,7 @@ static int update_vport_qp_param(struct mlx4_dev *dev,
         struct mlx4_vport_oper_state *vp_oper;
         struct mlx4_priv *priv;
         u32 qp_type;
-        int port;
+        int port, err = 0;
 
         port = (qpc->pri_path.sched_queue & 0x40) ? 2 : 1;
         priv = mlx4_priv(dev);
@@ -738,7 +738,9 @@ static int update_vport_qp_param(struct mlx4_dev *dev,
                         } else {
                                 struct mlx4_update_qp_params params = {.flags = 0};
 
-                                mlx4_update_qp(dev, qpn, MLX4_UPDATE_QP_VSD, &params);
+                                err = mlx4_update_qp(dev, qpn, MLX4_UPDATE_QP_VSD, &params);
+                                if (err)
+                                        goto out;
                         }
                 }
 
@@ -773,7 +775,8 @@ static int update_vport_qp_param(struct mlx4_dev *dev,
                 qpc->pri_path.feup |= MLX4_FSM_FORCE_ETH_SRC_MAC;
                 qpc->pri_path.grh_mylmc = (0x80 & qpc->pri_path.grh_mylmc) + vp_oper->mac_idx;
         }
-        return 0;
+out:
+        return err;
 }
 
 static int mpt_mask(struct mlx4_dev *dev)
diff --git a/drivers/net/ethernet/pasemi/pasemi_mac.c b/drivers/net/ethernet/pasemi/pasemi_mac.c
index 44e8d7d25547..57a6e6cd74fc 100644
--- a/drivers/net/ethernet/pasemi/pasemi_mac.c
+++ b/drivers/net/ethernet/pasemi/pasemi_mac.c
@@ -1239,11 +1239,9 @@ static int pasemi_mac_open(struct net_device *dev)
         if (mac->phydev)
                 phy_start(mac->phydev);
 
-        init_timer(&mac->tx->clean_timer);
-        mac->tx->clean_timer.function = pasemi_mac_tx_timer;
-        mac->tx->clean_timer.data = (unsigned long)mac->tx;
-        mac->tx->clean_timer.expires = jiffies+HZ;
-        add_timer(&mac->tx->clean_timer);
+        setup_timer(&mac->tx->clean_timer, pasemi_mac_tx_timer,
+                    (unsigned long)mac->tx);
+        mod_timer(&mac->tx->clean_timer, jiffies + HZ);
 
         return 0;
 
diff --git a/drivers/net/ethernet/qlogic/netxen/netxen_nic.h b/drivers/net/ethernet/qlogic/netxen/netxen_nic.h
index 6e426ae94692..0a5e204a0179 100644
--- a/drivers/net/ethernet/qlogic/netxen/netxen_nic.h
+++ b/drivers/net/ethernet/qlogic/netxen/netxen_nic.h
@@ -354,7 +354,7 @@ struct cmd_desc_type0 {
 
 } __attribute__ ((aligned(64)));
 
-/* Note: sizeof(rcv_desc) should always be a mutliple of 2 */
+/* Note: sizeof(rcv_desc) should always be a multiple of 2 */
 struct rcv_desc {
         __le16 reference_handle;
         __le16 reserved;
@@ -499,7 +499,7 @@ struct uni_data_desc{
 #define NETXEN_IMAGE_START      0x43000 /* compressed image */
 #define NETXEN_SECONDARY_START  0x200000        /* backup images */
 #define NETXEN_PXE_START        0x3E0000        /* PXE boot rom */
-#define NETXEN_USER_START       0x3E8000        /* Firmare info */
+#define NETXEN_USER_START       0x3E8000        /* Firmware info */
 #define NETXEN_FIXED_START      0x3F0000        /* backup of crbinit */
 #define NETXEN_USER_START_OLD   NETXEN_PXE_START /* very old flash */
 
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic.h b/drivers/net/ethernet/qlogic/qlcnic/qlcnic.h
index fa4317611fd6..f221126a5c4e 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic.h
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic.h
@@ -314,7 +314,7 @@ struct qlcnic_fdt {
 #define QLCNIC_BRDCFG_START     0x4000          /* board config */
 #define QLCNIC_BOOTLD_START     0x10000         /* bootld */
 #define QLCNIC_IMAGE_START      0x43000         /* compressed image */
-#define QLCNIC_USER_START       0x3E8000        /* Firmare info */
+#define QLCNIC_USER_START       0x3E8000        /* Firmware info */
 
 #define QLCNIC_FW_VERSION_OFFSET        (QLCNIC_USER_START+0x408)
 #define QLCNIC_FW_SIZE_OFFSET           (QLCNIC_USER_START+0x40c)
diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c
index ad0020af2193..c70ab40d8698 100644
--- a/drivers/net/ethernet/realtek/r8169.c
+++ b/drivers/net/ethernet/realtek/r8169.c
@@ -2561,7 +2561,7 @@ static int rtl_check_firmware(struct rtl8169_private *tp, struct rtl_fw *rtl_fw)
         int rc = -EINVAL;
 
         if (!rtl_fw_format_ok(tp, rtl_fw)) {
-                netif_err(tp, ifup, dev, "invalid firwmare\n");
+                netif_err(tp, ifup, dev, "invalid firmware\n");
                 goto out;
         }
 
@@ -5067,8 +5067,6 @@ static void rtl_hw_reset(struct rtl8169_private *tp)
         RTL_W8(ChipCmd, CmdReset);
 
         rtl_udelay_loop_wait_low(tp, &rtl_chipcmd_cond, 100, 100);
-
-        netdev_reset_queue(tp->dev);
 }
 
 static void rtl_request_uncached_firmware(struct rtl8169_private *tp)
@@ -7049,7 +7047,6 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
         u32 status, len;
         u32 opts[2];
         int frags;
-        bool stop_queue;
 
         if (unlikely(!TX_FRAGS_READY_FOR(tp, skb_shinfo(skb)->nr_frags))) {
                 netif_err(tp, drv, dev, "BUG! Tx Ring full when queue awake!\n");
@@ -7090,8 +7087,6 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
 
         txd->opts2 = cpu_to_le32(opts[1]);
 
-        netdev_sent_queue(dev, skb->len);
-
         skb_tx_timestamp(skb);
 
         /* Force memory writes to complete before releasing descriptor */
@@ -7106,16 +7101,11 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
 
         tp->cur_tx += frags + 1;
 
-        stop_queue = !TX_FRAGS_READY_FOR(tp, MAX_SKB_FRAGS);
+        RTL_W8(TxPoll, NPQ);
 
-        if (!skb->xmit_more || stop_queue ||
-            netif_xmit_stopped(netdev_get_tx_queue(dev, 0))) {
-                RTL_W8(TxPoll, NPQ);
-
-                mmiowb();
-        }
+        mmiowb();
 
-        if (stop_queue) {
+        if (!TX_FRAGS_READY_FOR(tp, MAX_SKB_FRAGS)) {
                 /* Avoid wrongly optimistic queue wake-up: rtl_tx thread must
                  * not miss a ring update when it notices a stopped queue.
                  */
@@ -7198,7 +7188,6 @@ static void rtl8169_pcierr_interrupt(struct net_device *dev)
 static void rtl_tx(struct net_device *dev, struct rtl8169_private *tp)
 {
         unsigned int dirty_tx, tx_left;
-        unsigned int bytes_compl = 0, pkts_compl = 0;
 
         dirty_tx = tp->dirty_tx;
         smp_rmb();
@@ -7222,8 +7211,10 @@ static void rtl_tx(struct net_device *dev, struct rtl8169_private *tp)
                 rtl8169_unmap_tx_skb(&tp->pci_dev->dev, tx_skb,
                                      tp->TxDescArray + entry);
                 if (status & LastFrag) {
-                        pkts_compl++;
-                        bytes_compl += tx_skb->skb->len;
+                        u64_stats_update_begin(&tp->tx_stats.syncp);
+                        tp->tx_stats.packets++;
+                        tp->tx_stats.bytes += tx_skb->skb->len;
+                        u64_stats_update_end(&tp->tx_stats.syncp);
                         dev_kfree_skb_any(tx_skb->skb);
                         tx_skb->skb = NULL;
                 }
@@ -7232,13 +7223,6 @@ static void rtl_tx(struct net_device *dev, struct rtl8169_private *tp)
         }
 
         if (tp->dirty_tx != dirty_tx) {
-                netdev_completed_queue(tp->dev, pkts_compl, bytes_compl);
-
-                u64_stats_update_begin(&tp->tx_stats.syncp);
-                tp->tx_stats.packets += pkts_compl;
-                tp->tx_stats.bytes += bytes_compl;
-                u64_stats_update_end(&tp->tx_stats.syncp);
-
                 tp->dirty_tx = dirty_tx;
                 /* Sync with rtl8169_start_xmit:
                  * - publish dirty_tx ring index (write barrier)
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index 4da8bd263997..736d5d1624a1 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -508,7 +508,6 @@ static struct sh_eth_cpu_data r8a779x_data = {
         .tpauser        = 1,
         .hw_swap        = 1,
         .rmiimode       = 1,
-        .shift_rd0      = 1,
 };
 
 static void sh_eth_set_rate_sh7724(struct net_device *ndev)
@@ -1392,6 +1391,9 @@ static void sh_eth_dev_exit(struct net_device *ndev)
         msleep(2); /* max frame time at 10 Mbps < 1250 us */
         sh_eth_get_stats(ndev);
         sh_eth_reset(ndev);
+
+        /* Set MAC address again */
+        update_mac_address(ndev);
 }
 
 /* free Tx skb function */
@@ -1407,6 +1409,8 @@ static int sh_eth_txfree(struct net_device *ndev)
                 txdesc = &mdp->tx_ring[entry];
                 if (txdesc->status & cpu_to_edmac(mdp, TD_TACT))
                         break;
+                /* TACT bit must be checked before all the following reads */
+                rmb();
                 /* Free the original skb. */
                 if (mdp->tx_skbuff[entry]) {
                         dma_unmap_single(&ndev->dev, txdesc->addr,
@@ -1444,6 +1448,8 @@ static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
         limit = boguscnt;
         rxdesc = &mdp->rx_ring[entry];
         while (!(rxdesc->status & cpu_to_edmac(mdp, RD_RACT))) {
+                /* RACT bit must be checked before all the following reads */
+                rmb();
                 desc_status = edmac_to_cpu(mdp, rxdesc->status);
                 pkt_len = rxdesc->frame_length;
 
@@ -1455,8 +1461,8 @@ static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
 
                 /* In case of almost all GETHER/ETHERs, the Receive Frame State
                  * (RFS) bits in the Receive Descriptor 0 are from bit 9 to
-                 * bit 0. However, in case of the R8A7740, R8A779x, and
-                 * R7S72100 the RFS bits are from bit 25 to bit 16. So, the
+                 * bit 0. However, in case of the R8A7740 and R7S72100
+                 * the RFS bits are from bit 25 to bit 16. So, the
                  * driver needs right shifting by 16.
                  */
                 if (mdp->cd->shift_rd0)
@@ -1523,6 +1529,7 @@ static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
                         skb_checksum_none_assert(skb);
                         rxdesc->addr = dma_addr;
                 }
+                wmb(); /* RACT bit must be set after all the above writes */
                 if (entry >= mdp->num_rx_ring - 1)
                         rxdesc->status |=
                                 cpu_to_edmac(mdp, RD_RACT | RD_RFP | RD_RDEL);
@@ -1535,7 +1542,7 @@ static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
         /* If we don't need to check status, don't. -KDU */
         if (!(sh_eth_read(ndev, EDRRR) & EDRRR_R)) {
                 /* fix the values for the next receiving if RDE is set */
-                if (intr_status & EESR_RDE) {
+                if (intr_status & EESR_RDE && mdp->reg_offset[RDFAR] != 0) {
                         u32 count = (sh_eth_read(ndev, RDFAR) -
                                      sh_eth_read(ndev, RDLAR)) >> 4;
 
@@ -2174,7 +2181,7 @@ static int sh_eth_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         }
         spin_unlock_irqrestore(&mdp->lock, flags);
 
-        if (skb_padto(skb, ETH_ZLEN))
+        if (skb_put_padto(skb, ETH_ZLEN))
                 return NETDEV_TX_OK;
 
         entry = mdp->cur_tx % mdp->num_tx_ring;
@@ -2192,6 +2199,7 @@ static int sh_eth_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         }
         txdesc->buffer_length = skb->len;
 
+        wmb(); /* TACT bit must be set after all the above writes */
         if (entry >= mdp->num_tx_ring - 1)
                 txdesc->status |= cpu_to_edmac(mdp, TD_TACT | TD_TDLE);
         else
diff --git a/drivers/net/ethernet/rocker/rocker.c b/drivers/net/ethernet/rocker/rocker.c
index e5a15a4c4e8f..a5d1e6ea7d58 100644
--- a/drivers/net/ethernet/rocker/rocker.c
+++ b/drivers/net/ethernet/rocker/rocker.c
@@ -1280,9 +1280,9 @@ static void rocker_port_set_enable(struct rocker_port *rocker_port, bool enable)
         u64 val = rocker_read64(rocker_port->rocker, PORT_PHYS_ENABLE);
 
         if (enable)
-                val |= 1 << rocker_port->pport;
+                val |= 1ULL << rocker_port->pport;
         else
-                val &= ~(1 << rocker_port->pport);
+                val &= ~(1ULL << rocker_port->pport);
         rocker_write64(rocker_port->rocker, PORT_PHYS_ENABLE, val);
 }
 
@@ -4241,6 +4241,8 @@ static int rocker_probe_ports(struct rocker *rocker)
 
         alloc_size = sizeof(struct rocker_port *) * rocker->port_count;
         rocker->ports = kmalloc(alloc_size, GFP_KERNEL);
+        if (!rocker->ports)
+                return -ENOMEM;
         for (i = 0; i < rocker->port_count; i++) {
                 err = rocker_probe_port(rocker, i);
                 if (err)
diff --git a/drivers/net/ethernet/smsc/smc91c92_cs.c b/drivers/net/ethernet/smsc/smc91c92_cs.c
index 6b33127ab352..3449893aea8d 100644
--- a/drivers/net/ethernet/smsc/smc91c92_cs.c
+++ b/drivers/net/ethernet/smsc/smc91c92_cs.c
@@ -1070,11 +1070,8 @@ static int smc_open(struct net_device *dev)
     smc->packets_waiting = 0;
 
     smc_reset(dev);
-    init_timer(&smc->media);
-    smc->media.function = media_check;
-    smc->media.data = (u_long) dev;
-    smc->media.expires = jiffies + HZ;
-    add_timer(&smc->media);
+    setup_timer(&smc->media, media_check, (u_long)dev);
+    mod_timer(&smc->media, jiffies + HZ);
 
     return 0;
 } /* smc_open */
diff --git a/drivers/net/ethernet/smsc/smc91x.c b/drivers/net/ethernet/smsc/smc91x.c
index 88a55f95fe09..209ee1b27f8d 100644
--- a/drivers/net/ethernet/smsc/smc91x.c
+++ b/drivers/net/ethernet/smsc/smc91x.c
@@ -91,6 +91,10 @@ static const char version[] =
 
 #include "smc91x.h"
 
+#if defined(CONFIG_ASSABET_NEPONSET)
+#include <mach/neponset.h>
+#endif
+
 #ifndef SMC_NOWAIT
 # define SMC_NOWAIT             0
 #endif
@@ -2355,8 +2359,9 @@ static int smc_drv_probe(struct platform_device *pdev)
         ret = smc_request_attrib(pdev, ndev);
         if (ret)
                 goto out_release_io;
-#if defined(CONFIG_SA1100_ASSABET)
-        neponset_ncr_set(NCR_ENET_OSC_EN);
+#if defined(CONFIG_ASSABET_NEPONSET)
+        if (machine_is_assabet() && machine_has_neponset())
+                neponset_ncr_set(NCR_ENET_OSC_EN);
 #endif
         platform_set_drvdata(pdev, ndev);
         ret = smc_enable_device(pdev);
diff --git a/drivers/net/ethernet/smsc/smc91x.h b/drivers/net/ethernet/smsc/smc91x.h
index be67baf5f677..3a18501d1068 100644
--- a/drivers/net/ethernet/smsc/smc91x.h
+++ b/drivers/net/ethernet/smsc/smc91x.h
@@ -39,14 +39,7 @@
  * Define your architecture specific bus configuration parameters here.
  */
 
-#if defined(CONFIG_ARCH_LUBBOCK) ||\
-    defined(CONFIG_MACH_MAINSTONE) ||\
-    defined(CONFIG_MACH_ZYLONITE) ||\
-    defined(CONFIG_MACH_LITTLETON) ||\
-    defined(CONFIG_MACH_ZYLONITE2) ||\
-    defined(CONFIG_ARCH_VIPER) ||\
-    defined(CONFIG_MACH_STARGATE2) ||\
-    defined(CONFIG_ARCH_VERSATILE)
+#if defined(CONFIG_ARM)
 
 #include <asm/mach-types.h>
 
@@ -74,95 +67,8 @@
 /* We actually can't write halfwords properly if not word aligned */
 static inline void SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 {
-        if ((machine_is_mainstone() || machine_is_stargate2()) && reg & 2) {
-                unsigned int v = val << 16;
-                v |= readl(ioaddr + (reg & ~2)) & 0xffff;
-                writel(v, ioaddr + (reg & ~2));
-        } else {
-                writew(val, ioaddr + reg);
-        }
-}
-
-#elif defined(CONFIG_SA1100_PLEB)
-/* We can only do 16-bit reads and writes in the static memory space. */
-#define SMC_CAN_USE_8BIT        1
-#define SMC_CAN_USE_16BIT       1
-#define SMC_CAN_USE_32BIT       0
-#define SMC_IO_SHIFT            0
-#define SMC_NOWAIT              1
-
-#define SMC_inb(a, r)           readb((a) + (r))
-#define SMC_insb(a, r, p, l)    readsb((a) + (r), p, (l))
-#define SMC_inw(a, r)           readw((a) + (r))
-#define SMC_insw(a, r, p, l)    readsw((a) + (r), p, l)
-#define SMC_outb(v, a, r)       writeb(v, (a) + (r))
-#define SMC_outsb(a, r, p, l)   writesb((a) + (r), p, (l))
-#define SMC_outw(v, a, r)       writew(v, (a) + (r))
-#define SMC_outsw(a, r, p, l)   writesw((a) + (r), p, l)
-
-#define SMC_IRQ_FLAGS           (-1)
-
-#elif defined(CONFIG_SA1100_ASSABET)
-
-#include <mach/neponset.h>
-
-/* We can only do 8-bit reads and writes in the static memory space. */
-#define SMC_CAN_USE_8BIT        1
-#define SMC_CAN_USE_16BIT       0
-#define SMC_CAN_USE_32BIT       0
-#define SMC_NOWAIT              1
-
-/* The first two address lines aren't connected... */
-#define SMC_IO_SHIFT            2
-
-#define SMC_inb(a, r)           readb((a) + (r))
-#define SMC_outb(v, a, r)       writeb(v, (a) + (r))
-#define SMC_insb(a, r, p, l)    readsb((a) + (r), p, (l))
-#define SMC_outsb(a, r, p, l)   writesb((a) + (r), p, (l))
-#define SMC_IRQ_FLAGS           (-1)    /* from resource */
-
-#elif   defined(CONFIG_MACH_LOGICPD_PXA270) ||  \
-        defined(CONFIG_MACH_NOMADIK_8815NHK)
-
-#define SMC_CAN_USE_8BIT        0
-#define SMC_CAN_USE_16BIT       1
-#define SMC_CAN_USE_32BIT       0
-#define SMC_IO_SHIFT            0
-#define SMC_NOWAIT              1
-
-#define SMC_inw(a, r)           readw((a) + (r))
-#define SMC_outw(v, a, r)       writew(v, (a) + (r))
-#define SMC_insw(a, r, p, l)    readsw((a) + (r), p, l)
-#define SMC_outsw(a, r, p, l)   writesw((a) + (r), p, l)
-
-#elif   defined(CONFIG_ARCH_INNOKOM) || \
-        defined(CONFIG_ARCH_PXA_IDP) || \
-        defined(CONFIG_ARCH_RAMSES) || \
-        defined(CONFIG_ARCH_PCM027)
-
-#define SMC_CAN_USE_8BIT        1
-#define SMC_CAN_USE_16BIT       1
-#define SMC_CAN_USE_32BIT       1
-#define SMC_IO_SHIFT            0
-#define SMC_NOWAIT              1
-#define SMC_USE_PXA_DMA         1
-
-#define SMC_inb(a, r)           readb((a) + (r))
-#define SMC_inw(a, r)           readw((a) + (r))
-#define SMC_inl(a, r)           readl((a) + (r))
-#define SMC_outb(v, a, r)       writeb(v, (a) + (r))
-#define SMC_outl(v, a, r)       writel(v, (a) + (r))
-#define SMC_insl(a, r, p, l)    readsl((a) + (r), p, l)
-#define SMC_outsl(a, r, p, l)   writesl((a) + (r), p, l)
-#define SMC_insw(a, r, p, l)    readsw((a) + (r), p, l)
-#define SMC_outsw(a, r, p, l)   writesw((a) + (r), p, l)
-#define SMC_IRQ_FLAGS           (-1)    /* from resource */
-
-/* We actually can't write halfwords properly if not word aligned */
-static inline void
-SMC_outw(u16 val, void __iomem *ioaddr, int reg)
-{
-        if (reg & 2) {
+        if ((machine_is_mainstone() || machine_is_stargate2() ||
+             machine_is_pxa_idp()) && reg & 2) {
                 unsigned int v = val << 16;
                 v |= readl(ioaddr + (reg & ~2)) & 0xffff;
                 writel(v, ioaddr + (reg & ~2));
@@ -237,20 +143,6 @@ SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 #define RPC_LSA_DEFAULT         RPC_LED_100_10
 #define RPC_LSB_DEFAULT         RPC_LED_TX_RX
 
-#elif defined(CONFIG_ARCH_MSM)
-
-#define SMC_CAN_USE_8BIT        0
-#define SMC_CAN_USE_16BIT       1
-#define SMC_CAN_USE_32BIT       0
-#define SMC_NOWAIT              1
-
-#define SMC_inw(a, r)           readw((a) + (r))
-#define SMC_outw(v, a, r)       writew(v, (a) + (r))
-#define SMC_insw(a, r, p, l)    readsw((a) + (r), p, l)
-#define SMC_outsw(a, r, p, l)   writesw((a) + (r), p, l)
-
-#define SMC_IRQ_FLAGS           IRQF_TRIGGER_HIGH
-
 #elif defined(CONFIG_COLDFIRE)
 
 #define SMC_CAN_USE_8BIT        0
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 55e89b3838f1..a0ea84fe6519 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -310,11 +310,11 @@ bool stmmac_eee_init(struct stmmac_priv *priv)
                 spin_lock_irqsave(&priv->lock, flags);
                 if (!priv->eee_active) {
                         priv->eee_active = 1;
-                        init_timer(&priv->eee_ctrl_timer);
-                        priv->eee_ctrl_timer.function = stmmac_eee_ctrl_timer;
-                        priv->eee_ctrl_timer.data = (unsigned long)priv;
-                        priv->eee_ctrl_timer.expires = STMMAC_LPI_T(eee_timer);
-                        add_timer(&priv->eee_ctrl_timer);
+                        setup_timer(&priv->eee_ctrl_timer,
+                                    stmmac_eee_ctrl_timer,
+                                    (unsigned long)priv);
+                        mod_timer(&priv->eee_ctrl_timer,
+                                  STMMAC_LPI_T(eee_timer));
 
                         priv->hw->mac->set_eee_timer(priv->hw,
                                                      STMMAC_DEFAULT_LIT_LS,
diff --git a/drivers/net/ethernet/sun/niu.c b/drivers/net/ethernet/sun/niu.c
index 4b51f903fb73..0c5842aeb807 100644
--- a/drivers/net/ethernet/sun/niu.c
+++ b/drivers/net/ethernet/sun/niu.c
@@ -6989,10 +6989,10 @@ static int niu_class_to_ethflow(u64 class, int *flow_type)
                 *flow_type = IP_USER_FLOW;
                 break;
         default:
-                return 0;
+                return -EINVAL;
         }
 
-        return 1;
+        return 0;
 }
 
 static int niu_ethflow_to_class(int flow_type, u64 *class)
@@ -7198,11 +7198,9 @@ static int niu_get_ethtool_tcam_entry(struct niu *np,
         class = (tp->key[0] & TCAM_V4KEY0_CLASS_CODE) >>
                 TCAM_V4KEY0_CLASS_CODE_SHIFT;
         ret = niu_class_to_ethflow(class, &fsp->flow_type);
-
         if (ret < 0) {
                 netdev_info(np->dev, "niu%d: niu_class_to_ethflow failed\n",
                             parent->index);
-                ret = -EINVAL;
                 goto out;
         }
 
diff --git a/drivers/net/ethernet/ti/Kconfig b/drivers/net/ethernet/ti/Kconfig
index 3bc992cd70b7..f6a71092e135 100644
--- a/drivers/net/ethernet/ti/Kconfig
+++ b/drivers/net/ethernet/ti/Kconfig
@@ -50,7 +50,7 @@ config TI_DAVINCI_CPDMA
           will be called davinci_cpdma.  This is recommended.
 
 config TI_CPSW_PHY_SEL
-        boolean "TI CPSW Switch Phy sel Support"
+        bool "TI CPSW Switch Phy sel Support"
         depends on TI_CPSW
         ---help---
           This driver supports configuring of the phy mode connected to
@@ -77,7 +77,7 @@ config TI_CPSW
           will be called cpsw.
 
 config TI_CPTS
-        boolean "TI Common Platform Time Sync (CPTS) Support"
+        bool "TI Common Platform Time Sync (CPTS) Support"
         depends on TI_CPSW
         select PTP_1588_CLOCK
         ---help---
diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c
index 7d8dd0d2182e..a1bbaf6352ba 100644
--- a/drivers/net/ethernet/ti/cpsw.c
+++ b/drivers/net/ethernet/ti/cpsw.c
@@ -1103,7 +1103,7 @@ static inline void cpsw_add_dual_emac_def_ale_entries(
         cpsw_ale_add_mcast(priv->ale, priv->ndev->broadcast,
                            port_mask, ALE_VLAN, slave->port_vlan, 0);
         cpsw_ale_add_ucast(priv->ale, priv->mac_addr,
-                priv->host_port, ALE_VLAN, slave->port_vlan);
+                priv->host_port, ALE_VLAN | ALE_SECURE, slave->port_vlan);
 }
 
 static void soft_reset_slave(struct cpsw_slave *slave)
@@ -2466,6 +2466,7 @@ static int cpsw_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
 static int cpsw_suspend(struct device *dev)
 {
         struct platform_device  *pdev = to_platform_device(dev);
@@ -2518,11 +2519,9 @@ static int cpsw_resume(struct device *dev)
         }
         return 0;
 }
+#endif
 
-static const struct dev_pm_ops cpsw_pm_ops = {
-        .suspend        = cpsw_suspend,
-        .resume         = cpsw_resume,
-};
+static SIMPLE_DEV_PM_OPS(cpsw_pm_ops, cpsw_suspend, cpsw_resume);
 
 static const struct of_device_id cpsw_of_mtable[] = {
         { .compatible = "ti,cpsw", },
diff --git a/drivers/net/ethernet/ti/davinci_mdio.c b/drivers/net/ethernet/ti/davinci_mdio.c
index 98655b44b97e..c00084d689f3 100644
--- a/drivers/net/ethernet/ti/davinci_mdio.c
+++ b/drivers/net/ethernet/ti/davinci_mdio.c
@@ -423,6 +423,7 @@ static int davinci_mdio_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
 static int davinci_mdio_suspend(struct device *dev)
 {
         struct davinci_mdio_data *data = dev_get_drvdata(dev);
@@ -464,10 +465,10 @@ static int davinci_mdio_resume(struct device *dev)
 
         return 0;
 }
+#endif
 
 static const struct dev_pm_ops davinci_mdio_pm_ops = {
-        .suspend_late   = davinci_mdio_suspend,
-        .resume_early   = davinci_mdio_resume,
+        SET_LATE_SYSTEM_SLEEP_PM_OPS(davinci_mdio_suspend, davinci_mdio_resume)
 };
 
 #if IS_ENABLED(CONFIG_OF)
diff --git a/drivers/net/ethernet/xscale/ixp4xx_eth.c b/drivers/net/ethernet/xscale/ixp4xx_eth.c
index 44ff8d7c64a5..5138407941cf 100644
--- a/drivers/net/ethernet/xscale/ixp4xx_eth.c
+++ b/drivers/net/ethernet/xscale/ixp4xx_eth.c
@@ -938,7 +938,7 @@ static void eth_set_mcast_list(struct net_device *dev)
         int i;
         static const u8 allmulti[] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
-        if (dev->flags & IFF_ALLMULTI) {
+        if ((dev->flags & IFF_ALLMULTI) && !(dev->flags & IFF_PROMISC)) {
                 for (i = 0; i < ETH_ALEN; i++) {
                         __raw_writel(allmulti[i], &port->regs->mcast_addr[i]);
                         __raw_writel(allmulti[i], &port->regs->mcast_mask[i]);
diff --git a/drivers/net/macvtap.c b/drivers/net/macvtap.c
index 1e51c6bf3ae1..8362aef0c15e 100644
--- a/drivers/net/macvtap.c
+++ b/drivers/net/macvtap.c
@@ -654,11 +654,14 @@ static void macvtap_skb_to_vnet_hdr(struct macvtap_queue *q,
         } /* else everything is zero */
 }
 
+/* Neighbour code has some assumptions on HH_DATA_MOD alignment */
+#define MACVTAP_RESERVE HH_DATA_OFF(ETH_HLEN)
+
 /* Get packet from user space buffer */
 static ssize_t macvtap_get_user(struct macvtap_queue *q, struct msghdr *m,
                                 struct iov_iter *from, int noblock)
 {
-        int good_linear = SKB_MAX_HEAD(NET_IP_ALIGN);
+        int good_linear = SKB_MAX_HEAD(MACVTAP_RESERVE);
         struct sk_buff *skb;
         struct macvlan_dev *vlan;
         unsigned long total_len = iov_iter_count(from);
@@ -722,7 +725,7 @@ static ssize_t macvtap_get_user(struct macvtap_queue *q, struct msghdr *m,
                         linear = macvtap16_to_cpu(q, vnet_hdr.hdr_len);
         }
 
-        skb = macvtap_alloc_skb(&q->sk, NET_IP_ALIGN, copylen,
+        skb = macvtap_alloc_skb(&q->sk, MACVTAP_RESERVE, copylen,
                                 linear, noblock, &err);
         if (!skb)
                 goto err;
diff --git a/drivers/net/phy/amd-xgbe-phy.c b/drivers/net/phy/amd-xgbe-phy.c
index 9e3af54c9010..32efbd48f326 100644
--- a/drivers/net/phy/amd-xgbe-phy.c
+++ b/drivers/net/phy/amd-xgbe-phy.c
@@ -92,6 +92,8 @@ MODULE_DESCRIPTION("AMD 10GbE (amd-xgbe) PHY driver");
 #define XGBE_PHY_CDR_RATE_PROPERTY      "amd,serdes-cdr-rate"
 #define XGBE_PHY_PQ_SKEW_PROPERTY       "amd,serdes-pq-skew"
 #define XGBE_PHY_TX_AMP_PROPERTY        "amd,serdes-tx-amp"
+#define XGBE_PHY_DFE_CFG_PROPERTY       "amd,serdes-dfe-tap-config"
+#define XGBE_PHY_DFE_ENA_PROPERTY       "amd,serdes-dfe-tap-enable"
 
 #define XGBE_PHY_SPEEDS                 3
 #define XGBE_PHY_SPEED_1000             0
@@ -177,10 +179,12 @@ MODULE_DESCRIPTION("AMD 10GbE (amd-xgbe) PHY driver");
 #define SPEED_10000_BLWC                0
 #define SPEED_10000_CDR                 0x7
 #define SPEED_10000_PLL                 0x1
-#define SPEED_10000_PQ                  0x1e
+#define SPEED_10000_PQ                  0x12
 #define SPEED_10000_RATE                0x0
 #define SPEED_10000_TXAMP               0xa
 #define SPEED_10000_WORD                0x7
+#define SPEED_10000_DFE_TAP_CONFIG      0x1
+#define SPEED_10000_DFE_TAP_ENABLE      0x7f
 
 #define SPEED_2500_BLWC                 1
 #define SPEED_2500_CDR                  0x2
@@ -189,6 +193,8 @@ MODULE_DESCRIPTION("AMD 10GbE (amd-xgbe) PHY driver");
 #define SPEED_2500_RATE                 0x1
 #define SPEED_2500_TXAMP                0xf
 #define SPEED_2500_WORD                 0x1
+#define SPEED_2500_DFE_TAP_CONFIG       0x3
+#define SPEED_2500_DFE_TAP_ENABLE       0x0
 
 #define SPEED_1000_BLWC                 1
 #define SPEED_1000_CDR                  0x2
@@ -197,16 +203,25 @@ MODULE_DESCRIPTION("AMD 10GbE (amd-xgbe) PHY driver");
 #define SPEED_1000_RATE                 0x3
 #define SPEED_1000_TXAMP                0xf
 #define SPEED_1000_WORD                 0x1
+#define SPEED_1000_DFE_TAP_CONFIG       0x3
+#define SPEED_1000_DFE_TAP_ENABLE       0x0
 
 /* SerDes RxTx register offsets */
+#define RXTX_REG6                       0x0018
 #define RXTX_REG20                      0x0050
+#define RXTX_REG22                      0x0058
 #define RXTX_REG114                     0x01c8
+#define RXTX_REG129                     0x0204
 
 /* SerDes RxTx register entry bit positions and sizes */
+#define RXTX_REG6_RESETB_RXD_INDEX      8
+#define RXTX_REG6_RESETB_RXD_WIDTH      1
 #define RXTX_REG20_BLWC_ENA_INDEX       2
 #define RXTX_REG20_BLWC_ENA_WIDTH       1
 #define RXTX_REG114_PQ_REG_INDEX        9
 #define RXTX_REG114_PQ_REG_WIDTH        7
+#define RXTX_REG129_RXDFE_CONFIG_INDEX  14
+#define RXTX_REG129_RXDFE_CONFIG_WIDTH  2
 
 /* Bit setting and getting macros
  *  The get macro will extract the current bit field value from within
@@ -333,6 +348,18 @@ static const u32 amd_xgbe_phy_serdes_tx_amp[] = {
         SPEED_10000_TXAMP,
 };
 
+static const u32 amd_xgbe_phy_serdes_dfe_tap_cfg[] = {
+        SPEED_1000_DFE_TAP_CONFIG,
+        SPEED_2500_DFE_TAP_CONFIG,
+        SPEED_10000_DFE_TAP_CONFIG,
+};
+
+static const u32 amd_xgbe_phy_serdes_dfe_tap_ena[] = {
+        SPEED_1000_DFE_TAP_ENABLE,
+        SPEED_2500_DFE_TAP_ENABLE,
+        SPEED_10000_DFE_TAP_ENABLE,
+};
+
 enum amd_xgbe_phy_an {
         AMD_XGBE_AN_READY = 0,
         AMD_XGBE_AN_PAGE_RECEIVED,
@@ -393,6 +420,8 @@ struct amd_xgbe_phy_priv {
         u32 serdes_cdr_rate[XGBE_PHY_SPEEDS];
         u32 serdes_pq_skew[XGBE_PHY_SPEEDS];
         u32 serdes_tx_amp[XGBE_PHY_SPEEDS];
+        u32 serdes_dfe_tap_cfg[XGBE_PHY_SPEEDS];
+        u32 serdes_dfe_tap_ena[XGBE_PHY_SPEEDS];
 
         /* Auto-negotiation state machine support */
         struct mutex an_mutex;
@@ -481,11 +510,16 @@ static void amd_xgbe_phy_serdes_complete_ratechange(struct phy_device *phydev)
                 status = XSIR0_IOREAD(priv, SIR0_STATUS);
                 if (XSIR_GET_BITS(status, SIR0_STATUS, RX_READY) &&
                     XSIR_GET_BITS(status, SIR0_STATUS, TX_READY))
-                        return;
+                        goto rx_reset;
         }
 
         netdev_dbg(phydev->attached_dev, "SerDes rx/tx not ready (%#hx)\n",
                    status);
+
+rx_reset:
+        /* Perform Rx reset for the DFE changes */
+        XRXTX_IOWRITE_BITS(priv, RXTX_REG6, RESETB_RXD, 0);
+        XRXTX_IOWRITE_BITS(priv, RXTX_REG6, RESETB_RXD, 1);
 }
 
 static int amd_xgbe_phy_xgmii_mode(struct phy_device *phydev)
@@ -534,6 +568,10 @@ static int amd_xgbe_phy_xgmii_mode(struct phy_device *phydev)
                            priv->serdes_blwc[XGBE_PHY_SPEED_10000]);
         XRXTX_IOWRITE_BITS(priv, RXTX_REG114, PQ_REG,
                            priv->serdes_pq_skew[XGBE_PHY_SPEED_10000]);
+        XRXTX_IOWRITE_BITS(priv, RXTX_REG129, RXDFE_CONFIG,
+                           priv->serdes_dfe_tap_cfg[XGBE_PHY_SPEED_10000]);
+        XRXTX_IOWRITE(priv, RXTX_REG22,
+                      priv->serdes_dfe_tap_ena[XGBE_PHY_SPEED_10000]);
 
         amd_xgbe_phy_serdes_complete_ratechange(phydev);
 
@@ -586,6 +624,10 @@ static int amd_xgbe_phy_gmii_2500_mode(struct phy_device *phydev)
                            priv->serdes_blwc[XGBE_PHY_SPEED_2500]);
         XRXTX_IOWRITE_BITS(priv, RXTX_REG114, PQ_REG,
                            priv->serdes_pq_skew[XGBE_PHY_SPEED_2500]);
+        XRXTX_IOWRITE_BITS(priv, RXTX_REG129, RXDFE_CONFIG,
+                           priv->serdes_dfe_tap_cfg[XGBE_PHY_SPEED_2500]);
+        XRXTX_IOWRITE(priv, RXTX_REG22,
+                      priv->serdes_dfe_tap_ena[XGBE_PHY_SPEED_2500]);
 
         amd_xgbe_phy_serdes_complete_ratechange(phydev);
 
@@ -638,6 +680,10 @@ static int amd_xgbe_phy_gmii_mode(struct phy_device *phydev)
                            priv->serdes_blwc[XGBE_PHY_SPEED_1000]);
         XRXTX_IOWRITE_BITS(priv, RXTX_REG114, PQ_REG,
                            priv->serdes_pq_skew[XGBE_PHY_SPEED_1000]);
+        XRXTX_IOWRITE_BITS(priv, RXTX_REG129, RXDFE_CONFIG,
+                           priv->serdes_dfe_tap_cfg[XGBE_PHY_SPEED_1000]);
+        XRXTX_IOWRITE(priv, RXTX_REG22,
+                      priv->serdes_dfe_tap_ena[XGBE_PHY_SPEED_1000]);
 
         amd_xgbe_phy_serdes_complete_ratechange(phydev);
 
@@ -1668,6 +1714,38 @@ static int amd_xgbe_phy_probe(struct phy_device *phydev)
                        sizeof(priv->serdes_tx_amp));
         }
 
+        if (device_property_present(phy_dev, XGBE_PHY_DFE_CFG_PROPERTY)) {
+                ret = device_property_read_u32_array(phy_dev,
+                                                     XGBE_PHY_DFE_CFG_PROPERTY,
+                                                     priv->serdes_dfe_tap_cfg,
+                                                     XGBE_PHY_SPEEDS);
+                if (ret) {
+                        dev_err(dev, "invalid %s property\n",
+                                XGBE_PHY_DFE_CFG_PROPERTY);
+                        goto err_sir1;
+                }
+        } else {
+                memcpy(priv->serdes_dfe_tap_cfg,
+                       amd_xgbe_phy_serdes_dfe_tap_cfg,
+                       sizeof(priv->serdes_dfe_tap_cfg));
+        }
+
+        if (device_property_present(phy_dev, XGBE_PHY_DFE_ENA_PROPERTY)) {
+                ret = device_property_read_u32_array(phy_dev,
+                                                     XGBE_PHY_DFE_ENA_PROPERTY,
+                                                     priv->serdes_dfe_tap_ena,
+                                                     XGBE_PHY_SPEEDS);
+                if (ret) {
+                        dev_err(dev, "invalid %s property\n",
+                                XGBE_PHY_DFE_ENA_PROPERTY);
+                        goto err_sir1;
+                }
+        } else {
+                memcpy(priv->serdes_dfe_tap_ena,
+                       amd_xgbe_phy_serdes_dfe_tap_ena,
+                       sizeof(priv->serdes_dfe_tap_ena));
+        }
+
         phydev->priv = priv;
 
         if (!priv->adev || acpi_disabled)
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index cdcac6aa4260..52cd8db2c57d 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -236,6 +236,25 @@ static inline unsigned int phy_find_valid(unsigned int idx, u32 features)
 }
 
 /**
+ * phy_check_valid - check if there is a valid PHY setting which matches
+ *                   speed, duplex, and feature mask
+ * @speed: speed to match
+ * @duplex: duplex to match
+ * @features: A mask of the valid settings
+ *
+ * Description: Returns true if there is a valid setting, false otherwise.
+ */
+static inline bool phy_check_valid(int speed, int duplex, u32 features)
+{
+        unsigned int idx;
+
+        idx = phy_find_valid(phy_find_setting(speed, duplex), features);
+
+        return settings[idx].speed == speed && settings[idx].duplex == duplex &&
+                (settings[idx].setting & features);
+}
+
+/**
  * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
  * @phydev: the target phy_device struct
  *
@@ -1045,7 +1064,6 @@ int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
                 int eee_lp, eee_cap, eee_adv;
                 u32 lp, cap, adv;
                 int status;
-                unsigned int idx;
 
                 /* Read phy status to properly get the right settings */
                 status = phy_read_status(phydev);
@@ -1077,8 +1095,7 @@ int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
 
                 adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
                 lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
-                idx = phy_find_setting(phydev->speed, phydev->duplex);
-                if (!(lp & adv & settings[idx].setting))
+                if (!phy_check_valid(phydev->speed, phydev->duplex, lp & adv))
                         goto eee_exit_err;
 
                 if (clk_stop_enable) {
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index a7d163bf5bbb..9d3366f7c9ad 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -43,9 +43,7 @@
 
 static struct team_port *team_port_get_rcu(const struct net_device *dev)
 {
-        struct team_port *port = rcu_dereference(dev->rx_handler_data);
-
-        return team_port_exists(dev) ? port : NULL;
+        return rcu_dereference(dev->rx_handler_data);
 }
 
 static struct team_port *team_port_get_rtnl(const struct net_device *dev)
diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig
index 37eed4d84e9c..7ba8d0885f12 100644
--- a/drivers/net/usb/Kconfig
+++ b/drivers/net/usb/Kconfig
@@ -161,6 +161,7 @@ config USB_NET_AX8817X
             * Linksys USB200M
             * Netgear FA120
             * Sitecom LN-029
+            * Sitecom LN-028
             * Intellinet USB 2.0 Ethernet
             * ST Lab USB 2.0 Ethernet
             * TrendNet TU2-ET100
@@ -397,14 +398,14 @@ config USB_NET_CDC_SUBSET
           not generally have permanently assigned Ethernet addresses.
 
 config USB_ALI_M5632
-        boolean "ALi M5632 based 'USB 2.0 Data Link' cables"
+        bool "ALi M5632 based 'USB 2.0 Data Link' cables"
         depends on USB_NET_CDC_SUBSET
         help
           Choose this option if you're using a host-to-host cable
           based on this design, which supports USB 2.0 high speed.
 
 config USB_AN2720
-        boolean "AnchorChips 2720 based cables (Xircom PGUNET, ...)"
+        bool "AnchorChips 2720 based cables (Xircom PGUNET, ...)"
         depends on USB_NET_CDC_SUBSET
         help
           Choose this option if you're using a host-to-host cable
@@ -412,7 +413,7 @@ config USB_AN2720
           Cypress brand.
 
 config USB_BELKIN
-        boolean "eTEK based host-to-host cables (Advance, Belkin, ...)"
+        bool "eTEK based host-to-host cables (Advance, Belkin, ...)"
         depends on USB_NET_CDC_SUBSET
         default y
         help
@@ -421,7 +422,7 @@ config USB_BELKIN
           microcontroller, with LEDs that indicate traffic.
 
 config USB_ARMLINUX
-        boolean "Embedded ARM Linux links (iPaq, ...)"
+        bool "Embedded ARM Linux links (iPaq, ...)"
         depends on USB_NET_CDC_SUBSET
         default y
         help
@@ -438,14 +439,14 @@ config USB_ARMLINUX
           this simpler protocol by installing a different kernel.
 
 config USB_EPSON2888
-        boolean "Epson 2888 based firmware (DEVELOPMENT)"
+        bool "Epson 2888 based firmware (DEVELOPMENT)"
         depends on USB_NET_CDC_SUBSET
         help
           Choose this option to support the usb networking links used
           by some sample firmware from Epson.
 
 config USB_KC2190
-        boolean "KT Technology KC2190 based cables (InstaNet)"
+        bool "KT Technology KC2190 based cables (InstaNet)"
         depends on USB_NET_CDC_SUBSET
         help
           Choose this option if you're using a host-to-host cable
diff --git a/drivers/net/usb/asix_devices.c b/drivers/net/usb/asix_devices.c
index bf49792062a2..1173a24feda3 100644
--- a/drivers/net/usb/asix_devices.c
+++ b/drivers/net/usb/asix_devices.c
@@ -979,6 +979,10 @@ static const struct usb_device_id	products [] = {
         USB_DEVICE (0x0df6, 0x0056),
         .driver_info =  (unsigned long) &ax88178_info,
 }, {
+        // Sitecom LN-028 "USB 2.0 10/100/1000 Ethernet adapter"
+        USB_DEVICE (0x0df6, 0x061c),
+        .driver_info =  (unsigned long) &ax88178_info,
+}, {
         // corega FEther USB2-TX
         USB_DEVICE (0x07aa, 0x0017),
         .driver_info =  (unsigned long) &ax8817x_info,
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index 3c8dfe5e46ed..111d907e0c11 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -1597,7 +1597,7 @@ hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
                 }
                 cprev = cnow;
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&tiocmget->waitq, &wait);
 
         return ret;
diff --git a/drivers/net/usb/plusb.c b/drivers/net/usb/plusb.c
index 3d18bb0eee85..1bfe0fcaccf5 100644
--- a/drivers/net/usb/plusb.c
+++ b/drivers/net/usb/plusb.c
@@ -134,6 +134,11 @@ static const struct usb_device_id	products [] = {
 }, {
         USB_DEVICE(0x050d, 0x258a),     /* Belkin F5U258/F5U279 (PL-25A1) */
         .driver_info =  (unsigned long) &prolific_info,
+}, {
+        USB_DEVICE(0x3923, 0x7825),     /* National Instruments USB
+                                         * Host-to-Host Cable
+                                         */
+        .driver_info =  (unsigned long) &prolific_info,
 },
 
         { },            // END
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 110a2cf67244..f1ff3666f090 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -1710,6 +1710,12 @@ static int virtnet_probe(struct virtio_device *vdev)
         struct virtnet_info *vi;
         u16 max_queue_pairs;
 
+        if (!vdev->config->get) {
+                dev_err(&vdev->dev, "%s failure: config access disabled\n",
+                        __func__);
+                return -EINVAL;
+        }
+
         if (!virtnet_validate_features(vdev))
                 return -EINVAL;
 
diff --git a/drivers/net/wan/cosa.c b/drivers/net/wan/cosa.c
index 83c39e2858bf..88d121d43c08 100644
--- a/drivers/net/wan/cosa.c
+++ b/drivers/net/wan/cosa.c
@@ -806,21 +806,21 @@ static ssize_t cosa_read(struct file *file,
         spin_lock_irqsave(&cosa->lock, flags);
         add_wait_queue(&chan->rxwaitq, &wait);
         while (!chan->rx_status) {
-                current->state = TASK_INTERRUPTIBLE;
+                set_current_state(TASK_INTERRUPTIBLE);
                 spin_unlock_irqrestore(&cosa->lock, flags);
                 schedule();
                 spin_lock_irqsave(&cosa->lock, flags);
                 if (signal_pending(current) && chan->rx_status == 0) {
                         chan->rx_status = 1;
                         remove_wait_queue(&chan->rxwaitq, &wait);
-                        current->state = TASK_RUNNING;
+                        __set_current_state(TASK_RUNNING);
                         spin_unlock_irqrestore(&cosa->lock, flags);
                         mutex_unlock(&chan->rlock);
                         return -ERESTARTSYS;
                 }
         }
         remove_wait_queue(&chan->rxwaitq, &wait);
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         kbuf = chan->rxdata;
         count = chan->rxsize;
         spin_unlock_irqrestore(&cosa->lock, flags);
@@ -890,14 +890,14 @@ static ssize_t cosa_write(struct file *file,
         spin_lock_irqsave(&cosa->lock, flags);
         add_wait_queue(&chan->txwaitq, &wait);
         while (!chan->tx_status) {
-                current->state = TASK_INTERRUPTIBLE;
+                set_current_state(TASK_INTERRUPTIBLE);
                 spin_unlock_irqrestore(&cosa->lock, flags);
                 schedule();
                 spin_lock_irqsave(&cosa->lock, flags);
                 if (signal_pending(current) && chan->tx_status == 0) {
                         chan->tx_status = 1;
                         remove_wait_queue(&chan->txwaitq, &wait);
-                        current->state = TASK_RUNNING;
+                        __set_current_state(TASK_RUNNING);
                         chan->tx_status = 1;
                         spin_unlock_irqrestore(&cosa->lock, flags);
                         up(&chan->wsem);
@@ -905,7 +905,7 @@ static ssize_t cosa_write(struct file *file,
                 }
         }
         remove_wait_queue(&chan->txwaitq, &wait);
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         up(&chan->wsem);
         spin_unlock_irqrestore(&cosa->lock, flags);
         kfree(kbuf);
diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c
index c1947c5915eb..d56b7859a437 100644
--- a/drivers/net/wireless/mac80211_hwsim.c
+++ b/drivers/net/wireless/mac80211_hwsim.c
@@ -946,7 +946,8 @@ static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
                 goto nla_put_failure;
 
         genlmsg_end(skb, msg_head);
-        genlmsg_unicast(&init_net, skb, dst_portid);
+        if (genlmsg_unicast(&init_net, skb, dst_portid))
+                goto err_free_txskb;
 
         /* Enqueue the packet */
         skb_queue_tail(&data->pending, my_skb);
@@ -955,6 +956,8 @@ static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
         return;
 
 nla_put_failure:
+        nlmsg_free(skb);
+err_free_txskb:
         printk(KERN_DEBUG "mac80211_hwsim: error occurred in %s\n", __func__);
         ieee80211_free_txskb(hw, my_skb);
         data->tx_failed++;
diff --git a/drivers/net/wireless/rt2x00/Kconfig b/drivers/net/wireless/rt2x00/Kconfig
index 006b8bcb2e31..2b4ef256c6b9 100644
--- a/drivers/net/wireless/rt2x00/Kconfig
+++ b/drivers/net/wireless/rt2x00/Kconfig
@@ -243,14 +243,14 @@ config RT2X00_LIB
         select AVERAGE
 
 config RT2X00_LIB_FIRMWARE
-        boolean
+        bool
         select FW_LOADER
 
 config RT2X00_LIB_CRYPTO
-        boolean
+        bool
 
 config RT2X00_LIB_LEDS
-        boolean
+        bool
         default y if (RT2X00_LIB=y && LEDS_CLASS=y) || (RT2X00_LIB=m && LEDS_CLASS!=n)
 
 config RT2X00_LIB_DEBUGFS
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index f7a31d2cb3f1..c4d68d768408 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -655,9 +655,15 @@ static void xenvif_tx_err(struct xenvif_queue *queue,
         unsigned long flags;
 
         do {
+                int notify;
+
                 spin_lock_irqsave(&queue->response_lock, flags);
                 make_tx_response(queue, txp, XEN_NETIF_RSP_ERROR);
+                RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&queue->tx, notify);
                 spin_unlock_irqrestore(&queue->response_lock, flags);
+                if (notify)
+                        notify_remote_via_irq(queue->tx_irq);
+
                 if (cons == end)
                         break;
                 txp = RING_GET_REQUEST(&queue->tx, cons++);
@@ -1649,17 +1655,28 @@ static void xenvif_idx_release(struct xenvif_queue *queue, u16 pending_idx,
 {
         struct pending_tx_info *pending_tx_info;
         pending_ring_idx_t index;
+        int notify;
         unsigned long flags;
 
         pending_tx_info = &queue->pending_tx_info[pending_idx];
+
         spin_lock_irqsave(&queue->response_lock, flags);
+
         make_tx_response(queue, &pending_tx_info->req, status);
-        index = pending_index(queue->pending_prod);
+
+        /* Release the pending index before pusing the Tx response so
+         * its available before a new Tx request is pushed by the
+         * frontend.
+         */
+        index = pending_index(queue->pending_prod++);
         queue->pending_ring[index] = pending_idx;
-        /* TX shouldn't use the index before we give it back here */
-        mb();
-        queue->pending_prod++;
+
+        RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&queue->tx, notify);
+
         spin_unlock_irqrestore(&queue->response_lock, flags);
+
+        if (notify)
+                notify_remote_via_irq(queue->tx_irq);
 }
 
 
@@ -1669,7 +1686,6 @@ static void make_tx_response(struct xenvif_queue *queue,
 {
         RING_IDX i = queue->tx.rsp_prod_pvt;
         struct xen_netif_tx_response *resp;
-        int notify;
 
         resp = RING_GET_RESPONSE(&queue->tx, i);
         resp->id     = txp->id;
@@ -1679,9 +1695,6 @@ static void make_tx_response(struct xenvif_queue *queue,
                 RING_GET_RESPONSE(&queue->tx, ++i)->status = XEN_NETIF_RSP_NULL;
 
         queue->tx.rsp_prod_pvt = ++i;
-        RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&queue->tx, notify);
-        if (notify)
-                notify_remote_via_irq(queue->tx_irq);
 }
 
 static struct xen_netif_rx_response *make_rx_response(struct xenvif_queue *queue,
diff --git a/drivers/of/of_pci.c b/drivers/of/of_pci.c
index 110fece2ff53..62426d81a4d6 100644
--- a/drivers/of/of_pci.c
+++ b/drivers/of/of_pci.c
@@ -229,7 +229,6 @@ parse_failed:
         resource_list_for_each_entry(window, resources)
                 kfree(window->res);
         pci_free_resource_list(resources);
-        kfree(bus_range);
         return err;
 }
 EXPORT_SYMBOL_GPL(of_pci_get_host_bridge_resources);
diff --git a/drivers/pci/pcie/aer/Kconfig b/drivers/pci/pcie/aer/Kconfig
index 389440228c1d..7d1437b01fdd 100644
--- a/drivers/pci/pcie/aer/Kconfig
+++ b/drivers/pci/pcie/aer/Kconfig
@@ -3,7 +3,7 @@
 #
 
 config PCIEAER
-        boolean "Root Port Advanced Error Reporting support"
+        bool "Root Port Advanced Error Reporting support"
         depends on PCIEPORTBUS
         select RAS
         default y
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 638e797037da..97527614141b 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -735,6 +735,31 @@ config INTEL_IPS
           functionality.  If in doubt, say Y here; it will only load on
           supported platforms.
 
+config INTEL_IMR
+        bool "Intel Isolated Memory Region support"
+        default n
+        depends on X86_INTEL_QUARK && IOSF_MBI
+        ---help---
+          This option provides a means to manipulate Isolated Memory Regions.
+          IMRs are a set of registers that define read and write access masks
+          to prohibit certain system agents from accessing memory with 1 KiB
+          granularity.
+
+          IMRs make it possible to control read/write access to an address
+          by hardware agents inside the SoC. Read and write masks can be
+          defined for:
+                - eSRAM flush
+                - Dirty CPU snoop (write only)
+                - RMU access
+                - PCI Virtual Channel 0/Virtual Channel 1
+                - SMM mode
+                - Non SMM mode
+
+          Quark contains a set of eight IMR registers and makes use of those
+          registers during its bootup process.
+
+          If you are running on a Galileo/Quark say Y here.
+
 config IBM_RTL
         tristate "Device driver to enable PRTL support"
         depends on X86 && PCI
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index f71700e0d132..46b274693872 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -856,8 +856,8 @@ static void asus_backlight_exit(struct asus_laptop *asus)
  * than count bytes. We set eof to 1 if we handle those 2 values. We return the
  * number of bytes written in page
  */
-static ssize_t show_infos(struct device *dev,
-                          struct device_attribute *attr, char *page)
+static ssize_t infos_show(struct device *dev, struct device_attribute *attr,
+                          char *page)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
         int len = 0;
@@ -926,6 +926,7 @@ static ssize_t show_infos(struct device *dev,
 
         return len;
 }
+static DEVICE_ATTR_RO(infos);
 
 static int parse_arg(const char *buf, unsigned long count, int *val)
 {
@@ -957,15 +958,15 @@ static ssize_t sysfs_acpi_set(struct asus_laptop *asus,
 /*
  * LEDD display
  */
-static ssize_t show_ledd(struct device *dev,
-                         struct device_attribute *attr, char *buf)
+static ssize_t ledd_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sprintf(buf, "0x%08x\n", asus->ledd_status);
 }
 
-static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
+static ssize_t ledd_store(struct device *dev, struct device_attribute *attr,
                           const char *buf, size_t count)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
@@ -981,6 +982,7 @@ static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
         }
         return rv;
 }
+static DEVICE_ATTR_RW(ledd);
 
 /*
  * Wireless
@@ -1014,21 +1016,22 @@ static int asus_wlan_set(struct asus_laptop *asus, int status)
         return 0;
 }
 
-static ssize_t show_wlan(struct device *dev,
-                         struct device_attribute *attr, char *buf)
+static ssize_t wlan_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sprintf(buf, "%d\n", asus_wireless_status(asus, WL_RSTS));
 }
 
-static ssize_t store_wlan(struct device *dev, struct device_attribute *attr,
+static ssize_t wlan_store(struct device *dev, struct device_attribute *attr,
                           const char *buf, size_t count)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sysfs_acpi_set(asus, buf, count, METHOD_WLAN);
 }
+static DEVICE_ATTR_RW(wlan);
 
 /*e
  * Bluetooth
@@ -1042,15 +1045,15 @@ static int asus_bluetooth_set(struct asus_laptop *asus, int status)
         return 0;
 }
 
-static ssize_t show_bluetooth(struct device *dev,
-                              struct device_attribute *attr, char *buf)
+static ssize_t bluetooth_show(struct device *dev, struct device_attribute *attr,
+                              char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sprintf(buf, "%d\n", asus_wireless_status(asus, BT_RSTS));
 }
 
-static ssize_t store_bluetooth(struct device *dev,
+static ssize_t bluetooth_store(struct device *dev,
                                struct device_attribute *attr, const char *buf,
                                size_t count)
 {
@@ -1058,6 +1061,7 @@ static ssize_t store_bluetooth(struct device *dev,
 
         return sysfs_acpi_set(asus, buf, count, METHOD_BLUETOOTH);
 }
+static DEVICE_ATTR_RW(bluetooth);
 
 /*
  * Wimax
@@ -1071,22 +1075,22 @@ static int asus_wimax_set(struct asus_laptop *asus, int status)
         return 0;
 }
 
-static ssize_t show_wimax(struct device *dev,
-                              struct device_attribute *attr, char *buf)
+static ssize_t wimax_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sprintf(buf, "%d\n", asus_wireless_status(asus, WM_RSTS));
 }
 
-static ssize_t store_wimax(struct device *dev,
-                               struct device_attribute *attr, const char *buf,
-                               size_t count)
+static ssize_t wimax_store(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sysfs_acpi_set(asus, buf, count, METHOD_WIMAX);
 }
+static DEVICE_ATTR_RW(wimax);
 
 /*
  * Wwan
@@ -1100,22 +1104,22 @@ static int asus_wwan_set(struct asus_laptop *asus, int status)
         return 0;
 }
 
-static ssize_t show_wwan(struct device *dev,
-                              struct device_attribute *attr, char *buf)
+static ssize_t wwan_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sprintf(buf, "%d\n", asus_wireless_status(asus, WW_RSTS));
 }
 
-static ssize_t store_wwan(struct device *dev,
-                               struct device_attribute *attr, const char *buf,
-                               size_t count)
+static ssize_t wwan_store(struct device *dev, struct device_attribute *attr,
+                          const char *buf, size_t count)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sysfs_acpi_set(asus, buf, count, METHOD_WWAN);
 }
+static DEVICE_ATTR_RW(wwan);
 
 /*
  * Display
@@ -1135,8 +1139,8 @@ static void asus_set_display(struct asus_laptop *asus, int value)
  * displays hooked up simultaneously, so be warned. See the acpi4asus README
  * for more info.
  */
-static ssize_t store_disp(struct device *dev, struct device_attribute *attr,
-                          const char *buf, size_t count)
+static ssize_t display_store(struct device *dev, struct device_attribute *attr,
+                             const char *buf, size_t count)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
         int rv, value;
@@ -1146,6 +1150,7 @@ static ssize_t store_disp(struct device *dev, struct device_attribute *attr,
                 asus_set_display(asus, value);
         return rv;
 }
+static DEVICE_ATTR_WO(display);
 
 /*
  * Light Sens
@@ -1167,16 +1172,17 @@ static void asus_als_switch(struct asus_laptop *asus, int value)
         asus->light_switch = value;
 }
 
-static ssize_t show_lssw(struct device *dev,
-                         struct device_attribute *attr, char *buf)
+static ssize_t ls_switch_show(struct device *dev, struct device_attribute *attr,
+                              char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sprintf(buf, "%d\n", asus->light_switch);
 }
 
-static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
-                          const char *buf, size_t count)
+static ssize_t ls_switch_store(struct device *dev,
+                               struct device_attribute *attr, const char *buf,
+                               size_t count)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
         int rv, value;
@@ -1187,6 +1193,7 @@ static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
 
         return rv;
 }
+static DEVICE_ATTR_RW(ls_switch);
 
 static void asus_als_level(struct asus_laptop *asus, int value)
 {
@@ -1195,16 +1202,16 @@ static void asus_als_level(struct asus_laptop *asus, int value)
         asus->light_level = value;
 }
 
-static ssize_t show_lslvl(struct device *dev,
-                          struct device_attribute *attr, char *buf)
+static ssize_t ls_level_show(struct device *dev, struct device_attribute *attr,
+                             char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sprintf(buf, "%d\n", asus->light_level);
 }
 
-static ssize_t store_lslvl(struct device *dev, struct device_attribute *attr,
-                           const char *buf, size_t count)
+static ssize_t ls_level_store(struct device *dev, struct device_attribute *attr,
+                              const char *buf, size_t count)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
         int rv, value;
@@ -1218,6 +1225,7 @@ static ssize_t store_lslvl(struct device *dev, struct device_attribute *attr,
 
         return rv;
 }
+static DEVICE_ATTR_RW(ls_level);
 
 static int pega_int_read(struct asus_laptop *asus, int arg, int *result)
 {
@@ -1234,8 +1242,8 @@ static int pega_int_read(struct asus_laptop *asus, int arg, int *result)
         return err;
 }
 
-static ssize_t show_lsvalue(struct device *dev,
-                            struct device_attribute *attr, char *buf)
+static ssize_t ls_value_show(struct device *dev, struct device_attribute *attr,
+                             char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
         int err, hi, lo;
@@ -1247,6 +1255,7 @@ static ssize_t show_lsvalue(struct device *dev,
                 return sprintf(buf, "%d\n", 10 * hi + lo);
         return err;
 }
+static DEVICE_ATTR_RO(ls_value);
 
 /*
  * GPS
@@ -1274,15 +1283,15 @@ static int asus_gps_switch(struct asus_laptop *asus, int status)
         return 0;
 }
 
-static ssize_t show_gps(struct device *dev,
-                        struct device_attribute *attr, char *buf)
+static ssize_t gps_show(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
 
         return sprintf(buf, "%d\n", asus_gps_status(asus));
 }
 
-static ssize_t store_gps(struct device *dev, struct device_attribute *attr,
+static ssize_t gps_store(struct device *dev, struct device_attribute *attr,
                          const char *buf, size_t count)
 {
         struct asus_laptop *asus = dev_get_drvdata(dev);
@@ -1298,6 +1307,7 @@ static ssize_t store_gps(struct device *dev, struct device_attribute *attr,
         rfkill_set_sw_state(asus->gps.rfkill, !value);
         return rv;
 }
+static DEVICE_ATTR_RW(gps);
 
 /*
  * rfkill
@@ -1569,19 +1579,6 @@ static void asus_acpi_notify(struct acpi_device *device, u32 event)
         asus_input_notify(asus, event);
 }
 
-static DEVICE_ATTR(infos, S_IRUGO, show_infos, NULL);
-static DEVICE_ATTR(wlan, S_IRUGO | S_IWUSR, show_wlan, store_wlan);
-static DEVICE_ATTR(bluetooth, S_IRUGO | S_IWUSR,
-                   show_bluetooth, store_bluetooth);
-static DEVICE_ATTR(wimax, S_IRUGO | S_IWUSR, show_wimax, store_wimax);
-static DEVICE_ATTR(wwan, S_IRUGO | S_IWUSR, show_wwan, store_wwan);
-static DEVICE_ATTR(display, S_IWUSR, NULL, store_disp);
-static DEVICE_ATTR(ledd, S_IRUGO | S_IWUSR, show_ledd, store_ledd);
-static DEVICE_ATTR(ls_value, S_IRUGO, show_lsvalue, NULL);
-static DEVICE_ATTR(ls_level, S_IRUGO | S_IWUSR, show_lslvl, store_lslvl);
-static DEVICE_ATTR(ls_switch, S_IRUGO | S_IWUSR, show_lssw, store_lssw);
-static DEVICE_ATTR(gps, S_IRUGO | S_IWUSR, show_gps, store_gps);
-
 static struct attribute *asus_attributes[] = {
         &dev_attr_infos.attr,
         &dev_attr_wlan.attr,
@@ -1616,7 +1613,7 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj,
                 else
                         goto normal;
 
-                return supported;
+                return supported ? attr->mode : 0;
         }
 
 normal:
diff --git a/drivers/platform/x86/classmate-laptop.c b/drivers/platform/x86/classmate-laptop.c
index 70d355a9ae2c..55cf10bc7817 100644
--- a/drivers/platform/x86/classmate-laptop.c
+++ b/drivers/platform/x86/classmate-laptop.c
@@ -520,7 +520,7 @@ static acpi_status cmpc_get_accel(acpi_handle handle,
 {
         union acpi_object param[2];
         struct acpi_object_list input;
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, 0 };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
         unsigned char *locs;
         acpi_status status;
 
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index 7c21c1c44dfa..2a9afa261c61 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -64,6 +64,7 @@
 #include <linux/acpi.h>
 #include <linux/dmi.h>
 #include <linux/backlight.h>
+#include <linux/fb.h>
 #include <linux/input.h>
 #include <linux/kfifo.h>
 #include <linux/platform_device.h>
@@ -398,7 +399,7 @@ static int bl_get_brightness(struct backlight_device *b)
 static int bl_update_status(struct backlight_device *b)
 {
         int ret;
-        if (b->props.power == 4)
+        if (b->props.power == FB_BLANK_POWERDOWN)
                 ret = call_fext_func(FUNC_BACKLIGHT, 0x1, 0x4, 0x3);
         else
                 ret = call_fext_func(FUNC_BACKLIGHT, 0x1, 0x4, 0x0);
@@ -1139,9 +1140,9 @@ static int __init fujitsu_init(void)
 
         if (!acpi_video_backlight_support()) {
                 if (call_fext_func(FUNC_BACKLIGHT, 0x2, 0x4, 0x0) == 3)
-                        fujitsu->bl_device->props.power = 4;
+                        fujitsu->bl_device->props.power = FB_BLANK_POWERDOWN;
                 else
-                        fujitsu->bl_device->props.power = 0;
+                        fujitsu->bl_device->props.power = FB_BLANK_UNBLANK;
         }
 
         pr_info("driver " FUJITSU_DRIVER_VERSION " successfully loaded\n");
diff --git a/drivers/platform/x86/intel_scu_ipc.c b/drivers/platform/x86/intel_scu_ipc.c
index 66a4d3284aab..001b199a8c33 100644
--- a/drivers/platform/x86/intel_scu_ipc.c
+++ b/drivers/platform/x86/intel_scu_ipc.c
@@ -1,7 +1,7 @@
 /*
  * intel_scu_ipc.c: Driver for the Intel SCU IPC mechanism
  *
- * (C) Copyright 2008-2010 Intel Corporation
+ * (C) Copyright 2008-2010,2015 Intel Corporation
  * Author: Sreedhara DS (sreedhara.ds@intel.com)
  *
  * This program is free software; you can redistribute it and/or
@@ -43,10 +43,9 @@
 /*
  * IPC register summary
  *
- * IPC register blocks are memory mapped at fixed address of 0xFF11C000
+ * IPC register blocks are memory mapped at fixed address of PCI BAR 0.
  * To read or write information to the SCU, driver writes to IPC-1 memory
- * mapped registers (base address 0xFF11C000). The following is the IPC
- * mechanism
+ * mapped registers. The following is the IPC mechanism
  *
  * 1. IA core cDMI interface claims this transaction and converts it to a
  *    Transaction Layer Packet (TLP) message which is sent across the cDMI.
@@ -67,36 +66,28 @@
 #define PCI_DEVICE_ID_CLOVERVIEW        0x08ea
 #define PCI_DEVICE_ID_TANGIER           0x11a0
 
-/* intel scu ipc driver data*/
+/* intel scu ipc driver data */
 struct intel_scu_ipc_pdata_t {
-        u32 ipc_base;
         u32 i2c_base;
-        u32 ipc_len;
         u32 i2c_len;
         u8 irq_mode;
 };
 
 static struct intel_scu_ipc_pdata_t intel_scu_ipc_lincroft_pdata = {
-        .ipc_base = 0xff11c000,
         .i2c_base = 0xff12b000,
-        .ipc_len = 0x100,
         .i2c_len = 0x10,
         .irq_mode = 0,
 };
 
 /* Penwell and Cloverview */
 static struct intel_scu_ipc_pdata_t intel_scu_ipc_penwell_pdata = {
-        .ipc_base = 0xff11c000,
         .i2c_base = 0xff12b000,
-        .ipc_len = 0x100,
         .i2c_len = 0x10,
         .irq_mode = 1,
 };
 
 static struct intel_scu_ipc_pdata_t intel_scu_ipc_tangier_pdata = {
-        .ipc_base = 0xff009000,
         .i2c_base  = 0xff00d000,
-        .ipc_len  = 0x100,
         .i2c_len = 0x10,
         .irq_mode = 0,
 };
@@ -114,8 +105,6 @@ struct intel_scu_ipc_dev {
 
 static struct intel_scu_ipc_dev  ipcdev; /* Only one for now */
 
-static int platform;            /* Platform type */
-
 /*
  * IPC Read Buffer (Read Only):
  * 16 byte buffer for receiving data from SCU, if IPC command
@@ -160,7 +149,6 @@ static inline void ipc_data_writel(u32 data, u32 offset) /* Write ipc data */
  * Format:
  * |rfu3(8)|error code(8)|initiator id(8)|cmd id(4)|rfu1(2)|error(1)|busy(1)|
  */
-
 static inline u8 ipc_read_status(void)
 {
         return __raw_readl(ipcdev.ipc_base + 0x04);
@@ -176,23 +164,24 @@ static inline u32 ipc_data_readl(u32 offset) /* Read ipc u32 data */
         return readl(ipcdev.ipc_base + IPC_READ_BUFFER + offset);
 }
 
-static inline int busy_loop(void) /* Wait till scu status is busy */
+/* Wait till scu status is busy */
+static inline int busy_loop(void)
 {
-        u32 status = 0;
-        u32 loop_count = 0;
+        u32 status = ipc_read_status();
+        u32 loop_count = 100000;
 
-        status = ipc_read_status();
-        while (status & 1) {
+        /* break if scu doesn't reset busy bit after huge retry */
+        while ((status & BIT(0)) && --loop_count) {
                 udelay(1); /* scu processing time is in few u secods */
                 status = ipc_read_status();
-                loop_count++;
-                /* break if scu doesn't reset busy bit after huge retry */
-                if (loop_count > 100000) {
-                        dev_err(&ipcdev.pdev->dev, "IPC timed out");
-                        return -ETIMEDOUT;
-                }
         }
-        if ((status >> 1) & 1)
+
+        if (status & BIT(0)) {
+                dev_err(&ipcdev.pdev->dev, "IPC timed out");
+                return -ETIMEDOUT;
+        }
+
+        if (status & BIT(1))
                 return -EIO;
 
         return 0;
@@ -210,14 +199,13 @@ static inline int ipc_wait_for_interrupt(void)
         }
 
         status = ipc_read_status();
-
-        if ((status >> 1) & 1)
+        if (status & BIT(1))
                 return -EIO;
 
         return 0;
 }
 
-int intel_scu_ipc_check_status(void)
+static int intel_scu_ipc_check_status(void)
 {
         return ipcdev.irq_mode ? ipc_wait_for_interrupt() : busy_loop();
 }
@@ -248,18 +236,18 @@ static int pwr_reg_rdwr(u16 *addr, u8 *data, u32 count, u32 op, u32 id)
         if (id == IPC_CMD_PCNTRL_R) {
                 for (nc = 0, offset = 0; nc < count; nc++, offset += 4)
                         ipc_data_writel(wbuf[nc], offset);
-                ipc_command((count*2) << 16 |  id << 12 | 0 << 8 | op);
+                ipc_command((count * 2) << 16 | id << 12 | 0 << 8 | op);
         } else if (id == IPC_CMD_PCNTRL_W) {
                 for (nc = 0; nc < count; nc++, offset += 1)
                         cbuf[offset] = data[nc];
                 for (nc = 0, offset = 0; nc < count; nc++, offset += 4)
                         ipc_data_writel(wbuf[nc], offset);
-                ipc_command((count*3) << 16 |  id << 12 | 0 << 8 | op);
+                ipc_command((count * 3) << 16 | id << 12 | 0 << 8 | op);
         } else if (id == IPC_CMD_PCNTRL_M) {
                 cbuf[offset] = data[0];
                 cbuf[offset + 1] = data[1];
                 ipc_data_writel(wbuf[0], 0); /* Write wbuff */
-                ipc_command(4 << 16 |  id << 12 | 0 << 8 | op);
+                ipc_command(4 << 16 | id << 12 | 0 << 8 | op);
         }
 
         err = intel_scu_ipc_check_status();
@@ -301,7 +289,7 @@ EXPORT_SYMBOL(intel_scu_ipc_ioread8);
  */
 int intel_scu_ipc_ioread16(u16 addr, u16 *data)
 {
-        u16 x[2] = {addr, addr + 1 };
+        u16 x[2] = {addr, addr + 1};
         return pwr_reg_rdwr(x, (u8 *)data, 2, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_R);
 }
 EXPORT_SYMBOL(intel_scu_ipc_ioread16);
@@ -351,7 +339,7 @@ EXPORT_SYMBOL(intel_scu_ipc_iowrite8);
  */
 int intel_scu_ipc_iowrite16(u16 addr, u16 data)
 {
-        u16 x[2] = {addr, addr + 1 };
+        u16 x[2] = {addr, addr + 1};
         return pwr_reg_rdwr(x, (u8 *)&data, 2, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_W);
 }
 EXPORT_SYMBOL(intel_scu_ipc_iowrite16);
@@ -412,7 +400,6 @@ int intel_scu_ipc_writev(u16 *addr, u8 *data, int len)
 }
 EXPORT_SYMBOL(intel_scu_ipc_writev);
 
-
 /**
  *      intel_scu_ipc_update_register   -       r/m/w a register
  *      @addr: register address
@@ -475,9 +462,8 @@ EXPORT_SYMBOL(intel_scu_ipc_simple_command);
  *      Issue a command to the SCU which involves data transfers. Do the
  *      data copies under the lock but leave it for the caller to interpret
  */
-
 int intel_scu_ipc_command(int cmd, int sub, u32 *in, int inlen,
-                                                        u32 *out, int outlen)
+                          u32 *out, int outlen)
 {
         int i, err;
 
@@ -503,7 +489,7 @@ int intel_scu_ipc_command(int cmd, int sub, u32 *in, int inlen,
 }
 EXPORT_SYMBOL(intel_scu_ipc_command);
 
-/*I2C commands */
+/* I2C commands */
 #define IPC_I2C_WRITE 1 /* I2C Write command */
 #define IPC_I2C_READ  2 /* I2C Read command */
 
@@ -577,7 +563,7 @@ static int ipc_probe(struct pci_dev *dev, const struct pci_device_id *id)
 {
         int err;
         struct intel_scu_ipc_pdata_t *pdata;
-        resource_size_t pci_resource;
+        resource_size_t base;
 
         if (ipcdev.pdev)                /* We support only one SCU */
                 return -EBUSY;
@@ -595,8 +581,8 @@ static int ipc_probe(struct pci_dev *dev, const struct pci_device_id *id)
         if (err)
                 return err;
 
-        pci_resource = pci_resource_start(dev, 0);
-        if (!pci_resource)
+        base = pci_resource_start(dev, 0);
+        if (!base)
                 return -ENOMEM;
 
         init_completion(&ipcdev.cmd_complete);
@@ -604,7 +590,7 @@ static int ipc_probe(struct pci_dev *dev, const struct pci_device_id *id)
         if (request_irq(dev->irq, ioc, 0, "intel_scu_ipc", &ipcdev))
                 return -EBUSY;
 
-        ipcdev.ipc_base = ioremap_nocache(pdata->ipc_base, pdata->ipc_len);
+        ipcdev.ipc_base = ioremap_nocache(base, pci_resource_len(dev, 0));
         if (!ipcdev.ipc_base)
                 return -ENOMEM;
 
@@ -666,9 +652,10 @@ static struct pci_driver ipc_driver = {
         .remove = ipc_remove,
 };
 
-
 static int __init intel_scu_ipc_init(void)
 {
+        int platform;           /* Platform type */
+
         platform = intel_mid_identify_cpu();
         if (platform == 0)
                 return -ENODEV;
diff --git a/drivers/platform/x86/samsung-laptop.c b/drivers/platform/x86/samsung-laptop.c
index ff765d8e1a09..9e701b2256f9 100644
--- a/drivers/platform/x86/samsung-laptop.c
+++ b/drivers/platform/x86/samsung-laptop.c
@@ -124,6 +124,10 @@ struct sabi_commands {
         u16 get_wireless_status;
         u16 set_wireless_status;
 
+        /* 0x80 is off, 0x81 is on */
+        u16 get_lid_handling;
+        u16 set_lid_handling;
+
         /* 0x81 to read, (0x82 | level << 8) to set, 0xaabb to enable */
         u16 kbd_backlight;
 
@@ -194,6 +198,9 @@ static const struct sabi_config sabi_configs[] = {
                         .get_wireless_status = 0xFFFF,
                         .set_wireless_status = 0xFFFF,
 
+                        .get_lid_handling = 0xFFFF,
+                        .set_lid_handling = 0xFFFF,
+
                         .kbd_backlight = 0xFFFF,
 
                         .set_linux = 0x0a,
@@ -254,6 +261,9 @@ static const struct sabi_config sabi_configs[] = {
                         .get_wireless_status = 0x69,
                         .set_wireless_status = 0x6a,
 
+                        .get_lid_handling = 0x6d,
+                        .set_lid_handling = 0x6e,
+
                         .kbd_backlight = 0x78,
 
                         .set_linux = 0xff,
@@ -353,6 +363,8 @@ struct samsung_quirks {
         bool broken_acpi_video;
         bool four_kbd_backlight_levels;
         bool enable_kbd_backlight;
+        bool use_native_backlight;
+        bool lid_handling;
 };
 
 static struct samsung_quirks samsung_unknown = {};
@@ -361,11 +373,19 @@ static struct samsung_quirks samsung_broken_acpi_video = {
         .broken_acpi_video = true,
 };
 
+static struct samsung_quirks samsung_use_native_backlight = {
+        .use_native_backlight = true,
+};
+
 static struct samsung_quirks samsung_np740u3e = {
         .four_kbd_backlight_levels = true,
         .enable_kbd_backlight = true,
 };
 
+static struct samsung_quirks samsung_lid_handling = {
+        .lid_handling = true,
+};
+
 static bool force;
 module_param(force, bool, 0);
 MODULE_PARM_DESC(force,
@@ -748,7 +768,7 @@ static ssize_t set_battery_life_extender(struct device *dev,
         struct samsung_laptop *samsung = dev_get_drvdata(dev);
         int ret, value;
 
-        if (!count || sscanf(buf, "%i", &value) != 1)
+        if (!count || kstrtoint(buf, 0, &value) != 0)
                 return -EINVAL;
 
         ret = write_battery_life_extender(samsung, !!value);
@@ -817,7 +837,7 @@ static ssize_t set_usb_charge(struct device *dev,
         struct samsung_laptop *samsung = dev_get_drvdata(dev);
         int ret, value;
 
-        if (!count || sscanf(buf, "%i", &value) != 1)
+        if (!count || kstrtoint(buf, 0, &value) != 0)
                 return -EINVAL;
 
         ret = write_usb_charge(samsung, !!value);
@@ -830,10 +850,76 @@ static ssize_t set_usb_charge(struct device *dev,
 static DEVICE_ATTR(usb_charge, S_IWUSR | S_IRUGO,
                    get_usb_charge, set_usb_charge);
 
+static int read_lid_handling(struct samsung_laptop *samsung)
+{
+        const struct sabi_commands *commands = &samsung->config->commands;
+        struct sabi_data data;
+        int retval;
+
+        if (commands->get_lid_handling == 0xFFFF)
+                return -ENODEV;
+
+        memset(&data, 0, sizeof(data));
+        retval = sabi_command(samsung, commands->get_lid_handling,
+                              &data, &data);
+
+        if (retval)
+                return retval;
+
+        return data.data[0] & 0x1;
+}
+
+static int write_lid_handling(struct samsung_laptop *samsung,
+                              int enabled)
+{
+        const struct sabi_commands *commands = &samsung->config->commands;
+        struct sabi_data data;
+
+        memset(&data, 0, sizeof(data));
+        data.data[0] = 0x80 | enabled;
+        return sabi_command(samsung, commands->set_lid_handling,
+                            &data, NULL);
+}
+
+static ssize_t get_lid_handling(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        struct samsung_laptop *samsung = dev_get_drvdata(dev);
+        int ret;
+
+        ret = read_lid_handling(samsung);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", ret);
+}
+
+static ssize_t set_lid_handling(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        struct samsung_laptop *samsung = dev_get_drvdata(dev);
+        int ret, value;
+
+        if (!count || kstrtoint(buf, 0, &value) != 0)
+                return -EINVAL;
+
+        ret = write_lid_handling(samsung, !!value);
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+
+static DEVICE_ATTR(lid_handling, S_IWUSR | S_IRUGO,
+                   get_lid_handling, set_lid_handling);
+
 static struct attribute *platform_attributes[] = {
         &dev_attr_performance_level.attr,
         &dev_attr_battery_life_extender.attr,
         &dev_attr_usb_charge.attr,
+        &dev_attr_lid_handling.attr,
         NULL
 };
 
@@ -956,6 +1042,22 @@ static int __init samsung_rfkill_init(struct samsung_laptop *samsung)
         return 0;
 }
 
+static void samsung_lid_handling_exit(struct samsung_laptop *samsung)
+{
+        if (samsung->quirks->lid_handling)
+                write_lid_handling(samsung, 0);
+}
+
+static int __init samsung_lid_handling_init(struct samsung_laptop *samsung)
+{
+        int retval = 0;
+
+        if (samsung->quirks->lid_handling)
+                retval = write_lid_handling(samsung, 1);
+
+        return retval;
+}
+
 static int kbd_backlight_enable(struct samsung_laptop *samsung)
 {
         const struct sabi_commands *commands = &samsung->config->commands;
@@ -1111,7 +1213,7 @@ static int __init samsung_backlight_init(struct samsung_laptop *samsung)
 }
 
 static umode_t samsung_sysfs_is_visible(struct kobject *kobj,
-                                       struct attribute *attr, int idx)
+                                        struct attribute *attr, int idx)
 {
         struct device *dev = container_of(kobj, struct device, kobj);
         struct platform_device *pdev = to_platform_device(dev);
@@ -1124,6 +1226,8 @@ static umode_t samsung_sysfs_is_visible(struct kobject *kobj,
                 ok = !!(read_battery_life_extender(samsung) >= 0);
         if (attr == &dev_attr_usb_charge.attr)
                 ok = !!(read_usb_charge(samsung) >= 0);
+        if (attr == &dev_attr_lid_handling.attr)
+                ok = !!(read_lid_handling(samsung) >= 0);
 
         return ok ? attr->mode : 0;
 }
@@ -1357,7 +1461,7 @@ static int __init samsung_sabi_init(struct samsung_laptop *samsung)
         samsung_sabi_diag(samsung);
 
         /* Try to find one of the signatures in memory to find the header */
-        for (i = 0; sabi_configs[i].test_string != 0; ++i) {
+        for (i = 0; sabi_configs[i].test_string != NULL; ++i) {
                 samsung->config = &sabi_configs[i];
                 loca = find_signature(samsung->f0000_segment,
                                       samsung->config->test_string);
@@ -1436,6 +1540,9 @@ static int samsung_pm_notification(struct notifier_block *nb,
             samsung->quirks->enable_kbd_backlight)
                 kbd_backlight_enable(samsung);
 
+        if (val == PM_POST_HIBERNATION && samsung->quirks->lid_handling)
+                write_lid_handling(samsung, 1);
+
         return 0;
 }
 
@@ -1507,7 +1614,7 @@ static struct dmi_system_id __initdata samsung_dmi_table[] = {
                 DMI_MATCH(DMI_PRODUCT_NAME, "N150P"),
                 DMI_MATCH(DMI_BOARD_NAME, "N150P"),
                 },
-         .driver_data = &samsung_broken_acpi_video,
+         .driver_data = &samsung_use_native_backlight,
         },
         {
          .callback = samsung_dmi_matched,
@@ -1517,7 +1624,7 @@ static struct dmi_system_id __initdata samsung_dmi_table[] = {
                 DMI_MATCH(DMI_PRODUCT_NAME, "N145P/N250P/N260P"),
                 DMI_MATCH(DMI_BOARD_NAME, "N145P/N250P/N260P"),
                 },
-         .driver_data = &samsung_broken_acpi_video,
+         .driver_data = &samsung_use_native_backlight,
         },
         {
          .callback = samsung_dmi_matched,
@@ -1557,7 +1664,7 @@ static struct dmi_system_id __initdata samsung_dmi_table[] = {
                 DMI_MATCH(DMI_PRODUCT_NAME, "N250P"),
                 DMI_MATCH(DMI_BOARD_NAME, "N250P"),
                 },
-         .driver_data = &samsung_broken_acpi_video,
+         .driver_data = &samsung_use_native_backlight,
         },
         {
          .callback = samsung_dmi_matched,
@@ -1578,6 +1685,15 @@ static struct dmi_system_id __initdata samsung_dmi_table[] = {
                 },
          .driver_data = &samsung_np740u3e,
         },
+        {
+         .callback = samsung_dmi_matched,
+         .ident = "300V3Z/300V4Z/300V5Z",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                DMI_MATCH(DMI_PRODUCT_NAME, "300V3Z/300V4Z/300V5Z"),
+                },
+         .driver_data = &samsung_lid_handling,
+        },
         { },
 };
 MODULE_DEVICE_TABLE(dmi, samsung_dmi_table);
@@ -1616,6 +1732,15 @@ static int __init samsung_init(void)
                 pr_info("Disabling ACPI video driver\n");
                 acpi_video_unregister();
         }
+
+        if (samsung->quirks->use_native_backlight) {
+                pr_info("Using native backlight driver\n");
+                /* Tell acpi-video to not handle the backlight */
+                acpi_video_dmi_promote_vendor();
+                acpi_video_unregister();
+                /* And also do not handle it ourselves */
+                samsung->handle_backlight = false;
+        }
 #endif
 
         ret = samsung_platform_init(samsung);
@@ -1648,6 +1773,10 @@ static int __init samsung_init(void)
         if (ret)
                 goto error_leds;
 
+        ret = samsung_lid_handling_init(samsung);
+        if (ret)
+                goto error_lid_handling;
+
         ret = samsung_debugfs_init(samsung);
         if (ret)
                 goto error_debugfs;
@@ -1659,6 +1788,8 @@ static int __init samsung_init(void)
         return ret;
 
 error_debugfs:
+        samsung_lid_handling_exit(samsung);
+error_lid_handling:
         samsung_leds_exit(samsung);
 error_leds:
         samsung_rfkill_exit(samsung);
@@ -1683,6 +1814,7 @@ static void __exit samsung_exit(void)
         unregister_pm_notifier(&samsung->pm_nb);
 
         samsung_debugfs_exit(samsung);
+        samsung_lid_handling_exit(samsung);
         samsung_leds_exit(samsung);
         samsung_rfkill_exit(samsung);
         samsung_backlight_exit(samsung);
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 6dd1c0e7dcd9..e51c1e753607 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -1032,7 +1032,7 @@ struct sony_backlight_props {
         u8                      offset;
         u8                      maxlvl;
 };
-struct sony_backlight_props sony_bl_props;
+static struct sony_backlight_props sony_bl_props;
 
 static int sony_backlight_update_status(struct backlight_device *bd)
 {
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index c3d11fabc46f..3b8ceee7c5cb 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -196,6 +196,7 @@ enum tpacpi_hkey_event_t {
         /* Key-related user-interface events */
         TP_HKEY_EV_KEY_NUMLOCK          = 0x6000, /* NumLock key pressed */
         TP_HKEY_EV_KEY_FN               = 0x6005, /* Fn key pressed? E420 */
+        TP_HKEY_EV_KEY_FN_ESC           = 0x6060, /* Fn+Esc key pressed X240 */
 
         /* Thermal events */
         TP_HKEY_EV_ALARM_BAT_HOT        = 0x6011, /* battery too hot */
@@ -3456,7 +3457,7 @@ enum ADAPTIVE_KEY_MODE {
         LAYFLAT_MODE
 };
 
-const int adaptive_keyboard_modes[] = {
+static const int adaptive_keyboard_modes[] = {
         HOME_MODE,
 /*      WEB_BROWSER_MODE = 2,
         WEB_CONFERENCE_MODE = 3, */
@@ -3712,6 +3713,7 @@ static bool hotkey_notify_6xxx(const u32 hkey,
 
         case TP_HKEY_EV_KEY_NUMLOCK:
         case TP_HKEY_EV_KEY_FN:
+        case TP_HKEY_EV_KEY_FN_ESC:
                 /* key press events, we just ignore them as long as the EC
                  * is still reporting them in the normal keyboard stream */
                 *send_acpi_ev = false;
@@ -8883,17 +8885,31 @@ static bool __pure __init tpacpi_is_fw_digit(const char c)
         return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z');
 }
 
-/* Most models: xxyTkkWW (#.##c); Ancient 570/600 and -SL lacks (#.##c) */
 static bool __pure __init tpacpi_is_valid_fw_id(const char * const s,
                                                 const char t)
 {
-        return s && strlen(s) >= 8 &&
+        /*
+         * Most models: xxyTkkWW (#.##c)
+         * Ancient 570/600 and -SL lacks (#.##c)
+         */
+        if (s && strlen(s) >= 8 &&
                 tpacpi_is_fw_digit(s[0]) &&
                 tpacpi_is_fw_digit(s[1]) &&
                 s[2] == t &&
                 (s[3] == 'T' || s[3] == 'N') &&
                 tpacpi_is_fw_digit(s[4]) &&
-                tpacpi_is_fw_digit(s[5]);
+                tpacpi_is_fw_digit(s[5]))
+                return true;
+
+        /* New models: xxxyTkkW (#.##c); T550 and some others */
+        return s && strlen(s) >= 8 &&
+                tpacpi_is_fw_digit(s[0]) &&
+                tpacpi_is_fw_digit(s[1]) &&
+                tpacpi_is_fw_digit(s[2]) &&
+                s[3] == t &&
+                (s[4] == 'T' || s[4] == 'N') &&
+                tpacpi_is_fw_digit(s[5]) &&
+                tpacpi_is_fw_digit(s[6]);
 }
 
 /* returns 0 - probe ok, or < 0 - probe error.
diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index fc34a71866ed..dbcb7a8915b8 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -1,11 +1,10 @@
 /*
  *  toshiba_acpi.c - Toshiba Laptop ACPI Extras
  *
- *
  *  Copyright (C) 2002-2004 John Belmonte
  *  Copyright (C) 2008 Philip Langdale
  *  Copyright (C) 2010 Pierre Ducroquet
- *  Copyright (C) 2014 Azael Avalos
+ *  Copyright (C) 2014-2015 Azael Avalos
  *
  *  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
@@ -17,10 +16,8 @@
  *  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
- *
+ *  The full GNU General Public License is included in this distribution in
+ *  the file called "COPYING".
  *
  *  The devolpment page for this driver is located at
  *  http://memebeam.org/toys/ToshibaAcpiDriver.
@@ -30,15 +27,11 @@
  *              engineering the Windows drivers
  *      Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
  *      Rob Miller - TV out and hotkeys help
- *
- *
- *  TODO
- *
  */
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#define TOSHIBA_ACPI_VERSION    "0.20"
+#define TOSHIBA_ACPI_VERSION    "0.21"
 #define PROC_INTERFACE_VERSION  1
 
 #include <linux/kernel.h>
@@ -57,7 +50,7 @@
 #include <linux/i8042.h>
 #include <linux/acpi.h>
 #include <linux/dmi.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 MODULE_AUTHOR("John Belmonte");
 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
@@ -71,7 +64,8 @@ MODULE_LICENSE("GPL");
 /* Toshiba ACPI method paths */
 #define METHOD_VIDEO_OUT        "\\_SB_.VALX.DSSX"
 
-/* The Toshiba configuration interface is composed of the HCI and the SCI,
+/*
+ * The Toshiba configuration interface is composed of the HCI and the SCI,
  * which are defined as follows:
  *
  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
@@ -108,6 +102,7 @@ MODULE_LICENSE("GPL");
 #define TOS_FIFO_EMPTY                  0x8c00
 #define TOS_DATA_NOT_AVAILABLE          0x8d20
 #define TOS_NOT_INITIALIZED             0x8d50
+#define TOS_NOT_INSTALLED               0x8e00
 
 /* registers */
 #define HCI_FAN                         0x0004
@@ -121,9 +116,14 @@ MODULE_LICENSE("GPL");
 #define HCI_KBD_ILLUMINATION            0x0095
 #define HCI_ECO_MODE                    0x0097
 #define HCI_ACCELEROMETER2              0x00a6
+#define SCI_PANEL_POWER_ON              0x010d
 #define SCI_ILLUMINATION                0x014e
+#define SCI_USB_SLEEP_CHARGE            0x0150
 #define SCI_KBD_ILLUM_STATUS            0x015c
+#define SCI_USB_SLEEP_MUSIC             0x015e
+#define SCI_USB_THREE                   0x0169
 #define SCI_TOUCHPAD                    0x050e
+#define SCI_KBD_FUNCTION_KEYS           0x0522
 
 /* field definitions */
 #define HCI_ACCEL_MASK                  0x7fff
@@ -146,6 +146,15 @@ MODULE_LICENSE("GPL");
 #define SCI_KBD_MODE_ON                 0x8
 #define SCI_KBD_MODE_OFF                0x10
 #define SCI_KBD_TIME_MAX                0x3c001a
+#define SCI_USB_CHARGE_MODE_MASK        0xff
+#define SCI_USB_CHARGE_DISABLED         0x30000
+#define SCI_USB_CHARGE_ALTERNATE        0x30009
+#define SCI_USB_CHARGE_AUTO             0x30021
+#define SCI_USB_CHARGE_BAT_MASK         0x7
+#define SCI_USB_CHARGE_BAT_LVL_OFF      0x1
+#define SCI_USB_CHARGE_BAT_LVL_ON       0x4
+#define SCI_USB_CHARGE_BAT_LVL          0x0200
+#define SCI_USB_CHARGE_RAPID_DSP        0x0300
 
 struct toshiba_acpi_dev {
         struct acpi_device *acpi_dev;
@@ -164,6 +173,7 @@ struct toshiba_acpi_dev {
         int kbd_type;
         int kbd_mode;
         int kbd_time;
+        int usbsc_bat_level;
 
         unsigned int illumination_supported:1;
         unsigned int video_supported:1;
@@ -177,6 +187,12 @@ struct toshiba_acpi_dev {
         unsigned int touchpad_supported:1;
         unsigned int eco_supported:1;
         unsigned int accelerometer_supported:1;
+        unsigned int usb_sleep_charge_supported:1;
+        unsigned int usb_rapid_charge_supported:1;
+        unsigned int usb_sleep_music_supported:1;
+        unsigned int kbd_function_keys_supported:1;
+        unsigned int panel_power_on_supported:1;
+        unsigned int usb_three_supported:1;
         unsigned int sysfs_created:1;
 
         struct mutex mutex;
@@ -264,15 +280,17 @@ static const struct key_entry toshiba_acpi_alt_keymap[] = {
         { KE_END, 0 },
 };
 
-/* utility
+/*
+ * Utility
  */
 
-static __inline__ void _set_bit(u32 * word, u32 mask, int value)
+static inline void _set_bit(u32 *word, u32 mask, int value)
 {
         *word = (*word & ~mask) | (mask * value);
 }
 
-/* acpi interface wrappers
+/*
+ * ACPI interface wrappers
  */
 
 static int write_acpi_int(const char *methodName, int val)
@@ -283,7 +301,8 @@ static int write_acpi_int(const char *methodName, int val)
         return (status == AE_OK) ? 0 : -EIO;
 }
 
-/* Perform a raw configuration call.  Here we don't care about input or output
+/*
+ * Perform a raw configuration call.  Here we don't care about input or output
  * buffer format.
  */
 static acpi_status tci_raw(struct toshiba_acpi_dev *dev,
@@ -310,15 +329,15 @@ static acpi_status tci_raw(struct toshiba_acpi_dev *dev,
                                       (char *)dev->method_hci, &params,
                                       &results);
         if ((status == AE_OK) && (out_objs->package.count <= TCI_WORDS)) {
-                for (i = 0; i < out_objs->package.count; ++i) {
+                for (i = 0; i < out_objs->package.count; ++i)
                         out[i] = out_objs->package.elements[i].integer.value;
-                }
         }
 
         return status;
 }
 
-/* common hci tasks (get or set one or two value)
+/*
+ * Common hci tasks (get or set one or two value)
  *
  * In addition to the ACPI status, the HCI system returns a result which
  * may be useful (such as "not supported").
@@ -338,6 +357,7 @@ static u32 hci_read1(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1)
         u32 in[TCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
         u32 out[TCI_WORDS];
         acpi_status status = tci_raw(dev, in, out);
+
         if (ACPI_FAILURE(status))
                 return TOS_FAILURE;
 
@@ -355,11 +375,13 @@ static u32 hci_write2(struct toshiba_acpi_dev *dev, u32 reg, u32 in1, u32 in2)
         return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
 }
 
-static u32 hci_read2(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1, u32 *out2)
+static u32 hci_read2(struct toshiba_acpi_dev *dev,
+                     u32 reg, u32 *out1, u32 *out2)
 {
         u32 in[TCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
         u32 out[TCI_WORDS];
         acpi_status status = tci_raw(dev, in, out);
+
         if (ACPI_FAILURE(status))
                 return TOS_FAILURE;
 
@@ -369,7 +391,8 @@ static u32 hci_read2(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1, u32 *out2
         return out[0];
 }
 
-/* common sci tasks
+/*
+ * Common sci tasks
  */
 
 static int sci_open(struct toshiba_acpi_dev *dev)
@@ -389,6 +412,20 @@ static int sci_open(struct toshiba_acpi_dev *dev)
         } else if (out[0] == TOS_ALREADY_OPEN) {
                 pr_info("Toshiba SCI already opened\n");
                 return 1;
+        } else if (out[0] == TOS_NOT_SUPPORTED) {
+                /*
+                 * Some BIOSes do not have the SCI open/close functions
+                 * implemented and return 0x8000 (Not Supported), failing to
+                 * register some supported features.
+                 *
+                 * Simply return 1 if we hit those affected laptops to make the
+                 * supported features work.
+                 *
+                 * In the case that some laptops really do not support the SCI,
+                 * all the SCI dependent functions check for TOS_NOT_SUPPORTED,
+                 * and thus, not registering support for the queried feature.
+                 */
+                return 1;
         } else if (out[0] == TOS_NOT_PRESENT) {
                 pr_info("Toshiba SCI is not present\n");
         }
@@ -421,6 +458,7 @@ static u32 sci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1)
         u32 in[TCI_WORDS] = { SCI_GET, reg, 0, 0, 0, 0 };
         u32 out[TCI_WORDS];
         acpi_status status = tci_raw(dev, in, out);
+
         if (ACPI_FAILURE(status))
                 return TOS_FAILURE;
 
@@ -529,10 +567,11 @@ static int toshiba_kbd_illum_available(struct toshiba_acpi_dev *dev)
                 return 0;
         }
 
-        /* Check for keyboard backlight timeout max value,
+        /*
+         * Check for keyboard backlight timeout max value,
          * previous kbd backlight implementation set this to
          * 0x3c0003, and now the new implementation set this
-         * to 0x3c001a, use this to distinguish between them
+         * to 0x3c001a, use this to distinguish between them.
          */
         if (out[3] == SCI_KBD_TIME_MAX)
                 dev->kbd_type = 2;
@@ -667,19 +706,37 @@ static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state)
 static int toshiba_eco_mode_available(struct toshiba_acpi_dev *dev)
 {
         acpi_status status;
-        u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 };
+        u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 0, 0, 0 };
         u32 out[TCI_WORDS];
 
         status = tci_raw(dev, in, out);
-        if (ACPI_FAILURE(status) || out[0] == TOS_INPUT_DATA_ERROR) {
-                pr_info("ACPI call to get ECO led failed\n");
-                return 0;
+        if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to get ECO led failed\n");
+        } else if (out[0] == TOS_NOT_INSTALLED) {
+                pr_info("ECO led not installed");
+        } else if (out[0] == TOS_INPUT_DATA_ERROR) {
+                /*
+                 * If we receive 0x8300 (Input Data Error), it means that the
+                 * LED device is present, but that we just screwed the input
+                 * parameters.
+                 *
+                 * Let's query the status of the LED to see if we really have a
+                 * success response, indicating the actual presense of the LED,
+                 * bail out otherwise.
+                 */
+                in[3] = 1;
+                status = tci_raw(dev, in, out);
+                if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE)
+                        pr_err("ACPI call to get ECO led failed\n");
+                else if (out[0] == TOS_SUCCESS)
+                        return 1;
         }
 
-        return 1;
+        return 0;
 }
 
-static enum led_brightness toshiba_eco_mode_get_status(struct led_classdev *cdev)
+static enum led_brightness
+toshiba_eco_mode_get_status(struct led_classdev *cdev)
 {
         struct toshiba_acpi_dev *dev = container_of(cdev,
                         struct toshiba_acpi_dev, eco_led);
@@ -721,7 +778,8 @@ static int toshiba_accelerometer_supported(struct toshiba_acpi_dev *dev)
         u32 out[TCI_WORDS];
         acpi_status status;
 
-        /* Check if the accelerometer call exists,
+        /*
+         * Check if the accelerometer call exists,
          * this call also serves as initialization
          */
         status = tci_raw(dev, in, out);
@@ -760,6 +818,337 @@ static int toshiba_accelerometer_get(struct toshiba_acpi_dev *dev,
         return 0;
 }
 
+/* Sleep (Charge and Music) utilities support */
+static int toshiba_usb_sleep_charge_get(struct toshiba_acpi_dev *dev,
+                                        u32 *mode)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_read(dev, SCI_USB_SLEEP_CHARGE, mode);
+        sci_close(dev);
+        if (result == TOS_FAILURE) {
+                pr_err("ACPI call to set USB S&C mode failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int toshiba_usb_sleep_charge_set(struct toshiba_acpi_dev *dev,
+                                        u32 mode)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_write(dev, SCI_USB_SLEEP_CHARGE, mode);
+        sci_close(dev);
+        if (result == TOS_FAILURE) {
+                pr_err("ACPI call to set USB S&C mode failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int toshiba_sleep_functions_status_get(struct toshiba_acpi_dev *dev,
+                                              u32 *mode)
+{
+        u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
+        u32 out[TCI_WORDS];
+        acpi_status status;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        in[5] = SCI_USB_CHARGE_BAT_LVL;
+        status = tci_raw(dev, in, out);
+        sci_close(dev);
+        if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to get USB S&C battery level failed\n");
+                return -EIO;
+        } else if (out[0] == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (out[0] == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        *mode = out[2];
+
+        return 0;
+}
+
+static int toshiba_sleep_functions_status_set(struct toshiba_acpi_dev *dev,
+                                              u32 mode)
+{
+        u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
+        u32 out[TCI_WORDS];
+        acpi_status status;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        in[2] = mode;
+        in[5] = SCI_USB_CHARGE_BAT_LVL;
+        status = tci_raw(dev, in, out);
+        sci_close(dev);
+        if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to set USB S&C battery level failed\n");
+                return -EIO;
+        } else if (out[0] == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (out[0] == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int toshiba_usb_rapid_charge_get(struct toshiba_acpi_dev *dev,
+                                        u32 *state)
+{
+        u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
+        u32 out[TCI_WORDS];
+        acpi_status status;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        in[5] = SCI_USB_CHARGE_RAPID_DSP;
+        status = tci_raw(dev, in, out);
+        sci_close(dev);
+        if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to get USB S&C battery level failed\n");
+                return -EIO;
+        } else if (out[0] == TOS_NOT_SUPPORTED ||
+                   out[0] == TOS_INPUT_DATA_ERROR) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        }
+
+        *state = out[2];
+
+        return 0;
+}
+
+static int toshiba_usb_rapid_charge_set(struct toshiba_acpi_dev *dev,
+                                        u32 state)
+{
+        u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
+        u32 out[TCI_WORDS];
+        acpi_status status;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        in[2] = state;
+        in[5] = SCI_USB_CHARGE_RAPID_DSP;
+        status = tci_raw(dev, in, out);
+        sci_close(dev);
+        if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to set USB S&C battery level failed\n");
+                return -EIO;
+        } else if (out[0] == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (out[0] == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int toshiba_usb_sleep_music_get(struct toshiba_acpi_dev *dev, u32 *state)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_read(dev, SCI_USB_SLEEP_MUSIC, state);
+        sci_close(dev);
+        if (result == TOS_FAILURE) {
+                pr_err("ACPI call to set USB S&C mode failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int toshiba_usb_sleep_music_set(struct toshiba_acpi_dev *dev, u32 state)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_write(dev, SCI_USB_SLEEP_MUSIC, state);
+        sci_close(dev);
+        if (result == TOS_FAILURE) {
+                pr_err("ACPI call to set USB S&C mode failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+/* Keyboard function keys */
+static int toshiba_function_keys_get(struct toshiba_acpi_dev *dev, u32 *mode)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_read(dev, SCI_KBD_FUNCTION_KEYS, mode);
+        sci_close(dev);
+        if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
+                pr_err("ACPI call to get KBD function keys failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("KBD function keys not supported\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int toshiba_function_keys_set(struct toshiba_acpi_dev *dev, u32 mode)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_write(dev, SCI_KBD_FUNCTION_KEYS, mode);
+        sci_close(dev);
+        if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
+                pr_err("ACPI call to set KBD function keys failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("KBD function keys not supported\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+/* Panel Power ON */
+static int toshiba_panel_power_on_get(struct toshiba_acpi_dev *dev, u32 *state)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_read(dev, SCI_PANEL_POWER_ON, state);
+        sci_close(dev);
+        if (result == TOS_FAILURE) {
+                pr_err("ACPI call to get Panel Power ON failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("Panel Power on not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int toshiba_panel_power_on_set(struct toshiba_acpi_dev *dev, u32 state)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_write(dev, SCI_PANEL_POWER_ON, state);
+        sci_close(dev);
+        if (result == TOS_FAILURE) {
+                pr_err("ACPI call to set Panel Power ON failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("Panel Power ON not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+/* USB Three */
+static int toshiba_usb_three_get(struct toshiba_acpi_dev *dev, u32 *state)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_read(dev, SCI_USB_THREE, state);
+        sci_close(dev);
+        if (result == TOS_FAILURE) {
+                pr_err("ACPI call to get USB 3 failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB 3 not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int toshiba_usb_three_set(struct toshiba_acpi_dev *dev, u32 state)
+{
+        u32 result;
+
+        if (!sci_open(dev))
+                return -EIO;
+
+        result = sci_write(dev, SCI_USB_THREE, state);
+        sci_close(dev);
+        if (result == TOS_FAILURE) {
+                pr_err("ACPI call to set USB 3 failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB 3 not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
 /* Bluetooth rfkill handlers */
 
 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present)
@@ -870,7 +1259,7 @@ static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable)
         return hci_result == TOS_SUCCESS ? 0 : -EIO;
 }
 
-static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
+static struct proc_dir_entry *toshiba_proc_dir /*= 0*/;
 
 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
 {
@@ -881,6 +1270,7 @@ static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
         if (dev->tr_backlight_supported) {
                 bool enabled;
                 int ret = get_tr_backlight_status(dev, &enabled);
+
                 if (ret)
                         return ret;
                 if (enabled)
@@ -898,6 +1288,7 @@ static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
 static int get_lcd_brightness(struct backlight_device *bd)
 {
         struct toshiba_acpi_dev *dev = bl_get_data(bd);
+
         return __get_lcd_brightness(dev);
 }
 
@@ -934,6 +1325,7 @@ static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
         if (dev->tr_backlight_supported) {
                 bool enable = !value;
                 int ret = set_tr_backlight_status(dev, enable);
+
                 if (ret)
                         return ret;
                 if (value)
@@ -948,6 +1340,7 @@ static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
 static int set_lcd_status(struct backlight_device *bd)
 {
         struct toshiba_acpi_dev *dev = bl_get_data(bd);
+
         return set_lcd_brightness(dev, bd->props.brightness);
 }
 
@@ -1005,6 +1398,7 @@ static int video_proc_show(struct seq_file *m, void *v)
                 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
                 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
                 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
+
                 seq_printf(m, "lcd_out:                 %d\n", is_lcd);
                 seq_printf(m, "crt_out:                 %d\n", is_crt);
                 seq_printf(m, "tv_out:                  %d\n", is_tv);
@@ -1042,9 +1436,9 @@ static ssize_t video_proc_write(struct file *file, const char __user *buf,
 
         buffer = cmd;
 
-        /* scan expression.  Multiple expressions may be delimited with ;
-         *
-         *  NOTE: to keep scanning simple, invalid fields are ignored
+        /*
+         * Scan expression.  Multiple expressions may be delimited with ;
+         * NOTE: To keep scanning simple, invalid fields are ignored.
          */
         while (remain) {
                 if (sscanf(buffer, " lcd_out : %i", &value) == 1)
@@ -1053,12 +1447,11 @@ static ssize_t video_proc_write(struct file *file, const char __user *buf,
                         crt_out = value & 1;
                 else if (sscanf(buffer, " tv_out : %i", &value) == 1)
                         tv_out = value & 1;
-                /* advance to one character past the next ; */
+                /* Advance to one character past the next ; */
                 do {
                         ++buffer;
                         --remain;
-                }
-                while (remain && *(buffer - 1) != ';');
+                } while (remain && *(buffer - 1) != ';');
         }
 
         kfree(cmd);
@@ -1066,13 +1459,15 @@ static ssize_t video_proc_write(struct file *file, const char __user *buf,
         ret = get_video_status(dev, &video_out);
         if (!ret) {
                 unsigned int new_video_out = video_out;
+
                 if (lcd_out != -1)
                         _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
                 if (crt_out != -1)
                         _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
                 if (tv_out != -1)
                         _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
-                /* To avoid unnecessary video disruption, only write the new
+                /*
+                 * To avoid unnecessary video disruption, only write the new
                  * video setting if something changed. */
                 if (new_video_out != video_out)
                         ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
@@ -1135,10 +1530,10 @@ static ssize_t fan_proc_write(struct file *file, const char __user *buf,
         if (sscanf(cmd, " force_on : %i", &value) == 1 &&
             value >= 0 && value <= 1) {
                 hci_result = hci_write1(dev, HCI_FAN, value);
-                if (hci_result != TOS_SUCCESS)
-                        return -EIO;
-                else
+                if (hci_result == TOS_SUCCESS)
                         dev->force_fan = value;
+                else
+                        return -EIO;
         } else {
                 return -EINVAL;
         }
@@ -1167,11 +1562,13 @@ static int keys_proc_show(struct seq_file *m, void *v)
                         dev->key_event_valid = 1;
                         dev->last_key_event = value;
                 } else if (hci_result == TOS_FIFO_EMPTY) {
-                        /* better luck next time */
+                        /* Better luck next time */
                 } else if (hci_result == TOS_NOT_SUPPORTED) {
-                        /* This is a workaround for an unresolved issue on
+                        /*
+                         * This is a workaround for an unresolved issue on
                          * some machines where system events sporadically
-                         * become disabled. */
+                         * become disabled.
+                         */
                         hci_result = hci_write1(dev, HCI_SYSTEM_EVENT, 1);
                         pr_notice("Re-enabled hotkeys\n");
                 } else {
@@ -1203,11 +1600,10 @@ static ssize_t keys_proc_write(struct file *file, const char __user *buf,
                 return -EFAULT;
         cmd[len] = '\0';
 
-        if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
+        if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0)
                 dev->key_event_valid = 0;
-        } else {
+        else
                 return -EINVAL;
-        }
 
         return count;
 }
@@ -1241,7 +1637,8 @@ static const struct file_operations version_proc_fops = {
         .release        = single_release,
 };
 
-/* proc and module init
+/*
+ * Proc and module init
  */
 
 #define PROC_TOSHIBA            "toshiba"
@@ -1286,66 +1683,56 @@ static const struct backlight_ops toshiba_backlight_data = {
 /*
  * Sysfs files
  */
-static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
-                                         struct device_attribute *attr,
-                                         const char *buf, size_t count);
-static ssize_t toshiba_kbd_bl_mode_show(struct device *dev,
-                                        struct device_attribute *attr,
-                                        char *buf);
-static ssize_t toshiba_kbd_type_show(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf);
-static ssize_t toshiba_available_kbd_modes_show(struct device *dev,
-                                        struct device_attribute *attr,
-                                        char *buf);
-static ssize_t toshiba_kbd_bl_timeout_store(struct device *dev,
-                                            struct device_attribute *attr,
-                                            const char *buf, size_t count);
-static ssize_t toshiba_kbd_bl_timeout_show(struct device *dev,
-                                           struct device_attribute *attr,
-                                           char *buf);
-static ssize_t toshiba_touchpad_store(struct device *dev,
-                                      struct device_attribute *attr,
-                                      const char *buf, size_t count);
-static ssize_t toshiba_touchpad_show(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf);
-static ssize_t toshiba_position_show(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf);
-
-static DEVICE_ATTR(kbd_backlight_mode, S_IRUGO | S_IWUSR,
-                   toshiba_kbd_bl_mode_show, toshiba_kbd_bl_mode_store);
-static DEVICE_ATTR(kbd_type, S_IRUGO, toshiba_kbd_type_show, NULL);
-static DEVICE_ATTR(available_kbd_modes, S_IRUGO,
-                   toshiba_available_kbd_modes_show, NULL);
-static DEVICE_ATTR(kbd_backlight_timeout, S_IRUGO | S_IWUSR,
-                   toshiba_kbd_bl_timeout_show, toshiba_kbd_bl_timeout_store);
-static DEVICE_ATTR(touchpad, S_IRUGO | S_IWUSR,
-                   toshiba_touchpad_show, toshiba_touchpad_store);
-static DEVICE_ATTR(position, S_IRUGO, toshiba_position_show, NULL);
+static ssize_t version_show(struct device *dev,
+                            struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%s\n", TOSHIBA_ACPI_VERSION);
+}
+static DEVICE_ATTR_RO(version);
 
-static struct attribute *toshiba_attributes[] = {
-        &dev_attr_kbd_backlight_mode.attr,
-        &dev_attr_kbd_type.attr,
-        &dev_attr_available_kbd_modes.attr,
-        &dev_attr_kbd_backlight_timeout.attr,
-        &dev_attr_touchpad.attr,
-        &dev_attr_position.attr,
-        NULL,
-};
+static ssize_t fan_store(struct device *dev,
+                         struct device_attribute *attr,
+                         const char *buf, size_t count)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 result;
+        int state;
+        int ret;
 
-static umode_t toshiba_sysfs_is_visible(struct kobject *,
-                                        struct attribute *, int);
+        ret = kstrtoint(buf, 0, &state);
+        if (ret)
+                return ret;
 
-static struct attribute_group toshiba_attr_group = {
-        .is_visible = toshiba_sysfs_is_visible,
-        .attrs = toshiba_attributes,
-};
+        if (state != 0 && state != 1)
+                return -EINVAL;
 
-static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
-                                         struct device_attribute *attr,
-                                         const char *buf, size_t count)
+        result = hci_write1(toshiba, HCI_FAN, state);
+        if (result == TOS_FAILURE)
+                return -EIO;
+        else if (result == TOS_NOT_SUPPORTED)
+                return -ENODEV;
+
+        return count;
+}
+
+static ssize_t fan_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 value;
+        int ret;
+
+        ret = get_fan_status(toshiba, &value);
+        if (ret)
+                return ret;
+
+        return sprintf(buf, "%d\n", value);
+}
+static DEVICE_ATTR_RW(fan);
+
+static ssize_t kbd_backlight_mode_store(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
         int mode;
@@ -1369,7 +1756,8 @@ static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
                         return -EINVAL;
         }
 
-        /* Set the Keyboard Backlight Mode where:
+        /*
+         * Set the Keyboard Backlight Mode where:
          *      Auto - KBD backlight turns off automatically in given time
          *      FN-Z - KBD backlight "toggles" when hotkey pressed
          *      ON   - KBD backlight is always on
@@ -1400,9 +1788,9 @@ static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
         return count;
 }
 
-static ssize_t toshiba_kbd_bl_mode_show(struct device *dev,
-                                        struct device_attribute *attr,
-                                        char *buf)
+static ssize_t kbd_backlight_mode_show(struct device *dev,
+                                       struct device_attribute *attr,
+                                       char *buf)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
         u32 time;
@@ -1412,19 +1800,20 @@ static ssize_t toshiba_kbd_bl_mode_show(struct device *dev,
 
         return sprintf(buf, "%i\n", time & SCI_KBD_MODE_MASK);
 }
+static DEVICE_ATTR_RW(kbd_backlight_mode);
 
-static ssize_t toshiba_kbd_type_show(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf)
+static ssize_t kbd_type_show(struct device *dev,
+                             struct device_attribute *attr, char *buf)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
 
         return sprintf(buf, "%d\n", toshiba->kbd_type);
 }
+static DEVICE_ATTR_RO(kbd_type);
 
-static ssize_t toshiba_available_kbd_modes_show(struct device *dev,
-                                                struct device_attribute *attr,
-                                                char *buf)
+static ssize_t available_kbd_modes_show(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
 
@@ -1435,10 +1824,11 @@ static ssize_t toshiba_available_kbd_modes_show(struct device *dev,
         return sprintf(buf, "%x %x %x\n",
                        SCI_KBD_MODE_AUTO, SCI_KBD_MODE_ON, SCI_KBD_MODE_OFF);
 }
+static DEVICE_ATTR_RO(available_kbd_modes);
 
-static ssize_t toshiba_kbd_bl_timeout_store(struct device *dev,
-                                            struct device_attribute *attr,
-                                            const char *buf, size_t count)
+static ssize_t kbd_backlight_timeout_store(struct device *dev,
+                                           struct device_attribute *attr,
+                                           const char *buf, size_t count)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
         int time;
@@ -1479,9 +1869,9 @@ static ssize_t toshiba_kbd_bl_timeout_store(struct device *dev,
         return count;
 }
 
-static ssize_t toshiba_kbd_bl_timeout_show(struct device *dev,
-                                           struct device_attribute *attr,
-                                           char *buf)
+static ssize_t kbd_backlight_timeout_show(struct device *dev,
+                                          struct device_attribute *attr,
+                                          char *buf)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
         u32 time;
@@ -1491,10 +1881,11 @@ static ssize_t toshiba_kbd_bl_timeout_show(struct device *dev,
 
         return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT);
 }
+static DEVICE_ATTR_RW(kbd_backlight_timeout);
 
-static ssize_t toshiba_touchpad_store(struct device *dev,
-                                      struct device_attribute *attr,
-                                      const char *buf, size_t count)
+static ssize_t touchpad_store(struct device *dev,
+                              struct device_attribute *attr,
+                              const char *buf, size_t count)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
         int state;
@@ -1514,8 +1905,8 @@ static ssize_t toshiba_touchpad_store(struct device *dev,
         return count;
 }
 
-static ssize_t toshiba_touchpad_show(struct device *dev,
-                                     struct device_attribute *attr, char *buf)
+static ssize_t touchpad_show(struct device *dev,
+                             struct device_attribute *attr, char *buf)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
         u32 state;
@@ -1527,9 +1918,10 @@ static ssize_t toshiba_touchpad_show(struct device *dev,
 
         return sprintf(buf, "%i\n", state);
 }
+static DEVICE_ATTR_RW(touchpad);
 
-static ssize_t toshiba_position_show(struct device *dev,
-                                     struct device_attribute *attr, char *buf)
+static ssize_t position_show(struct device *dev,
+                             struct device_attribute *attr, char *buf)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
         u32 xyval, zval, tmp;
@@ -1548,6 +1940,336 @@ static ssize_t toshiba_position_show(struct device *dev,
 
         return sprintf(buf, "%d %d %d\n", x, y, z);
 }
+static DEVICE_ATTR_RO(position);
+
+static ssize_t usb_sleep_charge_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 mode;
+        int ret;
+
+        ret = toshiba_usb_sleep_charge_get(toshiba, &mode);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%x\n", mode & SCI_USB_CHARGE_MODE_MASK);
+}
+
+static ssize_t usb_sleep_charge_store(struct device *dev,
+                                      struct device_attribute *attr,
+                                      const char *buf, size_t count)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 mode;
+        int state;
+        int ret;
+
+        ret = kstrtoint(buf, 0, &state);
+        if (ret)
+                return ret;
+        /*
+         * Check for supported values, where:
+         * 0 - Disabled
+         * 1 - Alternate (Non USB conformant devices that require more power)
+         * 2 - Auto (USB conformant devices)
+         */
+        if (state != 0 && state != 1 && state != 2)
+                return -EINVAL;
+
+        /* Set the USB charging mode to internal value */
+        if (state == 0)
+                mode = SCI_USB_CHARGE_DISABLED;
+        else if (state == 1)
+                mode = SCI_USB_CHARGE_ALTERNATE;
+        else if (state == 2)
+                mode = SCI_USB_CHARGE_AUTO;
+
+        ret = toshiba_usb_sleep_charge_set(toshiba, mode);
+        if (ret)
+                return ret;
+
+        return count;
+}
+static DEVICE_ATTR_RW(usb_sleep_charge);
+
+static ssize_t sleep_functions_on_battery_show(struct device *dev,
+                                               struct device_attribute *attr,
+                                               char *buf)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 state;
+        int bat_lvl;
+        int status;
+        int ret;
+        int tmp;
+
+        ret = toshiba_sleep_functions_status_get(toshiba, &state);
+        if (ret < 0)
+                return ret;
+
+        /* Determine the status: 0x4 - Enabled | 0x1 - Disabled */
+        tmp = state & SCI_USB_CHARGE_BAT_MASK;
+        status = (tmp == 0x4) ? 1 : 0;
+        /* Determine the battery level set */
+        bat_lvl = state >> HCI_MISC_SHIFT;
+
+        return sprintf(buf, "%d %d\n", status, bat_lvl);
+}
+
+static ssize_t sleep_functions_on_battery_store(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t count)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 status;
+        int value;
+        int ret;
+        int tmp;
+
+        ret = kstrtoint(buf, 0, &value);
+        if (ret)
+                return ret;
+
+        /*
+         * Set the status of the function:
+         * 0 - Disabled
+         * 1-100 - Enabled
+         */
+        if (value < 0 || value > 100)
+                return -EINVAL;
+
+        if (value == 0) {
+                tmp = toshiba->usbsc_bat_level << HCI_MISC_SHIFT;
+                status = tmp | SCI_USB_CHARGE_BAT_LVL_OFF;
+        } else {
+                tmp = value << HCI_MISC_SHIFT;
+                status = tmp | SCI_USB_CHARGE_BAT_LVL_ON;
+        }
+        ret = toshiba_sleep_functions_status_set(toshiba, status);
+        if (ret < 0)
+                return ret;
+
+        toshiba->usbsc_bat_level = status >> HCI_MISC_SHIFT;
+
+        return count;
+}
+static DEVICE_ATTR_RW(sleep_functions_on_battery);
+
+static ssize_t usb_rapid_charge_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 state;
+        int ret;
+
+        ret = toshiba_usb_rapid_charge_get(toshiba, &state);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", state);
+}
+
+static ssize_t usb_rapid_charge_store(struct device *dev,
+                                      struct device_attribute *attr,
+                                      const char *buf, size_t count)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        int state;
+        int ret;
+
+        ret = kstrtoint(buf, 0, &state);
+        if (ret)
+                return ret;
+        if (state != 0 && state != 1)
+                return -EINVAL;
+
+        ret = toshiba_usb_rapid_charge_set(toshiba, state);
+        if (ret)
+                return ret;
+
+        return count;
+}
+static DEVICE_ATTR_RW(usb_rapid_charge);
+
+static ssize_t usb_sleep_music_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 state;
+        int ret;
+
+        ret = toshiba_usb_sleep_music_get(toshiba, &state);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", state);
+}
+
+static ssize_t usb_sleep_music_store(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        int state;
+        int ret;
+
+        ret = kstrtoint(buf, 0, &state);
+        if (ret)
+                return ret;
+        if (state != 0 && state != 1)
+                return -EINVAL;
+
+        ret = toshiba_usb_sleep_music_set(toshiba, state);
+        if (ret)
+                return ret;
+
+        return count;
+}
+static DEVICE_ATTR_RW(usb_sleep_music);
+
+static ssize_t kbd_function_keys_show(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        int mode;
+        int ret;
+
+        ret = toshiba_function_keys_get(toshiba, &mode);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", mode);
+}
+
+static ssize_t kbd_function_keys_store(struct device *dev,
+                                       struct device_attribute *attr,
+                                       const char *buf, size_t count)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        int mode;
+        int ret;
+
+        ret = kstrtoint(buf, 0, &mode);
+        if (ret)
+                return ret;
+        /*
+         * Check for the function keys mode where:
+         * 0 - Normal operation (F{1-12} as usual and hotkeys via FN-F{1-12})
+         * 1 - Special functions (Opposite of the above setting)
+         */
+        if (mode != 0 && mode != 1)
+                return -EINVAL;
+
+        ret = toshiba_function_keys_set(toshiba, mode);
+        if (ret)
+                return ret;
+
+        pr_info("Reboot for changes to KBD Function Keys to take effect");
+
+        return count;
+}
+static DEVICE_ATTR_RW(kbd_function_keys);
+
+static ssize_t panel_power_on_show(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 state;
+        int ret;
+
+        ret = toshiba_panel_power_on_get(toshiba, &state);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", state);
+}
+
+static ssize_t panel_power_on_store(struct device *dev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        int state;
+        int ret;
+
+        ret = kstrtoint(buf, 0, &state);
+        if (ret)
+                return ret;
+        if (state != 0 && state != 1)
+                return -EINVAL;
+
+        ret = toshiba_panel_power_on_set(toshiba, state);
+        if (ret)
+                return ret;
+
+        pr_info("Reboot for changes to Panel Power ON to take effect");
+
+        return count;
+}
+static DEVICE_ATTR_RW(panel_power_on);
+
+static ssize_t usb_three_show(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        u32 state;
+        int ret;
+
+        ret = toshiba_usb_three_get(toshiba, &state);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", state);
+}
+
+static ssize_t usb_three_store(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
+        int state;
+        int ret;
+
+        ret = kstrtoint(buf, 0, &state);
+        if (ret)
+                return ret;
+        /*
+         * Check for USB 3 mode where:
+         * 0 - Disabled (Acts like a USB 2 port, saving power)
+         * 1 - Enabled
+         */
+        if (state != 0 && state != 1)
+                return -EINVAL;
+
+        ret = toshiba_usb_three_set(toshiba, state);
+        if (ret)
+                return ret;
+
+        pr_info("Reboot for changes to USB 3 to take effect");
+
+        return count;
+}
+static DEVICE_ATTR_RW(usb_three);
+
+static struct attribute *toshiba_attributes[] = {
+        &dev_attr_version.attr,
+        &dev_attr_fan.attr,
+        &dev_attr_kbd_backlight_mode.attr,
+        &dev_attr_kbd_type.attr,
+        &dev_attr_available_kbd_modes.attr,
+        &dev_attr_kbd_backlight_timeout.attr,
+        &dev_attr_touchpad.attr,
+        &dev_attr_position.attr,
+        &dev_attr_usb_sleep_charge.attr,
+        &dev_attr_sleep_functions_on_battery.attr,
+        &dev_attr_usb_rapid_charge.attr,
+        &dev_attr_usb_sleep_music.attr,
+        &dev_attr_kbd_function_keys.attr,
+        &dev_attr_panel_power_on.attr,
+        &dev_attr_usb_three.attr,
+        NULL,
+};
 
 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
                                         struct attribute *attr, int idx)
@@ -1556,7 +2278,9 @@ static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
         struct toshiba_acpi_dev *drv = dev_get_drvdata(dev);
         bool exists = true;
 
-        if (attr == &dev_attr_kbd_backlight_mode.attr)
+        if (attr == &dev_attr_fan.attr)
+                exists = (drv->fan_supported) ? true : false;
+        else if (attr == &dev_attr_kbd_backlight_mode.attr)
                 exists = (drv->kbd_illum_supported) ? true : false;
         else if (attr == &dev_attr_kbd_backlight_timeout.attr)
                 exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false;
@@ -1564,10 +2288,29 @@ static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
                 exists = (drv->touchpad_supported) ? true : false;
         else if (attr == &dev_attr_position.attr)
                 exists = (drv->accelerometer_supported) ? true : false;
+        else if (attr == &dev_attr_usb_sleep_charge.attr)
+                exists = (drv->usb_sleep_charge_supported) ? true : false;
+        else if (attr == &dev_attr_sleep_functions_on_battery.attr)
+                exists = (drv->usb_sleep_charge_supported) ? true : false;
+        else if (attr == &dev_attr_usb_rapid_charge.attr)
+                exists = (drv->usb_rapid_charge_supported) ? true : false;
+        else if (attr == &dev_attr_usb_sleep_music.attr)
+                exists = (drv->usb_sleep_music_supported) ? true : false;
+        else if (attr == &dev_attr_kbd_function_keys.attr)
+                exists = (drv->kbd_function_keys_supported) ? true : false;
+        else if (attr == &dev_attr_panel_power_on.attr)
+                exists = (drv->panel_power_on_supported) ? true : false;
+        else if (attr == &dev_attr_usb_three.attr)
+                exists = (drv->usb_three_supported) ? true : false;
 
         return exists ? attr->mode : 0;
 }
 
+static struct attribute_group toshiba_attr_group = {
+        .is_visible = toshiba_sysfs_is_visible,
+        .attrs = toshiba_attributes,
+};
+
 /*
  * Hotkeys
  */
@@ -1644,7 +2387,7 @@ static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
         if (scancode == 0x100)
                 return;
 
-        /* act on key press; ignore key release */
+        /* Act on key press; ignore key release */
         if (scancode & 0x80)
                 return;
 
@@ -1680,7 +2423,7 @@ static void toshiba_acpi_process_hotkeys(struct toshiba_acpi_dev *dev)
                                 hci_result =
                                         hci_write1(dev, HCI_SYSTEM_EVENT, 1);
                                 pr_notice("Re-enabled hotkeys\n");
-                                /* fall through */
+                                /* Fall through */
                         default:
                                 retries--;
                                 break;
@@ -1802,7 +2545,7 @@ static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
         props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
 
-        /* adding an extra level and having 0 change to transflective mode */
+        /* Adding an extra level and having 0 change to transflective mode */
         if (dev->tr_backlight_supported)
                 props.max_brightness++;
 
@@ -1973,6 +2716,24 @@ static int toshiba_acpi_add(struct acpi_device *acpi_dev)
         ret = toshiba_accelerometer_supported(dev);
         dev->accelerometer_supported = !ret;
 
+        ret = toshiba_usb_sleep_charge_get(dev, &dummy);
+        dev->usb_sleep_charge_supported = !ret;
+
+        ret = toshiba_usb_rapid_charge_get(dev, &dummy);
+        dev->usb_rapid_charge_supported = !ret;
+
+        ret = toshiba_usb_sleep_music_get(dev, &dummy);
+        dev->usb_sleep_music_supported = !ret;
+
+        ret = toshiba_function_keys_get(dev, &dummy);
+        dev->kbd_function_keys_supported = !ret;
+
+        ret = toshiba_panel_power_on_get(dev, &dummy);
+        dev->panel_power_on_supported = !ret;
+
+        ret = toshiba_usb_three_get(dev, &dummy);
+        dev->usb_three_supported = !ret;
+
         /* Determine whether or not BIOS supports fan and video interfaces */
 
         ret = get_video_status(dev, &dummy);
diff --git a/drivers/pnp/resource.c b/drivers/pnp/resource.c
index 782e82289571..f980ff7166e9 100644
--- a/drivers/pnp/resource.c
+++ b/drivers/pnp/resource.c
@@ -179,8 +179,9 @@ int pnp_check_port(struct pnp_dev *dev, struct resource *res)
         /* check if the resource is already in use, skip if the
          * device is active because it itself may be in use */
         if (!dev->active) {
-                if (__check_region(&ioport_resource, *port, length(port, end)))
+                if (!request_region(*port, length(port, end), "pnp"))
                         return 0;
+                release_region(*port, length(port, end));
         }
 
         /* check if the resource is reserved */
@@ -241,8 +242,9 @@ int pnp_check_mem(struct pnp_dev *dev, struct resource *res)
         /* check if the resource is already in use, skip if the
          * device is active because it itself may be in use */
         if (!dev->active) {
-                if (check_mem_region(*addr, length(addr, end)))
+                if (!request_mem_region(*addr, length(addr, end), "pnp"))
                         return 0;
+                release_mem_region(*addr, length(addr, end));
         }
 
         /* check if the resource is reserved */
diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
index a3ecf5809634..b1541f40fd8d 100644
--- a/drivers/pwm/Kconfig
+++ b/drivers/pwm/Kconfig
@@ -53,6 +53,7 @@ config PWM_ATMEL
 config PWM_ATMEL_HLCDC_PWM
         tristate "Atmel HLCDC PWM support"
         depends on MFD_ATMEL_HLCDC
+        depends on HAVE_CLK
         help
           Generic PWM framework driver for the PWM output of the HLCDC
           (Atmel High-end LCD Controller). This PWM output is mainly used
@@ -130,6 +131,19 @@ config PWM_FSL_FTM
           To compile this driver as a module, choose M here: the module
           will be called pwm-fsl-ftm.
 
+config PWM_IMG
+        tristate "Imagination Technologies PWM driver"
+        depends on HAS_IOMEM
+        depends on MFD_SYSCON
+        depends on COMMON_CLK
+        depends on MIPS || COMPILE_TEST
+        help
+          Generic PWM framework driver for Imagination Technologies
+          PWM block which supports 4 channels.
+
+          To compile this driver as a module, choose M here: the module
+          will be called pwm-img
+
 config PWM_IMX
         tristate "i.MX PWM support"
         depends on ARCH_MXC
@@ -283,6 +297,16 @@ config PWM_STI
           To compile this driver as a module, choose M here: the module
           will be called pwm-sti.
 
+config PWM_SUN4I
+        tristate "Allwinner PWM support"
+        depends on ARCH_SUNXI || COMPILE_TEST
+        depends on HAS_IOMEM && COMMON_CLK
+        help
+          Generic PWM framework driver for Allwinner SoCs.
+
+          To compile this driver as a module, choose M here: the module
+          will be called pwm-sun4i.
+
 config PWM_TEGRA
         tristate "NVIDIA Tegra PWM support"
         depends on ARCH_TEGRA
diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
index 65259ac1e8de..ec50eb5b5a8f 100644
--- a/drivers/pwm/Makefile
+++ b/drivers/pwm/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_PWM_BFIN)		+= pwm-bfin.o
 obj-$(CONFIG_PWM_CLPS711X)      += pwm-clps711x.o
 obj-$(CONFIG_PWM_EP93XX)        += pwm-ep93xx.o
 obj-$(CONFIG_PWM_FSL_FTM)       += pwm-fsl-ftm.o
+obj-$(CONFIG_PWM_IMG)           += pwm-img.o
 obj-$(CONFIG_PWM_IMX)           += pwm-imx.o
 obj-$(CONFIG_PWM_JZ4740)        += pwm-jz4740.o
 obj-$(CONFIG_PWM_LP3943)        += pwm-lp3943.o
@@ -26,6 +27,7 @@ obj-$(CONFIG_PWM_ROCKCHIP)	+= pwm-rockchip.o
 obj-$(CONFIG_PWM_SAMSUNG)       += pwm-samsung.o
 obj-$(CONFIG_PWM_SPEAR)         += pwm-spear.o
 obj-$(CONFIG_PWM_STI)           += pwm-sti.o
+obj-$(CONFIG_PWM_SUN4I)         += pwm-sun4i.o
 obj-$(CONFIG_PWM_TEGRA)         += pwm-tegra.o
 obj-$(CONFIG_PWM_TIECAP)        += pwm-tiecap.o
 obj-$(CONFIG_PWM_TIEHRPWM)      += pwm-tiehrpwm.o
diff --git a/drivers/pwm/core.c b/drivers/pwm/core.c
index 966497d10c6e..810aef3f4c3e 100644
--- a/drivers/pwm/core.c
+++ b/drivers/pwm/core.c
@@ -192,7 +192,7 @@ static void of_pwmchip_add(struct pwm_chip *chip)
 
 static void of_pwmchip_remove(struct pwm_chip *chip)
 {
-        if (chip->dev && chip->dev->of_node)
+        if (chip->dev)
                 of_node_put(chip->dev->of_node);
 }
 
diff --git a/drivers/pwm/pwm-atmel-hlcdc.c b/drivers/pwm/pwm-atmel-hlcdc.c
index e7a785fadcdf..522f7075bb1a 100644
--- a/drivers/pwm/pwm-atmel-hlcdc.c
+++ b/drivers/pwm/pwm-atmel-hlcdc.c
@@ -64,6 +64,9 @@ static int atmel_hlcdc_pwm_config(struct pwm_chip *c,
 
         if (!chip->errata || !chip->errata->slow_clk_erratum) {
                 clk_freq = clk_get_rate(new_clk);
+                if (!clk_freq)
+                        return -EINVAL;
+
                 clk_period_ns = (u64)NSEC_PER_SEC * 256;
                 do_div(clk_period_ns, clk_freq);
         }
@@ -73,6 +76,9 @@ static int atmel_hlcdc_pwm_config(struct pwm_chip *c,
             clk_period_ns > period_ns) {
                 new_clk = hlcdc->sys_clk;
                 clk_freq = clk_get_rate(new_clk);
+                if (!clk_freq)
+                        return -EINVAL;
+
                 clk_period_ns = (u64)NSEC_PER_SEC * 256;
                 do_div(clk_period_ns, clk_freq);
         }
diff --git a/drivers/pwm/pwm-img.c b/drivers/pwm/pwm-img.c
new file mode 100644
index 000000000000..476171a768d6
--- /dev/null
+++ b/drivers/pwm/pwm-img.c
@@ -0,0 +1,249 @@
+/*
+ * Imagination Technologies Pulse Width Modulator driver
+ *
+ * Copyright (c) 2014-2015, Imagination Technologies
+ *
+ * Based on drivers/pwm/pwm-tegra.c, Copyright (c) 2010, NVIDIA 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; either version 2 of the License.
+ */
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pwm.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+
+/* PWM registers */
+#define PWM_CTRL_CFG                            0x0000
+#define PWM_CTRL_CFG_NO_SUB_DIV                 0
+#define PWM_CTRL_CFG_SUB_DIV0                   1
+#define PWM_CTRL_CFG_SUB_DIV1                   2
+#define PWM_CTRL_CFG_SUB_DIV0_DIV1              3
+#define PWM_CTRL_CFG_DIV_SHIFT(ch)              ((ch) * 2 + 4)
+#define PWM_CTRL_CFG_DIV_MASK                   0x3
+
+#define PWM_CH_CFG(ch)                          (0x4 + (ch) * 4)
+#define PWM_CH_CFG_TMBASE_SHIFT                 0
+#define PWM_CH_CFG_DUTY_SHIFT                   16
+
+#define PERIP_PWM_PDM_CONTROL                   0x0140
+#define PERIP_PWM_PDM_CONTROL_CH_MASK           0x1
+#define PERIP_PWM_PDM_CONTROL_CH_SHIFT(ch)      ((ch) * 4)
+
+#define MAX_TMBASE_STEPS                        65536
+
+struct img_pwm_chip {
+        struct device   *dev;
+        struct pwm_chip chip;
+        struct clk      *pwm_clk;
+        struct clk      *sys_clk;
+        void __iomem    *base;
+        struct regmap   *periph_regs;
+};
+
+static inline struct img_pwm_chip *to_img_pwm_chip(struct pwm_chip *chip)
+{
+        return container_of(chip, struct img_pwm_chip, chip);
+}
+
+static inline void img_pwm_writel(struct img_pwm_chip *chip,
+                                  u32 reg, u32 val)
+{
+        writel(val, chip->base + reg);
+}
+
+static inline u32 img_pwm_readl(struct img_pwm_chip *chip,
+                                         u32 reg)
+{
+        return readl(chip->base + reg);
+}
+
+static int img_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
+                          int duty_ns, int period_ns)
+{
+        u32 val, div, duty, timebase;
+        unsigned long mul, output_clk_hz, input_clk_hz;
+        struct img_pwm_chip *pwm_chip = to_img_pwm_chip(chip);
+
+        input_clk_hz = clk_get_rate(pwm_chip->pwm_clk);
+        output_clk_hz = DIV_ROUND_UP(NSEC_PER_SEC, period_ns);
+
+        mul = DIV_ROUND_UP(input_clk_hz, output_clk_hz);
+        if (mul <= MAX_TMBASE_STEPS) {
+                div = PWM_CTRL_CFG_NO_SUB_DIV;
+                timebase = DIV_ROUND_UP(mul, 1);
+        } else if (mul <= MAX_TMBASE_STEPS * 8) {
+                div = PWM_CTRL_CFG_SUB_DIV0;
+                timebase = DIV_ROUND_UP(mul, 8);
+        } else if (mul <= MAX_TMBASE_STEPS * 64) {
+                div = PWM_CTRL_CFG_SUB_DIV1;
+                timebase = DIV_ROUND_UP(mul, 64);
+        } else if (mul <= MAX_TMBASE_STEPS * 512) {
+                div = PWM_CTRL_CFG_SUB_DIV0_DIV1;
+                timebase = DIV_ROUND_UP(mul, 512);
+        } else if (mul > MAX_TMBASE_STEPS * 512) {
+                dev_err(chip->dev,
+                        "failed to configure timebase steps/divider value\n");
+                return -EINVAL;
+        }
+
+        duty = DIV_ROUND_UP(timebase * duty_ns, period_ns);
+
+        val = img_pwm_readl(pwm_chip, PWM_CTRL_CFG);
+        val &= ~(PWM_CTRL_CFG_DIV_MASK << PWM_CTRL_CFG_DIV_SHIFT(pwm->hwpwm));
+        val |= (div & PWM_CTRL_CFG_DIV_MASK) <<
+                PWM_CTRL_CFG_DIV_SHIFT(pwm->hwpwm);
+        img_pwm_writel(pwm_chip, PWM_CTRL_CFG, val);
+
+        val = (duty << PWM_CH_CFG_DUTY_SHIFT) |
+              (timebase << PWM_CH_CFG_TMBASE_SHIFT);
+        img_pwm_writel(pwm_chip, PWM_CH_CFG(pwm->hwpwm), val);
+
+        return 0;
+}
+
+static int img_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
+{
+        u32 val;
+        struct img_pwm_chip *pwm_chip = to_img_pwm_chip(chip);
+
+        val = img_pwm_readl(pwm_chip, PWM_CTRL_CFG);
+        val |= BIT(pwm->hwpwm);
+        img_pwm_writel(pwm_chip, PWM_CTRL_CFG, val);
+
+        regmap_update_bits(pwm_chip->periph_regs, PERIP_PWM_PDM_CONTROL,
+                           PERIP_PWM_PDM_CONTROL_CH_MASK <<
+                           PERIP_PWM_PDM_CONTROL_CH_SHIFT(pwm->hwpwm), 0);
+
+        return 0;
+}
+
+static void img_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
+{
+        u32 val;
+        struct img_pwm_chip *pwm_chip = to_img_pwm_chip(chip);
+
+        val = img_pwm_readl(pwm_chip, PWM_CTRL_CFG);
+        val &= ~BIT(pwm->hwpwm);
+        img_pwm_writel(pwm_chip, PWM_CTRL_CFG, val);
+}
+
+static const struct pwm_ops img_pwm_ops = {
+        .config = img_pwm_config,
+        .enable = img_pwm_enable,
+        .disable = img_pwm_disable,
+        .owner = THIS_MODULE,
+};
+
+static int img_pwm_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct resource *res;
+        struct img_pwm_chip *pwm;
+
+        pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL);
+        if (!pwm)
+                return -ENOMEM;
+
+        pwm->dev = &pdev->dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        pwm->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(pwm->base))
+                return PTR_ERR(pwm->base);
+
+        pwm->periph_regs = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
+                                                           "img,cr-periph");
+        if (IS_ERR(pwm->periph_regs))
+                return PTR_ERR(pwm->periph_regs);
+
+        pwm->sys_clk = devm_clk_get(&pdev->dev, "sys");
+        if (IS_ERR(pwm->sys_clk)) {
+                dev_err(&pdev->dev, "failed to get system clock\n");
+                return PTR_ERR(pwm->sys_clk);
+        }
+
+        pwm->pwm_clk = devm_clk_get(&pdev->dev, "pwm");
+        if (IS_ERR(pwm->pwm_clk)) {
+                dev_err(&pdev->dev, "failed to get pwm clock\n");
+                return PTR_ERR(pwm->pwm_clk);
+        }
+
+        ret = clk_prepare_enable(pwm->sys_clk);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "could not prepare or enable sys clock\n");
+                return ret;
+        }
+
+        ret = clk_prepare_enable(pwm->pwm_clk);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "could not prepare or enable pwm clock\n");
+                goto disable_sysclk;
+        }
+
+        pwm->chip.dev = &pdev->dev;
+        pwm->chip.ops = &img_pwm_ops;
+        pwm->chip.base = -1;
+        pwm->chip.npwm = 4;
+
+        ret = pwmchip_add(&pwm->chip);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "pwmchip_add failed: %d\n", ret);
+                goto disable_pwmclk;
+        }
+
+        platform_set_drvdata(pdev, pwm);
+        return 0;
+
+disable_pwmclk:
+        clk_disable_unprepare(pwm->pwm_clk);
+disable_sysclk:
+        clk_disable_unprepare(pwm->sys_clk);
+        return ret;
+}
+
+static int img_pwm_remove(struct platform_device *pdev)
+{
+        struct img_pwm_chip *pwm_chip = platform_get_drvdata(pdev);
+        u32 val;
+        unsigned int i;
+
+        for (i = 0; i < pwm_chip->chip.npwm; i++) {
+                val = img_pwm_readl(pwm_chip, PWM_CTRL_CFG);
+                val &= ~BIT(i);
+                img_pwm_writel(pwm_chip, PWM_CTRL_CFG, val);
+        }
+
+        clk_disable_unprepare(pwm_chip->pwm_clk);
+        clk_disable_unprepare(pwm_chip->sys_clk);
+
+        return pwmchip_remove(&pwm_chip->chip);
+}
+
+static const struct of_device_id img_pwm_of_match[] = {
+        { .compatible = "img,pistachio-pwm", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, img_pwm_of_match);
+
+static struct platform_driver img_pwm_driver = {
+        .driver = {
+                .name = "img-pwm",
+                .of_match_table = img_pwm_of_match,
+        },
+        .probe = img_pwm_probe,
+        .remove = img_pwm_remove,
+};
+module_platform_driver(img_pwm_driver);
+
+MODULE_AUTHOR("Sai Masarapu <Sai.Masarapu@imgtec.com>");
+MODULE_DESCRIPTION("Imagination Technologies PWM DAC driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pwm/pwm-sti.c b/drivers/pwm/pwm-sti.c
index b95115cdaea7..92abbd56b9f7 100644
--- a/drivers/pwm/pwm-sti.c
+++ b/drivers/pwm/pwm-sti.c
@@ -57,6 +57,7 @@ struct sti_pwm_chip {
         struct regmap_field *pwm_int_en;
         struct pwm_chip chip;
         struct pwm_device *cur;
+        unsigned long configured;
         unsigned int en_count;
         struct mutex sti_pwm_lock; /* To sync between enable/disable calls */
         void __iomem *mmio;
@@ -102,24 +103,6 @@ static int sti_pwm_get_prescale(struct sti_pwm_chip *pc, unsigned long period,
         return 0;
 }
 
-/* Calculate the number of PWM devices configured with a period. */
-static unsigned int sti_pwm_count_configured(struct pwm_chip *chip)
-{
-        struct pwm_device *pwm;
-        unsigned int ncfg = 0;
-        unsigned int i;
-
-        for (i = 0; i < chip->npwm; i++) {
-                pwm = &chip->pwms[i];
-                if (test_bit(PWMF_REQUESTED, &pwm->flags)) {
-                        if (pwm_get_period(pwm))
-                                ncfg++;
-                }
-        }
-
-        return ncfg;
-}
-
 /*
  * For STiH4xx PWM IP, the PWM period is fixed to 256 local clock cycles.
  * The only way to change the period (apart from changing the PWM input clock)
@@ -141,7 +124,7 @@ static int sti_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
         unsigned int ncfg;
         bool period_same = false;
 
-        ncfg = sti_pwm_count_configured(chip);
+        ncfg = hweight_long(pc->configured);
         if (ncfg)
                 period_same = (period_ns == pwm_get_period(cur));
 
@@ -197,6 +180,7 @@ static int sti_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
 
                 ret = regmap_field_write(pc->pwm_int_en, 0);
 
+                set_bit(pwm->hwpwm, &pc->configured);
                 pc->cur = pwm;
 
                 dev_dbg(dev, "prescale:%u, period:%i, duty:%i, pwmvalx:%u\n",
@@ -254,10 +238,18 @@ static void sti_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
         mutex_unlock(&pc->sti_pwm_lock);
 }
 
+static void sti_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
+{
+        struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
+
+        clear_bit(pwm->hwpwm, &pc->configured);
+}
+
 static const struct pwm_ops sti_pwm_ops = {
         .config = sti_pwm_config,
         .enable = sti_pwm_enable,
         .disable = sti_pwm_disable,
+        .free = sti_pwm_free,
         .owner = THIS_MODULE,
 };
 
diff --git a/drivers/pwm/pwm-sun4i.c b/drivers/pwm/pwm-sun4i.c
new file mode 100644
index 000000000000..cd9dde563018
--- /dev/null
+++ b/drivers/pwm/pwm-sun4i.c
@@ -0,0 +1,366 @@
+/*
+ * Driver for Allwinner sun4i Pulse Width Modulation Controller
+ *
+ * Copyright (C) 2014 Alexandre Belloni <alexandre.belloni@free-electrons.com>
+ *
+ * Licensed under GPLv2.
+ */
+
+#include <linux/bitops.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/pwm.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/time.h>
+
+#define PWM_CTRL_REG            0x0
+
+#define PWM_CH_PRD_BASE         0x4
+#define PWM_CH_PRD_OFFSET       0x4
+#define PWM_CH_PRD(ch)          (PWM_CH_PRD_BASE + PWM_CH_PRD_OFFSET * (ch))
+
+#define PWMCH_OFFSET            15
+#define PWM_PRESCAL_MASK        GENMASK(3, 0)
+#define PWM_PRESCAL_OFF         0
+#define PWM_EN                  BIT(4)
+#define PWM_ACT_STATE           BIT(5)
+#define PWM_CLK_GATING          BIT(6)
+#define PWM_MODE                BIT(7)
+#define PWM_PULSE               BIT(8)
+#define PWM_BYPASS              BIT(9)
+
+#define PWM_RDY_BASE            28
+#define PWM_RDY_OFFSET          1
+#define PWM_RDY(ch)             BIT(PWM_RDY_BASE + PWM_RDY_OFFSET * (ch))
+
+#define PWM_PRD(prd)            (((prd) - 1) << 16)
+#define PWM_PRD_MASK            GENMASK(15, 0)
+
+#define PWM_DTY_MASK            GENMASK(15, 0)
+
+#define BIT_CH(bit, chan)       ((bit) << ((chan) * PWMCH_OFFSET))
+
+static const u32 prescaler_table[] = {
+        120,
+        180,
+        240,
+        360,
+        480,
+        0,
+        0,
+        0,
+        12000,
+        24000,
+        36000,
+        48000,
+        72000,
+        0,
+        0,
+        0, /* Actually 1 but tested separately */
+};
+
+struct sun4i_pwm_data {
+        bool has_prescaler_bypass;
+        bool has_rdy;
+};
+
+struct sun4i_pwm_chip {
+        struct pwm_chip chip;
+        struct clk *clk;
+        void __iomem *base;
+        spinlock_t ctrl_lock;
+        const struct sun4i_pwm_data *data;
+};
+
+static inline struct sun4i_pwm_chip *to_sun4i_pwm_chip(struct pwm_chip *chip)
+{
+        return container_of(chip, struct sun4i_pwm_chip, chip);
+}
+
+static inline u32 sun4i_pwm_readl(struct sun4i_pwm_chip *chip,
+                                  unsigned long offset)
+{
+        return readl(chip->base + offset);
+}
+
+static inline void sun4i_pwm_writel(struct sun4i_pwm_chip *chip,
+                                    u32 val, unsigned long offset)
+{
+        writel(val, chip->base + offset);
+}
+
+static int sun4i_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
+                            int duty_ns, int period_ns)
+{
+        struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
+        u32 prd, dty, val, clk_gate;
+        u64 clk_rate, div = 0;
+        unsigned int prescaler = 0;
+        int err;
+
+        clk_rate = clk_get_rate(sun4i_pwm->clk);
+
+        if (sun4i_pwm->data->has_prescaler_bypass) {
+                /* First, test without any prescaler when available */
+                prescaler = PWM_PRESCAL_MASK;
+                /*
+                 * When not using any prescaler, the clock period in nanoseconds
+                 * is not an integer so round it half up instead of
+                 * truncating to get less surprising values.
+                 */
+                div = clk_rate * period_ns + NSEC_PER_SEC/2;
+                do_div(div, NSEC_PER_SEC);
+                if (div - 1 > PWM_PRD_MASK)
+                        prescaler = 0;
+        }
+
+        if (prescaler == 0) {
+                /* Go up from the first divider */
+                for (prescaler = 0; prescaler < PWM_PRESCAL_MASK; prescaler++) {
+                        if (!prescaler_table[prescaler])
+                                continue;
+                        div = clk_rate;
+                        do_div(div, prescaler_table[prescaler]);
+                        div = div * period_ns;
+                        do_div(div, NSEC_PER_SEC);
+                        if (div - 1 <= PWM_PRD_MASK)
+                                break;
+                }
+
+                if (div - 1 > PWM_PRD_MASK) {
+                        dev_err(chip->dev, "period exceeds the maximum value\n");
+                        return -EINVAL;
+                }
+        }
+
+        prd = div;
+        div *= duty_ns;
+        do_div(div, period_ns);
+        dty = div;
+
+        err = clk_prepare_enable(sun4i_pwm->clk);
+        if (err) {
+                dev_err(chip->dev, "failed to enable PWM clock\n");
+                return err;
+        }
+
+        spin_lock(&sun4i_pwm->ctrl_lock);
+        val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
+
+        if (sun4i_pwm->data->has_rdy && (val & PWM_RDY(pwm->hwpwm))) {
+                spin_unlock(&sun4i_pwm->ctrl_lock);
+                clk_disable_unprepare(sun4i_pwm->clk);
+                return -EBUSY;
+        }
+
+        clk_gate = val & BIT_CH(PWM_CLK_GATING, pwm->hwpwm);
+        if (clk_gate) {
+                val &= ~BIT_CH(PWM_CLK_GATING, pwm->hwpwm);
+                sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
+        }
+
+        val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
+        val &= ~BIT_CH(PWM_PRESCAL_MASK, pwm->hwpwm);
+        val |= BIT_CH(prescaler, pwm->hwpwm);
+        sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
+
+        val = (dty & PWM_DTY_MASK) | PWM_PRD(prd);
+        sun4i_pwm_writel(sun4i_pwm, val, PWM_CH_PRD(pwm->hwpwm));
+
+        if (clk_gate) {
+                val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
+                val |= clk_gate;
+                sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
+        }
+
+        spin_unlock(&sun4i_pwm->ctrl_lock);
+        clk_disable_unprepare(sun4i_pwm->clk);
+
+        return 0;
+}
+
+static int sun4i_pwm_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,
+                                  enum pwm_polarity polarity)
+{
+        struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
+        u32 val;
+        int ret;
+
+        ret = clk_prepare_enable(sun4i_pwm->clk);
+        if (ret) {
+                dev_err(chip->dev, "failed to enable PWM clock\n");
+                return ret;
+        }
+
+        spin_lock(&sun4i_pwm->ctrl_lock);
+        val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
+
+        if (polarity != PWM_POLARITY_NORMAL)
+                val &= ~BIT_CH(PWM_ACT_STATE, pwm->hwpwm);
+        else
+                val |= BIT_CH(PWM_ACT_STATE, pwm->hwpwm);
+
+        sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
+
+        spin_unlock(&sun4i_pwm->ctrl_lock);
+        clk_disable_unprepare(sun4i_pwm->clk);
+
+        return 0;
+}
+
+static int sun4i_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
+{
+        struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
+        u32 val;
+        int ret;
+
+        ret = clk_prepare_enable(sun4i_pwm->clk);
+        if (ret) {
+                dev_err(chip->dev, "failed to enable PWM clock\n");
+                return ret;
+        }
+
+        spin_lock(&sun4i_pwm->ctrl_lock);
+        val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
+        val |= BIT_CH(PWM_EN, pwm->hwpwm);
+        val |= BIT_CH(PWM_CLK_GATING, pwm->hwpwm);
+        sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
+        spin_unlock(&sun4i_pwm->ctrl_lock);
+
+        return 0;
+}
+
+static void sun4i_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
+{
+        struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
+        u32 val;
+
+        spin_lock(&sun4i_pwm->ctrl_lock);
+        val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
+        val &= ~BIT_CH(PWM_EN, pwm->hwpwm);
+        val &= ~BIT_CH(PWM_CLK_GATING, pwm->hwpwm);
+        sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
+        spin_unlock(&sun4i_pwm->ctrl_lock);
+
+        clk_disable_unprepare(sun4i_pwm->clk);
+}
+
+static const struct pwm_ops sun4i_pwm_ops = {
+        .config = sun4i_pwm_config,
+        .set_polarity = sun4i_pwm_set_polarity,
+        .enable = sun4i_pwm_enable,
+        .disable = sun4i_pwm_disable,
+        .owner = THIS_MODULE,
+};
+
+static const struct sun4i_pwm_data sun4i_pwm_data_a10 = {
+        .has_prescaler_bypass = false,
+        .has_rdy = false,
+};
+
+static const struct sun4i_pwm_data sun4i_pwm_data_a20 = {
+        .has_prescaler_bypass = true,
+        .has_rdy = true,
+};
+
+static const struct of_device_id sun4i_pwm_dt_ids[] = {
+        {
+                .compatible = "allwinner,sun4i-a10-pwm",
+                .data = &sun4i_pwm_data_a10,
+        }, {
+                .compatible = "allwinner,sun7i-a20-pwm",
+                .data = &sun4i_pwm_data_a20,
+        }, {
+                /* sentinel */
+        },
+};
+MODULE_DEVICE_TABLE(of, sun4i_pwm_dt_ids);
+
+static int sun4i_pwm_probe(struct platform_device *pdev)
+{
+        struct sun4i_pwm_chip *pwm;
+        struct resource *res;
+        u32 val;
+        int i, ret;
+        const struct of_device_id *match;
+
+        match = of_match_device(sun4i_pwm_dt_ids, &pdev->dev);
+
+        pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL);
+        if (!pwm)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        pwm->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(pwm->base))
+                return PTR_ERR(pwm->base);
+
+        pwm->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(pwm->clk))
+                return PTR_ERR(pwm->clk);
+
+        pwm->chip.dev = &pdev->dev;
+        pwm->chip.ops = &sun4i_pwm_ops;
+        pwm->chip.base = -1;
+        pwm->chip.npwm = 2;
+        pwm->chip.can_sleep = true;
+        pwm->chip.of_xlate = of_pwm_xlate_with_flags;
+        pwm->chip.of_pwm_n_cells = 3;
+        pwm->data = match->data;
+
+        spin_lock_init(&pwm->ctrl_lock);
+
+        ret = pwmchip_add(&pwm->chip);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "failed to add PWM chip: %d\n", ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, pwm);
+
+        ret = clk_prepare_enable(pwm->clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable PWM clock\n");
+                goto clk_error;
+        }
+
+        val = sun4i_pwm_readl(pwm, PWM_CTRL_REG);
+        for (i = 0; i < pwm->chip.npwm; i++)
+                if (!(val & BIT_CH(PWM_ACT_STATE, i)))
+                        pwm->chip.pwms[i].polarity = PWM_POLARITY_INVERSED;
+        clk_disable_unprepare(pwm->clk);
+
+        return 0;
+
+clk_error:
+        pwmchip_remove(&pwm->chip);
+        return ret;
+}
+
+static int sun4i_pwm_remove(struct platform_device *pdev)
+{
+        struct sun4i_pwm_chip *pwm = platform_get_drvdata(pdev);
+
+        return pwmchip_remove(&pwm->chip);
+}
+
+static struct platform_driver sun4i_pwm_driver = {
+        .driver = {
+                .name = "sun4i-pwm",
+                .of_match_table = sun4i_pwm_dt_ids,
+        },
+        .probe = sun4i_pwm_probe,
+        .remove = sun4i_pwm_remove,
+};
+module_platform_driver(sun4i_pwm_driver);
+
+MODULE_ALIAS("platform:sun4i-pwm");
+MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>");
+MODULE_DESCRIPTION("Allwinner sun4i PWM driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pwm/pwm-tegra.c b/drivers/pwm/pwm-tegra.c
index 5b97cae5423a..cabd7d8e05cc 100644
--- a/drivers/pwm/pwm-tegra.c
+++ b/drivers/pwm/pwm-tegra.c
@@ -87,7 +87,7 @@ static int tegra_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
          * cycles at the PWM clock rate will take period_ns nanoseconds.
          */
         rate = clk_get_rate(pc->clk) >> PWM_DUTY_WIDTH;
-        hz = 1000000000ul / period_ns;
+        hz = NSEC_PER_SEC / period_ns;
 
         rate = (rate + (hz / 2)) / hz;
 
diff --git a/drivers/rapidio/devices/tsi721_dma.c b/drivers/rapidio/devices/tsi721_dma.c
index f64c5decb747..47295940a868 100644
--- a/drivers/rapidio/devices/tsi721_dma.c
+++ b/drivers/rapidio/devices/tsi721_dma.c
@@ -815,8 +815,7 @@ struct dma_async_tx_descriptor *tsi721_prep_rio_sg(struct dma_chan *dchan,
         return txd;
 }
 
-static int tsi721_device_control(struct dma_chan *dchan, enum dma_ctrl_cmd cmd,
-                             unsigned long arg)
+static int tsi721_terminate_all(struct dma_chan *dchan)
 {
         struct tsi721_bdma_chan *bdma_chan = to_tsi721_chan(dchan);
         struct tsi721_tx_desc *desc, *_d;
@@ -825,9 +824,6 @@ static int tsi721_device_control(struct dma_chan *dchan, enum dma_ctrl_cmd cmd,
 
         dev_dbg(dchan->device->dev, "%s: Entry\n", __func__);
 
-        if (cmd != DMA_TERMINATE_ALL)
-                return -ENOSYS;
-
         spin_lock_bh(&bdma_chan->lock);
 
         bdma_chan->active = false;
@@ -901,7 +897,7 @@ int tsi721_register_dma(struct tsi721_device *priv)
         mport->dma.device_tx_status = tsi721_tx_status;
         mport->dma.device_issue_pending = tsi721_issue_pending;
         mport->dma.device_prep_slave_sg = tsi721_prep_rio_sg;
-        mport->dma.device_control = tsi721_device_control;
+        mport->dma.device_terminate_all = tsi721_terminate_all;
 
         err = dma_async_device_register(&mport->dma);
         if (err)
diff --git a/drivers/regulator/qcom_rpm-regulator.c b/drivers/regulator/qcom_rpm-regulator.c
index e8647f7cf25e..00c5cc3d9546 100644
--- a/drivers/regulator/qcom_rpm-regulator.c
+++ b/drivers/regulator/qcom_rpm-regulator.c
@@ -205,6 +205,7 @@ static int rpm_reg_write(struct qcom_rpm_reg *vreg,
         vreg->val[req->word] |= value << req->shift;
 
         return qcom_rpm_write(vreg->rpm,
+                              QCOM_RPM_ACTIVE_STATE,
                               vreg->resource,
                               vreg->val,
                               vreg->parts->request_len);
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index cedb41c95dae..b5b5c3d485d6 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -65,7 +65,7 @@ config RTC_DEBUG
 comment "RTC interfaces"
 
 config RTC_INTF_SYSFS
-        boolean "/sys/class/rtc/rtcN (sysfs)"
+        bool "/sys/class/rtc/rtcN (sysfs)"
         depends on SYSFS
         default RTC_CLASS
         help
@@ -75,7 +75,7 @@ config RTC_INTF_SYSFS
           If unsure, say Y.
 
 config RTC_INTF_PROC
-        boolean "/proc/driver/rtc (procfs for rtcN)"
+        bool "/proc/driver/rtc (procfs for rtcN)"
         depends on PROC_FS
         default RTC_CLASS
         help
@@ -88,7 +88,7 @@ config RTC_INTF_PROC
           If unsure, say Y.
 
 config RTC_INTF_DEV
-        boolean "/dev/rtcN (character devices)"
+        bool "/dev/rtcN (character devices)"
         default RTC_CLASS
         help
           Say yes here if you want to use your RTCs using the /dev
@@ -466,7 +466,7 @@ config RTC_DRV_DM355EVM
           Supports the RTC firmware in the MSP430 on the DM355 EVM.
 
 config RTC_DRV_TWL92330
-        boolean "TI TWL92330/Menelaus"
+        bool "TI TWL92330/Menelaus"
         depends on MENELAUS
         help
           If you say yes here you get support for the RTC on the
diff --git a/drivers/rtc/rtc-ds1685.c b/drivers/rtc/rtc-ds1685.c
index 8c3bfcb115b7..803869c7d7c2 100644
--- a/drivers/rtc/rtc-ds1685.c
+++ b/drivers/rtc/rtc-ds1685.c
@@ -399,21 +399,21 @@ ds1685_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
          * of this RTC chip.  We check for it anyways in case support is
          * added in the future.
          */
-        if (unlikely((seconds >= 0xc0) && (seconds <= 0xff)))
+        if (unlikely(seconds >= 0xc0))
                 alrm->time.tm_sec = -1;
         else
                 alrm->time.tm_sec = ds1685_rtc_bcd2bin(rtc, seconds,
                                                        RTC_SECS_BCD_MASK,
                                                        RTC_SECS_BIN_MASK);
 
-        if (unlikely((minutes >= 0xc0) && (minutes <= 0xff)))
+        if (unlikely(minutes >= 0xc0))
                 alrm->time.tm_min = -1;
         else
                 alrm->time.tm_min = ds1685_rtc_bcd2bin(rtc, minutes,
                                                        RTC_MINS_BCD_MASK,
                                                        RTC_MINS_BIN_MASK);
 
-        if (unlikely((hours >= 0xc0) && (hours <= 0xff)))
+        if (unlikely(hours >= 0xc0))
                 alrm->time.tm_hour = -1;
         else
                 alrm->time.tm_hour = ds1685_rtc_bcd2bin(rtc, hours,
@@ -472,13 +472,13 @@ ds1685_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
          * field, and we only support four fields.  We put the support
          * here anyways for the future.
          */
-        if (unlikely((seconds >= 0xc0) && (seconds <= 0xff)))
+        if (unlikely(seconds >= 0xc0))
                 seconds = 0xff;
 
-        if (unlikely((minutes >= 0xc0) && (minutes <= 0xff)))
+        if (unlikely(minutes >= 0xc0))
                 minutes = 0xff;
 
-        if (unlikely((hours >= 0xc0) && (hours <= 0xff)))
+        if (unlikely(hours >= 0xc0))
                 hours = 0xff;
 
         alrm->time.tm_mon       = -1;
@@ -528,7 +528,6 @@ ds1685_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 /* ----------------------------------------------------------------------- */
 /* /dev/rtcX Interface functions */
 
-#ifdef CONFIG_RTC_INTF_DEV
 /**
  * ds1685_rtc_alarm_irq_enable - replaces ioctl() RTC_AIE on/off.
  * @dev: pointer to device structure.
@@ -557,7 +556,6 @@ ds1685_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 
         return 0;
 }
-#endif
 /* ----------------------------------------------------------------------- */
 
 
@@ -1612,7 +1610,7 @@ ds1685_rtc_sysfs_time_regs_show(struct device *dev,
                 ds1685_rtc_sysfs_time_regs_lookup(attr->attr.name, false);
 
         /* Make sure we actually matched something. */
-        if (!bcd_reg_info && !bin_reg_info)
+        if (!bcd_reg_info || !bin_reg_info)
                 return -EINVAL;
 
         /* bcd_reg_info->reg == bin_reg_info->reg. */
@@ -1650,7 +1648,7 @@ ds1685_rtc_sysfs_time_regs_store(struct device *dev,
                 return -EINVAL;
 
         /* Make sure we actually matched something. */
-        if (!bcd_reg_info && !bin_reg_info)
+        if (!bcd_reg_info || !bin_reg_info)
                 return -EINVAL;
 
         /* Check for a valid range. */
diff --git a/drivers/scsi/am53c974.c b/drivers/scsi/am53c974.c
index aa3e2c7cd83c..a6f5ee80fadc 100644
--- a/drivers/scsi/am53c974.c
+++ b/drivers/scsi/am53c974.c
@@ -178,12 +178,6 @@ static void pci_esp_dma_drain(struct esp *esp)
                         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
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 96241b20fd2c..a7cc61837818 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -585,7 +585,6 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
                         "beiscsi_hba_alloc - iscsi_host_alloc failed\n");
                 return NULL;
         }
-        shost->dma_boundary = pcidev->dma_mask;
         shost->max_id = BE2_MAX_SESSIONS;
         shost->max_channel = 0;
         shost->max_cmd_len = BEISCSI_MAX_CMD_LEN;
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 95d581c45413..a1cfbd3dda47 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -6831,10 +6831,8 @@ static struct workqueue_struct *hpsa_create_controller_wq(struct ctlr_info *h,
                                                 char *name)
 {
         struct workqueue_struct *wq = NULL;
-        char wq_name[20];
 
-        snprintf(wq_name, sizeof(wq_name), "%s_%d_hpsa", name, h->ctlr);
-        wq = alloc_ordered_workqueue(wq_name, 0);
+        wq = alloc_ordered_workqueue("%s_%d_hpsa", 0, name, h->ctlr);
         if (!wq)
                 dev_err(&h->pdev->dev, "failed to create %s workqueue\n", name);
 
diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
index 73f9feecda72..99f43b7fc9ab 100644
--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c
+++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
@@ -1570,9 +1570,7 @@ static int tcm_qla2xxx_check_initiator_node_acl(
          * match the format by tcm_qla2xxx explict ConfigFS NodeACLs.
          */
         memset(&port_name, 0, 36);
-        snprintf(port_name, 36, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
-                fc_wwpn[0], fc_wwpn[1], fc_wwpn[2], fc_wwpn[3], fc_wwpn[4],
-                fc_wwpn[5], fc_wwpn[6], fc_wwpn[7]);
+        snprintf(port_name, sizeof(port_name), "%8phC", fc_wwpn);
         /*
          * Locate our struct se_node_acl either from an explict NodeACL created
          * via ConfigFS, or via running in TPG demo mode.
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 0cbc1fb45f10..2270bd51f9c2 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -546,7 +546,7 @@ static ssize_t
 sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
 {
         sg_io_hdr_t *hp = &srp->header;
-        int err = 0;
+        int err = 0, err2;
         int len;
 
         if (count < SZ_SG_IO_HDR) {
@@ -575,8 +575,8 @@ sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
                 goto err_out;
         }
 err_out:
-        err = sg_finish_rem_req(srp);
-        return (0 == err) ? count : err;
+        err2 = sg_finish_rem_req(srp);
+        return err ? : err2 ? : count;
 }
 
 static ssize_t
@@ -1335,6 +1335,17 @@ sg_rq_end_io(struct request *rq, int uptodate)
         }
         /* Rely on write phase to clean out srp status values, so no "else" */
 
+        /*
+         * Free the request as soon as it is complete so that its resources
+         * can be reused without waiting for userspace to read() the
+         * result.  But keep the associated bio (if any) around until
+         * blk_rq_unmap_user() can be called from user context.
+         */
+        srp->rq = NULL;
+        if (rq->cmd != rq->__cmd)
+                kfree(rq->cmd);
+        __blk_put_request(rq->q, rq);
+
         write_lock_irqsave(&sfp->rq_list_lock, iflags);
         if (unlikely(srp->orphan)) {
                 if (sfp->keep_orphan)
@@ -1669,7 +1680,22 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
                         return -ENOMEM;
         }
 
-        rq = blk_get_request(q, rw, GFP_ATOMIC);
+        /*
+         * NOTE
+         *
+         * With scsi-mq enabled, there are a fixed number of preallocated
+         * requests equal in number to shost->can_queue.  If all of the
+         * preallocated requests are already in use, then using GFP_ATOMIC with
+         * blk_get_request() will return -EWOULDBLOCK, whereas using GFP_KERNEL
+         * will cause blk_get_request() to sleep until an active command
+         * completes, freeing up a request.  Neither option is ideal, but
+         * GFP_KERNEL is the better choice to prevent userspace from getting an
+         * unexpected EWOULDBLOCK.
+         *
+         * With scsi-mq disabled, blk_get_request() with GFP_KERNEL usually
+         * does not sleep except under memory pressure.
+         */
+        rq = blk_get_request(q, rw, GFP_KERNEL);
         if (IS_ERR(rq)) {
                 kfree(long_cmdp);
                 return PTR_ERR(rq);
@@ -1759,10 +1785,10 @@ sg_finish_rem_req(Sg_request *srp)
         SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
                                       "sg_finish_rem_req: res_used=%d\n",
                                       (int) srp->res_used));
-        if (srp->rq) {
-                if (srp->bio)
-                        ret = blk_rq_unmap_user(srp->bio);
+        if (srp->bio)
+                ret = blk_rq_unmap_user(srp->bio);
 
+        if (srp->rq) {
                 if (srp->rq->cmd != srp->rq->__cmd)
                         kfree(srp->rq->cmd);
                 blk_put_request(srp->rq);
diff --git a/drivers/scsi/virtio_scsi.c b/drivers/scsi/virtio_scsi.c
index c52bb5dfaedb..f164f24a4a55 100644
--- a/drivers/scsi/virtio_scsi.c
+++ b/drivers/scsi/virtio_scsi.c
@@ -950,6 +950,12 @@ static int virtscsi_probe(struct virtio_device *vdev)
         u32 num_queues;
         struct scsi_host_template *hostt;
 
+        if (!vdev->config->get) {
+                dev_err(&vdev->dev, "%s failure: config access disabled\n",
+                        __func__);
+                return -EINVAL;
+        }
+
         /* We need to know how many queues before we allocate. */
         num_queues = virtscsi_config_get(vdev, num_queues) ? : 1;
 
diff --git a/drivers/scsi/wd719x.c b/drivers/scsi/wd719x.c
index 7702664d7ed3..289ad016d925 100644
--- a/drivers/scsi/wd719x.c
+++ b/drivers/scsi/wd719x.c
@@ -870,6 +870,7 @@ fail_free_params:
 }
 
 static struct scsi_host_template wd719x_template = {
+        .module                         = THIS_MODULE,
         .name                           = "Western Digital 719x",
         .queuecommand                   = wd719x_queuecommand,
         .eh_abort_handler               = wd719x_abort,
diff --git a/drivers/sh/pm_runtime.c b/drivers/sh/pm_runtime.c
index f3ee439d6f0e..cd4c293f0dd0 100644
--- a/drivers/sh/pm_runtime.c
+++ b/drivers/sh/pm_runtime.c
@@ -81,7 +81,9 @@ static int __init sh_pm_runtime_init(void)
                 if (!of_machine_is_compatible("renesas,emev2") &&
                     !of_machine_is_compatible("renesas,r7s72100") &&
                     !of_machine_is_compatible("renesas,r8a73a4") &&
+#ifndef CONFIG_PM_GENERIC_DOMAINS_OF
                     !of_machine_is_compatible("renesas,r8a7740") &&
+#endif
                     !of_machine_is_compatible("renesas,r8a7778") &&
                     !of_machine_is_compatible("renesas,r8a7779") &&
                     !of_machine_is_compatible("renesas,r8a7790") &&
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 95ccedabba4f..ab8dfbef6f1b 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -29,7 +29,7 @@ menuconfig SPI
 if SPI
 
 config SPI_DEBUG
-        boolean "Debug support for SPI drivers"
+        bool "Debug support for SPI drivers"
         depends on DEBUG_KERNEL
         help
           Say "yes" to enable debug messaging (like dev_dbg and pr_debug),
@@ -40,8 +40,8 @@ config SPI_DEBUG
 #
 
 config SPI_MASTER
-#       boolean "SPI Master Support"
-        boolean
+#       bool "SPI Master Support"
+        bool
         default SPI
         help
           If your system has an master-capable SPI controller (which
diff --git a/drivers/staging/board/Kconfig b/drivers/staging/board/Kconfig
index 7eda0b8b7aab..0a89ad16371f 100644
--- a/drivers/staging/board/Kconfig
+++ b/drivers/staging/board/Kconfig
@@ -1,5 +1,5 @@
 config STAGING_BOARD
-        boolean "Staging Board Support"
+        bool "Staging Board Support"
         depends on OF_ADDRESS
         depends on BROKEN
         help
diff --git a/drivers/staging/emxx_udc/Kconfig b/drivers/staging/emxx_udc/Kconfig
index 9bc6d3db86d9..cc3402020487 100644
--- a/drivers/staging/emxx_udc/Kconfig
+++ b/drivers/staging/emxx_udc/Kconfig
@@ -1,5 +1,5 @@
 config USB_EMXX
-        boolean "EMXX USB Function Device Controller"
+        bool "EMXX USB Function Device Controller"
         depends on USB_GADGET && (ARCH_SHMOBILE || (ARM && COMPILE_TEST))
         help
            The Emma Mobile series of SoCs from Renesas Electronics and
diff --git a/drivers/staging/iio/Kconfig b/drivers/staging/iio/Kconfig
index fa38be0982f9..24183028bd71 100644
--- a/drivers/staging/iio/Kconfig
+++ b/drivers/staging/iio/Kconfig
@@ -30,13 +30,13 @@ config IIO_SIMPLE_DUMMY
 if IIO_SIMPLE_DUMMY
 
 config IIO_SIMPLE_DUMMY_EVENTS
-       boolean "Event generation support"
+       bool "Event generation support"
        select IIO_DUMMY_EVGEN
        help
          Add some dummy events to the simple dummy driver.
 
 config IIO_SIMPLE_DUMMY_BUFFER
-        boolean "Buffered capture support"
+        bool "Buffered capture support"
         select IIO_BUFFER
         select IIO_KFIFO_BUF
         help
diff --git a/drivers/staging/lustre/lustre/llite/dcache.c b/drivers/staging/lustre/lustre/llite/dcache.c
index 88614b71cf6d..ddf1fa9f67f8 100644
--- a/drivers/staging/lustre/lustre/llite/dcache.c
+++ b/drivers/staging/lustre/lustre/llite/dcache.c
@@ -270,7 +270,7 @@ void ll_invalidate_aliases(struct inode *inode)
 
 int ll_revalidate_it_finish(struct ptlrpc_request *request,
                             struct lookup_intent *it,
-                            struct dentry *de)
+                            struct inode *inode)
 {
         int rc = 0;
 
@@ -280,19 +280,17 @@ int ll_revalidate_it_finish(struct ptlrpc_request *request,
         if (it_disposition(it, DISP_LOOKUP_NEG))
                 return -ENOENT;
 
-        rc = ll_prep_inode(&de->d_inode, request, NULL, it);
+        rc = ll_prep_inode(&inode, request, NULL, it);
 
         return rc;
 }
 
-void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry)
+void ll_lookup_finish_locks(struct lookup_intent *it, struct inode *inode)
 {
         LASSERT(it != NULL);
-        LASSERT(dentry != NULL);
 
-        if (it->d.lustre.it_lock_mode && dentry->d_inode != NULL) {
-                struct inode *inode = dentry->d_inode;
-                struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
+        if (it->d.lustre.it_lock_mode && inode != NULL) {
+                struct ll_sb_info *sbi = ll_i2sbi(inode);
 
                 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
                        inode, inode->i_ino, inode->i_generation);
diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index 7c7ef7ec908e..5ebee6ca0a10 100644
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -2912,8 +2912,8 @@ static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
                         oit.it_op = IT_LOOKUP;
 
                 /* Call getattr by fid, so do not provide name at all. */
-                op_data = ll_prep_md_op_data(NULL, dentry->d_inode,
-                                             dentry->d_inode, NULL, 0, 0,
+                op_data = ll_prep_md_op_data(NULL, inode,
+                                             inode, NULL, 0, 0,
                                              LUSTRE_OPC_ANY, NULL);
                 if (IS_ERR(op_data))
                         return PTR_ERR(op_data);
@@ -2931,7 +2931,7 @@ static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
                         goto out;
                 }
 
-                rc = ll_revalidate_it_finish(req, &oit, dentry);
+                rc = ll_revalidate_it_finish(req, &oit, inode);
                 if (rc != 0) {
                         ll_intent_release(&oit);
                         goto out;
@@ -2944,7 +2944,7 @@ static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
                 if (!dentry->d_inode->i_nlink)
                         d_lustre_invalidate(dentry, 0);
 
-                ll_lookup_finish_locks(&oit, dentry);
+                ll_lookup_finish_locks(&oit, inode);
         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
                 u64 valid = OBD_MD_FLGETATTR;
diff --git a/drivers/staging/lustre/lustre/llite/llite_internal.h b/drivers/staging/lustre/lustre/llite/llite_internal.h
index d032c2b086cc..2af1d7286250 100644
--- a/drivers/staging/lustre/lustre/llite/llite_internal.h
+++ b/drivers/staging/lustre/lustre/llite/llite_internal.h
@@ -786,9 +786,9 @@ extern const struct dentry_operations ll_d_ops;
 void ll_intent_drop_lock(struct lookup_intent *);
 void ll_intent_release(struct lookup_intent *);
 void ll_invalidate_aliases(struct inode *);
-void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry);
+void ll_lookup_finish_locks(struct lookup_intent *it, struct inode *inode);
 int ll_revalidate_it_finish(struct ptlrpc_request *request,
-                            struct lookup_intent *it, struct dentry *de);
+                            struct lookup_intent *it, struct inode *inode);
 
 /* llite/llite_lib.c */
 extern struct super_operations lustre_super_operations;
diff --git a/drivers/staging/lustre/lustre/llite/namei.c b/drivers/staging/lustre/lustre/llite/namei.c
index 4f361b77c749..890ac190f5fa 100644
--- a/drivers/staging/lustre/lustre/llite/namei.c
+++ b/drivers/staging/lustre/lustre/llite/namei.c
@@ -481,6 +481,7 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
         struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
         struct dentry *save = dentry, *retval;
         struct ptlrpc_request *req = NULL;
+        struct inode *inode;
         struct md_op_data *op_data;
         __u32 opc;
         int rc;
@@ -539,12 +540,13 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
                 goto out;
         }
 
-        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->d_inode, it);
+        inode = dentry->d_inode;
+        if ((it->it_op & IT_OPEN) && inode &&
+            !S_ISREG(inode->i_mode) &&
+            !S_ISDIR(inode->i_mode)) {
+                ll_release_openhandle(inode, it);
         }
-        ll_lookup_finish_locks(it, dentry);
+        ll_lookup_finish_locks(it, inode);
 
         if (dentry == save)
                 retval = NULL;
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index aebde3289c50..50bad55a0c42 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -30,7 +30,7 @@
 #include <target/target_core_fabric.h>
 #include <target/target_core_configfs.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_parameters.h"
 #include "iscsi_target_seq_pdu_list.h"
 #include "iscsi_target_tq.h"
@@ -45,7 +45,7 @@
 #include "iscsi_target_util.h"
 #include "iscsi_target.h"
 #include "iscsi_target_device.h"
-#include "iscsi_target_stat.h"
+#include <target/iscsi/iscsi_target_stat.h>
 
 #include <target/iscsi/iscsi_transport.h>
 
@@ -968,11 +968,7 @@ int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
 
         conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
         if (hdr->flags & ISCSI_FLAG_CMD_READ) {
-                spin_lock_bh(&conn->sess->ttt_lock);
-                cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++;
-                if (cmd->targ_xfer_tag == 0xFFFFFFFF)
-                        cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++;
-                spin_unlock_bh(&conn->sess->ttt_lock);
+                cmd->targ_xfer_tag = session_get_next_ttt(conn->sess);
         } else if (hdr->flags & ISCSI_FLAG_CMD_WRITE)
                 cmd->targ_xfer_tag = 0xFFFFFFFF;
         cmd->cmd_sn             = be32_to_cpu(hdr->cmdsn);
@@ -1998,6 +1994,7 @@ iscsit_setup_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
         cmd->cmd_sn             = be32_to_cpu(hdr->cmdsn);
         cmd->exp_stat_sn        = be32_to_cpu(hdr->exp_statsn);
         cmd->data_direction     = DMA_NONE;
+        cmd->text_in_ptr        = NULL;
 
         return 0;
 }
@@ -2011,9 +2008,13 @@ iscsit_process_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
         int cmdsn_ret;
 
         if (!text_in) {
-                pr_err("Unable to locate text_in buffer for sendtargets"
-                       " discovery\n");
-                goto reject;
+                cmd->targ_xfer_tag = be32_to_cpu(hdr->ttt);
+                if (cmd->targ_xfer_tag == 0xFFFFFFFF) {
+                        pr_err("Unable to locate text_in buffer for sendtargets"
+                               " discovery\n");
+                        goto reject;
+                }
+                goto empty_sendtargets;
         }
         if (strncmp("SendTargets", text_in, 11) != 0) {
                 pr_err("Received Text Data that is not"
@@ -2040,6 +2041,7 @@ iscsit_process_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
         list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
         spin_unlock_bh(&conn->cmd_lock);
 
+empty_sendtargets:
         iscsit_ack_from_expstatsn(conn, be32_to_cpu(hdr->exp_statsn));
 
         if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
@@ -3047,11 +3049,7 @@ static int iscsit_send_r2t(
         int_to_scsilun(cmd->se_cmd.orig_fe_lun,
                         (struct scsi_lun *)&hdr->lun);
         hdr->itt                = cmd->init_task_tag;
-        spin_lock_bh(&conn->sess->ttt_lock);
-        r2t->targ_xfer_tag      = conn->sess->targ_xfer_tag++;
-        if (r2t->targ_xfer_tag == 0xFFFFFFFF)
-                r2t->targ_xfer_tag = conn->sess->targ_xfer_tag++;
-        spin_unlock_bh(&conn->sess->ttt_lock);
+        r2t->targ_xfer_tag      = session_get_next_ttt(conn->sess);
         hdr->ttt                = cpu_to_be32(r2t->targ_xfer_tag);
         hdr->statsn             = cpu_to_be32(conn->stat_sn);
         hdr->exp_cmdsn          = cpu_to_be32(conn->sess->exp_cmd_sn);
@@ -3393,7 +3391,8 @@ static bool iscsit_check_inaddr_any(struct iscsi_np *np)
 
 static int
 iscsit_build_sendtargets_response(struct iscsi_cmd *cmd,
-                                  enum iscsit_transport_type network_transport)
+                                  enum iscsit_transport_type network_transport,
+                                  int skip_bytes, bool *completed)
 {
         char *payload = NULL;
         struct iscsi_conn *conn = cmd->conn;
@@ -3405,7 +3404,7 @@ iscsit_build_sendtargets_response(struct iscsi_cmd *cmd,
         unsigned char buf[ISCSI_IQN_LEN+12]; /* iqn + "TargetName=" + \0 */
         unsigned char *text_in = cmd->text_in_ptr, *text_ptr = NULL;
 
-        buffer_len = max(conn->conn_ops->MaxRecvDataSegmentLength,
+        buffer_len = min(conn->conn_ops->MaxRecvDataSegmentLength,
                          SENDTARGETS_BUF_LIMIT);
 
         payload = kzalloc(buffer_len, GFP_KERNEL);
@@ -3484,9 +3483,16 @@ iscsit_build_sendtargets_response(struct iscsi_cmd *cmd,
                                                 end_of_buf = 1;
                                                 goto eob;
                                         }
-                                        memcpy(payload + payload_len, buf, len);
-                                        payload_len += len;
-                                        target_name_printed = 1;
+
+                                        if (skip_bytes && len <= skip_bytes) {
+                                                skip_bytes -= len;
+                                        } else {
+                                                memcpy(payload + payload_len, buf, len);
+                                                payload_len += len;
+                                                target_name_printed = 1;
+                                                if (len > skip_bytes)
+                                                        skip_bytes = 0;
+                                        }
                                 }
 
                                 len = sprintf(buf, "TargetAddress="
@@ -3502,15 +3508,24 @@ iscsit_build_sendtargets_response(struct iscsi_cmd *cmd,
                                         end_of_buf = 1;
                                         goto eob;
                                 }
-                                memcpy(payload + payload_len, buf, len);
-                                payload_len += len;
+
+                                if (skip_bytes && len <= skip_bytes) {
+                                        skip_bytes -= len;
+                                } else {
+                                        memcpy(payload + payload_len, buf, len);
+                                        payload_len += len;
+                                        if (len > skip_bytes)
+                                                skip_bytes = 0;
+                                }
                         }
                         spin_unlock(&tpg->tpg_np_lock);
                 }
                 spin_unlock(&tiqn->tiqn_tpg_lock);
 eob:
-                if (end_of_buf)
+                if (end_of_buf) {
+                        *completed = false;
                         break;
+                }
 
                 if (cmd->cmd_flags & ICF_SENDTARGETS_SINGLE)
                         break;
@@ -3528,13 +3543,23 @@ iscsit_build_text_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
                       enum iscsit_transport_type network_transport)
 {
         int text_length, padding;
+        bool completed = true;
 
-        text_length = iscsit_build_sendtargets_response(cmd, network_transport);
+        text_length = iscsit_build_sendtargets_response(cmd, network_transport,
+                                                        cmd->read_data_done,
+                                                        &completed);
         if (text_length < 0)
                 return text_length;
 
+        if (completed) {
+                hdr->flags |= ISCSI_FLAG_CMD_FINAL;
+        } else {
+                hdr->flags |= ISCSI_FLAG_TEXT_CONTINUE;
+                cmd->read_data_done += text_length;
+                if (cmd->targ_xfer_tag == 0xFFFFFFFF)
+                        cmd->targ_xfer_tag = session_get_next_ttt(conn->sess);
+        }
         hdr->opcode = ISCSI_OP_TEXT_RSP;
-        hdr->flags |= ISCSI_FLAG_CMD_FINAL;
         padding = ((-text_length) & 3);
         hton24(hdr->dlength, text_length);
         hdr->itt = cmd->init_task_tag;
@@ -3543,21 +3568,25 @@ iscsit_build_text_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
         hdr->statsn = cpu_to_be32(cmd->stat_sn);
 
         iscsit_increment_maxcmdsn(cmd, conn->sess);
+        /*
+         * Reset maxcmdsn_inc in multi-part text payload exchanges to
+         * correctly increment MaxCmdSN for each response answering a
+         * non immediate text request with a valid CmdSN.
+         */
+        cmd->maxcmdsn_inc = 0;
         hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn);
         hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn);
 
-        pr_debug("Built Text Response: ITT: 0x%08x, StatSN: 0x%08x,"
-                " Length: %u, CID: %hu\n", cmd->init_task_tag, cmd->stat_sn,
-                text_length, conn->cid);
+        pr_debug("Built Text Response: ITT: 0x%08x, TTT: 0x%08x, StatSN: 0x%08x,"
+                " Length: %u, CID: %hu F: %d C: %d\n", cmd->init_task_tag,
+                cmd->targ_xfer_tag, cmd->stat_sn, text_length, conn->cid,
+                !!(hdr->flags & ISCSI_FLAG_CMD_FINAL),
+                !!(hdr->flags & ISCSI_FLAG_TEXT_CONTINUE));
 
         return text_length + padding;
 }
 EXPORT_SYMBOL(iscsit_build_text_rsp);
 
-/*
- *      FIXME: Add support for F_BIT and C_BIT when the length is longer than
- *      MaxRecvDataSegmentLength.
- */
 static int iscsit_send_text_rsp(
         struct iscsi_cmd *cmd,
         struct iscsi_conn *conn)
@@ -4021,9 +4050,15 @@ static int iscsi_target_rx_opcode(struct iscsi_conn *conn, unsigned char *buf)
                 ret = iscsit_handle_task_mgt_cmd(conn, cmd, buf);
                 break;
         case ISCSI_OP_TEXT:
-                cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
-                if (!cmd)
-                        goto reject;
+                if (hdr->ttt != cpu_to_be32(0xFFFFFFFF)) {
+                        cmd = iscsit_find_cmd_from_itt(conn, hdr->itt);
+                        if (!cmd)
+                                goto reject;
+                } else {
+                        cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
+                        if (!cmd)
+                                goto reject;
+                }
 
                 ret = iscsit_handle_text_cmd(conn, cmd, buf);
                 break;
diff --git a/drivers/target/iscsi/iscsi_target_auth.c b/drivers/target/iscsi/iscsi_target_auth.c
index ab4915c0d933..47e249dccb5f 100644
--- a/drivers/target/iscsi/iscsi_target_auth.c
+++ b/drivers/target/iscsi/iscsi_target_auth.c
@@ -22,7 +22,7 @@
 #include <linux/err.h>
 #include <linux/scatterlist.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_nego.h"
 #include "iscsi_target_auth.h"
 
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index 9059c1e0b26e..48384b675e62 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -28,7 +28,7 @@
 #include <target/configfs_macros.h>
 #include <target/iscsi/iscsi_transport.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_parameters.h"
 #include "iscsi_target_device.h"
 #include "iscsi_target_erl0.h"
@@ -36,7 +36,7 @@
 #include "iscsi_target_tpg.h"
 #include "iscsi_target_util.h"
 #include "iscsi_target.h"
-#include "iscsi_target_stat.h"
+#include <target/iscsi/iscsi_target_stat.h>
 #include "iscsi_target_configfs.h"
 
 struct target_fabric_configfs *lio_target_fabric_configfs;
@@ -674,12 +674,9 @@ static ssize_t lio_target_nacl_show_info(
                 rb += sprintf(page+rb, "InitiatorAlias: %s\n",
                         sess->sess_ops->InitiatorAlias);
 
-                rb += sprintf(page+rb, "LIO Session ID: %u   "
-                        "ISID: 0x%02x %02x %02x %02x %02x %02x  "
-                        "TSIH: %hu  ", sess->sid,
-                        sess->isid[0], sess->isid[1], sess->isid[2],
-                        sess->isid[3], sess->isid[4], sess->isid[5],
-                        sess->tsih);
+                rb += sprintf(page+rb,
+                              "LIO Session ID: %u   ISID: 0x%6ph  TSIH: %hu  ",
+                              sess->sid, sess->isid, sess->tsih);
                 rb += sprintf(page+rb, "SessionType: %s\n",
                                 (sess->sess_ops->SessionType) ?
                                 "Discovery" : "Normal");
@@ -1758,9 +1755,7 @@ static u32 lio_sess_get_initiator_sid(
         /*
          * iSCSI Initiator Session Identifier from RFC-3720.
          */
-        return snprintf(buf, size, "%02x%02x%02x%02x%02x%02x",
-                sess->isid[0], sess->isid[1], sess->isid[2],
-                sess->isid[3], sess->isid[4], sess->isid[5]);
+        return snprintf(buf, size, "%6phN", sess->isid);
 }
 
 static int lio_queue_data_in(struct se_cmd *se_cmd)
diff --git a/drivers/target/iscsi/iscsi_target_core.h b/drivers/target/iscsi/iscsi_target_core.h
deleted file mode 100644
index cbcff38ac9b7..000000000000
--- a/drivers/target/iscsi/iscsi_target_core.h
+++ /dev/null
@@ -1,883 +0,0 @@
-#ifndef ISCSI_TARGET_CORE_H
-#define ISCSI_TARGET_CORE_H
-
-#include <linux/in.h>
-#include <linux/configfs.h>
-#include <net/sock.h>
-#include <net/tcp.h>
-#include <scsi/scsi_cmnd.h>
-#include <scsi/iscsi_proto.h>
-#include <target/target_core_base.h>
-
-#define ISCSIT_VERSION                  "v4.1.0"
-#define ISCSI_MAX_DATASN_MISSING_COUNT  16
-#define ISCSI_TX_THREAD_TCP_TIMEOUT     2
-#define ISCSI_RX_THREAD_TCP_TIMEOUT     2
-#define SECONDS_FOR_ASYNC_LOGOUT        10
-#define SECONDS_FOR_ASYNC_TEXT          10
-#define SECONDS_FOR_LOGOUT_COMP         15
-#define WHITE_SPACE                     " \t\v\f\n\r"
-#define ISCSIT_MIN_TAGS                 16
-#define ISCSIT_EXTRA_TAGS               8
-#define ISCSIT_TCP_BACKLOG              256
-
-/* struct iscsi_node_attrib sanity values */
-#define NA_DATAOUT_TIMEOUT              3
-#define NA_DATAOUT_TIMEOUT_MAX          60
-#define NA_DATAOUT_TIMEOUT_MIX          2
-#define NA_DATAOUT_TIMEOUT_RETRIES      5
-#define NA_DATAOUT_TIMEOUT_RETRIES_MAX  15
-#define NA_DATAOUT_TIMEOUT_RETRIES_MIN  1
-#define NA_NOPIN_TIMEOUT                15
-#define NA_NOPIN_TIMEOUT_MAX            60
-#define NA_NOPIN_TIMEOUT_MIN            3
-#define NA_NOPIN_RESPONSE_TIMEOUT       30
-#define NA_NOPIN_RESPONSE_TIMEOUT_MAX   60
-#define NA_NOPIN_RESPONSE_TIMEOUT_MIN   3
-#define NA_RANDOM_DATAIN_PDU_OFFSETS    0
-#define NA_RANDOM_DATAIN_SEQ_OFFSETS    0
-#define NA_RANDOM_R2T_OFFSETS           0
-
-/* struct iscsi_tpg_attrib sanity values */
-#define TA_AUTHENTICATION               1
-#define TA_LOGIN_TIMEOUT                15
-#define TA_LOGIN_TIMEOUT_MAX            30
-#define TA_LOGIN_TIMEOUT_MIN            5
-#define TA_NETIF_TIMEOUT                2
-#define TA_NETIF_TIMEOUT_MAX            15
-#define TA_NETIF_TIMEOUT_MIN            2
-#define TA_GENERATE_NODE_ACLS           0
-#define TA_DEFAULT_CMDSN_DEPTH          64
-#define TA_DEFAULT_CMDSN_DEPTH_MAX      512
-#define TA_DEFAULT_CMDSN_DEPTH_MIN      1
-#define TA_CACHE_DYNAMIC_ACLS           0
-/* Enabled by default in demo mode (generic_node_acls=1) */
-#define TA_DEMO_MODE_WRITE_PROTECT      1
-/* Disabled by default in production mode w/ explict ACLs */
-#define TA_PROD_MODE_WRITE_PROTECT      0
-#define TA_DEMO_MODE_DISCOVERY          1
-#define TA_DEFAULT_ERL                  0
-#define TA_CACHE_CORE_NPS               0
-/* T10 protection information disabled by default */
-#define TA_DEFAULT_T10_PI               0
-
-#define ISCSI_IOV_DATA_BUFFER           5
-
-enum iscsit_transport_type {
-        ISCSI_TCP                               = 0,
-        ISCSI_SCTP_TCP                          = 1,
-        ISCSI_SCTP_UDP                          = 2,
-        ISCSI_IWARP_TCP                         = 3,
-        ISCSI_IWARP_SCTP                        = 4,
-        ISCSI_INFINIBAND                        = 5,
-};
-
-/* RFC-3720 7.1.4  Standard Connection State Diagram for a Target */
-enum target_conn_state_table {
-        TARG_CONN_STATE_FREE                    = 0x1,
-        TARG_CONN_STATE_XPT_UP                  = 0x3,
-        TARG_CONN_STATE_IN_LOGIN                = 0x4,
-        TARG_CONN_STATE_LOGGED_IN               = 0x5,
-        TARG_CONN_STATE_IN_LOGOUT               = 0x6,
-        TARG_CONN_STATE_LOGOUT_REQUESTED        = 0x7,
-        TARG_CONN_STATE_CLEANUP_WAIT            = 0x8,
-};
-
-/* RFC-3720 7.3.2  Session State Diagram for a Target */
-enum target_sess_state_table {
-        TARG_SESS_STATE_FREE                    = 0x1,
-        TARG_SESS_STATE_ACTIVE                  = 0x2,
-        TARG_SESS_STATE_LOGGED_IN               = 0x3,
-        TARG_SESS_STATE_FAILED                  = 0x4,
-        TARG_SESS_STATE_IN_CONTINUE             = 0x5,
-};
-
-/* struct iscsi_data_count->type */
-enum data_count_type {
-        ISCSI_RX_DATA   = 1,
-        ISCSI_TX_DATA   = 2,
-};
-
-/* struct iscsi_datain_req->dr_complete */
-enum datain_req_comp_table {
-        DATAIN_COMPLETE_NORMAL                  = 1,
-        DATAIN_COMPLETE_WITHIN_COMMAND_RECOVERY = 2,
-        DATAIN_COMPLETE_CONNECTION_RECOVERY     = 3,
-};
-
-/* struct iscsi_datain_req->recovery */
-enum datain_req_rec_table {
-        DATAIN_WITHIN_COMMAND_RECOVERY          = 1,
-        DATAIN_CONNECTION_RECOVERY              = 2,
-};
-
-/* struct iscsi_portal_group->state */
-enum tpg_state_table {
-        TPG_STATE_FREE                          = 0,
-        TPG_STATE_ACTIVE                        = 1,
-        TPG_STATE_INACTIVE                      = 2,
-        TPG_STATE_COLD_RESET                    = 3,
-};
-
-/* struct iscsi_tiqn->tiqn_state */
-enum tiqn_state_table {
-        TIQN_STATE_ACTIVE                       = 1,
-        TIQN_STATE_SHUTDOWN                     = 2,
-};
-
-/* struct iscsi_cmd->cmd_flags */
-enum cmd_flags_table {
-        ICF_GOT_LAST_DATAOUT                    = 0x00000001,
-        ICF_GOT_DATACK_SNACK                    = 0x00000002,
-        ICF_NON_IMMEDIATE_UNSOLICITED_DATA      = 0x00000004,
-        ICF_SENT_LAST_R2T                       = 0x00000008,
-        ICF_WITHIN_COMMAND_RECOVERY             = 0x00000010,
-        ICF_CONTIG_MEMORY                       = 0x00000020,
-        ICF_ATTACHED_TO_RQUEUE                  = 0x00000040,
-        ICF_OOO_CMDSN                           = 0x00000080,
-        ICF_SENDTARGETS_ALL                     = 0x00000100,
-        ICF_SENDTARGETS_SINGLE                  = 0x00000200,
-};
-
-/* struct iscsi_cmd->i_state */
-enum cmd_i_state_table {
-        ISTATE_NO_STATE                 = 0,
-        ISTATE_NEW_CMD                  = 1,
-        ISTATE_DEFERRED_CMD             = 2,
-        ISTATE_UNSOLICITED_DATA         = 3,
-        ISTATE_RECEIVE_DATAOUT          = 4,
-        ISTATE_RECEIVE_DATAOUT_RECOVERY = 5,
-        ISTATE_RECEIVED_LAST_DATAOUT    = 6,
-        ISTATE_WITHIN_DATAOUT_RECOVERY  = 7,
-        ISTATE_IN_CONNECTION_RECOVERY   = 8,
-        ISTATE_RECEIVED_TASKMGT         = 9,
-        ISTATE_SEND_ASYNCMSG            = 10,
-        ISTATE_SENT_ASYNCMSG            = 11,
-        ISTATE_SEND_DATAIN              = 12,
-        ISTATE_SEND_LAST_DATAIN         = 13,
-        ISTATE_SENT_LAST_DATAIN         = 14,
-        ISTATE_SEND_LOGOUTRSP           = 15,
-        ISTATE_SENT_LOGOUTRSP           = 16,
-        ISTATE_SEND_NOPIN               = 17,
-        ISTATE_SENT_NOPIN               = 18,
-        ISTATE_SEND_REJECT              = 19,
-        ISTATE_SENT_REJECT              = 20,
-        ISTATE_SEND_R2T                 = 21,
-        ISTATE_SENT_R2T                 = 22,
-        ISTATE_SEND_R2T_RECOVERY        = 23,
-        ISTATE_SENT_R2T_RECOVERY        = 24,
-        ISTATE_SEND_LAST_R2T            = 25,
-        ISTATE_SENT_LAST_R2T            = 26,
-        ISTATE_SEND_LAST_R2T_RECOVERY   = 27,
-        ISTATE_SENT_LAST_R2T_RECOVERY   = 28,
-        ISTATE_SEND_STATUS              = 29,
-        ISTATE_SEND_STATUS_BROKEN_PC    = 30,
-        ISTATE_SENT_STATUS              = 31,
-        ISTATE_SEND_STATUS_RECOVERY     = 32,
-        ISTATE_SENT_STATUS_RECOVERY     = 33,
-        ISTATE_SEND_TASKMGTRSP          = 34,
-        ISTATE_SENT_TASKMGTRSP          = 35,
-        ISTATE_SEND_TEXTRSP             = 36,
-        ISTATE_SENT_TEXTRSP             = 37,
-        ISTATE_SEND_NOPIN_WANT_RESPONSE = 38,
-        ISTATE_SENT_NOPIN_WANT_RESPONSE = 39,
-        ISTATE_SEND_NOPIN_NO_RESPONSE   = 40,
-        ISTATE_REMOVE                   = 41,
-        ISTATE_FREE                     = 42,
-};
-
-/* Used for iscsi_recover_cmdsn() return values */
-enum recover_cmdsn_ret_table {
-        CMDSN_ERROR_CANNOT_RECOVER      = -1,
-        CMDSN_NORMAL_OPERATION          = 0,
-        CMDSN_LOWER_THAN_EXP            = 1,
-        CMDSN_HIGHER_THAN_EXP           = 2,
-        CMDSN_MAXCMDSN_OVERRUN          = 3,
-};
-
-/* Used for iscsi_handle_immediate_data() return values */
-enum immedate_data_ret_table {
-        IMMEDIATE_DATA_CANNOT_RECOVER   = -1,
-        IMMEDIATE_DATA_NORMAL_OPERATION = 0,
-        IMMEDIATE_DATA_ERL1_CRC_FAILURE = 1,
-};
-
-/* Used for iscsi_decide_dataout_action() return values */
-enum dataout_action_ret_table {
-        DATAOUT_CANNOT_RECOVER          = -1,
-        DATAOUT_NORMAL                  = 0,
-        DATAOUT_SEND_R2T                = 1,
-        DATAOUT_SEND_TO_TRANSPORT       = 2,
-        DATAOUT_WITHIN_COMMAND_RECOVERY = 3,
-};
-
-/* Used for struct iscsi_node_auth->naf_flags */
-enum naf_flags_table {
-        NAF_USERID_SET                  = 0x01,
-        NAF_PASSWORD_SET                = 0x02,
-        NAF_USERID_IN_SET               = 0x04,
-        NAF_PASSWORD_IN_SET             = 0x08,
-};
-
-/* Used by various struct timer_list to manage iSCSI specific state */
-enum iscsi_timer_flags_table {
-        ISCSI_TF_RUNNING                = 0x01,
-        ISCSI_TF_STOP                   = 0x02,
-        ISCSI_TF_EXPIRED                = 0x04,
-};
-
-/* Used for struct iscsi_np->np_flags */
-enum np_flags_table {
-        NPF_IP_NETWORK          = 0x00,
-};
-
-/* Used for struct iscsi_np->np_thread_state */
-enum np_thread_state_table {
-        ISCSI_NP_THREAD_ACTIVE          = 1,
-        ISCSI_NP_THREAD_INACTIVE        = 2,
-        ISCSI_NP_THREAD_RESET           = 3,
-        ISCSI_NP_THREAD_SHUTDOWN        = 4,
-        ISCSI_NP_THREAD_EXIT            = 5,
-};
-
-struct iscsi_conn_ops {
-        u8      HeaderDigest;                   /* [0,1] == [None,CRC32C] */
-        u8      DataDigest;                     /* [0,1] == [None,CRC32C] */
-        u32     MaxRecvDataSegmentLength;       /* [512..2**24-1] */
-        u32     MaxXmitDataSegmentLength;       /* [512..2**24-1] */
-        u8      OFMarker;                       /* [0,1] == [No,Yes] */
-        u8      IFMarker;                       /* [0,1] == [No,Yes] */
-        u32     OFMarkInt;                      /* [1..65535] */
-        u32     IFMarkInt;                      /* [1..65535] */
-        /*
-         * iSER specific connection parameters
-         */
-        u32     InitiatorRecvDataSegmentLength; /* [512..2**24-1] */
-        u32     TargetRecvDataSegmentLength;    /* [512..2**24-1] */
-};
-
-struct iscsi_sess_ops {
-        char    InitiatorName[224];
-        char    InitiatorAlias[256];
-        char    TargetName[224];
-        char    TargetAlias[256];
-        char    TargetAddress[256];
-        u16     TargetPortalGroupTag;           /* [0..65535] */
-        u16     MaxConnections;                 /* [1..65535] */
-        u8      InitialR2T;                     /* [0,1] == [No,Yes] */
-        u8      ImmediateData;                  /* [0,1] == [No,Yes] */
-        u32     MaxBurstLength;                 /* [512..2**24-1] */
-        u32     FirstBurstLength;               /* [512..2**24-1] */
-        u16     DefaultTime2Wait;               /* [0..3600] */
-        u16     DefaultTime2Retain;             /* [0..3600] */
-        u16     MaxOutstandingR2T;              /* [1..65535] */
-        u8      DataPDUInOrder;                 /* [0,1] == [No,Yes] */
-        u8      DataSequenceInOrder;            /* [0,1] == [No,Yes] */
-        u8      ErrorRecoveryLevel;             /* [0..2] */
-        u8      SessionType;                    /* [0,1] == [Normal,Discovery]*/
-        /*
-         * iSER specific session parameters
-         */
-        u8      RDMAExtensions;                 /* [0,1] == [No,Yes] */
-};
-
-struct iscsi_queue_req {
-        int                     state;
-        struct iscsi_cmd        *cmd;
-        struct list_head        qr_list;
-};
-
-struct iscsi_data_count {
-        int                     data_length;
-        int                     sync_and_steering;
-        enum data_count_type    type;
-        u32                     iov_count;
-        u32                     ss_iov_count;
-        u32                     ss_marker_count;
-        struct kvec             *iov;
-};
-
-struct iscsi_param_list {
-        bool                    iser;
-        struct list_head        param_list;
-        struct list_head        extra_response_list;
-};
-
-struct iscsi_datain_req {
-        enum datain_req_comp_table dr_complete;
-        int                     generate_recovery_values;
-        enum datain_req_rec_table recovery;
-        u32                     begrun;
-        u32                     runlength;
-        u32                     data_length;
-        u32                     data_offset;
-        u32                     data_sn;
-        u32                     next_burst_len;
-        u32                     read_data_done;
-        u32                     seq_send_order;
-        struct list_head        cmd_datain_node;
-} ____cacheline_aligned;
-
-struct iscsi_ooo_cmdsn {
-        u16                     cid;
-        u32                     batch_count;
-        u32                     cmdsn;
-        u32                     exp_cmdsn;
-        struct iscsi_cmd        *cmd;
-        struct list_head        ooo_list;
-} ____cacheline_aligned;
-
-struct iscsi_datain {
-        u8                      flags;
-        u32                     data_sn;
-        u32                     length;
-        u32                     offset;
-} ____cacheline_aligned;
-
-struct iscsi_r2t {
-        int                     seq_complete;
-        int                     recovery_r2t;
-        int                     sent_r2t;
-        u32                     r2t_sn;
-        u32                     offset;
-        u32                     targ_xfer_tag;
-        u32                     xfer_len;
-        struct list_head        r2t_list;
-} ____cacheline_aligned;
-
-struct iscsi_cmd {
-        enum iscsi_timer_flags_table dataout_timer_flags;
-        /* DataOUT timeout retries */
-        u8                      dataout_timeout_retries;
-        /* Within command recovery count */
-        u8                      error_recovery_count;
-        /* iSCSI dependent state for out or order CmdSNs */
-        enum cmd_i_state_table  deferred_i_state;
-        /* iSCSI dependent state */
-        enum cmd_i_state_table  i_state;
-        /* Command is an immediate command (ISCSI_OP_IMMEDIATE set) */
-        u8                      immediate_cmd;
-        /* Immediate data present */
-        u8                      immediate_data;
-        /* iSCSI Opcode */
-        u8                      iscsi_opcode;
-        /* iSCSI Response Code */
-        u8                      iscsi_response;
-        /* Logout reason when iscsi_opcode == ISCSI_INIT_LOGOUT_CMND */
-        u8                      logout_reason;
-        /* Logout response code when iscsi_opcode == ISCSI_INIT_LOGOUT_CMND */
-        u8                      logout_response;
-        /* MaxCmdSN has been incremented */
-        u8                      maxcmdsn_inc;
-        /* Immediate Unsolicited Dataout */
-        u8                      unsolicited_data;
-        /* Reject reason code */
-        u8                      reject_reason;
-        /* CID contained in logout PDU when opcode == ISCSI_INIT_LOGOUT_CMND */
-        u16                     logout_cid;
-        /* Command flags */
-        enum cmd_flags_table    cmd_flags;
-        /* Initiator Task Tag assigned from Initiator */
-        itt_t                   init_task_tag;
-        /* Target Transfer Tag assigned from Target */
-        u32                     targ_xfer_tag;
-        /* CmdSN assigned from Initiator */
-        u32                     cmd_sn;
-        /* ExpStatSN assigned from Initiator */
-        u32                     exp_stat_sn;
-        /* StatSN assigned to this ITT */
-        u32                     stat_sn;
-        /* DataSN Counter */
-        u32                     data_sn;
-        /* R2TSN Counter */
-        u32                     r2t_sn;
-        /* Last DataSN acknowledged via DataAck SNACK */
-        u32                     acked_data_sn;
-        /* Used for echoing NOPOUT ping data */
-        u32                     buf_ptr_size;
-        /* Used to store DataDigest */
-        u32                     data_crc;
-        /* Counter for MaxOutstandingR2T */
-        u32                     outstanding_r2ts;
-        /* Next R2T Offset when DataSequenceInOrder=Yes */
-        u32                     r2t_offset;
-        /* Iovec current and orig count for iscsi_cmd->iov_data */
-        u32                     iov_data_count;
-        u32                     orig_iov_data_count;
-        /* Number of miscellaneous iovecs used for IP stack calls */
-        u32                     iov_misc_count;
-        /* Number of struct iscsi_pdu in struct iscsi_cmd->pdu_list */
-        u32                     pdu_count;
-        /* Next struct iscsi_pdu to send in struct iscsi_cmd->pdu_list */
-        u32                     pdu_send_order;
-        /* Current struct iscsi_pdu in struct iscsi_cmd->pdu_list */
-        u32                     pdu_start;
-        /* Next struct iscsi_seq to send in struct iscsi_cmd->seq_list */
-        u32                     seq_send_order;
-        /* Number of struct iscsi_seq in struct iscsi_cmd->seq_list */
-        u32                     seq_count;
-        /* Current struct iscsi_seq in struct iscsi_cmd->seq_list */
-        u32                     seq_no;
-        /* Lowest offset in current DataOUT sequence */
-        u32                     seq_start_offset;
-        /* Highest offset in current DataOUT sequence */
-        u32                     seq_end_offset;
-        /* Total size in bytes received so far of READ data */
-        u32                     read_data_done;
-        /* Total size in bytes received so far of WRITE data */
-        u32                     write_data_done;
-        /* Counter for FirstBurstLength key */
-        u32                     first_burst_len;
-        /* Counter for MaxBurstLength key */
-        u32                     next_burst_len;
-        /* Transfer size used for IP stack calls */
-        u32                     tx_size;
-        /* Buffer used for various purposes */
-        void                    *buf_ptr;
-        /* Used by SendTargets=[iqn.,eui.] discovery */
-        void                    *text_in_ptr;
-        /* See include/linux/dma-mapping.h */
-        enum dma_data_direction data_direction;
-        /* iSCSI PDU Header + CRC */
-        unsigned char           pdu[ISCSI_HDR_LEN + ISCSI_CRC_LEN];
-        /* Number of times struct iscsi_cmd is present in immediate queue */
-        atomic_t                immed_queue_count;
-        atomic_t                response_queue_count;
-        spinlock_t              datain_lock;
-        spinlock_t              dataout_timeout_lock;
-        /* spinlock for protecting struct iscsi_cmd->i_state */
-        spinlock_t              istate_lock;
-        /* spinlock for adding within command recovery entries */
-        spinlock_t              error_lock;
-        /* spinlock for adding R2Ts */
-        spinlock_t              r2t_lock;
-        /* DataIN List */
-        struct list_head        datain_list;
-        /* R2T List */
-        struct list_head        cmd_r2t_list;
-        /* Timer for DataOUT */
-        struct timer_list       dataout_timer;
-        /* Iovecs for SCSI data payload RX/TX w/ kernel level sockets */
-        struct kvec             *iov_data;
-        /* Iovecs for miscellaneous purposes */
-#define ISCSI_MISC_IOVECS                       5
-        struct kvec             iov_misc[ISCSI_MISC_IOVECS];
-        /* Array of struct iscsi_pdu used for DataPDUInOrder=No */
-        struct iscsi_pdu        *pdu_list;
-        /* Current struct iscsi_pdu used for DataPDUInOrder=No */
-        struct iscsi_pdu        *pdu_ptr;
-        /* Array of struct iscsi_seq used for DataSequenceInOrder=No */
-        struct iscsi_seq        *seq_list;
-        /* Current struct iscsi_seq used for DataSequenceInOrder=No */
-        struct iscsi_seq        *seq_ptr;
-        /* TMR Request when iscsi_opcode == ISCSI_OP_SCSI_TMFUNC */
-        struct iscsi_tmr_req    *tmr_req;
-        /* Connection this command is alligient to */
-        struct iscsi_conn       *conn;
-        /* Pointer to connection recovery entry */
-        struct iscsi_conn_recovery *cr;
-        /* Session the command is part of,  used for connection recovery */
-        struct iscsi_session    *sess;
-        /* list_head for connection list */
-        struct list_head        i_conn_node;
-        /* The TCM I/O descriptor that is accessed via container_of() */
-        struct se_cmd           se_cmd;
-        /* Sense buffer that will be mapped into outgoing status */
-#define ISCSI_SENSE_BUFFER_LEN          (TRANSPORT_SENSE_BUFFER + 2)
-        unsigned char           sense_buffer[ISCSI_SENSE_BUFFER_LEN];
-
-        u32                     padding;
-        u8                      pad_bytes[4];
-
-        struct scatterlist      *first_data_sg;
-        u32                     first_data_sg_off;
-        u32                     kmapped_nents;
-        sense_reason_t          sense_reason;
-}  ____cacheline_aligned;
-
-struct iscsi_tmr_req {
-        bool                    task_reassign:1;
-        u32                     exp_data_sn;
-        struct iscsi_cmd        *ref_cmd;
-        struct iscsi_conn_recovery *conn_recovery;
-        struct se_tmr_req       *se_tmr_req;
-};
-
-struct iscsi_conn {
-        wait_queue_head_t       queues_wq;
-        /* Authentication Successful for this connection */
-        u8                      auth_complete;
-        /* State connection is currently in */
-        u8                      conn_state;
-        u8                      conn_logout_reason;
-        u8                      network_transport;
-        enum iscsi_timer_flags_table nopin_timer_flags;
-        enum iscsi_timer_flags_table nopin_response_timer_flags;
-        /* Used to know what thread encountered a transport failure */
-        u8                      which_thread;
-        /* connection id assigned by the Initiator */
-        u16                     cid;
-        /* Remote TCP Port */
-        u16                     login_port;
-        u16                     local_port;
-        int                     net_size;
-        int                     login_family;
-        u32                     auth_id;
-        u32                     conn_flags;
-        /* Used for iscsi_tx_login_rsp() */
-        itt_t                   login_itt;
-        u32                     exp_statsn;
-        /* Per connection status sequence number */
-        u32                     stat_sn;
-        /* IFMarkInt's Current Value */
-        u32                     if_marker;
-        /* OFMarkInt's Current Value */
-        u32                     of_marker;
-        /* Used for calculating OFMarker offset to next PDU */
-        u32                     of_marker_offset;
-#define IPV6_ADDRESS_SPACE                              48
-        unsigned char           login_ip[IPV6_ADDRESS_SPACE];
-        unsigned char           local_ip[IPV6_ADDRESS_SPACE];
-        int                     conn_usage_count;
-        int                     conn_waiting_on_uc;
-        atomic_t                check_immediate_queue;
-        atomic_t                conn_logout_remove;
-        atomic_t                connection_exit;
-        atomic_t                connection_recovery;
-        atomic_t                connection_reinstatement;
-        atomic_t                connection_wait_rcfr;
-        atomic_t                sleep_on_conn_wait_comp;
-        atomic_t                transport_failed;
-        struct completion       conn_post_wait_comp;
-        struct completion       conn_wait_comp;
-        struct completion       conn_wait_rcfr_comp;
-        struct completion       conn_waiting_on_uc_comp;
-        struct completion       conn_logout_comp;
-        struct completion       tx_half_close_comp;
-        struct completion       rx_half_close_comp;
-        /* socket used by this connection */
-        struct socket           *sock;
-        void                    (*orig_data_ready)(struct sock *);
-        void                    (*orig_state_change)(struct sock *);
-#define LOGIN_FLAGS_READ_ACTIVE         1
-#define LOGIN_FLAGS_CLOSED              2
-#define LOGIN_FLAGS_READY               4
-        unsigned long           login_flags;
-        struct delayed_work     login_work;
-        struct delayed_work     login_cleanup_work;
-        struct iscsi_login      *login;
-        struct timer_list       nopin_timer;
-        struct timer_list       nopin_response_timer;
-        struct timer_list       transport_timer;
-        struct task_struct      *login_kworker;
-        /* Spinlock used for add/deleting cmd's from conn_cmd_list */
-        spinlock_t              cmd_lock;
-        spinlock_t              conn_usage_lock;
-        spinlock_t              immed_queue_lock;
-        spinlock_t              nopin_timer_lock;
-        spinlock_t              response_queue_lock;
-        spinlock_t              state_lock;
-        /* libcrypto RX and TX contexts for crc32c */
-        struct hash_desc        conn_rx_hash;
-        struct hash_desc        conn_tx_hash;
-        /* Used for scheduling TX and RX connection kthreads */
-        cpumask_var_t           conn_cpumask;
-        unsigned int            conn_rx_reset_cpumask:1;
-        unsigned int            conn_tx_reset_cpumask:1;
-        /* list_head of struct iscsi_cmd for this connection */
-        struct list_head        conn_cmd_list;
-        struct list_head        immed_queue_list;
-        struct list_head        response_queue_list;
-        struct iscsi_conn_ops   *conn_ops;
-        struct iscsi_login      *conn_login;
-        struct iscsit_transport *conn_transport;
-        struct iscsi_param_list *param_list;
-        /* Used for per connection auth state machine */
-        void                    *auth_protocol;
-        void                    *context;
-        struct iscsi_login_thread_s *login_thread;
-        struct iscsi_portal_group *tpg;
-        struct iscsi_tpg_np     *tpg_np;
-        /* Pointer to parent session */
-        struct iscsi_session    *sess;
-        /* Pointer to thread_set in use for this conn's threads */
-        struct iscsi_thread_set *thread_set;
-        /* list_head for session connection list */
-        struct list_head        conn_list;
-} ____cacheline_aligned;
-
-struct iscsi_conn_recovery {
-        u16                     cid;
-        u32                     cmd_count;
-        u32                     maxrecvdatasegmentlength;
-        u32                     maxxmitdatasegmentlength;
-        int                     ready_for_reallegiance;
-        struct list_head        conn_recovery_cmd_list;
-        spinlock_t              conn_recovery_cmd_lock;
-        struct timer_list       time2retain_timer;
-        struct iscsi_session    *sess;
-        struct list_head        cr_list;
-}  ____cacheline_aligned;
-
-struct iscsi_session {
-        u8                      initiator_vendor;
-        u8                      isid[6];
-        enum iscsi_timer_flags_table time2retain_timer_flags;
-        u8                      version_active;
-        u16                     cid_called;
-        u16                     conn_recovery_count;
-        u16                     tsih;
-        /* state session is currently in */
-        u32                     session_state;
-        /* session wide counter: initiator assigned task tag */
-        itt_t                   init_task_tag;
-        /* session wide counter: target assigned task tag */
-        u32                     targ_xfer_tag;
-        u32                     cmdsn_window;
-
-        /* protects cmdsn values */
-        struct mutex            cmdsn_mutex;
-        /* session wide counter: expected command sequence number */
-        u32                     exp_cmd_sn;
-        /* session wide counter: maximum allowed command sequence number */
-        u32                     max_cmd_sn;
-        struct list_head        sess_ooo_cmdsn_list;
-
-        /* LIO specific session ID */
-        u32                     sid;
-        char                    auth_type[8];
-        /* unique within the target */
-        int                     session_index;
-        /* Used for session reference counting */
-        int                     session_usage_count;
-        int                     session_waiting_on_uc;
-        atomic_long_t           cmd_pdus;
-        atomic_long_t           rsp_pdus;
-        atomic_long_t           tx_data_octets;
-        atomic_long_t           rx_data_octets;
-        atomic_long_t           conn_digest_errors;
-        atomic_long_t           conn_timeout_errors;
-        u64                     creation_time;
-        /* Number of active connections */
-        atomic_t                nconn;
-        atomic_t                session_continuation;
-        atomic_t                session_fall_back_to_erl0;
-        atomic_t                session_logout;
-        atomic_t                session_reinstatement;
-        atomic_t                session_stop_active;
-        atomic_t                sleep_on_sess_wait_comp;
-        /* connection list */
-        struct list_head        sess_conn_list;
-        struct list_head        cr_active_list;
-        struct list_head        cr_inactive_list;
-        spinlock_t              conn_lock;
-        spinlock_t              cr_a_lock;
-        spinlock_t              cr_i_lock;
-        spinlock_t              session_usage_lock;
-        spinlock_t              ttt_lock;
-        struct completion       async_msg_comp;
-        struct completion       reinstatement_comp;
-        struct completion       session_wait_comp;
-        struct completion       session_waiting_on_uc_comp;
-        struct timer_list       time2retain_timer;
-        struct iscsi_sess_ops   *sess_ops;
-        struct se_session       *se_sess;
-        struct iscsi_portal_group *tpg;
-} ____cacheline_aligned;
-
-struct iscsi_login {
-        u8 auth_complete;
-        u8 checked_for_existing;
-        u8 current_stage;
-        u8 leading_connection;
-        u8 first_request;
-        u8 version_min;
-        u8 version_max;
-        u8 login_complete;
-        u8 login_failed;
-        bool zero_tsih;
-        char isid[6];
-        u32 cmd_sn;
-        itt_t init_task_tag;
-        u32 initial_exp_statsn;
-        u32 rsp_length;
-        u16 cid;
-        u16 tsih;
-        char req[ISCSI_HDR_LEN];
-        char rsp[ISCSI_HDR_LEN];
-        char *req_buf;
-        char *rsp_buf;
-        struct iscsi_conn *conn;
-        struct iscsi_np *np;
-} ____cacheline_aligned;
-
-struct iscsi_node_attrib {
-        u32                     dataout_timeout;
-        u32                     dataout_timeout_retries;
-        u32                     default_erl;
-        u32                     nopin_timeout;
-        u32                     nopin_response_timeout;
-        u32                     random_datain_pdu_offsets;
-        u32                     random_datain_seq_offsets;
-        u32                     random_r2t_offsets;
-        u32                     tmr_cold_reset;
-        u32                     tmr_warm_reset;
-        struct iscsi_node_acl *nacl;
-};
-
-struct se_dev_entry_s;
-
-struct iscsi_node_auth {
-        enum naf_flags_table    naf_flags;
-        int                     authenticate_target;
-        /* Used for iscsit_global->discovery_auth,
-         * set to zero (auth disabled) by default */
-        int                     enforce_discovery_auth;
-#define MAX_USER_LEN                            256
-#define MAX_PASS_LEN                            256
-        char                    userid[MAX_USER_LEN];
-        char                    password[MAX_PASS_LEN];
-        char                    userid_mutual[MAX_USER_LEN];
-        char                    password_mutual[MAX_PASS_LEN];
-};
-
-#include "iscsi_target_stat.h"
-
-struct iscsi_node_stat_grps {
-        struct config_group     iscsi_sess_stats_group;
-        struct config_group     iscsi_conn_stats_group;
-};
-
-struct iscsi_node_acl {
-        struct iscsi_node_attrib node_attrib;
-        struct iscsi_node_auth  node_auth;
-        struct iscsi_node_stat_grps node_stat_grps;
-        struct se_node_acl      se_node_acl;
-};
-
-struct iscsi_tpg_attrib {
-        u32                     authentication;
-        u32                     login_timeout;
-        u32                     netif_timeout;
-        u32                     generate_node_acls;
-        u32                     cache_dynamic_acls;
-        u32                     default_cmdsn_depth;
-        u32                     demo_mode_write_protect;
-        u32                     prod_mode_write_protect;
-        u32                     demo_mode_discovery;
-        u32                     default_erl;
-        u8                      t10_pi;
-        struct iscsi_portal_group *tpg;
-};
-
-struct iscsi_np {
-        int                     np_network_transport;
-        int                     np_ip_proto;
-        int                     np_sock_type;
-        enum np_thread_state_table np_thread_state;
-        bool                    enabled;
-        enum iscsi_timer_flags_table np_login_timer_flags;
-        u32                     np_exports;
-        enum np_flags_table     np_flags;
-        unsigned char           np_ip[IPV6_ADDRESS_SPACE];
-        u16                     np_port;
-        spinlock_t              np_thread_lock;
-        struct completion       np_restart_comp;
-        struct socket           *np_socket;
-        struct __kernel_sockaddr_storage np_sockaddr;
-        struct task_struct      *np_thread;
-        struct timer_list       np_login_timer;
-        void                    *np_context;
-        struct iscsit_transport *np_transport;
-        struct list_head        np_list;
-} ____cacheline_aligned;
-
-struct iscsi_tpg_np {
-        struct iscsi_np         *tpg_np;
-        struct iscsi_portal_group *tpg;
-        struct iscsi_tpg_np     *tpg_np_parent;
-        struct list_head        tpg_np_list;
-        struct list_head        tpg_np_child_list;
-        struct list_head        tpg_np_parent_list;
-        struct se_tpg_np        se_tpg_np;
-        spinlock_t              tpg_np_parent_lock;
-        struct completion       tpg_np_comp;
-        struct kref             tpg_np_kref;
-};
-
-struct iscsi_portal_group {
-        unsigned char           tpg_chap_id;
-        /* TPG State */
-        enum tpg_state_table    tpg_state;
-        /* Target Portal Group Tag */
-        u16                     tpgt;
-        /* Id assigned to target sessions */
-        u16                     ntsih;
-        /* Number of active sessions */
-        u32                     nsessions;
-        /* Number of Network Portals available for this TPG */
-        u32                     num_tpg_nps;
-        /* Per TPG LIO specific session ID. */
-        u32                     sid;
-        /* Spinlock for adding/removing Network Portals */
-        spinlock_t              tpg_np_lock;
-        spinlock_t              tpg_state_lock;
-        struct se_portal_group tpg_se_tpg;
-        struct mutex            tpg_access_lock;
-        struct semaphore        np_login_sem;
-        struct iscsi_tpg_attrib tpg_attrib;
-        struct iscsi_node_auth  tpg_demo_auth;
-        /* Pointer to default list of iSCSI parameters for TPG */
-        struct iscsi_param_list *param_list;
-        struct iscsi_tiqn       *tpg_tiqn;
-        struct list_head        tpg_gnp_list;
-        struct list_head        tpg_list;
-} ____cacheline_aligned;
-
-struct iscsi_wwn_stat_grps {
-        struct config_group     iscsi_stat_group;
-        struct config_group     iscsi_instance_group;
-        struct config_group     iscsi_sess_err_group;
-        struct config_group     iscsi_tgt_attr_group;
-        struct config_group     iscsi_login_stats_group;
-        struct config_group     iscsi_logout_stats_group;
-};
-
-struct iscsi_tiqn {
-#define ISCSI_IQN_LEN                           224
-        unsigned char           tiqn[ISCSI_IQN_LEN];
-        enum tiqn_state_table   tiqn_state;
-        int                     tiqn_access_count;
-        u32                     tiqn_active_tpgs;
-        u32                     tiqn_ntpgs;
-        u32                     tiqn_num_tpg_nps;
-        u32                     tiqn_nsessions;
-        struct list_head        tiqn_list;
-        struct list_head        tiqn_tpg_list;
-        spinlock_t              tiqn_state_lock;
-        spinlock_t              tiqn_tpg_lock;
-        struct se_wwn           tiqn_wwn;
-        struct iscsi_wwn_stat_grps tiqn_stat_grps;
-        int                     tiqn_index;
-        struct iscsi_sess_err_stats  sess_err_stats;
-        struct iscsi_login_stats     login_stats;
-        struct iscsi_logout_stats    logout_stats;
-} ____cacheline_aligned;
-
-struct iscsit_global {
-        /* In core shutdown */
-        u32                     in_shutdown;
-        u32                     active_ts;
-        /* Unique identifier used for the authentication daemon */
-        u32                     auth_id;
-        u32                     inactive_ts;
-        /* Thread Set bitmap count */
-        int                     ts_bitmap_count;
-        /* Thread Set bitmap pointer */
-        unsigned long           *ts_bitmap;
-        /* Used for iSCSI discovery session authentication */
-        struct iscsi_node_acl   discovery_acl;
-        struct iscsi_portal_group       *discovery_tpg;
-};
-
-#endif /* ISCSI_TARGET_CORE_H */
diff --git a/drivers/target/iscsi/iscsi_target_datain_values.c b/drivers/target/iscsi/iscsi_target_datain_values.c
index e93d5a7a3f81..fb3b52b124ac 100644
--- a/drivers/target/iscsi/iscsi_target_datain_values.c
+++ b/drivers/target/iscsi/iscsi_target_datain_values.c
@@ -18,7 +18,7 @@
 
 #include <scsi/iscsi_proto.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_seq_pdu_list.h"
 #include "iscsi_target_erl1.h"
 #include "iscsi_target_util.h"
diff --git a/drivers/target/iscsi/iscsi_target_device.c b/drivers/target/iscsi/iscsi_target_device.c
index 7087c736daa5..34c3cd1b05ce 100644
--- a/drivers/target/iscsi/iscsi_target_device.c
+++ b/drivers/target/iscsi/iscsi_target_device.c
@@ -21,7 +21,7 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_device.h"
 #include "iscsi_target_tpg.h"
 #include "iscsi_target_util.h"
diff --git a/drivers/target/iscsi/iscsi_target_erl0.c b/drivers/target/iscsi/iscsi_target_erl0.c
index a0ae5fc0ad75..1c197bad6132 100644
--- a/drivers/target/iscsi/iscsi_target_erl0.c
+++ b/drivers/target/iscsi/iscsi_target_erl0.c
@@ -21,7 +21,8 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
+#include <target/iscsi/iscsi_transport.h>
 #include "iscsi_target_seq_pdu_list.h"
 #include "iscsi_target_tq.h"
 #include "iscsi_target_erl0.h"
@@ -939,7 +940,8 @@ void iscsit_take_action_for_connection_exit(struct iscsi_conn *conn)
 
         if (conn->conn_state == TARG_CONN_STATE_IN_LOGOUT) {
                 spin_unlock_bh(&conn->state_lock);
-                iscsit_close_connection(conn);
+                if (conn->conn_transport->transport_type == ISCSI_TCP)
+                        iscsit_close_connection(conn);
                 return;
         }
 
diff --git a/drivers/target/iscsi/iscsi_target_erl1.c b/drivers/target/iscsi/iscsi_target_erl1.c
index cda4d80cfaef..2e561deb30a2 100644
--- a/drivers/target/iscsi/iscsi_target_erl1.c
+++ b/drivers/target/iscsi/iscsi_target_erl1.c
@@ -22,7 +22,7 @@
 #include <target/target_core_fabric.h>
 #include <target/iscsi/iscsi_transport.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_seq_pdu_list.h"
 #include "iscsi_target_datain_values.h"
 #include "iscsi_target_device.h"
diff --git a/drivers/target/iscsi/iscsi_target_erl2.c b/drivers/target/iscsi/iscsi_target_erl2.c
index 4ca8fd2a70db..e24f1c7c5862 100644
--- a/drivers/target/iscsi/iscsi_target_erl2.c
+++ b/drivers/target/iscsi/iscsi_target_erl2.c
@@ -21,7 +21,7 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_datain_values.h"
 #include "iscsi_target_util.h"
 #include "iscsi_target_erl0.h"
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index 713c0c1877ab..153fb66ac1b8 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -24,14 +24,14 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
+#include <target/iscsi/iscsi_target_stat.h>
 #include "iscsi_target_tq.h"
 #include "iscsi_target_device.h"
 #include "iscsi_target_nego.h"
 #include "iscsi_target_erl0.h"
 #include "iscsi_target_erl2.h"
 #include "iscsi_target_login.h"
-#include "iscsi_target_stat.h"
 #include "iscsi_target_tpg.h"
 #include "iscsi_target_util.h"
 #include "iscsi_target.h"
diff --git a/drivers/target/iscsi/iscsi_target_nego.c b/drivers/target/iscsi/iscsi_target_nego.c
index 62a095f36bf2..8c02fa34716f 100644
--- a/drivers/target/iscsi/iscsi_target_nego.c
+++ b/drivers/target/iscsi/iscsi_target_nego.c
@@ -22,7 +22,7 @@
 #include <target/target_core_fabric.h>
 #include <target/iscsi/iscsi_transport.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_parameters.h"
 #include "iscsi_target_login.h"
 #include "iscsi_target_nego.h"
diff --git a/drivers/target/iscsi/iscsi_target_nodeattrib.c b/drivers/target/iscsi/iscsi_target_nodeattrib.c
index 16454a922e2b..208cca8a363c 100644
--- a/drivers/target/iscsi/iscsi_target_nodeattrib.c
+++ b/drivers/target/iscsi/iscsi_target_nodeattrib.c
@@ -18,7 +18,7 @@
 
 #include <target/target_core_base.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_device.h"
 #include "iscsi_target_tpg.h"
 #include "iscsi_target_util.h"
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index 18c29260b4a2..d4f9e9645697 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -18,7 +18,7 @@
 
 #include <linux/slab.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_util.h"
 #include "iscsi_target_parameters.h"
 
diff --git a/drivers/target/iscsi/iscsi_target_seq_pdu_list.c b/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
index ca41b583f2f6..e446a09c886b 100644
--- a/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
+++ b/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
@@ -20,7 +20,7 @@
 #include <linux/slab.h>
 #include <linux/random.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_util.h"
 #include "iscsi_target_tpg.h"
 #include "iscsi_target_seq_pdu_list.h"
diff --git a/drivers/target/iscsi/iscsi_target_stat.c b/drivers/target/iscsi/iscsi_target_stat.c
index 103395510307..5e1349a3b143 100644
--- a/drivers/target/iscsi/iscsi_target_stat.c
+++ b/drivers/target/iscsi/iscsi_target_stat.c
@@ -23,12 +23,12 @@
 #include <target/target_core_base.h>
 #include <target/configfs_macros.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_parameters.h"
 #include "iscsi_target_device.h"
 #include "iscsi_target_tpg.h"
 #include "iscsi_target_util.h"
-#include "iscsi_target_stat.h"
+#include <target/iscsi/iscsi_target_stat.h>
 
 #ifndef INITIAL_JIFFIES
 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
diff --git a/drivers/target/iscsi/iscsi_target_stat.h b/drivers/target/iscsi/iscsi_target_stat.h
deleted file mode 100644
index 3ff76b4faad3..000000000000
--- a/drivers/target/iscsi/iscsi_target_stat.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef ISCSI_TARGET_STAT_H
-#define ISCSI_TARGET_STAT_H
-
-/*
- * For struct iscsi_tiqn->tiqn_wwn default groups
- */
-extern struct config_item_type iscsi_stat_instance_cit;
-extern struct config_item_type iscsi_stat_sess_err_cit;
-extern struct config_item_type iscsi_stat_tgt_attr_cit;
-extern struct config_item_type iscsi_stat_login_cit;
-extern struct config_item_type iscsi_stat_logout_cit;
-
-/*
- * For struct iscsi_session->se_sess default groups
- */
-extern struct config_item_type iscsi_stat_sess_cit;
-
-/* iSCSI session error types */
-#define ISCSI_SESS_ERR_UNKNOWN          0
-#define ISCSI_SESS_ERR_DIGEST           1
-#define ISCSI_SESS_ERR_CXN_TIMEOUT      2
-#define ISCSI_SESS_ERR_PDU_FORMAT       3
-
-/* iSCSI session error stats */
-struct iscsi_sess_err_stats {
-        spinlock_t      lock;
-        u32             digest_errors;
-        u32             cxn_timeout_errors;
-        u32             pdu_format_errors;
-        u32             last_sess_failure_type;
-        char            last_sess_fail_rem_name[224];
-} ____cacheline_aligned;
-
-/* iSCSI login failure types (sub oids) */
-#define ISCSI_LOGIN_FAIL_OTHER          2
-#define ISCSI_LOGIN_FAIL_REDIRECT       3
-#define ISCSI_LOGIN_FAIL_AUTHORIZE      4
-#define ISCSI_LOGIN_FAIL_AUTHENTICATE   5
-#define ISCSI_LOGIN_FAIL_NEGOTIATE      6
-
-/* iSCSI login stats */
-struct iscsi_login_stats {
-        spinlock_t      lock;
-        u32             accepts;
-        u32             other_fails;
-        u32             redirects;
-        u32             authorize_fails;
-        u32             authenticate_fails;
-        u32             negotiate_fails;        /* used for notifications */
-        u64             last_fail_time;         /* time stamp (jiffies) */
-        u32             last_fail_type;
-        int             last_intr_fail_ip_family;
-        unsigned char   last_intr_fail_ip_addr[IPV6_ADDRESS_SPACE];
-        char            last_intr_fail_name[224];
-} ____cacheline_aligned;
-
-/* iSCSI logout stats */
-struct iscsi_logout_stats {
-        spinlock_t      lock;
-        u32             normal_logouts;
-        u32             abnormal_logouts;
-} ____cacheline_aligned;
-
-#endif   /*** ISCSI_TARGET_STAT_H ***/
diff --git a/drivers/target/iscsi/iscsi_target_tmr.c b/drivers/target/iscsi/iscsi_target_tmr.c
index 78404b1cc0bf..b0224a77e26d 100644
--- a/drivers/target/iscsi/iscsi_target_tmr.c
+++ b/drivers/target/iscsi/iscsi_target_tmr.c
@@ -23,7 +23,7 @@
 #include <target/target_core_fabric.h>
 #include <target/iscsi/iscsi_transport.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_seq_pdu_list.h"
 #include "iscsi_target_datain_values.h"
 #include "iscsi_target_device.h"
diff --git a/drivers/target/iscsi/iscsi_target_tpg.c b/drivers/target/iscsi/iscsi_target_tpg.c
index 9053a3c0c6e5..bdd127c0e3ae 100644
--- a/drivers/target/iscsi/iscsi_target_tpg.c
+++ b/drivers/target/iscsi/iscsi_target_tpg.c
@@ -20,7 +20,7 @@
 #include <target/target_core_fabric.h>
 #include <target/target_core_configfs.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_erl0.h"
 #include "iscsi_target_login.h"
 #include "iscsi_target_nodeattrib.h"
diff --git a/drivers/target/iscsi/iscsi_target_tq.c b/drivers/target/iscsi/iscsi_target_tq.c
index 601e9cc61e98..26aa50996473 100644
--- a/drivers/target/iscsi/iscsi_target_tq.c
+++ b/drivers/target/iscsi/iscsi_target_tq.c
@@ -20,40 +20,26 @@
 #include <linux/list.h>
 #include <linux/bitmap.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_tq.h"
 #include "iscsi_target.h"
 
-static LIST_HEAD(active_ts_list);
 static LIST_HEAD(inactive_ts_list);
-static DEFINE_SPINLOCK(active_ts_lock);
 static DEFINE_SPINLOCK(inactive_ts_lock);
 static DEFINE_SPINLOCK(ts_bitmap_lock);
 
-static void iscsi_add_ts_to_active_list(struct iscsi_thread_set *ts)
-{
-        spin_lock(&active_ts_lock);
-        list_add_tail(&ts->ts_list, &active_ts_list);
-        iscsit_global->active_ts++;
-        spin_unlock(&active_ts_lock);
-}
-
 static void iscsi_add_ts_to_inactive_list(struct iscsi_thread_set *ts)
 {
+        if (!list_empty(&ts->ts_list)) {
+                WARN_ON(1);
+                return;
+        }
         spin_lock(&inactive_ts_lock);
         list_add_tail(&ts->ts_list, &inactive_ts_list);
         iscsit_global->inactive_ts++;
         spin_unlock(&inactive_ts_lock);
 }
 
-static void iscsi_del_ts_from_active_list(struct iscsi_thread_set *ts)
-{
-        spin_lock(&active_ts_lock);
-        list_del(&ts->ts_list);
-        iscsit_global->active_ts--;
-        spin_unlock(&active_ts_lock);
-}
-
 static struct iscsi_thread_set *iscsi_get_ts_from_inactive_list(void)
 {
         struct iscsi_thread_set *ts;
@@ -66,7 +52,7 @@ static struct iscsi_thread_set *iscsi_get_ts_from_inactive_list(void)
 
         ts = list_first_entry(&inactive_ts_list, struct iscsi_thread_set, ts_list);
 
-        list_del(&ts->ts_list);
+        list_del_init(&ts->ts_list);
         iscsit_global->inactive_ts--;
         spin_unlock(&inactive_ts_lock);
 
@@ -204,8 +190,6 @@ static void iscsi_deallocate_extra_thread_sets(void)
 
 void iscsi_activate_thread_set(struct iscsi_conn *conn, struct iscsi_thread_set *ts)
 {
-        iscsi_add_ts_to_active_list(ts);
-
         spin_lock_bh(&ts->ts_state_lock);
         conn->thread_set = ts;
         ts->conn = conn;
@@ -397,7 +381,6 @@ struct iscsi_conn *iscsi_rx_thread_pre_handler(struct iscsi_thread_set *ts)
 
         if (ts->delay_inactive && (--ts->thread_count == 0)) {
                 spin_unlock_bh(&ts->ts_state_lock);
-                iscsi_del_ts_from_active_list(ts);
 
                 if (!iscsit_global->in_shutdown)
                         iscsi_deallocate_extra_thread_sets();
@@ -452,7 +435,6 @@ struct iscsi_conn *iscsi_tx_thread_pre_handler(struct iscsi_thread_set *ts)
 
         if (ts->delay_inactive && (--ts->thread_count == 0)) {
                 spin_unlock_bh(&ts->ts_state_lock);
-                iscsi_del_ts_from_active_list(ts);
 
                 if (!iscsit_global->in_shutdown)
                         iscsi_deallocate_extra_thread_sets();
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index bcd88ec99793..390df8ed72b2 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -25,7 +25,7 @@
 #include <target/target_core_configfs.h>
 #include <target/iscsi/iscsi_transport.h>
 
-#include "iscsi_target_core.h"
+#include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_parameters.h"
 #include "iscsi_target_seq_pdu_list.h"
 #include "iscsi_target_datain_values.h"
@@ -390,6 +390,7 @@ struct iscsi_cmd *iscsit_find_cmd_from_itt(
                         init_task_tag, conn->cid);
         return NULL;
 }
+EXPORT_SYMBOL(iscsit_find_cmd_from_itt);
 
 struct iscsi_cmd *iscsit_find_cmd_from_itt_or_dump(
         struct iscsi_conn *conn,
@@ -939,13 +940,8 @@ static int iscsit_add_nopin(struct iscsi_conn *conn, int want_response)
         state = (want_response) ? ISTATE_SEND_NOPIN_WANT_RESPONSE :
                                 ISTATE_SEND_NOPIN_NO_RESPONSE;
         cmd->init_task_tag = RESERVED_ITT;
-        spin_lock_bh(&conn->sess->ttt_lock);
-        cmd->targ_xfer_tag = (want_response) ? conn->sess->targ_xfer_tag++ :
-                        0xFFFFFFFF;
-        if (want_response && (cmd->targ_xfer_tag == 0xFFFFFFFF))
-                cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++;
-        spin_unlock_bh(&conn->sess->ttt_lock);
-
+        cmd->targ_xfer_tag = (want_response) ?
+                             session_get_next_ttt(conn->sess) : 0xFFFFFFFF;
         spin_lock_bh(&conn->cmd_lock);
         list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
         spin_unlock_bh(&conn->cmd_lock);
diff --git a/drivers/target/iscsi/iscsi_target_util.h b/drivers/target/iscsi/iscsi_target_util.h
index a68508c4fec8..1ab754a671ff 100644
--- a/drivers/target/iscsi/iscsi_target_util.h
+++ b/drivers/target/iscsi/iscsi_target_util.h
@@ -16,7 +16,6 @@ extern struct iscsi_r2t *iscsit_get_holder_for_r2tsn(struct iscsi_cmd *, u32);
 extern int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
                                unsigned char * ,__be32 cmdsn);
 extern int iscsit_check_unsolicited_dataout(struct iscsi_cmd *, unsigned char *);
-extern struct iscsi_cmd *iscsit_find_cmd_from_itt(struct iscsi_conn *, itt_t);
 extern struct iscsi_cmd *iscsit_find_cmd_from_itt_or_dump(struct iscsi_conn *,
                         itt_t, u32);
 extern struct iscsi_cmd *iscsit_find_cmd_from_ttt(struct iscsi_conn *, u32);
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index d836de200a03..44620fb6bd45 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -494,6 +494,11 @@ fd_execute_write_same(struct se_cmd *cmd)
                 target_complete_cmd(cmd, SAM_STAT_GOOD);
                 return 0;
         }
+        if (cmd->prot_op) {
+                pr_err("WRITE_SAME: Protection information with FILEIO"
+                       " backends not supported\n");
+                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+        }
         sg = &cmd->t_data_sg[0];
 
         if (cmd->t_data_nents > 1 ||
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 78346b850968..d4a4b0fb444a 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -464,6 +464,11 @@ iblock_execute_write_same(struct se_cmd *cmd)
         sector_t block_lba = cmd->t_task_lba;
         sector_t sectors = sbc_get_write_same_sectors(cmd);
 
+        if (cmd->prot_op) {
+                pr_err("WRITE_SAME: Protection information with IBLOCK"
+                       " backends not supported\n");
+                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+        }
         sg = &cmd->t_data_sg[0];
 
         if (cmd->t_data_nents > 1 ||
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 283cf786ef98..2de6fb8cee8d 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -1874,8 +1874,8 @@ static int core_scsi3_update_aptpl_buf(
                 }
 
                 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
-                        pr_err("Unable to update renaming"
-                                " APTPL metadata\n");
+                        pr_err("Unable to update renaming APTPL metadata,"
+                               " reallocating larger buffer\n");
                         ret = -EMSGSIZE;
                         goto out;
                 }
@@ -1892,8 +1892,8 @@ static int core_scsi3_update_aptpl_buf(
                         lun->lun_sep->sep_rtpi, lun->unpacked_lun, reg_count);
 
                 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
-                        pr_err("Unable to update renaming"
-                                " APTPL metadata\n");
+                        pr_err("Unable to update renaming APTPL metadata,"
+                               " reallocating larger buffer\n");
                         ret = -EMSGSIZE;
                         goto out;
                 }
@@ -1956,7 +1956,7 @@ static int __core_scsi3_write_aptpl_to_file(
 static sense_reason_t core_scsi3_update_and_write_aptpl(struct se_device *dev, bool aptpl)
 {
         unsigned char *buf;
-        int rc;
+        int rc, len = PR_APTPL_BUF_LEN;
 
         if (!aptpl) {
                 char *null_buf = "No Registrations or Reservations\n";
@@ -1970,25 +1970,26 @@ static sense_reason_t core_scsi3_update_and_write_aptpl(struct se_device *dev, b
 
                 return 0;
         }
-
-        buf = kzalloc(PR_APTPL_BUF_LEN, GFP_KERNEL);
+retry:
+        buf = vzalloc(len);
         if (!buf)
                 return TCM_OUT_OF_RESOURCES;
 
-        rc = core_scsi3_update_aptpl_buf(dev, buf, PR_APTPL_BUF_LEN);
+        rc = core_scsi3_update_aptpl_buf(dev, buf, len);
         if (rc < 0) {
-                kfree(buf);
-                return TCM_OUT_OF_RESOURCES;
+                vfree(buf);
+                len *= 2;
+                goto retry;
         }
 
         rc = __core_scsi3_write_aptpl_to_file(dev, buf);
         if (rc != 0) {
                 pr_err("SPC-3 PR: Could not update APTPL\n");
-                kfree(buf);
+                vfree(buf);
                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
         }
         dev->t10_pr.pr_aptpl_active = 1;
-        kfree(buf);
+        vfree(buf);
         pr_debug("SPC-3 PR: Set APTPL Bit Activated\n");
         return 0;
 }
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index cd4bed7b2757..9a2f9d3a6e70 100644
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -37,6 +37,9 @@
 #include "target_core_alua.h"
 
 static sense_reason_t
+sbc_check_prot(struct se_device *, struct se_cmd *, unsigned char *, u32, bool);
+
+static sense_reason_t
 sbc_emulate_readcapacity(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
@@ -251,7 +254,10 @@ static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
 static sense_reason_t
 sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *ops)
 {
+        struct se_device *dev = cmd->se_dev;
+        sector_t end_lba = dev->transport->get_blocks(dev) + 1;
         unsigned int sectors = sbc_get_write_same_sectors(cmd);
+        sense_reason_t ret;
 
         if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
                 pr_err("WRITE_SAME PBDATA and LBDATA"
@@ -264,6 +270,16 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *o
                         sectors, cmd->se_dev->dev_attrib.max_write_same_len);
                 return TCM_INVALID_CDB_FIELD;
         }
+        /*
+         * Sanity check for LBA wrap and request past end of device.
+         */
+        if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
+            ((cmd->t_task_lba + sectors) > end_lba)) {
+                pr_err("WRITE_SAME exceeds last lba %llu (lba %llu, sectors %u)\n",
+                       (unsigned long long)end_lba, cmd->t_task_lba, sectors);
+                return TCM_ADDRESS_OUT_OF_RANGE;
+        }
+
         /* We always have ANC_SUP == 0 so setting ANCHOR is always an error */
         if (flags[0] & 0x10) {
                 pr_warn("WRITE SAME with ANCHOR not supported\n");
@@ -277,12 +293,21 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *o
                 if (!ops->execute_write_same_unmap)
                         return TCM_UNSUPPORTED_SCSI_OPCODE;
 
+                if (!dev->dev_attrib.emulate_tpws) {
+                        pr_err("Got WRITE_SAME w/ UNMAP=1, but backend device"
+                               " has emulate_tpws disabled\n");
+                        return TCM_UNSUPPORTED_SCSI_OPCODE;
+                }
                 cmd->execute_cmd = ops->execute_write_same_unmap;
                 return 0;
         }
         if (!ops->execute_write_same)
                 return TCM_UNSUPPORTED_SCSI_OPCODE;
 
+        ret = sbc_check_prot(dev, cmd, &cmd->t_task_cdb[0], sectors, true);
+        if (ret)
+                return ret;
+
         cmd->execute_cmd = ops->execute_write_same;
         return 0;
 }
@@ -614,14 +639,21 @@ sbc_set_prot_op_checks(u8 protect, enum target_prot_type prot_type,
         return 0;
 }
 
-static bool
+static sense_reason_t
 sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb,
                u32 sectors, bool is_write)
 {
         u8 protect = cdb[1] >> 5;
 
-        if ((!cmd->t_prot_sg || !cmd->t_prot_nents) && cmd->prot_pto)
-                return true;
+        if (!cmd->t_prot_sg || !cmd->t_prot_nents) {
+                if (protect && !dev->dev_attrib.pi_prot_type) {
+                        pr_err("CDB contains protect bit, but device does not"
+                               " advertise PROTECT=1 feature bit\n");
+                        return TCM_INVALID_CDB_FIELD;
+                }
+                if (cmd->prot_pto)
+                        return TCM_NO_SENSE;
+        }
 
         switch (dev->dev_attrib.pi_prot_type) {
         case TARGET_DIF_TYPE3_PROT:
@@ -629,7 +661,7 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb,
                 break;
         case TARGET_DIF_TYPE2_PROT:
                 if (protect)
-                        return false;
+                        return TCM_INVALID_CDB_FIELD;
 
                 cmd->reftag_seed = cmd->t_task_lba;
                 break;
@@ -638,12 +670,12 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb,
                 break;
         case TARGET_DIF_TYPE0_PROT:
         default:
-                return true;
+                return TCM_NO_SENSE;
         }
 
         if (sbc_set_prot_op_checks(protect, dev->dev_attrib.pi_prot_type,
                                    is_write, cmd))
-                return false;
+                return TCM_INVALID_CDB_FIELD;
 
         cmd->prot_type = dev->dev_attrib.pi_prot_type;
         cmd->prot_length = dev->prot_length * sectors;
@@ -662,7 +694,30 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb,
                  __func__, cmd->prot_type, cmd->data_length, cmd->prot_length,
                  cmd->prot_op, cmd->prot_checks);
 
-        return true;
+        return TCM_NO_SENSE;
+}
+
+static int
+sbc_check_dpofua(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb)
+{
+        if (cdb[1] & 0x10) {
+                if (!dev->dev_attrib.emulate_dpo) {
+                        pr_err("Got CDB: 0x%02x with DPO bit set, but device"
+                               " does not advertise support for DPO\n", cdb[0]);
+                        return -EINVAL;
+                }
+        }
+        if (cdb[1] & 0x8) {
+                if (!dev->dev_attrib.emulate_fua_write ||
+                    !dev->dev_attrib.emulate_write_cache) {
+                        pr_err("Got CDB: 0x%02x with FUA bit set, but device"
+                               " does not advertise support for FUA write\n",
+                               cdb[0]);
+                        return -EINVAL;
+                }
+                cmd->se_cmd_flags |= SCF_FUA;
+        }
+        return 0;
 }
 
 sense_reason_t
@@ -686,8 +741,12 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 sectors = transport_get_sectors_10(cdb);
                 cmd->t_task_lba = transport_lba_32(cdb);
 
-                if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
-                        return TCM_UNSUPPORTED_SCSI_OPCODE;
+                if (sbc_check_dpofua(dev, cmd, cdb))
+                        return TCM_INVALID_CDB_FIELD;
+
+                ret = sbc_check_prot(dev, cmd, cdb, sectors, false);
+                if (ret)
+                        return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
                 cmd->execute_rw = ops->execute_rw;
@@ -697,8 +756,12 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 sectors = transport_get_sectors_12(cdb);
                 cmd->t_task_lba = transport_lba_32(cdb);
 
-                if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
-                        return TCM_UNSUPPORTED_SCSI_OPCODE;
+                if (sbc_check_dpofua(dev, cmd, cdb))
+                        return TCM_INVALID_CDB_FIELD;
+
+                ret = sbc_check_prot(dev, cmd, cdb, sectors, false);
+                if (ret)
+                        return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
                 cmd->execute_rw = ops->execute_rw;
@@ -708,8 +771,12 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 sectors = transport_get_sectors_16(cdb);
                 cmd->t_task_lba = transport_lba_64(cdb);
 
-                if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
-                        return TCM_UNSUPPORTED_SCSI_OPCODE;
+                if (sbc_check_dpofua(dev, cmd, cdb))
+                        return TCM_INVALID_CDB_FIELD;
+
+                ret = sbc_check_prot(dev, cmd, cdb, sectors, false);
+                if (ret)
+                        return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
                 cmd->execute_rw = ops->execute_rw;
@@ -727,11 +794,13 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 sectors = transport_get_sectors_10(cdb);
                 cmd->t_task_lba = transport_lba_32(cdb);
 
-                if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
-                        return TCM_UNSUPPORTED_SCSI_OPCODE;
+                if (sbc_check_dpofua(dev, cmd, cdb))
+                        return TCM_INVALID_CDB_FIELD;
+
+                ret = sbc_check_prot(dev, cmd, cdb, sectors, true);
+                if (ret)
+                        return ret;
 
-                if (cdb[1] & 0x8)
-                        cmd->se_cmd_flags |= SCF_FUA;
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
                 cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
@@ -740,11 +809,13 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 sectors = transport_get_sectors_12(cdb);
                 cmd->t_task_lba = transport_lba_32(cdb);
 
-                if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
-                        return TCM_UNSUPPORTED_SCSI_OPCODE;
+                if (sbc_check_dpofua(dev, cmd, cdb))
+                        return TCM_INVALID_CDB_FIELD;
+
+                ret = sbc_check_prot(dev, cmd, cdb, sectors, true);
+                if (ret)
+                        return ret;
 
-                if (cdb[1] & 0x8)
-                        cmd->se_cmd_flags |= SCF_FUA;
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
                 cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
@@ -753,11 +824,13 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 sectors = transport_get_sectors_16(cdb);
                 cmd->t_task_lba = transport_lba_64(cdb);
 
-                if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
-                        return TCM_UNSUPPORTED_SCSI_OPCODE;
+                if (sbc_check_dpofua(dev, cmd, cdb))
+                        return TCM_INVALID_CDB_FIELD;
+
+                ret = sbc_check_prot(dev, cmd, cdb, sectors, true);
+                if (ret)
+                        return ret;
 
-                if (cdb[1] & 0x8)
-                        cmd->se_cmd_flags |= SCF_FUA;
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
                 cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
@@ -768,6 +841,9 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         return TCM_INVALID_CDB_FIELD;
                 sectors = transport_get_sectors_10(cdb);
 
+                if (sbc_check_dpofua(dev, cmd, cdb))
+                        return TCM_INVALID_CDB_FIELD;
+
                 cmd->t_task_lba = transport_lba_32(cdb);
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 
@@ -777,8 +853,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 cmd->transport_complete_callback = &xdreadwrite_callback;
-                if (cdb[1] & 0x8)
-                        cmd->se_cmd_flags |= SCF_FUA;
                 break;
         case VARIABLE_LENGTH_CMD:
         {
@@ -787,6 +861,8 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 case XDWRITEREAD_32:
                         sectors = transport_get_sectors_32(cdb);
 
+                        if (sbc_check_dpofua(dev, cmd, cdb))
+                                return TCM_INVALID_CDB_FIELD;
                         /*
                          * Use WRITE_32 and READ_32 opcodes for the emulated
                          * XDWRITE_READ_32 logic.
@@ -801,8 +877,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         cmd->execute_rw = ops->execute_rw;
                         cmd->execute_cmd = sbc_execute_rw;
                         cmd->transport_complete_callback = &xdreadwrite_callback;
-                        if (cdb[1] & 0x8)
-                                cmd->se_cmd_flags |= SCF_FUA;
                         break;
                 case WRITE_SAME_32:
                         sectors = transport_get_sectors_32(cdb);
@@ -888,6 +962,11 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 if (!ops->execute_unmap)
                         return TCM_UNSUPPORTED_SCSI_OPCODE;
 
+                if (!dev->dev_attrib.emulate_tpu) {
+                        pr_err("Got UNMAP, but backend device has"
+                               " emulate_tpu disabled\n");
+                        return TCM_UNSUPPORTED_SCSI_OPCODE;
+                }
                 size = get_unaligned_be16(&cdb[7]);
                 cmd->execute_cmd = ops->execute_unmap;
                 break;
@@ -955,7 +1034,8 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 unsigned long long end_lba;
 check_lba:
                 end_lba = dev->transport->get_blocks(dev) + 1;
-                if (cmd->t_task_lba + sectors > end_lba) {
+                if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
+                    ((cmd->t_task_lba + sectors) > end_lba)) {
                         pr_err("cmd exceeds last lba %llu "
                                 "(lba %llu, sectors %u)\n",
                                 end_lba, cmd->t_task_lba, sectors);
diff --git a/drivers/target/target_core_spc.c b/drivers/target/target_core_spc.c
index 4c71657da56a..460e93109473 100644
--- a/drivers/target/target_core_spc.c
+++ b/drivers/target/target_core_spc.c
@@ -647,7 +647,7 @@ spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
          * support the use of the WRITE SAME (16) command to unmap LBAs.
          */
         if (dev->dev_attrib.emulate_tpws != 0)
-                buf[5] |= 0x40;
+                buf[5] |= 0x40 | 0x20;
 
         return 0;
 }
diff --git a/drivers/thermal/int340x_thermal/Makefile b/drivers/thermal/int340x_thermal/Makefile
index d4413698a85f..ba77a34f659f 100644
--- a/drivers/thermal/int340x_thermal/Makefile
+++ b/drivers/thermal/int340x_thermal/Makefile
@@ -1,4 +1,5 @@
 obj-$(CONFIG_INT340X_THERMAL)   += int3400_thermal.o
+obj-$(CONFIG_INT340X_THERMAL)   += int340x_thermal_zone.o
 obj-$(CONFIG_INT340X_THERMAL)   += int3402_thermal.o
 obj-$(CONFIG_INT340X_THERMAL)   += int3403_thermal.o
 obj-$(CONFIG_INT340X_THERMAL)   += processor_thermal_device.o
diff --git a/drivers/thermal/int340x_thermal/int3400_thermal.c b/drivers/thermal/int340x_thermal/int3400_thermal.c
index 65a98a97df07..031018e7a65b 100644
--- a/drivers/thermal/int340x_thermal/int3400_thermal.c
+++ b/drivers/thermal/int340x_thermal/int3400_thermal.c
@@ -18,19 +18,15 @@
 
 enum int3400_thermal_uuid {
         INT3400_THERMAL_PASSIVE_1,
-        INT3400_THERMAL_PASSIVE_2,
         INT3400_THERMAL_ACTIVE,
         INT3400_THERMAL_CRITICAL,
-        INT3400_THERMAL_COOLING_MODE,
         INT3400_THERMAL_MAXIMUM_UUID,
 };
 
 static u8 *int3400_thermal_uuids[INT3400_THERMAL_MAXIMUM_UUID] = {
         "42A441D6-AE6A-462b-A84B-4A8CE79027D3",
-        "9E04115A-AE87-4D1C-9500-0F3E340BFE75",
         "3A95C389-E4B8-4629-A526-C52C88626BAE",
         "97C68AE7-15FA-499c-B8C9-5DA81D606E0A",
-        "16CAF1B7-DD38-40ed-B1C1-1B8A1913D531",
 };
 
 struct int3400_thermal_priv {
@@ -266,13 +262,12 @@ static int int3400_thermal_probe(struct platform_device *pdev)
         result = acpi_parse_art(priv->adev->handle, &priv->art_count,
                                 &priv->arts, true);
         if (result)
-                goto free_priv;
-
+                dev_dbg(&pdev->dev, "_ART table parsing error\n");
 
         result = acpi_parse_trt(priv->adev->handle, &priv->trt_count,
                                 &priv->trts, true);
         if (result)
-                goto free_art;
+                dev_dbg(&pdev->dev, "_TRT table parsing error\n");
 
         platform_set_drvdata(pdev, priv);
 
@@ -285,7 +280,7 @@ static int int3400_thermal_probe(struct platform_device *pdev)
                                                 &int3400_thermal_params, 0, 0);
         if (IS_ERR(priv->thermal)) {
                 result = PTR_ERR(priv->thermal);
-                goto free_trt;
+                goto free_art_trt;
         }
 
         priv->rel_misc_dev_res = acpi_thermal_rel_misc_device_add(
@@ -299,9 +294,8 @@ static int int3400_thermal_probe(struct platform_device *pdev)
 
 free_zone:
         thermal_zone_device_unregister(priv->thermal);
-free_trt:
+free_art_trt:
         kfree(priv->trts);
-free_art:
         kfree(priv->arts);
 free_priv:
         kfree(priv);
diff --git a/drivers/thermal/int340x_thermal/int3402_thermal.c b/drivers/thermal/int340x_thermal/int3402_thermal.c
index c5cbc3af3a05..69df3d960303 100644
--- a/drivers/thermal/int340x_thermal/int3402_thermal.c
+++ b/drivers/thermal/int340x_thermal/int3402_thermal.c
@@ -14,152 +14,39 @@
 #include <linux/platform_device.h>
 #include <linux/acpi.h>
 #include <linux/thermal.h>
+#include "int340x_thermal_zone.h"
 
-#define ACPI_ACTIVE_COOLING_MAX_NR 10
-
-struct active_trip {
-        unsigned long temp;
-        int id;
-        bool valid;
-};
+#define INT3402_PERF_CHANGED_EVENT      0x80
+#define INT3402_THERMAL_EVENT           0x90
 
 struct int3402_thermal_data {
-        unsigned long *aux_trips;
-        int aux_trip_nr;
-        unsigned long psv_temp;
-        int psv_trip_id;
-        unsigned long crt_temp;
-        int crt_trip_id;
-        unsigned long hot_temp;
-        int hot_trip_id;
-        struct active_trip act_trips[ACPI_ACTIVE_COOLING_MAX_NR];
         acpi_handle *handle;
+        struct int34x_thermal_zone *int340x_zone;
 };
 
-static int int3402_thermal_get_zone_temp(struct thermal_zone_device *zone,
-                                         unsigned long *temp)
-{
-        struct int3402_thermal_data *d = zone->devdata;
-        unsigned long long tmp;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(d->handle, "_TMP", NULL, &tmp);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        /* _TMP returns the temperature in tenths of degrees Kelvin */
-        *temp = DECI_KELVIN_TO_MILLICELSIUS(tmp);
-
-        return 0;
-}
-
-static int int3402_thermal_get_trip_temp(struct thermal_zone_device *zone,
-                                         int trip, unsigned long *temp)
+static void int3402_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct int3402_thermal_data *d = zone->devdata;
-        int i;
-
-        if (trip < d->aux_trip_nr)
-                *temp = d->aux_trips[trip];
-        else if (trip == d->crt_trip_id)
-                *temp = d->crt_temp;
-        else if (trip == d->psv_trip_id)
-                *temp = d->psv_temp;
-        else if (trip == d->hot_trip_id)
-                *temp = d->hot_temp;
-        else {
-                for (i = 0; i < ACPI_ACTIVE_COOLING_MAX_NR; i++) {
-                        if (d->act_trips[i].valid &&
-                            d->act_trips[i].id == trip) {
-                                *temp = d->act_trips[i].temp;
-                                break;
-                        }
-                }
-                if (i == ACPI_ACTIVE_COOLING_MAX_NR)
-                        return -EINVAL;
+        struct int3402_thermal_data *priv = data;
+
+        if (!priv)
+                return;
+
+        switch (event) {
+        case INT3402_PERF_CHANGED_EVENT:
+                break;
+        case INT3402_THERMAL_EVENT:
+                int340x_thermal_zone_device_update(priv->int340x_zone);
+                break;
+        default:
+                break;
         }
-        return 0;
-}
-
-static int int3402_thermal_get_trip_type(struct thermal_zone_device *zone,
-                                         int trip, enum thermal_trip_type *type)
-{
-        struct int3402_thermal_data *d = zone->devdata;
-        int i;
-
-        if (trip < d->aux_trip_nr)
-                *type = THERMAL_TRIP_PASSIVE;
-        else if (trip == d->crt_trip_id)
-                *type = THERMAL_TRIP_CRITICAL;
-        else if (trip == d->hot_trip_id)
-                *type = THERMAL_TRIP_HOT;
-        else if (trip == d->psv_trip_id)
-                *type = THERMAL_TRIP_PASSIVE;
-        else {
-                for (i = 0; i < ACPI_ACTIVE_COOLING_MAX_NR; i++) {
-                        if (d->act_trips[i].valid &&
-                            d->act_trips[i].id == trip) {
-                                *type = THERMAL_TRIP_ACTIVE;
-                                break;
-                        }
-                }
-                if (i == ACPI_ACTIVE_COOLING_MAX_NR)
-                        return -EINVAL;
-        }
-        return 0;
-}
-
-static int int3402_thermal_set_trip_temp(struct thermal_zone_device *zone, int trip,
-                                  unsigned long temp)
-{
-        struct int3402_thermal_data *d = zone->devdata;
-        acpi_status status;
-        char name[10];
-
-        snprintf(name, sizeof(name), "PAT%d", trip);
-        status = acpi_execute_simple_method(d->handle, name,
-                        MILLICELSIUS_TO_DECI_KELVIN(temp));
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        d->aux_trips[trip] = temp;
-        return 0;
-}
-
-static struct thermal_zone_device_ops int3402_thermal_zone_ops = {
-        .get_temp       = int3402_thermal_get_zone_temp,
-        .get_trip_temp  = int3402_thermal_get_trip_temp,
-        .get_trip_type  = int3402_thermal_get_trip_type,
-        .set_trip_temp  = int3402_thermal_set_trip_temp,
-};
-
-static struct thermal_zone_params int3402_thermal_params = {
-        .governor_name = "user_space",
-        .no_hwmon = true,
-};
-
-static int int3402_thermal_get_temp(acpi_handle handle, char *name,
-                                    unsigned long *temp)
-{
-        unsigned long long r;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(handle, name, NULL, &r);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        *temp = DECI_KELVIN_TO_MILLICELSIUS(r);
-        return 0;
 }
 
 static int int3402_thermal_probe(struct platform_device *pdev)
 {
         struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
         struct int3402_thermal_data *d;
-        struct thermal_zone_device *zone;
-        acpi_status status;
-        unsigned long long trip_cnt;
-        int trip_mask = 0, i;
+        int ret;
 
         if (!acpi_has_method(adev->handle, "_TMP"))
                 return -ENODEV;
@@ -168,54 +55,33 @@ static int int3402_thermal_probe(struct platform_device *pdev)
         if (!d)
                 return -ENOMEM;
 
-        status = acpi_evaluate_integer(adev->handle, "PATC", NULL, &trip_cnt);
-        if (ACPI_FAILURE(status))
-                trip_cnt = 0;
-        else {
-                d->aux_trips = devm_kzalloc(&pdev->dev,
-                                sizeof(*d->aux_trips) * trip_cnt, GFP_KERNEL);
-                if (!d->aux_trips)
-                        return -ENOMEM;
-                trip_mask = trip_cnt - 1;
-                d->handle = adev->handle;
-                d->aux_trip_nr = trip_cnt;
-        }
-
-        d->crt_trip_id = -1;
-        if (!int3402_thermal_get_temp(adev->handle, "_CRT", &d->crt_temp))
-                d->crt_trip_id = trip_cnt++;
-        d->hot_trip_id = -1;
-        if (!int3402_thermal_get_temp(adev->handle, "_HOT", &d->hot_temp))
-                d->hot_trip_id = trip_cnt++;
-        d->psv_trip_id = -1;
-        if (!int3402_thermal_get_temp(adev->handle, "_PSV", &d->psv_temp))
-                d->psv_trip_id = trip_cnt++;
-        for (i = 0; i < ACPI_ACTIVE_COOLING_MAX_NR; i++) {
-                char name[5] = { '_', 'A', 'C', '0' + i, '\0' };
-                if (int3402_thermal_get_temp(adev->handle, name,
-                                             &d->act_trips[i].temp))
-                        break;
-                d->act_trips[i].id = trip_cnt++;
-                d->act_trips[i].valid = true;
+        d->int340x_zone = int340x_thermal_zone_add(adev, NULL);
+        if (IS_ERR(d->int340x_zone))
+                return PTR_ERR(d->int340x_zone);
+
+        ret = acpi_install_notify_handler(adev->handle,
+                                          ACPI_DEVICE_NOTIFY,
+                                          int3402_notify,
+                                          d);
+        if (ret) {
+                int340x_thermal_zone_remove(d->int340x_zone);
+                return ret;
         }
 
-        zone = thermal_zone_device_register(acpi_device_bid(adev), trip_cnt,
-                                            trip_mask, d,
-                                            &int3402_thermal_zone_ops,
-                                            &int3402_thermal_params,
-                                            0, 0);
-        if (IS_ERR(zone))
-                return PTR_ERR(zone);
-        platform_set_drvdata(pdev, zone);
+        d->handle = adev->handle;
+        platform_set_drvdata(pdev, d);
 
         return 0;
 }
 
 static int int3402_thermal_remove(struct platform_device *pdev)
 {
-        struct thermal_zone_device *zone = platform_get_drvdata(pdev);
+        struct int3402_thermal_data *d = platform_get_drvdata(pdev);
+
+        acpi_remove_notify_handler(d->handle,
+                                   ACPI_DEVICE_NOTIFY, int3402_notify);
+        int340x_thermal_zone_remove(d->int340x_zone);
 
-        thermal_zone_device_unregister(zone);
         return 0;
 }
 
diff --git a/drivers/thermal/int340x_thermal/int3403_thermal.c b/drivers/thermal/int340x_thermal/int3403_thermal.c
index 0faf500d8a77..50a7a08e3a15 100644
--- a/drivers/thermal/int340x_thermal/int3403_thermal.c
+++ b/drivers/thermal/int340x_thermal/int3403_thermal.c
@@ -19,6 +19,7 @@
 #include <linux/acpi.h>
 #include <linux/thermal.h>
 #include <linux/platform_device.h>
+#include "int340x_thermal_zone.h"
 
 #define INT3403_TYPE_SENSOR             0x03
 #define INT3403_TYPE_CHARGER            0x0B
@@ -26,18 +27,9 @@
 #define INT3403_PERF_CHANGED_EVENT      0x80
 #define INT3403_THERMAL_EVENT           0x90
 
-#define DECI_KELVIN_TO_MILLI_CELSIUS(t, off) (((t) - (off)) * 100)
-#define KELVIN_OFFSET   2732
-#define MILLI_CELSIUS_TO_DECI_KELVIN(t, off) (((t) / 100) + (off))
-
+/* Preserved structure for future expandbility */
 struct int3403_sensor {
-        struct thermal_zone_device *tzone;
-        unsigned long *thresholds;
-        unsigned long   crit_temp;
-        int             crit_trip_id;
-        unsigned long   psv_temp;
-        int             psv_trip_id;
-
+        struct int34x_thermal_zone *int340x_zone;
 };
 
 struct int3403_performance_state {
@@ -63,126 +55,6 @@ struct int3403_priv {
         void *priv;
 };
 
-static int sys_get_curr_temp(struct thermal_zone_device *tzone,
-                                unsigned long *temp)
-{
-        struct int3403_priv *priv = tzone->devdata;
-        struct acpi_device *device = priv->adev;
-        unsigned long long tmp;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(device->handle, "_TMP", NULL, &tmp);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(tmp, KELVIN_OFFSET);
-
-        return 0;
-}
-
-static int sys_get_trip_hyst(struct thermal_zone_device *tzone,
-                int trip, unsigned long *temp)
-{
-        struct int3403_priv *priv = tzone->devdata;
-        struct acpi_device *device = priv->adev;
-        unsigned long long hyst;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(device->handle, "GTSH", NULL, &hyst);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        /*
-         * Thermal hysteresis represents a temperature difference.
-         * Kelvin and Celsius have same degree size. So the
-         * conversion here between tenths of degree Kelvin unit
-         * and Milli-Celsius unit is just to multiply 100.
-         */
-        *temp = hyst * 100;
-
-        return 0;
-}
-
-static int sys_get_trip_temp(struct thermal_zone_device *tzone,
-                int trip, unsigned long *temp)
-{
-        struct int3403_priv *priv = tzone->devdata;
-        struct int3403_sensor *obj = priv->priv;
-
-        if (priv->type != INT3403_TYPE_SENSOR || !obj)
-                return -EINVAL;
-
-        if (trip == obj->crit_trip_id)
-                *temp = obj->crit_temp;
-        else if (trip == obj->psv_trip_id)
-                *temp = obj->psv_temp;
-        else {
-                /*
-                 * get_trip_temp is a mandatory callback but
-                 * PATx method doesn't return any value, so return
-                 * cached value, which was last set from user space
-                 */
-                *temp = obj->thresholds[trip];
-        }
-
-        return 0;
-}
-
-static int sys_get_trip_type(struct thermal_zone_device *thermal,
-                int trip, enum thermal_trip_type *type)
-{
-        struct int3403_priv *priv = thermal->devdata;
-        struct int3403_sensor *obj = priv->priv;
-
-        /* Mandatory callback, may not mean much here */
-        if (trip == obj->crit_trip_id)
-                *type = THERMAL_TRIP_CRITICAL;
-        else
-                *type = THERMAL_TRIP_PASSIVE;
-
-        return 0;
-}
-
-int sys_set_trip_temp(struct thermal_zone_device *tzone, int trip,
-                                                        unsigned long temp)
-{
-        struct int3403_priv *priv = tzone->devdata;
-        struct acpi_device *device = priv->adev;
-        struct int3403_sensor *obj = priv->priv;
-        acpi_status status;
-        char name[10];
-        int ret = 0;
-
-        snprintf(name, sizeof(name), "PAT%d", trip);
-        if (acpi_has_method(device->handle, name)) {
-                status = acpi_execute_simple_method(device->handle, name,
-                                MILLI_CELSIUS_TO_DECI_KELVIN(temp,
-                                                        KELVIN_OFFSET));
-                if (ACPI_FAILURE(status))
-                        ret = -EIO;
-                else
-                        obj->thresholds[trip] = temp;
-        } else {
-                ret = -EIO;
-                dev_err(&device->dev, "sys_set_trip_temp: method not found\n");
-        }
-
-        return ret;
-}
-
-static struct thermal_zone_device_ops tzone_ops = {
-        .get_temp = sys_get_curr_temp,
-        .get_trip_temp = sys_get_trip_temp,
-        .get_trip_type = sys_get_trip_type,
-        .set_trip_temp = sys_set_trip_temp,
-        .get_trip_hyst =  sys_get_trip_hyst,
-};
-
-static struct thermal_zone_params int3403_thermal_params = {
-        .governor_name = "user_space",
-        .no_hwmon = true,
-};
-
 static void int3403_notify(acpi_handle handle,
                 u32 event, void *data)
 {
@@ -200,7 +72,7 @@ static void int3403_notify(acpi_handle handle,
         case INT3403_PERF_CHANGED_EVENT:
                 break;
         case INT3403_THERMAL_EVENT:
-                thermal_zone_device_update(obj->tzone);
+                int340x_thermal_zone_device_update(obj->int340x_zone);
                 break;
         default:
                 dev_err(&priv->pdev->dev, "Unsupported event [0x%x]\n", event);
@@ -208,41 +80,10 @@ static void int3403_notify(acpi_handle handle,
         }
 }
 
-static int sys_get_trip_crt(struct acpi_device *device, unsigned long *temp)
-{
-        unsigned long long crt;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(device->handle, "_CRT", NULL, &crt);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(crt, KELVIN_OFFSET);
-
-        return 0;
-}
-
-static int sys_get_trip_psv(struct acpi_device *device, unsigned long *temp)
-{
-        unsigned long long psv;
-        acpi_status status;
-
-        status = acpi_evaluate_integer(device->handle, "_PSV", NULL, &psv);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        *temp = DECI_KELVIN_TO_MILLI_CELSIUS(psv, KELVIN_OFFSET);
-
-        return 0;
-}
-
 static int int3403_sensor_add(struct int3403_priv *priv)
 {
         int result = 0;
-        acpi_status status;
         struct int3403_sensor *obj;
-        unsigned long long trip_cnt;
-        int trip_mask = 0;
 
         obj = devm_kzalloc(&priv->pdev->dev, sizeof(*obj), GFP_KERNEL);
         if (!obj)
@@ -250,39 +91,9 @@ static int int3403_sensor_add(struct int3403_priv *priv)
 
         priv->priv = obj;
 
-        status = acpi_evaluate_integer(priv->adev->handle, "PATC", NULL,
-                                                &trip_cnt);
-        if (ACPI_FAILURE(status))
-                trip_cnt = 0;
-
-        if (trip_cnt) {
-                /* We have to cache, thresholds can't be readback */
-                obj->thresholds = devm_kzalloc(&priv->pdev->dev,
-                                        sizeof(*obj->thresholds) * trip_cnt,
-                                        GFP_KERNEL);
-                if (!obj->thresholds) {
-                        result = -ENOMEM;
-                        goto err_free_obj;
-                }
-                trip_mask = BIT(trip_cnt) - 1;
-        }
-
-        obj->psv_trip_id = -1;
-        if (!sys_get_trip_psv(priv->adev, &obj->psv_temp))
-                obj->psv_trip_id = trip_cnt++;
-
-        obj->crit_trip_id = -1;
-        if (!sys_get_trip_crt(priv->adev, &obj->crit_temp))
-                obj->crit_trip_id = trip_cnt++;
-
-        obj->tzone = thermal_zone_device_register(acpi_device_bid(priv->adev),
-                                trip_cnt, trip_mask, priv, &tzone_ops,
-                                &int3403_thermal_params, 0, 0);
-        if (IS_ERR(obj->tzone)) {
-                result = PTR_ERR(obj->tzone);
-                obj->tzone = NULL;
-                goto err_free_obj;
-        }
+        obj->int340x_zone = int340x_thermal_zone_add(priv->adev, NULL);
+        if (IS_ERR(obj->int340x_zone))
+                return PTR_ERR(obj->int340x_zone);
 
         result = acpi_install_notify_handler(priv->adev->handle,
                         ACPI_DEVICE_NOTIFY, int3403_notify,
@@ -293,7 +104,7 @@ static int int3403_sensor_add(struct int3403_priv *priv)
         return 0;
 
  err_free_obj:
-        thermal_zone_device_unregister(obj->tzone);
+        int340x_thermal_zone_remove(obj->int340x_zone);
         return result;
 }
 
@@ -303,7 +114,8 @@ static int int3403_sensor_remove(struct int3403_priv *priv)
 
         acpi_remove_notify_handler(priv->adev->handle,
                                    ACPI_DEVICE_NOTIFY, int3403_notify);
-        thermal_zone_device_unregister(obj->tzone);
+        int340x_thermal_zone_remove(obj->int340x_zone);
+
         return 0;
 }
 
diff --git a/drivers/thermal/int340x_thermal/int340x_thermal_zone.c b/drivers/thermal/int340x_thermal/int340x_thermal_zone.c
new file mode 100644
index 000000000000..f88b08877025
--- /dev/null
+++ b/drivers/thermal/int340x_thermal/int340x_thermal_zone.c
@@ -0,0 +1,276 @@
+/*
+ * int340x_thermal_zone.c
+ * Copyright (c) 2015, Intel Corporation.
+ *
+ * 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.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/thermal.h>
+#include "int340x_thermal_zone.h"
+
+static int int340x_thermal_get_zone_temp(struct thermal_zone_device *zone,
+                                         unsigned long *temp)
+{
+        struct int34x_thermal_zone *d = zone->devdata;
+        unsigned long long tmp;
+        acpi_status status;
+
+        if (d->override_ops && d->override_ops->get_temp)
+                return d->override_ops->get_temp(zone, temp);
+
+        status = acpi_evaluate_integer(d->adev->handle, "_TMP", NULL, &tmp);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        if (d->lpat_table) {
+                int conv_temp;
+
+                conv_temp = acpi_lpat_raw_to_temp(d->lpat_table, (int)tmp);
+                if (conv_temp < 0)
+                        return conv_temp;
+
+                *temp = (unsigned long)conv_temp * 10;
+        } else
+                /* _TMP returns the temperature in tenths of degrees Kelvin */
+                *temp = DECI_KELVIN_TO_MILLICELSIUS(tmp);
+
+        return 0;
+}
+
+static int int340x_thermal_get_trip_temp(struct thermal_zone_device *zone,
+                                         int trip, unsigned long *temp)
+{
+        struct int34x_thermal_zone *d = zone->devdata;
+        int i;
+
+        if (d->override_ops && d->override_ops->get_trip_temp)
+                return d->override_ops->get_trip_temp(zone, trip, temp);
+
+        if (trip < d->aux_trip_nr)
+                *temp = d->aux_trips[trip];
+        else if (trip == d->crt_trip_id)
+                *temp = d->crt_temp;
+        else if (trip == d->psv_trip_id)
+                *temp = d->psv_temp;
+        else if (trip == d->hot_trip_id)
+                *temp = d->hot_temp;
+        else {
+                for (i = 0; i < INT340X_THERMAL_MAX_ACT_TRIP_COUNT; i++) {
+                        if (d->act_trips[i].valid &&
+                            d->act_trips[i].id == trip) {
+                                *temp = d->act_trips[i].temp;
+                                break;
+                        }
+                }
+                if (i == INT340X_THERMAL_MAX_ACT_TRIP_COUNT)
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int int340x_thermal_get_trip_type(struct thermal_zone_device *zone,
+                                         int trip,
+                                         enum thermal_trip_type *type)
+{
+        struct int34x_thermal_zone *d = zone->devdata;
+        int i;
+
+        if (d->override_ops && d->override_ops->get_trip_type)
+                return d->override_ops->get_trip_type(zone, trip, type);
+
+        if (trip < d->aux_trip_nr)
+                *type = THERMAL_TRIP_PASSIVE;
+        else if (trip == d->crt_trip_id)
+                *type = THERMAL_TRIP_CRITICAL;
+        else if (trip == d->hot_trip_id)
+                *type = THERMAL_TRIP_HOT;
+        else if (trip == d->psv_trip_id)
+                *type = THERMAL_TRIP_PASSIVE;
+        else {
+                for (i = 0; i < INT340X_THERMAL_MAX_ACT_TRIP_COUNT; i++) {
+                        if (d->act_trips[i].valid &&
+                            d->act_trips[i].id == trip) {
+                                *type = THERMAL_TRIP_ACTIVE;
+                                break;
+                        }
+                }
+                if (i == INT340X_THERMAL_MAX_ACT_TRIP_COUNT)
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int int340x_thermal_set_trip_temp(struct thermal_zone_device *zone,
+                                      int trip, unsigned long temp)
+{
+        struct int34x_thermal_zone *d = zone->devdata;
+        acpi_status status;
+        char name[10];
+
+        if (d->override_ops && d->override_ops->set_trip_temp)
+                return d->override_ops->set_trip_temp(zone, trip, temp);
+
+        snprintf(name, sizeof(name), "PAT%d", trip);
+        status = acpi_execute_simple_method(d->adev->handle, name,
+                        MILLICELSIUS_TO_DECI_KELVIN(temp));
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        d->aux_trips[trip] = temp;
+
+        return 0;
+}
+
+
+static int int340x_thermal_get_trip_hyst(struct thermal_zone_device *zone,
+                int trip, unsigned long *temp)
+{
+        struct int34x_thermal_zone *d = zone->devdata;
+        acpi_status status;
+        unsigned long long hyst;
+
+        if (d->override_ops && d->override_ops->get_trip_hyst)
+                return d->override_ops->get_trip_hyst(zone, trip, temp);
+
+        status = acpi_evaluate_integer(d->adev->handle, "GTSH", NULL, &hyst);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        *temp = hyst * 100;
+
+        return 0;
+}
+
+static struct thermal_zone_device_ops int340x_thermal_zone_ops = {
+        .get_temp       = int340x_thermal_get_zone_temp,
+        .get_trip_temp  = int340x_thermal_get_trip_temp,
+        .get_trip_type  = int340x_thermal_get_trip_type,
+        .set_trip_temp  = int340x_thermal_set_trip_temp,
+        .get_trip_hyst =  int340x_thermal_get_trip_hyst,
+};
+
+static int int340x_thermal_get_trip_config(acpi_handle handle, char *name,
+                                      unsigned long *temp)
+{
+        unsigned long long r;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(handle, name, NULL, &r);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        *temp = DECI_KELVIN_TO_MILLICELSIUS(r);
+
+        return 0;
+}
+
+static struct thermal_zone_params int340x_thermal_params = {
+        .governor_name = "user_space",
+        .no_hwmon = true,
+};
+
+struct int34x_thermal_zone *int340x_thermal_zone_add(struct acpi_device *adev,
+                                struct thermal_zone_device_ops *override_ops)
+{
+        struct int34x_thermal_zone *int34x_thermal_zone;
+        acpi_status status;
+        unsigned long long trip_cnt;
+        int trip_mask = 0, i;
+        int ret;
+
+        int34x_thermal_zone = kzalloc(sizeof(*int34x_thermal_zone),
+                                      GFP_KERNEL);
+        if (!int34x_thermal_zone)
+                return ERR_PTR(-ENOMEM);
+
+        int34x_thermal_zone->adev = adev;
+        int34x_thermal_zone->override_ops = override_ops;
+
+        status = acpi_evaluate_integer(adev->handle, "PATC", NULL, &trip_cnt);
+        if (ACPI_FAILURE(status))
+                trip_cnt = 0;
+        else {
+                int34x_thermal_zone->aux_trips = kzalloc(
+                                sizeof(*int34x_thermal_zone->aux_trips) *
+                                trip_cnt, GFP_KERNEL);
+                if (!int34x_thermal_zone->aux_trips) {
+                        ret = -ENOMEM;
+                        goto free_mem;
+                }
+                trip_mask = BIT(trip_cnt) - 1;
+                int34x_thermal_zone->aux_trip_nr = trip_cnt;
+        }
+
+        int34x_thermal_zone->crt_trip_id = -1;
+        if (!int340x_thermal_get_trip_config(adev->handle, "_CRT",
+                                             &int34x_thermal_zone->crt_temp))
+                int34x_thermal_zone->crt_trip_id = trip_cnt++;
+        int34x_thermal_zone->hot_trip_id = -1;
+        if (!int340x_thermal_get_trip_config(adev->handle, "_HOT",
+                                             &int34x_thermal_zone->hot_temp))
+                int34x_thermal_zone->hot_trip_id = trip_cnt++;
+        int34x_thermal_zone->psv_trip_id = -1;
+        if (!int340x_thermal_get_trip_config(adev->handle, "_PSV",
+                                             &int34x_thermal_zone->psv_temp))
+                int34x_thermal_zone->psv_trip_id = trip_cnt++;
+        for (i = 0; i < INT340X_THERMAL_MAX_ACT_TRIP_COUNT; i++) {
+                char name[5] = { '_', 'A', 'C', '0' + i, '\0' };
+
+                if (int340x_thermal_get_trip_config(adev->handle, name,
+                                &int34x_thermal_zone->act_trips[i].temp))
+                        break;
+
+                int34x_thermal_zone->act_trips[i].id = trip_cnt++;
+                int34x_thermal_zone->act_trips[i].valid = true;
+        }
+        int34x_thermal_zone->lpat_table = acpi_lpat_get_conversion_table(
+                                                                adev->handle);
+
+        int34x_thermal_zone->zone = thermal_zone_device_register(
+                                                acpi_device_bid(adev),
+                                                trip_cnt,
+                                                trip_mask, int34x_thermal_zone,
+                                                &int340x_thermal_zone_ops,
+                                                &int340x_thermal_params,
+                                                0, 0);
+        if (IS_ERR(int34x_thermal_zone->zone)) {
+                ret = PTR_ERR(int34x_thermal_zone->zone);
+                goto free_lpat;
+        }
+
+        return int34x_thermal_zone;
+
+free_lpat:
+        acpi_lpat_free_conversion_table(int34x_thermal_zone->lpat_table);
+free_mem:
+        kfree(int34x_thermal_zone);
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(int340x_thermal_zone_add);
+
+void int340x_thermal_zone_remove(struct int34x_thermal_zone
+                                 *int34x_thermal_zone)
+{
+        thermal_zone_device_unregister(int34x_thermal_zone->zone);
+        acpi_lpat_free_conversion_table(int34x_thermal_zone->lpat_table);
+        kfree(int34x_thermal_zone);
+}
+EXPORT_SYMBOL_GPL(int340x_thermal_zone_remove);
+
+MODULE_AUTHOR("Aaron Lu <aaron.lu@intel.com>");
+MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
+MODULE_DESCRIPTION("Intel INT340x common thermal zone handler");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/thermal/int340x_thermal/int340x_thermal_zone.h b/drivers/thermal/int340x_thermal/int340x_thermal_zone.h
new file mode 100644
index 000000000000..9f38ab72c4bf
--- /dev/null
+++ b/drivers/thermal/int340x_thermal/int340x_thermal_zone.h
@@ -0,0 +1,68 @@
+/*
+ * int340x_thermal_zone.h
+ * Copyright (c) 2015, Intel Corporation.
+ *
+ * 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.
+ *
+ */
+
+#ifndef __INT340X_THERMAL_ZONE_H__
+#define __INT340X_THERMAL_ZONE_H__
+
+#include <acpi/acpi_lpat.h>
+
+#define INT340X_THERMAL_MAX_ACT_TRIP_COUNT      10
+
+struct active_trip {
+        unsigned long temp;
+        int id;
+        bool valid;
+};
+
+struct int34x_thermal_zone {
+        struct acpi_device *adev;
+        struct active_trip act_trips[INT340X_THERMAL_MAX_ACT_TRIP_COUNT];
+        unsigned long *aux_trips;
+        int aux_trip_nr;
+        unsigned long psv_temp;
+        int psv_trip_id;
+        unsigned long crt_temp;
+        int crt_trip_id;
+        unsigned long hot_temp;
+        int hot_trip_id;
+        struct thermal_zone_device *zone;
+        struct thermal_zone_device_ops *override_ops;
+        void *priv_data;
+        struct acpi_lpat_conversion_table *lpat_table;
+};
+
+struct int34x_thermal_zone *int340x_thermal_zone_add(struct acpi_device *,
+                                struct thermal_zone_device_ops *override_ops);
+void int340x_thermal_zone_remove(struct int34x_thermal_zone *);
+
+static inline void int340x_thermal_zone_set_priv_data(
+                        struct int34x_thermal_zone *tzone, void *priv_data)
+{
+        tzone->priv_data = priv_data;
+}
+
+static inline void *int340x_thermal_zone_get_priv_data(
+                        struct int34x_thermal_zone *tzone)
+{
+        return tzone->priv_data;
+}
+
+static inline void int340x_thermal_zone_device_update(
+                        struct int34x_thermal_zone *tzone)
+{
+        thermal_zone_device_update(tzone->zone);
+}
+
+#endif
diff --git a/drivers/thermal/int340x_thermal/processor_thermal_device.c b/drivers/thermal/int340x_thermal/processor_thermal_device.c
index 0fe5dbbea968..5e8d8e91ea6d 100644
--- a/drivers/thermal/int340x_thermal/processor_thermal_device.c
+++ b/drivers/thermal/int340x_thermal/processor_thermal_device.c
@@ -18,6 +18,8 @@
 #include <linux/pci.h>
 #include <linux/platform_device.h>
 #include <linux/acpi.h>
+#include <linux/thermal.h>
+#include "int340x_thermal_zone.h"
 
 /* Broadwell-U/HSB thermal reporting device */
 #define PCI_DEVICE_ID_PROC_BDW_THERMAL  0x1603
@@ -39,6 +41,7 @@ struct proc_thermal_device {
         struct device *dev;
         struct acpi_device *adev;
         struct power_config power_limits[2];
+        struct int34x_thermal_zone *int340x_zone;
 };
 
 enum proc_thermal_emum_mode_type {
@@ -117,6 +120,72 @@ static struct attribute_group power_limit_attribute_group = {
         .name = "power_limits"
 };
 
+static int stored_tjmax; /* since it is fixed, we can have local storage */
+
+static int get_tjmax(void)
+{
+        u32 eax, edx;
+        u32 val;
+        int err;
+
+        err = rdmsr_safe(MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
+        if (err)
+                return err;
+
+        val = (eax >> 16) & 0xff;
+        if (val)
+                return val;
+
+        return -EINVAL;
+}
+
+static int read_temp_msr(unsigned long *temp)
+{
+        int cpu;
+        u32 eax, edx;
+        int err;
+        unsigned long curr_temp_off = 0;
+
+        *temp = 0;
+
+        for_each_online_cpu(cpu) {
+                err = rdmsr_safe_on_cpu(cpu, MSR_IA32_THERM_STATUS, &eax,
+                                        &edx);
+                if (err)
+                        goto err_ret;
+                else {
+                        if (eax & 0x80000000) {
+                                curr_temp_off = (eax >> 16) & 0x7f;
+                                if (!*temp || curr_temp_off < *temp)
+                                        *temp = curr_temp_off;
+                        } else {
+                                err = -EINVAL;
+                                goto err_ret;
+                        }
+                }
+        }
+
+        return 0;
+err_ret:
+        return err;
+}
+
+static int proc_thermal_get_zone_temp(struct thermal_zone_device *zone,
+                                         unsigned long *temp)
+{
+        int ret;
+
+        ret = read_temp_msr(temp);
+        if (!ret)
+                *temp = (stored_tjmax - *temp) * 1000;
+
+        return ret;
+}
+
+static struct thermal_zone_device_ops proc_thermal_local_ops = {
+        .get_temp       = proc_thermal_get_zone_temp,
+};
+
 static int proc_thermal_add(struct device *dev,
                             struct proc_thermal_device **priv)
 {
@@ -126,6 +195,8 @@ static int proc_thermal_add(struct device *dev,
         struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *elements, *ppcc;
         union acpi_object *p;
+        unsigned long long tmp;
+        struct thermal_zone_device_ops *ops = NULL;
         int i;
         int ret;
 
@@ -178,6 +249,24 @@ static int proc_thermal_add(struct device *dev,
 
         ret = sysfs_create_group(&dev->kobj,
                                  &power_limit_attribute_group);
+        if (ret)
+                goto free_buffer;
+
+        status = acpi_evaluate_integer(adev->handle, "_TMP", NULL, &tmp);
+        if (ACPI_FAILURE(status)) {
+                /* there is no _TMP method, add local method */
+                stored_tjmax = get_tjmax();
+                if (stored_tjmax > 0)
+                        ops = &proc_thermal_local_ops;
+        }
+
+        proc_priv->int340x_zone = int340x_thermal_zone_add(adev, ops);
+        if (IS_ERR(proc_priv->int340x_zone)) {
+                sysfs_remove_group(&proc_priv->dev->kobj,
+                           &power_limit_attribute_group);
+                ret = PTR_ERR(proc_priv->int340x_zone);
+        } else
+                ret = 0;
 
 free_buffer:
         kfree(buf.pointer);
@@ -185,8 +274,9 @@ free_buffer:
         return ret;
 }
 
-void proc_thermal_remove(struct proc_thermal_device *proc_priv)
+static void proc_thermal_remove(struct proc_thermal_device *proc_priv)
 {
+        int340x_thermal_zone_remove(proc_priv->int340x_zone);
         sysfs_remove_group(&proc_priv->dev->kobj,
                            &power_limit_attribute_group);
 }
diff --git a/drivers/thermal/intel_powerclamp.c b/drivers/thermal/intel_powerclamp.c
index 6ceebd659dd4..12623bc02f46 100644
--- a/drivers/thermal/intel_powerclamp.c
+++ b/drivers/thermal/intel_powerclamp.c
@@ -688,6 +688,7 @@ static const struct x86_cpu_id intel_powerclamp_ids[] = {
         { X86_VENDOR_INTEL, 6, 0x45},
         { X86_VENDOR_INTEL, 6, 0x46},
         { X86_VENDOR_INTEL, 6, 0x4c},
+        { X86_VENDOR_INTEL, 6, 0x4d},
         { X86_VENDOR_INTEL, 6, 0x56},
         {}
 };
diff --git a/drivers/thermal/intel_soc_dts_thermal.c b/drivers/thermal/intel_soc_dts_thermal.c
index 5580f5b24eb9..9013505e43b7 100644
--- a/drivers/thermal/intel_soc_dts_thermal.c
+++ b/drivers/thermal/intel_soc_dts_thermal.c
@@ -309,10 +309,13 @@ static int soc_dts_enable(int id)
         return ret;
 }
 
-static struct soc_sensor_entry *alloc_soc_dts(int id, u32 tj_max)
+static struct soc_sensor_entry *alloc_soc_dts(int id, u32 tj_max,
+                                              bool notification_support)
 {
         struct soc_sensor_entry *aux_entry;
         char name[10];
+        int trip_count = 0;
+        int trip_mask = 0;
         int err;
 
         aux_entry = kzalloc(sizeof(*aux_entry), GFP_KERNEL);
@@ -332,11 +335,16 @@ static struct soc_sensor_entry *alloc_soc_dts(int id, u32 tj_max)
         aux_entry->tj_max = tj_max;
         aux_entry->temp_mask = 0x00FF << (id * 8);
         aux_entry->temp_shift = id * 8;
+        if (notification_support) {
+                trip_count = SOC_MAX_DTS_TRIPS;
+                trip_mask = 0x02;
+        }
         snprintf(name, sizeof(name), "soc_dts%d", id);
         aux_entry->tzone = thermal_zone_device_register(name,
-                        SOC_MAX_DTS_TRIPS,
-                        0x02,
-                        aux_entry, &tzone_ops, NULL, 0, 0);
+                                                        trip_count,
+                                                        trip_mask,
+                                                        aux_entry, &tzone_ops,
+                                                        NULL, 0, 0);
         if (IS_ERR(aux_entry->tzone)) {
                 err = PTR_ERR(aux_entry->tzone);
                 goto err_ret;
@@ -402,6 +410,7 @@ static irqreturn_t soc_irq_thread_fn(int irq, void *dev_data)
 
 static const struct x86_cpu_id soc_thermal_ids[] = {
         { X86_VENDOR_INTEL, X86_FAMILY_ANY, 0x37, 0, BYT_SOC_DTS_APIC_IRQ},
+        { X86_VENDOR_INTEL, X86_FAMILY_ANY, 0x4c, 0, 0},
         {}
 };
 MODULE_DEVICE_TABLE(x86cpu, soc_thermal_ids);
@@ -420,8 +429,11 @@ static int __init intel_soc_thermal_init(void)
         if (get_tj_max(&tj_max))
                 return -EINVAL;
 
+        soc_dts_thres_irq = (int)match_cpu->driver_data;
+
         for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
-                soc_dts[i] = alloc_soc_dts(i, tj_max);
+                soc_dts[i] = alloc_soc_dts(i, tj_max,
+                                           soc_dts_thres_irq ? true : false);
                 if (IS_ERR(soc_dts[i])) {
                         err = PTR_ERR(soc_dts[i]);
                         goto err_free;
@@ -430,15 +442,15 @@ static int __init intel_soc_thermal_init(void)
 
         spin_lock_init(&intr_notify_lock);
 
-        soc_dts_thres_irq = (int)match_cpu->driver_data;
-
-        err = request_threaded_irq(soc_dts_thres_irq, NULL,
-                                        soc_irq_thread_fn,
-                                        IRQF_TRIGGER_RISING | IRQF_ONESHOT,
-                                        "soc_dts", soc_dts);
-        if (err) {
-                pr_err("request_threaded_irq ret %d\n", err);
-                goto err_free;
+        if (soc_dts_thres_irq) {
+                err = request_threaded_irq(soc_dts_thres_irq, NULL,
+                                           soc_irq_thread_fn,
+                                           IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+                                           "soc_dts", soc_dts);
+                if (err) {
+                        pr_err("request_threaded_irq ret %d\n", err);
+                        goto err_free;
+                }
         }
 
         for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i) {
@@ -451,7 +463,8 @@ static int __init intel_soc_thermal_init(void)
 
 err_trip_temp:
         i = SOC_MAX_DTS_SENSORS;
-        free_irq(soc_dts_thres_irq, soc_dts);
+        if (soc_dts_thres_irq)
+                free_irq(soc_dts_thres_irq, soc_dts);
 err_free:
         while (--i >= 0)
                 free_soc_dts(soc_dts[i]);
@@ -466,7 +479,8 @@ static void __exit intel_soc_thermal_exit(void)
         for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i)
                 update_trip_temp(soc_dts[i], 0, 0);
 
-        free_irq(soc_dts_thres_irq, soc_dts);
+        if (soc_dts_thres_irq)
+                free_irq(soc_dts_thres_irq, soc_dts);
 
         for (i = 0; i < SOC_MAX_DTS_SENSORS; ++i)
                 free_soc_dts(soc_dts[i]);
diff --git a/drivers/thermal/of-thermal.c b/drivers/thermal/of-thermal.c
index d717f3dab6f1..668fb1bdea9e 100644
--- a/drivers/thermal/of-thermal.c
+++ b/drivers/thermal/of-thermal.c
@@ -497,6 +497,9 @@ thermal_zone_of_sensor_register(struct device *dev, int sensor_id, void *data,
                 if (sensor_specs.np == sensor_np && id == sensor_id) {
                         tzd = thermal_zone_of_add_sensor(child, sensor_np,
                                                          data, ops);
+                        if (!IS_ERR(tzd))
+                                tzd->ops->set_mode(tzd, THERMAL_DEVICE_ENABLED);
+
                         of_node_put(sensor_specs.np);
                         of_node_put(child);
                         goto exit;
diff --git a/drivers/thermal/rcar_thermal.c b/drivers/thermal/rcar_thermal.c
index 2580a4872f90..fe4e767018c4 100644
--- a/drivers/thermal/rcar_thermal.c
+++ b/drivers/thermal/rcar_thermal.c
@@ -387,21 +387,9 @@ static int rcar_thermal_probe(struct platform_device *pdev)
 
         irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (irq) {
-                int ret;
-
                 /*
                  * platform has IRQ support.
                  * Then, driver uses common registers
-                 */
-
-                ret = devm_request_irq(dev, irq->start, rcar_thermal_irq, 0,
-                                       dev_name(dev), common);
-                if (ret) {
-                        dev_err(dev, "irq request failed\n ");
-                        return ret;
-                }
-
-                /*
                  * rcar_has_irq_support() will be enabled
                  */
                 res = platform_get_resource(pdev, IORESOURCE_MEM, mres++);
@@ -456,8 +444,16 @@ static int rcar_thermal_probe(struct platform_device *pdev)
         }
 
         /* enable temperature comparation */
-        if (irq)
+        if (irq) {
+                ret = devm_request_irq(dev, irq->start, rcar_thermal_irq, 0,
+                                       dev_name(dev), common);
+                if (ret) {
+                        dev_err(dev, "irq request failed\n ");
+                        goto error_unregister;
+                }
+
                 rcar_thermal_common_write(common, ENR, enr_bits);
+        }
 
         platform_set_drvdata(pdev, common);
 
@@ -467,9 +463,9 @@ static int rcar_thermal_probe(struct platform_device *pdev)
 
 error_unregister:
         rcar_thermal_for_each_priv(priv, common) {
-                thermal_zone_device_unregister(priv->zone);
                 if (rcar_has_irq_support(priv))
                         rcar_thermal_irq_disable(priv);
+                thermal_zone_device_unregister(priv->zone);
         }
 
         pm_runtime_put(dev);
@@ -485,9 +481,9 @@ static int rcar_thermal_remove(struct platform_device *pdev)
         struct rcar_thermal_priv *priv;
 
         rcar_thermal_for_each_priv(priv, common) {
-                thermal_zone_device_unregister(priv->zone);
                 if (rcar_has_irq_support(priv))
                         rcar_thermal_irq_disable(priv);
+                thermal_zone_device_unregister(priv->zone);
         }
 
         pm_runtime_put(dev);
diff --git a/drivers/thermal/rockchip_thermal.c b/drivers/thermal/rockchip_thermal.c
index 9c6ce548e363..3aa46ac7cdbc 100644
--- a/drivers/thermal/rockchip_thermal.c
+++ b/drivers/thermal/rockchip_thermal.c
@@ -193,19 +193,20 @@ static u32 rk_tsadcv2_temp_to_code(long temp)
 
 static long rk_tsadcv2_code_to_temp(u32 code)
 {
-        int high, low, mid;
-
-        low = 0;
-        high = ARRAY_SIZE(v2_code_table) - 1;
-        mid = (high + low) / 2;
-
-        if (code > v2_code_table[low].code || code < v2_code_table[high].code)
-                return 125000; /* No code available, return max temperature */
+        unsigned int low = 0;
+        unsigned int high = ARRAY_SIZE(v2_code_table) - 1;
+        unsigned int mid = (low + high) / 2;
+        unsigned int num;
+        unsigned long denom;
+
+        /* Invalid code, return -EAGAIN */
+        if (code > TSADCV2_DATA_MASK)
+                return -EAGAIN;
 
-        while (low <= high) {
-                if (code >= v2_code_table[mid].code && code <
-                    v2_code_table[mid - 1].code)
-                        return v2_code_table[mid].temp;
+        while (low <= high && mid) {
+                if (code >= v2_code_table[mid].code &&
+                    code < v2_code_table[mid - 1].code)
+                        break;
                 else if (code < v2_code_table[mid].code)
                         low = mid + 1;
                 else
@@ -213,7 +214,16 @@ static long rk_tsadcv2_code_to_temp(u32 code)
                 mid = (low + high) / 2;
         }
 
-        return 125000;
+        /*
+         * The 5C granularity provided by the table is too much. Let's
+         * assume that the relationship between sensor readings and
+         * temperature between 2 table entries is linear and interpolate
+         * to produce less granular result.
+         */
+        num = v2_code_table[mid].temp - v2_code_table[mid - 1].temp;
+        num *= v2_code_table[mid - 1].code - code;
+        denom = v2_code_table[mid - 1].code - v2_code_table[mid].code;
+        return v2_code_table[mid - 1].temp + (num / denom);
 }
 
 /**
diff --git a/drivers/thermal/samsung/Kconfig b/drivers/thermal/samsung/Kconfig
index c43306ecc0ab..c8e35c1a43dc 100644
--- a/drivers/thermal/samsung/Kconfig
+++ b/drivers/thermal/samsung/Kconfig
@@ -7,12 +7,3 @@ config EXYNOS_THERMAL
           the TMU, reports temperature and handles cooling action if defined.
           This driver uses the Exynos core thermal APIs and TMU configuration
           data from the supported SoCs.
-
-config EXYNOS_THERMAL_CORE
-        bool "Core thermal framework support for EXYNOS SOCs"
-        depends on EXYNOS_THERMAL
-        help
-          If you say yes here you get support for EXYNOS TMU
-          (Thermal Management Unit) common registration/unregistration
-          functions to the core thermal layer and also to use the generic
-          CPU cooling APIs.
diff --git a/drivers/thermal/samsung/Makefile b/drivers/thermal/samsung/Makefile
index c09d83095dc2..1e47d0d89ce0 100644
--- a/drivers/thermal/samsung/Makefile
+++ b/drivers/thermal/samsung/Makefile
@@ -3,5 +3,3 @@
 #
 obj-$(CONFIG_EXYNOS_THERMAL)                    += exynos_thermal.o
 exynos_thermal-y                                := exynos_tmu.o
-exynos_thermal-y                                += exynos_tmu_data.o
-exynos_thermal-$(CONFIG_EXYNOS_THERMAL_CORE)    += exynos_thermal_common.o
diff --git a/drivers/thermal/samsung/exynos_thermal_common.c b/drivers/thermal/samsung/exynos_thermal_common.c
deleted file mode 100644
index 6dc3815cc73f..000000000000
--- a/drivers/thermal/samsung/exynos_thermal_common.c
+++ /dev/null
@@ -1,427 +0,0 @@
-/*
- * exynos_thermal_common.c - Samsung EXYNOS common thermal file
- *
- *  Copyright (C) 2013 Samsung Electronics
- *  Amit Daniel Kachhap <amit.daniel@samsung.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.
- *
- * 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/cpu_cooling.h>
-#include <linux/err.h>
-#include <linux/slab.h>
-#include <linux/thermal.h>
-
-#include "exynos_thermal_common.h"
-
-struct exynos_thermal_zone {
-        enum thermal_device_mode mode;
-        struct thermal_zone_device *therm_dev;
-        struct thermal_cooling_device *cool_dev[MAX_COOLING_DEVICE];
-        unsigned int cool_dev_size;
-        struct platform_device *exynos4_dev;
-        struct thermal_sensor_conf *sensor_conf;
-        bool bind;
-};
-
-/* Get mode callback functions for thermal zone */
-static int exynos_get_mode(struct thermal_zone_device *thermal,
-                        enum thermal_device_mode *mode)
-{
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-        if (th_zone)
-                *mode = th_zone->mode;
-        return 0;
-}
-
-/* Set mode callback functions for thermal zone */
-static int exynos_set_mode(struct thermal_zone_device *thermal,
-                        enum thermal_device_mode mode)
-{
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-        if (!th_zone) {
-                dev_err(&thermal->device,
-                        "thermal zone not registered\n");
-                return 0;
-        }
-
-        mutex_lock(&thermal->lock);
-
-        if (mode == THERMAL_DEVICE_ENABLED &&
-                !th_zone->sensor_conf->trip_data.trigger_falling)
-                thermal->polling_delay = IDLE_INTERVAL;
-        else
-                thermal->polling_delay = 0;
-
-        mutex_unlock(&thermal->lock);
-
-        th_zone->mode = mode;
-        thermal_zone_device_update(thermal);
-        dev_dbg(th_zone->sensor_conf->dev,
-                "thermal polling set for duration=%d msec\n",
-                thermal->polling_delay);
-        return 0;
-}
-
-
-/* Get trip type callback functions for thermal zone */
-static int exynos_get_trip_type(struct thermal_zone_device *thermal, int trip,
-                                 enum thermal_trip_type *type)
-{
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-        int max_trip = th_zone->sensor_conf->trip_data.trip_count;
-        int trip_type;
-
-        if (trip < 0 || trip >= max_trip)
-                return -EINVAL;
-
-        trip_type = th_zone->sensor_conf->trip_data.trip_type[trip];
-
-        if (trip_type == SW_TRIP)
-                *type = THERMAL_TRIP_CRITICAL;
-        else if (trip_type == THROTTLE_ACTIVE)
-                *type = THERMAL_TRIP_ACTIVE;
-        else if (trip_type == THROTTLE_PASSIVE)
-                *type = THERMAL_TRIP_PASSIVE;
-        else
-                return -EINVAL;
-
-        return 0;
-}
-
-/* Get trip temperature callback functions for thermal zone */
-static int exynos_get_trip_temp(struct thermal_zone_device *thermal, int trip,
-                                unsigned long *temp)
-{
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-        int max_trip = th_zone->sensor_conf->trip_data.trip_count;
-
-        if (trip < 0 || trip >= max_trip)
-                return -EINVAL;
-
-        *temp = th_zone->sensor_conf->trip_data.trip_val[trip];
-        /* convert the temperature into millicelsius */
-        *temp = *temp * MCELSIUS;
-
-        return 0;
-}
-
-/* Get critical temperature callback functions for thermal zone */
-static int exynos_get_crit_temp(struct thermal_zone_device *thermal,
-                                unsigned long *temp)
-{
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-        int max_trip = th_zone->sensor_conf->trip_data.trip_count;
-        /* Get the temp of highest trip*/
-        return exynos_get_trip_temp(thermal, max_trip - 1, temp);
-}
-
-/* Bind callback functions for thermal zone */
-static int exynos_bind(struct thermal_zone_device *thermal,
-                        struct thermal_cooling_device *cdev)
-{
-        int ret = 0, i, tab_size, level;
-        struct freq_clip_table *tab_ptr, *clip_data;
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-        struct thermal_sensor_conf *data = th_zone->sensor_conf;
-
-        tab_ptr = (struct freq_clip_table *)data->cooling_data.freq_data;
-        tab_size = data->cooling_data.freq_clip_count;
-
-        if (tab_ptr == NULL || tab_size == 0)
-                return 0;
-
-        /* find the cooling device registered*/
-        for (i = 0; i < th_zone->cool_dev_size; i++)
-                if (cdev == th_zone->cool_dev[i])
-                        break;
-
-        /* No matching cooling device */
-        if (i == th_zone->cool_dev_size)
-                return 0;
-
-        /* Bind the thermal zone to the cpufreq cooling device */
-        for (i = 0; i < tab_size; i++) {
-                clip_data = (struct freq_clip_table *)&(tab_ptr[i]);
-                level = cpufreq_cooling_get_level(0, clip_data->freq_clip_max);
-                if (level == THERMAL_CSTATE_INVALID)
-                        return 0;
-                switch (GET_ZONE(i)) {
-                case MONITOR_ZONE:
-                case WARN_ZONE:
-                        if (thermal_zone_bind_cooling_device(thermal, i, cdev,
-                                                                level, 0)) {
-                                dev_err(data->dev,
-                                        "error unbinding cdev inst=%d\n", i);
-                                ret = -EINVAL;
-                        }
-                        th_zone->bind = true;
-                        break;
-                default:
-                        ret = -EINVAL;
-                }
-        }
-
-        return ret;
-}
-
-/* Unbind callback functions for thermal zone */
-static int exynos_unbind(struct thermal_zone_device *thermal,
-                        struct thermal_cooling_device *cdev)
-{
-        int ret = 0, i, tab_size;
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-        struct thermal_sensor_conf *data = th_zone->sensor_conf;
-
-        if (th_zone->bind == false)
-                return 0;
-
-        tab_size = data->cooling_data.freq_clip_count;
-
-        if (tab_size == 0)
-                return 0;
-
-        /* find the cooling device registered*/
-        for (i = 0; i < th_zone->cool_dev_size; i++)
-                if (cdev == th_zone->cool_dev[i])
-                        break;
-
-        /* No matching cooling device */
-        if (i == th_zone->cool_dev_size)
-                return 0;
-
-        /* Bind the thermal zone to the cpufreq cooling device */
-        for (i = 0; i < tab_size; i++) {
-                switch (GET_ZONE(i)) {
-                case MONITOR_ZONE:
-                case WARN_ZONE:
-                        if (thermal_zone_unbind_cooling_device(thermal, i,
-                                                                cdev)) {
-                                dev_err(data->dev,
-                                        "error unbinding cdev inst=%d\n", i);
-                                ret = -EINVAL;
-                        }
-                        th_zone->bind = false;
-                        break;
-                default:
-                        ret = -EINVAL;
-                }
-        }
-        return ret;
-}
-
-/* Get temperature callback functions for thermal zone */
-static int exynos_get_temp(struct thermal_zone_device *thermal,
-                        unsigned long *temp)
-{
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-        void *data;
-
-        if (!th_zone->sensor_conf) {
-                dev_err(&thermal->device,
-                        "Temperature sensor not initialised\n");
-                return -EINVAL;
-        }
-        data = th_zone->sensor_conf->driver_data;
-        *temp = th_zone->sensor_conf->read_temperature(data);
-        /* convert the temperature into millicelsius */
-        *temp = *temp * MCELSIUS;
-        return 0;
-}
-
-/* Get temperature callback functions for thermal zone */
-static int exynos_set_emul_temp(struct thermal_zone_device *thermal,
-                                                unsigned long temp)
-{
-        void *data;
-        int ret = -EINVAL;
-        struct exynos_thermal_zone *th_zone = thermal->devdata;
-
-        if (!th_zone->sensor_conf) {
-                dev_err(&thermal->device,
-                        "Temperature sensor not initialised\n");
-                return -EINVAL;
-        }
-        data = th_zone->sensor_conf->driver_data;
-        if (th_zone->sensor_conf->write_emul_temp)
-                ret = th_zone->sensor_conf->write_emul_temp(data, temp);
-        return ret;
-}
-
-/* Get the temperature trend */
-static int exynos_get_trend(struct thermal_zone_device *thermal,
-                        int trip, enum thermal_trend *trend)
-{
-        int ret;
-        unsigned long trip_temp;
-
-        ret = exynos_get_trip_temp(thermal, trip, &trip_temp);
-        if (ret < 0)
-                return ret;
-
-        if (thermal->temperature >= trip_temp)
-                *trend = THERMAL_TREND_RAISE_FULL;
-        else
-                *trend = THERMAL_TREND_DROP_FULL;
-
-        return 0;
-}
-/* Operation callback functions for thermal zone */
-static struct thermal_zone_device_ops exynos_dev_ops = {
-        .bind = exynos_bind,
-        .unbind = exynos_unbind,
-        .get_temp = exynos_get_temp,
-        .set_emul_temp = exynos_set_emul_temp,
-        .get_trend = exynos_get_trend,
-        .get_mode = exynos_get_mode,
-        .set_mode = exynos_set_mode,
-        .get_trip_type = exynos_get_trip_type,
-        .get_trip_temp = exynos_get_trip_temp,
-        .get_crit_temp = exynos_get_crit_temp,
-};
-
-/*
- * This function may be called from interrupt based temperature sensor
- * when threshold is changed.
- */
-void exynos_report_trigger(struct thermal_sensor_conf *conf)
-{
-        unsigned int i;
-        char data[10];
-        char *envp[] = { data, NULL };
-        struct exynos_thermal_zone *th_zone;
-
-        if (!conf || !conf->pzone_data) {
-                pr_err("Invalid temperature sensor configuration data\n");
-                return;
-        }
-
-        th_zone = conf->pzone_data;
-
-        if (th_zone->bind == false) {
-                for (i = 0; i < th_zone->cool_dev_size; i++) {
-                        if (!th_zone->cool_dev[i])
-                                continue;
-                        exynos_bind(th_zone->therm_dev,
-                                        th_zone->cool_dev[i]);
-                }
-        }
-
-        thermal_zone_device_update(th_zone->therm_dev);
-
-        mutex_lock(&th_zone->therm_dev->lock);
-        /* Find the level for which trip happened */
-        for (i = 0; i < th_zone->sensor_conf->trip_data.trip_count; i++) {
-                if (th_zone->therm_dev->last_temperature <
-                        th_zone->sensor_conf->trip_data.trip_val[i] * MCELSIUS)
-                        break;
-        }
-
-        if (th_zone->mode == THERMAL_DEVICE_ENABLED &&
-                !th_zone->sensor_conf->trip_data.trigger_falling) {
-                if (i > 0)
-                        th_zone->therm_dev->polling_delay = ACTIVE_INTERVAL;
-                else
-                        th_zone->therm_dev->polling_delay = IDLE_INTERVAL;
-        }
-
-        snprintf(data, sizeof(data), "%u", i);
-        kobject_uevent_env(&th_zone->therm_dev->device.kobj, KOBJ_CHANGE, envp);
-        mutex_unlock(&th_zone->therm_dev->lock);
-}
-
-/* Register with the in-kernel thermal management */
-int exynos_register_thermal(struct thermal_sensor_conf *sensor_conf)
-{
-        int ret;
-        struct exynos_thermal_zone *th_zone;
-
-        if (!sensor_conf || !sensor_conf->read_temperature) {
-                pr_err("Temperature sensor not initialised\n");
-                return -EINVAL;
-        }
-
-        th_zone = devm_kzalloc(sensor_conf->dev,
-                                sizeof(struct exynos_thermal_zone), GFP_KERNEL);
-        if (!th_zone)
-                return -ENOMEM;
-
-        th_zone->sensor_conf = sensor_conf;
-        /*
-         * TODO: 1) Handle multiple cooling devices in a thermal zone
-         *       2) Add a flag/name in cooling info to map to specific
-         *       sensor
-         */
-        if (sensor_conf->cooling_data.freq_clip_count > 0) {
-                th_zone->cool_dev[th_zone->cool_dev_size] =
-                                cpufreq_cooling_register(cpu_present_mask);
-                if (IS_ERR(th_zone->cool_dev[th_zone->cool_dev_size])) {
-                        ret = PTR_ERR(th_zone->cool_dev[th_zone->cool_dev_size]);
-                        if (ret != -EPROBE_DEFER)
-                                dev_err(sensor_conf->dev,
-                                        "Failed to register cpufreq cooling device: %d\n",
-                                        ret);
-                        goto err_unregister;
-                }
-                th_zone->cool_dev_size++;
-        }
-
-        th_zone->therm_dev = thermal_zone_device_register(
-                        sensor_conf->name, sensor_conf->trip_data.trip_count,
-                        0, th_zone, &exynos_dev_ops, NULL, 0,
-                        sensor_conf->trip_data.trigger_falling ? 0 :
-                        IDLE_INTERVAL);
-
-        if (IS_ERR(th_zone->therm_dev)) {
-                dev_err(sensor_conf->dev,
-                        "Failed to register thermal zone device\n");
-                ret = PTR_ERR(th_zone->therm_dev);
-                goto err_unregister;
-        }
-        th_zone->mode = THERMAL_DEVICE_ENABLED;
-        sensor_conf->pzone_data = th_zone;
-
-        dev_info(sensor_conf->dev,
-                "Exynos: Thermal zone(%s) registered\n", sensor_conf->name);
-
-        return 0;
-
-err_unregister:
-        exynos_unregister_thermal(sensor_conf);
-        return ret;
-}
-
-/* Un-Register with the in-kernel thermal management */
-void exynos_unregister_thermal(struct thermal_sensor_conf *sensor_conf)
-{
-        int i;
-        struct exynos_thermal_zone *th_zone;
-
-        if (!sensor_conf || !sensor_conf->pzone_data) {
-                pr_err("Invalid temperature sensor configuration data\n");
-                return;
-        }
-
-        th_zone = sensor_conf->pzone_data;
-
-        thermal_zone_device_unregister(th_zone->therm_dev);
-
-        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/samsung/exynos_thermal_common.h b/drivers/thermal/samsung/exynos_thermal_common.h
deleted file mode 100644
index cd4471925cdd..000000000000
--- a/drivers/thermal/samsung/exynos_thermal_common.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * exynos_thermal_common.h - Samsung EXYNOS common header file
- *
- *  Copyright (C) 2013 Samsung Electronics
- *  Amit Daniel Kachhap <amit.daniel@samsung.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.
- *
- * 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
- *
- */
-
-#ifndef _EXYNOS_THERMAL_COMMON_H
-#define _EXYNOS_THERMAL_COMMON_H
-
-/* In-kernel thermal framework related macros & definations */
-#define SENSOR_NAME_LEN 16
-#define MAX_TRIP_COUNT  8
-#define MAX_COOLING_DEVICE 4
-
-#define ACTIVE_INTERVAL 500
-#define IDLE_INTERVAL 10000
-#define MCELSIUS        1000
-
-/* CPU Zone information */
-#define PANIC_ZONE      4
-#define WARN_ZONE       3
-#define MONITOR_ZONE    2
-#define SAFE_ZONE       1
-
-#define GET_ZONE(trip) (trip + 2)
-#define GET_TRIP(zone) (zone - 2)
-
-enum trigger_type {
-        THROTTLE_ACTIVE = 1,
-        THROTTLE_PASSIVE,
-        SW_TRIP,
-        HW_TRIP,
-};
-
-/**
- * struct freq_clip_table
- * @freq_clip_max: maximum frequency allowed for this cooling state.
- * @temp_level: Temperature level at which the temperature clipping will
- *      happen.
- * @mask_val: cpumask of the allowed cpu's where the clipping will take place.
- *
- * This structure is required to be filled and passed to the
- * cpufreq_cooling_unregister function.
- */
-struct freq_clip_table {
-        unsigned int freq_clip_max;
-        unsigned int temp_level;
-        const struct cpumask *mask_val;
-};
-
-struct  thermal_trip_point_conf {
-        int trip_val[MAX_TRIP_COUNT];
-        int trip_type[MAX_TRIP_COUNT];
-        int trip_count;
-        unsigned char trigger_falling;
-};
-
-struct  thermal_cooling_conf {
-        struct freq_clip_table freq_data[MAX_TRIP_COUNT];
-        int freq_clip_count;
-};
-
-struct thermal_sensor_conf {
-        char name[SENSOR_NAME_LEN];
-        int (*read_temperature)(void *data);
-        int (*write_emul_temp)(void *drv_data, unsigned long temp);
-        struct thermal_trip_point_conf trip_data;
-        struct thermal_cooling_conf cooling_data;
-        void *driver_data;
-        void *pzone_data;
-        struct device *dev;
-};
-
-/*Functions used exynos based thermal sensor driver*/
-#ifdef CONFIG_EXYNOS_THERMAL_CORE
-void exynos_unregister_thermal(struct thermal_sensor_conf *sensor_conf);
-int exynos_register_thermal(struct thermal_sensor_conf *sensor_conf);
-void exynos_report_trigger(struct thermal_sensor_conf *sensor_conf);
-#else
-static inline void
-exynos_unregister_thermal(struct thermal_sensor_conf *sensor_conf) { return; }
-
-static inline int
-exynos_register_thermal(struct thermal_sensor_conf *sensor_conf) { return 0; }
-
-static inline void
-exynos_report_trigger(struct thermal_sensor_conf *sensor_conf) { return; }
-
-#endif /* CONFIG_EXYNOS_THERMAL_CORE */
-#endif /* _EXYNOS_THERMAL_COMMON_H */
diff --git a/drivers/thermal/samsung/exynos_tmu.c b/drivers/thermal/samsung/exynos_tmu.c
index d2f1e62a4232..1fc54ab911d2 100644
--- a/drivers/thermal/samsung/exynos_tmu.c
+++ b/drivers/thermal/samsung/exynos_tmu.c
@@ -1,6 +1,10 @@
 /*
  * exynos_tmu.c - Samsung EXYNOS TMU (Thermal Management Unit)
  *
+ *  Copyright (C) 2014 Samsung Electronics
+ *  Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
+ *  Lukasz Majewski <l.majewski@samsung.com>
+ *
  *  Copyright (C) 2011 Samsung Electronics
  *  Donggeun Kim <dg77.kim@samsung.com>
  *  Amit Daniel Kachhap <amit.kachhap@linaro.org>
@@ -31,8 +35,8 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/consumer.h>
 
-#include "exynos_thermal_common.h"
 #include "exynos_tmu.h"
+#include "../thermal_core.h"
 
 /* Exynos generic registers */
 #define EXYNOS_TMU_REG_TRIMINFO         0x0
@@ -115,6 +119,27 @@
 #define EXYNOS5440_TMU_TH_RISE4_SHIFT           24
 #define EXYNOS5440_EFUSE_SWAP_OFFSET            8
 
+/* Exynos7 specific registers */
+#define EXYNOS7_THD_TEMP_RISE7_6                0x50
+#define EXYNOS7_THD_TEMP_FALL7_6                0x60
+#define EXYNOS7_TMU_REG_INTEN                   0x110
+#define EXYNOS7_TMU_REG_INTPEND                 0x118
+#define EXYNOS7_TMU_REG_EMUL_CON                0x160
+
+#define EXYNOS7_TMU_TEMP_MASK                   0x1ff
+#define EXYNOS7_PD_DET_EN_SHIFT                 23
+#define EXYNOS7_TMU_INTEN_RISE0_SHIFT           0
+#define EXYNOS7_TMU_INTEN_RISE1_SHIFT           1
+#define EXYNOS7_TMU_INTEN_RISE2_SHIFT           2
+#define EXYNOS7_TMU_INTEN_RISE3_SHIFT           3
+#define EXYNOS7_TMU_INTEN_RISE4_SHIFT           4
+#define EXYNOS7_TMU_INTEN_RISE5_SHIFT           5
+#define EXYNOS7_TMU_INTEN_RISE6_SHIFT           6
+#define EXYNOS7_TMU_INTEN_RISE7_SHIFT           7
+#define EXYNOS7_EMUL_DATA_SHIFT                 7
+#define EXYNOS7_EMUL_DATA_MASK                  0x1ff
+
+#define MCELSIUS        1000
 /**
  * struct exynos_tmu_data : A structure to hold the private data of the TMU
         driver
@@ -128,6 +153,7 @@
  * @lock: lock to implement synchronization.
  * @clk: pointer to the clock structure.
  * @clk_sec: pointer to the clock structure for accessing the base_second.
+ * @sclk: pointer to the clock structure for accessing the tmu special clk.
  * @temp_error1: fused value of the first point trim.
  * @temp_error2: fused value of the second point trim.
  * @regulator: pointer to the TMU regulator structure.
@@ -147,10 +173,11 @@ struct exynos_tmu_data {
         enum soc_type soc;
         struct work_struct irq_work;
         struct mutex lock;
-        struct clk *clk, *clk_sec;
-        u8 temp_error1, temp_error2;
+        struct clk *clk, *clk_sec, *sclk;
+        u16 temp_error1, temp_error2;
         struct regulator *regulator;
-        struct thermal_sensor_conf *reg_conf;
+        struct thermal_zone_device *tzd;
+
         int (*tmu_initialize)(struct platform_device *pdev);
         void (*tmu_control)(struct platform_device *pdev, bool on);
         int (*tmu_read)(struct exynos_tmu_data *data);
@@ -159,6 +186,33 @@ struct exynos_tmu_data {
         void (*tmu_clear_irqs)(struct exynos_tmu_data *data);
 };
 
+static void exynos_report_trigger(struct exynos_tmu_data *p)
+{
+        char data[10], *envp[] = { data, NULL };
+        struct thermal_zone_device *tz = p->tzd;
+        unsigned long temp;
+        unsigned int i;
+
+        if (!tz) {
+                pr_err("No thermal zone device defined\n");
+                return;
+        }
+
+        thermal_zone_device_update(tz);
+
+        mutex_lock(&tz->lock);
+        /* Find the level for which trip happened */
+        for (i = 0; i < of_thermal_get_ntrips(tz); i++) {
+                tz->ops->get_trip_temp(tz, i, &temp);
+                if (tz->last_temperature < temp)
+                        break;
+        }
+
+        snprintf(data, sizeof(data), "%u", i);
+        kobject_uevent_env(&tz->device.kobj, KOBJ_CHANGE, envp);
+        mutex_unlock(&tz->lock);
+}
+
 /*
  * TMU treats temperature as a mapped temperature code.
  * The temperature is converted differently depending on the calibration type.
@@ -190,7 +244,7 @@ static int temp_to_code(struct exynos_tmu_data *data, u8 temp)
  * Calculate a temperature value from a temperature code.
  * The unit of the temperature is degree Celsius.
  */
-static int code_to_temp(struct exynos_tmu_data *data, u8 temp_code)
+static int code_to_temp(struct exynos_tmu_data *data, u16 temp_code)
 {
         struct exynos_tmu_platform_data *pdata = data->pdata;
         int temp;
@@ -234,14 +288,25 @@ static void sanitize_temp_error(struct exynos_tmu_data *data, u32 trim_info)
 
 static u32 get_th_reg(struct exynos_tmu_data *data, u32 threshold, bool falling)
 {
-        struct exynos_tmu_platform_data *pdata = data->pdata;
+        struct thermal_zone_device *tz = data->tzd;
+        const struct thermal_trip * const trips =
+                of_thermal_get_trip_points(tz);
+        unsigned long temp;
         int i;
 
-        for (i = 0; i < pdata->non_hw_trigger_levels; i++) {
-                u8 temp = pdata->trigger_levels[i];
+        if (!trips) {
+                pr_err("%s: Cannot get trip points from of-thermal.c!\n",
+                       __func__);
+                return 0;
+        }
+
+        for (i = 0; i < of_thermal_get_ntrips(tz); i++) {
+                if (trips[i].type == THERMAL_TRIP_CRITICAL)
+                        continue;
 
+                temp = trips[i].temperature / MCELSIUS;
                 if (falling)
-                        temp -= pdata->threshold_falling;
+                        temp -= (trips[i].hysteresis / MCELSIUS);
                 else
                         threshold &= ~(0xff << 8 * i);
 
@@ -305,9 +370,19 @@ static void exynos_tmu_control(struct platform_device *pdev, bool on)
 static int exynos4210_tmu_initialize(struct platform_device *pdev)
 {
         struct exynos_tmu_data *data = platform_get_drvdata(pdev);
-        struct exynos_tmu_platform_data *pdata = data->pdata;
-        unsigned int status;
+        struct thermal_zone_device *tz = data->tzd;
+        const struct thermal_trip * const trips =
+                of_thermal_get_trip_points(tz);
         int ret = 0, threshold_code, i;
+        unsigned long reference, temp;
+        unsigned int status;
+
+        if (!trips) {
+                pr_err("%s: Cannot get trip points from of-thermal.c!\n",
+                       __func__);
+                ret = -ENODEV;
+                goto out;
+        }
 
         status = readb(data->base + EXYNOS_TMU_REG_STATUS);
         if (!status) {
@@ -318,12 +393,19 @@ static int exynos4210_tmu_initialize(struct platform_device *pdev)
         sanitize_temp_error(data, readl(data->base + EXYNOS_TMU_REG_TRIMINFO));
 
         /* Write temperature code for threshold */
-        threshold_code = temp_to_code(data, pdata->threshold);
+        reference = trips[0].temperature / MCELSIUS;
+        threshold_code = temp_to_code(data, reference);
+        if (threshold_code < 0) {
+                ret = threshold_code;
+                goto out;
+        }
         writeb(threshold_code, data->base + EXYNOS4210_TMU_REG_THRESHOLD_TEMP);
 
-        for (i = 0; i < pdata->non_hw_trigger_levels; i++)
-                writeb(pdata->trigger_levels[i], data->base +
+        for (i = 0; i < of_thermal_get_ntrips(tz); i++) {
+                temp = trips[i].temperature / MCELSIUS;
+                writeb(temp - reference, data->base +
                        EXYNOS4210_TMU_REG_TRIG_LEVEL0 + i * 4);
+        }
 
         data->tmu_clear_irqs(data);
 out:
@@ -333,9 +415,11 @@ out:
 static int exynos4412_tmu_initialize(struct platform_device *pdev)
 {
         struct exynos_tmu_data *data = platform_get_drvdata(pdev);
-        struct exynos_tmu_platform_data *pdata = data->pdata;
+        const struct thermal_trip * const trips =
+                of_thermal_get_trip_points(data->tzd);
         unsigned int status, trim_info, con, ctrl, rising_threshold;
         int ret = 0, threshold_code, i;
+        unsigned long crit_temp = 0;
 
         status = readb(data->base + EXYNOS_TMU_REG_STATUS);
         if (!status) {
@@ -373,17 +457,29 @@ static int exynos4412_tmu_initialize(struct platform_device *pdev)
         data->tmu_clear_irqs(data);
 
         /* if last threshold limit is also present */
-        i = pdata->max_trigger_level - 1;
-        if (pdata->trigger_levels[i] && pdata->trigger_type[i] == HW_TRIP) {
-                threshold_code = temp_to_code(data, pdata->trigger_levels[i]);
-                /* 1-4 level to be assigned in th0 reg */
-                rising_threshold &= ~(0xff << 8 * i);
-                rising_threshold |= threshold_code << 8 * i;
-                writel(rising_threshold, data->base + EXYNOS_THD_TEMP_RISE);
-                con = readl(data->base + EXYNOS_TMU_REG_CONTROL);
-                con |= (1 << EXYNOS_TMU_THERM_TRIP_EN_SHIFT);
-                writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
+        for (i = 0; i < of_thermal_get_ntrips(data->tzd); i++) {
+                if (trips[i].type == THERMAL_TRIP_CRITICAL) {
+                        crit_temp = trips[i].temperature;
+                        break;
+                }
+        }
+
+        if (i == of_thermal_get_ntrips(data->tzd)) {
+                pr_err("%s: No CRITICAL trip point defined at of-thermal.c!\n",
+                       __func__);
+                ret = -EINVAL;
+                goto out;
         }
+
+        threshold_code = temp_to_code(data, crit_temp / MCELSIUS);
+        /* 1-4 level to be assigned in th0 reg */
+        rising_threshold &= ~(0xff << 8 * i);
+        rising_threshold |= threshold_code << 8 * i;
+        writel(rising_threshold, data->base + EXYNOS_THD_TEMP_RISE);
+        con = readl(data->base + EXYNOS_TMU_REG_CONTROL);
+        con |= (1 << EXYNOS_TMU_THERM_TRIP_EN_SHIFT);
+        writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
+
 out:
         return ret;
 }
@@ -391,9 +487,9 @@ out:
 static int exynos5440_tmu_initialize(struct platform_device *pdev)
 {
         struct exynos_tmu_data *data = platform_get_drvdata(pdev);
-        struct exynos_tmu_platform_data *pdata = data->pdata;
         unsigned int trim_info = 0, con, rising_threshold;
-        int ret = 0, threshold_code, i;
+        int ret = 0, threshold_code;
+        unsigned long crit_temp = 0;
 
         /*
          * For exynos5440 soc triminfo value is swapped between TMU0 and
@@ -422,9 +518,8 @@ static int exynos5440_tmu_initialize(struct platform_device *pdev)
         data->tmu_clear_irqs(data);
 
         /* if last threshold limit is also present */
-        i = pdata->max_trigger_level - 1;
-        if (pdata->trigger_levels[i] && pdata->trigger_type[i] == HW_TRIP) {
-                threshold_code = temp_to_code(data, pdata->trigger_levels[i]);
+        if (!data->tzd->ops->get_crit_temp(data->tzd, &crit_temp)) {
+                threshold_code = temp_to_code(data, crit_temp / MCELSIUS);
                 /* 5th level to be assigned in th2 reg */
                 rising_threshold =
                         threshold_code << EXYNOS5440_TMU_TH_RISE4_SHIFT;
@@ -439,10 +534,88 @@ static int exynos5440_tmu_initialize(struct platform_device *pdev)
         return ret;
 }
 
-static void exynos4210_tmu_control(struct platform_device *pdev, bool on)
+static int exynos7_tmu_initialize(struct platform_device *pdev)
 {
         struct exynos_tmu_data *data = platform_get_drvdata(pdev);
+        struct thermal_zone_device *tz = data->tzd;
         struct exynos_tmu_platform_data *pdata = data->pdata;
+        unsigned int status, trim_info;
+        unsigned int rising_threshold = 0, falling_threshold = 0;
+        int ret = 0, threshold_code, i;
+        unsigned long temp, temp_hist;
+        unsigned int reg_off, bit_off;
+
+        status = readb(data->base + EXYNOS_TMU_REG_STATUS);
+        if (!status) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        trim_info = readl(data->base + EXYNOS_TMU_REG_TRIMINFO);
+
+        data->temp_error1 = trim_info & EXYNOS7_TMU_TEMP_MASK;
+        if (!data->temp_error1 ||
+            (pdata->min_efuse_value > data->temp_error1) ||
+            (data->temp_error1 > pdata->max_efuse_value))
+                data->temp_error1 = pdata->efuse_value & EXYNOS_TMU_TEMP_MASK;
+
+        /* Write temperature code for rising and falling threshold */
+        for (i = (of_thermal_get_ntrips(tz) - 1); i >= 0; i--) {
+                /*
+                 * On exynos7 there are 4 rising and 4 falling threshold
+                 * registers (0x50-0x5c and 0x60-0x6c respectively). Each
+                 * register holds the value of two threshold levels (at bit
+                 * offsets 0 and 16). Based on the fact that there are atmost
+                 * eight possible trigger levels, calculate the register and
+                 * bit offsets where the threshold levels are to be written.
+                 *
+                 * e.g. EXYNOS7_THD_TEMP_RISE7_6 (0x50)
+                 * [24:16] - Threshold level 7
+                 * [8:0] - Threshold level 6
+                 * e.g. EXYNOS7_THD_TEMP_RISE5_4 (0x54)
+                 * [24:16] - Threshold level 5
+                 * [8:0] - Threshold level 4
+                 *
+                 * and similarly for falling thresholds.
+                 *
+                 * Based on the above, calculate the register and bit offsets
+                 * for rising/falling threshold levels and populate them.
+                 */
+                reg_off = ((7 - i) / 2) * 4;
+                bit_off = ((8 - i) % 2);
+
+                tz->ops->get_trip_temp(tz, i, &temp);
+                temp /= MCELSIUS;
+
+                tz->ops->get_trip_hyst(tz, i, &temp_hist);
+                temp_hist = temp - (temp_hist / MCELSIUS);
+
+                /* Set 9-bit temperature code for rising threshold levels */
+                threshold_code = temp_to_code(data, temp);
+                rising_threshold = readl(data->base +
+                        EXYNOS7_THD_TEMP_RISE7_6 + reg_off);
+                rising_threshold &= ~(EXYNOS7_TMU_TEMP_MASK << (16 * bit_off));
+                rising_threshold |= threshold_code << (16 * bit_off);
+                writel(rising_threshold,
+                       data->base + EXYNOS7_THD_TEMP_RISE7_6 + reg_off);
+
+                /* Set 9-bit temperature code for falling threshold levels */
+                threshold_code = temp_to_code(data, temp_hist);
+                falling_threshold &= ~(EXYNOS7_TMU_TEMP_MASK << (16 * bit_off));
+                falling_threshold |= threshold_code << (16 * bit_off);
+                writel(falling_threshold,
+                       data->base + EXYNOS7_THD_TEMP_FALL7_6 + reg_off);
+        }
+
+        data->tmu_clear_irqs(data);
+out:
+        return ret;
+}
+
+static void exynos4210_tmu_control(struct platform_device *pdev, bool on)
+{
+        struct exynos_tmu_data *data = platform_get_drvdata(pdev);
+        struct thermal_zone_device *tz = data->tzd;
         unsigned int con, interrupt_en;
 
         con = get_con_reg(data, readl(data->base + EXYNOS_TMU_REG_CONTROL));
@@ -450,10 +623,15 @@ static void exynos4210_tmu_control(struct platform_device *pdev, bool on)
         if (on) {
                 con |= (1 << EXYNOS_TMU_CORE_EN_SHIFT);
                 interrupt_en =
-                        pdata->trigger_enable[3] << EXYNOS_TMU_INTEN_RISE3_SHIFT |
-                        pdata->trigger_enable[2] << EXYNOS_TMU_INTEN_RISE2_SHIFT |
-                        pdata->trigger_enable[1] << EXYNOS_TMU_INTEN_RISE1_SHIFT |
-                        pdata->trigger_enable[0] << EXYNOS_TMU_INTEN_RISE0_SHIFT;
+                        (of_thermal_is_trip_valid(tz, 3)
+                         << EXYNOS_TMU_INTEN_RISE3_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 2)
+                         << EXYNOS_TMU_INTEN_RISE2_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 1)
+                         << EXYNOS_TMU_INTEN_RISE1_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 0)
+                         << EXYNOS_TMU_INTEN_RISE0_SHIFT);
+
                 if (data->soc != SOC_ARCH_EXYNOS4210)
                         interrupt_en |=
                                 interrupt_en << EXYNOS_TMU_INTEN_FALL0_SHIFT;
@@ -468,7 +646,7 @@ static void exynos4210_tmu_control(struct platform_device *pdev, bool on)
 static void exynos5440_tmu_control(struct platform_device *pdev, bool on)
 {
         struct exynos_tmu_data *data = platform_get_drvdata(pdev);
-        struct exynos_tmu_platform_data *pdata = data->pdata;
+        struct thermal_zone_device *tz = data->tzd;
         unsigned int con, interrupt_en;
 
         con = get_con_reg(data, readl(data->base + EXYNOS5440_TMU_S0_7_CTRL));
@@ -476,11 +654,16 @@ static void exynos5440_tmu_control(struct platform_device *pdev, bool on)
         if (on) {
                 con |= (1 << EXYNOS_TMU_CORE_EN_SHIFT);
                 interrupt_en =
-                        pdata->trigger_enable[3] << EXYNOS5440_TMU_INTEN_RISE3_SHIFT |
-                        pdata->trigger_enable[2] << EXYNOS5440_TMU_INTEN_RISE2_SHIFT |
-                        pdata->trigger_enable[1] << EXYNOS5440_TMU_INTEN_RISE1_SHIFT |
-                        pdata->trigger_enable[0] << EXYNOS5440_TMU_INTEN_RISE0_SHIFT;
-                interrupt_en |= interrupt_en << EXYNOS5440_TMU_INTEN_FALL0_SHIFT;
+                        (of_thermal_is_trip_valid(tz, 3)
+                         << EXYNOS5440_TMU_INTEN_RISE3_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 2)
+                         << EXYNOS5440_TMU_INTEN_RISE2_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 1)
+                         << EXYNOS5440_TMU_INTEN_RISE1_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 0)
+                         << EXYNOS5440_TMU_INTEN_RISE0_SHIFT);
+                interrupt_en |=
+                        interrupt_en << EXYNOS5440_TMU_INTEN_FALL0_SHIFT;
         } else {
                 con &= ~(1 << EXYNOS_TMU_CORE_EN_SHIFT);
                 interrupt_en = 0; /* Disable all interrupts */
@@ -489,19 +672,62 @@ static void exynos5440_tmu_control(struct platform_device *pdev, bool on)
         writel(con, data->base + EXYNOS5440_TMU_S0_7_CTRL);
 }
 
-static int exynos_tmu_read(struct exynos_tmu_data *data)
+static void exynos7_tmu_control(struct platform_device *pdev, bool on)
 {
-        int ret;
+        struct exynos_tmu_data *data = platform_get_drvdata(pdev);
+        struct thermal_zone_device *tz = data->tzd;
+        unsigned int con, interrupt_en;
+
+        con = get_con_reg(data, readl(data->base + EXYNOS_TMU_REG_CONTROL));
+
+        if (on) {
+                con |= (1 << EXYNOS_TMU_CORE_EN_SHIFT);
+                interrupt_en =
+                        (of_thermal_is_trip_valid(tz, 7)
+                        << EXYNOS7_TMU_INTEN_RISE7_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 6)
+                        << EXYNOS7_TMU_INTEN_RISE6_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 5)
+                        << EXYNOS7_TMU_INTEN_RISE5_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 4)
+                        << EXYNOS7_TMU_INTEN_RISE4_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 3)
+                        << EXYNOS7_TMU_INTEN_RISE3_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 2)
+                        << EXYNOS7_TMU_INTEN_RISE2_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 1)
+                        << EXYNOS7_TMU_INTEN_RISE1_SHIFT) |
+                        (of_thermal_is_trip_valid(tz, 0)
+                        << EXYNOS7_TMU_INTEN_RISE0_SHIFT);
+
+                interrupt_en |=
+                        interrupt_en << EXYNOS_TMU_INTEN_FALL0_SHIFT;
+        } else {
+                con &= ~(1 << EXYNOS_TMU_CORE_EN_SHIFT);
+                interrupt_en = 0; /* Disable all interrupts */
+        }
+        con |= 1 << EXYNOS7_PD_DET_EN_SHIFT;
+
+        writel(interrupt_en, data->base + EXYNOS7_TMU_REG_INTEN);
+        writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
+}
+
+static int exynos_get_temp(void *p, long *temp)
+{
+        struct exynos_tmu_data *data = p;
+
+        if (!data || !data->tmu_read)
+                return -EINVAL;
 
         mutex_lock(&data->lock);
         clk_enable(data->clk);
-        ret = data->tmu_read(data);
-        if (ret >= 0)
-                ret = code_to_temp(data, ret);
+
+        *temp = code_to_temp(data, data->tmu_read(data)) * MCELSIUS;
+
         clk_disable(data->clk);
         mutex_unlock(&data->lock);
 
-        return ret;
+        return 0;
 }
 
 #ifdef CONFIG_THERMAL_EMULATION
@@ -515,9 +741,19 @@ static u32 get_emul_con_reg(struct exynos_tmu_data *data, unsigned int val,
                         val &= ~(EXYNOS_EMUL_TIME_MASK << EXYNOS_EMUL_TIME_SHIFT);
                         val |= (EXYNOS_EMUL_TIME << EXYNOS_EMUL_TIME_SHIFT);
                 }
-                val &= ~(EXYNOS_EMUL_DATA_MASK << EXYNOS_EMUL_DATA_SHIFT);
-                val |= (temp_to_code(data, temp) << EXYNOS_EMUL_DATA_SHIFT) |
-                        EXYNOS_EMUL_ENABLE;
+                if (data->soc == SOC_ARCH_EXYNOS7) {
+                        val &= ~(EXYNOS7_EMUL_DATA_MASK <<
+                                EXYNOS7_EMUL_DATA_SHIFT);
+                        val |= (temp_to_code(data, temp) <<
+                                EXYNOS7_EMUL_DATA_SHIFT) |
+                                EXYNOS_EMUL_ENABLE;
+                } else {
+                        val &= ~(EXYNOS_EMUL_DATA_MASK <<
+                                EXYNOS_EMUL_DATA_SHIFT);
+                        val |= (temp_to_code(data, temp) <<
+                                EXYNOS_EMUL_DATA_SHIFT) |
+                                EXYNOS_EMUL_ENABLE;
+                }
         } else {
                 val &= ~EXYNOS_EMUL_ENABLE;
         }
@@ -533,6 +769,8 @@ static void exynos4412_tmu_set_emulation(struct exynos_tmu_data *data,
 
         if (data->soc == SOC_ARCH_EXYNOS5260)
                 emul_con = EXYNOS5260_EMUL_CON;
+        else if (data->soc == SOC_ARCH_EXYNOS7)
+                emul_con = EXYNOS7_TMU_REG_EMUL_CON;
         else
                 emul_con = EXYNOS_EMUL_CON;
 
@@ -576,7 +814,7 @@ out:
 #define exynos5440_tmu_set_emulation NULL
 static int exynos_tmu_set_emulation(void *drv_data,     unsigned long temp)
         { return -EINVAL; }
-#endif/*CONFIG_THERMAL_EMULATION*/
+#endif /* CONFIG_THERMAL_EMULATION */
 
 static int exynos4210_tmu_read(struct exynos_tmu_data *data)
 {
@@ -596,6 +834,12 @@ static int exynos5440_tmu_read(struct exynos_tmu_data *data)
         return readb(data->base + EXYNOS5440_TMU_S0_7_TEMP);
 }
 
+static int exynos7_tmu_read(struct exynos_tmu_data *data)
+{
+        return readw(data->base + EXYNOS_TMU_REG_CURRENT_TEMP) &
+                EXYNOS7_TMU_TEMP_MASK;
+}
+
 static void exynos_tmu_work(struct work_struct *work)
 {
         struct exynos_tmu_data *data = container_of(work,
@@ -613,7 +857,7 @@ static void exynos_tmu_work(struct work_struct *work)
         if (!IS_ERR(data->clk_sec))
                 clk_disable(data->clk_sec);
 
-        exynos_report_trigger(data->reg_conf);
+        exynos_report_trigger(data);
         mutex_lock(&data->lock);
         clk_enable(data->clk);
 
@@ -634,6 +878,9 @@ static void exynos4210_tmu_clear_irqs(struct exynos_tmu_data *data)
         if (data->soc == SOC_ARCH_EXYNOS5260) {
                 tmu_intstat = EXYNOS5260_TMU_REG_INTSTAT;
                 tmu_intclear = EXYNOS5260_TMU_REG_INTCLEAR;
+        } else if (data->soc == SOC_ARCH_EXYNOS7) {
+                tmu_intstat = EXYNOS7_TMU_REG_INTPEND;
+                tmu_intclear = EXYNOS7_TMU_REG_INTPEND;
         } else {
                 tmu_intstat = EXYNOS_TMU_REG_INTSTAT;
                 tmu_intclear = EXYNOS_TMU_REG_INTCLEAR;
@@ -671,57 +918,78 @@ static irqreturn_t exynos_tmu_irq(int irq, void *id)
 }
 
 static const struct of_device_id exynos_tmu_match[] = {
-        {
-                .compatible = "samsung,exynos3250-tmu",
-                .data = &exynos3250_default_tmu_data,
-        },
-        {
-                .compatible = "samsung,exynos4210-tmu",
-                .data = &exynos4210_default_tmu_data,
-        },
-        {
-                .compatible = "samsung,exynos4412-tmu",
-                .data = &exynos4412_default_tmu_data,
-        },
-        {
-                .compatible = "samsung,exynos5250-tmu",
-                .data = &exynos5250_default_tmu_data,
-        },
-        {
-                .compatible = "samsung,exynos5260-tmu",
-                .data = &exynos5260_default_tmu_data,
-        },
-        {
-                .compatible = "samsung,exynos5420-tmu",
-                .data = &exynos5420_default_tmu_data,
-        },
-        {
-                .compatible = "samsung,exynos5420-tmu-ext-triminfo",
-                .data = &exynos5420_default_tmu_data,
-        },
-        {
-                .compatible = "samsung,exynos5440-tmu",
-                .data = &exynos5440_default_tmu_data,
-        },
-        {},
+        { .compatible = "samsung,exynos3250-tmu", },
+        { .compatible = "samsung,exynos4210-tmu", },
+        { .compatible = "samsung,exynos4412-tmu", },
+        { .compatible = "samsung,exynos5250-tmu", },
+        { .compatible = "samsung,exynos5260-tmu", },
+        { .compatible = "samsung,exynos5420-tmu", },
+        { .compatible = "samsung,exynos5420-tmu-ext-triminfo", },
+        { .compatible = "samsung,exynos5440-tmu", },
+        { .compatible = "samsung,exynos7-tmu", },
+        { /* sentinel */ },
 };
 MODULE_DEVICE_TABLE(of, exynos_tmu_match);
 
-static inline struct  exynos_tmu_platform_data *exynos_get_driver_data(
-                        struct platform_device *pdev, int id)
+static int exynos_of_get_soc_type(struct device_node *np)
+{
+        if (of_device_is_compatible(np, "samsung,exynos3250-tmu"))
+                return SOC_ARCH_EXYNOS3250;
+        else if (of_device_is_compatible(np, "samsung,exynos4210-tmu"))
+                return SOC_ARCH_EXYNOS4210;
+        else if (of_device_is_compatible(np, "samsung,exynos4412-tmu"))
+                return SOC_ARCH_EXYNOS4412;
+        else if (of_device_is_compatible(np, "samsung,exynos5250-tmu"))
+                return SOC_ARCH_EXYNOS5250;
+        else if (of_device_is_compatible(np, "samsung,exynos5260-tmu"))
+                return SOC_ARCH_EXYNOS5260;
+        else if (of_device_is_compatible(np, "samsung,exynos5420-tmu"))
+                return SOC_ARCH_EXYNOS5420;
+        else if (of_device_is_compatible(np,
+                                         "samsung,exynos5420-tmu-ext-triminfo"))
+                return SOC_ARCH_EXYNOS5420_TRIMINFO;
+        else if (of_device_is_compatible(np, "samsung,exynos5440-tmu"))
+                return SOC_ARCH_EXYNOS5440;
+        else if (of_device_is_compatible(np, "samsung,exynos7-tmu"))
+                return SOC_ARCH_EXYNOS7;
+
+        return -EINVAL;
+}
+
+static int exynos_of_sensor_conf(struct device_node *np,
+                                 struct exynos_tmu_platform_data *pdata)
 {
-        struct  exynos_tmu_init_data *data_table;
-        struct exynos_tmu_platform_data *tmu_data;
-        const struct of_device_id *match;
+        u32 value;
+        int ret;
 
-        match = of_match_node(exynos_tmu_match, pdev->dev.of_node);
-        if (!match)
-                return NULL;
-        data_table = (struct exynos_tmu_init_data *) match->data;
-        if (!data_table || id >= data_table->tmu_count)
-                return NULL;
-        tmu_data = data_table->tmu_data;
-        return (struct exynos_tmu_platform_data *) (tmu_data + id);
+        of_node_get(np);
+
+        ret = of_property_read_u32(np, "samsung,tmu_gain", &value);
+        pdata->gain = (u8)value;
+        of_property_read_u32(np, "samsung,tmu_reference_voltage", &value);
+        pdata->reference_voltage = (u8)value;
+        of_property_read_u32(np, "samsung,tmu_noise_cancel_mode", &value);
+        pdata->noise_cancel_mode = (u8)value;
+
+        of_property_read_u32(np, "samsung,tmu_efuse_value",
+                             &pdata->efuse_value);
+        of_property_read_u32(np, "samsung,tmu_min_efuse_value",
+                             &pdata->min_efuse_value);
+        of_property_read_u32(np, "samsung,tmu_max_efuse_value",
+                             &pdata->max_efuse_value);
+
+        of_property_read_u32(np, "samsung,tmu_first_point_trim", &value);
+        pdata->first_point_trim = (u8)value;
+        of_property_read_u32(np, "samsung,tmu_second_point_trim", &value);
+        pdata->second_point_trim = (u8)value;
+        of_property_read_u32(np, "samsung,tmu_default_temp_offset", &value);
+        pdata->default_temp_offset = (u8)value;
+
+        of_property_read_u32(np, "samsung,tmu_cal_type", &pdata->cal_type);
+        of_property_read_u32(np, "samsung,tmu_cal_mode", &pdata->cal_mode);
+
+        of_node_put(np);
+        return 0;
 }
 
 static int exynos_map_dt_data(struct platform_device *pdev)
@@ -771,14 +1039,15 @@ static int exynos_map_dt_data(struct platform_device *pdev)
                 return -EADDRNOTAVAIL;
         }
 
-        pdata = exynos_get_driver_data(pdev, data->id);
-        if (!pdata) {
-                dev_err(&pdev->dev, "No platform init data supplied.\n");
-                return -ENODEV;
-        }
+        pdata = devm_kzalloc(&pdev->dev,
+                             sizeof(struct exynos_tmu_platform_data),
+                             GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
 
+        exynos_of_sensor_conf(pdev->dev.of_node, pdata);
         data->pdata = pdata;
-        data->soc = pdata->type;
+        data->soc = exynos_of_get_soc_type(pdev->dev.of_node);
 
         switch (data->soc) {
         case SOC_ARCH_EXYNOS4210:
@@ -806,6 +1075,13 @@ static int exynos_map_dt_data(struct platform_device *pdev)
                 data->tmu_set_emulation = exynos5440_tmu_set_emulation;
                 data->tmu_clear_irqs = exynos5440_tmu_clear_irqs;
                 break;
+        case SOC_ARCH_EXYNOS7:
+                data->tmu_initialize = exynos7_tmu_initialize;
+                data->tmu_control = exynos7_tmu_control;
+                data->tmu_read = exynos7_tmu_read;
+                data->tmu_set_emulation = exynos4412_tmu_set_emulation;
+                data->tmu_clear_irqs = exynos4210_tmu_clear_irqs;
+                break;
         default:
                 dev_err(&pdev->dev, "Platform not supported\n");
                 return -EINVAL;
@@ -834,12 +1110,16 @@ static int exynos_map_dt_data(struct platform_device *pdev)
         return 0;
 }
 
+static struct thermal_zone_of_device_ops exynos_sensor_ops = {
+        .get_temp = exynos_get_temp,
+        .set_emul_temp = exynos_tmu_set_emulation,
+};
+
 static int exynos_tmu_probe(struct platform_device *pdev)
 {
-        struct exynos_tmu_data *data;
         struct exynos_tmu_platform_data *pdata;
-        struct thermal_sensor_conf *sensor_conf;
-        int ret, i;
+        struct exynos_tmu_data *data;
+        int ret;
 
         data = devm_kzalloc(&pdev->dev, sizeof(struct exynos_tmu_data),
                                         GFP_KERNEL);
@@ -849,9 +1129,15 @@ static int exynos_tmu_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, data);
         mutex_init(&data->lock);
 
+        data->tzd = thermal_zone_of_sensor_register(&pdev->dev, 0, data,
+                                                    &exynos_sensor_ops);
+        if (IS_ERR(data->tzd)) {
+                pr_err("thermal: tz: %p ERROR\n", data->tzd);
+                return PTR_ERR(data->tzd);
+        }
         ret = exynos_map_dt_data(pdev);
         if (ret)
-                return ret;
+                goto err_sensor;
 
         pdata = data->pdata;
 
@@ -860,20 +1146,22 @@ static int exynos_tmu_probe(struct platform_device *pdev)
         data->clk = devm_clk_get(&pdev->dev, "tmu_apbif");
         if (IS_ERR(data->clk)) {
                 dev_err(&pdev->dev, "Failed to get clock\n");
-                return  PTR_ERR(data->clk);
+                ret = PTR_ERR(data->clk);
+                goto err_sensor;
         }
 
         data->clk_sec = devm_clk_get(&pdev->dev, "tmu_triminfo_apbif");
         if (IS_ERR(data->clk_sec)) {
                 if (data->soc == SOC_ARCH_EXYNOS5420_TRIMINFO) {
                         dev_err(&pdev->dev, "Failed to get triminfo clock\n");
-                        return PTR_ERR(data->clk_sec);
+                        ret = PTR_ERR(data->clk_sec);
+                        goto err_sensor;
                 }
         } else {
                 ret = clk_prepare(data->clk_sec);
                 if (ret) {
                         dev_err(&pdev->dev, "Failed to get clock\n");
-                        return ret;
+                        goto err_sensor;
                 }
         }
 
@@ -883,82 +1171,57 @@ static int exynos_tmu_probe(struct platform_device *pdev)
                 goto err_clk_sec;
         }
 
-        ret = exynos_tmu_initialize(pdev);
-        if (ret) {
-                dev_err(&pdev->dev, "Failed to initialize TMU\n");
-                goto err_clk;
+        if (data->soc == SOC_ARCH_EXYNOS7) {
+                data->sclk = devm_clk_get(&pdev->dev, "tmu_sclk");
+                if (IS_ERR(data->sclk)) {
+                        dev_err(&pdev->dev, "Failed to get sclk\n");
+                        goto err_clk;
+                } else {
+                        ret = clk_prepare_enable(data->sclk);
+                        if (ret) {
+                                dev_err(&pdev->dev, "Failed to enable sclk\n");
+                                goto err_clk;
+                        }
+                }
         }
 
-        exynos_tmu_control(pdev, true);
-
-        /* Allocate a structure to register with the exynos core thermal */
-        sensor_conf = devm_kzalloc(&pdev->dev,
-                                sizeof(struct thermal_sensor_conf), GFP_KERNEL);
-        if (!sensor_conf) {
-                ret = -ENOMEM;
-                goto err_clk;
-        }
-        sprintf(sensor_conf->name, "therm_zone%d", data->id);
-        sensor_conf->read_temperature = (int (*)(void *))exynos_tmu_read;
-        sensor_conf->write_emul_temp =
-                (int (*)(void *, unsigned long))exynos_tmu_set_emulation;
-        sensor_conf->driver_data = data;
-        sensor_conf->trip_data.trip_count = pdata->trigger_enable[0] +
-                        pdata->trigger_enable[1] + pdata->trigger_enable[2]+
-                        pdata->trigger_enable[3];
-
-        for (i = 0; i < sensor_conf->trip_data.trip_count; i++) {
-                sensor_conf->trip_data.trip_val[i] =
-                        pdata->threshold + pdata->trigger_levels[i];
-                sensor_conf->trip_data.trip_type[i] =
-                                        pdata->trigger_type[i];
-        }
-
-        sensor_conf->trip_data.trigger_falling = pdata->threshold_falling;
-
-        sensor_conf->cooling_data.freq_clip_count = pdata->freq_tab_count;
-        for (i = 0; i < pdata->freq_tab_count; i++) {
-                sensor_conf->cooling_data.freq_data[i].freq_clip_max =
-                                        pdata->freq_tab[i].freq_clip_max;
-                sensor_conf->cooling_data.freq_data[i].temp_level =
-                                        pdata->freq_tab[i].temp_level;
-        }
-        sensor_conf->dev = &pdev->dev;
-        /* Register the sensor with thermal management interface */
-        ret = exynos_register_thermal(sensor_conf);
+        ret = exynos_tmu_initialize(pdev);
         if (ret) {
-                if (ret != -EPROBE_DEFER)
-                        dev_err(&pdev->dev,
-                                "Failed to register thermal interface: %d\n",
-                                ret);
-                goto err_clk;
+                dev_err(&pdev->dev, "Failed to initialize TMU\n");
+                goto err_sclk;
         }
-        data->reg_conf = sensor_conf;
 
         ret = devm_request_irq(&pdev->dev, data->irq, exynos_tmu_irq,
                 IRQF_TRIGGER_RISING | IRQF_SHARED, dev_name(&pdev->dev), data);
         if (ret) {
                 dev_err(&pdev->dev, "Failed to request irq: %d\n", data->irq);
-                goto err_clk;
+                goto err_sclk;
         }
 
+        exynos_tmu_control(pdev, true);
         return 0;
+err_sclk:
+        clk_disable_unprepare(data->sclk);
 err_clk:
         clk_unprepare(data->clk);
 err_clk_sec:
         if (!IS_ERR(data->clk_sec))
                 clk_unprepare(data->clk_sec);
+err_sensor:
+        thermal_zone_of_sensor_unregister(&pdev->dev, data->tzd);
+
         return ret;
 }
 
 static int exynos_tmu_remove(struct platform_device *pdev)
 {
         struct exynos_tmu_data *data = platform_get_drvdata(pdev);
+        struct thermal_zone_device *tzd = data->tzd;
 
-        exynos_unregister_thermal(data->reg_conf);
-
+        thermal_zone_of_sensor_unregister(&pdev->dev, tzd);
         exynos_tmu_control(pdev, false);
 
+        clk_disable_unprepare(data->sclk);
         clk_unprepare(data->clk);
         if (!IS_ERR(data->clk_sec))
                 clk_unprepare(data->clk_sec);
diff --git a/drivers/thermal/samsung/exynos_tmu.h b/drivers/thermal/samsung/exynos_tmu.h
index da3009bff6c4..4d71ec6c9aa0 100644
--- a/drivers/thermal/samsung/exynos_tmu.h
+++ b/drivers/thermal/samsung/exynos_tmu.h
@@ -23,16 +23,7 @@
 #ifndef _EXYNOS_TMU_H
 #define _EXYNOS_TMU_H
 #include <linux/cpu_cooling.h>
-
-#include "exynos_thermal_common.h"
-
-enum calibration_type {
-        TYPE_ONE_POINT_TRIMMING,
-        TYPE_ONE_POINT_TRIMMING_25,
-        TYPE_ONE_POINT_TRIMMING_85,
-        TYPE_TWO_POINT_TRIMMING,
-        TYPE_NONE,
-};
+#include <dt-bindings/thermal/thermal_exynos.h>
 
 enum soc_type {
         SOC_ARCH_EXYNOS3250 = 1,
@@ -43,38 +34,11 @@ enum soc_type {
         SOC_ARCH_EXYNOS5420,
         SOC_ARCH_EXYNOS5420_TRIMINFO,
         SOC_ARCH_EXYNOS5440,
+        SOC_ARCH_EXYNOS7,
 };
 
 /**
  * struct exynos_tmu_platform_data
- * @threshold: basic temperature for generating interrupt
- *             25 <= threshold <= 125 [unit: degree Celsius]
- * @threshold_falling: differntial value for setting threshold
- *                     of temperature falling interrupt.
- * @trigger_levels: array for each interrupt levels
- *      [unit: degree Celsius]
- *      0: temperature for trigger_level0 interrupt
- *         condition for trigger_level0 interrupt:
- *              current temperature > threshold + trigger_levels[0]
- *      1: temperature for trigger_level1 interrupt
- *         condition for trigger_level1 interrupt:
- *              current temperature > threshold + trigger_levels[1]
- *      2: temperature for trigger_level2 interrupt
- *         condition for trigger_level2 interrupt:
- *              current temperature > threshold + trigger_levels[2]
- *      3: temperature for trigger_level3 interrupt
- *         condition for trigger_level3 interrupt:
- *              current temperature > threshold + trigger_levels[3]
- * @trigger_type: defines the type of trigger. Possible values are,
- *      THROTTLE_ACTIVE trigger type
- *      THROTTLE_PASSIVE trigger type
- *      SW_TRIP trigger type
- *      HW_TRIP
- * @trigger_enable[]: array to denote which trigger levels are enabled.
- *      1 = enable trigger_level[] interrupt,
- *      0 = disable trigger_level[] interrupt
- * @max_trigger_level: max trigger level supported by the TMU
- * @non_hw_trigger_levels: number of defined non-hardware trigger levels
  * @gain: gain of amplifier in the positive-TC generator block
  *      0 < gain <= 15
  * @reference_voltage: reference voltage of amplifier
@@ -86,24 +50,12 @@ enum soc_type {
  * @efuse_value: platform defined fuse value
  * @min_efuse_value: minimum valid trimming data
  * @max_efuse_value: maximum valid trimming data
- * @first_point_trim: temp value of the first point trimming
- * @second_point_trim: temp value of the second point trimming
  * @default_temp_offset: default temperature offset in case of no trimming
  * @cal_type: calibration type for temperature
- * @freq_clip_table: Table representing frequency reduction percentage.
- * @freq_tab_count: Count of the above table as frequency reduction may
- *      applicable to only some of the trigger levels.
  *
  * This structure is required for configuration of exynos_tmu driver.
  */
 struct exynos_tmu_platform_data {
-        u8 threshold;
-        u8 threshold_falling;
-        u8 trigger_levels[MAX_TRIP_COUNT];
-        enum trigger_type trigger_type[MAX_TRIP_COUNT];
-        bool trigger_enable[MAX_TRIP_COUNT];
-        u8 max_trigger_level;
-        u8 non_hw_trigger_levels;
         u8 gain;
         u8 reference_voltage;
         u8 noise_cancel_mode;
@@ -115,30 +67,9 @@ struct exynos_tmu_platform_data {
         u8 second_point_trim;
         u8 default_temp_offset;
 
-        enum calibration_type cal_type;
         enum soc_type type;
-        struct freq_clip_table freq_tab[4];
-        unsigned int freq_tab_count;
-};
-
-/**
- * struct exynos_tmu_init_data
- * @tmu_count: number of TMU instances.
- * @tmu_data: platform data of all TMU instances.
- * This structure is required to store data for multi-instance exynos tmu
- * driver.
- */
-struct exynos_tmu_init_data {
-        int tmu_count;
-        struct exynos_tmu_platform_data tmu_data[];
+        u32 cal_type;
+        u32 cal_mode;
 };
 
-extern struct exynos_tmu_init_data const exynos3250_default_tmu_data;
-extern struct exynos_tmu_init_data const exynos4210_default_tmu_data;
-extern struct exynos_tmu_init_data const exynos4412_default_tmu_data;
-extern struct exynos_tmu_init_data const exynos5250_default_tmu_data;
-extern struct exynos_tmu_init_data const exynos5260_default_tmu_data;
-extern struct exynos_tmu_init_data const exynos5420_default_tmu_data;
-extern struct exynos_tmu_init_data const exynos5440_default_tmu_data;
-
 #endif /* _EXYNOS_TMU_H */
diff --git a/drivers/thermal/samsung/exynos_tmu_data.c b/drivers/thermal/samsung/exynos_tmu_data.c
deleted file mode 100644
index b23910069f68..000000000000
--- a/drivers/thermal/samsung/exynos_tmu_data.c
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * exynos_tmu_data.c - Samsung EXYNOS tmu data file
- *
- *  Copyright (C) 2013 Samsung Electronics
- *  Amit Daniel Kachhap <amit.daniel@samsung.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.
- *
- * 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 "exynos_thermal_common.h"
-#include "exynos_tmu.h"
-
-struct exynos_tmu_init_data const exynos4210_default_tmu_data = {
-        .tmu_data = {
-                {
-                .threshold = 80,
-                .trigger_levels[0] = 5,
-                .trigger_levels[1] = 20,
-                .trigger_levels[2] = 30,
-                .trigger_enable[0] = true,
-                .trigger_enable[1] = true,
-                .trigger_enable[2] = true,
-                .trigger_enable[3] = false,
-                .trigger_type[0] = THROTTLE_ACTIVE,
-                .trigger_type[1] = THROTTLE_ACTIVE,
-                .trigger_type[2] = SW_TRIP,
-                .max_trigger_level = 4,
-                .non_hw_trigger_levels = 3,
-                .gain = 15,
-                .reference_voltage = 7,
-                .cal_type = TYPE_ONE_POINT_TRIMMING,
-                .min_efuse_value = 40,
-                .max_efuse_value = 100,
-                .first_point_trim = 25,
-                .second_point_trim = 85,
-                .default_temp_offset = 50,
-                .freq_tab[0] = {
-                        .freq_clip_max = 800 * 1000,
-                        .temp_level = 85,
-                        },
-                .freq_tab[1] = {
-                        .freq_clip_max = 200 * 1000,
-                        .temp_level = 100,
-                },
-                .freq_tab_count = 2,
-                .type = SOC_ARCH_EXYNOS4210,
-                },
-        },
-        .tmu_count = 1,
-};
-
-#define EXYNOS3250_TMU_DATA \
-        .threshold_falling = 10, \
-        .trigger_levels[0] = 70, \
-        .trigger_levels[1] = 95, \
-        .trigger_levels[2] = 110, \
-        .trigger_levels[3] = 120, \
-        .trigger_enable[0] = true, \
-        .trigger_enable[1] = true, \
-        .trigger_enable[2] = true, \
-        .trigger_enable[3] = false, \
-        .trigger_type[0] = THROTTLE_ACTIVE, \
-        .trigger_type[1] = THROTTLE_ACTIVE, \
-        .trigger_type[2] = SW_TRIP, \
-        .trigger_type[3] = HW_TRIP, \
-        .max_trigger_level = 4, \
-        .non_hw_trigger_levels = 3, \
-        .gain = 8, \
-        .reference_voltage = 16, \
-        .noise_cancel_mode = 4, \
-        .cal_type = TYPE_TWO_POINT_TRIMMING, \
-        .efuse_value = 55, \
-        .min_efuse_value = 40, \
-        .max_efuse_value = 100, \
-        .first_point_trim = 25, \
-        .second_point_trim = 85, \
-        .default_temp_offset = 50, \
-        .freq_tab[0] = { \
-                .freq_clip_max = 800 * 1000, \
-                .temp_level = 70, \
-        }, \
-        .freq_tab[1] = { \
-                .freq_clip_max = 400 * 1000, \
-                .temp_level = 95, \
-        }, \
-        .freq_tab_count = 2
-
-struct exynos_tmu_init_data const exynos3250_default_tmu_data = {
-        .tmu_data = {
-                {
-                        EXYNOS3250_TMU_DATA,
-                        .type = SOC_ARCH_EXYNOS3250,
-                },
-        },
-        .tmu_count = 1,
-};
-
-#define EXYNOS4412_TMU_DATA \
-        .threshold_falling = 10, \
-        .trigger_levels[0] = 70, \
-        .trigger_levels[1] = 95, \
-        .trigger_levels[2] = 110, \
-        .trigger_levels[3] = 120, \
-        .trigger_enable[0] = true, \
-        .trigger_enable[1] = true, \
-        .trigger_enable[2] = true, \
-        .trigger_enable[3] = false, \
-        .trigger_type[0] = THROTTLE_ACTIVE, \
-        .trigger_type[1] = THROTTLE_ACTIVE, \
-        .trigger_type[2] = SW_TRIP, \
-        .trigger_type[3] = HW_TRIP, \
-        .max_trigger_level = 4, \
-        .non_hw_trigger_levels = 3, \
-        .gain = 8, \
-        .reference_voltage = 16, \
-        .noise_cancel_mode = 4, \
-        .cal_type = TYPE_ONE_POINT_TRIMMING, \
-        .efuse_value = 55, \
-        .min_efuse_value = 40, \
-        .max_efuse_value = 100, \
-        .first_point_trim = 25, \
-        .second_point_trim = 85, \
-        .default_temp_offset = 50, \
-        .freq_tab[0] = { \
-                .freq_clip_max = 1400 * 1000, \
-                .temp_level = 70, \
-        }, \
-        .freq_tab[1] = { \
-                .freq_clip_max = 400 * 1000, \
-                .temp_level = 95, \
-        }, \
-        .freq_tab_count = 2
-
-struct exynos_tmu_init_data const exynos4412_default_tmu_data = {
-        .tmu_data = {
-                {
-                        EXYNOS4412_TMU_DATA,
-                        .type = SOC_ARCH_EXYNOS4412,
-                },
-        },
-        .tmu_count = 1,
-};
-
-struct exynos_tmu_init_data const exynos5250_default_tmu_data = {
-        .tmu_data = {
-                {
-                        EXYNOS4412_TMU_DATA,
-                        .type = SOC_ARCH_EXYNOS5250,
-                },
-        },
-        .tmu_count = 1,
-};
-
-#define __EXYNOS5260_TMU_DATA   \
-        .threshold_falling = 10, \
-        .trigger_levels[0] = 85, \
-        .trigger_levels[1] = 103, \
-        .trigger_levels[2] = 110, \
-        .trigger_levels[3] = 120, \
-        .trigger_enable[0] = true, \
-        .trigger_enable[1] = true, \
-        .trigger_enable[2] = true, \
-        .trigger_enable[3] = false, \
-        .trigger_type[0] = THROTTLE_ACTIVE, \
-        .trigger_type[1] = THROTTLE_ACTIVE, \
-        .trigger_type[2] = SW_TRIP, \
-        .trigger_type[3] = HW_TRIP, \
-        .max_trigger_level = 4, \
-        .non_hw_trigger_levels = 3, \
-        .gain = 8, \
-        .reference_voltage = 16, \
-        .noise_cancel_mode = 4, \
-        .cal_type = TYPE_ONE_POINT_TRIMMING, \
-        .efuse_value = 55, \
-        .min_efuse_value = 40, \
-        .max_efuse_value = 100, \
-        .first_point_trim = 25, \
-        .second_point_trim = 85, \
-        .default_temp_offset = 50, \
-        .freq_tab[0] = { \
-                .freq_clip_max = 800 * 1000, \
-                .temp_level = 85, \
-        }, \
-        .freq_tab[1] = { \
-                .freq_clip_max = 200 * 1000, \
-                .temp_level = 103, \
-        }, \
-        .freq_tab_count = 2, \
-
-#define EXYNOS5260_TMU_DATA \
-        __EXYNOS5260_TMU_DATA \
-        .type = SOC_ARCH_EXYNOS5260
-
-struct exynos_tmu_init_data const exynos5260_default_tmu_data = {
-        .tmu_data = {
-                { EXYNOS5260_TMU_DATA },
-                { EXYNOS5260_TMU_DATA },
-                { EXYNOS5260_TMU_DATA },
-                { EXYNOS5260_TMU_DATA },
-                { EXYNOS5260_TMU_DATA },
-        },
-        .tmu_count = 5,
-};
-
-#define EXYNOS5420_TMU_DATA \
-        __EXYNOS5260_TMU_DATA \
-        .type = SOC_ARCH_EXYNOS5420
-
-#define EXYNOS5420_TMU_DATA_SHARED \
-        __EXYNOS5260_TMU_DATA \
-        .type = SOC_ARCH_EXYNOS5420_TRIMINFO
-
-struct exynos_tmu_init_data const exynos5420_default_tmu_data = {
-        .tmu_data = {
-                { EXYNOS5420_TMU_DATA },
-                { EXYNOS5420_TMU_DATA },
-                { EXYNOS5420_TMU_DATA_SHARED },
-                { EXYNOS5420_TMU_DATA_SHARED },
-                { EXYNOS5420_TMU_DATA_SHARED },
-        },
-        .tmu_count = 5,
-};
-
-#define EXYNOS5440_TMU_DATA \
-        .trigger_levels[0] = 100, \
-        .trigger_levels[4] = 105, \
-        .trigger_enable[0] = 1, \
-        .trigger_type[0] = SW_TRIP, \
-        .trigger_type[4] = HW_TRIP, \
-        .max_trigger_level = 5, \
-        .non_hw_trigger_levels = 1, \
-        .gain = 5, \
-        .reference_voltage = 16, \
-        .noise_cancel_mode = 4, \
-        .cal_type = TYPE_ONE_POINT_TRIMMING, \
-        .efuse_value = 0x5b2d, \
-        .min_efuse_value = 16, \
-        .max_efuse_value = 76, \
-        .first_point_trim = 25, \
-        .second_point_trim = 70, \
-        .default_temp_offset = 25, \
-        .type = SOC_ARCH_EXYNOS5440
-
-struct exynos_tmu_init_data const exynos5440_default_tmu_data = {
-        .tmu_data = {
-                { EXYNOS5440_TMU_DATA } ,
-                { EXYNOS5440_TMU_DATA } ,
-                { EXYNOS5440_TMU_DATA } ,
-        },
-        .tmu_count = 3,
-};
diff --git a/drivers/thermal/step_wise.c b/drivers/thermal/step_wise.c
index fdd1f523a1ed..5a0f12d08e8b 100644
--- a/drivers/thermal/step_wise.c
+++ b/drivers/thermal/step_wise.c
@@ -45,7 +45,7 @@
  *    c. if the trend is THERMAL_TREND_RAISE_FULL, do nothing
  *    d. if the trend is THERMAL_TREND_DROP_FULL, use lower limit,
  *       if the cooling state already equals lower limit,
- *       deactive the thermal instance
+ *       deactivate the thermal instance
  */
 static unsigned long get_target_state(struct thermal_instance *instance,
                                 enum thermal_trend trend, bool throttle)
@@ -169,7 +169,7 @@ static void thermal_zone_trip_update(struct thermal_zone_device *tz, int trip)
 }
 
 /**
- * step_wise_throttle - throttles devices asscciated with the given zone
+ * step_wise_throttle - throttles devices associated with the given zone
  * @tz - thermal_zone_device
  * @trip - the trip point
  * @trip_type - type of the trip point
diff --git a/drivers/thermal/ti-soc-thermal/ti-bandgap.c b/drivers/thermal/ti-soc-thermal/ti-bandgap.c
index 634b6ce0e63a..62a5d449c388 100644
--- a/drivers/thermal/ti-soc-thermal/ti-bandgap.c
+++ b/drivers/thermal/ti-soc-thermal/ti-bandgap.c
@@ -1402,7 +1402,7 @@ int ti_bandgap_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int ti_bandgap_save_ctxt(struct ti_bandgap *bgp)
 {
         int i;
diff --git a/drivers/thermal/ti-soc-thermal/ti-thermal-common.c b/drivers/thermal/ti-soc-thermal/ti-thermal-common.c
index 3fb054a10f6a..a38c1756442a 100644
--- a/drivers/thermal/ti-soc-thermal/ti-thermal-common.c
+++ b/drivers/thermal/ti-soc-thermal/ti-thermal-common.c
@@ -429,7 +429,7 @@ int ti_thermal_unregister_cpu_cooling(struct ti_bandgap *bgp, int id)
 
         data = ti_bandgap_get_sensor_data(bgp, id);
 
-        if (data && data->cool_dev)
+        if (data)
                 cpufreq_cooling_unregister(data->cool_dev);
 
         return 0;
diff --git a/drivers/tty/serial/Kconfig b/drivers/tty/serial/Kconfig
index 5d916c7a216b..d2501f01cd03 100644
--- a/drivers/tty/serial/Kconfig
+++ b/drivers/tty/serial/Kconfig
@@ -489,7 +489,7 @@ config SERIAL_MFD_HSU
         select SERIAL_CORE
 
 config SERIAL_MFD_HSU_CONSOLE
-        boolean "Medfile HSU serial console support"
+        bool "Medfile HSU serial console support"
         depends on SERIAL_MFD_HSU=y
         select SERIAL_CORE_CONSOLE
 
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 96539038c03a..b454d05be583 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -45,7 +45,7 @@ menuconfig USB_GADGET
 if USB_GADGET
 
 config USB_GADGET_DEBUG
-        boolean "Debugging messages (DEVELOPMENT)"
+        bool "Debugging messages (DEVELOPMENT)"
         depends on DEBUG_KERNEL
         help
            Many controller and gadget drivers will print some debugging
@@ -73,7 +73,7 @@ config USB_GADGET_VERBOSE
            production build.
 
 config USB_GADGET_DEBUG_FILES
-        boolean "Debugging information files (DEVELOPMENT)"
+        bool "Debugging information files (DEVELOPMENT)"
         depends on PROC_FS
         help
            Some of the drivers in the "gadget" framework can expose
@@ -84,7 +84,7 @@ config USB_GADGET_DEBUG_FILES
            here.  If in doubt, or to conserve kernel memory, say "N".
 
 config USB_GADGET_DEBUG_FS
-        boolean "Debugging information files in debugfs (DEVELOPMENT)"
+        bool "Debugging information files in debugfs (DEVELOPMENT)"
         depends on DEBUG_FS
         help
            Some of the drivers in the "gadget" framework can expose
@@ -230,7 +230,7 @@ config USB_CONFIGFS
           For more information see Documentation/usb/gadget_configfs.txt.
 
 config USB_CONFIGFS_SERIAL
-        boolean "Generic serial bulk in/out"
+        bool "Generic serial bulk in/out"
         depends on USB_CONFIGFS
         depends on TTY
         select USB_U_SERIAL
@@ -239,7 +239,7 @@ config USB_CONFIGFS_SERIAL
           The function talks to the Linux-USB generic serial driver.
 
 config USB_CONFIGFS_ACM
-        boolean "Abstract Control Model (CDC ACM)"
+        bool "Abstract Control Model (CDC ACM)"
         depends on USB_CONFIGFS
         depends on TTY
         select USB_U_SERIAL
@@ -249,7 +249,7 @@ config USB_CONFIGFS_ACM
           MS-Windows hosts or with the Linux-USB "cdc-acm" driver.
 
 config USB_CONFIGFS_OBEX
-        boolean "Object Exchange Model (CDC OBEX)"
+        bool "Object Exchange Model (CDC OBEX)"
         depends on USB_CONFIGFS
         depends on TTY
         select USB_U_SERIAL
@@ -259,7 +259,7 @@ config USB_CONFIGFS_OBEX
           since the kernel itself doesn't implement the OBEX protocol.
 
 config USB_CONFIGFS_NCM
-        boolean "Network Control Model (CDC NCM)"
+        bool "Network Control Model (CDC NCM)"
         depends on USB_CONFIGFS
         depends on NET
         select USB_U_ETHER
@@ -270,7 +270,7 @@ config USB_CONFIGFS_NCM
           different alignment possibilities.
 
 config USB_CONFIGFS_ECM
-        boolean "Ethernet Control Model (CDC ECM)"
+        bool "Ethernet Control Model (CDC ECM)"
         depends on USB_CONFIGFS
         depends on NET
         select USB_U_ETHER
@@ -282,7 +282,7 @@ config USB_CONFIGFS_ECM
           supported by firmware for smart network devices.
 
 config USB_CONFIGFS_ECM_SUBSET
-        boolean "Ethernet Control Model (CDC ECM) subset"
+        bool "Ethernet Control Model (CDC ECM) subset"
         depends on USB_CONFIGFS
         depends on NET
         select USB_U_ETHER
@@ -323,7 +323,7 @@ config USB_CONFIGFS_EEM
           the host is the same (a usbX device), so the differences are minimal.
 
 config USB_CONFIGFS_PHONET
-        boolean "Phonet protocol"
+        bool "Phonet protocol"
         depends on USB_CONFIGFS
         depends on NET
         depends on PHONET
@@ -333,7 +333,7 @@ config USB_CONFIGFS_PHONET
           The Phonet protocol implementation for USB device.
 
 config USB_CONFIGFS_MASS_STORAGE
-        boolean "Mass storage"
+        bool "Mass storage"
         depends on USB_CONFIGFS
         depends on BLOCK
         select USB_F_MASS_STORAGE
@@ -344,7 +344,7 @@ config USB_CONFIGFS_MASS_STORAGE
           specified as a module parameter or sysfs option.
 
 config USB_CONFIGFS_F_LB_SS
-        boolean "Loopback and sourcesink function (for testing)"
+        bool "Loopback and sourcesink function (for testing)"
         depends on USB_CONFIGFS
         select USB_F_SS_LB
         help
@@ -357,7 +357,7 @@ config USB_CONFIGFS_F_LB_SS
           and its driver through a basic set of functional tests.
 
 config USB_CONFIGFS_F_FS
-        boolean "Function filesystem (FunctionFS)"
+        bool "Function filesystem (FunctionFS)"
         depends on USB_CONFIGFS
         select USB_F_FS
         help
@@ -369,7 +369,7 @@ config USB_CONFIGFS_F_FS
           mass storage) and other are implemented in user space.
 
 config USB_CONFIGFS_F_UAC1
-        boolean "Audio Class 1.0"
+        bool "Audio Class 1.0"
         depends on USB_CONFIGFS
         depends on SND
         select USB_LIBCOMPOSITE
@@ -382,7 +382,7 @@ config USB_CONFIGFS_F_UAC1
           on the device.
 
 config USB_CONFIGFS_F_UAC2
-        boolean "Audio Class 2.0"
+        bool "Audio Class 2.0"
         depends on USB_CONFIGFS
         depends on SND
         select USB_LIBCOMPOSITE
@@ -400,7 +400,7 @@ config USB_CONFIGFS_F_UAC2
           wants as audio data to the USB Host.
 
 config USB_CONFIGFS_F_MIDI
-        boolean "MIDI function"
+        bool "MIDI function"
         depends on USB_CONFIGFS
         depends on SND
         select USB_LIBCOMPOSITE
@@ -414,7 +414,7 @@ config USB_CONFIGFS_F_MIDI
           ALSA's aconnect utility etc.
 
 config USB_CONFIGFS_F_HID
-        boolean "HID function"
+        bool "HID function"
         depends on USB_CONFIGFS
         select USB_F_HID
         help
diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig
index fd48ef3af4eb..113c87e22117 100644
--- a/drivers/usb/gadget/legacy/Kconfig
+++ b/drivers/usb/gadget/legacy/Kconfig
@@ -40,7 +40,7 @@ config USB_ZERO
           dynamically linked module called "g_zero".
 
 config USB_ZERO_HNPTEST
-        boolean "HNP Test Device"
+        bool "HNP Test Device"
         depends on USB_ZERO && USB_OTG
         help
           You can configure this device to enumerate using the device
diff --git a/drivers/usb/gadget/udc/Kconfig b/drivers/usb/gadget/udc/Kconfig
index 366e551aeff0..9a3a6b00391a 100644
--- a/drivers/usb/gadget/udc/Kconfig
+++ b/drivers/usb/gadget/udc/Kconfig
@@ -199,7 +199,7 @@ config USB_S3C2410
           S3C2440 processors.
 
 config USB_S3C2410_DEBUG
-        boolean "S3C2410 udc debug messages"
+        bool "S3C2410 udc debug messages"
         depends on USB_S3C2410
 
 config USB_S3C_HSUDC
@@ -288,7 +288,7 @@ config USB_NET2272
           gadget drivers to also be dynamically linked.
 
 config USB_NET2272_DMA
-        boolean "Support external DMA controller"
+        bool "Support external DMA controller"
         depends on USB_NET2272 && HAS_DMA
         help
           The NET2272 part can optionally support an external DMA
diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
index c6d0c8e745b9..52d3d58252e1 100644
--- a/drivers/usb/phy/Kconfig
+++ b/drivers/usb/phy/Kconfig
@@ -119,7 +119,7 @@ config TAHVO_USB
 
 config TAHVO_USB_HOST_BY_DEFAULT
         depends on TAHVO_USB
-        boolean "Device in USB host mode by default"
+        bool "Device in USB host mode by default"
         help
           Say Y here, if you want the device to enter USB host mode
           by default on bootup.
diff --git a/drivers/vfio/pci/vfio_pci.c b/drivers/vfio/pci/vfio_pci.c
index 7cc0122a18ce..f8a186381ae8 100644
--- a/drivers/vfio/pci/vfio_pci.c
+++ b/drivers/vfio/pci/vfio_pci.c
@@ -239,9 +239,12 @@ static int vfio_pci_get_irq_count(struct vfio_pci_device *vdev, int irq_type)
 
                         return (flags & PCI_MSIX_FLAGS_QSIZE) + 1;
                 }
-        } else if (irq_type == VFIO_PCI_ERR_IRQ_INDEX)
+        } else if (irq_type == VFIO_PCI_ERR_IRQ_INDEX) {
                 if (pci_is_pcie(vdev->pdev))
                         return 1;
+        } else if (irq_type == VFIO_PCI_REQ_IRQ_INDEX) {
+                return 1;
+        }
 
         return 0;
 }
@@ -464,6 +467,7 @@ static long vfio_pci_ioctl(void *device_data,
 
                 switch (info.index) {
                 case VFIO_PCI_INTX_IRQ_INDEX ... VFIO_PCI_MSIX_IRQ_INDEX:
+                case VFIO_PCI_REQ_IRQ_INDEX:
                         break;
                 case VFIO_PCI_ERR_IRQ_INDEX:
                         if (pci_is_pcie(vdev->pdev))
@@ -828,6 +832,20 @@ static int vfio_pci_mmap(void *device_data, struct vm_area_struct *vma)
                                req_len, vma->vm_page_prot);
 }
 
+static void vfio_pci_request(void *device_data, unsigned int count)
+{
+        struct vfio_pci_device *vdev = device_data;
+
+        mutex_lock(&vdev->igate);
+
+        if (vdev->req_trigger) {
+                dev_dbg(&vdev->pdev->dev, "Requesting device from user\n");
+                eventfd_signal(vdev->req_trigger, 1);
+        }
+
+        mutex_unlock(&vdev->igate);
+}
+
 static const struct vfio_device_ops vfio_pci_ops = {
         .name           = "vfio-pci",
         .open           = vfio_pci_open,
@@ -836,6 +854,7 @@ static const struct vfio_device_ops vfio_pci_ops = {
         .read           = vfio_pci_read,
         .write          = vfio_pci_write,
         .mmap           = vfio_pci_mmap,
+        .request        = vfio_pci_request,
 };
 
 static int vfio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
diff --git a/drivers/vfio/pci/vfio_pci_intrs.c b/drivers/vfio/pci/vfio_pci_intrs.c
index e8d695b3f54e..f88bfdf5b6a0 100644
--- a/drivers/vfio/pci/vfio_pci_intrs.c
+++ b/drivers/vfio/pci/vfio_pci_intrs.c
@@ -763,46 +763,70 @@ static int vfio_pci_set_msi_trigger(struct vfio_pci_device *vdev,
         return 0;
 }
 
-static int vfio_pci_set_err_trigger(struct vfio_pci_device *vdev,
-                                    unsigned index, unsigned start,
-                                    unsigned count, uint32_t flags, void *data)
+static int vfio_pci_set_ctx_trigger_single(struct eventfd_ctx **ctx,
+                                           uint32_t flags, void *data)
 {
         int32_t fd = *(int32_t *)data;
 
-        if ((index != VFIO_PCI_ERR_IRQ_INDEX) ||
-            !(flags & VFIO_IRQ_SET_DATA_TYPE_MASK))
+        if (!(flags & VFIO_IRQ_SET_DATA_TYPE_MASK))
                 return -EINVAL;
 
         /* DATA_NONE/DATA_BOOL enables loopback testing */
         if (flags & VFIO_IRQ_SET_DATA_NONE) {
-                if (vdev->err_trigger)
-                        eventfd_signal(vdev->err_trigger, 1);
+                if (*ctx)
+                        eventfd_signal(*ctx, 1);
                 return 0;
         } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
                 uint8_t trigger = *(uint8_t *)data;
-                if (trigger && vdev->err_trigger)
-                        eventfd_signal(vdev->err_trigger, 1);
+                if (trigger && *ctx)
+                        eventfd_signal(*ctx, 1);
                 return 0;
         }
 
         /* Handle SET_DATA_EVENTFD */
         if (fd == -1) {
-                if (vdev->err_trigger)
-                        eventfd_ctx_put(vdev->err_trigger);
-                vdev->err_trigger = NULL;
+                if (*ctx)
+                        eventfd_ctx_put(*ctx);
+                *ctx = NULL;
                 return 0;
         } else if (fd >= 0) {
                 struct eventfd_ctx *efdctx;
                 efdctx = eventfd_ctx_fdget(fd);
                 if (IS_ERR(efdctx))
                         return PTR_ERR(efdctx);
-                if (vdev->err_trigger)
-                        eventfd_ctx_put(vdev->err_trigger);
-                vdev->err_trigger = efdctx;
+                if (*ctx)
+                        eventfd_ctx_put(*ctx);
+                *ctx = efdctx;
                 return 0;
         } else
                 return -EINVAL;
 }
+
+static int vfio_pci_set_err_trigger(struct vfio_pci_device *vdev,
+                                    unsigned index, unsigned start,
+                                    unsigned count, uint32_t flags, void *data)
+{
+        if (index != VFIO_PCI_ERR_IRQ_INDEX)
+                return -EINVAL;
+
+        /*
+         * We should sanitize start & count, but that wasn't caught
+         * originally, so this IRQ index must forever ignore them :-(
+         */
+
+        return vfio_pci_set_ctx_trigger_single(&vdev->err_trigger, flags, data);
+}
+
+static int vfio_pci_set_req_trigger(struct vfio_pci_device *vdev,
+                                    unsigned index, unsigned start,
+                                    unsigned count, uint32_t flags, void *data)
+{
+        if (index != VFIO_PCI_REQ_IRQ_INDEX || start != 0 || count != 1)
+                return -EINVAL;
+
+        return vfio_pci_set_ctx_trigger_single(&vdev->req_trigger, flags, data);
+}
+
 int vfio_pci_set_irqs_ioctl(struct vfio_pci_device *vdev, uint32_t flags,
                             unsigned index, unsigned start, unsigned count,
                             void *data)
@@ -844,6 +868,12 @@ int vfio_pci_set_irqs_ioctl(struct vfio_pci_device *vdev, uint32_t flags,
                                 func = vfio_pci_set_err_trigger;
                         break;
                 }
+        case VFIO_PCI_REQ_IRQ_INDEX:
+                switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
+                case VFIO_IRQ_SET_ACTION_TRIGGER:
+                        func = vfio_pci_set_req_trigger;
+                        break;
+                }
         }
 
         if (!func)
diff --git a/drivers/vfio/pci/vfio_pci_private.h b/drivers/vfio/pci/vfio_pci_private.h
index 671c17a6e6d0..c9f9b323f152 100644
--- a/drivers/vfio/pci/vfio_pci_private.h
+++ b/drivers/vfio/pci/vfio_pci_private.h
@@ -58,6 +58,7 @@ struct vfio_pci_device {
         struct pci_saved_state  *pci_saved_state;
         int                     refcnt;
         struct eventfd_ctx      *err_trigger;
+        struct eventfd_ctx      *req_trigger;
 };
 
 #define is_intx(vdev) (vdev->irq_type == VFIO_PCI_INTX_IRQ_INDEX)
diff --git a/drivers/vfio/vfio.c b/drivers/vfio/vfio.c
index f018d8d0f975..4cde85501444 100644
--- a/drivers/vfio/vfio.c
+++ b/drivers/vfio/vfio.c
@@ -63,6 +63,11 @@ struct vfio_container {
         void                            *iommu_data;
 };
 
+struct vfio_unbound_dev {
+        struct device                   *dev;
+        struct list_head                unbound_next;
+};
+
 struct vfio_group {
         struct kref                     kref;
         int                             minor;
@@ -75,6 +80,8 @@ struct vfio_group {
         struct notifier_block           nb;
         struct list_head                vfio_next;
         struct list_head                container_next;
+        struct list_head                unbound_list;
+        struct mutex                    unbound_lock;
         atomic_t                        opened;
 };
 
@@ -204,6 +211,8 @@ static struct vfio_group *vfio_create_group(struct iommu_group *iommu_group)
         kref_init(&group->kref);
         INIT_LIST_HEAD(&group->device_list);
         mutex_init(&group->device_lock);
+        INIT_LIST_HEAD(&group->unbound_list);
+        mutex_init(&group->unbound_lock);
         atomic_set(&group->container_users, 0);
         atomic_set(&group->opened, 0);
         group->iommu_group = iommu_group;
@@ -264,13 +273,22 @@ static struct vfio_group *vfio_create_group(struct iommu_group *iommu_group)
 static void vfio_group_release(struct kref *kref)
 {
         struct vfio_group *group = container_of(kref, struct vfio_group, kref);
+        struct vfio_unbound_dev *unbound, *tmp;
+        struct iommu_group *iommu_group = group->iommu_group;
 
         WARN_ON(!list_empty(&group->device_list));
 
+        list_for_each_entry_safe(unbound, tmp,
+                                 &group->unbound_list, unbound_next) {
+                list_del(&unbound->unbound_next);
+                kfree(unbound);
+        }
+
         device_destroy(vfio.class, MKDEV(MAJOR(vfio.group_devt), group->minor));
         list_del(&group->vfio_next);
         vfio_free_group_minor(group->minor);
         vfio_group_unlock_and_free(group);
+        iommu_group_put(iommu_group);
 }
 
 static void vfio_group_put(struct vfio_group *group)
@@ -440,17 +458,36 @@ static bool vfio_whitelisted_driver(struct device_driver *drv)
 }
 
 /*
- * A vfio group is viable for use by userspace if all devices are either
- * driver-less or bound to a vfio or whitelisted driver.  We test the
- * latter by the existence of a struct vfio_device matching the dev.
+ * A vfio group is viable for use by userspace if all devices are in
+ * one of the following states:
+ *  - driver-less
+ *  - bound to a vfio driver
+ *  - bound to a whitelisted driver
+ *
+ * We use two methods to determine whether a device is bound to a vfio
+ * driver.  The first is to test whether the device exists in the vfio
+ * group.  The second is to test if the device exists on the group
+ * unbound_list, indicating it's in the middle of transitioning from
+ * a vfio driver to driver-less.
  */
 static int vfio_dev_viable(struct device *dev, void *data)
 {
         struct vfio_group *group = data;
         struct vfio_device *device;
         struct device_driver *drv = ACCESS_ONCE(dev->driver);
+        struct vfio_unbound_dev *unbound;
+        int ret = -EINVAL;
 
-        if (!drv || vfio_whitelisted_driver(drv))
+        mutex_lock(&group->unbound_lock);
+        list_for_each_entry(unbound, &group->unbound_list, unbound_next) {
+                if (dev == unbound->dev) {
+                        ret = 0;
+                        break;
+                }
+        }
+        mutex_unlock(&group->unbound_lock);
+
+        if (!ret || !drv || vfio_whitelisted_driver(drv))
                 return 0;
 
         device = vfio_group_get_device(group, dev);
@@ -459,7 +496,7 @@ static int vfio_dev_viable(struct device *dev, void *data)
                 return 0;
         }
 
-        return -EINVAL;
+        return ret;
 }
 
 /**
@@ -501,6 +538,7 @@ static int vfio_iommu_group_notifier(struct notifier_block *nb,
 {
         struct vfio_group *group = container_of(nb, struct vfio_group, nb);
         struct device *dev = data;
+        struct vfio_unbound_dev *unbound;
 
         /*
          * Need to go through a group_lock lookup to get a reference or we
@@ -550,6 +588,17 @@ static int vfio_iommu_group_notifier(struct notifier_block *nb,
                  * stop the system to maintain isolation.  At a minimum, we'd
                  * want a toggle to disable driver auto probe for this device.
                  */
+
+                mutex_lock(&group->unbound_lock);
+                list_for_each_entry(unbound,
+                                    &group->unbound_list, unbound_next) {
+                        if (dev == unbound->dev) {
+                                list_del(&unbound->unbound_next);
+                                kfree(unbound);
+                                break;
+                        }
+                }
+                mutex_unlock(&group->unbound_lock);
                 break;
         }
 
@@ -578,6 +627,12 @@ int vfio_add_group_dev(struct device *dev,
                         iommu_group_put(iommu_group);
                         return PTR_ERR(group);
                 }
+        } else {
+                /*
+                 * A found vfio_group already holds a reference to the
+                 * iommu_group.  A created vfio_group keeps the reference.
+                 */
+                iommu_group_put(iommu_group);
         }
 
         device = vfio_group_get_device(group, dev);
@@ -586,21 +641,19 @@ int vfio_add_group_dev(struct device *dev,
                      dev_name(dev), iommu_group_id(iommu_group));
                 vfio_device_put(device);
                 vfio_group_put(group);
-                iommu_group_put(iommu_group);
                 return -EBUSY;
         }
 
         device = vfio_group_create_device(group, dev, ops, device_data);
         if (IS_ERR(device)) {
                 vfio_group_put(group);
-                iommu_group_put(iommu_group);
                 return PTR_ERR(device);
         }
 
         /*
-         * Added device holds reference to iommu_group and vfio_device
-         * (which in turn holds reference to vfio_group).  Drop extra
-         * group reference used while acquiring device.
+         * Drop all but the vfio_device reference.  The vfio_device holds
+         * a reference to the vfio_group, which holds a reference to the
+         * iommu_group.
          */
         vfio_group_put(group);
 
@@ -655,8 +708,9 @@ void *vfio_del_group_dev(struct device *dev)
 {
         struct vfio_device *device = dev_get_drvdata(dev);
         struct vfio_group *group = device->group;
-        struct iommu_group *iommu_group = group->iommu_group;
         void *device_data = device->device_data;
+        struct vfio_unbound_dev *unbound;
+        unsigned int i = 0;
 
         /*
          * The group exists so long as we have a device reference.  Get
@@ -664,14 +718,49 @@ void *vfio_del_group_dev(struct device *dev)
          */
         vfio_group_get(group);
 
+        /*
+         * When the device is removed from the group, the group suddenly
+         * becomes non-viable; the device has a driver (until the unbind
+         * completes), but it's not present in the group.  This is bad news
+         * for any external users that need to re-acquire a group reference
+         * in order to match and release their existing reference.  To
+         * solve this, we track such devices on the unbound_list to bridge
+         * the gap until they're fully unbound.
+         */
+        unbound = kzalloc(sizeof(*unbound), GFP_KERNEL);
+        if (unbound) {
+                unbound->dev = dev;
+                mutex_lock(&group->unbound_lock);
+                list_add(&unbound->unbound_next, &group->unbound_list);
+                mutex_unlock(&group->unbound_lock);
+        }
+        WARN_ON(!unbound);
+
         vfio_device_put(device);
 
-        /* TODO send a signal to encourage this to be released */
-        wait_event(vfio.release_q, !vfio_dev_present(group, dev));
+        /*
+         * If the device is still present in the group after the above
+         * 'put', then it is in use and we need to request it from the
+         * bus driver.  The driver may in turn need to request the
+         * device from the user.  We send the request on an arbitrary
+         * interval with counter to allow the driver to take escalating
+         * measures to release the device if it has the ability to do so.
+         */
+        do {
+                device = vfio_group_get_device(group, dev);
+                if (!device)
+                        break;
 
-        vfio_group_put(group);
+                if (device->ops->request)
+                        device->ops->request(device_data, i++);
 
-        iommu_group_put(iommu_group);
+                vfio_device_put(device);
+
+        } while (wait_event_interruptible_timeout(vfio.release_q,
+                                                  !vfio_dev_present(group, dev),
+                                                  HZ * 10) <= 0);
+
+        vfio_group_put(group);
 
         return device_data;
 }
diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
index 4a9d666f1e91..57d8c37a002b 100644
--- a/drivers/vfio/vfio_iommu_type1.c
+++ b/drivers/vfio/vfio_iommu_type1.c
@@ -66,6 +66,7 @@ struct vfio_domain {
         struct list_head        next;
         struct list_head        group_list;
         int                     prot;           /* IOMMU_CACHE */
+        bool                    fgsp;           /* Fine-grained super pages */
 };
 
 struct vfio_dma {
@@ -264,6 +265,7 @@ static long vfio_pin_pages(unsigned long vaddr, long npage,
         unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
         bool lock_cap = capable(CAP_IPC_LOCK);
         long ret, i;
+        bool rsvd;
 
         if (!current->mm)
                 return -ENODEV;
@@ -272,10 +274,9 @@ static long vfio_pin_pages(unsigned long vaddr, long npage,
         if (ret)
                 return ret;
 
-        if (is_invalid_reserved_pfn(*pfn_base))
-                return 1;
+        rsvd = is_invalid_reserved_pfn(*pfn_base);
 
-        if (!lock_cap && current->mm->locked_vm + 1 > limit) {
+        if (!rsvd && !lock_cap && current->mm->locked_vm + 1 > limit) {
                 put_pfn(*pfn_base, prot);
                 pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n", __func__,
                         limit << PAGE_SHIFT);
@@ -283,7 +284,8 @@ static long vfio_pin_pages(unsigned long vaddr, long npage,
         }
 
         if (unlikely(disable_hugepages)) {
-                vfio_lock_acct(1);
+                if (!rsvd)
+                        vfio_lock_acct(1);
                 return 1;
         }
 
@@ -295,12 +297,14 @@ static long vfio_pin_pages(unsigned long vaddr, long npage,
                 if (ret)
                         break;
 
-                if (pfn != *pfn_base + i || is_invalid_reserved_pfn(pfn)) {
+                if (pfn != *pfn_base + i ||
+                    rsvd != is_invalid_reserved_pfn(pfn)) {
                         put_pfn(pfn, prot);
                         break;
                 }
 
-                if (!lock_cap && current->mm->locked_vm + i + 1 > limit) {
+                if (!rsvd && !lock_cap &&
+                    current->mm->locked_vm + i + 1 > limit) {
                         put_pfn(pfn, prot);
                         pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n",
                                 __func__, limit << PAGE_SHIFT);
@@ -308,7 +312,8 @@ static long vfio_pin_pages(unsigned long vaddr, long npage,
                 }
         }
 
-        vfio_lock_acct(i);
+        if (!rsvd)
+                vfio_lock_acct(i);
 
         return i;
 }
@@ -346,12 +351,14 @@ static void vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma)
         domain = d = list_first_entry(&iommu->domain_list,
                                       struct vfio_domain, next);
 
-        list_for_each_entry_continue(d, &iommu->domain_list, next)
+        list_for_each_entry_continue(d, &iommu->domain_list, next) {
                 iommu_unmap(d->domain, dma->iova, dma->size);
+                cond_resched();
+        }
 
         while (iova < end) {
-                size_t unmapped;
-                phys_addr_t phys;
+                size_t unmapped, len;
+                phys_addr_t phys, next;
 
                 phys = iommu_iova_to_phys(domain->domain, iova);
                 if (WARN_ON(!phys)) {
@@ -359,7 +366,19 @@ static void vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma)
                         continue;
                 }
 
-                unmapped = iommu_unmap(domain->domain, iova, PAGE_SIZE);
+                /*
+                 * To optimize for fewer iommu_unmap() calls, each of which
+                 * may require hardware cache flushing, try to find the
+                 * largest contiguous physical memory chunk to unmap.
+                 */
+                for (len = PAGE_SIZE;
+                     !domain->fgsp && iova + len < end; len += PAGE_SIZE) {
+                        next = iommu_iova_to_phys(domain->domain, iova + len);
+                        if (next != phys + len)
+                                break;
+                }
+
+                unmapped = iommu_unmap(domain->domain, iova, len);
                 if (WARN_ON(!unmapped))
                         break;
 
@@ -367,6 +386,8 @@ static void vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma)
                                              unmapped >> PAGE_SHIFT,
                                              dma->prot, false);
                 iova += unmapped;
+
+                cond_resched();
         }
 
         vfio_lock_acct(-unlocked);
@@ -511,6 +532,8 @@ static int vfio_iommu_map(struct vfio_iommu *iommu, dma_addr_t iova,
                             map_try_harder(d, iova, pfn, npage, prot))
                                 goto unwind;
                 }
+
+                cond_resched();
         }
 
         return 0;
@@ -665,6 +688,39 @@ static int vfio_iommu_replay(struct vfio_iommu *iommu,
         return 0;
 }
 
+/*
+ * We change our unmap behavior slightly depending on whether the IOMMU
+ * supports fine-grained superpages.  IOMMUs like AMD-Vi will use a superpage
+ * for practically any contiguous power-of-two mapping we give it.  This means
+ * we don't need to look for contiguous chunks ourselves to make unmapping
+ * more efficient.  On IOMMUs with coarse-grained super pages, like Intel VT-d
+ * with discrete 2M/1G/512G/1T superpages, identifying contiguous chunks
+ * significantly boosts non-hugetlbfs mappings and doesn't seem to hurt when
+ * hugetlbfs is in use.
+ */
+static void vfio_test_domain_fgsp(struct vfio_domain *domain)
+{
+        struct page *pages;
+        int ret, order = get_order(PAGE_SIZE * 2);
+
+        pages = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
+        if (!pages)
+                return;
+
+        ret = iommu_map(domain->domain, 0, page_to_phys(pages), PAGE_SIZE * 2,
+                        IOMMU_READ | IOMMU_WRITE | domain->prot);
+        if (!ret) {
+                size_t unmapped = iommu_unmap(domain->domain, 0, PAGE_SIZE);
+
+                if (unmapped == PAGE_SIZE)
+                        iommu_unmap(domain->domain, PAGE_SIZE, PAGE_SIZE);
+                else
+                        domain->fgsp = true;
+        }
+
+        __free_pages(pages, order);
+}
+
 static int vfio_iommu_type1_attach_group(void *iommu_data,
                                          struct iommu_group *iommu_group)
 {
@@ -758,6 +814,8 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,
                 }
         }
 
+        vfio_test_domain_fgsp(domain);
+
         /* replay mappings on new domains */
         ret = vfio_iommu_replay(iommu, domain);
         if (ret)
diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index 633012cc9a57..18f05bff8826 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -591,11 +591,6 @@ static void handle_rx(struct vhost_net *net)
                          * TODO: support TSO.
                          */
                         iov_iter_advance(&msg.msg_iter, vhost_hlen);
-                } else {
-                        /* It'll come from socket; we'll need to patch
-                         * ->num_buffers over if VIRTIO_NET_F_MRG_RXBUF
-                         */
-                        iov_iter_advance(&fixup, sizeof(hdr));
                 }
                 err = sock->ops->recvmsg(sock, &msg,
                                          sock_len, MSG_DONTWAIT | MSG_TRUNC);
@@ -609,17 +604,25 @@ static void handle_rx(struct vhost_net *net)
                         continue;
                 }
                 /* Supply virtio_net_hdr if VHOST_NET_F_VIRTIO_NET_HDR */
-                if (unlikely(vhost_hlen) &&
-                    copy_to_iter(&hdr, sizeof(hdr), &fixup) != sizeof(hdr)) {
-                        vq_err(vq, "Unable to write vnet_hdr at addr %p\n",
-                               vq->iov->iov_base);
-                        break;
+                if (unlikely(vhost_hlen)) {
+                        if (copy_to_iter(&hdr, sizeof(hdr),
+                                         &fixup) != sizeof(hdr)) {
+                                vq_err(vq, "Unable to write vnet_hdr "
+                                       "at addr %p\n", vq->iov->iov_base);
+                                break;
+                        }
+                } else {
+                        /* Header came from socket; we'll need to patch
+                         * ->num_buffers over if VIRTIO_NET_F_MRG_RXBUF
+                         */
+                        iov_iter_advance(&fixup, sizeof(hdr));
                 }
                 /* TODO: Should check and handle checksum. */
 
                 num_buffers = cpu_to_vhost16(vq, headcount);
                 if (likely(mergeable) &&
-                    copy_to_iter(&num_buffers, 2, &fixup) != 2) {
+                    copy_to_iter(&num_buffers, sizeof num_buffers,
+                                 &fixup) != sizeof num_buffers) {
                         vq_err(vq, "Failed num_buffers write");
                         vhost_discard_vq_desc(vq, headcount);
                         break;
diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
index dc78d87e0fc2..8d4f3f1ff799 100644
--- a/drivers/vhost/scsi.c
+++ b/drivers/vhost/scsi.c
@@ -38,7 +38,6 @@
 #include <linux/miscdevice.h>
 #include <asm/unaligned.h>
 #include <scsi/scsi.h>
-#include <scsi/scsi_tcq.h>
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
@@ -52,13 +51,13 @@
 
 #include "vhost.h"
 
-#define TCM_VHOST_VERSION  "v0.1"
-#define TCM_VHOST_NAMELEN 256
-#define TCM_VHOST_MAX_CDB_SIZE 32
-#define TCM_VHOST_DEFAULT_TAGS 256
-#define TCM_VHOST_PREALLOC_SGLS 2048
-#define TCM_VHOST_PREALLOC_UPAGES 2048
-#define TCM_VHOST_PREALLOC_PROT_SGLS 512
+#define VHOST_SCSI_VERSION  "v0.1"
+#define VHOST_SCSI_NAMELEN 256
+#define VHOST_SCSI_MAX_CDB_SIZE 32
+#define VHOST_SCSI_DEFAULT_TAGS 256
+#define VHOST_SCSI_PREALLOC_SGLS 2048
+#define VHOST_SCSI_PREALLOC_UPAGES 2048
+#define VHOST_SCSI_PREALLOC_PROT_SGLS 512
 
 struct vhost_scsi_inflight {
         /* Wait for the flush operation to finish */
@@ -67,11 +66,13 @@ struct vhost_scsi_inflight {
         struct kref kref;
 };
 
-struct tcm_vhost_cmd {
+struct vhost_scsi_cmd {
         /* Descriptor from vhost_get_vq_desc() for virt_queue segment */
         int tvc_vq_desc;
         /* virtio-scsi initiator task attribute */
         int tvc_task_attr;
+        /* virtio-scsi response incoming iovecs */
+        int tvc_in_iovs;
         /* virtio-scsi initiator data direction */
         enum dma_data_direction tvc_data_direction;
         /* Expected data transfer length from virtio-scsi header */
@@ -81,26 +82,26 @@ struct tcm_vhost_cmd {
         /* The number of scatterlists associated with this cmd */
         u32 tvc_sgl_count;
         u32 tvc_prot_sgl_count;
-        /* Saved unpacked SCSI LUN for tcm_vhost_submission_work() */
+        /* Saved unpacked SCSI LUN for vhost_scsi_submission_work() */
         u32 tvc_lun;
         /* Pointer to the SGL formatted memory from virtio-scsi */
         struct scatterlist *tvc_sgl;
         struct scatterlist *tvc_prot_sgl;
         struct page **tvc_upages;
-        /* Pointer to response */
-        struct virtio_scsi_cmd_resp __user *tvc_resp;
+        /* Pointer to response header iovec */
+        struct iovec *tvc_resp_iov;
         /* Pointer to vhost_scsi for our device */
         struct vhost_scsi *tvc_vhost;
         /* Pointer to vhost_virtqueue for the cmd */
         struct vhost_virtqueue *tvc_vq;
         /* Pointer to vhost nexus memory */
-        struct tcm_vhost_nexus *tvc_nexus;
+        struct vhost_scsi_nexus *tvc_nexus;
         /* The TCM I/O descriptor that is accessed via container_of() */
         struct se_cmd tvc_se_cmd;
-        /* work item used for cmwq dispatch to tcm_vhost_submission_work() */
+        /* work item used for cmwq dispatch to vhost_scsi_submission_work() */
         struct work_struct work;
         /* Copy of the incoming SCSI command descriptor block (CDB) */
-        unsigned char tvc_cdb[TCM_VHOST_MAX_CDB_SIZE];
+        unsigned char tvc_cdb[VHOST_SCSI_MAX_CDB_SIZE];
         /* Sense buffer that will be mapped into outgoing status */
         unsigned char tvc_sense_buf[TRANSPORT_SENSE_BUFFER];
         /* Completed commands list, serviced from vhost worker thread */
@@ -109,53 +110,53 @@ struct tcm_vhost_cmd {
         struct vhost_scsi_inflight *inflight;
 };
 
-struct tcm_vhost_nexus {
+struct vhost_scsi_nexus {
         /* Pointer to TCM session for I_T Nexus */
         struct se_session *tvn_se_sess;
 };
 
-struct tcm_vhost_nacl {
+struct vhost_scsi_nacl {
         /* Binary World Wide unique Port Name for Vhost Initiator port */
         u64 iport_wwpn;
         /* ASCII formatted WWPN for Sas Initiator port */
-        char iport_name[TCM_VHOST_NAMELEN];
-        /* Returned by tcm_vhost_make_nodeacl() */
+        char iport_name[VHOST_SCSI_NAMELEN];
+        /* Returned by vhost_scsi_make_nodeacl() */
         struct se_node_acl se_node_acl;
 };
 
-struct tcm_vhost_tpg {
+struct vhost_scsi_tpg {
         /* Vhost port target portal group tag for TCM */
         u16 tport_tpgt;
         /* Used to track number of TPG Port/Lun Links wrt to explict I_T Nexus shutdown */
         int tv_tpg_port_count;
         /* Used for vhost_scsi device reference to tpg_nexus, protected by tv_tpg_mutex */
         int tv_tpg_vhost_count;
-        /* list for tcm_vhost_list */
+        /* list for vhost_scsi_list */
         struct list_head tv_tpg_list;
         /* Used to protect access for tpg_nexus */
         struct mutex tv_tpg_mutex;
         /* Pointer to the TCM VHost I_T Nexus for this TPG endpoint */
-        struct tcm_vhost_nexus *tpg_nexus;
-        /* Pointer back to tcm_vhost_tport */
-        struct tcm_vhost_tport *tport;
-        /* Returned by tcm_vhost_make_tpg() */
+        struct vhost_scsi_nexus *tpg_nexus;
+        /* Pointer back to vhost_scsi_tport */
+        struct vhost_scsi_tport *tport;
+        /* Returned by vhost_scsi_make_tpg() */
         struct se_portal_group se_tpg;
         /* Pointer back to vhost_scsi, protected by tv_tpg_mutex */
         struct vhost_scsi *vhost_scsi;
 };
 
-struct tcm_vhost_tport {
+struct vhost_scsi_tport {
         /* SCSI protocol the tport is providing */
         u8 tport_proto_id;
         /* Binary World Wide unique Port Name for Vhost Target port */
         u64 tport_wwpn;
         /* ASCII formatted WWPN for Vhost Target port */
-        char tport_name[TCM_VHOST_NAMELEN];
-        /* Returned by tcm_vhost_make_tport() */
+        char tport_name[VHOST_SCSI_NAMELEN];
+        /* Returned by vhost_scsi_make_tport() */
         struct se_wwn tport_wwn;
 };
 
-struct tcm_vhost_evt {
+struct vhost_scsi_evt {
         /* event to be sent to guest */
         struct virtio_scsi_event event;
         /* event list, serviced from vhost worker thread */
@@ -171,7 +172,9 @@ enum {
 /* 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)
+                                               (1ULL << VIRTIO_SCSI_F_T10_PI) |
+                                               (1ULL << VIRTIO_F_ANY_LAYOUT) |
+                                               (1ULL << VIRTIO_F_VERSION_1)
 };
 
 #define VHOST_SCSI_MAX_TARGET   256
@@ -195,7 +198,7 @@ struct vhost_scsi_virtqueue {
 
 struct vhost_scsi {
         /* Protected by vhost_scsi->dev.mutex */
-        struct tcm_vhost_tpg **vs_tpg;
+        struct vhost_scsi_tpg **vs_tpg;
         char vs_vhost_wwpn[TRANSPORT_IQN_LEN];
 
         struct vhost_dev dev;
@@ -212,21 +215,21 @@ struct vhost_scsi {
 };
 
 /* Local pointer to allocated TCM configfs fabric module */
-static struct target_fabric_configfs *tcm_vhost_fabric_configfs;
+static struct target_fabric_configfs *vhost_scsi_fabric_configfs;
 
-static struct workqueue_struct *tcm_vhost_workqueue;
+static struct workqueue_struct *vhost_scsi_workqueue;
 
-/* Global spinlock to protect tcm_vhost TPG list for vhost IOCTL access */
-static DEFINE_MUTEX(tcm_vhost_mutex);
-static LIST_HEAD(tcm_vhost_list);
+/* Global spinlock to protect vhost_scsi TPG list for vhost IOCTL access */
+static DEFINE_MUTEX(vhost_scsi_mutex);
+static LIST_HEAD(vhost_scsi_list);
 
-static int iov_num_pages(struct iovec *iov)
+static int iov_num_pages(void __user *iov_base, size_t iov_len)
 {
-        return (PAGE_ALIGN((unsigned long)iov->iov_base + iov->iov_len) -
-               ((unsigned long)iov->iov_base & PAGE_MASK)) >> PAGE_SHIFT;
+        return (PAGE_ALIGN((unsigned long)iov_base + iov_len) -
+               ((unsigned long)iov_base & PAGE_MASK)) >> PAGE_SHIFT;
 }
 
-static void tcm_vhost_done_inflight(struct kref *kref)
+static void vhost_scsi_done_inflight(struct kref *kref)
 {
         struct vhost_scsi_inflight *inflight;
 
@@ -234,7 +237,7 @@ static void tcm_vhost_done_inflight(struct kref *kref)
         complete(&inflight->comp);
 }
 
-static void tcm_vhost_init_inflight(struct vhost_scsi *vs,
+static void vhost_scsi_init_inflight(struct vhost_scsi *vs,
                                     struct vhost_scsi_inflight *old_inflight[])
 {
         struct vhost_scsi_inflight *new_inflight;
@@ -262,7 +265,7 @@ static void tcm_vhost_init_inflight(struct vhost_scsi *vs,
 }
 
 static struct vhost_scsi_inflight *
-tcm_vhost_get_inflight(struct vhost_virtqueue *vq)
+vhost_scsi_get_inflight(struct vhost_virtqueue *vq)
 {
         struct vhost_scsi_inflight *inflight;
         struct vhost_scsi_virtqueue *svq;
@@ -274,31 +277,31 @@ tcm_vhost_get_inflight(struct vhost_virtqueue *vq)
         return inflight;
 }
 
-static void tcm_vhost_put_inflight(struct vhost_scsi_inflight *inflight)
+static void vhost_scsi_put_inflight(struct vhost_scsi_inflight *inflight)
 {
-        kref_put(&inflight->kref, tcm_vhost_done_inflight);
+        kref_put(&inflight->kref, vhost_scsi_done_inflight);
 }
 
-static int tcm_vhost_check_true(struct se_portal_group *se_tpg)
+static int vhost_scsi_check_true(struct se_portal_group *se_tpg)
 {
         return 1;
 }
 
-static int tcm_vhost_check_false(struct se_portal_group *se_tpg)
+static int vhost_scsi_check_false(struct se_portal_group *se_tpg)
 {
         return 0;
 }
 
-static char *tcm_vhost_get_fabric_name(void)
+static char *vhost_scsi_get_fabric_name(void)
 {
         return "vhost";
 }
 
-static u8 tcm_vhost_get_fabric_proto_ident(struct se_portal_group *se_tpg)
+static u8 vhost_scsi_get_fabric_proto_ident(struct se_portal_group *se_tpg)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
-        struct tcm_vhost_tport *tport = tpg->tport;
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
+        struct vhost_scsi_tport *tport = tpg->tport;
 
         switch (tport->tport_proto_id) {
         case SCSI_PROTOCOL_SAS:
@@ -316,37 +319,37 @@ static u8 tcm_vhost_get_fabric_proto_ident(struct se_portal_group *se_tpg)
         return sas_get_fabric_proto_ident(se_tpg);
 }
 
-static char *tcm_vhost_get_fabric_wwn(struct se_portal_group *se_tpg)
+static char *vhost_scsi_get_fabric_wwn(struct se_portal_group *se_tpg)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
-        struct tcm_vhost_tport *tport = tpg->tport;
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
+        struct vhost_scsi_tport *tport = tpg->tport;
 
         return &tport->tport_name[0];
 }
 
-static u16 tcm_vhost_get_tag(struct se_portal_group *se_tpg)
+static u16 vhost_scsi_get_tpgt(struct se_portal_group *se_tpg)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
         return tpg->tport_tpgt;
 }
 
-static u32 tcm_vhost_get_default_depth(struct se_portal_group *se_tpg)
+static u32 vhost_scsi_get_default_depth(struct se_portal_group *se_tpg)
 {
         return 1;
 }
 
 static u32
-tcm_vhost_get_pr_transport_id(struct se_portal_group *se_tpg,
+vhost_scsi_get_pr_transport_id(struct se_portal_group *se_tpg,
                               struct se_node_acl *se_nacl,
                               struct t10_pr_registration *pr_reg,
                               int *format_code,
                               unsigned char *buf)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
-        struct tcm_vhost_tport *tport = tpg->tport;
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
+        struct vhost_scsi_tport *tport = tpg->tport;
 
         switch (tport->tport_proto_id) {
         case SCSI_PROTOCOL_SAS:
@@ -369,14 +372,14 @@ tcm_vhost_get_pr_transport_id(struct se_portal_group *se_tpg,
 }
 
 static u32
-tcm_vhost_get_pr_transport_id_len(struct se_portal_group *se_tpg,
+vhost_scsi_get_pr_transport_id_len(struct se_portal_group *se_tpg,
                                   struct se_node_acl *se_nacl,
                                   struct t10_pr_registration *pr_reg,
                                   int *format_code)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
-        struct tcm_vhost_tport *tport = tpg->tport;
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
+        struct vhost_scsi_tport *tport = tpg->tport;
 
         switch (tport->tport_proto_id) {
         case SCSI_PROTOCOL_SAS:
@@ -399,14 +402,14 @@ tcm_vhost_get_pr_transport_id_len(struct se_portal_group *se_tpg,
 }
 
 static char *
-tcm_vhost_parse_pr_out_transport_id(struct se_portal_group *se_tpg,
+vhost_scsi_parse_pr_out_transport_id(struct se_portal_group *se_tpg,
                                     const char *buf,
                                     u32 *out_tid_len,
                                     char **port_nexus_ptr)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
-        struct tcm_vhost_tport *tport = tpg->tport;
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
+        struct vhost_scsi_tport *tport = tpg->tport;
 
         switch (tport->tport_proto_id) {
         case SCSI_PROTOCOL_SAS:
@@ -429,13 +432,13 @@ tcm_vhost_parse_pr_out_transport_id(struct se_portal_group *se_tpg,
 }
 
 static struct se_node_acl *
-tcm_vhost_alloc_fabric_acl(struct se_portal_group *se_tpg)
+vhost_scsi_alloc_fabric_acl(struct se_portal_group *se_tpg)
 {
-        struct tcm_vhost_nacl *nacl;
+        struct vhost_scsi_nacl *nacl;
 
-        nacl = kzalloc(sizeof(struct tcm_vhost_nacl), GFP_KERNEL);
+        nacl = kzalloc(sizeof(struct vhost_scsi_nacl), GFP_KERNEL);
         if (!nacl) {
-                pr_err("Unable to allocate struct tcm_vhost_nacl\n");
+                pr_err("Unable to allocate struct vhost_scsi_nacl\n");
                 return NULL;
         }
 
@@ -443,24 +446,24 @@ tcm_vhost_alloc_fabric_acl(struct se_portal_group *se_tpg)
 }
 
 static void
-tcm_vhost_release_fabric_acl(struct se_portal_group *se_tpg,
+vhost_scsi_release_fabric_acl(struct se_portal_group *se_tpg,
                              struct se_node_acl *se_nacl)
 {
-        struct tcm_vhost_nacl *nacl = container_of(se_nacl,
-                        struct tcm_vhost_nacl, se_node_acl);
+        struct vhost_scsi_nacl *nacl = container_of(se_nacl,
+                        struct vhost_scsi_nacl, se_node_acl);
         kfree(nacl);
 }
 
-static u32 tcm_vhost_tpg_get_inst_index(struct se_portal_group *se_tpg)
+static u32 vhost_scsi_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
         return 1;
 }
 
-static void tcm_vhost_release_cmd(struct se_cmd *se_cmd)
+static void vhost_scsi_release_cmd(struct se_cmd *se_cmd)
 {
-        struct tcm_vhost_cmd *tv_cmd = container_of(se_cmd,
-                                struct tcm_vhost_cmd, tvc_se_cmd);
-        struct se_session *se_sess = se_cmd->se_sess;
+        struct vhost_scsi_cmd *tv_cmd = container_of(se_cmd,
+                                struct vhost_scsi_cmd, tvc_se_cmd);
+        struct se_session *se_sess = tv_cmd->tvc_nexus->tvn_se_sess;
         int i;
 
         if (tv_cmd->tvc_sgl_count) {
@@ -472,53 +475,53 @@ static void tcm_vhost_release_cmd(struct se_cmd *se_cmd)
                         put_page(sg_page(&tv_cmd->tvc_prot_sgl[i]));
         }
 
-        tcm_vhost_put_inflight(tv_cmd->inflight);
+        vhost_scsi_put_inflight(tv_cmd->inflight);
         percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag);
 }
 
-static int tcm_vhost_shutdown_session(struct se_session *se_sess)
+static int vhost_scsi_shutdown_session(struct se_session *se_sess)
 {
         return 0;
 }
 
-static void tcm_vhost_close_session(struct se_session *se_sess)
+static void vhost_scsi_close_session(struct se_session *se_sess)
 {
         return;
 }
 
-static u32 tcm_vhost_sess_get_index(struct se_session *se_sess)
+static u32 vhost_scsi_sess_get_index(struct se_session *se_sess)
 {
         return 0;
 }
 
-static int tcm_vhost_write_pending(struct se_cmd *se_cmd)
+static int vhost_scsi_write_pending(struct se_cmd *se_cmd)
 {
         /* Go ahead and process the write immediately */
         target_execute_cmd(se_cmd);
         return 0;
 }
 
-static int tcm_vhost_write_pending_status(struct se_cmd *se_cmd)
+static int vhost_scsi_write_pending_status(struct se_cmd *se_cmd)
 {
         return 0;
 }
 
-static void tcm_vhost_set_default_node_attrs(struct se_node_acl *nacl)
+static void vhost_scsi_set_default_node_attrs(struct se_node_acl *nacl)
 {
         return;
 }
 
-static u32 tcm_vhost_get_task_tag(struct se_cmd *se_cmd)
+static u32 vhost_scsi_get_task_tag(struct se_cmd *se_cmd)
 {
         return 0;
 }
 
-static int tcm_vhost_get_cmd_state(struct se_cmd *se_cmd)
+static int vhost_scsi_get_cmd_state(struct se_cmd *se_cmd)
 {
         return 0;
 }
 
-static void vhost_scsi_complete_cmd(struct tcm_vhost_cmd *cmd)
+static void vhost_scsi_complete_cmd(struct vhost_scsi_cmd *cmd)
 {
         struct vhost_scsi *vs = cmd->tvc_vhost;
 
@@ -527,44 +530,44 @@ static void vhost_scsi_complete_cmd(struct tcm_vhost_cmd *cmd)
         vhost_work_queue(&vs->dev, &vs->vs_completion_work);
 }
 
-static int tcm_vhost_queue_data_in(struct se_cmd *se_cmd)
+static int vhost_scsi_queue_data_in(struct se_cmd *se_cmd)
 {
-        struct tcm_vhost_cmd *cmd = container_of(se_cmd,
-                                struct tcm_vhost_cmd, tvc_se_cmd);
+        struct vhost_scsi_cmd *cmd = container_of(se_cmd,
+                                struct vhost_scsi_cmd, tvc_se_cmd);
         vhost_scsi_complete_cmd(cmd);
         return 0;
 }
 
-static int tcm_vhost_queue_status(struct se_cmd *se_cmd)
+static int vhost_scsi_queue_status(struct se_cmd *se_cmd)
 {
-        struct tcm_vhost_cmd *cmd = container_of(se_cmd,
-                                struct tcm_vhost_cmd, tvc_se_cmd);
+        struct vhost_scsi_cmd *cmd = container_of(se_cmd,
+                                struct vhost_scsi_cmd, tvc_se_cmd);
         vhost_scsi_complete_cmd(cmd);
         return 0;
 }
 
-static void tcm_vhost_queue_tm_rsp(struct se_cmd *se_cmd)
+static void vhost_scsi_queue_tm_rsp(struct se_cmd *se_cmd)
 {
         return;
 }
 
-static void tcm_vhost_aborted_task(struct se_cmd *se_cmd)
+static void vhost_scsi_aborted_task(struct se_cmd *se_cmd)
 {
         return;
 }
 
-static void tcm_vhost_free_evt(struct vhost_scsi *vs, struct tcm_vhost_evt *evt)
+static void vhost_scsi_free_evt(struct vhost_scsi *vs, struct vhost_scsi_evt *evt)
 {
         vs->vs_events_nr--;
         kfree(evt);
 }
 
-static struct tcm_vhost_evt *
-tcm_vhost_allocate_evt(struct vhost_scsi *vs,
+static struct vhost_scsi_evt *
+vhost_scsi_allocate_evt(struct vhost_scsi *vs,
                        u32 event, u32 reason)
 {
         struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
-        struct tcm_vhost_evt *evt;
+        struct vhost_scsi_evt *evt;
 
         if (vs->vs_events_nr > VHOST_SCSI_MAX_EVENT) {
                 vs->vs_events_missed = true;
@@ -573,7 +576,7 @@ tcm_vhost_allocate_evt(struct vhost_scsi *vs,
 
         evt = kzalloc(sizeof(*evt), GFP_KERNEL);
         if (!evt) {
-                vq_err(vq, "Failed to allocate tcm_vhost_evt\n");
+                vq_err(vq, "Failed to allocate vhost_scsi_evt\n");
                 vs->vs_events_missed = true;
                 return NULL;
         }
@@ -585,7 +588,7 @@ tcm_vhost_allocate_evt(struct vhost_scsi *vs,
         return evt;
 }
 
-static void vhost_scsi_free_cmd(struct tcm_vhost_cmd *cmd)
+static void vhost_scsi_free_cmd(struct vhost_scsi_cmd *cmd)
 {
         struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
 
@@ -600,7 +603,7 @@ static int vhost_scsi_check_stop_free(struct se_cmd *se_cmd)
 }
 
 static void
-tcm_vhost_do_evt_work(struct vhost_scsi *vs, struct tcm_vhost_evt *evt)
+vhost_scsi_do_evt_work(struct vhost_scsi *vs, struct vhost_scsi_evt *evt)
 {
         struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
         struct virtio_scsi_event *event = &evt->event;
@@ -646,24 +649,24 @@ again:
         if (!ret)
                 vhost_add_used_and_signal(&vs->dev, vq, head, 0);
         else
-                vq_err(vq, "Faulted on tcm_vhost_send_event\n");
+                vq_err(vq, "Faulted on vhost_scsi_send_event\n");
 }
 
-static void tcm_vhost_evt_work(struct vhost_work *work)
+static void vhost_scsi_evt_work(struct vhost_work *work)
 {
         struct vhost_scsi *vs = container_of(work, struct vhost_scsi,
                                         vs_event_work);
         struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
-        struct tcm_vhost_evt *evt;
+        struct vhost_scsi_evt *evt;
         struct llist_node *llnode;
 
         mutex_lock(&vq->mutex);
         llnode = llist_del_all(&vs->vs_event_list);
         while (llnode) {
-                evt = llist_entry(llnode, struct tcm_vhost_evt, list);
+                evt = llist_entry(llnode, struct vhost_scsi_evt, list);
                 llnode = llist_next(llnode);
-                tcm_vhost_do_evt_work(vs, evt);
-                tcm_vhost_free_evt(vs, evt);
+                vhost_scsi_do_evt_work(vs, evt);
+                vhost_scsi_free_evt(vs, evt);
         }
         mutex_unlock(&vq->mutex);
 }
@@ -679,15 +682,16 @@ static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
                                         vs_completion_work);
         DECLARE_BITMAP(signal, VHOST_SCSI_MAX_VQ);
         struct virtio_scsi_cmd_resp v_rsp;
-        struct tcm_vhost_cmd *cmd;
+        struct vhost_scsi_cmd *cmd;
         struct llist_node *llnode;
         struct se_cmd *se_cmd;
+        struct iov_iter iov_iter;
         int ret, vq;
 
         bitmap_zero(signal, VHOST_SCSI_MAX_VQ);
         llnode = llist_del_all(&vs->vs_completion_list);
         while (llnode) {
-                cmd = llist_entry(llnode, struct tcm_vhost_cmd,
+                cmd = llist_entry(llnode, struct vhost_scsi_cmd,
                                      tvc_completion_list);
                 llnode = llist_next(llnode);
                 se_cmd = &cmd->tvc_se_cmd;
@@ -703,8 +707,11 @@ static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
                                                  se_cmd->scsi_sense_length);
                 memcpy(v_rsp.sense, cmd->tvc_sense_buf,
                        se_cmd->scsi_sense_length);
-                ret = copy_to_user(cmd->tvc_resp, &v_rsp, sizeof(v_rsp));
-                if (likely(ret == 0)) {
+
+                iov_iter_init(&iov_iter, READ, cmd->tvc_resp_iov,
+                              cmd->tvc_in_iovs, sizeof(v_rsp));
+                ret = copy_to_iter(&v_rsp, sizeof(v_rsp), &iov_iter);
+                if (likely(ret == sizeof(v_rsp))) {
                         struct vhost_scsi_virtqueue *q;
                         vhost_add_used(cmd->tvc_vq, cmd->tvc_vq_desc, 0);
                         q = container_of(cmd->tvc_vq, struct vhost_scsi_virtqueue, vq);
@@ -722,13 +729,13 @@ static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
                 vhost_signal(&vs->dev, &vs->vqs[vq].vq);
 }
 
-static struct tcm_vhost_cmd *
-vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct tcm_vhost_tpg *tpg,
+static struct vhost_scsi_cmd *
+vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg,
                    unsigned char *cdb, u64 scsi_tag, u16 lun, u8 task_attr,
                    u32 exp_data_len, int data_direction)
 {
-        struct tcm_vhost_cmd *cmd;
-        struct tcm_vhost_nexus *tv_nexus;
+        struct vhost_scsi_cmd *cmd;
+        struct vhost_scsi_nexus *tv_nexus;
         struct se_session *se_sess;
         struct scatterlist *sg, *prot_sg;
         struct page **pages;
@@ -736,22 +743,22 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct tcm_vhost_tpg *tpg,
 
         tv_nexus = tpg->tpg_nexus;
         if (!tv_nexus) {
-                pr_err("Unable to locate active struct tcm_vhost_nexus\n");
+                pr_err("Unable to locate active struct vhost_scsi_nexus\n");
                 return ERR_PTR(-EIO);
         }
         se_sess = tv_nexus->tvn_se_sess;
 
         tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING);
         if (tag < 0) {
-                pr_err("Unable to obtain tag for tcm_vhost_cmd\n");
+                pr_err("Unable to obtain tag for vhost_scsi_cmd\n");
                 return ERR_PTR(-ENOMEM);
         }
 
-        cmd = &((struct tcm_vhost_cmd *)se_sess->sess_cmd_map)[tag];
+        cmd = &((struct vhost_scsi_cmd *)se_sess->sess_cmd_map)[tag];
         sg = cmd->tvc_sgl;
         prot_sg = cmd->tvc_prot_sgl;
         pages = cmd->tvc_upages;
-        memset(cmd, 0, sizeof(struct tcm_vhost_cmd));
+        memset(cmd, 0, sizeof(struct vhost_scsi_cmd));
 
         cmd->tvc_sgl = sg;
         cmd->tvc_prot_sgl = prot_sg;
@@ -763,9 +770,9 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct tcm_vhost_tpg *tpg,
         cmd->tvc_exp_data_len = exp_data_len;
         cmd->tvc_data_direction = data_direction;
         cmd->tvc_nexus = tv_nexus;
-        cmd->inflight = tcm_vhost_get_inflight(vq);
+        cmd->inflight = vhost_scsi_get_inflight(vq);
 
-        memcpy(cmd->tvc_cdb, cdb, TCM_VHOST_MAX_CDB_SIZE);
+        memcpy(cmd->tvc_cdb, cdb, VHOST_SCSI_MAX_CDB_SIZE);
 
         return cmd;
 }
@@ -776,29 +783,22 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct tcm_vhost_tpg *tpg,
  * Returns the number of scatterlist entries used or -errno on error.
  */
 static int
-vhost_scsi_map_to_sgl(struct tcm_vhost_cmd *tv_cmd,
+vhost_scsi_map_to_sgl(struct vhost_scsi_cmd *cmd,
+                      void __user *ptr,
+                      size_t len,
                       struct scatterlist *sgl,
-                      unsigned int sgl_count,
-                      struct iovec *iov,
-                      struct page **pages,
                       bool write)
 {
-        unsigned int npages = 0, pages_nr, offset, nbytes;
+        unsigned int npages = 0, offset, nbytes;
+        unsigned int pages_nr = iov_num_pages(ptr, len);
         struct scatterlist *sg = sgl;
-        void __user *ptr = iov->iov_base;
-        size_t len = iov->iov_len;
+        struct page **pages = cmd->tvc_upages;
         int ret, i;
 
-        pages_nr = iov_num_pages(iov);
-        if (pages_nr > sgl_count) {
-                pr_err("vhost_scsi_map_to_sgl() pages_nr: %u greater than"
-                       " sgl_count: %u\n", pages_nr, sgl_count);
-                return -ENOBUFS;
-        }
-        if (pages_nr > TCM_VHOST_PREALLOC_UPAGES) {
+        if (pages_nr > VHOST_SCSI_PREALLOC_UPAGES) {
                 pr_err("vhost_scsi_map_to_sgl() pages_nr: %u greater than"
-                       " preallocated TCM_VHOST_PREALLOC_UPAGES: %u\n",
-                        pages_nr, TCM_VHOST_PREALLOC_UPAGES);
+                       " preallocated VHOST_SCSI_PREALLOC_UPAGES: %u\n",
+                        pages_nr, VHOST_SCSI_PREALLOC_UPAGES);
                 return -ENOBUFS;
         }
 
@@ -829,84 +829,94 @@ out:
 }
 
 static int
-vhost_scsi_map_iov_to_sgl(struct tcm_vhost_cmd *cmd,
-                          struct iovec *iov,
-                          int niov,
-                          bool write)
+vhost_scsi_calc_sgls(struct iov_iter *iter, size_t bytes, int max_sgls)
 {
-        struct scatterlist *sg = cmd->tvc_sgl;
-        unsigned int sgl_count = 0;
-        int ret, i;
+        int sgl_count = 0;
 
-        for (i = 0; i < niov; i++)
-                sgl_count += iov_num_pages(&iov[i]);
+        if (!iter || !iter->iov) {
+                pr_err("%s: iter->iov is NULL, but expected bytes: %zu"
+                       " present\n", __func__, bytes);
+                return -EINVAL;
+        }
 
-        if (sgl_count > TCM_VHOST_PREALLOC_SGLS) {
-                pr_err("vhost_scsi_map_iov_to_sgl() sgl_count: %u greater than"
-                        " preallocated TCM_VHOST_PREALLOC_SGLS: %u\n",
-                        sgl_count, TCM_VHOST_PREALLOC_SGLS);
-                return -ENOBUFS;
+        sgl_count = iov_iter_npages(iter, 0xffff);
+        if (sgl_count > max_sgls) {
+                pr_err("%s: requested sgl_count: %d exceeds pre-allocated"
+                       " max_sgls: %d\n", __func__, sgl_count, max_sgls);
+                return -EINVAL;
         }
+        return sgl_count;
+}
 
-        pr_debug("%s sg %p sgl_count %u\n", __func__, sg, sgl_count);
-        sg_init_table(sg, sgl_count);
-        cmd->tvc_sgl_count = sgl_count;
+static int
+vhost_scsi_iov_to_sgl(struct vhost_scsi_cmd *cmd, bool write,
+                      struct iov_iter *iter,
+                      struct scatterlist *sg, int sg_count)
+{
+        size_t off = iter->iov_offset;
+        int i, ret;
 
-        pr_debug("Mapping iovec %p for %u pages\n", &iov[0], sgl_count);
+        for (i = 0; i < iter->nr_segs; i++) {
+                void __user *base = iter->iov[i].iov_base + off;
+                size_t len = iter->iov[i].iov_len - off;
 
-        for (i = 0; i < niov; i++) {
-                ret = vhost_scsi_map_to_sgl(cmd, sg, sgl_count, &iov[i],
-                                            cmd->tvc_upages, write);
+                ret = vhost_scsi_map_to_sgl(cmd, base, len, sg, write);
                 if (ret < 0) {
-                        for (i = 0; i < cmd->tvc_sgl_count; i++)
-                                put_page(sg_page(&cmd->tvc_sgl[i]));
-
-                        cmd->tvc_sgl_count = 0;
+                        for (i = 0; i < sg_count; i++) {
+                                struct page *page = sg_page(&sg[i]);
+                                if (page)
+                                        put_page(page);
+                        }
                         return ret;
                 }
                 sg += ret;
-                sgl_count -= ret;
+                off = 0;
         }
         return 0;
 }
 
 static int
-vhost_scsi_map_iov_to_prot(struct tcm_vhost_cmd *cmd,
-                           struct iovec *iov,
-                           int niov,
-                           bool write)
-{
-        struct scatterlist *prot_sg = cmd->tvc_prot_sgl;
-        unsigned int prot_sgl_count = 0;
-        int ret, i;
-
-        for (i = 0; i < niov; i++)
-                prot_sgl_count += iov_num_pages(&iov[i]);
-
-        if (prot_sgl_count > TCM_VHOST_PREALLOC_PROT_SGLS) {
-                pr_err("vhost_scsi_map_iov_to_prot() sgl_count: %u greater than"
-                        " preallocated TCM_VHOST_PREALLOC_PROT_SGLS: %u\n",
-                        prot_sgl_count, TCM_VHOST_PREALLOC_PROT_SGLS);
-                return -ENOBUFS;
-        }
-
-        pr_debug("%s prot_sg %p prot_sgl_count %u\n", __func__,
-                 prot_sg, prot_sgl_count);
-        sg_init_table(prot_sg, prot_sgl_count);
-        cmd->tvc_prot_sgl_count = prot_sgl_count;
-
-        for (i = 0; i < niov; i++) {
-                ret = vhost_scsi_map_to_sgl(cmd, prot_sg, prot_sgl_count, &iov[i],
-                                            cmd->tvc_upages, write);
+vhost_scsi_mapal(struct vhost_scsi_cmd *cmd,
+                 size_t prot_bytes, struct iov_iter *prot_iter,
+                 size_t data_bytes, struct iov_iter *data_iter)
+{
+        int sgl_count, ret;
+        bool write = (cmd->tvc_data_direction == DMA_FROM_DEVICE);
+
+        if (prot_bytes) {
+                sgl_count = vhost_scsi_calc_sgls(prot_iter, prot_bytes,
+                                                 VHOST_SCSI_PREALLOC_PROT_SGLS);
+                if (sgl_count < 0)
+                        return sgl_count;
+
+                sg_init_table(cmd->tvc_prot_sgl, sgl_count);
+                cmd->tvc_prot_sgl_count = sgl_count;
+                pr_debug("%s prot_sg %p prot_sgl_count %u\n", __func__,
+                         cmd->tvc_prot_sgl, cmd->tvc_prot_sgl_count);
+
+                ret = vhost_scsi_iov_to_sgl(cmd, write, prot_iter,
+                                            cmd->tvc_prot_sgl,
+                                            cmd->tvc_prot_sgl_count);
                 if (ret < 0) {
-                        for (i = 0; i < cmd->tvc_prot_sgl_count; i++)
-                                put_page(sg_page(&cmd->tvc_prot_sgl[i]));
-
                         cmd->tvc_prot_sgl_count = 0;
                         return ret;
                 }
-                prot_sg += ret;
-                prot_sgl_count -= ret;
+        }
+        sgl_count = vhost_scsi_calc_sgls(data_iter, data_bytes,
+                                         VHOST_SCSI_PREALLOC_SGLS);
+        if (sgl_count < 0)
+                return sgl_count;
+
+        sg_init_table(cmd->tvc_sgl, sgl_count);
+        cmd->tvc_sgl_count = sgl_count;
+        pr_debug("%s data_sg %p data_sgl_count %u\n", __func__,
+                  cmd->tvc_sgl, cmd->tvc_sgl_count);
+
+        ret = vhost_scsi_iov_to_sgl(cmd, write, data_iter,
+                                    cmd->tvc_sgl, cmd->tvc_sgl_count);
+        if (ret < 0) {
+                cmd->tvc_sgl_count = 0;
+                return ret;
         }
         return 0;
 }
@@ -928,11 +938,11 @@ static int vhost_scsi_to_tcm_attr(int attr)
         return TCM_SIMPLE_TAG;
 }
 
-static void tcm_vhost_submission_work(struct work_struct *work)
+static void vhost_scsi_submission_work(struct work_struct *work)
 {
-        struct tcm_vhost_cmd *cmd =
-                container_of(work, struct tcm_vhost_cmd, work);
-        struct tcm_vhost_nexus *tv_nexus;
+        struct vhost_scsi_cmd *cmd =
+                container_of(work, struct vhost_scsi_cmd, work);
+        struct vhost_scsi_nexus *tv_nexus;
         struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
         struct scatterlist *sg_ptr, *sg_prot_ptr = NULL;
         int rc;
@@ -986,19 +996,20 @@ vhost_scsi_send_bad_target(struct vhost_scsi *vs,
 static void
 vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
 {
-        struct tcm_vhost_tpg **vs_tpg;
+        struct vhost_scsi_tpg **vs_tpg, *tpg;
         struct virtio_scsi_cmd_req v_req;
         struct virtio_scsi_cmd_req_pi v_req_pi;
-        struct tcm_vhost_tpg *tpg;
-        struct tcm_vhost_cmd *cmd;
+        struct vhost_scsi_cmd *cmd;
+        struct iov_iter out_iter, in_iter, prot_iter, data_iter;
         u64 tag;
-        u32 exp_data_len, data_first, data_num, data_direction, prot_first;
-        unsigned out, in, i;
-        int head, ret, data_niov, prot_niov, prot_bytes;
-        size_t req_size;
+        u32 exp_data_len, data_direction;
+        unsigned out, in;
+        int head, ret, prot_bytes;
+        size_t req_size, rsp_size = sizeof(struct virtio_scsi_cmd_resp);
+        size_t out_size, in_size;
         u16 lun;
         u8 *target, *lunp, task_attr;
-        bool hdr_pi;
+        bool t10_pi = vhost_has_feature(vq, VIRTIO_SCSI_F_T10_PI);
         void *req, *cdb;
 
         mutex_lock(&vq->mutex);
@@ -1014,10 +1025,10 @@ vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
 
         for (;;) {
                 head = vhost_get_vq_desc(vq, vq->iov,
-                                        ARRAY_SIZE(vq->iov), &out, &in,
-                                        NULL, NULL);
+                                         ARRAY_SIZE(vq->iov), &out, &in,
+                                         NULL, NULL);
                 pr_debug("vhost_get_vq_desc: head: %d, out: %u in: %u\n",
-                                        head, out, in);
+                         head, out, in);
                 /* On error, stop handling until the next kick. */
                 if (unlikely(head < 0))
                         break;
@@ -1029,113 +1040,134 @@ vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
                         }
                         break;
                 }
-
-                /* FIXME: BIDI operation */
-                if (out == 1 && in == 1) {
-                        data_direction = DMA_NONE;
-                        data_first = 0;
-                        data_num = 0;
-                } else if (out == 1 && in > 1) {
-                        data_direction = DMA_FROM_DEVICE;
-                        data_first = out + 1;
-                        data_num = in - 1;
-                } else if (out > 1 && in == 1) {
-                        data_direction = DMA_TO_DEVICE;
-                        data_first = 1;
-                        data_num = out - 1;
-                } else {
-                        vq_err(vq, "Invalid buffer layout out: %u in: %u\n",
-                                        out, in);
-                        break;
-                }
-
                 /*
-                 * Check for a sane resp buffer so we can report errors to
-                 * the guest.
+                 * Check for a sane response buffer so we can report early
+                 * errors back to the guest.
                  */
-                if (unlikely(vq->iov[out].iov_len !=
-                                        sizeof(struct virtio_scsi_cmd_resp))) {
-                        vq_err(vq, "Expecting virtio_scsi_cmd_resp, got %zu"
-                                " bytes\n", vq->iov[out].iov_len);
+                if (unlikely(vq->iov[out].iov_len < rsp_size)) {
+                        vq_err(vq, "Expecting at least virtio_scsi_cmd_resp"
+                                " size, got %zu bytes\n", vq->iov[out].iov_len);
                         break;
                 }
-
-                if (vhost_has_feature(vq, VIRTIO_SCSI_F_T10_PI)) {
+                /*
+                 * Setup pointers and values based upon different virtio-scsi
+                 * request header if T10_PI is enabled in KVM guest.
+                 */
+                if (t10_pi) {
                         req = &v_req_pi;
+                        req_size = sizeof(v_req_pi);
                         lunp = &v_req_pi.lun[0];
                         target = &v_req_pi.lun[1];
-                        req_size = sizeof(v_req_pi);
-                        hdr_pi = true;
                 } else {
                         req = &v_req;
+                        req_size = sizeof(v_req);
                         lunp = &v_req.lun[0];
                         target = &v_req.lun[1];
-                        req_size = sizeof(v_req);
-                        hdr_pi = false;
                 }
+                /*
+                 * FIXME: Not correct for BIDI operation
+                 */
+                out_size = iov_length(vq->iov, out);
+                in_size = iov_length(&vq->iov[out], in);
 
-                if (unlikely(vq->iov[0].iov_len < req_size)) {
-                        pr_err("Expecting virtio-scsi header: %zu, got %zu\n",
-                               req_size, vq->iov[0].iov_len);
-                        break;
-                }
-                ret = copy_from_user(req, vq->iov[0].iov_base, req_size);
-                if (unlikely(ret)) {
-                        vq_err(vq, "Faulted on virtio_scsi_cmd_req\n");
-                        break;
-                }
+                /*
+                 * Copy over the virtio-scsi request header, which for a
+                 * ANY_LAYOUT enabled guest may span multiple iovecs, or a
+                 * single iovec may contain both the header + outgoing
+                 * WRITE payloads.
+                 *
+                 * copy_from_iter() will advance out_iter, so that it will
+                 * point at the start of the outgoing WRITE payload, if
+                 * DMA_TO_DEVICE is set.
+                 */
+                iov_iter_init(&out_iter, WRITE, vq->iov, out, out_size);
 
+                ret = copy_from_iter(req, req_size, &out_iter);
+                if (unlikely(ret != req_size)) {
+                        vq_err(vq, "Faulted on copy_from_iter\n");
+                        vhost_scsi_send_bad_target(vs, vq, head, out);
+                        continue;
+                }
                 /* virtio-scsi spec requires byte 0 of the lun to be 1 */
                 if (unlikely(*lunp != 1)) {
+                        vq_err(vq, "Illegal virtio-scsi lun: %u\n", *lunp);
                         vhost_scsi_send_bad_target(vs, vq, head, out);
                         continue;
                 }
 
                 tpg = ACCESS_ONCE(vs_tpg[*target]);
-
-                /* Target does not exist, fail the request */
                 if (unlikely(!tpg)) {
+                        /* Target does not exist, fail the request */
                         vhost_scsi_send_bad_target(vs, vq, head, out);
                         continue;
                 }
-
-                data_niov = data_num;
-                prot_niov = prot_first = prot_bytes = 0;
                 /*
-                 * Determine if any protection information iovecs are preceeding
-                 * the actual data payload, and adjust data_first + data_niov
-                 * values accordingly for vhost_scsi_map_iov_to_sgl() below.
+                 * Determine data_direction by calculating the total outgoing
+                 * iovec sizes + incoming iovec sizes vs. virtio-scsi request +
+                 * response headers respectively.
                  *
-                 * Also extract virtio_scsi header bits for vhost_scsi_get_tag()
+                 * For DMA_TO_DEVICE this is out_iter, which is already pointing
+                 * to the right place.
+                 *
+                 * For DMA_FROM_DEVICE, the iovec will be just past the end
+                 * of the virtio-scsi response header in either the same
+                 * or immediately following iovec.
+                 *
+                 * Any associated T10_PI bytes for the outgoing / incoming
+                 * payloads are included in calculation of exp_data_len here.
                  */
-                if (hdr_pi) {
+                prot_bytes = 0;
+
+                if (out_size > req_size) {
+                        data_direction = DMA_TO_DEVICE;
+                        exp_data_len = out_size - req_size;
+                        data_iter = out_iter;
+                } else if (in_size > rsp_size) {
+                        data_direction = DMA_FROM_DEVICE;
+                        exp_data_len = in_size - rsp_size;
+
+                        iov_iter_init(&in_iter, READ, &vq->iov[out], in,
+                                      rsp_size + exp_data_len);
+                        iov_iter_advance(&in_iter, rsp_size);
+                        data_iter = in_iter;
+                } else {
+                        data_direction = DMA_NONE;
+                        exp_data_len = 0;
+                }
+                /*
+                 * If T10_PI header + payload is present, setup prot_iter values
+                 * and recalculate data_iter for vhost_scsi_mapal() mapping to
+                 * host scatterlists via get_user_pages_fast().
+                 */
+                if (t10_pi) {
                         if (v_req_pi.pi_bytesout) {
                                 if (data_direction != DMA_TO_DEVICE) {
-                                        vq_err(vq, "Received non zero do_pi_niov"
-                                                ", but wrong data_direction\n");
-                                        goto err_cmd;
+                                        vq_err(vq, "Received non zero pi_bytesout,"
+                                                " but wrong data_direction\n");
+                                        vhost_scsi_send_bad_target(vs, vq, head, out);
+                                        continue;
                                 }
                                 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;
+                                        vq_err(vq, "Received non zero pi_bytesin,"
+                                                " but wrong data_direction\n");
+                                        vhost_scsi_send_bad_target(vs, vq, head, out);
+                                        continue;
                                 }
                                 prot_bytes = vhost32_to_cpu(vq, v_req_pi.pi_bytesin);
                         }
+                        /*
+                         * Set prot_iter to data_iter, and advance past any
+                         * preceeding prot_bytes that may be present.
+                         *
+                         * Also fix up the exp_data_len to reflect only the
+                         * actual data payload length.
+                         */
                         if (prot_bytes) {
-                                int tmp = 0;
-
-                                for (i = 0; i < data_num; i++) {
-                                        tmp += vq->iov[data_first + i].iov_len;
-                                        prot_niov++;
-                                        if (tmp >= prot_bytes)
-                                                break;
-                                }
-                                prot_first = data_first;
-                                data_first += prot_niov;
-                                data_niov = data_num - prot_niov;
+                                exp_data_len -= prot_bytes;
+                                prot_iter = data_iter;
+                                iov_iter_advance(&data_iter, prot_bytes);
                         }
                         tag = vhost64_to_cpu(vq, v_req_pi.tag);
                         task_attr = v_req_pi.task_attr;
@@ -1147,83 +1179,65 @@ vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
                         cdb = &v_req.cdb[0];
                         lun = ((v_req.lun[2] << 8) | v_req.lun[3]) & 0x3FFF;
                 }
-                exp_data_len = 0;
-                for (i = 0; i < data_niov; i++)
-                        exp_data_len += vq->iov[data_first + i].iov_len;
                 /*
-                 * Check that the recieved CDB size does not exceeded our
-                 * hardcoded max for vhost-scsi
+                 * Check that the received CDB size does not exceeded our
+                 * hardcoded max for vhost-scsi, then get a pre-allocated
+                 * cmd descriptor for the new virtio-scsi tag.
                  *
                  * TODO what if cdb was too small for varlen cdb header?
                  */
-                if (unlikely(scsi_command_size(cdb) > TCM_VHOST_MAX_CDB_SIZE)) {
+                if (unlikely(scsi_command_size(cdb) > VHOST_SCSI_MAX_CDB_SIZE)) {
                         vq_err(vq, "Received SCSI CDB with command_size: %d that"
                                 " exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
-                                scsi_command_size(cdb), TCM_VHOST_MAX_CDB_SIZE);
-                        goto err_cmd;
+                                scsi_command_size(cdb), VHOST_SCSI_MAX_CDB_SIZE);
+                        vhost_scsi_send_bad_target(vs, vq, head, out);
+                        continue;
                 }
-
                 cmd = vhost_scsi_get_tag(vq, tpg, cdb, tag, lun, task_attr,
                                          exp_data_len + prot_bytes,
                                          data_direction);
                 if (IS_ERR(cmd)) {
                         vq_err(vq, "vhost_scsi_get_tag failed %ld\n",
-                                        PTR_ERR(cmd));
-                        goto err_cmd;
+                               PTR_ERR(cmd));
+                        vhost_scsi_send_bad_target(vs, vq, head, out);
+                        continue;
                 }
-
-                pr_debug("Allocated tv_cmd: %p exp_data_len: %d, data_direction"
-                        ": %d\n", cmd, exp_data_len, data_direction);
-
                 cmd->tvc_vhost = vs;
                 cmd->tvc_vq = vq;
-                cmd->tvc_resp = vq->iov[out].iov_base;
+                cmd->tvc_resp_iov = &vq->iov[out];
+                cmd->tvc_in_iovs = in;
 
                 pr_debug("vhost_scsi got command opcode: %#02x, lun: %d\n",
-                        cmd->tvc_cdb[0], cmd->tvc_lun);
+                         cmd->tvc_cdb[0], cmd->tvc_lun);
+                pr_debug("cmd: %p exp_data_len: %d, prot_bytes: %d data_direction:"
+                         " %d\n", cmd, exp_data_len, prot_bytes, data_direction);
 
-                if (prot_niov) {
-                        ret = vhost_scsi_map_iov_to_prot(cmd,
-                                        &vq->iov[prot_first], prot_niov,
-                                        data_direction == DMA_FROM_DEVICE);
-                        if (unlikely(ret)) {
-                                vq_err(vq, "Failed to map iov to"
-                                        " prot_sgl\n");
-                                goto err_free;
-                        }
-                }
                 if (data_direction != DMA_NONE) {
-                        ret = vhost_scsi_map_iov_to_sgl(cmd,
-                                        &vq->iov[data_first], data_niov,
-                                        data_direction == DMA_FROM_DEVICE);
+                        ret = vhost_scsi_mapal(cmd,
+                                               prot_bytes, &prot_iter,
+                                               exp_data_len, &data_iter);
                         if (unlikely(ret)) {
                                 vq_err(vq, "Failed to map iov to sgl\n");
-                                goto err_free;
+                                vhost_scsi_release_cmd(&cmd->tvc_se_cmd);
+                                vhost_scsi_send_bad_target(vs, vq, head, out);
+                                continue;
                         }
                 }
                 /*
                  * Save the descriptor from vhost_get_vq_desc() to be used to
                  * complete the virtio-scsi request in TCM callback context via
-                 * tcm_vhost_queue_data_in() and tcm_vhost_queue_status()
+                 * vhost_scsi_queue_data_in() and vhost_scsi_queue_status()
                  */
                 cmd->tvc_vq_desc = head;
                 /*
-                 * Dispatch tv_cmd descriptor for cmwq execution in process
-                 * context provided by tcm_vhost_workqueue.  This also ensures
-                 * tv_cmd is executed on the same kworker CPU as this vhost
-                 * thread to gain positive L2 cache locality effects..
+                 * Dispatch cmd descriptor for cmwq execution in process
+                 * context provided by vhost_scsi_workqueue.  This also ensures
+                 * cmd is executed on the same kworker CPU as this vhost
+                 * thread to gain positive L2 cache locality effects.
                  */
-                INIT_WORK(&cmd->work, tcm_vhost_submission_work);
-                queue_work(tcm_vhost_workqueue, &cmd->work);
+                INIT_WORK(&cmd->work, vhost_scsi_submission_work);
+                queue_work(vhost_scsi_workqueue, &cmd->work);
         }
-
-        mutex_unlock(&vq->mutex);
-        return;
-
-err_free:
-        vhost_scsi_free_cmd(cmd);
-err_cmd:
-        vhost_scsi_send_bad_target(vs, vq, head, out);
 out:
         mutex_unlock(&vq->mutex);
 }
@@ -1234,15 +1248,15 @@ static void vhost_scsi_ctl_handle_kick(struct vhost_work *work)
 }
 
 static void
-tcm_vhost_send_evt(struct vhost_scsi *vs,
-                   struct tcm_vhost_tpg *tpg,
+vhost_scsi_send_evt(struct vhost_scsi *vs,
+                   struct vhost_scsi_tpg *tpg,
                    struct se_lun *lun,
                    u32 event,
                    u32 reason)
 {
-        struct tcm_vhost_evt *evt;
+        struct vhost_scsi_evt *evt;
 
-        evt = tcm_vhost_allocate_evt(vs, event, reason);
+        evt = vhost_scsi_allocate_evt(vs, event, reason);
         if (!evt)
                 return;
 
@@ -1253,7 +1267,7 @@ tcm_vhost_send_evt(struct vhost_scsi *vs,
                  * lun[4-7] need to be zero according to virtio-scsi spec.
                  */
                 evt->event.lun[0] = 0x01;
-                evt->event.lun[1] = tpg->tport_tpgt & 0xFF;
+                evt->event.lun[1] = tpg->tport_tpgt;
                 if (lun->unpacked_lun >= 256)
                         evt->event.lun[2] = lun->unpacked_lun >> 8 | 0x40 ;
                 evt->event.lun[3] = lun->unpacked_lun & 0xFF;
@@ -1274,7 +1288,7 @@ static void vhost_scsi_evt_handle_kick(struct vhost_work *work)
                 goto out;
 
         if (vs->vs_events_missed)
-                tcm_vhost_send_evt(vs, NULL, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
+                vhost_scsi_send_evt(vs, NULL, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
 out:
         mutex_unlock(&vq->mutex);
 }
@@ -1300,7 +1314,7 @@ static void vhost_scsi_flush(struct vhost_scsi *vs)
         int i;
 
         /* Init new inflight and remember the old inflight */
-        tcm_vhost_init_inflight(vs, old_inflight);
+        vhost_scsi_init_inflight(vs, old_inflight);
 
         /*
          * The inflight->kref was initialized to 1. We decrement it here to
@@ -1308,7 +1322,7 @@ static void vhost_scsi_flush(struct vhost_scsi *vs)
          * when all the reqs are finished.
          */
         for (i = 0; i < VHOST_SCSI_MAX_VQ; i++)
-                kref_put(&old_inflight[i]->kref, tcm_vhost_done_inflight);
+                kref_put(&old_inflight[i]->kref, vhost_scsi_done_inflight);
 
         /* Flush both the vhost poll and vhost work */
         for (i = 0; i < VHOST_SCSI_MAX_VQ; i++)
@@ -1323,24 +1337,24 @@ static void vhost_scsi_flush(struct vhost_scsi *vs)
 
 /*
  * Called from vhost_scsi_ioctl() context to walk the list of available
- * tcm_vhost_tpg with an active struct tcm_vhost_nexus
+ * vhost_scsi_tpg with an active struct vhost_scsi_nexus
  *
  *  The lock nesting rule is:
- *    tcm_vhost_mutex -> vs->dev.mutex -> tpg->tv_tpg_mutex -> vq->mutex
+ *    vhost_scsi_mutex -> vs->dev.mutex -> tpg->tv_tpg_mutex -> vq->mutex
  */
 static int
 vhost_scsi_set_endpoint(struct vhost_scsi *vs,
                         struct vhost_scsi_target *t)
 {
         struct se_portal_group *se_tpg;
-        struct tcm_vhost_tport *tv_tport;
-        struct tcm_vhost_tpg *tpg;
-        struct tcm_vhost_tpg **vs_tpg;
+        struct vhost_scsi_tport *tv_tport;
+        struct vhost_scsi_tpg *tpg;
+        struct vhost_scsi_tpg **vs_tpg;
         struct vhost_virtqueue *vq;
         int index, ret, i, len;
         bool match = false;
 
-        mutex_lock(&tcm_vhost_mutex);
+        mutex_lock(&vhost_scsi_mutex);
         mutex_lock(&vs->dev.mutex);
 
         /* Verify that ring has been setup correctly. */
@@ -1361,7 +1375,7 @@ vhost_scsi_set_endpoint(struct vhost_scsi *vs,
         if (vs->vs_tpg)
                 memcpy(vs_tpg, vs->vs_tpg, len);
 
-        list_for_each_entry(tpg, &tcm_vhost_list, tv_tpg_list) {
+        list_for_each_entry(tpg, &vhost_scsi_list, tv_tpg_list) {
                 mutex_lock(&tpg->tv_tpg_mutex);
                 if (!tpg->tpg_nexus) {
                         mutex_unlock(&tpg->tv_tpg_mutex);
@@ -1429,7 +1443,7 @@ vhost_scsi_set_endpoint(struct vhost_scsi *vs,
 
 out:
         mutex_unlock(&vs->dev.mutex);
-        mutex_unlock(&tcm_vhost_mutex);
+        mutex_unlock(&vhost_scsi_mutex);
         return ret;
 }
 
@@ -1438,14 +1452,14 @@ vhost_scsi_clear_endpoint(struct vhost_scsi *vs,
                           struct vhost_scsi_target *t)
 {
         struct se_portal_group *se_tpg;
-        struct tcm_vhost_tport *tv_tport;
-        struct tcm_vhost_tpg *tpg;
+        struct vhost_scsi_tport *tv_tport;
+        struct vhost_scsi_tpg *tpg;
         struct vhost_virtqueue *vq;
         bool match = false;
         int index, ret, i;
         u8 target;
 
-        mutex_lock(&tcm_vhost_mutex);
+        mutex_lock(&vhost_scsi_mutex);
         mutex_lock(&vs->dev.mutex);
         /* Verify that ring has been setup correctly. */
         for (index = 0; index < vs->dev.nvqs; ++index) {
@@ -1511,14 +1525,14 @@ vhost_scsi_clear_endpoint(struct vhost_scsi *vs,
         vs->vs_tpg = NULL;
         WARN_ON(vs->vs_events_nr);
         mutex_unlock(&vs->dev.mutex);
-        mutex_unlock(&tcm_vhost_mutex);
+        mutex_unlock(&vhost_scsi_mutex);
         return 0;
 
 err_tpg:
         mutex_unlock(&tpg->tv_tpg_mutex);
 err_dev:
         mutex_unlock(&vs->dev.mutex);
-        mutex_unlock(&tcm_vhost_mutex);
+        mutex_unlock(&vhost_scsi_mutex);
         return ret;
 }
 
@@ -1565,7 +1579,7 @@ static int vhost_scsi_open(struct inode *inode, struct file *f)
                 goto err_vqs;
 
         vhost_work_init(&vs->vs_completion_work, vhost_scsi_complete_cmd_work);
-        vhost_work_init(&vs->vs_event_work, tcm_vhost_evt_work);
+        vhost_work_init(&vs->vs_event_work, vhost_scsi_evt_work);
 
         vs->vs_events_nr = 0;
         vs->vs_events_missed = false;
@@ -1580,7 +1594,7 @@ static int vhost_scsi_open(struct inode *inode, struct file *f)
         }
         vhost_dev_init(&vs->dev, vqs, VHOST_SCSI_MAX_VQ);
 
-        tcm_vhost_init_inflight(vs, NULL);
+        vhost_scsi_init_inflight(vs, NULL);
 
         f->private_data = vs;
         return 0;
@@ -1712,7 +1726,7 @@ static int vhost_scsi_deregister(void)
         return misc_deregister(&vhost_scsi_misc);
 }
 
-static char *tcm_vhost_dump_proto_id(struct tcm_vhost_tport *tport)
+static char *vhost_scsi_dump_proto_id(struct vhost_scsi_tport *tport)
 {
         switch (tport->tport_proto_id) {
         case SCSI_PROTOCOL_SAS:
@@ -1729,7 +1743,7 @@ static char *tcm_vhost_dump_proto_id(struct tcm_vhost_tport *tport)
 }
 
 static void
-tcm_vhost_do_plug(struct tcm_vhost_tpg *tpg,
+vhost_scsi_do_plug(struct vhost_scsi_tpg *tpg,
                   struct se_lun *lun, bool plug)
 {
 
@@ -1750,71 +1764,71 @@ tcm_vhost_do_plug(struct tcm_vhost_tpg *tpg,
         vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
         mutex_lock(&vq->mutex);
         if (vhost_has_feature(vq, VIRTIO_SCSI_F_HOTPLUG))
-                tcm_vhost_send_evt(vs, tpg, lun,
+                vhost_scsi_send_evt(vs, tpg, lun,
                                    VIRTIO_SCSI_T_TRANSPORT_RESET, reason);
         mutex_unlock(&vq->mutex);
         mutex_unlock(&vs->dev.mutex);
 }
 
-static void tcm_vhost_hotplug(struct tcm_vhost_tpg *tpg, struct se_lun *lun)
+static void vhost_scsi_hotplug(struct vhost_scsi_tpg *tpg, struct se_lun *lun)
 {
-        tcm_vhost_do_plug(tpg, lun, true);
+        vhost_scsi_do_plug(tpg, lun, true);
 }
 
-static void tcm_vhost_hotunplug(struct tcm_vhost_tpg *tpg, struct se_lun *lun)
+static void vhost_scsi_hotunplug(struct vhost_scsi_tpg *tpg, struct se_lun *lun)
 {
-        tcm_vhost_do_plug(tpg, lun, false);
+        vhost_scsi_do_plug(tpg, lun, false);
 }
 
-static int tcm_vhost_port_link(struct se_portal_group *se_tpg,
+static int vhost_scsi_port_link(struct se_portal_group *se_tpg,
                                struct se_lun *lun)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
 
-        mutex_lock(&tcm_vhost_mutex);
+        mutex_lock(&vhost_scsi_mutex);
 
         mutex_lock(&tpg->tv_tpg_mutex);
         tpg->tv_tpg_port_count++;
         mutex_unlock(&tpg->tv_tpg_mutex);
 
-        tcm_vhost_hotplug(tpg, lun);
+        vhost_scsi_hotplug(tpg, lun);
 
-        mutex_unlock(&tcm_vhost_mutex);
+        mutex_unlock(&vhost_scsi_mutex);
 
         return 0;
 }
 
-static void tcm_vhost_port_unlink(struct se_portal_group *se_tpg,
+static void vhost_scsi_port_unlink(struct se_portal_group *se_tpg,
                                   struct se_lun *lun)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
 
-        mutex_lock(&tcm_vhost_mutex);
+        mutex_lock(&vhost_scsi_mutex);
 
         mutex_lock(&tpg->tv_tpg_mutex);
         tpg->tv_tpg_port_count--;
         mutex_unlock(&tpg->tv_tpg_mutex);
 
-        tcm_vhost_hotunplug(tpg, lun);
+        vhost_scsi_hotunplug(tpg, lun);
 
-        mutex_unlock(&tcm_vhost_mutex);
+        mutex_unlock(&vhost_scsi_mutex);
 }
 
 static struct se_node_acl *
-tcm_vhost_make_nodeacl(struct se_portal_group *se_tpg,
+vhost_scsi_make_nodeacl(struct se_portal_group *se_tpg,
                        struct config_group *group,
                        const char *name)
 {
         struct se_node_acl *se_nacl, *se_nacl_new;
-        struct tcm_vhost_nacl *nacl;
+        struct vhost_scsi_nacl *nacl;
         u64 wwpn = 0;
         u32 nexus_depth;
 
-        /* tcm_vhost_parse_wwn(name, &wwpn, 1) < 0)
+        /* vhost_scsi_parse_wwn(name, &wwpn, 1) < 0)
                 return ERR_PTR(-EINVAL); */
-        se_nacl_new = tcm_vhost_alloc_fabric_acl(se_tpg);
+        se_nacl_new = vhost_scsi_alloc_fabric_acl(se_tpg);
         if (!se_nacl_new)
                 return ERR_PTR(-ENOMEM);
 
@@ -1826,37 +1840,37 @@ tcm_vhost_make_nodeacl(struct se_portal_group *se_tpg,
         se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
                                 name, nexus_depth);
         if (IS_ERR(se_nacl)) {
-                tcm_vhost_release_fabric_acl(se_tpg, se_nacl_new);
+                vhost_scsi_release_fabric_acl(se_tpg, se_nacl_new);
                 return se_nacl;
         }
         /*
-         * Locate our struct tcm_vhost_nacl and set the FC Nport WWPN
+         * Locate our struct vhost_scsi_nacl and set the FC Nport WWPN
          */
-        nacl = container_of(se_nacl, struct tcm_vhost_nacl, se_node_acl);
+        nacl = container_of(se_nacl, struct vhost_scsi_nacl, se_node_acl);
         nacl->iport_wwpn = wwpn;
 
         return se_nacl;
 }
 
-static void tcm_vhost_drop_nodeacl(struct se_node_acl *se_acl)
+static void vhost_scsi_drop_nodeacl(struct se_node_acl *se_acl)
 {
-        struct tcm_vhost_nacl *nacl = container_of(se_acl,
-                                struct tcm_vhost_nacl, se_node_acl);
+        struct vhost_scsi_nacl *nacl = container_of(se_acl,
+                                struct vhost_scsi_nacl, se_node_acl);
         core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1);
         kfree(nacl);
 }
 
-static void tcm_vhost_free_cmd_map_res(struct tcm_vhost_nexus *nexus,
+static void vhost_scsi_free_cmd_map_res(struct vhost_scsi_nexus *nexus,
                                        struct se_session *se_sess)
 {
-        struct tcm_vhost_cmd *tv_cmd;
+        struct vhost_scsi_cmd *tv_cmd;
         unsigned int i;
 
         if (!se_sess->sess_cmd_map)
                 return;
 
-        for (i = 0; i < TCM_VHOST_DEFAULT_TAGS; i++) {
-                tv_cmd = &((struct tcm_vhost_cmd *)se_sess->sess_cmd_map)[i];
+        for (i = 0; i < VHOST_SCSI_DEFAULT_TAGS; i++) {
+                tv_cmd = &((struct vhost_scsi_cmd *)se_sess->sess_cmd_map)[i];
 
                 kfree(tv_cmd->tvc_sgl);
                 kfree(tv_cmd->tvc_prot_sgl);
@@ -1864,13 +1878,13 @@ static void tcm_vhost_free_cmd_map_res(struct tcm_vhost_nexus *nexus,
         }
 }
 
-static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
+static int vhost_scsi_make_nexus(struct vhost_scsi_tpg *tpg,
                                 const char *name)
 {
         struct se_portal_group *se_tpg;
         struct se_session *se_sess;
-        struct tcm_vhost_nexus *tv_nexus;
-        struct tcm_vhost_cmd *tv_cmd;
+        struct vhost_scsi_nexus *tv_nexus;
+        struct vhost_scsi_cmd *tv_cmd;
         unsigned int i;
 
         mutex_lock(&tpg->tv_tpg_mutex);
@@ -1881,19 +1895,19 @@ static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
         }
         se_tpg = &tpg->se_tpg;
 
-        tv_nexus = kzalloc(sizeof(struct tcm_vhost_nexus), GFP_KERNEL);
+        tv_nexus = kzalloc(sizeof(struct vhost_scsi_nexus), GFP_KERNEL);
         if (!tv_nexus) {
                 mutex_unlock(&tpg->tv_tpg_mutex);
-                pr_err("Unable to allocate struct tcm_vhost_nexus\n");
+                pr_err("Unable to allocate struct vhost_scsi_nexus\n");
                 return -ENOMEM;
         }
         /*
          *  Initialize the struct se_session pointer and setup tagpool
-         *  for struct tcm_vhost_cmd descriptors
+         *  for struct vhost_scsi_cmd descriptors
          */
         tv_nexus->tvn_se_sess = transport_init_session_tags(
-                                        TCM_VHOST_DEFAULT_TAGS,
-                                        sizeof(struct tcm_vhost_cmd),
+                                        VHOST_SCSI_DEFAULT_TAGS,
+                                        sizeof(struct vhost_scsi_cmd),
                                         TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS);
         if (IS_ERR(tv_nexus->tvn_se_sess)) {
                 mutex_unlock(&tpg->tv_tpg_mutex);
@@ -1901,11 +1915,11 @@ static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
                 return -ENOMEM;
         }
         se_sess = tv_nexus->tvn_se_sess;
-        for (i = 0; i < TCM_VHOST_DEFAULT_TAGS; i++) {
-                tv_cmd = &((struct tcm_vhost_cmd *)se_sess->sess_cmd_map)[i];
+        for (i = 0; i < VHOST_SCSI_DEFAULT_TAGS; i++) {
+                tv_cmd = &((struct vhost_scsi_cmd *)se_sess->sess_cmd_map)[i];
 
                 tv_cmd->tvc_sgl = kzalloc(sizeof(struct scatterlist) *
-                                        TCM_VHOST_PREALLOC_SGLS, GFP_KERNEL);
+                                        VHOST_SCSI_PREALLOC_SGLS, GFP_KERNEL);
                 if (!tv_cmd->tvc_sgl) {
                         mutex_unlock(&tpg->tv_tpg_mutex);
                         pr_err("Unable to allocate tv_cmd->tvc_sgl\n");
@@ -1913,7 +1927,7 @@ static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
                 }
 
                 tv_cmd->tvc_upages = kzalloc(sizeof(struct page *) *
-                                        TCM_VHOST_PREALLOC_UPAGES, GFP_KERNEL);
+                                        VHOST_SCSI_PREALLOC_UPAGES, GFP_KERNEL);
                 if (!tv_cmd->tvc_upages) {
                         mutex_unlock(&tpg->tv_tpg_mutex);
                         pr_err("Unable to allocate tv_cmd->tvc_upages\n");
@@ -1921,7 +1935,7 @@ static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
                 }
 
                 tv_cmd->tvc_prot_sgl = kzalloc(sizeof(struct scatterlist) *
-                                        TCM_VHOST_PREALLOC_PROT_SGLS, GFP_KERNEL);
+                                        VHOST_SCSI_PREALLOC_PROT_SGLS, GFP_KERNEL);
                 if (!tv_cmd->tvc_prot_sgl) {
                         mutex_unlock(&tpg->tv_tpg_mutex);
                         pr_err("Unable to allocate tv_cmd->tvc_prot_sgl\n");
@@ -1930,7 +1944,7 @@ static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
         }
         /*
          * Since we are running in 'demo mode' this call with generate a
-         * struct se_node_acl for the tcm_vhost struct se_portal_group with
+         * struct se_node_acl for the vhost_scsi struct se_portal_group with
          * the SCSI Initiator port name of the passed configfs group 'name'.
          */
         tv_nexus->tvn_se_sess->se_node_acl = core_tpg_check_initiator_node_acl(
@@ -1953,16 +1967,16 @@ static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
         return 0;
 
 out:
-        tcm_vhost_free_cmd_map_res(tv_nexus, se_sess);
+        vhost_scsi_free_cmd_map_res(tv_nexus, se_sess);
         transport_free_session(se_sess);
         kfree(tv_nexus);
         return -ENOMEM;
 }
 
-static int tcm_vhost_drop_nexus(struct tcm_vhost_tpg *tpg)
+static int vhost_scsi_drop_nexus(struct vhost_scsi_tpg *tpg)
 {
         struct se_session *se_sess;
-        struct tcm_vhost_nexus *tv_nexus;
+        struct vhost_scsi_nexus *tv_nexus;
 
         mutex_lock(&tpg->tv_tpg_mutex);
         tv_nexus = tpg->tpg_nexus;
@@ -1994,10 +2008,10 @@ static int tcm_vhost_drop_nexus(struct tcm_vhost_tpg *tpg)
         }
 
         pr_debug("TCM_vhost_ConfigFS: Removing I_T Nexus to emulated"
-                " %s Initiator Port: %s\n", tcm_vhost_dump_proto_id(tpg->tport),
+                " %s Initiator Port: %s\n", vhost_scsi_dump_proto_id(tpg->tport),
                 tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
 
-        tcm_vhost_free_cmd_map_res(tv_nexus, se_sess);
+        vhost_scsi_free_cmd_map_res(tv_nexus, se_sess);
         /*
          * Release the SCSI I_T Nexus to the emulated vhost Target Port
          */
@@ -2009,12 +2023,12 @@ static int tcm_vhost_drop_nexus(struct tcm_vhost_tpg *tpg)
         return 0;
 }
 
-static ssize_t tcm_vhost_tpg_show_nexus(struct se_portal_group *se_tpg,
+static ssize_t vhost_scsi_tpg_show_nexus(struct se_portal_group *se_tpg,
                                         char *page)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
-        struct tcm_vhost_nexus *tv_nexus;
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
+        struct vhost_scsi_nexus *tv_nexus;
         ssize_t ret;
 
         mutex_lock(&tpg->tv_tpg_mutex);
@@ -2030,40 +2044,40 @@ static ssize_t tcm_vhost_tpg_show_nexus(struct se_portal_group *se_tpg,
         return ret;
 }
 
-static ssize_t tcm_vhost_tpg_store_nexus(struct se_portal_group *se_tpg,
+static ssize_t vhost_scsi_tpg_store_nexus(struct se_portal_group *se_tpg,
                                          const char *page,
                                          size_t count)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
-        struct tcm_vhost_tport *tport_wwn = tpg->tport;
-        unsigned char i_port[TCM_VHOST_NAMELEN], *ptr, *port_ptr;
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
+        struct vhost_scsi_tport *tport_wwn = tpg->tport;
+        unsigned char i_port[VHOST_SCSI_NAMELEN], *ptr, *port_ptr;
         int ret;
         /*
          * Shutdown the active I_T nexus if 'NULL' is passed..
          */
         if (!strncmp(page, "NULL", 4)) {
-                ret = tcm_vhost_drop_nexus(tpg);
+                ret = vhost_scsi_drop_nexus(tpg);
                 return (!ret) ? count : ret;
         }
         /*
          * Otherwise make sure the passed virtual Initiator port WWN matches
-         * the fabric protocol_id set in tcm_vhost_make_tport(), and call
-         * tcm_vhost_make_nexus().
+         * the fabric protocol_id set in vhost_scsi_make_tport(), and call
+         * vhost_scsi_make_nexus().
          */
-        if (strlen(page) >= TCM_VHOST_NAMELEN) {
+        if (strlen(page) >= VHOST_SCSI_NAMELEN) {
                 pr_err("Emulated NAA Sas Address: %s, exceeds"
-                                " max: %d\n", page, TCM_VHOST_NAMELEN);
+                                " max: %d\n", page, VHOST_SCSI_NAMELEN);
                 return -EINVAL;
         }
-        snprintf(&i_port[0], TCM_VHOST_NAMELEN, "%s", page);
+        snprintf(&i_port[0], VHOST_SCSI_NAMELEN, "%s", page);
 
         ptr = strstr(i_port, "naa.");
         if (ptr) {
                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_SAS) {
                         pr_err("Passed SAS Initiator Port %s does not"
                                 " match target port protoid: %s\n", i_port,
-                                tcm_vhost_dump_proto_id(tport_wwn));
+                                vhost_scsi_dump_proto_id(tport_wwn));
                         return -EINVAL;
                 }
                 port_ptr = &i_port[0];
@@ -2074,7 +2088,7 @@ static ssize_t tcm_vhost_tpg_store_nexus(struct se_portal_group *se_tpg,
                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_FCP) {
                         pr_err("Passed FCP Initiator Port %s does not"
                                 " match target port protoid: %s\n", i_port,
-                                tcm_vhost_dump_proto_id(tport_wwn));
+                                vhost_scsi_dump_proto_id(tport_wwn));
                         return -EINVAL;
                 }
                 port_ptr = &i_port[3]; /* Skip over "fc." */
@@ -2085,7 +2099,7 @@ static ssize_t tcm_vhost_tpg_store_nexus(struct se_portal_group *se_tpg,
                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_ISCSI) {
                         pr_err("Passed iSCSI Initiator Port %s does not"
                                 " match target port protoid: %s\n", i_port,
-                                tcm_vhost_dump_proto_id(tport_wwn));
+                                vhost_scsi_dump_proto_id(tport_wwn));
                         return -EINVAL;
                 }
                 port_ptr = &i_port[0];
@@ -2101,40 +2115,40 @@ check_newline:
         if (i_port[strlen(i_port)-1] == '\n')
                 i_port[strlen(i_port)-1] = '\0';
 
-        ret = tcm_vhost_make_nexus(tpg, port_ptr);
+        ret = vhost_scsi_make_nexus(tpg, port_ptr);
         if (ret < 0)
                 return ret;
 
         return count;
 }
 
-TF_TPG_BASE_ATTR(tcm_vhost, nexus, S_IRUGO | S_IWUSR);
+TF_TPG_BASE_ATTR(vhost_scsi, nexus, S_IRUGO | S_IWUSR);
 
-static struct configfs_attribute *tcm_vhost_tpg_attrs[] = {
-        &tcm_vhost_tpg_nexus.attr,
+static struct configfs_attribute *vhost_scsi_tpg_attrs[] = {
+        &vhost_scsi_tpg_nexus.attr,
         NULL,
 };
 
 static struct se_portal_group *
-tcm_vhost_make_tpg(struct se_wwn *wwn,
+vhost_scsi_make_tpg(struct se_wwn *wwn,
                    struct config_group *group,
                    const char *name)
 {
-        struct tcm_vhost_tport *tport = container_of(wwn,
-                        struct tcm_vhost_tport, tport_wwn);
+        struct vhost_scsi_tport *tport = container_of(wwn,
+                        struct vhost_scsi_tport, tport_wwn);
 
-        struct tcm_vhost_tpg *tpg;
-        unsigned long tpgt;
+        struct vhost_scsi_tpg *tpg;
+        u16 tpgt;
         int ret;
 
         if (strstr(name, "tpgt_") != name)
                 return ERR_PTR(-EINVAL);
-        if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX)
+        if (kstrtou16(name + 5, 10, &tpgt) || tpgt >= VHOST_SCSI_MAX_TARGET)
                 return ERR_PTR(-EINVAL);
 
-        tpg = kzalloc(sizeof(struct tcm_vhost_tpg), GFP_KERNEL);
+        tpg = kzalloc(sizeof(struct vhost_scsi_tpg), GFP_KERNEL);
         if (!tpg) {
-                pr_err("Unable to allocate struct tcm_vhost_tpg");
+                pr_err("Unable to allocate struct vhost_scsi_tpg");
                 return ERR_PTR(-ENOMEM);
         }
         mutex_init(&tpg->tv_tpg_mutex);
@@ -2142,31 +2156,31 @@ tcm_vhost_make_tpg(struct se_wwn *wwn,
         tpg->tport = tport;
         tpg->tport_tpgt = tpgt;
 
-        ret = core_tpg_register(&tcm_vhost_fabric_configfs->tf_ops, wwn,
+        ret = core_tpg_register(&vhost_scsi_fabric_configfs->tf_ops, wwn,
                                 &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
         if (ret < 0) {
                 kfree(tpg);
                 return NULL;
         }
-        mutex_lock(&tcm_vhost_mutex);
-        list_add_tail(&tpg->tv_tpg_list, &tcm_vhost_list);
-        mutex_unlock(&tcm_vhost_mutex);
+        mutex_lock(&vhost_scsi_mutex);
+        list_add_tail(&tpg->tv_tpg_list, &vhost_scsi_list);
+        mutex_unlock(&vhost_scsi_mutex);
 
         return &tpg->se_tpg;
 }
 
-static void tcm_vhost_drop_tpg(struct se_portal_group *se_tpg)
+static void vhost_scsi_drop_tpg(struct se_portal_group *se_tpg)
 {
-        struct tcm_vhost_tpg *tpg = container_of(se_tpg,
-                                struct tcm_vhost_tpg, se_tpg);
+        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
+                                struct vhost_scsi_tpg, se_tpg);
 
-        mutex_lock(&tcm_vhost_mutex);
+        mutex_lock(&vhost_scsi_mutex);
         list_del(&tpg->tv_tpg_list);
-        mutex_unlock(&tcm_vhost_mutex);
+        mutex_unlock(&vhost_scsi_mutex);
         /*
          * Release the virtual I_T Nexus for this vhost TPG
          */
-        tcm_vhost_drop_nexus(tpg);
+        vhost_scsi_drop_nexus(tpg);
         /*
          * Deregister the se_tpg from TCM..
          */
@@ -2175,21 +2189,21 @@ static void tcm_vhost_drop_tpg(struct se_portal_group *se_tpg)
 }
 
 static struct se_wwn *
-tcm_vhost_make_tport(struct target_fabric_configfs *tf,
+vhost_scsi_make_tport(struct target_fabric_configfs *tf,
                      struct config_group *group,
                      const char *name)
 {
-        struct tcm_vhost_tport *tport;
+        struct vhost_scsi_tport *tport;
         char *ptr;
         u64 wwpn = 0;
         int off = 0;
 
-        /* if (tcm_vhost_parse_wwn(name, &wwpn, 1) < 0)
+        /* if (vhost_scsi_parse_wwn(name, &wwpn, 1) < 0)
                 return ERR_PTR(-EINVAL); */
 
-        tport = kzalloc(sizeof(struct tcm_vhost_tport), GFP_KERNEL);
+        tport = kzalloc(sizeof(struct vhost_scsi_tport), GFP_KERNEL);
         if (!tport) {
-                pr_err("Unable to allocate struct tcm_vhost_tport");
+                pr_err("Unable to allocate struct vhost_scsi_tport");
                 return ERR_PTR(-ENOMEM);
         }
         tport->tport_wwpn = wwpn;
@@ -2220,102 +2234,102 @@ tcm_vhost_make_tport(struct target_fabric_configfs *tf,
         return ERR_PTR(-EINVAL);
 
 check_len:
-        if (strlen(name) >= TCM_VHOST_NAMELEN) {
+        if (strlen(name) >= VHOST_SCSI_NAMELEN) {
                 pr_err("Emulated %s Address: %s, exceeds"
-                        " max: %d\n", name, tcm_vhost_dump_proto_id(tport),
-                        TCM_VHOST_NAMELEN);
+                        " max: %d\n", name, vhost_scsi_dump_proto_id(tport),
+                        VHOST_SCSI_NAMELEN);
                 kfree(tport);
                 return ERR_PTR(-EINVAL);
         }
-        snprintf(&tport->tport_name[0], TCM_VHOST_NAMELEN, "%s", &name[off]);
+        snprintf(&tport->tport_name[0], VHOST_SCSI_NAMELEN, "%s", &name[off]);
 
         pr_debug("TCM_VHost_ConfigFS: Allocated emulated Target"
-                " %s Address: %s\n", tcm_vhost_dump_proto_id(tport), name);
+                " %s Address: %s\n", vhost_scsi_dump_proto_id(tport), name);
 
         return &tport->tport_wwn;
 }
 
-static void tcm_vhost_drop_tport(struct se_wwn *wwn)
+static void vhost_scsi_drop_tport(struct se_wwn *wwn)
 {
-        struct tcm_vhost_tport *tport = container_of(wwn,
-                                struct tcm_vhost_tport, tport_wwn);
+        struct vhost_scsi_tport *tport = container_of(wwn,
+                                struct vhost_scsi_tport, tport_wwn);
 
         pr_debug("TCM_VHost_ConfigFS: Deallocating emulated Target"
-                " %s Address: %s\n", tcm_vhost_dump_proto_id(tport),
+                " %s Address: %s\n", vhost_scsi_dump_proto_id(tport),
                 tport->tport_name);
 
         kfree(tport);
 }
 
 static ssize_t
-tcm_vhost_wwn_show_attr_version(struct target_fabric_configfs *tf,
+vhost_scsi_wwn_show_attr_version(struct target_fabric_configfs *tf,
                                 char *page)
 {
         return sprintf(page, "TCM_VHOST fabric module %s on %s/%s"
-                "on "UTS_RELEASE"\n", TCM_VHOST_VERSION, utsname()->sysname,
+                "on "UTS_RELEASE"\n", VHOST_SCSI_VERSION, utsname()->sysname,
                 utsname()->machine);
 }
 
-TF_WWN_ATTR_RO(tcm_vhost, version);
+TF_WWN_ATTR_RO(vhost_scsi, version);
 
-static struct configfs_attribute *tcm_vhost_wwn_attrs[] = {
-        &tcm_vhost_wwn_version.attr,
+static struct configfs_attribute *vhost_scsi_wwn_attrs[] = {
+        &vhost_scsi_wwn_version.attr,
         NULL,
 };
 
-static struct target_core_fabric_ops tcm_vhost_ops = {
-        .get_fabric_name                = tcm_vhost_get_fabric_name,
-        .get_fabric_proto_ident         = tcm_vhost_get_fabric_proto_ident,
-        .tpg_get_wwn                    = tcm_vhost_get_fabric_wwn,
-        .tpg_get_tag                    = tcm_vhost_get_tag,
-        .tpg_get_default_depth          = tcm_vhost_get_default_depth,
-        .tpg_get_pr_transport_id        = tcm_vhost_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = tcm_vhost_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = tcm_vhost_parse_pr_out_transport_id,
-        .tpg_check_demo_mode            = tcm_vhost_check_true,
-        .tpg_check_demo_mode_cache      = tcm_vhost_check_true,
-        .tpg_check_demo_mode_write_protect = tcm_vhost_check_false,
-        .tpg_check_prod_mode_write_protect = tcm_vhost_check_false,
-        .tpg_alloc_fabric_acl           = tcm_vhost_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = tcm_vhost_release_fabric_acl,
-        .tpg_get_inst_index             = tcm_vhost_tpg_get_inst_index,
-        .release_cmd                    = tcm_vhost_release_cmd,
+static struct target_core_fabric_ops vhost_scsi_ops = {
+        .get_fabric_name                = vhost_scsi_get_fabric_name,
+        .get_fabric_proto_ident         = vhost_scsi_get_fabric_proto_ident,
+        .tpg_get_wwn                    = vhost_scsi_get_fabric_wwn,
+        .tpg_get_tag                    = vhost_scsi_get_tpgt,
+        .tpg_get_default_depth          = vhost_scsi_get_default_depth,
+        .tpg_get_pr_transport_id        = vhost_scsi_get_pr_transport_id,
+        .tpg_get_pr_transport_id_len    = vhost_scsi_get_pr_transport_id_len,
+        .tpg_parse_pr_out_transport_id  = vhost_scsi_parse_pr_out_transport_id,
+        .tpg_check_demo_mode            = vhost_scsi_check_true,
+        .tpg_check_demo_mode_cache      = vhost_scsi_check_true,
+        .tpg_check_demo_mode_write_protect = vhost_scsi_check_false,
+        .tpg_check_prod_mode_write_protect = vhost_scsi_check_false,
+        .tpg_alloc_fabric_acl           = vhost_scsi_alloc_fabric_acl,
+        .tpg_release_fabric_acl         = vhost_scsi_release_fabric_acl,
+        .tpg_get_inst_index             = vhost_scsi_tpg_get_inst_index,
+        .release_cmd                    = vhost_scsi_release_cmd,
         .check_stop_free                = vhost_scsi_check_stop_free,
-        .shutdown_session               = tcm_vhost_shutdown_session,
-        .close_session                  = tcm_vhost_close_session,
-        .sess_get_index                 = tcm_vhost_sess_get_index,
+        .shutdown_session               = vhost_scsi_shutdown_session,
+        .close_session                  = vhost_scsi_close_session,
+        .sess_get_index                 = vhost_scsi_sess_get_index,
         .sess_get_initiator_sid         = NULL,
-        .write_pending                  = tcm_vhost_write_pending,
-        .write_pending_status           = tcm_vhost_write_pending_status,
-        .set_default_node_attributes    = tcm_vhost_set_default_node_attrs,
-        .get_task_tag                   = tcm_vhost_get_task_tag,
-        .get_cmd_state                  = tcm_vhost_get_cmd_state,
-        .queue_data_in                  = tcm_vhost_queue_data_in,
-        .queue_status                   = tcm_vhost_queue_status,
-        .queue_tm_rsp                   = tcm_vhost_queue_tm_rsp,
-        .aborted_task                   = tcm_vhost_aborted_task,
+        .write_pending                  = vhost_scsi_write_pending,
+        .write_pending_status           = vhost_scsi_write_pending_status,
+        .set_default_node_attributes    = vhost_scsi_set_default_node_attrs,
+        .get_task_tag                   = vhost_scsi_get_task_tag,
+        .get_cmd_state                  = vhost_scsi_get_cmd_state,
+        .queue_data_in                  = vhost_scsi_queue_data_in,
+        .queue_status                   = vhost_scsi_queue_status,
+        .queue_tm_rsp                   = vhost_scsi_queue_tm_rsp,
+        .aborted_task                   = vhost_scsi_aborted_task,
         /*
          * Setup callers for generic logic in target_core_fabric_configfs.c
          */
-        .fabric_make_wwn                = tcm_vhost_make_tport,
-        .fabric_drop_wwn                = tcm_vhost_drop_tport,
-        .fabric_make_tpg                = tcm_vhost_make_tpg,
-        .fabric_drop_tpg                = tcm_vhost_drop_tpg,
-        .fabric_post_link               = tcm_vhost_port_link,
-        .fabric_pre_unlink              = tcm_vhost_port_unlink,
+        .fabric_make_wwn                = vhost_scsi_make_tport,
+        .fabric_drop_wwn                = vhost_scsi_drop_tport,
+        .fabric_make_tpg                = vhost_scsi_make_tpg,
+        .fabric_drop_tpg                = vhost_scsi_drop_tpg,
+        .fabric_post_link               = vhost_scsi_port_link,
+        .fabric_pre_unlink              = vhost_scsi_port_unlink,
         .fabric_make_np                 = NULL,
         .fabric_drop_np                 = NULL,
-        .fabric_make_nodeacl            = tcm_vhost_make_nodeacl,
-        .fabric_drop_nodeacl            = tcm_vhost_drop_nodeacl,
+        .fabric_make_nodeacl            = vhost_scsi_make_nodeacl,
+        .fabric_drop_nodeacl            = vhost_scsi_drop_nodeacl,
 };
 
-static int tcm_vhost_register_configfs(void)
+static int vhost_scsi_register_configfs(void)
 {
         struct target_fabric_configfs *fabric;
         int ret;
 
-        pr_debug("TCM_VHOST fabric module %s on %s/%s"
-                " on "UTS_RELEASE"\n", TCM_VHOST_VERSION, utsname()->sysname,
+        pr_debug("vhost-scsi fabric module %s on %s/%s"
+                " on "UTS_RELEASE"\n", VHOST_SCSI_VERSION, utsname()->sysname,
                 utsname()->machine);
         /*
          * Register the top level struct config_item_type with TCM core
@@ -2326,14 +2340,14 @@ static int tcm_vhost_register_configfs(void)
                 return PTR_ERR(fabric);
         }
         /*
-         * Setup fabric->tf_ops from our local tcm_vhost_ops
+         * Setup fabric->tf_ops from our local vhost_scsi_ops
          */
-        fabric->tf_ops = tcm_vhost_ops;
+        fabric->tf_ops = vhost_scsi_ops;
         /*
          * Setup default attribute lists for various fabric->tf_cit_tmpl
          */
-        fabric->tf_cit_tmpl.tfc_wwn_cit.ct_attrs = tcm_vhost_wwn_attrs;
-        fabric->tf_cit_tmpl.tfc_tpg_base_cit.ct_attrs = tcm_vhost_tpg_attrs;
+        fabric->tf_cit_tmpl.tfc_wwn_cit.ct_attrs = vhost_scsi_wwn_attrs;
+        fabric->tf_cit_tmpl.tfc_tpg_base_cit.ct_attrs = vhost_scsi_tpg_attrs;
         fabric->tf_cit_tmpl.tfc_tpg_attrib_cit.ct_attrs = NULL;
         fabric->tf_cit_tmpl.tfc_tpg_param_cit.ct_attrs = NULL;
         fabric->tf_cit_tmpl.tfc_tpg_np_base_cit.ct_attrs = NULL;
@@ -2353,37 +2367,37 @@ static int tcm_vhost_register_configfs(void)
         /*
          * Setup our local pointer to *fabric
          */
-        tcm_vhost_fabric_configfs = fabric;
-        pr_debug("TCM_VHOST[0] - Set fabric -> tcm_vhost_fabric_configfs\n");
+        vhost_scsi_fabric_configfs = fabric;
+        pr_debug("TCM_VHOST[0] - Set fabric -> vhost_scsi_fabric_configfs\n");
         return 0;
 };
 
-static void tcm_vhost_deregister_configfs(void)
+static void vhost_scsi_deregister_configfs(void)
 {
-        if (!tcm_vhost_fabric_configfs)
+        if (!vhost_scsi_fabric_configfs)
                 return;
 
-        target_fabric_configfs_deregister(tcm_vhost_fabric_configfs);
-        tcm_vhost_fabric_configfs = NULL;
-        pr_debug("TCM_VHOST[0] - Cleared tcm_vhost_fabric_configfs\n");
+        target_fabric_configfs_deregister(vhost_scsi_fabric_configfs);
+        vhost_scsi_fabric_configfs = NULL;
+        pr_debug("TCM_VHOST[0] - Cleared vhost_scsi_fabric_configfs\n");
 };
 
-static int __init tcm_vhost_init(void)
+static int __init vhost_scsi_init(void)
 {
         int ret = -ENOMEM;
         /*
          * Use our own dedicated workqueue for submitting I/O into
          * target core to avoid contention within system_wq.
          */
-        tcm_vhost_workqueue = alloc_workqueue("tcm_vhost", 0, 0);
-        if (!tcm_vhost_workqueue)
+        vhost_scsi_workqueue = alloc_workqueue("vhost_scsi", 0, 0);
+        if (!vhost_scsi_workqueue)
                 goto out;
 
         ret = vhost_scsi_register();
         if (ret < 0)
                 goto out_destroy_workqueue;
 
-        ret = tcm_vhost_register_configfs();
+        ret = vhost_scsi_register_configfs();
         if (ret < 0)
                 goto out_vhost_scsi_deregister;
 
@@ -2392,20 +2406,20 @@ static int __init tcm_vhost_init(void)
 out_vhost_scsi_deregister:
         vhost_scsi_deregister();
 out_destroy_workqueue:
-        destroy_workqueue(tcm_vhost_workqueue);
+        destroy_workqueue(vhost_scsi_workqueue);
 out:
         return ret;
 };
 
-static void tcm_vhost_exit(void)
+static void vhost_scsi_exit(void)
 {
-        tcm_vhost_deregister_configfs();
+        vhost_scsi_deregister_configfs();
         vhost_scsi_deregister();
-        destroy_workqueue(tcm_vhost_workqueue);
+        destroy_workqueue(vhost_scsi_workqueue);
 };
 
 MODULE_DESCRIPTION("VHOST_SCSI series fabric driver");
 MODULE_ALIAS("tcm_vhost");
 MODULE_LICENSE("GPL");
-module_init(tcm_vhost_init);
-module_exit(tcm_vhost_exit);
+module_init(vhost_scsi_init);
+module_exit(vhost_scsi_exit);
diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
index 00b228638274..b546da5d8ea3 100644
--- a/drivers/virtio/Kconfig
+++ b/drivers/virtio/Kconfig
@@ -12,16 +12,32 @@ config VIRTIO_PCI
         depends on PCI
         select VIRTIO
         ---help---
-          This drivers provides support for virtio based paravirtual device
+          This driver provides support for virtio based paravirtual device
           drivers over PCI.  This requires that your VMM has appropriate PCI
           virtio backends.  Most QEMU based VMMs should support these devices
           (like KVM or Xen).
 
-          Currently, the ABI is not considered stable so there is no guarantee
-          that this version of the driver will work with your VMM.
-
           If unsure, say M.
 
+config VIRTIO_PCI_LEGACY
+        bool "Support for legacy virtio draft 0.9.X and older devices"
+        default y
+        depends on VIRTIO_PCI
+        ---help---
+          Virtio PCI Card 0.9.X Draft (circa 2014) and older device support.
+
+          This option enables building a transitional driver, supporting
+          both devices conforming to Virtio 1 specification, and legacy devices.
+          If disabled, you get a slightly smaller, non-transitional driver,
+          with no legacy compatibility.
+
+          So look out into your driveway.  Do you have a flying car?  If
+          so, you can happily disable this option and virtio will not
+          break.  Otherwise, leave it set.  Unless you're testing what
+          life will be like in The Future.
+
+          If unsure, say Y.
+
 config VIRTIO_BALLOON
         tristate "Virtio balloon driver"
         depends on VIRTIO
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index bf5104b56894..d85565b8ea46 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -1,5 +1,6 @@
 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
+virtio_pci-y := virtio_pci_modern.o virtio_pci_common.o
+virtio_pci-$(CONFIG_VIRTIO_PCI_LEGACY) += virtio_pci_legacy.o
 obj-$(CONFIG_VIRTIO_BALLOON) += virtio_balloon.o
diff --git a/drivers/virtio/virtio.c b/drivers/virtio/virtio.c
index b9f70dfc4751..5ce2aa48fc6e 100644
--- a/drivers/virtio/virtio.c
+++ b/drivers/virtio/virtio.c
@@ -236,7 +236,10 @@ static int virtio_dev_probe(struct device *_d)
         if (err)
                 goto err;
 
-        add_status(dev, VIRTIO_CONFIG_S_DRIVER_OK);
+        /* If probe didn't do it, mark device DRIVER_OK ourselves. */
+        if (!(dev->config->get_status(dev) & VIRTIO_CONFIG_S_DRIVER_OK))
+                virtio_device_ready(dev);
+
         if (drv->scan)
                 drv->scan(dev);
 
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index 50c5f42d7a9f..0413157f3b49 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -44,8 +44,7 @@ static int oom_pages = OOM_VBALLOON_DEFAULT_PAGES;
 module_param(oom_pages, int, S_IRUSR | S_IWUSR);
 MODULE_PARM_DESC(oom_pages, "pages to free on OOM");
 
-struct virtio_balloon
-{
+struct virtio_balloon {
         struct virtio_device *vdev;
         struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
 
@@ -466,6 +465,12 @@ static int virtballoon_probe(struct virtio_device *vdev)
         struct virtio_balloon *vb;
         int err;
 
+        if (!vdev->config->get) {
+                dev_err(&vdev->dev, "%s failure: config access disabled\n",
+                        __func__);
+                return -EINVAL;
+        }
+
         vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL);
         if (!vb) {
                 err = -ENOMEM;
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
index 00d115b22bd8..cad569890908 100644
--- a/drivers/virtio/virtio_mmio.c
+++ b/drivers/virtio/virtio_mmio.c
@@ -1,7 +1,7 @@
 /*
  * Virtio memory mapped device driver
  *
- * Copyright 2011, ARM Ltd.
+ * Copyright 2011-2014, ARM Ltd.
  *
  * This module allows virtio devices to be used over a virtual, memory mapped
  * platform device.
@@ -50,36 +50,6 @@
  *
  *
  *
- * Registers layout (all 32-bit wide):
- *
- * offset d. name             description
- * ------ -- ---------------- -----------------
- *
- * 0x000  R  MagicValue       Magic value "virt"
- * 0x004  R  Version          Device version (current max. 1)
- * 0x008  R  DeviceID         Virtio device ID
- * 0x00c  R  VendorID         Virtio vendor ID
- *
- * 0x010  R  HostFeatures     Features supported by the host
- * 0x014  W  HostFeaturesSel  Set of host features to access via HostFeatures
- *
- * 0x020  W  GuestFeatures    Features activated by the guest
- * 0x024  W  GuestFeaturesSel Set of activated features to set via GuestFeatures
- * 0x028  W  GuestPageSize    Size of guest's memory page in bytes
- *
- * 0x030  W  QueueSel         Queue selector
- * 0x034  R  QueueNumMax      Maximum size of the currently selected queue
- * 0x038  W  QueueNum         Queue size for the currently selected queue
- * 0x03c  W  QueueAlign       Used Ring alignment for the current queue
- * 0x040  RW QueuePFN         PFN for the currently selected queue
- *
- * 0x050  W  QueueNotify      Queue notifier
- * 0x060  R  InterruptStatus  Interrupt status register
- * 0x064  W  InterruptACK     Interrupt acknowledge register
- * 0x070  RW Status           Device status register
- *
- * 0x100+ RW                  Device-specific configuration space
- *
  * Based on Virtio PCI driver by Anthony Liguori, copyright IBM Corp. 2007
  *
  * This work is licensed under the terms of the GNU GPL, version 2 or later.
@@ -145,11 +115,16 @@ struct virtio_mmio_vq_info {
 static u64 vm_get_features(struct virtio_device *vdev)
 {
         struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
+        u64 features;
+
+        writel(1, vm_dev->base + VIRTIO_MMIO_DEVICE_FEATURES_SEL);
+        features = readl(vm_dev->base + VIRTIO_MMIO_DEVICE_FEATURES);
+        features <<= 32;
 
-        /* TODO: Features > 32 bits */
-        writel(0, vm_dev->base + VIRTIO_MMIO_HOST_FEATURES_SEL);
+        writel(0, vm_dev->base + VIRTIO_MMIO_DEVICE_FEATURES_SEL);
+        features |= readl(vm_dev->base + VIRTIO_MMIO_DEVICE_FEATURES);
 
-        return readl(vm_dev->base + VIRTIO_MMIO_HOST_FEATURES);
+        return features;
 }
 
 static int vm_finalize_features(struct virtio_device *vdev)
@@ -159,11 +134,20 @@ static int vm_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);
+        /* Make sure there is are no mixed devices */
+        if (vm_dev->version == 2 &&
+                        !__virtio_test_bit(vdev, VIRTIO_F_VERSION_1)) {
+                dev_err(&vdev->dev, "New virtio-mmio devices (version 2) must provide VIRTIO_F_VERSION_1 feature!\n");
+                return -EINVAL;
+        }
+
+        writel(1, vm_dev->base + VIRTIO_MMIO_DRIVER_FEATURES_SEL);
+        writel((u32)(vdev->features >> 32),
+                        vm_dev->base + VIRTIO_MMIO_DRIVER_FEATURES);
 
-        writel(0, vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES_SEL);
-        writel(vdev->features, vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES);
+        writel(0, vm_dev->base + VIRTIO_MMIO_DRIVER_FEATURES_SEL);
+        writel((u32)vdev->features,
+                        vm_dev->base + VIRTIO_MMIO_DRIVER_FEATURES);
 
         return 0;
 }
@@ -275,7 +259,12 @@ static void vm_del_vq(struct virtqueue *vq)
 
         /* Select and deactivate the queue */
         writel(index, vm_dev->base + VIRTIO_MMIO_QUEUE_SEL);
-        writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
+        if (vm_dev->version == 1) {
+                writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
+        } else {
+                writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_READY);
+                WARN_ON(readl(vm_dev->base + VIRTIO_MMIO_QUEUE_READY));
+        }
 
         size = PAGE_ALIGN(vring_size(info->num, VIRTIO_MMIO_VRING_ALIGN));
         free_pages_exact(info->queue, size);
@@ -312,7 +301,8 @@ static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned index,
         writel(index, vm_dev->base + VIRTIO_MMIO_QUEUE_SEL);
 
         /* Queue shouldn't already be set up. */
-        if (readl(vm_dev->base + VIRTIO_MMIO_QUEUE_PFN)) {
+        if (readl(vm_dev->base + (vm_dev->version == 1 ?
+                        VIRTIO_MMIO_QUEUE_PFN : VIRTIO_MMIO_QUEUE_READY))) {
                 err = -ENOENT;
                 goto error_available;
         }
@@ -356,13 +346,6 @@ static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned index,
                 info->num /= 2;
         }
 
-        /* Activate the queue */
-        writel(info->num, vm_dev->base + VIRTIO_MMIO_QUEUE_NUM);
-        writel(VIRTIO_MMIO_VRING_ALIGN,
-                        vm_dev->base + VIRTIO_MMIO_QUEUE_ALIGN);
-        writel(virt_to_phys(info->queue) >> PAGE_SHIFT,
-                        vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
-
         /* Create the vring */
         vq = vring_new_virtqueue(index, info->num, VIRTIO_MMIO_VRING_ALIGN, vdev,
                                  true, info->queue, vm_notify, callback, name);
@@ -371,6 +354,33 @@ static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned index,
                 goto error_new_virtqueue;
         }
 
+        /* Activate the queue */
+        writel(info->num, vm_dev->base + VIRTIO_MMIO_QUEUE_NUM);
+        if (vm_dev->version == 1) {
+                writel(PAGE_SIZE, vm_dev->base + VIRTIO_MMIO_QUEUE_ALIGN);
+                writel(virt_to_phys(info->queue) >> PAGE_SHIFT,
+                                vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
+        } else {
+                u64 addr;
+
+                addr = virt_to_phys(info->queue);
+                writel((u32)addr, vm_dev->base + VIRTIO_MMIO_QUEUE_DESC_LOW);
+                writel((u32)(addr >> 32),
+                                vm_dev->base + VIRTIO_MMIO_QUEUE_DESC_HIGH);
+
+                addr = virt_to_phys(virtqueue_get_avail(vq));
+                writel((u32)addr, vm_dev->base + VIRTIO_MMIO_QUEUE_AVAIL_LOW);
+                writel((u32)(addr >> 32),
+                                vm_dev->base + VIRTIO_MMIO_QUEUE_AVAIL_HIGH);
+
+                addr = virt_to_phys(virtqueue_get_used(vq));
+                writel((u32)addr, vm_dev->base + VIRTIO_MMIO_QUEUE_USED_LOW);
+                writel((u32)(addr >> 32),
+                                vm_dev->base + VIRTIO_MMIO_QUEUE_USED_HIGH);
+
+                writel(1, vm_dev->base + VIRTIO_MMIO_QUEUE_READY);
+        }
+
         vq->priv = info;
         info->vq = vq;
 
@@ -381,7 +391,12 @@ static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned index,
         return vq;
 
 error_new_virtqueue:
-        writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
+        if (vm_dev->version == 1) {
+                writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
+        } else {
+                writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_READY);
+                WARN_ON(readl(vm_dev->base + VIRTIO_MMIO_QUEUE_READY));
+        }
         free_pages_exact(info->queue, size);
 error_alloc_pages:
         kfree(info);
@@ -476,16 +491,32 @@ static int virtio_mmio_probe(struct platform_device *pdev)
 
         /* Check device version */
         vm_dev->version = readl(vm_dev->base + VIRTIO_MMIO_VERSION);
-        if (vm_dev->version != 1) {
+        if (vm_dev->version < 1 || vm_dev->version > 2) {
                 dev_err(&pdev->dev, "Version %ld not supported!\n",
                                 vm_dev->version);
                 return -ENXIO;
         }
 
         vm_dev->vdev.id.device = readl(vm_dev->base + VIRTIO_MMIO_DEVICE_ID);
+        if (vm_dev->vdev.id.device == 0) {
+                /*
+                 * virtio-mmio device with an ID 0 is a (dummy) placeholder
+                 * with no function. End probing now with no error reported.
+                 */
+                return -ENODEV;
+        }
         vm_dev->vdev.id.vendor = readl(vm_dev->base + VIRTIO_MMIO_VENDOR_ID);
 
-        writel(PAGE_SIZE, vm_dev->base + VIRTIO_MMIO_GUEST_PAGE_SIZE);
+        /* Reject legacy-only IDs for version 2 devices */
+        if (vm_dev->version == 2 &&
+                        virtio_device_is_legacy_only(vm_dev->vdev.id)) {
+                dev_err(&pdev->dev, "Version 2 not supported for devices %u!\n",
+                                vm_dev->vdev.id.device);
+                return -ENODEV;
+        }
+
+        if (vm_dev->version == 1)
+                writel(PAGE_SIZE, vm_dev->base + VIRTIO_MMIO_GUEST_PAGE_SIZE);
 
         platform_set_drvdata(pdev, vm_dev);
 
diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
index 9756f21b809e..e894eb278d83 100644
--- a/drivers/virtio/virtio_pci_common.c
+++ b/drivers/virtio/virtio_pci_common.c
@@ -19,6 +19,14 @@
 
 #include "virtio_pci_common.h"
 
+static bool force_legacy = false;
+
+#if IS_ENABLED(CONFIG_VIRTIO_PCI_LEGACY)
+module_param(force_legacy, bool, 0444);
+MODULE_PARM_DESC(force_legacy,
+                 "Force legacy mode for transitional virtio 1 devices");
+#endif
+
 /* wait for pending irq handlers */
 void vp_synchronize_vectors(struct virtio_device *vdev)
 {
@@ -464,15 +472,97 @@ static const struct pci_device_id virtio_pci_id_table[] = {
 
 MODULE_DEVICE_TABLE(pci, virtio_pci_id_table);
 
+static void virtio_pci_release_dev(struct device *_d)
+{
+        struct virtio_device *vdev = dev_to_virtio(_d);
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+
+        /* As struct device is a kobject, it's not safe to
+         * free the memory (including the reference counter itself)
+         * until it's release callback. */
+        kfree(vp_dev);
+}
+
 static int virtio_pci_probe(struct pci_dev *pci_dev,
                             const struct pci_device_id *id)
 {
-        return virtio_pci_legacy_probe(pci_dev, id);
+        struct virtio_pci_device *vp_dev;
+        int rc;
+
+        /* allocate our structure and fill it out */
+        vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL);
+        if (!vp_dev)
+                return -ENOMEM;
+
+        pci_set_drvdata(pci_dev, vp_dev);
+        vp_dev->vdev.dev.parent = &pci_dev->dev;
+        vp_dev->vdev.dev.release = virtio_pci_release_dev;
+        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 */
+        rc = pci_enable_device(pci_dev);
+        if (rc)
+                goto err_enable_device;
+
+        rc = pci_request_regions(pci_dev, "virtio-pci");
+        if (rc)
+                goto err_request_regions;
+
+        if (force_legacy) {
+                rc = virtio_pci_legacy_probe(vp_dev);
+                /* Also try modern mode if we can't map BAR0 (no IO space). */
+                if (rc == -ENODEV || rc == -ENOMEM)
+                        rc = virtio_pci_modern_probe(vp_dev);
+                if (rc)
+                        goto err_probe;
+        } else {
+                rc = virtio_pci_modern_probe(vp_dev);
+                if (rc == -ENODEV)
+                        rc = virtio_pci_legacy_probe(vp_dev);
+                if (rc)
+                        goto err_probe;
+        }
+
+        pci_set_master(pci_dev);
+
+        rc = register_virtio_device(&vp_dev->vdev);
+        if (rc)
+                goto err_register;
+
+        return 0;
+
+err_register:
+        if (vp_dev->ioaddr)
+             virtio_pci_legacy_remove(vp_dev);
+        else
+             virtio_pci_modern_remove(vp_dev);
+err_probe:
+        pci_release_regions(pci_dev);
+err_request_regions:
+        pci_disable_device(pci_dev);
+err_enable_device:
+        kfree(vp_dev);
+        return rc;
 }
 
 static void virtio_pci_remove(struct pci_dev *pci_dev)
 {
-     virtio_pci_legacy_remove(pci_dev);
+        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
+
+        unregister_virtio_device(&vp_dev->vdev);
+
+        if (vp_dev->ioaddr)
+                virtio_pci_legacy_remove(vp_dev);
+        else
+                virtio_pci_modern_remove(vp_dev);
+
+        pci_release_regions(pci_dev);
+        pci_disable_device(pci_dev);
 }
 
 static struct pci_driver virtio_pci_driver = {
diff --git a/drivers/virtio/virtio_pci_common.h b/drivers/virtio/virtio_pci_common.h
index 5a497289b7e9..28ee4e56badf 100644
--- a/drivers/virtio/virtio_pci_common.h
+++ b/drivers/virtio/virtio_pci_common.h
@@ -53,12 +53,32 @@ struct virtio_pci_device {
         struct virtio_device vdev;
         struct pci_dev *pci_dev;
 
+        /* In legacy mode, these two point to within ->legacy. */
+        /* Where to read and clear interrupt */
+        u8 __iomem *isr;
+
+        /* Modern only fields */
+        /* The IO mapping for the PCI config space (non-legacy mode) */
+        struct virtio_pci_common_cfg __iomem *common;
+        /* Device-specific data (non-legacy mode)  */
+        void __iomem *device;
+        /* Base of vq notifications (non-legacy mode). */
+        void __iomem *notify_base;
+
+        /* So we can sanity-check accesses. */
+        size_t notify_len;
+        size_t device_len;
+
+        /* Capability for when we need to map notifications per-vq. */
+        int notify_map_cap;
+
+        /* Multiply queue_notify_off by this value. (non-legacy mode). */
+        u32 notify_offset_multiplier;
+
+        /* Legacy only field */
         /* 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;
@@ -127,8 +147,19 @@ const char *vp_bus_name(struct virtio_device *vdev);
  */
 int vp_set_vq_affinity(struct virtqueue *vq, int cpu);
 
-int virtio_pci_legacy_probe(struct pci_dev *pci_dev,
-                            const struct pci_device_id *id);
-void virtio_pci_legacy_remove(struct pci_dev *pci_dev);
+#if IS_ENABLED(CONFIG_VIRTIO_PCI_LEGACY)
+int virtio_pci_legacy_probe(struct virtio_pci_device *);
+void virtio_pci_legacy_remove(struct virtio_pci_device *);
+#else
+static inline int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev)
+{
+        return -ENODEV;
+}
+static inline void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev)
+{
+}
+#endif
+int virtio_pci_modern_probe(struct virtio_pci_device *);
+void virtio_pci_modern_remove(struct virtio_pci_device *);
 
 #endif
diff --git a/drivers/virtio/virtio_pci_legacy.c b/drivers/virtio/virtio_pci_legacy.c
index a5486e65e04b..256a5278a515 100644
--- a/drivers/virtio/virtio_pci_legacy.c
+++ b/drivers/virtio/virtio_pci_legacy.c
@@ -211,23 +211,10 @@ static const struct virtio_config_ops virtio_pci_config_ops = {
         .set_vq_affinity = vp_set_vq_affinity,
 };
 
-static void virtio_pci_release_dev(struct device *_d)
-{
-        struct virtio_device *vdev = dev_to_virtio(_d);
-        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-
-        /* As struct device is a kobject, it's not safe to
-         * free the memory (including the reference counter itself)
-         * until it's release callback. */
-        kfree(vp_dev);
-}
-
 /* the PCI probing function */
-int virtio_pci_legacy_probe(struct pci_dev *pci_dev,
-                            const struct pci_device_id *id)
+int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev)
 {
-        struct virtio_pci_device *vp_dev;
-        int err;
+        struct pci_dev *pci_dev = vp_dev->pci_dev;
 
         /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */
         if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f)
@@ -239,41 +226,12 @@ int virtio_pci_legacy_probe(struct pci_dev *pci_dev,
                 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;
-        }
+        if (!vp_dev->ioaddr)
+                return -ENOMEM;
 
         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
@@ -281,36 +239,18 @@ int virtio_pci_legacy_probe(struct pci_dev *pci_dev,
         vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor;
         vp_dev->vdev.id.device = pci_dev->subsystem_device;
 
+        vp_dev->vdev.config = &virtio_pci_config_ops;
+
         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;
 }
 
-void virtio_pci_legacy_remove(struct pci_dev *pci_dev)
+void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev)
 {
-        struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
-
-        unregister_virtio_device(&vp_dev->vdev);
+        struct pci_dev *pci_dev = vp_dev->pci_dev;
 
-        vp_del_vqs(&vp_dev->vdev);
         pci_iounmap(pci_dev, vp_dev->ioaddr);
-        pci_release_regions(pci_dev);
-        pci_disable_device(pci_dev);
 }
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
new file mode 100644
index 000000000000..2aa38e59db2e
--- /dev/null
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -0,0 +1,695 @@
+/*
+ * Virtio PCI driver - modern (virtio 1.0) 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.
+ *
+ */
+
+#define VIRTIO_PCI_NO_LEGACY
+#include "virtio_pci_common.h"
+
+static void __iomem *map_capability(struct pci_dev *dev, int off,
+                                    size_t minlen,
+                                    u32 align,
+                                    u32 start, u32 size,
+                                    size_t *len)
+{
+        u8 bar;
+        u32 offset, length;
+        void __iomem *p;
+
+        pci_read_config_byte(dev, off + offsetof(struct virtio_pci_cap,
+                                                 bar),
+                             &bar);
+        pci_read_config_dword(dev, off + offsetof(struct virtio_pci_cap, offset),
+                             &offset);
+        pci_read_config_dword(dev, off + offsetof(struct virtio_pci_cap, length),
+                              &length);
+
+        if (length <= start) {
+                dev_err(&dev->dev,
+                        "virtio_pci: bad capability len %u (>%u expected)\n",
+                        length, start);
+                return NULL;
+        }
+
+        if (length - start < minlen) {
+                dev_err(&dev->dev,
+                        "virtio_pci: bad capability len %u (>=%zu expected)\n",
+                        length, minlen);
+                return NULL;
+        }
+
+        length -= start;
+
+        if (start + offset < offset) {
+                dev_err(&dev->dev,
+                        "virtio_pci: map wrap-around %u+%u\n",
+                        start, offset);
+                return NULL;
+        }
+
+        offset += start;
+
+        if (offset & (align - 1)) {
+                dev_err(&dev->dev,
+                        "virtio_pci: offset %u not aligned to %u\n",
+                        offset, align);
+                return NULL;
+        }
+
+        if (length > size)
+                length = size;
+
+        if (len)
+                *len = length;
+
+        if (minlen + offset < minlen ||
+            minlen + offset > pci_resource_len(dev, bar)) {
+                dev_err(&dev->dev,
+                        "virtio_pci: map virtio %zu@%u "
+                        "out of range on bar %i length %lu\n",
+                        minlen, offset,
+                        bar, (unsigned long)pci_resource_len(dev, bar));
+                return NULL;
+        }
+
+        p = pci_iomap_range(dev, bar, offset, length);
+        if (!p)
+                dev_err(&dev->dev,
+                        "virtio_pci: unable to map virtio %u@%u on bar %i\n",
+                        length, offset, bar);
+        return p;
+}
+
+static void iowrite64_twopart(u64 val, __le32 __iomem *lo, __le32 __iomem *hi)
+{
+        iowrite32((u32)val, lo);
+        iowrite32(val >> 32, hi);
+}
+
+/* virtio config->get_features() implementation */
+static u64 vp_get_features(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        u64 features;
+
+        iowrite32(0, &vp_dev->common->device_feature_select);
+        features = ioread32(&vp_dev->common->device_feature);
+        iowrite32(1, &vp_dev->common->device_feature_select);
+        features |= ((u64)ioread32(&vp_dev->common->device_feature) << 32);
+
+        return 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);
+
+        if (!__virtio_test_bit(vdev, VIRTIO_F_VERSION_1)) {
+                dev_err(&vdev->dev, "virtio: device uses modern interface "
+                        "but does not have VIRTIO_F_VERSION_1\n");
+                return -EINVAL;
+        }
+
+        iowrite32(0, &vp_dev->common->guest_feature_select);
+        iowrite32((u32)vdev->features, &vp_dev->common->guest_feature);
+        iowrite32(1, &vp_dev->common->guest_feature_select);
+        iowrite32(vdev->features >> 32, &vp_dev->common->guest_feature);
+
+        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);
+        u8 b;
+        __le16 w;
+        __le32 l;
+
+        BUG_ON(offset + len > vp_dev->device_len);
+
+        switch (len) {
+        case 1:
+                b = ioread8(vp_dev->device + offset);
+                memcpy(buf, &b, sizeof b);
+                break;
+        case 2:
+                w = cpu_to_le16(ioread16(vp_dev->device + offset));
+                memcpy(buf, &w, sizeof w);
+                break;
+        case 4:
+                l = cpu_to_le32(ioread32(vp_dev->device + offset));
+                memcpy(buf, &l, sizeof l);
+                break;
+        case 8:
+                l = cpu_to_le32(ioread32(vp_dev->device + offset));
+                memcpy(buf, &l, sizeof l);
+                l = cpu_to_le32(ioread32(vp_dev->device + offset + sizeof l));
+                memcpy(buf + sizeof l, &l, sizeof l);
+                break;
+        default:
+                BUG();
+        }
+}
+
+/* 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);
+        u8 b;
+        __le16 w;
+        __le32 l;
+
+        BUG_ON(offset + len > vp_dev->device_len);
+
+        switch (len) {
+        case 1:
+                memcpy(&b, buf, sizeof b);
+                iowrite8(b, vp_dev->device + offset);
+                break;
+        case 2:
+                memcpy(&w, buf, sizeof w);
+                iowrite16(le16_to_cpu(w), vp_dev->device + offset);
+                break;
+        case 4:
+                memcpy(&l, buf, sizeof l);
+                iowrite32(le32_to_cpu(l), vp_dev->device + offset);
+                break;
+        case 8:
+                memcpy(&l, buf, sizeof l);
+                iowrite32(le32_to_cpu(l), vp_dev->device + offset);
+                memcpy(&l, buf + sizeof l, sizeof l);
+                iowrite32(le32_to_cpu(l), vp_dev->device + offset + sizeof l);
+                break;
+        default:
+                BUG();
+        }
+}
+
+static u32 vp_generation(struct virtio_device *vdev)
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        return ioread8(&vp_dev->common->config_generation);
+}
+
+/* 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->common->device_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->common->device_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->common->device_status);
+        /* Flush out the status write, and flush in device writes,
+         * including MSI-X interrupts, if any. */
+        ioread8(&vp_dev->common->device_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->common->msix_config);
+        /* Verify we had enough resources to assign the vector */
+        /* Will also flush the write out to device */
+        return ioread16(&vp_dev->common->msix_config);
+}
+
+static size_t vring_pci_size(u16 num)
+{
+        /* We only need a cacheline separation. */
+        return PAGE_ALIGN(vring_size(num, SMP_CACHE_BYTES));
+}
+
+static void *alloc_virtqueue_pages(int *num)
+{
+        void *pages;
+
+        /* TODO: allocate each queue chunk individually */
+        for (; *num && vring_pci_size(*num) > PAGE_SIZE; *num /= 2) {
+                pages = alloc_pages_exact(vring_pci_size(*num),
+                                          GFP_KERNEL|__GFP_ZERO|__GFP_NOWARN);
+                if (pages)
+                        return pages;
+        }
+
+        if (!*num)
+                return NULL;
+
+        /* Try to get a single page. You are my only hope! */
+        return alloc_pages_exact(vring_pci_size(*num), GFP_KERNEL|__GFP_ZERO);
+}
+
+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 virtio_pci_common_cfg __iomem *cfg = vp_dev->common;
+        struct virtqueue *vq;
+        u16 num, off;
+        int err;
+
+        if (index >= ioread16(&cfg->num_queues))
+                return ERR_PTR(-ENOENT);
+
+        /* Select the queue we're interested in */
+        iowrite16(index, &cfg->queue_select);
+
+        /* Check if queue is either not available or already active. */
+        num = ioread16(&cfg->queue_size);
+        if (!num || ioread16(&cfg->queue_enable))
+                return ERR_PTR(-ENOENT);
+
+        if (num & (num - 1)) {
+                dev_warn(&vp_dev->pci_dev->dev, "bad queue size %u", num);
+                return ERR_PTR(-EINVAL);
+        }
+
+        /* get offset of notification word for this vq */
+        off = ioread16(&cfg->queue_notify_off);
+
+        info->num = num;
+        info->msix_vector = msix_vec;
+
+        info->queue = alloc_virtqueue_pages(&info->num);
+        if (info->queue == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        /* create the vring */
+        vq = vring_new_virtqueue(index, info->num,
+                                 SMP_CACHE_BYTES, &vp_dev->vdev,
+                                 true, info->queue, vp_notify, callback, name);
+        if (!vq) {
+                err = -ENOMEM;
+                goto err_new_queue;
+        }
+
+        /* activate the queue */
+        iowrite16(num, &cfg->queue_size);
+        iowrite64_twopart(virt_to_phys(info->queue),
+                          &cfg->queue_desc_lo, &cfg->queue_desc_hi);
+        iowrite64_twopart(virt_to_phys(virtqueue_get_avail(vq)),
+                          &cfg->queue_avail_lo, &cfg->queue_avail_hi);
+        iowrite64_twopart(virt_to_phys(virtqueue_get_used(vq)),
+                          &cfg->queue_used_lo, &cfg->queue_used_hi);
+
+        if (vp_dev->notify_base) {
+                /* offset should not wrap */
+                if ((u64)off * vp_dev->notify_offset_multiplier + 2
+                    > vp_dev->notify_len) {
+                        dev_warn(&vp_dev->pci_dev->dev,
+                                 "bad notification offset %u (x %u) "
+                                 "for queue %u > %zd",
+                                 off, vp_dev->notify_offset_multiplier,
+                                 index, vp_dev->notify_len);
+                        err = -EINVAL;
+                        goto err_map_notify;
+                }
+                vq->priv = (void __force *)vp_dev->notify_base +
+                        off * vp_dev->notify_offset_multiplier;
+        } else {
+                vq->priv = (void __force *)map_capability(vp_dev->pci_dev,
+                                          vp_dev->notify_map_cap, 2, 2,
+                                          off * vp_dev->notify_offset_multiplier, 2,
+                                          NULL);
+        }
+
+        if (!vq->priv) {
+                err = -ENOMEM;
+                goto err_map_notify;
+        }
+
+        if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
+                iowrite16(msix_vec, &cfg->queue_msix_vector);
+                msix_vec = ioread16(&cfg->queue_msix_vector);
+                if (msix_vec == VIRTIO_MSI_NO_VECTOR) {
+                        err = -EBUSY;
+                        goto err_assign_vector;
+                }
+        }
+
+        return vq;
+
+err_assign_vector:
+        if (!vp_dev->notify_base)
+                pci_iounmap(vp_dev->pci_dev, (void __iomem __force *)vq->priv);
+err_map_notify:
+        vring_del_virtqueue(vq);
+err_new_queue:
+        free_pages_exact(info->queue, vring_pci_size(info->num));
+        return ERR_PTR(err);
+}
+
+static int vp_modern_find_vqs(struct virtio_device *vdev, unsigned nvqs,
+                              struct virtqueue *vqs[],
+                              vq_callback_t *callbacks[],
+                              const char *names[])
+{
+        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
+        struct virtqueue *vq;
+        int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names);
+
+        if (rc)
+                return rc;
+
+        /* Select and activate all queues. Has to be done last: once we do
+         * this, there's no way to go back except reset.
+         */
+        list_for_each_entry(vq, &vdev->vqs, list) {
+                iowrite16(vq->index, &vp_dev->common->queue_select);
+                iowrite16(1, &vp_dev->common->queue_enable);
+        }
+
+        return 0;
+}
+
+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);
+
+        iowrite16(vq->index, &vp_dev->common->queue_select);
+
+        if (vp_dev->msix_enabled) {
+                iowrite16(VIRTIO_MSI_NO_VECTOR,
+                          &vp_dev->common->queue_msix_vector);
+                /* Flush the write out to device */
+                ioread16(&vp_dev->common->queue_msix_vector);
+        }
+
+        if (!vp_dev->notify_base)
+                pci_iounmap(vp_dev->pci_dev, (void __force __iomem *)vq->priv);
+
+        vring_del_virtqueue(vq);
+
+        free_pages_exact(info->queue, vring_pci_size(info->num));
+}
+
+static const struct virtio_config_ops virtio_pci_config_nodev_ops = {
+        .get            = NULL,
+        .set            = NULL,
+        .generation     = vp_generation,
+        .get_status     = vp_get_status,
+        .set_status     = vp_set_status,
+        .reset          = vp_reset,
+        .find_vqs       = vp_modern_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 const struct virtio_config_ops virtio_pci_config_ops = {
+        .get            = vp_get,
+        .set            = vp_set,
+        .generation     = vp_generation,
+        .get_status     = vp_get_status,
+        .set_status     = vp_set_status,
+        .reset          = vp_reset,
+        .find_vqs       = vp_modern_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,
+};
+
+/**
+ * virtio_pci_find_capability - walk capabilities to find device info.
+ * @dev: the pci device
+ * @cfg_type: the VIRTIO_PCI_CAP_* value we seek
+ * @ioresource_types: IORESOURCE_MEM and/or IORESOURCE_IO.
+ *
+ * Returns offset of the capability, or 0.
+ */
+static inline int virtio_pci_find_capability(struct pci_dev *dev, u8 cfg_type,
+                                             u32 ioresource_types)
+{
+        int pos;
+
+        for (pos = pci_find_capability(dev, PCI_CAP_ID_VNDR);
+             pos > 0;
+             pos = pci_find_next_capability(dev, pos, PCI_CAP_ID_VNDR)) {
+                u8 type, bar;
+                pci_read_config_byte(dev, pos + offsetof(struct virtio_pci_cap,
+                                                         cfg_type),
+                                     &type);
+                pci_read_config_byte(dev, pos + offsetof(struct virtio_pci_cap,
+                                                         bar),
+                                     &bar);
+
+                /* Ignore structures with reserved BAR values */
+                if (bar > 0x5)
+                        continue;
+
+                if (type == cfg_type) {
+                        if (pci_resource_len(dev, bar) &&
+                            pci_resource_flags(dev, bar) & ioresource_types)
+                                return pos;
+                }
+        }
+        return 0;
+}
+
+/* This is part of the ABI.  Don't screw with it. */
+static inline void check_offsets(void)
+{
+        /* Note: disk space was harmed in compilation of this function. */
+        BUILD_BUG_ON(VIRTIO_PCI_CAP_VNDR !=
+                     offsetof(struct virtio_pci_cap, cap_vndr));
+        BUILD_BUG_ON(VIRTIO_PCI_CAP_NEXT !=
+                     offsetof(struct virtio_pci_cap, cap_next));
+        BUILD_BUG_ON(VIRTIO_PCI_CAP_LEN !=
+                     offsetof(struct virtio_pci_cap, cap_len));
+        BUILD_BUG_ON(VIRTIO_PCI_CAP_CFG_TYPE !=
+                     offsetof(struct virtio_pci_cap, cfg_type));
+        BUILD_BUG_ON(VIRTIO_PCI_CAP_BAR !=
+                     offsetof(struct virtio_pci_cap, bar));
+        BUILD_BUG_ON(VIRTIO_PCI_CAP_OFFSET !=
+                     offsetof(struct virtio_pci_cap, offset));
+        BUILD_BUG_ON(VIRTIO_PCI_CAP_LENGTH !=
+                     offsetof(struct virtio_pci_cap, length));
+        BUILD_BUG_ON(VIRTIO_PCI_NOTIFY_CAP_MULT !=
+                     offsetof(struct virtio_pci_notify_cap,
+                              notify_off_multiplier));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_DFSELECT !=
+                     offsetof(struct virtio_pci_common_cfg,
+                              device_feature_select));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_DF !=
+                     offsetof(struct virtio_pci_common_cfg, device_feature));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_GFSELECT !=
+                     offsetof(struct virtio_pci_common_cfg,
+                              guest_feature_select));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_GF !=
+                     offsetof(struct virtio_pci_common_cfg, guest_feature));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_MSIX !=
+                     offsetof(struct virtio_pci_common_cfg, msix_config));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_NUMQ !=
+                     offsetof(struct virtio_pci_common_cfg, num_queues));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_STATUS !=
+                     offsetof(struct virtio_pci_common_cfg, device_status));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_CFGGENERATION !=
+                     offsetof(struct virtio_pci_common_cfg, config_generation));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_SELECT !=
+                     offsetof(struct virtio_pci_common_cfg, queue_select));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_SIZE !=
+                     offsetof(struct virtio_pci_common_cfg, queue_size));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_MSIX !=
+                     offsetof(struct virtio_pci_common_cfg, queue_msix_vector));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_ENABLE !=
+                     offsetof(struct virtio_pci_common_cfg, queue_enable));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_NOFF !=
+                     offsetof(struct virtio_pci_common_cfg, queue_notify_off));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_DESCLO !=
+                     offsetof(struct virtio_pci_common_cfg, queue_desc_lo));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_DESCHI !=
+                     offsetof(struct virtio_pci_common_cfg, queue_desc_hi));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_AVAILLO !=
+                     offsetof(struct virtio_pci_common_cfg, queue_avail_lo));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_AVAILHI !=
+                     offsetof(struct virtio_pci_common_cfg, queue_avail_hi));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_USEDLO !=
+                     offsetof(struct virtio_pci_common_cfg, queue_used_lo));
+        BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_USEDHI !=
+                     offsetof(struct virtio_pci_common_cfg, queue_used_hi));
+}
+
+/* the PCI probing function */
+int virtio_pci_modern_probe(struct virtio_pci_device *vp_dev)
+{
+        struct pci_dev *pci_dev = vp_dev->pci_dev;
+        int err, common, isr, notify, device;
+        u32 notify_length;
+        u32 notify_offset;
+
+        check_offsets();
+
+        /* We only own devices >= 0x1000 and <= 0x107f: leave the rest. */
+        if (pci_dev->device < 0x1000 || pci_dev->device > 0x107f)
+                return -ENODEV;
+
+        if (pci_dev->device < 0x1040) {
+                /* Transitional devices: use the PCI subsystem device id as
+                 * virtio device id, same as legacy driver always did.
+                 */
+                vp_dev->vdev.id.device = pci_dev->subsystem_device;
+        } else {
+                /* Modern devices: simply use PCI device id, but start from 0x1040. */
+                vp_dev->vdev.id.device = pci_dev->device - 0x1040;
+        }
+        vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor;
+
+        if (virtio_device_is_legacy_only(vp_dev->vdev.id))
+                return -ENODEV;
+
+        /* check for a common config: if not, use legacy mode (bar 0). */
+        common = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_COMMON_CFG,
+                                            IORESOURCE_IO | IORESOURCE_MEM);
+        if (!common) {
+                dev_info(&pci_dev->dev,
+                         "virtio_pci: leaving for legacy driver\n");
+                return -ENODEV;
+        }
+
+        /* If common is there, these should be too... */
+        isr = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_ISR_CFG,
+                                         IORESOURCE_IO | IORESOURCE_MEM);
+        notify = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_NOTIFY_CFG,
+                                            IORESOURCE_IO | IORESOURCE_MEM);
+        if (!isr || !notify) {
+                dev_err(&pci_dev->dev,
+                        "virtio_pci: missing capabilities %i/%i/%i\n",
+                        common, isr, notify);
+                return -EINVAL;
+        }
+
+        /* Device capability is only mandatory for devices that have
+         * device-specific configuration.
+         */
+        device = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_DEVICE_CFG,
+                                            IORESOURCE_IO | IORESOURCE_MEM);
+
+        err = -EINVAL;
+        vp_dev->common = map_capability(pci_dev, common,
+                                        sizeof(struct virtio_pci_common_cfg), 4,
+                                        0, sizeof(struct virtio_pci_common_cfg),
+                                        NULL);
+        if (!vp_dev->common)
+                goto err_map_common;
+        vp_dev->isr = map_capability(pci_dev, isr, sizeof(u8), 1,
+                                     0, 1,
+                                     NULL);
+        if (!vp_dev->isr)
+                goto err_map_isr;
+
+        /* Read notify_off_multiplier from config space. */
+        pci_read_config_dword(pci_dev,
+                              notify + offsetof(struct virtio_pci_notify_cap,
+                                                notify_off_multiplier),
+                              &vp_dev->notify_offset_multiplier);
+        /* Read notify length and offset from config space. */
+        pci_read_config_dword(pci_dev,
+                              notify + offsetof(struct virtio_pci_notify_cap,
+                                                cap.length),
+                              &notify_length);
+
+        pci_read_config_dword(pci_dev,
+                              notify + offsetof(struct virtio_pci_notify_cap,
+                                                cap.length),
+                              &notify_offset);
+
+        /* We don't know how many VQs we'll map, ahead of the time.
+         * If notify length is small, map it all now.
+         * Otherwise, map each VQ individually later.
+         */
+        if ((u64)notify_length + (notify_offset % PAGE_SIZE) <= PAGE_SIZE) {
+                vp_dev->notify_base = map_capability(pci_dev, notify, 2, 2,
+                                                     0, notify_length,
+                                                     &vp_dev->notify_len);
+                if (!vp_dev->notify_base)
+                        goto err_map_notify;
+        } else {
+                vp_dev->notify_map_cap = notify;
+        }
+
+        /* Again, we don't know how much we should map, but PAGE_SIZE
+         * is more than enough for all existing devices.
+         */
+        if (device) {
+                vp_dev->device = map_capability(pci_dev, device, 0, 4,
+                                                0, PAGE_SIZE,
+                                                &vp_dev->device_len);
+                if (!vp_dev->device)
+                        goto err_map_device;
+
+                vp_dev->vdev.config = &virtio_pci_config_ops;
+        } else {
+                vp_dev->vdev.config = &virtio_pci_config_nodev_ops;
+        }
+
+        vp_dev->config_vector = vp_config_vector;
+        vp_dev->setup_vq = setup_vq;
+        vp_dev->del_vq = del_vq;
+
+        return 0;
+
+err_map_device:
+        if (vp_dev->notify_base)
+                pci_iounmap(pci_dev, vp_dev->notify_base);
+err_map_notify:
+        pci_iounmap(pci_dev, vp_dev->isr);
+err_map_isr:
+        pci_iounmap(pci_dev, vp_dev->common);
+err_map_common:
+        return err;
+}
+
+void virtio_pci_modern_remove(struct virtio_pci_device *vp_dev)
+{
+        struct pci_dev *pci_dev = vp_dev->pci_dev;
+
+        if (vp_dev->device)
+                pci_iounmap(pci_dev, vp_dev->device);
+        if (vp_dev->notify_base)
+                pci_iounmap(pci_dev, vp_dev->notify_base);
+        pci_iounmap(pci_dev, vp_dev->isr);
+        pci_iounmap(pci_dev, vp_dev->common);
+}
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 00ec6b3f96b2..096b857e7b75 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -54,8 +54,7 @@
 #define END_USE(vq)
 #endif
 
-struct vring_virtqueue
-{
+struct vring_virtqueue {
         struct virtqueue vq;
 
         /* Actual memory layout for this queue */
@@ -245,14 +244,14 @@ static inline int virtqueue_add(struct virtqueue *_vq,
         vq->vring.avail->idx = cpu_to_virtio16(_vq->vdev, virtio16_to_cpu(_vq->vdev, vq->vring.avail->idx) + 1);
         vq->num_added++;
 
+        pr_debug("Added buffer head %i to %p\n", head, vq);
+        END_USE(vq);
+
         /* This is very unlikely, but theoretically possible.  Kick
          * just in case. */
         if (unlikely(vq->num_added == (1 << 16) - 1))
                 virtqueue_kick(_vq);
 
-        pr_debug("Added buffer head %i to %p\n", head, vq);
-        END_USE(vq);
-
         return 0;
 }
 
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index 08f41add1461..16f202350997 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -505,6 +505,16 @@ config MESON_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called meson_wdt.
 
+config MEDIATEK_WATCHDOG
+        tristate "Mediatek SoCs watchdog support"
+        depends on ARCH_MEDIATEK
+        select WATCHDOG_CORE
+        help
+          Say Y here to include support for the watchdog timer
+          in Mediatek SoCs.
+          To compile this driver as a module, choose M here: the
+          module will be called mtk_wdt.
+
 # AVR32 Architecture
 
 config AT32AP700X_WDT
@@ -1005,6 +1015,8 @@ config W83627HF_WDT
                 NCT6775
                 NCT6776
                 NCT6779
+                NCT6791
+                NCT6792
 
           This watchdog simply watches your kernel to make sure it doesn't
           freeze, and if it does, it reboots your computer after a certain
@@ -1101,7 +1113,7 @@ config ATH79_WDT
 
 config BCM47XX_WDT
         tristate "Broadcom BCM47xx Watchdog Timer"
-        depends on BCM47XX
+        depends on BCM47XX || ARCH_BCM_5301X
         select WATCHDOG_CORE
         help
           Hardware driver for the Broadcom BCM47xx Watchdog Timer.
@@ -1235,6 +1247,17 @@ config BCM_KONA_WDT_DEBUG
 
           If in doubt, say 'N'.
 
+config IMGPDC_WDT
+        tristate "Imagination Technologies PDC Watchdog Timer"
+        depends on HAS_IOMEM
+        depends on METAG || MIPS || COMPILE_TEST
+        help
+          Driver for Imagination Technologies PowerDown Controller
+          Watchdog Timer.
+
+          To compile this driver as a loadable module, choose M here.
+          The module will be called imgpdc_wdt.
+
 config LANTIQ_WDT
         tristate "Lantiq SoC watchdog"
         depends on LANTIQ
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index c569ec8f8a76..5c19294d1c30 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -63,6 +63,7 @@ obj-$(CONFIG_QCOM_WDT) += qcom-wdt.o
 obj-$(CONFIG_BCM_KONA_WDT) += bcm_kona_wdt.o
 obj-$(CONFIG_TEGRA_WATCHDOG) += tegra_wdt.o
 obj-$(CONFIG_MESON_WATCHDOG) += meson_wdt.o
+obj-$(CONFIG_MEDIATEK_WATCHDOG) += mtk_wdt.o
 
 # AVR32 Architecture
 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
@@ -142,6 +143,7 @@ obj-$(CONFIG_OCTEON_WDT) += octeon-wdt.o
 octeon-wdt-y := octeon-wdt-main.o octeon-wdt-nmi.o
 obj-$(CONFIG_LANTIQ_WDT) += lantiq_wdt.o
 obj-$(CONFIG_RALINK_WDT) += rt2880_wdt.o
+obj-$(CONFIG_IMGPDC_WDT) += imgpdc_wdt.o
 
 # PARISC Architecture
 
diff --git a/drivers/watchdog/bcm47xx_wdt.c b/drivers/watchdog/bcm47xx_wdt.c
index 9816485f6825..b28a072abf78 100644
--- a/drivers/watchdog/bcm47xx_wdt.c
+++ b/drivers/watchdog/bcm47xx_wdt.c
@@ -169,6 +169,17 @@ static int bcm47xx_wdt_notify_sys(struct notifier_block *this,
         return NOTIFY_DONE;
 }
 
+static int bcm47xx_wdt_restart(struct notifier_block *this, unsigned long mode,
+                               void *cmd)
+{
+        struct bcm47xx_wdt *wdt;
+
+        wdt = container_of(this, struct bcm47xx_wdt, restart_handler);
+        wdt->timer_set(wdt, 1);
+
+        return NOTIFY_DONE;
+}
+
 static struct watchdog_ops bcm47xx_wdt_soft_ops = {
         .owner          = THIS_MODULE,
         .start          = bcm47xx_wdt_soft_start,
@@ -209,15 +220,23 @@ static int bcm47xx_wdt_probe(struct platform_device *pdev)
         if (ret)
                 goto err_timer;
 
-        ret = watchdog_register_device(&wdt->wdd);
+        wdt->restart_handler.notifier_call = &bcm47xx_wdt_restart;
+        wdt->restart_handler.priority = 64;
+        ret = register_restart_handler(&wdt->restart_handler);
         if (ret)
                 goto err_notifier;
 
+        ret = watchdog_register_device(&wdt->wdd);
+        if (ret)
+                goto err_handler;
+
         dev_info(&pdev->dev, "BCM47xx Watchdog Timer enabled (%d seconds%s%s)\n",
                 timeout, nowayout ? ", nowayout" : "",
                 soft ? ", Software Timer" : "");
         return 0;
 
+err_handler:
+        unregister_restart_handler(&wdt->restart_handler);
 err_notifier:
         unregister_reboot_notifier(&wdt->notifier);
 err_timer:
diff --git a/drivers/watchdog/da9063_wdt.c b/drivers/watchdog/da9063_wdt.c
index 2cd6b2c2dd2a..e2fe2ebdebd4 100644
--- a/drivers/watchdog/da9063_wdt.c
+++ b/drivers/watchdog/da9063_wdt.c
@@ -20,6 +20,7 @@
 #include <linux/delay.h>
 #include <linux/mfd/da9063/registers.h>
 #include <linux/mfd/da9063/core.h>
+#include <linux/reboot.h>
 #include <linux/regmap.h>
 
 /*
@@ -38,6 +39,7 @@ static const unsigned int wdt_timeout[] = { 0, 2, 4, 8, 16, 32, 65, 131 };
 struct da9063_watchdog {
         struct da9063 *da9063;
         struct watchdog_device wdtdev;
+        struct notifier_block restart_handler;
 };
 
 static unsigned int da9063_wdt_timeout_to_sel(unsigned int secs)
@@ -119,6 +121,23 @@ static int da9063_wdt_set_timeout(struct watchdog_device *wdd,
         return ret;
 }
 
+static int da9063_wdt_restart_handler(struct notifier_block *this,
+                                      unsigned long mode, void *cmd)
+{
+        struct da9063_watchdog *wdt = container_of(this,
+                                                   struct da9063_watchdog,
+                                                   restart_handler);
+        int ret;
+
+        ret = regmap_write(wdt->da9063->regmap, DA9063_REG_CONTROL_F,
+                           DA9063_SHUTDOWN);
+        if (ret)
+                dev_alert(wdt->da9063->dev, "Failed to shutdown (err = %d)\n",
+                          ret);
+
+        return NOTIFY_DONE;
+}
+
 static const struct watchdog_info da9063_watchdog_info = {
         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
         .identity = "DA9063 Watchdog",
@@ -163,14 +182,25 @@ static int da9063_wdt_probe(struct platform_device *pdev)
         dev_set_drvdata(&pdev->dev, wdt);
 
         ret = watchdog_register_device(&wdt->wdtdev);
+        if (ret)
+                return ret;
 
-        return ret;
+        wdt->restart_handler.notifier_call = da9063_wdt_restart_handler;
+        wdt->restart_handler.priority = 128;
+        ret = register_restart_handler(&wdt->restart_handler);
+        if (ret)
+                dev_err(wdt->da9063->dev,
+                        "Failed to register restart handler (err = %d)\n", ret);
+
+        return 0;
 }
 
 static int da9063_wdt_remove(struct platform_device *pdev)
 {
         struct da9063_watchdog *wdt = dev_get_drvdata(&pdev->dev);
 
+        unregister_restart_handler(&wdt->restart_handler);
+
         watchdog_unregister_device(&wdt->wdtdev);
 
         return 0;
diff --git a/drivers/watchdog/dw_wdt.c b/drivers/watchdog/dw_wdt.c
index b34a2e4e4e43..d0bb9499d12c 100644
--- a/drivers/watchdog/dw_wdt.c
+++ b/drivers/watchdog/dw_wdt.c
@@ -51,6 +51,8 @@
 /* The maximum TOP (timeout period) value that can be set in the watchdog. */
 #define DW_WDT_MAX_TOP          15
 
+#define DW_WDT_DEFAULT_SECONDS  30
+
 static bool nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, bool, 0);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
@@ -96,6 +98,12 @@ static inline void dw_wdt_set_next_heartbeat(void)
         dw_wdt.next_heartbeat = jiffies + dw_wdt_get_top() * HZ;
 }
 
+static void dw_wdt_keepalive(void)
+{
+        writel(WDOG_COUNTER_RESTART_KICK_VALUE, dw_wdt.regs +
+               WDOG_COUNTER_RESTART_REG_OFFSET);
+}
+
 static int dw_wdt_set_top(unsigned top_s)
 {
         int i, top_val = DW_WDT_MAX_TOP;
@@ -110,21 +118,27 @@ static int dw_wdt_set_top(unsigned top_s)
                         break;
                 }
 
-        /* Set the new value in the watchdog. */
+        /*
+         * Set the new value in the watchdog.  Some versions of dw_wdt
+         * have have TOPINIT in the TIMEOUT_RANGE register (as per
+         * CP_WDT_DUAL_TOP in WDT_COMP_PARAMS_1).  On those we
+         * effectively get a pat of the watchdog right here.
+         */
         writel(top_val | top_val << WDOG_TIMEOUT_RANGE_TOPINIT_SHIFT,
                 dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET);
 
+        /*
+         * Add an explicit pat to handle versions of the watchdog that
+         * don't have TOPINIT.  This won't hurt on versions that have
+         * it.
+         */
+        dw_wdt_keepalive();
+
         dw_wdt_set_next_heartbeat();
 
         return dw_wdt_top_in_seconds(top_val);
 }
 
-static void dw_wdt_keepalive(void)
-{
-        writel(WDOG_COUNTER_RESTART_KICK_VALUE, dw_wdt.regs +
-               WDOG_COUNTER_RESTART_REG_OFFSET);
-}
-
 static int dw_wdt_restart_handle(struct notifier_block *this,
                                 unsigned long mode, void *cmd)
 {
@@ -167,9 +181,9 @@ static int dw_wdt_open(struct inode *inode, struct file *filp)
         if (!dw_wdt_is_enabled()) {
                 /*
                  * The watchdog is not currently enabled. Set the timeout to
-                 * the maximum and then start it.
+                 * something reasonable and then start it.
                  */
-                dw_wdt_set_top(DW_WDT_MAX_TOP);
+                dw_wdt_set_top(DW_WDT_DEFAULT_SECONDS);
                 writel(WDOG_CONTROL_REG_WDT_EN_MASK,
                        dw_wdt.regs + WDOG_CONTROL_REG_OFFSET);
         }
diff --git a/drivers/watchdog/gpio_wdt.c b/drivers/watchdog/gpio_wdt.c
index bbdb19b45332..cbc313d37c59 100644
--- a/drivers/watchdog/gpio_wdt.c
+++ b/drivers/watchdog/gpio_wdt.c
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
         int                     gpio;
         bool                    active_low;
         bool                    state;
+        bool                    always_running;
+        bool                    armed;
         unsigned int            hw_algo;
         unsigned int            hw_margin;
         unsigned long           last_jiffies;
@@ -48,14 +50,20 @@ static void gpio_wdt_disable(struct gpio_wdt_priv *priv)
                 gpio_direction_input(priv->gpio);
 }
 
-static int gpio_wdt_start(struct watchdog_device *wdd)
+static void gpio_wdt_start_impl(struct gpio_wdt_priv *priv)
 {
-        struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
-
         priv->state = priv->active_low;
         gpio_direction_output(priv->gpio, priv->state);
         priv->last_jiffies = jiffies;
         mod_timer(&priv->timer, priv->last_jiffies + priv->hw_margin);
+}
+
+static int gpio_wdt_start(struct watchdog_device *wdd)
+{
+        struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
+
+        gpio_wdt_start_impl(priv);
+        priv->armed = true;
 
         return 0;
 }
@@ -64,8 +72,11 @@ static int gpio_wdt_stop(struct watchdog_device *wdd)
 {
         struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-        mod_timer(&priv->timer, 0);
-        gpio_wdt_disable(priv);
+        priv->armed = false;
+        if (!priv->always_running) {
+                mod_timer(&priv->timer, 0);
+                gpio_wdt_disable(priv);
+        }
 
         return 0;
 }
@@ -91,8 +102,8 @@ static void gpio_wdt_hwping(unsigned long data)
         struct watchdog_device *wdd = (struct watchdog_device *)data;
         struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-        if (time_after(jiffies, priv->last_jiffies +
-                       msecs_to_jiffies(wdd->timeout * 1000))) {
+        if (priv->armed && time_after(jiffies, priv->last_jiffies +
+                                      msecs_to_jiffies(wdd->timeout * 1000))) {
                 dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
                 return;
         }
@@ -197,6 +208,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
         /* Use safe value (1/2 of real timeout) */
         priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+        priv->always_running = of_property_read_bool(pdev->dev.of_node,
+                                                     "always-running");
+
         watchdog_set_drvdata(&priv->wdd, priv);
 
         priv->wdd.info          = &gpio_wdt_ident;
@@ -216,8 +230,15 @@ static int gpio_wdt_probe(struct platform_device *pdev)
         priv->notifier.notifier_call = gpio_wdt_notify_sys;
         ret = register_reboot_notifier(&priv->notifier);
         if (ret)
-                watchdog_unregister_device(&priv->wdd);
+                goto error_unregister;
 
+        if (priv->always_running)
+                gpio_wdt_start_impl(priv);
+
+        return 0;
+
+error_unregister:
+        watchdog_unregister_device(&priv->wdd);
         return ret;
 }
 
diff --git a/drivers/watchdog/hpwdt.c b/drivers/watchdog/hpwdt.c
index 75d2243b94f5..ada3e44f9932 100644
--- a/drivers/watchdog/hpwdt.c
+++ b/drivers/watchdog/hpwdt.c
@@ -745,7 +745,7 @@ static int hpwdt_init_nmi_decoding(struct pci_dev *dev)
 
         dev_info(&dev->dev,
                         "HP Watchdog Timer Driver: NMI decoding initialized"
-                        ", allow kernel dump: %s (default = 0/OFF)\n",
+                        ", allow kernel dump: %s (default = 1/ON)\n",
                         (allow_kdump == 0) ? "OFF" : "ON");
         return 0;
 
diff --git a/drivers/watchdog/imgpdc_wdt.c b/drivers/watchdog/imgpdc_wdt.c
new file mode 100644
index 000000000000..c8def68d9e4c
--- /dev/null
+++ b/drivers/watchdog/imgpdc_wdt.c
@@ -0,0 +1,289 @@
+/*
+ * Imagination Technologies PowerDown Controller Watchdog Timer.
+ *
+ * Copyright (c) 2014 Imagination Technologies Ltd.
+ *
+ * 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.
+ *
+ * Based on drivers/watchdog/sunxi_wdt.c Copyright (c) 2013 Carlo Caione
+ *                                                     2012 Henrik Nordstrom
+ */
+
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/log2.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/watchdog.h>
+
+/* registers */
+#define PDC_WDT_SOFT_RESET              0x00
+#define PDC_WDT_CONFIG                  0x04
+  #define PDC_WDT_CONFIG_ENABLE         BIT(31)
+  #define PDC_WDT_CONFIG_DELAY_MASK     0x1f
+
+#define PDC_WDT_TICKLE1                 0x08
+#define PDC_WDT_TICKLE1_MAGIC           0xabcd1234
+#define PDC_WDT_TICKLE2                 0x0c
+#define PDC_WDT_TICKLE2_MAGIC           0x4321dcba
+
+#define PDC_WDT_TICKLE_STATUS_MASK      0x7
+#define PDC_WDT_TICKLE_STATUS_SHIFT     0
+#define PDC_WDT_TICKLE_STATUS_HRESET    0x0  /* Hard reset */
+#define PDC_WDT_TICKLE_STATUS_TIMEOUT   0x1  /* Timeout */
+#define PDC_WDT_TICKLE_STATUS_TICKLE    0x2  /* Tickled incorrectly */
+#define PDC_WDT_TICKLE_STATUS_SRESET    0x3  /* Soft reset */
+#define PDC_WDT_TICKLE_STATUS_USER      0x4  /* User reset */
+
+/* Timeout values are in seconds */
+#define PDC_WDT_MIN_TIMEOUT             1
+#define PDC_WDT_DEF_TIMEOUT             64
+
+static int heartbeat;
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat, "Watchdog heartbeats in seconds. "
+        "(default = " __MODULE_STRING(PDC_WDT_DEF_TIMEOUT) ")");
+
+static bool nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, bool, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
+        "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+struct pdc_wdt_dev {
+        struct watchdog_device wdt_dev;
+        struct clk *wdt_clk;
+        struct clk *sys_clk;
+        void __iomem *base;
+};
+
+static int pdc_wdt_keepalive(struct watchdog_device *wdt_dev)
+{
+        struct pdc_wdt_dev *wdt = watchdog_get_drvdata(wdt_dev);
+
+        writel(PDC_WDT_TICKLE1_MAGIC, wdt->base + PDC_WDT_TICKLE1);
+        writel(PDC_WDT_TICKLE2_MAGIC, wdt->base + PDC_WDT_TICKLE2);
+
+        return 0;
+}
+
+static int pdc_wdt_stop(struct watchdog_device *wdt_dev)
+{
+        unsigned int val;
+        struct pdc_wdt_dev *wdt = watchdog_get_drvdata(wdt_dev);
+
+        val = readl(wdt->base + PDC_WDT_CONFIG);
+        val &= ~PDC_WDT_CONFIG_ENABLE;
+        writel(val, wdt->base + PDC_WDT_CONFIG);
+
+        /* Must tickle to finish the stop */
+        pdc_wdt_keepalive(wdt_dev);
+
+        return 0;
+}
+
+static int pdc_wdt_set_timeout(struct watchdog_device *wdt_dev,
+                               unsigned int new_timeout)
+{
+        unsigned int val;
+        struct pdc_wdt_dev *wdt = watchdog_get_drvdata(wdt_dev);
+        unsigned long clk_rate = clk_get_rate(wdt->wdt_clk);
+
+        wdt->wdt_dev.timeout = new_timeout;
+
+        val = readl(wdt->base + PDC_WDT_CONFIG) & ~PDC_WDT_CONFIG_DELAY_MASK;
+        val |= order_base_2(new_timeout * clk_rate) - 1;
+        writel(val, wdt->base + PDC_WDT_CONFIG);
+
+        return 0;
+}
+
+/* Start the watchdog timer (delay should already be set) */
+static int pdc_wdt_start(struct watchdog_device *wdt_dev)
+{
+        unsigned int val;
+        struct pdc_wdt_dev *wdt = watchdog_get_drvdata(wdt_dev);
+
+        val = readl(wdt->base + PDC_WDT_CONFIG);
+        val |= PDC_WDT_CONFIG_ENABLE;
+        writel(val, wdt->base + PDC_WDT_CONFIG);
+
+        return 0;
+}
+
+static struct watchdog_info pdc_wdt_info = {
+        .identity       = "IMG PDC Watchdog",
+        .options        = WDIOF_SETTIMEOUT |
+                          WDIOF_KEEPALIVEPING |
+                          WDIOF_MAGICCLOSE,
+};
+
+static const struct watchdog_ops pdc_wdt_ops = {
+        .owner          = THIS_MODULE,
+        .start          = pdc_wdt_start,
+        .stop           = pdc_wdt_stop,
+        .ping           = pdc_wdt_keepalive,
+        .set_timeout    = pdc_wdt_set_timeout,
+};
+
+static int pdc_wdt_probe(struct platform_device *pdev)
+{
+        int ret, val;
+        unsigned long clk_rate;
+        struct resource *res;
+        struct pdc_wdt_dev *pdc_wdt;
+
+        pdc_wdt = devm_kzalloc(&pdev->dev, sizeof(*pdc_wdt), GFP_KERNEL);
+        if (!pdc_wdt)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        pdc_wdt->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(pdc_wdt->base))
+                return PTR_ERR(pdc_wdt->base);
+
+        pdc_wdt->sys_clk = devm_clk_get(&pdev->dev, "sys");
+        if (IS_ERR(pdc_wdt->sys_clk)) {
+                dev_err(&pdev->dev, "failed to get the sys clock\n");
+                return PTR_ERR(pdc_wdt->sys_clk);
+        }
+
+        pdc_wdt->wdt_clk = devm_clk_get(&pdev->dev, "wdt");
+        if (IS_ERR(pdc_wdt->wdt_clk)) {
+                dev_err(&pdev->dev, "failed to get the wdt clock\n");
+                return PTR_ERR(pdc_wdt->wdt_clk);
+        }
+
+        ret = clk_prepare_enable(pdc_wdt->sys_clk);
+        if (ret) {
+                dev_err(&pdev->dev, "could not prepare or enable sys clock\n");
+                return ret;
+        }
+
+        ret = clk_prepare_enable(pdc_wdt->wdt_clk);
+        if (ret) {
+                dev_err(&pdev->dev, "could not prepare or enable wdt clock\n");
+                goto disable_sys_clk;
+        }
+
+        /* We use the clock rate to calculate the max timeout */
+        clk_rate = clk_get_rate(pdc_wdt->wdt_clk);
+        if (clk_rate == 0) {
+                dev_err(&pdev->dev, "failed to get clock rate\n");
+                ret = -EINVAL;
+                goto disable_wdt_clk;
+        }
+
+        if (order_base_2(clk_rate) > PDC_WDT_CONFIG_DELAY_MASK + 1) {
+                dev_err(&pdev->dev, "invalid clock rate\n");
+                ret = -EINVAL;
+                goto disable_wdt_clk;
+        }
+
+        if (order_base_2(clk_rate) == 0)
+                pdc_wdt->wdt_dev.min_timeout = PDC_WDT_MIN_TIMEOUT + 1;
+        else
+                pdc_wdt->wdt_dev.min_timeout = PDC_WDT_MIN_TIMEOUT;
+
+        pdc_wdt->wdt_dev.info = &pdc_wdt_info;
+        pdc_wdt->wdt_dev.ops = &pdc_wdt_ops;
+        pdc_wdt->wdt_dev.max_timeout = 1 << PDC_WDT_CONFIG_DELAY_MASK;
+        pdc_wdt->wdt_dev.parent = &pdev->dev;
+
+        ret = watchdog_init_timeout(&pdc_wdt->wdt_dev, heartbeat, &pdev->dev);
+        if (ret < 0) {
+                pdc_wdt->wdt_dev.timeout = pdc_wdt->wdt_dev.max_timeout;
+                dev_warn(&pdev->dev,
+                         "Initial timeout out of range! setting max timeout\n");
+        }
+
+        pdc_wdt_stop(&pdc_wdt->wdt_dev);
+
+        /* Find what caused the last reset */
+        val = readl(pdc_wdt->base + PDC_WDT_TICKLE1);
+        val = (val & PDC_WDT_TICKLE_STATUS_MASK) >> PDC_WDT_TICKLE_STATUS_SHIFT;
+        switch (val) {
+        case PDC_WDT_TICKLE_STATUS_TICKLE:
+        case PDC_WDT_TICKLE_STATUS_TIMEOUT:
+                pdc_wdt->wdt_dev.bootstatus |= WDIOF_CARDRESET;
+                dev_info(&pdev->dev,
+                         "watchdog module last reset due to timeout\n");
+                break;
+        case PDC_WDT_TICKLE_STATUS_HRESET:
+                dev_info(&pdev->dev,
+                         "watchdog module last reset due to hard reset\n");
+                break;
+        case PDC_WDT_TICKLE_STATUS_SRESET:
+                dev_info(&pdev->dev,
+                         "watchdog module last reset due to soft reset\n");
+                break;
+        case PDC_WDT_TICKLE_STATUS_USER:
+                dev_info(&pdev->dev,
+                         "watchdog module last reset due to user reset\n");
+                break;
+        default:
+                dev_info(&pdev->dev,
+                         "contains an illegal status code (%08x)\n", val);
+                break;
+        }
+
+        watchdog_set_nowayout(&pdc_wdt->wdt_dev, nowayout);
+
+        platform_set_drvdata(pdev, pdc_wdt);
+        watchdog_set_drvdata(&pdc_wdt->wdt_dev, pdc_wdt);
+
+        ret = watchdog_register_device(&pdc_wdt->wdt_dev);
+        if (ret)
+                goto disable_wdt_clk;
+
+        return 0;
+
+disable_wdt_clk:
+        clk_disable_unprepare(pdc_wdt->wdt_clk);
+disable_sys_clk:
+        clk_disable_unprepare(pdc_wdt->sys_clk);
+        return ret;
+}
+
+static void pdc_wdt_shutdown(struct platform_device *pdev)
+{
+        struct pdc_wdt_dev *pdc_wdt = platform_get_drvdata(pdev);
+
+        pdc_wdt_stop(&pdc_wdt->wdt_dev);
+}
+
+static int pdc_wdt_remove(struct platform_device *pdev)
+{
+        struct pdc_wdt_dev *pdc_wdt = platform_get_drvdata(pdev);
+
+        pdc_wdt_stop(&pdc_wdt->wdt_dev);
+        watchdog_unregister_device(&pdc_wdt->wdt_dev);
+        clk_disable_unprepare(pdc_wdt->wdt_clk);
+        clk_disable_unprepare(pdc_wdt->sys_clk);
+
+        return 0;
+}
+
+static const struct of_device_id pdc_wdt_match[] = {
+        { .compatible = "img,pdc-wdt" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, pdc_wdt_match);
+
+static struct platform_driver pdc_wdt_driver = {
+        .driver = {
+                .name = "imgpdc-wdt",
+                .of_match_table = pdc_wdt_match,
+        },
+        .probe = pdc_wdt_probe,
+        .remove = pdc_wdt_remove,
+        .shutdown = pdc_wdt_shutdown,
+};
+module_platform_driver(pdc_wdt_driver);
+
+MODULE_AUTHOR("Jude Abraham <Jude.Abraham@imgtec.com>");
+MODULE_AUTHOR("Naidu Tellapati <Naidu.Tellapati@imgtec.com>");
+MODULE_DESCRIPTION("Imagination Technologies PDC Watchdog Timer Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/watchdog/imx2_wdt.c b/drivers/watchdog/imx2_wdt.c
index 5142bbabe027..5e6d808d358a 100644
--- a/drivers/watchdog/imx2_wdt.c
+++ b/drivers/watchdog/imx2_wdt.c
@@ -205,7 +205,7 @@ static inline void imx2_wdt_ping_if_active(struct watchdog_device *wdog)
         }
 }
 
-static struct watchdog_ops imx2_wdt_ops = {
+static const struct watchdog_ops imx2_wdt_ops = {
         .owner = THIS_MODULE,
         .start = imx2_wdt_start,
         .stop = imx2_wdt_stop,
@@ -213,7 +213,7 @@ static struct watchdog_ops imx2_wdt_ops = {
         .set_timeout = imx2_wdt_set_timeout,
 };
 
-static struct regmap_config imx2_wdt_regmap_config = {
+static const struct regmap_config imx2_wdt_regmap_config = {
         .reg_bits = 16,
         .reg_stride = 2,
         .val_bits = 16,
diff --git a/drivers/watchdog/it87_wdt.c b/drivers/watchdog/it87_wdt.c
index 0b93739c0106..e54839b12650 100644
--- a/drivers/watchdog/it87_wdt.c
+++ b/drivers/watchdog/it87_wdt.c
@@ -12,8 +12,8 @@
  *                  http://www.ite.com.tw/
  *
  *      Support of the watchdog timers, which are available on
- *      IT8702, IT8712, IT8716, IT8718, IT8720, IT8721, IT8726
- *      and IT8728.
+ *      IT8702, IT8712, IT8716, IT8718, IT8720, IT8721, IT8726,
+ *      IT8728 and IT8783.
  *
  *      This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
@@ -87,6 +87,7 @@
 #define IT8721_ID       0x8721
 #define IT8726_ID       0x8726  /* the data sheet suggest wrongly 0x8716 */
 #define IT8728_ID       0x8728
+#define IT8783_ID       0x8783
 
 /* GPIO Configuration Registers LDN=0x07 */
 #define WDTCTRL         0x71
@@ -633,6 +634,7 @@ static int __init it87_wdt_init(void)
         case IT8720_ID:
         case IT8721_ID:
         case IT8728_ID:
+        case IT8783_ID:
                 max_units = 65535;
                 try_gameport = 0;
                 break;
diff --git a/drivers/watchdog/jz4740_wdt.c b/drivers/watchdog/jz4740_wdt.c
index 18e41afa4da3..4c2cc09c0c57 100644
--- a/drivers/watchdog/jz4740_wdt.c
+++ b/drivers/watchdog/jz4740_wdt.c
@@ -24,6 +24,7 @@
 #include <linux/clk.h>
 #include <linux/slab.h>
 #include <linux/err.h>
+#include <linux/of.h>
 
 #include <asm/mach-jz4740/timer.h>
 
@@ -142,6 +143,14 @@ static const struct watchdog_ops jz4740_wdt_ops = {
         .set_timeout = jz4740_wdt_set_timeout,
 };
 
+#ifdef CONFIG_OF
+static const struct of_device_id jz4740_wdt_of_matches[] = {
+        { .compatible = "ingenic,jz4740-watchdog", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, jz4740_wdt_of_matches)
+#endif
+
 static int jz4740_wdt_probe(struct platform_device *pdev)
 {
         struct jz4740_wdt_drvdata *drvdata;
@@ -211,6 +220,7 @@ static struct platform_driver jz4740_wdt_driver = {
         .remove = jz4740_wdt_remove,
         .driver = {
                 .name = "jz4740-wdt",
+                .of_match_table = of_match_ptr(jz4740_wdt_of_matches),
         },
 };
 
diff --git a/drivers/watchdog/mtk_wdt.c b/drivers/watchdog/mtk_wdt.c
new file mode 100644
index 000000000000..a87f6df6e85f
--- /dev/null
+++ b/drivers/watchdog/mtk_wdt.c
@@ -0,0 +1,251 @@
+/*
+ * Mediatek Watchdog Driver
+ *
+ * Copyright (C) 2014 Matthias Brugger
+ *
+ * Matthias Brugger <matthias.bgg@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.
+ *
+ * Based on sunxi_wdt.c
+ */
+
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/types.h>
+#include <linux/watchdog.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/delay.h>
+
+#define WDT_MAX_TIMEOUT         31
+#define WDT_MIN_TIMEOUT         1
+#define WDT_LENGTH_TIMEOUT(n)   ((n) << 5)
+
+#define WDT_LENGTH              0x04
+#define WDT_LENGTH_KEY          0x8
+
+#define WDT_RST                 0x08
+#define WDT_RST_RELOAD          0x1971
+
+#define WDT_MODE                0x00
+#define WDT_MODE_EN             (1 << 0)
+#define WDT_MODE_EXT_POL_LOW    (0 << 1)
+#define WDT_MODE_EXT_POL_HIGH   (1 << 1)
+#define WDT_MODE_EXRST_EN       (1 << 2)
+#define WDT_MODE_IRQ_EN         (1 << 3)
+#define WDT_MODE_AUTO_START     (1 << 4)
+#define WDT_MODE_DUAL_EN        (1 << 6)
+#define WDT_MODE_KEY            0x22000000
+
+#define WDT_SWRST               0x14
+#define WDT_SWRST_KEY           0x1209
+
+#define DRV_NAME                "mtk-wdt"
+#define DRV_VERSION             "1.0"
+
+static bool nowayout = WATCHDOG_NOWAYOUT;
+static unsigned int timeout = WDT_MAX_TIMEOUT;
+
+struct mtk_wdt_dev {
+        struct watchdog_device wdt_dev;
+        void __iomem *wdt_base;
+        struct notifier_block restart_handler;
+};
+
+static int mtk_reset_handler(struct notifier_block *this, unsigned long mode,
+                                void *cmd)
+{
+        struct mtk_wdt_dev *mtk_wdt;
+        void __iomem *wdt_base;
+
+        mtk_wdt = container_of(this, struct mtk_wdt_dev, restart_handler);
+        wdt_base = mtk_wdt->wdt_base;
+
+        while (1) {
+                writel(WDT_SWRST_KEY, wdt_base + WDT_SWRST);
+                mdelay(5);
+        }
+
+        return NOTIFY_DONE;
+}
+
+static int mtk_wdt_ping(struct watchdog_device *wdt_dev)
+{
+        struct mtk_wdt_dev *mtk_wdt = watchdog_get_drvdata(wdt_dev);
+        void __iomem *wdt_base = mtk_wdt->wdt_base;
+
+        iowrite32(WDT_RST_RELOAD, wdt_base + WDT_RST);
+
+        return 0;
+}
+
+static int mtk_wdt_set_timeout(struct watchdog_device *wdt_dev,
+                                unsigned int timeout)
+{
+        struct mtk_wdt_dev *mtk_wdt = watchdog_get_drvdata(wdt_dev);
+        void __iomem *wdt_base = mtk_wdt->wdt_base;
+        u32 reg;
+
+        wdt_dev->timeout = timeout;
+
+        /*
+         * One bit is the value of 512 ticks
+         * The clock has 32 KHz
+         */
+        reg = WDT_LENGTH_TIMEOUT(timeout << 6) | WDT_LENGTH_KEY;
+        iowrite32(reg, wdt_base + WDT_LENGTH);
+
+        mtk_wdt_ping(wdt_dev);
+
+        return 0;
+}
+
+static int mtk_wdt_stop(struct watchdog_device *wdt_dev)
+{
+        struct mtk_wdt_dev *mtk_wdt = watchdog_get_drvdata(wdt_dev);
+        void __iomem *wdt_base = mtk_wdt->wdt_base;
+        u32 reg;
+
+        reg = readl(wdt_base + WDT_MODE);
+        reg &= ~WDT_MODE_EN;
+        iowrite32(reg, wdt_base + WDT_MODE);
+
+        return 0;
+}
+
+static int mtk_wdt_start(struct watchdog_device *wdt_dev)
+{
+        u32 reg;
+        struct mtk_wdt_dev *mtk_wdt = watchdog_get_drvdata(wdt_dev);
+        void __iomem *wdt_base = mtk_wdt->wdt_base;
+        u32 ret;
+
+        ret = mtk_wdt_set_timeout(wdt_dev, wdt_dev->timeout);
+        if (ret < 0)
+                return ret;
+
+        reg = ioread32(wdt_base + WDT_MODE);
+        reg &= ~(WDT_MODE_IRQ_EN | WDT_MODE_DUAL_EN);
+        reg |= (WDT_MODE_EN | WDT_MODE_KEY);
+        iowrite32(reg, wdt_base + WDT_MODE);
+
+        return 0;
+}
+
+static const struct watchdog_info mtk_wdt_info = {
+        .identity       = DRV_NAME,
+        .options        = WDIOF_SETTIMEOUT |
+                          WDIOF_KEEPALIVEPING |
+                          WDIOF_MAGICCLOSE,
+};
+
+static const struct watchdog_ops mtk_wdt_ops = {
+        .owner          = THIS_MODULE,
+        .start          = mtk_wdt_start,
+        .stop           = mtk_wdt_stop,
+        .ping           = mtk_wdt_ping,
+        .set_timeout    = mtk_wdt_set_timeout,
+};
+
+static int mtk_wdt_probe(struct platform_device *pdev)
+{
+        struct mtk_wdt_dev *mtk_wdt;
+        struct resource *res;
+        int err;
+
+        mtk_wdt = devm_kzalloc(&pdev->dev, sizeof(*mtk_wdt), GFP_KERNEL);
+        if (!mtk_wdt)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, mtk_wdt);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        mtk_wdt->wdt_base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(mtk_wdt->wdt_base))
+                return PTR_ERR(mtk_wdt->wdt_base);
+
+        mtk_wdt->wdt_dev.info = &mtk_wdt_info;
+        mtk_wdt->wdt_dev.ops = &mtk_wdt_ops;
+        mtk_wdt->wdt_dev.timeout = WDT_MAX_TIMEOUT;
+        mtk_wdt->wdt_dev.max_timeout = WDT_MAX_TIMEOUT;
+        mtk_wdt->wdt_dev.min_timeout = WDT_MIN_TIMEOUT;
+        mtk_wdt->wdt_dev.parent = &pdev->dev;
+
+        watchdog_init_timeout(&mtk_wdt->wdt_dev, timeout, &pdev->dev);
+        watchdog_set_nowayout(&mtk_wdt->wdt_dev, nowayout);
+
+        watchdog_set_drvdata(&mtk_wdt->wdt_dev, mtk_wdt);
+
+        mtk_wdt_stop(&mtk_wdt->wdt_dev);
+
+        err = watchdog_register_device(&mtk_wdt->wdt_dev);
+        if (unlikely(err))
+                return err;
+
+        mtk_wdt->restart_handler.notifier_call = mtk_reset_handler;
+        mtk_wdt->restart_handler.priority = 128;
+        err = register_restart_handler(&mtk_wdt->restart_handler);
+        if (err)
+                dev_warn(&pdev->dev,
+                        "cannot register restart handler (err=%d)\n", err);
+
+        dev_info(&pdev->dev, "Watchdog enabled (timeout=%d sec, nowayout=%d)\n",
+                        mtk_wdt->wdt_dev.timeout, nowayout);
+
+        return 0;
+}
+
+static int mtk_wdt_remove(struct platform_device *pdev)
+{
+        struct mtk_wdt_dev *mtk_wdt = platform_get_drvdata(pdev);
+
+        unregister_restart_handler(&mtk_wdt->restart_handler);
+
+        watchdog_unregister_device(&mtk_wdt->wdt_dev);
+
+        return 0;
+}
+
+static const struct of_device_id mtk_wdt_dt_ids[] = {
+        { .compatible = "mediatek,mt6589-wdt" },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mtk_wdt_dt_ids);
+
+static struct platform_driver mtk_wdt_driver = {
+        .probe          = mtk_wdt_probe,
+        .remove         = mtk_wdt_remove,
+        .driver         = {
+                .name           = DRV_NAME,
+                .of_match_table = mtk_wdt_dt_ids,
+        },
+};
+
+module_platform_driver(mtk_wdt_driver);
+
+module_param(timeout, uint, 0);
+MODULE_PARM_DESC(timeout, "Watchdog heartbeat in seconds");
+
+module_param(nowayout, bool, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+                        __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Matthias Brugger <matthias.bgg@gmail.com>");
+MODULE_DESCRIPTION("Mediatek WatchDog Timer Driver");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/watchdog/omap_wdt.c b/drivers/watchdog/omap_wdt.c
index 9f2709db61ca..1e6be9e40577 100644
--- a/drivers/watchdog/omap_wdt.c
+++ b/drivers/watchdog/omap_wdt.c
@@ -189,7 +189,7 @@ static int omap_wdt_set_timeout(struct watchdog_device *wdog,
 }
 
 static const struct watchdog_info omap_wdt_info = {
-        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+        .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
         .identity = "OMAP Watchdog",
 };
 
diff --git a/drivers/watchdog/retu_wdt.c b/drivers/watchdog/retu_wdt.c
index a7a0695971e4..b7c68e275aeb 100644
--- a/drivers/watchdog/retu_wdt.c
+++ b/drivers/watchdog/retu_wdt.c
@@ -94,7 +94,7 @@ static int retu_wdt_set_timeout(struct watchdog_device *wdog,
 }
 
 static const struct watchdog_info retu_wdt_info = {
-        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+        .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
         .identity = "Retu watchdog",
 };
 
diff --git a/drivers/watchdog/rt2880_wdt.c b/drivers/watchdog/rt2880_wdt.c
index 11aad5b7aafe..a6f7e2e29beb 100644
--- a/drivers/watchdog/rt2880_wdt.c
+++ b/drivers/watchdog/rt2880_wdt.c
@@ -45,6 +45,7 @@
 static struct clk *rt288x_wdt_clk;
 static unsigned long rt288x_wdt_freq;
 static void __iomem *rt288x_wdt_base;
+static struct reset_control *rt288x_wdt_reset;
 
 static bool nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, bool, 0);
@@ -151,16 +152,18 @@ static int rt288x_wdt_probe(struct platform_device *pdev)
         if (IS_ERR(rt288x_wdt_clk))
                 return PTR_ERR(rt288x_wdt_clk);
 
-        device_reset(&pdev->dev);
+        rt288x_wdt_reset = devm_reset_control_get(&pdev->dev, NULL);
+        if (!IS_ERR(rt288x_wdt_reset))
+                reset_control_deassert(rt288x_wdt_reset);
 
         rt288x_wdt_freq = clk_get_rate(rt288x_wdt_clk) / RALINK_WDT_PRESCALE;
 
         rt288x_wdt_dev.dev = &pdev->dev;
         rt288x_wdt_dev.bootstatus = rt288x_wdt_bootcause();
-
         rt288x_wdt_dev.max_timeout = (0xfffful / rt288x_wdt_freq);
-        rt288x_wdt_dev.timeout = rt288x_wdt_dev.max_timeout;
 
+        watchdog_init_timeout(&rt288x_wdt_dev, rt288x_wdt_dev.max_timeout,
+                              &pdev->dev);
         watchdog_set_nowayout(&rt288x_wdt_dev, nowayout);
 
         ret = watchdog_register_device(&rt288x_wdt_dev);
diff --git a/drivers/watchdog/twl4030_wdt.c b/drivers/watchdog/twl4030_wdt.c
index 12c15903d098..2c1db6fa9a27 100644
--- a/drivers/watchdog/twl4030_wdt.c
+++ b/drivers/watchdog/twl4030_wdt.c
@@ -57,7 +57,7 @@ static int twl4030_wdt_set_timeout(struct watchdog_device *wdt,
 }
 
 static const struct watchdog_info twl4030_wdt_info = {
-        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+        .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
         .identity = "TWL4030 Watchdog",
 };
 
diff --git a/drivers/watchdog/w83627hf_wdt.c b/drivers/watchdog/w83627hf_wdt.c
index 7165704a3e33..5824e25eebbb 100644
--- a/drivers/watchdog/w83627hf_wdt.c
+++ b/drivers/watchdog/w83627hf_wdt.c
@@ -50,7 +50,7 @@ static int cr_wdt_control;	/* WDT control register */
 
 enum chips { w83627hf, w83627s, w83697hf, w83697ug, w83637hf, w83627thf,
              w83687thf, w83627ehf, w83627dhg, w83627uhg, w83667hg, w83627dhg_p,
-             w83667hg_b, nct6775, nct6776, nct6779 };
+             w83667hg_b, nct6775, nct6776, nct6779, nct6791, nct6792 };
 
 static int timeout;                     /* in seconds */
 module_param(timeout, int, 0);
@@ -95,6 +95,8 @@ MODULE_PARM_DESC(early_disable, "Disable watchdog at boot time (default=0)");
 #define NCT6775_ID              0xb4
 #define NCT6776_ID              0xc3
 #define NCT6779_ID              0xc5
+#define NCT6791_ID              0xc8
+#define NCT6792_ID              0xc9
 
 #define W83627HF_WDT_TIMEOUT    0xf6
 #define W83697HF_WDT_TIMEOUT    0xf4
@@ -195,6 +197,8 @@ static int w83627hf_init(struct watchdog_device *wdog, enum chips chip)
         case nct6775:
         case nct6776:
         case nct6779:
+        case nct6791:
+        case nct6792:
                 /*
                  * These chips have a fixed WDTO# output pin (W83627UHG),
                  * or support more than one WDTO# output pin.
@@ -395,6 +399,12 @@ static int wdt_find(int addr)
         case NCT6779_ID:
                 ret = nct6779;
                 break;
+        case NCT6791_ID:
+                ret = nct6791;
+                break;
+        case NCT6792_ID:
+                ret = nct6792;
+                break;
         case 0xff:
                 ret = -ENODEV;
                 break;
@@ -428,6 +438,8 @@ static int __init wdt_init(void)
                 "NCT6775",
                 "NCT6776",
                 "NCT6779",
+                "NCT6791",
+                "NCT6792",
         };
 
         wdt_io = 0x2e;
diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
index 2140398a2a8c..2ccd3592d41f 100644
--- a/drivers/xen/Makefile
+++ b/drivers/xen/Makefile
@@ -2,7 +2,7 @@ ifeq ($(filter y, $(CONFIG_ARM) $(CONFIG_ARM64)),)
 obj-$(CONFIG_HOTPLUG_CPU)               += cpu_hotplug.o
 endif
 obj-$(CONFIG_X86)                       += fallback.o
-obj-y   += grant-table.o features.o balloon.o manage.o
+obj-y   += grant-table.o features.o balloon.o manage.o preempt.o
 obj-y   += events/
 obj-y   += xenbus/
 
diff --git a/drivers/xen/preempt.c b/drivers/xen/preempt.c
new file mode 100644
index 000000000000..a1800c150839
--- /dev/null
+++ b/drivers/xen/preempt.c
@@ -0,0 +1,44 @@
+/*
+ * Preemptible hypercalls
+ *
+ * Copyright (C) 2014 Citrix Systems R&D ltd.
+ *
+ * This source code 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/sched.h>
+#include <xen/xen-ops.h>
+
+#ifndef CONFIG_PREEMPT
+
+/*
+ * Some hypercalls issued by the toolstack can take many 10s of
+ * seconds. Allow tasks running hypercalls via the privcmd driver to
+ * be voluntarily preempted even if full kernel preemption is
+ * disabled.
+ *
+ * Such preemptible hypercalls are bracketed by
+ * xen_preemptible_hcall_begin() and xen_preemptible_hcall_end()
+ * calls.
+ */
+
+DEFINE_PER_CPU(bool, xen_in_preemptible_hcall);
+EXPORT_SYMBOL_GPL(xen_in_preemptible_hcall);
+
+asmlinkage __visible void xen_maybe_preempt_hcall(void)
+{
+        if (unlikely(__this_cpu_read(xen_in_preemptible_hcall)
+                     && should_resched())) {
+                /*
+                 * Clear flag as we may be rescheduled on a different
+                 * cpu.
+                 */
+                __this_cpu_write(xen_in_preemptible_hcall, false);
+                _cond_resched();
+                __this_cpu_write(xen_in_preemptible_hcall, true);
+        }
+}
+#endif /* CONFIG_PREEMPT */
diff --git a/drivers/xen/privcmd.c b/drivers/xen/privcmd.c
index 569a13b9e856..59ac71c4a043 100644
--- a/drivers/xen/privcmd.c
+++ b/drivers/xen/privcmd.c
@@ -56,10 +56,12 @@ static long privcmd_ioctl_hypercall(void __user *udata)
         if (copy_from_user(&hypercall, udata, sizeof(hypercall)))
                 return -EFAULT;
 
+        xen_preemptible_hcall_begin();
         ret = privcmd_call(hypercall.op,
                            hypercall.arg[0], hypercall.arg[1],
                            hypercall.arg[2], hypercall.arg[3],
                            hypercall.arg[4]);
+        xen_preemptible_hcall_end();
 
         return ret;
 }
diff --git a/drivers/xen/xen-scsiback.c b/drivers/xen/xen-scsiback.c
index 61653a03a8f5..9faca6a60bb0 100644
--- a/drivers/xen/xen-scsiback.c
+++ b/drivers/xen/xen-scsiback.c
@@ -709,12 +709,11 @@ static int prepare_pending_reqs(struct vscsibk_info *info,
 static int scsiback_do_cmd_fn(struct vscsibk_info *info)
 {
         struct vscsiif_back_ring *ring = &info->ring;
-        struct vscsiif_request *ring_req;
+        struct vscsiif_request ring_req;
         struct vscsibk_pend *pending_req;
         RING_IDX rc, rp;
         int err, more_to_do;
         uint32_t result;
-        uint8_t act;
 
         rc = ring->req_cons;
         rp = ring->sring->req_prod;
@@ -735,11 +734,10 @@ static int scsiback_do_cmd_fn(struct vscsibk_info *info)
                 if (!pending_req)
                         return 1;
 
-                ring_req = RING_GET_REQUEST(ring, rc);
+                ring_req = *RING_GET_REQUEST(ring, rc);
                 ring->req_cons = ++rc;
 
-                act = ring_req->act;
-                err = prepare_pending_reqs(info, ring_req, pending_req);
+                err = prepare_pending_reqs(info, &ring_req, pending_req);
                 if (err) {
                         switch (err) {
                         case -ENODEV:
@@ -755,9 +753,9 @@ static int scsiback_do_cmd_fn(struct vscsibk_info *info)
                         return 1;
                 }
 
-                switch (act) {
+                switch (ring_req.act) {
                 case VSCSIIF_ACT_SCSI_CDB:
-                        if (scsiback_gnttab_data_map(ring_req, pending_req)) {
+                        if (scsiback_gnttab_data_map(&ring_req, pending_req)) {
                                 scsiback_fast_flush_area(pending_req);
                                 scsiback_do_resp_with_sense(NULL,
                                         DRIVER_ERROR << 24, 0, pending_req);
@@ -768,7 +766,7 @@ static int scsiback_do_cmd_fn(struct vscsibk_info *info)
                         break;
                 case VSCSIIF_ACT_SCSI_ABORT:
                         scsiback_device_action(pending_req, TMR_ABORT_TASK,
-                                ring_req->ref_rqid);
+                                ring_req.ref_rqid);
                         break;
                 case VSCSIIF_ACT_SCSI_RESET:
                         scsiback_device_action(pending_req, TMR_LUN_RESET, 0);