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