28 files changed, 1347 insertions, 506 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index c8b453939da2..07abd9d76f7f 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -145,6 +145,17 @@ config EXTRA_FIRMWARE_DIR
           this option you can point it elsewhere, such as /lib/firmware/ or
           some other directory containing the firmware files.
 
+config FW_LOADER_USER_HELPER
+        bool "Fallback user-helper invocation for firmware loading"
+        depends on FW_LOADER
+        default y
+        help
+          This option enables / disables the invocation of user-helper
+          (e.g. udev) for loading firmware files as a fallback after the
+          direct file loading in kernel fails.  The user-mode helper is
+          no longer required unless you have a special firmware file that
+          resides in a non-standard path.
+
 config DEBUG_DRIVER
         bool "Driver Core verbose debug messages"
         depends on DEBUG_KERNEL
diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 5aa2d703d19f..4e22ce3ed73d 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -21,6 +21,7 @@ endif
 obj-$(CONFIG_SYS_HYPERVISOR) += hypervisor.o
 obj-$(CONFIG_REGMAP)    += regmap/
 obj-$(CONFIG_SOC_BUS) += soc.o
+obj-$(CONFIG_PINCTRL) += pinctrl.o
 
 ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
 
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 24eb07868344..519865b53f76 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -290,7 +290,7 @@ int bus_for_each_dev(struct bus_type *bus, struct device *start,
         struct device *dev;
         int error = 0;
 
-        if (!bus)
+        if (!bus || !bus->p)
                 return -EINVAL;
 
         klist_iter_init_node(&bus->p->klist_devices, &i,
@@ -324,7 +324,7 @@ struct device *bus_find_device(struct bus_type *bus,
         struct klist_iter i;
         struct device *dev;
 
-        if (!bus)
+        if (!bus || !bus->p)
                 return NULL;
 
         klist_iter_init_node(&bus->p->klist_devices, &i,
@@ -700,12 +700,12 @@ int bus_add_driver(struct device_driver *drv)
         if (error)
                 goto out_unregister;
 
+        klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
         if (drv->bus->p->drivers_autoprobe) {
                 error = driver_attach(drv);
                 if (error)
                         goto out_unregister;
         }
-        klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
         module_add_driver(drv->owner, drv);
 
         error = driver_create_file(drv, &driver_attr_uevent);
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 03243d4002fd..3ce845471327 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -420,8 +420,8 @@ EXPORT_SYMBOL_GPL(class_for_each_device);
  * code.  There's no locking restriction.
  */
 struct device *class_find_device(struct class *class, struct device *start,
-                                 void *data,
-                                 int (*match)(struct device *, void *))
+                                 const void *data,
+                                 int (*match)(struct device *, const void *))
 {
         struct class_dev_iter iter;
         struct device *dev;
diff --git a/drivers/base/core.c b/drivers/base/core.c
index a235085e343c..56536f4b0f6b 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -1617,9 +1617,9 @@ struct device *device_create(struct class *class, struct device *parent,
 }
 EXPORT_SYMBOL_GPL(device_create);
 
-static int __match_devt(struct device *dev, void *data)
+static int __match_devt(struct device *dev, const void *data)
 {
-        dev_t *devt = data;
+        const dev_t *devt = data;
 
         return dev->devt == *devt;
 }
@@ -1685,8 +1685,6 @@ EXPORT_SYMBOL_GPL(device_destroy);
  */
 int device_rename(struct device *dev, const char *new_name)
 {
-        char *old_class_name = NULL;
-        char *new_class_name = NULL;
         char *old_device_name = NULL;
         int error;
 
@@ -1717,8 +1715,6 @@ int device_rename(struct device *dev, const char *new_name)
 out:
         put_device(dev);
 
-        kfree(new_class_name);
-        kfree(old_class_name);
         kfree(old_device_name);
 
         return error;
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index e3bbed8a617c..bb5645ea0282 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -24,6 +24,7 @@
 #include <linux/wait.h>
 #include <linux/async.h>
 #include <linux/pm_runtime.h>
+#include <linux/pinctrl/devinfo.h>
 
 #include "base.h"
 #include "power/power.h"
@@ -172,6 +173,8 @@ static int deferred_probe_initcall(void)
 
         driver_deferred_probe_enable = true;
         driver_deferred_probe_trigger();
+        /* Sort as many dependencies as possible before exiting initcalls */
+        flush_workqueue(deferred_wq);
         return 0;
 }
 late_initcall(deferred_probe_initcall);
@@ -269,6 +272,12 @@ static int really_probe(struct device *dev, struct device_driver *drv)
         WARN_ON(!list_empty(&dev->devres_head));
 
         dev->driver = drv;
+
+        /* If using pinctrl, bind pins now before probing */
+        ret = pinctrl_bind_pins(dev);
+        if (ret)
+                goto probe_failed;
+
         if (driver_sysfs_add(dev)) {
                 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
                         __func__, dev_name(dev));
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 17cf7cad601e..01fc5b07f951 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -302,7 +302,8 @@ static int handle_remove(const char *nodename, struct device *dev)
 
         if (dentry->d_inode) {
                 struct kstat stat;
-                err = vfs_getattr(parent.mnt, dentry, &stat);
+                struct path p = {.mnt = parent.mnt, .dentry = dentry};
+                err = vfs_getattr(&p, &stat);
                 if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
                         struct iattr newattrs;
                         /*
diff --git a/drivers/base/dma-buf.c b/drivers/base/dma-buf.c
index a3f79c495a41..2a7cb0df176b 100644
--- a/drivers/base/dma-buf.c
+++ b/drivers/base/dma-buf.c
@@ -39,6 +39,8 @@ static int dma_buf_release(struct inode *inode, struct file *file)
 
         dmabuf = file->private_data;
 
+        BUG_ON(dmabuf->vmapping_counter);
+
         dmabuf->ops->release(dmabuf);
         kfree(dmabuf);
         return 0;
@@ -134,15 +136,14 @@ EXPORT_SYMBOL_GPL(dma_buf_export);
  */
 int dma_buf_fd(struct dma_buf *dmabuf, int flags)
 {
-        int error, fd;
+        int fd;
 
         if (!dmabuf || !dmabuf->file)
                 return -EINVAL;
 
-        error = get_unused_fd_flags(flags);
-        if (error < 0)
-                return error;
-        fd = error;
+        fd = get_unused_fd_flags(flags);
+        if (fd < 0)
+                return fd;
 
         fd_install(fd, dmabuf->file);
 
@@ -446,6 +447,9 @@ EXPORT_SYMBOL_GPL(dma_buf_kunmap);
 int dma_buf_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma,
                  unsigned long pgoff)
 {
+        struct file *oldfile;
+        int ret;
+
         if (WARN_ON(!dmabuf || !vma))
                 return -EINVAL;
 
@@ -459,14 +463,22 @@ int dma_buf_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma,
                 return -EINVAL;
 
         /* readjust the vma */
-        if (vma->vm_file)
-                fput(vma->vm_file);
-
-        vma->vm_file = get_file(dmabuf->file);
-
+        get_file(dmabuf->file);
+        oldfile = vma->vm_file;
+        vma->vm_file = dmabuf->file;
         vma->vm_pgoff = pgoff;
 
-        return dmabuf->ops->mmap(dmabuf, vma);
+        ret = dmabuf->ops->mmap(dmabuf, vma);
+        if (ret) {
+                /* restore old parameters on failure */
+                vma->vm_file = oldfile;
+                fput(dmabuf->file);
+        } else {
+                if (oldfile)
+                        fput(oldfile);
+        }
+        return ret;
+
 }
 EXPORT_SYMBOL_GPL(dma_buf_mmap);
 
@@ -482,12 +494,34 @@ EXPORT_SYMBOL_GPL(dma_buf_mmap);
  */
 void *dma_buf_vmap(struct dma_buf *dmabuf)
 {
+        void *ptr;
+
         if (WARN_ON(!dmabuf))
                 return NULL;
 
-        if (dmabuf->ops->vmap)
-                return dmabuf->ops->vmap(dmabuf);
-        return NULL;
+        if (!dmabuf->ops->vmap)
+                return NULL;
+
+        mutex_lock(&dmabuf->lock);
+        if (dmabuf->vmapping_counter) {
+                dmabuf->vmapping_counter++;
+                BUG_ON(!dmabuf->vmap_ptr);
+                ptr = dmabuf->vmap_ptr;
+                goto out_unlock;
+        }
+
+        BUG_ON(dmabuf->vmap_ptr);
+
+        ptr = dmabuf->ops->vmap(dmabuf);
+        if (IS_ERR_OR_NULL(ptr))
+                goto out_unlock;
+
+        dmabuf->vmap_ptr = ptr;
+        dmabuf->vmapping_counter = 1;
+
+out_unlock:
+        mutex_unlock(&dmabuf->lock);
+        return ptr;
 }
 EXPORT_SYMBOL_GPL(dma_buf_vmap);
 
@@ -501,7 +535,16 @@ void dma_buf_vunmap(struct dma_buf *dmabuf, void *vaddr)
         if (WARN_ON(!dmabuf))
                 return;
 
-        if (dmabuf->ops->vunmap)
-                dmabuf->ops->vunmap(dmabuf, vaddr);
+        BUG_ON(!dmabuf->vmap_ptr);
+        BUG_ON(dmabuf->vmapping_counter == 0);
+        BUG_ON(dmabuf->vmap_ptr != vaddr);
+
+        mutex_lock(&dmabuf->lock);
+        if (--dmabuf->vmapping_counter == 0) {
+                if (dmabuf->ops->vunmap)
+                        dmabuf->ops->vunmap(dmabuf, vaddr);
+                dmabuf->vmap_ptr = NULL;
+        }
+        mutex_unlock(&dmabuf->lock);
 }
 EXPORT_SYMBOL_GPL(dma_buf_vunmap);
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index b392b353be39..4b1f9265887f 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -88,11 +88,6 @@ enum {
         FW_STATUS_ABORT,
 };
 
-enum fw_buf_fmt {
-        VMALLOC_BUF,    /* used in direct loading */
-        PAGE_BUF,       /* used in loading via userspace */
-};
-
 static int loading_timeout = 60;        /* In seconds */
 
 static inline long firmware_loading_timeout(void)
@@ -128,12 +123,14 @@ struct firmware_buf {
         struct completion completion;
         struct firmware_cache *fwc;
         unsigned long status;
-        enum fw_buf_fmt fmt;
         void *data;
         size_t size;
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+        bool is_paged_buf;
         struct page **pages;
         int nr_pages;
         int page_array_size;
+#endif
         char fw_id[];
 };
 
@@ -142,14 +139,6 @@ struct fw_cache_entry {
         char name[];
 };
 
-struct firmware_priv {
-        struct delayed_work timeout_work;
-        bool nowait;
-        struct device dev;
-        struct firmware_buf *buf;
-        struct firmware *fw;
-};
-
 struct fw_name_devm {
         unsigned long magic;
         char name[];
@@ -182,7 +171,6 @@ static struct firmware_buf *__allocate_fw_buf(const char *fw_name,
         strcpy(buf->fw_id, fw_name);
         buf->fwc = fwc;
         init_completion(&buf->completion);
-        buf->fmt = VMALLOC_BUF;
 
         pr_debug("%s: fw-%s buf=%p\n", __func__, fw_name, buf);
 
@@ -240,7 +228,6 @@ static void __fw_free_buf(struct kref *ref)
 {
         struct firmware_buf *buf = to_fwbuf(ref);
         struct firmware_cache *fwc = buf->fwc;
-        int i;
 
         pr_debug("%s: fw-%s buf=%p data=%p size=%u\n",
                  __func__, buf->fw_id, buf, buf->data,
@@ -249,13 +236,15 @@ static void __fw_free_buf(struct kref *ref)
         list_del(&buf->list);
         spin_unlock(&fwc->lock);
 
-
-        if (buf->fmt == PAGE_BUF) {
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+        if (buf->is_paged_buf) {
+                int i;
                 vunmap(buf->data);
                 for (i = 0; i < buf->nr_pages; i++)
                         __free_page(buf->pages[i]);
                 kfree(buf->pages);
         } else
+#endif
                 vfree(buf->data);
         kfree(buf);
 }
@@ -290,7 +279,7 @@ MODULE_PARM_DESC(path, "customized firmware image search path with a higher prio
 static noinline_for_stack long fw_file_size(struct file *file)
 {
         struct kstat st;
-        if (vfs_getattr(file->f_path.mnt, file->f_path.dentry, &st))
+        if (vfs_getattr(&file->f_path, &st))
                 return -1;
         if (!S_ISREG(st.mode))
                 return -1;
@@ -319,7 +308,8 @@ static bool fw_read_file_contents(struct file *file, struct firmware_buf *fw_buf
         return true;
 }
 
-static bool fw_get_filesystem_firmware(struct firmware_buf *buf)
+static bool fw_get_filesystem_firmware(struct device *device,
+                                       struct firmware_buf *buf)
 {
         int i;
         bool success = false;
@@ -343,9 +333,114 @@ static bool fw_get_filesystem_firmware(struct firmware_buf *buf)
                         break;
         }
         __putname(path);
+
+        if (success) {
+                dev_dbg(device, "firmware: direct-loading firmware %s\n",
+                        buf->fw_id);
+                mutex_lock(&fw_lock);
+                set_bit(FW_STATUS_DONE, &buf->status);
+                complete_all(&buf->completion);
+                mutex_unlock(&fw_lock);
+        }
+
         return success;
 }
 
+/* firmware holds the ownership of pages */
+static void firmware_free_data(const struct firmware *fw)
+{
+        /* Loaded directly? */
+        if (!fw->priv) {
+                vfree(fw->data);
+                return;
+        }
+        fw_free_buf(fw->priv);
+}
+
+/* store the pages buffer info firmware from buf */
+static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw)
+{
+        fw->priv = buf;
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+        fw->pages = buf->pages;
+#endif
+        fw->size = buf->size;
+        fw->data = buf->data;
+
+        pr_debug("%s: fw-%s buf=%p data=%p size=%u\n",
+                 __func__, buf->fw_id, buf, buf->data,
+                 (unsigned int)buf->size);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static void fw_name_devm_release(struct device *dev, void *res)
+{
+        struct fw_name_devm *fwn = res;
+
+        if (fwn->magic == (unsigned long)&fw_cache)
+                pr_debug("%s: fw_name-%s devm-%p released\n",
+                                __func__, fwn->name, res);
+}
+
+static int fw_devm_match(struct device *dev, void *res,
+                void *match_data)
+{
+        struct fw_name_devm *fwn = res;
+
+        return (fwn->magic == (unsigned long)&fw_cache) &&
+                !strcmp(fwn->name, match_data);
+}
+
+static struct fw_name_devm *fw_find_devm_name(struct device *dev,
+                const char *name)
+{
+        struct fw_name_devm *fwn;
+
+        fwn = devres_find(dev, fw_name_devm_release,
+                          fw_devm_match, (void *)name);
+        return fwn;
+}
+
+/* add firmware name into devres list */
+static int fw_add_devm_name(struct device *dev, const char *name)
+{
+        struct fw_name_devm *fwn;
+
+        fwn = fw_find_devm_name(dev, name);
+        if (fwn)
+                return 1;
+
+        fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm) +
+                           strlen(name) + 1, GFP_KERNEL);
+        if (!fwn)
+                return -ENOMEM;
+
+        fwn->magic = (unsigned long)&fw_cache;
+        strcpy(fwn->name, name);
+        devres_add(dev, fwn);
+
+        return 0;
+}
+#else
+static int fw_add_devm_name(struct device *dev, const char *name)
+{
+        return 0;
+}
+#endif
+
+
+/*
+ * user-mode helper code
+ */
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+struct firmware_priv {
+        struct delayed_work timeout_work;
+        bool nowait;
+        struct device dev;
+        struct firmware_buf *buf;
+        struct firmware *fw;
+};
+
 static struct firmware_priv *to_firmware_priv(struct device *dev)
 {
         return container_of(dev, struct firmware_priv, dev);
@@ -359,6 +454,9 @@ static void fw_load_abort(struct firmware_priv *fw_priv)
         complete_all(&buf->completion);
 }
 
+#define is_fw_load_aborted(buf) \
+        test_bit(FW_STATUS_ABORT, &(buf)->status)
+
 static ssize_t firmware_timeout_show(struct class *class,
                                      struct class_attribute *attr,
                                      char *buf)
@@ -435,17 +533,6 @@ static ssize_t firmware_loading_show(struct device *dev,
         return sprintf(buf, "%d\n", loading);
 }
 
-/* firmware holds the ownership of pages */
-static void firmware_free_data(const struct firmware *fw)
-{
-        /* Loaded directly? */
-        if (!fw->priv) {
-                vfree(fw->data);
-                return;
-        }
-        fw_free_buf(fw->priv);
-}
-
 /* Some architectures don't have PAGE_KERNEL_RO */
 #ifndef PAGE_KERNEL_RO
 #define PAGE_KERNEL_RO PAGE_KERNEL
@@ -454,7 +541,7 @@ static void firmware_free_data(const struct firmware *fw)
 /* one pages buffer should be mapped/unmapped only once */
 static int fw_map_pages_buf(struct firmware_buf *buf)
 {
-        if (buf->fmt != PAGE_BUF)
+        if (!buf->is_paged_buf)
                 return 0;
 
         if (buf->data)
@@ -727,171 +814,16 @@ exit:
         return fw_priv;
 }
 
-/* store the pages buffer info firmware from buf */
-static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw)
-{
-        fw->priv = buf;
-        fw->pages = buf->pages;
-        fw->size = buf->size;
-        fw->data = buf->data;
-
-        pr_debug("%s: fw-%s buf=%p data=%p size=%u\n",
-                 __func__, buf->fw_id, buf, buf->data,
-                 (unsigned int)buf->size);
-}
-
-#ifdef CONFIG_PM_SLEEP
-static void fw_name_devm_release(struct device *dev, void *res)
-{
-        struct fw_name_devm *fwn = res;
-
-        if (fwn->magic == (unsigned long)&fw_cache)
-                pr_debug("%s: fw_name-%s devm-%p released\n",
-                                __func__, fwn->name, res);
-}
-
-static int fw_devm_match(struct device *dev, void *res,
-                void *match_data)
-{
-        struct fw_name_devm *fwn = res;
-
-        return (fwn->magic == (unsigned long)&fw_cache) &&
-                !strcmp(fwn->name, match_data);
-}
-
-static struct fw_name_devm *fw_find_devm_name(struct device *dev,
-                const char *name)
-{
-        struct fw_name_devm *fwn;
-
-        fwn = devres_find(dev, fw_name_devm_release,
-                          fw_devm_match, (void *)name);
-        return fwn;
-}
-
-/* add firmware name into devres list */
-static int fw_add_devm_name(struct device *dev, const char *name)
-{
-        struct fw_name_devm *fwn;
-
-        fwn = fw_find_devm_name(dev, name);
-        if (fwn)
-                return 1;
-
-        fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm) +
-                           strlen(name) + 1, GFP_KERNEL);
-        if (!fwn)
-                return -ENOMEM;
-
-        fwn->magic = (unsigned long)&fw_cache;
-        strcpy(fwn->name, name);
-        devres_add(dev, fwn);
-
-        return 0;
-}
-#else
-static int fw_add_devm_name(struct device *dev, const char *name)
-{
-        return 0;
-}
-#endif
-
-static void _request_firmware_cleanup(const struct firmware **firmware_p)
-{
-        release_firmware(*firmware_p);
-        *firmware_p = NULL;
-}
-
-static struct firmware_priv *
-_request_firmware_prepare(const struct firmware **firmware_p, const char *name,
-                          struct device *device, bool uevent, bool nowait)
-{
-        struct firmware *firmware;
-        struct firmware_priv *fw_priv = NULL;
-        struct firmware_buf *buf;
-        int ret;
-
-        if (!firmware_p)
-                return ERR_PTR(-EINVAL);
-
-        *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
-        if (!firmware) {
-                dev_err(device, "%s: kmalloc(struct firmware) failed\n",
-                        __func__);
-                return ERR_PTR(-ENOMEM);
-        }
-
-        if (fw_get_builtin_firmware(firmware, name)) {
-                dev_dbg(device, "firmware: using built-in firmware %s\n", name);
-                return NULL;
-        }
-
-        ret = fw_lookup_and_allocate_buf(name, &fw_cache, &buf);
-        if (!ret)
-                fw_priv = fw_create_instance(firmware, name, device,
-                                uevent, nowait);
-
-        if (IS_ERR(fw_priv) || ret < 0) {
-                kfree(firmware);
-                *firmware_p = NULL;
-                return ERR_PTR(-ENOMEM);
-        } else if (fw_priv) {
-                fw_priv->buf = buf;
-
-                /*
-                 * bind with 'buf' now to avoid warning in failure path
-                 * of requesting firmware.
-                 */
-                firmware->priv = buf;
-                return fw_priv;
-        }
-
-        /* share the cached buf, which is inprogessing or completed */
- check_status:
-        mutex_lock(&fw_lock);
-        if (test_bit(FW_STATUS_ABORT, &buf->status)) {
-                fw_priv = ERR_PTR(-ENOENT);
-                firmware->priv = buf;
-                _request_firmware_cleanup(firmware_p);
-                goto exit;
-        } else if (test_bit(FW_STATUS_DONE, &buf->status)) {
-                fw_priv = NULL;
-                fw_set_page_data(buf, firmware);
-                goto exit;
-        }
-        mutex_unlock(&fw_lock);
-        wait_for_completion(&buf->completion);
-        goto check_status;
-
-exit:
-        mutex_unlock(&fw_lock);
-        return fw_priv;
-}
-
+/* load a firmware via user helper */
 static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
                                   long timeout)
 {
         int retval = 0;
         struct device *f_dev = &fw_priv->dev;
         struct firmware_buf *buf = fw_priv->buf;
-        struct firmware_cache *fwc = &fw_cache;
-        int direct_load = 0;
-
-        /* try direct loading from fs first */
-        if (fw_get_filesystem_firmware(buf)) {
-                dev_dbg(f_dev->parent, "firmware: direct-loading"
-                        " firmware %s\n", buf->fw_id);
-
-                mutex_lock(&fw_lock);
-                set_bit(FW_STATUS_DONE, &buf->status);
-                mutex_unlock(&fw_lock);
-                complete_all(&buf->completion);
-                direct_load = 1;
-                goto handle_fw;
-        }
 
         /* fall back on userspace loading */
-        buf->fmt = PAGE_BUF;
+        buf->is_paged_buf = true;
 
         dev_set_uevent_suppress(f_dev, true);
 
@@ -929,47 +861,196 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
 
         cancel_delayed_work_sync(&fw_priv->timeout_work);
 
-handle_fw:
+        fw_priv->buf = NULL;
+
+        device_remove_file(f_dev, &dev_attr_loading);
+err_del_bin_attr:
+        device_remove_bin_file(f_dev, &firmware_attr_data);
+err_del_dev:
+        device_del(f_dev);
+err_put_dev:
+        put_device(f_dev);
+        return retval;
+}
+
+static int fw_load_from_user_helper(struct firmware *firmware,
+                                    const char *name, struct device *device,
+                                    bool uevent, bool nowait, long timeout)
+{
+        struct firmware_priv *fw_priv;
+
+        fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
+        if (IS_ERR(fw_priv))
+                return PTR_ERR(fw_priv);
+
+        fw_priv->buf = firmware->priv;
+        return _request_firmware_load(fw_priv, uevent, timeout);
+}
+#else /* CONFIG_FW_LOADER_USER_HELPER */
+static inline int
+fw_load_from_user_helper(struct firmware *firmware, const char *name,
+                         struct device *device, bool uevent, bool nowait,
+                         long timeout)
+{
+        return -ENOENT;
+}
+
+/* No abort during direct loading */
+#define is_fw_load_aborted(buf) false
+
+#endif /* CONFIG_FW_LOADER_USER_HELPER */
+
+
+/* wait until the shared firmware_buf becomes ready (or error) */
+static int sync_cached_firmware_buf(struct firmware_buf *buf)
+{
+        int ret = 0;
+
+        mutex_lock(&fw_lock);
+        while (!test_bit(FW_STATUS_DONE, &buf->status)) {
+                if (is_fw_load_aborted(buf)) {
+                        ret = -ENOENT;
+                        break;
+                }
+                mutex_unlock(&fw_lock);
+                wait_for_completion(&buf->completion);
+                mutex_lock(&fw_lock);
+        }
+        mutex_unlock(&fw_lock);
+        return ret;
+}
+
+/* prepare firmware and firmware_buf structs;
+ * return 0 if a firmware is already assigned, 1 if need to load one,
+ * or a negative error code
+ */
+static int
+_request_firmware_prepare(struct firmware **firmware_p, const char *name,
+                          struct device *device)
+{
+        struct firmware *firmware;
+        struct firmware_buf *buf;
+        int ret;
+
+        *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
+        if (!firmware) {
+                dev_err(device, "%s: kmalloc(struct firmware) failed\n",
+                        __func__);
+                return -ENOMEM;
+        }
+
+        if (fw_get_builtin_firmware(firmware, name)) {
+                dev_dbg(device, "firmware: using built-in firmware %s\n", name);
+                return 0; /* assigned */
+        }
+
+        ret = fw_lookup_and_allocate_buf(name, &fw_cache, &buf);
+
+        /*
+         * bind with 'buf' now to avoid warning in failure path
+         * of requesting firmware.
+         */
+        firmware->priv = buf;
+
+        if (ret > 0) {
+                ret = sync_cached_firmware_buf(buf);
+                if (!ret) {
+                        fw_set_page_data(buf, firmware);
+                        return 0; /* assigned */
+                }
+        }
+
+        if (ret < 0)
+                return ret;
+        return 1; /* need to load */
+}
+
+static int assign_firmware_buf(struct firmware *fw, struct device *device)
+{
+        struct firmware_buf *buf = fw->priv;
+
         mutex_lock(&fw_lock);
-        if (!buf->size || test_bit(FW_STATUS_ABORT, &buf->status))
-                retval = -ENOENT;
+        if (!buf->size || is_fw_load_aborted(buf)) {
+                mutex_unlock(&fw_lock);
+                return -ENOENT;
+        }
 
         /*
          * add firmware name into devres list so that we can auto cache
          * and uncache firmware for device.
          *
-         * f_dev->parent may has been deleted already, but the problem
+         * device may has been deleted already, but the problem
          * should be fixed in devres or driver core.
          */
-        if (!retval && f_dev->parent)
-                fw_add_devm_name(f_dev->parent, buf->fw_id);
+        if (device)
+                fw_add_devm_name(device, buf->fw_id);
 
         /*
          * After caching firmware image is started, let it piggyback
          * on request firmware.
          */
-        if (!retval && fwc->state == FW_LOADER_START_CACHE) {
+        if (buf->fwc->state == FW_LOADER_START_CACHE) {
                 if (fw_cache_piggyback_on_request(buf->fw_id))
                         kref_get(&buf->ref);
         }
 
         /* pass the pages buffer to driver at the last minute */
-        fw_set_page_data(buf, fw_priv->fw);
-
-        fw_priv->buf = NULL;
+        fw_set_page_data(buf, fw);
         mutex_unlock(&fw_lock);
+        return 0;
+}
 
-        if (direct_load)
-                goto err_put_dev;
+/* called from request_firmware() and request_firmware_work_func() */
+static int
+_request_firmware(const struct firmware **firmware_p, const char *name,
+                  struct device *device, bool uevent, bool nowait)
+{
+        struct firmware *fw;
+        long timeout;
+        int ret;
 
-        device_remove_file(f_dev, &dev_attr_loading);
-err_del_bin_attr:
-        device_remove_bin_file(f_dev, &firmware_attr_data);
-err_del_dev:
-        device_del(f_dev);
-err_put_dev:
-        put_device(f_dev);
-        return retval;
+        if (!firmware_p)
+                return -EINVAL;
+
+        ret = _request_firmware_prepare(&fw, name, device);
+        if (ret <= 0) /* error or already assigned */
+                goto out;
+
+        ret = 0;
+        timeout = firmware_loading_timeout();
+        if (nowait) {
+                timeout = usermodehelper_read_lock_wait(timeout);
+                if (!timeout) {
+                        dev_dbg(device, "firmware: %s loading timed out\n",
+                                name);
+                        ret = -EBUSY;
+                        goto out;
+                }
+        } else {
+                ret = usermodehelper_read_trylock();
+                if (WARN_ON(ret)) {
+                        dev_err(device, "firmware: %s will not be loaded\n",
+                                name);
+                        goto out;
+                }
+        }
+
+        if (!fw_get_filesystem_firmware(device, fw->priv))
+                ret = fw_load_from_user_helper(fw, name, device,
+                                               uevent, nowait, timeout);
+        if (!ret)
+                ret = assign_firmware_buf(fw, device);
+
+        usermodehelper_read_unlock();
+
+ out:
+        if (ret < 0) {
+                release_firmware(fw);
+                fw = NULL;
+        }
+
+        *firmware_p = fw;
+        return ret;
 }
 
 /**
@@ -996,26 +1077,7 @@ int
 request_firmware(const struct firmware **firmware_p, const char *name,
                  struct device *device)
 {
-        struct firmware_priv *fw_priv;
-        int ret;
-
-        fw_priv = _request_firmware_prepare(firmware_p, name, device, true,
-                                            false);
-        if (IS_ERR_OR_NULL(fw_priv))
-                return PTR_RET(fw_priv);
-
-        ret = usermodehelper_read_trylock();
-        if (WARN_ON(ret)) {
-                dev_err(device, "firmware: %s will not be loaded\n", name);
-        } else {
-                ret = _request_firmware_load(fw_priv, true,
-                                        firmware_loading_timeout());
-                usermodehelper_read_unlock();
-        }
-        if (ret)
-                _request_firmware_cleanup(firmware_p);
-
-        return ret;
+        return _request_firmware(firmware_p, name, device, true, false);
 }
 
 /**
@@ -1046,33 +1108,13 @@ static void request_firmware_work_func(struct work_struct *work)
 {
         struct firmware_work *fw_work;
         const struct firmware *fw;
-        struct firmware_priv *fw_priv;
-        long timeout;
-        int ret;
 
         fw_work = container_of(work, struct firmware_work, work);
-        fw_priv = _request_firmware_prepare(&fw, fw_work->name, fw_work->device,
-                        fw_work->uevent, true);
-        if (IS_ERR_OR_NULL(fw_priv)) {
-                ret = PTR_RET(fw_priv);
-                goto out;
-        }
-
-        timeout = usermodehelper_read_lock_wait(firmware_loading_timeout());
-        if (timeout) {
-                ret = _request_firmware_load(fw_priv, fw_work->uevent, timeout);
-                usermodehelper_read_unlock();
-        } else {
-                dev_dbg(fw_work->device, "firmware: %s loading timed out\n",
-                        fw_work->name);
-                ret = -EAGAIN;
-        }
-        if (ret)
-                _request_firmware_cleanup(&fw);
 
- out:
+        _request_firmware(&fw, fw_work->name, fw_work->device,
+                          fw_work->uevent, true);
         fw_work->cont(fw, fw_work->context);
-        put_device(fw_work->device);
+        put_device(fw_work->device); /* taken in request_firmware_nowait() */
 
         module_put(fw_work->module);
         kfree(fw_work);
@@ -1474,7 +1516,11 @@ static void __init fw_cache_init(void)
 static int __init firmware_class_init(void)
 {
         fw_cache_init();
+#ifdef CONFIG_FW_LOADER_USER_HELPER
         return class_register(&firmware_class);
+#else
+        return 0;
+#endif
 }
 
 static void __exit firmware_class_exit(void)
@@ -1483,7 +1529,9 @@ static void __exit firmware_class_exit(void)
         unregister_syscore_ops(&fw_syscore_ops);
         unregister_pm_notifier(&fw_cache.pm_notify);
 #endif
+#ifdef CONFIG_FW_LOADER_USER_HELPER
         class_unregister(&firmware_class);
+#endif
 }
 
 fs_initcall(firmware_class_init);
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 987604d56c83..a51007b79032 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -494,8 +494,8 @@ store_hard_offline_page(struct device *dev,
         return ret ? ret : count;
 }
 
-static DEVICE_ATTR(soft_offline_page, 0644, NULL, store_soft_offline_page);
-static DEVICE_ATTR(hard_offline_page, 0644, NULL, store_hard_offline_page);
+static DEVICE_ATTR(soft_offline_page, S_IWUSR, NULL, store_soft_offline_page);
+static DEVICE_ATTR(hard_offline_page, S_IWUSR, NULL, store_hard_offline_page);
 
 static __init int memory_fail_init(void)
 {
@@ -693,6 +693,12 @@ int offline_memory_block(struct memory_block *mem)
         return ret;
 }
 
+/* return true if the memory block is offlined, otherwise, return false */
+bool is_memblock_offlined(struct memory_block *mem)
+{
+        return mem->state == MEM_OFFLINE;
+}
+
 /*
  * Initialize the sysfs support for memory devices...
  */
diff --git a/drivers/base/pinctrl.c b/drivers/base/pinctrl.c
new file mode 100644
index 000000000000..67a274e86727
--- /dev/null
+++ b/drivers/base/pinctrl.c
@@ -0,0 +1,69 @@
+/*
+ * Driver core interface to the pinctrl subsystem.
+ *
+ * Copyright (C) 2012 ST-Ericsson SA
+ * Written on behalf of Linaro for ST-Ericsson
+ * Based on bits of regulator core, gpio core and clk core
+ *
+ * Author: Linus Walleij <linus.walleij@linaro.org>
+ *
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#include <linux/device.h>
+#include <linux/pinctrl/devinfo.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/slab.h>
+
+/**
+ * pinctrl_bind_pins() - called by the device core before probe
+ * @dev: the device that is just about to probe
+ */
+int pinctrl_bind_pins(struct device *dev)
+{
+        int ret;
+
+        dev->pins = devm_kzalloc(dev, sizeof(*(dev->pins)), GFP_KERNEL);
+        if (!dev->pins)
+                return -ENOMEM;
+
+        dev->pins->p = devm_pinctrl_get(dev);
+        if (IS_ERR(dev->pins->p)) {
+                dev_dbg(dev, "no pinctrl handle\n");
+                ret = PTR_ERR(dev->pins->p);
+                goto cleanup_alloc;
+        }
+
+        dev->pins->default_state = pinctrl_lookup_state(dev->pins->p,
+                                        PINCTRL_STATE_DEFAULT);
+        if (IS_ERR(dev->pins->default_state)) {
+                dev_dbg(dev, "no default pinctrl state\n");
+                ret = 0;
+                goto cleanup_get;
+        }
+
+        ret = pinctrl_select_state(dev->pins->p, dev->pins->default_state);
+        if (ret) {
+                dev_dbg(dev, "failed to activate default pinctrl state\n");
+                goto cleanup_get;
+        }
+
+        return 0;
+
+        /*
+         * If no pinctrl handle or default state was found for this device,
+         * let's explicitly free the pin container in the device, there is
+         * no point in keeping it around.
+         */
+cleanup_get:
+        devm_pinctrl_put(dev->pins->p);
+cleanup_alloc:
+        devm_kfree(dev, dev->pins);
+        dev->pins = NULL;
+
+        /* Only return deferrals */
+        if (ret != -EPROBE_DEFER)
+                ret = 0;
+
+        return ret;
+}
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index acc3a8ded29d..9a6b05a35603 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -433,8 +433,7 @@ static bool genpd_abort_poweroff(struct generic_pm_domain *genpd)
  */
 void genpd_queue_power_off_work(struct generic_pm_domain *genpd)
 {
-        if (!work_pending(&genpd->power_off_work))
-                queue_work(pm_wq, &genpd->power_off_work);
+        queue_work(pm_wq, &genpd->power_off_work);
 }
 
 /**
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 2b7f77d3fcb0..15beb500a4e4 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -99,7 +99,6 @@ void device_pm_add(struct device *dev)
                 dev_warn(dev, "parent %s should not be sleeping\n",
                         dev_name(dev->parent));
         list_add_tail(&dev->power.entry, &dpm_list);
-        dev_pm_qos_constraints_init(dev);
         mutex_unlock(&dpm_list_mtx);
 }
 
@@ -113,7 +112,6 @@ void device_pm_remove(struct device *dev)
                  dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
         complete_all(&dev->power.completion);
         mutex_lock(&dpm_list_mtx);
-        dev_pm_qos_constraints_destroy(dev);
         list_del_init(&dev->power.entry);
         mutex_unlock(&dpm_list_mtx);
         device_wakeup_disable(dev);
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index 50b2831e027d..32ee0fc7ea54 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -162,7 +162,7 @@ unsigned long opp_get_voltage(struct opp *opp)
 
         return v;
 }
-EXPORT_SYMBOL(opp_get_voltage);
+EXPORT_SYMBOL_GPL(opp_get_voltage);
 
 /**
  * opp_get_freq() - Gets the frequency corresponding to an available opp
@@ -192,7 +192,7 @@ unsigned long opp_get_freq(struct opp *opp)
 
         return f;
 }
-EXPORT_SYMBOL(opp_get_freq);
+EXPORT_SYMBOL_GPL(opp_get_freq);
 
 /**
  * opp_get_opp_count() - Get number of opps available in the opp list
@@ -225,7 +225,7 @@ int opp_get_opp_count(struct device *dev)
 
         return count;
 }
-EXPORT_SYMBOL(opp_get_opp_count);
+EXPORT_SYMBOL_GPL(opp_get_opp_count);
 
 /**
  * opp_find_freq_exact() - search for an exact frequency
@@ -276,7 +276,7 @@ struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
 
         return opp;
 }
-EXPORT_SYMBOL(opp_find_freq_exact);
+EXPORT_SYMBOL_GPL(opp_find_freq_exact);
 
 /**
  * opp_find_freq_ceil() - Search for an rounded ceil freq
@@ -323,7 +323,7 @@ struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
 
         return opp;
 }
-EXPORT_SYMBOL(opp_find_freq_ceil);
+EXPORT_SYMBOL_GPL(opp_find_freq_ceil);
 
 /**
  * opp_find_freq_floor() - Search for a rounded floor freq
@@ -374,7 +374,7 @@ struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
 
         return opp;
 }
-EXPORT_SYMBOL(opp_find_freq_floor);
+EXPORT_SYMBOL_GPL(opp_find_freq_floor);
 
 /**
  * opp_add()  - Add an OPP table from a table definitions
@@ -568,7 +568,7 @@ int opp_enable(struct device *dev, unsigned long freq)
 {
         return opp_set_availability(dev, freq, true);
 }
-EXPORT_SYMBOL(opp_enable);
+EXPORT_SYMBOL_GPL(opp_enable);
 
 /**
  * opp_disable() - Disable a specific OPP
@@ -590,7 +590,7 @@ int opp_disable(struct device *dev, unsigned long freq)
 {
         return opp_set_availability(dev, freq, false);
 }
-EXPORT_SYMBOL(opp_disable);
+EXPORT_SYMBOL_GPL(opp_disable);
 
 #ifdef CONFIG_CPU_FREQ
 /**
@@ -661,6 +661,7 @@ int opp_init_cpufreq_table(struct device *dev,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(opp_init_cpufreq_table);
 
 /**
  * opp_free_cpufreq_table() - free the cpufreq table
@@ -678,6 +679,7 @@ void opp_free_cpufreq_table(struct device *dev,
         kfree(*table);
         *table = NULL;
 }
+EXPORT_SYMBOL_GPL(opp_free_cpufreq_table);
 #endif          /* CONFIG_CPU_FREQ */
 
 /**
@@ -738,4 +740,5 @@ int of_init_opp_table(struct device *dev)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(of_init_opp_table);
 #endif
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index b16686a0a5a2..cfc3226ec492 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -4,7 +4,7 @@ static inline void device_pm_init_common(struct device *dev)
 {
         if (!dev->power.early_init) {
                 spin_lock_init(&dev->power.lock);
-                dev->power.power_state = PMSG_INVALID;
+                dev->power.qos = NULL;
                 dev->power.early_init = true;
         }
 }
@@ -56,14 +56,10 @@ extern void device_pm_move_last(struct device *);
 
 static inline void device_pm_sleep_init(struct device *dev) {}
 
-static inline void device_pm_add(struct device *dev)
-{
-        dev_pm_qos_constraints_init(dev);
-}
+static inline void device_pm_add(struct device *dev) {}
 
 static inline void device_pm_remove(struct device *dev)
 {
-        dev_pm_qos_constraints_destroy(dev);
         pm_runtime_remove(dev);
 }
 
diff --git a/drivers/base/power/qos.c b/drivers/base/power/qos.c
index d21349544ce5..5f74587ef258 100644
--- a/drivers/base/power/qos.c
+++ b/drivers/base/power/qos.c
@@ -41,6 +41,7 @@
 #include <linux/mutex.h>
 #include <linux/export.h>
 #include <linux/pm_runtime.h>
+#include <linux/err.h>
 
 #include "power.h"
 
@@ -61,7 +62,7 @@ enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev, s32 mask)
         struct pm_qos_flags *pqf;
         s32 val;
 
-        if (!qos)
+        if (IS_ERR_OR_NULL(qos))
                 return PM_QOS_FLAGS_UNDEFINED;
 
         pqf = &qos->flags;
@@ -91,6 +92,7 @@ enum pm_qos_flags_status dev_pm_qos_flags(struct device *dev, s32 mask)
 
         return ret;
 }
+EXPORT_SYMBOL_GPL(dev_pm_qos_flags);
 
 /**
  * __dev_pm_qos_read_value - Get PM QoS constraint for a given device.
@@ -100,7 +102,8 @@ enum pm_qos_flags_status dev_pm_qos_flags(struct device *dev, s32 mask)
  */
 s32 __dev_pm_qos_read_value(struct device *dev)
 {
-        return dev->power.qos ? pm_qos_read_value(&dev->power.qos->latency) : 0;
+        return IS_ERR_OR_NULL(dev->power.qos) ?
+                0 : pm_qos_read_value(&dev->power.qos->latency);
 }
 
 /**
@@ -197,20 +200,8 @@ static int dev_pm_qos_constraints_allocate(struct device *dev)
         return 0;
 }
 
-/**
- * dev_pm_qos_constraints_init - Initalize device's PM QoS constraints pointer.
- * @dev: target device
- *
- * Called from the device PM subsystem during device insertion under
- * device_pm_lock().
- */
-void dev_pm_qos_constraints_init(struct device *dev)
-{
-        mutex_lock(&dev_pm_qos_mtx);
-        dev->power.qos = NULL;
-        dev->power.power_state = PMSG_ON;
-        mutex_unlock(&dev_pm_qos_mtx);
-}
+static void __dev_pm_qos_hide_latency_limit(struct device *dev);
+static void __dev_pm_qos_hide_flags(struct device *dev);
 
 /**
  * dev_pm_qos_constraints_destroy
@@ -225,16 +216,15 @@ void dev_pm_qos_constraints_destroy(struct device *dev)
         struct pm_qos_constraints *c;
         struct pm_qos_flags *f;
 
+        mutex_lock(&dev_pm_qos_mtx);
+
         /*
          * If the device's PM QoS resume latency limit or PM QoS flags have been
          * exposed to user space, they have to be hidden at this point.
          */
-        dev_pm_qos_hide_latency_limit(dev);
-        dev_pm_qos_hide_flags(dev);
+        __dev_pm_qos_hide_latency_limit(dev);
+        __dev_pm_qos_hide_flags(dev);
 
-        mutex_lock(&dev_pm_qos_mtx);
-
-        dev->power.power_state = PMSG_INVALID;
         qos = dev->power.qos;
         if (!qos)
                 goto out;
@@ -256,7 +246,7 @@ void dev_pm_qos_constraints_destroy(struct device *dev)
         }
 
         spin_lock_irq(&dev->power.lock);
-        dev->power.qos = NULL;
+        dev->power.qos = ERR_PTR(-ENODEV);
         spin_unlock_irq(&dev->power.lock);
 
         kfree(c->notifiers);
@@ -300,32 +290,19 @@ int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
                  "%s() called for already added request\n", __func__))
                 return -EINVAL;
 
-        req->dev = dev;
-
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (!dev->power.qos) {
-                if (dev->power.power_state.event == PM_EVENT_INVALID) {
-                        /* The device has been removed from the system. */
-                        req->dev = NULL;
-                        ret = -ENODEV;
-                        goto out;
-                } else {
-                        /*
-                         * Allocate the constraints data on the first call to
-                         * add_request, i.e. only if the data is not already
-                         * allocated and if the device has not been removed.
-                         */
-                        ret = dev_pm_qos_constraints_allocate(dev);
-                }
-        }
+        if (IS_ERR(dev->power.qos))
+                ret = -ENODEV;
+        else if (!dev->power.qos)
+                ret = dev_pm_qos_constraints_allocate(dev);
 
         if (!ret) {
+                req->dev = dev;
                 req->type = type;
                 ret = apply_constraint(req, PM_QOS_ADD_REQ, value);
         }
 
- out:
         mutex_unlock(&dev_pm_qos_mtx);
 
         return ret;
@@ -343,7 +320,14 @@ static int __dev_pm_qos_update_request(struct dev_pm_qos_request *req,
         s32 curr_value;
         int ret = 0;
 
-        if (!req->dev->power.qos)
+        if (!req) /*guard against callers passing in null */
+                return -EINVAL;
+
+        if (WARN(!dev_pm_qos_request_active(req),
+                 "%s() called for unknown object\n", __func__))
+                return -EINVAL;
+
+        if (IS_ERR_OR_NULL(req->dev->power.qos))
                 return -ENODEV;
 
         switch(req->type) {
@@ -385,6 +369,17 @@ int dev_pm_qos_update_request(struct dev_pm_qos_request *req, s32 new_value)
 {
         int ret;
 
+        mutex_lock(&dev_pm_qos_mtx);
+        ret = __dev_pm_qos_update_request(req, new_value);
+        mutex_unlock(&dev_pm_qos_mtx);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
+
+static int __dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
+{
+        int ret;
+
         if (!req) /*guard against callers passing in null */
                 return -EINVAL;
 
@@ -392,13 +387,13 @@ int dev_pm_qos_update_request(struct dev_pm_qos_request *req, s32 new_value)
                  "%s() called for unknown object\n", __func__))
                 return -EINVAL;
 
-        mutex_lock(&dev_pm_qos_mtx);
-        ret = __dev_pm_qos_update_request(req, new_value);
-        mutex_unlock(&dev_pm_qos_mtx);
+        if (IS_ERR_OR_NULL(req->dev->power.qos))
+                return -ENODEV;
 
+        ret = apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
+        memset(req, 0, sizeof(*req));
         return ret;
 }
-EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
 
 /**
  * dev_pm_qos_remove_request - modifies an existing qos request
@@ -417,26 +412,10 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
  */
 int dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
 {
-        int ret = 0;
-
-        if (!req) /*guard against callers passing in null */
-                return -EINVAL;
-
-        if (WARN(!dev_pm_qos_request_active(req),
-                 "%s() called for unknown object\n", __func__))
-                return -EINVAL;
+        int ret;
 
         mutex_lock(&dev_pm_qos_mtx);
-
-        if (req->dev->power.qos) {
-                ret = apply_constraint(req, PM_QOS_REMOVE_REQ,
-                                       PM_QOS_DEFAULT_VALUE);
-                memset(req, 0, sizeof(*req));
-        } else {
-                /* Return if the device has been removed */
-                ret = -ENODEV;
-        }
-
+        ret = __dev_pm_qos_remove_request(req);
         mutex_unlock(&dev_pm_qos_mtx);
         return ret;
 }
@@ -461,9 +440,10 @@ int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier)
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (!dev->power.qos)
-                ret = dev->power.power_state.event != PM_EVENT_INVALID ?
-                        dev_pm_qos_constraints_allocate(dev) : -ENODEV;
+        if (IS_ERR(dev->power.qos))
+                ret = -ENODEV;
+        else if (!dev->power.qos)
+                ret = dev_pm_qos_constraints_allocate(dev);
 
         if (!ret)
                 ret = blocking_notifier_chain_register(
@@ -492,7 +472,7 @@ int dev_pm_qos_remove_notifier(struct device *dev,
         mutex_lock(&dev_pm_qos_mtx);
 
         /* Silently return if the constraints object is not present. */
-        if (dev->power.qos)
+        if (!IS_ERR_OR_NULL(dev->power.qos))
                 retval = blocking_notifier_chain_unregister(
                                 dev->power.qos->latency.notifiers,
                                 notifier);
@@ -562,16 +542,20 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_add_ancestor_request);
 static void __dev_pm_qos_drop_user_request(struct device *dev,
                                            enum dev_pm_qos_req_type type)
 {
+        struct dev_pm_qos_request *req = NULL;
+
         switch(type) {
         case DEV_PM_QOS_LATENCY:
-                dev_pm_qos_remove_request(dev->power.qos->latency_req);
+                req = dev->power.qos->latency_req;
                 dev->power.qos->latency_req = NULL;
                 break;
         case DEV_PM_QOS_FLAGS:
-                dev_pm_qos_remove_request(dev->power.qos->flags_req);
+                req = dev->power.qos->flags_req;
                 dev->power.qos->flags_req = NULL;
                 break;
         }
+        __dev_pm_qos_remove_request(req);
+        kfree(req);
 }
 
 /**
@@ -587,36 +571,57 @@ int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
         if (!device_is_registered(dev) || value < 0)
                 return -EINVAL;
 
-        if (dev->power.qos && dev->power.qos->latency_req)
-                return -EEXIST;
-
         req = kzalloc(sizeof(*req), GFP_KERNEL);
         if (!req)
                 return -ENOMEM;
 
         ret = dev_pm_qos_add_request(dev, req, DEV_PM_QOS_LATENCY, value);
-        if (ret < 0)
+        if (ret < 0) {
+                kfree(req);
                 return ret;
+        }
+
+        mutex_lock(&dev_pm_qos_mtx);
+
+        if (IS_ERR_OR_NULL(dev->power.qos))
+                ret = -ENODEV;
+        else if (dev->power.qos->latency_req)
+                ret = -EEXIST;
+
+        if (ret < 0) {
+                __dev_pm_qos_remove_request(req);
+                kfree(req);
+                goto out;
+        }
 
         dev->power.qos->latency_req = req;
         ret = pm_qos_sysfs_add_latency(dev);
         if (ret)
                 __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_LATENCY);
 
+ out:
+        mutex_unlock(&dev_pm_qos_mtx);
         return ret;
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_expose_latency_limit);
 
+static void __dev_pm_qos_hide_latency_limit(struct device *dev)
+{
+        if (!IS_ERR_OR_NULL(dev->power.qos) && dev->power.qos->latency_req) {
+                pm_qos_sysfs_remove_latency(dev);
+                __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_LATENCY);
+        }
+}
+
 /**
  * dev_pm_qos_hide_latency_limit - Hide PM QoS latency limit from user space.
  * @dev: Device whose PM QoS latency limit is to be hidden from user space.
  */
 void dev_pm_qos_hide_latency_limit(struct device *dev)
 {
-        if (dev->power.qos && dev->power.qos->latency_req) {
-                pm_qos_sysfs_remove_latency(dev);
-                __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_LATENCY);
-        }
+        mutex_lock(&dev_pm_qos_mtx);
+        __dev_pm_qos_hide_latency_limit(dev);
+        mutex_unlock(&dev_pm_qos_mtx);
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_latency_limit);
 
@@ -633,41 +638,61 @@ int dev_pm_qos_expose_flags(struct device *dev, s32 val)
         if (!device_is_registered(dev))
                 return -EINVAL;
 
-        if (dev->power.qos && dev->power.qos->flags_req)
-                return -EEXIST;
-
         req = kzalloc(sizeof(*req), GFP_KERNEL);
         if (!req)
                 return -ENOMEM;
 
-        pm_runtime_get_sync(dev);
         ret = dev_pm_qos_add_request(dev, req, DEV_PM_QOS_FLAGS, val);
-        if (ret < 0)
-                goto fail;
+        if (ret < 0) {
+                kfree(req);
+                return ret;
+        }
+
+        pm_runtime_get_sync(dev);
+        mutex_lock(&dev_pm_qos_mtx);
+
+        if (IS_ERR_OR_NULL(dev->power.qos))
+                ret = -ENODEV;
+        else if (dev->power.qos->flags_req)
+                ret = -EEXIST;
+
+        if (ret < 0) {
+                __dev_pm_qos_remove_request(req);
+                kfree(req);
+                goto out;
+        }
 
         dev->power.qos->flags_req = req;
         ret = pm_qos_sysfs_add_flags(dev);
         if (ret)
                 __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_FLAGS);
 
-fail:
+ out:
+        mutex_unlock(&dev_pm_qos_mtx);
         pm_runtime_put(dev);
         return ret;
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_expose_flags);
 
+static void __dev_pm_qos_hide_flags(struct device *dev)
+{
+        if (!IS_ERR_OR_NULL(dev->power.qos) && dev->power.qos->flags_req) {
+                pm_qos_sysfs_remove_flags(dev);
+                __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_FLAGS);
+        }
+}
+
 /**
  * dev_pm_qos_hide_flags - Hide PM QoS flags of a device from user space.
  * @dev: Device whose PM QoS flags are to be hidden from user space.
  */
 void dev_pm_qos_hide_flags(struct device *dev)
 {
-        if (dev->power.qos && dev->power.qos->flags_req) {
-                pm_qos_sysfs_remove_flags(dev);
-                pm_runtime_get_sync(dev);
-                __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_FLAGS);
-                pm_runtime_put(dev);
-        }
+        pm_runtime_get_sync(dev);
+        mutex_lock(&dev_pm_qos_mtx);
+        __dev_pm_qos_hide_flags(dev);
+        mutex_unlock(&dev_pm_qos_mtx);
+        pm_runtime_put(dev);
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_flags);
 
@@ -682,12 +707,14 @@ int dev_pm_qos_update_flags(struct device *dev, s32 mask, bool set)
         s32 value;
         int ret;
 
-        if (!dev->power.qos || !dev->power.qos->flags_req)
-                return -EINVAL;
-
         pm_runtime_get_sync(dev);
         mutex_lock(&dev_pm_qos_mtx);
 
+        if (IS_ERR_OR_NULL(dev->power.qos) || !dev->power.qos->flags_req) {
+                ret = -EINVAL;
+                goto out;
+        }
+
         value = dev_pm_qos_requested_flags(dev);
         if (set)
                 value |= mask;
@@ -696,9 +723,12 @@ int dev_pm_qos_update_flags(struct device *dev, s32 mask, bool set)
 
         ret = __dev_pm_qos_update_request(dev->power.qos->flags_req, value);
 
+ out:
         mutex_unlock(&dev_pm_qos_mtx);
         pm_runtime_put(dev);
-
         return ret;
 }
+#else /* !CONFIG_PM_RUNTIME */
+static void __dev_pm_qos_hide_latency_limit(struct device *dev) {}
+static void __dev_pm_qos_hide_flags(struct device *dev) {}
 #endif /* CONFIG_PM_RUNTIME */
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 3148b10dc2e5..1244930e3d7a 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -124,6 +124,76 @@ unsigned long pm_runtime_autosuspend_expiration(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(pm_runtime_autosuspend_expiration);
 
+static int dev_memalloc_noio(struct device *dev, void *data)
+{
+        return dev->power.memalloc_noio;
+}
+
+/*
+ * pm_runtime_set_memalloc_noio - Set a device's memalloc_noio flag.
+ * @dev: Device to handle.
+ * @enable: True for setting the flag and False for clearing the flag.
+ *
+ * Set the flag for all devices in the path from the device to the
+ * root device in the device tree if @enable is true, otherwise clear
+ * the flag for devices in the path whose siblings don't set the flag.
+ *
+ * The function should only be called by block device, or network
+ * device driver for solving the deadlock problem during runtime
+ * resume/suspend:
+ *
+ *     If memory allocation with GFP_KERNEL is called inside runtime
+ *     resume/suspend callback of any one of its ancestors(or the
+ *     block device itself), the deadlock may be triggered inside the
+ *     memory allocation since it might not complete until the block
+ *     device becomes active and the involed page I/O finishes. The
+ *     situation is pointed out first by Alan Stern. Network device
+ *     are involved in iSCSI kind of situation.
+ *
+ * The lock of dev_hotplug_mutex is held in the function for handling
+ * hotplug race because pm_runtime_set_memalloc_noio() may be called
+ * in async probe().
+ *
+ * The function should be called between device_add() and device_del()
+ * on the affected device(block/network device).
+ */
+void pm_runtime_set_memalloc_noio(struct device *dev, bool enable)
+{
+        static DEFINE_MUTEX(dev_hotplug_mutex);
+
+        mutex_lock(&dev_hotplug_mutex);
+        for (;;) {
+                bool enabled;
+
+                /* hold power lock since bitfield is not SMP-safe. */
+                spin_lock_irq(&dev->power.lock);
+                enabled = dev->power.memalloc_noio;
+                dev->power.memalloc_noio = enable;
+                spin_unlock_irq(&dev->power.lock);
+
+                /*
+                 * not need to enable ancestors any more if the device
+                 * has been enabled.
+                 */
+                if (enabled && enable)
+                        break;
+
+                dev = dev->parent;
+
+                /*
+                 * clear flag of the parent device only if all the
+                 * children don't set the flag because ancestor's
+                 * flag was set by any one of the descendants.
+                 */
+                if (!dev || (!enable &&
+                             device_for_each_child(dev, NULL,
+                                                   dev_memalloc_noio)))
+                        break;
+        }
+        mutex_unlock(&dev_hotplug_mutex);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_set_memalloc_noio);
+
 /**
  * rpm_check_suspend_allowed - Test whether a device may be suspended.
  * @dev: Device to test.
@@ -278,7 +348,24 @@ static int rpm_callback(int (*cb)(struct device *), struct device *dev)
         if (!cb)
                 return -ENOSYS;
 
-        retval = __rpm_callback(cb, dev);
+        if (dev->power.memalloc_noio) {
+                unsigned int noio_flag;
+
+                /*
+                 * Deadlock might be caused if memory allocation with
+                 * GFP_KERNEL happens inside runtime_suspend and
+                 * runtime_resume callbacks of one block device's
+                 * ancestor or the block device itself. Network
+                 * device might be thought as part of iSCSI block
+                 * device, so network device and its ancestor should
+                 * be marked as memalloc_noio too.
+                 */
+                noio_flag = memalloc_noio_save();
+                retval = __rpm_callback(cb, dev);
+                memalloc_noio_restore(noio_flag);
+        } else {
+                retval = __rpm_callback(cb, dev);
+        }
 
         dev->power.runtime_error = retval;
         return retval != -EACCES ? retval : -EIO;
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index 50d16e3cb0a9..a53ebd265701 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -708,6 +708,7 @@ void rpm_sysfs_remove(struct device *dev)
 
 void dpm_sysfs_remove(struct device *dev)
 {
+        dev_pm_qos_constraints_destroy(dev);
         rpm_sysfs_remove(dev);
         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
         sysfs_remove_group(&dev->kobj, &pm_attr_group);
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index e6ee5e80e546..79715e7fa43e 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -382,6 +382,12 @@ static void wakeup_source_activate(struct wakeup_source *ws)
 {
         unsigned int cec;
 
+        /*
+         * active wakeup source should bring the system
+         * out of PM_SUSPEND_FREEZE state
+         */
+        freeze_wake();
+
         ws->active = true;
         ws->active_count++;
         ws->last_time = ktime_get();
diff --git a/drivers/base/regmap/Makefile b/drivers/base/regmap/Makefile
index 5e75d1b683e2..cf129980abd0 100644
--- a/drivers/base/regmap/Makefile
+++ b/drivers/base/regmap/Makefile
@@ -1,5 +1,5 @@
 obj-$(CONFIG_REGMAP) += regmap.o regcache.o
-obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-lzo.o
+obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-lzo.o regcache-flat.o
 obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o
 obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o
 obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o
diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index 401d1919635a..5a22bd33ce3d 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -16,6 +16,7 @@
 #include <linux/regmap.h>
 #include <linux/fs.h>
 #include <linux/list.h>
+#include <linux/wait.h>
 
 struct regmap;
 struct regcache_ops;
@@ -25,6 +26,7 @@ struct regmap_debugfs_off_cache {
         off_t min;
         off_t max;
         unsigned int base_reg;
+        unsigned int max_reg;
 };
 
 struct regmap_format {
@@ -39,6 +41,13 @@ struct regmap_format {
         unsigned int (*parse_val)(void *buf);
 };
 
+struct regmap_async {
+        struct list_head list;
+        struct work_struct cleanup;
+        struct regmap *map;
+        void *work_buf;
+};
+
 struct regmap {
         struct mutex mutex;
         spinlock_t spinlock;
@@ -53,6 +62,11 @@ struct regmap {
         void *bus_context;
         const char *name;
 
+        spinlock_t async_lock;
+        wait_queue_head_t async_waitq;
+        struct list_head async_list;
+        int async_ret;
+
 #ifdef CONFIG_DEBUG_FS
         struct dentry *debugfs;
         const char *debugfs_name;
@@ -74,6 +88,11 @@ struct regmap {
         const struct regmap_access_table *volatile_table;
         const struct regmap_access_table *precious_table;
 
+        int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
+        int (*reg_write)(void *context, unsigned int reg, unsigned int val);
+
+        bool defer_caching;
+
         u8 read_flag_mask;
         u8 write_flag_mask;
 
@@ -175,7 +194,10 @@ bool regcache_set_val(void *base, unsigned int idx,
                       unsigned int val, unsigned int word_size);
 int regcache_lookup_reg(struct regmap *map, unsigned int reg);
 
+void regmap_async_complete_cb(struct regmap_async *async, int ret);
+
 extern struct regcache_ops regcache_rbtree_ops;
 extern struct regcache_ops regcache_lzo_ops;
+extern struct regcache_ops regcache_flat_ops;
 
 #endif
diff --git a/drivers/base/regmap/regcache-flat.c b/drivers/base/regmap/regcache-flat.c
new file mode 100644
index 000000000000..d9762e41959b
--- /dev/null
+++ b/drivers/base/regmap/regcache-flat.c
@@ -0,0 +1,72 @@
+/*
+ * Register cache access API - flat caching support
+ *
+ * Copyright 2012 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/seq_file.h>
+
+#include "internal.h"
+
+static int regcache_flat_init(struct regmap *map)
+{
+        int i;
+        unsigned int *cache;
+
+        map->cache = kzalloc(sizeof(unsigned int) * (map->max_register + 1),
+                             GFP_KERNEL);
+        if (!map->cache)
+                return -ENOMEM;
+
+        cache = map->cache;
+
+        for (i = 0; i < map->num_reg_defaults; i++)
+                cache[map->reg_defaults[i].reg] = map->reg_defaults[i].def;
+
+        return 0;
+}
+
+static int regcache_flat_exit(struct regmap *map)
+{
+        kfree(map->cache);
+        map->cache = NULL;
+
+        return 0;
+}
+
+static int regcache_flat_read(struct regmap *map,
+                              unsigned int reg, unsigned int *value)
+{
+        unsigned int *cache = map->cache;
+
+        *value = cache[reg];
+
+        return 0;
+}
+
+static int regcache_flat_write(struct regmap *map, unsigned int reg,
+                               unsigned int value)
+{
+        unsigned int *cache = map->cache;
+
+        cache[reg] = value;
+
+        return 0;
+}
+
+struct regcache_ops regcache_flat_ops = {
+        .type = REGCACHE_FLAT,
+        .name = "flat",
+        .init = regcache_flat_init,
+        .exit = regcache_flat_exit,
+        .read = regcache_flat_read,
+        .write = regcache_flat_write,
+};
diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.c
index 835883bda977..e69ff3e4742c 100644
--- a/drivers/base/regmap/regcache.c
+++ b/drivers/base/regmap/regcache.c
@@ -22,6 +22,7 @@
 static const struct regcache_ops *cache_types[] = {
         &regcache_rbtree_ops,
         &regcache_lzo_ops,
+        &regcache_flat_ops,
 };
 
 static int regcache_hw_init(struct regmap *map)
diff --git a/drivers/base/regmap/regmap-debugfs.c b/drivers/base/regmap/regmap-debugfs.c
index d9a6c94ce423..81d6f605c92e 100644
--- a/drivers/base/regmap/regmap-debugfs.c
+++ b/drivers/base/regmap/regmap-debugfs.c
@@ -81,6 +81,8 @@ static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
         struct regmap_debugfs_off_cache *c = NULL;
         loff_t p = 0;
         unsigned int i, ret;
+        unsigned int fpos_offset;
+        unsigned int reg_offset;
 
         /*
          * If we don't have a cache build one so we don't have to do a
@@ -93,6 +95,9 @@ static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
                             regmap_precious(map, i)) {
                                 if (c) {
                                         c->max = p - 1;
+                                        fpos_offset = c->max - c->min;
+                                        reg_offset = fpos_offset / map->debugfs_tot_len;
+                                        c->max_reg = c->base_reg + reg_offset;
                                         list_add_tail(&c->list,
                                                       &map->debugfs_off_cache);
                                         c = NULL;
@@ -119,6 +124,9 @@ static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
         /* Close the last entry off if we didn't scan beyond it */
         if (c) {
                 c->max = p - 1;
+                fpos_offset = c->max - c->min;
+                reg_offset = fpos_offset / map->debugfs_tot_len;
+                c->max_reg = c->base_reg + reg_offset;
                 list_add_tail(&c->list,
                               &map->debugfs_off_cache);
         }
@@ -128,25 +136,38 @@ static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
          * allocate and we should never be in this code if there are
          * no registers at all.
          */
-        if (list_empty(&map->debugfs_off_cache)) {
-                WARN_ON(list_empty(&map->debugfs_off_cache));
-                return base;
-        }
+        WARN_ON(list_empty(&map->debugfs_off_cache));
+        ret = base;
 
-        /* Find the relevant block */
+        /* Find the relevant block:offset */
         list_for_each_entry(c, &map->debugfs_off_cache, list) {
                 if (from >= c->min && from <= c->max) {
-                        *pos = c->min;
-                        return c->base_reg;
+                        fpos_offset = from - c->min;
+                        reg_offset = fpos_offset / map->debugfs_tot_len;
+                        *pos = c->min + (reg_offset * map->debugfs_tot_len);
+                        return c->base_reg + reg_offset;
                 }
 
-                *pos = c->min;
-                ret = c->base_reg;
+                *pos = c->max;
+                ret = c->max_reg;
         }
 
         return ret;
 }
 
+static inline void regmap_calc_tot_len(struct regmap *map,
+                                       void *buf, size_t count)
+{
+        /* Calculate the length of a fixed format  */
+        if (!map->debugfs_tot_len) {
+                map->debugfs_reg_len = regmap_calc_reg_len(map->max_register,
+                                                           buf, count);
+                map->debugfs_val_len = 2 * map->format.val_bytes;
+                map->debugfs_tot_len = map->debugfs_reg_len +
+                        map->debugfs_val_len + 3;      /* : \n */
+        }
+}
+
 static ssize_t regmap_read_debugfs(struct regmap *map, unsigned int from,
                                    unsigned int to, char __user *user_buf,
                                    size_t count, loff_t *ppos)
@@ -165,14 +186,7 @@ static ssize_t regmap_read_debugfs(struct regmap *map, unsigned int from,
         if (!buf)
                 return -ENOMEM;
 
-        /* Calculate the length of a fixed format  */
-        if (!map->debugfs_tot_len) {
-                map->debugfs_reg_len = regmap_calc_reg_len(map->max_register,
-                                                           buf, count);
-                map->debugfs_val_len = 2 * map->format.val_bytes;
-                map->debugfs_tot_len = map->debugfs_reg_len +
-                        map->debugfs_val_len + 3;      /* : \n */
-        }
+        regmap_calc_tot_len(map, buf, count);
 
         /* Work out which register we're starting at */
         start_reg = regmap_debugfs_get_dump_start(map, from, *ppos, &p);
@@ -187,7 +201,7 @@ static ssize_t regmap_read_debugfs(struct regmap *map, unsigned int from,
                 /* If we're in the region the user is trying to read */
                 if (p >= *ppos) {
                         /* ...but not beyond it */
-                        if (buf_pos + 1 + map->debugfs_tot_len >= count)
+                        if (buf_pos + map->debugfs_tot_len > count)
                                 break;
 
                         /* Format the register */
@@ -265,7 +279,7 @@ static ssize_t regmap_map_write_file(struct file *file,
                 return -EINVAL;
 
         /* Userspace has been fiddling around behind the kernel's back */
-        add_taint(TAINT_USER);
+        add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
 
         regmap_write(map, reg, value);
         return buf_size;
diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 5972ad958544..020ea2b9fd2f 100644
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -34,6 +34,7 @@ struct regmap_irq_chip_data {
         int irq;
         int wake_count;
 
+        void *status_reg_buf;
         unsigned int *status_buf;
         unsigned int *mask_buf;
         unsigned int *mask_buf_def;
@@ -87,6 +88,23 @@ static void regmap_irq_sync_unlock(struct irq_data *data)
                 if (ret != 0)
                         dev_err(d->map->dev, "Failed to sync masks in %x\n",
                                 reg);
+
+                reg = d->chip->wake_base +
+                        (i * map->reg_stride * d->irq_reg_stride);
+                if (d->wake_buf) {
+                        if (d->chip->wake_invert)
+                                ret = regmap_update_bits(d->map, reg,
+                                                         d->mask_buf_def[i],
+                                                         ~d->wake_buf[i]);
+                        else
+                                ret = regmap_update_bits(d->map, reg,
+                                                         d->mask_buf_def[i],
+                                                         d->wake_buf[i]);
+                        if (ret != 0)
+                                dev_err(d->map->dev,
+                                        "Failed to sync wakes in %x: %d\n",
+                                        reg, ret);
+                }
         }
 
         if (d->chip->runtime_pm)
@@ -129,16 +147,15 @@ static int regmap_irq_set_wake(struct irq_data *data, unsigned int on)
         struct regmap *map = d->map;
         const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->hwirq);
 
-        if (!d->chip->wake_base)
-                return -EINVAL;
-
         if (on) {
-                d->wake_buf[irq_data->reg_offset / map->reg_stride]
-                        &= ~irq_data->mask;
+                if (d->wake_buf)
+                        d->wake_buf[irq_data->reg_offset / map->reg_stride]
+                                &= ~irq_data->mask;
                 d->wake_count++;
         } else {
-                d->wake_buf[irq_data->reg_offset / map->reg_stride]
-                        |= irq_data->mask;
+                if (d->wake_buf)
+                        d->wake_buf[irq_data->reg_offset / map->reg_stride]
+                                |= irq_data->mask;
                 d->wake_count--;
         }
 
@@ -167,30 +184,75 @@ static irqreturn_t regmap_irq_thread(int irq, void *d)
                 if (ret < 0) {
                         dev_err(map->dev, "IRQ thread failed to resume: %d\n",
                                 ret);
+                        pm_runtime_put(map->dev);
                         return IRQ_NONE;
                 }
         }
 
         /*
-         * Ignore masked IRQs and ack if we need to; we ack early so
-         * there is no race between handling and acknowleding the
-         * interrupt.  We assume that typically few of the interrupts
-         * will fire simultaneously so don't worry about overhead from
-         * doing a write per register.
+         * Read in the statuses, using a single bulk read if possible
+         * in order to reduce the I/O overheads.
          */
-        for (i = 0; i < data->chip->num_regs; i++) {
-                ret = regmap_read(map, chip->status_base + (i * map->reg_stride
-                                   * data->irq_reg_stride),
-                                   &data->status_buf[i]);
+        if (!map->use_single_rw && map->reg_stride == 1 &&
+            data->irq_reg_stride == 1) {
+                u8 *buf8 = data->status_reg_buf;
+                u16 *buf16 = data->status_reg_buf;
+                u32 *buf32 = data->status_reg_buf;
 
+                BUG_ON(!data->status_reg_buf);
+
+                ret = regmap_bulk_read(map, chip->status_base,
+                                       data->status_reg_buf,
+                                       chip->num_regs);
                 if (ret != 0) {
                         dev_err(map->dev, "Failed to read IRQ status: %d\n",
-                                        ret);
-                        if (chip->runtime_pm)
-                                pm_runtime_put(map->dev);
+                                ret);
                         return IRQ_NONE;
                 }
 
+                for (i = 0; i < data->chip->num_regs; i++) {
+                        switch (map->format.val_bytes) {
+                        case 1:
+                                data->status_buf[i] = buf8[i];
+                                break;
+                        case 2:
+                                data->status_buf[i] = buf16[i];
+                                break;
+                        case 4:
+                                data->status_buf[i] = buf32[i];
+                                break;
+                        default:
+                                BUG();
+                                return IRQ_NONE;
+                        }
+                }
+
+        } else {
+                for (i = 0; i < data->chip->num_regs; i++) {
+                        ret = regmap_read(map, chip->status_base +
+                                          (i * map->reg_stride
+                                           * data->irq_reg_stride),
+                                          &data->status_buf[i]);
+
+                        if (ret != 0) {
+                                dev_err(map->dev,
+                                        "Failed to read IRQ status: %d\n",
+                                        ret);
+                                if (chip->runtime_pm)
+                                        pm_runtime_put(map->dev);
+                                return IRQ_NONE;
+                        }
+                }
+        }
+
+        /*
+         * Ignore masked IRQs and ack if we need to; we ack early so
+         * there is no race between handling and acknowleding the
+         * interrupt.  We assume that typically few of the interrupts
+         * will fire simultaneously so don't worry about overhead from
+         * doing a write per register.
+         */
+        for (i = 0; i < data->chip->num_regs; i++) {
                 data->status_buf[i] &= ~data->mask_buf[i];
 
                 if (data->status_buf[i] && chip->ack_base) {
@@ -316,11 +378,6 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
 
         d->irq_chip = regmap_irq_chip;
         d->irq_chip.name = chip->name;
-        if (!chip->wake_base) {
-                d->irq_chip.irq_set_wake = NULL;
-                d->irq_chip.flags |= IRQCHIP_MASK_ON_SUSPEND |
-                                     IRQCHIP_SKIP_SET_WAKE;
-        }
         d->irq = irq;
         d->map = map;
         d->chip = chip;
@@ -331,6 +388,14 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
         else
                 d->irq_reg_stride = 1;
 
+        if (!map->use_single_rw && map->reg_stride == 1 &&
+            d->irq_reg_stride == 1) {
+                d->status_reg_buf = kmalloc(map->format.val_bytes *
+                                            chip->num_regs, GFP_KERNEL);
+                if (!d->status_reg_buf)
+                        goto err_alloc;
+        }
+
         mutex_init(&d->lock);
 
         for (i = 0; i < chip->num_irqs; i++)
@@ -361,8 +426,15 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
                         d->wake_buf[i] = d->mask_buf_def[i];
                         reg = chip->wake_base +
                                 (i * map->reg_stride * d->irq_reg_stride);
-                        ret = regmap_update_bits(map, reg, d->wake_buf[i],
-                                                 d->wake_buf[i]);
+
+                        if (chip->wake_invert)
+                                ret = regmap_update_bits(map, reg,
+                                                         d->mask_buf_def[i],
+                                                         0);
+                        else
+                                ret = regmap_update_bits(map, reg,
+                                                         d->mask_buf_def[i],
+                                                         d->wake_buf[i]);
                         if (ret != 0) {
                                 dev_err(map->dev, "Failed to set masks in 0x%x: %d\n",
                                         reg, ret);
@@ -401,6 +473,7 @@ err_alloc:
         kfree(d->mask_buf_def);
         kfree(d->mask_buf);
         kfree(d->status_buf);
+        kfree(d->status_reg_buf);
         kfree(d);
         return ret;
 }
@@ -422,6 +495,7 @@ void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d)
         kfree(d->wake_buf);
         kfree(d->mask_buf_def);
         kfree(d->mask_buf);
+        kfree(d->status_reg_buf);
         kfree(d->status_buf);
         kfree(d);
 }
diff --git a/drivers/base/regmap/regmap-mmio.c b/drivers/base/regmap/regmap-mmio.c
index f05fc74dd84a..98745dd77e8c 100644
--- a/drivers/base/regmap/regmap-mmio.c
+++ b/drivers/base/regmap/regmap-mmio.c
@@ -16,6 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/io.h>
@@ -26,6 +27,7 @@
 struct regmap_mmio_context {
         void __iomem *regs;
         unsigned val_bytes;
+        struct clk *clk;
 };
 
 static int regmap_mmio_gather_write(void *context,
@@ -34,9 +36,16 @@ static int regmap_mmio_gather_write(void *context,
 {
         struct regmap_mmio_context *ctx = context;
         u32 offset;
+        int ret;
 
         BUG_ON(reg_size != 4);
 
+        if (ctx->clk) {
+                ret = clk_enable(ctx->clk);
+                if (ret < 0)
+                        return ret;
+        }
+
         offset = *(u32 *)reg;
 
         while (val_size) {
@@ -64,6 +73,9 @@ static int regmap_mmio_gather_write(void *context,
                 offset += ctx->val_bytes;
         }
 
+        if (ctx->clk)
+                clk_disable(ctx->clk);
+
         return 0;
 }
 
@@ -80,9 +92,16 @@ static int regmap_mmio_read(void *context,
 {
         struct regmap_mmio_context *ctx = context;
         u32 offset;
+        int ret;
 
         BUG_ON(reg_size != 4);
 
+        if (ctx->clk) {
+                ret = clk_enable(ctx->clk);
+                if (ret < 0)
+                        return ret;
+        }
+
         offset = *(u32 *)reg;
 
         while (val_size) {
@@ -110,11 +129,20 @@ static int regmap_mmio_read(void *context,
                 offset += ctx->val_bytes;
         }
 
+        if (ctx->clk)
+                clk_disable(ctx->clk);
+
         return 0;
 }
 
 static void regmap_mmio_free_context(void *context)
 {
+        struct regmap_mmio_context *ctx = context;
+
+        if (ctx->clk) {
+                clk_unprepare(ctx->clk);
+                clk_put(ctx->clk);
+        }
         kfree(context);
 }
 
@@ -128,11 +156,14 @@ static struct regmap_bus regmap_mmio = {
         .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
 };
 
-static struct regmap_mmio_context *regmap_mmio_gen_context(void __iomem *regs,
+static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev,
+                                        const char *clk_id,
+                                        void __iomem *regs,
                                         const struct regmap_config *config)
 {
         struct regmap_mmio_context *ctx;
         int min_stride;
+        int ret;
 
         if (config->reg_bits != 32)
                 return ERR_PTR(-EINVAL);
@@ -179,37 +210,59 @@ static struct regmap_mmio_context *regmap_mmio_gen_context(void __iomem *regs,
         ctx->regs = regs;
         ctx->val_bytes = config->val_bits / 8;
 
+        if (clk_id == NULL)
+                return ctx;
+
+        ctx->clk = clk_get(dev, clk_id);
+        if (IS_ERR(ctx->clk)) {
+                ret = PTR_ERR(ctx->clk);
+                goto err_free;
+        }
+
+        ret = clk_prepare(ctx->clk);
+        if (ret < 0) {
+                clk_put(ctx->clk);
+                goto err_free;
+        }
+
         return ctx;
+
+err_free:
+        kfree(ctx);
+
+        return ERR_PTR(ret);
 }
 
 /**
- * regmap_init_mmio(): Initialise register map
+ * regmap_init_mmio_clk(): Initialise register map with register clock
  *
  * @dev: Device that will be interacted with
+ * @clk_id: register clock consumer ID
  * @regs: Pointer to memory-mapped IO region
  * @config: Configuration for register map
  *
  * The return value will be an ERR_PTR() on error or a valid pointer to
  * a struct regmap.
  */
-struct regmap *regmap_init_mmio(struct device *dev,
-                                void __iomem *regs,
-                                const struct regmap_config *config)
+struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
+                                    void __iomem *regs,
+                                    const struct regmap_config *config)
 {
         struct regmap_mmio_context *ctx;
 
-        ctx = regmap_mmio_gen_context(regs, config);
+        ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
         if (IS_ERR(ctx))
                 return ERR_CAST(ctx);
 
         return regmap_init(dev, &regmap_mmio, ctx, config);
 }
-EXPORT_SYMBOL_GPL(regmap_init_mmio);
+EXPORT_SYMBOL_GPL(regmap_init_mmio_clk);
 
 /**
- * devm_regmap_init_mmio(): Initialise managed register map
+ * devm_regmap_init_mmio_clk(): Initialise managed register map with clock
  *
  * @dev: Device that will be interacted with
+ * @clk_id: register clock consumer ID
  * @regs: Pointer to memory-mapped IO region
  * @config: Configuration for register map
  *
@@ -217,18 +270,18 @@ EXPORT_SYMBOL_GPL(regmap_init_mmio);
  * to a struct regmap.  The regmap will be automatically freed by the
  * device management code.
  */
-struct regmap *devm_regmap_init_mmio(struct device *dev,
-                                     void __iomem *regs,
-                                     const struct regmap_config *config)
+struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
+                                         void __iomem *regs,
+                                         const struct regmap_config *config)
 {
         struct regmap_mmio_context *ctx;
 
-        ctx = regmap_mmio_gen_context(regs, config);
+        ctx = regmap_mmio_gen_context(dev, clk_id, regs, config);
         if (IS_ERR(ctx))
                 return ERR_CAST(ctx);
 
         return devm_regmap_init(dev, &regmap_mmio, ctx, config);
 }
-EXPORT_SYMBOL_GPL(devm_regmap_init_mmio);
+EXPORT_SYMBOL_GPL(devm_regmap_init_mmio_clk);
 
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/base/regmap/regmap-spi.c b/drivers/base/regmap/regmap-spi.c
index ffa46a92ad33..4c506bd940f3 100644
--- a/drivers/base/regmap/regmap-spi.c
+++ b/drivers/base/regmap/regmap-spi.c
@@ -15,6 +15,21 @@
 #include <linux/init.h>
 #include <linux/module.h>
 
+#include "internal.h"
+
+struct regmap_async_spi {
+        struct regmap_async core;
+        struct spi_message m;
+        struct spi_transfer t[2];
+};
+
+static void regmap_spi_complete(void *data)
+{
+        struct regmap_async_spi *async = data;
+
+        regmap_async_complete_cb(&async->core, async->m.status);
+}
+
 static int regmap_spi_write(void *context, const void *data, size_t count)
 {
         struct device *dev = context;
@@ -40,6 +55,43 @@ static int regmap_spi_gather_write(void *context,
         return spi_sync(spi, &m);
 }
 
+static int regmap_spi_async_write(void *context,
+                                  const void *reg, size_t reg_len,
+                                  const void *val, size_t val_len,
+                                  struct regmap_async *a)
+{
+        struct regmap_async_spi *async = container_of(a,
+                                                      struct regmap_async_spi,
+                                                      core);
+        struct device *dev = context;
+        struct spi_device *spi = to_spi_device(dev);
+
+        async->t[0].tx_buf = reg;
+        async->t[0].len = reg_len;
+        async->t[1].tx_buf = val;
+        async->t[1].len = val_len;
+
+        spi_message_init(&async->m);
+        spi_message_add_tail(&async->t[0], &async->m);
+        spi_message_add_tail(&async->t[1], &async->m);
+
+        async->m.complete = regmap_spi_complete;
+        async->m.context = async;
+
+        return spi_async(spi, &async->m);
+}
+
+static struct regmap_async *regmap_spi_async_alloc(void)
+{
+        struct regmap_async_spi *async_spi;
+
+        async_spi = kzalloc(sizeof(*async_spi), GFP_KERNEL);
+        if (!async_spi)
+                return NULL;
+
+        return &async_spi->core;
+}
+
 static int regmap_spi_read(void *context,
                            const void *reg, size_t reg_size,
                            void *val, size_t val_size)
@@ -53,6 +105,8 @@ static int regmap_spi_read(void *context,
 static struct regmap_bus regmap_spi = {
         .write = regmap_spi_write,
         .gather_write = regmap_spi_gather_write,
+        .async_write = regmap_spi_async_write,
+        .async_alloc = regmap_spi_async_alloc,
         .read = regmap_spi_read,
         .read_flag_mask = 0x80,
 };
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index f00b059c057a..3d2367501fd0 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -16,6 +16,7 @@
 #include <linux/mutex.h>
 #include <linux/err.h>
 #include <linux/rbtree.h>
+#include <linux/sched.h>
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/regmap.h>
@@ -34,6 +35,22 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
                                unsigned int mask, unsigned int val,
                                bool *change);
 
+static int _regmap_bus_read(void *context, unsigned int reg,
+                            unsigned int *val);
+static int _regmap_bus_formatted_write(void *context, unsigned int reg,
+                                       unsigned int val);
+static int _regmap_bus_raw_write(void *context, unsigned int reg,
+                                 unsigned int val);
+
+static void async_cleanup(struct work_struct *work)
+{
+        struct regmap_async *async = container_of(work, struct regmap_async,
+                                                  cleanup);
+
+        kfree(async->work_buf);
+        kfree(async);
+}
+
 bool regmap_reg_in_ranges(unsigned int reg,
                           const struct regmap_range *ranges,
                           unsigned int nranges)
@@ -372,7 +389,7 @@ struct regmap *regmap_init(struct device *dev,
         enum regmap_endian reg_endian, val_endian;
         int i, j;
 
-        if (!bus || !config)
+        if (!config)
                 goto err;
 
         map = kzalloc(sizeof(*map), GFP_KERNEL);
@@ -386,7 +403,8 @@ struct regmap *regmap_init(struct device *dev,
                 map->unlock = config->unlock;
                 map->lock_arg = config->lock_arg;
         } else {
-                if (bus->fast_io) {
+                if ((bus && bus->fast_io) ||
+                    config->fast_io) {
                         spin_lock_init(&map->spinlock);
                         map->lock = regmap_lock_spinlock;
                         map->unlock = regmap_unlock_spinlock;
@@ -423,13 +441,27 @@ struct regmap *regmap_init(struct device *dev,
         map->cache_type = config->cache_type;
         map->name = config->name;
 
+        spin_lock_init(&map->async_lock);
+        INIT_LIST_HEAD(&map->async_list);
+        init_waitqueue_head(&map->async_waitq);
+
         if (config->read_flag_mask || config->write_flag_mask) {
                 map->read_flag_mask = config->read_flag_mask;
                 map->write_flag_mask = config->write_flag_mask;
-        } else {
+        } else if (bus) {
                 map->read_flag_mask = bus->read_flag_mask;
         }
 
+        if (!bus) {
+                map->reg_read  = config->reg_read;
+                map->reg_write = config->reg_write;
+
+                map->defer_caching = false;
+                goto skip_format_initialization;
+        } else {
+                map->reg_read  = _regmap_bus_read;
+        }
+
         reg_endian = config->reg_format_endian;
         if (reg_endian == REGMAP_ENDIAN_DEFAULT)
                 reg_endian = bus->reg_format_endian_default;
@@ -500,6 +532,12 @@ struct regmap *regmap_init(struct device *dev,
                 }
                 break;
 
+        case 24:
+                if (reg_endian != REGMAP_ENDIAN_BIG)
+                        goto err_map;
+                map->format.format_reg = regmap_format_24;
+                break;
+
         case 32:
                 switch (reg_endian) {
                 case REGMAP_ENDIAN_BIG:
@@ -575,6 +613,16 @@ struct regmap *regmap_init(struct device *dev,
                 goto err_map;
         }
 
+        if (map->format.format_write) {
+                map->defer_caching = false;
+                map->reg_write = _regmap_bus_formatted_write;
+        } else if (map->format.format_val) {
+                map->defer_caching = true;
+                map->reg_write = _regmap_bus_raw_write;
+        }
+
+skip_format_initialization:
+
         map->range_tree = RB_ROOT;
         for (i = 0; i < config->num_ranges; i++) {
                 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
@@ -776,7 +824,7 @@ void regmap_exit(struct regmap *map)
         regcache_exit(map);
         regmap_debugfs_exit(map);
         regmap_range_exit(map);
-        if (map->bus->free_context)
+        if (map->bus && map->bus->free_context)
                 map->bus->free_context(map->bus_context);
         kfree(map->work_buf);
         kfree(map);
@@ -870,15 +918,20 @@ static int _regmap_select_page(struct regmap *map, unsigned int *reg,
 }
 
 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
-                             const void *val, size_t val_len)
+                             const void *val, size_t val_len, bool async)
 {
         struct regmap_range_node *range;
+        unsigned long flags;
         u8 *u8 = map->work_buf;
+        void *work_val = map->work_buf + map->format.reg_bytes +
+                map->format.pad_bytes;
         void *buf;
         int ret = -ENOTSUPP;
         size_t len;
         int i;
 
+        BUG_ON(!map->bus);
+
         /* Check for unwritable registers before we start */
         if (map->writeable_reg)
                 for (i = 0; i < val_len / map->format.val_bytes; i++)
@@ -918,7 +971,7 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
                         dev_dbg(map->dev, "Writing window %d/%zu\n",
                                 win_residue, val_len / map->format.val_bytes);
                         ret = _regmap_raw_write(map, reg, val, win_residue *
-                                                map->format.val_bytes);
+                                                map->format.val_bytes, async);
                         if (ret != 0)
                                 return ret;
 
@@ -941,6 +994,50 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
 
         u8[0] |= map->write_flag_mask;
 
+        if (async && map->bus->async_write) {
+                struct regmap_async *async = map->bus->async_alloc();
+                if (!async)
+                        return -ENOMEM;
+
+                async->work_buf = kzalloc(map->format.buf_size,
+                                          GFP_KERNEL | GFP_DMA);
+                if (!async->work_buf) {
+                        kfree(async);
+                        return -ENOMEM;
+                }
+
+                INIT_WORK(&async->cleanup, async_cleanup);
+                async->map = map;
+
+                /* If the caller supplied the value we can use it safely. */
+                memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
+                       map->format.reg_bytes + map->format.val_bytes);
+                if (val == work_val)
+                        val = async->work_buf + map->format.pad_bytes +
+                                map->format.reg_bytes;
+
+                spin_lock_irqsave(&map->async_lock, flags);
+                list_add_tail(&async->list, &map->async_list);
+                spin_unlock_irqrestore(&map->async_lock, flags);
+
+                ret = map->bus->async_write(map->bus_context, async->work_buf,
+                                            map->format.reg_bytes +
+                                            map->format.pad_bytes,
+                                            val, val_len, async);
+
+                if (ret != 0) {
+                        dev_err(map->dev, "Failed to schedule write: %d\n",
+                                ret);
+
+                        spin_lock_irqsave(&map->async_lock, flags);
+                        list_del(&async->list);
+                        spin_unlock_irqrestore(&map->async_lock, flags);
+
+                        kfree(async->work_buf);
+                        kfree(async);
+                }
+        }
+
         trace_regmap_hw_write_start(map->dev, reg,
                                     val_len / map->format.val_bytes);
 
@@ -948,8 +1045,7 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
          * send the work_buf directly, otherwise try to do a gather
          * write.
          */
-        if (val == (map->work_buf + map->format.pad_bytes +
-                    map->format.reg_bytes))
+        if (val == work_val)
                 ret = map->bus->write(map->bus_context, map->work_buf,
                                       map->format.reg_bytes +
                                       map->format.pad_bytes +
@@ -981,14 +1077,62 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
         return ret;
 }
 
+static int _regmap_bus_formatted_write(void *context, unsigned int reg,
+                                       unsigned int val)
+{
+        int ret;
+        struct regmap_range_node *range;
+        struct regmap *map = context;
+
+        BUG_ON(!map->bus || !map->format.format_write);
+
+        range = _regmap_range_lookup(map, reg);
+        if (range) {
+                ret = _regmap_select_page(map, &reg, range, 1);
+                if (ret != 0)
+                        return ret;
+        }
+
+        map->format.format_write(map, reg, val);
+
+        trace_regmap_hw_write_start(map->dev, reg, 1);
+
+        ret = map->bus->write(map->bus_context, map->work_buf,
+                              map->format.buf_size);
+
+        trace_regmap_hw_write_done(map->dev, reg, 1);
+
+        return ret;
+}
+
+static int _regmap_bus_raw_write(void *context, unsigned int reg,
+                                 unsigned int val)
+{
+        struct regmap *map = context;
+
+        BUG_ON(!map->bus || !map->format.format_val);
+
+        map->format.format_val(map->work_buf + map->format.reg_bytes
+                               + map->format.pad_bytes, val, 0);
+        return _regmap_raw_write(map, reg,
+                                 map->work_buf +
+                                 map->format.reg_bytes +
+                                 map->format.pad_bytes,
+                                 map->format.val_bytes, false);
+}
+
+static inline void *_regmap_map_get_context(struct regmap *map)
+{
+        return (map->bus) ? map : map->bus_context;
+}
+
 int _regmap_write(struct regmap *map, unsigned int reg,
                   unsigned int val)
 {
-        struct regmap_range_node *range;
         int ret;
-        BUG_ON(!map->format.format_write && !map->format.format_val);
+        void *context = _regmap_map_get_context(map);
 
-        if (!map->cache_bypass && map->format.format_write) {
+        if (!map->cache_bypass && !map->defer_caching) {
                 ret = regcache_write(map, reg, val);
                 if (ret != 0)
                         return ret;
@@ -1005,33 +1149,7 @@ int _regmap_write(struct regmap *map, unsigned int reg,
 
         trace_regmap_reg_write(map->dev, reg, val);
 
-        if (map->format.format_write) {
-                range = _regmap_range_lookup(map, reg);
-                if (range) {
-                        ret = _regmap_select_page(map, &reg, range, 1);
-                        if (ret != 0)
-                                return ret;
-                }
-
-                map->format.format_write(map, reg, val);
-
-                trace_regmap_hw_write_start(map->dev, reg, 1);
-
-                ret = map->bus->write(map->bus_context, map->work_buf,
-                                      map->format.buf_size);
-
-                trace_regmap_hw_write_done(map->dev, reg, 1);
-
-                return ret;
-        } else {
-                map->format.format_val(map->work_buf + map->format.reg_bytes
-                                       + map->format.pad_bytes, val, 0);
-                return _regmap_raw_write(map, reg,
-                                         map->work_buf +
-                                         map->format.reg_bytes +
-                                         map->format.pad_bytes,
-                                         map->format.val_bytes);
-        }
+        return map->reg_write(context, reg, val);
 }
 
 /**
@@ -1082,6 +1200,8 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
 {
         int ret;
 
+        if (!map->bus)
+                return -EINVAL;
         if (val_len % map->format.val_bytes)
                 return -EINVAL;
         if (reg % map->reg_stride)
@@ -1089,7 +1209,7 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
 
         map->lock(map->lock_arg);
 
-        ret = _regmap_raw_write(map, reg, val, val_len);
+        ret = _regmap_raw_write(map, reg, val, val_len, false);
 
         map->unlock(map->lock_arg);
 
@@ -1118,6 +1238,8 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
         size_t val_bytes = map->format.val_bytes;
         void *wval;
 
+        if (!map->bus)
+                return -EINVAL;
         if (!map->format.parse_val)
                 return -EINVAL;
         if (reg % map->reg_stride)
@@ -1145,14 +1267,15 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
         if (map->use_single_rw) {
                 for (i = 0; i < val_count; i++) {
                         ret = regmap_raw_write(map,
-                                                reg + (i * map->reg_stride),
-                                                val + (i * val_bytes),
-                                                val_bytes);
+                                               reg + (i * map->reg_stride),
+                                               val + (i * val_bytes),
+                                               val_bytes);
                         if (ret != 0)
                                 return ret;
                 }
         } else {
-                ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
+                ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count,
+                                        false);
         }
 
         if (val_bytes != 1)
@@ -1164,6 +1287,48 @@ out:
 }
 EXPORT_SYMBOL_GPL(regmap_bulk_write);
 
+/**
+ * regmap_raw_write_async(): Write raw values to one or more registers
+ *                           asynchronously
+ *
+ * @map: Register map to write to
+ * @reg: Initial register to write to
+ * @val: Block of data to be written, laid out for direct transmission to the
+ *       device.  Must be valid until regmap_async_complete() is called.
+ * @val_len: Length of data pointed to by val.
+ *
+ * This function is intended to be used for things like firmware
+ * download where a large block of data needs to be transferred to the
+ * device.  No formatting will be done on the data provided.
+ *
+ * If supported by the underlying bus the write will be scheduled
+ * asynchronously, helping maximise I/O speed on higher speed buses
+ * like SPI.  regmap_async_complete() can be called to ensure that all
+ * asynchrnous writes have been completed.
+ *
+ * A value of zero will be returned on success, a negative errno will
+ * be returned in error cases.
+ */
+int regmap_raw_write_async(struct regmap *map, unsigned int reg,
+                           const void *val, size_t val_len)
+{
+        int ret;
+
+        if (val_len % map->format.val_bytes)
+                return -EINVAL;
+        if (reg % map->reg_stride)
+                return -EINVAL;
+
+        map->lock(map->lock_arg);
+
+        ret = _regmap_raw_write(map, reg, val, val_len, true);
+
+        map->unlock(map->lock_arg);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(regmap_raw_write_async);
+
 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
                             unsigned int val_len)
 {
@@ -1171,6 +1336,8 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
         u8 *u8 = map->work_buf;
         int ret;
 
+        BUG_ON(!map->bus);
+
         range = _regmap_range_lookup(map, reg);
         if (range) {
                 ret = _regmap_select_page(map, &reg, range,
@@ -1202,10 +1369,29 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
         return ret;
 }
 
+static int _regmap_bus_read(void *context, unsigned int reg,
+                            unsigned int *val)
+{
+        int ret;
+        struct regmap *map = context;
+
+        if (!map->format.parse_val)
+                return -EINVAL;
+
+        ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
+        if (ret == 0)
+                *val = map->format.parse_val(map->work_buf);
+
+        return ret;
+}
+
 static int _regmap_read(struct regmap *map, unsigned int reg,
                         unsigned int *val)
 {
         int ret;
+        void *context = _regmap_map_get_context(map);
+
+        BUG_ON(!map->reg_read);
 
         if (!map->cache_bypass) {
                 ret = regcache_read(map, reg, val);
@@ -1213,26 +1399,21 @@ static int _regmap_read(struct regmap *map, unsigned int reg,
                         return 0;
         }
 
-        if (!map->format.parse_val)
-                return -EINVAL;
-
         if (map->cache_only)
                 return -EBUSY;
 
-        ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
+        ret = map->reg_read(context, reg, val);
         if (ret == 0) {
-                *val = map->format.parse_val(map->work_buf);
-
 #ifdef LOG_DEVICE
                 if (strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
                         dev_info(map->dev, "%x => %x\n", reg, *val);
 #endif
 
                 trace_regmap_reg_read(map->dev, reg, *val);
-        }
 
-        if (ret == 0 && !map->cache_bypass)
-                regcache_write(map, reg, *val);
+                if (!map->cache_bypass)
+                        regcache_write(map, reg, *val);
+        }
 
         return ret;
 }
@@ -1283,6 +1464,8 @@ int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
         unsigned int v;
         int ret, i;
 
+        if (!map->bus)
+                return -EINVAL;
         if (val_len % map->format.val_bytes)
                 return -EINVAL;
         if (reg % map->reg_stride)
@@ -1334,6 +1517,8 @@ int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
         size_t val_bytes = map->format.val_bytes;
         bool vol = regmap_volatile_range(map, reg, val_count);
 
+        if (!map->bus)
+                return -EINVAL;
         if (!map->format.parse_val)
                 return -EINVAL;
         if (reg % map->reg_stride)
@@ -1450,6 +1635,68 @@ int regmap_update_bits_check(struct regmap *map, unsigned int reg,
 }
 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
 
+void regmap_async_complete_cb(struct regmap_async *async, int ret)
+{
+        struct regmap *map = async->map;
+        bool wake;
+
+        spin_lock(&map->async_lock);
+
+        list_del(&async->list);
+        wake = list_empty(&map->async_list);
+
+        if (ret != 0)
+                map->async_ret = ret;
+
+        spin_unlock(&map->async_lock);
+
+        schedule_work(&async->cleanup);
+
+        if (wake)
+                wake_up(&map->async_waitq);
+}
+EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
+
+static int regmap_async_is_done(struct regmap *map)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&map->async_lock, flags);
+        ret = list_empty(&map->async_list);
+        spin_unlock_irqrestore(&map->async_lock, flags);
+
+        return ret;
+}
+
+/**
+ * regmap_async_complete: Ensure all asynchronous I/O has completed.
+ *
+ * @map: Map to operate on.
+ *
+ * Blocks until any pending asynchronous I/O has completed.  Returns
+ * an error code for any failed I/O operations.
+ */
+int regmap_async_complete(struct regmap *map)
+{
+        unsigned long flags;
+        int ret;
+
+        /* Nothing to do with no async support */
+        if (!map->bus->async_write)
+                return 0;
+
+        wait_event(map->async_waitq, regmap_async_is_done(map));
+
+        spin_lock_irqsave(&map->async_lock, flags);
+        ret = map->async_ret;
+        map->async_ret = 0;
+        spin_unlock_irqrestore(&map->async_lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(regmap_async_complete);
+
 /**
  * regmap_register_patch: Register and apply register updates to be applied
  *                        on device initialistion