regmap: Add generic non-memory mapped register access API

There are many places in the tree where we implement register access for
devices on non-memory mapped buses, especially I2C and SPI. Since hardware
designers seem to have settled on a relatively consistent set of register
interfaces this can be effectively factored out into shared code.  There
are a standard set of formats for marshalling data for exchange with the
device, with the actual I/O mechanisms generally being simple byte
streams.

We create an abstraction for marshaling data into formats which can be
sent on the control interfaces, and create a standard method for
plugging in actual transport underneath that.

This is mostly a refactoring and renaming of the bottom level of the
existing code for sharing register I/O which we have in ASoC. A
subsequent patch in this series converts ASoC to use this.  The main
difference in interface is that reads return values by writing to a
location provided by a pointer rather than in the return value, ensuring
we can use the full range of the type for register data.  We also use
unsigned types rather than ints for the same reason.

As some of the devices can have very large register maps the existing
ASoC code also contains infrastructure for managing register caches.
This cache work will be moved over in a future stage to allow for
separate review, the current patch only deals with the physical I/O.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Wolfram Sang <w.sang@pengutronix.de>
Acked-by: Grant Likely <grant.likely@secretlab.ca>

7 files changed, 546 insertions, 0 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index 187282da9213..b7eaf6393d36 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -5313,6 +5313,13 @@ L:	reiserfs-devel@vger.kernel.org
 S:      Supported
 F:      fs/reiserfs/
 
+REGISTER MAP ABSTRACTION
+M:      Mark Brown <broonie@opensource.wolfsonmicro.com>
+T:      git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap.git
+S:      Supported
+F:      drivers/base/regmap/
+F:      include/linux/regmap.h
+
 RFKILL
 M:      Johannes Berg <johannes@sipsolutions.net>
 L:      linux-wireless@vger.kernel.org
diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index d57e8d0fb823..b605d01f5d45 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -168,4 +168,6 @@ config SYS_HYPERVISOR
         bool
         default n
 
+source "drivers/base/regmap/Kconfig"
+
 endmenu
diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 4c5701c15f53..dd4f9b245fc1 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -18,6 +18,7 @@ ifeq ($(CONFIG_SYSFS),y)
 obj-$(CONFIG_MODULES)   += module.o
 endif
 obj-$(CONFIG_SYS_HYPERVISOR) += hypervisor.o
+obj-$(CONFIG_REGMAP)    += regmap/
 
 ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
 
diff --git a/drivers/base/regmap/Kconfig b/drivers/base/regmap/Kconfig
new file mode 100644
index 000000000000..fc0eb1d484dd
--- /dev/null
+++ b/drivers/base/regmap/Kconfig
@@ -0,0 +1,6 @@
+# Generic register map support.  There are no user servicable options here,
+# this is an API intended to be used by other kernel subsystems.  These
+# subsystems should select the appropriate symbols.
+
+config REGMAP
+        bool
diff --git a/drivers/base/regmap/Makefile b/drivers/base/regmap/Makefile
new file mode 100644
index 000000000000..7532e13e0f00
--- /dev/null
+++ b/drivers/base/regmap/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_REGMAP) += regmap.o
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
new file mode 100644
index 000000000000..cf3565cae93d
--- /dev/null
+++ b/drivers/base/regmap/regmap.c
@@ -0,0 +1,455 @@
+/*
+ * Register map access API
+ *
+ * Copyright 2011 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+
+#include <linux/regmap.h>
+
+struct regmap;
+
+struct regmap_format {
+        size_t buf_size;
+        size_t reg_bytes;
+        size_t val_bytes;
+        void (*format_write)(struct regmap *map,
+                             unsigned int reg, unsigned int val);
+        void (*format_reg)(void *buf, unsigned int reg);
+        void (*format_val)(void *buf, unsigned int val);
+        unsigned int (*parse_val)(void *buf);
+};
+
+struct regmap {
+        struct mutex lock;
+
+        struct device *dev; /* Device we do I/O on */
+        void *work_buf;     /* Scratch buffer used to format I/O */
+        struct regmap_format format;  /* Buffer format */
+        const struct regmap_bus *bus;
+};
+
+static void regmap_format_4_12_write(struct regmap *map,
+                                     unsigned int reg, unsigned int val)
+{
+        __be16 *out = map->work_buf;
+        *out = cpu_to_be16((reg << 12) | val);
+}
+
+static void regmap_format_7_9_write(struct regmap *map,
+                                    unsigned int reg, unsigned int val)
+{
+        __be16 *out = map->work_buf;
+        *out = cpu_to_be16((reg << 9) | val);
+}
+
+static void regmap_format_8(void *buf, unsigned int val)
+{
+        u8 *b = buf;
+
+        b[0] = val;
+}
+
+static void regmap_format_16(void *buf, unsigned int val)
+{
+        __be16 *b = buf;
+
+        b[0] = cpu_to_be16(val);
+}
+
+static unsigned int regmap_parse_8(void *buf)
+{
+        u8 *b = buf;
+
+        return b[0];
+}
+
+static unsigned int regmap_parse_16(void *buf)
+{
+        __be16 *b = buf;
+
+        b[0] = be16_to_cpu(b[0]);
+
+        return b[0];
+}
+
+/**
+ * regmap_init(): Initialise register map
+ *
+ * @dev: Device that will be interacted with
+ * @bus: Bus-specific callbacks to use with device
+ * @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,
+                           const struct regmap_config *config)
+{
+        struct regmap *map;
+        int ret = -EINVAL;
+
+        if (!bus || !config)
+                return NULL;
+
+        map = kzalloc(sizeof(*map), GFP_KERNEL);
+        if (map == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        mutex_init(&map->lock);
+        map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
+        map->format.reg_bytes = config->reg_bits / 8;
+        map->format.val_bytes = config->val_bits / 8;
+        map->dev = dev;
+        map->bus = bus;
+
+        switch (config->reg_bits) {
+        case 4:
+                switch (config->val_bits) {
+                case 12:
+                        map->format.format_write = regmap_format_4_12_write;
+                        break;
+                default:
+                        goto err_map;
+                }
+                break;
+
+        case 7:
+                switch (config->val_bits) {
+                case 9:
+                        map->format.format_write = regmap_format_7_9_write;
+                        break;
+                default: