Merge tag 'pwm/for-4.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/thierry...
[linux-2.6-microblaze.git] / drivers / regulator / of_regulator.c
1 /*
2  * OF helpers for regulator framework
3  *
4  * Copyright (C) 2011 Texas Instruments, Inc.
5  * Rajendra Nayak <rnayak@ti.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  */
12
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/of.h>
16 #include <linux/regulator/machine.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/of_regulator.h>
19
20 #include "internal.h"
21
22 static const char *const regulator_states[PM_SUSPEND_MAX + 1] = {
23         [PM_SUSPEND_MEM]        = "regulator-state-mem",
24         [PM_SUSPEND_MAX]        = "regulator-state-disk",
25 };
26
27 static void of_get_regulation_constraints(struct device_node *np,
28                                         struct regulator_init_data **init_data,
29                                         const struct regulator_desc *desc)
30 {
31         struct regulation_constraints *constraints = &(*init_data)->constraints;
32         struct regulator_state *suspend_state;
33         struct device_node *suspend_np;
34         unsigned int mode;
35         int ret, i, len;
36         u32 pval;
37
38         constraints->name = of_get_property(np, "regulator-name", NULL);
39
40         if (!of_property_read_u32(np, "regulator-min-microvolt", &pval))
41                 constraints->min_uV = pval;
42
43         if (!of_property_read_u32(np, "regulator-max-microvolt", &pval))
44                 constraints->max_uV = pval;
45
46         /* Voltage change possible? */
47         if (constraints->min_uV != constraints->max_uV)
48                 constraints->valid_ops_mask |= REGULATOR_CHANGE_VOLTAGE;
49
50         /* Do we have a voltage range, if so try to apply it? */
51         if (constraints->min_uV && constraints->max_uV)
52                 constraints->apply_uV = true;
53
54         if (!of_property_read_u32(np, "regulator-microvolt-offset", &pval))
55                 constraints->uV_offset = pval;
56         if (!of_property_read_u32(np, "regulator-min-microamp", &pval))
57                 constraints->min_uA = pval;
58         if (!of_property_read_u32(np, "regulator-max-microamp", &pval))
59                 constraints->max_uA = pval;
60
61         if (!of_property_read_u32(np, "regulator-input-current-limit-microamp",
62                                   &pval))
63                 constraints->ilim_uA = pval;
64
65         /* Current change possible? */
66         if (constraints->min_uA != constraints->max_uA)
67                 constraints->valid_ops_mask |= REGULATOR_CHANGE_CURRENT;
68
69         constraints->boot_on = of_property_read_bool(np, "regulator-boot-on");
70         constraints->always_on = of_property_read_bool(np, "regulator-always-on");
71         if (!constraints->always_on) /* status change should be possible. */
72                 constraints->valid_ops_mask |= REGULATOR_CHANGE_STATUS;
73
74         constraints->pull_down = of_property_read_bool(np, "regulator-pull-down");
75
76         if (of_property_read_bool(np, "regulator-allow-bypass"))
77                 constraints->valid_ops_mask |= REGULATOR_CHANGE_BYPASS;
78
79         if (of_property_read_bool(np, "regulator-allow-set-load"))
80                 constraints->valid_ops_mask |= REGULATOR_CHANGE_DRMS;
81
82         ret = of_property_read_u32(np, "regulator-ramp-delay", &pval);
83         if (!ret) {
84                 if (pval)
85                         constraints->ramp_delay = pval;
86                 else
87                         constraints->ramp_disable = true;
88         }
89
90         ret = of_property_read_u32(np, "regulator-settling-time-us", &pval);
91         if (!ret)
92                 constraints->settling_time = pval;
93
94         ret = of_property_read_u32(np, "regulator-settling-time-up-us", &pval);
95         if (!ret)
96                 constraints->settling_time_up = pval;
97         if (constraints->settling_time_up && constraints->settling_time) {
98                 pr_warn("%s: ambiguous configuration for settling time, ignoring 'regulator-settling-time-up-us'\n",
99                         np->name);
100                 constraints->settling_time_up = 0;
101         }
102
103         ret = of_property_read_u32(np, "regulator-settling-time-down-us",
104                                    &pval);
105         if (!ret)
106                 constraints->settling_time_down = pval;
107         if (constraints->settling_time_down && constraints->settling_time) {
108                 pr_warn("%s: ambiguous configuration for settling time, ignoring 'regulator-settling-time-down-us'\n",
109                         np->name);
110                 constraints->settling_time_down = 0;
111         }
112
113         ret = of_property_read_u32(np, "regulator-enable-ramp-delay", &pval);
114         if (!ret)
115                 constraints->enable_time = pval;
116
117         constraints->soft_start = of_property_read_bool(np,
118                                         "regulator-soft-start");
119         ret = of_property_read_u32(np, "regulator-active-discharge", &pval);
120         if (!ret) {
121                 constraints->active_discharge =
122                                 (pval) ? REGULATOR_ACTIVE_DISCHARGE_ENABLE :
123                                         REGULATOR_ACTIVE_DISCHARGE_DISABLE;
124         }
125
126         if (!of_property_read_u32(np, "regulator-initial-mode", &pval)) {
127                 if (desc && desc->of_map_mode) {
128                         mode = desc->of_map_mode(pval);
129                         if (mode == REGULATOR_MODE_INVALID)
130                                 pr_err("%s: invalid mode %u\n", np->name, pval);
131                         else
132                                 constraints->initial_mode = mode;
133                 } else {
134                         pr_warn("%s: mapping for mode %d not defined\n",
135                                 np->name, pval);
136                 }
137         }
138
139         len = of_property_count_elems_of_size(np, "regulator-allowed-modes",
140                                                 sizeof(u32));
141         if (len > 0) {
142                 if (desc && desc->of_map_mode) {
143                         for (i = 0; i < len; i++) {
144                                 ret = of_property_read_u32_index(np,
145                                         "regulator-allowed-modes", i, &pval);
146                                 if (ret) {
147                                         pr_err("%s: couldn't read allowed modes index %d, ret=%d\n",
148                                                 np->name, i, ret);
149                                         break;
150                                 }
151                                 mode = desc->of_map_mode(pval);
152                                 if (mode == REGULATOR_MODE_INVALID)
153                                         pr_err("%s: invalid regulator-allowed-modes element %u\n",
154                                                 np->name, pval);
155                                 else
156                                         constraints->valid_modes_mask |= mode;
157                         }
158                         if (constraints->valid_modes_mask)
159                                 constraints->valid_ops_mask
160                                         |= REGULATOR_CHANGE_MODE;
161                 } else {
162                         pr_warn("%s: mode mapping not defined\n", np->name);
163                 }
164         }
165
166         if (!of_property_read_u32(np, "regulator-system-load", &pval))
167                 constraints->system_load = pval;
168
169         if (!of_property_read_u32(np, "regulator-coupled-max-spread",
170                                   &pval))
171                 constraints->max_spread = pval;
172
173         constraints->over_current_protection = of_property_read_bool(np,
174                                         "regulator-over-current-protection");
175
176         for (i = 0; i < ARRAY_SIZE(regulator_states); i++) {
177                 switch (i) {
178                 case PM_SUSPEND_MEM:
179                         suspend_state = &constraints->state_mem;
180                         break;
181                 case PM_SUSPEND_MAX:
182                         suspend_state = &constraints->state_disk;
183                         break;
184                 case PM_SUSPEND_ON:
185                 case PM_SUSPEND_TO_IDLE:
186                 case PM_SUSPEND_STANDBY:
187                 default:
188                         continue;
189                 }
190
191                 suspend_np = of_get_child_by_name(np, regulator_states[i]);
192                 if (!suspend_np || !suspend_state)
193                         continue;
194
195                 if (!of_property_read_u32(suspend_np, "regulator-mode",
196                                           &pval)) {
197                         if (desc && desc->of_map_mode) {
198                                 mode = desc->of_map_mode(pval);
199                                 if (mode == REGULATOR_MODE_INVALID)
200                                         pr_err("%s: invalid mode %u\n",
201                                                np->name, pval);
202                                 else
203                                         suspend_state->mode = mode;
204                         } else {
205                                 pr_warn("%s: mapping for mode %d not defined\n",
206                                         np->name, pval);
207                         }
208                 }
209
210                 if (of_property_read_bool(suspend_np,
211                                         "regulator-on-in-suspend"))
212                         suspend_state->enabled = ENABLE_IN_SUSPEND;
213                 else if (of_property_read_bool(suspend_np,
214                                         "regulator-off-in-suspend"))
215                         suspend_state->enabled = DISABLE_IN_SUSPEND;
216                 else
217                         suspend_state->enabled = DO_NOTHING_IN_SUSPEND;
218
219                 if (!of_property_read_u32(np, "regulator-suspend-min-microvolt",
220                                           &pval))
221                         suspend_state->min_uV = pval;
222
223                 if (!of_property_read_u32(np, "regulator-suspend-max-microvolt",
224                                           &pval))
225                         suspend_state->max_uV = pval;
226
227                 if (!of_property_read_u32(suspend_np,
228                                         "regulator-suspend-microvolt", &pval))
229                         suspend_state->uV = pval;
230                 else /* otherwise use min_uV as default suspend voltage */
231                         suspend_state->uV = suspend_state->min_uV;
232
233                 if (of_property_read_bool(suspend_np,
234                                         "regulator-changeable-in-suspend"))
235                         suspend_state->changeable = true;
236
237                 if (i == PM_SUSPEND_MEM)
238                         constraints->initial_state = PM_SUSPEND_MEM;
239
240                 of_node_put(suspend_np);
241                 suspend_state = NULL;
242                 suspend_np = NULL;
243         }
244 }
245
246 /**
247  * of_get_regulator_init_data - extract regulator_init_data structure info
248  * @dev: device requesting for regulator_init_data
249  * @node: regulator device node
250  * @desc: regulator description
251  *
252  * Populates regulator_init_data structure by extracting data from device
253  * tree node, returns a pointer to the populated struture or NULL if memory
254  * alloc fails.
255  */
256 struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
257                                           struct device_node *node,
258                                           const struct regulator_desc *desc)
259 {
260         struct regulator_init_data *init_data;
261
262         if (!node)
263                 return NULL;
264
265         init_data = devm_kzalloc(dev, sizeof(*init_data), GFP_KERNEL);
266         if (!init_data)
267                 return NULL; /* Out of memory? */
268
269         of_get_regulation_constraints(node, &init_data, desc);
270         return init_data;
271 }
272 EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
273
274 struct devm_of_regulator_matches {
275         struct of_regulator_match *matches;
276         unsigned int num_matches;
277 };
278
279 static void devm_of_regulator_put_matches(struct device *dev, void *res)
280 {
281         struct devm_of_regulator_matches *devm_matches = res;
282         int i;
283
284         for (i = 0; i < devm_matches->num_matches; i++)
285                 of_node_put(devm_matches->matches[i].of_node);
286 }
287
288 /**
289  * of_regulator_match - extract multiple regulator init data from device tree.
290  * @dev: device requesting the data
291  * @node: parent device node of the regulators
292  * @matches: match table for the regulators
293  * @num_matches: number of entries in match table
294  *
295  * This function uses a match table specified by the regulator driver to
296  * parse regulator init data from the device tree. @node is expected to
297  * contain a set of child nodes, each providing the init data for one
298  * regulator. The data parsed from a child node will be matched to a regulator
299  * based on either the deprecated property regulator-compatible if present,
300  * or otherwise the child node's name. Note that the match table is modified
301  * in place and an additional of_node reference is taken for each matched
302  * regulator.
303  *
304  * Returns the number of matches found or a negative error code on failure.
305  */
306 int of_regulator_match(struct device *dev, struct device_node *node,
307                        struct of_regulator_match *matches,
308                        unsigned int num_matches)
309 {
310         unsigned int count = 0;
311         unsigned int i;
312         const char *name;
313         struct device_node *child;
314         struct devm_of_regulator_matches *devm_matches;
315
316         if (!dev || !node)
317                 return -EINVAL;
318
319         devm_matches = devres_alloc(devm_of_regulator_put_matches,
320                                     sizeof(struct devm_of_regulator_matches),
321                                     GFP_KERNEL);
322         if (!devm_matches)
323                 return -ENOMEM;
324
325         devm_matches->matches = matches;
326         devm_matches->num_matches = num_matches;
327
328         devres_add(dev, devm_matches);
329
330         for (i = 0; i < num_matches; i++) {
331                 struct of_regulator_match *match = &matches[i];
332                 match->init_data = NULL;
333                 match->of_node = NULL;
334         }
335
336         for_each_child_of_node(node, child) {
337                 name = of_get_property(child,
338                                         "regulator-compatible", NULL);
339                 if (!name)
340                         name = child->name;
341                 for (i = 0; i < num_matches; i++) {
342                         struct of_regulator_match *match = &matches[i];
343                         if (match->of_node)
344                                 continue;
345
346                         if (strcmp(match->name, name))
347                                 continue;
348
349                         match->init_data =
350                                 of_get_regulator_init_data(dev, child,
351                                                            match->desc);
352                         if (!match->init_data) {
353                                 dev_err(dev,
354                                         "failed to parse DT for regulator %s\n",
355                                         child->name);
356                                 of_node_put(child);
357                                 return -EINVAL;
358                         }
359                         match->of_node = of_node_get(child);
360                         count++;
361                         break;
362                 }
363         }
364
365         return count;
366 }
367 EXPORT_SYMBOL_GPL(of_regulator_match);
368
369 struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
370                                             const struct regulator_desc *desc,
371                                             struct regulator_config *config,
372                                             struct device_node **node)
373 {
374         struct device_node *search, *child;
375         struct regulator_init_data *init_data = NULL;
376         const char *name;
377
378         if (!dev->of_node || !desc->of_match)
379                 return NULL;
380
381         if (desc->regulators_node)
382                 search = of_get_child_by_name(dev->of_node,
383                                               desc->regulators_node);
384         else
385                 search = of_node_get(dev->of_node);
386
387         if (!search) {
388                 dev_dbg(dev, "Failed to find regulator container node '%s'\n",
389                         desc->regulators_node);
390                 return NULL;
391         }
392
393         for_each_available_child_of_node(search, child) {
394                 name = of_get_property(child, "regulator-compatible", NULL);
395                 if (!name)
396                         name = child->name;
397
398                 if (strcmp(desc->of_match, name))
399                         continue;
400
401                 init_data = of_get_regulator_init_data(dev, child, desc);
402                 if (!init_data) {
403                         dev_err(dev,
404                                 "failed to parse DT for regulator %s\n",
405                                 child->name);
406                         break;
407                 }
408
409                 if (desc->of_parse_cb) {
410                         if (desc->of_parse_cb(child, desc, config)) {
411                                 dev_err(dev,
412                                         "driver callback failed to parse DT for regulator %s\n",
413                                         child->name);
414                                 init_data = NULL;
415                                 break;
416                         }
417                 }
418
419                 of_node_get(child);
420                 *node = child;
421                 break;
422         }
423
424         of_node_put(search);
425
426         return init_data;
427 }
428
429 static int of_node_match(struct device *dev, const void *data)
430 {
431         return dev->of_node == data;
432 }
433
434 struct regulator_dev *of_find_regulator_by_node(struct device_node *np)
435 {
436         struct device *dev;
437
438         dev = class_find_device(&regulator_class, NULL, np, of_node_match);
439
440         return dev ? dev_to_rdev(dev) : NULL;
441 }
442
443 /*
444  * Returns number of regulators coupled with rdev.
445  */
446 int of_get_n_coupled(struct regulator_dev *rdev)
447 {
448         struct device_node *node = rdev->dev.of_node;
449         int n_phandles;
450
451         n_phandles = of_count_phandle_with_args(node,
452                                                 "regulator-coupled-with",
453                                                 NULL);
454
455         return (n_phandles > 0) ? n_phandles : 0;
456 }
457
458 /* Looks for "to_find" device_node in src's "regulator-coupled-with" property */
459 static bool of_coupling_find_node(struct device_node *src,
460                                   struct device_node *to_find)
461 {
462         int n_phandles, i;
463         bool found = false;
464
465         n_phandles = of_count_phandle_with_args(src,
466                                                 "regulator-coupled-with",
467                                                 NULL);
468
469         for (i = 0; i < n_phandles; i++) {
470                 struct device_node *tmp = of_parse_phandle(src,
471                                            "regulator-coupled-with", i);
472
473                 if (!tmp)
474                         break;
475
476                 /* found */
477                 if (tmp == to_find)
478                         found = true;
479
480                 of_node_put(tmp);
481
482                 if (found)
483                         break;
484         }
485
486         return found;
487 }
488
489 /**
490  * of_check_coupling_data - Parse rdev's coupling properties and check data
491  *                          consistency
492  * @rdev - pointer to regulator_dev whose data is checked
493  *
494  * Function checks if all the following conditions are met:
495  * - rdev's max_spread is greater than 0
496  * - all coupled regulators have the same max_spread
497  * - all coupled regulators have the same number of regulator_dev phandles
498  * - all regulators are linked to each other
499  *
500  * Returns true if all conditions are met.
501  */
502 bool of_check_coupling_data(struct regulator_dev *rdev)
503 {
504         int max_spread = rdev->constraints->max_spread;
505         struct device_node *node = rdev->dev.of_node;
506         int n_phandles = of_get_n_coupled(rdev);
507         struct device_node *c_node;
508         int i;
509         bool ret = true;
510
511         if (max_spread <= 0) {
512                 dev_err(&rdev->dev, "max_spread value invalid\n");
513                 return false;
514         }
515
516         /* iterate over rdev's phandles */
517         for (i = 0; i < n_phandles; i++) {
518                 int c_max_spread, c_n_phandles;
519
520                 c_node = of_parse_phandle(node,
521                                           "regulator-coupled-with", i);
522
523                 if (!c_node)
524                         ret = false;
525
526                 c_n_phandles = of_count_phandle_with_args(c_node,
527                                                           "regulator-coupled-with",
528                                                           NULL);
529
530                 if (c_n_phandles != n_phandles) {
531                         dev_err(&rdev->dev, "number of couped reg phandles mismatch\n");
532                         ret = false;
533                         goto clean;
534                 }
535
536                 if (of_property_read_u32(c_node, "regulator-coupled-max-spread",
537                                          &c_max_spread)) {
538                         ret = false;
539                         goto clean;
540                 }
541
542                 if (c_max_spread != max_spread) {
543                         dev_err(&rdev->dev,
544                                 "coupled regulators max_spread mismatch\n");
545                         ret = false;
546                         goto clean;
547                 }
548
549                 if (!of_coupling_find_node(c_node, node)) {
550                         dev_err(&rdev->dev, "missing 2-way linking for coupled regulators\n");
551                         ret = false;
552                 }
553
554 clean:
555                 of_node_put(c_node);
556                 if (!ret)
557                         break;
558         }
559
560         return ret;
561 }
562
563 /**
564  * of_parse_coupled regulator - Get regulator_dev pointer from rdev's property
565  * @rdev: Pointer to regulator_dev, whose DTS is used as a source to parse
566  *        "regulator-coupled-with" property
567  * @index: Index in phandles array
568  *
569  * Returns the regulator_dev pointer parsed from DTS. If it has not been yet
570  * registered, returns NULL
571  */
572 struct regulator_dev *of_parse_coupled_regulator(struct regulator_dev *rdev,
573                                                  int index)
574 {
575         struct device_node *node = rdev->dev.of_node;
576         struct device_node *c_node;
577         struct regulator_dev *c_rdev;
578
579         c_node = of_parse_phandle(node, "regulator-coupled-with", index);
580         if (!c_node)
581                 return NULL;
582
583         c_rdev = of_find_regulator_by_node(c_node);
584
585         of_node_put(c_node);
586
587         return c_rdev;
588 }