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/gpio-regulator.h>
32 #include <linux/gpio.h>
33 #include <linux/slab.h>
35 struct gpio_regulator_data
{
36 struct regulator_desc desc
;
37 struct regulator_dev
*dev
;
42 struct gpio_regulator_state
*states
;
48 static int gpio_regulator_get_value(struct regulator_dev
*dev
)
50 struct gpio_regulator_data
*data
= rdev_get_drvdata(dev
);
53 for (ptr
= 0; ptr
< data
->nr_states
; ptr
++)
54 if (data
->states
[ptr
].gpios
== data
->state
)
55 return data
->states
[ptr
].value
;
60 static int gpio_regulator_set_value(struct regulator_dev
*dev
,
61 int min
, int max
, unsigned *selector
)
63 struct gpio_regulator_data
*data
= rdev_get_drvdata(dev
);
64 int ptr
, target
= 0, state
, best_val
= INT_MAX
;
66 for (ptr
= 0; ptr
< data
->nr_states
; ptr
++)
67 if (data
->states
[ptr
].value
< best_val
&&
68 data
->states
[ptr
].value
>= min
&&
69 data
->states
[ptr
].value
<= max
) {
70 target
= data
->states
[ptr
].gpios
;
71 best_val
= data
->states
[ptr
].value
;
76 if (best_val
== INT_MAX
)
79 for (ptr
= 0; ptr
< data
->nr_gpios
; ptr
++) {
80 state
= (target
& (1 << ptr
)) >> ptr
;
81 gpio_set_value(data
->gpios
[ptr
].gpio
, state
);
88 static int gpio_regulator_set_voltage(struct regulator_dev
*dev
,
89 int min_uV
, int max_uV
,
92 return gpio_regulator_set_value(dev
, min_uV
, max_uV
, selector
);
95 static int gpio_regulator_list_voltage(struct regulator_dev
*dev
,
98 struct gpio_regulator_data
*data
= rdev_get_drvdata(dev
);
100 if (selector
>= data
->nr_states
)
103 return data
->states
[selector
].value
;
106 static int gpio_regulator_set_current_limit(struct regulator_dev
*dev
,
107 int min_uA
, int max_uA
)
109 return gpio_regulator_set_value(dev
, min_uA
, max_uA
, NULL
);
112 static struct regulator_ops gpio_regulator_voltage_ops
= {
113 .get_voltage
= gpio_regulator_get_value
,
114 .set_voltage
= gpio_regulator_set_voltage
,
115 .list_voltage
= gpio_regulator_list_voltage
,
118 static struct regulator_ops gpio_regulator_current_ops
= {
119 .get_current_limit
= gpio_regulator_get_value
,
120 .set_current_limit
= gpio_regulator_set_current_limit
,
123 static int __devinit
gpio_regulator_probe(struct platform_device
*pdev
)
125 struct gpio_regulator_config
*config
= pdev
->dev
.platform_data
;
126 struct gpio_regulator_data
*drvdata
;
127 struct regulator_config cfg
= { };
130 drvdata
= devm_kzalloc(&pdev
->dev
, sizeof(struct gpio_regulator_data
),
132 if (drvdata
== NULL
) {
133 dev_err(&pdev
->dev
, "Failed to allocate device data\n");
137 drvdata
->desc
.name
= kstrdup(config
->supply_name
, GFP_KERNEL
);
138 if (drvdata
->desc
.name
== NULL
) {
139 dev_err(&pdev
->dev
, "Failed to allocate supply name\n");
144 drvdata
->gpios
= kmemdup(config
->gpios
,
145 config
->nr_gpios
* sizeof(struct gpio
),
147 if (drvdata
->gpios
== NULL
) {
148 dev_err(&pdev
->dev
, "Failed to allocate gpio data\n");
153 drvdata
->states
= kmemdup(config
->states
,
155 sizeof(struct gpio_regulator_state
),
157 if (drvdata
->states
== NULL
) {
158 dev_err(&pdev
->dev
, "Failed to allocate state data\n");
162 drvdata
->nr_states
= config
->nr_states
;
164 drvdata
->desc
.owner
= THIS_MODULE
;
165 drvdata
->desc
.enable_time
= config
->startup_delay
;
167 /* handle regulator type*/
168 switch (config
->type
) {
169 case REGULATOR_VOLTAGE
:
170 drvdata
->desc
.type
= REGULATOR_VOLTAGE
;
171 drvdata
->desc
.ops
= &gpio_regulator_voltage_ops
;
172 drvdata
->desc
.n_voltages
= config
->nr_states
;
174 case REGULATOR_CURRENT
:
175 drvdata
->desc
.type
= REGULATOR_CURRENT
;
176 drvdata
->desc
.ops
= &gpio_regulator_current_ops
;
179 dev_err(&pdev
->dev
, "No regulator type set\n");
185 drvdata
->nr_gpios
= config
->nr_gpios
;
186 ret
= gpio_request_array(drvdata
->gpios
, drvdata
->nr_gpios
);
189 "Could not obtain regulator setting GPIOs: %d\n", ret
);
193 /* build initial state from gpio init data. */
195 for (ptr
= 0; ptr
< drvdata
->nr_gpios
; ptr
++) {
196 if (config
->gpios
[ptr
].flags
& GPIOF_OUT_INIT_HIGH
)
199 drvdata
->state
= state
;
201 cfg
.dev
= &pdev
->dev
;
202 cfg
.init_data
= config
->init_data
;
203 cfg
.driver_data
= drvdata
;
205 if (config
->enable_gpio
>= 0)
206 cfg
.ena_gpio
= config
->enable_gpio
;
207 cfg
.ena_gpio_invert
= !config
->enable_high
;
208 if (config
->enabled_at_boot
) {
209 if (config
->enable_high
)
210 cfg
.ena_gpio_flags
|= GPIOF_OUT_INIT_HIGH
;
212 cfg
.ena_gpio_flags
|= GPIOF_OUT_INIT_LOW
;
214 if (config
->enable_high
)
215 cfg
.ena_gpio_flags
|= GPIOF_OUT_INIT_LOW
;
217 cfg
.ena_gpio_flags
|= GPIOF_OUT_INIT_HIGH
;
220 drvdata
->dev
= regulator_register(&drvdata
->desc
, &cfg
);
221 if (IS_ERR(drvdata
->dev
)) {
222 ret
= PTR_ERR(drvdata
->dev
);
223 dev_err(&pdev
->dev
, "Failed to register regulator: %d\n", ret
);
227 platform_set_drvdata(pdev
, drvdata
);
232 gpio_free_array(drvdata
->gpios
, drvdata
->nr_gpios
);
234 kfree(drvdata
->states
);
236 kfree(drvdata
->gpios
);
238 kfree(drvdata
->desc
.name
);
243 static int __devexit
gpio_regulator_remove(struct platform_device
*pdev
)
245 struct gpio_regulator_data
*drvdata
= platform_get_drvdata(pdev
);
247 regulator_unregister(drvdata
->dev
);
249 gpio_free_array(drvdata
->gpios
, drvdata
->nr_gpios
);
251 kfree(drvdata
->states
);
252 kfree(drvdata
->gpios
);
254 kfree(drvdata
->desc
.name
);
259 static struct platform_driver gpio_regulator_driver
= {
260 .probe
= gpio_regulator_probe
,
261 .remove
= __devexit_p(gpio_regulator_remove
),
263 .name
= "gpio-regulator",
264 .owner
= THIS_MODULE
,
268 static int __init
gpio_regulator_init(void)
270 return platform_driver_register(&gpio_regulator_driver
);
272 subsys_initcall(gpio_regulator_init
);
274 static void __exit
gpio_regulator_exit(void)
276 platform_driver_unregister(&gpio_regulator_driver
);
278 module_exit(gpio_regulator_exit
);
280 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
281 MODULE_DESCRIPTION("gpio voltage regulator");
282 MODULE_LICENSE("GPL");
283 MODULE_ALIAS("platform:gpio-regulator");