?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
irqchip/s3c24xx: Mark init_eint as __maybe_unused
[linux/fpc-iii.git] / drivers / regulator / axp20x-regulator.c
blob35de22fdb7a06d96e0bb7bdf3e199165b5b83cc1
1 /*
2 * AXP20x regulators driver.
3 *
4 * Copyright (C) 2013 Carlo Caione <carlo@caione.org>
5 *
6 * This file is subject to the terms and conditions of the GNU General
7 * Public License. See the file "COPYING" in the main directory of this
8 * archive for more details.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15
16 #include <linux/err.h>
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/of_device.h>
21 #include <linux/platform_device.h>
22 #include <linux/regmap.h>
23 #include <linux/mfd/axp20x.h>
24 #include <linux/regulator/driver.h>
25 #include <linux/regulator/of_regulator.h>
26
27 #define AXP20X_IO_ENABLED 0x03
28 #define AXP20X_IO_DISABLED 0x07
29
30 #define AXP22X_IO_ENABLED 0x04
31 #define AXP22X_IO_DISABLED 0x03
32
33 #define AXP20X_WORKMODE_DCDC2_MASK BIT(2)
34 #define AXP20X_WORKMODE_DCDC3_MASK BIT(1)
35 #define AXP22X_WORKMODE_DCDCX_MASK(x) BIT(x)
36
37 #define AXP20X_FREQ_DCDC_MASK 0x0f
38
39 #define AXP_DESC_IO(_family, _id, _match, _supply, _min, _max, _step, _vreg, \
40 _vmask, _ereg, _emask, _enable_val, _disable_val) \
41 [_family##_##_id] = { \
42 .name = #_id, \
43 .supply_name = (_supply), \
44 .of_match = of_match_ptr(_match), \
45 .regulators_node = of_match_ptr("regulators"), \
46 .type = REGULATOR_VOLTAGE, \
47 .id = _family##_##_id, \
48 .n_voltages = (((_max) - (_min)) / (_step) + 1), \
49 .owner = THIS_MODULE, \
50 .min_uV = (_min) * 1000, \
51 .uV_step = (_step) * 1000, \
52 .vsel_reg = (_vreg), \
53 .vsel_mask = (_vmask), \
54 .enable_reg = (_ereg), \
55 .enable_mask = (_emask), \
56 .enable_val = (_enable_val), \
57 .disable_val = (_disable_val), \
58 .ops = &axp20x_ops, \
59 }
60
61 #define AXP_DESC(_family, _id, _match, _supply, _min, _max, _step, _vreg, \
62 _vmask, _ereg, _emask) \
63 [_family##_##_id] = { \
64 .name = #_id, \
65 .supply_name = (_supply), \
66 .of_match = of_match_ptr(_match), \
67 .regulators_node = of_match_ptr("regulators"), \
68 .type = REGULATOR_VOLTAGE, \
69 .id = _family##_##_id, \
70 .n_voltages = (((_max) - (_min)) / (_step) + 1), \
71 .owner = THIS_MODULE, \
72 .min_uV = (_min) * 1000, \
73 .uV_step = (_step) * 1000, \
74 .vsel_reg = (_vreg), \
75 .vsel_mask = (_vmask), \
76 .enable_reg = (_ereg), \
77 .enable_mask = (_emask), \
78 .ops = &axp20x_ops, \
79 }
80
81 #define AXP_DESC_SW(_family, _id, _match, _supply, _min, _max, _step, _vreg, \
82 _vmask, _ereg, _emask) \
83 [_family##_##_id] = { \
84 .name = #_id, \
85 .supply_name = (_supply), \
86 .of_match = of_match_ptr(_match), \
87 .regulators_node = of_match_ptr("regulators"), \
88 .type = REGULATOR_VOLTAGE, \
89 .id = _family##_##_id, \
90 .n_voltages = (((_max) - (_min)) / (_step) + 1), \
91 .owner = THIS_MODULE, \
92 .min_uV = (_min) * 1000, \
93 .uV_step = (_step) * 1000, \
94 .vsel_reg = (_vreg), \
95 .vsel_mask = (_vmask), \
96 .enable_reg = (_ereg), \
97 .enable_mask = (_emask), \
98 .ops = &axp20x_ops_sw, \
99 }
100
101 #define AXP_DESC_FIXED(_family, _id, _match, _supply, _volt) \
102 [_family##_##_id] = { \
103 .name = #_id, \
104 .supply_name = (_supply), \
105 .of_match = of_match_ptr(_match), \
106 .regulators_node = of_match_ptr("regulators"), \
107 .type = REGULATOR_VOLTAGE, \
108 .id = _family##_##_id, \
109 .n_voltages = 1, \
110 .owner = THIS_MODULE, \
111 .min_uV = (_volt) * 1000, \
112 .ops = &axp20x_ops_fixed \
113 }
114
115 #define AXP_DESC_TABLE(_family, _id, _match, _supply, _table, _vreg, _vmask, \
116 _ereg, _emask) \
117 [_family##_##_id] = { \
118 .name = #_id, \
119 .supply_name = (_supply), \
120 .of_match = of_match_ptr(_match), \
121 .regulators_node = of_match_ptr("regulators"), \
122 .type = REGULATOR_VOLTAGE, \
123 .id = _family##_##_id, \
124 .n_voltages = ARRAY_SIZE(_table), \
125 .owner = THIS_MODULE, \
126 .vsel_reg = (_vreg), \
127 .vsel_mask = (_vmask), \
128 .enable_reg = (_ereg), \
129 .enable_mask = (_emask), \
130 .volt_table = (_table), \
131 .ops = &axp20x_ops_table, \
132 }
133
134 static const int axp20x_ldo4_data[] = { 1250000, 1300000, 1400000, 1500000, 1600000,
135 1700000, 1800000, 1900000, 2000000, 2500000,
136 2700000, 2800000, 3000000, 3100000, 3200000,
137 3300000 };
138
139 static struct regulator_ops axp20x_ops_fixed = {
140 .list_voltage = regulator_list_voltage_linear,
141 };
142
143 static struct regulator_ops axp20x_ops_table = {
144 .set_voltage_sel = regulator_set_voltage_sel_regmap,
145 .get_voltage_sel = regulator_get_voltage_sel_regmap,
146 .list_voltage = regulator_list_voltage_table,
147 .map_voltage = regulator_map_voltage_ascend,
148 .enable = regulator_enable_regmap,
149 .disable = regulator_disable_regmap,
150 .is_enabled = regulator_is_enabled_regmap,
151 };
152
153 static struct regulator_ops axp20x_ops = {
154 .set_voltage_sel = regulator_set_voltage_sel_regmap,
155 .get_voltage_sel = regulator_get_voltage_sel_regmap,
156 .list_voltage = regulator_list_voltage_linear,
157 .enable = regulator_enable_regmap,
158 .disable = regulator_disable_regmap,
159 .is_enabled = regulator_is_enabled_regmap,
160 };
161
162 static struct regulator_ops axp20x_ops_sw = {
163 .get_voltage_sel = regulator_get_voltage_sel_regmap,
164 .list_voltage = regulator_list_voltage_linear,
165 .enable = regulator_enable_regmap,
166 .disable = regulator_disable_regmap,
167 .is_enabled = regulator_is_enabled_regmap,
168 };
169
170 static const struct regulator_desc axp20x_regulators[] = {
171 AXP_DESC(AXP20X, DCDC2, "dcdc2", "vin2", 700, 2275, 25,
172 AXP20X_DCDC2_V_OUT, 0x3f, AXP20X_PWR_OUT_CTRL, 0x10),
173 AXP_DESC(AXP20X, DCDC3, "dcdc3", "vin3", 700, 3500, 25,
174 AXP20X_DCDC3_V_OUT, 0x7f, AXP20X_PWR_OUT_CTRL, 0x02),
175 AXP_DESC_FIXED(AXP20X, LDO1, "ldo1", "acin", 1300),
176 AXP_DESC(AXP20X, LDO2, "ldo2", "ldo24in", 1800, 3300, 100,
177 AXP20X_LDO24_V_OUT, 0xf0, AXP20X_PWR_OUT_CTRL, 0x04),
178 AXP_DESC(AXP20X, LDO3, "ldo3", "ldo3in", 700, 3500, 25,
179 AXP20X_LDO3_V_OUT, 0x7f, AXP20X_PWR_OUT_CTRL, 0x40),
180 AXP_DESC_TABLE(AXP20X, LDO4, "ldo4", "ldo24in", axp20x_ldo4_data,
181 AXP20X_LDO24_V_OUT, 0x0f, AXP20X_PWR_OUT_CTRL, 0x08),
182 AXP_DESC_IO(AXP20X, LDO5, "ldo5", "ldo5in", 1800, 3300, 100,
183 AXP20X_LDO5_V_OUT, 0xf0, AXP20X_GPIO0_CTRL, 0x07,
184 AXP20X_IO_ENABLED, AXP20X_IO_DISABLED),
185 };
186
187 static const struct regulator_desc axp22x_regulators[] = {
188 AXP_DESC(AXP22X, DCDC1, "dcdc1", "vin1", 1600, 3400, 100,
189 AXP22X_DCDC1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL1, BIT(1)),
190 AXP_DESC(AXP22X, DCDC2, "dcdc2", "vin2", 600, 1540, 20,
191 AXP22X_DCDC2_V_OUT, 0x3f, AXP22X_PWR_OUT_CTRL1, BIT(2)),
192 AXP_DESC(AXP22X, DCDC3, "dcdc3", "vin3", 600, 1860, 20,
193 AXP22X_DCDC3_V_OUT, 0x3f, AXP22X_PWR_OUT_CTRL1, BIT(3)),
194 AXP_DESC(AXP22X, DCDC4, "dcdc4", "vin4", 600, 1540, 20,
195 AXP22X_DCDC4_V_OUT, 0x3f, AXP22X_PWR_OUT_CTRL1, BIT(4)),
196 AXP_DESC(AXP22X, DCDC5, "dcdc5", "vin5", 1000, 2550, 50,
197 AXP22X_DCDC5_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL1, BIT(5)),
198 /* secondary switchable output of DCDC1 */
199 AXP_DESC_SW(AXP22X, DC1SW, "dc1sw", NULL, 1600, 3400, 100,
200 AXP22X_DCDC1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(7)),
201 /* LDO regulator internally chained to DCDC5 */
202 AXP_DESC(AXP22X, DC5LDO, "dc5ldo", NULL, 700, 1400, 100,
203 AXP22X_DC5LDO_V_OUT, 0x7, AXP22X_PWR_OUT_CTRL1, BIT(0)),
204 AXP_DESC(AXP22X, ALDO1, "aldo1", "aldoin", 700, 3300, 100,
205 AXP22X_ALDO1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL1, BIT(6)),
206 AXP_DESC(AXP22X, ALDO2, "aldo2", "aldoin", 700, 3300, 100,
207 AXP22X_ALDO2_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL1, BIT(7)),
208 AXP_DESC(AXP22X, ALDO3, "aldo3", "aldoin", 700, 3300, 100,
209 AXP22X_ALDO3_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL3, BIT(7)),
210 AXP_DESC(AXP22X, DLDO1, "dldo1", "dldoin", 700, 3300, 100,
211 AXP22X_DLDO1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(3)),
212 AXP_DESC(AXP22X, DLDO2, "dldo2", "dldoin", 700, 3300, 100,
213 AXP22X_DLDO2_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(4)),
214 AXP_DESC(AXP22X, DLDO3, "dldo3", "dldoin", 700, 3300, 100,
215 AXP22X_DLDO3_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(5)),
216 AXP_DESC(AXP22X, DLDO4, "dldo4", "dldoin", 700, 3300, 100,
217 AXP22X_DLDO4_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(6)),
218 AXP_DESC(AXP22X, ELDO1, "eldo1", "eldoin", 700, 3300, 100,
219 AXP22X_ELDO1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(0)),
220 AXP_DESC(AXP22X, ELDO2, "eldo2", "eldoin", 700, 3300, 100,
221 AXP22X_ELDO2_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(1)),
222 AXP_DESC(AXP22X, ELDO3, "eldo3", "eldoin", 700, 3300, 100,
223 AXP22X_ELDO3_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(2)),
224 AXP_DESC_IO(AXP22X, LDO_IO0, "ldo_io0", "ips", 1800, 3300, 100,
225 AXP22X_LDO_IO0_V_OUT, 0x1f, AXP20X_GPIO0_CTRL, 0x07,
226 AXP22X_IO_ENABLED, AXP22X_IO_DISABLED),
227 AXP_DESC_IO(AXP22X, LDO_IO1, "ldo_io1", "ips", 1800, 3300, 100,
228 AXP22X_LDO_IO1_V_OUT, 0x1f, AXP20X_GPIO1_CTRL, 0x07,
229 AXP22X_IO_ENABLED, AXP22X_IO_DISABLED),
230 AXP_DESC_FIXED(AXP22X, RTC_LDO, "rtc_ldo", "ips", 3000),
231 };
232
233 static int axp20x_set_dcdc_freq(struct platform_device *pdev, u32 dcdcfreq)
234 {
235 struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
236 u32 min, max, def, step;
237
238 switch (axp20x->variant) {
239 case AXP202_ID:
240 case AXP209_ID:
241 min = 750;
242 max = 1875;
243 def = 1500;
244 step = 75;
245 break;
246 case AXP221_ID:
247 min = 1800;
248 max = 4050;
249 def = 3000;
250 step = 150;
251 break;
252 default:
253 dev_err(&pdev->dev,
254 "Setting DCDC frequency for unsupported AXP variant\n");
255 return -EINVAL;
256 }
257
258 if (dcdcfreq == 0)
259 dcdcfreq = def;
260
261 if (dcdcfreq < min) {
262 dcdcfreq = min;
263 dev_warn(&pdev->dev, "DCDC frequency too low. Set to %ukHz\n",
264 min);
265 }
266
267 if (dcdcfreq > max) {
268 dcdcfreq = max;
269 dev_warn(&pdev->dev, "DCDC frequency too high. Set to %ukHz\n",
270 max);
271 }
272
273 dcdcfreq = (dcdcfreq - min) / step;
274
275 return regmap_update_bits(axp20x->regmap, AXP20X_DCDC_FREQ,
276 AXP20X_FREQ_DCDC_MASK, dcdcfreq);
277 }
278
279 static int axp20x_regulator_parse_dt(struct platform_device *pdev)
280 {
281 struct device_node *np, *regulators;
282 int ret;
283 u32 dcdcfreq = 0;
284
285 np = of_node_get(pdev->dev.parent->of_node);
286 if (!np)
287 return 0;
288
289 regulators = of_get_child_by_name(np, "regulators");
290 if (!regulators) {
291 dev_warn(&pdev->dev, "regulators node not found\n");
292 } else {
293 of_property_read_u32(regulators, "x-powers,dcdc-freq", &dcdcfreq);
294 ret = axp20x_set_dcdc_freq(pdev, dcdcfreq);
295 if (ret < 0) {
296 dev_err(&pdev->dev, "Error setting dcdc frequency: %d\n", ret);
297 return ret;
298 }
299
300 of_node_put(regulators);
301 }
302
303 return 0;
304 }
305
306 static int axp20x_set_dcdc_workmode(struct regulator_dev *rdev, int id, u32 workmode)
307 {
308 struct axp20x_dev *axp20x = rdev_get_drvdata(rdev);
309 unsigned int mask;
310
311 switch (axp20x->variant) {
312 case AXP202_ID:
313 case AXP209_ID:
314 if ((id != AXP20X_DCDC2) && (id != AXP20X_DCDC3))
315 return -EINVAL;
316
317 mask = AXP20X_WORKMODE_DCDC2_MASK;
318 if (id == AXP20X_DCDC3)
319 mask = AXP20X_WORKMODE_DCDC3_MASK;
320
321 workmode <<= ffs(mask) - 1;
322 break;
323
324 case AXP221_ID:
325 if (id < AXP22X_DCDC1 || id > AXP22X_DCDC5)
326 return -EINVAL;
327
328 mask = AXP22X_WORKMODE_DCDCX_MASK(id - AXP22X_DCDC1);
329 workmode <<= id - AXP22X_DCDC1;
330 break;
331
332 default:
333 /* should not happen */
334 WARN_ON(1);
335 return -EINVAL;
336 }
337
338 return regmap_update_bits(rdev->regmap, AXP20X_DCDC_MODE, mask, workmode);
339 }
340
341 static int axp20x_regulator_probe(struct platform_device *pdev)
342 {
343 struct regulator_dev *rdev;
344 struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
345 const struct regulator_desc *regulators;
346 struct regulator_config config = {
347 .dev = pdev->dev.parent,
348 .regmap = axp20x->regmap,
349 .driver_data = axp20x,
350 };
351 int ret, i, nregulators;
352 u32 workmode;
353 const char *axp22x_dc1_name = axp22x_regulators[AXP22X_DCDC1].name;
354 const char *axp22x_dc5_name = axp22x_regulators[AXP22X_DCDC5].name;
355
356 switch (axp20x->variant) {
357 case AXP202_ID:
358 case AXP209_ID:
359 regulators = axp20x_regulators;
360 nregulators = AXP20X_REG_ID_MAX;
361 break;
362 case AXP221_ID:
363 regulators = axp22x_regulators;
364 nregulators = AXP22X_REG_ID_MAX;
365 break;
366 default:
367 dev_err(&pdev->dev, "Unsupported AXP variant: %ld\n",
368 axp20x->variant);
369 return -EINVAL;
370 }
371
372 /* This only sets the dcdc freq. Ignore any errors */
373 axp20x_regulator_parse_dt(pdev);
374
375 for (i = 0; i < nregulators; i++) {
376 const struct regulator_desc *desc = &regulators[i];
377 struct regulator_desc *new_desc;
378
379 /*
380 * Regulators DC1SW and DC5LDO are connected internally,
381 * so we have to handle their supply names separately.
382 *
383 * We always register the regulators in proper sequence,
384 * so the supply names are correctly read. See the last
385 * part of this loop to see where we save the DT defined
386 * name.
387 */
388 if (regulators == axp22x_regulators) {
389 if (i == AXP22X_DC1SW) {
390 new_desc = devm_kzalloc(&pdev->dev,
391 sizeof(*desc),
392 GFP_KERNEL);
393 *new_desc = regulators[i];
394 new_desc->supply_name = axp22x_dc1_name;
395 desc = new_desc;
396 } else if (i == AXP22X_DC5LDO) {
397 new_desc = devm_kzalloc(&pdev->dev,
398 sizeof(*desc),
399 GFP_KERNEL);
400 *new_desc = regulators[i];
401 new_desc->supply_name = axp22x_dc5_name;
402 desc = new_desc;
403 }
404 }
405
406 rdev = devm_regulator_register(&pdev->dev, desc, &config);
407 if (IS_ERR(rdev)) {
408 dev_err(&pdev->dev, "Failed to register %s\n",
409 regulators[i].name);
410
411 return PTR_ERR(rdev);
412 }
413
414 ret = of_property_read_u32(rdev->dev.of_node,
415 "x-powers,dcdc-workmode",
416 &workmode);
417 if (!ret) {
418 if (axp20x_set_dcdc_workmode(rdev, i, workmode))
419 dev_err(&pdev->dev, "Failed to set workmode on %s\n",
420 rdev->desc->name);
421 }
422
423 /*
424 * Save AXP22X DCDC1 / DCDC5 regulator names for later.
425 */
426 if (regulators == axp22x_regulators) {
427 /* Can we use rdev->constraints->name instead? */
428 if (i == AXP22X_DCDC1)
429 of_property_read_string(rdev->dev.of_node,
430 "regulator-name",
431 &axp22x_dc1_name);
432 else if (i == AXP22X_DCDC5)
433 of_property_read_string(rdev->dev.of_node,
434 "regulator-name",
435 &axp22x_dc5_name);
436 }
437 }
438
439 return 0;
440 }
441
442 static struct platform_driver axp20x_regulator_driver = {
443 .probe = axp20x_regulator_probe,
444 .driver = {
445 .name = "axp20x-regulator",
446 },
447 };
448
449 module_platform_driver(axp20x_regulator_driver);
450
451 MODULE_LICENSE("GPL v2");
452 MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
453 MODULE_DESCRIPTION("Regulator Driver for AXP20X PMIC");
454 MODULE_ALIAS("platform:axp20x-regulator");
Linux with added FPC-III support