1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
|
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2019, The Linux Foundation. All rights reserved.
*/
#define pr_fmt(fmt) "%s: " fmt, __func__
#include <linux/bitops.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/slab.h>
#include <linux/regulator/consumer.h>
#include <linux/regulator/proxy-consumer.h>
struct proxy_consumer {
struct list_head list;
struct regulator *reg;
struct device *dev;
bool enable;
int min_uV;
int max_uV;
u32 current_uA;
};
static DEFINE_MUTEX(proxy_consumer_list_lock);
static LIST_HEAD(proxy_consumer_list);
static bool proxy_consumers_removed;
/**
* regulator_proxy_consumer_add() - conditionally add a proxy consumer for the
* specified regulator and set its boot time
* parameters
* @dev: Device pointer of the regulator
* @node: Device node pointer of the regulator
*
* This function calls regulator_get() after first checking if any proxy
* consumer properties are present in the 'node' device node. After that, the
* voltage, minimum current, and/or the enable state will be set based upon the
* device node property values.
*
* Returns a valid pointer on successfully proxy voting, NULL if no proxy voting
* is needed, or an ERR_PTR(errno) if an error occurred.
*/
static struct proxy_consumer *regulator_proxy_consumer_add(struct device *dev,
struct device_node *node)
{
struct proxy_consumer *consumer = NULL;
const char *reg_name = "";
const char *supply_name;
u32 voltage[2] = {0};
int ret;
if (!dev || !node) {
pr_err("dev or node is NULL\n");
return ERR_PTR(-EINVAL);
}
/* Return immediately if no proxy consumer properties are specified. */
if (!of_find_property(node, "qcom,proxy-consumer-enable", NULL)
&& !of_find_property(node, "qcom,proxy-consumer-voltage", NULL)
&& !of_find_property(node, "qcom,proxy-consumer-current", NULL))
return NULL;
mutex_lock(&proxy_consumer_list_lock);
/* Do not register new consumers if they cannot be removed later. */
if (proxy_consumers_removed) {
ret = -EPERM;
goto unlock_list;
}
if (node->name)
reg_name = node->name;
consumer = kzalloc(sizeof(*consumer), GFP_KERNEL);
if (!consumer) {
ret = -ENOMEM;
goto unlock_list;
}
consumer->dev = dev;
consumer->enable
= of_property_read_bool(node, "qcom,proxy-consumer-enable");
of_property_read_u32(node, "qcom,proxy-consumer-current",
&consumer->current_uA);
ret = of_property_read_u32_array(node, "qcom,proxy-consumer-voltage",
voltage, 2);
if (!ret) {
consumer->min_uV = voltage[0];
consumer->max_uV = voltage[1];
}
dev_dbg(dev, "proxy consumer request: enable=%d, voltage_range=[%d, %d] uV, min_current=%d uA\n",
consumer->enable, consumer->min_uV, consumer->max_uV,
consumer->current_uA);
supply_name = "proxy";
of_property_read_string(node, "qcom,proxy-consumer-name", &supply_name);
consumer->reg = regulator_get(dev, supply_name);
if (IS_ERR_OR_NULL(consumer->reg)) {
ret = PTR_ERR(consumer->reg);
pr_err("regulator_get(%s) failed for %s, ret=%d\n", supply_name,
reg_name, ret);
goto free_consumer;
}
if (consumer->max_uV > 0 && consumer->min_uV <= consumer->max_uV) {
ret = regulator_set_voltage(consumer->reg, consumer->min_uV,
consumer->max_uV);
if (ret) {
pr_err("regulator_set_voltage %s failed, ret=%d\n",
reg_name, ret);
goto free_regulator;
}
}
if (consumer->current_uA > 0) {
ret = regulator_set_load(consumer->reg, consumer->current_uA);
if (ret < 0) {
pr_err("regulator_set_load %s failed, ret=%d\n",
reg_name, ret);
goto remove_voltage;
}
}
if (consumer->enable) {
ret = regulator_enable(consumer->reg);
if (ret) {
pr_err("regulator_enable %s failed, ret=%d\n", reg_name,
ret);
goto remove_current;
}
}
list_add(&consumer->list, &proxy_consumer_list);
mutex_unlock(&proxy_consumer_list_lock);
return consumer;
remove_current:
regulator_set_load(consumer->reg, 0);
remove_voltage:
regulator_set_voltage(consumer->reg, 0, INT_MAX);
free_regulator:
regulator_put(consumer->reg);
free_consumer:
kfree(consumer);
unlock_list:
mutex_unlock(&proxy_consumer_list_lock);
return ERR_PTR(ret);
}
/**
* regulator_proxy_consumer_register() - conditionally register a proxy consumer
* for the specified regulator and set its boot time parameters
* @dev: Device pointer of the regulator
* @node: Device node pointer of the regulator
*
* This function calls regulator_get() after first checking if any proxy
* consumer properties are present in the 'node' device node. After that, the
* voltage, minimum current, and/or the enable state will be set based upon the
* device node property values.
*
* Returns 0 on successfully proxy voting or if no proxy voting is needed, or an
* errno if an error occurred.
*/
int regulator_proxy_consumer_register(struct device *dev,
struct device_node *node)
{
struct proxy_consumer *consumer;
consumer = regulator_proxy_consumer_add(dev, node);
return PTR_ERR_OR_ZERO(consumer);
}
EXPORT_SYMBOL(regulator_proxy_consumer_register);
/* proxy_consumer_list_lock must be held by caller. */
static int regulator_proxy_consumer_remove(struct proxy_consumer *consumer)
{
int ret = 0;
if (consumer->enable) {
ret = regulator_disable(consumer->reg);
if (ret)
pr_err("regulator_disable failed, ret=%d\n", ret);
}
if (consumer->current_uA > 0) {
ret = regulator_set_load(consumer->reg, 0);
if (ret < 0)
pr_err("regulator_set_load failed, ret=%d\n",
ret);
}
if (consumer->max_uV > 0 && consumer->min_uV <= consumer->max_uV) {
ret = regulator_set_voltage(consumer->reg, 0, INT_MAX);
if (ret)
pr_err("regulator_set_voltage failed, ret=%d\n", ret);
}
regulator_put(consumer->reg);
list_del(&consumer->list);
kfree(consumer);
return ret;
}
/**
* regulator_proxy_consumer_unregister() - unregister the proxy consumers of a
* device and remove their boot time
* requests
* @dev: Device pointer of the regulator
*
* This function removes all requests made by the proxy consumers of regulators
* in dev which where issued in regulator_proxy_consumer_register() and then
* frees the consumers' resources.
*
* Returns 0 on success or an errno on failure.
*/
void regulator_proxy_consumer_unregister(struct device *dev)
{
struct proxy_consumer *consumer, *temp;
if (IS_ERR_OR_NULL(dev)) {
pr_err("invalid device pointer\n");
return;
}
mutex_lock(&proxy_consumer_list_lock);
list_for_each_entry_safe(consumer, temp, &proxy_consumer_list, list) {
if (consumer->dev == dev)
regulator_proxy_consumer_remove(consumer);
}
mutex_unlock(&proxy_consumer_list_lock);
}
EXPORT_SYMBOL(regulator_proxy_consumer_unregister);
/* proxy_consumer_list_lock must be held by caller. */
static void
_devm_regulator_proxy_consumer_release(struct device *dev, void *res)
{
struct proxy_consumer *consumer = *(struct proxy_consumer **)res;
struct proxy_consumer *temp;
bool found = false;
/*
* The proxy consumer may have already been removed due to a
* sync_state() or devm_regulator_proxy_consumer_unregister() call.
* Therefore, verify that it is still in the list before attempting to
* remove it.
*/
list_for_each_entry(temp, &proxy_consumer_list, list) {
if (temp == consumer) {
found = true;
break;
}
}
if (found)
regulator_proxy_consumer_remove(consumer);
}
static void devm_regulator_proxy_consumer_release(struct device *dev, void *res)
{
mutex_lock(&proxy_consumer_list_lock);
_devm_regulator_proxy_consumer_release(dev, res);
mutex_unlock(&proxy_consumer_list_lock);
}
/**
* devm_regulator_proxy_consumer_register() - resource managed version of
* regulator_proxy_consumer_register()
* @dev: Device pointer of the regulator
* @node: Device node pointer of the regulator
*
* This is a resource managed version of regulator_proxy_consumer_register().
* Proxy consumer requests made via this call are automatically removed via
* regulator_proxy_consumer_unregister() on driver detach. See
* regulator_proxy_consumer_register() for more details.
*
* Returns 0 on success or an errno on failure.
*/
int devm_regulator_proxy_consumer_register(struct device *dev,
struct device_node *node)
{
struct proxy_consumer *consumer;
struct proxy_consumer **ptr;
ptr = devres_alloc(devm_regulator_proxy_consumer_release, sizeof(*ptr),
GFP_KERNEL);
if (!ptr)
return -ENOMEM;
consumer = regulator_proxy_consumer_add(dev, node);
if (IS_ERR_OR_NULL(consumer)) {
devres_free(ptr);
return PTR_ERR(consumer);
}
*ptr = consumer;
devres_add(dev, ptr);
return 0;
}
EXPORT_SYMBOL(devm_regulator_proxy_consumer_register);
static int devm_regulator_proxy_consumer_match(struct device *dev, void *res,
void *data)
{
struct proxy_consumer **consumer = res;
if (!consumer || !*consumer) {
WARN_ON(!consumer || !*consumer);
return 0;
}
return *consumer == data;
}
/**
* devm_regulator_proxy_consumer_unregister() - resource managed version of
* regulator_proxy_consumer_unregister()
* @dev: Device pointer of the regulator
*
* Deallocate the proxy consumers allocated for 'dev' with
* devm_regulator_proxy_consumer_register(). Normally this function will not
* need to be called and the resource management code will ensure that the
* resource is freed.
*
* Returns 0 on success or an errno on failure.
*/
void devm_regulator_proxy_consumer_unregister(struct device *dev)
{
struct proxy_consumer *consumer, *temp;
if (IS_ERR_OR_NULL(dev))
return;
mutex_lock(&proxy_consumer_list_lock);
list_for_each_entry_safe(consumer, temp, &proxy_consumer_list, list) {
if (consumer->dev == dev)
devres_release(dev,
_devm_regulator_proxy_consumer_release,
devm_regulator_proxy_consumer_match,
consumer);
}
mutex_unlock(&proxy_consumer_list_lock);
}
EXPORT_SYMBOL(devm_regulator_proxy_consumer_unregister);
#ifndef CONFIG_REGULATOR_PROXY_CONSUMER_LEGACY
void regulator_proxy_consumer_sync_state(struct device *dev)
{
regulator_proxy_consumer_unregister(dev);
}
EXPORT_SYMBOL(regulator_proxy_consumer_sync_state);
#else /* CONFIG_REGULATOR_PROXY_CONSUMER_LEGACY=y */
void regulator_proxy_consumer_sync_state(struct device *dev) { }
EXPORT_SYMBOL(regulator_proxy_consumer_sync_state);
/*
* Remove all proxy requests at late_initcall_sync. The assumption is that all
* devices have probed at this point and made their own regulator requests.
*/
static int __init regulator_proxy_consumer_remove_all(void)
{
struct proxy_consumer *consumer;
struct proxy_consumer *temp;
mutex_lock(&proxy_consumer_list_lock);
proxy_consumers_removed = true;
if (!list_empty(&proxy_consumer_list))
pr_info("removing regulator proxy consumer requests\n");
list_for_each_entry_safe(consumer, temp, &proxy_consumer_list, list) {
regulator_proxy_consumer_remove(consumer);
}
mutex_unlock(&proxy_consumer_list_lock);
return 0;
}
late_initcall_sync(regulator_proxy_consumer_remove_all);
#endif
MODULE_DESCRIPTION("Regulator proxy consumer library");
MODULE_LICENSE("GPL v2");
|