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 static const struct regulator_linear_range wm831x_gp_ldo_ranges
[] = {
66 { .min_uV
= 900000, .min_sel
= 0, .max_sel
= 14, .uV_step
= 50000 },
67 { .min_uV
= 1700000, .min_sel
= 15, .max_sel
= 31, .uV_step
= 100000 },
70 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev
*rdev
,
73 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
74 struct wm831x
*wm831x
= ldo
->wm831x
;
75 int sel
, reg
= ldo
->base
+ WM831X_LDO_SLEEP_CONTROL
;
77 sel
= regulator_map_voltage_linear_range(rdev
, uV
, uV
);
81 return wm831x_set_bits(wm831x
, reg
, WM831X_LDO1_ON_VSEL_MASK
, sel
);
84 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev
*rdev
)
86 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
87 struct wm831x
*wm831x
= ldo
->wm831x
;
88 int ctrl_reg
= ldo
->base
+ WM831X_LDO_CONTROL
;
89 int on_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
92 ret
= wm831x_reg_read(wm831x
, on_reg
);
96 if (!(ret
& WM831X_LDO1_ON_MODE
))
97 return REGULATOR_MODE_NORMAL
;
99 ret
= wm831x_reg_read(wm831x
, ctrl_reg
);
103 if (ret
& WM831X_LDO1_LP_MODE
)
104 return REGULATOR_MODE_STANDBY
;
106 return REGULATOR_MODE_IDLE
;
109 static int wm831x_gp_ldo_set_mode(struct regulator_dev
*rdev
,
112 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
113 struct wm831x
*wm831x
= ldo
->wm831x
;
114 int ctrl_reg
= ldo
->base
+ WM831X_LDO_CONTROL
;
115 int on_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
120 case REGULATOR_MODE_NORMAL
:
121 ret
= wm831x_set_bits(wm831x
, on_reg
,
122 WM831X_LDO1_ON_MODE
, 0);
127 case REGULATOR_MODE_IDLE
:
128 ret
= wm831x_set_bits(wm831x
, ctrl_reg
,
129 WM831X_LDO1_LP_MODE
, 0);
133 ret
= wm831x_set_bits(wm831x
, on_reg
,
135 WM831X_LDO1_ON_MODE
);
140 case REGULATOR_MODE_STANDBY
:
141 ret
= wm831x_set_bits(wm831x
, ctrl_reg
,
143 WM831X_LDO1_LP_MODE
);
147 ret
= wm831x_set_bits(wm831x
, on_reg
,
149 WM831X_LDO1_ON_MODE
);
161 static int wm831x_gp_ldo_get_status(struct regulator_dev
*rdev
)
163 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
164 struct wm831x
*wm831x
= ldo
->wm831x
;
165 int mask
= 1 << rdev_get_id(rdev
);
168 /* Is the regulator on? */
169 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_STATUS
);
173 return REGULATOR_STATUS_OFF
;
175 /* Is it reporting under voltage? */
176 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_UV_STATUS
);
180 return REGULATOR_STATUS_ERROR
;
182 ret
= wm831x_gp_ldo_get_mode(rdev
);
186 return regulator_mode_to_status(ret
);
189 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev
*rdev
,
191 int output_uV
, int load_uA
)
194 return REGULATOR_MODE_STANDBY
;
196 return REGULATOR_MODE_IDLE
;
197 return REGULATOR_MODE_NORMAL
;
201 static struct regulator_ops wm831x_gp_ldo_ops
= {
202 .list_voltage
= regulator_list_voltage_linear_range
,
203 .map_voltage
= regulator_map_voltage_linear_range
,
204 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
205 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
206 .set_suspend_voltage
= wm831x_gp_ldo_set_suspend_voltage
,
207 .get_mode
= wm831x_gp_ldo_get_mode
,
208 .set_mode
= wm831x_gp_ldo_set_mode
,
209 .get_status
= wm831x_gp_ldo_get_status
,
210 .get_optimum_mode
= wm831x_gp_ldo_get_optimum_mode
,
211 .get_bypass
= regulator_get_bypass_regmap
,
212 .set_bypass
= regulator_set_bypass_regmap
,
214 .is_enabled
= regulator_is_enabled_regmap
,
215 .enable
= regulator_enable_regmap
,
216 .disable
= regulator_disable_regmap
,
219 static int wm831x_gp_ldo_probe(struct platform_device
*pdev
)
221 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
222 struct wm831x_pdata
*pdata
= dev_get_platdata(wm831x
->dev
);
223 struct regulator_config config
= { };
225 struct wm831x_ldo
*ldo
;
226 struct resource
*res
;
229 if (pdata
&& pdata
->wm831x_num
)
230 id
= (pdata
->wm831x_num
* 10) + 1;
235 dev_dbg(&pdev
->dev
, "Probing LDO%d\n", id
+ 1);
237 ldo
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_ldo
), GFP_KERNEL
);
239 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
243 ldo
->wm831x
= wm831x
;
245 res
= platform_get_resource(pdev
, IORESOURCE_REG
, 0);
247 dev_err(&pdev
->dev
, "No REG resource\n");
251 ldo
->base
= res
->start
;
253 snprintf(ldo
->name
, sizeof(ldo
->name
), "LDO%d", id
+ 1);
254 ldo
->desc
.name
= ldo
->name
;
256 snprintf(ldo
->supply_name
, sizeof(ldo
->supply_name
),
258 ldo
->desc
.supply_name
= ldo
->supply_name
;
261 ldo
->desc
.type
= REGULATOR_VOLTAGE
;
262 ldo
->desc
.n_voltages
= 32;
263 ldo
->desc
.ops
= &wm831x_gp_ldo_ops
;
264 ldo
->desc
.owner
= THIS_MODULE
;
265 ldo
->desc
.vsel_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
266 ldo
->desc
.vsel_mask
= WM831X_LDO1_ON_VSEL_MASK
;
267 ldo
->desc
.enable_reg
= WM831X_LDO_ENABLE
;
268 ldo
->desc
.enable_mask
= 1 << id
;
269 ldo
->desc
.bypass_reg
= ldo
->base
;
270 ldo
->desc
.bypass_mask
= WM831X_LDO1_SWI
;
271 ldo
->desc
.linear_ranges
= wm831x_gp_ldo_ranges
;
272 ldo
->desc
.n_linear_ranges
= ARRAY_SIZE(wm831x_gp_ldo_ranges
);
274 config
.dev
= pdev
->dev
.parent
;
276 config
.init_data
= pdata
->ldo
[id
];
277 config
.driver_data
= ldo
;
278 config
.regmap
= wm831x
->regmap
;
280 ldo
->regulator
= regulator_register(&ldo
->desc
, &config
);
281 if (IS_ERR(ldo
->regulator
)) {
282 ret
= PTR_ERR(ldo
->regulator
);
283 dev_err(wm831x
->dev
, "Failed to register LDO%d: %d\n",
288 irq
= wm831x_irq(wm831x
, platform_get_irq_byname(pdev
, "UV"));
289 ret
= request_threaded_irq(irq
, NULL
, wm831x_ldo_uv_irq
,
290 IRQF_TRIGGER_RISING
, ldo
->name
,
293 dev_err(&pdev
->dev
, "Failed to request UV IRQ %d: %d\n",
298 platform_set_drvdata(pdev
, ldo
);
303 regulator_unregister(ldo
->regulator
);
308 static int wm831x_gp_ldo_remove(struct platform_device
*pdev
)
310 struct wm831x_ldo
*ldo
= platform_get_drvdata(pdev
);
312 free_irq(wm831x_irq(ldo
->wm831x
,
313 platform_get_irq_byname(pdev
, "UV")), ldo
);
314 regulator_unregister(ldo
->regulator
);
319 static struct platform_driver wm831x_gp_ldo_driver
= {
320 .probe
= wm831x_gp_ldo_probe
,
321 .remove
= wm831x_gp_ldo_remove
,
323 .name
= "wm831x-ldo",
324 .owner
= THIS_MODULE
,
332 static const struct regulator_linear_range wm831x_aldo_ranges
[] = {
333 { .min_uV
= 1000000, .min_sel
= 0, .max_sel
= 12, .uV_step
= 50000 },
334 { .min_uV
= 1700000, .min_sel
= 13, .max_sel
= 31, .uV_step
= 100000 },
337 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev
*rdev
,
340 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
341 struct wm831x
*wm831x
= ldo
->wm831x
;
342 int sel
, reg
= ldo
->base
+ WM831X_LDO_SLEEP_CONTROL
;
344 sel
= regulator_map_voltage_linear_range(rdev
, uV
, uV
);
348 return wm831x_set_bits(wm831x
, reg
, WM831X_LDO7_ON_VSEL_MASK
, sel
);
351 static unsigned int wm831x_aldo_get_mode(struct regulator_dev
*rdev
)
353 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
354 struct wm831x
*wm831x
= ldo
->wm831x
;
355 int on_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
358 ret
= wm831x_reg_read(wm831x
, on_reg
);
362 if (ret
& WM831X_LDO7_ON_MODE
)
363 return REGULATOR_MODE_IDLE
;
365 return REGULATOR_MODE_NORMAL
;
368 static int wm831x_aldo_set_mode(struct regulator_dev
*rdev
,
371 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
372 struct wm831x
*wm831x
= ldo
->wm831x
;
373 int on_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
378 case REGULATOR_MODE_NORMAL
:
379 ret
= wm831x_set_bits(wm831x
, on_reg
, WM831X_LDO7_ON_MODE
, 0);
384 case REGULATOR_MODE_IDLE
:
385 ret
= wm831x_set_bits(wm831x
, on_reg
, WM831X_LDO7_ON_MODE
,
386 WM831X_LDO7_ON_MODE
);
398 static int wm831x_aldo_get_status(struct regulator_dev
*rdev
)
400 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
401 struct wm831x
*wm831x
= ldo
->wm831x
;
402 int mask
= 1 << rdev_get_id(rdev
);
405 /* Is the regulator on? */
406 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_STATUS
);
410 return REGULATOR_STATUS_OFF
;
412 /* Is it reporting under voltage? */
413 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_UV_STATUS
);
417 return REGULATOR_STATUS_ERROR
;
419 ret
= wm831x_aldo_get_mode(rdev
);
423 return regulator_mode_to_status(ret
);
426 static struct regulator_ops wm831x_aldo_ops
= {
427 .list_voltage
= regulator_list_voltage_linear_range
,
428 .map_voltage
= regulator_map_voltage_linear_range
,
429 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
430 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
431 .set_suspend_voltage
= wm831x_aldo_set_suspend_voltage
,
432 .get_mode
= wm831x_aldo_get_mode
,
433 .set_mode
= wm831x_aldo_set_mode
,
434 .get_status
= wm831x_aldo_get_status
,
435 .set_bypass
= regulator_set_bypass_regmap
,
436 .get_bypass
= regulator_get_bypass_regmap
,
438 .is_enabled
= regulator_is_enabled_regmap
,
439 .enable
= regulator_enable_regmap
,
440 .disable
= regulator_disable_regmap
,
443 static int wm831x_aldo_probe(struct platform_device
*pdev
)
445 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
446 struct wm831x_pdata
*pdata
= dev_get_platdata(wm831x
->dev
);
447 struct regulator_config config
= { };
449 struct wm831x_ldo
*ldo
;
450 struct resource
*res
;
453 if (pdata
&& pdata
->wm831x_num
)
454 id
= (pdata
->wm831x_num
* 10) + 1;
459 dev_dbg(&pdev
->dev
, "Probing LDO%d\n", id
+ 1);
461 ldo
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_ldo
), GFP_KERNEL
);
463 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
467 ldo
->wm831x
= wm831x
;
469 res
= platform_get_resource(pdev
, IORESOURCE_REG
, 0);
471 dev_err(&pdev
->dev
, "No REG resource\n");
475 ldo
->base
= res
->start
;
477 snprintf(ldo
->name
, sizeof(ldo
->name
), "LDO%d", id
+ 1);
478 ldo
->desc
.name
= ldo
->name
;
480 snprintf(ldo
->supply_name
, sizeof(ldo
->supply_name
),
482 ldo
->desc
.supply_name
= ldo
->supply_name
;
485 ldo
->desc
.type
= REGULATOR_VOLTAGE
;
486 ldo
->desc
.n_voltages
= 32;
487 ldo
->desc
.linear_ranges
= wm831x_aldo_ranges
;
488 ldo
->desc
.n_linear_ranges
= ARRAY_SIZE(wm831x_aldo_ranges
);
489 ldo
->desc
.ops
= &wm831x_aldo_ops
;
490 ldo
->desc
.owner
= THIS_MODULE
;
491 ldo
->desc
.vsel_reg
= ldo
->base
+ WM831X_LDO_ON_CONTROL
;
492 ldo
->desc
.vsel_mask
= WM831X_LDO7_ON_VSEL_MASK
;
493 ldo
->desc
.enable_reg
= WM831X_LDO_ENABLE
;
494 ldo
->desc
.enable_mask
= 1 << id
;
495 ldo
->desc
.bypass_reg
= ldo
->base
;
496 ldo
->desc
.bypass_mask
= WM831X_LDO7_SWI
;
498 config
.dev
= pdev
->dev
.parent
;
500 config
.init_data
= pdata
->ldo
[id
];
501 config
.driver_data
= ldo
;
502 config
.regmap
= wm831x
->regmap
;
504 ldo
->regulator
= regulator_register(&ldo
->desc
, &config
);
505 if (IS_ERR(ldo
->regulator
)) {
506 ret
= PTR_ERR(ldo
->regulator
);
507 dev_err(wm831x
->dev
, "Failed to register LDO%d: %d\n",
512 irq
= wm831x_irq(wm831x
, platform_get_irq_byname(pdev
, "UV"));
513 ret
= request_threaded_irq(irq
, NULL
, wm831x_ldo_uv_irq
,
514 IRQF_TRIGGER_RISING
, ldo
->name
, ldo
);
516 dev_err(&pdev
->dev
, "Failed to request UV IRQ %d: %d\n",
521 platform_set_drvdata(pdev
, ldo
);
526 regulator_unregister(ldo
->regulator
);
531 static int wm831x_aldo_remove(struct platform_device
*pdev
)
533 struct wm831x_ldo
*ldo
= platform_get_drvdata(pdev
);
535 free_irq(wm831x_irq(ldo
->wm831x
, platform_get_irq_byname(pdev
, "UV")),
537 regulator_unregister(ldo
->regulator
);
542 static struct platform_driver wm831x_aldo_driver
= {
543 .probe
= wm831x_aldo_probe
,
544 .remove
= wm831x_aldo_remove
,
546 .name
= "wm831x-aldo",
547 .owner
= THIS_MODULE
,
555 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
557 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev
*rdev
,
560 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
561 struct wm831x
*wm831x
= ldo
->wm831x
;
562 int sel
, reg
= ldo
->base
+ WM831X_ALIVE_LDO_SLEEP_CONTROL
;
564 sel
= regulator_map_voltage_linear(rdev
, uV
, uV
);
568 return wm831x_set_bits(wm831x
, reg
, WM831X_LDO11_ON_VSEL_MASK
, sel
);
571 static int wm831x_alive_ldo_get_status(struct regulator_dev
*rdev
)
573 struct wm831x_ldo
*ldo
= rdev_get_drvdata(rdev
);
574 struct wm831x
*wm831x
= ldo
->wm831x
;
575 int mask
= 1 << rdev_get_id(rdev
);
578 /* Is the regulator on? */
579 ret
= wm831x_reg_read(wm831x
, WM831X_LDO_STATUS
);
583 return REGULATOR_STATUS_ON
;
585 return REGULATOR_STATUS_OFF
;
588 static struct regulator_ops wm831x_alive_ldo_ops
= {
589 .list_voltage
= regulator_list_voltage_linear
,
590 .map_voltage
= regulator_map_voltage_linear
,
591 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
592 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
593 .set_suspend_voltage
= wm831x_alive_ldo_set_suspend_voltage
,
594 .get_status
= wm831x_alive_ldo_get_status
,
596 .is_enabled
= regulator_is_enabled_regmap
,
597 .enable
= regulator_enable_regmap
,
598 .disable
= regulator_disable_regmap
,
601 static int wm831x_alive_ldo_probe(struct platform_device
*pdev
)
603 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
604 struct wm831x_pdata
*pdata
= dev_get_platdata(wm831x
->dev
);
605 struct regulator_config config
= { };
607 struct wm831x_ldo
*ldo
;
608 struct resource
*res
;
611 if (pdata
&& pdata
->wm831x_num
)
612 id
= (pdata
->wm831x_num
* 10) + 1;
618 dev_dbg(&pdev
->dev
, "Probing LDO%d\n", id
+ 1);
620 ldo
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_ldo
), GFP_KERNEL
);
622 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
626 ldo
->wm831x
= wm831x
;
628 res
= platform_get_resource(pdev
, IORESOURCE_REG
, 0);
630 dev_err(&pdev
->dev
, "No REG resource\n");
634 ldo
->base
= res
->start
;
636 snprintf(ldo
->name
, sizeof(ldo
->name
), "LDO%d", id
+ 1);
637 ldo
->desc
.name
= ldo
->name
;
639 snprintf(ldo
->supply_name
, sizeof(ldo
->supply_name
),
641 ldo
->desc
.supply_name
= ldo
->supply_name
;
644 ldo
->desc
.type
= REGULATOR_VOLTAGE
;
645 ldo
->desc
.n_voltages
= WM831X_ALIVE_LDO_MAX_SELECTOR
+ 1;
646 ldo
->desc
.ops
= &wm831x_alive_ldo_ops
;
647 ldo
->desc
.owner
= THIS_MODULE
;
648 ldo
->desc
.vsel_reg
= ldo
->base
+ WM831X_ALIVE_LDO_ON_CONTROL
;
649 ldo
->desc
.vsel_mask
= WM831X_LDO11_ON_VSEL_MASK
;
650 ldo
->desc
.enable_reg
= WM831X_LDO_ENABLE
;
651 ldo
->desc
.enable_mask
= 1 << id
;
652 ldo
->desc
.min_uV
= 800000;
653 ldo
->desc
.uV_step
= 50000;
654 ldo
->desc
.enable_time
= 1000;
656 config
.dev
= pdev
->dev
.parent
;
658 config
.init_data
= pdata
->ldo
[id
];
659 config
.driver_data
= ldo
;
660 config
.regmap
= wm831x
->regmap
;
662 ldo
->regulator
= regulator_register(&ldo
->desc
, &config
);
663 if (IS_ERR(ldo
->regulator
)) {
664 ret
= PTR_ERR(ldo
->regulator
);
665 dev_err(wm831x
->dev
, "Failed to register LDO%d: %d\n",
670 platform_set_drvdata(pdev
, ldo
);
678 static int wm831x_alive_ldo_remove(struct platform_device
*pdev
)
680 struct wm831x_ldo
*ldo
= platform_get_drvdata(pdev
);
682 regulator_unregister(ldo
->regulator
);
687 static struct platform_driver wm831x_alive_ldo_driver
= {
688 .probe
= wm831x_alive_ldo_probe
,
689 .remove
= wm831x_alive_ldo_remove
,
691 .name
= "wm831x-alive-ldo",
692 .owner
= THIS_MODULE
,
696 static int __init
wm831x_ldo_init(void)
700 ret
= platform_driver_register(&wm831x_gp_ldo_driver
);
702 pr_err("Failed to register WM831x GP LDO driver: %d\n", ret
);
704 ret
= platform_driver_register(&wm831x_aldo_driver
);
706 pr_err("Failed to register WM831x ALDO driver: %d\n", ret
);
708 ret
= platform_driver_register(&wm831x_alive_ldo_driver
);
710 pr_err("Failed to register WM831x alive LDO driver: %d\n",
715 subsys_initcall(wm831x_ldo_init
);
717 static void __exit
wm831x_ldo_exit(void)
719 platform_driver_unregister(&wm831x_alive_ldo_driver
);
720 platform_driver_unregister(&wm831x_aldo_driver
);
721 platform_driver_unregister(&wm831x_gp_ldo_driver
);
723 module_exit(wm831x_ldo_exit
);
725 /* Module information */
726 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
727 MODULE_DESCRIPTION("WM831x LDO driver");
728 MODULE_LICENSE("GPL");
729 MODULE_ALIAS("platform:wm831x-ldo");
730 MODULE_ALIAS("platform:wm831x-aldo");
731 MODULE_ALIAS("platform:wm831x-aliveldo");