Merge tag 'regmap-v4.3' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap

Pull regmap updates from Mark Brown:
 "This has been a busy release for regmap.

  By far the biggest set of changes here are those from Markus Pargmann
  which implement support for block transfers in smbus devices.  This
  required quite a bit of refactoring but leaves us better able to
  handle odd restrictions that controllers may have and with better
  performance on smbus.

  Other new features include:

   - Fix interactions with lockdep for nested regmaps (eg, when a device
     using regmap is connected to a bus where the bus controller has a
     separate regmap).  Lockdep's default class identification is too
     crude to work without help.

   - Support for must write bitfield operations, useful for operations
     which require writing a bit to trigger them from Kuniori Morimoto.

   - Support for delaying during register patch application from Nariman
     Poushin.

   - Support for overriding cache state via the debugfs implementation
     from Richard Fitzgerald"

* tag 'regmap-v4.3' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap: (25 commits)
  regmap: fix a NULL pointer dereference in __regmap_init
  regmap: Support bulk reads for devices without raw formatting
  regmap-i2c: Add smbus i2c block support
  regmap: Add raw_write/read checks for max_raw_write/read sizes
  regmap: regmap max_raw_read/write getter functions
  regmap: Introduce max_raw_read/write for regmap_bulk_read/write
  regmap: Add missing comments about struct regmap_bus
  regmap: No multi_write support if bus->write does not exist
  regmap: Split use_single_rw internally into use_single_read/write
  regmap: Fix regmap_bulk_write for bus writes
  regmap: regmap_raw_read return error on !bus->read
  regulator: core: Print at debug level on debugfs creation failure
  regmap: Fix regmap_can_raw_write check
  regmap: fix typos in regmap.c
  regmap: Fix integertypes for register address and value
  regmap: Move documentation to regmap.h
  regmap: Use different lockdep class for each regmap init call
  thermal: sti: Add parentheses around bridge->ops->regmap_init call
  mfd: vexpress: Add parentheses around bridge->ops->regmap_init call
  regmap: debugfs: Fix misuse of IS_ENABLED
  ...

16 files changed, 808 insertions, 303 deletions

diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index 873ddf91c9d3..cc557886ab23 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -139,11 +139,17 @@ struct regmap {
         struct reg_sequence *patch;
         int patch_regs;
 
-        /* if set, converts bulk rw to single rw */
-        bool use_single_rw;
+        /* if set, converts bulk read to single read */
+        bool use_single_read;
+        /* if set, converts bulk read to single read */
+        bool use_single_write;
         /* if set, the device supports multi write mode */
         bool can_multi_write;
 
+        /* if set, raw reads/writes are limited to this size */
+        size_t max_raw_read;
+        size_t max_raw_write;
+
         struct rb_root range_tree;
         void *selector_work_buf;        /* Scratch buffer used for selector */
 };
diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.c
index b9862d741a56..6f8a13ec32a4 100644
--- a/drivers/base/regmap/regcache.c
+++ b/drivers/base/regmap/regcache.c
@@ -729,7 +729,7 @@ int regcache_sync_block(struct regmap *map, void *block,
                         unsigned int block_base, unsigned int start,
                         unsigned int end)
 {
-        if (regmap_can_raw_write(map) && !map->use_single_rw)
+        if (regmap_can_raw_write(map) && !map->use_single_write)
                 return regcache_sync_block_raw(map, block, cache_present,
                                                block_base, start, end);
         else
diff --git a/drivers/base/regmap/regmap-ac97.c b/drivers/base/regmap/regmap-ac97.c
index 8d304e2a943d..c03ebfd4c731 100644
--- a/drivers/base/regmap/regmap-ac97.c
+++ b/drivers/base/regmap/regmap-ac97.c
@@ -78,37 +78,24 @@ static const struct regmap_bus ac97_regmap_bus = {
         .reg_read = regmap_ac97_reg_read,
 };
 
-/**
- * regmap_init_ac97(): Initialise AC'97 register map
- *
- * @ac97: Device that will be interacted with
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer to
- * a struct regmap.
- */
-struct regmap *regmap_init_ac97(struct snd_ac97 *ac97,
-                                const struct regmap_config *config)
+struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
+                                  const struct regmap_config *config,
+                                  struct lock_class_key *lock_key,
+                                  const char *lock_name)
 {
-        return regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config);
+        return __regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config,
+                             lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(regmap_init_ac97);
+EXPORT_SYMBOL_GPL(__regmap_init_ac97);
 
-/**
- * devm_regmap_init_ac97(): Initialise AC'97 register map
- *
- * @ac97: Device that will be interacted with
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer
- * to a struct regmap.  The regmap will be automatically freed by the
- * device management code.
- */
-struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97,
-                                     const struct regmap_config *config)
+struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
+                                       const struct regmap_config *config,
+                                       struct lock_class_key *lock_key,
+                                       const char *lock_name)
 {
-        return devm_regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config);
+        return __devm_regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config,
+                                  lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(devm_regmap_init_ac97);
+EXPORT_SYMBOL_GPL(__devm_regmap_init_ac97);
 
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/base/regmap/regmap-debugfs.c b/drivers/base/regmap/regmap-debugfs.c
index 5799a0b9e6cc..f42f2bac6466 100644
--- a/drivers/base/regmap/regmap-debugfs.c
+++ b/drivers/base/regmap/regmap-debugfs.c
@@ -469,6 +469,87 @@ static const struct file_operations regmap_access_fops = {
         .llseek = default_llseek,
 };
 
+static ssize_t regmap_cache_only_write_file(struct file *file,
+                                            const char __user *user_buf,
+                                            size_t count, loff_t *ppos)
+{
+        struct regmap *map = container_of(file->private_data,
+                                          struct regmap, cache_only);
+        ssize_t result;
+        bool was_enabled, require_sync = false;
+        int err;
+
+        map->lock(map->lock_arg);
+
+        was_enabled = map->cache_only;
+
+        result = debugfs_write_file_bool(file, user_buf, count, ppos);
+        if (result < 0) {
+                map->unlock(map->lock_arg);
+                return result;
+        }
+
+        if (map->cache_only && !was_enabled) {
+                dev_warn(map->dev, "debugfs cache_only=Y forced\n");
+                add_taint(TAINT_USER, LOCKDEP_STILL_OK);
+        } else if (!map->cache_only && was_enabled) {
+                dev_warn(map->dev, "debugfs cache_only=N forced: syncing cache\n");
+                require_sync = true;
+        }
+
+        map->unlock(map->lock_arg);
+
+        if (require_sync) {
+                err = regcache_sync(map);
+                if (err)
+                        dev_err(map->dev, "Failed to sync cache %d\n", err);
+        }
+
+        return result;
+}
+
+static const struct file_operations regmap_cache_only_fops = {
+        .open = simple_open,
+        .read = debugfs_read_file_bool,
+        .write = regmap_cache_only_write_file,
+};
+
+static ssize_t regmap_cache_bypass_write_file(struct file *file,
+                                              const char __user *user_buf,
+                                              size_t count, loff_t *ppos)
+{
+        struct regmap *map = container_of(file->private_data,
+                                          struct regmap, cache_bypass);
+        ssize_t result;
+        bool was_enabled;
+
+        map->lock(map->lock_arg);
+
+        was_enabled = map->cache_bypass;
+
+        result = debugfs_write_file_bool(file, user_buf, count, ppos);
+        if (result < 0)
+                goto out;
+
+        if (map->cache_bypass && !was_enabled) {
+                dev_warn(map->dev, "debugfs cache_bypass=Y forced\n");
+                add_taint(TAINT_USER, LOCKDEP_STILL_OK);
+        } else if (!map->cache_bypass && was_enabled) {
+                dev_warn(map->dev, "debugfs cache_bypass=N forced\n");
+        }
+
+out:
+        map->unlock(map->lock_arg);
+
+        return result;
+}
+
+static const struct file_operations regmap_cache_bypass_fops = {
+        .open = simple_open,
+        .read = debugfs_read_file_bool,
+        .write = regmap_cache_bypass_write_file,
+};
+
 void regmap_debugfs_init(struct regmap *map, const char *name)
 {
         struct rb_node *next;
@@ -518,10 +599,11 @@ void regmap_debugfs_init(struct regmap *map, const char *name)
         if (map->max_register || regmap_readable(map, 0)) {
                 umode_t registers_mode;
 
-                if (IS_ENABLED(REGMAP_ALLOW_WRITE_DEBUGFS))
-                        registers_mode = 0600;
-                else
-                        registers_mode = 0400;
+#if defined(REGMAP_ALLOW_WRITE_DEBUGFS)
+                registers_mode = 0600;
+#else
+                registers_mode = 0400;
+#endif
 
                 debugfs_create_file("registers", registers_mode, map->debugfs,
                                     map, &regmap_map_fops);
@@ -530,12 +612,13 @@ void regmap_debugfs_init(struct regmap *map, const char *name)
         }
 
         if (map->cache_type) {
-                debugfs_create_bool("cache_only", 0400, map->debugfs,
-                                    &map->cache_only);
+                debugfs_create_file("cache_only", 0600, map->debugfs,
+                                    &map->cache_only, &regmap_cache_only_fops);
                 debugfs_create_bool("cache_dirty", 0400, map->debugfs,
                                     &map->cache_dirty);
-                debugfs_create_bool("cache_bypass", 0400, map->debugfs,
-                                    &map->cache_bypass);
+                debugfs_create_file("cache_bypass", 0600, map->debugfs,
+                                    &map->cache_bypass,
+                                    &regmap_cache_bypass_fops);
         }
 
         next = rb_first(&map->range_tree);
diff --git a/drivers/base/regmap/regmap-i2c.c b/drivers/base/regmap/regmap-i2c.c
index 4b76e33110a2..1a8ec3b2b601 100644
--- a/drivers/base/regmap/regmap-i2c.c
+++ b/drivers/base/regmap/regmap-i2c.c
@@ -209,11 +209,60 @@ static struct regmap_bus regmap_i2c = {
         .val_format_endian_default = REGMAP_ENDIAN_BIG,
 };
 
+static int regmap_i2c_smbus_i2c_write(void *context, const void *data,
+                                      size_t count)
+{
+        struct device *dev = context;
+        struct i2c_client *i2c = to_i2c_client(dev);
+
+        if (count < 1)
+                return -EINVAL;
+        if (count >= I2C_SMBUS_BLOCK_MAX)
+                return -E2BIG;
+
+        --count;
+        return i2c_smbus_write_i2c_block_data(i2c, ((u8 *)data)[0], count,
+                                              ((u8 *)data + 1));
+}
+
+static int regmap_i2c_smbus_i2c_read(void *context, const void *reg,
+                                     size_t reg_size, void *val,
+                                     size_t val_size)
+{
+        struct device *dev = context;
+        struct i2c_client *i2c = to_i2c_client(dev);
+        int ret;
+
+        if (reg_size != 1 || val_size < 1)
+                return -EINVAL;
+        if (val_size >= I2C_SMBUS_BLOCK_MAX)
+                return -E2BIG;
+
+        ret = i2c_smbus_read_i2c_block_data(i2c, ((u8 *)reg)[0], val_size, val);
+        if (ret == val_size)
+                return 0;
+        else if (ret < 0)
+                return ret;
+        else
+                return -EIO;
+}
+
+static struct regmap_bus regmap_i2c_smbus_i2c_block = {
+        .write = regmap_i2c_smbus_i2c_write,
+        .read = regmap_i2c_smbus_i2c_read,
+        .max_raw_read = I2C_SMBUS_BLOCK_MAX,
+        .max_raw_write = I2C_SMBUS_BLOCK_MAX,
+};
+
 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->reg_bits == 8 &&
+                 i2c_check_functionality(i2c->adapter,
+                                         I2C_FUNC_SMBUS_I2C_BLOCK))
+                return &regmap_i2c_smbus_i2c_block;
         else if (config->val_bits == 16 && config->reg_bits == 8 &&
                  i2c_check_functionality(i2c->adapter,
                                          I2C_FUNC_SMBUS_WORD_DATA))
@@ -233,47 +282,34 @@ static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c,
         return ERR_PTR(-ENOTSUPP);
 }
 
-/**
- * regmap_init_i2c(): Initialise register map
- *
- * @i2c: Device that will be interacted with
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer to
- * a struct regmap.
- */
-struct regmap *regmap_init_i2c(struct i2c_client *i2c,
-                               const struct regmap_config *config)
+struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name)
 {
         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);
+        return __regmap_init(&i2c->dev, bus, &i2c->dev, config,
+                             lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(regmap_init_i2c);
+EXPORT_SYMBOL_GPL(__regmap_init_i2c);
 
-/**
- * devm_regmap_init_i2c(): Initialise managed register map
- *
- * @i2c: Device that will be interacted with
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer
- * to a struct regmap.  The regmap will be automatically freed by the
- * device management code.
- */
-struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
-                                    const struct regmap_config *config)
+struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
+                                      const struct regmap_config *config,
+                                      struct lock_class_key *lock_key,
+                                      const char *lock_name)
 {
         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);
+        return __devm_regmap_init(&i2c->dev, bus, &i2c->dev, config,
+                                  lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(devm_regmap_init_i2c);
+EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 2597600a5d26..38d1f72d869c 100644
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -209,7 +209,7 @@ static irqreturn_t regmap_irq_thread(int irq, void *d)
          * Read in the statuses, using a single bulk read if possible
          * in order to reduce the I/O overheads.
          */
-        if (!map->use_single_rw && map->reg_stride == 1 &&
+        if (!map->use_single_read && map->reg_stride == 1 &&
             data->irq_reg_stride == 1) {
                 u8 *buf8 = data->status_reg_buf;
                 u16 *buf16 = data->status_reg_buf;
@@ -398,7 +398,7 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
         else
                 d->irq_reg_stride = 1;
 
-        if (!map->use_single_rw && map->reg_stride == 1 &&
+        if (!map->use_single_read && map->reg_stride == 1 &&
             d->irq_reg_stride == 1) {
                 d->status_reg_buf = kmalloc(map->format.val_bytes *
                                             chip->num_regs, GFP_KERNEL);
diff --git a/drivers/base/regmap/regmap-mmio.c b/drivers/base/regmap/regmap-mmio.c
index 04a329a377e9..426a57e41ac7 100644
--- a/drivers/base/regmap/regmap-mmio.c
+++ b/drivers/base/regmap/regmap-mmio.c
@@ -296,20 +296,11 @@ err_free:
         return ERR_PTR(ret);
 }
 
-/**
- * regmap_init_mmio_clk(): Initialise register map with register clock
- *
- * @dev: Device that will be interacted with
- * @clk_id: register clock consumer ID
- * @regs: Pointer to memory-mapped IO region
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer to
- * a struct regmap.
- */
-struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
-                                    void __iomem *regs,
-                                    const struct regmap_config *config)
+struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
+                                      void __iomem *regs,
+                                      const struct regmap_config *config,
+                                      struct lock_class_key *lock_key,
+                                      const char *lock_name)
 {
         struct regmap_mmio_context *ctx;
 
@@ -317,25 +308,17 @@ struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
         if (IS_ERR(ctx))
                 return ERR_CAST(ctx);
 
-        return regmap_init(dev, &regmap_mmio, ctx, config);
+        return __regmap_init(dev, &regmap_mmio, ctx, config,
+                             lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(regmap_init_mmio_clk);
-
-/**
- * devm_regmap_init_mmio_clk(): Initialise managed register map with clock
- *
- * @dev: Device that will be interacted with
- * @clk_id: register clock consumer ID
- * @regs: Pointer to memory-mapped IO region
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer
- * to a struct regmap.  The regmap will be automatically freed by the
- * device management code.
- */
-struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
-                                         void __iomem *regs,
-                                         const struct regmap_config *config)
+EXPORT_SYMBOL_GPL(__regmap_init_mmio_clk);
+
+struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
+                                           const char *clk_id,
+                                           void __iomem *regs,
+                                           const struct regmap_config *config,
+                                           struct lock_class_key *lock_key,
+                                           const char *lock_name)
 {
         struct regmap_mmio_context *ctx;
 
@@ -343,8 +326,9 @@ struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
         if (IS_ERR(ctx))
                 return ERR_CAST(ctx);
 
-        return devm_regmap_init(dev, &regmap_mmio, ctx, config);
+        return __devm_regmap_init(dev, &regmap_mmio, ctx, config,
+                                  lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(devm_regmap_init_mmio_clk);
+EXPORT_SYMBOL_GPL(__devm_regmap_init_mmio_clk);
 
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/base/regmap/regmap-spi.c b/drivers/base/regmap/regmap-spi.c
index 53d1148e80a0..edd9a839d004 100644
--- a/drivers/base/regmap/regmap-spi.c
+++ b/drivers/base/regmap/regmap-spi.c
@@ -113,37 +113,24 @@ static struct regmap_bus regmap_spi = {
         .val_format_endian_default = REGMAP_ENDIAN_BIG,
 };
 
-/**
- * regmap_init_spi(): Initialise register map
- *
- * @spi: Device that will be interacted with
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer to
- * a struct regmap.
- */
-struct regmap *regmap_init_spi(struct spi_device *spi,
-                               const struct regmap_config *config)
+struct regmap *__regmap_init_spi(struct spi_device *spi,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name)
 {
-        return regmap_init(&spi->dev, &regmap_spi, &spi->dev, config);
+        return __regmap_init(&spi->dev, &regmap_spi, &spi->dev, config,
+                             lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(regmap_init_spi);
+EXPORT_SYMBOL_GPL(__regmap_init_spi);
 
-/**
- * devm_regmap_init_spi(): Initialise register map
- *
- * @spi: Device that will be interacted with
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer
- * to a struct regmap.  The map will be automatically freed by the
- * device management code.
- */
-struct regmap *devm_regmap_init_spi(struct spi_device *spi,
-                                    const struct regmap_config *config)
+struct regmap *__devm_regmap_init_spi(struct spi_device *spi,
+                                      const struct regmap_config *config,
+                                      struct lock_class_key *lock_key,
+                                      const char *lock_name)
 {
-        return devm_regmap_init(&spi->dev, &regmap_spi, &spi->dev, config);
+        return __devm_regmap_init(&spi->dev, &regmap_spi, &spi->dev, config,
+                                  lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(devm_regmap_init_spi);
+EXPORT_SYMBOL_GPL(__devm_regmap_init_spi);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap-spmi.c b/drivers/base/regmap/regmap-spmi.c
index d7026dc33388..7e58f6560399 100644
--- a/drivers/base/regmap/regmap-spmi.c
+++ b/drivers/base/regmap/regmap-spmi.c
@@ -91,36 +91,25 @@ static struct regmap_bus regmap_spmi_base = {
         .val_format_endian_default      = REGMAP_ENDIAN_NATIVE,
 };
 
-/**
- * regmap_init_spmi_base(): Create regmap for the Base register space
- * @sdev:       SPMI device that will be interacted with
- * @config:     Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer to
- * a struct regmap.
- */
-struct regmap *regmap_init_spmi_base(struct spmi_device *sdev,
-                                     const struct regmap_config *config)
+struct regmap *__regmap_init_spmi_base(struct spmi_device *sdev,
+                                       const struct regmap_config *config,
+                                       struct lock_class_key *lock_key,
+                                       const char *lock_name)
 {
-        return regmap_init(&sdev->dev, &regmap_spmi_base, sdev, config);
+        return __regmap_init(&sdev->dev, &regmap_spmi_base, sdev, config,
+                             lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(regmap_init_spmi_base);
+EXPORT_SYMBOL_GPL(__regmap_init_spmi_base);
 
-/**
- * devm_regmap_init_spmi_base(): Create managed regmap for Base register space
- * @sdev:       SPMI device that will be interacted with
- * @config:     Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer
- * to a struct regmap.  The regmap will be automatically freed by the
- * device management code.
- */
-struct regmap *devm_regmap_init_spmi_base(struct spmi_device *sdev,
-                                          const struct regmap_config *config)
+struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *sdev,
+                                            const struct regmap_config *config,
+                                            struct lock_class_key *lock_key,
+                                            const char *lock_name)
 {
-        return devm_regmap_init(&sdev->dev, &regmap_spmi_base, sdev, config);
+        return __devm_regmap_init(&sdev->dev, &regmap_spmi_base, sdev, config,
+                                  lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(devm_regmap_init_spmi_base);
+EXPORT_SYMBOL_GPL(__devm_regmap_init_spmi_base);
 
 static int regmap_spmi_ext_read(void *context,
                                 const void *reg, size_t reg_size,
@@ -222,35 +211,24 @@ static struct regmap_bus regmap_spmi_ext = {
         .val_format_endian_default      = REGMAP_ENDIAN_NATIVE,
 };
 
-/**
- * regmap_init_spmi_ext(): Create regmap for Ext register space
- * @sdev:       Device that will be interacted with
- * @config:     Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer to
- * a struct regmap.
- */
-struct regmap *regmap_init_spmi_ext(struct spmi_device *sdev,
-                                    const struct regmap_config *config)
+struct regmap *__regmap_init_spmi_ext(struct spmi_device *sdev,
+                                      const struct regmap_config *config,
+                                      struct lock_class_key *lock_key,
+                                      const char *lock_name)
 {
-        return regmap_init(&sdev->dev, &regmap_spmi_ext, sdev, config);
+        return __regmap_init(&sdev->dev, &regmap_spmi_ext, sdev, config,
+                             lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(regmap_init_spmi_ext);
+EXPORT_SYMBOL_GPL(__regmap_init_spmi_ext);
 
-/**
- * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space
- * @sdev:       SPMI device that will be interacted with
- * @config:     Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer
- * to a struct regmap.  The regmap will be automatically freed by the
- * device management code.
- */
-struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *sdev,
-                                     const struct regmap_config *config)
+struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *sdev,
+                                           const struct regmap_config *config,
+                                           struct lock_class_key *lock_key,
+                                           const char *lock_name)
 {
-        return devm_regmap_init(&sdev->dev, &regmap_spmi_ext, sdev, config);
+        return __devm_regmap_init(&sdev->dev, &regmap_spmi_ext, sdev, config,
+                                  lock_key, lock_name);
 }
-EXPORT_SYMBOL_GPL(devm_regmap_init_spmi_ext);
+EXPORT_SYMBOL_GPL(__devm_regmap_init_spmi_ext);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index 0a849eeaf952..afaf56200674 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -18,6 +18,7 @@
 #include <linux/of.h>
 #include <linux/rbtree.h>
 #include <linux/sched.h>
+#include <linux/delay.h>
 
 #define CREATE_TRACE_POINTS
 #include "trace.h"
@@ -93,6 +94,9 @@ bool regmap_writeable(struct regmap *map, unsigned int reg)
 
 bool regmap_readable(struct regmap *map, unsigned int reg)
 {
+        if (!map->reg_read)
+                return false;
+
         if (map->max_register && reg > map->max_register)
                 return false;
 
@@ -515,22 +519,12 @@ enum regmap_endian regmap_get_val_endian(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(regmap_get_val_endian);
 
-/**
- * regmap_init(): Initialise register map
- *
- * @dev: Device that will be interacted with
- * @bus: Bus-specific callbacks to use with device
- * @bus_context: Data passed to bus-specific callbacks
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer to
- * a struct regmap.  This function should generally not be called
- * directly, it should be called by bus-specific init functions.
- */
-struct regmap *regmap_init(struct device *dev,
-                           const struct regmap_bus *bus,
-                           void *bus_context,
-                           const struct regmap_config *config)
+struct regmap *__regmap_init(struct device *dev,
+                             const struct regmap_bus *bus,
+                             void *bus_context,
+                             const struct regmap_config *config,
+                             struct lock_class_key *lock_key,
+                             const char *lock_name)
 {
         struct regmap *map;
         int ret = -EINVAL;
@@ -556,10 +550,14 @@ struct regmap *regmap_init(struct device *dev,
                         spin_lock_init(&map->spinlock);
                         map->lock = regmap_lock_spinlock;
                         map->unlock = regmap_unlock_spinlock;
+                        lockdep_set_class_and_name(&map->spinlock,
+                                                   lock_key, lock_name);
                 } else {
                         mutex_init(&map->mutex);
                         map->lock = regmap_lock_mutex;
                         map->unlock = regmap_unlock_mutex;
+                        lockdep_set_class_and_name(&map->mutex,
+                                                   lock_key, lock_name);
                 }
                 map->lock_arg = map;
         }
@@ -573,8 +571,13 @@ struct regmap *regmap_init(struct device *dev,
                 map->reg_stride = config->reg_stride;
         else
                 map->reg_stride = 1;
-        map->use_single_rw = config->use_single_rw;
-        map->can_multi_write = config->can_multi_write;
+        map->use_single_read = config->use_single_rw || !bus || !bus->read;
+        map->use_single_write = config->use_single_rw || !bus || !bus->write;
+        map->can_multi_write = config->can_multi_write && bus && bus->write;
+        if (bus) {
+                map->max_raw_read = bus->max_raw_read;
+                map->max_raw_write = bus->max_raw_write;
+        }
         map->dev = dev;
         map->bus = bus;
         map->bus_context = bus_context;
@@ -763,7 +766,7 @@ struct regmap *regmap_init(struct device *dev,
                 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
                     (val_endian != REGMAP_ENDIAN_BIG))
                         goto err_map;
-                map->use_single_rw = true;
+                map->use_single_write = true;
         }
 
         if (!map->format.format_write &&
@@ -899,30 +902,19 @@ err_map:
 err:
         return ERR_PTR(ret);
 }
-EXPORT_SYMBOL_GPL(regmap_init);
+EXPORT_SYMBOL_GPL(__regmap_init);
 
 static void devm_regmap_release(struct device *dev, void *res)
 {
         regmap_exit(*(struct regmap **)res);
 }
 
-/**
- * devm_regmap_init(): Initialise managed register map
- *
- * @dev: Device that will be interacted with
- * @bus: Bus-specific callbacks to use with device
- * @bus_context: Data passed to bus-specific callbacks
- * @config: Configuration for register map
- *
- * The return value will be an ERR_PTR() on error or a valid pointer
- * to a struct regmap.  This function should generally not be called
- * directly, it should be called by bus-specific init functions.  The
- * map will be automatically freed by the device management code.
- */
-struct regmap *devm_regmap_init(struct device *dev,
-                                const struct regmap_bus *bus,
-                                void *bus_context,
-                                const struct regmap_config *config)
+struct regmap *__devm_regmap_init(struct device *dev,
+                                  const struct regmap_bus *bus,
+                                  void *bus_context,
+                                  const struct regmap_config *config,
+                                  struct lock_class_key *lock_key,
+                                  const char *lock_name)
 {
         struct regmap **ptr, *regmap;
 
@@ -930,7 +922,8 @@ struct regmap *devm_regmap_init(struct device *dev,
         if (!ptr)
                 return ERR_PTR(-ENOMEM);
 
-        regmap = regmap_init(dev, bus, bus_context, config);
+        regmap = __regmap_init(dev, bus, bus_context, config,
+                               lock_key, lock_name);
         if (!IS_ERR(regmap)) {
                 *ptr = regmap;
                 devres_add(dev, ptr);
@@ -940,7 +933,7 @@ struct regmap *devm_regmap_init(struct device *dev,
 
         return regmap;
 }
-EXPORT_SYMBOL_GPL(devm_regmap_init);
+EXPORT_SYMBOL_GPL(__devm_regmap_init);
 
 static void regmap_field_init(struct regmap_field *rm_field,
         struct regmap *regmap, struct reg_field reg_field)
@@ -1382,10 +1375,33 @@ int _regmap_raw_write(struct regmap *map, unsigned int reg,
  */
 bool regmap_can_raw_write(struct regmap *map)
 {
-        return map->bus && map->format.format_val && map->format.format_reg;
+        return map->bus && map->bus->write && map->format.format_val &&
+                map->format.format_reg;
 }
 EXPORT_SYMBOL_GPL(regmap_can_raw_write);
 
+/**
+ * regmap_get_raw_read_max - Get the maximum size we can read
+ *
+ * @map: Map to check.
+ */
+size_t regmap_get_raw_read_max(struct regmap *map)
+{
+        return map->max_raw_read;
+}
+EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);
+
+/**
+ * regmap_get_raw_write_max - Get the maximum size we can read
+ *
+ * @map: Map to check.
+ */
+size_t regmap_get_raw_write_max(struct regmap *map)
+{
+        return map->max_raw_write;
+}
+EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
+
 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
                                        unsigned int val)
 {
@@ -1555,6 +1571,8 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
                 return -EINVAL;
         if (val_len % map->format.val_bytes)
                 return -EINVAL;
+        if (map->max_raw_write && map->max_raw_write > val_len)
+                return -E2BIG;
 
         map->lock(map->lock_arg);
 
@@ -1681,6 +1699,7 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
 {
         int ret = 0, i;
         size_t val_bytes = map->format.val_bytes;
+        size_t total_size = val_bytes * val_count;
 
         if (map->bus && !map->format.parse_inplace)
                 return -EINVAL;
@@ -1689,9 +1708,15 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
 
         /*
          * Some devices don't support bulk write, for
-         * them we have a series of single write operations.
+         * them we have a series of single write operations in the first two if
+         * blocks.
+         *
+         * The first if block is used for memory mapped io. It does not allow
+         * val_bytes of 3 for example.
+         * The second one is used for busses which do not have this limitation
+         * and can write arbitrary value lengths.
          */
-        if (!map->bus || map->use_single_rw) {
+        if (!map->bus) {
                 map->lock(map->lock_arg);
                 for (i = 0; i < val_count; i++) {
                         unsigned int ival;
@@ -1723,6 +1748,38 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
                 }
 out:
                 map->unlock(map->lock_arg);
+        } else if (map->use_single_write ||
+                   (map->max_raw_write && map->max_raw_write < total_size)) {
+                int chunk_stride = map->reg_stride;
+                size_t chunk_size = val_bytes;
+                size_t chunk_count = val_count;
+
+                if (!map->use_single_write) {
+                        chunk_size = map->max_raw_write;
+                        if (chunk_size % val_bytes)
+                                chunk_size -= chunk_size % val_bytes;
+                        chunk_count = total_size / chunk_size;
+                        chunk_stride *= chunk_size / val_bytes;
+                }
+
+                map->lock(map->lock_arg);
+                /* Write as many bytes as possible with chunk_size */
+                for (i = 0; i < chunk_count; i++) {
+                        ret = _regmap_raw_write(map,
+                                                reg + (i * chunk_stride),
+                                                val + (i * chunk_size),
+                                                chunk_size);
+                        if (ret)
+                                break;
+                }
+
+                /* Write remaining bytes */
+                if (!ret && chunk_size * i < total_size) {
+                        ret = _regmap_raw_write(map, reg + (i * chunk_stride),
+                                                val + (i * chunk_size),
+                                                total_size - i * chunk_size);
+                }
+                map->unlock(map->lock_arg);
         } else {
                 void *wval;
 
@@ -1752,7 +1809,7 @@ EXPORT_SYMBOL_GPL(regmap_bulk_write);
  *
  * the (register,newvalue) pairs in regs have not been formatted, but
  * they are all in the same page and have been changed to being page
- * relative. The page register has been written if that was neccessary.
+ * relative. The page register has been written if that was necessary.
  */
 static int _regmap_raw_multi_reg_write(struct regmap *map,
                                        const struct reg_sequence *regs,
@@ -1780,8 +1837,8 @@ static int _regmap_raw_multi_reg_write(struct regmap *map,
         u8 = buf;
 
         for (i = 0; i < num_regs; i++) {
-                int reg = regs[i].reg;
-                int val = regs[i].def;
+                unsigned int reg = regs[i].reg;
+                unsigned int val = regs[i].def;
                 trace_regmap_hw_write_start(map, reg, 1);
                 map->format.format_reg(u8, reg, map->reg_shift);
                 u8 += reg_bytes + pad_bytes;
@@ -1819,10 +1876,12 @@ static int _regmap_range_multi_paged_reg_write(struct regmap *map,
         int i, n;
         struct reg_sequence *base;
         unsigned int this_page = 0;
+        unsigned int page_change = 0;
         /*
          * the set of registers are not neccessarily in order, but
          * since the order of write must be preserved this algorithm
-         * chops the set each time the page changes
+         * chops the set each time the page changes. This also applies
+         * if there is a delay required at any point in the sequence.
          */
         base = regs;
         for (i = 0, n = 0; i < num_regs; i++, n++) {
@@ -1838,16 +1897,48 @@ static int _regmap_range_multi_paged_reg_write(struct regmap *map,
                                 this_page = win_page;
                         if (win_page != this_page) {
                                 this_page = win_page;
+                                page_change = 1;
+                        }
+                }
+
+                /* If we have both a page change and a delay make sure to
+                 * write the regs and apply the delay before we change the
+                 * page.
+                 */
+
+                if (page_change || regs[i].delay_us) {
+
+                                /* For situations where the first write requires
+                                 * a delay we need to make sure we don't call
+                                 * raw_multi_reg_write with n=0
+                                 * This can't occur with page breaks as we
+                                 * never write on the first iteration
+                                 */
+                                if (regs[i].delay_us && i == 0)
+                                        n = 1;
+
                                 ret = _regmap_raw_multi_reg_write(map, base, n);
                                 if (ret != 0)
                                         return ret;
+
+                                if (regs[i].delay_us)
+                                        udelay(regs[i].delay_us);
+
                                 base += n;
                                 n = 0;
-                        }
-                        ret = _regmap_select_page(map, &base[n].reg, range, 1);
-                        if (ret != 0)
-                                return ret;
+
+                                if (page_change) {
+                                        ret = _regmap_select_page(map,
+                                                                  &base[n].reg,
+                                                                  range, 1);
+                                        if (ret != 0)
+                                                return ret;
+
+                                        page_change = 0;
+                                }
+
                 }
+
         }
         if (n > 0)
                 return _regmap_raw_multi_reg_write(map, base, n);
@@ -1866,6 +1957,9 @@ static int _regmap_multi_reg_write(struct regmap *map,
                         ret = _regmap_write(map, regs[i].reg, regs[i].def);
                         if (ret != 0)
                                 return ret;
+
+                        if (regs[i].delay_us)
+                                udelay(regs[i].delay_us);
                 }
                 return 0;
         }
@@ -1905,8 +1999,12 @@ static int _regmap_multi_reg_write(struct regmap *map,
         for (i = 0; i < num_regs; i++) {
                 unsigned int reg = regs[i].reg;
                 struct regmap_range_node *range;
+
+                /* Coalesce all the writes between a page break or a delay
+                 * in a sequence
+                 */
                 range = _regmap_range_lookup(map, reg);
-                if (range) {
+                if (range || regs[i].delay_us) {
                         size_t len = sizeof(struct reg_sequence)*num_regs;
                         struct reg_sequence *base = kmemdup(regs, len,
                                                            GFP_KERNEL);
@@ -2062,7 +2160,7 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
 
         /*
          * Some buses or devices flag reads by setting the high bits in the
-         * register addresss; since it's always the high bits for all
+         * register address; since it's always the high bits for all
          * current formats we can do this here rather than in
          * formatting.  This may break if we get interesting formats.
          */
@@ -2109,8 +2207,6 @@ static int _regmap_read(struct regmap *map, unsigned int reg,
         int ret;
         void *context = _regmap_map_get_context(map);
 
-        WARN_ON(!map->reg_read);
-
         if (!map->cache_bypass) {
                 ret = regcache_read(map, reg, val);
                 if (ret == 0)
@@ -2191,11 +2287,22 @@ int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
                 return -EINVAL;
         if (reg % map->reg_stride)
                 return -EINVAL;
+        if (val_count == 0)
+                return -EINVAL;
 
         map->lock(map->lock_arg);
 
         if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
             map->cache_type == REGCACHE_NONE) {
+                if (!map->bus->read) {
+                        ret = -ENOTSUPP;
+                        goto out;
+                }
+                if (map->max_raw_read && map->max_raw_read < val_len) {
+                        ret = -E2BIG;
+                        goto out;
+                }
+
                 /* Physical block read if there's no cache involved */
                 ret = _regmap_raw_read(map, reg, val, val_len);
 
@@ -2304,20 +2411,51 @@ int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
                  * Some devices does not support bulk read, for
                  * them we have a series of single read operations.
                  */
-                if (map->use_single_rw) {
-                        for (i = 0; i < val_count; i++) {
-                                ret = regmap_raw_read(map,
-                                                reg + (i * map->reg_stride),
-                                                val + (i * val_bytes),
-                                                val_bytes);
-                                if (ret != 0)
-                                        return ret;
-                        }
-                } else {
+                size_t total_size = val_bytes * val_count;
+
+                if (!map->use_single_read &&
+                    (!map->max_raw_read || map->max_raw_read > total_size)) {
                         ret = regmap_raw_read(map, reg, val,
                                               val_bytes * val_count);
                         if (ret != 0)
                                 return ret;
+                } else {
+                        /*
+                         * Some devices do not support bulk read or do not
+                         * support large bulk reads, for them we have a series
+                         * of read operations.
+                         */
+                        int chunk_stride = map->reg_stride;
+                        size_t chunk_size = val_bytes;
+                        size_t chunk_count = val_count;
+
+                        if (!map->use_single_read) {
+                                chunk_size = map->max_raw_read;
+                                if (chunk_size % val_bytes)
+                                        chunk_size -= chunk_size % val_bytes;
+                                chunk_count = total_size / chunk_size;
+                                chunk_stride *= chunk_size / val_bytes;
+                        }
+
+                        /* Read bytes that fit into a multiple of chunk_size */
+                        for (i = 0; i < chunk_count; i++) {
+                                ret = regmap_raw_read(map,
+                                                      reg + (i * chunk_stride),
+                                                      val + (i * chunk_size),
+                                                      chunk_size);
+                                if (ret != 0)
+                                        return ret;
+                        }
+
+                        /* Read remaining bytes */
+                        if (chunk_size * i < total_size) {
+                                ret = regmap_raw_read(map,
+                                                      reg + (i * chunk_stride),
+                                                      val + (i * chunk_size),
+                                                      total_size - i * chunk_size);
+                                if (ret != 0)
+                                        return ret;
+                        }
                 }
 
                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
@@ -2329,7 +2467,34 @@ int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
                                           &ival);
                         if (ret != 0)
                                 return ret;
-                        map->format.format_val(val + (i * val_bytes), ival, 0);
+
+                        if (map->format.format_val) {
+                                map->format.format_val(val + (i * val_bytes), ival, 0);
+                        } else {
+                                /* Devices providing read and write
+                                 * operations can use the bulk I/O
+                                 * functions if they define a val_bytes,
+                                 * we assume that the values are native
+                                 * endian.
+                                 */
+                                u32 *u32 = val;
+                                u16 *u16 = val;
+                                u8 *u8 = val;
+
+                                switch (map->format.val_bytes) {
+                                case 4:
+                                        u32[i] = ival;
+                                        break;
+                                case 2:
+                                        u16[i] = ival;
+                                        break;
+                                case 1:
+                                        u8[i] = ival;
+                                        break;
+                                default:
+                                        return -EINVAL;
+                                }
+                        }
                 }
         }
 
diff --git a/drivers/bus/vexpress-config.c b/drivers/bus/vexpress-config.c
index a64763b6b5fd..6575c0fe6a4e 100644
--- a/drivers/bus/vexpress-config.c
+++ b/drivers/bus/vexpress-config.c
@@ -107,7 +107,7 @@ struct regmap *devm_regmap_init_vexpress_config(struct device *dev)
         if (!res)
                 return ERR_PTR(-ENOMEM);
 
-        regmap = bridge->ops->regmap_init(dev, bridge->context);
+        regmap = (bridge->ops->regmap_init)(dev, bridge->context);
         if (IS_ERR(regmap)) {
                 devres_free(res);
                 return regmap;
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index de9f272a0faf..7a85ac9e32c5 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -1262,7 +1262,7 @@ static struct regulator *create_regulator(struct regulator_dev *rdev,
         regulator->debugfs = debugfs_create_dir(regulator->supply_name,
                                                 rdev->debugfs);
         if (!regulator->debugfs) {
-                rdev_warn(rdev, "Failed to create debugfs directory\n");
+                rdev_dbg(rdev, "Failed to create debugfs directory\n");
         } else {
                 debugfs_create_u32("uA_load", 0444, regulator->debugfs,
                                    &regulator->uA_load);
diff --git a/drivers/thermal/st/st_thermal.c b/drivers/thermal/st/st_thermal.c
index 76c515dd802b..88c759d746c3 100644
--- a/drivers/thermal/st/st_thermal.c
+++ b/drivers/thermal/st/st_thermal.c
@@ -214,7 +214,7 @@ int st_thermal_register(struct platform_device *pdev,
 
         sensor->ops = sensor->cdata->ops;
 
-        ret = sensor->ops->regmap_init(sensor);
+        ret = (sensor->ops->regmap_init)(sensor);
         if (ret)
                 return ret;
 
diff --git a/fs/debugfs/file.c b/fs/debugfs/file.c
index 284f9aa0028b..6c55ade071c3 100644
--- a/fs/debugfs/file.c
+++ b/fs/debugfs/file.c
@@ -435,8 +435,8 @@ struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
 }
 EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
 
-static ssize_t read_file_bool(struct file *file, char __user *user_buf,
-                              size_t count, loff_t *ppos)
+ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
+                               size_t count, loff_t *ppos)
 {
         char buf[3];
         u32 *val = file->private_data;
@@ -449,9 +449,10 @@ static ssize_t read_file_bool(struct file *file, char __user *user_buf,
         buf[2] = 0x00;
         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 }
+EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
 
-static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
-                               size_t count, loff_t *ppos)
+ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
+                                size_t count, loff_t *ppos)
 {
         char buf[32];
         size_t buf_size;
@@ -468,10 +469,11 @@ static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
 
         return count;
 }
+EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
 
 static const struct file_operations fops_bool = {
-        .read =         read_file_bool,
-        .write =        write_file_bool,
+        .read =         debugfs_read_file_bool,
+        .write =        debugfs_write_file_bool,
         .open =         simple_open,
         .llseek =       default_llseek,
 };
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index 420311bcee38..9beb636b97eb 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -116,6 +116,12 @@ struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
 
 bool debugfs_initialized(void);
 
+ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
+                               size_t count, loff_t *ppos);
+
+ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
+                                size_t count, loff_t *ppos);
+
 #else
 
 #include <linux/err.h>
@@ -282,6 +288,20 @@ static inline struct dentry *debugfs_create_devm_seqfile(struct device *dev,
         return ERR_PTR(-ENODEV);
 }
 
+static inline ssize_t debugfs_read_file_bool(struct file *file,
+                                             char __user *user_buf,
+                                             size_t count, loff_t *ppos)
+{
+        return -ENODEV;
+}
+
+static inline ssize_t debugfs_write_file_bool(struct file *file,
+                                              const char __user *user_buf,
+                                              size_t count, loff_t *ppos)
+{
+        return -ENODEV;
+}
+
 #endif
 
 #endif
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 4a6759098769..8fc0bfd8edc4 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -17,6 +17,7 @@
 #include <linux/rbtree.h>
 #include <linux/err.h>
 #include <linux/bug.h>
+#include <linux/lockdep.h>
 
 struct module;
 struct device;
@@ -51,14 +52,17 @@ struct reg_default {
 };
 
 /**
- * Register/value pairs for sequences of writes
+ * Register/value pairs for sequences of writes with an optional delay in
+ * microseconds to be applied after each write.
  *
  * @reg: Register address.
  * @def: Register value.
+ * @delay_us: Delay to be applied after the register write in microseconds
  */
 struct reg_sequence {
         unsigned int reg;
         unsigned int def;
+        unsigned int delay_us;
 };
 
 #ifdef CONFIG_REGMAP
@@ -307,8 +311,12 @@ typedef void (*regmap_hw_free_context)(void *context);
  *                if not implemented  on a given device.
  * @async_write: Write operation which completes asynchronously, optional and
  *               must serialise with respect to non-async I/O.
+ * @reg_write: Write a single register value to the given register address. This
+ *             write operation has to complete when returning from the function.
  * @read: Read operation.  Data is returned in the buffer used to transmit
  *         data.
+ * @reg_read: Read a single register value from a given register address.
+ * @free_context: Free context.
  * @async_alloc: Allocate a regmap_async() structure.
  * @read_flag_mask: Mask to be set in the top byte of the register when doing
  *                  a read.
@@ -318,7 +326,8 @@ typedef void (*regmap_hw_free_context)(void *context);
  * @val_format_endian_default: Default endianness for formatted register
  *     values. Used when the regmap_config specifies DEFAULT. If this is
  *     DEFAULT, BIG is assumed.
- * @async_size: Size of struct used for async work.
+ * @max_raw_read: Max raw read size that can be used on the bus.
+ * @max_raw_write: Max raw write size that can be used on the bus.
  */
 struct regmap_bus {
         bool fast_io;
@@ -333,47 +342,186 @@ struct regmap_bus {
         u8 read_flag_mask;
         enum regmap_endian reg_format_endian_default;
         enum regmap_endian val_format_endian_default;
+        size_t max_raw_read;
+        size_t max_raw_write;
 };
 
-struct regmap *regmap_init(struct device *dev,
-                           const struct regmap_bus *bus,
-                           void *bus_context,
-                           const struct regmap_config *config);
+/*
+ * __regmap_init functions.
+ *
+ * These functions take a lock key and name parameter, and should not be called
+ * directly. Instead, use the regmap_init macros that generate a key and name
+ * for each call.
+ */
+struct regmap *__regmap_init(struct device *dev,
+                             const struct regmap_bus *bus,
+                             void *bus_context,
+                             const struct regmap_config *config,
+                             struct lock_class_key *lock_key,
+                             const char *lock_name);
+struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
+struct regmap *__regmap_init_spi(struct spi_device *dev,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
+struct regmap *__regmap_init_spmi_base(struct spmi_device *dev,
+                                       const struct regmap_config *config,
+                                       struct lock_class_key *lock_key,
+                                       const char *lock_name);
+struct regmap *__regmap_init_spmi_ext(struct spmi_device *dev,
+                                      const struct regmap_config *config,
+                                      struct lock_class_key *lock_key,
+                                      const char *lock_name);
+struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
+                                      void __iomem *regs,
+                                      const struct regmap_config *config,
+                                      struct lock_class_key *lock_key,
+                                      const char *lock_name);
+struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
+                                  const struct regmap_config *config,
+                                  struct lock_class_key *lock_key,
+                                  const char *lock_name);
+
+struct regmap *__devm_regmap_init(struct device *dev,
+                                  const struct regmap_bus *bus,
+                                  void *bus_context,
+                                  const struct regmap_config *config,
+                                  struct lock_class_key *lock_key,
+                                  const char *lock_name);
+struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
+                                      const struct regmap_config *config,
+                                      struct lock_class_key *lock_key,
+                                      const char *lock_name);
+struct regmap *__devm_regmap_init_spi(struct spi_device *dev,
+                                      const struct regmap_config *config,
+                                      struct lock_class_key *lock_key,
+                                      const char *lock_name);
+struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *dev,
+                                            const struct regmap_config *config,
+                                            struct lock_class_key *lock_key,
+                                            const char *lock_name);
+struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *dev,
+                                           const struct regmap_config *config,
+                                           struct lock_class_key *lock_key,
+                                           const char *lock_name);
+struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
+                                           const char *clk_id,
+                                           void __iomem *regs,
+                                           const struct regmap_config *config,
+                                           struct lock_class_key *lock_key,
+                                           const char *lock_name);
+struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
+                                       const struct regmap_config *config,
+                                       struct lock_class_key *lock_key,
+                                       const char *lock_name);
+
+/*
+ * Wrapper for regmap_init macros to include a unique lockdep key and name
+ * for each call. No-op if CONFIG_LOCKDEP is not set.
+ *
+ * @fn: Real function to call (in the form __[*_]regmap_init[_*])
+ * @name: Config variable name (#config in the calling macro)
+ **/
+#ifdef CONFIG_LOCKDEP
+#define __regmap_lockdep_wrapper(fn, name, ...)                         \
+(                                                                       \
+        ({                                                              \
+                static struct lock_class_key _key;                      \
+                fn(__VA_ARGS__, &_key,                                  \
+                        KBUILD_BASENAME ":"                             \
+                        __stringify(__LINE__) ":"                       \
+                        "(" name ")->lock");                            \
+        })                                                              \
+)
+#else
+#define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL)
+#endif
+
+/**
+ * regmap_init(): Initialise register map
+ *
+ * @dev: Device that will be interacted with
+ * @bus: Bus-specific callbacks to use with device
+ * @bus_context: Data passed to bus-specific callbacks
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.  This function should generally not be called
+ * directly, it should be called by bus-specific init functions.
+ */
+#define regmap_init(dev, bus, bus_context, config)                      \
+        __regmap_lockdep_wrapper(__regmap_init, #config,                \
+                                dev, bus, bus_context, config)
 int regmap_attach_dev(struct device *dev, struct regmap *map,
-                                 const struct regmap_config *config);
-struct regmap *regmap_init_i2c(struct i2c_client *i2c,
-                               const struct regmap_config *config);
-struct regmap *regmap_init_spi(struct spi_device *dev,
-                               const struct regmap_config *config);
-struct regmap *regmap_init_spmi_base(struct spmi_device *dev,
-                                     const struct regmap_config *config);
-struct regmap *regmap_init_spmi_ext(struct spmi_device *dev,
-                                    const struct regmap_config *config);
-struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
-                                    void __iomem *regs,
-                                    const struct regmap_config *config);
-struct regmap *regmap_init_ac97(struct snd_ac97 *ac97,
-                                const struct regmap_config *config);
-
-struct regmap *devm_regmap_init(struct device *dev,
-                                const struct regmap_bus *bus,
-                                void *bus_context,
-                                const struct regmap_config *config);
-struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
-                                    const struct regmap_config *config);
-struct regmap *devm_regmap_init_spi(struct spi_device *dev,
-                                    const struct regmap_config *config);
-struct regmap *devm_regmap_init_spmi_base(struct spmi_device *dev,
-                                          const struct regmap_config *config);
-struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *dev,
-                                         const struct regmap_config *config);
-struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
-                                         void __iomem *regs,
-                                         const struct regmap_config *config);
-struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97,
-                                     const struct regmap_config *config);
+                      const struct regmap_config *config);
 
-bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
+/**
+ * regmap_init_i2c(): Initialise register map
+ *
+ * @i2c: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_i2c(i2c, config)                                    \
+        __regmap_lockdep_wrapper(__regmap_init_i2c, #config,            \
+                                i2c, config)
+
+/**
+ * regmap_init_spi(): Initialise register map
+ *
+ * @spi: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_spi(dev, config)                                    \
+        __regmap_lockdep_wrapper(__regmap_init_spi, #config,            \
+                                dev, config)
+
+/**
+ * regmap_init_spmi_base(): Create regmap for the Base register space
+ * @sdev:       SPMI device that will be interacted with
+ * @config:     Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_spmi_base(dev, config)                              \
+        __regmap_lockdep_wrapper(__regmap_init_spmi_base, #config,      \
+                                dev, config)
+
+/**
+ * regmap_init_spmi_ext(): Create regmap for Ext register space
+ * @sdev:       Device that will be interacted with
+ * @config:     Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_spmi_ext(dev, config)                               \
+        __regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config,       \
+                                dev, config)
+
+/**
+ * regmap_init_mmio_clk(): Initialise register map with register clock
+ *
+ * @dev: Device that will be interacted with
+ * @clk_id: register clock consumer ID
+ * @regs: Pointer to memory-mapped IO region
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_mmio_clk(dev, clk_id, regs, config)                 \
+        __regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config,       \
+                                dev, clk_id, regs, config)
 
 /**
  * regmap_init_mmio(): Initialise register map
@@ -385,12 +533,109 @@ bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
  * The return value will be an ERR_PTR() on error or a valid pointer to
  * a struct regmap.
  */
-static inline struct regmap *regmap_init_mmio(struct device *dev,
-                                        void __iomem *regs,
-                                        const struct regmap_config *config)
-{
-        return regmap_init_mmio_clk(dev, NULL, regs, config);
-}
+#define regmap_init_mmio(dev, regs, config)             \
+        regmap_init_mmio_clk(dev, NULL, regs, config)
+
+/**
+ * regmap_init_ac97(): Initialise AC'97 register map
+ *
+ * @ac97: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_ac97(ac97, config)                                  \
+        __regmap_lockdep_wrapper(__regmap_init_ac97, #config,           \
+                                ac97, config)
+bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
+
+/**
+ * devm_regmap_init(): Initialise managed register map
+ *
+ * @dev: Device that will be interacted with
+ * @bus: Bus-specific callbacks to use with device
+ * @bus_context: Data passed to bus-specific callbacks
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  This function should generally not be called
+ * directly, it should be called by bus-specific init functions.  The
+ * map will be automatically freed by the device management code.
+ */
+#define devm_regmap_init(dev, bus, bus_context, config)                 \
+        __regmap_lockdep_wrapper(__devm_regmap_init, #config,           \
+                                dev, bus, bus_context, config)
+
+/**
+ * devm_regmap_init_i2c(): Initialise managed register map
+ *
+ * @i2c: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_i2c(i2c, config)                               \
+        __regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config,       \
+                                i2c, config)
+
+/**
+ * devm_regmap_init_spi(): Initialise register map
+ *
+ * @spi: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The map will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_spi(dev, config)                               \
+        __regmap_lockdep_wrapper(__devm_regmap_init_spi, #config,       \
+                                dev, config)
+
+/**
+ * devm_regmap_init_spmi_base(): Create managed regmap for Base register space
+ * @sdev:       SPMI device that will be interacted with
+ * @config:     Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_spmi_base(dev, config)                         \
+        __regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config, \
+                                dev, config)
+
+/**
+ * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space
+ * @sdev:       SPMI device that will be interacted with
+ * @config:     Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_spmi_ext(dev, config)                          \
+        __regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config,  \
+                                dev, config)
+
+/**
+ * devm_regmap_init_mmio_clk(): Initialise managed register map with clock
+ *
+ * @dev: Device that will be interacted with
+ * @clk_id: register clock consumer ID
+ * @regs: Pointer to memory-mapped IO region
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_mmio_clk(dev, clk_id, regs, config)            \
+        __regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config,  \
+                                dev, clk_id, regs, config)
 
 /**
  * devm_regmap_init_mmio(): Initialise managed register map
@@ -403,12 +648,22 @@ static inline struct regmap *regmap_init_mmio(struct device *dev,
  * to a struct regmap.  The regmap will be automatically freed by the
  * device management code.
  */
-static inline struct regmap *devm_regmap_init_mmio(struct device *dev,
-                                        void __iomem *regs,
-                                        const struct regmap_config *config)
-{
-        return devm_regmap_init_mmio_clk(dev, NULL, regs, config);
-}
+#define devm_regmap_init_mmio(dev, regs, config)                \
+        devm_regmap_init_mmio_clk(dev, NULL, regs, config)
+
+/**
+ * devm_regmap_init_ac97(): Initialise AC'97 register map
+ *
+ * @ac97: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_ac97(ac97, config)                             \
+        __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config,      \
+                                ac97, config)
 
 void regmap_exit(struct regmap *map);
 int regmap_reinit_cache(struct regmap *map,
@@ -450,6 +705,8 @@ int regmap_get_max_register(struct regmap *map);
 int regmap_get_reg_stride(struct regmap *map);
 int regmap_async_complete(struct regmap *map);
 bool regmap_can_raw_write(struct regmap *map);
+size_t regmap_get_raw_read_max(struct regmap *map);
+size_t regmap_get_raw_write_max(struct regmap *map);
 
 int regcache_sync(struct regmap *map);
 int regcache_sync_region(struct regmap *map, unsigned int min,