4 * Copyright (c) 2011 Samsung Electronics Co., Ltd
5 * http://www.samsung.com
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
14 #include <linux/bug.h>
15 #include <linux/delay.h>
16 #include <linux/err.h>
17 #include <linux/gpio.h>
18 #include <linux/slab.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/regulator/driver.h>
22 #include <linux/regulator/machine.h>
23 #include <linux/mfd/s5m87xx/s5m-core.h>
24 #include <linux/mfd/s5m87xx/s5m-pmic.h>
28 struct s5m87xx_dev
*iodev
;
30 struct regulator_dev
**rdev
;
47 struct s5m_voltage_desc
{
53 static const struct s5m_voltage_desc buck_voltage_val1
= {
59 static const struct s5m_voltage_desc buck_voltage_val2
= {
65 static const struct s5m_voltage_desc buck_voltage_val3
= {
71 static const struct s5m_voltage_desc ldo_voltage_val1
= {
77 static const struct s5m_voltage_desc ldo_voltage_val2
= {
83 static const struct s5m_voltage_desc
*reg_voltage_map
[] = {
84 [S5M8767_LDO1
] = &ldo_voltage_val2
,
85 [S5M8767_LDO2
] = &ldo_voltage_val2
,
86 [S5M8767_LDO3
] = &ldo_voltage_val1
,
87 [S5M8767_LDO4
] = &ldo_voltage_val1
,
88 [S5M8767_LDO5
] = &ldo_voltage_val1
,
89 [S5M8767_LDO6
] = &ldo_voltage_val2
,
90 [S5M8767_LDO7
] = &ldo_voltage_val2
,
91 [S5M8767_LDO8
] = &ldo_voltage_val2
,
92 [S5M8767_LDO9
] = &ldo_voltage_val1
,
93 [S5M8767_LDO10
] = &ldo_voltage_val1
,
94 [S5M8767_LDO11
] = &ldo_voltage_val1
,
95 [S5M8767_LDO12
] = &ldo_voltage_val1
,
96 [S5M8767_LDO13
] = &ldo_voltage_val1
,
97 [S5M8767_LDO14
] = &ldo_voltage_val1
,
98 [S5M8767_LDO15
] = &ldo_voltage_val2
,
99 [S5M8767_LDO16
] = &ldo_voltage_val1
,
100 [S5M8767_LDO17
] = &ldo_voltage_val1
,
101 [S5M8767_LDO18
] = &ldo_voltage_val1
,
102 [S5M8767_LDO19
] = &ldo_voltage_val1
,
103 [S5M8767_LDO20
] = &ldo_voltage_val1
,
104 [S5M8767_LDO21
] = &ldo_voltage_val1
,
105 [S5M8767_LDO22
] = &ldo_voltage_val1
,
106 [S5M8767_LDO23
] = &ldo_voltage_val1
,
107 [S5M8767_LDO24
] = &ldo_voltage_val1
,
108 [S5M8767_LDO25
] = &ldo_voltage_val1
,
109 [S5M8767_LDO26
] = &ldo_voltage_val1
,
110 [S5M8767_LDO27
] = &ldo_voltage_val1
,
111 [S5M8767_LDO28
] = &ldo_voltage_val1
,
112 [S5M8767_BUCK1
] = &buck_voltage_val1
,
113 [S5M8767_BUCK2
] = &buck_voltage_val2
,
114 [S5M8767_BUCK3
] = &buck_voltage_val2
,
115 [S5M8767_BUCK4
] = &buck_voltage_val2
,
116 [S5M8767_BUCK5
] = &buck_voltage_val1
,
117 [S5M8767_BUCK6
] = &buck_voltage_val1
,
118 [S5M8767_BUCK7
] = NULL
,
119 [S5M8767_BUCK8
] = NULL
,
120 [S5M8767_BUCK9
] = &buck_voltage_val3
,
123 static int s5m8767_list_voltage(struct regulator_dev
*rdev
,
124 unsigned int selector
)
126 const struct s5m_voltage_desc
*desc
;
127 int reg_id
= rdev_get_id(rdev
);
130 if (reg_id
>= ARRAY_SIZE(reg_voltage_map
) || reg_id
< 0)
133 desc
= reg_voltage_map
[reg_id
];
137 val
= desc
->min
+ desc
->step
* selector
;
144 static int s5m8767_get_register(struct regulator_dev
*rdev
, int *reg
)
146 int reg_id
= rdev_get_id(rdev
);
149 case S5M8767_LDO1
... S5M8767_LDO2
:
150 *reg
= S5M8767_REG_LDO1CTRL
+ (reg_id
- S5M8767_LDO1
);
152 case S5M8767_LDO3
... S5M8767_LDO28
:
153 *reg
= S5M8767_REG_LDO3CTRL
+ (reg_id
- S5M8767_LDO3
);
156 *reg
= S5M8767_REG_BUCK1CTRL1
;
158 case S5M8767_BUCK2
... S5M8767_BUCK4
:
159 *reg
= S5M8767_REG_BUCK2CTRL
+ (reg_id
- S5M8767_BUCK2
) * 9;
162 *reg
= S5M8767_REG_BUCK5CTRL1
;
164 case S5M8767_BUCK6
... S5M8767_BUCK9
:
165 *reg
= S5M8767_REG_BUCK6CTRL1
+ (reg_id
- S5M8767_BUCK6
) * 2;
174 static int s5m8767_reg_is_enabled(struct regulator_dev
*rdev
)
176 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
178 int mask
= 0xc0, pattern
= 0xc0;
181 ret
= s5m8767_get_register(rdev
, ®
);
187 ret
= s5m_reg_read(s5m8767
->iodev
, reg
, &val
);
191 return (val
& mask
) == pattern
;
194 static int s5m8767_reg_enable(struct regulator_dev
*rdev
)
196 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
198 int mask
= 0xc0, pattern
= 0xc0;
200 ret
= s5m8767_get_register(rdev
, ®
);
204 return s5m_reg_update(s5m8767
->iodev
, reg
, pattern
, mask
);
207 static int s5m8767_reg_disable(struct regulator_dev
*rdev
)
209 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
211 int mask
= 0xc0, pattern
= 0xc0;
213 ret
= s5m8767_get_register(rdev
, ®
);
217 return s5m_reg_update(s5m8767
->iodev
, reg
, ~pattern
, mask
);
220 static int s5m8767_get_voltage_register(struct regulator_dev
*rdev
, int *_reg
)
222 int reg_id
= rdev_get_id(rdev
);
226 case S5M8767_LDO1
... S5M8767_LDO2
:
227 reg
= S5M8767_REG_LDO1CTRL
+ (reg_id
- S5M8767_LDO1
);
229 case S5M8767_LDO3
... S5M8767_LDO28
:
230 reg
= S5M8767_REG_LDO3CTRL
+ (reg_id
- S5M8767_LDO3
);
233 reg
= S5M8767_REG_BUCK1CTRL2
;
236 reg
= S5M8767_REG_BUCK2DVS1
;
239 reg
= S5M8767_REG_BUCK3DVS1
;
242 reg
= S5M8767_REG_BUCK4DVS1
;
245 reg
= S5M8767_REG_BUCK5CTRL2
;
247 case S5M8767_BUCK6
... S5M8767_BUCK9
:
248 reg
= S5M8767_REG_BUCK6CTRL2
+ (reg_id
- S5M8767_BUCK6
) * 2;
259 static int s5m8767_get_voltage_sel(struct regulator_dev
*rdev
)
261 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
262 int reg
, mask
= 0xff, ret
;
263 int reg_id
= rdev_get_id(rdev
);
266 ret
= s5m8767_get_voltage_register(rdev
, ®
);
271 case S5M8767_LDO1
... S5M8767_LDO28
:
275 if (s5m8767
->buck2_gpiodvs
)
276 reg
+= s5m8767
->buck_gpioindex
;
279 if (s5m8767
->buck3_gpiodvs
)
280 reg
+= s5m8767
->buck_gpioindex
;
283 if (s5m8767
->buck4_gpiodvs
)
284 reg
+= s5m8767
->buck_gpioindex
;
288 ret
= s5m_reg_read(s5m8767
->iodev
, reg
, &val
);
297 static int s5m8767_convert_voltage_to_sel(
298 const struct s5m_voltage_desc
*desc
,
299 int min_vol
, int max_vol
)
306 if (max_vol
< desc
->min
|| min_vol
> desc
->max
)
309 selector
= (min_vol
- desc
->min
) / desc
->step
;
311 if (desc
->min
+ desc
->step
* selector
> max_vol
)
317 static int s5m8767_set_voltage(struct regulator_dev
*rdev
,
318 int min_uV
, int max_uV
, unsigned *selector
)
320 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
321 const struct s5m_voltage_desc
*desc
;
322 int reg_id
= rdev_get_id(rdev
);
328 case S5M8767_LDO1
... S5M8767_LDO28
:
331 case S5M8767_BUCK1
... S5M8767_BUCK6
:
334 case S5M8767_BUCK7
... S5M8767_BUCK8
:
343 desc
= reg_voltage_map
[reg_id
];
345 i
= s5m8767_convert_voltage_to_sel(desc
, min_uV
, max_uV
);
349 ret
= s5m8767_get_voltage_register(rdev
, ®
);
353 s5m_reg_read(s5m8767
->iodev
, reg
, &val
);
356 ret
= s5m_reg_write(s5m8767
->iodev
, reg
, val
);
362 static inline void s5m8767_set_high(struct s5m8767_info
*s5m8767
)
364 int temp_index
= s5m8767
->buck_gpioindex
;
366 gpio_set_value(s5m8767
->buck_gpios
[0], (temp_index
>> 2) & 0x1);
367 gpio_set_value(s5m8767
->buck_gpios
[1], (temp_index
>> 1) & 0x1);
368 gpio_set_value(s5m8767
->buck_gpios
[2], temp_index
& 0x1);
371 static inline void s5m8767_set_low(struct s5m8767_info
*s5m8767
)
373 int temp_index
= s5m8767
->buck_gpioindex
;
375 gpio_set_value(s5m8767
->buck_gpios
[2], temp_index
& 0x1);
376 gpio_set_value(s5m8767
->buck_gpios
[1], (temp_index
>> 1) & 0x1);
377 gpio_set_value(s5m8767
->buck_gpios
[0], (temp_index
>> 2) & 0x1);
380 static int s5m8767_set_voltage_buck(struct regulator_dev
*rdev
,
381 int min_uV
, int max_uV
, unsigned *selector
)
383 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
384 int reg_id
= rdev_get_id(rdev
);
385 const struct s5m_voltage_desc
*desc
;
386 int new_val
, old_val
, i
= 0;
388 if (reg_id
< S5M8767_BUCK1
|| reg_id
> S5M8767_BUCK6
)
393 return s5m8767_set_voltage(rdev
, min_uV
, max_uV
, selector
);
394 case S5M8767_BUCK2
... S5M8767_BUCK4
:
396 case S5M8767_BUCK5
... S5M8767_BUCK6
:
397 return s5m8767_set_voltage(rdev
, min_uV
, max_uV
, selector
);
399 return s5m8767_set_voltage(rdev
, min_uV
, max_uV
, selector
);
402 desc
= reg_voltage_map
[reg_id
];
403 new_val
= s5m8767_convert_voltage_to_sel(desc
, min_uV
, max_uV
);
409 if (s5m8767
->buck2_gpiodvs
) {
410 while (s5m8767
->buck2_vol
[i
] != new_val
)
413 return s5m8767_set_voltage(rdev
, min_uV
,
417 if (s5m8767
->buck3_gpiodvs
) {
418 while (s5m8767
->buck3_vol
[i
] != new_val
)
421 return s5m8767_set_voltage(rdev
, min_uV
,
425 if (s5m8767
->buck3_gpiodvs
) {
426 while (s5m8767
->buck4_vol
[i
] != new_val
)
429 return s5m8767_set_voltage(rdev
, min_uV
,
434 old_val
= s5m8767
->buck_gpioindex
;
435 s5m8767
->buck_gpioindex
= i
;
438 s5m8767_set_high(s5m8767
);
440 s5m8767_set_low(s5m8767
);
446 static int s5m8767_set_voltage_time_sel(struct regulator_dev
*rdev
,
447 unsigned int old_sel
,
448 unsigned int new_sel
)
450 struct s5m8767_info
*s5m8767
= rdev_get_drvdata(rdev
);
451 const struct s5m_voltage_desc
*desc
;
452 int reg_id
= rdev_get_id(rdev
);
454 desc
= reg_voltage_map
[reg_id
];
456 if (old_sel
< new_sel
)
457 return DIV_ROUND_UP(desc
->step
* (new_sel
- old_sel
),
458 s5m8767
->ramp_delay
* 1000);
462 static struct regulator_ops s5m8767_ldo_ops
= {
463 .list_voltage
= s5m8767_list_voltage
,
464 .is_enabled
= s5m8767_reg_is_enabled
,
465 .enable
= s5m8767_reg_enable
,
466 .disable
= s5m8767_reg_disable
,
467 .get_voltage_sel
= s5m8767_get_voltage_sel
,
468 .set_voltage
= s5m8767_set_voltage
,
469 .set_voltage_time_sel
= s5m8767_set_voltage_time_sel
,
472 static struct regulator_ops s5m8767_buck_ops
= {
473 .list_voltage
= s5m8767_list_voltage
,
474 .is_enabled
= s5m8767_reg_is_enabled
,
475 .enable
= s5m8767_reg_enable
,
476 .disable
= s5m8767_reg_disable
,
477 .get_voltage_sel
= s5m8767_get_voltage_sel
,
478 .set_voltage
= s5m8767_set_voltage_buck
,
479 .set_voltage_time_sel
= s5m8767_set_voltage_time_sel
,
482 #define regulator_desc_ldo(num) { \
484 .id = S5M8767_LDO##num, \
485 .ops = &s5m8767_ldo_ops, \
486 .type = REGULATOR_VOLTAGE, \
487 .owner = THIS_MODULE, \
489 #define regulator_desc_buck(num) { \
490 .name = "BUCK"#num, \
491 .id = S5M8767_BUCK##num, \
492 .ops = &s5m8767_buck_ops, \
493 .type = REGULATOR_VOLTAGE, \
494 .owner = THIS_MODULE, \
497 static struct regulator_desc regulators
[] = {
498 regulator_desc_ldo(1),
499 regulator_desc_ldo(2),
500 regulator_desc_ldo(3),
501 regulator_desc_ldo(4),
502 regulator_desc_ldo(5),
503 regulator_desc_ldo(6),
504 regulator_desc_ldo(7),
505 regulator_desc_ldo(8),
506 regulator_desc_ldo(9),
507 regulator_desc_ldo(10),
508 regulator_desc_ldo(11),
509 regulator_desc_ldo(12),
510 regulator_desc_ldo(13),
511 regulator_desc_ldo(14),
512 regulator_desc_ldo(15),
513 regulator_desc_ldo(16),
514 regulator_desc_ldo(17),
515 regulator_desc_ldo(18),
516 regulator_desc_ldo(19),
517 regulator_desc_ldo(20),
518 regulator_desc_ldo(21),
519 regulator_desc_ldo(22),
520 regulator_desc_ldo(23),
521 regulator_desc_ldo(24),
522 regulator_desc_ldo(25),
523 regulator_desc_ldo(26),
524 regulator_desc_ldo(27),
525 regulator_desc_ldo(28),
526 regulator_desc_buck(1),
527 regulator_desc_buck(2),
528 regulator_desc_buck(3),
529 regulator_desc_buck(4),
530 regulator_desc_buck(5),
531 regulator_desc_buck(6),
532 regulator_desc_buck(7),
533 regulator_desc_buck(8),
534 regulator_desc_buck(9),
537 static __devinit
int s5m8767_pmic_probe(struct platform_device
*pdev
)
539 struct s5m87xx_dev
*iodev
= dev_get_drvdata(pdev
->dev
.parent
);
540 struct s5m_platform_data
*pdata
= dev_get_platdata(iodev
->dev
);
541 struct regulator_dev
**rdev
;
542 struct s5m8767_info
*s5m8767
;
546 dev_err(pdev
->dev
.parent
, "Platform data not supplied\n");
550 if (pdata
->buck2_gpiodvs
) {
551 if (pdata
->buck3_gpiodvs
|| pdata
->buck4_gpiodvs
) {
552 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
557 if (pdata
->buck3_gpiodvs
) {
558 if (pdata
->buck2_gpiodvs
|| pdata
->buck4_gpiodvs
) {
559 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
564 if (pdata
->buck4_gpiodvs
) {
565 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
) {
566 dev_err(&pdev
->dev
, "S5M8767 GPIO DVS NOT VALID\n");
571 s5m8767
= devm_kzalloc(&pdev
->dev
, sizeof(struct s5m8767_info
),
576 size
= sizeof(struct regulator_dev
*) * (S5M8767_REG_MAX
- 2);
577 s5m8767
->rdev
= devm_kzalloc(&pdev
->dev
, size
, GFP_KERNEL
);
581 rdev
= s5m8767
->rdev
;
582 s5m8767
->dev
= &pdev
->dev
;
583 s5m8767
->iodev
= iodev
;
584 s5m8767
->num_regulators
= S5M8767_REG_MAX
- 2;
585 platform_set_drvdata(pdev
, s5m8767
);
587 s5m8767
->buck_gpioindex
= pdata
->buck_default_idx
;
588 s5m8767
->buck2_gpiodvs
= pdata
->buck2_gpiodvs
;
589 s5m8767
->buck3_gpiodvs
= pdata
->buck3_gpiodvs
;
590 s5m8767
->buck4_gpiodvs
= pdata
->buck4_gpiodvs
;
591 s5m8767
->buck_gpios
[0] = pdata
->buck_gpios
[0];
592 s5m8767
->buck_gpios
[1] = pdata
->buck_gpios
[1];
593 s5m8767
->buck_gpios
[2] = pdata
->buck_gpios
[2];
594 s5m8767
->ramp_delay
= pdata
->buck_ramp_delay
;
595 s5m8767
->buck2_ramp
= pdata
->buck2_ramp_enable
;
596 s5m8767
->buck3_ramp
= pdata
->buck3_ramp_enable
;
597 s5m8767
->buck4_ramp
= pdata
->buck4_ramp_enable
;
599 for (i
= 0; i
< 8; i
++) {
600 if (s5m8767
->buck2_gpiodvs
) {
601 s5m8767
->buck2_vol
[i
] =
602 s5m8767_convert_voltage_to_sel(
604 pdata
->buck2_voltage
[i
],
605 pdata
->buck2_voltage
[i
] +
606 buck_voltage_val2
.step
);
609 if (s5m8767
->buck3_gpiodvs
) {
610 s5m8767
->buck3_vol
[i
] =
611 s5m8767_convert_voltage_to_sel(
613 pdata
->buck3_voltage
[i
],
614 pdata
->buck3_voltage
[i
] +
615 buck_voltage_val2
.step
);
618 if (s5m8767
->buck4_gpiodvs
) {
619 s5m8767
->buck4_vol
[i
] =
620 s5m8767_convert_voltage_to_sel(
622 pdata
->buck4_voltage
[i
],
623 pdata
->buck4_voltage
[i
] +
624 buck_voltage_val2
.step
);
628 if (pdata
->buck2_gpiodvs
|| pdata
->buck3_gpiodvs
||
629 pdata
->buck4_gpiodvs
) {
630 if (gpio_is_valid(pdata
->buck_gpios
[0]) &&
631 gpio_is_valid(pdata
->buck_gpios
[1]) &&
632 gpio_is_valid(pdata
->buck_gpios
[2])) {
633 ret
= gpio_request(pdata
->buck_gpios
[0],
636 dev_warn(&pdev
->dev
, "Duplicated gpio request for SET1\n");
638 ret
= gpio_request(pdata
->buck_gpios
[1],
641 dev_warn(&pdev
->dev
, "Duplicated gpio request for SET2\n");
643 ret
= gpio_request(pdata
->buck_gpios
[2],
646 dev_warn(&pdev
->dev
, "Duplicated gpio request for SET3\n");
648 gpio_direction_output(pdata
->buck_gpios
[0],
649 (s5m8767
->buck_gpioindex
>> 2) & 0x1);
651 gpio_direction_output(pdata
->buck_gpios
[1],
652 (s5m8767
->buck_gpioindex
>> 1) & 0x1);
654 gpio_direction_output(pdata
->buck_gpios
[2],
655 (s5m8767
->buck_gpioindex
>> 0) & 0x1);
658 dev_err(&pdev
->dev
, "GPIO NOT VALID\n");
664 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_BUCK2CTRL
,
665 (pdata
->buck2_gpiodvs
) ? (1 << 1) : (0 << 1), 1 << 1);
666 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_BUCK3CTRL
,
667 (pdata
->buck3_gpiodvs
) ? (1 << 1) : (0 << 1), 1 << 1);
668 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_BUCK4CTRL
,
669 (pdata
->buck4_gpiodvs
) ? (1 << 1) : (0 << 1), 1 << 1);
671 /* Initialize GPIO DVS registers */
672 for (i
= 0; i
< 8; i
++) {
673 if (s5m8767
->buck2_gpiodvs
) {
674 s5m_reg_write(s5m8767
->iodev
, S5M8767_REG_BUCK2DVS1
+ i
,
675 s5m8767
->buck2_vol
[i
]);
678 if (s5m8767
->buck3_gpiodvs
) {
679 s5m_reg_write(s5m8767
->iodev
, S5M8767_REG_BUCK3DVS1
+ i
,
680 s5m8767
->buck3_vol
[i
]);
683 if (s5m8767
->buck4_gpiodvs
) {
684 s5m_reg_write(s5m8767
->iodev
, S5M8767_REG_BUCK4DVS1
+ i
,
685 s5m8767
->buck4_vol
[i
]);
688 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_BUCK2CTRL
, 0x78, 0xff);
689 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_BUCK3CTRL
, 0x58, 0xff);
690 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_BUCK4CTRL
, 0x78, 0xff);
692 if (s5m8767
->buck2_ramp
)
693 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_DVSRAMP
, 0x08, 0x08);
695 if (s5m8767
->buck3_ramp
)
696 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_DVSRAMP
, 0x04, 0x04);
698 if (s5m8767
->buck4_ramp
)
699 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_DVSRAMP
, 0x02, 0x02);
701 if (s5m8767
->buck2_ramp
|| s5m8767
->buck3_ramp
702 || s5m8767
->buck4_ramp
) {
703 switch (s5m8767
->ramp_delay
) {
705 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_DVSRAMP
,
709 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_DVSRAMP
,
713 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_DVSRAMP
,
717 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_DVSRAMP
,
721 s5m_reg_update(s5m8767
->iodev
, S5M8767_REG_DVSRAMP
,
726 for (i
= 0; i
< pdata
->num_regulators
; i
++) {
727 const struct s5m_voltage_desc
*desc
;
728 int id
= pdata
->regulators
[i
].id
;
730 desc
= reg_voltage_map
[id
];
732 regulators
[id
].n_voltages
=
733 (desc
->max
- desc
->min
) / desc
->step
+ 1;
735 rdev
[i
] = regulator_register(®ulators
[id
], s5m8767
->dev
,
736 pdata
->regulators
[i
].initdata
, s5m8767
, NULL
);
737 if (IS_ERR(rdev
[i
])) {
738 ret
= PTR_ERR(rdev
[i
]);
739 dev_err(s5m8767
->dev
, "regulator init failed for %d\n",
748 for (i
= 0; i
< s5m8767
->num_regulators
; i
++)
750 regulator_unregister(rdev
[i
]);
755 static int __devexit
s5m8767_pmic_remove(struct platform_device
*pdev
)
757 struct s5m8767_info
*s5m8767
= platform_get_drvdata(pdev
);
758 struct regulator_dev
**rdev
= s5m8767
->rdev
;
761 for (i
= 0; i
< s5m8767
->num_regulators
; i
++)
763 regulator_unregister(rdev
[i
]);
768 static const struct platform_device_id s5m8767_pmic_id
[] = {
769 { "s5m8767-pmic", 0},
772 MODULE_DEVICE_TABLE(platform
, s5m8767_pmic_id
);
774 static struct platform_driver s5m8767_pmic_driver
= {
776 .name
= "s5m8767-pmic",
777 .owner
= THIS_MODULE
,
779 .probe
= s5m8767_pmic_probe
,
780 .remove
= __devexit_p(s5m8767_pmic_remove
),
781 .id_table
= s5m8767_pmic_id
,
784 static int __init
s5m8767_pmic_init(void)
786 return platform_driver_register(&s5m8767_pmic_driver
);
788 subsys_initcall(s5m8767_pmic_init
);
790 static void __exit
s5m8767_pmic_exit(void)
792 platform_driver_unregister(&s5m8767_pmic_driver
);
794 module_exit(s5m8767_pmic_exit
);
796 /* Module information */
797 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
798 MODULE_DESCRIPTION("SAMSUNG S5M8767 Regulator Driver");
799 MODULE_LICENSE("GPL");