]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * driver.h -- SoC Regulator driver support. | |
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 Driver Interface. | |
13 | */ | |
14 | ||
15 | #ifndef __LINUX_REGULATOR_DRIVER_H_ | |
16 | #define __LINUX_REGULATOR_DRIVER_H_ | |
17 | ||
18 | #include <linux/device.h> | |
19 | #include <linux/notifier.h> | |
20 | #include <linux/regulator/consumer.h> | |
21 | ||
22 | struct regmap; | |
23 | struct regulator_dev; | |
24 | struct regulator_init_data; | |
25 | ||
26 | enum regulator_status { | |
27 | REGULATOR_STATUS_OFF, | |
28 | REGULATOR_STATUS_ON, | |
29 | REGULATOR_STATUS_ERROR, | |
30 | /* fast/normal/idle/standby are flavors of "on" */ | |
31 | REGULATOR_STATUS_FAST, | |
32 | REGULATOR_STATUS_NORMAL, | |
33 | REGULATOR_STATUS_IDLE, | |
34 | REGULATOR_STATUS_STANDBY, | |
35 | /* The regulator is enabled but not regulating */ | |
36 | REGULATOR_STATUS_BYPASS, | |
37 | /* in case that any other status doesn't apply */ | |
38 | REGULATOR_STATUS_UNDEFINED, | |
39 | }; | |
40 | ||
41 | /** | |
42 | * struct regulator_ops - regulator operations. | |
43 | * | |
44 | * @enable: Configure the regulator as enabled. | |
45 | * @disable: Configure the regulator as disabled. | |
46 | * @is_enabled: Return 1 if the regulator is enabled, 0 if not. | |
47 | * May also return negative errno. | |
48 | * | |
49 | * @set_voltage: Set the voltage for the regulator within the range specified. | |
50 | * The driver should select the voltage closest to min_uV. | |
51 | * @set_voltage_sel: Set the voltage for the regulator using the specified | |
52 | * selector. | |
53 | * @map_voltage: Convert a voltage into a selector | |
54 | * @get_voltage: Return the currently configured voltage for the regulator. | |
55 | * @get_voltage_sel: Return the currently configured voltage selector for the | |
56 | * regulator. | |
57 | * @list_voltage: Return one of the supported voltages, in microvolts; zero | |
58 | * if the selector indicates a voltage that is unusable on this system; | |
59 | * or negative errno. Selectors range from zero to one less than | |
60 | * regulator_desc.n_voltages. Voltages may be reported in any order. | |
61 | * | |
62 | * @set_current_limit: Configure a limit for a current-limited regulator. | |
63 | * The driver should select the current closest to max_uA. | |
64 | * @get_current_limit: Get the configured limit for a current-limited regulator. | |
65 | * | |
66 | * @set_mode: Set the configured operating mode for the regulator. | |
67 | * @get_mode: Get the configured operating mode for the regulator. | |
68 | * @get_status: Return actual (not as-configured) status of regulator, as a | |
69 | * REGULATOR_STATUS value (or negative errno) | |
70 | * @get_optimum_mode: Get the most efficient operating mode for the regulator | |
71 | * when running with the specified parameters. | |
72 | * | |
73 | * @set_bypass: Set the regulator in bypass mode. | |
74 | * @get_bypass: Get the regulator bypass mode state. | |
75 | * | |
76 | * @enable_time: Time taken for the regulator voltage output voltage to | |
77 | * stabilise after being enabled, in microseconds. | |
78 | * @set_ramp_delay: Set the ramp delay for the regulator. The driver should | |
79 | * select ramp delay equal to or less than(closest) ramp_delay. | |
80 | * @set_voltage_time_sel: Time taken for the regulator voltage output voltage | |
81 | * to stabilise after being set to a new value, in microseconds. | |
82 | * The function provides the from and to voltage selector, the | |
83 | * function should return the worst case. | |
84 | * | |
85 | * @set_suspend_voltage: Set the voltage for the regulator when the system | |
86 | * is suspended. | |
87 | * @set_suspend_enable: Mark the regulator as enabled when the system is | |
88 | * suspended. | |
89 | * @set_suspend_disable: Mark the regulator as disabled when the system is | |
90 | * suspended. | |
91 | * @set_suspend_mode: Set the operating mode for the regulator when the | |
92 | * system is suspended. | |
93 | * | |
94 | * This struct describes regulator operations which can be implemented by | |
95 | * regulator chip drivers. | |
96 | */ | |
97 | struct regulator_ops { | |
98 | ||
99 | /* enumerate supported voltages */ | |
100 | int (*list_voltage) (struct regulator_dev *, unsigned selector); | |
101 | ||
102 | /* get/set regulator voltage */ | |
103 | int (*set_voltage) (struct regulator_dev *, int min_uV, int max_uV, | |
104 | unsigned *selector); | |
105 | int (*map_voltage)(struct regulator_dev *, int min_uV, int max_uV); | |
106 | int (*set_voltage_sel) (struct regulator_dev *, unsigned selector); | |
107 | int (*get_voltage) (struct regulator_dev *); | |
108 | int (*get_voltage_sel) (struct regulator_dev *); | |
109 | ||
110 | /* get/set regulator current */ | |
111 | int (*set_current_limit) (struct regulator_dev *, | |
112 | int min_uA, int max_uA); | |
113 | int (*get_current_limit) (struct regulator_dev *); | |
114 | ||
115 | /* enable/disable regulator */ | |
116 | int (*enable) (struct regulator_dev *); | |
117 | int (*disable) (struct regulator_dev *); | |
118 | int (*is_enabled) (struct regulator_dev *); | |
119 | ||
120 | /* get/set regulator operating mode (defined in consumer.h) */ | |
121 | int (*set_mode) (struct regulator_dev *, unsigned int mode); | |
122 | unsigned int (*get_mode) (struct regulator_dev *); | |
123 | ||
124 | /* Time taken to enable or set voltage on the regulator */ | |
125 | int (*enable_time) (struct regulator_dev *); | |
126 | int (*set_ramp_delay) (struct regulator_dev *, int ramp_delay); | |
127 | int (*set_voltage_time_sel) (struct regulator_dev *, | |
128 | unsigned int old_selector, | |
129 | unsigned int new_selector); | |
130 | ||
131 | /* report regulator status ... most other accessors report | |
132 | * control inputs, this reports results of combining inputs | |
133 | * from Linux (and other sources) with the actual load. | |
134 | * returns REGULATOR_STATUS_* or negative errno. | |
135 | */ | |
136 | int (*get_status)(struct regulator_dev *); | |
137 | ||
138 | /* get most efficient regulator operating mode for load */ | |
139 | unsigned int (*get_optimum_mode) (struct regulator_dev *, int input_uV, | |
140 | int output_uV, int load_uA); | |
141 | ||
142 | /* control and report on bypass mode */ | |
143 | int (*set_bypass)(struct regulator_dev *dev, bool enable); | |
144 | int (*get_bypass)(struct regulator_dev *dev, bool *enable); | |
145 | ||
146 | /* the operations below are for configuration of regulator state when | |
147 | * its parent PMIC enters a global STANDBY/HIBERNATE state */ | |
148 | ||
149 | /* set regulator suspend voltage */ | |
150 | int (*set_suspend_voltage) (struct regulator_dev *, int uV); | |
151 | ||
152 | /* enable/disable regulator in suspend state */ | |
153 | int (*set_suspend_enable) (struct regulator_dev *); | |
154 | int (*set_suspend_disable) (struct regulator_dev *); | |
155 | ||
156 | /* set regulator suspend operating mode (defined in consumer.h) */ | |
157 | int (*set_suspend_mode) (struct regulator_dev *, unsigned int mode); | |
158 | }; | |
159 | ||
160 | /* | |
161 | * Regulators can either control voltage or current. | |
162 | */ | |
163 | enum regulator_type { | |
164 | REGULATOR_VOLTAGE, | |
165 | REGULATOR_CURRENT, | |
166 | }; | |
167 | ||
168 | /** | |
169 | * struct regulator_desc - Static regulator descriptor | |
170 | * | |
171 | * Each regulator registered with the core is described with a | |
172 | * structure of this type and a struct regulator_config. This | |
173 | * structure contains the non-varying parts of the regulator | |
174 | * description. | |
175 | * | |
176 | * @name: Identifying name for the regulator. | |
177 | * @supply_name: Identifying the regulator supply | |
178 | * @id: Numerical identifier for the regulator. | |
179 | * @ops: Regulator operations table. | |
180 | * @irq: Interrupt number for the regulator. | |
181 | * @type: Indicates if the regulator is a voltage or current regulator. | |
182 | * @owner: Module providing the regulator, used for refcounting. | |
183 | * | |
184 | * @continuous_voltage_range: Indicates if the regulator can set any | |
185 | * voltage within constrains range. | |
186 | * @n_voltages: Number of selectors available for ops.list_voltage(). | |
187 | * | |
188 | * @min_uV: Voltage given by the lowest selector (if linear mapping) | |
189 | * @uV_step: Voltage increase with each selector (if linear mapping) | |
190 | * @linear_min_sel: Minimal selector for starting linear mapping | |
191 | * @ramp_delay: Time to settle down after voltage change (unit: uV/us) | |
192 | * @volt_table: Voltage mapping table (if table based mapping) | |
193 | * | |
194 | * @vsel_reg: Register for selector when using regulator_regmap_X_voltage_ | |
195 | * @vsel_mask: Mask for register bitfield used for selector | |
196 | * @apply_reg: Register for initiate voltage change on the output when | |
197 | * using regulator_set_voltage_sel_regmap | |
198 | * @apply_bit: Register bitfield used for initiate voltage change on the | |
199 | * output when using regulator_set_voltage_sel_regmap | |
200 | * @enable_reg: Register for control when using regmap enable/disable ops | |
201 | * @enable_mask: Mask for control when using regmap enable/disable ops | |
202 | * @bypass_reg: Register for control when using regmap set_bypass | |
203 | * @bypass_mask: Mask for control when using regmap set_bypass | |
204 | * | |
205 | * @enable_time: Time taken for initial enable of regulator (in uS). | |
206 | */ | |
207 | struct regulator_desc { | |
208 | const char *name; | |
209 | const char *supply_name; | |
210 | int id; | |
211 | bool continuous_voltage_range; | |
212 | unsigned n_voltages; | |
213 | struct regulator_ops *ops; | |
214 | int irq; | |
215 | enum regulator_type type; | |
216 | struct module *owner; | |
217 | ||
218 | unsigned int min_uV; | |
219 | unsigned int uV_step; | |
220 | unsigned int linear_min_sel; | |
221 | unsigned int ramp_delay; | |
222 | ||
223 | const unsigned int *volt_table; | |
224 | ||
225 | unsigned int vsel_reg; | |
226 | unsigned int vsel_mask; | |
227 | unsigned int apply_reg; | |
228 | unsigned int apply_bit; | |
229 | unsigned int enable_reg; | |
230 | unsigned int enable_mask; | |
231 | unsigned int bypass_reg; | |
232 | unsigned int bypass_mask; | |
233 | ||
234 | unsigned int enable_time; | |
235 | }; | |
236 | ||
237 | /** | |
238 | * struct regulator_config - Dynamic regulator descriptor | |
239 | * | |
240 | * Each regulator registered with the core is described with a | |
241 | * structure of this type and a struct regulator_desc. This structure | |
242 | * contains the runtime variable parts of the regulator description. | |
243 | * | |
244 | * @dev: struct device for the regulator | |
245 | * @init_data: platform provided init data, passed through by driver | |
246 | * @driver_data: private regulator data | |
247 | * @of_node: OpenFirmware node to parse for device tree bindings (may be | |
248 | * NULL). | |
249 | * @regmap: regmap to use for core regmap helpers if dev_get_regulator() is | |
250 | * insufficient. | |
251 | * @ena_gpio: GPIO controlling regulator enable. | |
252 | * @ena_gpio_invert: Sense for GPIO enable control. | |
253 | * @ena_gpio_flags: Flags to use when calling gpio_request_one() | |
254 | */ | |
255 | struct regulator_config { | |
256 | struct device *dev; | |
257 | const struct regulator_init_data *init_data; | |
258 | void *driver_data; | |
259 | struct device_node *of_node; | |
260 | struct regmap *regmap; | |
261 | ||
262 | int ena_gpio; | |
263 | unsigned int ena_gpio_invert:1; | |
264 | unsigned int ena_gpio_flags; | |
265 | }; | |
266 | ||
267 | /* | |
268 | * struct regulator_dev | |
269 | * | |
270 | * Voltage / Current regulator class device. One for each | |
271 | * regulator. | |
272 | * | |
273 | * This should *not* be used directly by anything except the regulator | |
274 | * core and notification injection (which should take the mutex and do | |
275 | * no other direct access). | |
276 | */ | |
277 | struct regulator_dev { | |
278 | const struct regulator_desc *desc; | |
279 | int exclusive; | |
280 | u32 use_count; | |
281 | u32 open_count; | |
282 | u32 bypass_count; | |
283 | ||
284 | /* lists we belong to */ | |
285 | struct list_head list; /* list of all regulators */ | |
286 | ||
287 | /* lists we own */ | |
288 | struct list_head consumer_list; /* consumers we supply */ | |
289 | ||
290 | struct blocking_notifier_head notifier; | |
291 | struct mutex mutex; /* consumer lock */ | |
292 | struct module *owner; | |
293 | struct device dev; | |
294 | struct regulation_constraints *constraints; | |
295 | struct regulator *supply; /* for tree */ | |
296 | struct regmap *regmap; | |
297 | ||
298 | struct delayed_work disable_work; | |
299 | int deferred_disables; | |
300 | ||
301 | void *reg_data; /* regulator_dev data */ | |
302 | ||
303 | struct dentry *debugfs; | |
304 | ||
305 | int ena_gpio; | |
306 | unsigned int ena_gpio_invert:1; | |
307 | unsigned int ena_gpio_state:1; | |
308 | }; | |
309 | ||
310 | struct regulator_dev * | |
311 | regulator_register(const struct regulator_desc *regulator_desc, | |
312 | const struct regulator_config *config); | |
313 | void regulator_unregister(struct regulator_dev *rdev); | |
314 | ||
315 | int regulator_notifier_call_chain(struct regulator_dev *rdev, | |
316 | unsigned long event, void *data); | |
317 | ||
318 | void *rdev_get_drvdata(struct regulator_dev *rdev); | |
319 | struct device *rdev_get_dev(struct regulator_dev *rdev); | |
320 | int rdev_get_id(struct regulator_dev *rdev); | |
321 | ||
322 | int regulator_mode_to_status(unsigned int); | |
323 | ||
324 | int regulator_list_voltage_linear(struct regulator_dev *rdev, | |
325 | unsigned int selector); | |
326 | int regulator_list_voltage_table(struct regulator_dev *rdev, | |
327 | unsigned int selector); | |
328 | int regulator_map_voltage_linear(struct regulator_dev *rdev, | |
329 | int min_uV, int max_uV); | |
330 | int regulator_map_voltage_iterate(struct regulator_dev *rdev, | |
331 | int min_uV, int max_uV); | |
332 | int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev); | |
333 | int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel); | |
334 | int regulator_is_enabled_regmap(struct regulator_dev *rdev); | |
335 | int regulator_enable_regmap(struct regulator_dev *rdev); | |
336 | int regulator_disable_regmap(struct regulator_dev *rdev); | |
337 | int regulator_set_voltage_time_sel(struct regulator_dev *rdev, | |
338 | unsigned int old_selector, | |
339 | unsigned int new_selector); | |
340 | int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable); | |
341 | int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable); | |
342 | ||
343 | void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data); | |
344 | ||
345 | #endif |