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>
32 #include <linux/of_gpio.h>
33 #include <linux/platform_device.h>
34 #include <linux/regulator/driver.h>
35 #include <linux/regulator/of_regulator.h>
36 #include <linux/mfd/max8998.h>
37 #include <linux/mfd/max8998-private.h>
41 struct max8998_dev
*iodev
;
43 u8 buck1_vol
[4]; /* voltages for selection */
45 unsigned int buck1_idx
; /* index to last changed voltage */
47 unsigned int buck2_idx
;
50 struct voltage_map_desc
{
56 /* Voltage maps in uV*/
57 static const struct voltage_map_desc ldo23_voltage_map_desc
= {
58 .min
= 800000, .step
= 50000, .max
= 1300000,
60 static const struct voltage_map_desc ldo456711_voltage_map_desc
= {
61 .min
= 1600000, .step
= 100000, .max
= 3600000,
63 static const struct voltage_map_desc ldo8_voltage_map_desc
= {
64 .min
= 3000000, .step
= 100000, .max
= 3600000,
66 static const struct voltage_map_desc ldo9_voltage_map_desc
= {
67 .min
= 2800000, .step
= 100000, .max
= 3100000,
69 static const struct voltage_map_desc ldo10_voltage_map_desc
= {
70 .min
= 950000, .step
= 50000, .max
= 1300000,
72 static const struct voltage_map_desc ldo1213_voltage_map_desc
= {
73 .min
= 800000, .step
= 100000, .max
= 3300000,
75 static const struct voltage_map_desc ldo1415_voltage_map_desc
= {
76 .min
= 1200000, .step
= 100000, .max
= 3300000,
78 static const struct voltage_map_desc ldo1617_voltage_map_desc
= {
79 .min
= 1600000, .step
= 100000, .max
= 3600000,
81 static const struct voltage_map_desc buck12_voltage_map_desc
= {
82 .min
= 750000, .step
= 25000, .max
= 1525000,
84 static const struct voltage_map_desc buck3_voltage_map_desc
= {
85 .min
= 1600000, .step
= 100000, .max
= 3600000,
87 static const struct voltage_map_desc buck4_voltage_map_desc
= {
88 .min
= 800000, .step
= 100000, .max
= 2300000,
91 static const struct voltage_map_desc
*ldo_voltage_map
[] = {
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 */
116 static int max8998_get_enable_register(struct regulator_dev
*rdev
,
117 int *reg
, int *shift
)
119 int ldo
= rdev_get_id(rdev
);
122 case MAX8998_LDO2
... MAX8998_LDO5
:
123 *reg
= MAX8998_REG_ONOFF1
;
124 *shift
= 3 - (ldo
- MAX8998_LDO2
);
126 case MAX8998_LDO6
... MAX8998_LDO13
:
127 *reg
= MAX8998_REG_ONOFF2
;
128 *shift
= 7 - (ldo
- MAX8998_LDO6
);
130 case MAX8998_LDO14
... MAX8998_LDO17
:
131 *reg
= MAX8998_REG_ONOFF3
;
132 *shift
= 7 - (ldo
- MAX8998_LDO14
);
134 case MAX8998_BUCK1
... MAX8998_BUCK4
:
135 *reg
= MAX8998_REG_ONOFF1
;
136 *shift
= 7 - (ldo
- MAX8998_BUCK1
);
138 case MAX8998_EN32KHZ_AP
... MAX8998_ENVICHG
:
139 *reg
= MAX8998_REG_ONOFF4
;
140 *shift
= 7 - (ldo
- MAX8998_EN32KHZ_AP
);
142 case MAX8998_ESAFEOUT1
... MAX8998_ESAFEOUT2
:
143 *reg
= MAX8998_REG_CHGR2
;
144 *shift
= 7 - (ldo
- MAX8998_ESAFEOUT1
);
153 static int max8998_ldo_is_enabled(struct regulator_dev
*rdev
)
155 struct max8998_data
*max8998
= rdev_get_drvdata(rdev
);
156 struct i2c_client
*i2c
= max8998
->iodev
->i2c
;
157 int ret
, reg
, shift
= 8;
160 ret
= max8998_get_enable_register(rdev
, ®
, &shift
);
164 ret
= max8998_read_reg(i2c
, reg
, &val
);
168 return val
& (1 << shift
);
171 static int max8998_ldo_enable(struct regulator_dev
*rdev
)
173 struct max8998_data
*max8998
= rdev_get_drvdata(rdev
);
174 struct i2c_client
*i2c
= max8998
->iodev
->i2c
;
175 int reg
, shift
= 8, ret
;
177 ret
= max8998_get_enable_register(rdev
, ®
, &shift
);
181 return max8998_update_reg(i2c
, reg
, 1<<shift
, 1<<shift
);
184 static int max8998_ldo_disable(struct regulator_dev
*rdev
)
186 struct max8998_data
*max8998
= rdev_get_drvdata(rdev
);
187 struct i2c_client
*i2c
= max8998
->iodev
->i2c
;
188 int reg
, shift
= 8, ret
;
190 ret
= max8998_get_enable_register(rdev
, ®
, &shift
);
194 return max8998_update_reg(i2c
, reg
, 0, 1<<shift
);
197 static int max8998_get_voltage_register(struct regulator_dev
*rdev
,
198 int *_reg
, int *_shift
, int *_mask
)
200 int ldo
= rdev_get_id(rdev
);
201 struct max8998_data
*max8998
= rdev_get_drvdata(rdev
);
202 int reg
, shift
= 0, mask
= 0xff;
205 case MAX8998_LDO2
... MAX8998_LDO3
:
206 reg
= MAX8998_REG_LDO2_LDO3
;
208 if (ldo
== MAX8998_LDO2
)
213 case MAX8998_LDO4
... MAX8998_LDO7
:
214 reg
= MAX8998_REG_LDO4
+ (ldo
- MAX8998_LDO4
);
216 case MAX8998_LDO8
... MAX8998_LDO9
:
217 reg
= MAX8998_REG_LDO8_LDO9
;
219 if (ldo
== MAX8998_LDO8
)
224 case MAX8998_LDO10
... MAX8998_LDO11
:
225 reg
= MAX8998_REG_LDO10_LDO11
;
226 if (ldo
== MAX8998_LDO10
) {
234 case MAX8998_LDO12
... MAX8998_LDO17
:
235 reg
= MAX8998_REG_LDO12
+ (ldo
- MAX8998_LDO12
);
238 reg
= MAX8998_REG_BUCK1_VOLTAGE1
+ max8998
->buck1_idx
;
241 reg
= MAX8998_REG_BUCK2_VOLTAGE1
+ max8998
->buck2_idx
;
244 reg
= MAX8998_REG_BUCK3
;
247 reg
= MAX8998_REG_BUCK4
;
260 static int max8998_get_voltage_sel(struct regulator_dev
*rdev
)
262 struct max8998_data
*max8998
= rdev_get_drvdata(rdev
);
263 struct i2c_client
*i2c
= max8998
->iodev
->i2c
;
264 int reg
, shift
= 0, mask
, ret
;
267 ret
= max8998_get_voltage_register(rdev
, ®
, &shift
, &mask
);
271 ret
= max8998_read_reg(i2c
, reg
, &val
);
281 static int max8998_set_voltage_ldo_sel(struct regulator_dev
*rdev
,
284 struct max8998_data
*max8998
= rdev_get_drvdata(rdev
);
285 struct i2c_client
*i2c
= max8998
->iodev
->i2c
;
286 int reg
, shift
= 0, mask
, ret
;
288 ret
= max8998_get_voltage_register(rdev
, ®
, &shift
, &mask
);
292 ret
= max8998_update_reg(i2c
, reg
, selector
<<shift
, mask
<<shift
);
297 static inline void buck1_gpio_set(int gpio1
, int gpio2
, int v
)
299 gpio_set_value(gpio1
, v
& 0x1);
300 gpio_set_value(gpio2
, (v
>> 1) & 0x1);
303 static inline void buck2_gpio_set(int gpio
, int v
)
305 gpio_set_value(gpio
, v
& 0x1);
308 static int max8998_set_voltage_buck_sel(struct regulator_dev
*rdev
,
311 struct max8998_data
*max8998
= rdev_get_drvdata(rdev
);
312 struct max8998_platform_data
*pdata
= max8998
->iodev
->pdata
;
313 struct i2c_client
*i2c
= max8998
->iodev
->i2c
;
314 int buck
= rdev_get_id(rdev
);
315 int reg
, shift
= 0, mask
, ret
, j
;
316 static u8 buck1_last_val
;
318 ret
= max8998_get_voltage_register(rdev
, ®
, &shift
, &mask
);
324 dev_dbg(max8998
->dev
,
325 "BUCK1, selector:%d, buck1_vol1:%d, buck1_vol2:%d\n"
326 "buck1_vol3:%d, buck1_vol4:%d\n",
327 selector
, max8998
->buck1_vol
[0], max8998
->buck1_vol
[1],
328 max8998
->buck1_vol
[2], max8998
->buck1_vol
[3]);
330 if (gpio_is_valid(pdata
->buck1_set1
) &&
331 gpio_is_valid(pdata
->buck1_set2
)) {
333 /* check if requested voltage */
334 /* value is already defined */
335 for (j
= 0; j
< ARRAY_SIZE(max8998
->buck1_vol
); j
++) {
336 if (max8998
->buck1_vol
[j
] == selector
) {
337 max8998
->buck1_idx
= j
;
338 buck1_gpio_set(pdata
->buck1_set1
,
339 pdata
->buck1_set2
, j
);
344 if (pdata
->buck_voltage_lock
)
347 /* no predefine regulator found */
348 max8998
->buck1_idx
= (buck1_last_val
% 2) + 2;
349 dev_dbg(max8998
->dev
, "max8998->buck1_idx:%d\n",
351 max8998
->buck1_vol
[max8998
->buck1_idx
] = selector
;
352 ret
= max8998_get_voltage_register(rdev
, ®
,
355 ret
= max8998_write_reg(i2c
, reg
, selector
);
356 buck1_gpio_set(pdata
->buck1_set1
,
357 pdata
->buck1_set2
, max8998
->buck1_idx
);
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
));
365 ret
= max8998_write_reg(i2c
, reg
, selector
);
370 dev_dbg(max8998
->dev
,
371 "BUCK2, selector:%d buck2_vol1:%d, buck2_vol2:%d\n",
372 selector
, max8998
->buck2_vol
[0], max8998
->buck2_vol
[1]);
373 if (gpio_is_valid(pdata
->buck2_set3
)) {
375 /* check if requested voltage */
376 /* value is already defined */
377 for (j
= 0; j
< ARRAY_SIZE(max8998
->buck2_vol
); j
++) {
378 if (max8998
->buck2_vol
[j
] == selector
) {
379 max8998
->buck2_idx
= j
;
380 buck2_gpio_set(pdata
->buck2_set3
, j
);
385 if (pdata
->buck_voltage_lock
)
388 max8998_get_voltage_register(rdev
,
389 ®
, &shift
, &mask
);
390 ret
= max8998_write_reg(i2c
, reg
, selector
);
391 max8998
->buck2_vol
[max8998
->buck2_idx
] = selector
;
392 buck2_gpio_set(pdata
->buck2_set3
, max8998
->buck2_idx
);
394 dev_dbg(max8998
->dev
, "%s: SET3:%d\n", i2c
->name
,
395 gpio_get_value(pdata
->buck2_set3
));
397 ret
= max8998_write_reg(i2c
, reg
, selector
);
403 ret
= max8998_update_reg(i2c
, reg
, selector
<<shift
,
411 static int max8998_set_voltage_buck_time_sel(struct regulator_dev
*rdev
,
412 unsigned int old_selector
,
413 unsigned int new_selector
)
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
);
422 if (buck
< MAX8998_BUCK1
|| buck
> MAX8998_BUCK4
)
425 desc
= ldo_voltage_map
[buck
];
427 /* Voltage stabilization */
428 ret
= max8998_read_reg(i2c
, MAX8998_REG_ONOFF4
, &val
);
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
))
437 difference
= (new_selector
- old_selector
) * desc
->step
/ 1000;
439 return DIV_ROUND_UP(difference
, (val
& 0x0f) + 1);
444 static struct regulator_ops max8998_ldo_ops
= {
445 .list_voltage
= regulator_list_voltage_linear
,
446 .map_voltage
= regulator_map_voltage_linear
,
447 .is_enabled
= max8998_ldo_is_enabled
,
448 .enable
= max8998_ldo_enable
,
449 .disable
= max8998_ldo_disable
,
450 .get_voltage_sel
= max8998_get_voltage_sel
,
451 .set_voltage_sel
= max8998_set_voltage_ldo_sel
,
454 static struct regulator_ops max8998_buck_ops
= {
455 .list_voltage
= regulator_list_voltage_linear
,
456 .map_voltage
= regulator_map_voltage_linear
,
457 .is_enabled
= max8998_ldo_is_enabled
,
458 .enable
= max8998_ldo_enable
,
459 .disable
= max8998_ldo_disable
,
460 .get_voltage_sel
= max8998_get_voltage_sel
,
461 .set_voltage_sel
= max8998_set_voltage_buck_sel
,
462 .set_voltage_time_sel
= max8998_set_voltage_buck_time_sel
,
465 static struct regulator_ops max8998_others_ops
= {
466 .is_enabled
= max8998_ldo_is_enabled
,
467 .enable
= max8998_ldo_enable
,
468 .disable
= max8998_ldo_disable
,
471 static struct regulator_desc regulators
[] = {
475 .ops
= &max8998_ldo_ops
,
476 .type
= REGULATOR_VOLTAGE
,
477 .owner
= THIS_MODULE
,
481 .ops
= &max8998_ldo_ops
,
482 .type
= REGULATOR_VOLTAGE
,
483 .owner
= THIS_MODULE
,
487 .ops
= &max8998_ldo_ops
,
488 .type
= REGULATOR_VOLTAGE
,
489 .owner
= THIS_MODULE
,
493 .ops
= &max8998_ldo_ops
,
494 .type
= REGULATOR_VOLTAGE
,
495 .owner
= THIS_MODULE
,
499 .ops
= &max8998_ldo_ops
,
500 .type
= REGULATOR_VOLTAGE
,
501 .owner
= THIS_MODULE
,
505 .ops
= &max8998_ldo_ops
,
506 .type
= REGULATOR_VOLTAGE
,
507 .owner
= THIS_MODULE
,
511 .ops
= &max8998_ldo_ops
,
512 .type
= REGULATOR_VOLTAGE
,
513 .owner
= THIS_MODULE
,
517 .ops
= &max8998_ldo_ops
,
518 .type
= REGULATOR_VOLTAGE
,
519 .owner
= THIS_MODULE
,
523 .ops
= &max8998_ldo_ops
,
524 .type
= REGULATOR_VOLTAGE
,
525 .owner
= THIS_MODULE
,
529 .ops
= &max8998_ldo_ops
,
530 .type
= REGULATOR_VOLTAGE
,
531 .owner
= THIS_MODULE
,
535 .ops
= &max8998_ldo_ops
,
536 .type
= REGULATOR_VOLTAGE
,
537 .owner
= THIS_MODULE
,
541 .ops
= &max8998_ldo_ops
,
542 .type
= REGULATOR_VOLTAGE
,
543 .owner
= THIS_MODULE
,
547 .ops
= &max8998_ldo_ops
,
548 .type
= REGULATOR_VOLTAGE
,
549 .owner
= THIS_MODULE
,
553 .ops
= &max8998_ldo_ops
,
554 .type
= REGULATOR_VOLTAGE
,
555 .owner
= THIS_MODULE
,
559 .ops
= &max8998_ldo_ops
,
560 .type
= REGULATOR_VOLTAGE
,
561 .owner
= THIS_MODULE
,
565 .ops
= &max8998_ldo_ops
,
566 .type
= REGULATOR_VOLTAGE
,
567 .owner
= THIS_MODULE
,
571 .ops
= &max8998_buck_ops
,
572 .type
= REGULATOR_VOLTAGE
,
573 .owner
= THIS_MODULE
,
577 .ops
= &max8998_buck_ops
,
578 .type
= REGULATOR_VOLTAGE
,
579 .owner
= THIS_MODULE
,
583 .ops
= &max8998_buck_ops
,
584 .type
= REGULATOR_VOLTAGE
,
585 .owner
= THIS_MODULE
,
589 .ops
= &max8998_buck_ops
,
590 .type
= REGULATOR_VOLTAGE
,
591 .owner
= THIS_MODULE
,
593 .name
= "EN32KHz-AP",
594 .id
= MAX8998_EN32KHZ_AP
,
595 .ops
= &max8998_others_ops
,
596 .type
= REGULATOR_VOLTAGE
,
597 .owner
= THIS_MODULE
,
599 .name
= "EN32KHz-CP",
600 .id
= MAX8998_EN32KHZ_CP
,
601 .ops
= &max8998_others_ops
,
602 .type
= REGULATOR_VOLTAGE
,
603 .owner
= THIS_MODULE
,
606 .id
= MAX8998_ENVICHG
,
607 .ops
= &max8998_others_ops
,
608 .type
= REGULATOR_VOLTAGE
,
609 .owner
= THIS_MODULE
,
612 .id
= MAX8998_ESAFEOUT1
,
613 .ops
= &max8998_others_ops
,
614 .type
= REGULATOR_VOLTAGE
,
615 .owner
= THIS_MODULE
,
618 .id
= MAX8998_ESAFEOUT2
,
619 .ops
= &max8998_others_ops
,
620 .type
= REGULATOR_VOLTAGE
,
621 .owner
= THIS_MODULE
,
625 static int max8998_pmic_dt_parse_dvs_gpio(struct max8998_dev
*iodev
,
626 struct max8998_platform_data
*pdata
,
627 struct device_node
*pmic_np
)
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
);
636 pdata
->buck1_set1
= gpio
;
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
);
643 pdata
->buck1_set2
= gpio
;
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
);
650 pdata
->buck2_set3
= gpio
;
655 static int max8998_pmic_dt_parse_pdata(struct max8998_dev
*iodev
,
656 struct max8998_platform_data
*pdata
)
658 struct device_node
*pmic_np
= iodev
->dev
->of_node
;
659 struct device_node
*regulators_np
, *reg_np
;
660 struct max8998_regulator_data
*rdata
;
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");
670 /* count the number of regulators to be supported in pmic */
671 pdata
->num_regulators
= of_get_child_count(regulators_np
);
673 rdata
= devm_kcalloc(iodev
->dev
,
674 pdata
->num_regulators
, sizeof(*rdata
),
677 of_node_put(regulators_np
);
681 pdata
->regulators
= rdata
;
682 for (i
= 0; i
< ARRAY_SIZE(regulators
); ++i
) {
683 reg_np
= of_get_child_by_name(regulators_np
,
688 rdata
->id
= regulators
[i
].id
;
689 rdata
->initdata
= of_get_regulator_init_data(iodev
->dev
,
692 rdata
->reg_node
= reg_np
;
695 pdata
->num_regulators
= rdata
- pdata
->regulators
;
698 of_node_put(regulators_np
);
700 ret
= max8998_pmic_dt_parse_dvs_gpio(iodev
, pdata
, pmic_np
);
704 if (of_find_property(pmic_np
, "max8998,pmic-buck-voltage-lock", NULL
))
705 pdata
->buck_voltage_lock
= true;
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");
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");
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
));
728 dev_err(iodev
->dev
, "buck1 voltages not specified\n");
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
));
737 dev_err(iodev
->dev
, "buck2 voltages not specified\n");
744 static int max8998_pmic_probe(struct platform_device
*pdev
)
746 struct max8998_dev
*iodev
= dev_get_drvdata(pdev
->dev
.parent
);
747 struct max8998_platform_data
*pdata
= iodev
->pdata
;
748 struct regulator_config config
= { };
749 struct regulator_dev
*rdev
;
750 struct max8998_data
*max8998
;
751 struct i2c_client
*i2c
;
756 dev_err(pdev
->dev
.parent
, "No platform init data supplied\n");
760 if (IS_ENABLED(CONFIG_OF
) && iodev
->dev
->of_node
) {
761 ret
= max8998_pmic_dt_parse_pdata(iodev
, pdata
);
766 max8998
= devm_kzalloc(&pdev
->dev
, sizeof(struct max8998_data
),
771 max8998
->dev
= &pdev
->dev
;
772 max8998
->iodev
= iodev
;
773 max8998
->num_regulators
= pdata
->num_regulators
;
774 platform_set_drvdata(pdev
, max8998
);
775 i2c
= max8998
->iodev
->i2c
;
777 max8998
->buck1_idx
= pdata
->buck1_default_idx
;
778 max8998
->buck2_idx
= pdata
->buck2_default_idx
;
781 /* For unused GPIO NOT marked as -1 (thereof equal to 0) WARN_ON */
782 /* will be displayed */
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
) {
790 "MAX8998 SET1 GPIO defined as 0 !\n");
791 WARN_ON(!pdata
->buck1_set1
);
794 /* Check if SET2 is not equal to 0 */
795 if (!pdata
->buck1_set2
) {
797 "MAX8998 SET2 GPIO defined as 0 !\n");
798 WARN_ON(!pdata
->buck1_set2
);
802 gpio_request(pdata
->buck1_set1
, "MAX8998 BUCK1_SET1");
803 gpio_direction_output(pdata
->buck1_set1
,
804 max8998
->buck1_idx
& 0x1);
807 gpio_request(pdata
->buck1_set2
, "MAX8998 BUCK1_SET2");
808 gpio_direction_output(pdata
->buck1_set2
,
809 (max8998
->buck1_idx
>> 1) & 0x1);
811 /* Set predefined values for BUCK1 registers */
812 for (v
= 0; v
< ARRAY_SIZE(pdata
->buck1_voltage
); ++v
) {
814 while (buck12_voltage_map_desc
.min
+
815 buck12_voltage_map_desc
.step
*i
816 < pdata
->buck1_voltage
[v
])
819 max8998
->buck1_vol
[v
] = i
;
820 ret
= max8998_write_reg(i2c
,
821 MAX8998_REG_BUCK1_VOLTAGE1
+ v
, i
);
827 if (gpio_is_valid(pdata
->buck2_set3
)) {
828 /* Check if SET3 is not equal to 0 */
829 if (!pdata
->buck2_set3
) {
831 "MAX8998 SET3 GPIO defined as 0 !\n");
832 WARN_ON(!pdata
->buck2_set3
);
835 gpio_request(pdata
->buck2_set3
, "MAX8998 BUCK2_SET3");
836 gpio_direction_output(pdata
->buck2_set3
,
837 max8998
->buck2_idx
& 0x1);
839 /* Set predefined values for BUCK2 registers */
840 for (v
= 0; v
< ARRAY_SIZE(pdata
->buck2_voltage
); ++v
) {
842 while (buck12_voltage_map_desc
.min
+
843 buck12_voltage_map_desc
.step
*i
844 < pdata
->buck2_voltage
[v
])
847 max8998
->buck2_vol
[v
] = i
;
848 ret
= max8998_write_reg(i2c
,
849 MAX8998_REG_BUCK2_VOLTAGE1
+ v
, i
);
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
;
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;
864 regulators
[index
].n_voltages
= count
;
865 regulators
[index
].min_uV
= desc
->min
;
866 regulators
[index
].uV_step
= desc
->step
;
869 config
.dev
= max8998
->dev
;
870 config
.of_node
= pdata
->regulators
[i
].reg_node
;
871 config
.init_data
= pdata
->regulators
[i
].initdata
;
872 config
.driver_data
= max8998
;
874 rdev
= devm_regulator_register(&pdev
->dev
, ®ulators
[index
],
878 dev_err(max8998
->dev
, "regulator %s init failed (%d)\n",
879 regulators
[index
].name
, ret
);
888 static const struct platform_device_id max8998_pmic_id
[] = {
889 { "max8998-pmic", TYPE_MAX8998
},
890 { "lp3974-pmic", TYPE_LP3974
},
893 MODULE_DEVICE_TABLE(platform
, max8998_pmic_id
);
895 static struct platform_driver max8998_pmic_driver
= {
897 .name
= "max8998-pmic",
899 .probe
= max8998_pmic_probe
,
900 .id_table
= max8998_pmic_id
,
903 static int __init
max8998_pmic_init(void)
905 return platform_driver_register(&max8998_pmic_driver
);
907 subsys_initcall(max8998_pmic_init
);
909 static void __exit
max8998_pmic_cleanup(void)
911 platform_driver_unregister(&max8998_pmic_driver
);
913 module_exit(max8998_pmic_cleanup
);
915 MODULE_DESCRIPTION("MAXIM 8998 voltage regulator driver");
916 MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>");
917 MODULE_LICENSE("GPL");