4 * Copyright 2011 Heiko Stuebner <heiko@sntech.de>
8 * Copyright 2008 Wolfson Microelectronics PLC.
10 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
12 * Copyright (c) 2009 Nokia Corporation
13 * Roger Quadros <ext-roger.quadros@nokia.com>
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation; either version 2 of the
18 * License, or (at your option) any later version.
20 * This is useful for systems with mixed controllable and
21 * non-controllable regulators, as well as for allowing testing on
22 * systems with no controllable regulators.
25 #include <linux/err.h>
26 #include <linux/mutex.h>
27 #include <linux/module.h>
28 #include <linux/platform_device.h>
29 #include <linux/regulator/driver.h>
30 #include <linux/regulator/machine.h>
31 #include <linux/regulator/of_regulator.h>
32 #include <linux/regulator/gpio-regulator.h>
33 #include <linux/gpio.h>
34 #include <linux/slab.h>
36 #include <linux/of_gpio.h>
38 struct gpio_regulator_data
{
39 struct regulator_desc desc
;
40 struct regulator_dev
*dev
;
45 struct gpio_regulator_state
*states
;
51 static int gpio_regulator_get_value(struct regulator_dev
*dev
)
53 struct gpio_regulator_data
*data
= rdev_get_drvdata(dev
);
56 for (ptr
= 0; ptr
< data
->nr_states
; ptr
++)
57 if (data
->states
[ptr
].gpios
== data
->state
)
58 return data
->states
[ptr
].value
;
63 static int gpio_regulator_set_voltage(struct regulator_dev
*dev
,
64 int min_uV
, int max_uV
,
67 struct gpio_regulator_data
*data
= rdev_get_drvdata(dev
);
68 int ptr
, target
= 0, state
, best_val
= INT_MAX
;
70 for (ptr
= 0; ptr
< data
->nr_states
; ptr
++)
71 if (data
->states
[ptr
].value
< best_val
&&
72 data
->states
[ptr
].value
>= min_uV
&&
73 data
->states
[ptr
].value
<= max_uV
) {
74 target
= data
->states
[ptr
].gpios
;
75 best_val
= data
->states
[ptr
].value
;
80 if (best_val
== INT_MAX
)
83 for (ptr
= 0; ptr
< data
->nr_gpios
; ptr
++) {
84 state
= (target
& (1 << ptr
)) >> ptr
;
85 gpio_set_value_cansleep(data
->gpios
[ptr
].gpio
, state
);
92 static int gpio_regulator_list_voltage(struct regulator_dev
*dev
,
95 struct gpio_regulator_data
*data
= rdev_get_drvdata(dev
);
97 if (selector
>= data
->nr_states
)
100 return data
->states
[selector
].value
;
103 static int gpio_regulator_set_current_limit(struct regulator_dev
*dev
,
104 int min_uA
, int max_uA
)
106 struct gpio_regulator_data
*data
= rdev_get_drvdata(dev
);
107 int ptr
, target
= 0, state
, best_val
= 0;
109 for (ptr
= 0; ptr
< data
->nr_states
; ptr
++)
110 if (data
->states
[ptr
].value
> best_val
&&
111 data
->states
[ptr
].value
>= min_uA
&&
112 data
->states
[ptr
].value
<= max_uA
) {
113 target
= data
->states
[ptr
].gpios
;
114 best_val
= data
->states
[ptr
].value
;
120 for (ptr
= 0; ptr
< data
->nr_gpios
; ptr
++) {
121 state
= (target
& (1 << ptr
)) >> ptr
;
122 gpio_set_value_cansleep(data
->gpios
[ptr
].gpio
, state
);
124 data
->state
= target
;
129 static struct regulator_ops gpio_regulator_voltage_ops
= {
130 .get_voltage
= gpio_regulator_get_value
,
131 .set_voltage
= gpio_regulator_set_voltage
,
132 .list_voltage
= gpio_regulator_list_voltage
,
135 static struct gpio_regulator_config
*
136 of_get_gpio_regulator_config(struct device
*dev
, struct device_node
*np
,
137 const struct regulator_desc
*desc
)
139 struct gpio_regulator_config
*config
;
141 int proplen
, gpio
, i
;
144 config
= devm_kzalloc(dev
,
145 sizeof(struct gpio_regulator_config
),
148 return ERR_PTR(-ENOMEM
);
150 config
->init_data
= of_get_regulator_init_data(dev
, np
, desc
);
151 if (!config
->init_data
)
152 return ERR_PTR(-EINVAL
);
154 config
->supply_name
= config
->init_data
->constraints
.name
;
156 if (of_property_read_bool(np
, "enable-active-high"))
157 config
->enable_high
= true;
159 if (of_property_read_bool(np
, "enable-at-boot"))
160 config
->enabled_at_boot
= true;
162 of_property_read_u32(np
, "startup-delay-us", &config
->startup_delay
);
164 config
->enable_gpio
= of_get_named_gpio(np
, "enable-gpio", 0);
165 if (config
->enable_gpio
< 0 && config
->enable_gpio
!= -ENOENT
)
166 return ERR_PTR(config
->enable_gpio
);
168 /* Fetch GPIOs. - optional property*/
169 ret
= of_gpio_count(np
);
170 if ((ret
< 0) && (ret
!= -ENOENT
))
174 config
->nr_gpios
= ret
;
175 config
->gpios
= devm_kzalloc(dev
,
176 sizeof(struct gpio
) * config
->nr_gpios
,
179 return ERR_PTR(-ENOMEM
);
181 proplen
= of_property_count_u32_elems(np
, "gpios-states");
182 /* optional property */
186 if (proplen
> 0 && proplen
!= config
->nr_gpios
) {
187 dev_warn(dev
, "gpios <-> gpios-states mismatch\n");
191 for (i
= 0; i
< config
->nr_gpios
; i
++) {
192 gpio
= of_get_named_gpio(np
, "gpios", i
);
195 return ERR_PTR(gpio
);
198 config
->gpios
[i
].gpio
= gpio
;
200 of_property_read_u32_index(np
, "gpios-states",
203 config
->gpios
[i
].flags
=
210 proplen
= of_property_count_u32_elems(np
, "states");
212 dev_err(dev
, "No 'states' property found\n");
213 return ERR_PTR(-EINVAL
);
216 config
->states
= devm_kzalloc(dev
,
217 sizeof(struct gpio_regulator_state
)
221 return ERR_PTR(-ENOMEM
);
223 for (i
= 0; i
< proplen
/ 2; i
++) {
224 of_property_read_u32_index(np
, "states", i
* 2,
225 &config
->states
[i
].value
);
226 of_property_read_u32_index(np
, "states", i
* 2 + 1,
227 &config
->states
[i
].gpios
);
229 config
->nr_states
= i
;
231 config
->type
= REGULATOR_VOLTAGE
;
232 ret
= of_property_read_string(np
, "regulator-type", ®type
);
234 if (!strncmp("voltage", regtype
, 7))
235 config
->type
= REGULATOR_VOLTAGE
;
236 else if (!strncmp("current", regtype
, 7))
237 config
->type
= REGULATOR_CURRENT
;
239 dev_warn(dev
, "Unknown regulator-type '%s'\n",
246 static struct regulator_ops gpio_regulator_current_ops
= {
247 .get_current_limit
= gpio_regulator_get_value
,
248 .set_current_limit
= gpio_regulator_set_current_limit
,
251 static int gpio_regulator_probe(struct platform_device
*pdev
)
253 struct gpio_regulator_config
*config
= dev_get_platdata(&pdev
->dev
);
254 struct device_node
*np
= pdev
->dev
.of_node
;
255 struct gpio_regulator_data
*drvdata
;
256 struct regulator_config cfg
= { };
259 drvdata
= devm_kzalloc(&pdev
->dev
, sizeof(struct gpio_regulator_data
),
265 config
= of_get_gpio_regulator_config(&pdev
->dev
, np
,
268 return PTR_ERR(config
);
271 drvdata
->desc
.name
= kstrdup(config
->supply_name
, GFP_KERNEL
);
272 if (drvdata
->desc
.name
== NULL
) {
273 dev_err(&pdev
->dev
, "Failed to allocate supply name\n");
278 if (config
->nr_gpios
!= 0) {
279 drvdata
->gpios
= kmemdup(config
->gpios
,
280 config
->nr_gpios
* sizeof(struct gpio
),
282 if (drvdata
->gpios
== NULL
) {
283 dev_err(&pdev
->dev
, "Failed to allocate gpio data\n");
288 drvdata
->nr_gpios
= config
->nr_gpios
;
289 ret
= gpio_request_array(drvdata
->gpios
, drvdata
->nr_gpios
);
291 if (ret
!= -EPROBE_DEFER
)
293 "Could not obtain regulator setting GPIOs: %d\n",
299 drvdata
->states
= kmemdup(config
->states
,
301 sizeof(struct gpio_regulator_state
),
303 if (drvdata
->states
== NULL
) {
304 dev_err(&pdev
->dev
, "Failed to allocate state data\n");
308 drvdata
->nr_states
= config
->nr_states
;
310 drvdata
->desc
.owner
= THIS_MODULE
;
311 drvdata
->desc
.enable_time
= config
->startup_delay
;
313 /* handle regulator type*/
314 switch (config
->type
) {
315 case REGULATOR_VOLTAGE
:
316 drvdata
->desc
.type
= REGULATOR_VOLTAGE
;
317 drvdata
->desc
.ops
= &gpio_regulator_voltage_ops
;
318 drvdata
->desc
.n_voltages
= config
->nr_states
;
320 case REGULATOR_CURRENT
:
321 drvdata
->desc
.type
= REGULATOR_CURRENT
;
322 drvdata
->desc
.ops
= &gpio_regulator_current_ops
;
325 dev_err(&pdev
->dev
, "No regulator type set\n");
330 /* build initial state from gpio init data. */
332 for (ptr
= 0; ptr
< drvdata
->nr_gpios
; ptr
++) {
333 if (config
->gpios
[ptr
].flags
& GPIOF_OUT_INIT_HIGH
)
336 drvdata
->state
= state
;
338 cfg
.dev
= &pdev
->dev
;
339 cfg
.init_data
= config
->init_data
;
340 cfg
.driver_data
= drvdata
;
343 if (gpio_is_valid(config
->enable_gpio
)) {
344 cfg
.ena_gpio
= config
->enable_gpio
;
345 cfg
.ena_gpio_initialized
= true;
347 cfg
.ena_gpio_invert
= !config
->enable_high
;
348 if (config
->enabled_at_boot
) {
349 if (config
->enable_high
)
350 cfg
.ena_gpio_flags
|= GPIOF_OUT_INIT_HIGH
;
352 cfg
.ena_gpio_flags
|= GPIOF_OUT_INIT_LOW
;
354 if (config
->enable_high
)
355 cfg
.ena_gpio_flags
|= GPIOF_OUT_INIT_LOW
;
357 cfg
.ena_gpio_flags
|= GPIOF_OUT_INIT_HIGH
;
360 drvdata
->dev
= regulator_register(&drvdata
->desc
, &cfg
);
361 if (IS_ERR(drvdata
->dev
)) {
362 ret
= PTR_ERR(drvdata
->dev
);
363 dev_err(&pdev
->dev
, "Failed to register regulator: %d\n", ret
);
367 platform_set_drvdata(pdev
, drvdata
);
372 gpio_free_array(drvdata
->gpios
, drvdata
->nr_gpios
);
374 kfree(drvdata
->states
);
376 kfree(drvdata
->gpios
);
378 kfree(drvdata
->desc
.name
);
383 static int gpio_regulator_remove(struct platform_device
*pdev
)
385 struct gpio_regulator_data
*drvdata
= platform_get_drvdata(pdev
);
387 regulator_unregister(drvdata
->dev
);
389 gpio_free_array(drvdata
->gpios
, drvdata
->nr_gpios
);
391 kfree(drvdata
->states
);
392 kfree(drvdata
->gpios
);
394 kfree(drvdata
->desc
.name
);
399 #if defined(CONFIG_OF)
400 static const struct of_device_id regulator_gpio_of_match
[] = {
401 { .compatible
= "regulator-gpio", },
404 MODULE_DEVICE_TABLE(of
, regulator_gpio_of_match
);
407 static struct platform_driver gpio_regulator_driver
= {
408 .probe
= gpio_regulator_probe
,
409 .remove
= gpio_regulator_remove
,
411 .name
= "gpio-regulator",
412 .of_match_table
= of_match_ptr(regulator_gpio_of_match
),
416 static int __init
gpio_regulator_init(void)
418 return platform_driver_register(&gpio_regulator_driver
);
420 subsys_initcall(gpio_regulator_init
);
422 static void __exit
gpio_regulator_exit(void)
424 platform_driver_unregister(&gpio_regulator_driver
);
426 module_exit(gpio_regulator_exit
);
428 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
429 MODULE_DESCRIPTION("gpio voltage regulator");
430 MODULE_LICENSE("GPL");
431 MODULE_ALIAS("platform:gpio-regulator");