3 files changed, 87 insertions, 13 deletions

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-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..2615cc180d35 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -192,6 +192,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 +223,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 +254,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 +268,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 +297,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 +311,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;
@@ -608,6 +650,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 +676,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;
@@ -1615,6 +1667,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 +1717,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