2 * wm831x-ldo.c -- LDO driver for the WM831x series
4 * Copyright 2009 Wolfson Microelectronics PLC.
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/init.h>
17 #include <linux/bitops.h>
18 #include <linux/err.h>
19 #include <linux/i2c.h>
20 #include <linux/platform_device.h>
21 #include <linux/regulator/driver.h>
22 #include <linux/slab.h>
24 #include <linux/mfd/wm831x/core.h>
25 #include <linux/mfd/wm831x/regulator.h>
26 #include <linux/mfd/wm831x/pdata.h>
28 #define WM831X_LDO_MAX_NAME 9
30 #define WM831X_LDO_CONTROL 0
31 #define WM831X_LDO_ON_CONTROL 1
32 #define WM831X_LDO_SLEEP_CONTROL 2
34 #define WM831X_ALIVE_LDO_ON_CONTROL 0
35 #define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
38 char name
[WM831X_LDO_MAX_NAME
];
39 char supply_name
[WM831X_LDO_MAX_NAME
];
40 struct regulator_desc desc
;
42 struct wm831x
*wm831x
;
43 struct regulator_dev
*regulator
;
50 static irqreturn_t
wm831x_ldo_uv_irq(int irq
, void *data
)
52 struct wm831x_ldo
*ldo
= data
;
54 regulator_notifier_call_chain(ldo
->regulator
,
55 REGULATOR_EVENT_UNDER_VOLTAGE
,
62 * General purpose LDOs
65 #define WM831X_GP_LDO_SELECTOR_LOW 0xe
66 #define WM831X_GP_LDO_MAX_SELECTOR 0x1f
68 static int wm831x_gp_ldo_list_voltage(struct regulator_dev
*rdev
,
69 unsigned int selector
)
71 /* 0.9-1.6V in 50mV steps */
72 if (selector
<= WM831X_GP_LDO_SELECTOR_LOW
)
73 return 900000 + (selector
* 50000);
74 /* 1.7-3.3V in 100mV steps */
75 if (selector
<= WM831X_GP_LDO_MAX_SELECTOR
)
76 return 1600000 + ((selector
- WM831X_GP_LDO_SELECTOR_LOW
)
81 static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev
*rdev
, int reg
,
82 int min_uV
, int max_uV
,
85 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
86 struct wm831x
*wm831x
= ldo
->wm831x
;
91 else if (min_uV
< 1700000)
92 vsel
= ((min_uV
- 900000) / 50000);
94 vsel
= ((min_uV
- 1700000) / 100000)
95 + WM831X_GP_LDO_SELECTOR_LOW
+ 1;
97 ret
= wm831x_gp_ldo_list_voltage(rdev
, vsel
);
100 if (ret
< min_uV
|| ret
> max_uV
)
105 return wm831x_set_bits(wm831x
, reg
, WM831X_LDO1_ON_VSEL_MASK
, vsel
);
108 static int wm831x_gp_ldo_set_voltage(struct regulator_dev
*rdev
,
109 int min_uV
, int max_uV
,
112 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
113 int reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
115 return wm831x_gp_ldo_set_voltage_int(rdev
, reg
, min_uV
, max_uV
,
119 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev
*rdev
,
122 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
123 int reg
= ldo
->base
+ WM831X_LDO_SLEEP_CONTROL
;
124 unsigned int selector
;
126 return wm831x_gp_ldo_set_voltage_int(rdev
, reg
, uV
, uV
, &selector
);
129 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev
*rdev
)
131 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
132 struct wm831x
*wm831x
= ldo
->wm831x
;
133 int ctrl_reg
= ldo
->base
+ WM831X_LDO_CONTROL
;
134 int on_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
137 ret
= wm831x_reg_read(wm831x
, on_reg
);
141 if (!(ret
& WM831X_LDO1_ON_MODE
))
142 return REGULATOR_MODE_NORMAL
;
144 ret
= wm831x_reg_read(wm831x
, ctrl_reg
);
148 if (ret
& WM831X_LDO1_LP_MODE
)
149 return REGULATOR_MODE_STANDBY
;
151 return REGULATOR_MODE_IDLE
;
154 static int wm831x_gp_ldo_set_mode(struct regulator_dev
*rdev
,
157 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
158 struct wm831x
*wm831x
= ldo
->wm831x
;
159 int ctrl_reg
= ldo
->base
+ WM831X_LDO_CONTROL
;
160 int on_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
165 case REGULATOR_MODE_NORMAL
:
166 ret
= wm831x_set_bits(wm831x
, on_reg
,
167 WM831X_LDO1_ON_MODE
, 0);
172 case REGULATOR_MODE_IDLE
:
173 ret
= wm831x_set_bits(wm831x
, ctrl_reg
,
174 WM831X_LDO1_LP_MODE
, 0);
178 ret
= wm831x_set_bits(wm831x
, on_reg
,
180 WM831X_LDO1_ON_MODE
);
185 case REGULATOR_MODE_STANDBY
:
186 ret
= wm831x_set_bits(wm831x
, ctrl_reg
,
188 WM831X_LDO1_LP_MODE
);
192 ret
= wm831x_set_bits(wm831x
, on_reg
,
194 WM831X_LDO1_ON_MODE
);
206 static int wm831x_gp_ldo_get_status(struct regulator_dev
*rdev
)
208 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
209 struct wm831x
*wm831x
= ldo
->wm831x
;
210 int mask
= 1 << rdev_get_id(rdev
);
213 /* Is the regulator on? */
214 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_STATUS
);
218 return REGULATOR_STATUS_OFF
;
220 /* Is it reporting under voltage? */
221 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_UV_STATUS
);
223 return REGULATOR_STATUS_ERROR
;
225 ret
= wm831x_gp_ldo_get_mode(rdev
);
229 return regulator_mode_to_status(ret
);
232 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev
*rdev
,
234 int output_uV
, int load_uA
)
237 return REGULATOR_MODE_STANDBY
;
239 return REGULATOR_MODE_IDLE
;
240 return REGULATOR_MODE_NORMAL
;
244 static struct regulator_ops wm831x_gp_ldo_ops
= {
245 .list_voltage
= wm831x_gp_ldo_list_voltage
,
246 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
247 .set_voltage
= wm831x_gp_ldo_set_voltage
,
248 .set_suspend_voltage
= wm831x_gp_ldo_set_suspend_voltage
,
249 .get_mode
= wm831x_gp_ldo_get_mode
,
250 .set_mode
= wm831x_gp_ldo_set_mode
,
251 .get_status
= wm831x_gp_ldo_get_status
,
252 .get_optimum_mode
= wm831x_gp_ldo_get_optimum_mode
,
254 .is_enabled
= regulator_is_enabled_regmap
,
255 .enable
= regulator_enable_regmap
,
256 .disable
= regulator_disable_regmap
,
259 static __devinit
int wm831x_gp_ldo_probe(struct platform_device
*pdev
)
261 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
262 struct wm831x_pdata
*pdata
= wm831x
->dev
->platform_data
;
263 struct regulator_config config
= { };
265 struct wm831x_ldo
*ldo
;
266 struct resource
*res
;
269 if (pdata
&& pdata
->wm831x_num
)
270 id
= (pdata
->wm831x_num
* 10) + 1;
275 dev_dbg(&pdev
->dev
, "Probing LDO%d\n", id
+ 1);
277 ldo
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_ldo
), GFP_KERNEL
);
279 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
283 ldo
->wm831x
= wm831x
;
285 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
287 dev_err(&pdev
->dev
, "No I/O resource\n");
291 ldo
->base
= res
->start
;
293 snprintf(ldo
->name
, sizeof(ldo
->name
), "LDO%d", id
+ 1);
294 ldo
->desc
.name
= ldo
->name
;
296 snprintf(ldo
->supply_name
, sizeof(ldo
->supply_name
),
298 ldo
->desc
.supply_name
= ldo
->supply_name
;
301 ldo
->desc
.type
= REGULATOR_VOLTAGE
;
302 ldo
->desc
.n_voltages
= WM831X_GP_LDO_MAX_SELECTOR
+ 1;
303 ldo
->desc
.ops
= &wm831x_gp_ldo_ops
;
304 ldo
->desc
.owner
= THIS_MODULE
;
305 ldo
->desc
.vsel_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
306 ldo
->desc
.vsel_mask
= WM831X_LDO1_ON_VSEL_MASK
;
307 ldo
->desc
.enable_reg
= WM831X_LDO_ENABLE
;
308 ldo
->desc
.enable_mask
= 1 << id
;
310 config
.dev
= pdev
->dev
.parent
;
312 config
.init_data
= pdata
->ldo
[id
];
313 config
.driver_data
= ldo
;
314 config
.regmap
= wm831x
->regmap
;
316 ldo
->regulator
= regulator_register(&ldo
->desc
, &config
);
317 if (IS_ERR(ldo
->regulator
)) {
318 ret
= PTR_ERR(ldo
->regulator
);
319 dev_err(wm831x
->dev
, "Failed to register LDO%d: %d\n",
324 irq
= platform_get_irq_byname(pdev
, "UV");
325 ret
= request_threaded_irq(irq
, NULL
, wm831x_ldo_uv_irq
,
326 IRQF_TRIGGER_RISING
, ldo
->name
,
329 dev_err(&pdev
->dev
, "Failed to request UV IRQ %d: %d\n",
334 platform_set_drvdata(pdev
, ldo
);
339 regulator_unregister(ldo
->regulator
);
344 static __devexit
int wm831x_gp_ldo_remove(struct platform_device
*pdev
)
346 struct wm831x_ldo
*ldo
= platform_get_drvdata(pdev
);
348 platform_set_drvdata(pdev
, NULL
);
350 free_irq(platform_get_irq_byname(pdev
, "UV"), ldo
);
351 regulator_unregister(ldo
->regulator
);
356 static struct platform_driver wm831x_gp_ldo_driver
= {
357 .probe
= wm831x_gp_ldo_probe
,
358 .remove
= __devexit_p(wm831x_gp_ldo_remove
),
360 .name
= "wm831x-ldo",
361 .owner
= THIS_MODULE
,
370 #define WM831X_ALDO_SELECTOR_LOW 0xc
371 #define WM831X_ALDO_MAX_SELECTOR 0x1f
373 static int wm831x_aldo_list_voltage(struct regulator_dev
*rdev
,
374 unsigned int selector
)
376 /* 1-1.6V in 50mV steps */
377 if (selector
<= WM831X_ALDO_SELECTOR_LOW
)
378 return 1000000 + (selector
* 50000);
379 /* 1.7-3.5V in 100mV steps */
380 if (selector
<= WM831X_ALDO_MAX_SELECTOR
)
381 return 1600000 + ((selector
- WM831X_ALDO_SELECTOR_LOW
)
386 static int wm831x_aldo_set_voltage_int(struct regulator_dev
*rdev
, int reg
,
387 int min_uV
, int max_uV
,
390 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
391 struct wm831x
*wm831x
= ldo
->wm831x
;
394 if (min_uV
< 1000000)
396 else if (min_uV
< 1700000)
397 vsel
= ((min_uV
- 1000000) / 50000);
399 vsel
= ((min_uV
- 1700000) / 100000)
400 + WM831X_ALDO_SELECTOR_LOW
+ 1;
402 ret
= wm831x_aldo_list_voltage(rdev
, vsel
);
405 if (ret
< min_uV
|| ret
> max_uV
)
410 return wm831x_set_bits(wm831x
, reg
, WM831X_LDO7_ON_VSEL_MASK
, vsel
);
413 static int wm831x_aldo_set_voltage(struct regulator_dev
*rdev
,
414 int min_uV
, int max_uV
, unsigned *selector
)
416 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
417 int reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
419 return wm831x_aldo_set_voltage_int(rdev
, reg
, min_uV
, max_uV
,
423 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev
*rdev
,
426 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
427 int reg
= ldo
->base
+ WM831X_LDO_SLEEP_CONTROL
;
428 unsigned int selector
;
430 return wm831x_aldo_set_voltage_int(rdev
, reg
, uV
, uV
, &selector
);
433 static unsigned int wm831x_aldo_get_mode(struct regulator_dev
*rdev
)
435 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
436 struct wm831x
*wm831x
= ldo
->wm831x
;
437 int on_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
440 ret
= wm831x_reg_read(wm831x
, on_reg
);
444 if (ret
& WM831X_LDO7_ON_MODE
)
445 return REGULATOR_MODE_IDLE
;
447 return REGULATOR_MODE_NORMAL
;
450 static int wm831x_aldo_set_mode(struct regulator_dev
*rdev
,
453 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
454 struct wm831x
*wm831x
= ldo
->wm831x
;
455 int on_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
460 case REGULATOR_MODE_NORMAL
:
461 ret
= wm831x_set_bits(wm831x
, on_reg
, WM831X_LDO7_ON_MODE
, 0);
466 case REGULATOR_MODE_IDLE
:
467 ret
= wm831x_set_bits(wm831x
, on_reg
, WM831X_LDO7_ON_MODE
,
468 WM831X_LDO7_ON_MODE
);
480 static int wm831x_aldo_get_status(struct regulator_dev
*rdev
)
482 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
483 struct wm831x
*wm831x
= ldo
->wm831x
;
484 int mask
= 1 << rdev_get_id(rdev
);
487 /* Is the regulator on? */
488 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_STATUS
);
492 return REGULATOR_STATUS_OFF
;
494 /* Is it reporting under voltage? */
495 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_UV_STATUS
);
497 return REGULATOR_STATUS_ERROR
;
499 ret
= wm831x_aldo_get_mode(rdev
);
503 return regulator_mode_to_status(ret
);
506 static struct regulator_ops wm831x_aldo_ops
= {
507 .list_voltage
= wm831x_aldo_list_voltage
,
508 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
509 .set_voltage
= wm831x_aldo_set_voltage
,
510 .set_suspend_voltage
= wm831x_aldo_set_suspend_voltage
,
511 .get_mode
= wm831x_aldo_get_mode
,
512 .set_mode
= wm831x_aldo_set_mode
,
513 .get_status
= wm831x_aldo_get_status
,
515 .is_enabled
= regulator_is_enabled_regmap
,
516 .enable
= regulator_enable_regmap
,
517 .disable
= regulator_disable_regmap
,
520 static __devinit
int wm831x_aldo_probe(struct platform_device
*pdev
)
522 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
523 struct wm831x_pdata
*pdata
= wm831x
->dev
->platform_data
;
524 struct regulator_config config
= { };
526 struct wm831x_ldo
*ldo
;
527 struct resource
*res
;
530 if (pdata
&& pdata
->wm831x_num
)
531 id
= (pdata
->wm831x_num
* 10) + 1;
536 dev_dbg(&pdev
->dev
, "Probing LDO%d\n", id
+ 1);
538 ldo
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_ldo
), GFP_KERNEL
);
540 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
544 ldo
->wm831x
= wm831x
;
546 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
548 dev_err(&pdev
->dev
, "No I/O resource\n");
552 ldo
->base
= res
->start
;
554 snprintf(ldo
->name
, sizeof(ldo
->name
), "LDO%d", id
+ 1);
555 ldo
->desc
.name
= ldo
->name
;
557 snprintf(ldo
->supply_name
, sizeof(ldo
->supply_name
),
559 ldo
->desc
.supply_name
= ldo
->supply_name
;
562 ldo
->desc
.type
= REGULATOR_VOLTAGE
;
563 ldo
->desc
.n_voltages
= WM831X_ALDO_MAX_SELECTOR
+ 1;
564 ldo
->desc
.ops
= &wm831x_aldo_ops
;
565 ldo
->desc
.owner
= THIS_MODULE
;
566 ldo
->desc
.vsel_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
567 ldo
->desc
.vsel_mask
= WM831X_LDO7_ON_VSEL_MASK
;
568 ldo
->desc
.enable_reg
= WM831X_LDO_ENABLE
;
569 ldo
->desc
.enable_mask
= 1 << id
;
571 config
.dev
= pdev
->dev
.parent
;
573 config
.init_data
= pdata
->ldo
[id
];
574 config
.driver_data
= ldo
;
575 config
.regmap
= wm831x
->regmap
;
577 ldo
->regulator
= regulator_register(&ldo
->desc
, &config
);
578 if (IS_ERR(ldo
->regulator
)) {
579 ret
= PTR_ERR(ldo
->regulator
);
580 dev_err(wm831x
->dev
, "Failed to register LDO%d: %d\n",
585 irq
= platform_get_irq_byname(pdev
, "UV");
586 ret
= request_threaded_irq(irq
, NULL
, wm831x_ldo_uv_irq
,
587 IRQF_TRIGGER_RISING
, ldo
->name
, ldo
);
589 dev_err(&pdev
->dev
, "Failed to request UV IRQ %d: %d\n",
594 platform_set_drvdata(pdev
, ldo
);
599 regulator_unregister(ldo
->regulator
);
604 static __devexit
int wm831x_aldo_remove(struct platform_device
*pdev
)
606 struct wm831x_ldo
*ldo
= platform_get_drvdata(pdev
);
608 free_irq(platform_get_irq_byname(pdev
, "UV"), ldo
);
609 regulator_unregister(ldo
->regulator
);
614 static struct platform_driver wm831x_aldo_driver
= {
615 .probe
= wm831x_aldo_probe
,
616 .remove
= __devexit_p(wm831x_aldo_remove
),
618 .name
= "wm831x-aldo",
619 .owner
= THIS_MODULE
,
627 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
629 static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev
*rdev
,
631 int min_uV
, int max_uV
,
634 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
635 struct wm831x
*wm831x
= ldo
->wm831x
;
638 vsel
= (min_uV
- 800000) / 50000;
640 ret
= regulator_list_voltage_linear(rdev
, vsel
);
643 if (ret
< min_uV
|| ret
> max_uV
)
648 return wm831x_set_bits(wm831x
, reg
, WM831X_LDO11_ON_VSEL_MASK
, vsel
);
651 static int wm831x_alive_ldo_set_voltage(struct regulator_dev
*rdev
,
652 int min_uV
, int max_uV
,
655 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
656 int reg
= ldo
->base
+ WM831X_ALIVE_LDO_ON_CONTROL
;
658 return wm831x_alive_ldo_set_voltage_int(rdev
, reg
, min_uV
, max_uV
,
662 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev
*rdev
,
665 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
666 int reg
= ldo
->base
+ WM831X_ALIVE_LDO_SLEEP_CONTROL
;
669 return wm831x_alive_ldo_set_voltage_int(rdev
, reg
, uV
, uV
, &selector
);
672 static int wm831x_alive_ldo_get_status(struct regulator_dev
*rdev
)
674 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
675 struct wm831x
*wm831x
= ldo
->wm831x
;
676 int mask
= 1 << rdev_get_id(rdev
);
679 /* Is the regulator on? */
680 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_STATUS
);
684 return REGULATOR_STATUS_ON
;
686 return REGULATOR_STATUS_OFF
;
689 static struct regulator_ops wm831x_alive_ldo_ops
= {
690 .list_voltage
= regulator_list_voltage_linear
,
691 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
692 .set_voltage
= wm831x_alive_ldo_set_voltage
,
693 .set_suspend_voltage
= wm831x_alive_ldo_set_suspend_voltage
,
694 .get_status
= wm831x_alive_ldo_get_status
,
696 .is_enabled
= regulator_is_enabled_regmap
,
697 .enable
= regulator_enable_regmap
,
698 .disable
= regulator_disable_regmap
,
701 static __devinit
int wm831x_alive_ldo_probe(struct platform_device
*pdev
)
703 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
704 struct wm831x_pdata
*pdata
= wm831x
->dev
->platform_data
;
705 struct regulator_config config
= { };
707 struct wm831x_ldo
*ldo
;
708 struct resource
*res
;
711 if (pdata
&& pdata
->wm831x_num
)
712 id
= (pdata
->wm831x_num
* 10) + 1;
718 dev_dbg(&pdev
->dev
, "Probing LDO%d\n", id
+ 1);
720 ldo
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_ldo
), GFP_KERNEL
);
722 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
726 ldo
->wm831x
= wm831x
;
728 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
730 dev_err(&pdev
->dev
, "No I/O resource\n");
734 ldo
->base
= res
->start
;
736 snprintf(ldo
->name
, sizeof(ldo
->name
), "LDO%d", id
+ 1);
737 ldo
->desc
.name
= ldo
->name
;
739 snprintf(ldo
->supply_name
, sizeof(ldo
->supply_name
),
741 ldo
->desc
.supply_name
= ldo
->supply_name
;
744 ldo
->desc
.type
= REGULATOR_VOLTAGE
;
745 ldo
->desc
.n_voltages
= WM831X_ALIVE_LDO_MAX_SELECTOR
+ 1;
746 ldo
->desc
.ops
= &wm831x_alive_ldo_ops
;
747 ldo
->desc
.owner
= THIS_MODULE
;
748 ldo
->desc
.vsel_reg
= ldo
->base
+ WM831X_ALIVE_LDO_ON_CONTROL
;
749 ldo
->desc
.vsel_mask
= WM831X_LDO11_ON_VSEL_MASK
;
750 ldo
->desc
.enable_reg
= WM831X_LDO_ENABLE
;
751 ldo
->desc
.enable_mask
= 1 << id
;
752 ldo
->desc
.min_uV
= 800000;
753 ldo
->desc
.uV_step
= 50000;
755 config
.dev
= pdev
->dev
.parent
;
757 config
.init_data
= pdata
->ldo
[id
];
758 config
.driver_data
= ldo
;
759 config
.regmap
= wm831x
->regmap
;
761 ldo
->regulator
= regulator_register(&ldo
->desc
, &config
);
762 if (IS_ERR(ldo
->regulator
)) {
763 ret
= PTR_ERR(ldo
->regulator
);
764 dev_err(wm831x
->dev
, "Failed to register LDO%d: %d\n",
769 platform_set_drvdata(pdev
, ldo
);
777 static __devexit
int wm831x_alive_ldo_remove(struct platform_device
*pdev
)
779 struct wm831x_ldo
*ldo
= platform_get_drvdata(pdev
);
781 regulator_unregister(ldo
->regulator
);
786 static struct platform_driver wm831x_alive_ldo_driver
= {
787 .probe
= wm831x_alive_ldo_probe
,
788 .remove
= __devexit_p(wm831x_alive_ldo_remove
),
790 .name
= "wm831x-alive-ldo",
791 .owner
= THIS_MODULE
,
795 static int __init
wm831x_ldo_init(void)
799 ret
= platform_driver_register(&wm831x_gp_ldo_driver
);
801 pr_err("Failed to register WM831x GP LDO driver: %d\n", ret
);
803 ret
= platform_driver_register(&wm831x_aldo_driver
);
805 pr_err("Failed to register WM831x ALDO driver: %d\n", ret
);
807 ret
= platform_driver_register(&wm831x_alive_ldo_driver
);
809 pr_err("Failed to register WM831x alive LDO driver: %d\n",
814 subsys_initcall(wm831x_ldo_init
);
816 static void __exit
wm831x_ldo_exit(void)
818 platform_driver_unregister(&wm831x_alive_ldo_driver
);
819 platform_driver_unregister(&wm831x_aldo_driver
);
820 platform_driver_unregister(&wm831x_gp_ldo_driver
);
822 module_exit(wm831x_ldo_exit
);
824 /* Module information */
825 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
826 MODULE_DESCRIPTION("WM831x LDO driver");
827 MODULE_LICENSE("GPL");
828 MODULE_ALIAS("platform:wm831x-ldo");
829 MODULE_ALIAS("platform:wm831x-aldo");
830 MODULE_ALIAS("platform:wm831x-aliveldo");