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