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