?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf python: Do not force closing original perf descriptor in evlist.get_pollfd()
[linux/fpc-iii.git] / drivers / regulator / max8998.c
blob271bb736f3f55782c50bb3d2b6a73d0ddfe958b8
1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // max8998.c - Voltage regulator driver for the Maxim 8998
4 //
5 // Copyright (C) 2009-2010 Samsung Electronics
6 // Kyungmin Park <kyungmin.park@samsung.com>
7 // Marek Szyprowski <m.szyprowski@samsung.com>
8
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/i2c.h>
12 #include <linux/err.h>
13 #include <linux/gpio.h>
14 #include <linux/slab.h>
15 #include <linux/interrupt.h>
16 #include <linux/mutex.h>
17 #include <linux/of.h>
18 #include <linux/of_gpio.h>
19 #include <linux/platform_device.h>
20 #include <linux/regulator/driver.h>
21 #include <linux/regulator/of_regulator.h>
22 #include <linux/mfd/max8998.h>
23 #include <linux/mfd/max8998-private.h>
24
25 struct max8998_data {
26 struct device *dev;
27 struct max8998_dev *iodev;
28 int num_regulators;
29 u8 buck1_vol[4]; /* voltages for selection */
30 u8 buck2_vol[2];
31 unsigned int buck1_idx; /* index to last changed voltage */
32 /* value in a set */
33 unsigned int buck2_idx;
34 };
35
36 struct voltage_map_desc {
37 int min;
38 int max;
39 int step;
40 };
41
42 /* Voltage maps in uV*/
43 static const struct voltage_map_desc ldo23_voltage_map_desc = {
44 .min = 800000, .step = 50000, .max = 1300000,
45 };
46 static const struct voltage_map_desc ldo456711_voltage_map_desc = {
47 .min = 1600000, .step = 100000, .max = 3600000,
48 };
49 static const struct voltage_map_desc ldo8_voltage_map_desc = {
50 .min = 3000000, .step = 100000, .max = 3600000,
51 };
52 static const struct voltage_map_desc ldo9_voltage_map_desc = {
53 .min = 2800000, .step = 100000, .max = 3100000,
54 };
55 static const struct voltage_map_desc ldo10_voltage_map_desc = {
56 .min = 950000, .step = 50000, .max = 1300000,
57 };
58 static const struct voltage_map_desc ldo1213_voltage_map_desc = {
59 .min = 800000, .step = 100000, .max = 3300000,
60 };
61 static const struct voltage_map_desc ldo1415_voltage_map_desc = {
62 .min = 1200000, .step = 100000, .max = 3300000,
63 };
64 static const struct voltage_map_desc ldo1617_voltage_map_desc = {
65 .min = 1600000, .step = 100000, .max = 3600000,
66 };
67 static const struct voltage_map_desc buck12_voltage_map_desc = {
68 .min = 750000, .step = 25000, .max = 1525000,
69 };
70 static const struct voltage_map_desc buck3_voltage_map_desc = {
71 .min = 1600000, .step = 100000, .max = 3600000,
72 };
73 static const struct voltage_map_desc buck4_voltage_map_desc = {
74 .min = 800000, .step = 100000, .max = 2300000,
75 };
76
77 static const struct voltage_map_desc *ldo_voltage_map[] = {
78 NULL,
79 NULL,
80 &ldo23_voltage_map_desc, /* LDO2 */
81 &ldo23_voltage_map_desc, /* LDO3 */
82 &ldo456711_voltage_map_desc, /* LDO4 */
83 &ldo456711_voltage_map_desc, /* LDO5 */
84 &ldo456711_voltage_map_desc, /* LDO6 */
85 &ldo456711_voltage_map_desc, /* LDO7 */
86 &ldo8_voltage_map_desc, /* LDO8 */
87 &ldo9_voltage_map_desc, /* LDO9 */
88 &ldo10_voltage_map_desc, /* LDO10 */
89 &ldo456711_voltage_map_desc, /* LDO11 */
90 &ldo1213_voltage_map_desc, /* LDO12 */
91 &ldo1213_voltage_map_desc, /* LDO13 */
92 &ldo1415_voltage_map_desc, /* LDO14 */
93 &ldo1415_voltage_map_desc, /* LDO15 */
94 &ldo1617_voltage_map_desc, /* LDO16 */
95 &ldo1617_voltage_map_desc, /* LDO17 */
96 &buck12_voltage_map_desc, /* BUCK1 */
97 &buck12_voltage_map_desc, /* BUCK2 */
98 &buck3_voltage_map_desc, /* BUCK3 */
99 &buck4_voltage_map_desc, /* BUCK4 */
100 };
101
102 static int max8998_get_enable_register(struct regulator_dev *rdev,
103 int *reg, int *shift)
104 {
105 int ldo = rdev_get_id(rdev);
106
107 switch (ldo) {
108 case MAX8998_LDO2 ... MAX8998_LDO5:
109 *reg = MAX8998_REG_ONOFF1;
110 *shift = 3 - (ldo - MAX8998_LDO2);
111 break;
112 case MAX8998_LDO6 ... MAX8998_LDO13:
113 *reg = MAX8998_REG_ONOFF2;
114 *shift = 7 - (ldo - MAX8998_LDO6);
115 break;
116 case MAX8998_LDO14 ... MAX8998_LDO17:
117 *reg = MAX8998_REG_ONOFF3;
118 *shift = 7 - (ldo - MAX8998_LDO14);
119 break;
120 case MAX8998_BUCK1 ... MAX8998_BUCK4:
121 *reg = MAX8998_REG_ONOFF1;
122 *shift = 7 - (ldo - MAX8998_BUCK1);
123 break;
124 case MAX8998_EN32KHZ_AP ... MAX8998_ENVICHG:
125 *reg = MAX8998_REG_ONOFF4;
126 *shift = 7 - (ldo - MAX8998_EN32KHZ_AP);
127 break;
128 case MAX8998_ESAFEOUT1 ... MAX8998_ESAFEOUT2:
129 *reg = MAX8998_REG_CHGR2;
130 *shift = 7 - (ldo - MAX8998_ESAFEOUT1);
131 break;
132 default:
133 return -EINVAL;
134 }
135
136 return 0;
137 }
138
139 static int max8998_ldo_is_enabled(struct regulator_dev *rdev)
140 {
141 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
142 struct i2c_client *i2c = max8998->iodev->i2c;
143 int ret, reg, shift = 8;
144 u8 val;
145
146 ret = max8998_get_enable_register(rdev, &reg, &shift);
147 if (ret)
148 return ret;
149
150 ret = max8998_read_reg(i2c, reg, &val);
151 if (ret)
152 return ret;
153
154 return val & (1 << shift);
155 }
156
157 static int max8998_ldo_enable(struct regulator_dev *rdev)
158 {
159 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
160 struct i2c_client *i2c = max8998->iodev->i2c;
161 int reg, shift = 8, ret;
162
163 ret = max8998_get_enable_register(rdev, &reg, &shift);
164 if (ret)
165 return ret;
166
167 return max8998_update_reg(i2c, reg, 1<<shift, 1<<shift);
168 }
169
170 static int max8998_ldo_disable(struct regulator_dev *rdev)
171 {
172 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
173 struct i2c_client *i2c = max8998->iodev->i2c;
174 int reg, shift = 8, ret;
175
176 ret = max8998_get_enable_register(rdev, &reg, &shift);
177 if (ret)
178 return ret;
179
180 return max8998_update_reg(i2c, reg, 0, 1<<shift);
181 }
182
183 static int max8998_get_voltage_register(struct regulator_dev *rdev,
184 int *_reg, int *_shift, int *_mask)
185 {
186 int ldo = rdev_get_id(rdev);
187 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
188 int reg, shift = 0, mask = 0xff;
189
190 switch (ldo) {
191 case MAX8998_LDO2 ... MAX8998_LDO3:
192 reg = MAX8998_REG_LDO2_LDO3;
193 mask = 0xf;
194 if (ldo == MAX8998_LDO2)
195 shift = 4;
196 else
197 shift = 0;
198 break;
199 case MAX8998_LDO4 ... MAX8998_LDO7:
200 reg = MAX8998_REG_LDO4 + (ldo - MAX8998_LDO4);
201 break;
202 case MAX8998_LDO8 ... MAX8998_LDO9:
203 reg = MAX8998_REG_LDO8_LDO9;
204 mask = 0xf;
205 if (ldo == MAX8998_LDO8)
206 shift = 4;
207 else
208 shift = 0;
209 break;
210 case MAX8998_LDO10 ... MAX8998_LDO11:
211 reg = MAX8998_REG_LDO10_LDO11;
212 if (ldo == MAX8998_LDO10) {
213 shift = 5;
214 mask = 0x7;
215 } else {
216 shift = 0;
217 mask = 0x1f;
218 }
219 break;
220 case MAX8998_LDO12 ... MAX8998_LDO17:
221 reg = MAX8998_REG_LDO12 + (ldo - MAX8998_LDO12);
222 break;
223 case MAX8998_BUCK1:
224 reg = MAX8998_REG_BUCK1_VOLTAGE1 + max8998->buck1_idx;
225 break;
226 case MAX8998_BUCK2:
227 reg = MAX8998_REG_BUCK2_VOLTAGE1 + max8998->buck2_idx;
228 break;
229 case MAX8998_BUCK3:
230 reg = MAX8998_REG_BUCK3;
231 break;
232 case MAX8998_BUCK4:
233 reg = MAX8998_REG_BUCK4;
234 break;
235 default:
236 return -EINVAL;
237 }
238
239 *_reg = reg;
240 *_shift = shift;
241 *_mask = mask;
242
243 return 0;
244 }
245
246 static int max8998_get_voltage_sel(struct regulator_dev *rdev)
247 {
248 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
249 struct i2c_client *i2c = max8998->iodev->i2c;
250 int reg, shift = 0, mask, ret;
251 u8 val;
252
253 ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
254 if (ret)
255 return ret;
256
257 ret = max8998_read_reg(i2c, reg, &val);
258 if (ret)
259 return ret;
260
261 val >>= shift;
262 val &= mask;
263
264 return val;
265 }
266
267 static int max8998_set_voltage_ldo_sel(struct regulator_dev *rdev,
268 unsigned selector)
269 {
270 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
271 struct i2c_client *i2c = max8998->iodev->i2c;
272 int reg, shift = 0, mask, ret;
273
274 ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
275 if (ret)
276 return ret;
277
278 ret = max8998_update_reg(i2c, reg, selector<<shift, mask<<shift);
279
280 return ret;
281 }
282
283 static inline void buck1_gpio_set(int gpio1, int gpio2, int v)
284 {
285 gpio_set_value(gpio1, v & 0x1);
286 gpio_set_value(gpio2, (v >> 1) & 0x1);
287 }
288
289 static inline void buck2_gpio_set(int gpio, int v)
290 {
291 gpio_set_value(gpio, v & 0x1);
292 }
293
294 static int max8998_set_voltage_buck_sel(struct regulator_dev *rdev,
295 unsigned selector)
296 {
297 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
298 struct max8998_platform_data *pdata = max8998->iodev->pdata;
299 struct i2c_client *i2c = max8998->iodev->i2c;
300 int buck = rdev_get_id(rdev);
301 int reg, shift = 0, mask, ret, j;
302 static u8 buck1_last_val;
303
304 ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
305 if (ret)
306 return ret;
307
308 switch (buck) {
309 case MAX8998_BUCK1:
310 dev_dbg(max8998->dev,
311 "BUCK1, selector:%d, buck1_vol1:%d, buck1_vol2:%d\n"
312 "buck1_vol3:%d, buck1_vol4:%d\n",
313 selector, max8998->buck1_vol[0], max8998->buck1_vol[1],
314 max8998->buck1_vol[2], max8998->buck1_vol[3]);
315
316 if (gpio_is_valid(pdata->buck1_set1) &&
317 gpio_is_valid(pdata->buck1_set2)) {
318
319 /* check if requested voltage */
320 /* value is already defined */
321 for (j = 0; j < ARRAY_SIZE(max8998->buck1_vol); j++) {
322 if (max8998->buck1_vol[j] == selector) {
323 max8998->buck1_idx = j;
324 buck1_gpio_set(pdata->buck1_set1,
325 pdata->buck1_set2, j);
326 goto buck1_exit;
327 }
328 }
329
330 if (pdata->buck_voltage_lock)
331 return -EINVAL;
332
333 /* no predefine regulator found */
334 max8998->buck1_idx = (buck1_last_val % 2) + 2;
335 dev_dbg(max8998->dev, "max8998->buck1_idx:%d\n",
336 max8998->buck1_idx);
337 max8998->buck1_vol[max8998->buck1_idx] = selector;
338 ret = max8998_get_voltage_register(rdev, &reg,
339 &shift,
340 &mask);
341 ret = max8998_write_reg(i2c, reg, selector);
342 buck1_gpio_set(pdata->buck1_set1,
343 pdata->buck1_set2, max8998->buck1_idx);
344 buck1_last_val++;
345 buck1_exit:
346 dev_dbg(max8998->dev, "%s: SET1:%d, SET2:%d\n",
347 i2c->name, gpio_get_value(pdata->buck1_set1),
348 gpio_get_value(pdata->buck1_set2));
349 break;
350 } else {
351 ret = max8998_write_reg(i2c, reg, selector);
352 }
353 break;
354
355 case MAX8998_BUCK2:
356 dev_dbg(max8998->dev,
357 "BUCK2, selector:%d buck2_vol1:%d, buck2_vol2:%d\n",
358 selector, max8998->buck2_vol[0], max8998->buck2_vol[1]);
359 if (gpio_is_valid(pdata->buck2_set3)) {
360
361 /* check if requested voltage */
362 /* value is already defined */
363 for (j = 0; j < ARRAY_SIZE(max8998->buck2_vol); j++) {
364 if (max8998->buck2_vol[j] == selector) {
365 max8998->buck2_idx = j;
366 buck2_gpio_set(pdata->buck2_set3, j);
367 goto buck2_exit;
368 }
369 }
370
371 if (pdata->buck_voltage_lock)
372 return -EINVAL;
373
374 max8998_get_voltage_register(rdev,
375 &reg, &shift, &mask);
376 ret = max8998_write_reg(i2c, reg, selector);
377 max8998->buck2_vol[max8998->buck2_idx] = selector;
378 buck2_gpio_set(pdata->buck2_set3, max8998->buck2_idx);
379 buck2_exit:
380 dev_dbg(max8998->dev, "%s: SET3:%d\n", i2c->name,
381 gpio_get_value(pdata->buck2_set3));
382 } else {
383 ret = max8998_write_reg(i2c, reg, selector);
384 }
385 break;
386
387 case MAX8998_BUCK3:
388 case MAX8998_BUCK4:
389 ret = max8998_update_reg(i2c, reg, selector<<shift,
390 mask<<shift);
391 break;
392 }
393
394 return ret;
395 }
396
397 static int max8998_set_voltage_buck_time_sel(struct regulator_dev *rdev,
398 unsigned int old_selector,
399 unsigned int new_selector)
400 {
401 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
402 struct i2c_client *i2c = max8998->iodev->i2c;
403 const struct voltage_map_desc *desc;
404 int buck = rdev_get_id(rdev);
405 u8 val = 0;
406 int difference, ret;
407
408 if (buck < MAX8998_BUCK1 || buck > MAX8998_BUCK4)
409 return -EINVAL;
410
411 desc = ldo_voltage_map[buck];
412
413 /* Voltage stabilization */
414 ret = max8998_read_reg(i2c, MAX8998_REG_ONOFF4, &val);
415 if (ret)
416 return ret;
417
418 /* lp3974 hasn't got ENRAMP bit - ramp is assumed as true */
419 /* MAX8998 has ENRAMP bit implemented, so test it*/
420 if (max8998->iodev->type == TYPE_MAX8998 && !(val & MAX8998_ENRAMP))
421 return 0;
422
423 difference = (new_selector - old_selector) * desc->step / 1000;
424 if (difference > 0)
425 return DIV_ROUND_UP(difference, (val & 0x0f) + 1);
426
427 return 0;
428 }
429
430 static struct regulator_ops max8998_ldo_ops = {
431 .list_voltage = regulator_list_voltage_linear,
432 .map_voltage = regulator_map_voltage_linear,
433 .is_enabled = max8998_ldo_is_enabled,
434 .enable = max8998_ldo_enable,
435 .disable = max8998_ldo_disable,
436 .get_voltage_sel = max8998_get_voltage_sel,
437 .set_voltage_sel = max8998_set_voltage_ldo_sel,
438 };
439
440 static struct regulator_ops max8998_buck_ops = {
441 .list_voltage = regulator_list_voltage_linear,
442 .map_voltage = regulator_map_voltage_linear,
443 .is_enabled = max8998_ldo_is_enabled,
444 .enable = max8998_ldo_enable,
445 .disable = max8998_ldo_disable,
446 .get_voltage_sel = max8998_get_voltage_sel,
447 .set_voltage_sel = max8998_set_voltage_buck_sel,
448 .set_voltage_time_sel = max8998_set_voltage_buck_time_sel,
449 };
450
451 static struct regulator_ops max8998_others_ops = {
452 .is_enabled = max8998_ldo_is_enabled,
453 .enable = max8998_ldo_enable,
454 .disable = max8998_ldo_disable,
455 };
456
457 static struct regulator_desc regulators[] = {
458 {
459 .name = "LDO2",
460 .id = MAX8998_LDO2,
461 .ops = &max8998_ldo_ops,
462 .type = REGULATOR_VOLTAGE,
463 .owner = THIS_MODULE,
464 }, {
465 .name = "LDO3",
466 .id = MAX8998_LDO3,
467 .ops = &max8998_ldo_ops,
468 .type = REGULATOR_VOLTAGE,
469 .owner = THIS_MODULE,
470 }, {
471 .name = "LDO4",
472 .id = MAX8998_LDO4,
473 .ops = &max8998_ldo_ops,
474 .type = REGULATOR_VOLTAGE,
475 .owner = THIS_MODULE,
476 }, {
477 .name = "LDO5",
478 .id = MAX8998_LDO5,
479 .ops = &max8998_ldo_ops,
480 .type = REGULATOR_VOLTAGE,
481 .owner = THIS_MODULE,
482 }, {
483 .name = "LDO6",
484 .id = MAX8998_LDO6,
485 .ops = &max8998_ldo_ops,
486 .type = REGULATOR_VOLTAGE,
487 .owner = THIS_MODULE,
488 }, {
489 .name = "LDO7",
490 .id = MAX8998_LDO7,
491 .ops = &max8998_ldo_ops,
492 .type = REGULATOR_VOLTAGE,
493 .owner = THIS_MODULE,
494 }, {
495 .name = "LDO8",
496 .id = MAX8998_LDO8,
497 .ops = &max8998_ldo_ops,
498 .type = REGULATOR_VOLTAGE,
499 .owner = THIS_MODULE,
500 }, {
501 .name = "LDO9",
502 .id = MAX8998_LDO9,
503 .ops = &max8998_ldo_ops,
504 .type = REGULATOR_VOLTAGE,
505 .owner = THIS_MODULE,
506 }, {
507 .name = "LDO10",
508 .id = MAX8998_LDO10,
509 .ops = &max8998_ldo_ops,
510 .type = REGULATOR_VOLTAGE,
511 .owner = THIS_MODULE,
512 }, {
513 .name = "LDO11",
514 .id = MAX8998_LDO11,
515 .ops = &max8998_ldo_ops,
516 .type = REGULATOR_VOLTAGE,
517 .owner = THIS_MODULE,
518 }, {
519 .name = "LDO12",
520 .id = MAX8998_LDO12,
521 .ops = &max8998_ldo_ops,
522 .type = REGULATOR_VOLTAGE,
523 .owner = THIS_MODULE,
524 }, {
525 .name = "LDO13",
526 .id = MAX8998_LDO13,
527 .ops = &max8998_ldo_ops,
528 .type = REGULATOR_VOLTAGE,
529 .owner = THIS_MODULE,
530 }, {
531 .name = "LDO14",
532 .id = MAX8998_LDO14,
533 .ops = &max8998_ldo_ops,
534 .type = REGULATOR_VOLTAGE,
535 .owner = THIS_MODULE,
536 }, {
537 .name = "LDO15",
538 .id = MAX8998_LDO15,
539 .ops = &max8998_ldo_ops,
540 .type = REGULATOR_VOLTAGE,
541 .owner = THIS_MODULE,
542 }, {
543 .name = "LDO16",
544 .id = MAX8998_LDO16,
545 .ops = &max8998_ldo_ops,
546 .type = REGULATOR_VOLTAGE,
547 .owner = THIS_MODULE,
548 }, {
549 .name = "LDO17",
550 .id = MAX8998_LDO17,
551 .ops = &max8998_ldo_ops,
552 .type = REGULATOR_VOLTAGE,
553 .owner = THIS_MODULE,
554 }, {
555 .name = "BUCK1",
556 .id = MAX8998_BUCK1,
557 .ops = &max8998_buck_ops,
558 .type = REGULATOR_VOLTAGE,
559 .owner = THIS_MODULE,
560 }, {
561 .name = "BUCK2",
562 .id = MAX8998_BUCK2,
563 .ops = &max8998_buck_ops,
564 .type = REGULATOR_VOLTAGE,
565 .owner = THIS_MODULE,
566 }, {
567 .name = "BUCK3",
568 .id = MAX8998_BUCK3,
569 .ops = &max8998_buck_ops,
570 .type = REGULATOR_VOLTAGE,
571 .owner = THIS_MODULE,
572 }, {
573 .name = "BUCK4",
574 .id = MAX8998_BUCK4,
575 .ops = &max8998_buck_ops,
576 .type = REGULATOR_VOLTAGE,
577 .owner = THIS_MODULE,
578 }, {
579 .name = "EN32KHz-AP",
580 .id = MAX8998_EN32KHZ_AP,
581 .ops = &max8998_others_ops,
582 .type = REGULATOR_VOLTAGE,
583 .owner = THIS_MODULE,
584 }, {
585 .name = "EN32KHz-CP",
586 .id = MAX8998_EN32KHZ_CP,
587 .ops = &max8998_others_ops,
588 .type = REGULATOR_VOLTAGE,
589 .owner = THIS_MODULE,
590 }, {
591 .name = "ENVICHG",
592 .id = MAX8998_ENVICHG,
593 .ops = &max8998_others_ops,
594 .type = REGULATOR_VOLTAGE,
595 .owner = THIS_MODULE,
596 }, {
597 .name = "ESAFEOUT1",
598 .id = MAX8998_ESAFEOUT1,
599 .ops = &max8998_others_ops,
600 .type = REGULATOR_VOLTAGE,
601 .owner = THIS_MODULE,
602 }, {
603 .name = "ESAFEOUT2",
604 .id = MAX8998_ESAFEOUT2,
605 .ops = &max8998_others_ops,
606 .type = REGULATOR_VOLTAGE,
607 .owner = THIS_MODULE,
608 }
609 };
610
611 static int max8998_pmic_dt_parse_dvs_gpio(struct max8998_dev *iodev,
612 struct max8998_platform_data *pdata,
613 struct device_node *pmic_np)
614 {
615 int gpio;
616
617 gpio = of_get_named_gpio(pmic_np, "max8998,pmic-buck1-dvs-gpios", 0);
618 if (!gpio_is_valid(gpio)) {
619 dev_err(iodev->dev, "invalid buck1 gpio[0]: %d\n", gpio);
620 return -EINVAL;
621 }
622 pdata->buck1_set1 = gpio;
623
624 gpio = of_get_named_gpio(pmic_np, "max8998,pmic-buck1-dvs-gpios", 1);
625 if (!gpio_is_valid(gpio)) {
626 dev_err(iodev->dev, "invalid buck1 gpio[1]: %d\n", gpio);
627 return -EINVAL;
628 }
629 pdata->buck1_set2 = gpio;
630
631 gpio = of_get_named_gpio(pmic_np, "max8998,pmic-buck2-dvs-gpio", 0);
632 if (!gpio_is_valid(gpio)) {
633 dev_err(iodev->dev, "invalid buck 2 gpio: %d\n", gpio);
634 return -EINVAL;
635 }
636 pdata->buck2_set3 = gpio;
637
638 return 0;
639 }
640
641 static int max8998_pmic_dt_parse_pdata(struct max8998_dev *iodev,
642 struct max8998_platform_data *pdata)
643 {
644 struct device_node *pmic_np = iodev->dev->of_node;
645 struct device_node *regulators_np, *reg_np;
646 struct max8998_regulator_data *rdata;
647 unsigned int i;
648 int ret;
649
650 regulators_np = of_get_child_by_name(pmic_np, "regulators");
651 if (!regulators_np) {
652 dev_err(iodev->dev, "could not find regulators sub-node\n");
653 return -EINVAL;
654 }
655
656 /* count the number of regulators to be supported in pmic */
657 pdata->num_regulators = of_get_child_count(regulators_np);
658
659 rdata = devm_kcalloc(iodev->dev,
660 pdata->num_regulators, sizeof(*rdata),
661 GFP_KERNEL);
662 if (!rdata) {
663 of_node_put(regulators_np);
664 return -ENOMEM;
665 }
666
667 pdata->regulators = rdata;
668 for (i = 0; i < ARRAY_SIZE(regulators); ++i) {
669 reg_np = of_get_child_by_name(regulators_np,
670 regulators[i].name);
671 if (!reg_np)
672 continue;
673
674 rdata->id = regulators[i].id;
675 rdata->initdata = of_get_regulator_init_data(iodev->dev,
676 reg_np,
677 &regulators[i]);
678 rdata->reg_node = reg_np;
679 ++rdata;
680 }
681 pdata->num_regulators = rdata - pdata->regulators;
682
683 of_node_put(reg_np);
684 of_node_put(regulators_np);
685
686 ret = max8998_pmic_dt_parse_dvs_gpio(iodev, pdata, pmic_np);
687 if (ret)
688 return -EINVAL;
689
690 if (of_find_property(pmic_np, "max8998,pmic-buck-voltage-lock", NULL))
691 pdata->buck_voltage_lock = true;
692
693 ret = of_property_read_u32(pmic_np,
694 "max8998,pmic-buck1-default-dvs-idx",
695 &pdata->buck1_default_idx);
696 if (!ret && pdata->buck1_default_idx >= 4) {
697 pdata->buck1_default_idx = 0;
698 dev_warn(iodev->dev, "invalid value for default dvs index, using 0 instead\n");
699 }
700
701 ret = of_property_read_u32(pmic_np,
702 "max8998,pmic-buck2-default-dvs-idx",
703 &pdata->buck2_default_idx);
704 if (!ret && pdata->buck2_default_idx >= 2) {
705 pdata->buck2_default_idx = 0;
706 dev_warn(iodev->dev, "invalid value for default dvs index, using 0 instead\n");
707 }
708
709 ret = of_property_read_u32_array(pmic_np,
710 "max8998,pmic-buck1-dvs-voltage",
711 pdata->buck1_voltage,
712 ARRAY_SIZE(pdata->buck1_voltage));
713 if (ret) {
714 dev_err(iodev->dev, "buck1 voltages not specified\n");
715 return -EINVAL;
716 }
717
718 ret = of_property_read_u32_array(pmic_np,
719 "max8998,pmic-buck2-dvs-voltage",
720 pdata->buck2_voltage,
721 ARRAY_SIZE(pdata->buck2_voltage));
722 if (ret) {
723 dev_err(iodev->dev, "buck2 voltages not specified\n");
724 return -EINVAL;
725 }
726
727 return 0;
728 }
729
730 static int max8998_pmic_probe(struct platform_device *pdev)
731 {
732 struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent);
733 struct max8998_platform_data *pdata = iodev->pdata;
734 struct regulator_config config = { };
735 struct regulator_dev *rdev;
736 struct max8998_data *max8998;
737 struct i2c_client *i2c;
738 int i, ret;
739 unsigned int v;
740
741 if (!pdata) {
742 dev_err(pdev->dev.parent, "No platform init data supplied\n");
743 return -ENODEV;
744 }
745
746 if (IS_ENABLED(CONFIG_OF) && iodev->dev->of_node) {
747 ret = max8998_pmic_dt_parse_pdata(iodev, pdata);
748 if (ret)
749 return ret;
750 }
751
752 max8998 = devm_kzalloc(&pdev->dev, sizeof(struct max8998_data),
753 GFP_KERNEL);
754 if (!max8998)
755 return -ENOMEM;
756
757 max8998->dev = &pdev->dev;
758 max8998->iodev = iodev;
759 max8998->num_regulators = pdata->num_regulators;
760 platform_set_drvdata(pdev, max8998);
761 i2c = max8998->iodev->i2c;
762
763 max8998->buck1_idx = pdata->buck1_default_idx;
764 max8998->buck2_idx = pdata->buck2_default_idx;
765
766 /* NOTE: */
767 /* For unused GPIO NOT marked as -1 (thereof equal to 0) WARN_ON */
768 /* will be displayed */
769
770 /* Check if MAX8998 voltage selection GPIOs are defined */
771 if (gpio_is_valid(pdata->buck1_set1) &&
772 gpio_is_valid(pdata->buck1_set2)) {
773 /* Check if SET1 is not equal to 0 */
774 if (!pdata->buck1_set1) {
775 dev_err(&pdev->dev,
776 "MAX8998 SET1 GPIO defined as 0 !\n");
777 WARN_ON(!pdata->buck1_set1);
778 return -EIO;
779 }
780 /* Check if SET2 is not equal to 0 */
781 if (!pdata->buck1_set2) {
782 dev_err(&pdev->dev,
783 "MAX8998 SET2 GPIO defined as 0 !\n");
784 WARN_ON(!pdata->buck1_set2);
785 return -EIO;
786 }
787
788 gpio_request(pdata->buck1_set1, "MAX8998 BUCK1_SET1");
789 gpio_direction_output(pdata->buck1_set1,
790 max8998->buck1_idx & 0x1);
791
792
793 gpio_request(pdata->buck1_set2, "MAX8998 BUCK1_SET2");
794 gpio_direction_output(pdata->buck1_set2,
795 (max8998->buck1_idx >> 1) & 0x1);
796
797 /* Set predefined values for BUCK1 registers */
798 for (v = 0; v < ARRAY_SIZE(pdata->buck1_voltage); ++v) {
799 i = 0;
800 while (buck12_voltage_map_desc.min +
801 buck12_voltage_map_desc.step*i
802 < pdata->buck1_voltage[v])
803 i++;
804
805 max8998->buck1_vol[v] = i;
806 ret = max8998_write_reg(i2c,
807 MAX8998_REG_BUCK1_VOLTAGE1 + v, i);
808 if (ret)
809 return ret;
810 }
811 }
812
813 if (gpio_is_valid(pdata->buck2_set3)) {
814 /* Check if SET3 is not equal to 0 */
815 if (!pdata->buck2_set3) {
816 dev_err(&pdev->dev,
817 "MAX8998 SET3 GPIO defined as 0 !\n");
818 WARN_ON(!pdata->buck2_set3);
819 return -EIO;
820 }
821 gpio_request(pdata->buck2_set3, "MAX8998 BUCK2_SET3");
822 gpio_direction_output(pdata->buck2_set3,
823 max8998->buck2_idx & 0x1);
824
825 /* Set predefined values for BUCK2 registers */
826 for (v = 0; v < ARRAY_SIZE(pdata->buck2_voltage); ++v) {
827 i = 0;
828 while (buck12_voltage_map_desc.min +
829 buck12_voltage_map_desc.step*i
830 < pdata->buck2_voltage[v])
831 i++;
832
833 max8998->buck2_vol[v] = i;
834 ret = max8998_write_reg(i2c,
835 MAX8998_REG_BUCK2_VOLTAGE1 + v, i);
836 if (ret)
837 return ret;
838 }
839 }
840
841 for (i = 0; i < pdata->num_regulators; i++) {
842 const struct voltage_map_desc *desc;
843 int id = pdata->regulators[i].id;
844 int index = id - MAX8998_LDO2;
845
846 desc = ldo_voltage_map[id];
847 if (desc && regulators[index].ops != &max8998_others_ops) {
848 int count = (desc->max - desc->min) / desc->step + 1;
849
850 regulators[index].n_voltages = count;
851 regulators[index].min_uV = desc->min;
852 regulators[index].uV_step = desc->step;
853 }
854
855 config.dev = max8998->dev;
856 config.of_node = pdata->regulators[i].reg_node;
857 config.init_data = pdata->regulators[i].initdata;
858 config.driver_data = max8998;
859
860 rdev = devm_regulator_register(&pdev->dev, &regulators[index],
861 &config);
862 if (IS_ERR(rdev)) {
863 ret = PTR_ERR(rdev);
864 dev_err(max8998->dev, "regulator %s init failed (%d)\n",
865 regulators[index].name, ret);
866 return ret;
867 }
868 }
869
870
871 return 0;
872 }
873
874 static const struct platform_device_id max8998_pmic_id[] = {
875 { "max8998-pmic", TYPE_MAX8998 },
876 { "lp3974-pmic", TYPE_LP3974 },
877 { }
878 };
879 MODULE_DEVICE_TABLE(platform, max8998_pmic_id);
880
881 static struct platform_driver max8998_pmic_driver = {
882 .driver = {
883 .name = "max8998-pmic",
884 },
885 .probe = max8998_pmic_probe,
886 .id_table = max8998_pmic_id,
887 };
888
889 static int __init max8998_pmic_init(void)
890 {
891 return platform_driver_register(&max8998_pmic_driver);
892 }
893 subsys_initcall(max8998_pmic_init);
894
895 static void __exit max8998_pmic_cleanup(void)
896 {
897 platform_driver_unregister(&max8998_pmic_driver);
898 }
899 module_exit(max8998_pmic_cleanup);
900
901 MODULE_DESCRIPTION("MAXIM 8998 voltage regulator driver");
902 MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>");
903 MODULE_LICENSE("GPL");
Linux with added FPC-III support