regulator: add support for changing control mode of regulator
[linux-2.6.git] / include / linux / regulator / consumer.h
1 /*
2  * consumer.h -- SoC Regulator consumer support.
3  *
4  * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
5  * Copyright (C) 2012 NVIDIA Corporation
6  *
7  * Author: Liam Girdwood <lrg@slimlogic.co.uk>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  *
13  * Regulator Consumer Interface.
14  *
15  * A Power Management Regulator framework for SoC based devices.
16  * Features:-
17  *   o Voltage and current level control.
18  *   o Operating mode control.
19  *   o Regulator status.
20  *   o sysfs entries for showing client devices and status
21  *
22  * EXPERIMENTAL FEATURES:
23  *   Dynamic Regulator operating Mode Switching (DRMS) - allows regulators
24  *   to use most efficient operating mode depending upon voltage and load and
25  *   is transparent to client drivers.
26  *
27  *   e.g. Devices x,y,z share regulator r. Device x and y draw 20mA each during
28  *   IO and 1mA at idle. Device z draws 100mA when under load and 5mA when
29  *   idling. Regulator r has > 90% efficiency in NORMAL mode at loads > 100mA
30  *   but this drops rapidly to 60% when below 100mA. Regulator r has > 90%
31  *   efficiency in IDLE mode at loads < 10mA. Thus regulator r will operate
32  *   in normal mode for loads > 10mA and in IDLE mode for load <= 10mA.
33  *
34  */
35
36 #ifndef __LINUX_REGULATOR_CONSUMER_H_
37 #define __LINUX_REGULATOR_CONSUMER_H_
38
39 struct device;
40 struct notifier_block;
41
42 /*
43  * Regulator operating modes.
44  *
45  * Regulators can run in a variety of different operating modes depending on
46  * output load. This allows further system power savings by selecting the
47  * best (and most efficient) regulator mode for a desired load.
48  *
49  * Most drivers will only care about NORMAL. The modes below are generic and
50  * will probably not match the naming convention of your regulator data sheet
51  * but should match the use cases in the datasheet.
52  *
53  * In order of power efficiency (least efficient at top).
54  *
55  *  Mode       Description
56  *  FAST       Regulator can handle fast changes in it's load.
57  *             e.g. useful in CPU voltage & frequency scaling where
58  *             load can quickly increase with CPU frequency increases.
59  *
60  *  NORMAL     Normal regulator power supply mode. Most drivers will
61  *             use this mode.
62  *
63  *  IDLE       Regulator runs in a more efficient mode for light
64  *             loads. Can be used for devices that have a low power
65  *             requirement during periods of inactivity. This mode
66  *             may be more noisy than NORMAL and may not be able
67  *             to handle fast load switching.
68  *
69  *  STANDBY    Regulator runs in the most efficient mode for very
70  *             light loads. Can be used by devices when they are
71  *             in a sleep/standby state. This mode is likely to be
72  *             the most noisy and may not be able to handle fast load
73  *             switching.
74  *
75  * NOTE: Most regulators will only support a subset of these modes. Some
76  * will only just support NORMAL.
77  *
78  * These modes can be OR'ed together to make up a mask of valid register modes.
79  */
80
81 #define REGULATOR_MODE_FAST                     0x1
82 #define REGULATOR_MODE_NORMAL                   0x2
83 #define REGULATOR_MODE_IDLE                     0x4
84 #define REGULATOR_MODE_STANDBY                  0x8
85
86 /*
87  * Regulator control modes.
88  *
89  * Regulators can be control through i2c or PWM or any other interface.
90  * The control mode provides the way to control the regulator.
91  *
92  *  Mode       Description
93  *  I2C        Regulator can be control through I2C interface.
94  *  PWM        Regulator can be control through PWM interface.
95  */
96 #define REGULATOR_CONTROL_MODE_I2C              0x1
97 #define REGULATOR_CONTROL_MODE_PWM              0x2
98
99 /*
100  * Regulator notifier events.
101  *
102  * UNDER_VOLTAGE  Regulator output is under voltage.
103  * OVER_CURRENT   Regulator output current is too high.
104  * REGULATION_OUT Regulator output is out of regulation.
105  * FAIL           Regulator output has failed.
106  * OVER_TEMP      Regulator over temp.
107  * FORCE_DISABLE  Regulator forcibly shut down by software.
108  * VOLTAGE_CHANGE Regulator voltage changed.
109  * DISABLE        Regulator was disabled.
110  * PRE_ENABLE     Regulator is to be enabled
111  * POST_ENABLE    Regulator was enabled
112  * OUT_PRECHANGE  Regulator is enabled and its voltage is to be changed
113  * OUT_POSTCHANGE Regulator is enabled and its voltage was changed
114  *
115  * NOTE: These events can be OR'ed together when passed into handler.
116  */
117
118 #define REGULATOR_EVENT_UNDER_VOLTAGE           0x01
119 #define REGULATOR_EVENT_OVER_CURRENT            0x02
120 #define REGULATOR_EVENT_REGULATION_OUT          0x04
121 #define REGULATOR_EVENT_FAIL                    0x08
122 #define REGULATOR_EVENT_OVER_TEMP               0x10
123 #define REGULATOR_EVENT_FORCE_DISABLE           0x20
124 #define REGULATOR_EVENT_VOLTAGE_CHANGE          0x40
125 #define REGULATOR_EVENT_DISABLE                 0x80
126 #define REGULATOR_EVENT_PRE_ENABLE              0x100
127 #define REGULATOR_EVENT_POST_ENABLE             0x200
128 #define REGULATOR_EVENT_OUT_PRECHANGE           0x400
129 #define REGULATOR_EVENT_OUT_POSTCHANGE          0x800
130
131 struct regulator;
132
133 /**
134  * struct regulator_bulk_data - Data used for bulk regulator operations.
135  *
136  * @supply:   The name of the supply.  Initialised by the user before
137  *            using the bulk regulator APIs.
138  * @consumer: The regulator consumer for the supply.  This will be managed
139  *            by the bulk API.
140  *
141  * The regulator APIs provide a series of regulator_bulk_() API calls as
142  * a convenience to consumers which require multiple supplies.  This
143  * structure is used to manage data for these calls.
144  */
145 struct regulator_bulk_data {
146         const char *supply;
147         struct regulator *consumer;
148
149         /* private: Internal use */
150         int ret;
151 };
152
153 #if defined(CONFIG_REGULATOR)
154
155 /* regulator get and put */
156 struct regulator *__must_check regulator_get(struct device *dev,
157                                              const char *id);
158 struct regulator *__must_check devm_regulator_get(struct device *dev,
159                                              const char *id);
160 struct regulator *__must_check regulator_get_exclusive(struct device *dev,
161                                                        const char *id);
162 void regulator_put(struct regulator *regulator);
163 void devm_regulator_put(struct regulator *regulator);
164
165 /* regulator output control and status */
166 int regulator_enable(struct regulator *regulator);
167 int regulator_disable(struct regulator *regulator);
168 int regulator_force_disable(struct regulator *regulator);
169 int regulator_is_enabled(struct regulator *regulator);
170 int regulator_disable_deferred(struct regulator *regulator, int ms);
171
172 int regulator_bulk_get(struct device *dev, int num_consumers,
173                        struct regulator_bulk_data *consumers);
174 int devm_regulator_bulk_get(struct device *dev, int num_consumers,
175                             struct regulator_bulk_data *consumers);
176 int regulator_bulk_enable(int num_consumers,
177                           struct regulator_bulk_data *consumers);
178 int regulator_bulk_disable(int num_consumers,
179                            struct regulator_bulk_data *consumers);
180 int regulator_bulk_force_disable(int num_consumers,
181                            struct regulator_bulk_data *consumers);
182 void regulator_bulk_free(int num_consumers,
183                          struct regulator_bulk_data *consumers);
184
185 int regulator_count_voltages(struct regulator *regulator);
186 int regulator_list_voltage(struct regulator *regulator, unsigned selector);
187 int regulator_is_supported_voltage(struct regulator *regulator,
188                                    int min_uV, int max_uV);
189 int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV);
190 int regulator_set_voltage_time(struct regulator *regulator,
191                                int old_uV, int new_uV);
192 int regulator_get_voltage(struct regulator *regulator);
193 int regulator_sync_voltage(struct regulator *regulator);
194 int regulator_set_current_limit(struct regulator *regulator,
195                                int min_uA, int max_uA);
196 int regulator_get_current_limit(struct regulator *regulator);
197
198 int regulator_set_mode(struct regulator *regulator, unsigned int mode);
199 unsigned int regulator_get_mode(struct regulator *regulator);
200 int regulator_set_optimum_mode(struct regulator *regulator, int load_uA);
201
202 int regulator_set_control_mode(struct regulator *regulator, unsigned int mode);
203 unsigned int regulator_get_control_mode(struct regulator *regulator);
204
205 /* regulator notifier block */
206 int regulator_register_notifier(struct regulator *regulator,
207                               struct notifier_block *nb);
208 int regulator_unregister_notifier(struct regulator *regulator,
209                                 struct notifier_block *nb);
210
211 /* driver data - core doesn't touch */
212 void *regulator_get_drvdata(struct regulator *regulator);
213 void regulator_set_drvdata(struct regulator *regulator, void *data);
214
215 #else
216
217 /*
218  * Make sure client drivers will still build on systems with no software
219  * controllable voltage or current regulators.
220  */
221 static inline struct regulator *__must_check regulator_get(struct device *dev,
222         const char *id)
223 {
224         /* Nothing except the stubbed out regulator API should be
225          * looking at the value except to check if it is an error
226          * value. Drivers are free to handle NULL specifically by
227          * skipping all regulator API calls, but they don't have to.
228          * Drivers which don't, should make sure they properly handle
229          * corner cases of the API, such as regulator_get_voltage()
230          * returning 0.
231          */
232         return NULL;
233 }
234
235 static inline struct regulator *__must_check regulator_get_exclusive(
236                 struct device *dev, const char *id)
237 {
238         /* See comment for regulator_get() stub, above */
239         return NULL;
240 }
241
242 static inline struct regulator *__must_check
243 devm_regulator_get(struct device *dev, const char *id)
244 {
245         return NULL;
246 }
247
248 static inline void regulator_put(struct regulator *regulator)
249 {
250 }
251
252 static inline void devm_regulator_put(struct regulator *regulator)
253 {
254 }
255
256 static inline int regulator_enable(struct regulator *regulator)
257 {
258         return 0;
259 }
260
261 static inline int regulator_disable(struct regulator *regulator)
262 {
263         return 0;
264 }
265
266 static inline int regulator_force_disable(struct regulator *regulator)
267 {
268         return 0;
269 }
270
271 static inline int regulator_disable_deferred(struct regulator *regulator,
272                                              int ms)
273 {
274         return 0;
275 }
276
277 static inline int regulator_force_disable(struct regulator *regulator)
278 {
279         return 0;
280 }
281
282 static inline int regulator_is_enabled(struct regulator *regulator)
283 {
284         return 1;
285 }
286
287 static inline int regulator_bulk_get(struct device *dev,
288                                      int num_consumers,
289                                      struct regulator_bulk_data *consumers)
290 {
291         return 0;
292 }
293
294 static inline int devm_regulator_bulk_get(struct device *dev, int num_consumers,
295                                           struct regulator_bulk_data *consumers)
296 {
297         return 0;
298 }
299
300 static inline int regulator_bulk_enable(int num_consumers,
301                                         struct regulator_bulk_data *consumers)
302 {
303         return 0;
304 }
305
306 static inline int regulator_bulk_disable(int num_consumers,
307                                          struct regulator_bulk_data *consumers)
308 {
309         return 0;
310 }
311
312 static inline int regulator_bulk_force_disable(int num_consumers,
313                                         struct regulator_bulk_data *consumers)
314 {
315         return 0;
316 }
317
318 static inline void regulator_bulk_free(int num_consumers,
319                                        struct regulator_bulk_data *consumers)
320 {
321 }
322
323 static inline int regulator_count_voltages(struct regulator *regulator)
324 {
325         return 0;
326 }
327
328 static inline int regulator_list_voltage(struct regulator *regulator,
329                                          unsigned selector)
330 {
331         return 0;
332 }
333
334 static inline int regulator_is_supported_voltage(struct regulator *regulator,
335                                                  int min_uV, int max_uV)
336 {
337         return 0;
338 }
339
340 static inline int regulator_set_voltage(struct regulator *regulator,
341                                         int min_uV, int max_uV)
342 {
343         return 0;
344 }
345
346 static inline int regulator_set_voltage_time(struct regulator *regulator,
347                                              int old_uV, int new_uV)
348 {
349         return 0;
350 }
351
352 static inline int regulator_get_voltage(struct regulator *regulator)
353 {
354         return 0;
355 }
356
357 static inline int regulator_sync_voltage(struct regulator *regulator)
358 {
359         return 0;
360 }
361
362 static inline int regulator_set_current_limit(struct regulator *regulator,
363                                              int min_uA, int max_uA)
364 {
365         return 0;
366 }
367
368 static inline int regulator_get_current_limit(struct regulator *regulator)
369 {
370         return 0;
371 }
372
373 static inline int regulator_set_mode(struct regulator *regulator,
374         unsigned int mode)
375 {
376         return 0;
377 }
378
379 static inline unsigned int regulator_get_mode(struct regulator *regulator)
380 {
381         return REGULATOR_MODE_NORMAL;
382 }
383
384 static inline int regulator_set_optimum_mode(struct regulator *regulator,
385                                         int load_uA)
386 {
387         return REGULATOR_MODE_NORMAL;
388 }
389
390 static inline int regulator_set_control_mode(struct regulator *regulator,
391                 unsigned int mode)
392 {
393         return 0;
394 }
395
396 static inline unsigned int regulator_get_control_mode(
397                 struct regulator *regulator)
398 {
399         return REGULATOR_CONTROL_MODE_I2C;
400 }
401
402 static inline int regulator_register_notifier(struct regulator *regulator,
403                               struct notifier_block *nb)
404 {
405         return 0;
406 }
407
408 static inline int regulator_unregister_notifier(struct regulator *regulator,
409                                 struct notifier_block *nb)
410 {
411         return 0;
412 }
413
414 static inline void *regulator_get_drvdata(struct regulator *regulator)
415 {
416         return NULL;
417 }
418
419 static inline void regulator_set_drvdata(struct regulator *regulator,
420         void *data)
421 {
422 }
423
424 #endif
425
426 #endif