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