21 files changed, 1093 insertions, 400 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index b34b5cda5ae1..c8b453939da2 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -57,7 +57,7 @@ config DEVTMPFS_MOUNT
           on the rootfs is completely empty.
 
 config STANDALONE
-        bool "Select only drivers that don't need compile-time external firmware" if EXPERIMENTAL
+        bool "Select only drivers that don't need compile-time external firmware"
         default y
         help
           Select this option if you don't have magic firmware for drivers that
@@ -185,7 +185,6 @@ config DMA_SHARED_BUFFER
         bool
         default n
         select ANON_INODES
-        depends on EXPERIMENTAL
         help
           This option enables the framework for buffer-sharing between
           multiple drivers. A buffer is associated with a file using driver
@@ -193,8 +192,8 @@ config DMA_SHARED_BUFFER
           driver.
 
 config CMA
-        bool "Contiguous Memory Allocator (EXPERIMENTAL)"
-        depends on HAVE_DMA_CONTIGUOUS && HAVE_MEMBLOCK && EXPERIMENTAL
+        bool "Contiguous Memory Allocator"
+        depends on HAVE_DMA_CONTIGUOUS && HAVE_MEMBLOCK
         select MIGRATION
         select MEMORY_ISOLATION
         help
diff --git a/drivers/base/attribute_container.c b/drivers/base/attribute_container.c
index 8fc200b2e2c0..d78b204e65c1 100644
--- a/drivers/base/attribute_container.c
+++ b/drivers/base/attribute_container.c
@@ -158,7 +158,7 @@ attribute_container_add_device(struct device *dev,
 
                 ic = kzalloc(sizeof(*ic), GFP_KERNEL);
                 if (!ic) {
-                        dev_printk(KERN_ERR, dev, "failed to allocate class container\n");
+                        dev_err(dev, "failed to allocate class container\n");
                         continue;
                 }
 
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 181ed2660b33..24eb07868344 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -164,8 +164,6 @@ static const struct kset_uevent_ops bus_uevent_ops = {
 
 static struct kset *bus_kset;
 
-
-#ifdef CONFIG_HOTPLUG
 /* Manually detach a device from its associated driver. */
 static ssize_t driver_unbind(struct device_driver *drv,
                              const char *buf, size_t count)
@@ -252,7 +250,6 @@ static ssize_t store_drivers_probe(struct bus_type *bus,
                 return -EINVAL;
         return count;
 }
-#endif
 
 static struct device *next_device(struct klist_iter *i)
 {
@@ -618,11 +615,6 @@ static void driver_remove_attrs(struct bus_type *bus,
         }
 }
 
-#ifdef CONFIG_HOTPLUG
-/*
- * Thanks to drivers making their tables __devinit, we can't allow manual
- * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
- */
 static int __must_check add_bind_files(struct device_driver *drv)
 {
         int ret;
@@ -666,12 +658,6 @@ static void remove_probe_files(struct bus_type *bus)
         bus_remove_file(bus, &bus_attr_drivers_autoprobe);
         bus_remove_file(bus, &bus_attr_drivers_probe);
 }
-#else
-static inline int add_bind_files(struct device_driver *drv) { return 0; }
-static inline void remove_bind_files(struct device_driver *drv) {}
-static inline int add_probe_files(struct bus_type *bus) { return 0; }
-static inline void remove_probe_files(struct bus_type *bus) {}
-#endif
 
 static ssize_t driver_uevent_store(struct device_driver *drv,
                                    const char *buf, size_t count)
diff --git a/drivers/base/core.c b/drivers/base/core.c
index c8ae1f6b01b9..a235085e343c 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -1201,7 +1201,6 @@ void device_del(struct device *dev)
         if (dev->bus)
                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                              BUS_NOTIFY_DEL_DEVICE, dev);
-        device_pm_remove(dev);
         dpm_sysfs_remove(dev);
         if (parent)
                 klist_del(&dev->p->knode_parent);
@@ -1226,6 +1225,7 @@ void device_del(struct device *dev)
         device_remove_file(dev, &uevent_attr);
         device_remove_attrs(dev);
         bus_remove_device(dev);
+        device_pm_remove(dev);
         driver_deferred_probe_del(dev);
 
         /* Notify the platform of the removal, in case they
@@ -1420,7 +1420,7 @@ struct root_device {
         struct module *owner;
 };
 
-inline struct root_device *to_root_device(struct device *d)
+static inline struct root_device *to_root_device(struct device *d)
 {
         return container_of(d, struct root_device, dev);
 }
@@ -1861,10 +1861,12 @@ void device_shutdown(void)
                 pm_runtime_barrier(dev);
 
                 if (dev->bus && dev->bus->shutdown) {
-                        dev_dbg(dev, "shutdown\n");
+                        if (initcall_debug)
+                                dev_info(dev, "shutdown\n");
                         dev->bus->shutdown(dev);
                 } else if (dev->driver && dev->driver->shutdown) {
-                        dev_dbg(dev, "shutdown\n");
+                        if (initcall_debug)
+                                dev_info(dev, "shutdown\n");
                         dev->driver->shutdown(dev);
                 }
 
diff --git a/drivers/base/devres.c b/drivers/base/devres.c
index 8731979d668a..668390664764 100644
--- a/drivers/base/devres.c
+++ b/drivers/base/devres.c
@@ -50,8 +50,8 @@ static void devres_log(struct device *dev, struct devres_node *node,
                        const char *op)
 {
         if (unlikely(log_devres))
-                dev_printk(KERN_ERR, dev, "DEVRES %3s %p %s (%lu bytes)\n",
-                           op, node, node->name, (unsigned long)node->size);
+                dev_err(dev, "DEVRES %3s %p %s (%lu bytes)\n",
+                        op, node, node->name, (unsigned long)node->size);
 }
 #else /* CONFIG_DEBUG_DEVRES */
 #define set_node_dbginfo(node, n, s)    do {} while (0)
diff --git a/drivers/base/dma-contiguous.c b/drivers/base/dma-contiguous.c
index 612afcc5a938..0ca54421ce97 100644
--- a/drivers/base/dma-contiguous.c
+++ b/drivers/base/dma-contiguous.c
@@ -57,8 +57,8 @@ struct cma *dma_contiguous_default_area;
  * Users, who want to set the size of global CMA area for their system
  * should use cma= kernel parameter.
  */
-static const unsigned long size_bytes = CMA_SIZE_MBYTES * SZ_1M;
-static long size_cmdline = -1;
+static const phys_addr_t size_bytes = CMA_SIZE_MBYTES * SZ_1M;
+static phys_addr_t size_cmdline = -1;
 
 static int __init early_cma(char *p)
 {
@@ -70,7 +70,7 @@ early_param("cma", early_cma);
 
 #ifdef CONFIG_CMA_SIZE_PERCENTAGE
 
-static unsigned long __init __maybe_unused cma_early_percent_memory(void)
+static phys_addr_t __init __maybe_unused cma_early_percent_memory(void)
 {
         struct memblock_region *reg;
         unsigned long total_pages = 0;
@@ -88,7 +88,7 @@ static unsigned long __init __maybe_unused cma_early_percent_memory(void)
 
 #else
 
-static inline __maybe_unused unsigned long cma_early_percent_memory(void)
+static inline __maybe_unused phys_addr_t cma_early_percent_memory(void)
 {
         return 0;
 }
@@ -106,7 +106,7 @@ static inline __maybe_unused unsigned long cma_early_percent_memory(void)
  */
 void __init dma_contiguous_reserve(phys_addr_t limit)
 {
-        unsigned long selected_size = 0;
+        phys_addr_t selected_size = 0;
 
         pr_debug("%s(limit %08lx)\n", __func__, (unsigned long)limit);
 
@@ -126,7 +126,7 @@ void __init dma_contiguous_reserve(phys_addr_t limit)
 
         if (selected_size) {
                 pr_debug("%s: reserving %ld MiB for global area\n", __func__,
-                         selected_size / SZ_1M);
+                         (unsigned long)selected_size / SZ_1M);
 
                 dma_declare_contiguous(NULL, selected_size, 0, limit);
         }
@@ -227,11 +227,11 @@ core_initcall(cma_init_reserved_areas);
  * called by board specific code when early allocator (memblock or bootmem)
  * is still activate.
  */
-int __init dma_declare_contiguous(struct device *dev, unsigned long size,
+int __init dma_declare_contiguous(struct device *dev, phys_addr_t size,
                                   phys_addr_t base, phys_addr_t limit)
 {
         struct cma_reserved *r = &cma_reserved[cma_reserved_count];
-        unsigned long alignment;
+        phys_addr_t alignment;
 
         pr_debug("%s(size %lx, base %08lx, limit %08lx)\n", __func__,
                  (unsigned long)size, (unsigned long)base,
@@ -268,10 +268,6 @@ int __init dma_declare_contiguous(struct device *dev, unsigned long size,
                 if (!addr) {
                         base = -ENOMEM;
                         goto err;
-                } else if (addr + size > ~(unsigned long)0) {
-                        memblock_free(addr, size);
-                        base = -EINVAL;
-                        goto err;
                 } else {
                         base = addr;
                 }
@@ -285,14 +281,14 @@ int __init dma_declare_contiguous(struct device *dev, unsigned long size,
         r->size = size;
         r->dev = dev;
         cma_reserved_count++;
-        pr_info("CMA: reserved %ld MiB at %08lx\n", size / SZ_1M,
+        pr_info("CMA: reserved %ld MiB at %08lx\n", (unsigned long)size / SZ_1M,
                 (unsigned long)base);
 
         /* Architecture specific contiguous memory fixup. */
         dma_contiguous_early_fixup(base, size);
         return 0;
 err:
-        pr_err("CMA: failed to reserve %ld MiB\n", size / SZ_1M);
+        pr_err("CMA: failed to reserve %ld MiB\n", (unsigned long)size / SZ_1M);
         return base;
 }
 
diff --git a/drivers/base/dma-mapping.c b/drivers/base/dma-mapping.c
index 3fbedc75e7c5..0ce39a33b3c2 100644
--- a/drivers/base/dma-mapping.c
+++ b/drivers/base/dma-mapping.c
@@ -218,6 +218,8 @@ void dmam_release_declared_memory(struct device *dev)
 }
 EXPORT_SYMBOL(dmam_release_declared_memory);
 
+#endif
+
 /*
  * Create scatter-list for the already allocated DMA buffer.
  */
@@ -236,8 +238,6 @@ int dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
 }
 EXPORT_SYMBOL(dma_common_get_sgtable);
 
-#endif
-
 /*
  * Create userspace mapping for the DMA-coherent memory.
  */
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 81541452887b..d81460309182 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -36,68 +36,6 @@ MODULE_AUTHOR("Manuel Estrada Sainz");
 MODULE_DESCRIPTION("Multi purpose firmware loading support");
 MODULE_LICENSE("GPL");
 
-static const char *fw_path[] = {
-        "/lib/firmware/updates/" UTS_RELEASE,
-        "/lib/firmware/updates",
-        "/lib/firmware/" UTS_RELEASE,
-        "/lib/firmware"
-};
-
-/* Don't inline this: 'struct kstat' is biggish */
-static noinline long fw_file_size(struct file *file)
-{
-        struct kstat st;
-        if (vfs_getattr(file->f_path.mnt, file->f_path.dentry, &st))
-                return -1;
-        if (!S_ISREG(st.mode))
-                return -1;
-        if (st.size != (long)st.size)
-                return -1;
-        return st.size;
-}
-
-static bool fw_read_file_contents(struct file *file, struct firmware *fw)
-{
-        long size;
-        char *buf;
-
-        size = fw_file_size(file);
-        if (size < 0)
-                return false;
-        buf = vmalloc(size);
-        if (!buf)
-                return false;
-        if (kernel_read(file, 0, buf, size) != size) {
-                vfree(buf);
-                return false;
-        }
-        fw->data = buf;
-        fw->size = size;
-        return true;
-}
-
-static bool fw_get_filesystem_firmware(struct firmware *fw, const char *name)
-{
-        int i;
-        bool success = false;
-        char *path = __getname();
-
-        for (i = 0; i < ARRAY_SIZE(fw_path); i++) {
-                struct file *file;
-                snprintf(path, PATH_MAX, "%s/%s", fw_path[i], name);
-
-                file = filp_open(path, O_RDONLY, 0);
-                if (IS_ERR(file))
-                        continue;
-                success = fw_read_file_contents(file, fw);
-                fput(file);
-                if (success)
-                        break;
-        }
-        __putname(path);
-        return success;
-}
-
 /* Builtin firmware support */
 
 #ifdef CONFIG_FW_LOADER
@@ -150,6 +88,11 @@ 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)
@@ -173,8 +116,6 @@ struct firmware_cache {
         spinlock_t name_lock;
         struct list_head fw_names;
 
-        wait_queue_head_t wait_queue;
-        int cnt;
         struct delayed_work work;
 
         struct notifier_block   pm_notify;
@@ -187,6 +128,7 @@ struct firmware_buf {
         struct completion completion;
         struct firmware_cache *fwc;
         unsigned long status;
+        enum fw_buf_fmt fmt;
         void *data;
         size_t size;
         struct page **pages;
@@ -201,7 +143,7 @@ struct fw_cache_entry {
 };
 
 struct firmware_priv {
-        struct timer_list timeout;
+        struct delayed_work timeout_work;
         bool nowait;
         struct device dev;
         struct firmware_buf *buf;
@@ -240,6 +182,7 @@ 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);
 
@@ -303,20 +246,104 @@ static void __fw_free_buf(struct kref *ref)
                  __func__, buf->fw_id, buf, buf->data,
                  (unsigned int)buf->size);
 
-        spin_lock(&fwc->lock);
         list_del(&buf->list);
         spin_unlock(&fwc->lock);
 
-        vunmap(buf->data);
-        for (i = 0; i < buf->nr_pages; i++)
-                __free_page(buf->pages[i]);
-        kfree(buf->pages);
+
+        if (buf->fmt == PAGE_BUF) {
+                vunmap(buf->data);
+                for (i = 0; i < buf->nr_pages; i++)
+                        __free_page(buf->pages[i]);
+                kfree(buf->pages);
+        } else
+                vfree(buf->data);
         kfree(buf);
 }
 
 static void fw_free_buf(struct firmware_buf *buf)
 {
-        kref_put(&buf->ref, __fw_free_buf);
+        struct firmware_cache *fwc = buf->fwc;
+        spin_lock(&fwc->lock);
+        if (!kref_put(&buf->ref, __fw_free_buf))
+                spin_unlock(&fwc->lock);
+}
+
+/* direct firmware loading support */
+static char fw_path_para[256];
+static const char * const fw_path[] = {
+        fw_path_para,
+        "/lib/firmware/updates/" UTS_RELEASE,
+        "/lib/firmware/updates",
+        "/lib/firmware/" UTS_RELEASE,
+        "/lib/firmware"
+};
+
+/*
+ * Typical usage is that passing 'firmware_class.path=$CUSTOMIZED_PATH'
+ * from kernel command line because firmware_class is generally built in
+ * kernel instead of module.
+ */
+module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);
+MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path");
+
+/* Don't inline this: 'struct kstat' is biggish */
+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))
+                return -1;
+        if (!S_ISREG(st.mode))
+                return -1;
+        if (st.size != (long)st.size)
+                return -1;
+        return st.size;
+}
+
+static bool fw_read_file_contents(struct file *file, struct firmware_buf *fw_buf)
+{
+        long size;
+        char *buf;
+
+        size = fw_file_size(file);
+        if (size < 0)
+                return false;
+        buf = vmalloc(size);
+        if (!buf)
+                return false;
+        if (kernel_read(file, 0, buf, size) != size) {
+                vfree(buf);
+                return false;
+        }
+        fw_buf->data = buf;
+        fw_buf->size = size;
+        return true;
+}
+
+static bool fw_get_filesystem_firmware(struct firmware_buf *buf)
+{
+        int i;
+        bool success = false;
+        char *path = __getname();
+
+        for (i = 0; i < ARRAY_SIZE(fw_path); i++) {
+                struct file *file;
+
+                /* skip the unset customized path */
+                if (!fw_path[i][0])
+                        continue;
+
+                snprintf(path, PATH_MAX, "%s/%s", fw_path[i], buf->fw_id);
+
+                file = filp_open(path, O_RDONLY, 0);
+                if (IS_ERR(file))
+                        continue;
+                success = fw_read_file_contents(file, buf);
+                fput(file);
+                if (success)
+                        break;
+        }
+        __putname(path);
+        return success;
 }
 
 static struct firmware_priv *to_firmware_priv(struct device *dev)
@@ -423,6 +450,21 @@ static void firmware_free_data(const struct firmware *fw)
 #ifndef PAGE_KERNEL_RO
 #define PAGE_KERNEL_RO PAGE_KERNEL
 #endif
+
+/* one pages buffer should be mapped/unmapped only once */
+static int fw_map_pages_buf(struct firmware_buf *buf)
+{
+        if (buf->fmt != PAGE_BUF)
+                return 0;
+
+        if (buf->data)
+                vunmap(buf->data);
+        buf->data = vmap(buf->pages, buf->nr_pages, 0, PAGE_KERNEL_RO);
+        if (!buf->data)
+                return -ENOMEM;
+        return 0;
+}
+
 /**
  * firmware_loading_store - set value in the 'loading' control file
  * @dev: device pointer
@@ -467,6 +509,14 @@ static ssize_t firmware_loading_store(struct device *dev,
                 if (test_bit(FW_STATUS_LOADING, &fw_buf->status)) {
                         set_bit(FW_STATUS_DONE, &fw_buf->status);
                         clear_bit(FW_STATUS_LOADING, &fw_buf->status);
+
+                        /*
+                         * Several loading requests may be pending on
+                         * one same firmware buf, so let all requests
+                         * see the mapped 'buf->data' once the loading
+                         * is completed.
+                         * */
+                        fw_map_pages_buf(fw_buf);
                         complete_all(&fw_buf->completion);
                         break;
                 }
@@ -634,11 +684,18 @@ static struct bin_attribute firmware_attr_data = {
         .write = firmware_data_write,
 };
 
-static void firmware_class_timeout(u_long data)
+static void firmware_class_timeout_work(struct work_struct *work)
 {
-        struct firmware_priv *fw_priv = (struct firmware_priv *) data;
+        struct firmware_priv *fw_priv = container_of(work,
+                        struct firmware_priv, timeout_work.work);
 
+        mutex_lock(&fw_lock);
+        if (test_bit(FW_STATUS_DONE, &(fw_priv->buf->status))) {
+                mutex_unlock(&fw_lock);
+                return;
+        }
         fw_load_abort(fw_priv);
+        mutex_unlock(&fw_lock);
 }
 
 static struct firmware_priv *
@@ -657,8 +714,8 @@ fw_create_instance(struct firmware *firmware, const char *fw_name,
 
         fw_priv->nowait = nowait;
         fw_priv->fw = firmware;
-        setup_timer(&fw_priv->timeout,
-                    firmware_class_timeout, (u_long) fw_priv);
+        INIT_DELAYED_WORK(&fw_priv->timeout_work,
+                firmware_class_timeout_work);
 
         f_dev = &fw_priv->dev;
 
@@ -670,15 +727,6 @@ exit:
         return fw_priv;
 }
 
-/* one pages buffer is mapped/unmapped only once */
-static int fw_map_pages_buf(struct firmware_buf *buf)
-{
-        buf->data = vmap(buf->pages, buf->nr_pages, 0, PAGE_KERNEL_RO);
-        if (!buf->data)
-                return -ENOMEM;
-        return 0;
-}
-
 /* store the pages buffer info firmware from buf */
 static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw)
 {
@@ -778,11 +826,6 @@ _request_firmware_prepare(const struct firmware **firmware_p, const char *name,
                 return NULL;
         }
 
-        if (fw_get_filesystem_firmware(firmware, name)) {
-                dev_dbg(device, "firmware: direct-loading 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,
@@ -832,6 +875,23 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
         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;
 
         dev_set_uevent_suppress(f_dev, true);
 
@@ -860,16 +920,16 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
                 dev_set_uevent_suppress(f_dev, false);
                 dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
                 if (timeout != MAX_SCHEDULE_TIMEOUT)
-                        mod_timer(&fw_priv->timeout,
-                                  round_jiffies_up(jiffies + timeout));
+                        schedule_delayed_work(&fw_priv->timeout_work, timeout);
 
                 kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
         }
 
         wait_for_completion(&buf->completion);
 
-        del_timer_sync(&fw_priv->timeout);
+        cancel_delayed_work_sync(&fw_priv->timeout_work);
 
+handle_fw:
         mutex_lock(&fw_lock);
         if (!buf->size || test_bit(FW_STATUS_ABORT, &buf->status))
                 retval = -ENOENT;
@@ -884,9 +944,6 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
         if (!retval && f_dev->parent)
                 fw_add_devm_name(f_dev->parent, buf->fw_id);
 
-        if (!retval)
-                retval = fw_map_pages_buf(buf);
-
         /*
          * After caching firmware image is started, let it piggyback
          * on request firmware.
@@ -902,6 +959,9 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
         fw_priv->buf = NULL;
         mutex_unlock(&fw_lock);
 
+        if (direct_load)
+                goto err_put_dev;
+
         device_remove_file(f_dev, &dev_attr_loading);
 err_del_bin_attr:
         device_remove_bin_file(f_dev, &firmware_attr_data);
@@ -928,6 +988,9 @@ err_put_dev:
  *      firmware image for this or any other device.
  *
  *      Caller must hold the reference count of @device.
+ *
+ *      The function can be called safely inside device's suspend and
+ *      resume callback.
  **/
 int
 request_firmware(const struct firmware **firmware_p, const char *name,
@@ -1129,6 +1192,8 @@ int uncache_firmware(const char *fw_name)
 }
 
 #ifdef CONFIG_PM_SLEEP
+static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);
+
 static struct fw_cache_entry *alloc_fw_cache_entry(const char *name)
 {
         struct fw_cache_entry *fce;
@@ -1142,17 +1207,27 @@ exit:
         return fce;
 }
 
-static int fw_cache_piggyback_on_request(const char *name)
+static int __fw_entry_found(const char *name)
 {
         struct firmware_cache *fwc = &fw_cache;
         struct fw_cache_entry *fce;
-        int ret = 0;
 
-        spin_lock(&fwc->name_lock);
         list_for_each_entry(fce, &fwc->fw_names, list) {
                 if (!strcmp(fce->name, name))
-                        goto found;
+                        return 1;
         }
+        return 0;
+}
+
+static int fw_cache_piggyback_on_request(const char *name)
+{
+        struct firmware_cache *fwc = &fw_cache;
+        struct fw_cache_entry *fce;
+        int ret = 0;
+
+        spin_lock(&fwc->name_lock);
+        if (__fw_entry_found(name))
+                goto found;
 
         fce = alloc_fw_cache_entry(name);
         if (fce) {
@@ -1185,12 +1260,6 @@ static void __async_dev_cache_fw_image(void *fw_entry,
 
                 free_fw_cache_entry(fce);
         }
-
-        spin_lock(&fwc->name_lock);
-        fwc->cnt--;
-        spin_unlock(&fwc->name_lock);
-
-        wake_up(&fwc->wait_queue);
 }
 
 /* called with dev->devres_lock held */
@@ -1229,11 +1298,19 @@ static void dev_cache_fw_image(struct device *dev, void *data)
                 list_del(&fce->list);
 
                 spin_lock(&fwc->name_lock);
-                fwc->cnt++;
-                list_add(&fce->list, &fwc->fw_names);
+                /* only one cache entry for one firmware */
+                if (!__fw_entry_found(fce->name)) {
+                        list_add(&fce->list, &fwc->fw_names);
+                } else {
+                        free_fw_cache_entry(fce);
+                        fce = NULL;
+                }
                 spin_unlock(&fwc->name_lock);
 
-                async_schedule(__async_dev_cache_fw_image, (void *)fce);
+                if (fce)
+                        async_schedule_domain(__async_dev_cache_fw_image,
+                                              (void *)fce,
+                                              &fw_cache_domain);
         }
 }
 
@@ -1275,6 +1352,9 @@ static void device_cache_fw_images(void)
 
         pr_debug("%s\n", __func__);
 
+        /* cancel uncache work */
+        cancel_delayed_work_sync(&fwc->work);
+
         /*
          * use small loading timeout for caching devices' firmware
          * because all these firmware images have been loaded
@@ -1292,21 +1372,7 @@ static void device_cache_fw_images(void)
         mutex_unlock(&fw_lock);
 
         /* wait for completion of caching firmware for all devices */
-        spin_lock(&fwc->name_lock);
-        for (;;) {
-                prepare_to_wait(&fwc->wait_queue, &wait,
-                                TASK_UNINTERRUPTIBLE);
-                if (!fwc->cnt)
-                        break;
-
-                spin_unlock(&fwc->name_lock);
-
-                schedule();
-
-                spin_lock(&fwc->name_lock);
-        }
-        spin_unlock(&fwc->name_lock);
-        finish_wait(&fwc->wait_queue, &wait);
+        async_synchronize_full_domain(&fw_cache_domain);
 
         loading_timeout = old_timeout;
 }
@@ -1394,9 +1460,7 @@ static void __init fw_cache_init(void)
 #ifdef CONFIG_PM_SLEEP
         spin_lock_init(&fw_cache.name_lock);
         INIT_LIST_HEAD(&fw_cache.fw_names);
-        fw_cache.cnt = 0;
 
-        init_waitqueue_head(&fw_cache.wait_queue);
         INIT_DELAYED_WORK(&fw_cache.work,
                           device_uncache_fw_images_work);
 
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 86c88216a503..987604d56c83 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -70,6 +70,13 @@ void unregister_memory_isolate_notifier(struct notifier_block *nb)
 }
 EXPORT_SYMBOL(unregister_memory_isolate_notifier);
 
+static void memory_block_release(struct device *dev)
+{
+        struct memory_block *mem = container_of(dev, struct memory_block, dev);
+
+        kfree(mem);
+}
+
 /*
  * register_memory - Setup a sysfs device for a memory block
  */
@@ -80,6 +87,7 @@ int register_memory(struct memory_block *memory)
 
         memory->dev.bus = &memory_subsys;
         memory->dev.id = memory->start_section_nr / sections_per_block;
+        memory->dev.release = memory_block_release;
 
         error = device_register(&memory->dev);
         return error;
@@ -246,7 +254,7 @@ static bool pages_correctly_reserved(unsigned long start_pfn,
  * OK to have direct references to sparsemem variables in here.
  */
 static int
-memory_block_action(unsigned long phys_index, unsigned long action)
+memory_block_action(unsigned long phys_index, unsigned long action, int online_type)
 {
         unsigned long start_pfn;
         unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
@@ -261,7 +269,7 @@ memory_block_action(unsigned long phys_index, unsigned long action)
                         if (!pages_correctly_reserved(start_pfn, nr_pages))
                                 return -EBUSY;
 
-                        ret = online_pages(start_pfn, nr_pages);
+                        ret = online_pages(start_pfn, nr_pages, online_type);
                         break;
                 case MEM_OFFLINE:
                         ret = offline_pages(start_pfn, nr_pages);
@@ -276,7 +284,8 @@ memory_block_action(unsigned long phys_index, unsigned long action)
 }
 
 static int __memory_block_change_state(struct memory_block *mem,
-                unsigned long to_state, unsigned long from_state_req)
+                unsigned long to_state, unsigned long from_state_req,
+                int online_type)
 {
         int ret = 0;
 
@@ -288,7 +297,7 @@ static int __memory_block_change_state(struct memory_block *mem,
         if (to_state == MEM_OFFLINE)
                 mem->state = MEM_GOING_OFFLINE;
 
-        ret = memory_block_action(mem->start_section_nr, to_state);
+        ret = memory_block_action(mem->start_section_nr, to_state, online_type);
 
         if (ret) {
                 mem->state = from_state_req;
@@ -311,12 +320,14 @@ out:
 }
 
 static int memory_block_change_state(struct memory_block *mem,
-                unsigned long to_state, unsigned long from_state_req)
+                unsigned long to_state, unsigned long from_state_req,
+                int online_type)
 {
         int ret;
 
         mutex_lock(&mem->state_mutex);
-        ret = __memory_block_change_state(mem, to_state, from_state_req);
+        ret = __memory_block_change_state(mem, to_state, from_state_req,
+                                          online_type);
         mutex_unlock(&mem->state_mutex);
 
         return ret;
@@ -330,10 +341,18 @@ store_mem_state(struct device *dev,
 
         mem = container_of(dev, struct memory_block, dev);
 
-        if (!strncmp(buf, "online", min((int)count, 6)))
-                ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
-        else if(!strncmp(buf, "offline", min((int)count, 7)))
-                ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
+        if (!strncmp(buf, "online_kernel", min_t(int, count, 13)))
+                ret = memory_block_change_state(mem, MEM_ONLINE,
+                                                MEM_OFFLINE, ONLINE_KERNEL);
+        else if (!strncmp(buf, "online_movable", min_t(int, count, 14)))
+                ret = memory_block_change_state(mem, MEM_ONLINE,
+                                                MEM_OFFLINE, ONLINE_MOVABLE);
+        else if (!strncmp(buf, "online", min_t(int, count, 6)))
+                ret = memory_block_change_state(mem, MEM_ONLINE,
+                                                MEM_OFFLINE, ONLINE_KEEP);
+        else if(!strncmp(buf, "offline", min_t(int, count, 7)))
+                ret = memory_block_change_state(mem, MEM_OFFLINE,
+                                                MEM_ONLINE, -1);
 
         if (ret)
                 return ret;
@@ -635,7 +654,6 @@ int remove_memory_block(unsigned long node_id, struct mem_section *section,
                 mem_remove_simple_file(mem, phys_device);
                 mem_remove_simple_file(mem, removable);
                 unregister_memory(mem);
-                kfree(mem);
         } else
                 kobject_put(&mem->dev.kobj);
 
@@ -669,7 +687,7 @@ int offline_memory_block(struct memory_block *mem)
 
         mutex_lock(&mem->state_mutex);
         if (mem->state != MEM_OFFLINE)
-                ret = __memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
+                ret = __memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE, -1);
         mutex_unlock(&mem->state_mutex);
 
         return ret;
diff --git a/drivers/base/node.c b/drivers/base/node.c
index af1a177216f1..fac124a7e1c5 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -227,7 +227,7 @@ static node_registration_func_t __hugetlb_unregister_node;
 static inline bool hugetlb_register_node(struct node *node)
 {
         if (__hugetlb_register_node &&
-                        node_state(node->dev.id, N_HIGH_MEMORY)) {
+                        node_state(node->dev.id, N_MEMORY)) {
                 __hugetlb_register_node(node);
                 return true;
         }
@@ -252,6 +252,24 @@ static inline void hugetlb_register_node(struct node *node) {}
 static inline void hugetlb_unregister_node(struct node *node) {}
 #endif
 
+static void node_device_release(struct device *dev)
+{
+        struct node *node = to_node(dev);
+
+#if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_HUGETLBFS)
+        /*
+         * We schedule the work only when a memory section is
+         * onlined/offlined on this node. When we come here,
+         * all the memory on this node has been offlined,
+         * so we won't enqueue new work to this work.
+         *
+         * The work is using node->node_work, so we should
+         * flush work before freeing the memory.
+         */
+        flush_work(&node->node_work);
+#endif
+        kfree(node);
+}
 
 /*
  * register_node - Setup a sysfs device for a node.
@@ -259,12 +277,13 @@ static inline void hugetlb_unregister_node(struct node *node) {}
  *
  * Initialize and register the node device.
  */
-int register_node(struct node *node, int num, struct node *parent)
+static int register_node(struct node *node, int num, struct node *parent)
 {
         int error;
 
         node->dev.id = num;
         node->dev.bus = &node_subsys;
+        node->dev.release = node_device_release;
         error = device_register(&node->dev);
 
         if (!error){
@@ -306,7 +325,7 @@ void unregister_node(struct node *node)
         device_unregister(&node->dev);
 }
 
-struct node node_devices[MAX_NUMNODES];
+struct node *node_devices[MAX_NUMNODES];
 
 /*
  * register cpu under node
@@ -323,15 +342,15 @@ int register_cpu_under_node(unsigned int cpu, unsigned int nid)
         if (!obj)
                 return 0;
 
-        ret = sysfs_create_link(&node_devices[nid].dev.kobj,
+        ret = sysfs_create_link(&node_devices[nid]->dev.kobj,
                                 &obj->kobj,
                                 kobject_name(&obj->kobj));
         if (ret)
                 return ret;
 
         return sysfs_create_link(&obj->kobj,
-                                 &node_devices[nid].dev.kobj,
-                                 kobject_name(&node_devices[nid].dev.kobj));
+                                 &node_devices[nid]->dev.kobj,
+                                 kobject_name(&node_devices[nid]->dev.kobj));
 }
 
 int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
@@ -345,10 +364,10 @@ int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
         if (!obj)
                 return 0;
 
-        sysfs_remove_link(&node_devices[nid].dev.kobj,
+        sysfs_remove_link(&node_devices[nid]->dev.kobj,
                           kobject_name(&obj->kobj));
         sysfs_remove_link(&obj->kobj,
-                          kobject_name(&node_devices[nid].dev.kobj));
+                          kobject_name(&node_devices[nid]->dev.kobj));
 
         return 0;
 }
@@ -390,15 +409,15 @@ int register_mem_sect_under_node(struct memory_block *mem_blk, int nid)
                         continue;
                 if (page_nid != nid)
                         continue;
-                ret = sysfs_create_link_nowarn(&node_devices[nid].dev.kobj,
+                ret = sysfs_create_link_nowarn(&node_devices[nid]->dev.kobj,
                                         &mem_blk->dev.kobj,
                                         kobject_name(&mem_blk->dev.kobj));
                 if (ret)
                         return ret;
 
                 return sysfs_create_link_nowarn(&mem_blk->dev.kobj,
-                                &node_devices[nid].dev.kobj,
-                                kobject_name(&node_devices[nid].dev.kobj));
+                                &node_devices[nid]->dev.kobj,
+                                kobject_name(&node_devices[nid]->dev.kobj));
         }
         /* mem section does not span the specified node */
         return 0;
@@ -431,10 +450,10 @@ int unregister_mem_sect_under_nodes(struct memory_block *mem_blk,
                         continue;
                 if (node_test_and_set(nid, *unlinked_nodes))
                         continue;
-                sysfs_remove_link(&node_devices[nid].dev.kobj,
+                sysfs_remove_link(&node_devices[nid]->dev.kobj,
                          kobject_name(&mem_blk->dev.kobj));
                 sysfs_remove_link(&mem_blk->dev.kobj,
-                         kobject_name(&node_devices[nid].dev.kobj));
+                         kobject_name(&node_devices[nid]->dev.kobj));
         }
         NODEMASK_FREE(unlinked_nodes);
         return 0;
@@ -500,7 +519,7 @@ static void node_hugetlb_work(struct work_struct *work)
 
 static void init_node_hugetlb_work(int nid)
 {
-        INIT_WORK(&node_devices[nid].node_work, node_hugetlb_work);
+        INIT_WORK(&node_devices[nid]->node_work, node_hugetlb_work);
 }
 
 static int node_memory_callback(struct notifier_block *self,
@@ -517,7 +536,7 @@ static int node_memory_callback(struct notifier_block *self,
                  * when transitioning to/from memoryless state.
                  */
                 if (nid != NUMA_NO_NODE)
-                        schedule_work(&node_devices[nid].node_work);
+                        schedule_work(&node_devices[nid]->node_work);
                 break;
 
         case MEM_GOING_ONLINE:
@@ -558,9 +577,13 @@ int register_one_node(int nid)
                 struct node *parent = NULL;
 
                 if (p_node != nid)
-                        parent = &node_devices[p_node];
+                        parent = node_devices[p_node];
+
+                node_devices[nid] = kzalloc(sizeof(struct node), GFP_KERNEL);
+                if (!node_devices[nid])
+                        return -ENOMEM;
 
-                error = register_node(&node_devices[nid], nid, parent);
+                error = register_node(node_devices[nid], nid, parent);
 
                 /* link cpu under this node */
                 for_each_present_cpu(cpu) {
@@ -581,7 +604,8 @@ int register_one_node(int nid)
 
 void unregister_one_node(int nid)
 {
-        unregister_node(&node_devices[nid]);
+        unregister_node(node_devices[nid]);
+        node_devices[nid] = NULL;
 }
 
 /*
@@ -614,23 +638,29 @@ static ssize_t show_node_state(struct device *dev,
         { __ATTR(name, 0444, show_node_state, NULL), state }
 
 static struct node_attr node_state_attr[] = {
-        _NODE_ATTR(possible, N_POSSIBLE),
-        _NODE_ATTR(online, N_ONLINE),
-        _NODE_ATTR(has_normal_memory, N_NORMAL_MEMORY),
-        _NODE_ATTR(has_cpu, N_CPU),
+        [N_POSSIBLE] = _NODE_ATTR(possible, N_POSSIBLE),
+        [N_ONLINE] = _NODE_ATTR(online, N_ONLINE),
+        [N_NORMAL_MEMORY] = _NODE_ATTR(has_normal_memory, N_NORMAL_MEMORY),
 #ifdef CONFIG_HIGHMEM
-        _NODE_ATTR(has_high_memory, N_HIGH_MEMORY),
+        [N_HIGH_MEMORY] = _NODE_ATTR(has_high_memory, N_HIGH_MEMORY),
 #endif
+#ifdef CONFIG_MOVABLE_NODE
+        [N_MEMORY] = _NODE_ATTR(has_memory, N_MEMORY),
+#endif
+        [N_CPU] = _NODE_ATTR(has_cpu, N_CPU),
 };
 
 static struct attribute *node_state_attrs[] = {
-        &node_state_attr[0].attr.attr,
-        &node_state_attr[1].attr.attr,
-        &node_state_attr[2].attr.attr,
-        &node_state_attr[3].attr.attr,
+        &node_state_attr[N_POSSIBLE].attr.attr,
+        &node_state_attr[N_ONLINE].attr.attr,
+        &node_state_attr[N_NORMAL_MEMORY].attr.attr,
 #ifdef CONFIG_HIGHMEM
-        &node_state_attr[4].attr.attr,
+        &node_state_attr[N_HIGH_MEMORY].attr.attr,
+#endif
+#ifdef CONFIG_MOVABLE_NODE
+        &node_state_attr[N_MEMORY].attr.attr,
 #endif
+        &node_state_attr[N_CPU].attr.attr,
         NULL
 };
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 8727e9c5eea4..c0b8df38402b 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -21,6 +21,7 @@
 #include <linux/slab.h>
 #include <linux/pm_runtime.h>
 #include <linux/idr.h>
+#include <linux/acpi.h>
 
 #include "base.h"
 #include "power/power.h"
@@ -44,7 +45,7 @@ EXPORT_SYMBOL_GPL(platform_bus);
  * be setup before the platform_notifier is called.  So if a user needs to
  * manipulate any relevant information in the pdev_archdata they can do:
  *
- *      platform_devic_alloc()
+ *      platform_device_alloc()
  *      ... manipulate ...
  *      platform_device_add()
  *
@@ -83,9 +84,16 @@ EXPORT_SYMBOL_GPL(platform_get_resource);
  */
 int platform_get_irq(struct platform_device *dev, unsigned int num)
 {
+#ifdef CONFIG_SPARC
+        /* sparc does not have irqs represented as IORESOURCE_IRQ resources */
+        if (!dev || num >= dev->archdata.num_irqs)
+                return -ENXIO;
+        return dev->archdata.irqs[num];
+#else
         struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num);
 
         return r ? r->start : -ENXIO;
+#endif
 }
 EXPORT_SYMBOL_GPL(platform_get_irq);
 
@@ -115,7 +123,7 @@ struct resource *platform_get_resource_byname(struct platform_device *dev,
 EXPORT_SYMBOL_GPL(platform_get_resource_byname);
 
 /**
- * platform_get_irq - get an IRQ for a device
+ * platform_get_irq_byname - get an IRQ for a device by name
  * @dev: platform device
  * @name: IRQ name
  */
@@ -429,6 +437,7 @@ struct platform_device *platform_device_register_full(
                 goto err_alloc;
 
         pdev->dev.parent = pdevinfo->parent;
+        ACPI_HANDLE_SET(&pdev->dev, pdevinfo->acpi_node.handle);
 
         if (pdevinfo->dma_mask) {
                 /*
@@ -459,6 +468,7 @@ struct platform_device *platform_device_register_full(
         ret = platform_device_add(pdev);
         if (ret) {
 err:
+                ACPI_HANDLE_SET(&pdev->dev, NULL);
                 kfree(pdev->dev.dma_mask);
 
 err_alloc:
@@ -474,8 +484,16 @@ static int platform_drv_probe(struct device *_dev)
 {
         struct platform_driver *drv = to_platform_driver(_dev->driver);
         struct platform_device *dev = to_platform_device(_dev);
+        int ret;
+
+        if (ACPI_HANDLE(_dev))
+                acpi_dev_pm_attach(_dev, true);
 
-        return drv->probe(dev);
+        ret = drv->probe(dev);
+        if (ret && ACPI_HANDLE(_dev))
+                acpi_dev_pm_detach(_dev, true);
+
+        return ret;
 }
 
 static int platform_drv_probe_fail(struct device *_dev)
@@ -487,8 +505,13 @@ static int platform_drv_remove(struct device *_dev)
 {
         struct platform_driver *drv = to_platform_driver(_dev->driver);
         struct platform_device *dev = to_platform_device(_dev);
+        int ret;
 
-        return drv->remove(dev);
+        ret = drv->remove(dev);
+        if (ACPI_HANDLE(_dev))
+                acpi_dev_pm_detach(_dev, true);
+
+        return ret;
 }
 
 static void platform_drv_shutdown(struct device *_dev)
@@ -497,6 +520,8 @@ static void platform_drv_shutdown(struct device *_dev)
         struct platform_device *dev = to_platform_device(_dev);
 
         drv->shutdown(dev);
+        if (ACPI_HANDLE(_dev))
+                acpi_dev_pm_detach(_dev, true);
 }
 
 /**
@@ -702,6 +727,10 @@ static int platform_match(struct device *dev, struct device_driver *drv)
         if (of_driver_match_device(dev, drv))
                 return 1;
 
+        /* Then try ACPI style match */
+        if (acpi_driver_match_device(dev, drv))
+                return 1;
+
         /* Then try to match against the id table */
         if (pdrv->id_table)
                 return platform_match_id(pdrv->id_table, pdev) != NULL;
diff --git a/drivers/base/power/clock_ops.c b/drivers/base/power/clock_ops.c
index eb78e9640c4a..9d8fde709390 100644
--- a/drivers/base/power/clock_ops.c
+++ b/drivers/base/power/clock_ops.c
@@ -99,7 +99,7 @@ static void __pm_clk_remove(struct pm_clock_entry *ce)
 
         if (ce->status < PCE_STATUS_ERROR) {
                 if (ce->status == PCE_STATUS_ENABLED)
-                        clk_disable(ce->clk);
+                        clk_disable_unprepare(ce->clk);
 
                 if (ce->status >= PCE_STATUS_ACQUIRED)
                         clk_put(ce->clk);
@@ -396,7 +396,7 @@ static void enable_clock(struct device *dev, const char *con_id)
 
         clk = clk_get(dev, con_id);
         if (!IS_ERR(clk)) {
-                clk_enable(clk);
+                clk_prepare_enable(clk);
                 clk_put(clk);
                 dev_info(dev, "Runtime PM disabled, clock forced on.\n");
         }
@@ -413,7 +413,7 @@ static void disable_clock(struct device *dev, const char *con_id)
 
         clk = clk_get(dev, con_id);
         if (!IS_ERR(clk)) {
-                clk_disable(clk);
+                clk_disable_unprepare(clk);
                 clk_put(clk);
                 dev_info(dev, "Runtime PM disabled, clock forced off.\n");
         }
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index c22b869245d9..acc3a8ded29d 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -470,10 +470,19 @@ static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
                 return -EBUSY;
 
         not_suspended = 0;
-        list_for_each_entry(pdd, &genpd->dev_list, list_node)
+        list_for_each_entry(pdd, &genpd->dev_list, list_node) {
+                enum pm_qos_flags_status stat;
+
+                stat = dev_pm_qos_flags(pdd->dev,
+                                        PM_QOS_FLAG_NO_POWER_OFF
+                                                | PM_QOS_FLAG_REMOTE_WAKEUP);
+                if (stat > PM_QOS_FLAGS_NONE)
+                        return -EBUSY;
+
                 if (pdd->dev->driver && (!pm_runtime_suspended(pdd->dev)
                     || pdd->dev->power.irq_safe))
                         not_suspended++;
+        }
 
         if (not_suspended > genpd->in_progress)
                 return -EBUSY;
@@ -1862,7 +1871,7 @@ int pm_genpd_attach_cpuidle(struct generic_pm_domain *genpd, int state)
         cpuidle_drv = cpuidle_driver_ref();
         if (!cpuidle_drv) {
                 ret = -ENODEV;
-                goto out;
+                goto err_drv;
         }
         if (cpuidle_drv->state_count <= state) {
                 ret = -EINVAL;
@@ -1884,6 +1893,9 @@ int pm_genpd_attach_cpuidle(struct generic_pm_domain *genpd, int state)
 
  err:
         cpuidle_driver_unref();
+
+ err_drv:
+        kfree(cpu_data);
         goto out;
 }
 
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index d9468642fc41..50b2831e027d 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -23,6 +23,7 @@
 #include <linux/rcupdate.h>
 #include <linux/opp.h>
 #include <linux/of.h>
+#include <linux/export.h>
 
 /*
  * Internal data structure organization with the OPP layer library is as
@@ -65,6 +66,7 @@ struct opp {
         unsigned long u_volt;
 
         struct device_opp *dev_opp;
+        struct rcu_head head;
 };
 
 /**
@@ -160,6 +162,7 @@ unsigned long opp_get_voltage(struct opp *opp)
 
         return v;
 }
+EXPORT_SYMBOL(opp_get_voltage);
 
 /**
  * opp_get_freq() - Gets the frequency corresponding to an available opp
@@ -189,6 +192,7 @@ unsigned long opp_get_freq(struct opp *opp)
 
         return f;
 }
+EXPORT_SYMBOL(opp_get_freq);
 
 /**
  * opp_get_opp_count() - Get number of opps available in the opp list
@@ -221,6 +225,7 @@ int opp_get_opp_count(struct device *dev)
 
         return count;
 }
+EXPORT_SYMBOL(opp_get_opp_count);
 
 /**
  * opp_find_freq_exact() - search for an exact frequency
@@ -230,7 +235,10 @@ int opp_get_opp_count(struct device *dev)
  *
  * Searches for exact match in the opp list and returns pointer to the matching
  * opp if found, else returns ERR_PTR in case of error and should be handled
- * using IS_ERR.
+ * using IS_ERR. Error return values can be:
+ * EINVAL:      for bad pointer
+ * ERANGE:      no match found for search
+ * ENODEV:      if device not found in list of registered devices
  *
  * Note: available is a modifier for the search. if available=true, then the
  * match is for exact matching frequency and is available in the stored OPP
@@ -249,7 +257,7 @@ struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
                                 bool available)
 {
         struct device_opp *dev_opp;
-        struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+        struct opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 
         dev_opp = find_device_opp(dev);
         if (IS_ERR(dev_opp)) {
@@ -268,6 +276,7 @@ struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
 
         return opp;
 }
+EXPORT_SYMBOL(opp_find_freq_exact);
 
 /**
  * opp_find_freq_ceil() - Search for an rounded ceil freq
@@ -278,7 +287,11 @@ struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
  * for a device.
  *
  * Returns matching *opp and refreshes *freq accordingly, else returns
- * ERR_PTR in case of error and should be handled using IS_ERR.
+ * ERR_PTR in case of error and should be handled using IS_ERR. Error return
+ * values can be:
+ * EINVAL:      for bad pointer
+ * ERANGE:      no match found for search
+ * ENODEV:      if device not found in list of registered devices
  *
  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
  * protected pointer. The reason for the same is that the opp pointer which is
@@ -289,7 +302,7 @@ struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
 struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
 {
         struct device_opp *dev_opp;
-        struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+        struct opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 
         if (!dev || !freq) {
                 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
@@ -298,7 +311,7 @@ struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
 
         dev_opp = find_device_opp(dev);
         if (IS_ERR(dev_opp))
-                return opp;
+                return ERR_CAST(dev_opp);
 
         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
                 if (temp_opp->available && temp_opp->rate >= *freq) {
@@ -310,6 +323,7 @@ struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
 
         return opp;
 }
+EXPORT_SYMBOL(opp_find_freq_ceil);
 
 /**
  * opp_find_freq_floor() - Search for a rounded floor freq
@@ -320,7 +334,11 @@ struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
  * for a device.
  *
  * Returns matching *opp and refreshes *freq accordingly, else returns
- * ERR_PTR in case of error and should be handled using IS_ERR.
+ * ERR_PTR in case of error and should be handled using IS_ERR. Error return
+ * values can be:
+ * EINVAL:      for bad pointer
+ * ERANGE:      no match found for search
+ * ENODEV:      if device not found in list of registered devices
  *
  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
  * protected pointer. The reason for the same is that the opp pointer which is
@@ -331,7 +349,7 @@ struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
 struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
 {
         struct device_opp *dev_opp;
-        struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+        struct opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 
         if (!dev || !freq) {
                 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
@@ -340,7 +358,7 @@ struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
 
         dev_opp = find_device_opp(dev);
         if (IS_ERR(dev_opp))
-                return opp;
+                return ERR_CAST(dev_opp);
 
         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
                 if (temp_opp->available) {
@@ -356,6 +374,7 @@ struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
 
         return opp;
 }
+EXPORT_SYMBOL(opp_find_freq_floor);
 
 /**
  * opp_add()  - Add an OPP table from a table definitions
@@ -512,7 +531,7 @@ static int opp_set_availability(struct device *dev, unsigned long freq,
 
         list_replace_rcu(&opp->node, &new_opp->node);
         mutex_unlock(&dev_opp_list_lock);
-        synchronize_rcu();
+        kfree_rcu(opp, head);
 
         /* Notify the change of the OPP availability */
         if (availability_req)
@@ -522,13 +541,10 @@ static int opp_set_availability(struct device *dev, unsigned long freq,
                 srcu_notifier_call_chain(&dev_opp->head, OPP_EVENT_DISABLE,
                                          new_opp);
 
-        /* clean up old opp */
-        new_opp = opp;
-        goto out;
+        return 0;
 
 unlock:
         mutex_unlock(&dev_opp_list_lock);
-out:
         kfree(new_opp);
         return r;
 }
@@ -552,6 +568,7 @@ int opp_enable(struct device *dev, unsigned long freq)
 {
         return opp_set_availability(dev, freq, true);
 }
+EXPORT_SYMBOL(opp_enable);
 
 /**
  * opp_disable() - Disable a specific OPP
@@ -573,6 +590,7 @@ int opp_disable(struct device *dev, unsigned long freq)
 {
         return opp_set_availability(dev, freq, false);
 }
+EXPORT_SYMBOL(opp_disable);
 
 #ifdef CONFIG_CPU_FREQ
 /**
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index 0dbfdf4419af..b16686a0a5a2 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -93,8 +93,10 @@ extern void dpm_sysfs_remove(struct device *dev);
 extern void rpm_sysfs_remove(struct device *dev);
 extern int wakeup_sysfs_add(struct device *dev);
 extern void wakeup_sysfs_remove(struct device *dev);
-extern int pm_qos_sysfs_add(struct device *dev);
-extern void pm_qos_sysfs_remove(struct device *dev);
+extern int pm_qos_sysfs_add_latency(struct device *dev);
+extern void pm_qos_sysfs_remove_latency(struct device *dev);
+extern int pm_qos_sysfs_add_flags(struct device *dev);
+extern void pm_qos_sysfs_remove_flags(struct device *dev);
 
 #else /* CONFIG_PM */
 
diff --git a/drivers/base/power/qos.c b/drivers/base/power/qos.c
index 74a67e0019a2..ff46387f5308 100644
--- a/drivers/base/power/qos.c
+++ b/drivers/base/power/qos.c
@@ -40,6 +40,7 @@
 #include <linux/device.h>
 #include <linux/mutex.h>
 #include <linux/export.h>
+#include <linux/pm_runtime.h>
 
 #include "power.h"
 
@@ -48,6 +49,50 @@ static DEFINE_MUTEX(dev_pm_qos_mtx);
 static BLOCKING_NOTIFIER_HEAD(dev_pm_notifiers);
 
 /**
+ * __dev_pm_qos_flags - Check PM QoS flags for a given device.
+ * @dev: Device to check the PM QoS flags for.
+ * @mask: Flags to check against.
+ *
+ * This routine must be called with dev->power.lock held.
+ */
+enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev, s32 mask)
+{
+        struct dev_pm_qos *qos = dev->power.qos;
+        struct pm_qos_flags *pqf;
+        s32 val;
+
+        if (!qos)
+                return PM_QOS_FLAGS_UNDEFINED;
+
+        pqf = &qos->flags;
+        if (list_empty(&pqf->list))
+                return PM_QOS_FLAGS_UNDEFINED;
+
+        val = pqf->effective_flags & mask;
+        if (val)
+                return (val == mask) ? PM_QOS_FLAGS_ALL : PM_QOS_FLAGS_SOME;
+
+        return PM_QOS_FLAGS_NONE;
+}
+
+/**
+ * dev_pm_qos_flags - Check PM QoS flags for a given device (locked).
+ * @dev: Device to check the PM QoS flags for.
+ * @mask: Flags to check against.
+ */
+enum pm_qos_flags_status dev_pm_qos_flags(struct device *dev, s32 mask)
+{
+        unsigned long irqflags;
+        enum pm_qos_flags_status ret;
+
+        spin_lock_irqsave(&dev->power.lock, irqflags);
+        ret = __dev_pm_qos_flags(dev, mask);
+        spin_unlock_irqrestore(&dev->power.lock, irqflags);
+
+        return ret;
+}
+
+/**
  * __dev_pm_qos_read_value - Get PM QoS constraint for a given device.
  * @dev: Device to get the PM QoS constraint value for.
  *
@@ -55,9 +100,7 @@ static BLOCKING_NOTIFIER_HEAD(dev_pm_notifiers);
  */
 s32 __dev_pm_qos_read_value(struct device *dev)
 {
-        struct pm_qos_constraints *c = dev->power.constraints;
-
-        return c ? pm_qos_read_value(c) : 0;
+        return dev->power.qos ? pm_qos_read_value(&dev->power.qos->latency) : 0;
 }
 
 /**
@@ -76,30 +119,39 @@ s32 dev_pm_qos_read_value(struct device *dev)
         return ret;
 }
 
-/*
- * apply_constraint
- * @req: constraint request to apply
- * @action: action to perform add/update/remove, of type enum pm_qos_req_action
- * @value: defines the qos request
+/**
+ * apply_constraint - Add/modify/remove device PM QoS request.
+ * @req: Constraint request to apply
+ * @action: Action to perform (add/update/remove).
+ * @value: Value to assign to the QoS request.
  *
  * Internal function to update the constraints list using the PM QoS core
  * code and if needed call the per-device and the global notification
  * callbacks
  */
 static int apply_constraint(struct dev_pm_qos_request *req,
-                            enum pm_qos_req_action action, int value)
+                            enum pm_qos_req_action action, s32 value)
 {
-        int ret, curr_value;
-
-        ret = pm_qos_update_target(req->dev->power.constraints,
-                                   &req->node, action, value);
+        struct dev_pm_qos *qos = req->dev->power.qos;
+        int ret;
 
-        if (ret) {
-                /* Call the global callbacks if needed */
-                curr_value = pm_qos_read_value(req->dev->power.constraints);
-                blocking_notifier_call_chain(&dev_pm_notifiers,
-                                             (unsigned long)curr_value,
-                                             req);
+        switch(req->type) {
+        case DEV_PM_QOS_LATENCY:
+                ret = pm_qos_update_target(&qos->latency, &req->data.pnode,
+                                           action, value);
+                if (ret) {
+                        value = pm_qos_read_value(&qos->latency);
+                        blocking_notifier_call_chain(&dev_pm_notifiers,
+                                                     (unsigned long)value,
+                                                     req);
+                }
+                break;
+        case DEV_PM_QOS_FLAGS:
+                ret = pm_qos_update_flags(&qos->flags, &req->data.flr,
+                                          action, value);
+                break;
+        default:
+                ret = -EINVAL;
         }
 
         return ret;
@@ -114,28 +166,32 @@ static int apply_constraint(struct dev_pm_qos_request *req,
  */
 static int dev_pm_qos_constraints_allocate(struct device *dev)
 {
+        struct dev_pm_qos *qos;
         struct pm_qos_constraints *c;
         struct blocking_notifier_head *n;
 
-        c = kzalloc(sizeof(*c), GFP_KERNEL);
-        if (!c)
+        qos = kzalloc(sizeof(*qos), GFP_KERNEL);
+        if (!qos)
                 return -ENOMEM;
 
         n = kzalloc(sizeof(*n), GFP_KERNEL);
         if (!n) {
-                kfree(c);
+                kfree(qos);
                 return -ENOMEM;
         }
         BLOCKING_INIT_NOTIFIER_HEAD(n);
 
+        c = &qos->latency;
         plist_head_init(&c->list);
         c->target_value = PM_QOS_DEV_LAT_DEFAULT_VALUE;
         c->default_value = PM_QOS_DEV_LAT_DEFAULT_VALUE;
         c->type = PM_QOS_MIN;
         c->notifiers = n;
 
+        INIT_LIST_HEAD(&qos->flags.list);
+
         spin_lock_irq(&dev->power.lock);
-        dev->power.constraints = c;
+        dev->power.qos = qos;
         spin_unlock_irq(&dev->power.lock);
 
         return 0;
@@ -151,7 +207,7 @@ static int dev_pm_qos_constraints_allocate(struct device *dev)
 void dev_pm_qos_constraints_init(struct device *dev)
 {
         mutex_lock(&dev_pm_qos_mtx);
-        dev->power.constraints = NULL;
+        dev->power.qos = NULL;
         dev->power.power_state = PMSG_ON;
         mutex_unlock(&dev_pm_qos_mtx);
 }
@@ -164,24 +220,28 @@ void dev_pm_qos_constraints_init(struct device *dev)
  */
 void dev_pm_qos_constraints_destroy(struct device *dev)
 {
+        struct dev_pm_qos *qos;
         struct dev_pm_qos_request *req, *tmp;
         struct pm_qos_constraints *c;
+        struct pm_qos_flags *f;
 
         /*
-         * If the device's PM QoS resume latency limit has been exposed to user
-         * space, it has to be hidden at this point.
+         * 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);
 
         mutex_lock(&dev_pm_qos_mtx);
 
         dev->power.power_state = PMSG_INVALID;
-        c = dev->power.constraints;
-        if (!c)
+        qos = dev->power.qos;
+        if (!qos)
                 goto out;
 
-        /* Flush the constraints list for the device */
-        plist_for_each_entry_safe(req, tmp, &c->list, node) {
+        /* Flush the constraints lists for the device. */
+        c = &qos->latency;
+        plist_for_each_entry_safe(req, tmp, &c->list, data.pnode) {
                 /*
                  * Update constraints list and call the notification
                  * callbacks if needed
@@ -189,13 +249,18 @@ void dev_pm_qos_constraints_destroy(struct device *dev)
                 apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
                 memset(req, 0, sizeof(*req));
         }
+        f = &qos->flags;
+        list_for_each_entry_safe(req, tmp, &f->list, data.flr.node) {
+                apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
+                memset(req, 0, sizeof(*req));
+        }
 
         spin_lock_irq(&dev->power.lock);
-        dev->power.constraints = NULL;
+        dev->power.qos = NULL;
         spin_unlock_irq(&dev->power.lock);
 
         kfree(c->notifiers);
-        kfree(c);
+        kfree(qos);
 
  out:
         mutex_unlock(&dev_pm_qos_mtx);
@@ -205,6 +270,7 @@ void dev_pm_qos_constraints_destroy(struct device *dev)
  * dev_pm_qos_add_request - inserts new qos request into the list
  * @dev: target device for the constraint
  * @req: pointer to a preallocated handle
+ * @type: type of the request
  * @value: defines the qos request
  *
  * This function inserts a new entry in the device constraints list of
@@ -218,9 +284,12 @@ void dev_pm_qos_constraints_destroy(struct device *dev)
  * -EINVAL in case of wrong parameters, -ENOMEM if there's not enough memory
  * to allocate for data structures, -ENODEV if the device has just been removed
  * from the system.
+ *
+ * Callers should ensure that the target device is not RPM_SUSPENDED before
+ * using this function for requests of type DEV_PM_QOS_FLAGS.
  */
 int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
-                           s32 value)
+                           enum dev_pm_qos_req_type type, s32 value)
 {
         int ret = 0;
 
@@ -235,7 +304,7 @@ int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (!dev->power.constraints) {
+        if (!dev->power.qos) {
                 if (dev->power.power_state.event == PM_EVENT_INVALID) {
                         /* The device has been removed from the system. */
                         req->dev = NULL;
@@ -251,8 +320,10 @@ int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
                 }
         }
 
-        if (!ret)
+        if (!ret) {
+                req->type = type;
                 ret = apply_constraint(req, PM_QOS_ADD_REQ, value);
+        }
 
  out:
         mutex_unlock(&dev_pm_qos_mtx);
@@ -262,6 +333,37 @@ int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
 EXPORT_SYMBOL_GPL(dev_pm_qos_add_request);
 
 /**
+ * __dev_pm_qos_update_request - Modify an existing device PM QoS request.
+ * @req : PM QoS request to modify.
+ * @new_value: New value to request.
+ */
+static int __dev_pm_qos_update_request(struct dev_pm_qos_request *req,
+                                       s32 new_value)
+{
+        s32 curr_value;
+        int ret = 0;
+
+        if (!req->dev->power.qos)
+                return -ENODEV;
+
+        switch(req->type) {
+        case DEV_PM_QOS_LATENCY:
+                curr_value = req->data.pnode.prio;
+                break;
+        case DEV_PM_QOS_FLAGS:
+                curr_value = req->data.flr.flags;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (curr_value != new_value)
+                ret = apply_constraint(req, PM_QOS_UPDATE_REQ, new_value);
+
+        return ret;
+}
+
+/**
  * dev_pm_qos_update_request - modifies an existing qos request
  * @req : handle to list element holding a dev_pm_qos request to use
  * @new_value: defines the qos request
@@ -275,11 +377,13 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_add_request);
  * 0 if the aggregated constraint value has not changed,
  * -EINVAL in case of wrong parameters, -ENODEV if the device has been
  * removed from the system
+ *
+ * Callers should ensure that the target device is not RPM_SUSPENDED before
+ * using this function for requests of type DEV_PM_QOS_FLAGS.
  */
-int dev_pm_qos_update_request(struct dev_pm_qos_request *req,
-                              s32 new_value)
+int dev_pm_qos_update_request(struct dev_pm_qos_request *req, s32 new_value)
 {
-        int ret = 0;
+        int ret;
 
         if (!req) /*guard against callers passing in null */
                 return -EINVAL;
@@ -289,17 +393,9 @@ int dev_pm_qos_update_request(struct dev_pm_qos_request *req,
                 return -EINVAL;
 
         mutex_lock(&dev_pm_qos_mtx);
-
-        if (req->dev->power.constraints) {
-                if (new_value != req->node.prio)
-                        ret = apply_constraint(req, PM_QOS_UPDATE_REQ,
-                                               new_value);
-        } else {
-                /* Return if the device has been removed */
-                ret = -ENODEV;
-        }
-
+        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);
@@ -315,6 +411,9 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
  * 0 if the aggregated constraint value has not changed,
  * -EINVAL in case of wrong parameters, -ENODEV if the device has been
  * removed from the system
+ *
+ * Callers should ensure that the target device is not RPM_SUSPENDED before
+ * using this function for requests of type DEV_PM_QOS_FLAGS.
  */
 int dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
 {
@@ -329,7 +428,7 @@ int dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (req->dev->power.constraints) {
+        if (req->dev->power.qos) {
                 ret = apply_constraint(req, PM_QOS_REMOVE_REQ,
                                        PM_QOS_DEFAULT_VALUE);
                 memset(req, 0, sizeof(*req));
@@ -362,13 +461,13 @@ int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier)
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (!dev->power.constraints)
+        if (!dev->power.qos)
                 ret = dev->power.power_state.event != PM_EVENT_INVALID ?
                         dev_pm_qos_constraints_allocate(dev) : -ENODEV;
 
         if (!ret)
                 ret = blocking_notifier_chain_register(
-                                dev->power.constraints->notifiers, notifier);
+                                dev->power.qos->latency.notifiers, notifier);
 
         mutex_unlock(&dev_pm_qos_mtx);
         return ret;
@@ -393,9 +492,9 @@ 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.constraints)
+        if (dev->power.qos)
                 retval = blocking_notifier_chain_unregister(
-                                dev->power.constraints->notifiers,
+                                dev->power.qos->latency.notifiers,
                                 notifier);
 
         mutex_unlock(&dev_pm_qos_mtx);
@@ -449,9 +548,10 @@ int dev_pm_qos_add_ancestor_request(struct device *dev,
                 ancestor = ancestor->parent;
 
         if (ancestor)
-                error = dev_pm_qos_add_request(ancestor, req, value);
+                error = dev_pm_qos_add_request(ancestor, req,
+                                               DEV_PM_QOS_LATENCY, value);
 
-        if (error)
+        if (error < 0)
                 req->dev = NULL;
 
         return error;
@@ -459,10 +559,19 @@ int dev_pm_qos_add_ancestor_request(struct device *dev,
 EXPORT_SYMBOL_GPL(dev_pm_qos_add_ancestor_request);
 
 #ifdef CONFIG_PM_RUNTIME
-static void __dev_pm_qos_drop_user_request(struct device *dev)
+static void __dev_pm_qos_drop_user_request(struct device *dev,
+                                           enum dev_pm_qos_req_type type)
 {
-        dev_pm_qos_remove_request(dev->power.pq_req);
-        dev->power.pq_req = NULL;
+        switch(type) {
+        case DEV_PM_QOS_LATENCY:
+                dev_pm_qos_remove_request(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);
+                dev->power.qos->flags_req = NULL;
+                break;
+        }
 }
 
 /**
@@ -478,21 +587,21 @@ int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
         if (!device_is_registered(dev) || value < 0)
                 return -EINVAL;
 
-        if (dev->power.pq_req)
+        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, value);
+        ret = dev_pm_qos_add_request(dev, req, DEV_PM_QOS_LATENCY, value);
         if (ret < 0)
                 return ret;
 
-        dev->power.pq_req = req;
-        ret = pm_qos_sysfs_add(dev);
+        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_drop_user_request(dev, DEV_PM_QOS_LATENCY);
 
         return ret;
 }
@@ -504,10 +613,92 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_expose_latency_limit);
  */
 void dev_pm_qos_hide_latency_limit(struct device *dev)
 {
-        if (dev->power.pq_req) {
-                pm_qos_sysfs_remove(dev);
-                __dev_pm_qos_drop_user_request(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);
         }
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_latency_limit);
+
+/**
+ * dev_pm_qos_expose_flags - Expose PM QoS flags of a device to user space.
+ * @dev: Device whose PM QoS flags are to be exposed to user space.
+ * @val: Initial values of the flags.
+ */
+int dev_pm_qos_expose_flags(struct device *dev, s32 val)
+{
+        struct dev_pm_qos_request *req;
+        int ret;
+
+        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;
+
+        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:
+        pm_runtime_put(dev);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(dev_pm_qos_expose_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);
+        }
+}
+EXPORT_SYMBOL_GPL(dev_pm_qos_hide_flags);
+
+/**
+ * dev_pm_qos_update_flags - Update PM QoS flags request owned by user space.
+ * @dev: Device to update the PM QoS flags request for.
+ * @mask: Flags to set/clear.
+ * @set: Whether to set or clear the flags (true means set).
+ */
+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);
+
+        value = dev_pm_qos_requested_flags(dev);
+        if (set)
+                value |= mask;
+        else
+                value &= ~mask;
+
+        ret = __dev_pm_qos_update_request(dev->power.qos->flags_req, value);
+
+        mutex_unlock(&dev_pm_qos_mtx);
+        pm_runtime_put(dev);
+
+        return ret;
+}
 #endif /* CONFIG_PM_RUNTIME */
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index b91dc6f1e914..50d16e3cb0a9 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -221,7 +221,7 @@ static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
 static ssize_t pm_qos_latency_show(struct device *dev,
                                    struct device_attribute *attr, char *buf)
 {
-        return sprintf(buf, "%d\n", dev->power.pq_req->node.prio);
+        return sprintf(buf, "%d\n", dev_pm_qos_requested_latency(dev));
 }
 
 static ssize_t pm_qos_latency_store(struct device *dev,
@@ -237,12 +237,66 @@ static ssize_t pm_qos_latency_store(struct device *dev,
         if (value < 0)
                 return -EINVAL;
 
-        ret = dev_pm_qos_update_request(dev->power.pq_req, value);
+        ret = dev_pm_qos_update_request(dev->power.qos->latency_req, value);
         return ret < 0 ? ret : n;
 }
 
 static DEVICE_ATTR(pm_qos_resume_latency_us, 0644,
                    pm_qos_latency_show, pm_qos_latency_store);
+
+static ssize_t pm_qos_no_power_off_show(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
+                                        & PM_QOS_FLAG_NO_POWER_OFF));
+}
+
+static ssize_t pm_qos_no_power_off_store(struct device *dev,
+                                         struct device_attribute *attr,
+                                         const char *buf, size_t n)
+{
+        int ret;
+
+        if (kstrtoint(buf, 0, &ret))
+                return -EINVAL;
+
+        if (ret != 0 && ret != 1)
+                return -EINVAL;
+
+        ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret);
+        return ret < 0 ? ret : n;
+}
+
+static DEVICE_ATTR(pm_qos_no_power_off, 0644,
+                   pm_qos_no_power_off_show, pm_qos_no_power_off_store);
+
+static ssize_t pm_qos_remote_wakeup_show(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf)
+{
+        return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
+                                        & PM_QOS_FLAG_REMOTE_WAKEUP));
+}
+
+static ssize_t pm_qos_remote_wakeup_store(struct device *dev,
+                                          struct device_attribute *attr,
+                                          const char *buf, size_t n)
+{
+        int ret;
+
+        if (kstrtoint(buf, 0, &ret))
+                return -EINVAL;
+
+        if (ret != 0 && ret != 1)
+                return -EINVAL;
+
+        ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP, ret);
+        return ret < 0 ? ret : n;
+}
+
+static DEVICE_ATTR(pm_qos_remote_wakeup, 0644,
+                   pm_qos_remote_wakeup_show, pm_qos_remote_wakeup_store);
 #endif /* CONFIG_PM_RUNTIME */
 
 #ifdef CONFIG_PM_SLEEP
@@ -564,15 +618,27 @@ static struct attribute_group pm_runtime_attr_group = {
         .attrs  = runtime_attrs,
 };
 
-static struct attribute *pm_qos_attrs[] = {
+static struct attribute *pm_qos_latency_attrs[] = {
 #ifdef CONFIG_PM_RUNTIME
         &dev_attr_pm_qos_resume_latency_us.attr,
 #endif /* CONFIG_PM_RUNTIME */
         NULL,
 };
-static struct attribute_group pm_qos_attr_group = {
+static struct attribute_group pm_qos_latency_attr_group = {
         .name   = power_group_name,
-        .attrs  = pm_qos_attrs,
+        .attrs  = pm_qos_latency_attrs,
+};
+
+static struct attribute *pm_qos_flags_attrs[] = {
+#ifdef CONFIG_PM_RUNTIME
+        &dev_attr_pm_qos_no_power_off.attr,
+        &dev_attr_pm_qos_remote_wakeup.attr,
+#endif /* CONFIG_PM_RUNTIME */
+        NULL,
+};
+static struct attribute_group pm_qos_flags_attr_group = {
+        .name   = power_group_name,
+        .attrs  = pm_qos_flags_attrs,
 };
 
 int dpm_sysfs_add(struct device *dev)
@@ -615,14 +681,24 @@ void wakeup_sysfs_remove(struct device *dev)
         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 }
 
-int pm_qos_sysfs_add(struct device *dev)
+int pm_qos_sysfs_add_latency(struct device *dev)
+{
+        return sysfs_merge_group(&dev->kobj, &pm_qos_latency_attr_group);
+}
+
+void pm_qos_sysfs_remove_latency(struct device *dev)
+{
+        sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_attr_group);
+}
+
+int pm_qos_sysfs_add_flags(struct device *dev)
 {
-        return sysfs_merge_group(&dev->kobj, &pm_qos_attr_group);
+        return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
 }
 
-void pm_qos_sysfs_remove(struct device *dev)
+void pm_qos_sysfs_remove_flags(struct device *dev)
 {
-        sysfs_unmerge_group(&dev->kobj, &pm_qos_attr_group);
+        sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
 }
 
 void rpm_sysfs_remove(struct device *dev)
diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index 80f9ab9c3aa4..401d1919635a 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -15,10 +15,18 @@
 
 #include <linux/regmap.h>
 #include <linux/fs.h>
+#include <linux/list.h>
 
 struct regmap;
 struct regcache_ops;
 
+struct regmap_debugfs_off_cache {
+        struct list_head list;
+        off_t min;
+        off_t max;
+        unsigned int base_reg;
+};
+
 struct regmap_format {
         size_t buf_size;
         size_t reg_bytes;
@@ -31,14 +39,12 @@ struct regmap_format {
         unsigned int (*parse_val)(void *buf);
 };
 
-typedef void (*regmap_lock)(struct regmap *map);
-typedef void (*regmap_unlock)(struct regmap *map);
-
 struct regmap {
         struct mutex mutex;
         spinlock_t spinlock;
         regmap_lock lock;
         regmap_unlock unlock;
+        void *lock_arg; /* This is passed to lock/unlock functions */
 
         struct device *dev; /* Device we do I/O on */
         void *work_buf;     /* Scratch buffer used to format I/O */
@@ -50,6 +56,12 @@ struct regmap {
 #ifdef CONFIG_DEBUG_FS
         struct dentry *debugfs;
         const char *debugfs_name;
+
+        unsigned int debugfs_reg_len;
+        unsigned int debugfs_val_len;
+        unsigned int debugfs_tot_len;
+
+        struct list_head debugfs_off_cache;
 #endif
 
         unsigned int max_register;
@@ -57,6 +69,10 @@ struct regmap {
         bool (*readable_reg)(struct device *dev, unsigned int reg);
         bool (*volatile_reg)(struct device *dev, unsigned int reg);
         bool (*precious_reg)(struct device *dev, unsigned int reg);
+        const struct regmap_access_table *wr_table;
+        const struct regmap_access_table *rd_table;
+        const struct regmap_access_table *volatile_table;
+        const struct regmap_access_table *precious_table;
 
         u8 read_flag_mask;
         u8 write_flag_mask;
@@ -120,6 +136,8 @@ int _regmap_write(struct regmap *map, unsigned int reg,
 
 struct regmap_range_node {
         struct rb_node node;
+        const char *name;
+        struct regmap *map;
 
         unsigned int range_min;
         unsigned int range_max;
diff --git a/drivers/base/regmap/regmap-debugfs.c b/drivers/base/regmap/regmap-debugfs.c
index bb1ff175b962..07aad786f817 100644
--- a/drivers/base/regmap/regmap-debugfs.c
+++ b/drivers/base/regmap/regmap-debugfs.c
@@ -56,17 +56,74 @@ static const struct file_operations regmap_name_fops = {
         .llseek = default_llseek,
 };
 
-static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf,
-                                    size_t count, loff_t *ppos)
+/*
+ * Work out where the start offset maps into register numbers, bearing
+ * in mind that we suppress hidden registers.
+ */
+static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
+                                                  unsigned int base,
+                                                  loff_t from,
+                                                  loff_t *pos)
 {
-        int reg_len, val_len, tot_len;
-        size_t buf_pos = 0;
+        struct regmap_debugfs_off_cache *c = NULL;
         loff_t p = 0;
+        unsigned int i, ret;
+
+        /*
+         * If we don't have a cache build one so we don't have to do a
+         * linear scan each time.
+         */
+        if (list_empty(&map->debugfs_off_cache)) {
+                for (i = base; i <= map->max_register; i += map->reg_stride) {
+                        /* Skip unprinted registers, closing off cache entry */
+                        if (!regmap_readable(map, i) ||
+                            regmap_precious(map, i)) {
+                                if (c) {
+                                        c->max = p - 1;
+                                        list_add_tail(&c->list,
+                                                      &map->debugfs_off_cache);
+                                        c = NULL;
+                                }
+
+                                continue;
+                        }
+
+                        /* No cache entry?  Start a new one */
+                        if (!c) {
+                                c = kzalloc(sizeof(*c), GFP_KERNEL);
+                                if (!c)
+                                        break;
+                                c->min = p;
+                                c->base_reg = i;
+                        }
+
+                        p += map->debugfs_tot_len;
+                }
+        }
+
+        /* Find the relevant block */
+        list_for_each_entry(c, &map->debugfs_off_cache, list) {
+                if (*pos >= c->min && *pos <= c->max) {
+                        *pos = c->min;
+                        return c->base_reg;
+                }
+
+                ret = c->max;
+        }
+
+        return ret;
+}
+
+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)
+{
+        size_t buf_pos = 0;
+        loff_t p = *ppos;
         ssize_t ret;
         int i;
-        struct regmap *map = file->private_data;
         char *buf;
-        unsigned int val;
+        unsigned int val, start_reg;
 
         if (*ppos < 0 || !count)
                 return -EINVAL;
@@ -76,11 +133,18 @@ static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf,
                 return -ENOMEM;
 
         /* Calculate the length of a fixed format  */
-        reg_len = regmap_calc_reg_len(map->max_register, buf, count);
-        val_len = 2 * map->format.val_bytes;
-        tot_len = reg_len + val_len + 3;      /* : \n */
+        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 */
+        }
 
-        for (i = 0; i <= map->max_register; i += map->reg_stride) {
+        /* Work out which register we're starting at */
+        start_reg = regmap_debugfs_get_dump_start(map, from, *ppos, &p);
+
+        for (i = start_reg; i <= to; i += map->reg_stride) {
                 if (!regmap_readable(map, i))
                         continue;
 
@@ -90,26 +154,27 @@ static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf,
                 /* If we're in the region the user is trying to read */
                 if (p >= *ppos) {
                         /* ...but not beyond it */
-                        if (buf_pos >= count - 1 - tot_len)
+                        if (buf_pos + 1 + map->debugfs_tot_len >= count)
                                 break;
 
                         /* Format the register */
                         snprintf(buf + buf_pos, count - buf_pos, "%.*x: ",
-                                 reg_len, i);
-                        buf_pos += reg_len + 2;
+                                 map->debugfs_reg_len, i - from);
+                        buf_pos += map->debugfs_reg_len + 2;
 
                         /* Format the value, write all X if we can't read */
                         ret = regmap_read(map, i, &val);
                         if (ret == 0)
                                 snprintf(buf + buf_pos, count - buf_pos,
-                                         "%.*x", val_len, val);
+                                         "%.*x", map->debugfs_val_len, val);
                         else
-                                memset(buf + buf_pos, 'X', val_len);
+                                memset(buf + buf_pos, 'X',
+                                       map->debugfs_val_len);
                         buf_pos += 2 * map->format.val_bytes;
 
                         buf[buf_pos++] = '\n';
                 }
-                p += tot_len;
+                p += map->debugfs_tot_len;
         }
 
         ret = buf_pos;
@@ -126,6 +191,15 @@ out:
         return ret;
 }
 
+static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf,
+                                    size_t count, loff_t *ppos)
+{
+        struct regmap *map = file->private_data;
+
+        return regmap_read_debugfs(map, 0, map->max_register, user_buf,
+                                   count, ppos);
+}
+
 #undef REGMAP_ALLOW_WRITE_DEBUGFS
 #ifdef REGMAP_ALLOW_WRITE_DEBUGFS
 /*
@@ -174,6 +248,22 @@ static const struct file_operations regmap_map_fops = {
         .llseek = default_llseek,
 };
 
+static ssize_t regmap_range_read_file(struct file *file, char __user *user_buf,
+                                      size_t count, loff_t *ppos)
+{
+        struct regmap_range_node *range = file->private_data;
+        struct regmap *map = range->map;
+
+        return regmap_read_debugfs(map, range->range_min, range->range_max,
+                                   user_buf, count, ppos);
+}
+
+static const struct file_operations regmap_range_fops = {
+        .open = simple_open,
+        .read = regmap_range_read_file,
+        .llseek = default_llseek,
+};
+
 static ssize_t regmap_access_read_file(struct file *file,
                                        char __user *user_buf, size_t count,
                                        loff_t *ppos)
@@ -244,6 +334,11 @@ static const struct file_operations regmap_access_fops = {
 
 void regmap_debugfs_init(struct regmap *map, const char *name)
 {
+        struct rb_node *next;
+        struct regmap_range_node *range_node;
+
+        INIT_LIST_HEAD(&map->debugfs_off_cache);
+
         if (name) {
                 map->debugfs_name = kasprintf(GFP_KERNEL, "%s-%s",
                                               dev_name(map->dev), name);
@@ -276,11 +371,32 @@ void regmap_debugfs_init(struct regmap *map, const char *name)
                 debugfs_create_bool("cache_bypass", 0400, map->debugfs,
                                     &map->cache_bypass);
         }
+
+        next = rb_first(&map->range_tree);
+        while (next) {
+                range_node = rb_entry(next, struct regmap_range_node, node);
+
+                if (range_node->name)
+                        debugfs_create_file(range_node->name, 0400,
+                                            map->debugfs, range_node,
+                                            &regmap_range_fops);
+
+                next = rb_next(&range_node->node);
+        }
 }
 
 void regmap_debugfs_exit(struct regmap *map)
 {
+        struct regmap_debugfs_off_cache *c;
+
         debugfs_remove_recursive(map->debugfs);
+        while (!list_empty(&map->debugfs_off_cache)) {
+                c = list_first_entry(&map->debugfs_off_cache,
+                                     struct regmap_debugfs_off_cache,
+                                     list);
+                list_del(&c->list);
+                kfree(c);
+        }
         kfree(map->debugfs_name);
 }
 
diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 5b6b1d8e6cc0..5972ad958544 100644
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -458,3 +458,22 @@ int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq)
         return irq_create_mapping(data->domain, irq);
 }
 EXPORT_SYMBOL_GPL(regmap_irq_get_virq);
+
+/**
+ * regmap_irq_get_domain(): Retrieve the irq_domain for the chip
+ *
+ * Useful for drivers to request their own IRQs and for integration
+ * with subsystems.  For ease of integration NULL is accepted as a
+ * domain, allowing devices to just call this even if no domain is
+ * allocated.
+ *
+ * @data: regmap_irq controller to operate on.
+ */
+struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data)
+{
+        if (data)
+                return data->domain;
+        else
+                return NULL;
+}
+EXPORT_SYMBOL_GPL(regmap_irq_get_domain);
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index 52069d29ff12..42d5cb0f503f 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -34,6 +34,36 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
                                unsigned int mask, unsigned int val,
                                bool *change);
 
+bool regmap_reg_in_ranges(unsigned int reg,
+                          const struct regmap_range *ranges,
+                          unsigned int nranges)
+{
+        const struct regmap_range *r;
+        int i;
+
+        for (i = 0, r = ranges; i < nranges; i++, r++)
+                if (regmap_reg_in_range(reg, r))
+                        return true;
+        return false;
+}
+EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
+
+static bool _regmap_check_range_table(struct regmap *map,
+                                      unsigned int reg,
+                                      const struct regmap_access_table *table)
+{
+        /* Check "no ranges" first */
+        if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
+                return false;
+
+        /* In case zero "yes ranges" are supplied, any reg is OK */
+        if (!table->n_yes_ranges)
+                return true;
+
+        return regmap_reg_in_ranges(reg, table->yes_ranges,
+                                    table->n_yes_ranges);
+}
+
 bool regmap_writeable(struct regmap *map, unsigned int reg)
 {
         if (map->max_register && reg > map->max_register)
@@ -42,6 +72,9 @@ bool regmap_writeable(struct regmap *map, unsigned int reg)
         if (map->writeable_reg)
                 return map->writeable_reg(map->dev, reg);
 
+        if (map->wr_table)
+                return _regmap_check_range_table(map, reg, map->wr_table);
+
         return true;
 }
 
@@ -56,6 +89,9 @@ bool regmap_readable(struct regmap *map, unsigned int reg)
         if (map->readable_reg)
                 return map->readable_reg(map->dev, reg);
 
+        if (map->rd_table)
+                return _regmap_check_range_table(map, reg, map->rd_table);
+
         return true;
 }
 
@@ -67,6 +103,9 @@ bool regmap_volatile(struct regmap *map, unsigned int reg)
         if (map->volatile_reg)
                 return map->volatile_reg(map->dev, reg);
 
+        if (map->volatile_table)
+                return _regmap_check_range_table(map, reg, map->volatile_table);
+
         return true;
 }
 
@@ -78,11 +117,14 @@ bool regmap_precious(struct regmap *map, unsigned int reg)
         if (map->precious_reg)
                 return map->precious_reg(map->dev, reg);
 
+        if (map->precious_table)
+                return _regmap_check_range_table(map, reg, map->precious_table);
+
         return false;
 }
 
 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
-        unsigned int num)
+        size_t num)
 {
         unsigned int i;
 
@@ -214,23 +256,27 @@ static unsigned int regmap_parse_32_native(void *buf)
         return *(u32 *)buf;
 }
 
-static void regmap_lock_mutex(struct regmap *map)
+static void regmap_lock_mutex(void *__map)
 {
+        struct regmap *map = __map;
         mutex_lock(&map->mutex);
 }
 
-static void regmap_unlock_mutex(struct regmap *map)
+static void regmap_unlock_mutex(void *__map)
 {
+        struct regmap *map = __map;
         mutex_unlock(&map->mutex);
 }
 
-static void regmap_lock_spinlock(struct regmap *map)
+static void regmap_lock_spinlock(void *__map)
 {
+        struct regmap *map = __map;
         spin_lock(&map->spinlock);
 }
 
-static void regmap_unlock_spinlock(struct regmap *map)
+static void regmap_unlock_spinlock(void *__map)
 {
+        struct regmap *map = __map;
         spin_unlock(&map->spinlock);
 }
 
@@ -335,14 +381,21 @@ struct regmap *regmap_init(struct device *dev,
                 goto err;
         }
 
-        if (bus->fast_io) {
-                spin_lock_init(&map->spinlock);
-                map->lock = regmap_lock_spinlock;
-                map->unlock = regmap_unlock_spinlock;
+        if (config->lock && config->unlock) {
+                map->lock = config->lock;
+                map->unlock = config->unlock;
+                map->lock_arg = config->lock_arg;
         } else {
-                mutex_init(&map->mutex);
-                map->lock = regmap_lock_mutex;
-                map->unlock = regmap_unlock_mutex;
+                if (bus->fast_io) {
+                        spin_lock_init(&map->spinlock);
+                        map->lock = regmap_lock_spinlock;
+                        map->unlock = regmap_unlock_spinlock;
+                } else {
+                        mutex_init(&map->mutex);
+                        map->lock = regmap_lock_mutex;
+                        map->unlock = regmap_unlock_mutex;
+                }
+                map->lock_arg = map;
         }
         map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
         map->format.pad_bytes = config->pad_bits / 8;
@@ -359,6 +412,10 @@ struct regmap *regmap_init(struct device *dev,
         map->bus = bus;
         map->bus_context = bus_context;
         map->max_register = config->max_register;
+        map->wr_table = config->wr_table;
+        map->rd_table = config->rd_table;
+        map->volatile_table = config->volatile_table;
+        map->precious_table = config->precious_table;
         map->writeable_reg = config->writeable_reg;
         map->readable_reg = config->readable_reg;
         map->volatile_reg = config->volatile_reg;
@@ -519,20 +576,38 @@ struct regmap *regmap_init(struct device *dev,
         }
 
         map->range_tree = RB_ROOT;
-        for (i = 0; i < config->n_ranges; i++) {
+        for (i = 0; i < config->num_ranges; i++) {
                 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
                 struct regmap_range_node *new;
 
                 /* Sanity check */
-                if (range_cfg->range_max < range_cfg->range_min ||
-                    range_cfg->range_max > map->max_register ||
-                    range_cfg->selector_reg > map->max_register ||
-                    range_cfg->window_len == 0)
+                if (range_cfg->range_max < range_cfg->range_min) {
+                        dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
+                                range_cfg->range_max, range_cfg->range_min);
+                        goto err_range;
+                }
+
+                if (range_cfg->range_max > map->max_register) {
+                        dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
+                                range_cfg->range_max, map->max_register);
+                        goto err_range;
+                }
+
+                if (range_cfg->selector_reg > map->max_register) {
+                        dev_err(map->dev,
+                                "Invalid range %d: selector out of map\n", i);
+                        goto err_range;
+                }
+
+                if (range_cfg->window_len == 0) {
+                        dev_err(map->dev, "Invalid range %d: window_len 0\n",
+                                i);
                         goto err_range;
+                }
 
                 /* Make sure, that this register range has no selector
                    or data window within its boundary */
-                for (j = 0; j < config->n_ranges; j++) {
+                for (j = 0; j < config->num_ranges; j++) {
                         unsigned sel_reg = config->ranges[j].selector_reg;
                         unsigned win_min = config->ranges[j].window_start;
                         unsigned win_max = win_min +
@@ -540,11 +615,17 @@ struct regmap *regmap_init(struct device *dev,
 
                         if (range_cfg->range_min <= sel_reg &&
                             sel_reg <= range_cfg->range_max) {
+                                dev_err(map->dev,
+                                        "Range %d: selector for %d in window\n",
+                                        i, j);
                                 goto err_range;
                         }
 
                         if (!(win_max < range_cfg->range_min ||
                               win_min > range_cfg->range_max)) {
+                                dev_err(map->dev,
+                                        "Range %d: window for %d in window\n",
+                                        i, j);
                                 goto err_range;
                         }
                 }
@@ -555,6 +636,8 @@ struct regmap *regmap_init(struct device *dev,
                         goto err_range;
                 }
 
+                new->map = map;
+                new->name = range_cfg->name;
                 new->range_min = range_cfg->range_min;
                 new->range_max = range_cfg->range_max;
                 new->selector_reg = range_cfg->selector_reg;
@@ -564,6 +647,7 @@ struct regmap *regmap_init(struct device *dev,
                 new->window_len = range_cfg->window_len;
 
                 if (_regmap_range_add(map, new) == false) {
+                        dev_err(map->dev, "Failed to add range %d\n", i);
                         kfree(new);
                         goto err_range;
                 }
@@ -579,7 +663,7 @@ struct regmap *regmap_init(struct device *dev,
         }
 
         ret = regcache_init(map, config);
-        if (ret < 0)
+        if (ret != 0)
                 goto err_range;
 
         regmap_debugfs_init(map, config->name);
@@ -738,59 +822,57 @@ struct regmap *dev_get_regmap(struct device *dev, const char *name)
 EXPORT_SYMBOL_GPL(dev_get_regmap);
 
 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
+                               struct regmap_range_node *range,
                                unsigned int val_num)
 {
-        struct regmap_range_node *range;
         void *orig_work_buf;
         unsigned int win_offset;
         unsigned int win_page;
         bool page_chg;
         int ret;
 
-        range = _regmap_range_lookup(map, *reg);
-        if (range) {
-                win_offset = (*reg - range->range_min) % range->window_len;
-                win_page = (*reg - range->range_min) / range->window_len;
-
-                if (val_num > 1) {
-                        /* Bulk write shouldn't cross range boundary */
-                        if (*reg + val_num - 1 > range->range_max)
-                                return -EINVAL;
+        win_offset = (*reg - range->range_min) % range->window_len;
+        win_page = (*reg - range->range_min) / range->window_len;
 
-                        /* ... or single page boundary */
-                        if (val_num > range->window_len - win_offset)
-                                return -EINVAL;
-                }
+        if (val_num > 1) {
+                /* Bulk write shouldn't cross range boundary */
+                if (*reg + val_num - 1 > range->range_max)
+                        return -EINVAL;
 
-                /* It is possible to have selector register inside data window.
-                   In that case, selector register is located on every page and
-                   it needs no page switching, when accessed alone. */
-                if (val_num > 1 ||
-                    range->window_start + win_offset != range->selector_reg) {
-                        /* Use separate work_buf during page switching */
-                        orig_work_buf = map->work_buf;
-                        map->work_buf = map->selector_work_buf;
+                /* ... or single page boundary */
+                if (val_num > range->window_len - win_offset)
+                        return -EINVAL;
+        }
 
-                        ret = _regmap_update_bits(map, range->selector_reg,
-                                        range->selector_mask,
-                                        win_page << range->selector_shift,
-                                        &page_chg);
+        /* It is possible to have selector register inside data window.
+           In that case, selector register is located on every page and
+           it needs no page switching, when accessed alone. */
+        if (val_num > 1 ||
+            range->window_start + win_offset != range->selector_reg) {
+                /* Use separate work_buf during page switching */
+                orig_work_buf = map->work_buf;
+                map->work_buf = map->selector_work_buf;
 
-                        map->work_buf = orig_work_buf;
+                ret = _regmap_update_bits(map, range->selector_reg,
+                                          range->selector_mask,
+                                          win_page << range->selector_shift,
+                                          &page_chg);
 
-                        if (ret < 0)
-                                return ret;
-                }
+                map->work_buf = orig_work_buf;
 
-                *reg = range->window_start + win_offset;
+                if (ret != 0)
+                        return ret;
         }
 
+        *reg = range->window_start + win_offset;
+
         return 0;
 }
 
 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
                              const void *val, size_t val_len)
 {
+        struct regmap_range_node *range;
         u8 *u8 = map->work_buf;
         void *buf;
         int ret = -ENOTSUPP;
@@ -814,7 +896,7 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
                                              ival);
                         if (ret) {
                                 dev_err(map->dev,
-                                   "Error in caching of register: %u ret: %d\n",
+                                        "Error in caching of register: %x ret: %d\n",
                                         reg + i, ret);
                                 return ret;
                         }
@@ -825,9 +907,35 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
                 }
         }
 
-        ret = _regmap_select_page(map, &reg, val_len / map->format.val_bytes);
-        if (ret < 0)
-                return ret;
+        range = _regmap_range_lookup(map, reg);
+        if (range) {
+                int val_num = val_len / map->format.val_bytes;
+                int win_offset = (reg - range->range_min) % range->window_len;
+                int win_residue = range->window_len - win_offset;
+
+                /* If the write goes beyond the end of the window split it */
+                while (val_num > win_residue) {
+                        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);
+                        if (ret != 0)
+                                return ret;
+
+                        reg += win_residue;
+                        val_num -= win_residue;
+                        val += win_residue * map->format.val_bytes;
+                        val_len -= win_residue * map->format.val_bytes;
+
+                        win_offset = (reg - range->range_min) %
+                                range->window_len;
+                        win_residue = range->window_len - win_offset;
+                }
+
+                ret = _regmap_select_page(map, &reg, range, val_num);
+                if (ret != 0)
+                        return ret;
+        }
 
         map->format.format_reg(map->work_buf, reg, map->reg_shift);
 
@@ -876,6 +984,7 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
 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);
 
@@ -897,9 +1006,12 @@ int _regmap_write(struct regmap *map, unsigned int reg,
         trace_regmap_reg_write(map->dev, reg, val);
 
         if (map->format.format_write) {
-                ret = _regmap_select_page(map, &reg, 1);
-                if (ret < 0)
-                        return ret;
+                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);
 
@@ -939,11 +1051,11 @@ int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
         if (reg % map->reg_stride)
                 return -EINVAL;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
 
         ret = _regmap_write(map, reg, val);
 
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 
         return ret;
 }
@@ -975,11 +1087,11 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
         if (reg % map->reg_stride)
                 return -EINVAL;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
 
         ret = _regmap_raw_write(map, reg, val, val_len);
 
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 
         return ret;
 }
@@ -1011,7 +1123,7 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
         if (reg % map->reg_stride)
                 return -EINVAL;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
 
         /* No formatting is require if val_byte is 1 */
         if (val_bytes == 1) {
@@ -1047,7 +1159,7 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
                 kfree(wval);
 
 out:
-        map->unlock(map);
+        map->unlock(map->lock_arg);
         return ret;
 }
 EXPORT_SYMBOL_GPL(regmap_bulk_write);
@@ -1055,12 +1167,17 @@ EXPORT_SYMBOL_GPL(regmap_bulk_write);
 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
                             unsigned int val_len)
 {
+        struct regmap_range_node *range;
         u8 *u8 = map->work_buf;
         int ret;
 
-        ret = _regmap_select_page(map, &reg, val_len / map->format.val_bytes);
-        if (ret < 0)
-                return ret;
+        range = _regmap_range_lookup(map, reg);
+        if (range) {
+                ret = _regmap_select_page(map, &reg, range,
+                                          val_len / map->format.val_bytes);
+                if (ret != 0)
+                        return ret;
+        }
 
         map->format.format_reg(map->work_buf, reg, map->reg_shift);
 
@@ -1137,11 +1254,11 @@ int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
         if (reg % map->reg_stride)
                 return -EINVAL;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
 
         ret = _regmap_read(map, reg, val);
 
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 
         return ret;
 }
@@ -1171,7 +1288,7 @@ int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
         if (reg % map->reg_stride)
                 return -EINVAL;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
 
         if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
             map->cache_type == REGCACHE_NONE) {
@@ -1193,7 +1310,7 @@ int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
         }
 
  out:
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 
         return ret;
 }
@@ -1300,9 +1417,9 @@ int regmap_update_bits(struct regmap *map, unsigned int reg,
         bool change;
         int ret;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
         ret = _regmap_update_bits(map, reg, mask, val, &change);
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 
         return ret;
 }
@@ -1326,9 +1443,9 @@ int regmap_update_bits_check(struct regmap *map, unsigned int reg,
 {
         int ret;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
         ret = _regmap_update_bits(map, reg, mask, val, change);
-        map->unlock(map);
+        map->unlock(map->lock_arg);
         return ret;
 }
 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
@@ -1357,7 +1474,7 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
         if (map->patch)
                 return -EBUSY;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
 
         bypass = map->cache_bypass;
 
@@ -1385,7 +1502,7 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
 out:
         map->cache_bypass = bypass;
 
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 
         return ret;
 }