regulator: fixed: Set enable enable_time in regulator_desc
[linux-3.10.git] / drivers / regulator / fixed.c
1 /*
2  * fixed.c
3  *
4  * Copyright 2008 Wolfson Microelectronics PLC.
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  * Copyright (c) 2009 Nokia Corporation
9  * Roger Quadros <ext-roger.quadros@nokia.com>
10  *
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.
15  *
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.
19  */
20
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>
29 #include <linux/of.h>
30 #include <linux/of_gpio.h>
31 #include <linux/regulator/of_regulator.h>
32 #include <linux/regulator/machine.h>
33
34 struct fixed_voltage_data {
35         struct regulator_desc desc;
36         struct regulator_dev *dev;
37         int microvolts;
38         int gpio;
39         bool enable_high;
40         bool is_enabled;
41 };
42
43
44 /**
45  * of_get_fixed_voltage_config - extract fixed_voltage_config structure info
46  * @dev: device requesting for fixed_voltage_config
47  *
48  * Populates fixed_voltage_config structure by extracting data from device
49  * tree node, returns a pointer to the populated structure of NULL if memory
50  * alloc fails.
51  */
52 static struct fixed_voltage_config *
53 of_get_fixed_voltage_config(struct device *dev)
54 {
55         struct fixed_voltage_config *config;
56         struct device_node *np = dev->of_node;
57         const __be32 *delay;
58         struct regulator_init_data *init_data;
59
60         config = devm_kzalloc(dev, sizeof(struct fixed_voltage_config),
61                                                                  GFP_KERNEL);
62         if (!config)
63                 return ERR_PTR(-ENOMEM);
64
65         config->init_data = of_get_regulator_init_data(dev, dev->of_node);
66         if (!config->init_data)
67                 return ERR_PTR(-EINVAL);
68
69         init_data = config->init_data;
70         init_data->constraints.apply_uV = 0;
71
72         config->supply_name = init_data->constraints.name;
73         if (init_data->constraints.min_uV == init_data->constraints.max_uV) {
74                 config->microvolts = init_data->constraints.min_uV;
75         } else {
76                 dev_err(dev,
77                          "Fixed regulator specified with variable voltages\n");
78                 return ERR_PTR(-EINVAL);
79         }
80
81         if (init_data->constraints.boot_on)
82                 config->enabled_at_boot = true;
83
84         config->gpio = of_get_named_gpio(np, "gpio", 0);
85         /*
86          * of_get_named_gpio() currently returns ENODEV rather than
87          * EPROBE_DEFER. This code attempts to be compatible with both
88          * for now; the ENODEV check can be removed once the API is fixed.
89          * of_get_named_gpio() doesn't differentiate between a missing
90          * property (which would be fine here, since the GPIO is optional)
91          * and some other error. Patches have been posted for both issues.
92          * Once they are check in, we should replace this with:
93          * if (config->gpio < 0 && config->gpio != -ENOENT)
94          */
95         if ((config->gpio == -ENODEV) || (config->gpio == -EPROBE_DEFER))
96                 return ERR_PTR(-EPROBE_DEFER);
97
98         delay = of_get_property(np, "startup-delay-us", NULL);
99         if (delay)
100                 config->startup_delay = be32_to_cpu(*delay);
101
102         if (of_find_property(np, "enable-active-high", NULL))
103                 config->enable_high = true;
104
105         if (of_find_property(np, "gpio-open-drain", NULL))
106                 config->gpio_is_open_drain = true;
107
108         return config;
109 }
110
111 static int fixed_voltage_is_enabled(struct regulator_dev *dev)
112 {
113         struct fixed_voltage_data *data = rdev_get_drvdata(dev);
114
115         return data->is_enabled;
116 }
117
118 static int fixed_voltage_enable(struct regulator_dev *dev)
119 {
120         struct fixed_voltage_data *data = rdev_get_drvdata(dev);
121
122         gpio_set_value_cansleep(data->gpio, data->enable_high);
123         data->is_enabled = true;
124
125         return 0;
126 }
127
128 static int fixed_voltage_disable(struct regulator_dev *dev)
129 {
130         struct fixed_voltage_data *data = rdev_get_drvdata(dev);
131
132         gpio_set_value_cansleep(data->gpio, !data->enable_high);
133         data->is_enabled = false;
134
135         return 0;
136 }
137
138 static int fixed_voltage_get_voltage(struct regulator_dev *dev)
139 {
140         struct fixed_voltage_data *data = rdev_get_drvdata(dev);
141
142         if (data->microvolts)
143                 return data->microvolts;
144         else
145                 return -EINVAL;
146 }
147
148 static int fixed_voltage_list_voltage(struct regulator_dev *dev,
149                                       unsigned selector)
150 {
151         struct fixed_voltage_data *data = rdev_get_drvdata(dev);
152
153         if (selector != 0)
154                 return -EINVAL;
155
156         return data->microvolts;
157 }
158
159 static struct regulator_ops fixed_voltage_gpio_ops = {
160         .is_enabled = fixed_voltage_is_enabled,
161         .enable = fixed_voltage_enable,
162         .disable = fixed_voltage_disable,
163         .get_voltage = fixed_voltage_get_voltage,
164         .list_voltage = fixed_voltage_list_voltage,
165 };
166
167 static struct regulator_ops fixed_voltage_ops = {
168         .get_voltage = fixed_voltage_get_voltage,
169         .list_voltage = fixed_voltage_list_voltage,
170 };
171
172 static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
173 {
174         struct fixed_voltage_config *config;
175         struct fixed_voltage_data *drvdata;
176         struct regulator_config cfg = { };
177         int ret;
178
179         if (pdev->dev.of_node) {
180                 config = of_get_fixed_voltage_config(&pdev->dev);
181                 if (IS_ERR(config))
182                         return PTR_ERR(config);
183         } else {
184                 config = pdev->dev.platform_data;
185         }
186
187         if (!config)
188                 return -ENOMEM;
189
190         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data),
191                                GFP_KERNEL);
192         if (drvdata == NULL) {
193                 dev_err(&pdev->dev, "Failed to allocate device data\n");
194                 ret = -ENOMEM;
195                 goto err;
196         }
197
198         drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL);
199         if (drvdata->desc.name == NULL) {
200                 dev_err(&pdev->dev, "Failed to allocate supply name\n");
201                 ret = -ENOMEM;
202                 goto err;
203         }
204         drvdata->desc.type = REGULATOR_VOLTAGE;
205         drvdata->desc.owner = THIS_MODULE;
206
207         drvdata->desc.enable_time = config->startup_delay;
208
209         if (config->microvolts)
210                 drvdata->desc.n_voltages = 1;
211
212         drvdata->microvolts = config->microvolts;
213         drvdata->gpio = config->gpio;
214
215         if (gpio_is_valid(config->gpio)) {
216                 int gpio_flag;
217                 drvdata->enable_high = config->enable_high;
218
219                 /* FIXME: Remove below print warning
220                  *
221                  * config->gpio must be set to -EINVAL by platform code if
222                  * GPIO control is not required. However, early adopters
223                  * not requiring GPIO control may forget to initialize
224                  * config->gpio to -EINVAL. This will cause GPIO 0 to be used
225                  * for GPIO control.
226                  *
227                  * This warning will be removed once there are a couple of users
228                  * for this driver.
229                  */
230                 if (!config->gpio)
231                         dev_warn(&pdev->dev,
232                                 "using GPIO 0 for regulator enable control\n");
233
234                 /*
235                  * set output direction without changing state
236                  * to prevent glitch
237                  */
238                 drvdata->is_enabled = config->enabled_at_boot;
239                 ret = drvdata->is_enabled ?
240                                 config->enable_high : !config->enable_high;
241                 gpio_flag = ret ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
242
243                 if (config->gpio_is_open_drain)
244                         gpio_flag |= GPIOF_OPEN_DRAIN;
245
246                 ret = gpio_request_one(config->gpio, gpio_flag,
247                                                 config->supply_name);
248                 if (ret) {
249                         dev_err(&pdev->dev,
250                            "Could not obtain regulator enable GPIO %d: %d\n",
251                                                         config->gpio, ret);
252                         goto err_name;
253                 }
254
255                 drvdata->desc.ops = &fixed_voltage_gpio_ops;
256
257         } else {
258                 drvdata->desc.ops = &fixed_voltage_ops;
259         }
260
261         cfg.dev = &pdev->dev;
262         cfg.init_data = config->init_data;
263         cfg.driver_data = drvdata;
264         cfg.of_node = pdev->dev.of_node;
265
266         drvdata->dev = regulator_register(&drvdata->desc, &cfg);
267         if (IS_ERR(drvdata->dev)) {
268                 ret = PTR_ERR(drvdata->dev);
269                 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
270                 goto err_gpio;
271         }
272
273         platform_set_drvdata(pdev, drvdata);
274
275         dev_dbg(&pdev->dev, "%s supplying %duV\n", drvdata->desc.name,
276                 drvdata->microvolts);
277
278         return 0;
279
280 err_gpio:
281         if (gpio_is_valid(config->gpio))
282                 gpio_free(config->gpio);
283 err_name:
284         kfree(drvdata->desc.name);
285 err:
286         return ret;
287 }
288
289 static int __devexit reg_fixed_voltage_remove(struct platform_device *pdev)
290 {
291         struct fixed_voltage_data *drvdata = platform_get_drvdata(pdev);
292
293         regulator_unregister(drvdata->dev);
294         if (gpio_is_valid(drvdata->gpio))
295                 gpio_free(drvdata->gpio);
296         kfree(drvdata->desc.name);
297
298         return 0;
299 }
300
301 #if defined(CONFIG_OF)
302 static const struct of_device_id fixed_of_match[] __devinitconst = {
303         { .compatible = "regulator-fixed", },
304         {},
305 };
306 MODULE_DEVICE_TABLE(of, fixed_of_match);
307 #endif
308
309 static struct platform_driver regulator_fixed_voltage_driver = {
310         .probe          = reg_fixed_voltage_probe,
311         .remove         = __devexit_p(reg_fixed_voltage_remove),
312         .driver         = {
313                 .name           = "reg-fixed-voltage",
314                 .owner          = THIS_MODULE,
315                 .of_match_table = of_match_ptr(fixed_of_match),
316         },
317 };
318
319 static int __init regulator_fixed_voltage_init(void)
320 {
321         return platform_driver_register(&regulator_fixed_voltage_driver);
322 }
323 subsys_initcall(regulator_fixed_voltage_init);
324
325 static void __exit regulator_fixed_voltage_exit(void)
326 {
327         platform_driver_unregister(&regulator_fixed_voltage_driver);
328 }
329 module_exit(regulator_fixed_voltage_exit);
330
331 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
332 MODULE_DESCRIPTION("Fixed voltage regulator");
333 MODULE_LICENSE("GPL");
334 MODULE_ALIAS("platform:reg-fixed-voltage");