1/*
2 * fixed.c
3 *
4 * Copyright 2008 Wolfson Microelectronics PLC.
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 *
8 * Copyright (c) 2009 Nokia Corporation
9 * Roger Quadros <ext-roger.quadros@nokia.com>
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of the
14 * License, or (at your option) any later version.
15 *
16 * This is useful for systems with mixed controllable and
17 * non-controllable regulators, as well as for allowing testing on
18 * systems with no controllable regulators.
19 */
20
21#include <linux/err.h>
22#include <linux/mutex.h>
23#include <linux/module.h>
24#include <linux/platform_device.h>
25#include <linux/regulator/driver.h>
26#include <linux/regulator/fixed.h>
27#include <linux/gpio.h>
28#include <linux/slab.h>
29#include <linux/of.h>
30#include <linux/of_gpio.h>
31#include <linux/regulator/of_regulator.h>
32#include <linux/regulator/machine.h>
33
34struct fixed_voltage_data {
35	struct regulator_desc desc;
36	struct regulator_dev *dev;
37};
38
39
40/**
41 * of_get_fixed_voltage_config - extract fixed_voltage_config structure info
42 * @dev: device requesting for fixed_voltage_config
43 * @desc: regulator description
44 *
45 * Populates fixed_voltage_config structure by extracting data from device
46 * tree node, returns a pointer to the populated structure of NULL if memory
47 * alloc fails.
48 */
49static struct fixed_voltage_config *
50of_get_fixed_voltage_config(struct device *dev,
51			    const struct regulator_desc *desc)
52{
53	struct fixed_voltage_config *config;
54	struct device_node *np = dev->of_node;
55	struct regulator_init_data *init_data;
56
57	config = devm_kzalloc(dev, sizeof(struct fixed_voltage_config),
58								 GFP_KERNEL);
59	if (!config)
60		return ERR_PTR(-ENOMEM);
61
62	config->init_data = of_get_regulator_init_data(dev, dev->of_node, desc);
63	if (!config->init_data)
64		return ERR_PTR(-EINVAL);
65
66	init_data = config->init_data;
67	init_data->constraints.apply_uV = 0;
68
69	config->supply_name = init_data->constraints.name;
70	if (init_data->constraints.min_uV == init_data->constraints.max_uV) {
71		config->microvolts = init_data->constraints.min_uV;
72	} else {
73		dev_err(dev,
74			 "Fixed regulator specified with variable voltages\n");
75		return ERR_PTR(-EINVAL);
76	}
77
78	if (init_data->constraints.boot_on)
79		config->enabled_at_boot = true;
80
81	config->gpio = of_get_named_gpio(np, "gpio", 0);
82	/*
83	 * of_get_named_gpio() currently returns ENODEV rather than
84	 * EPROBE_DEFER. This code attempts to be compatible with both
85	 * for now; the ENODEV check can be removed once the API is fixed.
86	 * of_get_named_gpio() doesn't differentiate between a missing
87	 * property (which would be fine here, since the GPIO is optional)
88	 * and some other error. Patches have been posted for both issues.
89	 * Once they are check in, we should replace this with:
90	 * if (config->gpio < 0 && config->gpio != -ENOENT)
91	 */
92	if ((config->gpio == -ENODEV) || (config->gpio == -EPROBE_DEFER))
93		return ERR_PTR(-EPROBE_DEFER);
94
95	of_property_read_u32(np, "startup-delay-us", &config->startup_delay);
96
97	config->enable_high = of_property_read_bool(np, "enable-active-high");
98	config->gpio_is_open_drain = of_property_read_bool(np,
99							   "gpio-open-drain");
100
101	if (of_find_property(np, "vin-supply", NULL))
102		config->input_supply = "vin";
103
104	return config;
105}
106
107static struct regulator_ops fixed_voltage_ops = {
108};
109
110static int reg_fixed_voltage_probe(struct platform_device *pdev)
111{
112	struct fixed_voltage_config *config;
113	struct fixed_voltage_data *drvdata;
114	struct regulator_config cfg = { };
115	int ret;
116
117	drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data),
118			       GFP_KERNEL);
119	if (!drvdata)
120		return -ENOMEM;
121
122	if (pdev->dev.of_node) {
123		config = of_get_fixed_voltage_config(&pdev->dev,
124						     &drvdata->desc);
125		if (IS_ERR(config))
126			return PTR_ERR(config);
127	} else {
128		config = dev_get_platdata(&pdev->dev);
129	}
130
131	if (!config)
132		return -ENOMEM;
133
134	drvdata->desc.name = devm_kstrdup(&pdev->dev,
135					  config->supply_name,
136					  GFP_KERNEL);
137	if (drvdata->desc.name == NULL) {
138		dev_err(&pdev->dev, "Failed to allocate supply name\n");
139		return -ENOMEM;
140	}
141	drvdata->desc.type = REGULATOR_VOLTAGE;
142	drvdata->desc.owner = THIS_MODULE;
143	drvdata->desc.ops = &fixed_voltage_ops;
144
145	drvdata->desc.enable_time = config->startup_delay;
146
147	if (config->input_supply) {
148		drvdata->desc.supply_name = devm_kstrdup(&pdev->dev,
149					    config->input_supply,
150					    GFP_KERNEL);
151		if (!drvdata->desc.supply_name) {
152			dev_err(&pdev->dev,
153				"Failed to allocate input supply\n");
154			return -ENOMEM;
155		}
156	}
157
158	if (config->microvolts)
159		drvdata->desc.n_voltages = 1;
160
161	drvdata->desc.fixed_uV = config->microvolts;
162
163	if (gpio_is_valid(config->gpio)) {
164		cfg.ena_gpio = config->gpio;
165		if (pdev->dev.of_node)
166			cfg.ena_gpio_initialized = true;
167	}
168	cfg.ena_gpio_invert = !config->enable_high;
169	if (config->enabled_at_boot) {
170		if (config->enable_high)
171			cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
172		else
173			cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
174	} else {
175		if (config->enable_high)
176			cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
177		else
178			cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
179	}
180	if (config->gpio_is_open_drain)
181		cfg.ena_gpio_flags |= GPIOF_OPEN_DRAIN;
182
183	cfg.dev = &pdev->dev;
184	cfg.init_data = config->init_data;
185	cfg.driver_data = drvdata;
186	cfg.of_node = pdev->dev.of_node;
187
188	drvdata->dev = devm_regulator_register(&pdev->dev, &drvdata->desc,
189					       &cfg);
190	if (IS_ERR(drvdata->dev)) {
191		ret = PTR_ERR(drvdata->dev);
192		dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
193		return ret;
194	}
195
196	platform_set_drvdata(pdev, drvdata);
197
198	dev_dbg(&pdev->dev, "%s supplying %duV\n", drvdata->desc.name,
199		drvdata->desc.fixed_uV);
200
201	return 0;
202}
203
204#if defined(CONFIG_OF)
205static const struct of_device_id fixed_of_match[] = {
206	{ .compatible = "regulator-fixed", },
207	{},
208};
209MODULE_DEVICE_TABLE(of, fixed_of_match);
210#endif
211
212static struct platform_driver regulator_fixed_voltage_driver = {
213	.probe		= reg_fixed_voltage_probe,
214	.driver		= {
215		.name		= "reg-fixed-voltage",
216		.of_match_table = of_match_ptr(fixed_of_match),
217	},
218};
219
220static int __init regulator_fixed_voltage_init(void)
221{
222	return platform_driver_register(&regulator_fixed_voltage_driver);
223}
224subsys_initcall(regulator_fixed_voltage_init);
225
226static void __exit regulator_fixed_voltage_exit(void)
227{
228	platform_driver_unregister(&regulator_fixed_voltage_driver);
229}
230module_exit(regulator_fixed_voltage_exit);
231
232MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
233MODULE_DESCRIPTION("Fixed voltage regulator");
234MODULE_LICENSE("GPL");
235MODULE_ALIAS("platform:reg-fixed-voltage");
236