diff --git a/[refs] b/[refs]
index 4e28951e2a74..c6fc989666a8 100644
--- a/[refs]
+++ b/[refs]
@@ -1,2 +1,2 @@
 ---
-refs/heads/master: f5d6eba74b8aac7d4bf646c5445807aa6a247e6c
+refs/heads/master: c0eb46766d395da8d62148bda2e59bad5e6ee2f2
diff --git a/trunk/Makefile b/trunk/Makefile
index 71e6ed21dd15..156ac69c961e 100644
--- a/trunk/Makefile
+++ b/trunk/Makefile
@@ -1,7 +1,7 @@
 VERSION = 3
-PATCHLEVEL = 3
+PATCHLEVEL = 2
 SUBLEVEL = 0
-EXTRAVERSION = -rc1
+EXTRAVERSION =
 NAME = Saber-toothed Squirrel
 
 # *DOCUMENTATION*
diff --git a/trunk/drivers/base/regmap/internal.h b/trunk/drivers/base/regmap/internal.h
index e93d7b7d1cf9..1a02b7537c8b 100644
--- a/trunk/drivers/base/regmap/internal.h
+++ b/trunk/drivers/base/regmap/internal.h
@@ -22,7 +22,6 @@ struct regcache_ops;
 struct regmap_format {
 	size_t buf_size;
 	size_t reg_bytes;
-	size_t pad_bytes;
 	size_t val_bytes;
 	void (*format_write)(struct regmap *map,
 			     unsigned int reg, unsigned int val);
@@ -66,16 +65,16 @@ struct regmap {
 	unsigned int num_reg_defaults_raw;
 
 	/* if set, only the cache is modified not the HW */
-	u32 cache_only;
+	unsigned int cache_only:1;
 	/* if set, only the HW is modified not the cache */
-	u32 cache_bypass;
+	unsigned int cache_bypass:1;
 	/* if set, remember to free reg_defaults_raw */
-	bool cache_free;
+	unsigned int cache_free:1;
 
 	struct reg_default *reg_defaults;
 	const void *reg_defaults_raw;
 	void *cache;
-	u32 cache_dirty;
+	bool cache_dirty;
 };
 
 struct regcache_ops {
diff --git a/trunk/drivers/base/regmap/regcache-lzo.c b/trunk/drivers/base/regmap/regcache-lzo.c
index 3025cf920f25..b7d16143edeb 100644
--- a/trunk/drivers/base/regmap/regcache-lzo.c
+++ b/trunk/drivers/base/regmap/regcache-lzo.c
@@ -343,12 +343,6 @@ static int regcache_lzo_sync(struct regmap *map)
 		ret = regcache_read(map, i, &val);
 		if (ret)
 			return ret;
-
-		/* Is this the hardware default?  If so skip. */
-		ret = regcache_lookup_reg(map, i);
-		if (ret > 0 && val == map->reg_defaults[ret].def)
-			continue;
-
 		map->cache_bypass = 1;
 		ret = _regmap_write(map, i, val);
 		map->cache_bypass = 0;
diff --git a/trunk/drivers/base/regmap/regcache-rbtree.c b/trunk/drivers/base/regmap/regcache-rbtree.c
index 861ad2c81dff..32620c4f1683 100644
--- a/trunk/drivers/base/regmap/regcache-rbtree.c
+++ b/trunk/drivers/base/regmap/regcache-rbtree.c
@@ -377,7 +377,7 @@ static int regcache_rbtree_sync(struct regmap *map)
 
 			/* Is this the hardware default?  If so skip. */
 			ret = regcache_lookup_reg(map, i);
-			if (ret >= 0 && val == map->reg_defaults[ret].def)
+			if (ret > 0 && val == map->reg_defaults[ret].def)
 				continue;
 
 			map->cache_bypass = 1;
diff --git a/trunk/drivers/base/regmap/regcache.c b/trunk/drivers/base/regmap/regcache.c
index 2d89ce08f137..1ead66186b7c 100644
--- a/trunk/drivers/base/regmap/regcache.c
+++ b/trunk/drivers/base/regmap/regcache.c
@@ -211,6 +211,7 @@ int regcache_read(struct regmap *map,
 
 	return -EINVAL;
 }
+EXPORT_SYMBOL_GPL(regcache_read);
 
 /**
  * regcache_write: Set the value of a given register in the cache.
@@ -237,6 +238,7 @@ int regcache_write(struct regmap *map,
 
 	return 0;
 }
+EXPORT_SYMBOL_GPL(regcache_write);
 
 /**
  * regcache_sync: Sync the register cache with the hardware.
@@ -313,7 +315,6 @@ void regcache_cache_only(struct regmap *map, bool enable)
 	mutex_lock(&map->lock);
 	WARN_ON(map->cache_bypass && enable);
 	map->cache_only = enable;
-	trace_regmap_cache_only(map->dev, enable);
 	mutex_unlock(&map->lock);
 }
 EXPORT_SYMBOL_GPL(regcache_cache_only);
@@ -351,7 +352,6 @@ void regcache_cache_bypass(struct regmap *map, bool enable)
 	mutex_lock(&map->lock);
 	WARN_ON(map->cache_only && enable);
 	map->cache_bypass = enable;
-	trace_regmap_cache_bypass(map->dev, enable);
 	mutex_unlock(&map->lock);
 }
 EXPORT_SYMBOL_GPL(regcache_cache_bypass);
@@ -374,16 +374,10 @@ bool regcache_set_val(void *base, unsigned int idx,
 		cache[idx] = val;
 		break;
 	}
-	case 4: {
-		u32 *cache = base;
-		if (cache[idx] == val)
-			return true;
-		cache[idx] = val;
-		break;
-	}
 	default:
 		BUG();
 	}
+	/* unreachable */
 	return false;
 }
 
@@ -402,10 +396,6 @@ unsigned int regcache_get_val(const void *base, unsigned int idx,
 		const u16 *cache = base;
 		return cache[idx];
 	}
-	case 4: {
-		const u32 *cache = base;
-		return cache[idx];
-	}
 	default:
 		BUG();
 	}
diff --git a/trunk/drivers/base/regmap/regmap-debugfs.c b/trunk/drivers/base/regmap/regmap-debugfs.c
index 372f81a21201..6f397476e27c 100644
--- a/trunk/drivers/base/regmap/regmap-debugfs.c
+++ b/trunk/drivers/base/regmap/regmap-debugfs.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/slab.h>
+#include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/debugfs.h>
 #include <linux/uaccess.h>
@@ -32,35 +33,6 @@ static int regmap_open_file(struct inode *inode, struct file *file)
 	return 0;
 }
 
-static ssize_t regmap_name_read_file(struct file *file,
-				     char __user *user_buf, size_t count,
-				     loff_t *ppos)
-{
-	struct regmap *map = file->private_data;
-	int ret;
-	char *buf;
-
-	buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
-	if (!buf)
-		return -ENOMEM;
-
-	ret = snprintf(buf, PAGE_SIZE, "%s\n", map->dev->driver->name);
-	if (ret < 0) {
-		kfree(buf);
-		return ret;
-	}
-
-	ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
-	kfree(buf);
-	return ret;
-}
-
-static const struct file_operations regmap_name_fops = {
-	.open = regmap_open_file,
-	.read = regmap_name_read_file,
-	.llseek = default_llseek,
-};
-
 static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf,
 				    size_t count, loff_t *ppos)
 {
@@ -131,51 +103,9 @@ static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf,
 	return ret;
 }
 
-#undef REGMAP_ALLOW_WRITE_DEBUGFS
-#ifdef REGMAP_ALLOW_WRITE_DEBUGFS
-/*
- * This can be dangerous especially when we have clients such as
- * PMICs, therefore don't provide any real compile time configuration option
- * for this feature, people who want to use this will need to modify
- * the source code directly.
- */
-static ssize_t regmap_map_write_file(struct file *file,
-				     const char __user *user_buf,
-				     size_t count, loff_t *ppos)
-{
-	char buf[32];
-	size_t buf_size;
-	char *start = buf;
-	unsigned long reg, value;
-	struct regmap *map = file->private_data;
-
-	buf_size = min(count, (sizeof(buf)-1));
-	if (copy_from_user(buf, user_buf, buf_size))
-		return -EFAULT;
-	buf[buf_size] = 0;
-
-	while (*start == ' ')
-		start++;
-	reg = simple_strtoul(start, &start, 16);
-	while (*start == ' ')
-		start++;
-	if (strict_strtoul(start, 16, &value))
-		return -EINVAL;
-
-	/* Userspace has been fiddling around behind the kernel's back */
-	add_taint(TAINT_USER);
-
-	regmap_write(map, reg, value);
-	return buf_size;
-}
-#else
-#define regmap_map_write_file NULL
-#endif
-
 static const struct file_operations regmap_map_fops = {
 	.open = regmap_open_file,
 	.read = regmap_map_read_file,
-	.write = regmap_map_write_file,
 	.llseek = default_llseek,
 };
 
@@ -256,24 +186,12 @@ void regmap_debugfs_init(struct regmap *map)
 		return;
 	}
 
-	debugfs_create_file("name", 0400, map->debugfs,
-			    map, &regmap_name_fops);
-
 	if (map->max_register) {
 		debugfs_create_file("registers", 0400, map->debugfs,
 				    map, &regmap_map_fops);
 		debugfs_create_file("access", 0400, map->debugfs,
 				    map, &regmap_access_fops);
 	}
-
-	if (map->cache_type) {
-		debugfs_create_bool("cache_only", 0400, map->debugfs,
-				    &map->cache_only);
-		debugfs_create_bool("cache_dirty", 0400, map->debugfs,
-				    &map->cache_dirty);
-		debugfs_create_bool("cache_bypass", 0400, map->debugfs,
-				    &map->cache_bypass);
-	}
 }
 
 void regmap_debugfs_exit(struct regmap *map)
diff --git a/trunk/drivers/base/regmap/regmap-i2c.c b/trunk/drivers/base/regmap/regmap-i2c.c
index 38621ec87c05..9a3a8c564389 100644
--- a/trunk/drivers/base/regmap/regmap-i2c.c
+++ b/trunk/drivers/base/regmap/regmap-i2c.c
@@ -111,4 +111,21 @@ struct regmap *regmap_init_i2c(struct i2c_client *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)
+{
+	return devm_regmap_init(&i2c->dev, &regmap_i2c, config);
+}
+EXPORT_SYMBOL_GPL(devm_regmap_init_i2c);
+
 MODULE_LICENSE("GPL");
diff --git a/trunk/drivers/base/regmap/regmap-spi.c b/trunk/drivers/base/regmap/regmap-spi.c
index 2560658de344..7c0c35a39c33 100644
--- a/trunk/drivers/base/regmap/regmap-spi.c
+++ b/trunk/drivers/base/regmap/regmap-spi.c
@@ -70,4 +70,21 @@ struct regmap *regmap_init_spi(struct spi_device *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)
+{
+	return devm_regmap_init(&spi->dev, &regmap_spi, config);
+}
+EXPORT_SYMBOL_GPL(devm_regmap_init_spi);
+
 MODULE_LICENSE("GPL");
diff --git a/trunk/drivers/base/regmap/regmap.c b/trunk/drivers/base/regmap/regmap.c
index 253882d8392a..839cc82bd176 100644
--- a/trunk/drivers/base/regmap/regmap.c
+++ b/trunk/drivers/base/regmap/regmap.c
@@ -10,9 +10,8 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/device.h>
 #include <linux/slab.h>
-#include <linux/export.h>
+#include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/err.h>
 
@@ -37,9 +36,6 @@ bool regmap_readable(struct regmap *map, unsigned int reg)
 	if (map->max_register && reg > map->max_register)
 		return false;
 
-	if (map->format.format_write)
-		return false;
-
 	if (map->readable_reg)
 		return map->readable_reg(map->dev, reg);
 
@@ -48,7 +44,7 @@ bool regmap_readable(struct regmap *map, unsigned int reg)
 
 bool regmap_volatile(struct regmap *map, unsigned int reg)
 {
-	if (!regmap_readable(map, reg))
+	if (map->max_register && reg > map->max_register)
 		return false;
 
 	if (map->volatile_reg)
@@ -59,7 +55,7 @@ bool regmap_volatile(struct regmap *map, unsigned int reg)
 
 bool regmap_precious(struct regmap *map, unsigned int reg)
 {
-	if (!regmap_readable(map, reg))
+	if (map->max_register && reg > map->max_register)
 		return false;
 
 	if (map->precious_reg)
@@ -80,14 +76,6 @@ static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
 	return true;
 }
 
-static void regmap_format_2_6_write(struct regmap *map,
-				     unsigned int reg, unsigned int val)
-{
-	u8 *out = map->work_buf;
-
-	*out = (reg << 6) | val;
-}
-
 static void regmap_format_4_12_write(struct regmap *map,
 				     unsigned int reg, unsigned int val)
 {
@@ -126,13 +114,6 @@ static void regmap_format_16(void *buf, unsigned int val)
 	b[0] = cpu_to_be16(val);
 }
 
-static void regmap_format_32(void *buf, unsigned int val)
-{
-	__be32 *b = buf;
-
-	b[0] = cpu_to_be32(val);
-}
-
 static unsigned int regmap_parse_8(void *buf)
 {
 	u8 *b = buf;
@@ -149,15 +130,6 @@ static unsigned int regmap_parse_16(void *buf)
 	return b[0];
 }
 
-static unsigned int regmap_parse_32(void *buf)
-{
-	__be32 *b = buf;
-
-	b[0] = be32_to_cpu(b[0]);
-
-	return b[0];
-}
-
 /**
  * regmap_init(): Initialise register map
  *
@@ -187,10 +159,8 @@ struct regmap *regmap_init(struct device *dev,
 
 	mutex_init(&map->lock);
 	map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
-	map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
-	map->format.pad_bytes = config->pad_bits / 8;
-	map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
-	map->format.buf_size += map->format.pad_bytes;
+	map->format.reg_bytes = config->reg_bits / 8;
+	map->format.val_bytes = config->val_bits / 8;
 	map->dev = dev;
 	map->bus = bus;
 	map->max_register = config->max_register;
@@ -208,16 +178,6 @@ struct regmap *regmap_init(struct device *dev,
 	}
 
 	switch (config->reg_bits) {
-	case 2:
-		switch (config->val_bits) {
-		case 6:
-			map->format.format_write = regmap_format_2_6_write;
-			break;
-		default:
-			goto err_map;
-		}
-		break;
-
 	case 4:
 		switch (config->val_bits) {
 		case 12:
@@ -256,10 +216,6 @@ struct regmap *regmap_init(struct device *dev,
 		map->format.format_reg = regmap_format_16;
 		break;
 
-	case 32:
-		map->format.format_reg = regmap_format_32;
-		break;
-
 	default:
 		goto err_map;
 	}
@@ -273,17 +229,13 @@ struct regmap *regmap_init(struct device *dev,
 		map->format.format_val = regmap_format_16;
 		map->format.parse_val = regmap_parse_16;
 		break;
-	case 32:
-		map->format.format_val = regmap_format_32;
-		map->format.parse_val = regmap_parse_32;
-		break;
 	}
 
 	if (!map->format.format_write &&
 	    !(map->format.format_reg && map->format.format_val))
 		goto err_map;
 
-	map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
+	map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
 	if (map->work_buf == NULL) {
 		ret = -ENOMEM;
 		goto err_map;
@@ -306,6 +258,45 @@ struct regmap *regmap_init(struct device *dev,
 }
 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
+ * @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,
+				const struct regmap_config *config)
+{
+	struct regmap **ptr, *regmap;
+
+	ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
+	if (!ptr)
+		return ERR_PTR(-ENOMEM);
+
+	regmap = regmap_init(dev, bus, config);
+	if (!IS_ERR(regmap)) {
+		*ptr = regmap;
+		devres_add(dev, ptr);
+	} else {
+		devres_free(ptr);
+	}
+
+	return regmap;
+}
+EXPORT_SYMBOL_GPL(devm_regmap_init);
+
 /**
  * regmap_reinit_cache(): Reinitialise the current register cache
  *
@@ -324,7 +315,6 @@ int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
 	mutex_lock(&map->lock);
 
 	regcache_exit(map);
-	regmap_debugfs_exit(map);
 
 	map->max_register = config->max_register;
 	map->writeable_reg = config->writeable_reg;
@@ -333,8 +323,6 @@ int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
 	map->precious_reg = config->precious_reg;
 	map->cache_type = config->cache_type;
 
-	regmap_debugfs_init(map);
-
 	ret = regcache_init(map, config);
 
 	mutex_unlock(&map->lock);
@@ -380,28 +368,23 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
 	 * send the work_buf directly, otherwise try to do a gather
 	 * write.
 	 */
-	if (val == (map->work_buf + map->format.pad_bytes +
-		    map->format.reg_bytes))
+	if (val == map->work_buf + map->format.reg_bytes)
 		ret = map->bus->write(map->dev, map->work_buf,
-				      map->format.reg_bytes +
-				      map->format.pad_bytes +
-				      val_len);
+				      map->format.reg_bytes + val_len);
 	else if (map->bus->gather_write)
 		ret = map->bus->gather_write(map->dev, map->work_buf,
-					     map->format.reg_bytes +
-					     map->format.pad_bytes,
+					     map->format.reg_bytes,
 					     val, val_len);
 
 	/* If that didn't work fall back on linearising by hand. */
 	if (ret == -ENOTSUPP) {
-		len = map->format.reg_bytes + map->format.pad_bytes + val_len;
-		buf = kzalloc(len, GFP_KERNEL);
+		len = map->format.reg_bytes + val_len;
+		buf = kmalloc(len, GFP_KERNEL);
 		if (!buf)
 			return -ENOMEM;
 
 		memcpy(buf, map->work_buf, map->format.reg_bytes);
-		memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
-		       val, val_len);
+		memcpy(buf + map->format.reg_bytes, val, val_len);
 		ret = map->bus->write(map->dev, buf, len);
 
 		kfree(buf);
@@ -443,12 +426,10 @@ int _regmap_write(struct regmap *map, unsigned int reg,
 
 		return ret;
 	} else {
-		map->format.format_val(map->work_buf + map->format.reg_bytes
-				       + map->format.pad_bytes, val);
+		map->format.format_val(map->work_buf + map->format.reg_bytes,
+				       val);
 		return _regmap_raw_write(map, reg,
-					 map->work_buf +
-					 map->format.reg_bytes +
-					 map->format.pad_bytes,
+					 map->work_buf + map->format.reg_bytes,
 					 map->format.val_bytes);
 	}
 }
@@ -531,8 +512,7 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
 	trace_regmap_hw_read_start(map->dev, reg,
 				   val_len / map->format.val_bytes);
 
-	ret = map->bus->read(map->dev, map->work_buf,
-			     map->format.reg_bytes + map->format.pad_bytes,
+	ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
 			     val, val_len);
 
 	trace_regmap_hw_read_done(map->dev, reg,
@@ -605,32 +585,16 @@ EXPORT_SYMBOL_GPL(regmap_read);
 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
 		    size_t val_len)
 {
-	size_t val_bytes = map->format.val_bytes;
-	size_t val_count = val_len / val_bytes;
-	unsigned int v;
-	int ret, i;
-
-	mutex_lock(&map->lock);
+	size_t val_count = val_len / map->format.val_bytes;
+	int ret;
 
-	if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
-	    map->cache_type == REGCACHE_NONE) {
-		/* Physical block read if there's no cache involved */
-		ret = _regmap_raw_read(map, reg, val, val_len);
+	WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
+		map->cache_type != REGCACHE_NONE);
 
-	} else {
-		/* Otherwise go word by word for the cache; should be low
-		 * cost as we expect to hit the cache.
-		 */
-		for (i = 0; i < val_count; i++) {
-			ret = _regmap_read(map, reg + i, &v);
-			if (ret != 0)
-				goto out;
+	mutex_lock(&map->lock);
 
-			map->format.format_val(val + (i * val_bytes), v);
-		}
-	}
+	ret = _regmap_raw_read(map, reg, val, val_len);
 
- out:
 	mutex_unlock(&map->lock);
 
 	return ret;
diff --git a/trunk/include/linux/regmap.h b/trunk/include/linux/regmap.h
index 14b8252d8ed0..195db51ec79b 100644
--- a/trunk/include/linux/regmap.h
+++ b/trunk/include/linux/regmap.h
@@ -19,7 +19,6 @@
 struct module;
 struct i2c_client;
 struct spi_device;
-struct regmap;
 
 /* An enum of all the supported cache types */
 enum regcache_type {
@@ -41,13 +40,10 @@ struct reg_default {
 	unsigned int def;
 };
 
-#ifdef CONFIG_REGMAP
-
 /**
  * Configuration for the register map of a device.
  *
  * @reg_bits: Number of bits in a register address, mandatory.
- * @pad_bits: Number of bits of padding between register and value.
  * @val_bits: Number of bits in a register value, mandatory.
  *
  * @writeable_reg: Optional callback returning true if the register
@@ -78,7 +74,6 @@ struct reg_default {
  */
 struct regmap_config {
 	int reg_bits;
-	int pad_bits;
 	int val_bits;
 
 	bool (*writeable_reg)(struct device *dev, unsigned int reg);
@@ -132,6 +127,14 @@ struct regmap *regmap_init_i2c(struct i2c_client *i2c,
 struct regmap *regmap_init_spi(struct spi_device *dev,
 			       const struct regmap_config *config);
 
+struct regmap *devm_regmap_init(struct device *dev,
+				const struct regmap_bus *bus,
+				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);
+
 void regmap_exit(struct regmap *map);
 int regmap_reinit_cache(struct regmap *map,
 			const struct regmap_config *config);
@@ -202,115 +205,4 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
 
-#else
-
-/*
- * These stubs should only ever be called by generic code which has
- * regmap based facilities, if they ever get called at runtime
- * something is going wrong and something probably needs to select
- * REGMAP.
- */
-
-static inline int regmap_write(struct regmap *map, unsigned int reg,
-			       unsigned int val)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
-				   const void *val, size_t val_len)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
-				    const void *val, size_t val_count)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regmap_read(struct regmap *map, unsigned int reg,
-			      unsigned int *val)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
-				  void *val, size_t val_len)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
-				   void *val, size_t val_count)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
-				     unsigned int mask, unsigned int val)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regmap_update_bits_check(struct regmap *map,
-					   unsigned int reg,
-					   unsigned int mask, unsigned int val,
-					   bool *change)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regmap_get_val_bytes(struct regmap *map)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regcache_sync(struct regmap *map)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline int regcache_sync_region(struct regmap *map, unsigned int min,
-				       unsigned int max)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-static inline void regcache_cache_only(struct regmap *map, bool enable)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-}
-
-static inline void regcache_cache_bypass(struct regmap *map, bool enable)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-}
-
-static inline void regcache_mark_dirty(struct regmap *map)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-}
-
-static inline int regmap_register_patch(struct regmap *map,
-					const struct reg_default *regs,
-					int num_regs)
-{
-	WARN_ONCE(1, "regmap API is disabled");
-	return -EINVAL;
-}
-
-#endif
-
 #endif
diff --git a/trunk/include/trace/events/regmap.h b/trunk/include/trace/events/regmap.h
index d69738280ffa..12fbf43524e9 100644
--- a/trunk/include/trace/events/regmap.h
+++ b/trunk/include/trace/events/regmap.h
@@ -139,42 +139,6 @@ TRACE_EVENT(regcache_sync,
 		  __get_str(type), __get_str(status))
 );
 
-DECLARE_EVENT_CLASS(regmap_bool,
-
-	TP_PROTO(struct device *dev, bool flag),
-
-	TP_ARGS(dev, flag),
-
-	TP_STRUCT__entry(
-		__string(	name,		dev_name(dev)	)
-		__field(	int,		flag		)
-	),
-
-	TP_fast_assign(
-		__assign_str(name, dev_name(dev));
-		__entry->flag = flag;
-	),
-
-	TP_printk("%s flag=%d", __get_str(name),
-		  (int)__entry->flag)
-);
-
-DEFINE_EVENT(regmap_bool, regmap_cache_only,
-
-	TP_PROTO(struct device *dev, bool flag),
-
-	TP_ARGS(dev, flag)
-
-);
-
-DEFINE_EVENT(regmap_bool, regmap_cache_bypass,
-
-	TP_PROTO(struct device *dev, bool flag),
-
-	TP_ARGS(dev, flag)
-
-);
-
 #endif /* _TRACE_REGMAP_H */
 
 /* This part must be outside protection */