Merge branch 'next' into for-linus

Prepare first round of input updates for 3.17.

20 files changed, 537 insertions, 211 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index 8fa8deab6449..23b8726962af 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -1,10 +1,10 @@
 menu "Generic Driver Options"
 
-config UEVENT_HELPER_PATH
-        string "path to uevent helper"
-        default ""
+config UEVENT_HELPER
+        bool "Support for uevent helper"
+        default y
         help
-          Path to uevent helper program forked by the kernel for
+          The uevent helper program is forked by the kernel for
           every uevent.
           Before the switch to the netlink-based uevent source, this was
           used to hook hotplug scripts into kernel device events. It
@@ -15,8 +15,13 @@ config UEVENT_HELPER_PATH
           that it creates a high system load, or on smaller systems
           it is known to create out-of-memory situations during bootup.
 
-          To disable user space helper program execution at early boot
-          time specify an empty string here. This setting can be altered
+config UEVENT_HELPER_PATH
+        string "path to uevent helper"
+        depends on UEVENT_HELPER
+        default ""
+        help
+          To disable user space helper program execution at by default
+          specify an empty string here. This setting can still be altered
           via /proc/sys/kernel/hotplug or via /sys/kernel/uevent_helper
           later at runtime.
 
@@ -253,7 +258,7 @@ endchoice
 
 config CMA_ALIGNMENT
         int "Maximum PAGE_SIZE order of alignment for contiguous buffers"
-        range 4 9
+        range 4 12
         default 8
         help
           DMA mapping framework by default aligns all buffers to the smallest
diff --git a/drivers/base/base.h b/drivers/base/base.h
index 24f424249d9b..251c5d30f963 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -63,8 +63,6 @@ struct driver_private {
  *      binding of drivers which were unable to get all the resources needed by
  *      the device; typically because it depends on another driver getting
  *      probed first.
- * @driver_data - private pointer for driver specific info.  Will turn into a
- * list soon.
  * @device - pointer back to the struct class that this structure is
  * associated with.
  *
@@ -76,7 +74,6 @@ struct device_private {
         struct klist_node knode_driver;
         struct klist_node knode_bus;
         struct list_head deferred_probe;
-        void *driver_data;
         struct device *device;
 };
 #define to_device_private_parent(obj)   \
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 62ec61e8f84a..e4ffbcf2f519 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -587,29 +587,3 @@ void driver_detach(struct device_driver *drv)
                 put_device(dev);
         }
 }
-
-/*
- * These exports can't be _GPL due to .h files using this within them, and it
- * might break something that was previously working...
- */
-void *dev_get_drvdata(const struct device *dev)
-{
-        if (dev && dev->p)
-                return dev->p->driver_data;
-        return NULL;
-}
-EXPORT_SYMBOL(dev_get_drvdata);
-
-int dev_set_drvdata(struct device *dev, void *data)
-{
-        int error;
-
-        if (!dev->p) {
-                error = device_private_init(dev);
-                if (error)
-                        return error;
-        }
-        dev->p->driver_data = data;
-        return 0;
-}
-EXPORT_SYMBOL(dev_set_drvdata);
diff --git a/drivers/base/devres.c b/drivers/base/devres.c
index db4e264eecb6..52302946770f 100644
--- a/drivers/base/devres.c
+++ b/drivers/base/devres.c
@@ -831,3 +831,100 @@ void devm_kfree(struct device *dev, void *p)
         WARN_ON(rc);
 }
 EXPORT_SYMBOL_GPL(devm_kfree);
+
+/**
+ * devm_kmemdup - Resource-managed kmemdup
+ * @dev: Device this memory belongs to
+ * @src: Memory region to duplicate
+ * @len: Memory region length
+ * @gfp: GFP mask to use
+ *
+ * Duplicate region of a memory using resource managed kmalloc
+ */
+void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp)
+{
+        void *p;
+
+        p = devm_kmalloc(dev, len, gfp);
+        if (p)
+                memcpy(p, src, len);
+
+        return p;
+}
+EXPORT_SYMBOL_GPL(devm_kmemdup);
+
+struct pages_devres {
+        unsigned long addr;
+        unsigned int order;
+};
+
+static int devm_pages_match(struct device *dev, void *res, void *p)
+{
+        struct pages_devres *devres = res;
+        struct pages_devres *target = p;
+
+        return devres->addr == target->addr;
+}
+
+static void devm_pages_release(struct device *dev, void *res)
+{
+        struct pages_devres *devres = res;
+
+        free_pages(devres->addr, devres->order);
+}
+
+/**
+ * devm_get_free_pages - Resource-managed __get_free_pages
+ * @dev: Device to allocate memory for
+ * @gfp_mask: Allocation gfp flags
+ * @order: Allocation size is (1 << order) pages
+ *
+ * Managed get_free_pages.  Memory allocated with this function is
+ * automatically freed on driver detach.
+ *
+ * RETURNS:
+ * Address of allocated memory on success, 0 on failure.
+ */
+
+unsigned long devm_get_free_pages(struct device *dev,
+                                  gfp_t gfp_mask, unsigned int order)
+{
+        struct pages_devres *devres;
+        unsigned long addr;
+
+        addr = __get_free_pages(gfp_mask, order);
+
+        if (unlikely(!addr))
+                return 0;
+
+        devres = devres_alloc(devm_pages_release,
+                              sizeof(struct pages_devres), GFP_KERNEL);
+        if (unlikely(!devres)) {
+                free_pages(addr, order);
+                return 0;
+        }
+
+        devres->addr = addr;
+        devres->order = order;
+
+        devres_add(dev, devres);
+        return addr;
+}
+EXPORT_SYMBOL_GPL(devm_get_free_pages);
+
+/**
+ * devm_free_pages - Resource-managed free_pages
+ * @dev: Device this memory belongs to
+ * @addr: Memory to free
+ *
+ * Free memory allocated with devm_get_free_pages(). Unlike free_pages,
+ * there is no need to supply the @order.
+ */
+void devm_free_pages(struct device *dev, unsigned long addr)
+{
+        struct pages_devres devres = { .addr = addr };
+
+        WARN_ON(devres_release(dev, devm_pages_release, devm_pages_match,
+                               &devres));
+}
+EXPORT_SYMBOL_GPL(devm_free_pages);
diff --git a/drivers/base/dma-buf.c b/drivers/base/dma-buf.c
index ea77701deda4..840c7fa80983 100644
--- a/drivers/base/dma-buf.c
+++ b/drivers/base/dma-buf.c
@@ -491,7 +491,7 @@ EXPORT_SYMBOL_GPL(dma_buf_kunmap);
  *                      dma-buf buffer.
  *
  * This function adjusts the passed in vma so that it points at the file of the
- * dma_buf operation. It alsog adjusts the starting pgoff and does bounds
+ * dma_buf operation. It also adjusts the starting pgoff and does bounds
  * checking on the size of the vma. Then it calls the exporters mmap function to
  * set up the mapping.
  *
diff --git a/drivers/base/dma-coherent.c b/drivers/base/dma-coherent.c
index bc256b641027..7d6e84a51424 100644
--- a/drivers/base/dma-coherent.c
+++ b/drivers/base/dma-coherent.c
@@ -10,13 +10,13 @@
 struct dma_coherent_mem {
         void            *virt_base;
         dma_addr_t      device_base;
-        phys_addr_t     pfn_base;
+        unsigned long   pfn_base;
         int             size;
         int             flags;
         unsigned long   *bitmap;
 };
 
-int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
+int dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
                                 dma_addr_t device_addr, size_t size, int flags)
 {
         void __iomem *mem_base = NULL;
@@ -32,7 +32,7 @@ int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
 
         /* FIXME: this routine just ignores DMA_MEMORY_INCLUDES_CHILDREN */
 
-        mem_base = ioremap(bus_addr, size);
+        mem_base = ioremap(phys_addr, size);
         if (!mem_base)
                 goto out;
 
@@ -45,7 +45,7 @@ int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
 
         dev->dma_mem->virt_base = mem_base;
         dev->dma_mem->device_base = device_addr;
-        dev->dma_mem->pfn_base = PFN_DOWN(bus_addr);
+        dev->dma_mem->pfn_base = PFN_DOWN(phys_addr);
         dev->dma_mem->size = pages;
         dev->dma_mem->flags = flags;
 
@@ -208,7 +208,7 @@ int dma_mmap_from_coherent(struct device *dev, struct vm_area_struct *vma,
 
                 *ret = -ENXIO;
                 if (off < count && user_count <= count - off) {
-                        unsigned pfn = mem->pfn_base + start + off;
+                        unsigned long pfn = mem->pfn_base + start + off;
                         *ret = remap_pfn_range(vma, vma->vm_start, pfn,
                                                user_count << PAGE_SHIFT,
                                                vma->vm_page_prot);
diff --git a/drivers/base/dma-contiguous.c b/drivers/base/dma-contiguous.c
index 165c2c299e57..6467c919c509 100644
--- a/drivers/base/dma-contiguous.c
+++ b/drivers/base/dma-contiguous.c
@@ -37,6 +37,7 @@ struct cma {
         unsigned long   base_pfn;
         unsigned long   count;
         unsigned long   *bitmap;
+        struct mutex    lock;
 };
 
 struct cma *dma_contiguous_default_area;
@@ -59,11 +60,22 @@ struct cma *dma_contiguous_default_area;
  */
 static const phys_addr_t size_bytes = CMA_SIZE_MBYTES * SZ_1M;
 static phys_addr_t size_cmdline = -1;
+static phys_addr_t base_cmdline;
+static phys_addr_t limit_cmdline;
 
 static int __init early_cma(char *p)
 {
         pr_debug("%s(%s)\n", __func__, p);
         size_cmdline = memparse(p, &p);
+        if (*p != '@')
+                return 0;
+        base_cmdline = memparse(p + 1, &p);
+        if (*p != '-') {
+                limit_cmdline = base_cmdline + size_cmdline;
+                return 0;
+        }
+        limit_cmdline = memparse(p + 1, &p);
+
         return 0;
 }
 early_param("cma", early_cma);
@@ -107,11 +119,18 @@ static inline __maybe_unused phys_addr_t cma_early_percent_memory(void)
 void __init dma_contiguous_reserve(phys_addr_t limit)
 {
         phys_addr_t selected_size = 0;
+        phys_addr_t selected_base = 0;
+        phys_addr_t selected_limit = limit;
+        bool fixed = false;
 
         pr_debug("%s(limit %08lx)\n", __func__, (unsigned long)limit);
 
         if (size_cmdline != -1) {
                 selected_size = size_cmdline;
+                selected_base = base_cmdline;
+                selected_limit = min_not_zero(limit_cmdline, limit);
+                if (base_cmdline + size_cmdline == limit_cmdline)
+                        fixed = true;
         } else {
 #ifdef CONFIG_CMA_SIZE_SEL_MBYTES
                 selected_size = size_bytes;
@@ -128,10 +147,12 @@ void __init dma_contiguous_reserve(phys_addr_t limit)
                 pr_debug("%s: reserving %ld MiB for global area\n", __func__,
                          (unsigned long)selected_size / SZ_1M);
 
-                dma_contiguous_reserve_area(selected_size, 0, limit,
-                                            &dma_contiguous_default_area);
+                dma_contiguous_reserve_area(selected_size, selected_base,
+                                            selected_limit,
+                                            &dma_contiguous_default_area,
+                                            fixed);
         }
-};
+}
 
 static DEFINE_MUTEX(cma_mutex);
 
@@ -155,13 +176,24 @@ static int __init cma_activate_area(struct cma *cma)
                 base_pfn = pfn;
                 for (j = pageblock_nr_pages; j; --j, pfn++) {
                         WARN_ON_ONCE(!pfn_valid(pfn));
+                        /*
+                         * alloc_contig_range requires the pfn range
+                         * specified to be in the same zone. Make this
+                         * simple by forcing the entire CMA resv range
+                         * to be in the same zone.
+                         */
                         if (page_zone(pfn_to_page(pfn)) != zone)
-                                return -EINVAL;
+                                goto err;
                 }
                 init_cma_reserved_pageblock(pfn_to_page(base_pfn));
         } while (--i);
 
+        mutex_init(&cma->lock);
         return 0;
+
+err:
+        kfree(cma->bitmap);
+        return -EINVAL;
 }
 
 static struct cma cma_areas[MAX_CMA_AREAS];
@@ -187,15 +219,20 @@ core_initcall(cma_init_reserved_areas);
  * @base: Base address of the reserved area optional, use 0 for any
  * @limit: End address of the reserved memory (optional, 0 for any).
  * @res_cma: Pointer to store the created cma region.
+ * @fixed: hint about where to place the reserved area
  *
  * This function reserves memory from early allocator. It should be
  * called by arch specific code once the early allocator (memblock or bootmem)
  * has been activated and all other subsystems have already allocated/reserved
  * memory. This function allows to create custom reserved areas for specific
  * devices.
+ *
+ * If @fixed is true, reserve contiguous area at exactly @base.  If false,
+ * reserve in range from @base to @limit.
  */
 int __init dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base,
-                                       phys_addr_t limit, struct cma **res_cma)
+                                       phys_addr_t limit, struct cma **res_cma,
+                                       bool fixed)
 {
         struct cma *cma = &cma_areas[cma_area_count];
         phys_addr_t alignment;
@@ -221,18 +258,15 @@ int __init dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base,
         limit &= ~(alignment - 1);
 
         /* Reserve memory */
-        if (base) {
+        if (base && fixed) {
                 if (memblock_is_region_reserved(base, size) ||
                     memblock_reserve(base, size) < 0) {
                         ret = -EBUSY;
                         goto err;
                 }
         } else {
-                /*
-                 * Use __memblock_alloc_base() since
-                 * memblock_alloc_base() panic()s.
-                 */
-                phys_addr_t addr = __memblock_alloc_base(size, alignment, limit);
+                phys_addr_t addr = memblock_alloc_range(size, alignment, base,
+                                                        limit);
                 if (!addr) {
                         ret = -ENOMEM;
                         goto err;
@@ -261,6 +295,13 @@ err:
         return ret;
 }
 
+static void clear_cma_bitmap(struct cma *cma, unsigned long pfn, int count)
+{
+        mutex_lock(&cma->lock);
+        bitmap_clear(cma->bitmap, pfn - cma->base_pfn, count);
+        mutex_unlock(&cma->lock);
+}
+
 /**
  * dma_alloc_from_contiguous() - allocate pages from contiguous area
  * @dev:   Pointer to device for which the allocation is performed.
@@ -269,7 +310,7 @@ err:
  *
  * This function allocates memory buffer for specified device. It uses
  * device specific contiguous memory area if available or the default
- * global one. Requires architecture specific get_dev_cma_area() helper
+ * global one. Requires architecture specific dev_get_cma_area() helper
  * function.
  */
 struct page *dma_alloc_from_contiguous(struct device *dev, int count,
@@ -294,30 +335,41 @@ struct page *dma_alloc_from_contiguous(struct device *dev, int count,
 
         mask = (1 << align) - 1;
 
-        mutex_lock(&cma_mutex);
 
         for (;;) {
+                mutex_lock(&cma->lock);
                 pageno = bitmap_find_next_zero_area(cma->bitmap, cma->count,
                                                     start, count, mask);
-                if (pageno >= cma->count)
+                if (pageno >= cma->count) {
+                        mutex_unlock(&cma->lock);
                         break;
+                }
+                bitmap_set(cma->bitmap, pageno, count);
+                /*
+                 * It's safe to drop the lock here. We've marked this region for
+                 * our exclusive use. If the migration fails we will take the
+                 * lock again and unmark it.
+                 */
+                mutex_unlock(&cma->lock);
 
                 pfn = cma->base_pfn + pageno;
+                mutex_lock(&cma_mutex);
                 ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA);
+                mutex_unlock(&cma_mutex);
                 if (ret == 0) {
-                        bitmap_set(cma->bitmap, pageno, count);
                         page = pfn_to_page(pfn);
                         break;
                 } else if (ret != -EBUSY) {
+                        clear_cma_bitmap(cma, pfn, count);
                         break;
                 }
+                clear_cma_bitmap(cma, pfn, count);
                 pr_debug("%s(): memory range at %p is busy, retrying\n",
                          __func__, pfn_to_page(pfn));
                 /* try again with a bit different memory target */
                 start = pageno + mask + 1;
         }
 
-        mutex_unlock(&cma_mutex);
         pr_debug("%s(): returned %p\n", __func__, page);
         return page;
 }
@@ -350,10 +402,8 @@ bool dma_release_from_contiguous(struct device *dev, struct page *pages,
 
         VM_BUG_ON(pfn + count > cma->base_pfn + cma->count);
 
-        mutex_lock(&cma_mutex);
-        bitmap_clear(cma->bitmap, pfn - cma->base_pfn, count);
         free_contig_range(pfn, count);
-        mutex_unlock(&cma_mutex);
+        clear_cma_bitmap(cma, pfn, count);
 
         return true;
 }
diff --git a/drivers/base/dma-mapping.c b/drivers/base/dma-mapping.c
index 0ce39a33b3c2..6cd08e145bfa 100644
--- a/drivers/base/dma-mapping.c
+++ b/drivers/base/dma-mapping.c
@@ -175,7 +175,7 @@ static void dmam_coherent_decl_release(struct device *dev, void *res)
 /**
  * dmam_declare_coherent_memory - Managed dma_declare_coherent_memory()
  * @dev: Device to declare coherent memory for
- * @bus_addr: Bus address of coherent memory to be declared
+ * @phys_addr: Physical address of coherent memory to be declared
  * @device_addr: Device address of coherent memory to be declared
  * @size: Size of coherent memory to be declared
  * @flags: Flags
@@ -185,7 +185,7 @@ static void dmam_coherent_decl_release(struct device *dev, void *res)
  * RETURNS:
  * 0 on success, -errno on failure.
  */
-int dmam_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
+int dmam_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
                                  dma_addr_t device_addr, size_t size, int flags)
 {
         void *res;
@@ -195,7 +195,7 @@ int dmam_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
         if (!res)
                 return -ENOMEM;
 
-        rc = dma_declare_coherent_memory(dev, bus_addr, device_addr, size,
+        rc = dma_declare_coherent_memory(dev, phys_addr, device_addr, size,
                                          flags);
         if (rc == 0)
                 devres_add(dev, res);
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index bece691cb5d9..89f752dd8465 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -118,16 +118,6 @@ static ssize_t show_mem_start_phys_index(struct device *dev,
         return sprintf(buf, "%08lx\n", phys_index);
 }
 
-static ssize_t show_mem_end_phys_index(struct device *dev,
-                        struct device_attribute *attr, char *buf)
-{
-        struct memory_block *mem = to_memory_block(dev);
-        unsigned long phys_index;
-
-        phys_index = mem->end_section_nr / sections_per_block;
-        return sprintf(buf, "%08lx\n", phys_index);
-}
-
 /*
  * Show whether the section of memory is likely to be hot-removable
  */
@@ -384,7 +374,6 @@ static ssize_t show_phys_device(struct device *dev,
 }
 
 static DEVICE_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
-static DEVICE_ATTR(end_phys_index, 0444, show_mem_end_phys_index, NULL);
 static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state);
 static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL);
 static DEVICE_ATTR(removable, 0444, show_mem_removable, NULL);
@@ -529,7 +518,6 @@ struct memory_block *find_memory_block(struct mem_section *section)
 
 static struct attribute *memory_memblk_attrs[] = {
         &dev_attr_phys_index.attr,
-        &dev_attr_end_phys_index.attr,
         &dev_attr_state.attr,
         &dev_attr_phys_device.attr,
         &dev_attr_removable.attr,
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 5b47210889e0..eee48c49f5de 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -89,8 +89,13 @@ int platform_get_irq(struct platform_device *dev, unsigned int num)
         return dev->archdata.irqs[num];
 #else
         struct resource *r;
-        if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node)
-                return of_irq_get(dev->dev.of_node, num);
+        if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
+                int ret;
+
+                ret = of_irq_get(dev->dev.of_node, num);
+                if (ret >= 0 || ret == -EPROBE_DEFER)
+                        return ret;
+        }
 
         r = platform_get_resource(dev, IORESOURCE_IRQ, num);
 
@@ -131,9 +136,17 @@ EXPORT_SYMBOL_GPL(platform_get_resource_byname);
  */
 int platform_get_irq_byname(struct platform_device *dev, const char *name)
 {
-        struct resource *r = platform_get_resource_byname(dev, IORESOURCE_IRQ,
-                                                          name);
+        struct resource *r;
+
+        if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
+                int ret;
+
+                ret = of_irq_get_byname(dev->dev.of_node, name);
+                if (ret >= 0 || ret == -EPROBE_DEFER)
+                        return ret;
+        }
 
+        r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name);
         return r ? r->start : -ENXIO;
 }
 EXPORT_SYMBOL_GPL(platform_get_irq_byname);
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index ae098a261fcd..eee55c1e5fde 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -105,7 +105,7 @@ static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
 static void genpd_sd_counter_inc(struct generic_pm_domain *genpd)
 {
         atomic_inc(&genpd->sd_count);
-        smp_mb__after_atomic_inc();
+        smp_mb__after_atomic();
 }
 
 static void genpd_acquire_lock(struct generic_pm_domain *genpd)
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 86d5e4fb5b98..bf412961a934 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -214,9 +214,6 @@ static void initcall_debug_report(struct device *dev, ktime_t calltime,
                 pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
                         error, (unsigned long long)nsecs >> 10);
         }
-
-        trace_device_pm_report_time(dev, info, nsecs, pm_verb(state.event),
-                                    error);
 }
 
 /**
@@ -387,7 +384,9 @@ static int dpm_run_callback(pm_callback_t cb, struct device *dev,
         calltime = initcall_debug_start(dev);
 
         pm_dev_dbg(dev, state, info);
+        trace_device_pm_callback_start(dev, info, state.event);
         error = cb(dev);
+        trace_device_pm_callback_end(dev, error);
         suspend_report_result(cb, error);
 
         initcall_debug_report(dev, calltime, error, state, info);
@@ -479,7 +478,7 @@ static int device_resume_noirq(struct device *dev, pm_message_t state, bool asyn
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        if (dev->power.syscore)
+        if (dev->power.syscore || dev->power.direct_complete)
                 goto Out;
 
         if (!dev->power.is_noirq_suspended)
@@ -545,6 +544,7 @@ static void dpm_resume_noirq(pm_message_t state)
         struct device *dev;
         ktime_t starttime = ktime_get();
 
+        trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, true);
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
 
@@ -587,6 +587,7 @@ static void dpm_resume_noirq(pm_message_t state)
         dpm_show_time(starttime, state, "noirq");
         resume_device_irqs();
         cpuidle_resume();
+        trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
 }
 
 /**
@@ -605,7 +606,7 @@ static int device_resume_early(struct device *dev, pm_message_t state, bool asyn
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        if (dev->power.syscore)
+        if (dev->power.syscore || dev->power.direct_complete)
                 goto Out;
 
         if (!dev->power.is_late_suspended)
@@ -664,6 +665,7 @@ static void dpm_resume_early(pm_message_t state)
         struct device *dev;
         ktime_t starttime = ktime_get();
 
+        trace_suspend_resume(TPS("dpm_resume_early"), state.event, true);
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
 
@@ -703,6 +705,7 @@ static void dpm_resume_early(pm_message_t state)
         mutex_unlock(&dpm_list_mtx);
         async_synchronize_full();
         dpm_show_time(starttime, state, "early");
+        trace_suspend_resume(TPS("dpm_resume_early"), state.event, false);
 }
 
 /**
@@ -735,6 +738,12 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
         if (dev->power.syscore)
                 goto Complete;
 
+        if (dev->power.direct_complete) {
+                /* Match the pm_runtime_disable() in __device_suspend(). */
+                pm_runtime_enable(dev);
+                goto Complete;
+        }
+
         dpm_wait(dev->parent, async);
         dpm_watchdog_set(&wd, dev);
         device_lock(dev);
@@ -828,6 +837,7 @@ void dpm_resume(pm_message_t state)
         struct device *dev;
         ktime_t starttime = ktime_get();
 
+        trace_suspend_resume(TPS("dpm_resume"), state.event, true);
         might_sleep();
 
         mutex_lock(&dpm_list_mtx);
@@ -869,6 +879,7 @@ void dpm_resume(pm_message_t state)
         dpm_show_time(starttime, state, NULL);
 
         cpufreq_resume();
+        trace_suspend_resume(TPS("dpm_resume"), state.event, false);
 }
 
 /**
@@ -907,7 +918,9 @@ static void device_complete(struct device *dev, pm_message_t state)
 
         if (callback) {
                 pm_dev_dbg(dev, state, info);
+                trace_device_pm_callback_start(dev, info, state.event);
                 callback(dev);
+                trace_device_pm_callback_end(dev, 0);
         }
 
         device_unlock(dev);
@@ -926,6 +939,7 @@ void dpm_complete(pm_message_t state)
 {
         struct list_head list;
 
+        trace_suspend_resume(TPS("dpm_complete"), state.event, true);
         might_sleep();
 
         INIT_LIST_HEAD(&list);
@@ -945,6 +959,7 @@ void dpm_complete(pm_message_t state)
         }
         list_splice(&list, &dpm_list);
         mutex_unlock(&dpm_list_mtx);
+        trace_suspend_resume(TPS("dpm_complete"), state.event, false);
 }
 
 /**
@@ -1007,7 +1022,7 @@ static int __device_suspend_noirq(struct device *dev, pm_message_t state, bool a
                 goto Complete;
         }
 
-        if (dev->power.syscore)
+        if (dev->power.syscore || dev->power.direct_complete)
                 goto Complete;
 
         dpm_wait_for_children(dev, async);
@@ -1080,6 +1095,7 @@ static int dpm_suspend_noirq(pm_message_t state)
         ktime_t starttime = ktime_get();
         int error = 0;
 
+        trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
         cpuidle_pause();
         suspend_device_irqs();
         mutex_lock(&dpm_list_mtx);
@@ -1120,6 +1136,7 @@ static int dpm_suspend_noirq(pm_message_t state)
         } else {
                 dpm_show_time(starttime, state, "noirq");
         }
+        trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false);
         return error;
 }
 
@@ -1146,7 +1163,7 @@ static int __device_suspend_late(struct device *dev, pm_message_t state, bool as
                 goto Complete;
         }
 
-        if (dev->power.syscore)
+        if (dev->power.syscore || dev->power.direct_complete)
                 goto Complete;
 
         dpm_wait_for_children(dev, async);
@@ -1216,6 +1233,7 @@ static int dpm_suspend_late(pm_message_t state)
         ktime_t starttime = ktime_get();
         int error = 0;
 
+        trace_suspend_resume(TPS("dpm_suspend_late"), state.event, true);
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
         async_error = 0;
@@ -1251,6 +1269,7 @@ static int dpm_suspend_late(pm_message_t state)
         } else {
                 dpm_show_time(starttime, state, "late");
         }
+        trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false);
         return error;
 }
 
@@ -1289,7 +1308,9 @@ static int legacy_suspend(struct device *dev, pm_message_t state,
 
         calltime = initcall_debug_start(dev);
 
+        trace_device_pm_callback_start(dev, info, state.event);
         error = cb(dev, state);
+        trace_device_pm_callback_end(dev, error);
         suspend_report_result(cb, error);
 
         initcall_debug_report(dev, calltime, error, state, info);
@@ -1332,6 +1353,17 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         if (dev->power.syscore)
                 goto Complete;
 
+        if (dev->power.direct_complete) {
+                if (pm_runtime_status_suspended(dev)) {
+                        pm_runtime_disable(dev);
+                        if (pm_runtime_suspended_if_enabled(dev))
+                                goto Complete;
+
+                        pm_runtime_enable(dev);
+                }
+                dev->power.direct_complete = false;
+        }
+
         dpm_watchdog_set(&wd, dev);
         device_lock(dev);
 
@@ -1382,10 +1414,19 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
 
  End:
         if (!error) {
+                struct device *parent = dev->parent;
+
                 dev->power.is_suspended = true;
-                if (dev->power.wakeup_path
-                    && dev->parent && !dev->parent->power.ignore_children)
-                        dev->parent->power.wakeup_path = true;
+                if (parent) {
+                        spin_lock_irq(&parent->power.lock);
+
+                        dev->parent->power.direct_complete = false;
+                        if (dev->power.wakeup_path
+                            && !dev->parent->power.ignore_children)
+                                dev->parent->power.wakeup_path = true;
+
+                        spin_unlock_irq(&parent->power.lock);
+                }
         }
 
         device_unlock(dev);
@@ -1435,6 +1476,7 @@ int dpm_suspend(pm_message_t state)
         ktime_t starttime = ktime_get();
         int error = 0;
 
+        trace_suspend_resume(TPS("dpm_suspend"), state.event, true);
         might_sleep();
 
         cpufreq_suspend();
@@ -1472,6 +1514,7 @@ int dpm_suspend(pm_message_t state)
                 dpm_save_failed_step(SUSPEND_SUSPEND);
         } else
                 dpm_show_time(starttime, state, NULL);
+        trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
         return error;
 }
 
@@ -1487,7 +1530,7 @@ static int device_prepare(struct device *dev, pm_message_t state)
 {
         int (*callback)(struct device *) = NULL;
         char *info = NULL;
-        int error = 0;
+        int ret = 0;
 
         if (dev->power.syscore)
                 return 0;
@@ -1524,16 +1567,29 @@ static int device_prepare(struct device *dev, pm_message_t state)
         }
 
         if (callback) {
-                error = callback(dev);
-                suspend_report_result(callback, error);
+                trace_device_pm_callback_start(dev, info, state.event);
+                ret = callback(dev);
+                trace_device_pm_callback_end(dev, ret);
         }
 
         device_unlock(dev);
 
-        if (error)
+        if (ret < 0) {
+                suspend_report_result(callback, ret);
                 pm_runtime_put(dev);
-
-        return error;
+                return ret;
+        }
+        /*
+         * A positive return value from ->prepare() means "this device appears
+         * to be runtime-suspended and its state is fine, so if it really is
+         * runtime-suspended, you can leave it in that state provided that you
+         * will do the same thing with all of its descendants".  This only
+         * applies to suspend transitions, however.
+         */
+        spin_lock_irq(&dev->power.lock);
+        dev->power.direct_complete = ret > 0 && state.event == PM_EVENT_SUSPEND;
+        spin_unlock_irq(&dev->power.lock);
+        return 0;
 }
 
 /**
@@ -1546,6 +1602,7 @@ int dpm_prepare(pm_message_t state)
 {
         int error = 0;
 
+        trace_suspend_resume(TPS("dpm_prepare"), state.event, true);
         might_sleep();
 
         mutex_lock(&dpm_list_mtx);
@@ -1576,6 +1633,7 @@ int dpm_prepare(pm_message_t state)
                 put_device(dev);
         }
         mutex_unlock(&dpm_list_mtx);
+        trace_suspend_resume(TPS("dpm_prepare"), state.event, false);
         return error;
 }
 
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index 25538675d59e..89ced955fafa 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -15,7 +15,6 @@
 #include <linux/errno.h>
 #include <linux/err.h>
 #include <linux/slab.h>
-#include <linux/cpufreq.h>
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/rculist.h>
@@ -394,6 +393,13 @@ EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
  * to keep the integrity of the internal data structures. Callers should ensure
  * that this function is *NOT* called under RCU protection or in contexts where
  * mutex cannot be locked.
+ *
+ * Return:
+ * 0:           On success OR
+ *              Duplicate OPPs (both freq and volt are same) and opp->available
+ * -EEXIST:     Freq are same and volt are different OR
+ *              Duplicate OPPs (both freq and volt are same) and !opp->available
+ * -ENOMEM:     Memory allocation failure
  */
 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
 {
@@ -443,15 +449,31 @@ int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
         new_opp->u_volt = u_volt;
         new_opp->available = true;
 
-        /* Insert new OPP in order of increasing frequency */
+        /*
+         * Insert new OPP in order of increasing frequency
+         * and discard if already present
+         */
         head = &dev_opp->opp_list;
         list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
-                if (new_opp->rate < opp->rate)
+                if (new_opp->rate <= opp->rate)
                         break;
                 else
                         head = &opp->node;
         }
 
+        /* Duplicate OPPs ? */
+        if (new_opp->rate == opp->rate) {
+                int ret = opp->available && new_opp->u_volt == opp->u_volt ?
+                        0 : -EEXIST;
+
+                dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
+                         __func__, opp->rate, opp->u_volt, opp->available,
+                         new_opp->rate, new_opp->u_volt, new_opp->available);
+                mutex_unlock(&dev_opp_list_lock);
+                kfree(new_opp);
+                return ret;
+        }
+
         list_add_rcu(&new_opp->node, head);
         mutex_unlock(&dev_opp_list_lock);
 
@@ -596,96 +618,6 @@ int dev_pm_opp_disable(struct device *dev, unsigned long freq)
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
 
-#ifdef CONFIG_CPU_FREQ
-/**
- * dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
- * @dev:        device for which we do this operation
- * @table:      Cpufreq table returned back to caller
- *
- * Generate a cpufreq table for a provided device- this assumes that the
- * opp list is already initialized and ready for usage.
- *
- * This function allocates required memory for the cpufreq table. It is
- * expected that the caller does the required maintenance such as freeing
- * the table as required.
- *
- * Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
- * if no memory available for the operation (table is not populated), returns 0
- * if successful and table is populated.
- *
- * WARNING: It is  important for the callers to ensure refreshing their copy of
- * the table if any of the mentioned functions have been invoked in the interim.
- *
- * Locking: The internal device_opp and opp structures are RCU protected.
- * To simplify the logic, we pretend we are updater and hold relevant mutex here
- * Callers should ensure that this function is *NOT* called under RCU protection
- * or in contexts where mutex locking cannot be used.
- */
-int dev_pm_opp_init_cpufreq_table(struct device *dev,
-                            struct cpufreq_frequency_table **table)
-{
-        struct device_opp *dev_opp;
-        struct dev_pm_opp *opp;
-        struct cpufreq_frequency_table *freq_table;
-        int i = 0;
-
-        /* Pretend as if I am an updater */
-        mutex_lock(&dev_opp_list_lock);
-
-        dev_opp = find_device_opp(dev);
-        if (IS_ERR(dev_opp)) {
-                int r = PTR_ERR(dev_opp);
-                mutex_unlock(&dev_opp_list_lock);
-                dev_err(dev, "%s: Device OPP not found (%d)\n", __func__, r);
-                return r;
-        }
-
-        freq_table = kzalloc(sizeof(struct cpufreq_frequency_table) *
-                             (dev_pm_opp_get_opp_count(dev) + 1), GFP_KERNEL);
-        if (!freq_table) {
-                mutex_unlock(&dev_opp_list_lock);
-                dev_warn(dev, "%s: Unable to allocate frequency table\n",
-                        __func__);
-                return -ENOMEM;
-        }
-
-        list_for_each_entry(opp, &dev_opp->opp_list, node) {
-                if (opp->available) {
-                        freq_table[i].driver_data = i;
-                        freq_table[i].frequency = opp->rate / 1000;
-                        i++;
-                }
-        }
-        mutex_unlock(&dev_opp_list_lock);
-
-        freq_table[i].driver_data = i;
-        freq_table[i].frequency = CPUFREQ_TABLE_END;
-
-        *table = &freq_table[0];
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);
-
-/**
- * dev_pm_opp_free_cpufreq_table() - free the cpufreq table
- * @dev:        device for which we do this operation
- * @table:      table to free
- *
- * Free up the table allocated by dev_pm_opp_init_cpufreq_table
- */
-void dev_pm_opp_free_cpufreq_table(struct device *dev,
-                                struct cpufreq_frequency_table **table)
-{
-        if (!table)
-                return;
-
-        kfree(*table);
-        *table = NULL;
-}
-EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);
-#endif          /* CONFIG_CPU_FREQ */
-
 /**
  * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
  * @dev:        device pointer used to lookup device OPPs.
@@ -734,11 +666,9 @@ int of_init_opp_table(struct device *dev)
                 unsigned long freq = be32_to_cpup(val++) * 1000;
                 unsigned long volt = be32_to_cpup(val++);
 
-                if (dev_pm_opp_add(dev, freq, volt)) {
+                if (dev_pm_opp_add(dev, freq, volt))
                         dev_warn(dev, "%s: Failed to add OPP %ld\n",
                                  __func__, freq);
-                        continue;
-                }
                 nr -= 2;
         }
 
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index 2d56f4113ae7..eb1bd2ecad8b 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -318,10 +318,16 @@ int device_init_wakeup(struct device *dev, bool enable)
 {
         int ret = 0;
 
+        if (!dev)
+                return -EINVAL;
+
         if (enable) {
                 device_set_wakeup_capable(dev, true);
                 ret = device_wakeup_enable(dev);
         } else {
+                if (dev->power.can_wakeup)
+                        device_wakeup_disable(dev);
+
                 device_set_wakeup_capable(dev, false);
         }
 
diff --git a/drivers/base/regmap/regcache-rbtree.c b/drivers/base/regmap/regcache-rbtree.c
index 930cad4e5df8..6a7e4fa12854 100644
--- a/drivers/base/regmap/regcache-rbtree.c
+++ b/drivers/base/regmap/regcache-rbtree.c
@@ -23,16 +23,16 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
 static int regcache_rbtree_exit(struct regmap *map);
 
 struct regcache_rbtree_node {
-        /* the actual rbtree node holding this block */
-        struct rb_node node;
-        /* base register handled by this block */
-        unsigned int base_reg;
         /* block of adjacent registers */
         void *block;
         /* Which registers are present */
         long *cache_present;
+        /* base register handled by this block */
+        unsigned int base_reg;
         /* number of registers available in the block */
         unsigned int blklen;
+        /* the actual rbtree node holding this block */
+        struct rb_node node;
 } __attribute__ ((packed));
 
 struct regcache_rbtree_ctx {
diff --git a/drivers/base/regmap/regmap-i2c.c b/drivers/base/regmap/regmap-i2c.c
index ebd189529760..ca193d1ef47c 100644
--- a/drivers/base/regmap/regmap-i2c.c
+++ b/drivers/base/regmap/regmap-i2c.c
@@ -14,6 +14,79 @@
 #include <linux/i2c.h>
 #include <linux/module.h>
 
+
+static int regmap_smbus_byte_reg_read(void *context, unsigned int reg,
+                                      unsigned int *val)
+{
+        struct device *dev = context;
+        struct i2c_client *i2c = to_i2c_client(dev);
+        int ret;
+
+        if (reg > 0xff)
+                return -EINVAL;
+
+        ret = i2c_smbus_read_byte_data(i2c, reg);
+        if (ret < 0)
+                return ret;
+
+        *val = ret;
+
+        return 0;
+}
+
+static int regmap_smbus_byte_reg_write(void *context, unsigned int reg,
+                                       unsigned int val)
+{
+        struct device *dev = context;
+        struct i2c_client *i2c = to_i2c_client(dev);
+
+        if (val > 0xff || reg > 0xff)
+                return -EINVAL;
+
+        return i2c_smbus_write_byte_data(i2c, reg, val);
+}
+
+static struct regmap_bus regmap_smbus_byte = {
+        .reg_write = regmap_smbus_byte_reg_write,
+        .reg_read = regmap_smbus_byte_reg_read,
+};
+
+static int regmap_smbus_word_reg_read(void *context, unsigned int reg,
+                                      unsigned int *val)
+{
+        struct device *dev = context;
+        struct i2c_client *i2c = to_i2c_client(dev);
+        int ret;
+
+        if (reg > 0xff)
+                return -EINVAL;
+
+        ret = i2c_smbus_read_word_data(i2c, reg);
+        if (ret < 0)
+                return ret;
+
+        *val = ret;
+
+        return 0;
+}
+
+static int regmap_smbus_word_reg_write(void *context, unsigned int reg,
+                                       unsigned int val)
+{
+        struct device *dev = context;
+        struct i2c_client *i2c = to_i2c_client(dev);
+
+        if (val > 0xffff || reg > 0xff)
+                return -EINVAL;
+
+        return i2c_smbus_write_word_data(i2c, reg, val);
+}
+
+static struct regmap_bus regmap_smbus_word = {
+        .reg_write = regmap_smbus_word_reg_write,
+        .reg_read = regmap_smbus_word_reg_read,
+};
+
 static int regmap_i2c_write(void *context, const void *data, size_t count)
 {
         struct device *dev = context;
@@ -97,6 +170,23 @@ static struct regmap_bus regmap_i2c = {
         .read = regmap_i2c_read,
 };
 
+static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c,
+                                        const struct regmap_config *config)
+{
+        if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C))
+                return &regmap_i2c;
+        else if (config->val_bits == 16 && config->reg_bits == 8 &&
+                 i2c_check_functionality(i2c->adapter,
+                                         I2C_FUNC_SMBUS_WORD_DATA))
+                return &regmap_smbus_word;
+        else if (config->val_bits == 8 && config->reg_bits == 8 &&
+                 i2c_check_functionality(i2c->adapter,
+                                         I2C_FUNC_SMBUS_BYTE_DATA))
+                return &regmap_smbus_byte;
+
+        return ERR_PTR(-ENOTSUPP);
+}
+
 /**
  * regmap_init_i2c(): Initialise register map
  *
@@ -109,7 +199,12 @@ static struct regmap_bus regmap_i2c = {
 struct regmap *regmap_init_i2c(struct i2c_client *i2c,
                                const struct regmap_config *config)
 {
-        return regmap_init(&i2c->dev, &regmap_i2c, &i2c->dev, config);
+        const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
+
+        if (IS_ERR(bus))
+                return ERR_CAST(bus);
+
+        return regmap_init(&i2c->dev, bus, &i2c->dev, config);
 }
 EXPORT_SYMBOL_GPL(regmap_init_i2c);
 
@@ -126,7 +221,12 @@ EXPORT_SYMBOL_GPL(regmap_init_i2c);
 struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
                                     const struct regmap_config *config)
 {
-        return devm_regmap_init(&i2c->dev, &regmap_i2c, &i2c->dev, config);
+        const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
+
+        if (IS_ERR(bus))
+                return ERR_CAST(bus);
+
+        return devm_regmap_init(&i2c->dev, bus, &i2c->dev, config);
 }
 EXPORT_SYMBOL_GPL(devm_regmap_init_i2c);
 
diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index edf88f20cbce..6299a50a5960 100644
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -10,13 +10,13 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/export.h>
 #include <linux/device.h>
-#include <linux/regmap.h>
-#include <linux/irq.h>
+#include <linux/export.h>
 #include <linux/interrupt.h>
+#include <linux/irq.h>
 #include <linux/irqdomain.h>
 #include <linux/pm_runtime.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 
 #include "internal.h"
@@ -347,6 +347,9 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
         int ret = -ENOMEM;
         u32 reg;
 
+        if (chip->num_regs <= 0)
+                return -EINVAL;
+
         for (i = 0; i < chip->num_irqs; i++) {
                 if (chip->irqs[i].reg_offset % map->reg_stride)
                         return -EINVAL;
diff --git a/drivers/base/regmap/regmap-mmio.c b/drivers/base/regmap/regmap-mmio.c
index 1e03e7f8bacb..04a329a377e9 100644
--- a/drivers/base/regmap/regmap-mmio.c
+++ b/drivers/base/regmap/regmap-mmio.c
@@ -61,9 +61,28 @@ static int regmap_mmio_regbits_check(size_t reg_bits)
         }
 }
 
-static inline void regmap_mmio_count_check(size_t count)
+static inline void regmap_mmio_count_check(size_t count, u32 offset)
 {
-        BUG_ON(count % 2 != 0);
+        BUG_ON(count <= offset);
+}
+
+static inline unsigned int
+regmap_mmio_get_offset(const void *reg, size_t reg_size)
+{
+        switch (reg_size) {
+        case 1:
+                return *(u8 *)reg;
+        case 2:
+                return *(u16 *)reg;
+        case 4:
+                return *(u32 *)reg;
+#ifdef CONFIG_64BIT
+        case 8:
+                return *(u64 *)reg;
+#endif
+        default:
+                BUG();
+        }
 }
 
 static int regmap_mmio_gather_write(void *context,
@@ -71,7 +90,7 @@ static int regmap_mmio_gather_write(void *context,
                                     const void *val, size_t val_size)
 {
         struct regmap_mmio_context *ctx = context;
-        u32 offset;
+        unsigned int offset;
         int ret;
 
         regmap_mmio_regsize_check(reg_size);
@@ -82,7 +101,7 @@ static int regmap_mmio_gather_write(void *context,
                         return ret;
         }
 
-        offset = *(u32 *)reg;
+        offset = regmap_mmio_get_offset(reg, reg_size);
 
         while (val_size) {
                 switch (ctx->val_bytes) {
@@ -118,9 +137,9 @@ static int regmap_mmio_gather_write(void *context,
 static int regmap_mmio_write(void *context, const void *data, size_t count)
 {
         struct regmap_mmio_context *ctx = context;
-        u32 offset = ctx->reg_bytes + ctx->pad_bytes;
+        unsigned int offset = ctx->reg_bytes + ctx->pad_bytes;
 
-        regmap_mmio_count_check(count);
+        regmap_mmio_count_check(count, offset);
 
         return regmap_mmio_gather_write(context, data, ctx->reg_bytes,
                                         data + offset, count - offset);
@@ -131,7 +150,7 @@ static int regmap_mmio_read(void *context,
                             void *val, size_t val_size)
 {
         struct regmap_mmio_context *ctx = context;
-        u32 offset;
+        unsigned int offset;
         int ret;
 
         regmap_mmio_regsize_check(reg_size);
@@ -142,7 +161,7 @@ static int regmap_mmio_read(void *context,
                         return ret;
         }
 
-        offset = *(u32 *)reg;
+        offset = regmap_mmio_get_offset(reg, reg_size);
 
         while (val_size) {
                 switch (ctx->val_bytes) {
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index 63e30ef096e2..74d8c0672cf6 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -35,10 +35,14 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
                                unsigned int mask, unsigned int val,
                                bool *change);
 
+static int _regmap_bus_reg_read(void *context, unsigned int reg,
+                                unsigned int *val);
 static int _regmap_bus_read(void *context, unsigned int reg,
                             unsigned int *val);
 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
                                        unsigned int val);
+static int _regmap_bus_reg_write(void *context, unsigned int reg,
+                                 unsigned int val);
 static int _regmap_bus_raw_write(void *context, unsigned int reg,
                                  unsigned int val);
 
@@ -192,6 +196,13 @@ static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
         b[0] = cpu_to_be16(val << shift);
 }
 
+static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
+{
+        __le16 *b = buf;
+
+        b[0] = cpu_to_le16(val << shift);
+}
+
 static void regmap_format_16_native(void *buf, unsigned int val,
                                     unsigned int shift)
 {
@@ -216,6 +227,13 @@ static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
         b[0] = cpu_to_be32(val << shift);
 }
 
+static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
+{
+        __le32 *b = buf;
+
+        b[0] = cpu_to_le32(val << shift);
+}
+
 static void regmap_format_32_native(void *buf, unsigned int val,
                                     unsigned int shift)
 {
@@ -240,6 +258,13 @@ static unsigned int regmap_parse_16_be(const void *buf)
         return be16_to_cpu(b[0]);
 }
 
+static unsigned int regmap_parse_16_le(const void *buf)
+{
+        const __le16 *b = buf;
+
+        return le16_to_cpu(b[0]);
+}
+
 static void regmap_parse_16_be_inplace(void *buf)
 {
         __be16 *b = buf;
@@ -247,6 +272,13 @@ static void regmap_parse_16_be_inplace(void *buf)
         b[0] = be16_to_cpu(b[0]);
 }
 
+static void regmap_parse_16_le_inplace(void *buf)
+{
+        __le16 *b = buf;
+
+        b[0] = le16_to_cpu(b[0]);
+}
+
 static unsigned int regmap_parse_16_native(const void *buf)
 {
         return *(u16 *)buf;
@@ -269,6 +301,13 @@ static unsigned int regmap_parse_32_be(const void *buf)
         return be32_to_cpu(b[0]);
 }
 
+static unsigned int regmap_parse_32_le(const void *buf)
+{
+        const __le32 *b = buf;
+
+        return le32_to_cpu(b[0]);
+}
+
 static void regmap_parse_32_be_inplace(void *buf)
 {
         __be32 *b = buf;
@@ -276,6 +315,13 @@ static void regmap_parse_32_be_inplace(void *buf)
         b[0] = be32_to_cpu(b[0]);
 }
 
+static void regmap_parse_32_le_inplace(void *buf)
+{
+        __le32 *b = buf;
+
+        b[0] = le32_to_cpu(b[0]);
+}
+
 static unsigned int regmap_parse_32_native(const void *buf)
 {
         return *(u32 *)buf;
@@ -495,6 +541,12 @@ struct regmap *regmap_init(struct device *dev,
 
                 map->defer_caching = false;
                 goto skip_format_initialization;
+        } else if (!bus->read || !bus->write) {
+                map->reg_read = _regmap_bus_reg_read;
+                map->reg_write = _regmap_bus_reg_write;
+
+                map->defer_caching = false;
+                goto skip_format_initialization;
         } else {
                 map->reg_read  = _regmap_bus_read;
         }
@@ -608,6 +660,11 @@ struct regmap *regmap_init(struct device *dev,
                         map->format.parse_val = regmap_parse_16_be;
                         map->format.parse_inplace = regmap_parse_16_be_inplace;
                         break;
+                case REGMAP_ENDIAN_LITTLE:
+                        map->format.format_val = regmap_format_16_le;
+                        map->format.parse_val = regmap_parse_16_le;
+                        map->format.parse_inplace = regmap_parse_16_le_inplace;
+                        break;
                 case REGMAP_ENDIAN_NATIVE:
                         map->format.format_val = regmap_format_16_native;
                         map->format.parse_val = regmap_parse_16_native;
@@ -629,6 +686,11 @@ struct regmap *regmap_init(struct device *dev,
                         map->format.parse_val = regmap_parse_32_be;
                         map->format.parse_inplace = regmap_parse_32_be_inplace;
                         break;
+                case REGMAP_ENDIAN_LITTLE:
+                        map->format.format_val = regmap_format_32_le;
+                        map->format.parse_val = regmap_parse_32_le;
+                        map->format.parse_inplace = regmap_parse_32_le_inplace;
+                        break;
                 case REGMAP_ENDIAN_NATIVE:
                         map->format.format_val = regmap_format_32_native;
                         map->format.parse_val = regmap_parse_32_native;
@@ -1284,6 +1346,14 @@ static int _regmap_bus_formatted_write(void *context, unsigned int reg,
         return ret;
 }
 
+static int _regmap_bus_reg_write(void *context, unsigned int reg,
+                                 unsigned int val)
+{
+        struct regmap *map = context;
+
+        return map->bus->reg_write(map->bus_context, reg, val);
+}
+
 static int _regmap_bus_raw_write(void *context, unsigned int reg,
                                  unsigned int val)
 {
@@ -1615,6 +1685,9 @@ static int _regmap_raw_multi_reg_write(struct regmap *map,
         size_t pair_size = reg_bytes + pad_bytes + val_bytes;
         size_t len = pair_size * num_regs;
 
+        if (!len)
+                return -EINVAL;
+
         buf = kzalloc(len, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;
@@ -1662,7 +1735,7 @@ static int _regmap_range_multi_paged_reg_write(struct regmap *map,
         int ret;
         int i, n;
         struct reg_default *base;
-        unsigned int this_page;
+        unsigned int this_page = 0;
         /*
          * the set of registers are not neccessarily in order, but
          * since the order of write must be preserved this algorithm
@@ -1925,6 +1998,14 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
         return ret;
 }
 
+static int _regmap_bus_reg_read(void *context, unsigned int reg,
+                                unsigned int *val)
+{
+        struct regmap *map = context;
+
+        return map->bus->reg_read(map->bus_context, reg, val);
+}
+
 static int _regmap_bus_read(void *context, unsigned int reg,
                             unsigned int *val)
 {
diff --git a/drivers/base/syscore.c b/drivers/base/syscore.c
index e8d11b6630ee..dbb8350ea8dc 100644
--- a/drivers/base/syscore.c
+++ b/drivers/base/syscore.c
@@ -10,6 +10,7 @@
 #include <linux/mutex.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
+#include <trace/events/power.h>
 
 static LIST_HEAD(syscore_ops_list);
 static DEFINE_MUTEX(syscore_ops_lock);
@@ -49,6 +50,7 @@ int syscore_suspend(void)
         struct syscore_ops *ops;
         int ret = 0;
 
+        trace_suspend_resume(TPS("syscore_suspend"), 0, true);
         pr_debug("Checking wakeup interrupts\n");
 
         /* Return error code if there are any wakeup interrupts pending. */
@@ -70,6 +72,7 @@ int syscore_suspend(void)
                                 "Interrupts enabled after %pF\n", ops->suspend);
                 }
 
+        trace_suspend_resume(TPS("syscore_suspend"), 0, false);
         return 0;
 
  err_out:
@@ -92,6 +95,7 @@ void syscore_resume(void)
 {
         struct syscore_ops *ops;
 
+        trace_suspend_resume(TPS("syscore_resume"), 0, true);
         WARN_ONCE(!irqs_disabled(),
                 "Interrupts enabled before system core resume.\n");
 
@@ -103,6 +107,7 @@ void syscore_resume(void)
                         WARN_ONCE(!irqs_disabled(),
                                 "Interrupts enabled after %pF\n", ops->resume);
                 }
+        trace_suspend_resume(TPS("syscore_resume"), 0, false);
 }
 EXPORT_SYMBOL_GPL(syscore_resume);
 #endif /* CONFIG_PM_SLEEP */