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 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
307 	},
308 };
309 
310 /*
311  * Analogue LDOs
312  */
313 
314 static const struct linear_range wm831x_aldo_ranges[] = {
315 	REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000),
316 	REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000),
317 };
318 
319 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
320 					     int uV)
321 {
322 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
323 	struct wm831x *wm831x = ldo->wm831x;
324 	int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
325 
326 	sel = regulator_map_voltage_linear_range(rdev, uV, uV);
327 	if (sel < 0)
328 		return sel;
329 
330 	return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
331 }
332 
333 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
334 {
335 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
336 	struct wm831x *wm831x = ldo->wm831x;
337 	int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
338 	int ret;
339 
340 	ret = wm831x_reg_read(wm831x, on_reg);
341 	if (ret < 0)
342 		return 0;
343 
344 	if (ret & WM831X_LDO7_ON_MODE)
345 		return REGULATOR_MODE_IDLE;
346 	else
347 		return REGULATOR_MODE_NORMAL;
348 }
349 
350 static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
351 				  unsigned int mode)
352 {
353 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
354 	struct wm831x *wm831x = ldo->wm831x;
355 	int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
356 	int ret;
357 
358 
359 	switch (mode) {
360 	case REGULATOR_MODE_NORMAL:
361 		ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
362 		if (ret < 0)
363 			return ret;
364 		break;
365 
366 	case REGULATOR_MODE_IDLE:
367 		ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
368 				      WM831X_LDO7_ON_MODE);
369 		if (ret < 0)
370 			return ret;
371 		break;
372 
373 	default:
374 		return -EINVAL;
375 	}
376 
377 	return 0;
378 }
379 
380 static int wm831x_aldo_get_status(struct regulator_dev *rdev)
381 {
382 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
383 	struct wm831x *wm831x = ldo->wm831x;
384 	int mask = 1 << rdev_get_id(rdev);
385 	int ret;
386 
387 	/* Is the regulator on? */
388 	ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
389 	if (ret < 0)
390 		return ret;
391 	if (!(ret & mask))
392 		return REGULATOR_STATUS_OFF;
393 
394 	/* Is it reporting under voltage? */
395 	ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
396 	if (ret < 0)
397 		return ret;
398 	if (ret & mask)
399 		return REGULATOR_STATUS_ERROR;
400 
401 	ret = wm831x_aldo_get_mode(rdev);
402 	if (ret < 0)
403 		return ret;
404 	else
405 		return regulator_mode_to_status(ret);
406 }
407 
408 static const struct regulator_ops wm831x_aldo_ops = {
409 	.list_voltage = regulator_list_voltage_linear_range,
410 	.map_voltage = regulator_map_voltage_linear_range,
411 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
412 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
413 	.set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
414 	.get_mode = wm831x_aldo_get_mode,
415 	.set_mode = wm831x_aldo_set_mode,
416 	.get_status = wm831x_aldo_get_status,
417 	.set_bypass = regulator_set_bypass_regmap,
418 	.get_bypass = regulator_get_bypass_regmap,
419 
420 	.is_enabled = regulator_is_enabled_regmap,
421 	.enable = regulator_enable_regmap,
422 	.disable = regulator_disable_regmap,
423 };
424 
425 static int wm831x_aldo_probe(struct platform_device *pdev)
426 {
427 	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
428 	struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
429 	struct regulator_config config = { };
430 	int id;
431 	struct wm831x_ldo *ldo;
432 	struct resource *res;
433 	int ret, irq;
434 
435 	if (pdata && pdata->wm831x_num)
436 		id = (pdata->wm831x_num * 10) + 1;
437 	else
438 		id = 0;
439 	id = pdev->id - id;
440 
441 	dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
442 
443 	ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
444 	if (!ldo)
445 		return -ENOMEM;
446 
447 	ldo->wm831x = wm831x;
448 
449 	res = platform_get_resource(pdev, IORESOURCE_REG, 0);
450 	if (res == NULL) {
451 		dev_err(&pdev->dev, "No REG resource\n");
452 		ret = -EINVAL;
453 		goto err;
454 	}
455 	ldo->base = res->start;
456 
457 	snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
458 	ldo->desc.name = ldo->name;
459 
460 	snprintf(ldo->supply_name, sizeof(ldo->supply_name),
461 		 "LDO%dVDD", id + 1);
462 	ldo->desc.supply_name = ldo->supply_name;
463 
464 	ldo->desc.id = id;
465 	ldo->desc.type = REGULATOR_VOLTAGE;
466 	ldo->desc.n_voltages = 32;
467 	ldo->desc.linear_ranges = wm831x_aldo_ranges;
468 	ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges);
469 	ldo->desc.ops = &wm831x_aldo_ops;
470 	ldo->desc.owner = THIS_MODULE;
471 	ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
472 	ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
473 	ldo->desc.enable_reg = WM831X_LDO_ENABLE;
474 	ldo->desc.enable_mask = 1 << id;
475 	ldo->desc.bypass_reg = ldo->base;
476 	ldo->desc.bypass_mask = WM831X_LDO7_SWI;
477 
478 	config.dev = pdev->dev.parent;
479 	if (pdata)
480 		config.init_data = pdata->ldo[id];
481 	config.driver_data = ldo;
482 	config.regmap = wm831x->regmap;
483 
484 	ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
485 						 &config);
486 	if (IS_ERR(ldo->regulator)) {
487 		ret = PTR_ERR(ldo->regulator);
488 		dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
489 			id + 1, ret);
490 		goto err;
491 	}
492 
493 	irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
494 	ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
495 					wm831x_ldo_uv_irq,
496 					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
497 					ldo->name, ldo);
498 	if (ret != 0) {
499 		dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
500 			irq, ret);
501 		goto err;
502 	}
503 
504 	platform_set_drvdata(pdev, ldo);
505 
506 	return 0;
507 
508 err:
509 	return ret;
510 }
511 
512 static struct platform_driver wm831x_aldo_driver = {
513 	.probe = wm831x_aldo_probe,
514 	.driver		= {
515 		.name	= "wm831x-aldo",
516 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
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 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
651 	},
652 };
653 
654 static struct platform_driver * const drivers[] = {
655 	&wm831x_gp_ldo_driver,
656 	&wm831x_aldo_driver,
657 	&wm831x_alive_ldo_driver,
658 };
659 
660 static int __init wm831x_ldo_init(void)
661 {
662 	return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
663 }
664 subsys_initcall(wm831x_ldo_init);
665 
666 static void __exit wm831x_ldo_exit(void)
667 {
668 	platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
669 }
670 module_exit(wm831x_ldo_exit);
671 
672 /* Module information */
673 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
674 MODULE_DESCRIPTION("WM831x LDO driver");
675 MODULE_LICENSE("GPL");
676 MODULE_ALIAS("platform:wm831x-ldo");
677 MODULE_ALIAS("platform:wm831x-aldo");
678 MODULE_ALIAS("platform:wm831x-aliveldo");
679