1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * Copyright 2008 Wolfson Microelectronics PLC.
7 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
9 * Copyright (c) 2009 Nokia Corporation
10 * Roger Quadros <ext-roger.quadros@nokia.com>
12 * This is useful for systems with mixed controllable and
13 * non-controllable regulators, as well as for allowing testing on
14 * systems with no controllable regulators.
17 #include <linux/err.h>
18 #include <linux/mutex.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/pm_domain.h>
22 #include <linux/pm_opp.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/fixed.h>
25 #include <linux/gpio/consumer.h>
26 #include <linux/slab.h>
28 #include <linux/of_device.h>
29 #include <linux/regulator/of_regulator.h>
30 #include <linux/regulator/machine.h>
31 #include <linux/clk.h>
34 struct fixed_voltage_data
{
35 struct regulator_desc desc
;
36 struct regulator_dev
*dev
;
38 struct clk
*enable_clock
;
39 unsigned int enable_counter
;
40 int performance_state
;
43 struct fixed_dev_type
{
44 bool has_enable_clock
;
45 bool has_performance_state
;
48 static int reg_clock_enable(struct regulator_dev
*rdev
)
50 struct fixed_voltage_data
*priv
= rdev_get_drvdata(rdev
);
53 ret
= clk_prepare_enable(priv
->enable_clock
);
57 priv
->enable_counter
++;
62 static int reg_clock_disable(struct regulator_dev
*rdev
)
64 struct fixed_voltage_data
*priv
= rdev_get_drvdata(rdev
);
66 clk_disable_unprepare(priv
->enable_clock
);
67 priv
->enable_counter
--;
72 static int reg_domain_enable(struct regulator_dev
*rdev
)
74 struct fixed_voltage_data
*priv
= rdev_get_drvdata(rdev
);
75 struct device
*dev
= rdev
->dev
.parent
;
78 ret
= dev_pm_genpd_set_performance_state(dev
, priv
->performance_state
);
82 priv
->enable_counter
++;
87 static int reg_domain_disable(struct regulator_dev
*rdev
)
89 struct fixed_voltage_data
*priv
= rdev_get_drvdata(rdev
);
90 struct device
*dev
= rdev
->dev
.parent
;
93 ret
= dev_pm_genpd_set_performance_state(dev
, 0);
97 priv
->enable_counter
--;
102 static int reg_is_enabled(struct regulator_dev
*rdev
)
104 struct fixed_voltage_data
*priv
= rdev_get_drvdata(rdev
);
106 return priv
->enable_counter
> 0;
111 * of_get_fixed_voltage_config - extract fixed_voltage_config structure info
112 * @dev: device requesting for fixed_voltage_config
113 * @desc: regulator description
115 * Populates fixed_voltage_config structure by extracting data from device
116 * tree node, returns a pointer to the populated structure of NULL if memory
119 static struct fixed_voltage_config
*
120 of_get_fixed_voltage_config(struct device
*dev
,
121 const struct regulator_desc
*desc
)
123 struct fixed_voltage_config
*config
;
124 struct device_node
*np
= dev
->of_node
;
125 struct regulator_init_data
*init_data
;
127 config
= devm_kzalloc(dev
, sizeof(struct fixed_voltage_config
),
130 return ERR_PTR(-ENOMEM
);
132 config
->init_data
= of_get_regulator_init_data(dev
, dev
->of_node
, desc
);
133 if (!config
->init_data
)
134 return ERR_PTR(-EINVAL
);
136 init_data
= config
->init_data
;
137 init_data
->constraints
.apply_uV
= 0;
139 config
->supply_name
= init_data
->constraints
.name
;
140 if (init_data
->constraints
.min_uV
== init_data
->constraints
.max_uV
) {
141 config
->microvolts
= init_data
->constraints
.min_uV
;
144 "Fixed regulator specified with variable voltages\n");
145 return ERR_PTR(-EINVAL
);
148 if (init_data
->constraints
.boot_on
)
149 config
->enabled_at_boot
= true;
151 of_property_read_u32(np
, "startup-delay-us", &config
->startup_delay
);
152 of_property_read_u32(np
, "off-on-delay-us", &config
->off_on_delay
);
154 if (of_find_property(np
, "vin-supply", NULL
))
155 config
->input_supply
= "vin";
160 static const struct regulator_ops fixed_voltage_ops
= {
163 static const struct regulator_ops fixed_voltage_clkenabled_ops
= {
164 .enable
= reg_clock_enable
,
165 .disable
= reg_clock_disable
,
166 .is_enabled
= reg_is_enabled
,
169 static const struct regulator_ops fixed_voltage_domain_ops
= {
170 .enable
= reg_domain_enable
,
171 .disable
= reg_domain_disable
,
172 .is_enabled
= reg_is_enabled
,
175 static int reg_fixed_voltage_probe(struct platform_device
*pdev
)
177 struct device
*dev
= &pdev
->dev
;
178 struct fixed_voltage_config
*config
;
179 struct fixed_voltage_data
*drvdata
;
180 const struct fixed_dev_type
*drvtype
= of_device_get_match_data(dev
);
181 struct regulator_config cfg
= { };
182 enum gpiod_flags gflags
;
185 drvdata
= devm_kzalloc(&pdev
->dev
, sizeof(struct fixed_voltage_data
),
190 if (pdev
->dev
.of_node
) {
191 config
= of_get_fixed_voltage_config(&pdev
->dev
,
194 return PTR_ERR(config
);
196 config
= dev_get_platdata(&pdev
->dev
);
202 drvdata
->desc
.name
= devm_kstrdup(&pdev
->dev
,
205 if (drvdata
->desc
.name
== NULL
) {
206 dev_err(&pdev
->dev
, "Failed to allocate supply name\n");
209 drvdata
->desc
.type
= REGULATOR_VOLTAGE
;
210 drvdata
->desc
.owner
= THIS_MODULE
;
212 if (drvtype
&& drvtype
->has_enable_clock
) {
213 drvdata
->desc
.ops
= &fixed_voltage_clkenabled_ops
;
215 drvdata
->enable_clock
= devm_clk_get(dev
, NULL
);
216 if (IS_ERR(drvdata
->enable_clock
)) {
217 dev_err(dev
, "Can't get enable-clock from devicetree\n");
220 } else if (drvtype
&& drvtype
->has_performance_state
) {
221 drvdata
->desc
.ops
= &fixed_voltage_domain_ops
;
223 drvdata
->performance_state
= of_get_required_opp_performance_state(dev
->of_node
, 0);
224 if (drvdata
->performance_state
< 0) {
225 dev_err(dev
, "Can't get performance state from devicetree\n");
226 return drvdata
->performance_state
;
229 drvdata
->desc
.ops
= &fixed_voltage_ops
;
232 drvdata
->desc
.enable_time
= config
->startup_delay
;
233 drvdata
->desc
.off_on_delay
= config
->off_on_delay
;
235 if (config
->input_supply
) {
236 drvdata
->desc
.supply_name
= devm_kstrdup(&pdev
->dev
,
237 config
->input_supply
,
239 if (!drvdata
->desc
.supply_name
) {
241 "Failed to allocate input supply\n");
246 if (config
->microvolts
)
247 drvdata
->desc
.n_voltages
= 1;
249 drvdata
->desc
.fixed_uV
= config
->microvolts
;
252 * The signal will be inverted by the GPIO core if flagged so in the
255 if (config
->enabled_at_boot
)
256 gflags
= GPIOD_OUT_HIGH
;
258 gflags
= GPIOD_OUT_LOW
;
261 * Some fixed regulators share the enable line between two
262 * regulators which makes it necessary to get a handle on the
263 * same descriptor for two different consumers. This will get
264 * the GPIO descriptor, but only the first call will initialize
265 * it so any flags such as inversion or open drain will only
266 * be set up by the first caller and assumed identical on the
269 * FIXME: find a better way to deal with this.
271 gflags
|= GPIOD_FLAGS_BIT_NONEXCLUSIVE
;
274 * Do not use devm* here: the regulator core takes over the
275 * lifecycle management of the GPIO descriptor.
277 cfg
.ena_gpiod
= gpiod_get_optional(&pdev
->dev
, NULL
, gflags
);
278 if (IS_ERR(cfg
.ena_gpiod
))
279 return dev_err_probe(&pdev
->dev
, PTR_ERR(cfg
.ena_gpiod
),
282 cfg
.dev
= &pdev
->dev
;
283 cfg
.init_data
= config
->init_data
;
284 cfg
.driver_data
= drvdata
;
285 cfg
.of_node
= pdev
->dev
.of_node
;
287 drvdata
->dev
= devm_regulator_register(&pdev
->dev
, &drvdata
->desc
,
289 if (IS_ERR(drvdata
->dev
)) {
290 ret
= dev_err_probe(&pdev
->dev
, PTR_ERR(drvdata
->dev
),
291 "Failed to register regulator: %ld\n",
292 PTR_ERR(drvdata
->dev
));
296 platform_set_drvdata(pdev
, drvdata
);
298 dev_dbg(&pdev
->dev
, "%s supplying %duV\n", drvdata
->desc
.name
,
299 drvdata
->desc
.fixed_uV
);
304 #if defined(CONFIG_OF)
305 static const struct fixed_dev_type fixed_voltage_data
= {
306 .has_enable_clock
= false,
309 static const struct fixed_dev_type fixed_clkenable_data
= {
310 .has_enable_clock
= true,
313 static const struct fixed_dev_type fixed_domain_data
= {
314 .has_performance_state
= true,
317 static const struct of_device_id fixed_of_match
[] = {
319 .compatible
= "regulator-fixed",
320 .data
= &fixed_voltage_data
,
323 .compatible
= "regulator-fixed-clock",
324 .data
= &fixed_clkenable_data
,
327 .compatible
= "regulator-fixed-domain",
328 .data
= &fixed_domain_data
,
333 MODULE_DEVICE_TABLE(of
, fixed_of_match
);
336 static struct platform_driver regulator_fixed_voltage_driver
= {
337 .probe
= reg_fixed_voltage_probe
,
339 .name
= "reg-fixed-voltage",
340 .of_match_table
= of_match_ptr(fixed_of_match
),
344 static int __init
regulator_fixed_voltage_init(void)
346 return platform_driver_register(®ulator_fixed_voltage_driver
);
348 subsys_initcall(regulator_fixed_voltage_init
);
350 static void __exit
regulator_fixed_voltage_exit(void)
352 platform_driver_unregister(®ulator_fixed_voltage_driver
);
354 module_exit(regulator_fixed_voltage_exit
);
356 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
357 MODULE_DESCRIPTION("Fixed voltage regulator");
358 MODULE_LICENSE("GPL");
359 MODULE_ALIAS("platform:reg-fixed-voltage");