aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorNicolas Boichat <drinkcat@chromium.org>2015-07-08 02:30:18 -0400
committerMark Brown <broonie@kernel.org>2015-08-07 09:50:59 -0400
commit3cfe7a74d42b7e3644f8b2b26aa20146d4f90f0f (patch)
treeab9efb80f6e886934d6e003582cd40d0cb9a2d34
parent331a5fc9f2ed28033ddda89acb2a9b43592a545d (diff)
regmap: Use different lockdep class for each regmap init call
Lockdep validator complains about recursive locking and deadlock when two different regmap instances are called in a nested order. That happens anytime a regmap read/write call needs to access another regmap. This is because, for performance reason, lockdep groups all locks initialized by the same mutex_init() in the same lock class. Therefore all regmap mutexes are in the same lock class, leading to lockdep "nested locking" warnings if a regmap accesses another regmap. In general, it is impossible to establish in advance the hierarchy of regmaps, so we make sure that each regmap init call initializes its own static lock_class_key. This is done by wrapping all regmap_init calls into macros. This also allows us to give meaningful names to the lock_class_key. For example, in rt5677 case, we have in /proc/lockdep_chains: irq_context: 0 [ffffffc0018d2198] &dev->mutex [ffffffc0018d2198] &dev->mutex [ffffffc001bd7f60] rt5677:5104:(&rt5677_regmap)->_lock [ffffffc001bd7f58] rt5677:5096:(&rt5677_regmap_physical)->_lock [ffffffc001b95448] &(&base->lock)->rlock The above would have resulted in a lockdep recursive warning previously. This is not the case anymore as the lockdep validator now clearly identifies the 2 regmaps as separate. Signed-off-by: Nicolas Boichat <drinkcat@chromium.org> Signed-off-by: Mark Brown <broonie@kernel.org>
Diffstat
-rw-r--r--drivers/base/regmap/regmap-ac97.c22
-rw-r--r--drivers/base/regmap/regmap-i2c.c22
-rw-r--r--drivers/base/regmap/regmap-mmio.c27
-rw-r--r--drivers/base/regmap/regmap-spi.c22
-rw-r--r--drivers/base/regmap/regmap-spmi.c44
-rw-r--r--drivers/base/regmap/regmap.c31
-rw-r--r--include/linux/regmap.h192
7 files changed, 250 insertions, 110 deletions
diff --git a/drivers/base/regmap/regmap-ac97.c b/drivers/base/regmap/regmap-ac97.c
index 8d304e2a943d..aa631be8b821 100644
--- a/drivers/base/regmap/regmap-ac97.c
+++ b/drivers/base/regmap/regmap-ac97.c
@@ -87,12 +87,15 @@ static const struct regmap_bus ac97_regmap_bus = {
87 * The return value will be an ERR_PTR() on error or a valid pointer to 87 * The return value will be an ERR_PTR() on error or a valid pointer to
88 * a struct regmap. 88 * a struct regmap.
89 */ 89 */
90struct regmap *regmap_init_ac97(struct snd_ac97 *ac97, 90struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
91 const struct regmap_config *config) 91 const struct regmap_config *config,
92 struct lock_class_key *lock_key,
93 const char *lock_name)
92{ 94{
93 return regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config); 95 return __regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config,
96 lock_key, lock_name);
94} 97}
95EXPORT_SYMBOL_GPL(regmap_init_ac97); 98EXPORT_SYMBOL_GPL(__regmap_init_ac97);
96 99
97/** 100/**
98 * devm_regmap_init_ac97(): Initialise AC'97 register map 101 * devm_regmap_init_ac97(): Initialise AC'97 register map
@@ -104,11 +107,14 @@ EXPORT_SYMBOL_GPL(regmap_init_ac97);
104 * to a struct regmap. The regmap will be automatically freed by the 107 * to a struct regmap. The regmap will be automatically freed by the
105 * device management code. 108 * device management code.
106 */ 109 */
107struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97, 110struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
108 const struct regmap_config *config) 111 const struct regmap_config *config,
112 struct lock_class_key *lock_key,
113 const char *lock_name)
109{ 114{
110 return devm_regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config); 115 return __devm_regmap_init(&ac97->dev, &ac97_regmap_bus, ac97, config,
116 lock_key, lock_name);
111} 117}
112EXPORT_SYMBOL_GPL(devm_regmap_init_ac97); 118EXPORT_SYMBOL_GPL(__devm_regmap_init_ac97);
113 119
114MODULE_LICENSE("GPL v2"); 120MODULE_LICENSE("GPL v2");
diff --git a/drivers/base/regmap/regmap-i2c.c b/drivers/base/regmap/regmap-i2c.c
index 4b76e33110a2..3163b22e2baf 100644
--- a/drivers/base/regmap/regmap-i2c.c
+++ b/drivers/base/regmap/regmap-i2c.c
@@ -242,17 +242,20 @@ static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c,
242 * The return value will be an ERR_PTR() on error or a valid pointer to 242 * The return value will be an ERR_PTR() on error or a valid pointer to
243 * a struct regmap. 243 * a struct regmap.
244 */ 244 */
245struct regmap *regmap_init_i2c(struct i2c_client *i2c, 245struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
246 const struct regmap_config *config) 246 const struct regmap_config *config,
247 struct lock_class_key *lock_key,
248 const char *lock_name)
247{ 249{
248 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config); 250 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
249 251
250 if (IS_ERR(bus)) 252 if (IS_ERR(bus))
251 return ERR_CAST(bus); 253 return ERR_CAST(bus);
252 254
253 return regmap_init(&i2c->dev, bus, &i2c->dev, config); 255 return __regmap_init(&i2c->dev, bus, &i2c->dev, config,
256 lock_key, lock_name);
254} 257}
255EXPORT_SYMBOL_GPL(regmap_init_i2c); 258EXPORT_SYMBOL_GPL(__regmap_init_i2c);
256 259
257/** 260/**
258 * devm_regmap_init_i2c(): Initialise managed register map 261 * devm_regmap_init_i2c(): Initialise managed register map
@@ -264,16 +267,19 @@ EXPORT_SYMBOL_GPL(regmap_init_i2c);
264 * to a struct regmap. The regmap will be automatically freed by the 267 * to a struct regmap. The regmap will be automatically freed by the
265 * device management code. 268 * device management code.
266 */ 269 */
267struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, 270struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
268 const struct regmap_config *config) 271 const struct regmap_config *config,
272 struct lock_class_key *lock_key,
273 const char *lock_name)
269{ 274{
270 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config); 275 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
271 276
272 if (IS_ERR(bus)) 277 if (IS_ERR(bus))
273 return ERR_CAST(bus); 278 return ERR_CAST(bus);
274 279
275 return devm_regmap_init(&i2c->dev, bus, &i2c->dev, config); 280 return __devm_regmap_init(&i2c->dev, bus, &i2c->dev, config,
281 lock_key, lock_name);
276} 282}
277EXPORT_SYMBOL_GPL(devm_regmap_init_i2c); 283EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c);
278 284
279MODULE_LICENSE("GPL"); 285MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap-mmio.c b/drivers/base/regmap/regmap-mmio.c
index 04a329a377e9..a1b2b270e4bc 100644
--- a/drivers/base/regmap/regmap-mmio.c
+++ b/drivers/base/regmap/regmap-mmio.c
@@ -307,9 +307,11 @@ err_free:
307 * The return value will be an ERR_PTR() on error or a valid pointer to 307 * The return value will be an ERR_PTR() on error or a valid pointer to
308 * a struct regmap. 308 * a struct regmap.
309 */ 309 */
310struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id, 310struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
311 void __iomem *regs, 311 void __iomem *regs,
312 const struct regmap_config *config) 312 const struct regmap_config *config,
313 struct lock_class_key *lock_key,
314 const char *lock_name)
313{ 315{
314 struct regmap_mmio_context *ctx; 316 struct regmap_mmio_context *ctx;
315 317
@@ -317,9 +319,10 @@ struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
317 if (IS_ERR(ctx)) 319 if (IS_ERR(ctx))
318 return ERR_CAST(ctx); 320 return ERR_CAST(ctx);
319 321
320 return regmap_init(dev, &regmap_mmio, ctx, config); 322 return __regmap_init(dev, &regmap_mmio, ctx, config,
323 lock_key, lock_name);
321} 324}
322EXPORT_SYMBOL_GPL(regmap_init_mmio_clk); 325EXPORT_SYMBOL_GPL(__regmap_init_mmio_clk);
323 326
324/** 327/**
325 * devm_regmap_init_mmio_clk(): Initialise managed register map with clock 328 * devm_regmap_init_mmio_clk(): Initialise managed register map with clock
@@ -333,9 +336,12 @@ EXPORT_SYMBOL_GPL(regmap_init_mmio_clk);
333 * to a struct regmap. The regmap will be automatically freed by the 336 * to a struct regmap. The regmap will be automatically freed by the
334 * device management code. 337 * device management code.
335 */ 338 */
336struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id, 339struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
337 void __iomem *regs, 340 const char *clk_id,
338 const struct regmap_config *config) 341 void __iomem *regs,
342 const struct regmap_config *config,
343 struct lock_class_key *lock_key,
344 const char *lock_name)
339{ 345{
340 struct regmap_mmio_context *ctx; 346 struct regmap_mmio_context *ctx;
341 347
@@ -343,8 +349,9 @@ struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
343 if (IS_ERR(ctx)) 349 if (IS_ERR(ctx))
344 return ERR_CAST(ctx); 350 return ERR_CAST(ctx);
345 351
346 return devm_regmap_init(dev, &regmap_mmio, ctx, config); 352 return __devm_regmap_init(dev, &regmap_mmio, ctx, config,
353 lock_key, lock_name);
347} 354}
348EXPORT_SYMBOL_GPL(devm_regmap_init_mmio_clk); 355EXPORT_SYMBOL_GPL(__devm_regmap_init_mmio_clk);
349 356
350MODULE_LICENSE("GPL v2"); 357MODULE_LICENSE("GPL v2");
diff --git a/drivers/base/regmap/regmap-spi.c b/drivers/base/regmap/regmap-spi.c
index 53d1148e80a0..4c7850d660d1 100644
--- a/drivers/base/regmap/regmap-spi.c
+++ b/drivers/base/regmap/regmap-spi.c
@@ -122,12 +122,15 @@ static struct regmap_bus regmap_spi = {
122 * The return value will be an ERR_PTR() on error or a valid pointer to 122 * The return value will be an ERR_PTR() on error or a valid pointer to
123 * a struct regmap. 123 * a struct regmap.
124 */ 124 */
125struct regmap *regmap_init_spi(struct spi_device *spi, 125struct regmap *__regmap_init_spi(struct spi_device *spi,
126 const struct regmap_config *config) 126 const struct regmap_config *config,
127 struct lock_class_key *lock_key,
128 const char *lock_name)
127{ 129{
128 return regmap_init(&spi->dev, &regmap_spi, &spi->dev, config); 130 return __regmap_init(&spi->dev, &regmap_spi, &spi->dev, config,
131 lock_key, lock_name);
129} 132}
130EXPORT_SYMBOL_GPL(regmap_init_spi); 133EXPORT_SYMBOL_GPL(__regmap_init_spi);
131 134
132/** 135/**
133 * devm_regmap_init_spi(): Initialise register map 136 * devm_regmap_init_spi(): Initialise register map
@@ -139,11 +142,14 @@ EXPORT_SYMBOL_GPL(regmap_init_spi);
139 * to a struct regmap. The map will be automatically freed by the 142 * to a struct regmap. The map will be automatically freed by the
140 * device management code. 143 * device management code.
141 */ 144 */
142struct regmap *devm_regmap_init_spi(struct spi_device *spi, 145struct regmap *__devm_regmap_init_spi(struct spi_device *spi,
143 const struct regmap_config *config) 146 const struct regmap_config *config,
147 struct lock_class_key *lock_key,
148 const char *lock_name)
144{ 149{
145 return devm_regmap_init(&spi->dev, &regmap_spi, &spi->dev, config); 150 return __devm_regmap_init(&spi->dev, &regmap_spi, &spi->dev, config,
151 lock_key, lock_name);
146} 152}
147EXPORT_SYMBOL_GPL(devm_regmap_init_spi); 153EXPORT_SYMBOL_GPL(__devm_regmap_init_spi);
148 154
149MODULE_LICENSE("GPL"); 155MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap-spmi.c b/drivers/base/regmap/regmap-spmi.c
index d7026dc33388..7f50f5862d39 100644
--- a/drivers/base/regmap/regmap-spmi.c
+++ b/drivers/base/regmap/regmap-spmi.c
@@ -99,12 +99,15 @@ static struct regmap_bus regmap_spmi_base = {
99 * The return value will be an ERR_PTR() on error or a valid pointer to 99 * The return value will be an ERR_PTR() on error or a valid pointer to
100 * a struct regmap. 100 * a struct regmap.
101 */ 101 */
102struct regmap *regmap_init_spmi_base(struct spmi_device *sdev, 102struct regmap *__regmap_init_spmi_base(struct spmi_device *sdev,
103 const struct regmap_config *config) 103 const struct regmap_config *config,
104 struct lock_class_key *lock_key,
105 const char *lock_name)
104{ 106{
105 return regmap_init(&sdev->dev, &regmap_spmi_base, sdev, config); 107 return __regmap_init(&sdev->dev, &regmap_spmi_base, sdev, config,
108 lock_key, lock_name);
106} 109}
107EXPORT_SYMBOL_GPL(regmap_init_spmi_base); 110EXPORT_SYMBOL_GPL(__regmap_init_spmi_base);
108 111
109/** 112/**
110 * devm_regmap_init_spmi_base(): Create managed regmap for Base register space 113 * devm_regmap_init_spmi_base(): Create managed regmap for Base register space
@@ -115,12 +118,15 @@ EXPORT_SYMBOL_GPL(regmap_init_spmi_base);
115 * to a struct regmap. The regmap will be automatically freed by the 118 * to a struct regmap. The regmap will be automatically freed by the
116 * device management code. 119 * device management code.
117 */ 120 */
118struct regmap *devm_regmap_init_spmi_base(struct spmi_device *sdev, 121struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *sdev,
119 const struct regmap_config *config) 122 const struct regmap_config *config,
123 struct lock_class_key *lock_key,
124 const char *lock_name)
120{ 125{
121 return devm_regmap_init(&sdev->dev, &regmap_spmi_base, sdev, config); 126 return __devm_regmap_init(&sdev->dev, &regmap_spmi_base, sdev, config,
127 lock_key, lock_name);
122} 128}
123EXPORT_SYMBOL_GPL(devm_regmap_init_spmi_base); 129EXPORT_SYMBOL_GPL(__devm_regmap_init_spmi_base);
124 130
125static int regmap_spmi_ext_read(void *context, 131static int regmap_spmi_ext_read(void *context,
126 const void *reg, size_t reg_size, 132 const void *reg, size_t reg_size,
@@ -230,12 +236,15 @@ static struct regmap_bus regmap_spmi_ext = {
230 * The return value will be an ERR_PTR() on error or a valid pointer to 236 * The return value will be an ERR_PTR() on error or a valid pointer to
231 * a struct regmap. 237 * a struct regmap.
232 */ 238 */
233struct regmap *regmap_init_spmi_ext(struct spmi_device *sdev, 239struct regmap *__regmap_init_spmi_ext(struct spmi_device *sdev,
234 const struct regmap_config *config) 240 const struct regmap_config *config,
241 struct lock_class_key *lock_key,
242 const char *lock_name)
235{ 243{
236 return regmap_init(&sdev->dev, &regmap_spmi_ext, sdev, config); 244 return __regmap_init(&sdev->dev, &regmap_spmi_ext, sdev, config,
245 lock_key, lock_name);
237} 246}
238EXPORT_SYMBOL_GPL(regmap_init_spmi_ext); 247EXPORT_SYMBOL_GPL(__regmap_init_spmi_ext);
239 248
240/** 249/**
241 * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space 250 * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space
@@ -246,11 +255,14 @@ EXPORT_SYMBOL_GPL(regmap_init_spmi_ext);
246 * to a struct regmap. The regmap will be automatically freed by the 255 * to a struct regmap. The regmap will be automatically freed by the
247 * device management code. 256 * device management code.
248 */ 257 */
249struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *sdev, 258struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *sdev,
250 const struct regmap_config *config) 259 const struct regmap_config *config,
260 struct lock_class_key *lock_key,
261 const char *lock_name)
251{ 262{
252 return devm_regmap_init(&sdev->dev, &regmap_spmi_ext, sdev, config); 263 return __devm_regmap_init(&sdev->dev, &regmap_spmi_ext, sdev, config,
264 lock_key, lock_name);
253} 265}
254EXPORT_SYMBOL_GPL(devm_regmap_init_spmi_ext); 266EXPORT_SYMBOL_GPL(__devm_regmap_init_spmi_ext);
255 267
256MODULE_LICENSE("GPL"); 268MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index 7111d04f2621..b9fddccd6e06 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -527,10 +527,12 @@ EXPORT_SYMBOL_GPL(regmap_get_val_endian);
527 * a struct regmap. This function should generally not be called 527 * a struct regmap. This function should generally not be called
528 * directly, it should be called by bus-specific init functions. 528 * directly, it should be called by bus-specific init functions.
529 */ 529 */
530struct regmap *regmap_init(struct device *dev, 530struct regmap *__regmap_init(struct device *dev,
531 const struct regmap_bus *bus, 531 const struct regmap_bus *bus,
532 void *bus_context, 532 void *bus_context,
533 const struct regmap_config *config) 533 const struct regmap_config *config,
534 struct lock_class_key *lock_key,
535 const char *lock_name)
534{ 536{
535 struct regmap *map; 537 struct regmap *map;
536 int ret = -EINVAL; 538 int ret = -EINVAL;
@@ -556,10 +558,14 @@ struct regmap *regmap_init(struct device *dev,
556 spin_lock_init(&map->spinlock); 558 spin_lock_init(&map->spinlock);
557 map->lock = regmap_lock_spinlock; 559 map->lock = regmap_lock_spinlock;
558 map->unlock = regmap_unlock_spinlock; 560 map->unlock = regmap_unlock_spinlock;
561 lockdep_set_class_and_name(&map->spinlock,
562 lock_key, lock_name);
559 } else { 563 } else {
560 mutex_init(&map->mutex); 564 mutex_init(&map->mutex);
561 map->lock = regmap_lock_mutex; 565 map->lock = regmap_lock_mutex;
562 map->unlock = regmap_unlock_mutex; 566 map->unlock = regmap_unlock_mutex;
567 lockdep_set_class_and_name(&map->mutex,
568 lock_key, lock_name);
563 } 569 }
564 map->lock_arg = map; 570 map->lock_arg = map;
565 } 571 }
@@ -899,7 +905,7 @@ err_map:
899err: 905err:
900 return ERR_PTR(ret); 906 return ERR_PTR(ret);
901} 907}
902EXPORT_SYMBOL_GPL(regmap_init); 908EXPORT_SYMBOL_GPL(__regmap_init);
903 909
904static void devm_regmap_release(struct device *dev, void *res) 910static void devm_regmap_release(struct device *dev, void *res)
905{ 911{
@@ -919,10 +925,12 @@ static void devm_regmap_release(struct device *dev, void *res)
919 * directly, it should be called by bus-specific init functions. The 925 * directly, it should be called by bus-specific init functions. The
920 * map will be automatically freed by the device management code. 926 * map will be automatically freed by the device management code.
921 */ 927 */
922struct regmap *devm_regmap_init(struct device *dev, 928struct regmap *__devm_regmap_init(struct device *dev,
923 const struct regmap_bus *bus, 929 const struct regmap_bus *bus,
924 void *bus_context, 930 void *bus_context,
925 const struct regmap_config *config) 931 const struct regmap_config *config,
932 struct lock_class_key *lock_key,
933 const char *lock_name)
926{ 934{
927 struct regmap **ptr, *regmap; 935 struct regmap **ptr, *regmap;
928 936
@@ -930,7 +938,8 @@ struct regmap *devm_regmap_init(struct device *dev,
930 if (!ptr) 938 if (!ptr)
931 return ERR_PTR(-ENOMEM); 939 return ERR_PTR(-ENOMEM);
932 940
933 regmap = regmap_init(dev, bus, bus_context, config); 941 regmap = __regmap_init(dev, bus, bus_context, config,
942 lock_key, lock_name);
934 if (!IS_ERR(regmap)) { 943 if (!IS_ERR(regmap)) {
935 *ptr = regmap; 944 *ptr = regmap;
936 devres_add(dev, ptr); 945 devres_add(dev, ptr);
@@ -940,7 +949,7 @@ struct regmap *devm_regmap_init(struct device *dev,
940 949
941 return regmap; 950 return regmap;
942} 951}
943EXPORT_SYMBOL_GPL(devm_regmap_init); 952EXPORT_SYMBOL_GPL(__devm_regmap_init);
944 953
945static void regmap_field_init(struct regmap_field *rm_field, 954static void regmap_field_init(struct regmap_field *rm_field,
946 struct regmap *regmap, struct reg_field reg_field) 955 struct regmap *regmap, struct reg_field reg_field)
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 59c55ea0f0b5..5d7027286032 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -17,6 +17,7 @@
17#include <linux/rbtree.h> 17#include <linux/rbtree.h>
18#include <linux/err.h> 18#include <linux/err.h>
19#include <linux/bug.h> 19#include <linux/bug.h>
20#include <linux/lockdep.h>
20 21
21struct module; 22struct module;
22struct device; 23struct device;
@@ -324,46 +325,147 @@ struct regmap_bus {
324 enum regmap_endian val_format_endian_default; 325 enum regmap_endian val_format_endian_default;
325}; 326};
326 327
327struct regmap *regmap_init(struct device *dev, 328/*
328 const struct regmap_bus *bus, 329 * __regmap_init functions.
329 void *bus_context, 330 *
330 const struct regmap_config *config); 331 * These functions take a lock key and name parameter, and should not be called
331int regmap_attach_dev(struct device *dev, struct regmap *map, 332 * directly. Instead, use the regmap_init macros that generate a key and name
332 const struct regmap_config *config); 333 * for each call.
333struct regmap *regmap_init_i2c(struct i2c_client *i2c, 334 */
334 const struct regmap_config *config); 335struct regmap *__regmap_init(struct device *dev,
335struct regmap *regmap_init_spi(struct spi_device *dev, 336 const struct regmap_bus *bus,
336 const struct regmap_config *config); 337 void *bus_context,
337struct regmap *regmap_init_spmi_base(struct spmi_device *dev, 338 const struct regmap_config *config,
338 const struct regmap_config *config); 339 struct lock_class_key *lock_key,
339struct regmap *regmap_init_spmi_ext(struct spmi_device *dev, 340 const char *lock_name);
340 const struct regmap_config *config); 341struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
341struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id, 342 const struct regmap_config *config,
342 void __iomem *regs, 343 struct lock_class_key *lock_key,
343 const struct regmap_config *config); 344 const char *lock_name);
344struct regmap *regmap_init_ac97(struct snd_ac97 *ac97, 345struct regmap *__regmap_init_spi(struct spi_device *dev,
345 const struct regmap_config *config); 346 const struct regmap_config *config,
346 347 struct lock_class_key *lock_key,
347struct regmap *devm_regmap_init(struct device *dev, 348 const char *lock_name);
348 const struct regmap_bus *bus, 349struct regmap *__regmap_init_spmi_base(struct spmi_device *dev,
349 void *bus_context, 350 const struct regmap_config *config,
350 const struct regmap_config *config); 351 struct lock_class_key *lock_key,
351struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, 352 const char *lock_name);
352 const struct regmap_config *config); 353struct regmap *__regmap_init_spmi_ext(struct spmi_device *dev,
353struct regmap *devm_regmap_init_spi(struct spi_device *dev, 354 const struct regmap_config *config,
354 const struct regmap_config *config); 355 struct lock_class_key *lock_key,
355struct regmap *devm_regmap_init_spmi_base(struct spmi_device *dev, 356 const char *lock_name);
356 const struct regmap_config *config); 357struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
357struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *dev, 358 void __iomem *regs,
358 const struct regmap_config *config); 359 const struct regmap_config *config,
359struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id, 360 struct lock_class_key *lock_key,
360 void __iomem *regs, 361 const char *lock_name);
361 const struct regmap_config *config); 362struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
362struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97, 363 const struct regmap_config *config,
363 const struct regmap_config *config); 364 struct lock_class_key *lock_key,
365 const char *lock_name);
366
367struct regmap *__devm_regmap_init(struct device *dev,
368 const struct regmap_bus *bus,
369 void *bus_context,
370 const struct regmap_config *config,
371 struct lock_class_key *lock_key,
372 const char *lock_name);
373struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
374 const struct regmap_config *config,
375 struct lock_class_key *lock_key,
376 const char *lock_name);
377struct regmap *__devm_regmap_init_spi(struct spi_device *dev,
378 const struct regmap_config *config,
379 struct lock_class_key *lock_key,
380 const char *lock_name);
381struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *dev,
382 const struct regmap_config *config,
383 struct lock_class_key *lock_key,
384 const char *lock_name);
385struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *dev,
386 const struct regmap_config *config,
387 struct lock_class_key *lock_key,
388 const char *lock_name);
389struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
390 const char *clk_id,
391 void __iomem *regs,
392 const struct regmap_config *config,
393 struct lock_class_key *lock_key,
394 const char *lock_name);
395struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
396 const struct regmap_config *config,
397 struct lock_class_key *lock_key,
398 const char *lock_name);
364 399
400/*
401 * Wrapper for regmap_init macros to include a unique lockdep key and name
402 * for each call. No-op if CONFIG_LOCKDEP is not set.
403 *
404 * @fn: Real function to call (in the form __[*_]regmap_init[_*])
405 * @name: Config variable name (#config in the calling macro)
406 **/
407#ifdef CONFIG_LOCKDEP
408#define __regmap_lockdep_wrapper(fn, name, ...) \
409( \
410 ({ \
411 static struct lock_class_key _key; \
412 fn(__VA_ARGS__, &_key, \
413 KBUILD_BASENAME ":" \
414 __stringify(__LINE__) ":" \
415 "(" name ")->lock"); \
416 }) \
417)
418#else
419#define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL)
420#endif
421
422#define regmap_init(dev, bus, bus_context, config) \
423 __regmap_lockdep_wrapper(__regmap_init, #config, \
424 dev, bus, bus_context, config)
425int regmap_attach_dev(struct device *dev, struct regmap *map,
426 const struct regmap_config *config);
427#define regmap_init_i2c(i2c, config) \
428 __regmap_lockdep_wrapper(__regmap_init_i2c, #config, \
429 i2c, config)
430#define regmap_init_spi(dev, config) \
431 __regmap_lockdep_wrapper(__regmap_init_spi, #config, \
432 dev, config)
433#define regmap_init_spmi_base(dev, config) \
434 __regmap_lockdep_wrapper(__regmap_init_spmi_base, #config, \
435 dev, config)
436#define regmap_init_spmi_ext(dev, config) \
437 __regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config, \
438 dev, config)
439#define regmap_init_mmio_clk(dev, clk_id, regs, config) \
440 __regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config, \
441 dev, clk_id, regs, config)
442#define regmap_init_ac97(ac97, config) \
443 __regmap_lockdep_wrapper(__regmap_init_ac97, #config, \
444 ac97, config)
365bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg); 445bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
366 446
447#define devm_regmap_init(dev, bus, bus_context, config) \
448 __regmap_lockdep_wrapper(__devm_regmap_init, #config, \
449 dev, bus, bus_context, config)
450#define devm_regmap_init_i2c(i2c, config) \
451 __regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config, \
452 i2c, config)
453#define devm_regmap_init_spi(dev, config) \
454 __regmap_lockdep_wrapper(__devm_regmap_init_spi, #config, \
455 dev, config)
456#define devm_regmap_init_spmi_base(dev, config) \
457 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config, \
458 dev, config)
459#define devm_regmap_init_spmi_ext(dev, config) \
460 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config, \
461 dev, config)
462#define devm_regmap_init_mmio_clk(dev, clk_id, regs, config) \
463 __regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config, \
464 dev, clk_id, regs, config)
465#define devm_regmap_init_ac97(ac97, config) \
466 __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config, \
467 ac97, config)
468
367/** 469/**
368 * regmap_init_mmio(): Initialise register map 470 * regmap_init_mmio(): Initialise register map
369 * 471 *
@@ -374,12 +476,8 @@ bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
374 * The return value will be an ERR_PTR() on error or a valid pointer to 476 * The return value will be an ERR_PTR() on error or a valid pointer to
375 * a struct regmap. 477 * a struct regmap.
376 */ 478 */
377static inline struct regmap *regmap_init_mmio(struct device *dev, 479#define regmap_init_mmio(dev, regs, config) \
378 void __iomem *regs, 480 regmap_init_mmio_clk(dev, NULL, regs, config)
379 const struct regmap_config *config)
380{
381 return regmap_init_mmio_clk(dev, NULL, regs, config);
382}
383 481
384/** 482/**
385 * devm_regmap_init_mmio(): Initialise managed register map 483 * devm_regmap_init_mmio(): Initialise managed register map
@@ -392,12 +490,8 @@ static inline struct regmap *regmap_init_mmio(struct device *dev,
392 * to a struct regmap. The regmap will be automatically freed by the 490 * to a struct regmap. The regmap will be automatically freed by the
393 * device management code. 491 * device management code.
394 */ 492 */
395static inline struct regmap *devm_regmap_init_mmio(struct device *dev, 493#define devm_regmap_init_mmio(dev, regs, config) \
396 void __iomem *regs, 494 devm_regmap_init_mmio_clk(dev, NULL, regs, config)
397 const struct regmap_config *config)
398{
399 return devm_regmap_init_mmio_clk(dev, NULL, regs, config);
400}
401 495
402void regmap_exit(struct regmap *map); 496void regmap_exit(struct regmap *map);
403int regmap_reinit_cache(struct regmap *map, 497int regmap_reinit_cache(struct regmap *map,
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-12 06:37:36 -0400