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