regmap: Implement dev_get_regmap()

Use devres to implement dev_get_regmap(). This should mean that in almost
all cases devices wishing to take advantage of framework features based on
regmap shouldn't need to explicitly pass the regmap into the framework.
This simplifies device setup a bit.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>

diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index e46c279f828062bd3b243c475e86ec7fdfd13985..c994bc9bc04ffc9d82392bdde4547aa6aed2461d 100644 (file)
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -45,6 +45,7 @@ struct regmap {
        struct regmap_format format;  /* Buffer format */
        const struct regmap_bus *bus;
        void *bus_context;
+       const char *name;
 
 #ifdef CONFIG_DEBUG_FS
        struct dentry *debugfs;

diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index ee4fea351220447a514b6b30731f44d7c5f94b5b..618173e4c2b147c3c6a4b534462065d65a9653a6 100644 (file)
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -178,6 +178,15 @@ static void regmap_unlock_spinlock(struct regmap *map)
        spin_unlock(&map->spinlock);
 }
 
+static void dev_get_regmap_release(struct device *dev, void *res)
+{
+       /*
+        * We don't actually have anything to do here; the goal here
+        * is not to manage the regmap but to provide a simple way to
+        * get the regmap back given a struct device.
+        */
+}
+
 /**
  * regmap_init(): Initialise register map
  *
@@ -195,7 +204,7 @@ struct regmap *regmap_init(struct device *dev,
                           void *bus_context,
                           const struct regmap_config *config)
 {
-       struct regmap *map;
+       struct regmap *map, **m;
        int ret = -EINVAL;
 
        if (!bus || !config)
@@ -230,6 +239,7 @@ struct regmap *regmap_init(struct device *dev,
        map->volatile_reg = config->volatile_reg;
        map->precious_reg = config->precious_reg;
        map->cache_type = config->cache_type;
+       map->name = config->name;
 
        if (config->read_flag_mask || config->write_flag_mask) {
                map->read_flag_mask = config->read_flag_mask;
@@ -326,8 +336,19 @@ struct regmap *regmap_init(struct device *dev,
        if (ret < 0)
                goto err_free_workbuf;
 
+       /* Add a devres resource for dev_get_regmap() */
+       m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
+       if (!m) {
+               ret = -ENOMEM;
+               goto err_cache;
+       }
+       *m = map;
+       devres_add(dev, m);
+
        return map;
 
+err_cache:
+       regcache_exit(map);
 err_free_workbuf:
        kfree(map->work_buf);
 err_map:
@@ -431,6 +452,44 @@ void regmap_exit(struct regmap *map)
 }
 EXPORT_SYMBOL_GPL(regmap_exit);
 
+static int dev_get_regmap_match(struct device *dev, void *res, void *data)
+{
+       struct regmap **r = res;
+       if (!r || !*r) {
+               WARN_ON(!r || !*r);
+               return 0;
+       }
+
+       /* If the user didn't specify a name match any */
+       if (data)
+               return (*r)->name == data;
+       else
+               return 1;
+}
+
+/**
+ * dev_get_regmap(): Obtain the regmap (if any) for a device
+ *
+ * @dev: Device to retrieve the map for
+ * @name: Optional name for the register map, usually NULL.
+ *
+ * Returns the regmap for the device if one is present, or NULL.  If
+ * name is specified then it must match the name specified when
+ * registering the device, if it is NULL then the first regmap found
+ * will be used.  Devices with multiple register maps are very rare,
+ * generic code should normally not need to specify a name.
+ */
+struct regmap *dev_get_regmap(struct device *dev, const char *name)
+{
+       struct regmap **r = devres_find(dev, dev_get_regmap_release,
+                                       dev_get_regmap_match, (void *)name);
+
+       if (!r)
+               return NULL;
+       return *r;
+}
+EXPORT_SYMBOL_GPL(dev_get_regmap);
+
 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
                             const void *val, size_t val_len)
 {

diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index f6abc8d33d64c4bde60a062fa7c2710feb9bbdfc..90a4652eaaea61124fa5e8ada2395fe817678145 100644 (file)
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -156,6 +156,7 @@ struct regmap *devm_regmap_init_mmio(struct device *dev,
 void regmap_exit(struct regmap *map);
 int regmap_reinit_cache(struct regmap *map,
                        const struct regmap_config *config);
+struct regmap *dev_get_regmap(struct device *dev, const char *name);
 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
 int regmap_raw_write(struct regmap *map, unsigned int reg,
                     const void *val, size_t val_len);
@@ -340,6 +341,13 @@ static inline int regmap_register_patch(struct regmap *map,
        return -EINVAL;
 }
 
+static inline struct regmap *dev_get_regmap(struct device *dev,
+                                           const char *name)
+{
+       WARN_ONCE(1, "regmap API is disabled");
+       return NULL;
+}
+
 #endif
 
 #endif