]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * machine.h -- SoC Regulator support, machine/board driver API. | |
3 | * | |
4 | * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC. | |
5 | * | |
6 | * Author: Liam Girdwood <lrg@slimlogic.co.uk> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | * | |
12 | * Regulator Machine/Board Interface. | |
13 | */ | |
14 | ||
15 | #ifndef __LINUX_REGULATOR_MACHINE_H_ | |
16 | #define __LINUX_REGULATOR_MACHINE_H_ | |
17 | ||
18 | #include <linux/regulator/consumer.h> | |
19 | #include <linux/suspend.h> | |
20 | ||
21 | struct regulator; | |
22 | ||
23 | /* | |
24 | * Regulator operation constraint flags. These flags are used to enable | |
25 | * certain regulator operations and can be OR'ed together. | |
26 | * | |
27 | * VOLTAGE: Regulator output voltage can be changed by software on this | |
28 | * board/machine. | |
29 | * CURRENT: Regulator output current can be changed by software on this | |
30 | * board/machine. | |
31 | * MODE: Regulator operating mode can be changed by software on this | |
32 | * board/machine. | |
33 | * STATUS: Regulator can be enabled and disabled. | |
34 | * DRMS: Dynamic Regulator Mode Switching is enabled for this regulator. | |
35 | * BYPASS: Regulator can be put into bypass mode | |
36 | */ | |
37 | ||
38 | #define REGULATOR_CHANGE_VOLTAGE 0x1 | |
39 | #define REGULATOR_CHANGE_CURRENT 0x2 | |
40 | #define REGULATOR_CHANGE_MODE 0x4 | |
41 | #define REGULATOR_CHANGE_STATUS 0x8 | |
42 | #define REGULATOR_CHANGE_DRMS 0x10 | |
43 | #define REGULATOR_CHANGE_BYPASS 0x20 | |
44 | ||
45 | /* Regulator active discharge flags */ | |
46 | enum regulator_active_discharge { | |
47 | REGULATOR_ACTIVE_DISCHARGE_DEFAULT, | |
48 | REGULATOR_ACTIVE_DISCHARGE_DISABLE, | |
49 | REGULATOR_ACTIVE_DISCHARGE_ENABLE, | |
50 | }; | |
51 | ||
52 | /** | |
53 | * struct regulator_state - regulator state during low power system states | |
54 | * | |
55 | * This describes a regulators state during a system wide low power | |
56 | * state. One of enabled or disabled must be set for the | |
57 | * configuration to be applied. | |
58 | * | |
59 | * @uV: Operating voltage during suspend. | |
60 | * @mode: Operating mode during suspend. | |
61 | * @enabled: Enabled during suspend. | |
62 | * @disabled: Disabled during suspend. | |
63 | */ | |
64 | struct regulator_state { | |
65 | int uV; /* suspend voltage */ | |
66 | unsigned int mode; /* suspend regulator operating mode */ | |
67 | int enabled; /* is regulator enabled in this suspend state */ | |
68 | int disabled; /* is the regulator disbled in this suspend state */ | |
69 | }; | |
70 | ||
71 | /** | |
72 | * struct regulation_constraints - regulator operating constraints. | |
73 | * | |
74 | * This struct describes regulator and board/machine specific constraints. | |
75 | * | |
76 | * @name: Descriptive name for the constraints, used for display purposes. | |
77 | * | |
78 | * @min_uV: Smallest voltage consumers may set. | |
79 | * @max_uV: Largest voltage consumers may set. | |
80 | * @uV_offset: Offset applied to voltages from consumer to compensate for | |
81 | * voltage drops. | |
82 | * | |
83 | * @min_uA: Smallest current consumers may set. | |
84 | * @max_uA: Largest current consumers may set. | |
85 | * @ilim_uA: Maximum input current. | |
86 | * @system_load: Load that isn't captured by any consumer requests. | |
87 | * | |
88 | * @valid_modes_mask: Mask of modes which may be configured by consumers. | |
89 | * @valid_ops_mask: Operations which may be performed by consumers. | |
90 | * | |
91 | * @always_on: Set if the regulator should never be disabled. | |
92 | * @boot_on: Set if the regulator is enabled when the system is initially | |
93 | * started. If the regulator is not enabled by the hardware or | |
94 | * bootloader then it will be enabled when the constraints are | |
95 | * applied. | |
96 | * @apply_uV: Apply the voltage constraint when initialising. | |
97 | * @ramp_disable: Disable ramp delay when initialising or when setting voltage. | |
98 | * @soft_start: Enable soft start so that voltage ramps slowly. | |
99 | * @pull_down: Enable pull down when regulator is disabled. | |
100 | * @over_current_protection: Auto disable on over current event. | |
101 | * | |
102 | * @input_uV: Input voltage for regulator when supplied by another regulator. | |
103 | * | |
104 | * @state_disk: State for regulator when system is suspended in disk mode. | |
105 | * @state_mem: State for regulator when system is suspended in mem mode. | |
106 | * @state_standby: State for regulator when system is suspended in standby | |
107 | * mode. | |
108 | * @initial_state: Suspend state to set by default. | |
109 | * @initial_mode: Mode to set at startup. | |
110 | * @ramp_delay: Time to settle down after voltage change (unit: uV/us) | |
111 | * @active_discharge: Enable/disable active discharge. The enum | |
112 | * regulator_active_discharge values are used for | |
113 | * initialisation. | |
114 | * @enable_time: Turn-on time of the rails (unit: microseconds) | |
115 | */ | |
116 | struct regulation_constraints { | |
117 | ||
118 | const char *name; | |
119 | ||
120 | /* voltage output range (inclusive) - for voltage control */ | |
121 | int min_uV; | |
122 | int max_uV; | |
123 | ||
124 | int uV_offset; | |
125 | ||
126 | /* current output range (inclusive) - for current control */ | |
127 | int min_uA; | |
128 | int max_uA; | |
129 | int ilim_uA; | |
130 | ||
131 | int system_load; | |
132 | ||
133 | /* valid regulator operating modes for this machine */ | |
134 | unsigned int valid_modes_mask; | |
135 | ||
136 | /* valid operations for regulator on this machine */ | |
137 | unsigned int valid_ops_mask; | |
138 | ||
139 | /* regulator input voltage - only if supply is another regulator */ | |
140 | int input_uV; | |
141 | ||
142 | /* regulator suspend states for global PMIC STANDBY/HIBERNATE */ | |
143 | struct regulator_state state_disk; | |
144 | struct regulator_state state_mem; | |
145 | struct regulator_state state_standby; | |
146 | suspend_state_t initial_state; /* suspend state to set at init */ | |
147 | ||
148 | /* mode to set on startup */ | |
149 | unsigned int initial_mode; | |
150 | ||
151 | unsigned int ramp_delay; | |
152 | unsigned int enable_time; | |
153 | ||
154 | unsigned int active_discharge; | |
155 | ||
156 | /* constraint flags */ | |
157 | unsigned always_on:1; /* regulator never off when system is on */ | |
158 | unsigned boot_on:1; /* bootloader/firmware enabled regulator */ | |
159 | unsigned apply_uV:1; /* apply uV constraint if min == max */ | |
160 | unsigned ramp_disable:1; /* disable ramp delay */ | |
161 | unsigned soft_start:1; /* ramp voltage slowly */ | |
162 | unsigned pull_down:1; /* pull down resistor when regulator off */ | |
163 | unsigned over_current_protection:1; /* auto disable on over current */ | |
164 | }; | |
165 | ||
166 | /** | |
167 | * struct regulator_consumer_supply - supply -> device mapping | |
168 | * | |
169 | * This maps a supply name to a device. Use of dev_name allows support for | |
170 | * buses which make struct device available late such as I2C. | |
171 | * | |
172 | * @dev_name: Result of dev_name() for the consumer. | |
173 | * @supply: Name for the supply. | |
174 | */ | |
175 | struct regulator_consumer_supply { | |
176 | const char *dev_name; /* dev_name() for consumer */ | |
177 | const char *supply; /* consumer supply - e.g. "vcc" */ | |
178 | }; | |
179 | ||
180 | /* Initialize struct regulator_consumer_supply */ | |
181 | #define REGULATOR_SUPPLY(_name, _dev_name) \ | |
182 | { \ | |
183 | .supply = _name, \ | |
184 | .dev_name = _dev_name, \ | |
185 | } | |
186 | ||
187 | /** | |
188 | * struct regulator_init_data - regulator platform initialisation data. | |
189 | * | |
190 | * Initialisation constraints, our supply and consumers supplies. | |
191 | * | |
192 | * @supply_regulator: Parent regulator. Specified using the regulator name | |
193 | * as it appears in the name field in sysfs, which can | |
194 | * be explicitly set using the constraints field 'name'. | |
195 | * | |
196 | * @constraints: Constraints. These must be specified for the regulator to | |
197 | * be usable. | |
198 | * @num_consumer_supplies: Number of consumer device supplies. | |
199 | * @consumer_supplies: Consumer device supply configuration. | |
200 | * | |
201 | * @regulator_init: Callback invoked when the regulator has been registered. | |
202 | * @driver_data: Data passed to regulator_init. | |
203 | */ | |
204 | struct regulator_init_data { | |
205 | const char *supply_regulator; /* or NULL for system supply */ | |
206 | ||
207 | struct regulation_constraints constraints; | |
208 | ||
209 | int num_consumer_supplies; | |
210 | struct regulator_consumer_supply *consumer_supplies; | |
211 | ||
212 | /* optional regulator machine specific init */ | |
213 | int (*regulator_init)(void *driver_data); | |
214 | void *driver_data; /* core does not touch this */ | |
215 | }; | |
216 | ||
217 | #ifdef CONFIG_REGULATOR | |
218 | void regulator_has_full_constraints(void); | |
219 | int regulator_suspend_prepare(suspend_state_t state); | |
220 | int regulator_suspend_finish(void); | |
221 | #else | |
222 | static inline void regulator_has_full_constraints(void) | |
223 | { | |
224 | } | |
225 | static inline int regulator_suspend_prepare(suspend_state_t state) | |
226 | { | |
227 | return 0; | |
228 | } | |
229 | static inline int regulator_suspend_finish(void) | |
230 | { | |
231 | return 0; | |
232 | } | |
233 | #endif | |
234 | ||
235 | #endif |