1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * fixed.c |
4 | * |
5 | * Copyright 2008 Wolfson Microelectronics PLC. |
6 | * |
7 | * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> |
8 | * |
9 | * Copyright (c) 2009 Nokia Corporation |
10 | * Roger Quadros <ext-roger.quadros@nokia.com> |
11 | * |
12 | * This is useful for systems with mixed controllable and |
13 | * non-controllable regulators, as well as for allowing testing on |
14 | * systems with no controllable regulators. |
15 | */ |
16 | |
17 | #include <linux/err.h> |
18 | #include <linux/mutex.h> |
19 | #include <linux/module.h> |
20 | #include <linux/platform_device.h> |
21 | #include <linux/pm_domain.h> |
22 | #include <linux/pm_opp.h> |
23 | #include <linux/reboot.h> |
24 | #include <linux/regulator/driver.h> |
25 | #include <linux/regulator/fixed.h> |
26 | #include <linux/gpio/consumer.h> |
27 | #include <linux/slab.h> |
28 | #include <linux/of.h> |
29 | #include <linux/regulator/of_regulator.h> |
30 | #include <linux/regulator/machine.h> |
31 | #include <linux/clk.h> |
32 | |
33 | /* Default time in millisecond to wait for emergency shutdown */ |
34 | #define FV_DEF_EMERG_SHUTDWN_TMO 10 |
35 | |
36 | struct fixed_voltage_data { |
37 | struct regulator_desc desc; |
38 | struct regulator_dev *dev; |
39 | |
40 | struct clk *enable_clock; |
41 | unsigned int enable_counter; |
42 | int performance_state; |
43 | }; |
44 | |
45 | struct fixed_dev_type { |
46 | bool has_enable_clock; |
47 | bool has_performance_state; |
48 | }; |
49 | |
50 | static int reg_clock_enable(struct regulator_dev *rdev) |
51 | { |
52 | struct fixed_voltage_data *priv = rdev_get_drvdata(rdev); |
53 | int ret = 0; |
54 | |
55 | ret = clk_prepare_enable(clk: priv->enable_clock); |
56 | if (ret) |
57 | return ret; |
58 | |
59 | priv->enable_counter++; |
60 | |
61 | return ret; |
62 | } |
63 | |
64 | static int reg_clock_disable(struct regulator_dev *rdev) |
65 | { |
66 | struct fixed_voltage_data *priv = rdev_get_drvdata(rdev); |
67 | |
68 | clk_disable_unprepare(clk: priv->enable_clock); |
69 | priv->enable_counter--; |
70 | |
71 | return 0; |
72 | } |
73 | |
74 | static int reg_domain_enable(struct regulator_dev *rdev) |
75 | { |
76 | struct fixed_voltage_data *priv = rdev_get_drvdata(rdev); |
77 | struct device *dev = rdev->dev.parent; |
78 | int ret; |
79 | |
80 | ret = dev_pm_genpd_set_performance_state(dev, state: priv->performance_state); |
81 | if (ret) |
82 | return ret; |
83 | |
84 | priv->enable_counter++; |
85 | |
86 | return ret; |
87 | } |
88 | |
89 | static int reg_domain_disable(struct regulator_dev *rdev) |
90 | { |
91 | struct fixed_voltage_data *priv = rdev_get_drvdata(rdev); |
92 | struct device *dev = rdev->dev.parent; |
93 | int ret; |
94 | |
95 | ret = dev_pm_genpd_set_performance_state(dev, state: 0); |
96 | if (ret) |
97 | return ret; |
98 | |
99 | priv->enable_counter--; |
100 | |
101 | return 0; |
102 | } |
103 | |
104 | static int reg_is_enabled(struct regulator_dev *rdev) |
105 | { |
106 | struct fixed_voltage_data *priv = rdev_get_drvdata(rdev); |
107 | |
108 | return priv->enable_counter > 0; |
109 | } |
110 | |
111 | static irqreturn_t reg_fixed_under_voltage_irq_handler(int irq, void *data) |
112 | { |
113 | struct fixed_voltage_data *priv = data; |
114 | struct regulator_dev *rdev = priv->dev; |
115 | |
116 | regulator_notifier_call_chain(rdev, REGULATOR_EVENT_UNDER_VOLTAGE, |
117 | NULL); |
118 | |
119 | return IRQ_HANDLED; |
120 | } |
121 | |
122 | /** |
123 | * reg_fixed_get_irqs - Get and register the optional IRQ for fixed voltage |
124 | * regulator. |
125 | * @dev: Pointer to the device structure. |
126 | * @priv: Pointer to fixed_voltage_data structure containing private data. |
127 | * |
128 | * This function tries to get the IRQ from the device firmware node. |
129 | * If it's an optional IRQ and not found, it returns 0. |
130 | * Otherwise, it attempts to request the threaded IRQ. |
131 | * |
132 | * Return: 0 on success, or error code on failure. |
133 | */ |
134 | static int reg_fixed_get_irqs(struct device *dev, |
135 | struct fixed_voltage_data *priv) |
136 | { |
137 | int ret; |
138 | |
139 | ret = fwnode_irq_get(dev_fwnode(dev), index: 0); |
140 | /* This is optional IRQ. If not found we will get -EINVAL */ |
141 | if (ret == -EINVAL) |
142 | return 0; |
143 | if (ret < 0) |
144 | return dev_err_probe(dev, err: ret, fmt: "Failed to get IRQ\n" ); |
145 | |
146 | ret = devm_request_threaded_irq(dev, irq: ret, NULL, |
147 | thread_fn: reg_fixed_under_voltage_irq_handler, |
148 | IRQF_ONESHOT, devname: "under-voltage" , dev_id: priv); |
149 | if (ret) |
150 | return dev_err_probe(dev, err: ret, fmt: "Failed to request IRQ\n" ); |
151 | |
152 | return 0; |
153 | } |
154 | |
155 | /** |
156 | * of_get_fixed_voltage_config - extract fixed_voltage_config structure info |
157 | * @dev: device requesting for fixed_voltage_config |
158 | * @desc: regulator description |
159 | * |
160 | * Populates fixed_voltage_config structure by extracting data from device |
161 | * tree node, returns a pointer to the populated structure of NULL if memory |
162 | * alloc fails. |
163 | */ |
164 | static struct fixed_voltage_config * |
165 | of_get_fixed_voltage_config(struct device *dev, |
166 | const struct regulator_desc *desc) |
167 | { |
168 | struct fixed_voltage_config *config; |
169 | struct device_node *np = dev->of_node; |
170 | struct regulator_init_data *init_data; |
171 | |
172 | config = devm_kzalloc(dev, size: sizeof(struct fixed_voltage_config), |
173 | GFP_KERNEL); |
174 | if (!config) |
175 | return ERR_PTR(error: -ENOMEM); |
176 | |
177 | config->init_data = of_get_regulator_init_data(dev, node: dev->of_node, desc); |
178 | if (!config->init_data) |
179 | return ERR_PTR(error: -EINVAL); |
180 | |
181 | init_data = config->init_data; |
182 | init_data->constraints.apply_uV = 0; |
183 | |
184 | config->supply_name = init_data->constraints.name; |
185 | if (init_data->constraints.min_uV == init_data->constraints.max_uV) { |
186 | config->microvolts = init_data->constraints.min_uV; |
187 | } else { |
188 | dev_err(dev, |
189 | "Fixed regulator specified with variable voltages\n" ); |
190 | return ERR_PTR(error: -EINVAL); |
191 | } |
192 | |
193 | if (init_data->constraints.boot_on) |
194 | config->enabled_at_boot = true; |
195 | |
196 | of_property_read_u32(np, propname: "startup-delay-us" , out_value: &config->startup_delay); |
197 | of_property_read_u32(np, propname: "off-on-delay-us" , out_value: &config->off_on_delay); |
198 | |
199 | if (of_property_present(np, propname: "vin-supply" )) |
200 | config->input_supply = "vin" ; |
201 | |
202 | return config; |
203 | } |
204 | |
205 | static const struct regulator_ops fixed_voltage_ops = { |
206 | }; |
207 | |
208 | static const struct regulator_ops fixed_voltage_clkenabled_ops = { |
209 | .enable = reg_clock_enable, |
210 | .disable = reg_clock_disable, |
211 | .is_enabled = reg_is_enabled, |
212 | }; |
213 | |
214 | static const struct regulator_ops fixed_voltage_domain_ops = { |
215 | .enable = reg_domain_enable, |
216 | .disable = reg_domain_disable, |
217 | .is_enabled = reg_is_enabled, |
218 | }; |
219 | |
220 | static int reg_fixed_voltage_probe(struct platform_device *pdev) |
221 | { |
222 | struct device *dev = &pdev->dev; |
223 | struct fixed_voltage_config *config; |
224 | struct fixed_voltage_data *drvdata; |
225 | const struct fixed_dev_type *drvtype = of_device_get_match_data(dev); |
226 | struct regulator_config cfg = { }; |
227 | enum gpiod_flags gflags; |
228 | int ret; |
229 | |
230 | drvdata = devm_kzalloc(dev: &pdev->dev, size: sizeof(struct fixed_voltage_data), |
231 | GFP_KERNEL); |
232 | if (!drvdata) |
233 | return -ENOMEM; |
234 | |
235 | if (pdev->dev.of_node) { |
236 | config = of_get_fixed_voltage_config(dev: &pdev->dev, |
237 | desc: &drvdata->desc); |
238 | if (IS_ERR(ptr: config)) |
239 | return PTR_ERR(ptr: config); |
240 | } else { |
241 | config = dev_get_platdata(dev: &pdev->dev); |
242 | } |
243 | |
244 | if (!config) |
245 | return -ENOMEM; |
246 | |
247 | drvdata->desc.name = devm_kstrdup(dev: &pdev->dev, |
248 | s: config->supply_name, |
249 | GFP_KERNEL); |
250 | if (drvdata->desc.name == NULL) { |
251 | dev_err(&pdev->dev, "Failed to allocate supply name\n" ); |
252 | return -ENOMEM; |
253 | } |
254 | drvdata->desc.type = REGULATOR_VOLTAGE; |
255 | drvdata->desc.owner = THIS_MODULE; |
256 | |
257 | if (drvtype && drvtype->has_enable_clock) { |
258 | drvdata->desc.ops = &fixed_voltage_clkenabled_ops; |
259 | |
260 | drvdata->enable_clock = devm_clk_get(dev, NULL); |
261 | if (IS_ERR(ptr: drvdata->enable_clock)) { |
262 | dev_err(dev, "Can't get enable-clock from devicetree\n" ); |
263 | return PTR_ERR(ptr: drvdata->enable_clock); |
264 | } |
265 | } else if (drvtype && drvtype->has_performance_state) { |
266 | drvdata->desc.ops = &fixed_voltage_domain_ops; |
267 | |
268 | drvdata->performance_state = of_get_required_opp_performance_state(np: dev->of_node, index: 0); |
269 | if (drvdata->performance_state < 0) { |
270 | dev_err(dev, "Can't get performance state from devicetree\n" ); |
271 | return drvdata->performance_state; |
272 | } |
273 | } else { |
274 | drvdata->desc.ops = &fixed_voltage_ops; |
275 | } |
276 | |
277 | drvdata->desc.enable_time = config->startup_delay; |
278 | drvdata->desc.off_on_delay = config->off_on_delay; |
279 | |
280 | if (config->input_supply) { |
281 | drvdata->desc.supply_name = devm_kstrdup(dev: &pdev->dev, |
282 | s: config->input_supply, |
283 | GFP_KERNEL); |
284 | if (!drvdata->desc.supply_name) |
285 | return -ENOMEM; |
286 | } |
287 | |
288 | if (config->microvolts) |
289 | drvdata->desc.n_voltages = 1; |
290 | |
291 | drvdata->desc.fixed_uV = config->microvolts; |
292 | |
293 | /* |
294 | * The signal will be inverted by the GPIO core if flagged so in the |
295 | * descriptor. |
296 | */ |
297 | if (config->enabled_at_boot) |
298 | gflags = GPIOD_OUT_HIGH; |
299 | else |
300 | gflags = GPIOD_OUT_LOW; |
301 | |
302 | /* |
303 | * Some fixed regulators share the enable line between two |
304 | * regulators which makes it necessary to get a handle on the |
305 | * same descriptor for two different consumers. This will get |
306 | * the GPIO descriptor, but only the first call will initialize |
307 | * it so any flags such as inversion or open drain will only |
308 | * be set up by the first caller and assumed identical on the |
309 | * next caller. |
310 | * |
311 | * FIXME: find a better way to deal with this. |
312 | */ |
313 | gflags |= GPIOD_FLAGS_BIT_NONEXCLUSIVE; |
314 | |
315 | /* |
316 | * Do not use devm* here: the regulator core takes over the |
317 | * lifecycle management of the GPIO descriptor. |
318 | */ |
319 | cfg.ena_gpiod = gpiod_get_optional(dev: &pdev->dev, NULL, flags: gflags); |
320 | if (IS_ERR(ptr: cfg.ena_gpiod)) |
321 | return dev_err_probe(dev: &pdev->dev, err: PTR_ERR(ptr: cfg.ena_gpiod), |
322 | fmt: "can't get GPIO\n" ); |
323 | |
324 | cfg.dev = &pdev->dev; |
325 | cfg.init_data = config->init_data; |
326 | cfg.driver_data = drvdata; |
327 | cfg.of_node = pdev->dev.of_node; |
328 | |
329 | drvdata->dev = devm_regulator_register(dev: &pdev->dev, regulator_desc: &drvdata->desc, |
330 | config: &cfg); |
331 | if (IS_ERR(ptr: drvdata->dev)) { |
332 | ret = dev_err_probe(dev: &pdev->dev, err: PTR_ERR(ptr: drvdata->dev), |
333 | fmt: "Failed to register regulator: %ld\n" , |
334 | PTR_ERR(ptr: drvdata->dev)); |
335 | return ret; |
336 | } |
337 | |
338 | platform_set_drvdata(pdev, data: drvdata); |
339 | |
340 | dev_dbg(&pdev->dev, "%s supplying %duV\n" , drvdata->desc.name, |
341 | drvdata->desc.fixed_uV); |
342 | |
343 | ret = reg_fixed_get_irqs(dev, priv: drvdata); |
344 | if (ret) |
345 | return ret; |
346 | |
347 | return 0; |
348 | } |
349 | |
350 | #if defined(CONFIG_OF) |
351 | static const struct fixed_dev_type fixed_voltage_data = { |
352 | .has_enable_clock = false, |
353 | }; |
354 | |
355 | static const struct fixed_dev_type fixed_clkenable_data = { |
356 | .has_enable_clock = true, |
357 | }; |
358 | |
359 | static const struct fixed_dev_type fixed_domain_data = { |
360 | .has_performance_state = true, |
361 | }; |
362 | |
363 | static const struct of_device_id fixed_of_match[] = { |
364 | { |
365 | .compatible = "regulator-fixed" , |
366 | .data = &fixed_voltage_data, |
367 | }, |
368 | { |
369 | .compatible = "regulator-fixed-clock" , |
370 | .data = &fixed_clkenable_data, |
371 | }, |
372 | { |
373 | .compatible = "regulator-fixed-domain" , |
374 | .data = &fixed_domain_data, |
375 | }, |
376 | { |
377 | }, |
378 | }; |
379 | MODULE_DEVICE_TABLE(of, fixed_of_match); |
380 | #endif |
381 | |
382 | static struct platform_driver regulator_fixed_voltage_driver = { |
383 | .probe = reg_fixed_voltage_probe, |
384 | .driver = { |
385 | .name = "reg-fixed-voltage" , |
386 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
387 | .of_match_table = of_match_ptr(fixed_of_match), |
388 | }, |
389 | }; |
390 | |
391 | static int __init regulator_fixed_voltage_init(void) |
392 | { |
393 | return platform_driver_register(®ulator_fixed_voltage_driver); |
394 | } |
395 | subsys_initcall(regulator_fixed_voltage_init); |
396 | |
397 | static void __exit regulator_fixed_voltage_exit(void) |
398 | { |
399 | platform_driver_unregister(®ulator_fixed_voltage_driver); |
400 | } |
401 | module_exit(regulator_fixed_voltage_exit); |
402 | |
403 | MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>" ); |
404 | MODULE_DESCRIPTION("Fixed voltage regulator" ); |
405 | MODULE_LICENSE("GPL" ); |
406 | MODULE_ALIAS("platform:reg-fixed-voltage" ); |
407 | |