2 * wm831x-dcdc.c -- DC-DC buck convertor 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/regulator/machine.h>
23 #include <linux/gpio.h>
24 #include <linux/slab.h>
26 #include <linux/mfd/wm831x/core.h>
27 #include <linux/mfd/wm831x/regulator.h>
28 #include <linux/mfd/wm831x/pdata.h>
30 #define WM831X_BUCKV_MAX_SELECTOR 0x68
31 #define WM831X_BUCKP_MAX_SELECTOR 0x66
33 #define WM831X_DCDC_MODE_FAST 0
34 #define WM831X_DCDC_MODE_NORMAL 1
35 #define WM831X_DCDC_MODE_IDLE 2
36 #define WM831X_DCDC_MODE_STANDBY 3
38 #define WM831X_DCDC_MAX_NAME 9
40 /* Register offsets in control block */
41 #define WM831X_DCDC_CONTROL_1 0
42 #define WM831X_DCDC_CONTROL_2 1
43 #define WM831X_DCDC_ON_CONFIG 2
44 #define WM831X_DCDC_SLEEP_CONTROL 3
45 #define WM831X_DCDC_DVS_CONTROL 4
52 char name
[WM831X_DCDC_MAX_NAME
];
53 char supply_name
[WM831X_DCDC_MAX_NAME
];
54 struct regulator_desc desc
;
56 struct wm831x
*wm831x
;
57 struct regulator_dev
*regulator
;
64 static int wm831x_dcdc_is_enabled(struct regulator_dev
*rdev
)
66 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
67 struct wm831x
*wm831x
= dcdc
->wm831x
;
68 int mask
= 1 << rdev_get_id(rdev
);
71 reg
= wm831x_reg_read(wm831x
, WM831X_DCDC_ENABLE
);
81 static int wm831x_dcdc_enable(struct regulator_dev
*rdev
)
83 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
84 struct wm831x
*wm831x
= dcdc
->wm831x
;
85 int mask
= 1 << rdev_get_id(rdev
);
87 return wm831x_set_bits(wm831x
, WM831X_DCDC_ENABLE
, mask
, mask
);
90 static int wm831x_dcdc_disable(struct regulator_dev
*rdev
)
92 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
93 struct wm831x
*wm831x
= dcdc
->wm831x
;
94 int mask
= 1 << rdev_get_id(rdev
);
96 return wm831x_set_bits(wm831x
, WM831X_DCDC_ENABLE
, mask
, 0);
99 static unsigned int wm831x_dcdc_get_mode(struct regulator_dev
*rdev
)
102 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
103 struct wm831x
*wm831x
= dcdc
->wm831x
;
104 u16 reg
= dcdc
->base
+ WM831X_DCDC_ON_CONFIG
;
107 val
= wm831x_reg_read(wm831x
, reg
);
111 val
= (val
& WM831X_DC1_ON_MODE_MASK
) >> WM831X_DC1_ON_MODE_SHIFT
;
114 case WM831X_DCDC_MODE_FAST
:
115 return REGULATOR_MODE_FAST
;
116 case WM831X_DCDC_MODE_NORMAL
:
117 return REGULATOR_MODE_NORMAL
;
118 case WM831X_DCDC_MODE_STANDBY
:
119 return REGULATOR_MODE_STANDBY
;
120 case WM831X_DCDC_MODE_IDLE
:
121 return REGULATOR_MODE_IDLE
;
128 static int wm831x_dcdc_set_mode_int(struct wm831x
*wm831x
, int reg
,
134 case REGULATOR_MODE_FAST
:
135 val
= WM831X_DCDC_MODE_FAST
;
137 case REGULATOR_MODE_NORMAL
:
138 val
= WM831X_DCDC_MODE_NORMAL
;
140 case REGULATOR_MODE_STANDBY
:
141 val
= WM831X_DCDC_MODE_STANDBY
;
143 case REGULATOR_MODE_IDLE
:
144 val
= WM831X_DCDC_MODE_IDLE
;
150 return wm831x_set_bits(wm831x
, reg
, WM831X_DC1_ON_MODE_MASK
,
151 val
<< WM831X_DC1_ON_MODE_SHIFT
);
154 static int wm831x_dcdc_set_mode(struct regulator_dev
*rdev
, unsigned int mode
)
156 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
157 struct wm831x
*wm831x
= dcdc
->wm831x
;
158 u16 reg
= dcdc
->base
+ WM831X_DCDC_ON_CONFIG
;
160 return wm831x_dcdc_set_mode_int(wm831x
, reg
, mode
);
163 static int wm831x_dcdc_set_suspend_mode(struct regulator_dev
*rdev
,
166 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
167 struct wm831x
*wm831x
= dcdc
->wm831x
;
168 u16 reg
= dcdc
->base
+ WM831X_DCDC_SLEEP_CONTROL
;
170 return wm831x_dcdc_set_mode_int(wm831x
, reg
, mode
);
173 static int wm831x_dcdc_get_status(struct regulator_dev
*rdev
)
175 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
176 struct wm831x
*wm831x
= dcdc
->wm831x
;
179 /* First, check for errors */
180 ret
= wm831x_reg_read(wm831x
, WM831X_DCDC_UV_STATUS
);
184 if (ret
& (1 << rdev_get_id(rdev
))) {
185 dev_dbg(wm831x
->dev
, "DCDC%d under voltage\n",
186 rdev_get_id(rdev
) + 1);
187 return REGULATOR_STATUS_ERROR
;
190 /* DCDC1 and DCDC2 can additionally detect high voltage/current */
191 if (rdev_get_id(rdev
) < 2) {
192 if (ret
& (WM831X_DC1_OV_STS
<< rdev_get_id(rdev
))) {
193 dev_dbg(wm831x
->dev
, "DCDC%d over voltage\n",
194 rdev_get_id(rdev
) + 1);
195 return REGULATOR_STATUS_ERROR
;
198 if (ret
& (WM831X_DC1_HC_STS
<< rdev_get_id(rdev
))) {
199 dev_dbg(wm831x
->dev
, "DCDC%d over current\n",
200 rdev_get_id(rdev
) + 1);
201 return REGULATOR_STATUS_ERROR
;
205 /* Is the regulator on? */
206 ret
= wm831x_reg_read(wm831x
, WM831X_DCDC_STATUS
);
209 if (!(ret
& (1 << rdev_get_id(rdev
))))
210 return REGULATOR_STATUS_OFF
;
212 /* TODO: When we handle hardware control modes so we can report the
214 return REGULATOR_STATUS_ON
;
217 static irqreturn_t
wm831x_dcdc_uv_irq(int irq
, void *data
)
219 struct wm831x_dcdc
*dcdc
= data
;
221 regulator_notifier_call_chain(dcdc
->regulator
,
222 REGULATOR_EVENT_UNDER_VOLTAGE
,
228 static irqreturn_t
wm831x_dcdc_oc_irq(int irq
, void *data
)
230 struct wm831x_dcdc
*dcdc
= data
;
232 regulator_notifier_call_chain(dcdc
->regulator
,
233 REGULATOR_EVENT_OVER_CURRENT
,
243 static int wm831x_buckv_list_voltage(struct regulator_dev
*rdev
,
248 if (selector
<= WM831X_BUCKV_MAX_SELECTOR
)
249 return 600000 + ((selector
- 0x8) * 12500);
253 static int wm831x_buckv_select_min_voltage(struct regulator_dev
*rdev
,
254 int min_uV
, int max_uV
)
260 else if (min_uV
<= 1800000)
261 vsel
= ((min_uV
- 600000) / 12500) + 8;
265 if (wm831x_buckv_list_voltage(rdev
, vsel
) > max_uV
)
271 static int wm831x_buckv_set_dvs(struct regulator_dev
*rdev
, int state
)
273 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
275 if (state
== dcdc
->dvs_gpio_state
)
278 dcdc
->dvs_gpio_state
= state
;
279 gpio_set_value(dcdc
->dvs_gpio
, state
);
281 /* Should wait for DVS state change to be asserted if we have
282 * a GPIO for it, for now assume the device is configured
283 * for the fastest possible transition.
289 static int wm831x_buckv_set_voltage(struct regulator_dev
*rdev
,
290 int min_uV
, int max_uV
, unsigned *selector
)
292 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
293 struct wm831x
*wm831x
= dcdc
->wm831x
;
294 int on_reg
= dcdc
->base
+ WM831X_DCDC_ON_CONFIG
;
295 int dvs_reg
= dcdc
->base
+ WM831X_DCDC_DVS_CONTROL
;
298 vsel
= wm831x_buckv_select_min_voltage(rdev
, min_uV
, max_uV
);
304 /* If this value is already set then do a GPIO update if we can */
305 if (dcdc
->dvs_gpio
&& dcdc
->on_vsel
== vsel
)
306 return wm831x_buckv_set_dvs(rdev
, 0);
308 if (dcdc
->dvs_gpio
&& dcdc
->dvs_vsel
== vsel
)
309 return wm831x_buckv_set_dvs(rdev
, 1);
311 /* Always set the ON status to the minimum voltage */
312 ret
= wm831x_set_bits(wm831x
, on_reg
, WM831X_DC1_ON_VSEL_MASK
, vsel
);
315 dcdc
->on_vsel
= vsel
;
320 /* Kick the voltage transition now */
321 ret
= wm831x_buckv_set_dvs(rdev
, 0);
326 * If this VSEL is higher than the last one we've seen then
327 * remember it as the DVS VSEL. This is optimised for CPUfreq
328 * usage where we want to get to the highest voltage very
331 if (vsel
> dcdc
->dvs_vsel
) {
332 ret
= wm831x_set_bits(wm831x
, dvs_reg
,
333 WM831X_DC1_DVS_VSEL_MASK
,
336 dcdc
->dvs_vsel
= vsel
;
338 dev_warn(wm831x
->dev
,
339 "Failed to set DCDC DVS VSEL: %d\n", ret
);
345 static int wm831x_buckv_set_suspend_voltage(struct regulator_dev
*rdev
,
348 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
349 struct wm831x
*wm831x
= dcdc
->wm831x
;
350 u16 reg
= dcdc
->base
+ WM831X_DCDC_SLEEP_CONTROL
;
353 vsel
= wm831x_buckv_select_min_voltage(rdev
, uV
, uV
);
357 return wm831x_set_bits(wm831x
, reg
, WM831X_DC1_SLP_VSEL_MASK
, vsel
);
360 static int wm831x_buckv_get_voltage_sel(struct regulator_dev
*rdev
)
362 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
364 if (dcdc
->dvs_gpio
&& dcdc
->dvs_gpio_state
)
365 return dcdc
->dvs_vsel
;
367 return dcdc
->on_vsel
;
370 /* Current limit options */
371 static u16 wm831x_dcdc_ilim
[] = {
372 125, 250, 375, 500, 625, 750, 875, 1000
375 static int wm831x_buckv_set_current_limit(struct regulator_dev
*rdev
,
376 int min_uA
, int max_uA
)
378 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
379 struct wm831x
*wm831x
= dcdc
->wm831x
;
380 u16 reg
= dcdc
->base
+ WM831X_DCDC_CONTROL_2
;
383 for (i
= 0; i
< ARRAY_SIZE(wm831x_dcdc_ilim
); i
++) {
384 if ((min_uA
<= wm831x_dcdc_ilim
[i
]) &&
385 (wm831x_dcdc_ilim
[i
] <= max_uA
))
388 if (i
== ARRAY_SIZE(wm831x_dcdc_ilim
))
391 return wm831x_set_bits(wm831x
, reg
, WM831X_DC1_HC_THR_MASK
,
392 i
<< WM831X_DC1_HC_THR_SHIFT
);
395 static int wm831x_buckv_get_current_limit(struct regulator_dev
*rdev
)
397 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
398 struct wm831x
*wm831x
= dcdc
->wm831x
;
399 u16 reg
= dcdc
->base
+ WM831X_DCDC_CONTROL_2
;
402 val
= wm831x_reg_read(wm831x
, reg
);
406 val
= (val
& WM831X_DC1_HC_THR_MASK
) >> WM831X_DC1_HC_THR_SHIFT
;
407 return wm831x_dcdc_ilim
[val
];
410 static struct regulator_ops wm831x_buckv_ops
= {
411 .set_voltage
= wm831x_buckv_set_voltage
,
412 .get_voltage_sel
= wm831x_buckv_get_voltage_sel
,
413 .list_voltage
= wm831x_buckv_list_voltage
,
414 .set_suspend_voltage
= wm831x_buckv_set_suspend_voltage
,
415 .set_current_limit
= wm831x_buckv_set_current_limit
,
416 .get_current_limit
= wm831x_buckv_get_current_limit
,
418 .is_enabled
= wm831x_dcdc_is_enabled
,
419 .enable
= wm831x_dcdc_enable
,
420 .disable
= wm831x_dcdc_disable
,
421 .get_status
= wm831x_dcdc_get_status
,
422 .get_mode
= wm831x_dcdc_get_mode
,
423 .set_mode
= wm831x_dcdc_set_mode
,
424 .set_suspend_mode
= wm831x_dcdc_set_suspend_mode
,
428 * Set up DVS control. We just log errors since we can still run
429 * (with reduced performance) if we fail.
431 static __devinit
void wm831x_buckv_dvs_init(struct wm831x_dcdc
*dcdc
,
432 struct wm831x_buckv_pdata
*pdata
)
434 struct wm831x
*wm831x
= dcdc
->wm831x
;
438 if (!pdata
|| !pdata
->dvs_gpio
)
441 ret
= gpio_request(pdata
->dvs_gpio
, "DCDC DVS");
443 dev_err(wm831x
->dev
, "Failed to get %s DVS GPIO: %d\n",
448 /* gpiolib won't let us read the GPIO status so pick the higher
449 * of the two existing voltages so we take it as platform data.
451 dcdc
->dvs_gpio_state
= pdata
->dvs_init_state
;
453 ret
= gpio_direction_output(pdata
->dvs_gpio
, dcdc
->dvs_gpio_state
);
455 dev_err(wm831x
->dev
, "Failed to enable %s DVS GPIO: %d\n",
457 gpio_free(pdata
->dvs_gpio
);
461 dcdc
->dvs_gpio
= pdata
->dvs_gpio
;
463 switch (pdata
->dvs_control_src
) {
465 ctrl
= 2 << WM831X_DC1_DVS_SRC_SHIFT
;
468 ctrl
= 3 << WM831X_DC1_DVS_SRC_SHIFT
;
471 dev_err(wm831x
->dev
, "Invalid DVS control source %d for %s\n",
472 pdata
->dvs_control_src
, dcdc
->name
);
476 /* If DVS_VSEL is set to the minimum value then raise it to ON_VSEL
477 * to make bootstrapping a bit smoother.
479 if (!dcdc
->dvs_vsel
) {
480 ret
= wm831x_set_bits(wm831x
,
481 dcdc
->base
+ WM831X_DCDC_DVS_CONTROL
,
482 WM831X_DC1_DVS_VSEL_MASK
, dcdc
->on_vsel
);
484 dcdc
->dvs_vsel
= dcdc
->on_vsel
;
486 dev_warn(wm831x
->dev
, "Failed to set DVS_VSEL: %d\n",
490 ret
= wm831x_set_bits(wm831x
, dcdc
->base
+ WM831X_DCDC_DVS_CONTROL
,
491 WM831X_DC1_DVS_SRC_MASK
, ctrl
);
493 dev_err(wm831x
->dev
, "Failed to set %s DVS source: %d\n",
498 static __devinit
int wm831x_buckv_probe(struct platform_device
*pdev
)
500 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
501 struct wm831x_pdata
*pdata
= wm831x
->dev
->platform_data
;
502 struct regulator_config config
= { };
504 struct wm831x_dcdc
*dcdc
;
505 struct resource
*res
;
508 if (pdata
&& pdata
->wm831x_num
)
509 id
= (pdata
->wm831x_num
* 10) + 1;
514 dev_dbg(&pdev
->dev
, "Probing DCDC%d\n", id
+ 1);
516 if (pdata
== NULL
|| pdata
->dcdc
[id
] == NULL
)
519 dcdc
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_dcdc
),
522 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
526 dcdc
->wm831x
= wm831x
;
528 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
530 dev_err(&pdev
->dev
, "No I/O resource\n");
534 dcdc
->base
= res
->start
;
536 snprintf(dcdc
->name
, sizeof(dcdc
->name
), "DCDC%d", id
+ 1);
537 dcdc
->desc
.name
= dcdc
->name
;
539 snprintf(dcdc
->supply_name
, sizeof(dcdc
->supply_name
),
541 dcdc
->desc
.supply_name
= dcdc
->supply_name
;
544 dcdc
->desc
.type
= REGULATOR_VOLTAGE
;
545 dcdc
->desc
.n_voltages
= WM831X_BUCKV_MAX_SELECTOR
+ 1;
546 dcdc
->desc
.ops
= &wm831x_buckv_ops
;
547 dcdc
->desc
.owner
= THIS_MODULE
;
549 ret
= wm831x_reg_read(wm831x
, dcdc
->base
+ WM831X_DCDC_ON_CONFIG
);
551 dev_err(wm831x
->dev
, "Failed to read ON VSEL: %d\n", ret
);
554 dcdc
->on_vsel
= ret
& WM831X_DC1_ON_VSEL_MASK
;
556 ret
= wm831x_reg_read(wm831x
, dcdc
->base
+ WM831X_DCDC_DVS_CONTROL
);
558 dev_err(wm831x
->dev
, "Failed to read DVS VSEL: %d\n", ret
);
561 dcdc
->dvs_vsel
= ret
& WM831X_DC1_DVS_VSEL_MASK
;
564 wm831x_buckv_dvs_init(dcdc
, pdata
->dcdc
[id
]->driver_data
);
566 config
.dev
= pdev
->dev
.parent
;
567 config
.init_data
= pdata
->dcdc
[id
];
568 config
.driver_data
= dcdc
;
570 dcdc
->regulator
= regulator_register(&dcdc
->desc
, &config
);
571 if (IS_ERR(dcdc
->regulator
)) {
572 ret
= PTR_ERR(dcdc
->regulator
);
573 dev_err(wm831x
->dev
, "Failed to register DCDC%d: %d\n",
578 irq
= platform_get_irq_byname(pdev
, "UV");
579 ret
= request_threaded_irq(irq
, NULL
, wm831x_dcdc_uv_irq
,
580 IRQF_TRIGGER_RISING
, dcdc
->name
, dcdc
);
582 dev_err(&pdev
->dev
, "Failed to request UV IRQ %d: %d\n",
587 irq
= platform_get_irq_byname(pdev
, "HC");
588 ret
= request_threaded_irq(irq
, NULL
, wm831x_dcdc_oc_irq
,
589 IRQF_TRIGGER_RISING
, dcdc
->name
, dcdc
);
591 dev_err(&pdev
->dev
, "Failed to request HC IRQ %d: %d\n",
596 platform_set_drvdata(pdev
, dcdc
);
601 free_irq(platform_get_irq_byname(pdev
, "UV"), dcdc
);
603 regulator_unregister(dcdc
->regulator
);
606 gpio_free(dcdc
->dvs_gpio
);
610 static __devexit
int wm831x_buckv_remove(struct platform_device
*pdev
)
612 struct wm831x_dcdc
*dcdc
= platform_get_drvdata(pdev
);
614 platform_set_drvdata(pdev
, NULL
);
616 free_irq(platform_get_irq_byname(pdev
, "HC"), dcdc
);
617 free_irq(platform_get_irq_byname(pdev
, "UV"), dcdc
);
618 regulator_unregister(dcdc
->regulator
);
620 gpio_free(dcdc
->dvs_gpio
);
625 static struct platform_driver wm831x_buckv_driver
= {
626 .probe
= wm831x_buckv_probe
,
627 .remove
= __devexit_p(wm831x_buckv_remove
),
629 .name
= "wm831x-buckv",
630 .owner
= THIS_MODULE
,
638 static int wm831x_buckp_list_voltage(struct regulator_dev
*rdev
,
641 if (selector
<= WM831X_BUCKP_MAX_SELECTOR
)
642 return 850000 + (selector
* 25000);
647 static int wm831x_buckp_set_voltage_int(struct regulator_dev
*rdev
, int reg
,
648 int min_uV
, int max_uV
, int *selector
)
650 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
651 struct wm831x
*wm831x
= dcdc
->wm831x
;
654 if (min_uV
<= 34000000)
655 vsel
= (min_uV
- 850000) / 25000;
659 if (wm831x_buckp_list_voltage(rdev
, vsel
) > max_uV
)
664 return wm831x_set_bits(wm831x
, reg
, WM831X_DC3_ON_VSEL_MASK
, vsel
);
667 static int wm831x_buckp_set_voltage(struct regulator_dev
*rdev
,
668 int min_uV
, int max_uV
,
671 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
672 u16 reg
= dcdc
->base
+ WM831X_DCDC_ON_CONFIG
;
674 return wm831x_buckp_set_voltage_int(rdev
, reg
, min_uV
, max_uV
,
678 static int wm831x_buckp_set_suspend_voltage(struct regulator_dev
*rdev
,
681 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
682 u16 reg
= dcdc
->base
+ WM831X_DCDC_SLEEP_CONTROL
;
685 return wm831x_buckp_set_voltage_int(rdev
, reg
, uV
, uV
, &selector
);
688 static int wm831x_buckp_get_voltage_sel(struct regulator_dev
*rdev
)
690 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
691 struct wm831x
*wm831x
= dcdc
->wm831x
;
692 u16 reg
= dcdc
->base
+ WM831X_DCDC_ON_CONFIG
;
695 val
= wm831x_reg_read(wm831x
, reg
);
699 return val
& WM831X_DC3_ON_VSEL_MASK
;
702 static struct regulator_ops wm831x_buckp_ops
= {
703 .set_voltage
= wm831x_buckp_set_voltage
,
704 .get_voltage_sel
= wm831x_buckp_get_voltage_sel
,
705 .list_voltage
= wm831x_buckp_list_voltage
,
706 .set_suspend_voltage
= wm831x_buckp_set_suspend_voltage
,
708 .is_enabled
= wm831x_dcdc_is_enabled
,
709 .enable
= wm831x_dcdc_enable
,
710 .disable
= wm831x_dcdc_disable
,
711 .get_status
= wm831x_dcdc_get_status
,
712 .get_mode
= wm831x_dcdc_get_mode
,
713 .set_mode
= wm831x_dcdc_set_mode
,
714 .set_suspend_mode
= wm831x_dcdc_set_suspend_mode
,
717 static __devinit
int wm831x_buckp_probe(struct platform_device
*pdev
)
719 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
720 struct wm831x_pdata
*pdata
= wm831x
->dev
->platform_data
;
721 struct regulator_config config
= { };
723 struct wm831x_dcdc
*dcdc
;
724 struct resource
*res
;
727 if (pdata
&& pdata
->wm831x_num
)
728 id
= (pdata
->wm831x_num
* 10) + 1;
733 dev_dbg(&pdev
->dev
, "Probing DCDC%d\n", id
+ 1);
735 if (pdata
== NULL
|| pdata
->dcdc
[id
] == NULL
)
738 dcdc
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_dcdc
),
741 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
745 dcdc
->wm831x
= wm831x
;
747 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
749 dev_err(&pdev
->dev
, "No I/O resource\n");
753 dcdc
->base
= res
->start
;
755 snprintf(dcdc
->name
, sizeof(dcdc
->name
), "DCDC%d", id
+ 1);
756 dcdc
->desc
.name
= dcdc
->name
;
758 snprintf(dcdc
->supply_name
, sizeof(dcdc
->supply_name
),
760 dcdc
->desc
.supply_name
= dcdc
->supply_name
;
763 dcdc
->desc
.type
= REGULATOR_VOLTAGE
;
764 dcdc
->desc
.n_voltages
= WM831X_BUCKP_MAX_SELECTOR
+ 1;
765 dcdc
->desc
.ops
= &wm831x_buckp_ops
;
766 dcdc
->desc
.owner
= THIS_MODULE
;
768 config
.dev
= pdev
->dev
.parent
;
769 config
.init_data
= pdata
->dcdc
[id
];
770 config
.driver_data
= dcdc
;
772 dcdc
->regulator
= regulator_register(&dcdc
->desc
, &config
);
773 if (IS_ERR(dcdc
->regulator
)) {
774 ret
= PTR_ERR(dcdc
->regulator
);
775 dev_err(wm831x
->dev
, "Failed to register DCDC%d: %d\n",
780 irq
= platform_get_irq_byname(pdev
, "UV");
781 ret
= request_threaded_irq(irq
, NULL
, wm831x_dcdc_uv_irq
,
782 IRQF_TRIGGER_RISING
, dcdc
->name
, dcdc
);
784 dev_err(&pdev
->dev
, "Failed to request UV IRQ %d: %d\n",
789 platform_set_drvdata(pdev
, dcdc
);
794 regulator_unregister(dcdc
->regulator
);
799 static __devexit
int wm831x_buckp_remove(struct platform_device
*pdev
)
801 struct wm831x_dcdc
*dcdc
= platform_get_drvdata(pdev
);
803 platform_set_drvdata(pdev
, NULL
);
805 free_irq(platform_get_irq_byname(pdev
, "UV"), dcdc
);
806 regulator_unregister(dcdc
->regulator
);
811 static struct platform_driver wm831x_buckp_driver
= {
812 .probe
= wm831x_buckp_probe
,
813 .remove
= __devexit_p(wm831x_buckp_remove
),
815 .name
= "wm831x-buckp",
816 .owner
= THIS_MODULE
,
821 * DCDC boost convertors
824 static int wm831x_boostp_get_status(struct regulator_dev
*rdev
)
826 struct wm831x_dcdc
*dcdc
= rdev_get_drvdata(rdev
);
827 struct wm831x
*wm831x
= dcdc
->wm831x
;
830 /* First, check for errors */
831 ret
= wm831x_reg_read(wm831x
, WM831X_DCDC_UV_STATUS
);
835 if (ret
& (1 << rdev_get_id(rdev
))) {
836 dev_dbg(wm831x
->dev
, "DCDC%d under voltage\n",
837 rdev_get_id(rdev
) + 1);
838 return REGULATOR_STATUS_ERROR
;
841 /* Is the regulator on? */
842 ret
= wm831x_reg_read(wm831x
, WM831X_DCDC_STATUS
);
845 if (ret
& (1 << rdev_get_id(rdev
)))
846 return REGULATOR_STATUS_ON
;
848 return REGULATOR_STATUS_OFF
;
851 static struct regulator_ops wm831x_boostp_ops
= {
852 .get_status
= wm831x_boostp_get_status
,
854 .is_enabled
= wm831x_dcdc_is_enabled
,
855 .enable
= wm831x_dcdc_enable
,
856 .disable
= wm831x_dcdc_disable
,
859 static __devinit
int wm831x_boostp_probe(struct platform_device
*pdev
)
861 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
862 struct wm831x_pdata
*pdata
= wm831x
->dev
->platform_data
;
863 struct regulator_config config
= { };
864 int id
= pdev
->id
% ARRAY_SIZE(pdata
->dcdc
);
865 struct wm831x_dcdc
*dcdc
;
866 struct resource
*res
;
869 dev_dbg(&pdev
->dev
, "Probing DCDC%d\n", id
+ 1);
871 if (pdata
== NULL
|| pdata
->dcdc
[id
] == NULL
)
874 dcdc
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_dcdc
), GFP_KERNEL
);
876 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
880 dcdc
->wm831x
= wm831x
;
882 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
884 dev_err(&pdev
->dev
, "No I/O resource\n");
888 dcdc
->base
= res
->start
;
890 snprintf(dcdc
->name
, sizeof(dcdc
->name
), "DCDC%d", id
+ 1);
891 dcdc
->desc
.name
= dcdc
->name
;
893 dcdc
->desc
.type
= REGULATOR_VOLTAGE
;
894 dcdc
->desc
.ops
= &wm831x_boostp_ops
;
895 dcdc
->desc
.owner
= THIS_MODULE
;
897 config
.dev
= pdev
->dev
.parent
;
898 config
.init_data
= pdata
->dcdc
[id
];
899 config
.driver_data
= dcdc
;
901 dcdc
->regulator
= regulator_register(&dcdc
->desc
, &config
);
902 if (IS_ERR(dcdc
->regulator
)) {
903 ret
= PTR_ERR(dcdc
->regulator
);
904 dev_err(wm831x
->dev
, "Failed to register DCDC%d: %d\n",
909 irq
= platform_get_irq_byname(pdev
, "UV");
910 ret
= request_threaded_irq(irq
, NULL
, wm831x_dcdc_uv_irq
,
911 IRQF_TRIGGER_RISING
, dcdc
->name
,
914 dev_err(&pdev
->dev
, "Failed to request UV IRQ %d: %d\n",
919 platform_set_drvdata(pdev
, dcdc
);
924 regulator_unregister(dcdc
->regulator
);
929 static __devexit
int wm831x_boostp_remove(struct platform_device
*pdev
)
931 struct wm831x_dcdc
*dcdc
= platform_get_drvdata(pdev
);
933 platform_set_drvdata(pdev
, NULL
);
935 free_irq(platform_get_irq_byname(pdev
, "UV"), dcdc
);
936 regulator_unregister(dcdc
->regulator
);
941 static struct platform_driver wm831x_boostp_driver
= {
942 .probe
= wm831x_boostp_probe
,
943 .remove
= __devexit_p(wm831x_boostp_remove
),
945 .name
= "wm831x-boostp",
946 .owner
= THIS_MODULE
,
951 * External Power Enable
953 * These aren't actually DCDCs but look like them in hardware so share
957 #define WM831X_EPE_BASE 6
959 static struct regulator_ops wm831x_epe_ops
= {
960 .is_enabled
= wm831x_dcdc_is_enabled
,
961 .enable
= wm831x_dcdc_enable
,
962 .disable
= wm831x_dcdc_disable
,
963 .get_status
= wm831x_dcdc_get_status
,
966 static __devinit
int wm831x_epe_probe(struct platform_device
*pdev
)
968 struct wm831x
*wm831x
= dev_get_drvdata(pdev
->dev
.parent
);
969 struct wm831x_pdata
*pdata
= wm831x
->dev
->platform_data
;
970 struct regulator_config config
= { };
971 int id
= pdev
->id
% ARRAY_SIZE(pdata
->epe
);
972 struct wm831x_dcdc
*dcdc
;
975 dev_dbg(&pdev
->dev
, "Probing EPE%d\n", id
+ 1);
977 if (pdata
== NULL
|| pdata
->epe
[id
] == NULL
)
980 dcdc
= devm_kzalloc(&pdev
->dev
, sizeof(struct wm831x_dcdc
), GFP_KERNEL
);
982 dev_err(&pdev
->dev
, "Unable to allocate private data\n");
986 dcdc
->wm831x
= wm831x
;
988 /* For current parts this is correct; probably need to revisit
991 snprintf(dcdc
->name
, sizeof(dcdc
->name
), "EPE%d", id
+ 1);
992 dcdc
->desc
.name
= dcdc
->name
;
993 dcdc
->desc
.id
= id
+ WM831X_EPE_BASE
; /* Offset in DCDC registers */
994 dcdc
->desc
.ops
= &wm831x_epe_ops
;
995 dcdc
->desc
.type
= REGULATOR_VOLTAGE
;
996 dcdc
->desc
.owner
= THIS_MODULE
;
998 config
.dev
= pdev
->dev
.parent
;
999 config
.init_data
= pdata
->epe
[id
];
1000 config
.driver_data
= dcdc
;
1002 dcdc
->regulator
= regulator_register(&dcdc
->desc
, &config
);
1003 if (IS_ERR(dcdc
->regulator
)) {
1004 ret
= PTR_ERR(dcdc
->regulator
);
1005 dev_err(wm831x
->dev
, "Failed to register EPE%d: %d\n",
1010 platform_set_drvdata(pdev
, dcdc
);
1018 static __devexit
int wm831x_epe_remove(struct platform_device
*pdev
)
1020 struct wm831x_dcdc
*dcdc
= platform_get_drvdata(pdev
);
1022 platform_set_drvdata(pdev
, NULL
);
1023 regulator_unregister(dcdc
->regulator
);
1028 static struct platform_driver wm831x_epe_driver
= {
1029 .probe
= wm831x_epe_probe
,
1030 .remove
= __devexit_p(wm831x_epe_remove
),
1032 .name
= "wm831x-epe",
1033 .owner
= THIS_MODULE
,
1037 static int __init
wm831x_dcdc_init(void)
1040 ret
= platform_driver_register(&wm831x_buckv_driver
);
1042 pr_err("Failed to register WM831x BUCKV driver: %d\n", ret
);
1044 ret
= platform_driver_register(&wm831x_buckp_driver
);
1046 pr_err("Failed to register WM831x BUCKP driver: %d\n", ret
);
1048 ret
= platform_driver_register(&wm831x_boostp_driver
);
1050 pr_err("Failed to register WM831x BOOST driver: %d\n", ret
);
1052 ret
= platform_driver_register(&wm831x_epe_driver
);
1054 pr_err("Failed to register WM831x EPE driver: %d\n", ret
);
1058 subsys_initcall(wm831x_dcdc_init
);
1060 static void __exit
wm831x_dcdc_exit(void)
1062 platform_driver_unregister(&wm831x_epe_driver
);
1063 platform_driver_unregister(&wm831x_boostp_driver
);
1064 platform_driver_unregister(&wm831x_buckp_driver
);
1065 platform_driver_unregister(&wm831x_buckv_driver
);
1067 module_exit(wm831x_dcdc_exit
);
1069 /* Module information */
1070 MODULE_AUTHOR("Mark Brown");
1071 MODULE_DESCRIPTION("WM831x DC-DC convertor driver");
1072 MODULE_LICENSE("GPL");
1073 MODULE_ALIAS("platform:wm831x-buckv");
1074 MODULE_ALIAS("platform:wm831x-buckp");
1075 MODULE_ALIAS("platform:wm831x-epe");