2 * max8998.c - Voltage regulator driver for the Maxim 8998
4 * Copyright (C) 2009-2010 Samsung Electronics
5 * Kyungmin Park <kyungmin.park@samsung.com>
6 * Marek Szyprowski <m.szyprowski@samsung.com>
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.
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.
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
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>
31 #include <linux/platform_device.h>
32 #include <linux/regulator/driver.h>
33 #include <linux/mfd/max8998.h>
34 #include <linux/mfd/max8998-private.h>
38 struct max8998_dev *iodev;
40 struct regulator_dev **rdev;
43 struct voltage_map_desc {
50 static const struct voltage_map_desc ldo23_voltage_map_desc = {
51 .min = 800, .step = 50, .max = 1300,
53 static const struct voltage_map_desc ldo456711_voltage_map_desc = {
54 .min = 1600, .step = 100, .max = 3600,
56 static const struct voltage_map_desc ldo8_voltage_map_desc = {
57 .min = 3000, .step = 100, .max = 3600,
59 static const struct voltage_map_desc ldo9_voltage_map_desc = {
60 .min = 2800, .step = 100, .max = 3100,
62 static const struct voltage_map_desc ldo10_voltage_map_desc = {
63 .min = 950, .step = 50, .max = 1300,
65 static const struct voltage_map_desc ldo1213_voltage_map_desc = {
66 .min = 800, .step = 100, .max = 3300,
68 static const struct voltage_map_desc ldo1415_voltage_map_desc = {
69 .min = 1200, .step = 100, .max = 3300,
71 static const struct voltage_map_desc ldo1617_voltage_map_desc = {
72 .min = 1600, .step = 100, .max = 3600,
74 static const struct voltage_map_desc buck12_voltage_map_desc = {
75 .min = 750, .step = 25, .max = 1525,
77 static const struct voltage_map_desc buck3_voltage_map_desc = {
78 .min = 1600, .step = 100, .max = 3600,
80 static const struct voltage_map_desc buck4_voltage_map_desc = {
81 .min = 800, .step = 100, .max = 2300,
84 static const struct voltage_map_desc *ldo_voltage_map[] = {
87 &ldo23_voltage_map_desc, /* LDO2 */
88 &ldo23_voltage_map_desc, /* LDO3 */
89 &ldo456711_voltage_map_desc, /* LDO4 */
90 &ldo456711_voltage_map_desc, /* LDO5 */
91 &ldo456711_voltage_map_desc, /* LDO6 */
92 &ldo456711_voltage_map_desc, /* LDO7 */
93 &ldo8_voltage_map_desc, /* LDO8 */
94 &ldo9_voltage_map_desc, /* LDO9 */
95 &ldo10_voltage_map_desc, /* LDO10 */
96 &ldo456711_voltage_map_desc, /* LDO11 */
97 &ldo1213_voltage_map_desc, /* LDO12 */
98 &ldo1213_voltage_map_desc, /* LDO13 */
99 &ldo1415_voltage_map_desc, /* LDO14 */
100 &ldo1415_voltage_map_desc, /* LDO15 */
101 &ldo1617_voltage_map_desc, /* LDO16 */
102 &ldo1617_voltage_map_desc, /* LDO17 */
103 &buck12_voltage_map_desc, /* BUCK1 */
104 &buck12_voltage_map_desc, /* BUCK2 */
105 &buck3_voltage_map_desc, /* BUCK3 */
106 &buck4_voltage_map_desc, /* BUCK4 */
109 static inline int max8998_get_ldo(struct regulator_dev *rdev)
111 return rdev_get_id(rdev);
114 static int max8998_list_voltage(struct regulator_dev *rdev,
115 unsigned int selector)
117 const struct voltage_map_desc *desc;
118 int ldo = max8998_get_ldo(rdev);
121 if (ldo > ARRAY_SIZE(ldo_voltage_map))
124 desc = ldo_voltage_map[ldo];
128 val = desc->min + desc->step * selector;
135 static int max8998_get_enable_register(struct regulator_dev *rdev,
136 int *reg, int *shift)
138 int ldo = max8998_get_ldo(rdev);
141 case MAX8998_LDO2 ... MAX8998_LDO5:
142 *reg = MAX8998_REG_ONOFF1;
143 *shift = 3 - (ldo - MAX8998_LDO2);
145 case MAX8998_LDO6 ... MAX8998_LDO13:
146 *reg = MAX8998_REG_ONOFF2;
147 *shift = 7 - (ldo - MAX8998_LDO6);
149 case MAX8998_LDO14 ... MAX8998_LDO17:
150 *reg = MAX8998_REG_ONOFF3;
151 *shift = 7 - (ldo - MAX8998_LDO14);
153 case MAX8998_BUCK1 ... MAX8998_BUCK4:
154 *reg = MAX8998_REG_ONOFF1;
155 *shift = 7 - (ldo - MAX8998_BUCK1);
157 case MAX8998_EN32KHZ_AP ... MAX8998_ENVICHG:
158 *reg = MAX8998_REG_ONOFF4;
159 *shift = 7 - (ldo - MAX8998_EN32KHZ_AP);
161 case MAX8998_ESAFEOUT1 ... MAX8998_ESAFEOUT2:
162 *reg = MAX8998_REG_CHGR2;
163 *shift = 7 - (ldo - MAX8998_ESAFEOUT1);
172 static int max8998_ldo_is_enabled(struct regulator_dev *rdev)
174 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
175 int ret, reg, shift = 8;
178 ret = max8998_get_enable_register(rdev, ®, &shift);
182 ret = max8998_read_reg(max8998->iodev, reg, &val);
186 return val & (1 << shift);
189 static int max8998_ldo_enable(struct regulator_dev *rdev)
191 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
192 int reg, shift = 8, ret;
194 ret = max8998_get_enable_register(rdev, ®, &shift);
198 return max8998_update_reg(max8998->iodev, reg, 1<<shift, 1<<shift);
201 static int max8998_ldo_disable(struct regulator_dev *rdev)
203 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
204 int reg, shift = 8, ret;
206 ret = max8998_get_enable_register(rdev, ®, &shift);
210 return max8998_update_reg(max8998->iodev, reg, 0, 1<<shift);
213 static int max8998_get_voltage_register(struct regulator_dev *rdev,
214 int *_reg, int *_shift, int *_mask)
216 int ldo = max8998_get_ldo(rdev);
217 int reg, shift = 0, mask = 0xff;
220 case MAX8998_LDO2 ... MAX8998_LDO3:
221 reg = MAX8998_REG_LDO2_LDO3;
223 if (ldo == MAX8998_LDO2)
228 case MAX8998_LDO4 ... MAX8998_LDO7:
229 reg = MAX8998_REG_LDO4 + (ldo - MAX8998_LDO4);
231 case MAX8998_LDO8 ... MAX8998_LDO9:
232 reg = MAX8998_REG_LDO8_LDO9;
234 if (ldo == MAX8998_LDO8)
239 case MAX8998_LDO10 ... MAX8998_LDO11:
240 reg = MAX8998_REG_LDO10_LDO11;
241 if (ldo == MAX8998_LDO10) {
249 case MAX8998_LDO12 ... MAX8998_LDO17:
250 reg = MAX8998_REG_LDO12 + (ldo - MAX8998_LDO12);
253 reg = MAX8998_REG_BUCK1_DVSARM1;
256 reg = MAX8998_REG_BUCK2_DVSINT1;
259 reg = MAX8998_REG_BUCK3;
262 reg = MAX8998_REG_BUCK4;
275 static int max8998_get_voltage(struct regulator_dev *rdev)
277 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
278 int reg, shift = 0, mask, ret;
281 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask);
285 ret = max8998_read_reg(max8998->iodev, reg, &val);
292 return max8998_list_voltage(rdev, val);
295 static int max8998_set_voltage(struct regulator_dev *rdev,
296 int min_uV, int max_uV)
298 struct max8998_data *max8998 = rdev_get_drvdata(rdev);
299 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
300 const struct voltage_map_desc *desc;
301 int ldo = max8998_get_ldo(rdev);
302 int reg, shift = 0, mask, ret;
305 if (ldo > ARRAY_SIZE(ldo_voltage_map))
308 desc = ldo_voltage_map[ldo];
312 if (max_vol < desc->min || min_vol > desc->max)
315 while (desc->min + desc->step*i < max_vol &&
316 desc->min + desc->step*i < desc->max)
319 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask);
323 return max8998_update_reg(max8998->iodev, reg, i<<shift, mask<<shift);
326 static struct regulator_ops max8998_ldo_ops = {
327 .list_voltage = max8998_list_voltage,
328 .is_enabled = max8998_ldo_is_enabled,
329 .enable = max8998_ldo_enable,
330 .disable = max8998_ldo_disable,
331 .get_voltage = max8998_get_voltage,
332 .set_voltage = max8998_set_voltage,
333 .set_suspend_enable = max8998_ldo_enable,
334 .set_suspend_disable = max8998_ldo_disable,
337 static struct regulator_ops max8998_buck_ops = {
338 .list_voltage = max8998_list_voltage,
339 .is_enabled = max8998_ldo_is_enabled,
340 .enable = max8998_ldo_enable,
341 .disable = max8998_ldo_disable,
342 .get_voltage = max8998_get_voltage,
343 .set_voltage = max8998_set_voltage,
344 .set_suspend_enable = max8998_ldo_enable,
345 .set_suspend_disable = max8998_ldo_disable,
348 static struct regulator_ops max8998_others_ops = {
349 .is_enabled = max8998_ldo_is_enabled,
350 .enable = max8998_ldo_enable,
351 .disable = max8998_ldo_disable,
352 .set_suspend_enable = max8998_ldo_enable,
353 .set_suspend_disable = max8998_ldo_disable,
356 static struct regulator_desc regulators[] = {
360 .ops = &max8998_ldo_ops,
361 .type = REGULATOR_VOLTAGE,
362 .owner = THIS_MODULE,
366 .ops = &max8998_ldo_ops,
367 .type = REGULATOR_VOLTAGE,
368 .owner = THIS_MODULE,
372 .ops = &max8998_ldo_ops,
373 .type = REGULATOR_VOLTAGE,
374 .owner = THIS_MODULE,
378 .ops = &max8998_ldo_ops,
379 .type = REGULATOR_VOLTAGE,
380 .owner = THIS_MODULE,
384 .ops = &max8998_ldo_ops,
385 .type = REGULATOR_VOLTAGE,
386 .owner = THIS_MODULE,
390 .ops = &max8998_ldo_ops,
391 .type = REGULATOR_VOLTAGE,
392 .owner = THIS_MODULE,
396 .ops = &max8998_ldo_ops,
397 .type = REGULATOR_VOLTAGE,
398 .owner = THIS_MODULE,
402 .ops = &max8998_ldo_ops,
403 .type = REGULATOR_VOLTAGE,
404 .owner = THIS_MODULE,
408 .ops = &max8998_ldo_ops,
409 .type = REGULATOR_VOLTAGE,
410 .owner = THIS_MODULE,
414 .ops = &max8998_ldo_ops,
415 .type = REGULATOR_VOLTAGE,
416 .owner = THIS_MODULE,
420 .ops = &max8998_ldo_ops,
421 .type = REGULATOR_VOLTAGE,
422 .owner = THIS_MODULE,
426 .ops = &max8998_ldo_ops,
427 .type = REGULATOR_VOLTAGE,
428 .owner = THIS_MODULE,
432 .ops = &max8998_ldo_ops,
433 .type = REGULATOR_VOLTAGE,
434 .owner = THIS_MODULE,
438 .ops = &max8998_ldo_ops,
439 .type = REGULATOR_VOLTAGE,
440 .owner = THIS_MODULE,
444 .ops = &max8998_ldo_ops,
445 .type = REGULATOR_VOLTAGE,
446 .owner = THIS_MODULE,
450 .ops = &max8998_ldo_ops,
451 .type = REGULATOR_VOLTAGE,
452 .owner = THIS_MODULE,
456 .ops = &max8998_buck_ops,
457 .type = REGULATOR_VOLTAGE,
458 .owner = THIS_MODULE,
462 .ops = &max8998_buck_ops,
463 .type = REGULATOR_VOLTAGE,
464 .owner = THIS_MODULE,
468 .ops = &max8998_buck_ops,
469 .type = REGULATOR_VOLTAGE,
470 .owner = THIS_MODULE,
474 .ops = &max8998_buck_ops,
475 .type = REGULATOR_VOLTAGE,
476 .owner = THIS_MODULE,
478 .name = "EN32KHz AP",
479 .id = MAX8998_EN32KHZ_AP,
480 .ops = &max8998_others_ops,
481 .type = REGULATOR_VOLTAGE,
482 .owner = THIS_MODULE,
484 .name = "EN32KHz CP",
485 .id = MAX8998_EN32KHZ_CP,
486 .ops = &max8998_others_ops,
487 .type = REGULATOR_VOLTAGE,
488 .owner = THIS_MODULE,
491 .id = MAX8998_ENVICHG,
492 .ops = &max8998_others_ops,
493 .type = REGULATOR_VOLTAGE,
494 .owner = THIS_MODULE,
497 .id = MAX8998_ESAFEOUT1,
498 .ops = &max8998_others_ops,
499 .type = REGULATOR_VOLTAGE,
500 .owner = THIS_MODULE,
503 .id = MAX8998_ESAFEOUT2,
504 .ops = &max8998_others_ops,
505 .type = REGULATOR_VOLTAGE,
506 .owner = THIS_MODULE,
510 static __devinit int max8998_pmic_probe(struct platform_device *pdev)
512 struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent);
513 struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev);
514 struct regulator_dev **rdev;
515 struct max8998_data *max8998;
519 dev_err(pdev->dev.parent, "No platform init data supplied\n");
523 max8998 = kzalloc(sizeof(struct max8998_data), GFP_KERNEL);
527 size = sizeof(struct regulator_dev *) * (pdata->num_regulators + 1);
528 max8998->rdev = kzalloc(size, GFP_KERNEL);
529 if (!max8998->rdev) {
534 rdev = max8998->rdev;
535 max8998->iodev = iodev;
536 platform_set_drvdata(pdev, max8998);
538 for (i = 0; i < pdata->num_regulators; i++) {
539 const struct voltage_map_desc *desc;
540 int id = pdata->regulators[i].id;
541 int index = id - MAX8998_LDO2;
543 desc = ldo_voltage_map[id];
544 if (desc && regulators[index].ops != &max8998_others_ops) {
545 int count = (desc->max - desc->min) / desc->step + 1;
546 regulators[index].n_voltages = count;
548 rdev[i] = regulator_register(®ulators[index], max8998->dev,
549 pdata->regulators[i].initdata, max8998);
550 if (IS_ERR(rdev[i])) {
551 ret = PTR_ERR(rdev[i]);
552 dev_err(max8998->dev, "regulator init failed\n");
561 for (i = 0; i <= max8998->num_regulators; i++)
563 regulator_unregister(rdev[i]);
565 kfree(max8998->rdev);
571 static int __devexit max8998_pmic_remove(struct platform_device *pdev)
573 struct max8998_data *max8998 = platform_get_drvdata(pdev);
574 struct regulator_dev **rdev = max8998->rdev;
577 for (i = 0; i <= max8998->num_regulators; i++)
579 regulator_unregister(rdev[i]);
581 kfree(max8998->rdev);
587 static struct platform_driver max8998_pmic_driver = {
589 .name = "max8998-pmic",
590 .owner = THIS_MODULE,
592 .probe = max8998_pmic_probe,
593 .remove = __devexit_p(max8998_pmic_remove),
596 static int __init max8998_pmic_init(void)
598 return platform_driver_register(&max8998_pmic_driver);
600 subsys_initcall(max8998_pmic_init);
602 static void __exit max8998_pmic_cleanup(void)
604 platform_driver_unregister(&max8998_pmic_driver);
606 module_exit(max8998_pmic_cleanup);
608 MODULE_DESCRIPTION("MAXIM 8998 voltage regulator driver");
609 MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>");
610 MODULE_LICENSE("GPL");