Merge tag 'dmaengine-fix-5.2' of git://git.infradead.org/users/vkoul/slave-dma
[linux-2.6-microblaze.git] / drivers / regulator / wm831x-ldo.c
1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // wm831x-ldo.c  --  LDO driver for the WM831x series
4 //
5 // Copyright 2009 Wolfson Microelectronics PLC.
6 //
7 // Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8
9 #include <linux/module.h>
10 #include <linux/moduleparam.h>
11 #include <linux/init.h>
12 #include <linux/bitops.h>
13 #include <linux/err.h>
14 #include <linux/i2c.h>
15 #include <linux/platform_device.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/slab.h>
18
19 #include <linux/mfd/wm831x/core.h>
20 #include <linux/mfd/wm831x/regulator.h>
21 #include <linux/mfd/wm831x/pdata.h>
22
23 #define WM831X_LDO_MAX_NAME 9
24
25 #define WM831X_LDO_CONTROL       0
26 #define WM831X_LDO_ON_CONTROL    1
27 #define WM831X_LDO_SLEEP_CONTROL 2
28
29 #define WM831X_ALIVE_LDO_ON_CONTROL    0
30 #define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
31
32 struct wm831x_ldo {
33         char name[WM831X_LDO_MAX_NAME];
34         char supply_name[WM831X_LDO_MAX_NAME];
35         struct regulator_desc desc;
36         int base;
37         struct wm831x *wm831x;
38         struct regulator_dev *regulator;
39 };
40
41 /*
42  * Shared
43  */
44
45 static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data)
46 {
47         struct wm831x_ldo *ldo = data;
48
49         regulator_lock(ldo->regulator);
50         regulator_notifier_call_chain(ldo->regulator,
51                                       REGULATOR_EVENT_UNDER_VOLTAGE,
52                                       NULL);
53         regulator_unlock(ldo->regulator);
54
55         return IRQ_HANDLED;
56 }
57
58 /*
59  * General purpose LDOs
60  */
61
62 static const struct regulator_linear_range wm831x_gp_ldo_ranges[] = {
63         REGULATOR_LINEAR_RANGE(900000, 0, 14, 50000),
64         REGULATOR_LINEAR_RANGE(1700000, 15, 31, 100000),
65 };
66
67 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
68                                              int uV)
69 {
70         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
71         struct wm831x *wm831x = ldo->wm831x;
72         int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
73
74         sel = regulator_map_voltage_linear_range(rdev, uV, uV);
75         if (sel < 0)
76                 return sel;
77
78         return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
79 }
80
81 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
82 {
83         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
84         struct wm831x *wm831x = ldo->wm831x;
85         int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
86         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
87         int ret;
88
89         ret = wm831x_reg_read(wm831x, on_reg);
90         if (ret < 0)
91                 return ret;
92
93         if (!(ret & WM831X_LDO1_ON_MODE))
94                 return REGULATOR_MODE_NORMAL;
95
96         ret = wm831x_reg_read(wm831x, ctrl_reg);
97         if (ret < 0)
98                 return ret;
99
100         if (ret & WM831X_LDO1_LP_MODE)
101                 return REGULATOR_MODE_STANDBY;
102         else
103                 return REGULATOR_MODE_IDLE;
104 }
105
106 static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
107                                   unsigned int mode)
108 {
109         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
110         struct wm831x *wm831x = ldo->wm831x;
111         int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
112         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
113         int ret;
114
115
116         switch (mode) {
117         case REGULATOR_MODE_NORMAL:
118                 ret = wm831x_set_bits(wm831x, on_reg,
119                                       WM831X_LDO1_ON_MODE, 0);
120                 if (ret < 0)
121                         return ret;
122                 break;
123
124         case REGULATOR_MODE_IDLE:
125                 ret = wm831x_set_bits(wm831x, ctrl_reg,
126                                       WM831X_LDO1_LP_MODE, 0);
127                 if (ret < 0)
128                         return ret;
129
130                 ret = wm831x_set_bits(wm831x, on_reg,
131                                       WM831X_LDO1_ON_MODE,
132                                       WM831X_LDO1_ON_MODE);
133                 if (ret < 0)
134                         return ret;
135                 break;
136
137         case REGULATOR_MODE_STANDBY:
138                 ret = wm831x_set_bits(wm831x, ctrl_reg,
139                                       WM831X_LDO1_LP_MODE,
140                                       WM831X_LDO1_LP_MODE);
141                 if (ret < 0)
142                         return ret;
143
144                 ret = wm831x_set_bits(wm831x, on_reg,
145                                       WM831X_LDO1_ON_MODE,
146                                       WM831X_LDO1_ON_MODE);
147                 if (ret < 0)
148                         return ret;
149                 break;
150
151         default:
152                 return -EINVAL;
153         }
154
155         return 0;
156 }
157
158 static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
159 {
160         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
161         struct wm831x *wm831x = ldo->wm831x;
162         int mask = 1 << rdev_get_id(rdev);
163         int ret;
164
165         /* Is the regulator on? */
166         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
167         if (ret < 0)
168                 return ret;
169         if (!(ret & mask))
170                 return REGULATOR_STATUS_OFF;
171
172         /* Is it reporting under voltage? */
173         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
174         if (ret < 0)
175                 return ret;
176         if (ret & mask)
177                 return REGULATOR_STATUS_ERROR;
178
179         ret = wm831x_gp_ldo_get_mode(rdev);
180         if (ret < 0)
181                 return ret;
182         else
183                 return regulator_mode_to_status(ret);
184 }
185
186 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
187                                                    int input_uV,
188                                                    int output_uV, int load_uA)
189 {
190         if (load_uA < 20000)
191                 return REGULATOR_MODE_STANDBY;
192         if (load_uA < 50000)
193                 return REGULATOR_MODE_IDLE;
194         return REGULATOR_MODE_NORMAL;
195 }
196
197
198 static const struct regulator_ops wm831x_gp_ldo_ops = {
199         .list_voltage = regulator_list_voltage_linear_range,
200         .map_voltage = regulator_map_voltage_linear_range,
201         .get_voltage_sel = regulator_get_voltage_sel_regmap,
202         .set_voltage_sel = regulator_set_voltage_sel_regmap,
203         .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
204         .get_mode = wm831x_gp_ldo_get_mode,
205         .set_mode = wm831x_gp_ldo_set_mode,
206         .get_status = wm831x_gp_ldo_get_status,
207         .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
208         .get_bypass = regulator_get_bypass_regmap,
209         .set_bypass = regulator_set_bypass_regmap,
210
211         .is_enabled = regulator_is_enabled_regmap,
212         .enable = regulator_enable_regmap,
213         .disable = regulator_disable_regmap,
214 };
215
216 static int wm831x_gp_ldo_probe(struct platform_device *pdev)
217 {
218         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
219         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
220         struct regulator_config config = { };
221         int id;
222         struct wm831x_ldo *ldo;
223         struct resource *res;
224         int ret, irq;
225
226         if (pdata && pdata->wm831x_num)
227                 id = (pdata->wm831x_num * 10) + 1;
228         else
229                 id = 0;
230         id = pdev->id - id;
231
232         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
233
234         ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
235         if (!ldo)
236                 return -ENOMEM;
237
238         ldo->wm831x = wm831x;
239
240         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
241         if (res == NULL) {
242                 dev_err(&pdev->dev, "No REG resource\n");
243                 ret = -EINVAL;
244                 goto err;
245         }
246         ldo->base = res->start;
247
248         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
249         ldo->desc.name = ldo->name;
250
251         snprintf(ldo->supply_name, sizeof(ldo->supply_name),
252                  "LDO%dVDD", id + 1);
253         ldo->desc.supply_name = ldo->supply_name;
254
255         ldo->desc.id = id;
256         ldo->desc.type = REGULATOR_VOLTAGE;
257         ldo->desc.n_voltages = 32;
258         ldo->desc.ops = &wm831x_gp_ldo_ops;
259         ldo->desc.owner = THIS_MODULE;
260         ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
261         ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK;
262         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
263         ldo->desc.enable_mask = 1 << id;
264         ldo->desc.bypass_reg = ldo->base;
265         ldo->desc.bypass_mask = WM831X_LDO1_SWI;
266         ldo->desc.linear_ranges = wm831x_gp_ldo_ranges;
267         ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_gp_ldo_ranges);
268
269         config.dev = pdev->dev.parent;
270         if (pdata)
271                 config.init_data = pdata->ldo[id];
272         config.driver_data = ldo;
273         config.regmap = wm831x->regmap;
274
275         ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
276                                                  &config);
277         if (IS_ERR(ldo->regulator)) {
278                 ret = PTR_ERR(ldo->regulator);
279                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
280                         id + 1, ret);
281                 goto err;
282         }
283
284         irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
285         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
286                                         wm831x_ldo_uv_irq,
287                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
288                                         ldo->name,
289                                         ldo);
290         if (ret != 0) {
291                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
292                         irq, ret);
293                 goto err;
294         }
295
296         platform_set_drvdata(pdev, ldo);
297
298         return 0;
299
300 err:
301         return ret;
302 }
303
304 static struct platform_driver wm831x_gp_ldo_driver = {
305         .probe = wm831x_gp_ldo_probe,
306         .driver         = {
307                 .name   = "wm831x-ldo",
308         },
309 };
310
311 /*
312  * Analogue LDOs
313  */
314
315 static const struct regulator_linear_range wm831x_aldo_ranges[] = {
316         REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000),
317         REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000),
318 };
319
320 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
321                                              int uV)
322 {
323         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
324         struct wm831x *wm831x = ldo->wm831x;
325         int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
326
327         sel = regulator_map_voltage_linear_range(rdev, uV, uV);
328         if (sel < 0)
329                 return sel;
330
331         return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
332 }
333
334 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
335 {
336         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
337         struct wm831x *wm831x = ldo->wm831x;
338         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
339         int ret;
340
341         ret = wm831x_reg_read(wm831x, on_reg);
342         if (ret < 0)
343                 return 0;
344
345         if (ret & WM831X_LDO7_ON_MODE)
346                 return REGULATOR_MODE_IDLE;
347         else
348                 return REGULATOR_MODE_NORMAL;
349 }
350
351 static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
352                                   unsigned int mode)
353 {
354         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
355         struct wm831x *wm831x = ldo->wm831x;
356         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
357         int ret;
358
359
360         switch (mode) {
361         case REGULATOR_MODE_NORMAL:
362                 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
363                 if (ret < 0)
364                         return ret;
365                 break;
366
367         case REGULATOR_MODE_IDLE:
368                 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
369                                       WM831X_LDO7_ON_MODE);
370                 if (ret < 0)
371                         return ret;
372                 break;
373
374         default:
375                 return -EINVAL;
376         }
377
378         return 0;
379 }
380
381 static int wm831x_aldo_get_status(struct regulator_dev *rdev)
382 {
383         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
384         struct wm831x *wm831x = ldo->wm831x;
385         int mask = 1 << rdev_get_id(rdev);
386         int ret;
387
388         /* Is the regulator on? */
389         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
390         if (ret < 0)
391                 return ret;
392         if (!(ret & mask))
393                 return REGULATOR_STATUS_OFF;
394
395         /* Is it reporting under voltage? */
396         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
397         if (ret < 0)
398                 return ret;
399         if (ret & mask)
400                 return REGULATOR_STATUS_ERROR;
401
402         ret = wm831x_aldo_get_mode(rdev);
403         if (ret < 0)
404                 return ret;
405         else
406                 return regulator_mode_to_status(ret);
407 }
408
409 static const struct regulator_ops wm831x_aldo_ops = {
410         .list_voltage = regulator_list_voltage_linear_range,
411         .map_voltage = regulator_map_voltage_linear_range,
412         .get_voltage_sel = regulator_get_voltage_sel_regmap,
413         .set_voltage_sel = regulator_set_voltage_sel_regmap,
414         .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
415         .get_mode = wm831x_aldo_get_mode,
416         .set_mode = wm831x_aldo_set_mode,
417         .get_status = wm831x_aldo_get_status,
418         .set_bypass = regulator_set_bypass_regmap,
419         .get_bypass = regulator_get_bypass_regmap,
420
421         .is_enabled = regulator_is_enabled_regmap,
422         .enable = regulator_enable_regmap,
423         .disable = regulator_disable_regmap,
424 };
425
426 static int wm831x_aldo_probe(struct platform_device *pdev)
427 {
428         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
429         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
430         struct regulator_config config = { };
431         int id;
432         struct wm831x_ldo *ldo;
433         struct resource *res;
434         int ret, irq;
435
436         if (pdata && pdata->wm831x_num)
437                 id = (pdata->wm831x_num * 10) + 1;
438         else
439                 id = 0;
440         id = pdev->id - id;
441
442         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
443
444         ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
445         if (!ldo)
446                 return -ENOMEM;
447
448         ldo->wm831x = wm831x;
449
450         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
451         if (res == NULL) {
452                 dev_err(&pdev->dev, "No REG resource\n");
453                 ret = -EINVAL;
454                 goto err;
455         }
456         ldo->base = res->start;
457
458         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
459         ldo->desc.name = ldo->name;
460
461         snprintf(ldo->supply_name, sizeof(ldo->supply_name),
462                  "LDO%dVDD", id + 1);
463         ldo->desc.supply_name = ldo->supply_name;
464
465         ldo->desc.id = id;
466         ldo->desc.type = REGULATOR_VOLTAGE;
467         ldo->desc.n_voltages = 32;
468         ldo->desc.linear_ranges = wm831x_aldo_ranges;
469         ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges);
470         ldo->desc.ops = &wm831x_aldo_ops;
471         ldo->desc.owner = THIS_MODULE;
472         ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
473         ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
474         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
475         ldo->desc.enable_mask = 1 << id;
476         ldo->desc.bypass_reg = ldo->base;
477         ldo->desc.bypass_mask = WM831X_LDO7_SWI;
478
479         config.dev = pdev->dev.parent;
480         if (pdata)
481                 config.init_data = pdata->ldo[id];
482         config.driver_data = ldo;
483         config.regmap = wm831x->regmap;
484
485         ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
486                                                  &config);
487         if (IS_ERR(ldo->regulator)) {
488                 ret = PTR_ERR(ldo->regulator);
489                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
490                         id + 1, ret);
491                 goto err;
492         }
493
494         irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
495         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
496                                         wm831x_ldo_uv_irq,
497                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
498                                         ldo->name, ldo);
499         if (ret != 0) {
500                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
501                         irq, ret);
502                 goto err;
503         }
504
505         platform_set_drvdata(pdev, ldo);
506
507         return 0;
508
509 err:
510         return ret;
511 }
512
513 static struct platform_driver wm831x_aldo_driver = {
514         .probe = wm831x_aldo_probe,
515         .driver         = {
516                 .name   = "wm831x-aldo",
517         },
518 };
519
520 /*
521  * Alive LDO
522  */
523
524 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
525
526 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
527                                              int uV)
528 {
529         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
530         struct wm831x *wm831x = ldo->wm831x;
531         int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
532
533         sel = regulator_map_voltage_linear(rdev, uV, uV);
534         if (sel < 0)
535                 return sel;
536
537         return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
538 }
539
540 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
541 {
542         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
543         struct wm831x *wm831x = ldo->wm831x;
544         int mask = 1 << rdev_get_id(rdev);
545         int ret;
546
547         /* Is the regulator on? */
548         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
549         if (ret < 0)
550                 return ret;
551         if (ret & mask)
552                 return REGULATOR_STATUS_ON;
553         else
554                 return REGULATOR_STATUS_OFF;
555 }
556
557 static const struct regulator_ops wm831x_alive_ldo_ops = {
558         .list_voltage = regulator_list_voltage_linear,
559         .map_voltage = regulator_map_voltage_linear,
560         .get_voltage_sel = regulator_get_voltage_sel_regmap,
561         .set_voltage_sel = regulator_set_voltage_sel_regmap,
562         .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
563         .get_status = wm831x_alive_ldo_get_status,
564
565         .is_enabled = regulator_is_enabled_regmap,
566         .enable = regulator_enable_regmap,
567         .disable = regulator_disable_regmap,
568 };
569
570 static int wm831x_alive_ldo_probe(struct platform_device *pdev)
571 {
572         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
573         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
574         struct regulator_config config = { };
575         int id;
576         struct wm831x_ldo *ldo;
577         struct resource *res;
578         int ret;
579
580         if (pdata && pdata->wm831x_num)
581                 id = (pdata->wm831x_num * 10) + 1;
582         else
583                 id = 0;
584         id = pdev->id - id;
585
586
587         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
588
589         ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
590         if (!ldo)
591                 return -ENOMEM;
592
593         ldo->wm831x = wm831x;
594
595         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
596         if (res == NULL) {
597                 dev_err(&pdev->dev, "No REG resource\n");
598                 ret = -EINVAL;
599                 goto err;
600         }
601         ldo->base = res->start;
602
603         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
604         ldo->desc.name = ldo->name;
605
606         snprintf(ldo->supply_name, sizeof(ldo->supply_name),
607                  "LDO%dVDD", id + 1);
608         ldo->desc.supply_name = ldo->supply_name;
609
610         ldo->desc.id = id;
611         ldo->desc.type = REGULATOR_VOLTAGE;
612         ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
613         ldo->desc.ops = &wm831x_alive_ldo_ops;
614         ldo->desc.owner = THIS_MODULE;
615         ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
616         ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK;
617         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
618         ldo->desc.enable_mask = 1 << id;
619         ldo->desc.min_uV = 800000;
620         ldo->desc.uV_step = 50000;
621         ldo->desc.enable_time = 1000;
622
623         config.dev = pdev->dev.parent;
624         if (pdata)
625                 config.init_data = pdata->ldo[id];
626         config.driver_data = ldo;
627         config.regmap = wm831x->regmap;
628
629         ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
630                                                  &config);
631         if (IS_ERR(ldo->regulator)) {
632                 ret = PTR_ERR(ldo->regulator);
633                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
634                         id + 1, ret);
635                 goto err;
636         }
637
638         platform_set_drvdata(pdev, ldo);
639
640         return 0;
641
642 err:
643         return ret;
644 }
645
646 static struct platform_driver wm831x_alive_ldo_driver = {
647         .probe = wm831x_alive_ldo_probe,
648         .driver         = {
649                 .name   = "wm831x-alive-ldo",
650         },
651 };
652
653 static struct platform_driver * const drivers[] = {
654         &wm831x_gp_ldo_driver,
655         &wm831x_aldo_driver,
656         &wm831x_alive_ldo_driver,
657 };
658
659 static int __init wm831x_ldo_init(void)
660 {
661         return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
662 }
663 subsys_initcall(wm831x_ldo_init);
664
665 static void __exit wm831x_ldo_exit(void)
666 {
667         platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
668 }
669 module_exit(wm831x_ldo_exit);
670
671 /* Module information */
672 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
673 MODULE_DESCRIPTION("WM831x LDO driver");
674 MODULE_LICENSE("GPL");
675 MODULE_ALIAS("platform:wm831x-ldo");
676 MODULE_ALIAS("platform:wm831x-aldo");
677 MODULE_ALIAS("platform:wm831x-aliveldo");