4 * Copyright 2008 Wolfson Microelectronics PLC.
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8 * Copyright (c) 2009 Nokia Corporation
9 * Roger Quadros <ext-roger.quadros@nokia.com>
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of the
14 * License, or (at your option) any later version.
16 * This is useful for systems with mixed controllable and
17 * non-controllable regulators, as well as for allowing testing on
18 * systems with no controllable regulators.
21 #include <linux/err.h>
22 #include <linux/mutex.h>
23 #include <linux/module.h>
24 #include <linux/platform_device.h>
25 #include <linux/regulator/driver.h>
26 #include <linux/regulator/fixed.h>
27 #include <linux/gpio.h>
28 #include <linux/slab.h>
30 #include <linux/of_gpio.h>
31 #include <linux/regulator/of_regulator.h>
32 #include <linux/regulator/machine.h>
34 struct fixed_voltage_data
{
35 struct regulator_desc desc
;
36 struct regulator_dev
*dev
;
39 unsigned startup_delay
;
46 * of_get_fixed_voltage_config - extract fixed_voltage_config structure info
47 * @dev: device requesting for fixed_voltage_config
49 * Populates fixed_voltage_config structure by extracting data from device
50 * tree node, returns a pointer to the populated structure of NULL if memory
53 static struct fixed_voltage_config
*
54 of_get_fixed_voltage_config(struct device
*dev
)
56 struct fixed_voltage_config
*config
;
57 struct device_node
*np
= dev
->of_node
;
59 struct regulator_init_data
*init_data
;
61 config
= devm_kzalloc(dev
, sizeof(struct fixed_voltage_config
),
66 config
->init_data
= of_get_regulator_init_data(dev
, dev
->of_node
);
67 if (!config
->init_data
)
70 init_data
= config
->init_data
;
71 init_data
->constraints
.apply_uV
= 0;
73 config
->supply_name
= init_data
->constraints
.name
;
74 if (init_data
->constraints
.min_uV
== init_data
->constraints
.max_uV
) {
75 config
->microvolts
= init_data
->constraints
.min_uV
;
78 "Fixed regulator specified with variable voltages\n");
82 if (init_data
->constraints
.boot_on
)
83 config
->enabled_at_boot
= true;
85 config
->gpio
= of_get_named_gpio(np
, "gpio", 0);
86 delay
= of_get_property(np
, "startup-delay-us", NULL
);
88 config
->startup_delay
= be32_to_cpu(*delay
);
90 if (of_find_property(np
, "enable-active-high", NULL
))
91 config
->enable_high
= true;
93 if (of_find_property(np
, "gpio-open-drain", NULL
))
94 config
->gpio_is_open_drain
= true;
99 static int fixed_voltage_is_enabled(struct regulator_dev
*dev
)
101 struct fixed_voltage_data
*data
= rdev_get_drvdata(dev
);
103 return data
->is_enabled
;
106 static int fixed_voltage_enable(struct regulator_dev
*dev
)
108 struct fixed_voltage_data
*data
= rdev_get_drvdata(dev
);
110 gpio_set_value_cansleep(data
->gpio
, data
->enable_high
);
111 data
->is_enabled
= true;
116 static int fixed_voltage_disable(struct regulator_dev
*dev
)
118 struct fixed_voltage_data
*data
= rdev_get_drvdata(dev
);
120 gpio_set_value_cansleep(data
->gpio
, !data
->enable_high
);
121 data
->is_enabled
= false;
126 static int fixed_voltage_enable_time(struct regulator_dev
*dev
)
128 struct fixed_voltage_data
*data
= rdev_get_drvdata(dev
);
130 return data
->startup_delay
;
133 static int fixed_voltage_get_voltage(struct regulator_dev
*dev
)
135 struct fixed_voltage_data
*data
= rdev_get_drvdata(dev
);
137 if (data
->microvolts
)
138 return data
->microvolts
;
143 static int fixed_voltage_list_voltage(struct regulator_dev
*dev
,
146 struct fixed_voltage_data
*data
= rdev_get_drvdata(dev
);
151 return data
->microvolts
;
154 static struct regulator_ops fixed_voltage_gpio_ops
= {
155 .is_enabled
= fixed_voltage_is_enabled
,
156 .enable
= fixed_voltage_enable
,
157 .disable
= fixed_voltage_disable
,
158 .enable_time
= fixed_voltage_enable_time
,
159 .get_voltage
= fixed_voltage_get_voltage
,
160 .list_voltage
= fixed_voltage_list_voltage
,
163 static struct regulator_ops fixed_voltage_ops
= {
164 .get_voltage
= fixed_voltage_get_voltage
,
165 .list_voltage
= fixed_voltage_list_voltage
,
168 static int __devinit
reg_fixed_voltage_probe(struct platform_device
*pdev
)
170 struct fixed_voltage_config
*config
;
171 struct fixed_voltage_data
*drvdata
;
172 struct regulator_config cfg
= { };
175 if (pdev
->dev
.of_node
)
176 config
= of_get_fixed_voltage_config(&pdev
->dev
);
178 config
= pdev
->dev
.platform_data
;
183 drvdata
= devm_kzalloc(&pdev
->dev
, sizeof(struct fixed_voltage_data
),
185 if (drvdata
== NULL
) {
186 dev_err(&pdev
->dev
, "Failed to allocate device data\n");
191 drvdata
->desc
.name
= kstrdup(config
->supply_name
, GFP_KERNEL
);
192 if (drvdata
->desc
.name
== NULL
) {
193 dev_err(&pdev
->dev
, "Failed to allocate supply name\n");
197 drvdata
->desc
.type
= REGULATOR_VOLTAGE
;
198 drvdata
->desc
.owner
= THIS_MODULE
;
200 if (config
->microvolts
)
201 drvdata
->desc
.n_voltages
= 1;
203 drvdata
->microvolts
= config
->microvolts
;
204 drvdata
->gpio
= config
->gpio
;
205 drvdata
->startup_delay
= config
->startup_delay
;
207 if (gpio_is_valid(config
->gpio
)) {
209 drvdata
->enable_high
= config
->enable_high
;
211 /* FIXME: Remove below print warning
213 * config->gpio must be set to -EINVAL by platform code if
214 * GPIO control is not required. However, early adopters
215 * not requiring GPIO control may forget to initialize
216 * config->gpio to -EINVAL. This will cause GPIO 0 to be used
219 * This warning will be removed once there are a couple of users
224 "using GPIO 0 for regulator enable control\n");
227 * set output direction without changing state
230 drvdata
->is_enabled
= config
->enabled_at_boot
;
231 ret
= drvdata
->is_enabled
?
232 config
->enable_high
: !config
->enable_high
;
233 gpio_flag
= ret
? GPIOF_OUT_INIT_HIGH
: GPIOF_OUT_INIT_LOW
;
235 if (config
->gpio_is_open_drain
)
236 gpio_flag
|= GPIOF_OPEN_DRAIN
;
238 ret
= gpio_request_one(config
->gpio
, gpio_flag
,
239 config
->supply_name
);
242 "Could not obtain regulator enable GPIO %d: %d\n",
247 drvdata
->desc
.ops
= &fixed_voltage_gpio_ops
;
250 drvdata
->desc
.ops
= &fixed_voltage_ops
;
253 cfg
.dev
= &pdev
->dev
;
254 cfg
.init_data
= config
->init_data
;
255 cfg
.driver_data
= drvdata
;
256 cfg
.of_node
= pdev
->dev
.of_node
;
258 drvdata
->dev
= regulator_register(&drvdata
->desc
, &cfg
);
259 if (IS_ERR(drvdata
->dev
)) {
260 ret
= PTR_ERR(drvdata
->dev
);
261 dev_err(&pdev
->dev
, "Failed to register regulator: %d\n", ret
);
265 platform_set_drvdata(pdev
, drvdata
);
267 dev_dbg(&pdev
->dev
, "%s supplying %duV\n", drvdata
->desc
.name
,
268 drvdata
->microvolts
);
273 if (gpio_is_valid(config
->gpio
))
274 gpio_free(config
->gpio
);
276 kfree(drvdata
->desc
.name
);
281 static int __devexit
reg_fixed_voltage_remove(struct platform_device
*pdev
)
283 struct fixed_voltage_data
*drvdata
= platform_get_drvdata(pdev
);
285 regulator_unregister(drvdata
->dev
);
286 if (gpio_is_valid(drvdata
->gpio
))
287 gpio_free(drvdata
->gpio
);
288 kfree(drvdata
->desc
.name
);
293 #if defined(CONFIG_OF)
294 static const struct of_device_id fixed_of_match
[] __devinitconst
= {
295 { .compatible
= "regulator-fixed", },
298 MODULE_DEVICE_TABLE(of
, fixed_of_match
);
300 #define fixed_of_match NULL
303 static struct platform_driver regulator_fixed_voltage_driver
= {
304 .probe
= reg_fixed_voltage_probe
,
305 .remove
= __devexit_p(reg_fixed_voltage_remove
),
307 .name
= "reg-fixed-voltage",
308 .owner
= THIS_MODULE
,
309 .of_match_table
= fixed_of_match
,
313 static int __init
regulator_fixed_voltage_init(void)
315 return platform_driver_register(®ulator_fixed_voltage_driver
);
317 subsys_initcall(regulator_fixed_voltage_init
);
319 static void __exit
regulator_fixed_voltage_exit(void)
321 platform_driver_unregister(®ulator_fixed_voltage_driver
);
323 module_exit(regulator_fixed_voltage_exit
);
325 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
326 MODULE_DESCRIPTION("Fixed voltage regulator");
327 MODULE_LICENSE("GPL");
328 MODULE_ALIAS("platform:reg-fixed-voltage");